Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

133 files changed, 31727 insertions, 0 deletions

diff --git a/comm/mailnews/compose/.eslintrc.js b/comm/mailnews/compose/.eslintrc.js
new file mode 100644
index 0000000000..5816519fbb
--- /dev/null
+++ b/comm/mailnews/compose/.eslintrc.js
@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = {
+  extends: ["plugin:mozilla/valid-jsdoc"],
+};
diff --git a/comm/mailnews/compose/content/sendProgress.js b/comm/mailnews/compose/content/sendProgress.js
new file mode 100644
index 0000000000..fbc05451a7
--- /dev/null
+++ b/comm/mailnews/compose/content/sendProgress.js
@@ -0,0 +1,174 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// dialog is just an array we'll use to store various properties from the dialog document...
+var dialog;
+
+// the msgProgress is a nsIMsgProgress object
+var msgProgress = null;
+
+// random global variables...
+var itsASaveOperation = false;
+var gBundle;
+
+window.addEventListener("DOMContentLoaded", onLoad);
+window.addEventListener("unload", onUnload);
+document.addEventListener("dialogcancel", onCancel);
+
+// all progress notifications are done through the nsIWebProgressListener implementation...
+var progressListener = {
+  onStateChange(aWebProgress, aRequest, aStateFlags, aStatus) {
+    if (aStateFlags & Ci.nsIWebProgressListener.STATE_START) {
+      // Set progress meter to show indeterminate.
+      dialog.progress.removeAttribute("value");
+      dialog.progressText.value = "";
+    }
+
+    if (aStateFlags & Ci.nsIWebProgressListener.STATE_STOP) {
+      if (Components.isSuccessCode(aStatus)) {
+        // we are done sending/saving the message...
+        // Indicate completion in status area.
+        let msg;
+        if (itsASaveOperation) {
+          msg = gBundle.GetStringFromName("messageSaved");
+        } else {
+          msg = gBundle.GetStringFromName("messageSent");
+        }
+        dialog.status.setAttribute("value", msg);
+
+        // Put progress meter at 100%.
+        dialog.progress.setAttribute("value", 100);
+        dialog.progressText.setAttribute(
+          "value",
+          gBundle.formatStringFromName("percentMsg", [100])
+        );
+      }
+
+      // Note: Without some delay closing the window the "msg" string above may
+      // never be visible. Example: setTimeout(() => window.close(), 1000);
+      // Windows requires other delays. The delays also cause test failures.
+      window.close();
+    }
+  },
+
+  onProgressChange(
+    aWebProgress,
+    aRequest,
+    aCurSelfProgress,
+    aMaxSelfProgress,
+    aCurTotalProgress,
+    aMaxTotalProgress
+  ) {
+    // Calculate percentage.
+    var percent;
+    if (aMaxTotalProgress > 0) {
+      percent = Math.round((aCurTotalProgress / aMaxTotalProgress) * 100);
+      if (percent > 100) {
+        percent = 100;
+      }
+
+      // Advance progress meter.
+      dialog.progress.value = percent;
+
+      // Update percentage label on progress meter.
+      dialog.progressText.value = gBundle.formatStringFromName("percentMsg", [
+        percent,
+      ]);
+    } else {
+      // Have progress meter show indeterminate with denominator <= 0.
+      dialog.progress.removeAttribute("value");
+      dialog.progressText.value = "";
+    }
+  },
+
+  onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {
+    // we can ignore this notification
+  },
+
+  onStatusChange(aWebProgress, aRequest, aStatus, aMessage) {
+    if (aMessage != "") {
+      dialog.status.setAttribute("value", aMessage);
+    }
+  },
+
+  onSecurityChange(aWebProgress, aRequest, state) {
+    // we can ignore this notification
+  },
+
+  onContentBlockingEvent(aWebProgress, aRequest, aEvent) {
+    // we can ignore this notification
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIWebProgressListener",
+    "nsISupportsWeakReference",
+  ]),
+};
+
+function onLoad() {
+  // Set global variables.
+  gBundle = Services.strings.createBundle(
+    "chrome://messenger/locale/messengercompose/sendProgress.properties"
+  );
+
+  msgProgress = window.arguments[0];
+  if (!msgProgress) {
+    console.error("Invalid argument to sendProgress.xhtml.");
+    window.close();
+    return;
+  }
+
+  let subject = "";
+  if (window.arguments[1]) {
+    let progressParams = window.arguments[1].QueryInterface(
+      Ci.nsIMsgComposeProgressParams
+    );
+    if (progressParams) {
+      itsASaveOperation =
+        progressParams.deliveryMode != Ci.nsIMsgCompDeliverMode.Now;
+      subject = progressParams.subject;
+    }
+  }
+
+  if (subject) {
+    let title = itsASaveOperation
+      ? "titleSaveMsgSubject"
+      : "titleSendMsgSubject";
+    document.title = gBundle.formatStringFromName(title, [subject]);
+  } else {
+    let title = itsASaveOperation ? "titleSaveMsg" : "titleSendMsg";
+    document.title = gBundle.GetStringFromName(title);
+  }
+
+  dialog = {};
+  dialog.status = document.getElementById("dialog.status");
+  dialog.progress = document.getElementById("dialog.progress");
+  dialog.progressText = document.getElementById("dialog.progressText");
+
+  // set our web progress listener on the helper app launcher
+  msgProgress.registerListener(progressListener);
+}
+
+function onUnload() {
+  if (msgProgress) {
+    try {
+      msgProgress.unregisterListener(progressListener);
+      msgProgress = null;
+    } catch (e) {}
+  }
+}
+
+// If the user presses cancel, tell the app launcher and close the dialog...
+function onCancel(event) {
+  // Cancel app launcher.
+  try {
+    msgProgress.processCanceledByUser = true;
+  } catch (e) {
+    return;
+  }
+
+  // Don't close up dialog, the backend will close the dialog when everything will be aborted.
+  event.preventDefault();
+}
diff --git a/comm/mailnews/compose/content/sendProgress.xhtml b/comm/mailnews/compose/content/sendProgress.xhtml
new file mode 100644
index 0000000000..cf46d0c8cc
--- /dev/null
+++ b/comm/mailnews/compose/content/sendProgress.xhtml
@@ -0,0 +1,65 @@
+<?xml version="1.0"?>
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+
+<?xml-stylesheet href="chrome://messenger/skin/messenger.css" type="text/css"?>
+<?xml-stylesheet href="chrome://messenger/skin/colors.css" type="text/css"?>
+<?xml-stylesheet href="chrome://messenger/skin/themeableDialog.css" type="text/css"?>
+
+<!DOCTYPE html SYSTEM "chrome://messenger/locale/messengercompose/sendProgress.dtd">
+<html
+  xmlns="http://www.w3.org/1999/xhtml"
+  xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  xmlns:html="http://www.w3.org/1999/xhtml"
+  style="min-width: 56ch; min-height: 8em"
+  lightweightthemes="true"
+  scrolling="false"
+>
+  <head>
+    <title>&sendDialog.title;</title>
+    <link rel="localization" href="branding/brand.ftl" />
+    <script
+      defer="defer"
+      src="chrome://messenger/content/dialogShadowDom.js"
+    ></script>
+    <script
+      defer="defer"
+      src="chrome://messenger/content/messengercompose/sendProgress.js"
+    ></script>
+  </head>
+  <html:body
+    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+  >
+    <dialog id="sendProgress" buttons="cancel">
+      <hbox flex="1">
+        <vbox align="end">
+          <hbox flex="1" align="center">
+            <label value="&status.label;" />
+          </hbox>
+          <hbox flex="1" align="center">
+            <label value="&progress.label;" />
+          </hbox>
+        </vbox>
+        <vbox flex="1">
+          <hbox flex="1" align="center">
+            <label id="dialog.status" crop="center" />
+          </hbox>
+          <hbox
+            class="thin-separator"
+            flex="1"
+            style="display: flex; align-items: center"
+          >
+            <html:progress
+              id="dialog.progress"
+              value="0"
+              max="100"
+              style="flex: 1"
+            />
+            <label id="dialog.progressText" value="" />
+          </hbox>
+        </vbox>
+      </hbox>
+    </dialog>
+  </html:body>
+</html>
diff --git a/comm/mailnews/compose/moz.build b/comm/mailnews/compose/moz.build
new file mode 100644
index 0000000000..a49689ab64
--- /dev/null
+++ b/comm/mailnews/compose/moz.build
@@ -0,0 +1,11 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+DIRS += [
+    "public",
+    "src",
+]
+
+TEST_DIRS += ["test"]
diff --git a/comm/mailnews/compose/public/moz.build b/comm/mailnews/compose/public/moz.build
new file mode 100644
index 0000000000..b4e027ef05
--- /dev/null
+++ b/comm/mailnews/compose/public/moz.build
@@ -0,0 +1,30 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPIDL_SOURCES += [
+    "nsIMsgAttachment.idl",
+    "nsIMsgCompFields.idl",
+    "nsIMsgCompose.idl",
+    "nsIMsgComposeParams.idl",
+    "nsIMsgComposeProgressParams.idl",
+    "nsIMsgComposeSecure.idl",
+    "nsIMsgComposeService.idl",
+    "nsIMsgCompUtils.idl",
+    "nsIMsgCopy.idl",
+    "nsIMsgQuote.idl",
+    "nsIMsgQuotingOutputStreamListener.idl",
+    "nsIMsgSend.idl",
+    "nsIMsgSendLater.idl",
+    "nsIMsgSendLaterListener.idl",
+    "nsIMsgSendListener.idl",
+    "nsIMsgSendReport.idl",
+    "nsISmtpServer.idl",
+    "nsISmtpService.idl",
+    "nsISmtpUrl.idl",
+]
+
+XPIDL_MODULE = "msgcompose"
+
+EXPORTS += []
diff --git a/comm/mailnews/compose/public/nsIMsgAttachment.idl b/comm/mailnews/compose/public/nsIMsgAttachment.idl
new file mode 100644
index 0000000000..71356d6686
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgAttachment.idl
@@ -0,0 +1,144 @@
+/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+[scriptable, uuid(d17d2d60-ec3a-46de-8bd1-24c77dd9b87b)]
+interface nsIMsgAttachment : nsISupports {
+
+  /**
+   * name attribute
+   *
+   * @Attachment real name, will be sent with the attachment's header.
+   * @If no name has been provided, a name will be generated using the url.
+   */
+  attribute AString name;
+
+  /**
+   * url attribute
+   *
+   * @specify where the attachment live (locally or remotely)
+   */
+  attribute AUTF8String url;
+
+  /**
+   * msgUri attribute
+   *
+   * @specify the uri of the message this attachment belongs to
+   */
+  attribute AUTF8String msgUri;
+
+  /**
+   * urlCharset attribute
+   *
+   * @specify the Charset of url  (used to convert url to Unicode after
+   *  unescaping)
+   */
+  attribute ACString urlCharset;
+
+
+  /**
+   * temporary attribute
+   *
+   * @If set to true, the file pointed by the url will be destroyed when this object is destroyed.
+   * @This is only for local attachment.
+   */
+  attribute boolean temporary;
+
+  /**
+   * Are we storing this attachment via a cloud provider and linking to it?
+   */
+  attribute boolean sendViaCloud;
+
+  /**
+   * Cloud provider account key for this attachment, if any.
+   */
+  attribute ACString cloudFileAccountKey;
+
+  /**
+   * A data string stored in the x-mozilla-cloud-part header of draft messages,
+   * to be able to restore cloudFile information of re-opened drafts.
+   */
+  attribute AUTF8String cloudPartHeaderData;
+
+  /**
+   * This allows the compose front end code to put whatever html annotation
+   * it wants for the cloud part, e.g., with expiration time, etc.
+   */
+  attribute AUTF8String htmlAnnotation;
+
+  /**
+   * contentLocation attribute
+   *
+   * @Specify the origin url of the attachment, used normally when attaching
+   * a locally saved html document, but also used for cloud files and to store
+   * the original mailbox:// url of attachments, after they have been saves as
+   * temporary files.
+   */
+  attribute ACString contentLocation;
+
+  /**
+   * contentType attribute
+   *
+   * @Specify the content-type of the attachment, this does not include extra content-type parameters. If
+   * @you need to specify extra information, use contentTypeParam, charset, macType or macCreator.
+   * @If omitted, it will be determined base on either the name, the url or the content of the file.
+   */
+  attribute string contentType;
+
+  /**
+   * contentTypeParam attribute
+   *
+   * @Specify the any content-type parameter (other than the content-type itself, charset, macType or macCreator).
+   * @It will be added to the content-type during the send/save operation.
+   */
+  attribute string contentTypeParam;
+
+  /**
+   * Content-ID for embedded attachments inside a multipart/related container.
+   */
+  attribute AUTF8String contentId;
+
+  /**
+   * charset attribute
+   *
+   * @Specify the charset of the attachment. It will be added to the content-type during the
+   * @send/save operation
+   * @If omitted, will be determined automatically (if possible).
+   */
+  attribute string charset;
+
+  /**
+   * size attribute
+   *
+   * @Specify the size of the attachment.
+   */
+  attribute int64_t size;
+
+  /**
+   * macType attribute
+   *
+   * @Specify the Mac file type of the attachment. It will be added to the content-type during the
+   * @send/save operation
+   * @If omitted, will be determined automatically on Macintosh OS.
+   */
+  attribute string macType;
+
+  /**
+   * macCreator attribute
+   *
+   * @Specify the Mac file creator of the attachment. It will be added to the content-type during the
+   * @send/save operation
+   * @If omitted, will be determined automatically on Macintosh OS.
+   */
+  attribute string macCreator;
+
+  /**
+    * equalsUrl
+    *
+    * @ determines if both attachments have the same url.
+    */
+  boolean equalsUrl(in nsIMsgAttachment attachment);
+};
diff --git a/comm/mailnews/compose/public/nsIMsgCompFields.idl b/comm/mailnews/compose/public/nsIMsgCompFields.idl
new file mode 100644
index 0000000000..7ed51f4737
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgCompFields.idl
@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgIStructuredHeaders.idl"
+
+interface nsIMsgAttachment;
+interface nsIMsgComposeSecure;
+
+/**
+ * A collection of headers and other attributes for building a mail message.
+ */
+[scriptable, uuid(10928477-4F24-4357-9397-FBD847F46F0A)]
+interface nsIMsgCompFields : msgIWritableStructuredHeaders {
+
+  attribute AString from;
+  attribute AString replyTo;
+  attribute AString to;
+  attribute AString cc;
+  attribute AString bcc;
+  readonly attribute bool hasRecipients;
+
+  attribute AString fcc;
+  attribute AString fcc2;
+
+  attribute AString newsgroups;
+  attribute string  newspostUrl;
+  attribute AString followupTo;
+
+  attribute AString subject;
+
+  attribute AString organization;
+  attribute string  references;
+  attribute string  priority;
+  attribute string  messageId;
+
+  attribute AString templateName;
+  // The so-called draft/template ID is a URI in reality.
+  attribute AUTF8String draftId;
+  attribute AUTF8String templateId;
+
+  attribute boolean returnReceipt;
+  attribute long receiptHeaderType;
+  attribute boolean DSN;
+  attribute boolean attachVCard;
+  attribute boolean forcePlainText;
+  attribute boolean useMultipartAlternative;
+  attribute boolean bodyIsAsciiOnly;
+  attribute boolean forceMsgEncoding;
+  /// Status of manually-activated attachment reminder.
+  attribute boolean attachmentReminder;
+  /// Delivery format for the mail being composed
+  /// (auto = 4, text = 1, html = 2, text and html = 3).
+  attribute long deliveryFormat;
+  attribute string contentLanguage;
+  /// This is populated with the key of the identity which created the draft or template.
+  attribute string creatorIdentityKey;
+
+  /**
+   * Beware that when setting this property, your body must be properly wrapped,
+   * and the line endings must match MSG_LINEBREAK, namely "\r\n" on Windows
+   * and "\n" on Linux and OSX.
+   */
+  attribute AString body;
+
+  readonly attribute Array<nsIMsgAttachment> attachments;
+  void addAttachment(in nsIMsgAttachment attachment);
+  void removeAttachment(in nsIMsgAttachment attachment);
+  void removeAttachments();
+
+  /**
+   * Values for other headers. Headers in order, from the
+   * mail.compose.other.header pref.
+   */
+  attribute Array<AString> otherHeaders;
+
+  /**
+   * This function will split the recipients into an array.
+   *
+   * @param aRecipients       The recipients list to split.
+   * @param aEmailAddressOnly Set to true to drop display names from the results
+   *                          array.
+   *
+   * @return An array of the recipients.
+   */
+  Array<AString> splitRecipients(in AString aRecipients,
+                                 in boolean aEmailAddressOnly);
+
+  void ConvertBodyToPlainText();
+
+  /**
+   * Indicates whether we need to check if the current |DocumentCharset|
+   * can represent all the characters in the message body. It should be
+   * initialized to true and set to false when 'Send Anyway' is selected
+   * by a user. (bug 249530)
+   */
+  attribute boolean needToCheckCharset;
+
+  /**
+   * Object implementing encryption/signing functionality (e.g. S/MIME, PGP/MIME)
+   */
+  attribute nsIMsgComposeSecure composeSecure;
+};
diff --git a/comm/mailnews/compose/public/nsIMsgCompUtils.idl b/comm/mailnews/compose/public/nsIMsgCompUtils.idl
new file mode 100644
index 0000000000..18749e1f9d
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgCompUtils.idl
@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIMsgIdentity.idl"
+
+[scriptable, uuid(00b4569a-077e-4236-b993-980fd82bb948)]
+interface nsIMsgCompUtils : nsISupports {
+  string mimeMakeSeparator(in string prefix);
+
+  /**
+   * Try to use the provided identity and/or host name to generate a message ID.
+   *
+   * To identify the host name to use in the message ID, this will:
+   *   - if the attribute "FQDN" of the identity is set to a valid host name, use it
+   *   - otherwise, if the provided host name is valid, use it
+   *   - otherwise, if the identity's email address includes a valid host name after
+   *     an '@' symbol, use it
+   *   - otherwise, bail without generating a message ID (returns with an empty value)
+   *
+   * @param nsIMsgIdentity The identity to use to generate the message ID.
+   * @param string The host to use to generate the message ID. Ignored if empty.
+   *
+   * @returns A message ID usable in a Message-ID header, or an empty string
+   *          if no message ID could be generated.
+   */
+  AUTF8String msgGenerateMessageId(in nsIMsgIdentity identity, in AUTF8String host);
+
+  readonly attribute boolean msgMimeConformToStandard;
+
+  /**
+   * Detect the text encoding of an input string. This is a wrapper of
+   * mozilla::EncodingDetector to be used by JavaScript code. For C++, use
+   * MsgDetectCharsetFromFile from nsMsgUtils.cpp instead.
+   *
+   * @param aContent The string to detect charset.
+   *
+   * @returns Detected charset.
+   */
+  ACString detectCharset(in ACString aContent);
+};
diff --git a/comm/mailnews/compose/public/nsIMsgCompose.idl b/comm/mailnews/compose/public/nsIMsgCompose.idl
new file mode 100644
index 0000000000..7af2405e84
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgCompose.idl
@@ -0,0 +1,305 @@
+/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIMsgCompFields.idl"
+#include "nsIMsgComposeParams.idl"
+#include "nsIMsgSendListener.idl"
+
+%{C++
+#include "nsString.h"
+%}
+
+interface nsIMsgSend;
+interface nsIMsgIdentity;
+interface nsIMsgProgress;
+interface nsIDocShell;
+interface mozIDOMWindowProxy;
+interface nsIEditor;
+interface nsIMsgWindow;
+
+webidl Element;
+
+typedef long MSG_ComposeSaveType;
+
+[scriptable, uuid(6953e50a-7531-11d3-85fe-006008948010)]
+interface nsIMsgCompSaveType : nsISupports {
+    const long File     = 0;
+    const long Template = 1;
+    const long Draft    = 2;
+};
+
+typedef long MSG_DeliverMode;
+
+[scriptable, uuid(a9f27dd7-8f89-4de3-8fbf-41b789c16ee5)]
+interface nsIMsgCompDeliverMode : nsISupports {
+    const long Now = 0;
+    const long Later = 1;
+    const long Save = 2;
+    const long SaveAs = 3;
+    const long SaveAsDraft = 4;
+    const long SaveAsTemplate = 5;
+    const long SendUnsent = 6;
+    const long AutoSaveAsDraft = 7;
+    const long Background = 8;
+};
+
+[scriptable, uuid(f38ea280-e090-11d3-a449-e3153319347c)]
+interface nsIMsgCompSendFormat : nsISupports {
+    /* Send only plain text if the message is free of any rich formatting or
+     * inserted elements. Otherwise send both a HTML part and plain text
+     * alternative part. */
+    const long Auto = 0;
+    /* Only send a plain text part, losing any rich formatting or inserted
+     * elements. */
+    const long PlainText = 1;
+    /* Only send a HTML part. */
+    const long HTML = 2;
+    /* Send both the HTML part and the plain text alternative part. */
+    const long Both = 3;
+    /* An unset value, to be set with mail.default_send_format on loading the
+     * message in the compose window. */
+    const long Unset = 4;
+};
+
+[scriptable, uuid(9638af92-1dd1-11b2-bef1-ca5fee0abc62)]
+interface nsIMsgCompConvertible : nsISupports /*ToTXT*/ {
+    const long Plain = 1;  // Like 4.x: Only <html>, <p>, <br>, ...
+    const long Yes = 2;  // *Minor* alterations of the look: <ol>, <dd>, ...
+    const long Altering = 3;  /* Look altered: <strong>, <i>, <h1>, ...
+                                 Can be expressed in plaintext, but not in
+                                 the way it looked in the HTML composer. */
+    const long No = 4;  /* Will lose data: <font>, ...
+                           Really *requires* visual formatting or
+                           is not supported by our HTML->TXT converter. */
+    /* The values here have meaning, they are "levels":
+       convertible({a; b}) == max(convertible({a}), convertible({b}))
+       must be true, i.e. the higher value counts. */
+};
+
+[scriptable, uuid(6ce49b2a-07dc-4783-b307-9a355423163f)]
+interface nsIMsgComposeStateListener : nsISupports
+{
+  /* ... */
+  void        NotifyComposeFieldsReady();
+  void        ComposeProcessDone(in nsresult aResult);
+  void        SaveInFolderDone(in string folderName);
+  void        NotifyComposeBodyReady();
+};
+
+[scriptable, uuid(061aae23-7e0a-4818-9a15-1b5db3ceb7f4)]
+interface nsIMsgComposeNotificationType : nsISupports
+{
+    const long ComposeFieldsReady = 0;
+    const long ComposeProcessDone = 1;
+    const long SaveInFolderDone   = 2;
+    const long ComposeBodyReady   = 3;
+};
+
+native nsString(nsString);
+[ref] native nsStringRef(nsString);
+
+[scriptable, uuid(c6544b6b-06dd-43ac-89b5-949d7c81bb7b)]
+interface nsIMsgCompose : nsIMsgSendListener {
+
+  /**
+   * Initializes the msg compose object.
+   *
+   * @param aParams   An nsIMsgComposeParams object containing the initial
+   *                  details for the compose.
+   * @param aWindow   The optional window associated with this compose object.
+   * @param aDocShell The optional docShell of the editor element that is used
+   *                  for composing.
+   */
+  void initialize(in nsIMsgComposeParams aParams,
+                  [optional] in mozIDOMWindowProxy aWindow,
+                  [optional] in nsIDocShell aDocShell);
+
+  /* ... */
+  void RegisterStateListener(in nsIMsgComposeStateListener stateListener);
+
+  /* ... */
+  void UnregisterStateListener(in nsIMsgComposeStateListener stateListener);
+
+  /* ... */
+  Promise sendMsg(in MSG_DeliverMode deliverMode, in nsIMsgIdentity identity, in string accountKey, in nsIMsgWindow aMsgWindow, in nsIMsgProgress progress);
+
+  /**
+   * After all Compose preparations are complete, send the prepared message to
+   * the server. This exists primarily to allow an override of the sending to
+   * use a non-SMTP method for send.
+   *
+   * @param deliverMode One of the nsIMsgCompDeliverMode values.
+   * @param identity The message identity.
+   * @param accountKey The message account key.
+   */
+  Promise sendMsgToServer(in MSG_DeliverMode deliverMode,
+                          in nsIMsgIdentity identity,
+                          in string accountKey);
+
+  /* ... */
+  void CloseWindow();
+
+  /* ... */
+  void abort();
+
+  /* ... */
+  void quoteMessage(in AUTF8String msgURI);
+
+  /*
+    AttachmentPrettyName will return only the leafName if the it's a file URL.
+    It will also convert the filename to Unicode assuming it's in  the file system
+    charset. In case of URL, |charset| parameter will be used in the conversion.
+    This UI utility function should probably go into it's own class
+  */
+  AUTF8String AttachmentPrettyName(in AUTF8String url, in string charset);
+
+  /**
+   * Expand all mailing lists in the relevant compose fields to include the
+   * members of their output. This method will additionally update the
+   * popularity field of cards in the addressing header.
+   */
+  void expandMailingLists();
+
+  /**
+   * The level of "convertibility" of the message body (whole HTML document)
+   * to plaintext.
+   *
+   * @return a value from nsIMsgCompConvertible.
+   */
+  long bodyConvertible();
+
+  /**
+   * The level of "convertibility" of the provided node to plaintext.
+   *
+   * @return a value from nsIMsgCompConvertible.
+   */
+  long nodeTreeConvertible(in Element aNode);
+
+  /**
+   * The identity currently selected for the message compose object. When set
+   * this may change the signature on a message being composed. Note that
+   * typically SendMsg will be called with the same identity as is set here, but
+   * if it is different the SendMsg version will overwrite this identity.
+   */
+  attribute nsIMsgIdentity identity;
+
+  /* Check if the composing mail headers (and identity) can be converted to a mail charset.
+  */
+  boolean checkCharsetConversion(in nsIMsgIdentity identity, out string fallbackCharset);
+
+  /* The message send object. This is created by default to be the SMTP server
+   * in sendMsgToServer, but if that method is overridden, set the actual
+   * value used here.
+   */
+  attribute nsIMsgSend messageSend;
+
+  /*
+   * Clear the messageSend object to break any circular references
+   */
+   void clearMessageSend();
+
+  /* ... */
+  attribute nsIEditor editor;
+
+  /* ... */
+  readonly attribute mozIDOMWindowProxy domWindow;
+
+  /* ... */
+  readonly attribute nsIMsgCompFields compFields;
+
+  /* ... */
+  readonly attribute boolean composeHTML;
+
+  /* ... */
+  attribute MSG_ComposeType type;
+
+  /* ... */
+  readonly attribute long wrapLength;
+
+  /* by reading this value, you can determine if yes or not the message has been modified
+     by the user. When you set this value to false, you reset the modification count
+     of the body to 0 (clean).
+  */
+  attribute boolean bodyModified;
+
+  /**
+   *  Init the editor THIS USED TO BE [noscript]
+   *  Now, this is called after editor is created,
+   *  which is triggered by loading startup url from JS.
+   *  The completion of document loading is detected by observing
+   *  the "obs_documentCreated" command
+   */
+  void initEditor(in nsIEditor editor, in mozIDOMWindowProxy contentWindow);
+
+  /* The following functions are for internal use, essentially for the listener */
+
+  /* ... */
+  [noscript] void setCiteReference(in nsString citeReference);
+
+  /* Set the URI of the folder where the message has been saved */
+  attribute AUTF8String savedFolderURI;
+
+  /* Append the signature defined in the identity to the msgBody */
+  [noscript] void processSignature(in nsIMsgIdentity identity,
+                                   in boolean aQuoted,
+                                   inout nsString aMsgBody);
+
+  /* set any reply flags on the original message's folder */
+  [noscript] void processReplyFlags();
+  [noscript] void rememberQueuedDisposition();
+
+  /* ... */
+  [noscript]
+  void convertAndLoadComposeWindow(in nsStringRef aPrefix,
+                                   in nsStringRef aBuf,
+                                   in nsStringRef aSignature,
+                                   in boolean aQuoted,
+                                   in boolean aHTMLEditor);
+
+  /* Tell the doc state listeners that the doc state has changed
+   * aNotificationType is from nsIMsgComposeNotificationType
+   */
+  [noscript] void notifyStateListeners(in long aNotificationType, in nsresult aResult);
+
+  /* Retrieve the progress object */
+  readonly attribute nsIMsgProgress progress;
+
+  /* ... */
+  [noscript]
+  void buildBodyMessageAndSignature();
+
+  /* ... */
+  [noscript] void buildQuotedMessageAndSignature();
+
+  /* ... */
+  [noscript] void getQuotingToFollow(out boolean quotingToFollow);
+
+  readonly attribute AUTF8String originalMsgURI;
+
+  attribute boolean deleteDraft;
+
+  /** Set to true when remote content can load in the editor. E.g for pasting. */
+  attribute boolean allowRemoteContent;
+
+  /* for easier use of nsIMsgSendListener */
+  void addMsgSendListener(in nsIMsgSendListener sendListener);
+
+  /* for easier use of nsIMsgSendListener */
+  void removeMsgSendListener(in nsIMsgSendListener sendListener);
+
+  /// Access during mail-set-sender observer if needed, see nsIMsgCompDeliverMode.
+  readonly attribute MSG_DeliverMode deliverMode;
+
+};
+
+/* send listener interface */
+[scriptable, uuid(ad6ee068-b225-47f9-a50e-8e48440282ca)]
+interface nsIMsgComposeSendListener : nsISupports {
+
+  void setMsgCompose(in nsIMsgCompose msgCompose);
+  void setDeliverMode(in MSG_DeliverMode deliverMode);
+
+};
diff --git a/comm/mailnews/compose/public/nsIMsgComposeParams.idl b/comm/mailnews/compose/public/nsIMsgComposeParams.idl
new file mode 100644
index 0000000000..bafe7ef4e0
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgComposeParams.idl
@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+#include "nsISupports.idl"
+#include "nsIMsgIdentity.idl"
+#include "nsIMsgCompFields.idl"
+#include "nsIMsgSendListener.idl"
+
+interface nsIMsgDBHdr;
+typedef long MSG_ComposeType;
+
+[scriptable, uuid(c7035852-7531-11d3-9a73-006008948010)]
+interface nsIMsgCompType : nsISupports {
+    const long New                      = 0;
+    const long Reply                    = 1;
+    const long ReplyAll                 = 2;
+    const long ForwardAsAttachment      = 3;
+    const long ForwardInline            = 4;
+    const long NewsPost                 = 5;
+    const long ReplyToSender            = 6;
+    const long ReplyToGroup             = 7;
+    const long ReplyToSenderAndGroup    = 8;
+    const long Draft                    = 9;
+    const long Template                 = 10;  // New message from template.
+    const long MailToUrl                = 11;
+    const long ReplyWithTemplate        = 12;
+    const long ReplyToList              = 13;
+
+    /**
+     * Will resend the original message keeping the Subject and the body the
+     * same, and will set the Reply-To: header to the sender of the original
+     * message.  This gets the redirector "out of the loop" because replies
+     * to the message will go to the original sender.  This is not the same
+     * as the Resent mechanism described in section 3.6.6 of RFC 2822, and
+     * so therefore does not use Resent-* headers.
+     */
+    const long Redirect                 = 14;
+
+    /**
+     * Used to compose a new message from an existing message. Links
+     * are sanitized since the message could be from external sources.
+     */
+    const long EditAsNew                = 15;
+
+    /**
+     * Used to edit an existing template.
+     */
+    const long EditTemplate             = 16;
+};
+
+
+typedef long MSG_ComposeFormat;
+
+[scriptable, uuid(a28325e8-7531-11d3-8f1c-006008948010)]
+interface nsIMsgCompFormat : nsISupports{
+    const long Default                  = 0;
+    const long HTML                     = 1;
+    const long PlainText                = 2;
+    const long OppositeOfDefault        = 3;
+};
+
+
+[scriptable, uuid(930895f2-d610-43f4-9e3c-25e1d1fe4143)]
+interface nsIMsgComposeParams : nsISupports {
+  attribute MSG_ComposeType       type;
+  attribute MSG_ComposeFormat     format;
+  attribute AUTF8String           originalMsgURI;
+  attribute nsIMsgIdentity        identity;
+
+  attribute nsIMsgCompFields      composeFields;
+  attribute boolean               bodyIsLink;
+
+  attribute nsIMsgSendListener    sendListener;
+  attribute AString               smtpPassword;
+  attribute nsIMsgDBHdr           origMsgHdr;
+  attribute boolean               autodetectCharset;
+
+  /**
+   * HTML-formatted content to quote in the body of the message.
+   * Set this to get different content than what would normally
+   * appear in the body, e.g. the original message body in a reply.
+   */
+  attribute AUTF8String           htmlToQuote;
+};
diff --git a/comm/mailnews/compose/public/nsIMsgComposeProgressParams.idl b/comm/mailnews/compose/public/nsIMsgComposeProgressParams.idl
new file mode 100644
index 0000000000..9a77012c5c
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgComposeProgressParams.idl
@@ -0,0 +1,16 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsISupports.idl"
+#include "nsIMsgCompose.idl"
+
+[scriptable, uuid(1e0e7c00-3e4c-11d5-9daa-f88d288130fc)]
+interface nsIMsgComposeProgressParams: nsISupports {
+
+  /* message subject */
+  attribute wstring subject;
+
+  /* delivery mode */
+  attribute MSG_DeliverMode deliveryMode;
+};
diff --git a/comm/mailnews/compose/public/nsIMsgComposeSecure.idl b/comm/mailnews/compose/public/nsIMsgComposeSecure.idl
new file mode 100644
index 0000000000..cbebdb9495
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgComposeSecure.idl
@@ -0,0 +1,145 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIMsgSendReport.idl"
+#include "nsISupports.idl"
+
+interface nsIMsgCompFields;
+interface nsIMsgIdentity;
+interface nsIOutputStream;
+interface nsIX509Cert;
+
+/**
+ * Callback type for use with asyncFindCertByEmailAddr.
+ */
+[scriptable, function, uuid(6149d7d3-14bf-4280-8451-60fb48263894)]
+interface nsIDoneFindCertForEmailCallback : nsISupports {
+  /**
+   * Called after a searching for a certificate is done.
+   *
+   * @param emailAddress     - The email address that was used as the key
+   *                           to find this certificate.
+   * @param cert             - The valid certificate that was found,
+   *                           or null, if no valid cert was found.
+   */
+  void findCertDone(in AUTF8String emailAddress,
+                    in nsIX509Cert cert);
+};
+
+/**
+ * An instance of this type is related to exactly one email message
+ * while the user is composing it.
+ * Besides remembering flags and providing helper code, it is used to
+ * cache information about valid S/MIME encryption certificates that
+ * were found and which may be used at send time.
+ */
+[scriptable, uuid(245f2adc-410e-4bdb-91e2-a7bb42d61787)]
+interface nsIMsgComposeSecure : nsISupports
+{
+    /**
+     * Set to true if the outgoing message shall be signed.
+     */
+    attribute boolean signMessage;
+
+    /**
+     * Set to true if the outgoing message shall be encrypted.
+     */
+    attribute boolean requireEncryptMessage;
+
+    /***************************************************************************
+     * The following functions are called during message creation by nsMsgSend,
+     * after the message source is completely prepared.
+     ***************************************************************************/
+
+    /**
+     * Determine if encryption and/or signing is required.
+     *
+     * @param aIdentity   - The sender's identity
+     * @param compFields  - Attributes of the composed message
+     *
+     * @return - Returns true if the creation of the message requires us to go through
+     *           some encryption work, and false otherwise.
+    */
+    boolean requiresCryptoEncapsulation(in nsIMsgIdentity aIdentity, in nsIMsgCompFields aCompFields);
+
+    /**
+     * Start encryption work. Called before the encrypted data is processed.
+     *
+     * @param aStream     - Output stream that takes the resulting data
+     * @param aRecipients - RFC 2047-encoded list of all recipients (To:, Cc:, Bcc:, ... fields), separated by "," or ", "
+     *                      Recipients contain name and email addresses, just like they will be put into the message headers
+     * @param compFields  - Attributes of the composed message
+     * @param aIdentity   - The sender's identity
+     * @param sendReport  - Report feedback to the user
+     * @param aIsDraft    - True if send operation saves draft/template/etc., false if message is really sent (or sent later)
+     */
+    void beginCryptoEncapsulation(in nsIOutputStream aStream, in string aRecipients, in nsIMsgCompFields aCompFields, in nsIMsgIdentity aIdentity, in nsIMsgSendReport sendReport, in boolean aIsDraft);
+
+    /**
+     * Process a part of the message data. Called multiple times, usually for every
+     * line of the data to be encrypted
+     *
+     * @param aBuf  - Buffer holding the data to be processed
+     * @param aLen  - Length of the buffer (number of characters)
+     */
+    void mimeCryptoWriteBlock(in string aBuf, in long aLen);
+
+    /**
+     * End encryption work. Called after the encrypted data is processed.
+     *
+     * @param aAbort      - True if the send operation was aborted
+     * @param sendReport  - Report feedback to the user
+     */
+    void finishCryptoEncapsulation(in boolean aAbort, in nsIMsgSendReport sendReport);
+
+    /**
+     * Is information about a valid encryption certificate for the given
+     * email address already available in the cache?
+     *
+     * @param emailAddress     - The email address to check.
+     *
+     * @return - True if a valid cert is known by the cache.
+     */
+    boolean haveValidCertForEmail(in AUTF8String emailAddress);
+
+    /**
+     * If a valid encryption certificate for the given email address
+     * is already known by the cache, then return the NSS database
+     * key of that certificate.
+     *
+     * @param emailAddress     - The email address to check.
+     *
+     * @return - NSS db key of the valid cert.
+     */
+    ACString getCertDBKeyForEmail(in AUTF8String emailAddress);
+
+    /**
+     * Remember the given certificate database key in our cache. The
+     * given certDBey (as used with nsIX509CertDB) must reference a
+     * valid encryption certificate for the given email address.
+     *
+     * @param emailAddress     - The email address that is related to
+     *                           the given certDBKey.
+     * @param certDBKey        - The certificate database key.
+     */
+    void cacheValidCertForEmail(in AUTF8String emailAddress,
+                                in ACString certDBKey);
+
+    /*
+     * Asynchronously find an encryption certificate by email address. Calls
+     * `findCertDone` function on the provided `nsIDoneFindCertForEmailCallback`
+     * with the results of the operation.
+     *
+     *  @param emailAddress     - The email address to be used as the key
+     *                            to find the certificate.
+     *  @param callback         - A callback of type nsIDoneFindCertForEmailCallback,
+     *                            function findCertDone will be called with
+     *                            the result of the operation.
+     */
+    [must_use]
+    void asyncFindCertByEmailAddr(in AUTF8String emailAddress,
+                                  in nsIDoneFindCertForEmailCallback callback);
+};
diff --git a/comm/mailnews/compose/public/nsIMsgComposeService.idl b/comm/mailnews/compose/public/nsIMsgComposeService.idl
new file mode 100644
index 0000000000..068bb7bd46
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgComposeService.idl
@@ -0,0 +1,169 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+#include "nsISupports.idl"
+#include "nsIMsgCompose.idl"
+#include "nsIMsgComposeParams.idl"
+
+interface nsIURI;
+interface nsIDocShell;
+interface nsIMsgWindow;
+interface nsIMsgIdentity;
+interface nsIMsgIncomingServer;
+interface nsIMsgDBHdr;
+
+webidl Selection;
+
+[scriptable, uuid(041782bf-e523-444b-a268-d90868fd2b50)]
+interface nsIMsgComposeService : nsISupports {
+
+  /**
+   * Open a compose window given a mailto url and other options.
+   *
+   * @param msgComposeWindowURL Can be null in most cases. If you have your
+   *                            own chrome url you want to use in bringing up a
+   *                            compose window, pass it in here.
+   * @param msgHdr              The header of the original message.
+   * @param originalMsgURI      The URI of the original message.
+   * @param type                The message compose type: new/reply/forward/..
+   * @param format              The message compose format: text/html/..
+   * @param identity            The identity to send the message from.
+   * @param from                The email address of the sender.
+   * @param aMsgWindow          The message window to use.
+   * @param suppressReplyQuote  An optional boolean flag to ignore or include
+                                selected content in aMsgWindow as quote in the
+                                new compose window.
+   */
+  [can_run_script]
+  void OpenComposeWindow(in AUTF8String msgComposeWindowURL,
+                         in nsIMsgDBHdr msgHdr,
+                         in AUTF8String originalMsgURI,
+                         in MSG_ComposeType type,
+                         in MSG_ComposeFormat format,
+                         in nsIMsgIdentity identity,
+                         in AUTF8String from,
+                         in nsIMsgWindow aMsgWindow,
+                         [optional] in Selection aSelection,
+                         [optional] in boolean autodetectCharset);
+
+  /**
+   * Open a compose window given a mailto url and (optionally) an identity.
+   *
+   * @param aMsgComposeWindowURL Can be null in most cases. If you have your
+   *                             own chrome url you want to use in bringing up a
+   *                             compose window, pass it in here.
+   * @param aURI                 The mailto url you want to use as the
+   *                             foundation for the data inside the compose
+   *                             window.
+   * @param aIdentity            An optional identity to send the message from.
+   */
+  void OpenComposeWindowWithURI(in string msgComposeWindowURL,
+                                in nsIURI aURI,
+                                [optional] in nsIMsgIdentity aIdentity);
+
+  /* ... */
+  void OpenComposeWindowWithParams(in string msgComposeWindowURL, in nsIMsgComposeParams params);
+
+  /**
+   * Creates an nsIMsgCompose instance and initializes it.
+   *
+   * @param aParams   An nsIMsgComposeParams object containing the initial
+   *                  details for the compose.
+   * @param aWindow   The optional window associated with this compose object.
+   * @param aDocShell The optional docShell of the editor element that is used
+   *                  for composing.
+   */
+  nsIMsgCompose initCompose(in nsIMsgComposeParams aParams,
+                            [optional] in mozIDOMWindowProxy aWindow,
+                            [optional] in nsIDocShell aDocShell);
+
+  /**
+  * defaultIdentity
+  *
+  * @return the default identity, in case no identity has been setup yet, will return null
+  */
+  readonly attribute nsIMsgIdentity defaultIdentity;
+
+  /* This function is use for debugging purpose only and may go away at anytime without warning */
+  void TimeStamp(in string label, in boolean resetTime);
+
+  /* This attribute is use for debugging purposes for determining whether to PR_LOG or not */
+  readonly attribute boolean logComposePerformance;
+
+  [noscript] boolean determineComposeHTML(in nsIMsgIdentity aIdentity, in MSG_ComposeFormat aFormat);
+
+  /**
+   * given a mailto url, parse the attributes and turn them into a nsIMsgComposeParams object
+   * @return nsIMsgComposeParams which corresponds to the passed in mailto url
+   */
+  nsIMsgComposeParams getParamsForMailto(in nsIURI aURI);
+
+  /**
+   * @{
+   * These constants control how to forward messages in forwardMessage.
+   * kForwardAsDefault uses value of pref "mail.forward_message_mode".
+   */
+  const unsigned long kForwardAsDefault = 0;
+  const unsigned long kForwardAsAttachment = 1;
+  const unsigned long kForwardInline = 2;
+  /** @} */
+
+  /**
+   * Allow filters to automatically forward a message to the given address(es).
+   * @param forwardTo the address(es) to forward to
+   * @param msgHdr the header of the message being replied to
+   * @param msgWindow message window to use
+   * @param server server to use for determining which account to send from
+   * @param aForwardType - How to forward the message one of 3 values:
+   *                       kForwardAsDefault, kForwardInline, or
+   *                       kForwardAsAttachment.
+   */
+  void forwardMessage(in AString forwardTo, in nsIMsgDBHdr msgHdr,
+                      in nsIMsgWindow msgWindow, in nsIMsgIncomingServer server,
+                      in unsigned long aForwardType);
+
+  /**
+   * Allow filters to automatically reply to a message. The reply message is
+   * based on the given template.
+   * @param msgHdr the header of the message being replied to
+   * @param templateUri uri of the template to base ther reply on
+   * @param msgWindow message window to use
+   * @param server server to use for determining which account to send from
+   */
+  void replyWithTemplate(in nsIMsgDBHdr msgHdr, in AUTF8String templateUri,
+                         in nsIMsgWindow msgWindow, in nsIMsgIncomingServer server);
+
+  /**
+   * The docShell of each editor element used for composing should be registered
+   * with this service. docShells passed to initCompose get registered
+   * automatically. The registrations are typically used to get the msgCompose
+   * window when determining what remote content to allow to be displayed.
+   *
+   * @param aDocShell The nsIDocShell of the editor element.
+   * @param aMsgCompose The compose object associated with the compose window
+   */
+  void registerComposeDocShell(in nsIDocShell aDocShell,
+                               in nsIMsgCompose aMsgCompose);
+
+  /**
+   * When an editor docShell is being closed, you should
+   * unregister it from this service. nsIMsgCompose normally calls this
+   * automatically for items passed to initCompose.
+   *
+   * @param aDocShell The nsIDocShell of the editor element.
+   */
+  void unregisterComposeDocShell(in nsIDocShell aDocShell);
+
+  /**
+   * For a given docShell, returns the nsIMsgCompose object associated with it.
+   *
+   * @param aDocShell The nsIDocShell of the editor element.
+   *
+   * @return NS_ERROR_FAILURE if we could not find a nsIMsgCompose for
+   *         the passed in docShell.
+   */
+  nsIMsgCompose getMsgComposeForDocShell(in nsIDocShell aDocShell);
+};
diff --git a/comm/mailnews/compose/public/nsIMsgCopy.idl b/comm/mailnews/compose/public/nsIMsgCopy.idl
new file mode 100644
index 0000000000..338e7234de
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgCopy.idl
@@ -0,0 +1,38 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIMsgFolder.idl"
+#include "nsIMsgIdentity.idl"
+#include "nsIMsgSend.idl"
+
+/**
+ * The contract ID for this component is @mozilla.org/messengercompose/msgcopy;1.
+ */
+[scriptable, uuid(de03b16f-3a41-40d0-a487-ca21abcf2bee)]
+interface nsIMsgCopy : nsISupports {
+  /**
+   * Start the process of copying a message file to a message folder. The
+   * destinationfolder depends on pref and deliver mode.
+   *
+   * @param aUserIdentity The identity of the sender
+   * @param aFile         The message file
+   * @param aMode         The deliver mode
+   * @param aMsgSendObj   The nsIMsgSend instance that listens to copy events
+   * @param aSavePref     The folder uri on server
+   * @param aMsgToReplace The message to replace when copying
+   */
+  void startCopyOperation(in nsIMsgIdentity aUserIdentity,
+                          in nsIFile aFile,
+                          in nsMsgDeliverMode aMode,
+                          in nsIMsgSend aMsgSendObj,
+                          in AUTF8String aSavePref,
+                          in nsIMsgDBHdr aMsgToReplace);
+
+  /**
+   * Destination folder of the copy operation. Used when aborting copy operation.
+   */
+  readonly attribute nsIMsgFolder dstFolder;
+};
diff --git a/comm/mailnews/compose/public/nsIMsgQuote.idl b/comm/mailnews/compose/public/nsIMsgQuote.idl
new file mode 100644
index 0000000000..ae8fef2ab9
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgQuote.idl
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsISupports.idl"
+#include "nsIMsgQuotingOutputStreamListener.idl"
+#include "nsIChannel.idl"
+#include "nsIMimeStreamConverter.idl"
+
+interface nsIMsgDBHdr;
+
+[scriptable, uuid(f79b1d55-f546-4ed5-9f75-9428e35c4eff)]
+interface nsIMsgQuote : nsISupports {
+
+ /**
+  * Quote a particular message specified by its URI.
+  *
+  * @param charset optional parameter - if set, force the message to be
+  *                quoted using this particular charset
+  */
+  void quoteMessage(in AUTF8String msgURI, in boolean quoteHeaders,
+                    in nsIMsgQuotingOutputStreamListener streamListener,
+                    in bool autodetectCharset, in boolean headersOnly,
+                    in nsIMsgDBHdr aOrigHdr);
+
+  readonly attribute nsIMimeStreamConverterListener quoteListener;
+  readonly attribute nsIChannel quoteChannel;
+  readonly attribute nsIMsgQuotingOutputStreamListener streamListener;
+};
+
+[scriptable, uuid(1EC75AD9-88DE-11d3-989D-001083010E9B)]
+interface nsIMsgQuoteListener : nsIMimeStreamConverterListener
+{
+  attribute nsIMsgQuote msgQuote;
+};
diff --git a/comm/mailnews/compose/public/nsIMsgQuotingOutputStreamListener.idl b/comm/mailnews/compose/public/nsIMsgQuotingOutputStreamListener.idl
new file mode 100644
index 0000000000..ac86361ab5
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgQuotingOutputStreamListener.idl
@@ -0,0 +1,16 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIStreamListener.idl"
+
+interface nsIMimeHeaders;
+
+[scriptable, uuid(1fe345e6-2428-4a43-a0c6-d2acea0d4da4)]
+interface nsIMsgQuotingOutputStreamListener : nsIStreamListener {
+
+    // The headers are used to fill in the reply's compose fields
+    void setMimeHeaders(in nsIMimeHeaders headers);
+
+};
diff --git a/comm/mailnews/compose/public/nsIMsgSend.idl b/comm/mailnews/compose/public/nsIMsgSend.idl
new file mode 100644
index 0000000000..9d4639925d
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgSend.idl
@@ -0,0 +1,374 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * The nsIMsgSend method will create an RFC822 message and send it all in one operation
+ * as well as providing the ability to save disk files for later use. The mode of delivery
+ * can also be specified for the "Send Later", "Drafts" and "Templates" operations. (NOTE:
+ * This method could easily be broken in to a few different calls. Currently, this method
+ * does several functions depending on the arguments passed in, but this could easily lead
+ * to confusion. This is something that very well may change as time allows).
+ */
+#include "nsISupports.idl"
+#include "nsrootidl.idl"
+#include "nsIMsgIdentity.idl"
+#include "nsIMsgCompFields.idl"
+#include "nsIMsgSendListener.idl"
+#include "nsIMsgSendReport.idl"
+#include "domstubs.idl"
+#include "nsIPrompt.idl"
+#include "MailNewsTypes2.idl"
+#include "nsIMsgComposeParams.idl"
+
+interface nsIMsgProgress;
+interface nsIURI;
+interface nsIRequest;
+interface nsIMsgDBHdr;
+interface nsIMsgHdr;
+interface nsIFile;
+interface nsIOutputStream;
+interface nsIMsgComposeSecure;
+interface nsIMsgStatusFeedback;
+interface nsIEditor;
+interface mozIDOMWindowProxy;
+
+typedef long nsMsgDeliverMode;
+
+[scriptable, uuid(c658cd1f-dc4a-43c0-911c-c6d3e569ca7e)]
+interface nsIMsgAttachmentData : nsISupports
+{
+  /// The URL to attach.
+  attribute nsIURI url;
+
+  /**
+   * The type to which this document should be
+   * converted.  Legal values are NULL, TEXT_PLAIN
+   * and APPLICATION_POSTSCRIPT (which are macros
+   * defined in net.h); other values are ignored.
+   */
+  attribute ACString desiredType;
+
+  /**
+   * The type of the URL if known, otherwise empty. For example, if
+   * you were attaching a temp file which was known to contain HTML data,
+   * you would pass in TEXT_HTML as the realType, to override whatever type
+   * the name of the tmp file might otherwise indicate.
+   */
+  attribute ACString realType;
+
+  /// Goes along with real_type.
+  attribute ACString realEncoding;
+
+  /**
+   * The original name of this document, which will eventually show up in the
+   * Content-Disposition header. For example, if you had copied a document to a
+   * tmp file, this would be the original, human-readable name of the document.
+   */
+  attribute ACString realName;
+  /**
+   * If you put a string here, it will show up as the Content-Description
+   * header. This can be any explanatory text; it's not a file name.
+   */
+  attribute ACString description;
+
+  /// mac-specific info
+  attribute ACString xMacType;
+
+  /// mac-specific info
+  attribute ACString xMacCreator;
+};
+
+/**
+ * When we have downloaded a URL to a tmp file for attaching, this
+ * represents everything we learned about it (and did to it) in the
+ * process.
+ */
+[scriptable, uuid(c552345d-c74b-40b0-a673-79bb461e920b)]
+interface nsIMsgAttachedFile : nsISupports
+{
+  /// Where it came from on the network (or even elsewhere on the local disk.)
+  attribute nsIURI origUrl;
+
+  /// The tmp file in which the (possibly converted) data now resides.
+  attribute nsIFile tmpFile;
+
+  /// The type of the data in file_name (not necessarily the same as the type of orig_url.)
+  attribute ACString type;
+
+  /**
+   * The encoding of the tmp file. This will be set only if the original
+   * document had an encoding already; we don't do base64 encoding and so forth
+   * until it's time to assemble a full MIME message of all parts.
+   */
+  attribute ACString encoding;
+  /// For Content-Description header.
+  attribute ACString description;
+
+  /// X-Mozilla-Cloud-Part, if any.
+  attribute ACString cloudPartInfo;
+
+  attribute ACString xMacType;    // mac-specific info
+  attribute ACString xMacCreator; // mac-specific info
+  attribute ACString realName;      // The real name of the file.
+
+  /**
+   * Some statistics about the data that was written to the file, so that when
+   * it comes time to compose a MIME message, we can make an informed decision
+   * about what Content-Transfer-Encoding would be best for this attachment.
+   * (If it's encoded already, we ignore this information and ship it as-is.)
+   */
+  attribute unsigned long size;
+  attribute unsigned long unprintableCount;
+  attribute unsigned long highbitCount;
+  attribute unsigned long ctlCount;
+  attribute unsigned long nullCount;
+  attribute unsigned long maxLineLength;
+};
+
+/**
+ * This interface is used by Outlook import to shuttle embedded
+ * image information over to nsIMsgSend's createRFC822Message method via
+ * the aEmbbeddedObjects parameter.
+ */
+[scriptable, uuid(5d2c6554-b4c8-4d68-b864-50e0df929707)]
+interface nsIMsgEmbeddedImageData : nsISupports
+{
+  attribute nsIURI uri;
+  attribute ACString cid;
+  attribute ACString name;
+};
+
+[ptr] native nsMsgAttachedFile(nsMsgAttachedFile);
+
+[scriptable, uuid(747fdfa2-1754-4282-ab26-1e55fd8de13c)]
+interface nsIMsgSend : nsISupports
+{
+  //
+  // This is the primary interface for creating and sending RFC822 messages
+  // in the new architecture. Currently, this method supports many arguments
+  // that change the behavior of the operation. This will change in time to
+  // be separate calls that will be more singluar in nature.
+  //
+  // NOTE: when aEditor is non-null, a multipart related MHTML message will
+  // be created
+  //
+
+  /// Send the message straight away.
+  const nsMsgDeliverMode nsMsgDeliverNow = 0;
+  /**
+   * Queue the message for sending later, but then wait for the user to
+   * request to send it.
+   */
+  const nsMsgDeliverMode nsMsgQueueForLater = 1;
+  const nsMsgDeliverMode nsMsgSave = 2;
+  const nsMsgDeliverMode nsMsgSaveAs = 3;
+  const nsMsgDeliverMode nsMsgSaveAsDraft = 4;
+  const nsMsgDeliverMode nsMsgSaveAsTemplate = 5;
+  const nsMsgDeliverMode nsMsgSendUnsent = 6;
+
+  /// Queue the message in the unsent folder and send it in the background.
+  const nsMsgDeliverMode nsMsgDeliverBackground = 8;
+
+  /**
+   * Create an rfc822 message and send it.
+   * @param aEditor nsIEditor instance that contains message. May be a dummy,
+   *                especially in the case of import.
+   * @param aUserIdentity identity to send from.
+   * @param aAccountKey account we're sending message from. May be null.
+   * @param aFields composition fields from addressing widget
+   * @param aIsDigest is this a digest message?
+   * @param aDontDeliver Set to false by the import code - used when we're
+   *                     trying to create a message from parts.
+   * @param aMode delivery mode
+   * @param aMsgToReplace e.g., when saving a draft over an old draft. May be 0
+   * @param aBodyType content type of message body
+   * @param aBody message body text (should have native line endings)
+   * @param aParentWindow compose window; may be null.
+   * @param aProgress where to send progress info; may be null.
+   * @param aListener optional listener for send progress
+   * @param aPassword optional smtp server password
+   * @param aOriginalMsgURI may be null.
+   * @param aType see nsIMsgComposeParams.idl
+   */
+  Promise createAndSendMessage(in nsIEditor aEditor,
+                               in nsIMsgIdentity aUserIdentity,
+                               in string aAccountKey,
+                               in nsIMsgCompFields aFields,
+                               in boolean aIsDigest,
+                               in boolean aDontDeliver,
+                               in nsMsgDeliverMode aMode,
+                               in nsIMsgDBHdr aMsgToReplace,
+                               in string aBodyType,
+                               in AString aBody,
+                               in mozIDOMWindowProxy aParentWindow,
+                               in nsIMsgProgress aProgress,
+                               in nsIMsgSendListener aListener,
+                               in AString aPassword,
+                               in AUTF8String aOriginalMsgURI,
+                               in MSG_ComposeType aType);
+
+  /**
+   * Creates a file containing an rfc822 message, using the passed information.
+   * aListener's OnStopSending method will get called with the file the message
+   * was stored in. OnStopSending may be called sync or async, depending on
+   * content, so you need to handle both cases.
+   *
+   * @param aUserIdentity    The user identity to use for sending this email.
+   * @param aFields          An nsIMsgCompFields object containing information
+   *                         on who to send the message to.
+   * @param aBodyType content type of message body
+   * @param aBody message body text (should have native line endings)
+   * @param aCreateAsDraft If true, this message will be put in a drafts folder
+   * @param aAttachments Array of nsIMsgAttachedFile objects
+   * @param aEmbeddedObjects Array of nsIMsgEmbeddedImageData objects for
+   *                         MHTML messages.
+   * @param aListener listener for msg creation progress and resulting file.
+   */
+  void createRFC822Message(in nsIMsgIdentity aUserIdentity,
+                           in nsIMsgCompFields aFields,
+                           in string aBodyType,
+                           in ACString aBody,
+                           in boolean aCreateAsDraft,
+                           in Array<nsIMsgAttachedFile> aAttachments,
+                           in Array<nsIMsgEmbeddedImageData> aEmbeddedObjects,
+                           in nsIMsgSendListener aListener);
+
+  /**
+   * Sends a file to the specified composition fields, via the user identity
+   * provided.
+   *
+   * @param aUserIdentity    The user identity to use for sending this email.
+   * @param aAccountKey      The key of the account that this message relates
+   *                         to.
+   * @param aFields          An nsIMsgCompFields object containing information
+   *                         on who to send the message to.
+   * @param aSendIFile       A reference to the file to send.
+   * @param aDeleteSendFileOnCompletion
+   *                         Set to true if you want the send file deleted once
+   *                         the message has been sent.
+   * @param aDigest          If this is a multipart message, this param
+   *                         specifies whether the message is in digest or mixed
+   *                         format.
+   * @param aMode            The delivery mode for sending the message (see
+   *                         above for values).
+   * @param aMsgToReplace    A message header representing a message to be
+   *                         replaced by the one sent, this param may be null.
+   * @param aListener        An nsIMsgSendListener to receive feedback on the
+   *                         current send status. This parameter can also
+   *                         support the nsIMsgCopyServiceListener interface to
+   *                         receive notifications of copy finishing e.g. after
+   *                         saving a message to the sent mail folder.
+   *                         This param may be null.
+   * @param aStatusFeedback  A feedback listener for slightly different feedback
+   *                         on the message send status. This param may be null.
+   * @param aPassword        Pass this in to prevent a dialog if the password
+   *                         is needed for secure transmission.
+   */
+  Promise sendMessageFile(in nsIMsgIdentity       aUserIdentity,
+                          in string               aAccountKey,
+                          in nsIMsgCompFields     aFields,
+                          in nsIFile              aSendIFile,
+                          in boolean              aDeleteSendFileOnCompletion,
+                          in boolean              aDigest,
+                          in nsMsgDeliverMode     aMode,
+                          in nsIMsgDBHdr          aMsgToReplace,
+                          in nsIMsgSendListener   aListener,
+                          in nsIMsgStatusFeedback aStatusFeedback,
+                          in wstring              aPassword
+                          );
+
+    /* Abort current send/save operation */
+    void abort();
+
+    /**
+     * Report a send failure.
+     *
+     * @param aFailureCode     The failure code of the send operation. See
+     *                         nsComposeStrings.h for possible values. NS_OK is a possible
+     *                         value as well; if passed, the function won't prompt the user     *                         but will still about the session.
+     * @param aErrorMsg        The appropriate error string for the failure.
+     * @result                 A modified result value in the case a user action results in
+     *                         a different way to handle the failure.
+     */
+    nsresult fail(in nsresult aFailureCode, in wstring aErrorMsg);
+
+    /* Disable UI notification (alert message) */
+    void setGUINotificationState(in boolean aEnableFlag);
+
+    /* Crypto */
+    void BeginCryptoEncapsulation();
+
+    /* retrieve the last send process report*/
+    readonly attribute nsIMsgSendReport sendReport;
+
+    /* methods for send listener ... */
+    void notifyListenerOnStartSending(in string aMsgID, in unsigned long aMsgSize);
+    void notifyListenerOnProgress(in string aMsgID, in unsigned long aProgress, in unsigned long aProgressMax);
+    void notifyListenerOnStatus(in string aMsgID, in wstring aMsg);
+    void notifyListenerOnStopSending(in string aMsgID, in nsresult aStatus, in wstring aMsg, in nsIFile returnFile);
+    void notifyListenerOnTransportSecurityError(in string msgID, in nsresult status, in nsITransportSecurityInfo secInfo, in ACString location);
+    void deliverAsMailExit(in nsIURI aUrl, in nsresult aExitCode);
+    void deliverAsNewsExit(in nsIURI aUrl, in nsresult aExitCode);
+
+    void sendDeliveryCallback(in nsIURI aUrl, in boolean inIsNewsDelivery, in nsresult aExitCode);
+
+    /* methods for copy listener ... */
+    void notifyListenerOnStartCopy();
+    void notifyListenerOnProgressCopy(in unsigned long aProgress, in unsigned long aProgressMax);
+    void notifyListenerOnStopCopy(in nsresult aStatus);
+    void getMessageId(out ACString messageID);
+    /// When saving as draft, the folder uri we saved to.
+    readonly attribute AUTF8String folderUri;
+
+    /**
+     * After a draft is saved, use this to get the mime part number for the dom
+     * node in the editor embedded object list with the passed in index.
+     *
+     * @param aDomIndex - index in the editor dom embedded object list of
+     * the part we're interested in. These are generally images.
+     *
+     * @return the mime part number for that object.
+     */
+    ACString getPartForDomIndex(in long aDomIndex);
+
+    attribute nsMsgKey messageKey;
+
+    /* process attachment */
+    void gatherMimeAttachments();
+    readonly attribute boolean processAttachmentsSynchronously;
+    readonly attribute unsigned long attachmentCount;
+    attribute unsigned long pendingAttachmentCount;
+    readonly attribute nsMsgDeliverMode deliveryMode;
+
+    nsIMsgProgress getProgress();
+
+    nsIOutputStream getOutputStream();
+
+    attribute nsIRequest runningRequest;
+
+    attribute nsresult status;
+
+    attribute nsIMsgComposeSecure cryptoclosure;
+
+    /// Access the local copy of the composition fields.
+    readonly attribute nsIMsgCompFields sendCompFields;
+
+    /// The message body.
+    readonly attribute AString sendBody;
+
+    /// The type of the message body (typically text/plain or text/html).
+    readonly attribute ACString sendBodyType;
+
+    /// The identity to use to send the message.
+    readonly attribute nsIMsgIdentity identity;
+
+    /// The folder name to which the message will be saved,
+    /// used by error reporting.
+    attribute AString savedToFolderName;
+
+    /// Should we deliver this message (versus saving as a file)?
+    attribute boolean dontDeliver;
+
+};
diff --git a/comm/mailnews/compose/public/nsIMsgSendLater.idl b/comm/mailnews/compose/public/nsIMsgSendLater.idl
new file mode 100644
index 0000000000..65fecebced
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgSendLater.idl
@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIStreamListener.idl"
+
+interface nsIMsgStatusFeedback;
+interface nsIMsgIdentity;
+interface nsIMsgSendLaterListener;
+interface nsIMsgFolder;
+
+/**
+ * nsIMsgSendLater is a service used for sending messages in the background.
+ * Messages should be saved to an identity's unsent messages folder, and then
+ * can be sent by calling sendUnsentMessages.
+ *
+ * Although the service supports passing identities as parameters, until bug
+ * 317803 is fixed, all identities use the same folder, and hence the option
+ * currently doesn't work.
+ */
+[scriptable, uuid(fa324a4b-4b87-4e9a-a3c0-af9071a358df)]
+interface nsIMsgSendLater : nsIStreamListener
+{
+  /// Used to obtain status feedback for when messages are sent.
+  attribute nsIMsgStatusFeedback statusFeedback;
+
+  /**
+   * Sends any unsent messages in the identity's unsent messages folder.
+   *
+   * @param aIdentity   The identity to send messages for.
+   */
+  void sendUnsentMessages(in nsIMsgIdentity aIdentity);
+
+  /**
+   * Adds an listener to the service to receive notifications.
+   *
+   * @param aListener   The listener to add.
+   */
+  void addListener(in nsIMsgSendLaterListener aListener);
+
+  /**
+   * Removes a listener from the service.
+   *
+   * @param aListener                 The listener to remove.
+   * @exception NS_ERROR_INVALID_ARG  If the listener was not already added to
+   *                                  the service.
+   */
+  void removeListener(in nsIMsgSendLaterListener aListener);
+
+  /**
+   * Returns the unsent messages folder for the identity.
+   */
+  nsIMsgFolder getUnsentMessagesFolder(in nsIMsgIdentity userIdentity);
+
+  /**
+   * Returns true if there are any unsent messages to send.
+   *
+   * @param aIdentity  The identity whose folder to check for unsent messages.
+   *                   If not specified, all unsent message folders are checked.
+   */
+  boolean hasUnsentMessages([optional] in nsIMsgIdentity aIdentity);
+
+  /// Returns true if the service is currently sending messages.
+  readonly attribute boolean sendingMessages;
+};
diff --git a/comm/mailnews/compose/public/nsIMsgSendLaterListener.idl b/comm/mailnews/compose/public/nsIMsgSendLaterListener.idl
new file mode 100644
index 0000000000..6e6e29a794
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgSendLaterListener.idl
@@ -0,0 +1,86 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIMsgDBHdr;
+interface nsIMsgIdentity;
+
+/**
+ * Implement this interface and add to nsIMsgSendLater to receive notifications
+ * of send later actions.
+ */
+[scriptable, uuid(a7bc603b-d0da-4959-a82f-4b99c138b9f4)]
+interface nsIMsgSendLaterListener : nsISupports {
+  /**
+   * Notify the observer that the operation of sending messages later has
+   * started.
+   *
+   * @param aTotalMessageCount  Number of messages to be sent. This will not
+   *                            change over the time we are doing this sequence.
+   */
+  void onStartSending(in unsigned long aTotalMessageCount);
+
+  /**
+   * Notify the observer that the next message send/copy is starting and
+   * provide details about the message.
+   *
+   * @param aCurrentMessage      The current message number that is being sent.
+   * @param aTotalMessageCount   The total number of messages that we are
+   *                             trying to send.
+   * @param aMessageHeader       The header information for the message that is
+   *                             being sent.
+   * @param aMessageIdentity     The identity being used to send the message.
+   */
+  void onMessageStartSending(in unsigned long aCurrentMessage,
+                             in unsigned long aTotalMessageCount,
+                             in nsIMsgDBHdr aMessageHeader,
+                             in nsIMsgIdentity aIdentity);
+
+  /**
+   * Notify the observer of the current progress of sending a message. The one
+   * function covers sending the message over the network and copying to the
+   * appropriate sent folder.
+   *
+   * @param aCurrentMessage      The current message number that is being sent.
+   * @param aTotalMessageCount   The total number of messages that we are
+   *                             trying to send.
+   * @param aMessageSendPercent  The percentage of the message sent (0 to 100)
+   * @param aMessageCopyPercent  The percentage of the copy completed (0 to
+   *                             100). If there is no copy for this message,
+   *                             this may be set to 100 at the same time as
+   *                             aMessageSendPercent.
+   */
+  void onMessageSendProgress(in unsigned long aCurrentMessage,
+                             in unsigned long aTotalMessageCount,
+                             in unsigned long aMessageSendPercent,
+                             in unsigned long aMessageCopyPercent);
+
+  /**
+   * Notify the observer of an error in the send message later function.
+   *
+   * @param aCurrentMessage      The current message number that is being sent.
+   * @param aMessageHeader       The header information for the message that is
+   *                             being sent.
+   * @param aStatus              The error status code.
+   * @param aMsg                 A text string describing the error.
+   */
+  void onMessageSendError(in unsigned long aCurrentMessage,
+                          in nsIMsgDBHdr aMessageHeader,
+                          in nsresult aStatus,
+                          in wstring aMsg);
+
+  /**
+   * Notify the observer that the send unsent messages operation has finished.
+   * This is called regardless of the success/failure of the operation.
+   *
+   * @param aStatus     Status code for the message send.
+   * @param aMsg        A text string describing the error.
+   * @param aTotalTried Total number of messages that were attempted to be sent.
+   * @param aSuccessful How many messages were successfully sent.
+   */
+  void onStopSending(in nsresult aStatus, in wstring aMsg,
+                     in unsigned long aTotalTried, in unsigned long aSuccessful);
+};
diff --git a/comm/mailnews/compose/public/nsIMsgSendListener.idl b/comm/mailnews/compose/public/nsIMsgSendListener.idl
new file mode 100644
index 0000000000..0bca8cceb0
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgSendListener.idl
@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIFile;
+interface nsITransportSecurityInfo;
+
+[scriptable, uuid(D34DC178-5E78-45E8-8658-A8F52D9CCF5F)]
+interface nsIMsgSendListener : nsISupports {
+
+    /**
+     * Notify the observer that the message has started to be delivered. This method is
+     * called only once, at the beginning of a message send operation.
+     *
+     * @return The return value is currently ignored.  In the future it may be
+     * used to cancel the URL load..
+     */
+    void onStartSending(in string aMsgID, in uint32_t aMsgSize);
+
+    /**
+     * Notify the observer that progress as occurred for the message send
+     */
+    void onProgress(in string aMsgID, in uint32_t aProgress, in uint32_t aProgressMax);
+
+    /**
+     * Notify the observer with a status message for the message send
+     */
+    void onStatus(in string aMsgID, in wstring aMsg);
+
+    /**
+     * Notify the observer that the message has been sent.  This method is
+     * called once when the networking library has finished processing the
+     * message.
+     *
+     * This method is called regardless of whether the the operation was successful.
+     * aMsgID   The message id for the mail message
+     * status   Status code for the message send.
+     * msg      A text string describing the error.
+     * returnFileSpec The returned file spec for save to file operations.
+     */
+    void onStopSending(in string aMsgID, in nsresult aStatus, in wstring aMsg,
+                       in nsIFile aReturnFile);
+
+    /**
+     * Notify the observer with the message id and the folder uri before the draft
+     * is copied.
+     */
+    void onGetDraftFolderURI(in string aMsgID, in AUTF8String aFolderURI);
+
+    /**
+     * Notify the observer when the user aborts the send without actually doing the send
+     * eg : by closing the compose window without Send.
+     */
+    void onSendNotPerformed(in string aMsgID, in nsresult aStatus);
+
+    /**
+     * Notify that an NSS security error has occurred during the send
+     * (e.g. Bad Certificate or SSL version failure).
+     * This callback is invoked before onStopSending(), in case a listener
+     * needs the securityInfo - most likely to get at a failed certificate,
+     * allowing the user to add an exception.
+     * onStopSending() will still be called after this, so a listener
+     * which doesn't need special NSS handling can just leave this callback as
+     * an empty function and leave the handling to onStopSending().
+     *
+     * @param {string} msgID      - The message ID.
+     * @param {nsresult} status   - The error code (it will be in the NSS error
+     *                              code range).
+     * @param {nsITransportSecurityInfo} secInfo
+     *                            - Security info for the failed operation.
+     * @param {ACString} location - The location of the failed operation
+     *                              ("<host>:<port>")
+     */
+    void onTransportSecurityError(in string msgID, in nsresult status, in nsITransportSecurityInfo secInfo, in ACString location);
+
+};
diff --git a/comm/mailnews/compose/public/nsIMsgSendReport.idl b/comm/mailnews/compose/public/nsIMsgSendReport.idl
new file mode 100644
index 0000000000..bcdf8e7265
--- /dev/null
+++ b/comm/mailnews/compose/public/nsIMsgSendReport.idl
@@ -0,0 +1,47 @@
+/* -*- Mode: idl; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface mozIDOMWindowProxy;
+
+[scriptable, uuid(2ec81175-bc65-44b9-ba87-462bc3f938db)]
+interface nsIMsgProcessReport : nsISupports {
+
+  attribute boolean proceeded;
+  attribute nsresult error;
+  attribute wstring message;
+
+  void reset();
+};
+
+[scriptable, uuid(428c5bde-29f5-4bfe-830a-ec795a1c2975)]
+interface nsIMsgSendReport : nsISupports {
+
+  const long process_Current = -1;
+  const long process_BuildMessage = 0;
+  const long process_NNTP = 1;
+  const long process_SMTP = 2;
+  const long process_Copy = 3;
+  const long process_Filter = 4;
+  const long process_FCC = 5;
+
+  attribute long deliveryMode;      /* see nsMsgDeliverMode in nsIMsgSend.idl for valid value */
+  attribute long currentProcess;
+
+  void reset();
+
+  void setProceeded(in long process, in boolean proceeded);
+  void setError(in long process, in nsresult error, in boolean overwriteError);
+  void setMessage(in long process, in wstring message, in boolean overwriteMessage);
+
+  nsIMsgProcessReport getProcessReport(in long process);
+
+  /* Display Report will ananlyze data collected during the send and will show the most appropriate error.
+     Also it will return the error code. In case of no error or if the error has been canceld, it will return
+     NS_OK.
+  */
+  nsresult displayReport(in mozIDOMWindowProxy prompt, in boolean showErrorOnly, in boolean dontShowReportTwice);
+};
diff --git a/comm/mailnews/compose/public/nsISmtpServer.idl b/comm/mailnews/compose/public/nsISmtpServer.idl
new file mode 100644
index 0000000000..6180e9289d
--- /dev/null
+++ b/comm/mailnews/compose/public/nsISmtpServer.idl
@@ -0,0 +1,151 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "MailNewsTypes2.idl"
+
+interface nsIAuthPrompt;
+interface nsIUrlListener;
+interface nsIURI;
+interface nsIMsgWindow;
+
+/**
+ * This interface represents a single SMTP Server. A SMTP server instance may be
+ * created/obtained from nsIMsgAccountManager.
+ *
+ * Most of the attributes will set/get preferences from the main preferences
+ * file.
+ */
+[scriptable, uuid(a53dce6c-cd81-495c-83bc-45a65df1f08e)]
+interface nsISmtpServer : nsISupports {
+
+  /// A unique identifier for the server.
+  attribute string key;
+
+  /**
+   * A unique identifier for this server that can be used for the same
+   * server synced across multiple profiles. Auto-generated on first use.
+   */
+  attribute AUTF8String UID;
+
+  /// A user supplied description for the server.
+  attribute AUTF8String description;
+
+  /// The server's hostname.
+  attribute AUTF8String hostname;
+
+  /// The server's port.
+  attribute int32_t port;
+
+  /// The username to access the server with (if required)
+  attribute ACString username;
+
+  /**
+   * The CLIENTID to use for this server (if required).
+   * @see https://tools.ietf.org/html/draft-storey-smtp-client-id-05
+   */
+  attribute ACString clientid;
+
+  /**
+   * Whether the CLIENTID feature above is enabled.
+   */
+  attribute boolean clientidEnabled;
+
+  /**
+   * The password to access the server with (if required).
+   *
+   * @note this is stored within the server instance but not within preferences.
+   * It can be specified/saved here to avoid prompting the user constantly for
+   * the sending password.
+   */
+  attribute AString password;
+
+  /// Returns a displayname of the format hostname:port or just hostname
+  readonly attribute string displayname;
+
+  /**
+   * Authentication mechanism.
+   *
+   * @see nsMsgAuthMethod (in MailNewsTypes2.idl)
+   * Same as "mail.smtpserver...authMethod" pref
+   *
+   * Compatibility note: This attribute had a different meaning in TB < 3.1
+   */
+  attribute nsMsgAuthMethodValue authMethod;
+
+  /**
+   * Whether to SSL or STARTTLS or not
+   *
+   * @see nsMsgSocketType (in MailNewsTypes2.idl)
+   * Same as "mail.smtpserver...try_ssl" pref
+   */
+  attribute nsMsgSocketTypeValue socketType;
+
+  /**
+   * May contain an alternative argument to EHLO or HELO to provide to the
+   * server. Reflects the value of the mail.smtpserver.*.hello_argument pref.
+   * This is mainly useful where ISPs don't bother providing PTR records for
+   * their servers and therefore users get an error on sending. See bug 244030
+   * for more discussion.
+   */
+  readonly attribute ACString helloArgument;
+
+  /// Returns the URI of the server (smtp:///)
+  readonly attribute AUTF8String serverURI;
+
+  /** Limit of concurrent connections to a server. */
+  attribute long maximumConnectionsNumber;
+
+  /** Close cached server connections. */
+  void closeCachedConnections();
+
+  /**
+   * Gets a password for this server, using a UI prompt if necessary.
+   *
+   * @param promptString  The string to prompt the user with when asking for
+   *                      the password.
+   * @param promptTitle   The title of the prompt.
+   * @return              The password to use (may be null if no password was
+   *                      obtained).
+   */
+  AString getPasswordWithUI(in wstring promptString, in wstring promptTitle);
+
+  /**
+   * Gets a username and password for this server, using a UI prompt if
+   * necessary.
+   *
+   * @param promptString  The string to prompt the user with when asking for
+   *                      the password.
+   * @param promptTitle   The title of the prompt.
+   * @param netPrompt     An nsIAuthPrompt instance to use for the password
+   *                      prompt.
+   * @param userid        The username to use (may be null if no password was
+   *                      obtained).
+   * @param password      The password to use (may be empty if no password was
+   *                      obtained).
+   */
+  void getUsernamePasswordWithUI(in wstring promptString, in wstring promptTitle,
+                                 in nsIAuthPrompt netPrompt, out ACString userid,
+                                 out AString password);
+
+  /**
+   * Calling this will *remove* the saved password for this server from the
+   * password manager and from the stored value.
+   */
+  void forgetPassword();
+
+    /**
+   * Verify that we can logon
+   *
+   * @param  aPassword - password to use
+   * @param  aUrlListener - gets called back with success or failure.
+   * @return - the url that we run.
+   *
+   */
+  nsIURI verifyLogon(in nsIUrlListener aUrlListener, in nsIMsgWindow aMsgWindow);
+
+  /// Call this to clear all preference values for this server.
+  void clearAllValues();
+};
diff --git a/comm/mailnews/compose/public/nsISmtpService.idl b/comm/mailnews/compose/public/nsISmtpService.idl
new file mode 100644
index 0000000000..0fc306fe11
--- /dev/null
+++ b/comm/mailnews/compose/public/nsISmtpService.idl
@@ -0,0 +1,134 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsISmtpServer;
+interface nsIURI;
+interface nsIUrlListener;
+interface nsIMsgIdentity;
+interface nsIInterfaceRequestor;
+interface nsIFile;
+interface nsIMsgStatusFeedback;
+interface nsIRequest;
+interface nsIMsgWindow;
+
+[scriptable, uuid(1b11b532-1527-4fc0-a00f-4ce7e6886419)]
+interface nsISmtpService : nsISupports {
+  /**
+   * Sends a mail message via the given parameters. This function builds an
+   * SMTP URL and makes an SMTP connection, and then runs the url.
+   * The SMTP server defined
+   * in the aSenderIdentity object (see nsIMsgIdentity) will be used to send
+   * the message. If there is no SMTP server defined in aSenderIdentity, the
+   * default SMTP server will be used.
+   *
+   * @note The file to send must be in the format specified by RFC 2822 for
+   *       sending data. This includes having the correct CRLF line endings
+   *       throughout the file, and the <CRLF>.<CRLF> at the end of the file.
+   *       sendMailMessage does no processing/additions on the file.
+   *
+   * @param aFilePath               The file to send.
+   * @param aRecipients             A comma delimited list of recipients.
+   * @param aSenderIdentity         The identity of the sender.
+   * @param aSender                 The senders email address.
+   * @param aPassword               Pass this in to prevent a dialog if the
+   *                                password is needed for secure transmission.
+   * @param aUrlListener            A listener to listen to the URL being run,
+   *                                this parameter may be null.
+   * @param aStatusListener         A feedback listener for slightly different
+   *                                feedback on the message send status. This
+   *                                parameter may be null.
+   * @param aNotificationCallbacks  More notification callbacks
+   * @param aRequestDSN             Pass true to request Delivery Status
+   *                                Notification.
+   * @param aMessageId              The message id can be used as ENVID for DSN.
+   * @param aURL                    Provides a handle on the running url. You
+   *                                can later interrupt the action by asking the
+   *                                netlib service manager to interrupt the url
+   *                                you are given back. This parameter may be
+   *                                null.
+   * @param aRequest                Provides a handle to the running request.
+   *                                This parameter may be null.
+   */
+  void sendMailMessage(in nsIFile aFilePath, in string aRecipients,
+                       in nsIMsgIdentity aSenderIdentity,
+                       in string aSender,
+                       in AString aPassword,
+                       in nsIUrlListener aUrlListener,
+                       in nsIMsgStatusFeedback aStatusListener,
+                       in nsIInterfaceRequestor aNotificationCallbacks,
+                       in boolean aRequestDSN,
+                       in ACString aMessageId,
+                       out nsIURI aURL,
+                       out nsIRequest aRequest);
+
+  /**
+   * Verifies that we can logon to the server with given password
+   *
+   * @param  aSmtpServer       Server to try to logon to.
+   * @param  aUrlListener      Listener that will get notified whether logon
+   *                           was successful or not.
+   * @param aMsgWindow         nsIMsgWindow to use for notification callbacks.
+   * @return - the url that we run.
+   */
+  nsIURI verifyLogon(in nsISmtpServer aServer, in nsIUrlListener aListener,
+                     in nsIMsgWindow aMsgWindow);
+
+  /**
+   * Return the SMTP server that is associated with an identity.
+   * @param  aSenderIdentity   the identity
+   */
+  nsISmtpServer getServerByIdentity(in nsIMsgIdentity aSenderIdentity);
+
+  /**
+   * A copy of the array of SMTP servers, as stored in the preferences
+   */
+  readonly attribute Array<nsISmtpServer> servers;
+
+  /**
+   * The default server, across sessions of the app
+   * (eventually there will be a session default which does not
+   * persist past shutdown)
+   */
+  attribute nsISmtpServer defaultServer;
+
+  /**
+   * The "session default" server - this is never saved, and only used
+   * for the current session. Always falls back to the default server
+   * unless explicitly set.
+   */
+  attribute nsISmtpServer sessionDefaultServer;
+
+  /**
+   * Create a new SMTP server.
+   * Use this instead of createInstance(), so that the SMTP Service can
+   * be aware of this server
+   */
+  nsISmtpServer createServer();
+
+  /**
+   * Find the first server with the given hostname and/or username.
+   * Note: if either username or hostname is empty, then that parameter will
+   * not be used in the matching process.
+   * @param username  the username for the server
+   * @param hostname  the hostname of the server
+   * @returns         null if no server is found
+   */
+  nsISmtpServer findServer(in string username, in string hostname);
+
+  /**
+   * Look up the server with the given key.
+   */
+  nsISmtpServer getServerByKey(in string key);
+
+  /**
+   * Delete the given server from the server list - does nothing if the server
+   * does not exist
+   * @param server   the server to delete. Use findServer() if you only know
+   *                 the hostname
+   */
+  void deleteServer(in nsISmtpServer server);
+};
diff --git a/comm/mailnews/compose/public/nsISmtpUrl.idl b/comm/mailnews/compose/public/nsISmtpUrl.idl
new file mode 100644
index 0000000000..c03bc7f4e6
--- /dev/null
+++ b/comm/mailnews/compose/public/nsISmtpUrl.idl
@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIMsgComposeParams.idl"
+
+interface nsIMsgIdentity;
+interface nsIPrompt;
+interface nsIAuthPrompt;
+interface nsISmtpServer;
+interface nsIInterfaceRequestor;
+interface nsIFile;
+
+[scriptable, uuid(da22b8ac-059d-4f82-bf99-f5f3d3c8202d)]
+interface nsISmtpUrl : nsISupports {
+  /**
+   * SMTP Parse specific getters.
+   * These retrieve various parts from the url.
+   */
+
+  /**
+   * This list is a list of all recipients to send the email to.
+   * Each name is NULL terminated.
+   */
+  attribute string recipients;
+
+  attribute boolean PostMessage;
+
+  /**
+   * The message can be stored in a file, to allow accessors for getting and
+   * setting the file name to post.
+   */
+  attribute nsIFile postMessageFile;
+
+  attribute boolean requestDSN;
+
+  /**
+   * The envid which is used in the DSN.
+   */
+  attribute ACString dsnEnvid;
+
+  /**
+   * The sender of this mail (can be different from identity).
+   */
+  attribute string sender;
+
+  /**
+   * SMTP Url instance specific getters and setters
+   * Information the protocol needs to know in order to run the url.
+   * These are NOT event sinks which are things the caller needs to know.
+   */
+
+  /**
+   * By default the url is really a bring up the compose window mailto url.
+   * You need to call this function if you want to force the message to be
+   * posted to the mailserver.
+   */
+
+  /**
+   * The user's full name and user's email address are encapsulated in the
+   * senderIdentity.
+   * (the user's domain name can be glopped from the user's email address)
+   *
+   * NOTE:  the SMTP username and SMTP server are in the smtp url
+   * smtp://sspitzer@tintin/...
+   */
+  attribute nsIMsgIdentity senderIdentity;
+  attribute nsIPrompt prompt;
+  attribute nsIAuthPrompt authPrompt;
+  attribute nsIInterfaceRequestor notificationCallbacks;
+  attribute nsISmtpServer smtpServer;
+
+  attribute boolean verifyLogon; // we're just verifying the ability to logon
+
+  /// Constant for the default SMTP port number
+  const int32_t DEFAULT_SMTP_PORT = 25;
+
+  /// Constant for the default SMTP over ssl port number
+  const int32_t DEFAULT_SMTPS_PORT = 465;
+};
+
+[scriptable, uuid(87c36c23-4bc2-4992-b338-69f88f6ed0a1)]
+interface nsIMailtoUrl : nsISupports {
+  /**
+   * mailto: parse specific getters
+   *
+   * All of these fields are things we can effectively extract from a
+   * mailto url if it contains all of these values
+   *
+   * Note: Attachments aren't available because that would expose a potential
+   * security hole (see bug 99055).
+   *
+   * These items are in one function as we only ever get them from the one
+   * place and all at the same time.
+   */
+  void getMessageContents(out AUTF8String aToPart, out AUTF8String aCcPart,
+                          out AUTF8String aBccPart, out AUTF8String aSubjectPart,
+                          out AUTF8String aBodyPart, out AUTF8String aHtmlPart,
+                          out ACString aReferencePart,
+                          out AUTF8String aNewsgroupPart,
+                          out MSG_ComposeFormat aFormat);
+
+  /**
+   * These attributes are available should mailnews or extensions want them
+   * but aren't used by standard in mailnews.
+   */
+  readonly attribute AUTF8String fromPart;
+  readonly attribute AUTF8String followUpToPart;
+  readonly attribute AUTF8String organizationPart;
+  readonly attribute AUTF8String replyToPart;
+  readonly attribute AUTF8String priorityPart;
+  readonly attribute AUTF8String newsHostPart;
+};
diff --git a/comm/mailnews/compose/src/MailtoProtocolHandler.jsm b/comm/mailnews/compose/src/MailtoProtocolHandler.jsm
new file mode 100644
index 0000000000..a129e7d750
--- /dev/null
+++ b/comm/mailnews/compose/src/MailtoProtocolHandler.jsm
@@ -0,0 +1,38 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["MailtoProtocolHandler"];
+
+/**
+ * Protocol handler for mailto: url.
+ *
+ * @implements {nsIProtocolHandler}
+ */
+class MailtoProtocolHandler {
+  QueryInterface = ChromeUtils.generateQI([Ci.nsIProtocolHandler]);
+
+  scheme = "mailto";
+  allowPort = false;
+
+  newChannel(uri, loadInfo) {
+    // Create an empty pipe to get an inputStream.
+    let pipe = Cc["@mozilla.org/pipe;1"].createInstance(Ci.nsIPipe);
+    pipe.init(true, true, 0, 0);
+    pipe.outputStream.close();
+
+    // Create a channel so that we can set contentType onto it.
+    let streamChannel = Cc[
+      "@mozilla.org/network/input-stream-channel;1"
+    ].createInstance(Ci.nsIInputStreamChannel);
+    streamChannel.setURI(uri);
+    streamChannel.contentStream = pipe.inputStream;
+
+    let channel = streamChannel.QueryInterface(Ci.nsIChannel);
+    // With this set, a nsIContentHandler instance will take over to open a
+    // compose window.
+    channel.contentType = "application/x-mailto";
+    channel.loadInfo = loadInfo;
+    return channel;
+  }
+}
diff --git a/comm/mailnews/compose/src/MessageSend.jsm b/comm/mailnews/compose/src/MessageSend.jsm
new file mode 100644
index 0000000000..914694fa79
--- /dev/null
+++ b/comm/mailnews/compose/src/MessageSend.jsm
@@ -0,0 +1,1434 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["MessageSend"];
+
+const { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+const { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  setTimeout: "resource://gre/modules/Timer.sys.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  MailUtils: "resource:///modules/MailUtils.jsm",
+  jsmime: "resource:///modules/jsmime.jsm",
+  MimeMessage: "resource:///modules/MimeMessage.jsm",
+  MsgUtils: "resource:///modules/MimeMessageUtils.jsm",
+});
+
+// nsMsgKey_None from MailNewsTypes.h.
+const nsMsgKey_None = 0xffffffff;
+
+/**
+ * A class to manage sending processes.
+ *
+ * @implements {nsIMsgSend}
+ * @implements {nsIWebProgressListener}
+ */
+class MessageSend {
+  QueryInterface = ChromeUtils.generateQI([
+    "nsIMsgSend",
+    "nsIWebProgressListener",
+  ]);
+  classID = Components.ID("{028b9c1e-8d0a-4518-80c2-842e07846eaa}");
+
+  async createAndSendMessage(
+    editor,
+    userIdentity,
+    accountKey,
+    compFields,
+    isDigest,
+    dontDeliver,
+    deliverMode,
+    msgToReplace,
+    bodyType,
+    body,
+    parentWindow,
+    progress,
+    listener,
+    smtpPassword,
+    originalMsgURI,
+    compType
+  ) {
+    this._userIdentity = userIdentity;
+    this._accountKey = accountKey || this._accountKeyForIdentity(userIdentity);
+    this._compFields = compFields;
+    this._dontDeliver = dontDeliver;
+    this._deliverMode = deliverMode;
+    this._msgToReplace = msgToReplace;
+    this._sendProgress = progress;
+    this._smtpPassword = smtpPassword;
+    this._sendListener = listener;
+    this._parentWindow = parentWindow;
+    this._originalMsgURI = originalMsgURI;
+    this._shouldRemoveMessageFile = true;
+
+    this._sendReport = Cc[
+      "@mozilla.org/messengercompose/sendreport;1"
+    ].createInstance(Ci.nsIMsgSendReport);
+    this._composeBundle = Services.strings.createBundle(
+      "chrome://messenger/locale/messengercompose/composeMsgs.properties"
+    );
+
+    // Initialize the error reporting mechanism.
+    this.sendReport.reset();
+    this.sendReport.deliveryMode = deliverMode;
+    this._setStatusMessage(
+      this._composeBundle.GetStringFromName("assemblingMailInformation")
+    );
+    this.sendReport.currentProcess = Ci.nsIMsgSendReport.process_BuildMessage;
+
+    this._setStatusMessage(
+      this._composeBundle.GetStringFromName("assemblingMessage")
+    );
+
+    this._fcc = lazy.MsgUtils.getFcc(
+      userIdentity,
+      compFields,
+      originalMsgURI,
+      compType
+    );
+    let { embeddedAttachments, embeddedObjects } =
+      this._gatherEmbeddedAttachments(editor);
+
+    let bodyText = this._getBodyFromEditor(editor) || body;
+    // Convert to a binary string. This is because MimeMessage requires it and:
+    // 1. An attachment content is BinaryString.
+    // 2. Body text and attachment contents are handled in the same way by
+    // MimeEncoder to pick encoding and encode.
+    bodyText = lazy.jsmime.mimeutils.typedArrayToString(
+      new TextEncoder().encode(bodyText)
+    );
+
+    this._restoreEditorContent(embeddedObjects);
+    this._message = new lazy.MimeMessage(
+      userIdentity,
+      compFields,
+      this._fcc,
+      bodyType,
+      bodyText,
+      deliverMode,
+      originalMsgURI,
+      compType,
+      embeddedAttachments,
+      this.sendReport
+    );
+
+    this._messageKey = nsMsgKey_None;
+
+    this._setStatusMessage(
+      this._composeBundle.GetStringFromName("creatingMailMessage")
+    );
+    lazy.MsgUtils.sendLogger.debug("Creating message file");
+    let messageFile;
+    try {
+      // Create a local file from MimeMessage, then pass it to _deliverMessage.
+      messageFile = await this._message.createMessageFile();
+    } catch (e) {
+      lazy.MsgUtils.sendLogger.error(e);
+      let errorMsg = "";
+      if (e.result == lazy.MsgUtils.NS_MSG_ERROR_ATTACHING_FILE) {
+        errorMsg = this._composeBundle.formatStringFromName(
+          "errorAttachingFile",
+          [e.data.name || e.data.url]
+        );
+      }
+      this.fail(e.result || Cr.NS_ERROR_FAILURE, errorMsg);
+      this.notifyListenerOnStopSending(null, e.result, null, null);
+      return null;
+    }
+    this._setStatusMessage(
+      this._composeBundle.GetStringFromName("assemblingMessageDone")
+    );
+    lazy.MsgUtils.sendLogger.debug("Message file created");
+    return this._deliverMessage(messageFile);
+  }
+
+  sendMessageFile(
+    userIdentity,
+    accountKey,
+    compFields,
+    messageFile,
+    deleteSendFileOnCompletion,
+    digest,
+    deliverMode,
+    msgToReplace,
+    listener,
+    statusFeedback,
+    smtpPassword
+  ) {
+    this._userIdentity = userIdentity;
+    this._accountKey = accountKey || this._accountKeyForIdentity(userIdentity);
+    this._compFields = compFields;
+    this._deliverMode = deliverMode;
+    this._msgToReplace = msgToReplace;
+    this._smtpPassword = smtpPassword;
+    this._sendListener = listener;
+    this._statusFeedback = statusFeedback;
+    this._shouldRemoveMessageFile = deleteSendFileOnCompletion;
+
+    this._sendReport = Cc[
+      "@mozilla.org/messengercompose/sendreport;1"
+    ].createInstance(Ci.nsIMsgSendReport);
+    this._composeBundle = Services.strings.createBundle(
+      "chrome://messenger/locale/messengercompose/composeMsgs.properties"
+    );
+
+    // Initialize the error reporting mechanism.
+    this.sendReport.reset();
+    this.sendReport.deliveryMode = deliverMode;
+    this._setStatusMessage(
+      this._composeBundle.GetStringFromName("assemblingMailInformation")
+    );
+    this.sendReport.currentProcess = Ci.nsIMsgSendReport.process_BuildMessage;
+
+    this._setStatusMessage(
+      this._composeBundle.GetStringFromName("assemblingMessage")
+    );
+
+    this._fcc = lazy.MsgUtils.getFcc(
+      userIdentity,
+      compFields,
+      null,
+      Ci.nsIMsgCompType.New
+    );
+
+    // nsMsgKey_None from MailNewsTypes.h.
+    this._messageKey = 0xffffffff;
+
+    return this._deliverMessage(messageFile);
+  }
+
+  // @see nsIMsgSend
+  createRFC822Message(
+    userIdentity,
+    compFields,
+    bodyType,
+    bodyText,
+    isDraft,
+    attachedFiles,
+    embeddedObjects,
+    listener
+  ) {
+    this._userIdentity = userIdentity;
+    this._compFields = compFields;
+    this._dontDeliver = true;
+    this._sendListener = listener;
+
+    this._sendReport = Cc[
+      "@mozilla.org/messengercompose/sendreport;1"
+    ].createInstance(Ci.nsIMsgSendReport);
+    this._composeBundle = Services.strings.createBundle(
+      "chrome://messenger/locale/messengercompose/composeMsgs.properties"
+    );
+
+    // Initialize the error reporting mechanism.
+    this.sendReport.reset();
+    let deliverMode = isDraft
+      ? Ci.nsIMsgSend.nsMsgSaveAsDraft
+      : Ci.nsIMsgSend.nsMsgDeliverNow;
+    this.sendReport.deliveryMode = deliverMode;
+
+    // Convert nsIMsgAttachedFile[] to nsIMsgAttachment[]
+    for (let file of attachedFiles) {
+      let attachment = Cc[
+        "@mozilla.org/messengercompose/attachment;1"
+      ].createInstance(Ci.nsIMsgAttachment);
+      attachment.name = file.realName;
+      attachment.url = file.origUrl.spec;
+      attachment.contentType = file.type;
+      compFields.addAttachment(attachment);
+    }
+
+    // Convert nsIMsgEmbeddedImageData[] to nsIMsgAttachment[]
+    let embeddedAttachments = embeddedObjects.map(obj => {
+      let attachment = Cc[
+        "@mozilla.org/messengercompose/attachment;1"
+      ].createInstance(Ci.nsIMsgAttachment);
+      attachment.name = obj.name;
+      attachment.contentId = obj.cid;
+      attachment.url = obj.uri.spec;
+      return attachment;
+    });
+
+    this._message = new lazy.MimeMessage(
+      userIdentity,
+      compFields,
+      null,
+      bodyType,
+      bodyText,
+      deliverMode,
+      null,
+      Ci.nsIMsgCompType.New,
+      embeddedAttachments,
+      this.sendReport
+    );
+
+    this._messageKey = nsMsgKey_None;
+
+    // Create a local file from MimeMessage, then pass it to _deliverMessage.
+    this._message
+      .createMessageFile()
+      .then(messageFile => this._deliverMessage(messageFile));
+  }
+
+  // nsIWebProgressListener.
+  onLocationChange(webProgress, request, location, flags) {}
+  onProgressChange(
+    webProgress,
+    request,
+    curSelfProgress,
+    maxSelfProgress,
+    curTotalProgress,
+    maxTotalProgress
+  ) {}
+  onStatusChange(webProgress, request, status, message) {}
+  onSecurityChange(webProgress, request, state) {}
+  onContentBlockingEvent(webProgress, request, event) {}
+  onStateChange(webProgress, request, stateFlags, status) {
+    if (
+      stateFlags & Ci.nsIWebProgressListener.STATE_STOP &&
+      !Components.isSuccessCode(status)
+    ) {
+      lazy.MsgUtils.sendLogger.debug("onStateChange with failure. Aborting.");
+      this._isRetry = false;
+      this.abort();
+    }
+  }
+
+  abort() {
+    if (this._aborting) {
+      return;
+    }
+    this._aborting = true;
+    if (this._smtpRequest?.value) {
+      this._smtpRequest.value.cancel(Cr.NS_ERROR_ABORT);
+      this._smtpRequest = null;
+    }
+    if (this._msgCopy) {
+      MailServices.copy.notifyCompletion(
+        this._copyFile,
+        this._msgCopy.dstFolder,
+        Cr.NS_ERROR_ABORT
+      );
+    } else {
+      // If already in the fcc step, notifyListenerOnStopCopy will do the clean up.
+      this._cleanup();
+    }
+    if (!this._failed) {
+      // Emit stopsending event if the sending is cancelled by user, so that
+      // listeners can do necessary clean up, e.g. reset the sending button.
+      this.notifyListenerOnStopSending(null, Cr.NS_ERROR_ABORT, null, null);
+    }
+    this._aborting = false;
+  }
+
+  fail(exitCode, errorMsg) {
+    this._failed = true;
+    if (!Components.isSuccessCode(exitCode) && exitCode != Cr.NS_ERROR_ABORT) {
+      lazy.MsgUtils.sendLogger.error(
+        `Sending failed; ${errorMsg}, exitCode=${exitCode}, originalMsgURI=${this._originalMsgURI}`
+      );
+      this._sendReport.setError(
+        Ci.nsIMsgSendReport.process_Current,
+        exitCode,
+        false
+      );
+      if (errorMsg) {
+        this._sendReport.setMessage(
+          Ci.nsIMsgSendReport.process_Current,
+          errorMsg,
+          false
+        );
+      }
+      exitCode = this._sendReport.displayReport(this._parentWindow, true, true);
+    }
+    this.abort();
+
+    return exitCode;
+  }
+
+  getPartForDomIndex(domIndex) {
+    throw Components.Exception(
+      "getPartForDomIndex not implemented",
+      Cr.NS_ERROR_NOT_IMPLEMENTED
+    );
+  }
+
+  getProgress() {
+    return this._sendProgress;
+  }
+
+  /**
+   * NOTE: This is a copy of the C++ code, msgId and msgSize are only
+   * placeholders. Maybe refactor this after nsMsgSend is gone.
+   */
+  notifyListenerOnStartSending(msgId, msgSize) {
+    lazy.MsgUtils.sendLogger.debug("notifyListenerOnStartSending");
+    if (this._sendListener) {
+      this._sendListener.onStartSending(msgId, msgSize);
+    }
+  }
+
+  notifyListenerOnStartCopy() {
+    lazy.MsgUtils.sendLogger.debug("notifyListenerOnStartCopy");
+    if (this._sendListener instanceof Ci.nsIMsgCopyServiceListener) {
+      this._sendListener.OnStartCopy();
+    }
+  }
+
+  notifyListenerOnProgressCopy(progress, progressMax) {
+    lazy.MsgUtils.sendLogger.debug("notifyListenerOnProgressCopy");
+    if (this._sendListener instanceof Ci.nsIMsgCopyServiceListener) {
+      this._sendListener.OnProgress(progress, progressMax);
+    }
+  }
+
+  notifyListenerOnStopCopy(status) {
+    lazy.MsgUtils.sendLogger.debug(
+      `notifyListenerOnStopCopy; status=${status}`
+    );
+    this._msgCopy = null;
+
+    if (!this._isRetry) {
+      let statusMsgEntry = Components.isSuccessCode(status)
+        ? "copyMessageComplete"
+        : "copyMessageFailed";
+      this._setStatusMessage(
+        this._composeBundle.GetStringFromName(statusMsgEntry)
+      );
+    } else if (Components.isSuccessCode(status)) {
+      // We got here via retry and the save to sent, drafts or template
+      // succeeded so take down our progress dialog. We don't need it any more.
+      this._sendProgress.unregisterListener(this);
+      this._sendProgress.closeProgressDialog(false);
+      this._isRetry = false;
+    }
+
+    if (!Components.isSuccessCode(status)) {
+      let localFoldersAccountName =
+        MailServices.accounts.localFoldersServer.prettyName;
+      let folder = lazy.MailUtils.getOrCreateFolder(this._folderUri);
+      let accountName = folder?.server.prettyName;
+      if (!this._fcc || !localFoldersAccountName || !accountName) {
+        this.fail(Cr.NS_OK, null);
+        return;
+      }
+
+      let params = [folder.name, accountName, localFoldersAccountName];
+      let promptMsg;
+      switch (this._deliverMode) {
+        case Ci.nsIMsgSend.nsMsgDeliverNow:
+        case Ci.nsIMsgSend.nsMsgSendUnsent:
+          promptMsg = this._composeBundle.formatStringFromName(
+            "promptToSaveSentLocally2",
+            params
+          );
+          break;
+        case Ci.nsIMsgSend.nsMsgSaveAsDraft:
+          promptMsg = this._composeBundle.formatStringFromName(
+            "promptToSaveDraftLocally2",
+            params
+          );
+          break;
+        case Ci.nsIMsgSend.nsMsgSaveAsTemplate:
+          promptMsg = this._composeBundle.formatStringFromName(
+            "promptToSaveTemplateLocally2",
+            params
+          );
+          break;
+      }
+      if (promptMsg) {
+        let showCheckBox = { value: false };
+        let buttonFlags =
+          Ci.nsIPrompt.BUTTON_POS_0 * Ci.nsIPrompt.BUTTON_TITLE_IS_STRING +
+          Ci.nsIPrompt.BUTTON_POS_1 * Ci.nsIPrompt.BUTTON_TITLE_DONT_SAVE +
+          Ci.nsIPrompt.BUTTON_POS_2 * Ci.nsIPrompt.BUTTON_TITLE_SAVE;
+        let dialogTitle =
+          this._composeBundle.GetStringFromName("SaveDialogTitle");
+        let buttonLabelRety =
+          this._composeBundle.GetStringFromName("buttonLabelRetry2");
+        let buttonPressed = Services.prompt.confirmEx(
+          this._parentWindow,
+          dialogTitle,
+          promptMsg,
+          buttonFlags,
+          buttonLabelRety,
+          null,
+          null,
+          null,
+          showCheckBox
+        );
+        if (buttonPressed == 0) {
+          // retry button clicked
+          // Check we have a progress dialog.
+          if (
+            this._sendProgress.processCanceledByUser &&
+            Services.prefs.getBoolPref("mailnews.show_send_progress")
+          ) {
+            let progress = Cc[
+              "@mozilla.org/messenger/progress;1"
+            ].createInstance(Ci.nsIMsgProgress);
+
+            let params = Cc[
+              "@mozilla.org/messengercompose/composeprogressparameters;1"
+            ].createInstance(Ci.nsIMsgComposeProgressParams);
+            params.subject = this._parentWindow.gMsgCompose.compFields.subject;
+            params.deliveryMode = this._deliverMode;
+
+            progress.openProgressDialog(
+              this._parentWindow,
+              this._sendProgress.msgWindow,
+              "chrome://messenger/content/messengercompose/sendProgress.xhtml",
+              false,
+              params
+            );
+
+            progress.onStateChange(
+              null,
+              null,
+              Ci.nsIWebProgressListener.STATE_START,
+              Cr.NS_OK
+            );
+
+            // We want to hear when this is cancelled.
+            progress.registerListener(this);
+
+            this._sendProgress = progress;
+            this._isRetry = true;
+          }
+          // Ensure statusFeedback is set so progress percent bargraph occurs.
+          this._sendProgress.msgWindow.statusFeedback = this._sendProgress;
+
+          this._mimeDoFcc();
+          return;
+        } else if (buttonPressed == 2) {
+          try {
+            // Try to save to Local Folders/<account name>. Pass null to save
+            // to local folders and not the configured fcc.
+            this._mimeDoFcc(null, true, Ci.nsIMsgSend.nsMsgDeliverNow);
+            return;
+          } catch (e) {
+            Services.prompt.alert(
+              this._parentWindow,
+              null,
+              this._composeBundle.GetStringFromName("saveToLocalFoldersFailed")
+            );
+          }
+        }
+      }
+      this.fail(Cr.NS_OK, null);
+    }
+
+    if (
+      !this._fcc2Handled &&
+      this._messageKey != nsMsgKey_None &&
+      [Ci.nsIMsgSend.nsMsgDeliverNow, Ci.nsIMsgSend.nsMsgSendUnsent].includes(
+        this._deliverMode
+      )
+    ) {
+      try {
+        this._filterSentMessage();
+      } catch (e) {
+        this.onStopOperation(e.result);
+      }
+      return;
+    }
+
+    this._doFcc2();
+  }
+
+  notifyListenerOnStopSending(msgId, status, msg, returnFile) {
+    lazy.MsgUtils.sendLogger.debug(
+      `notifyListenerOnStopSending; status=${status}`
+    );
+    try {
+      this._sendListener?.onStopSending(msgId, status, msg, returnFile);
+    } catch (e) {}
+  }
+
+  notifyListenerOnTransportSecurityError(msgId, status, secInfo, location) {
+    lazy.MsgUtils.sendLogger.debug(
+      `notifyListenerOnTransportSecurityError; status=${status}, location=${location}`
+    );
+    if (!this._sendListener) {
+      return;
+    }
+    try {
+      this._sendListener.onTransportSecurityError(
+        msgId,
+        status,
+        secInfo,
+        location
+      );
+    } catch (e) {}
+  }
+
+  /**
+   * Called by nsIMsgFilterService.
+   */
+  onStopOperation(status) {
+    lazy.MsgUtils.sendLogger.debug(`onStopOperation; status=${status}`);
+    if (Components.isSuccessCode(status)) {
+      this._setStatusMessage(
+        this._composeBundle.GetStringFromName("filterMessageComplete")
+      );
+    } else {
+      this._setStatusMessage(
+        this._composeBundle.GetStringFromName("filterMessageFailed")
+      );
+      Services.prompt.alert(
+        this._parentWindow,
+        null,
+        this._composeBundle.GetStringFromName("errorFilteringMsg")
+      );
+    }
+
+    this._doFcc2();
+  }
+
+  /**
+   * Handle the exit code of message delivery.
+   *
+   * @param {nsIURI} url - The delivered message uri.
+   * @param {boolean} isNewsDelivery - The message was delivered to newsgroup.
+   * @param {nsreault} exitCode - The exit code of message delivery.
+   */
+  _deliveryExitProcessing(url, isNewsDelivery, exitCode) {
+    lazy.MsgUtils.sendLogger.debug(
+      `Delivery exit processing; exitCode=${exitCode}`
+    );
+    if (!Components.isSuccessCode(exitCode)) {
+      let isNSSError = false;
+      let errorName = lazy.MsgUtils.getErrorStringName(exitCode);
+      let errorMsg;
+      if (
+        [
+          lazy.MsgUtils.NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER,
+          lazy.MsgUtils.NS_ERROR_SMTP_SEND_FAILED_REFUSED,
+          lazy.MsgUtils.NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED,
+          lazy.MsgUtils.NS_ERROR_SMTP_SEND_FAILED_TIMEOUT,
+          lazy.MsgUtils.NS_ERROR_SMTP_PASSWORD_UNDEFINED,
+          lazy.MsgUtils.NS_ERROR_SMTP_AUTH_FAILURE,
+          lazy.MsgUtils.NS_ERROR_SMTP_AUTH_GSSAPI,
+          lazy.MsgUtils.NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED,
+          lazy.MsgUtils.NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL,
+          lazy.MsgUtils.NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL,
+          lazy.MsgUtils.NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT,
+          lazy.MsgUtils.NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS,
+        ].includes(exitCode)
+      ) {
+        errorMsg = lazy.MsgUtils.formatStringWithSMTPHostName(
+          this._userIdentity,
+          this._composeBundle,
+          errorName
+        );
+      } else {
+        let nssErrorsService = Cc[
+          "@mozilla.org/nss_errors_service;1"
+        ].getService(Ci.nsINSSErrorsService);
+        try {
+          // This is a server security issue as determined by the Mozilla
+          // platform. To the Mozilla security message string, appended a string
+          // having additional information with the server name encoded.
+          errorMsg = nssErrorsService.getErrorMessage(exitCode);
+          errorMsg +=
+            "\n" +
+            lazy.MsgUtils.formatStringWithSMTPHostName(
+              this._userIdentity,
+              this._composeBundle,
+              "smtpSecurityIssue"
+            );
+          isNSSError = true;
+        } catch (e) {
+          if (url.errorMessage) {
+            // url.errorMessage is an already localized message, usually
+            // combined with the error message from SMTP server.
+            errorMsg = url.errorMessage;
+          } else if (errorName != "sendFailed") {
+            // Not the default string. A mailnews error occurred that does not
+            // require the server name to be encoded. Just print the descriptive
+            // string.
+            errorMsg = this._composeBundle.GetStringFromName(errorName);
+          } else {
+            errorMsg = this._composeBundle.GetStringFromName(
+              "sendFailedUnexpected"
+            );
+            // nsIStringBundle.formatStringFromName doesn't work with %X.
+            errorMsg.replace("%X", `0x${exitCode.toString(16)}`);
+            errorMsg =
+              "\n" +
+              lazy.MsgUtils.formatStringWithSMTPHostName(
+                this._userIdentity,
+                this._composeBundle,
+                "smtpSendFailedUnknownReason"
+              );
+          }
+        }
+      }
+      if (isNSSError) {
+        let u = url.QueryInterface(Ci.nsIMsgMailNewsUrl);
+        this.notifyListenerOnTransportSecurityError(
+          null,
+          exitCode,
+          u.failedSecInfo,
+          u.asciiHostPort
+        );
+      }
+      this.notifyListenerOnStopSending(null, exitCode, null, null);
+      this.fail(exitCode, errorMsg);
+      return;
+    }
+
+    if (
+      isNewsDelivery &&
+      (this._compFields.to || this._compFields.cc || this._compFields.bcc)
+    ) {
+      this._deliverAsMail();
+      return;
+    }
+
+    this.notifyListenerOnStopSending(
+      this._compFields.messageId,
+      exitCode,
+      null,
+      null
+    );
+
+    this._doFcc();
+  }
+
+  sendDeliveryCallback(url, isNewsDelivery, exitCode) {
+    if (isNewsDelivery) {
+      if (
+        !Components.isSuccessCode(exitCode) &&
+        exitCode != Cr.NS_ERROR_ABORT &&
+        !lazy.MsgUtils.isMsgError(exitCode)
+      ) {
+        exitCode = lazy.MsgUtils.NS_ERROR_POST_FAILED;
+      }
+      return this._deliveryExitProcessing(url, isNewsDelivery, exitCode);
+    }
+    if (!Components.isSuccessCode(exitCode)) {
+      switch (exitCode) {
+        case Cr.NS_ERROR_UNKNOWN_HOST:
+        case Cr.NS_ERROR_UNKNOWN_PROXY_HOST:
+          exitCode = lazy.MsgUtils.NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER;
+          break;
+        case Cr.NS_ERROR_CONNECTION_REFUSED:
+        case Cr.NS_ERROR_PROXY_CONNECTION_REFUSED:
+          exitCode = lazy.MsgUtils.NS_ERROR_SMTP_SEND_FAILED_REFUSED;
+          break;
+        case Cr.NS_ERROR_NET_INTERRUPT:
+          exitCode = lazy.MsgUtils.NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED;
+          break;
+        case Cr.NS_ERROR_NET_TIMEOUT:
+        case Cr.NS_ERROR_NET_RESET:
+          exitCode = lazy.MsgUtils.NS_ERROR_SMTP_SEND_FAILED_TIMEOUT;
+          break;
+        default:
+          break;
+      }
+    }
+    return this._deliveryExitProcessing(url, isNewsDelivery, exitCode);
+  }
+
+  get folderUri() {
+    return this._folderUri;
+  }
+
+  /**
+   * @type {nsMsgKey}
+   */
+  set messageKey(key) {
+    this._messageKey = key;
+  }
+
+  /**
+   * @type {nsMsgKey}
+   */
+  get messageKey() {
+    return this._messageKey;
+  }
+
+  get sendReport() {
+    return this._sendReport;
+  }
+
+  _setStatusMessage(msg) {
+    if (this._sendProgress) {
+      this._sendProgress.onStatusChange(null, null, Cr.NS_OK, msg);
+    }
+  }
+
+  /**
+   * Deliver a message.
+   *
+   * @param {nsIFile} file - The message file to deliver.
+   */
+  async _deliverMessage(file) {
+    if (this._dontDeliver) {
+      this.notifyListenerOnStopSending(null, Cr.NS_OK, null, file);
+      return;
+    }
+
+    this._messageFile = file;
+    if (
+      [
+        Ci.nsIMsgSend.nsMsgQueueForLater,
+        Ci.nsIMsgSend.nsMsgDeliverBackground,
+        Ci.nsIMsgSend.nsMsgSaveAsDraft,
+        Ci.nsIMsgSend.nsMsgSaveAsTemplate,
+      ].includes(this._deliverMode)
+    ) {
+      await this._mimeDoFcc();
+      return;
+    }
+
+    let warningSize = Services.prefs.getIntPref(
+      "mailnews.message_warning_size"
+    );
+    if (warningSize > 0 && file.fileSize > warningSize) {
+      let messenger = Cc["@mozilla.org/messenger;1"].createInstance(
+        Ci.nsIMessenger
+      );
+      let msg = this._composeBundle.formatStringFromName(
+        "largeMessageSendWarning",
+        [messenger.formatFileSize(file.fileSize)]
+      );
+      if (!Services.prompt.confirm(this._parentWindow, null, msg)) {
+        this.fail(lazy.MsgUtils.NS_ERROR_BUT_DONT_SHOW_ALERT, msg);
+        throw Components.Exception(
+          "Cancelled sending large message",
+          Cr.NS_ERROR_FAILURE
+        );
+      }
+    }
+
+    this._deliveryFile = await this._createDeliveryFile();
+    if (this._compFields.newsgroups) {
+      this._deliverAsNews();
+      return;
+    }
+    await this._deliverAsMail();
+  }
+
+  /**
+   * Strip Bcc header, create the file to be actually delivered.
+   *
+   * @returns {nsIFile}
+   */
+  async _createDeliveryFile() {
+    if (!this._compFields.bcc) {
+      return this._messageFile;
+    }
+    let deliveryFile = Services.dirsvc.get("TmpD", Ci.nsIFile);
+    deliveryFile.append("nsemail.tmp");
+    deliveryFile.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+    let content = await IOUtils.read(this._messageFile.path);
+    let bodyIndex = content.findIndex(
+      (el, index) =>
+        // header and body are separated by \r\n\r\n
+        el == 13 &&
+        content[index + 1] == 10 &&
+        content[index + 2] == 13 &&
+        content[index + 3] == 10
+    );
+    let header = new TextDecoder("UTF-8").decode(content.slice(0, bodyIndex));
+    let lastLinePruned = false;
+    let headerToWrite = "";
+    for (let line of header.split("\r\n")) {
+      if (line.startsWith("Bcc") || (line.startsWith(" ") && lastLinePruned)) {
+        lastLinePruned = true;
+        continue;
+      }
+      lastLinePruned = false;
+      headerToWrite += `${line}\r\n`;
+    }
+    let encodedHeader = new TextEncoder().encode(headerToWrite);
+    // Prevent extra \r\n, which was already added to the last head line.
+    let body = content.slice(bodyIndex + 2);
+    let combinedContent = new Uint8Array(encodedHeader.length + body.length);
+    combinedContent.set(encodedHeader);
+    combinedContent.set(body, encodedHeader.length);
+    await IOUtils.write(deliveryFile.path, combinedContent);
+    return deliveryFile;
+  }
+
+  /**
+   * Create the file to be copied to the Sent folder, add X-Mozilla-Status and
+   * X-Mozilla-Status2 if needed.
+   *
+   * @returns {nsIFile}
+   */
+  async _createCopyFile() {
+    if (!this._folderUri.startsWith("mailbox:")) {
+      return this._messageFile;
+    }
+
+    // Add a `From - Date` line, so that nsLocalMailFolder.cpp won't add a
+    // dummy envelope. The date string will be parsed by PR_ParseTimeString.
+    // TODO: this should not be added to Maildir, see bug 1686852.
+    let contentToWrite = `From - ${new Date().toUTCString()}\r\n`;
+    let xMozillaStatus = lazy.MsgUtils.getXMozillaStatus(this._deliverMode);
+    let xMozillaStatus2 = lazy.MsgUtils.getXMozillaStatus2(this._deliverMode);
+    if (xMozillaStatus) {
+      contentToWrite += `X-Mozilla-Status: ${xMozillaStatus}\r\n`;
+    }
+    if (xMozillaStatus2) {
+      contentToWrite += `X-Mozilla-Status2: ${xMozillaStatus2}\r\n`;
+    }
+
+    // Create a separate copy file when there are extra headers.
+    let copyFile = Services.dirsvc.get("TmpD", Ci.nsIFile);
+    copyFile.append("nscopy.tmp");
+    copyFile.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+    await IOUtils.writeUTF8(copyFile.path, contentToWrite);
+    await IOUtils.write(
+      copyFile.path,
+      await IOUtils.read(this._messageFile.path),
+      {
+        mode: "append",
+      }
+    );
+    return copyFile;
+  }
+
+  /**
+   * Start copy operation according to this._fcc value.
+   */
+  async _doFcc() {
+    if (!this._fcc || !lazy.MsgUtils.canSaveToFolder(this._fcc)) {
+      this.notifyListenerOnStopCopy(Cr.NS_OK);
+      return;
+    }
+    this.sendReport.currentProcess = Ci.nsIMsgSendReport.process_Copy;
+    this._mimeDoFcc(this._fcc, false, Ci.nsIMsgSend.nsMsgDeliverNow);
+  }
+
+  /**
+   * Copy a message to a folder, or fallback to a folder depending on pref and
+   * deliverMode, usually Drafts/Sent.
+   *
+   * @param {string} [fccHeader=this._fcc] - The target folder uri to copy the
+   * message to.
+   * @param {boolean} [throwOnError=false] - By default notifyListenerOnStopCopy
+   * is called on error. When throwOnError is true, the caller can handle the
+   * error by itself.
+   * @param {nsMsgDeliverMode} [deliverMode=this._deliverMode] - The deliver mode.
+   */
+  async _mimeDoFcc(
+    fccHeader = this._fcc,
+    throwOnError = false,
+    deliverMode = this._deliverMode
+  ) {
+    let folder;
+    let folderUri;
+    if (fccHeader) {
+      folder = lazy.MailUtils.getExistingFolder(fccHeader);
+    }
+    if (
+      [Ci.nsIMsgSend.nsMsgDeliverNow, Ci.nsIMsgSend.nsMsgSendUnsent].includes(
+        deliverMode
+      ) &&
+      folder
+    ) {
+      this._folderUri = fccHeader;
+    } else if (fccHeader == null) {
+      // Set fcc_header to a special folder in Local Folders "account" since can't
+      // save to Sent mbox, typically because imap connection is down. This
+      // folder is created if it doesn't yet exist.
+      let rootFolder = MailServices.accounts.localFoldersServer.rootMsgFolder;
+      folderUri = rootFolder.URI + "/";
+
+      // Now append the special folder name folder to the local folder uri.
+      if (
+        [
+          Ci.nsIMsgSend.nsMsgDeliverNow,
+          Ci.nsIMsgSend.nsMsgSendUnsent,
+          Ci.nsIMsgSend.nsMsgSaveAsDraft,
+          Ci.nsIMsgSend.nsMsgSaveAsTemplate,
+        ].includes(this._deliverMode)
+      ) {
+        // Typically, this appends "Sent-", "Drafts-" or "Templates-" to folder
+        // and then has the account name appended, e.g., .../Sent-MyImapAccount.
+        let folder = lazy.MailUtils.getOrCreateFolder(this._folderUri);
+        folderUri += folder.name + "-";
+      }
+      if (this._fcc) {
+        // Get the account name where the "save to" failed.
+        let accountName = lazy.MailUtils.getOrCreateFolder(this._fcc).server
+          .prettyName;
+
+        // Now append the imap account name (escaped) to the folder uri.
+        folderUri += accountName;
+        this._folderUri = folderUri;
+      }
+    } else {
+      this._folderUri = lazy.MsgUtils.getMsgFolderURIFromPrefs(
+        this._userIdentity,
+        this._deliverMode
+      );
+      if (
+        (this._deliverMode == Ci.nsIMsgSend.nsMsgSaveAsDraft &&
+          this._compFields.draftId) ||
+        (this._deliverMode == Ci.nsIMsgSend.nsMsgSaveAsTemplate &&
+          this._compFields.templateId)
+      ) {
+        // Turn the draft/template ID into a folder URI string.
+        let messenger = Cc["@mozilla.org/messenger;1"].createInstance(
+          Ci.nsIMessenger
+        );
+        try {
+          // This can fail if the user renames/removed/moved the folder.
+          folderUri = messenger.msgHdrFromURI(
+            this._deliverMode == Ci.nsIMsgSend.nsMsgSaveAsDraft
+              ? this._compFields.draftId
+              : this._compFields.templateId
+          ).folder.URI;
+        } catch (ex) {
+          console.warn(ex);
+        }
+        // Only accept it if it's a subfolder of the identity's draft/template folder.
+        if (folderUri?.startsWith(this._folderUri)) {
+          this._folderUri = folderUri;
+        }
+      }
+    }
+    lazy.MsgUtils.sendLogger.debug(
+      `Processing fcc; folderUri=${this._folderUri}`
+    );
+
+    this._msgCopy = Cc[
+      "@mozilla.org/messengercompose/msgcopy;1"
+    ].createInstance(Ci.nsIMsgCopy);
+    this._copyFile = await this._createCopyFile();
+    lazy.MsgUtils.sendLogger.debug("fcc file created");
+
+    // Notify nsMsgCompose about the saved folder.
+    if (this._sendListener) {
+      this._sendListener.onGetDraftFolderURI(
+        this._compFields.messageId,
+        this._folderUri
+      );
+    }
+    folder = lazy.MailUtils.getOrCreateFolder(this._folderUri);
+    let statusMsg = this._composeBundle.formatStringFromName(
+      "copyMessageStart",
+      [folder?.name || "?"]
+    );
+    this._setStatusMessage(statusMsg);
+    lazy.MsgUtils.sendLogger.debug("startCopyOperation");
+    try {
+      this._msgCopy.startCopyOperation(
+        this._userIdentity,
+        this._copyFile,
+        this._deliverMode,
+        this,
+        this._folderUri,
+        this._msgToReplace
+      );
+    } catch (e) {
+      lazy.MsgUtils.sendLogger.warn(
+        `startCopyOperation failed with ${e.result}`
+      );
+      if (throwOnError) {
+        throw Components.Exception("startCopyOperation failed", e.result);
+      }
+      this.notifyListenerOnStopCopy(e.result);
+    }
+  }
+
+  /**
+   * Handle the fcc2 field. Then notify OnStopCopy and clean up.
+   */
+  _doFcc2() {
+    // Handle fcc2 only once.
+    if (!this._fcc2Handled && this._compFields.fcc2) {
+      lazy.MsgUtils.sendLogger.debug("Processing fcc2");
+      this._fcc2Handled = true;
+      this._mimeDoFcc(
+        this._compFields.fcc2,
+        false,
+        Ci.nsIMsgSend.nsMsgDeliverNow
+      );
+      return;
+    }
+
+    // NOTE: When nsMsgCompose receives OnStopCopy, it will release nsIMsgSend
+    // instance and close the compose window, which prevents the Promise from
+    // resolving in MsgComposeCommands.js. Use setTimeout to work around it.
+    lazy.setTimeout(() => {
+      try {
+        if (this._sendListener instanceof Ci.nsIMsgCopyServiceListener) {
+          this._sendListener.OnStopCopy(0);
+        }
+      } catch (e) {
+        // Ignore the return value of OnStopCopy. Non-zero nsresult will throw
+        // when going through XPConnect. In this case, we don't care about it.
+        console.warn(
+          `OnStopCopy failed with 0x${e.result.toString(16)}\n${e.stack}`
+        );
+      }
+      this._cleanup();
+    });
+  }
+
+  /**
+   * Run filters on the just sent message.
+   */
+  _filterSentMessage() {
+    this.sendReport.currentProcess = Ci.nsIMsgSendReport.process_Filter;
+    let folder = lazy.MailUtils.getExistingFolder(this._folderUri);
+    let msgHdr = folder.GetMessageHeader(this._messageKey);
+    let msgWindow = this._sendProgress?.msgWindow;
+    return MailServices.filters.applyFilters(
+      Ci.nsMsgFilterType.PostOutgoing,
+      [msgHdr],
+      folder,
+      msgWindow,
+      this
+    );
+  }
+
+  _cleanup() {
+    lazy.MsgUtils.sendLogger.debug("Clean up temporary files");
+    if (this._copyFile && this._copyFile != this._messageFile) {
+      IOUtils.remove(this._copyFile.path).catch(console.error);
+      this._copyFile = null;
+    }
+    if (this._deliveryFile && this._deliveryFile != this._messageFile) {
+      IOUtils.remove(this._deliveryFile.path).catch(console.error);
+      this._deliveryFile = null;
+    }
+    if (this._messageFile && this._shouldRemoveMessageFile) {
+      IOUtils.remove(this._messageFile.path).catch(console.error);
+      this._messageFile = null;
+    }
+  }
+
+  /**
+   * Send this._deliveryFile to smtp service.
+   */
+  async _deliverAsMail() {
+    this.sendReport.currentProcess = Ci.nsIMsgSendReport.process_SMTP;
+    this._setStatusMessage(
+      this._composeBundle.GetStringFromName("sendingMessage")
+    );
+    let recipients = [
+      this._compFields.to,
+      this._compFields.cc,
+      this._compFields.bcc,
+    ].filter(Boolean);
+    this._collectAddressesToAddressBook(recipients);
+    let converter = Cc["@mozilla.org/messenger/mimeconverter;1"].getService(
+      Ci.nsIMimeConverter
+    );
+    let encodedRecipients = encodeURIComponent(
+      converter.encodeMimePartIIStr_UTF8(
+        recipients.join(","),
+        true,
+        0,
+        Ci.nsIMimeConverter.MIME_ENCODED_WORD_SIZE
+      )
+    );
+    lazy.MsgUtils.sendLogger.debug(
+      `Delivering mail message <${this._compFields.messageId}>`
+    );
+    let deliveryListener = new MsgDeliveryListener(this, false);
+    let msgStatus =
+      this._sendProgress instanceof Ci.nsIMsgStatusFeedback
+        ? this._sendProgress
+        : this._statusFeedback;
+    this._smtpRequest = {};
+    // Do async call. This is necessary to ensure _smtpRequest is set so that
+    // cancel function can be obtained.
+    await MailServices.smtp.wrappedJSObject.sendMailMessage(
+      this._deliveryFile,
+      encodedRecipients,
+      this._userIdentity,
+      this._compFields.from,
+      this._smtpPassword,
+      deliveryListener,
+      msgStatus,
+      null,
+      this._compFields.DSN,
+      this._compFields.messageId,
+      {},
+      this._smtpRequest
+    );
+  }
+
+  /**
+   * Send this._deliveryFile to nntp service.
+   */
+  _deliverAsNews() {
+    this.sendReport.currentProcess = Ci.nsIMsgSendReport.process_NNTP;
+    lazy.MsgUtils.sendLogger.debug("Delivering news message");
+    let deliveryListener = new MsgDeliveryListener(this, true);
+    let msgWindow;
+    try {
+      msgWindow =
+        this._sendProgress?.msgWindow ||
+        MailServices.mailSession.topmostMsgWindow;
+    } catch (e) {}
+    MailServices.nntp.postMessage(
+      this._deliveryFile,
+      this._compFields.newsgroups,
+      this._accountKey,
+      deliveryListener,
+      msgWindow,
+      null
+    );
+  }
+
+  /**
+   * Collect outgoing addresses to address book.
+   *
+   * @param {string[]} recipients - Outgoing addresses including to/cc/bcc.
+   */
+  _collectAddressesToAddressBook(recipients) {
+    let createCard = Services.prefs.getBoolPref(
+      "mail.collect_email_address_outgoing",
+      false
+    );
+
+    let addressCollector = Cc[
+      "@mozilla.org/addressbook/services/addressCollector;1"
+    ].getService(Ci.nsIAbAddressCollector);
+    for (let recipient of recipients) {
+      addressCollector.collectAddress(recipient, createCard);
+    }
+  }
+
+  /**
+   * Check if link text is equivalent to the href.
+   *
+   * @param {string} text - The innerHTML of a <a> element.
+   * @param {string} href - The href of a <a> element.
+   * @returns {boolean} true if text is equivalent to href.
+   */
+  _isLinkFreeText(text, href) {
+    href = href.trim();
+    if (href.startsWith("mailto:")) {
+      return this._isLinkFreeText(text, href.slice("mailto:".length));
+    }
+    text = text.trim();
+    return (
+      text == href ||
+      (text.endsWith("/") && text.slice(0, -1) == href) ||
+      (href.endsWith("/") && href.slice(0, -1) == text)
+    );
+  }
+
+  /**
+   * Collect embedded objects as attachments.
+   *
+   * @returns {object} collected
+   * @returns {nsIMsgAttachment[]} collected.embeddedAttachments
+   * @returns {object[]} collected.embeddedObjects objects {element, url}
+   */
+  _gatherEmbeddedAttachments(editor) {
+    let embeddedAttachments = [];
+    let embeddedObjects = [];
+
+    if (!editor || !editor.document) {
+      return { embeddedAttachments, embeddedObjects };
+    }
+    let nodes = [];
+    nodes.push(...editor.document.querySelectorAll("img"));
+    nodes.push(...editor.document.querySelectorAll("a"));
+    let body = editor.document.querySelector("body[background]");
+    if (body) {
+      nodes.push(body);
+    }
+
+    let urlCidCache = {};
+    for (let element of nodes) {
+      if (element.tagName == "A" && element.href) {
+        if (this._isLinkFreeText(element.innerHTML, element.href)) {
+          // Set this special classname, which is recognized by nsIParserUtils,
+          // so that links are not duplicated in text/plain.
+          element.classList.add("moz-txt-link-freetext");
+        }
+      }
+      let isImage = false;
+      let url;
+      let name;
+      let mozDoNotSend = element.getAttribute("moz-do-not-send");
+      if (mozDoNotSend && mozDoNotSend != "false") {
+        // Only empty or moz-do-not-send="false" may be accepted later.
+        continue;
+      }
+      if (element.tagName == "BODY" && element.background) {
+        isImage = true;
+        url = element.background;
+      } else if (element.tagName == "IMG" && element.src) {
+        isImage = true;
+        url = element.src;
+        name = element.name;
+      } else if (element.tagName == "A" && element.href) {
+        url = element.href;
+        name = element.name;
+      } else {
+        continue;
+      }
+      let acceptObject = false;
+      // Before going further, check what scheme we're dealing with. Files need to
+      // be converted to data URLs during composition. "Attaching" means
+      // sending as a cid: part instead of original URL.
+      if (/^https?:\/\//i.test(url)) {
+        acceptObject =
+          (isImage &&
+            Services.prefs.getBoolPref(
+              "mail.compose.attach_http_images",
+              false
+            )) ||
+          mozDoNotSend == "false";
+      }
+      if (/^(data|news|snews|nntp):/i.test(url)) {
+        acceptObject = true;
+      }
+      if (!acceptObject) {
+        continue;
+      }
+
+      let cid;
+      if (urlCidCache[url]) {
+        // If an url has already been inserted as MimePart, just reuse the cid.
+        cid = urlCidCache[url];
+      } else {
+        cid = lazy.MsgUtils.makeContentId(
+          this._userIdentity,
+          embeddedAttachments.length + 1
+        );
+        urlCidCache[url] = cid;
+
+        let attachment = Cc[
+          "@mozilla.org/messengercompose/attachment;1"
+        ].createInstance(Ci.nsIMsgAttachment);
+        attachment.name = name || lazy.MsgUtils.pickFileNameFromUrl(url);
+        attachment.contentId = cid;
+        attachment.url = url;
+        embeddedAttachments.push(attachment);
+      }
+      embeddedObjects.push({
+        element,
+        url,
+      });
+
+      let newUrl = `cid:${cid}`;
+      if (element.tagName == "BODY") {
+        element.background = newUrl;
+      } else if (element.tagName == "IMG") {
+        element.src = newUrl;
+      } else if (element.tagName == "A") {
+        element.href = newUrl;
+      }
+    }
+    return { embeddedAttachments, embeddedObjects };
+  }
+
+  /**
+   * Restore embedded objects in editor to their original urls.
+   *
+   * @param {object[]} embeddedObjects - An array of embedded objects.
+   * @param {Element} embeddedObjects.element
+   * @param {string} embeddedObjects.url
+   */
+  _restoreEditorContent(embeddedObjects) {
+    for (let { element, url } of embeddedObjects) {
+      if (element.tagName == "BODY") {
+        element.background = url;
+      } else if (element.tagName == "IMG") {
+        element.src = url;
+      } else if (element.tagName == "A") {
+        element.href = url;
+      }
+    }
+  }
+
+  /**
+   * Get the message body from an editor.
+   *
+   * @param {nsIEditor} editor - The editor instance.
+   * @returns {string}
+   */
+  _getBodyFromEditor(editor) {
+    if (!editor) {
+      return "";
+    }
+
+    let flags =
+      Ci.nsIDocumentEncoder.OutputFormatted |
+      Ci.nsIDocumentEncoder.OutputNoFormattingInPre |
+      Ci.nsIDocumentEncoder.OutputDisallowLineBreaking;
+    // bodyText is UTF-16 string.
+    let bodyText = editor.outputToString("text/html", flags);
+
+    // No need to do conversion if forcing plain text.
+    if (!this._compFields.forcePlainText) {
+      let cs = Cc["@mozilla.org/txttohtmlconv;1"].getService(
+        Ci.mozITXTToHTMLConv
+      );
+      let csFlags = Ci.mozITXTToHTMLConv.kURLs;
+      if (Services.prefs.getBoolPref("mail.send_struct", false)) {
+        csFlags |= Ci.mozITXTToHTMLConv.kStructPhrase;
+      }
+      bodyText = cs.scanHTML(bodyText, csFlags);
+    }
+
+    return bodyText;
+  }
+
+  /**
+   * Get the first account key of an identity.
+   *
+   * @param {nsIMsgIdentity} identity - The identity.
+   * @returns {string}
+   */
+  _accountKeyForIdentity(identity) {
+    let servers = MailServices.accounts.getServersForIdentity(identity);
+    return servers.length
+      ? MailServices.accounts.FindAccountForServer(servers[0])?.key
+      : null;
+  }
+}
+
+/**
+ * A listener to be passed to the SMTP service.
+ *
+ * @implements {nsIUrlListener}
+ */
+class MsgDeliveryListener {
+  QueryInterface = ChromeUtils.generateQI(["nsIUrlListener"]);
+
+  /**
+   * @param {nsIMsgSend} msgSend - Send instance to use.
+   * @param {boolean} isNewsDelivery - Whether this is an nntp message delivery.
+   */
+  constructor(msgSend, isNewsDelivery) {
+    this._msgSend = msgSend;
+    this._isNewsDelivery = isNewsDelivery;
+  }
+
+  OnStartRunningUrl(url) {
+    this._msgSend.notifyListenerOnStartSending(null, 0);
+  }
+
+  OnStopRunningUrl(url, exitCode) {
+    lazy.MsgUtils.sendLogger.debug(`OnStopRunningUrl; exitCode=${exitCode}`);
+    let mailUrl = url.QueryInterface(Ci.nsIMsgMailNewsUrl);
+    mailUrl.UnRegisterListener(this);
+
+    this._msgSend.sendDeliveryCallback(url, this._isNewsDelivery, exitCode);
+  }
+}
diff --git a/comm/mailnews/compose/src/MimeEncoder.jsm b/comm/mailnews/compose/src/MimeEncoder.jsm
new file mode 100644
index 0000000000..ab4c60de42
--- /dev/null
+++ b/comm/mailnews/compose/src/MimeEncoder.jsm
@@ -0,0 +1,430 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["MimeEncoder"];
+
+const LINELENGTH_ENCODING_THRESHOLD = 990;
+const MESSAGE_RFC822 = "message/rfc822";
+
+/**
+ * A class to pick Content-Transfer-Encoding for a MimePart, and encode MimePart
+ * body accordingly.
+ */
+class MimeEncoder {
+  /**
+   * Create a MimeEncoder.
+   *
+   * @param {string} charset
+   * @param {string} contentType
+   * @param {boolean} forceMsgEncoding
+   * @param {boolean} isMainBody
+   * @param {string} content
+   */
+  constructor(charset, contentType, forceMsgEncoding, isMainBody, content) {
+    this._charset = charset;
+    this._contentType = contentType.toLowerCase();
+    this._forceMsgEncoding = forceMsgEncoding;
+    this._isMainBody = isMainBody;
+    this._body = content;
+    this._bodySize = content.length;
+
+    // The encoding value will be used to set Content-Transfer-Encoding header
+    // and encode this._body.
+    this._encoding = "";
+
+    // Flags used to pick encoding.
+    this._highBitCount = 0;
+    this._unPrintableCount = 0;
+    this._ctrlCount = 0;
+    this._nullCount = 0;
+    this._hasCr = 0;
+    this._hasLf = 0;
+    this._hasCrLf = 0;
+    this._maxColumn = 0;
+  }
+
+  /**
+   * @type {string}
+   */
+  get encoding() {
+    return this._encoding;
+  }
+
+  /**
+   * Use the combination of charset, content type and scanning this._body to
+   * decide what encoding it should have.
+   */
+  pickEncoding() {
+    this._analyzeBody();
+
+    let strictlyMime = Services.prefs.getBoolPref("mail.strictly_mime");
+    let needsB64 = false;
+    let isUsingQP = false;
+
+    // Allow users to override our percentage-wise guess on whether
+    // the file is text or binary.
+    let forceB64 = Services.prefs.getBoolPref("mail.file_attach_binary");
+
+    // If the content-type is "image/" or something else known to be binary or
+    // several flavors of newlines are present, use base64 unless we're attaching
+    // a message (so that we don't get confused by newline conversions).
+    if (
+      !this._isMainBody &&
+      (forceB64 ||
+        this._requiresB64() ||
+        this._hasCr + this._hasLf + this._hasCrLf != 1) &&
+      this._contentType != MESSAGE_RFC822
+    ) {
+      needsB64 = true;
+    } else {
+      // Otherwise, we need to pick an encoding based on the contents of the
+      // document.
+      let encodeP = false;
+
+      // Force quoted-printable if the sender does not allow conversion to 7bit.
+      if (
+        this._forceMsgEncoding ||
+        this._maxColumn > LINELENGTH_ENCODING_THRESHOLD ||
+        (strictlyMime && this._unPrintableCount) ||
+        this._nullCount
+      ) {
+        if (
+          this._isMainBody &&
+          this._contentType == "text/plain" &&
+          // From rfc3676#section-4.2, Quoted-Printable encoding SHOULD NOT be
+          // used with Format=Flowed unless absolutely necessary.
+          Services.prefs.getBoolPref("mailnews.send_plaintext_flowed")
+        ) {
+          needsB64 = true;
+        } else {
+          encodeP = true;
+        }
+      }
+
+      // MIME requires a special case that these types never be encoded.
+      if (
+        this._contentType.startsWith("message") ||
+        this._contentType.startsWith("multipart")
+      ) {
+        encodeP = false;
+      }
+
+      let manager = Cc["@mozilla.org/charset-converter-manager;1"].getService(
+        Ci.nsICharsetConverterManager
+      );
+      let isCharsetMultiByte = false;
+      try {
+        isCharsetMultiByte =
+          manager.getCharsetData(this._charset, ".isMultibyte") == "true";
+      } catch {}
+
+      // If the Mail charset is multibyte, we force it to use Base64 for
+      // attachments.
+      if (
+        !this._isMainBody &&
+        this._charset &&
+        isCharsetMultiByte &&
+        (this._contentType.startsWith("text") ||
+          // text/vcard synonym
+          this._contentType == "application/directory")
+      ) {
+        needsB64 = true;
+      } else if (this._charset == "ISO-2022-JP") {
+        this._encoding = "7bit";
+      } else if (encodeP && this._unPrintableCount > this._bodySize / 10) {
+        // If the document contains more than 10% unprintable characters,
+        // then that seems like a good candidate for base64 instead of
+        // quoted-printable.
+        needsB64 = true;
+      } else if (encodeP) {
+        this._encoding = "quoted-printable";
+        isUsingQP = true;
+      } else if (this._highBitCount > 0) {
+        this._encoding = "8bit";
+      } else {
+        this._encoding = "7bit";
+      }
+    }
+
+    // Always base64 binary data.
+    if (needsB64) {
+      this._encoding = "base64";
+    }
+
+    // According to RFC 821 we must always have lines shorter than 998 bytes.
+    // To encode "long lines" use a CTE that will transmit shorter lines.
+    // Switch to base64 if we are not already using "quoted printable".
+
+    // We don't do this for message/rfc822 attachments, since we can't
+    // change the original Content-Transfer-Encoding of the message we're
+    // attaching. We rely on the original message complying with RFC 821,
+    // if it doesn't we won't either. Not ideal.
+    if (
+      this._contentType != MESSAGE_RFC822 &&
+      this._maxColumn > LINELENGTH_ENCODING_THRESHOLD &&
+      !isUsingQP
+    ) {
+      this._encoding = "base64";
+    }
+  }
+
+  /**
+   * Encode this._body according to the value of this.encoding.
+   */
+  encode() {
+    let output;
+    if (this.encoding == "base64") {
+      output = this._encodeBase64();
+    } else if (this.encoding == "quoted-printable") {
+      output = this._encodeQP();
+    } else {
+      output = this._body.replaceAll("\r\n", "\n").replaceAll("\n", "\r\n");
+    }
+    if (!output.endsWith("\r\n")) {
+      output += "\r\n";
+    }
+    return output;
+  }
+
+  /**
+   * Scan this._body to set flags that will be used by pickEncoding.
+   */
+  _analyzeBody() {
+    let currentColumn = 0;
+    let prevCharWasCr = false;
+
+    for (let i = 0; i < this._bodySize; i++) {
+      let ch = this._body.charAt(i);
+      let charCode = this._body.charCodeAt(i);
+      if (charCode > 126) {
+        this._highBitCount++;
+        this._unPrintableCount++;
+      } else if (ch < " " && !"\t\r\n".includes(ch)) {
+        this._unPrintableCount++;
+        this._ctrlCount++;
+        if (ch == "\0") {
+          this._nullCount++;
+        }
+      }
+
+      if ("\r\n".includes(ch)) {
+        if (ch == "\r") {
+          if (prevCharWasCr) {
+            this._hasCr = 1;
+          } else {
+            prevCharWasCr = true;
+          }
+        } else if (prevCharWasCr) {
+          if (currentColumn == 0) {
+            this._hasCrLf = 1;
+          } else {
+            this._hasCr = 1;
+            this._hasLf = 1;
+          }
+          prevCharWasCr = false;
+        } else {
+          this._hasLf = 1;
+        }
+
+        if (this._maxColumn < currentColumn) {
+          this._maxColumn = currentColumn;
+        }
+        currentColumn = 0;
+      } else {
+        currentColumn++;
+      }
+    }
+
+    if (this._maxColumn < currentColumn) {
+      this._maxColumn = currentColumn;
+    }
+  }
+
+  /**
+   * Determine if base64 is required according to contentType.
+   */
+  _requiresB64() {
+    if (this._contentType == "application/x-unknown-content-type") {
+      // Unknown types don't necessarily require encoding.  (Note that
+      // "unknown" and "application/octet-stream" aren't the same.)
+      return false;
+    }
+    if (
+      this._contentType.startsWith("image/") ||
+      this._contentType.startsWith("audio/") ||
+      this._contentType.startsWith("video/") ||
+      this._contentType.startsWith("application/")
+    ) {
+      // The following types are application/ or image/ types that are actually
+      // known to contain textual data (meaning line-based, not binary, where
+      // CRLF conversion is desired rather than disastrous.)  So, if the type
+      // is any of these, it does not *require* base64, and if we do need to
+      // encode it for other reasons, we'll probably use quoted-printable.
+      // But, if it's not one of these types, then we assume that any subtypes
+      // of the non-"text/" types are binary data, where CRLF conversion would
+      // corrupt it, so we use base64 right off the bat.
+      // The reason it's desirable to ship these as text instead of just using
+      // base64 all the time is mainly to preserve the readability of them for
+      // non-MIME users: if I mail a /bin/sh script to someone, it might not
+      // need to be encoded at all, so we should leave it readable if we can.
+      // This list of types was derived from the comp.mail.mime FAQ, section
+      // 10.2.2, "List of known unregistered MIME types" on 2-Feb-96.
+      const typesWhichAreReallyText = [
+        "application/mac-binhex40", // APPLICATION_BINHEX
+        "application/pgp", // APPLICATION_PGP
+        "application/pgp-keys",
+        "application/x-pgp-message", // APPLICATION_PGP2
+        "application/postscript", // APPLICATION_POSTSCRIPT
+        "application/x-uuencode", // APPLICATION_UUENCODE
+        "application/x-uue", // APPLICATION_UUENCODE2
+        "application/uue", // APPLICATION_UUENCODE4
+        "application/uuencode", // APPLICATION_UUENCODE3
+        "application/sgml",
+        "application/x-csh",
+        "application/javascript",
+        "application/ecmascript",
+        "application/x-javascript",
+        "application/x-latex",
+        "application/x-macbinhex40",
+        "application/x-ns-proxy-autoconfig",
+        "application/x-www-form-urlencoded",
+        "application/x-perl",
+        "application/x-sh",
+        "application/x-shar",
+        "application/x-tcl",
+        "application/x-tex",
+        "application/x-texinfo",
+        "application/x-troff",
+        "application/x-troff-man",
+        "application/x-troff-me",
+        "application/x-troff-ms",
+        "application/x-troff-ms",
+        "application/x-wais-source",
+        "image/x-bitmap",
+        "image/x-pbm",
+        "image/x-pgm",
+        "image/x-portable-anymap",
+        "image/x-portable-bitmap",
+        "image/x-portable-graymap",
+        "image/x-portable-pixmap", // IMAGE_PPM
+        "image/x-ppm",
+        "image/x-xbitmap", // IMAGE_XBM
+        "image/x-xbm", // IMAGE_XBM2
+        "image/xbm", // IMAGE_XBM3
+        "image/x-xpixmap",
+        "image/x-xpm",
+      ];
+      if (typesWhichAreReallyText.includes(this._contentType)) {
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Base64 encoding. See RFC 2045 6.8. We use the built-in `btoa`, then ensure
+   * line width is no more than 72.
+   */
+  _encodeBase64() {
+    let encoded = btoa(this._body);
+    let ret = "";
+    let length = encoded.length;
+    let i = 0;
+    let limit = 72;
+    while (true) {
+      if (i * limit > length) {
+        break;
+      }
+      ret += encoded.substr(i * limit, limit) + "\r\n";
+      i++;
+    }
+    return ret;
+  }
+
+  /**
+   * Quoted-printable encoding. See RFC 2045 6.7.
+   */
+  _encodeQP() {
+    let currentColumn = 0;
+    let hexdigits = "0123456789ABCDEF";
+    let white = false;
+    let out = "";
+
+    function encodeChar(ch) {
+      let charCode = ch.charCodeAt(0);
+      let ret = "=";
+      ret += hexdigits[charCode >> 4];
+      ret += hexdigits[charCode & 0xf];
+      return ret;
+    }
+
+    for (let i = 0; i < this._bodySize; i++) {
+      let ch = this._body.charAt(i);
+      let charCode = this._body.charCodeAt(i);
+      if (ch == "\r" || ch == "\n") {
+        // If it's CRLF, swallow two chars instead of one.
+        if (i + 1 < this._bodySize && ch == "\r" && this._body[i + 1] == "\n") {
+          i++;
+        }
+
+        // Whitespace cannot be allowed to occur at the end of the line, so we
+        // back up and replace the whitespace with its code.
+        if (white) {
+          let whiteChar = out.slice(-1);
+          out = out.slice(0, -1);
+          out += encodeChar(whiteChar);
+        }
+
+        // Now write out the newline.
+        out += "\r";
+        out += "\n";
+        white = false;
+        currentColumn = 0;
+      } else if (
+        currentColumn == 0 &&
+        (ch == "." ||
+          (ch == "F" &&
+            (i >= this._bodySize - 1 || this._body[i + 1] == "r") &&
+            (i >= this._bodySize - 2 || this._body[i + 2] == "o") &&
+            (i >= this._bodySize - 3 || this._body[i + 3] == "m") &&
+            (i >= this._bodySize - 4 || this._body[i + 4] == " ")))
+      ) {
+        // Just to be SMTP-safe, if "." appears in column 0, encode it.
+        // If this line begins with "From " (or it could but we don't have enough
+        // data in the buffer to be certain), encode the 'F' in hex to avoid
+        // potential problems with BSD mailbox formats.
+        white = false;
+        out += encodeChar(ch);
+        currentColumn += 3;
+      } else if (
+        (charCode >= 33 && charCode <= 60) ||
+        (charCode >= 62 && charCode <= 126)
+      ) {
+        // Printable characters except for '='
+        white = false;
+        out += ch;
+        currentColumn++;
+      } else if (ch == " " || ch == "\t") {
+        // Whitespace
+        white = true;
+        out += ch;
+        currentColumn++;
+      } else {
+        white = false;
+        out += encodeChar(ch);
+        currentColumn += 3;
+      }
+
+      if (currentColumn >= 73) {
+        // Soft line break for readability
+        out += "=\r\n";
+        white = false;
+        currentColumn = 0;
+      }
+    }
+
+    return out;
+  }
+}
diff --git a/comm/mailnews/compose/src/MimeMessage.jsm b/comm/mailnews/compose/src/MimeMessage.jsm
new file mode 100644
index 0000000000..9423e84004
--- /dev/null
+++ b/comm/mailnews/compose/src/MimeMessage.jsm
@@ -0,0 +1,625 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["MimeMessage"];
+
+const { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+let { MimeMultiPart, MimePart } = ChromeUtils.import(
+  "resource:///modules/MimePart.jsm"
+);
+let { MsgUtils } = ChromeUtils.import(
+  "resource:///modules/MimeMessageUtils.jsm"
+);
+let { jsmime } = ChromeUtils.import("resource:///modules/jsmime.jsm");
+
+/**
+ * A class to create a top MimePart and write to a tmp file. It works like this:
+ * 1. collect top level MIME headers (_gatherMimeHeaders)
+ * 2. collect HTML/plain main body as MimePart[] (_gatherMainParts)
+ * 3. collect attachments as MimePart[] (_gatherAttachmentParts)
+ * 4. construct a top MimePart with above headers and MimePart[] (_initMimePart)
+ * 5. write the top MimePart to a tmp file (createMessageFile)
+ * NOTE: It's possible we will want to replace nsIMsgSend with the interfaces of
+ * MimeMessage. As a part of it, we will add a `send` method to this class.
+ */
+class MimeMessage {
+  /**
+   * Construct a MimeMessage.
+   *
+   * @param {nsIMsgIdentity} userIdentity
+   * @param {nsIMsgCompFields} compFields
+   * @param {string} fcc - The FCC header value.
+   * @param {string} bodyType
+   * @param {BinaryString} bodyText - This is ensured to be a 8-bit string, to
+   *   be handled the same as attachment content.
+   * @param {nsMsgDeliverMode} deliverMode
+   * @param {string} originalMsgURI
+   * @param {MSG_ComposeType} compType
+   * @param {nsIMsgAttachment[]} embeddedAttachments - Usually Embedded images.
+   * @param {nsIMsgSendReport} sendReport - Used by _startCryptoEncapsulation.
+   */
+  constructor(
+    userIdentity,
+    compFields,
+    fcc,
+    bodyType,
+    bodyText,
+    deliverMode,
+    originalMsgURI,
+    compType,
+    embeddedAttachments,
+    sendReport
+  ) {
+    this._userIdentity = userIdentity;
+    this._compFields = compFields;
+    this._fcc = fcc;
+    this._bodyType = bodyType;
+    this._bodyText = bodyText;
+    this._deliverMode = deliverMode;
+    this._compType = compType;
+    this._embeddedAttachments = embeddedAttachments;
+    this._sendReport = sendReport;
+  }
+
+  /**
+   * Write a MimeMessage to a tmp file.
+   *
+   * @returns {nsIFile}
+   */
+  async createMessageFile() {
+    let topPart = this._initMimePart();
+    let file = Services.dirsvc.get("TmpD", Ci.nsIFile);
+    file.append("nsemail.eml");
+    file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+
+    let fstream = Cc[
+      "@mozilla.org/network/file-output-stream;1"
+    ].createInstance(Ci.nsIFileOutputStream);
+    this._fstream = Cc[
+      "@mozilla.org/network/buffered-output-stream;1"
+    ].createInstance(Ci.nsIBufferedOutputStream);
+    fstream.init(file, -1, -1, 0);
+    this._fstream.init(fstream, 16 * 1024);
+
+    this._composeSecure = this._getComposeSecure();
+    if (this._composeSecure) {
+      await this._writePart(topPart);
+      this._composeSecure.finishCryptoEncapsulation(false, this._sendReport);
+    } else {
+      await this._writePart(topPart);
+    }
+
+    this._fstream.close();
+    fstream.close();
+
+    return file;
+  }
+
+  /**
+   * Create a top MimePart to represent the full message.
+   *
+   * @returns {MimePart}
+   */
+  _initMimePart() {
+    let { plainPart, htmlPart } = this._gatherMainParts();
+    let embeddedParts = this._gatherEmbeddedParts();
+    let attachmentParts = this._gatherAttachmentParts();
+
+    let relatedPart = htmlPart;
+    if (htmlPart && embeddedParts.length > 0) {
+      relatedPart = new MimeMultiPart("related");
+      relatedPart.addPart(htmlPart);
+      relatedPart.addParts(embeddedParts);
+    }
+    let mainParts = [plainPart, relatedPart].filter(Boolean);
+    let topPart;
+    if (attachmentParts.length > 0) {
+      // Use multipart/mixed as long as there is at least one attachment.
+      topPart = new MimeMultiPart("mixed");
+      if (plainPart && relatedPart) {
+        // Wrap mainParts inside a multipart/alternative MimePart.
+        let alternativePart = new MimeMultiPart("alternative");
+        alternativePart.addParts(mainParts);
+        topPart.addPart(alternativePart);
+      } else {
+        topPart.addParts(mainParts);
+      }
+      topPart.addParts(attachmentParts);
+    } else {
+      if (mainParts.length > 1) {
+        // Mark the topPart as multipart/alternative.
+        topPart = new MimeMultiPart("alternative");
+      } else {
+        topPart = new MimePart();
+      }
+      topPart.addParts(mainParts);
+    }
+
+    topPart.setHeaders(this._gatherMimeHeaders());
+
+    return topPart;
+  }
+
+  /**
+   * Collect top level headers like From/To/Subject into a Map.
+   */
+  _gatherMimeHeaders() {
+    let messageId = this._compFields.messageId;
+    if (
+      !messageId &&
+      (this._compFields.to ||
+        this._compFields.cc ||
+        this._compFields.bcc ||
+        !this._compFields.newsgroups ||
+        this._userIdentity.getBoolAttribute("generate_news_message_id"))
+    ) {
+      // Try to use the domain name of the From header to generate the message ID. We
+      // specifically don't use the nsIMsgIdentity associated with the account, because
+      // the user might have changed the address in the From header to use a different
+      // domain, and we don't want to leak the relationship between the domains.
+      const fromHdr = MailServices.headerParser.parseEncodedHeaderW(
+        this._compFields.from
+      );
+      const fromAddr = fromHdr[0].email;
+
+      // Extract the host from the address, if any, and generate a message ID from it.
+      // If we can't get a host for the message ID, let SMTP populate the header.
+      const atIndex = fromAddr.indexOf("@");
+      if (atIndex >= 0) {
+        messageId = Cc["@mozilla.org/messengercompose/computils;1"]
+          .createInstance(Ci.nsIMsgCompUtils)
+          .msgGenerateMessageId(
+            this._userIdentity,
+            fromAddr.slice(atIndex + 1)
+          );
+      }
+
+      this._compFields.messageId = messageId;
+    }
+    let headers = new Map([
+      ["message-id", messageId],
+      ["date", new Date()],
+      ["mime-version", "1.0"],
+    ]);
+
+    if (Services.prefs.getBoolPref("mailnews.headers.sendUserAgent")) {
+      if (Services.prefs.getBoolPref("mailnews.headers.useMinimalUserAgent")) {
+        headers.set(
+          "user-agent",
+          Services.strings
+            .createBundle("chrome://branding/locale/brand.properties")
+            .GetStringFromName("brandFullName")
+        );
+      } else {
+        headers.set(
+          "user-agent",
+          Cc["@mozilla.org/network/protocol;1?name=http"].getService(
+            Ci.nsIHttpProtocolHandler
+          ).userAgent
+        );
+      }
+    }
+
+    for (let headerName of [...this._compFields.headerNames]) {
+      let headerContent = this._compFields.getRawHeader(headerName);
+      if (headerContent) {
+        headers.set(headerName, headerContent);
+      }
+    }
+    let isDraft = [
+      Ci.nsIMsgSend.nsMsgQueueForLater,
+      Ci.nsIMsgSend.nsMsgDeliverBackground,
+      Ci.nsIMsgSend.nsMsgSaveAsDraft,
+      Ci.nsIMsgSend.nsMsgSaveAsTemplate,
+    ].includes(this._deliverMode);
+
+    let undisclosedRecipients = MsgUtils.getUndisclosedRecipients(
+      this._compFields,
+      this._deliverMode
+    );
+    if (undisclosedRecipients) {
+      headers.set("to", undisclosedRecipients);
+    }
+
+    if (isDraft) {
+      headers
+        .set(
+          "x-mozilla-draft-info",
+          MsgUtils.getXMozillaDraftInfo(this._compFields)
+        )
+        .set("x-identity-key", this._userIdentity.key)
+        .set("fcc", this._fcc);
+    }
+
+    if (messageId) {
+      // MDN request header requires to have MessageID header presented in the
+      // message in order to coorelate the MDN reports to the original message.
+      headers
+        .set(
+          "disposition-notification-to",
+          MsgUtils.getDispositionNotificationTo(
+            this._compFields,
+            this._deliverMode
+          )
+        )
+        .set(
+          "return-receipt-to",
+          MsgUtils.getReturnReceiptTo(this._compFields, this._deliverMode)
+        );
+    }
+
+    for (let { headerName, headerValue } of MsgUtils.getDefaultCustomHeaders(
+      this._userIdentity
+    )) {
+      headers.set(headerName, headerValue);
+    }
+
+    let rawMftHeader = headers.get("mail-followup-to");
+    // If there's already a Mail-Followup-To header, don't need to do anything.
+    if (!rawMftHeader) {
+      headers.set(
+        "mail-followup-to",
+        MsgUtils.getMailFollowupToHeader(this._compFields, this._userIdentity)
+      );
+    }
+
+    let rawMrtHeader = headers.get("mail-reply-to");
+    // If there's already a Mail-Reply-To header, don't need to do anything.
+    if (!rawMrtHeader) {
+      headers.set(
+        "mail-reply-to",
+        MsgUtils.getMailReplyToHeader(
+          this._compFields,
+          this._userIdentity,
+          rawMrtHeader
+        )
+      );
+    }
+
+    let rawPriority = headers.get("x-priority");
+    if (rawPriority) {
+      headers.set("x-priority", MsgUtils.getXPriority(rawPriority));
+    }
+
+    let rawReferences = headers.get("references");
+    if (rawReferences) {
+      let references = MsgUtils.getReferences(rawReferences);
+      // Don't reset "references" header if references is undefined.
+      if (references) {
+        headers.set("references", references);
+      }
+      headers.set("in-reply-to", MsgUtils.getInReplyTo(rawReferences));
+    }
+    if (
+      rawReferences &&
+      [
+        Ci.nsIMsgCompType.ForwardInline,
+        Ci.nsIMsgCompType.ForwardAsAttachment,
+      ].includes(this._compType)
+    ) {
+      headers.set("x-forwarded-message-id", rawReferences);
+    }
+
+    let rawNewsgroups = headers.get("newsgroups");
+    if (rawNewsgroups) {
+      let { newsgroups, newshost } = MsgUtils.getNewsgroups(
+        this._deliverMode,
+        rawNewsgroups
+      );
+      // Don't reset "newsgroups" header if newsgroups is undefined.
+      if (newsgroups) {
+        headers.set("newsgroups", newsgroups);
+      }
+      headers.set("x-mozilla-news-host", newshost);
+    }
+
+    return headers;
+  }
+
+  /**
+   * Determine if the message should include an HTML part, a plain part or both.
+   *
+   * @returns {{plainPart: MimePart, htmlPart: MimePart}}
+   */
+  _gatherMainParts() {
+    let formatFlowed = Services.prefs.getBoolPref(
+      "mailnews.send_plaintext_flowed"
+    );
+    let formatParam = "";
+    if (formatFlowed) {
+      // Set format=flowed as in RFC 2646 according to the preference.
+      formatParam += "; format=flowed";
+    }
+
+    let htmlPart = null;
+    let plainPart = null;
+    let parts = {};
+
+    if (this._bodyType === "text/html") {
+      htmlPart = new MimePart(
+        this._bodyType,
+        this._compFields.forceMsgEncoding,
+        true
+      );
+      htmlPart.setHeader("content-type", "text/html; charset=UTF-8");
+      htmlPart.bodyText = this._bodyText;
+    } else if (this._bodyType === "text/plain") {
+      plainPart = new MimePart(
+        this._bodyType,
+        this._compFields.forceMsgEncoding,
+        true
+      );
+      plainPart.setHeader(
+        "content-type",
+        `text/plain; charset=UTF-8${formatParam}`
+      );
+      plainPart.bodyText = this._bodyText;
+      parts.plainPart = plainPart;
+    }
+
+    // Assemble a multipart/alternative message.
+    if (
+      (this._compFields.forcePlainText ||
+        this._compFields.useMultipartAlternative) &&
+      plainPart === null &&
+      htmlPart !== null
+    ) {
+      plainPart = new MimePart(
+        "text/plain",
+        this._compFields.forceMsgEncoding,
+        true
+      );
+      plainPart.setHeader(
+        "content-type",
+        `text/plain; charset=UTF-8${formatParam}`
+      );
+      // nsIParserUtils.convertToPlainText expects unicode string.
+      let plainUnicode = MsgUtils.convertToPlainText(
+        new TextDecoder().decode(
+          jsmime.mimeutils.stringToTypedArray(this._bodyText)
+        ),
+        formatFlowed
+      );
+      // MimePart.bodyText should be binary string.
+      plainPart.bodyText = jsmime.mimeutils.typedArrayToString(
+        new TextEncoder().encode(plainUnicode)
+      );
+
+      parts.plainPart = plainPart;
+    }
+
+    // If useMultipartAlternative is true, send multipart/alternative message.
+    // Otherwise, send the plainPart only.
+    if (htmlPart) {
+      if (
+        (plainPart && this._compFields.useMultipartAlternative) ||
+        !plainPart
+      ) {
+        parts.htmlPart = htmlPart;
+      }
+    }
+
+    return parts;
+  }
+
+  /**
+   * Collect local attachments.
+   *
+   * @returns {MimePart[]}
+   */
+  _gatherAttachmentParts() {
+    let attachments = [...this._compFields.attachments];
+    let cloudParts = [];
+    let localParts = [];
+
+    for (let attachment of attachments) {
+      let part;
+      if (attachment.htmlAnnotation) {
+        part = new MimePart();
+        // MimePart.bodyText should be binary string.
+        part.bodyText = jsmime.mimeutils.typedArrayToString(
+          new TextEncoder().encode(attachment.htmlAnnotation)
+        );
+        part.setHeader("content-type", "text/html; charset=utf-8");
+
+        let suffix = /\.html$/i.test(attachment.name) ? "" : ".html";
+        let encodedFilename = MsgUtils.rfc2231ParamFolding(
+          "filename",
+          `${attachment.name}${suffix}`
+        );
+        part.setHeader("content-disposition", `attachment; ${encodedFilename}`);
+      } else {
+        part = new MimePart(null, this._compFields.forceMsgEncoding, false);
+        part.setBodyAttachment(attachment);
+      }
+
+      let cloudPartHeader = MsgUtils.getXMozillaCloudPart(
+        this._deliverMode,
+        attachment
+      );
+      if (cloudPartHeader) {
+        part.setHeader("x-mozilla-cloud-part", cloudPartHeader);
+      }
+
+      localParts.push(part);
+    }
+    // Cloud attachments are handled before local attachments in the C++
+    // implementation. We follow it here so that no need to change tests.
+    return cloudParts.concat(localParts);
+  }
+
+  /**
+   * Collect embedded objects as attachments.
+   *
+   * @returns {MimePart[]}
+   */
+  _gatherEmbeddedParts() {
+    return this._embeddedAttachments.map(attachment => {
+      let part = new MimePart(null, this._compFields.forceMsgEncoding, false);
+      part.setBodyAttachment(attachment, "inline", attachment.contentId);
+      return part;
+    });
+  }
+
+  /**
+   * If crypto encapsulation is required, returns an nsIMsgComposeSecure instance.
+   *
+   * @returns {nsIMsgComposeSecure}
+   */
+  _getComposeSecure() {
+    let secureCompose = this._compFields.composeSecure;
+    if (!secureCompose) {
+      return null;
+    }
+
+    if (
+      this._deliverMode == Ci.nsIMsgSend.nsMsgSaveAsDraft &&
+      !this._userIdentity.getBoolAttribute("autoEncryptDrafts")
+    ) {
+      return null;
+    }
+
+    if (
+      !secureCompose.requiresCryptoEncapsulation(
+        this._userIdentity,
+        this._compFields
+      )
+    ) {
+      return null;
+    }
+    return secureCompose;
+  }
+
+  /**
+   * Pass a stream and other params to this._composeSecure to start crypto
+   * encapsulation.
+   */
+  _startCryptoEncapsulation() {
+    let recipients = [
+      this._compFields.to,
+      this._compFields.cc,
+      this._compFields.bcc,
+      this._compFields.newsgroups,
+    ]
+      .filter(Boolean)
+      .join(",");
+
+    this._composeSecure.beginCryptoEncapsulation(
+      this._fstream,
+      recipients,
+      this._compFields,
+      this._userIdentity,
+      this._sendReport,
+      this._deliverMode == Ci.nsIMsgSend.nsMsgSaveAsDraft
+    );
+    this._cryptoEncapsulationStarted = true;
+  }
+
+  /**
+   * Recursively write an MimePart and its parts to a this._fstream.
+   *
+   * @param {MimePart} curPart - The MimePart to write out.
+   * @param {number} [depth=0] - Nested level of a part.
+   */
+  async _writePart(curPart, depth = 0) {
+    let bodyString;
+    try {
+      // `getEncodedBodyString()` returns a binary string.
+      bodyString = await curPart.getEncodedBodyString();
+    } catch (e) {
+      if (e.data && /^data:/i.test(e.data.url)) {
+        // Invalid data uri should not prevent sending message.
+        return;
+      }
+      throw e;
+    }
+
+    if (depth == 0 && this._composeSecure) {
+      // Crypto encapsulation will add a new content-type header.
+      curPart.deleteHeader("content-type");
+      if (curPart.parts.length > 1) {
+        // Move child parts one layer deeper so that the message is still well
+        // formed after crypto encapsulation.
+        let newChild = new MimeMultiPart(curPart.subtype);
+        newChild.parts = curPart._parts;
+        curPart.parts = [newChild];
+      }
+    }
+
+    // Write out headers, there could be non-ASCII in the headers
+    // which we need to encode into UTF-8.
+    this._writeString(curPart.getHeaderString());
+
+    // Start crypto encapsulation if needed.
+    if (depth == 0 && this._composeSecure) {
+      this._startCryptoEncapsulation();
+    }
+
+    // Recursively write out parts.
+    if (curPart.parts.length) {
+      // single part message
+      if (curPart.parts.length === 1) {
+        await this._writePart(curPart.parts[0], depth + 1);
+        this._writeBinaryString(bodyString);
+        return;
+      }
+
+      // We can safely use `_writeBinaryString()` for ASCII strings.
+      this._writeBinaryString("\r\n");
+      if (depth == 0) {
+        // Current part is a top part and multipart container.
+        this._writeBinaryString(
+          "This is a multi-part message in MIME format.\r\n"
+        );
+      }
+
+      // multipart message
+      for (let part of curPart.parts) {
+        this._writeBinaryString(`--${curPart.separator}\r\n`);
+        await this._writePart(part, depth + 1);
+      }
+      this._writeBinaryString(`\r\n--${curPart.separator}--\r\n`);
+      if (depth > 1) {
+        // If more separators follow, make sure there is a blank line after
+        // this one.
+        this._writeBinaryString("\r\n");
+      }
+    } else {
+      this._writeBinaryString(`\r\n`);
+    }
+
+    // Ensure there is exactly one blank line after a part and before
+    // the boundary, and exactly one blank line between boundary lines.
+    // This works around bugs in other software that erroneously remove
+    // additional blank lines, thereby causing verification failures of
+    // OpenPGP or S/MIME signatures. For example see bug 1731529.
+
+    // Write out body.
+    this._writeBinaryString(bodyString);
+  }
+
+  /**
+   * Write a binary string to this._fstream.
+   *
+   * @param {BinaryString} str - The binary string to write.
+   */
+  _writeBinaryString(str) {
+    this._cryptoEncapsulationStarted
+      ? this._composeSecure.mimeCryptoWriteBlock(str, str.length)
+      : this._fstream.write(str, str.length);
+  }
+
+  /**
+   * Write a string to this._fstream.
+   *
+   * @param {string} str - The string to write.
+   */
+  _writeString(str) {
+    this._writeBinaryString(
+      jsmime.mimeutils.typedArrayToString(new TextEncoder().encode(str))
+    );
+  }
+}
diff --git a/comm/mailnews/compose/src/MimeMessageUtils.jsm b/comm/mailnews/compose/src/MimeMessageUtils.jsm
new file mode 100644
index 0000000000..65682b6d4c
--- /dev/null
+++ b/comm/mailnews/compose/src/MimeMessageUtils.jsm
@@ -0,0 +1,1058 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["MsgUtils"];
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+var { MailUtils } = ChromeUtils.import("resource:///modules/MailUtils.jsm");
+var { jsmime } = ChromeUtils.import("resource:///modules/jsmime.jsm");
+
+// Defined in ErrorList.h.
+const NS_ERROR_MODULE_BASE_OFFSET = 69;
+const NS_ERROR_MODULE_MAILNEWS = 16;
+
+/**
+ * Generate an NS_ERROR code from a MAILNEWS error code. See NS_ERROR_GENERATE
+ * in nsError.h and NS_MSG_GENERATE_FAILURE in nsComposeStrings.h.
+ *
+ * @param {number} code - The error code in MAILNEWS module.
+ * @returns {number}
+ */
+function generateNSError(code) {
+  return (
+    ((1 << 31) |
+      ((NS_ERROR_MODULE_MAILNEWS + NS_ERROR_MODULE_BASE_OFFSET) << 16) |
+      code) >>>
+    0
+  );
+}
+
+/**
+ * Collection of helper functions for message sending process.
+ */
+var MsgUtils = {
+  /**
+   * Error codes defined in nsComposeStrings.h
+   */
+  NS_MSG_UNABLE_TO_OPEN_FILE: generateNSError(12500),
+  NS_MSG_UNABLE_TO_OPEN_TMP_FILE: generateNSError(12501),
+  NS_MSG_UNABLE_TO_SAVE_TEMPLATE: generateNSError(12502),
+  NS_MSG_UNABLE_TO_SAVE_DRAFT: generateNSError(12503),
+  NS_MSG_COULDNT_OPEN_FCC_FOLDER: generateNSError(12506),
+  NS_MSG_NO_SENDER: generateNSError(12510),
+  NS_MSG_NO_RECIPIENTS: generateNSError(12511),
+  NS_MSG_ERROR_WRITING_FILE: generateNSError(12512),
+  NS_ERROR_SENDING_FROM_COMMAND: generateNSError(12514),
+  NS_ERROR_SENDING_DATA_COMMAND: generateNSError(12516),
+  NS_ERROR_SENDING_MESSAGE: generateNSError(12517),
+  NS_ERROR_POST_FAILED: generateNSError(12518),
+  NS_ERROR_SMTP_SERVER_ERROR: generateNSError(12524),
+  NS_MSG_UNABLE_TO_SEND_LATER: generateNSError(12525),
+  NS_ERROR_COMMUNICATIONS_ERROR: generateNSError(12526),
+  NS_ERROR_BUT_DONT_SHOW_ALERT: generateNSError(12527),
+  NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS: generateNSError(12529),
+  NS_ERROR_COULD_NOT_GET_SENDERS_IDENTITY: generateNSError(12530),
+  NS_ERROR_MIME_MPART_ATTACHMENT_ERROR: generateNSError(12531),
+
+  // 12554 is taken by NS_ERROR_NNTP_NO_CROSS_POSTING.  use 12555 as the next one
+
+  // For message sending report
+  NS_MSG_ERROR_READING_FILE: generateNSError(12563),
+
+  NS_MSG_ERROR_ATTACHING_FILE: generateNSError(12570),
+
+  NS_ERROR_SMTP_GREETING: generateNSError(12572),
+
+  NS_ERROR_SENDING_RCPT_COMMAND: generateNSError(12575),
+
+  NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS: generateNSError(12582),
+
+  NS_ERROR_SMTP_PASSWORD_UNDEFINED: generateNSError(12584),
+  NS_ERROR_SMTP_SEND_NOT_ALLOWED: generateNSError(12585),
+  NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED: generateNSError(12586),
+  NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2: generateNSError(12588),
+
+  NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER: generateNSError(12589),
+  NS_ERROR_SMTP_SEND_FAILED_REFUSED: generateNSError(12590),
+  NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED: generateNSError(12591),
+  NS_ERROR_SMTP_SEND_FAILED_TIMEOUT: generateNSError(12592),
+  NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON: generateNSError(12593),
+
+  NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL: generateNSError(12594),
+  NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL: generateNSError(12595),
+  NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT: generateNSError(12596),
+  NS_ERROR_SMTP_AUTH_FAILURE: generateNSError(12597),
+  NS_ERROR_SMTP_AUTH_GSSAPI: generateNSError(12598),
+  NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED: generateNSError(12599),
+
+  NS_ERROR_ILLEGAL_LOCALPART: generateNSError(12601),
+
+  NS_ERROR_CLIENTID: generateNSError(12610),
+  NS_ERROR_CLIENTID_PERMISSION: generateNSError(12611),
+
+  sendLogger: console.createInstance({
+    prefix: "mailnews.send",
+    maxLogLevel: "Warn",
+    maxLogLevelPref: "mailnews.send.loglevel",
+  }),
+
+  smtpLogger: console.createInstance({
+    prefix: "mailnews.smtp",
+    maxLogLevel: "Warn",
+    maxLogLevelPref: "mailnews.smtp.loglevel",
+  }),
+
+  /**
+   * NS_IS_MSG_ERROR in msgCore.h.
+   *
+   * @param {nsresult} err - The nsresult value.
+   * @returns {boolean}
+   */
+  isMsgError(err) {
+    return (
+      (((err >> 16) - NS_ERROR_MODULE_BASE_OFFSET) & 0x1fff) ==
+      NS_ERROR_MODULE_MAILNEWS
+    );
+  },
+
+  /**
+   * Convert html to text to form a multipart/alternative message. The output
+   * depends on preference.
+   *
+   * @param {string} input - The HTML text to convert.
+   * @param {boolean} formatFlowed - A flag to enable OutputFormatFlowed.
+   * @returns {string}
+   */
+  convertToPlainText(input, formatFlowed) {
+    let wrapWidth = Services.prefs.getIntPref("mailnews.wraplength", 72);
+    if (wrapWidth == 0 || wrapWidth > 990) {
+      wrapWidth = 990;
+    } else if (wrapWidth < 10) {
+      wrapWidth = 10;
+    }
+
+    let flags =
+      Ci.nsIDocumentEncoder.OutputPersistNBSP |
+      Ci.nsIDocumentEncoder.OutputFormatted |
+      Ci.nsIDocumentEncoder.OutputDisallowLineBreaking;
+    if (formatFlowed) {
+      flags |= Ci.nsIDocumentEncoder.OutputFormatFlowed;
+    }
+
+    let parserUtils = Cc["@mozilla.org/parserutils;1"].getService(
+      Ci.nsIParserUtils
+    );
+    return parserUtils.convertToPlainText(input, flags, wrapWidth);
+  },
+
+  /**
+   * Get the list of default custom headers.
+   *
+   * @param {nsIMsgIdentity} userIdentity - User identity.
+   * @returns {{headerName: string, headerValue: string}[]}
+   */
+  getDefaultCustomHeaders(userIdentity) {
+    // mail.identity.<id#>.headers pref is a comma separated value of pref names
+    // containing headers to add headers are stored in
+    let headerAttributes = userIdentity
+      .getUnicharAttribute("headers")
+      .split(",");
+    let headers = [];
+    for (let attr of headerAttributes) {
+      // mail.identity.<id#>.header.<header name> grab all the headers
+      let attrValue = userIdentity.getUnicharAttribute(`header.${attr}`);
+      if (attrValue) {
+        let colonIndex = attrValue.indexOf(":");
+        headers.push({
+          headerName: attrValue.slice(0, colonIndex),
+          headerValue: attrValue.slice(colonIndex + 1).trim(),
+        });
+      }
+    }
+    return headers;
+  },
+
+  /**
+   * Get the fcc value.
+   *
+   * @param {nsIMsgIdentity} userIdentity - The user identity.
+   * @param {nsIMsgCompFields} compFields - The compose fields.
+   * @param {string} originalMsgURI - The original message uri, can be null.
+   * @param {MSG_ComposeType} compType - The compose type.
+   * @returns {string}
+   */
+  getFcc(userIdentity, compFields, originalMsgURI, compType) {
+    // Check if the default fcc has been overridden.
+    let fcc = "";
+    let useDefaultFcc = true;
+    if (compFields.fcc) {
+      if (compFields.fcc.startsWith("nocopy://")) {
+        useDefaultFcc = false;
+        fcc = "";
+      } else {
+        let folder = MailUtils.getExistingFolder(compFields.fcc);
+        if (folder) {
+          useDefaultFcc = false;
+          fcc = compFields.fcc;
+        }
+      }
+    }
+
+    // If the identity pref "fcc" is set to false, then we will not do the default
+    // FCC operation but still allow the override.
+    if (!userIdentity.doFcc) {
+      return fcc;
+    }
+
+    // We use default FCC setting if it's not set or was set to an invalid
+    // folder.
+    if (useDefaultFcc) {
+      // Only check whether the user wants the message in the original message
+      // folder if the msgcomptype is some kind of a reply.
+      if (
+        originalMsgURI &&
+        [
+          Ci.nsIMsgCompType.Reply,
+          Ci.nsIMsgCompType.ReplyAll,
+          Ci.nsIMsgCompType.ReplyToGroup,
+          Ci.nsIMsgCompType.ReplyToSender,
+          Ci.nsIMsgCompType.ReplyToSenderAndGroup,
+          Ci.nsIMsgCompType.ReplyToList,
+          Ci.nsIMsgCompType.ReplyWithTemplate,
+        ].includes(compType)
+      ) {
+        let msgHdr;
+        try {
+          msgHdr =
+            MailServices.messageServiceFromURI(
+              originalMsgURI
+            ).messageURIToMsgHdr(originalMsgURI);
+        } catch (e) {
+          console.warn(
+            `messageServiceFromURI failed for ${originalMsgURI}\n${e.stack}`
+          );
+        }
+        if (msgHdr) {
+          let folder = msgHdr.folder;
+          if (
+            folder &&
+            folder.canFileMessages &&
+            folder.server &&
+            folder.server.getCharValue("type") != "rss" &&
+            userIdentity.fccReplyFollowsParent
+          ) {
+            fcc = folder.URI;
+            useDefaultFcc = false;
+          }
+        }
+      }
+
+      if (useDefaultFcc) {
+        let uri = this.getMsgFolderURIFromPrefs(
+          userIdentity,
+          Ci.nsIMsgSend.nsMsgDeliverNow
+        );
+        fcc = uri == "nocopy://" ? "" : uri;
+      }
+    }
+
+    return fcc;
+  },
+
+  canSaveToFolder(folderUri) {
+    let folder = MailUtils.getOrCreateFolder(folderUri);
+    if (folder.server) {
+      return folder.server.canFileMessagesOnServer;
+    }
+    return false;
+  },
+
+  /**
+   * Get the To header value. When we don't have disclosed recipient but only
+   * Bcc, use the undisclosedRecipients entry from composeMsgs.properties as the
+   * To header value to prevent problem with some servers.
+   *
+   * @param {nsIMsgCompFields} compFields - The compose fields.
+   * @param {nsMsgDeliverMode} deliverMode - The deliver mode.
+   * @returns {string}
+   */
+  getUndisclosedRecipients(compFields, deliverMode) {
+    // Newsgroups count as recipients.
+    let hasDisclosedRecipient =
+      compFields.to || compFields.cc || compFields.newsgroups;
+    // If we are saving the message as a draft, don't bother inserting the
+    // undisclosed recipients field. We'll take care of that when we really send
+    // the message.
+    if (
+      hasDisclosedRecipient ||
+      [
+        Ci.nsIMsgSend.nsMsgDeliverBackground,
+        Ci.nsIMsgSend.nsMsgSaveAsDraft,
+        Ci.nsIMsgSend.nsMsgSaveAsTemplate,
+      ].includes(deliverMode) ||
+      !Services.prefs.getBoolPref("mail.compose.add_undisclosed_recipients")
+    ) {
+      return "";
+    }
+    let composeBundle = Services.strings.createBundle(
+      "chrome://messenger/locale/messengercompose/composeMsgs.properties"
+    );
+    let undisclosedRecipients = composeBundle.GetStringFromName(
+      "undisclosedRecipients"
+    );
+    let recipients = MailServices.headerParser.makeGroupObject(
+      undisclosedRecipients,
+      []
+    );
+    return recipients.toString();
+  },
+
+  /**
+   * Get the Mail-Followup-To header value.
+   * See bug #204339 and http://cr.yp.to/proto/replyto.html for details
+   *
+   * @param {nsIMsgCompFields} compFields - The compose fields.
+   * @param {nsIMsgIdentity} userIdentity - The user identity.
+   * @returns {string}
+   */
+  getMailFollowupToHeader(compFields, userIdentity) {
+    let mailLists = userIdentity.getUnicharAttribute(
+      "subscribed_mailing_lists"
+    );
+    if (!mailLists || !(compFields.to || compFields.cc)) {
+      return "";
+    }
+    let recipients = compFields.to;
+    if (recipients) {
+      if (compFields.cc) {
+        recipients += `,${compFields.cc}`;
+      }
+    } else {
+      recipients = compFields.cc;
+    }
+    let recipientsDedup =
+      MailServices.headerParser.removeDuplicateAddresses(recipients);
+    let recipientsWithoutMailList =
+      MailServices.headerParser.removeDuplicateAddresses(
+        recipientsDedup,
+        mailLists
+      );
+    if (recipientsDedup != recipientsWithoutMailList) {
+      return recipients;
+    }
+    return "";
+  },
+
+  /**
+   * Get the Mail-Reply-To header value.
+   * See bug #204339 and http://cr.yp.to/proto/replyto.html for details
+   *
+   * @param {nsIMsgCompFields} compFields - The compose fields.
+   * @param {nsIMsgIdentity} userIdentity - The user identity.
+   * @returns {string}
+   */
+  getMailReplyToHeader(compFields, userIdentity) {
+    let mailLists = userIdentity.getUnicharAttribute(
+      "replyto_mangling_mailing_lists"
+    );
+    if (
+      !mailLists ||
+      mailLists[0] == "*" ||
+      !(compFields.to || compFields.cc)
+    ) {
+      return "";
+    }
+    let recipients = compFields.to;
+    if (recipients) {
+      if (compFields.cc) {
+        recipients += `,${compFields.cc}`;
+      }
+    } else {
+      recipients = compFields.cc;
+    }
+    let recipientsDedup =
+      MailServices.headerParser.removeDuplicateAddresses(recipients);
+    let recipientsWithoutMailList =
+      MailServices.headerParser.removeDuplicateAddresses(
+        recipientsDedup,
+        mailLists
+      );
+    if (recipientsDedup != recipientsWithoutMailList) {
+      return compFields.replyTo || compFields.from;
+    }
+    return "";
+  },
+
+  /**
+   * Get the X-Mozilla-Draft-Info header value.
+   *
+   * @param {nsIMsgCompFields} compFields - The compose fields.
+   * @returns {string}
+   */
+  getXMozillaDraftInfo(compFields) {
+    let getCompField = (property, key) => {
+      let value = compFields[property] ? 1 : 0;
+      return `${key}=${value}; `;
+    };
+    let draftInfo = "internal/draft; ";
+    draftInfo += getCompField("attachVCard", "vcard");
+
+    let receiptValue = 0;
+    if (compFields.returnReceipt) {
+      // slight change compared to 4.x; we used to use receipt= to tell
+      // whether the draft/template has request for either MDN or DNS or both
+      // return receipt; since the DNS is out of the picture we now use the
+      // header type + 1 to tell whether user has requested the return receipt
+      receiptValue = compFields.receiptHeaderType + 1;
+    }
+    draftInfo += `receipt=${receiptValue}; `;
+
+    draftInfo += getCompField("DSN", "DSN");
+    draftInfo += "uuencode=0; ";
+    draftInfo += getCompField("attachmentReminder", "attachmentreminder");
+    draftInfo += `deliveryformat=${compFields.deliveryFormat}`;
+
+    return draftInfo;
+  },
+
+  /**
+   * Get the X-Mozilla-Cloud-Part header value.
+   *
+   * @param {nsMsgDeliverMode} deliverMode - The deliver mode.
+   * @param {nsIMsgAttachment} attachment - The cloud attachment.
+   * @returns {string}
+   */
+  getXMozillaCloudPart(deliverMode, attachment) {
+    let value = "";
+    if (attachment.sendViaCloud && attachment.contentLocation) {
+      value += `cloudFile; url=${attachment.contentLocation}`;
+
+      if (
+        (deliverMode == Ci.nsIMsgSend.nsMsgSaveAsDraft ||
+          deliverMode == Ci.nsIMsgSend.nsMsgSaveAsTemplate) &&
+        attachment.cloudFileAccountKey &&
+        attachment.cloudPartHeaderData
+      ) {
+        value += `; provider=${attachment.cloudFileAccountKey}`;
+        value += `; ${this.rfc2231ParamFolding(
+          "data",
+          attachment.cloudPartHeaderData
+        )}`;
+      }
+    }
+    return value;
+  },
+
+  /**
+   * Get the X-Mozilla-Status header value. The header value will be used to set
+   * some nsMsgMessageFlags. Including the Read flag for message in a local
+   * folder.
+   *
+   * @param {nsMsgDeliverMode} deliverMode - The deliver mode.
+   * @returns {string}
+   */
+  getXMozillaStatus(deliverMode) {
+    if (
+      ![
+        Ci.nsIMsgSend.nsMsgQueueForLater,
+        Ci.nsIMsgSend.nsMsgSaveAsDraft,
+        Ci.nsIMsgSend.nsMsgSaveAsTemplate,
+        Ci.nsIMsgSend.nsMsgDeliverNow,
+        Ci.nsIMsgSend.nsMsgSendUnsent,
+        Ci.nsIMsgSend.nsMsgDeliverBackground,
+      ].includes(deliverMode)
+    ) {
+      return "";
+    }
+    let flags = 0;
+    if (deliverMode == Ci.nsIMsgSend.nsMsgQueueForLater) {
+      flags |= Ci.nsMsgMessageFlags.Queued;
+    } else if (
+      deliverMode != Ci.nsIMsgSend.nsMsgSaveAsDraft &&
+      deliverMode != Ci.nsIMsgSend.nsMsgDeliverBackground
+    ) {
+      flags |= Ci.nsMsgMessageFlags.Read;
+    }
+    return flags.toString(16).padStart(4, "0");
+  },
+
+  /**
+   * Get the X-Mozilla-Status2 header value. The header value will be used to
+   * set some nsMsgMessageFlags.
+   *
+   * @param {nsMsgDeliverMode} deliverMode - The deliver mode.
+   * @returns {string}
+   */
+  getXMozillaStatus2(deliverMode) {
+    if (
+      ![
+        Ci.nsIMsgSend.nsMsgQueueForLater,
+        Ci.nsIMsgSend.nsMsgSaveAsDraft,
+        Ci.nsIMsgSend.nsMsgSaveAsTemplate,
+        Ci.nsIMsgSend.nsMsgDeliverNow,
+        Ci.nsIMsgSend.nsMsgSendUnsent,
+        Ci.nsIMsgSend.nsMsgDeliverBackground,
+      ].includes(deliverMode)
+    ) {
+      return "";
+    }
+    let flags = 0;
+    if (deliverMode == Ci.nsIMsgSend.nsMsgSaveAsTemplate) {
+      flags |= Ci.nsMsgMessageFlags.Template;
+    } else if (
+      deliverMode == Ci.nsIMsgSend.nsMsgDeliverNow ||
+      deliverMode == Ci.nsIMsgSend.nsMsgSendUnsent
+    ) {
+      flags &= ~Ci.nsMsgMessageFlags.MDNReportNeeded;
+      flags |= Ci.nsMsgMessageFlags.MDNReportSent;
+    }
+    return flags.toString(16).padStart(8, "0");
+  },
+
+  /**
+   * Get the Disposition-Notification-To header value.
+   *
+   * @param {nsIMsgCompFields} compFields - The compose fields.
+   * @param {nsMsgDeliverMode} deliverMode - The deliver mode.
+   * @returns {{dnt: string, rrt: string}}
+   */
+  getDispositionNotificationTo(compFields, deliverMode) {
+    if (
+      compFields.returnReceipt &&
+      deliverMode != Ci.nsIMsgSend.nsMsgSaveAsDraft &&
+      deliverMode != Ci.nsIMsgSend.nsMsgSaveAsTemplate &&
+      compFields.receiptHeaderType != Ci.nsIMsgMdnGenerator.eRrtType
+    ) {
+      return compFields.from;
+    }
+    return "";
+  },
+
+  /**
+   * Get the Return-Receipt-To header value.
+   *
+   * @param {nsIMsgCompFields} compFields - The compose fields.
+   * @param {nsMsgDeliverMode} deliverMode - The deliver mode.
+   * @returns {{dnt: string, rrt: string}}
+   */
+  getReturnReceiptTo(compFields, deliverMode) {
+    if (
+      compFields.returnReceipt &&
+      deliverMode != Ci.nsIMsgSend.nsMsgSaveAsDraft &&
+      deliverMode != Ci.nsIMsgSend.nsMsgSaveAsTemplate &&
+      compFields.receiptHeaderType != Ci.nsIMsgMdnGenerator.eDntType
+    ) {
+      return compFields.from;
+    }
+    return "";
+  },
+
+  /**
+   * Get the value of X-Priority header.
+   *
+   * @param {string} rawPriority - Raw X-Priority content.
+   * @returns {string}
+   */
+  getXPriority(rawPriority) {
+    rawPriority = rawPriority.toLowerCase();
+    let priorityValue = Ci.nsMsgPriority.Default;
+    let priorityValueString = "0";
+    let priorityName = "None";
+    if (rawPriority.startsWith("1") || rawPriority.startsWith("highest")) {
+      priorityValue = Ci.nsMsgPriority.highest;
+      priorityValueString = "1";
+      priorityName = "Highest";
+    } else if (
+      rawPriority.startsWith("2") ||
+      // "high" must be tested after "highest".
+      rawPriority.startsWith("high") ||
+      rawPriority.startsWith("urgent")
+    ) {
+      priorityValue = Ci.nsMsgPriority.high;
+      priorityValueString = "2";
+      priorityName = "High";
+    } else if (
+      rawPriority.startsWith("3") ||
+      rawPriority.startsWith("normal")
+    ) {
+      priorityValue = Ci.nsMsgPriority.normal;
+      priorityValueString = "3";
+      priorityName = "Normal";
+    } else if (
+      rawPriority.startsWith("5") ||
+      rawPriority.startsWith("lowest")
+    ) {
+      priorityValue = Ci.nsMsgPriority.lowest;
+      priorityValueString = "5";
+      priorityName = "Lowest";
+    } else if (
+      rawPriority.startsWith("4") ||
+      // "low" must be tested after "lowest".
+      rawPriority.startsWith("low")
+    ) {
+      priorityValue = Ci.nsMsgPriority.low;
+      priorityValueString = "4";
+      priorityName = "Low";
+    }
+    if (priorityValue == Ci.nsMsgPriority.Default) {
+      return "";
+    }
+    return `${priorityValueString} (${priorityName})`;
+  },
+
+  /**
+   * Get the References header value.
+   *
+   * @param {string} references - Raw References header content.
+   * @returns {string}
+   */
+  getReferences(references) {
+    if (references.length <= 986) {
+      return "";
+    }
+    // The References header should be kept under 998 characters: if it's too
+    // long, trim out the earliest references to make it smaller.
+    let newReferences = "";
+    let firstRef = references.indexOf("<");
+    let secondRef = references.indexOf("<", firstRef + 1);
+    if (secondRef > 0) {
+      newReferences = references.slice(0, secondRef);
+      let bracket = references.indexOf(
+        "<",
+        references.length + newReferences.length - 986
+      );
+      if (bracket > 0) {
+        newReferences += references.slice(bracket);
+      }
+    }
+    return newReferences;
+  },
+
+  /**
+   * Get the In-Reply-To header value.
+   *
+   * @param {string} references - Raw References header content.
+   * @returns {string}
+   */
+  getInReplyTo(references) {
+    // The In-Reply-To header is the last entry in the references header...
+    let bracket = references.lastIndexOf("<");
+    if (bracket >= 0) {
+      return references.slice(bracket);
+    }
+    return "";
+  },
+
+  /**
+   * Get the value of Newsgroups and X-Mozilla-News-Host header.
+   *
+   * @param {nsMsgDeliverMode} deliverMode - Message deliver mode.
+   * @param {string} newsgroups - Raw newsgroups header content.
+   * @returns {{newsgroups: string, newshost: string}}
+   */
+  getNewsgroups(deliverMode, newsgroups) {
+    let nntpService = Cc["@mozilla.org/messenger/nntpservice;1"].getService(
+      Ci.nsINntpService
+    );
+    let newsgroupsHeaderVal = {};
+    let newshostHeaderVal = {};
+    nntpService.generateNewsHeaderValsForPosting(
+      newsgroups,
+      newsgroupsHeaderVal,
+      newshostHeaderVal
+    );
+
+    // If we are here, we are NOT going to send this now. (i.e. it is a Draft,
+    // Send Later file, etc...). Because of that, we need to store what the user
+    // typed in on the original composition window for use later when rebuilding
+    // the headers
+    if (
+      deliverMode == Ci.nsIMsgSend.nsMsgDeliverNow ||
+      deliverMode == Ci.nsIMsgSend.nsMsgSendUnsent
+    ) {
+      // This is going to be saved for later, that means we should just store
+      // what the user typed into the "Newsgroup" line in the
+      // HEADER_X_MOZILLA_NEWSHOST header for later use by "Send Unsent
+      // Messages", "Drafts" or "Templates"
+      newshostHeaderVal.value = "";
+    }
+    return {
+      newsgroups: newsgroupsHeaderVal.value,
+      newshost: newshostHeaderVal.value,
+    };
+  },
+
+  /**
+   * Get the Content-Location header value.
+   *
+   * @param {string} baseUrl - The base url of an HTML attachment.
+   * @returns {string}
+   */
+  getContentLocation(baseUrl) {
+    let lowerBaseUrl = baseUrl.toLowerCase();
+    if (
+      !baseUrl.includes(":") ||
+      lowerBaseUrl.startsWith("news:") ||
+      lowerBaseUrl.startsWith("snews:") ||
+      lowerBaseUrl.startsWith("imap:") ||
+      lowerBaseUrl.startsWith("file:") ||
+      lowerBaseUrl.startsWith("mailbox:")
+    ) {
+      return "";
+    }
+    let transformMap = {
+      " ": "%20",
+      "\t": "%09",
+      "\n": "%0A",
+      "\r": "%0D",
+    };
+    let value = "";
+    for (let char of baseUrl) {
+      value += transformMap[char] || char;
+    }
+    return value;
+  },
+
+  /**
+   * Given a string, convert it to 'qtext' (quoted text) for RFC822 header
+   * purposes.
+   */
+  makeFilenameQtext(srcText, stripCRLFs) {
+    let size = srcText.length;
+    let ret = "";
+    for (let i = 0; i < size; i++) {
+      let char = srcText.charAt(i);
+      if (
+        char == "\\" ||
+        char == '"' ||
+        (!stripCRLFs &&
+          char == "\r" &&
+          (srcText[i + 1] != "\n" ||
+            (srcText[i + 1] == "\n" && i + 2 < size && srcText[i + 2] != " ")))
+      ) {
+        ret += "\\";
+      }
+
+      if (
+        stripCRLFs &&
+        char == "\r" &&
+        srcText[i + 1] == "\n" &&
+        i + 2 < size &&
+        srcText[i + 2] == " "
+      ) {
+        i += 3;
+      } else {
+        ret += char;
+      }
+    }
+    return ret;
+  },
+
+  /**
+   * Encode parameter value according to RFC 2047.
+   *
+   * @param {string} value - The parameter value.
+   * @returns {string}
+   */
+  rfc2047EncodeParam(value) {
+    let converter = Cc["@mozilla.org/messenger/mimeconverter;1"].getService(
+      Ci.nsIMimeConverter
+    );
+
+    let encoded = converter.encodeMimePartIIStr_UTF8(
+      value,
+      false,
+      0,
+      Ci.nsIMimeConverter.MIME_ENCODED_WORD_SIZE
+    );
+
+    return this.makeFilenameQtext(encoded, false);
+  },
+
+  /**
+   * Encode parameter value according to RFC 2231.
+   *
+   * @param {string} paramName - The parameter name.
+   * @param {string} paramValue - The parameter value.
+   * @returns {string}
+   */
+  rfc2231ParamFolding(paramName, paramValue) {
+    // this is to guarantee the folded line will never be greater
+    // than 78 = 75 + CRLFLWSP
+    const PR_MAX_FOLDING_LEN = 75;
+
+    let needsEscape = false;
+    let encoder = new TextEncoder();
+    let dupParamValue = jsmime.mimeutils.typedArrayToString(
+      encoder.encode(paramValue)
+    );
+
+    if (/[\x80-\xff]/.test(dupParamValue)) {
+      needsEscape = true;
+      dupParamValue = Services.io.escapeString(
+        dupParamValue,
+        Ci.nsINetUtil.ESCAPE_ALL
+      );
+    } else {
+      dupParamValue = this.makeFilenameQtext(dupParamValue, true);
+    }
+
+    let paramNameLen = paramName.length;
+    let paramValueLen = dupParamValue.length;
+    paramNameLen += 5; // *=__'__'___ or *[0]*=__'__'__ or *[1]*=___ or *[0]="___"
+    let foldedParam = "";
+
+    if (paramValueLen + paramNameLen + "UTF-8".length < PR_MAX_FOLDING_LEN) {
+      foldedParam = paramName;
+      if (needsEscape) {
+        foldedParam += "*=UTF-8''";
+      } else {
+        foldedParam += '="';
+      }
+      foldedParam += dupParamValue;
+      if (!needsEscape) {
+        foldedParam += '"';
+      }
+    } else {
+      let curLineLen = 0;
+      let counter = 0;
+      let start = 0;
+      let end = null;
+
+      while (paramValueLen > 0) {
+        curLineLen = 0;
+        if (counter == 0) {
+          foldedParam = paramName;
+        } else {
+          foldedParam += `;\r\n ${paramName}`;
+        }
+        foldedParam += `*${counter}`;
+        curLineLen += `*${counter}`.length;
+        if (needsEscape) {
+          foldedParam += "*=";
+          if (counter == 0) {
+            foldedParam += "UTF-8''";
+            curLineLen += "UTF-8".length;
+          }
+        } else {
+          foldedParam += '="';
+        }
+        counter++;
+        curLineLen += paramNameLen;
+        if (paramValueLen <= PR_MAX_FOLDING_LEN - curLineLen) {
+          end = start + paramValueLen;
+        } else {
+          end = start + (PR_MAX_FOLDING_LEN - curLineLen);
+        }
+
+        if (end && needsEscape) {
+          // Check to see if we are in the middle of escaped char.
+          // We use ESCAPE_ALL, so every third character is a '%'.
+          if (end - 1 > start && dupParamValue[end - 1] == "%") {
+            end -= 1;
+          } else if (end - 2 > start && dupParamValue[end - 2] == "%") {
+            end -= 2;
+          }
+          // *end is now a '%'.
+          // Check if the following UTF-8 octet is a continuation.
+          while (end - 3 > start && "89AB".includes(dupParamValue[end + 1])) {
+            end -= 3;
+          }
+        }
+        foldedParam += dupParamValue.slice(start, end);
+        if (!needsEscape) {
+          foldedParam += '"';
+        }
+        paramValueLen -= end - start;
+        start = end;
+      }
+    }
+
+    return foldedParam;
+  },
+
+  /**
+   * Get the target message folder to copy to.
+   *
+   * @param {nsIMsgIdentity} userIdentity - The user identity.
+   * @param {nsMsgDeliverMode} deliverMode - The deliver mode.
+   * @returns {string}
+   */
+  getMsgFolderURIFromPrefs(userIdentity, deliverMode) {
+    if (
+      deliverMode == Ci.nsIMsgSend.nsMsgQueueForLater ||
+      deliverMode == Ci.nsIMsgSend.nsMsgDeliverBackground
+    ) {
+      let uri = Services.prefs.getCharPref("mail.default_sendlater_uri");
+      // check if uri is unescaped, and if so, escape it and reset the pef.
+      if (!uri) {
+        return "anyfolder://";
+      } else if (uri.includes(" ")) {
+        uri.replaceAll(" ", "%20");
+        Services.prefs.setCharPref("mail.default_sendlater_uri", uri);
+      }
+      return uri;
+    } else if (deliverMode == Ci.nsIMsgSend.nsMsgSaveAsDraft) {
+      return userIdentity.draftFolder;
+    } else if (deliverMode == Ci.nsIMsgSend.nsMsgSaveAsTemplate) {
+      return userIdentity.stationeryFolder;
+    }
+    if (userIdentity.doFcc) {
+      return userIdentity.fccFolder;
+    }
+    return "";
+  },
+
+  /**
+   * Get the error string name of an exit code. The name will corresponds to an
+   * entry in composeMsgs.properties.
+   *
+   * @param {nsresult} exitCode - Exit code of sending mail process.
+   * @returns {string}
+   */
+  getErrorStringName(exitCode) {
+    let codeNameMap = {
+      [this.NS_MSG_UNABLE_TO_OPEN_FILE]: "unableToOpenFile",
+      [this.NS_MSG_UNABLE_TO_OPEN_TMP_FILE]: "unableToOpenTmpFile",
+      [this.NS_MSG_UNABLE_TO_SAVE_TEMPLATE]: "unableToSaveTemplate",
+      [this.NS_MSG_UNABLE_TO_SAVE_DRAFT]: "unableToSaveDraft",
+      [this.NS_MSG_COULDNT_OPEN_FCC_FOLDER]: "couldntOpenFccFolder",
+      [this.NS_MSG_NO_SENDER]: "noSender",
+      [this.NS_MSG_NO_RECIPIENTS]: "noRecipients",
+      [this.NS_MSG_ERROR_WRITING_FILE]: "errorWritingFile",
+      [this.NS_ERROR_SENDING_FROM_COMMAND]: "errorSendingFromCommand",
+      [this.NS_ERROR_SENDING_DATA_COMMAND]: "errorSendingDataCommand",
+      [this.NS_ERROR_SENDING_MESSAGE]: "errorSendingMessage",
+      [this.NS_ERROR_POST_FAILED]: "postFailed",
+      [this.NS_ERROR_SMTP_SERVER_ERROR]: "smtpServerError",
+      [this.NS_MSG_UNABLE_TO_SEND_LATER]: "unableToSendLater",
+      [this.NS_ERROR_COMMUNICATIONS_ERROR]: "communicationsError",
+      [this.NS_ERROR_BUT_DONT_SHOW_ALERT]: "dontShowAlert",
+      [this.NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS]:
+        "couldNotGetUsersMailAddress2",
+      [this.NS_ERROR_COULD_NOT_GET_SENDERS_IDENTITY]:
+        "couldNotGetSendersIdentity",
+      [this.NS_ERROR_MIME_MPART_ATTACHMENT_ERROR]: "mimeMpartAttachmentError",
+      [this.NS_ERROR_NNTP_NO_CROSS_POSTING]: "nntpNoCrossPosting",
+      [this.NS_MSG_ERROR_READING_FILE]: "errorReadingFile",
+      [this.NS_MSG_ERROR_ATTACHING_FILE]: "errorAttachingFile",
+      [this.NS_ERROR_SMTP_GREETING]: "incorrectSmtpGreeting",
+      [this.NS_ERROR_SENDING_RCPT_COMMAND]: "errorSendingRcptCommand",
+      [this.NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS]: "startTlsFailed",
+      [this.NS_ERROR_SMTP_PASSWORD_UNDEFINED]: "smtpPasswordUndefined",
+      [this.NS_ERROR_SMTP_SEND_NOT_ALLOWED]: "smtpSendNotAllowed",
+      [this.NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED]: "smtpTooManyRecipients",
+      [this.NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2]: "smtpPermSizeExceeded2",
+      [this.NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER]:
+        "smtpSendFailedUnknownServer",
+      [this.NS_ERROR_SMTP_SEND_FAILED_REFUSED]: "smtpSendRequestRefused",
+      [this.NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED]: "smtpSendInterrupted",
+      [this.NS_ERROR_SMTP_SEND_FAILED_TIMEOUT]: "smtpSendTimeout",
+      [this.NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON]:
+        "smtpSendFailedUnknownReason",
+      [this.NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL]:
+        "smtpHintAuthEncryptToPlainNoSsl",
+      [this.NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL]:
+        "smtpHintAuthEncryptToPlainSsl",
+      [this.NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT]:
+        "smtpHintAuthPlainToEncrypt",
+      [this.NS_ERROR_SMTP_AUTH_FAILURE]: "smtpAuthFailure",
+      [this.NS_ERROR_SMTP_AUTH_GSSAPI]: "smtpAuthGssapi",
+      [this.NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED]: "smtpAuthMechNotSupported",
+      [this.NS_ERROR_ILLEGAL_LOCALPART]: "errorIllegalLocalPart2",
+      [this.NS_ERROR_CLIENTID]: "smtpClientid",
+      [this.NS_ERROR_CLIENTID_PERMISSION]: "smtpClientidPermission",
+    };
+    return codeNameMap[exitCode] || "sendFailed";
+  },
+
+  /**
+   * Format the error message that will be shown to the user.
+   *
+   * @param {nsIMsgIdentity} userIdentity - User identity.
+   * @param {nsIStringBundle} composeBundle - Localized string bundle.
+   * @param {string} errorName - The error name derived from an exit code.
+   * @returns {string}
+   */
+  formatStringWithSMTPHostName(userIdentity, composeBundle, errorName) {
+    let smtpServer = MailServices.smtp.getServerByIdentity(userIdentity);
+    let smtpHostname = smtpServer.hostname;
+    return composeBundle.formatStringFromName(errorName, [smtpHostname]);
+  },
+
+  /**
+   * Generate random alphanumeric string.
+   *
+   * @param {number} size - The length of generated string.
+   * @returns {string}
+   */
+  randomString(size) {
+    let length = Math.round((size * 3) / 4);
+    return btoa(
+      String.fromCharCode(
+        ...[...Array(length)].map(() => Math.floor(Math.random() * 256))
+      )
+    )
+      .slice(0, size)
+      .replaceAll(/[+/=]/g, "0");
+  },
+
+  /**
+   * Generate a content id to be used by embedded images.
+   *
+   * @param {nsIMsgIdentity} userIdentity - User identity.
+   * @param {number} partNum - The number of embedded MimePart.
+   * @returns {string}
+   */
+  makeContentId(userIdentity, partNum) {
+    let domain = userIdentity.email.split("@")[1];
+    return `part${partNum}.${this.randomString(8)}.${this.randomString(
+      8
+    )}@${domain}`;
+  },
+
+  /**
+   * Pick a file name from the file URL.
+   *
+   * @param {string} url - The file URL.
+   * @returns {string}
+   */
+  pickFileNameFromUrl(url) {
+    if (/^(news|snews|imap|mailbox):/i.test(url)) {
+      // No sensible file name in it,
+      return "";
+    }
+    if (/^data:/i.test(url)) {
+      let matches = /filename=(.*);/.exec(url);
+      if (matches && matches[1]) {
+        return decodeURIComponent(matches[1]);
+      }
+      let mimeType = url.slice(5, url.indexOf(";"));
+      let extname = "";
+      try {
+        extname = Cc["@mozilla.org/mime;1"]
+          .getService(Ci.nsIMIMEService)
+          .getPrimaryExtension(mimeType, null);
+        if (!extname) {
+          return "";
+        }
+      } catch (e) {
+        return "";
+      }
+      return `${this.randomString(16)}.${extname}`;
+    }
+    // Take the part after the last / or \.
+    let lastSlash = url.lastIndexOf("\\");
+    if (lastSlash == -1) {
+      lastSlash = url.lastIndexOf("/");
+    }
+    // Strip any search or anchor.
+    return url
+      .slice(lastSlash + 1)
+      .split("?")[0]
+      .split("#")[0];
+  },
+};
diff --git a/comm/mailnews/compose/src/MimePart.jsm b/comm/mailnews/compose/src/MimePart.jsm
new file mode 100644
index 0000000000..a22c0527af
--- /dev/null
+++ b/comm/mailnews/compose/src/MimePart.jsm
@@ -0,0 +1,378 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["MimePart", "MimeMultiPart"];
+
+let { jsmime } = ChromeUtils.import("resource:///modules/jsmime.jsm");
+let { MimeEncoder } = ChromeUtils.import("resource:///modules/MimeEncoder.jsm");
+let { MsgUtils } = ChromeUtils.import(
+  "resource:///modules/MimeMessageUtils.jsm"
+);
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+var { MailStringUtils } = ChromeUtils.import(
+  "resource:///modules/MailStringUtils.jsm"
+);
+var { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+
+/**
+ * A class to represent a RFC2045 message. MimePart can be nested, each MimePart
+ * can contain a list of MimePart. HTML and plain text are parts as well. Use
+ * class MimeMultiPart for multipart/*, that's why this class doesn't expose an
+ * addPart method
+ */
+class MimePart {
+  /**
+   * @param {string} contentType - Content type of the part, e.g. text/plain.
+   * @param {boolean} forceMsgEncoding - A flag used to determine Content-Transfer-Encoding.
+   * @param {boolean} isMainBody - The part is main part or an attachment part.
+   */
+  constructor(contentType = "", forceMsgEncoding = false, isMainBody = false) {
+    this._charset = "UTF-8";
+    this._contentType = contentType;
+    this._forceMsgEncoding = forceMsgEncoding;
+    this._isMainBody = isMainBody;
+
+    this._headers = new Map();
+    // 8-bit string to avoid converting back and forth.
+    this._bodyText = "";
+    this._bodyAttachment = null;
+    this._contentDisposition = null;
+    this._contentId = null;
+    this._separator = "";
+    this._parts = [];
+  }
+
+  /**
+   * @type {BinaryString} text - The string to use as body.
+   */
+  set bodyText(text) {
+    this._bodyText = text.replaceAll("\r\n", "\n").replaceAll("\n", "\r\n");
+  }
+
+  /**
+   * @type {MimePart[]} - The child parts.
+   */
+  get parts() {
+    return this._parts;
+  }
+
+  /**
+   * @type {MimePart[]} parts - The child parts.
+   */
+  set parts(parts) {
+    this._parts = parts;
+  }
+
+  /**
+   * @type {string} - The separator string.
+   */
+  get separator() {
+    return this._separator;
+  }
+
+  /**
+   * Set a header.
+   *
+   * @param {string} name - The header name, e.g. "content-type".
+   * @param {string} content - The header content, e.g. "text/plain".
+   */
+  setHeader(name, content) {
+    if (!content) {
+      return;
+    }
+    // There is no Content-Type encoder in jsmime yet. If content is not string,
+    // assume it's already a structured header.
+    if (name == "content-type" || typeof content != "string") {
+      // _headers will be passed to jsmime, which requires header content to be
+      // an array.
+      this._headers.set(name, [content]);
+      return;
+    }
+    try {
+      this._headers.set(name, [
+        jsmime.headerparser.parseStructuredHeader(name, content),
+      ]);
+    } catch (e) {
+      this._headers.set(name, [content.trim()]);
+    }
+  }
+
+  /**
+   * Delete a header.
+   *
+   * @param {string} name - The header name to delete, e.g. "content-type".
+   */
+  deleteHeader(name) {
+    this._headers.delete(name);
+  }
+
+  /**
+   * Set headers by an iterable.
+   *
+   * @param {Iterable.<string, string>} entries - The header entries.
+   */
+  setHeaders(entries) {
+    for (let [name, content] of entries) {
+      this.setHeader(name, content);
+    }
+  }
+
+  /**
+   * Set an attachment as body, with optional contentDisposition and contentId.
+   *
+   * @param {nsIMsgAttachment} attachment - The attachment to use as body.
+   * @param {string} [contentDisposition=attachment] - "attachment" or "inline".
+   * @param {string} [contentId] - The url of an embedded object is cid:contentId.
+   */
+  setBodyAttachment(
+    attachment,
+    contentDisposition = "attachment",
+    contentId = null
+  ) {
+    this._bodyAttachment = attachment;
+    this._contentDisposition = contentDisposition;
+    this._contentId = contentId;
+  }
+
+  /**
+   * Add a child part.
+   *
+   * @param {MimePart} part - A MimePart.
+   */
+  addPart(part) {
+    this._parts.push(part);
+  }
+
+  /**
+   * Add child parts.
+   *
+   * @param {MimePart[]} parts - An array of MimePart.
+   */
+  addParts(parts) {
+    this._parts.push(...parts);
+  }
+
+  /**
+   * Pick an encoding according to _bodyText or _bodyAttachment content. Set
+   * content-transfer-encoding header, then return the encoded value.
+   *
+   * @returns {BinaryString}
+   */
+  async getEncodedBodyString() {
+    let bodyString = this._bodyText;
+    // If this is an attachment part, use the attachment content as bodyString.
+    if (this._bodyAttachment) {
+      try {
+        bodyString = await this._fetchAttachment();
+      } catch (e) {
+        MsgUtils.sendLogger.error(
+          `Failed to fetch attachment; name=${this._bodyAttachment.name}, url=${this._bodyAttachment.url}, error=${e}`
+        );
+        throw Components.Exception(
+          "Failed to fetch attachment",
+          MsgUtils.NS_MSG_ERROR_ATTACHING_FILE,
+          e.stack,
+          this._bodyAttachment
+        );
+      }
+    }
+    if (bodyString) {
+      let encoder = new MimeEncoder(
+        this._charset,
+        this._contentType,
+        this._forceMsgEncoding,
+        this._isMainBody,
+        bodyString
+      );
+      encoder.pickEncoding();
+      this.setHeader("content-transfer-encoding", encoder.encoding);
+      bodyString = encoder.encode();
+    } else if (this._isMainBody) {
+      this.setHeader("content-transfer-encoding", "7bit");
+    }
+    return bodyString;
+  }
+
+  /**
+   * Use jsmime to convert _headers to string.
+   *
+   * @returns {string}
+   */
+  getHeaderString() {
+    return jsmime.headeremitter.emitStructuredHeaders(this._headers, {
+      useASCII: true,
+      sanitizeDate: Services.prefs.getBoolPref(
+        "mail.sanitize_date_header",
+        false
+      ),
+    });
+  }
+
+  /**
+   * Fetch the attached message file to get its content.
+   *
+   * @returns {string}
+   */
+  async _fetchMsgAttachment() {
+    let msgService = MailServices.messageServiceFromURI(
+      this._bodyAttachment.url
+    );
+    return new Promise((resolve, reject) => {
+      let streamListener = {
+        _data: "",
+        _stream: null,
+        onDataAvailable(request, inputStream, offset, count) {
+          if (!this._stream) {
+            this._stream = Cc[
+              "@mozilla.org/scriptableinputstream;1"
+            ].createInstance(Ci.nsIScriptableInputStream);
+            this._stream.init(inputStream);
+          }
+          this._data += this._stream.read(count);
+        },
+        onStartRequest() {},
+        onStopRequest(request, status) {
+          if (Components.isSuccessCode(status)) {
+            resolve(this._data);
+          } else {
+            reject(`Fetch message attachment failed with status=${status}`);
+          }
+        },
+        QueryInterface: ChromeUtils.generateQI(["nsIStreamListener"]),
+      };
+
+      msgService.streamMessage(
+        this._bodyAttachment.url,
+        streamListener,
+        null, // msgWindow
+        null, // urlListener
+        false, // convertData
+        "" // additionalHeader
+      );
+    });
+  }
+
+  /**
+   * Fetch the attachment file to get its content type and content.
+   *
+   * Previously, we used the Fetch API to download all attachments, but Fetch
+   * doesn't support url with embedded credentials (imap://name@server). As a
+   * result, it's unreliable when having two mail accounts on the same IMAP
+   * server.
+   *
+   * @returns {string}
+   */
+  async _fetchAttachment() {
+    let url = this._bodyAttachment.url;
+    MsgUtils.sendLogger.debug(`Fetching ${url}`);
+
+    let content = "";
+    if (/^[^:]+-message:/i.test(url)) {
+      content = await this._fetchMsgAttachment();
+      if (!content) {
+        // Message content is empty usually means it's (re)moved.
+        throw new Error("Message is gone");
+      }
+      this._contentType = "message/rfc822";
+    } else {
+      let channel = Services.io.newChannelFromURI(
+        Services.io.newURI(url),
+        null,
+        Services.scriptSecurityManager.getSystemPrincipal(),
+        null,
+        Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+        Ci.nsIContentPolicy.TYPE_OTHER
+      );
+      content = await new Promise((resolve, reject) =>
+        NetUtil.asyncFetch(channel, (stream, status, request) => {
+          if (!Components.isSuccessCode(status)) {
+            reject(`asyncFetch failed with status=${status}`);
+            return;
+          }
+          let data = "";
+          try {
+            data = NetUtil.readInputStreamToString(stream, stream.available());
+          } catch (e) {
+            // stream.available() throws if the file is empty.
+          }
+          resolve(data);
+        })
+      );
+      this._contentType =
+        this._bodyAttachment.contentType || channel.contentType;
+    }
+
+    let parmFolding = Services.prefs.getIntPref(
+      "mail.strictly_mime.parm_folding",
+      2
+    );
+    // File name can contain non-ASCII chars, encode according to RFC 2231.
+    let encodedName, encodedFileName;
+    if (this._bodyAttachment.name) {
+      encodedName = MsgUtils.rfc2047EncodeParam(this._bodyAttachment.name);
+      encodedFileName = MsgUtils.rfc2231ParamFolding(
+        "filename",
+        this._bodyAttachment.name
+      );
+    }
+    this._charset = this._contentType.startsWith("text/")
+      ? MailStringUtils.detectCharset(content)
+      : "";
+
+    let contentTypeParams = "";
+    if (this._charset) {
+      contentTypeParams += `; charset=${this._charset}`;
+    }
+    if (encodedName && parmFolding != 2) {
+      contentTypeParams += `; name="${encodedName}"`;
+    }
+    this.setHeader("content-type", `${this._contentType}${contentTypeParams}`);
+    if (encodedFileName) {
+      this.setHeader(
+        "content-disposition",
+        `${this._contentDisposition}; ${encodedFileName}`
+      );
+    }
+    if (this._contentId) {
+      this.setHeader("content-id", `<${this._contentId}>`);
+    }
+    if (this._contentType == "text/html") {
+      let contentLocation = MsgUtils.getContentLocation(
+        this._bodyAttachment.url
+      );
+      this.setHeader("content-location", contentLocation);
+    } else if (this._contentType == "application/pgp-keys") {
+      this.setHeader("content-description", "OpenPGP public key");
+    }
+
+    return content;
+  }
+}
+
+/**
+ * A class to represent a multipart/* part inside a RFC2045 message.
+ */
+class MimeMultiPart extends MimePart {
+  /**
+   * @param {string} subtype - The multipart subtype, e.g. "alternative" or "mixed".
+   */
+  constructor(subtype) {
+    super();
+    this.subtype = subtype;
+    this._separator = this._makePartSeparator();
+    this.setHeader(
+      "content-type",
+      `multipart/${subtype}; boundary="${this._separator}"`
+    );
+  }
+
+  /**
+   * Use 12 hyphen characters and 24 random base64 characters as separator.
+   */
+  _makePartSeparator() {
+    return "------------" + MsgUtils.randomString(24);
+  }
+}
diff --git a/comm/mailnews/compose/src/SMTPProtocolHandler.jsm b/comm/mailnews/compose/src/SMTPProtocolHandler.jsm
new file mode 100644
index 0000000000..d139e15784
--- /dev/null
+++ b/comm/mailnews/compose/src/SMTPProtocolHandler.jsm
@@ -0,0 +1,39 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var EXPORTED_SYMBOLS = ["SMTPProtocolHandler", "SMTPSProtocolHandler"];
+
+/**
+ * @implements {nsIProtocolHandler}
+ */
+class SMTPProtocolHandler {
+  QueryInterface = ChromeUtils.generateQI(["nsIProtocolHandler"]);
+
+  scheme = "smtp";
+
+  newChannel(aURI, aLoadInfo) {
+    throw Components.Exception(
+      `${this.constructor.name}.newChannel not implemented`,
+      Cr.NS_ERROR_NOT_IMPLEMENTED
+    );
+  }
+
+  allowPort(port, scheme) {
+    return port == Ci.nsISmtpUrl.DEFAULT_SMTP_PORT;
+  }
+}
+SMTPProtocolHandler.prototype.classID = Components.ID(
+  "{b14c2b67-8680-4c11-8d63-9403c7d4f757}"
+);
+
+class SMTPSProtocolHandler extends SMTPProtocolHandler {
+  scheme = "smtps";
+
+  allowPort(port, scheme) {
+    return port == Ci.nsISmtpUrl.DEFAULT_SMTPS_PORT;
+  }
+}
+SMTPSProtocolHandler.prototype.classID = Components.ID(
+  "{057d0997-9e3a-411e-b4ee-2602f53fe05f}"
+);
diff --git a/comm/mailnews/compose/src/SmtpClient.jsm b/comm/mailnews/compose/src/SmtpClient.jsm
new file mode 100644
index 0000000000..2eb13985e3
--- /dev/null
+++ b/comm/mailnews/compose/src/SmtpClient.jsm
@@ -0,0 +1,1344 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Based on https://github.com/emailjs/emailjs-smtp-client
+ *
+ * Copyright (c) 2013 Andris Reinman
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+const EXPORTED_SYMBOLS = ["SmtpClient"];
+
+var { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+var { setTimeout } = ChromeUtils.importESModule(
+  "resource://gre/modules/Timer.sys.mjs"
+);
+var { MailStringUtils } = ChromeUtils.import(
+  "resource:///modules/MailStringUtils.jsm"
+);
+var { SmtpAuthenticator } = ChromeUtils.import(
+  "resource:///modules/MailAuthenticator.jsm"
+);
+var { MsgUtils } = ChromeUtils.import(
+  "resource:///modules/MimeMessageUtils.jsm"
+);
+
+class SmtpClient {
+  /**
+   * The number of RCPT TO commands sent on the connection by this client.
+   * This can count-up over multiple messages.
+   */
+  rcptCount = 0;
+
+  /**
+   * Set true only when doing a retry.
+   */
+  isRetry = false;
+
+  /**
+   * Creates a connection object to a SMTP server and allows to send mail through it.
+   * Call `connect` method to inititate the actual connection, the constructor only
+   * defines the properties but does not actually connect.
+   *
+   * @class
+   *
+   * @param {nsISmtpServer} server - The associated nsISmtpServer instance.
+   */
+  constructor(server) {
+    this.options = {
+      alwaysSTARTTLS:
+        server.socketType == Ci.nsMsgSocketType.trySTARTTLS ||
+        server.socketType == Ci.nsMsgSocketType.alwaysSTARTTLS,
+      requireTLS: server.socketType == Ci.nsMsgSocketType.SSL,
+    };
+
+    this.socket = false; // Downstream TCP socket to the SMTP server, created with TCPSocket
+    this.waitDrain = false; // Keeps track if the downstream socket is currently full and a drain event should be waited for or not
+
+    // Private properties
+
+    this._server = server;
+    this._authenticator = new SmtpAuthenticator(server);
+    this._authenticating = false;
+    // A list of auth methods detected from the EHLO response.
+    this._supportedAuthMethods = [];
+    // A list of auth methods that worth a try.
+    this._possibleAuthMethods = [];
+    // Auth method set by user preference.
+    this._preferredAuthMethods =
+      {
+        [Ci.nsMsgAuthMethod.passwordCleartext]: ["PLAIN", "LOGIN"],
+        [Ci.nsMsgAuthMethod.passwordEncrypted]: ["CRAM-MD5"],
+        [Ci.nsMsgAuthMethod.GSSAPI]: ["GSSAPI"],
+        [Ci.nsMsgAuthMethod.NTLM]: ["NTLM"],
+        [Ci.nsMsgAuthMethod.OAuth2]: ["XOAUTH2"],
+        [Ci.nsMsgAuthMethod.secure]: ["CRAM-MD5", "XOAUTH2"],
+      }[server.authMethod] || [];
+    // The next auth method to try if the current failed.
+    this._nextAuthMethod = null;
+
+    // A list of capabilities detected from the EHLO response.
+    this._capabilities = [];
+
+    this._dataMode = false; // If true, accepts data from the upstream to be passed directly to the downstream socket. Used after the DATA command
+    this._lastDataBytes = ""; // Keep track of the last bytes to see how the terminating dot should be placed
+    this._envelope = null; // Envelope object for tracking who is sending mail to whom
+    this._currentAction = null; // Stores the function that should be run after a response has been received from the server
+
+    this._parseBlock = { data: [], statusCode: null };
+    this._parseRemainder = ""; // If the complete line is not received yet, contains the beginning of it
+
+    this.logger = MsgUtils.smtpLogger;
+
+    // Event placeholders
+    this.onerror = (e, failedSecInfo) => {}; // Will be run when an error occurs. The `onclose` event will fire subsequently.
+    this.ondrain = () => {}; // More data can be buffered in the socket.
+    this.onclose = () => {}; // The connection to the server has been closed
+    this.onidle = () => {}; // The connection is established and idle, you can send mail now
+    this.onready = failedRecipients => {}; // Waiting for mail body, lists addresses that were not accepted as recipients
+    this.ondone = success => {}; // The mail has been sent. Wait for `onidle` next. Indicates if the message was queued by the server.
+    // Callback when this client is ready to be reused.
+    this.onFree = () => {};
+  }
+
+  /**
+   * Initiate a connection to the server
+   */
+  connect() {
+    if (this.socket?.readyState == "open") {
+      this.logger.debug("Reusing a connection");
+      this.onidle();
+    } else {
+      let hostname = this._server.hostname.toLowerCase();
+      let port = this._server.port || (this.options.requireTLS ? 465 : 587);
+      this.logger.debug(`Connecting to smtp://${hostname}:${port}`);
+      this._secureTransport = this.options.requireTLS;
+      this.socket = new TCPSocket(hostname, port, {
+        binaryType: "arraybuffer",
+        useSecureTransport: this._secureTransport,
+      });
+
+      this.socket.onerror = this._onError;
+      this.socket.onopen = this._onOpen;
+    }
+    this._freed = false;
+  }
+
+  /**
+   * Sends QUIT
+   */
+  quit() {
+    this._authenticating = false;
+    this._freed = true;
+    this._sendCommand("QUIT");
+    this._currentAction = this.close;
+  }
+
+  /**
+   * Closes the connection to the server
+   *
+   * @param {boolean} [immediately] - Close the socket without waiting for
+   *   unsent data.
+   */
+  close(immediately) {
+    if (this.socket && this.socket.readyState === "open") {
+      if (immediately) {
+        this.logger.debug(
+          `Closing connection to ${this._server.hostname} immediately!`
+        );
+        this.socket.closeImmediately();
+      } else {
+        this.logger.debug(`Closing connection to ${this._server.hostname}...`);
+        this.socket.close();
+      }
+    } else {
+      this.logger.debug(`Connection to ${this._server.hostname} closed`);
+      this._free();
+    }
+  }
+
+  // Mail related methods
+
+  /**
+   * Initiates a new message by submitting envelope data, starting with
+   * `MAIL FROM:` command. Use after `onidle` event
+   *
+   * @param {object} envelope - The envelope object.
+   * @param {string} envelope.from - The from address.
+   * @param {string[]} envelope.to - The to addresses.
+   * @param {number} envelope.size - The file size.
+   * @param {boolean} envelope.requestDSN - Whether to request Delivery Status Notifications.
+   * @param {boolean} envelope.messageId - The message id.
+   */
+  useEnvelope(envelope) {
+    this._envelope = envelope || {};
+    this._envelope.from = [].concat(
+      this._envelope.from || "anonymous@" + this._getHelloArgument()
+    )[0];
+
+    if (!this._capabilities.includes("SMTPUTF8")) {
+      // If server doesn't support SMTPUTF8, check if addresses contain invalid
+      // characters.
+
+      let recipients = this._envelope.to;
+      this._envelope.to = [];
+
+      for (let recipient of recipients) {
+        let lastAt = null;
+        let firstInvalid = null;
+        for (let i = 0; i < recipient.length; i++) {
+          let ch = recipient[i];
+          if (ch == "@") {
+            lastAt = i;
+          } else if ((ch < " " || ch > "~") && ch != "\t") {
+            firstInvalid = i;
+            break;
+          }
+        }
+        if (!recipient || firstInvalid != null) {
+          if (!lastAt) {
+            // Invalid char found in the localpart, throw error until we implement RFC 6532.
+            this._onNsError(MsgUtils.NS_ERROR_ILLEGAL_LOCALPART, recipient);
+            return;
+          }
+          // Invalid char found in the domainpart, convert it to ACE.
+          let idnService = Cc["@mozilla.org/network/idn-service;1"].getService(
+            Ci.nsIIDNService
+          );
+          let domain = idnService.convertUTF8toACE(recipient.slice(lastAt + 1));
+          recipient = `${recipient.slice(0, lastAt)}@${domain}`;
+        }
+        this._envelope.to.push(recipient);
+      }
+    }
+
+    // clone the recipients array for latter manipulation
+    this._envelope.rcptQueue = [...new Set(this._envelope.to)];
+    this._envelope.rcptFailed = [];
+    this._envelope.responseQueue = [];
+
+    if (!this._envelope.rcptQueue.length) {
+      this._onNsError(MsgUtils.NS_MSG_NO_RECIPIENTS);
+      return;
+    }
+
+    this._currentAction = this._actionMAIL;
+    let cmd = `MAIL FROM:<${this._envelope.from}>`;
+    if (
+      this._capabilities.includes("8BITMIME") &&
+      !Services.prefs.getBoolPref("mail.strictly_mime", false)
+    ) {
+      cmd += " BODY=8BITMIME";
+    }
+    if (this._capabilities.includes("SMTPUTF8")) {
+      // Should not send SMTPUTF8 if all ascii, see RFC6531.
+      // eslint-disable-next-line no-control-regex
+      let ascii = /^[\x00-\x7F]+$/;
+      if ([envelope.from, ...envelope.to].some(x => !ascii.test(x))) {
+        cmd += " SMTPUTF8";
+      }
+    }
+    if (this._capabilities.includes("SIZE")) {
+      cmd += ` SIZE=${this._envelope.size}`;
+    }
+    if (this._capabilities.includes("DSN") && this._envelope.requestDSN) {
+      let ret = Services.prefs.getBoolPref("mail.dsn.ret_full_on")
+        ? "FULL"
+        : "HDRS";
+      cmd += ` RET=${ret} ENVID=${envelope.messageId}`;
+    }
+    this._sendCommand(cmd);
+  }
+
+  /**
+   * Send ASCII data to the server. Works only in data mode (after `onready` event), ignored
+   * otherwise
+   *
+   * @param {string} chunk ASCII string (quoted-printable, base64 etc.) to be sent to the server
+   * @returns {boolean} If true, it is safe to send more data, if false, you *should* wait for the ondrain event before sending more
+   */
+  send(chunk) {
+    // works only in data mode
+    if (!this._dataMode) {
+      // this line should never be reached but if it does,
+      // act like everything's normal.
+      return true;
+    }
+
+    // TODO: if the chunk is an arraybuffer, use a separate function to send the data
+    return this._sendString(chunk);
+  }
+
+  /**
+   * Indicates that a data stream for the socket is ended. Works only in data
+   * mode (after `onready` event), ignored otherwise. Use it when you are done
+   * with sending the mail. This method does not close the socket. Once the mail
+   * has been queued by the server, `ondone` and `onidle` are emitted.
+   *
+   * @param {Buffer} [chunk] Chunk of data to be sent to the server
+   */
+  end(chunk) {
+    // works only in data mode
+    if (!this._dataMode) {
+      // this line should never be reached but if it does,
+      // act like everything's normal.
+      return true;
+    }
+
+    if (chunk && chunk.length) {
+      this.send(chunk);
+    }
+
+    // redirect output from the server to _actionStream
+    this._currentAction = this._actionStream;
+
+    // indicate that the stream has ended by sending a single dot on its own line
+    // if the client already closed the data with \r\n no need to do it again
+    if (this._lastDataBytes === "\r\n") {
+      this.waitDrain = this._send(new Uint8Array([0x2e, 0x0d, 0x0a]).buffer); // .\r\n
+    } else if (this._lastDataBytes.substr(-1) === "\r") {
+      this.waitDrain = this._send(
+        new Uint8Array([0x0a, 0x2e, 0x0d, 0x0a]).buffer
+      ); // \n.\r\n
+    } else {
+      this.waitDrain = this._send(
+        new Uint8Array([0x0d, 0x0a, 0x2e, 0x0d, 0x0a]).buffer
+      ); // \r\n.\r\n
+    }
+
+    // End data mode.
+    this._dataMode = false;
+
+    return this.waitDrain;
+  }
+
+  // PRIVATE METHODS
+
+  /**
+   * Queue some data from the server for parsing.
+   *
+   * @param {string} chunk Chunk of data received from the server
+   */
+  _parse(chunk) {
+    // Lines should always end with <CR><LF> but you never know, might be only <LF> as well
+    var lines = (this._parseRemainder + (chunk || "")).split(/\r?\n/);
+    this._parseRemainder = lines.pop(); // not sure if the line has completely arrived yet
+
+    for (let i = 0, len = lines.length; i < len; i++) {
+      if (!lines[i].trim()) {
+        // nothing to check, empty line
+        continue;
+      }
+
+      // possible input strings for the regex:
+      // 250-MULTILINE REPLY
+      // 250 LAST LINE OF REPLY
+      // 250 1.2.3 MESSAGE
+
+      const match = lines[i].match(
+        /^(\d{3})([- ])(?:(\d+\.\d+\.\d+)(?: ))?(.*)/
+      );
+
+      if (match) {
+        this._parseBlock.data.push(match[4]);
+
+        if (match[2] === "-") {
+          // this is a multiline reply
+          this._parseBlock.statusCode =
+            this._parseBlock.statusCode || Number(match[1]);
+        } else {
+          const statusCode = Number(match[1]) || 0;
+          const response = {
+            statusCode,
+            data: this._parseBlock.data.join("\n"),
+            // Success means can move to the next step. Though 3xx is not
+            // failure, we don't consider it success here.
+            success: statusCode >= 200 && statusCode < 300,
+          };
+
+          this._onCommand(response);
+          this._parseBlock = {
+            data: [],
+            statusCode: null,
+          };
+        }
+      } else {
+        this._onCommand({
+          success: false,
+          statusCode: this._parseBlock.statusCode || null,
+          data: [lines[i]].join("\n"),
+        });
+        this._parseBlock = {
+          data: [],
+          statusCode: null,
+        };
+      }
+    }
+  }
+
+  // EVENT HANDLERS FOR THE SOCKET
+
+  /**
+   * Connection listener that is run when the connection to the server is opened.
+   * Sets up different event handlers for the opened socket
+   */
+  _onOpen = () => {
+    this.logger.debug("Connected");
+
+    this.socket.ondata = this._onData;
+    this.socket.onclose = this._onClose;
+    this.socket.ondrain = this._onDrain;
+
+    this._currentAction = this._actionGreeting;
+    this.socket.transport.setTimeout(
+      Ci.nsISocketTransport.TIMEOUT_READ_WRITE,
+      Services.prefs.getIntPref("mailnews.tcptimeout")
+    );
+  };
+
+  /**
+   * Data listener for chunks of data emitted by the server
+   *
+   * @param {Event} evt - Event object. See `evt.data` for the chunk received
+   */
+  _onData = async evt => {
+    let stringPayload = new TextDecoder("UTF-8").decode(
+      new Uint8Array(evt.data)
+    );
+    // "S: " to denote that this is data from the Server.
+    this.logger.debug(`S: ${stringPayload}`);
+
+    // Prevent blocking the main thread, otherwise onclose/onerror may not be
+    // called in time. test_smtpPasswordFailure3 is such a case, the server
+    // rejects AUTH PLAIN then closes the connection, the client then sends AUTH
+    // LOGIN. This line guarantees onclose is called before sending AUTH LOGIN.
+    await new Promise(resolve => setTimeout(resolve));
+    this._parse(stringPayload);
+  };
+
+  /**
+   * More data can be buffered in the socket, `waitDrain` is reset to false
+   */
+  _onDrain = () => {
+    this.waitDrain = false;
+    this.ondrain();
+  };
+
+  /**
+   * Error handler. Emits an nsresult value.
+   *
+   * @param {Error|TCPSocketErrorEvent} event - An Error or TCPSocketErrorEvent object.
+   */
+  _onError = async event => {
+    this.logger.error(`${event.name}: a ${event.message} error occurred`);
+    if (this._freed) {
+      // Ignore socket errors if already freed.
+      return;
+    }
+
+    this._free();
+    this.quit();
+
+    let nsError = Cr.NS_ERROR_FAILURE;
+    let secInfo = null;
+    if (TCPSocketErrorEvent.isInstance(event)) {
+      nsError = event.errorCode;
+      secInfo =
+        await event.target.transport?.tlsSocketControl?.asyncGetSecurityInfo();
+      if (secInfo) {
+        this.logger.error(`SecurityError info: ${secInfo.errorCodeString}`);
+        if (secInfo.failedCertChain.length) {
+          let chain = secInfo.failedCertChain.map(c => {
+            return c.commonName + "; serial# " + c.serialNumber;
+          });
+          this.logger.error(`SecurityError cert chain: ${chain.join(" <- ")}`);
+        }
+        this._server.closeCachedConnections();
+      }
+    }
+
+    // Use nsresult to integrate with other parts of sending process, e.g.
+    // MessageSend.jsm will show an error message depending on the nsresult.
+    this.onerror(nsError, "", secInfo);
+  };
+
+  /**
+   * Error handler. Emits an nsresult value.
+   *
+   * @param {nsresult} nsError - A nsresult.
+   * @param {string} errorParam - Param to form the error message.
+   * @param {string} [extra] - Some messages take two arguments to format.
+   * @param {number} [statusCode] - Only needed when checking need to retry.
+   */
+  _onNsError(nsError, errorParam, extra, statusCode) {
+    // First check if handling an error response that might need a retry.
+    if ([this._actionMAIL, this._actionRCPT].includes(this._currentAction)) {
+      if (statusCode >= 400 && statusCode < 500) {
+        // Possibly too many recipients, too many messages, to much data
+        // or too much time has elapsed on this connection.
+        if (!this.isRetry) {
+          // Now seeing error 4xx meaning that the current message can't be
+          // accepted. We close the connection and try again to send on a new
+          // connection using this same client instance. If the retry also
+          // fails on the new connection, we give up and report the error.
+          this.logger.debug("Retry send on new connection.");
+          this.quit();
+          this.isRetry = true; // flag that we will retry on new connection
+          this.close(true);
+          this.connect();
+          return; // return without reporting the error yet
+        }
+      }
+    }
+
+    let errorName = MsgUtils.getErrorStringName(nsError);
+    let errorMessage = "";
+    if (
+      [
+        MsgUtils.NS_ERROR_SMTP_SERVER_ERROR,
+        MsgUtils.NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED,
+        MsgUtils.NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2,
+        MsgUtils.NS_ERROR_SENDING_FROM_COMMAND,
+        MsgUtils.NS_ERROR_SENDING_RCPT_COMMAND,
+        MsgUtils.NS_ERROR_SENDING_DATA_COMMAND,
+        MsgUtils.NS_ERROR_SENDING_MESSAGE,
+        MsgUtils.NS_ERROR_ILLEGAL_LOCALPART,
+      ].includes(nsError)
+    ) {
+      let bundle = Services.strings.createBundle(
+        "chrome://messenger/locale/messengercompose/composeMsgs.properties"
+      );
+      if (nsError == MsgUtils.NS_ERROR_ILLEGAL_LOCALPART) {
+        errorMessage = bundle
+          .GetStringFromName(errorName)
+          .replace("%s", errorParam);
+      } else {
+        errorMessage = bundle.formatStringFromName(errorName, [
+          errorParam,
+          extra,
+        ]);
+      }
+    }
+    this.onerror(nsError, errorMessage);
+    this.close();
+  }
+
+  /**
+   * Indicates that the socket has been closed
+   */
+  _onClose = () => {
+    this.logger.debug("Socket closed.");
+    this._free();
+    this.rcptCount = 0;
+    if (this._authenticating) {
+      // In some cases, socket is closed for invalid username/password.
+      this._onAuthFailed({ data: "Socket closed." });
+    }
+  };
+
+  /**
+   * This is not a socket data handler but the handler for data emitted by the parser,
+   * so this data is safe to use as it is always complete (server might send partial chunks)
+   *
+   * @param {object} command - Parsed data.
+   */
+  _onCommand(command) {
+    if (command.statusCode < 200 || command.statusCode >= 400) {
+      // @see https://datatracker.ietf.org/doc/html/rfc5321#section-3.8
+      // 421: SMTP service shutting down and closing transmission channel.
+      // When that happens during idle, just close the connection.
+      if (
+        command.statusCode == 421 &&
+        this._currentAction == this._actionIdle
+      ) {
+        this.close(true);
+        return;
+      }
+
+      this.logger.error(
+        `Command failed: ${command.statusCode} ${command.data}; currentAction=${this._currentAction?.name}`
+      );
+    }
+    if (typeof this._currentAction === "function") {
+      this._currentAction(command);
+    }
+  }
+
+  /**
+   * This client has finished the current process and ready to be reused.
+   */
+  _free() {
+    if (!this._freed) {
+      this._freed = true;
+      this.onFree();
+    }
+  }
+
+  /**
+   * Sends a string to the socket.
+   *
+   * @param {string} chunk ASCII string (quoted-printable, base64 etc.) to be sent to the server
+   * @returns {boolean} If true, it is safe to send more data, if false, you *should* wait for the ondrain event before sending more
+   */
+  _sendString(chunk) {
+    // escape dots
+    if (!this.options.disableEscaping) {
+      chunk = chunk.replace(/\n\./g, "\n..");
+      if (
+        (this._lastDataBytes.substr(-1) === "\n" || !this._lastDataBytes) &&
+        chunk.charAt(0) === "."
+      ) {
+        chunk = "." + chunk;
+      }
+    }
+
+    // Keeping eye on the last bytes sent, to see if there is a <CR><LF> sequence
+    // at the end which is needed to end the data stream
+    if (chunk.length > 2) {
+      this._lastDataBytes = chunk.substr(-2);
+    } else if (chunk.length === 1) {
+      this._lastDataBytes = this._lastDataBytes.substr(-1) + chunk;
+    }
+
+    this.logger.debug("Sending " + chunk.length + " bytes of payload");
+
+    // pass the chunk to the socket
+    this.waitDrain = this._send(
+      MailStringUtils.byteStringToUint8Array(chunk).buffer
+    );
+    return this.waitDrain;
+  }
+
+  /**
+   * Send a string command to the server, also append CRLF if needed.
+   *
+   * @param {string} str - String to be sent to the server.
+   * @param {boolean} [suppressLogging=false] - If true and not in dev mode,
+   *   do not log the str. For non-release builds output won't be suppressed,
+   *   so that debugging auth problems is easier.
+   */
+  _sendCommand(str, suppressLogging = false) {
+    if (this.socket.readyState !== "open") {
+      if (str != "QUIT") {
+        this.logger.warn(
+          `Failed to send "${str}" because socket state is ${this.socket.readyState}`
+        );
+      }
+      return;
+    }
+    // "C: " is used to denote that this is data from the Client.
+    if (suppressLogging && AppConstants.MOZ_UPDATE_CHANNEL != "default") {
+      this.logger.debug(
+        "C: Logging suppressed (it probably contained auth information)"
+      );
+    } else {
+      this.logger.debug(`C: ${str}`);
+    }
+    this.waitDrain = this._send(
+      new TextEncoder().encode(str + (str.substr(-2) !== "\r\n" ? "\r\n" : ""))
+        .buffer
+    );
+  }
+
+  _send(buffer) {
+    return this.socket.send(buffer);
+  }
+
+  /**
+   * Intitiate authentication sequence if needed
+   *
+   * @param {boolean} forceNewPassword - Discard cached password.
+   */
+  async _authenticateUser(forceNewPassword) {
+    if (
+      this._preferredAuthMethods.length == 0 ||
+      this._supportedAuthMethods.length == 0
+    ) {
+      // no need to authenticate, at least no data given
+      this._currentAction = this._actionIdle;
+      this.onidle(); // ready to take orders
+      return;
+    }
+
+    if (!this._nextAuthMethod) {
+      this._onAuthFailed({ data: "No available auth method." });
+      return;
+    }
+
+    this._authenticating = true;
+
+    this._currentAuthMethod = this._nextAuthMethod;
+    this._nextAuthMethod =
+      this._possibleAuthMethods[
+        this._possibleAuthMethods.indexOf(this._currentAuthMethod) + 1
+      ];
+    this.logger.debug(`Current auth method: ${this._currentAuthMethod}`);
+
+    switch (this._currentAuthMethod) {
+      case "LOGIN":
+        // LOGIN is a 3 step authentication process
+        // C: AUTH LOGIN
+        // C: BASE64(USER)
+        // C: BASE64(PASS)
+        this.logger.debug("Authentication via AUTH LOGIN");
+        this._currentAction = this._actionAUTH_LOGIN_USER;
+        this._sendCommand("AUTH LOGIN");
+        return;
+      case "PLAIN":
+        // AUTH PLAIN is a 1 step authentication process
+        // C: AUTH PLAIN BASE64(\0 USER \0 PASS)
+        this.logger.debug("Authentication via AUTH PLAIN");
+        this._currentAction = this._actionAUTHComplete;
+        this._sendCommand(
+          "AUTH PLAIN " + this._authenticator.getPlainToken(),
+          true
+        );
+        return;
+      case "CRAM-MD5":
+        this.logger.debug("Authentication via AUTH CRAM-MD5");
+        this._currentAction = this._actionAUTH_CRAM;
+        this._sendCommand("AUTH CRAM-MD5");
+        return;
+      case "XOAUTH2":
+        // See https://developers.google.com/gmail/xoauth2_protocol#smtp_protocol_exchange
+        this.logger.debug("Authentication via AUTH XOAUTH2");
+        this._currentAction = this._actionAUTH_XOAUTH2;
+        let oauthToken = await this._authenticator.getOAuthToken();
+        this._sendCommand("AUTH XOAUTH2 " + oauthToken, true);
+        return;
+      case "GSSAPI": {
+        this.logger.debug("Authentication via AUTH GSSAPI");
+        this._currentAction = this._actionAUTH_GSSAPI;
+        this._authenticator.initGssapiAuth("smtp");
+        let token;
+        try {
+          token = this._authenticator.getNextGssapiToken("");
+        } catch (e) {
+          this.logger.error(e);
+          this._actionAUTHComplete({ success: false, data: "AUTH GSSAPI" });
+          return;
+        }
+        this._sendCommand(`AUTH GSSAPI ${token}`, true);
+        return;
+      }
+      case "NTLM": {
+        this.logger.debug("Authentication via AUTH NTLM");
+        this._currentAction = this._actionAUTH_NTLM;
+        this._authenticator.initNtlmAuth("smtp");
+        let token;
+        try {
+          token = this._authenticator.getNextNtlmToken("");
+        } catch (e) {
+          this.logger.error(e);
+          this._actionAUTHComplete({ success: false, data: "AUTH NTLM" });
+          return;
+        }
+        this._sendCommand(`AUTH NTLM ${token}`, true);
+        return;
+      }
+    }
+
+    this._onAuthFailed({
+      data: `Unknown authentication method ${this._currentAuthMethod}`,
+    });
+  }
+
+  _onAuthFailed(command) {
+    this.logger.error(`Authentication failed: ${command.data}`);
+    if (!this._freed) {
+      if (this._nextAuthMethod) {
+        // Try the next auth method.
+        this._authenticateUser();
+        return;
+      } else if (!this._currentAuthMethod) {
+        // No auth method was even tried.
+        let err;
+        if (
+          this._server.authMethod == Ci.nsMsgAuthMethod.passwordEncrypted &&
+          (this._supportedAuthMethods.includes("PLAIN") ||
+            this._supportedAuthMethods.includes("LOGIN"))
+        ) {
+          // Pref has encrypted password, server claims to support plaintext
+          // password.
+          err = [
+            Ci.nsMsgSocketType.alwaysSTARTTLS,
+            Ci.nsMsgSocketType.SSL,
+          ].includes(this._server.socketType)
+            ? MsgUtils.NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL
+            : MsgUtils.NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL;
+        } else if (
+          this._server.authMethod == Ci.nsMsgAuthMethod.passwordCleartext &&
+          this._supportedAuthMethods.includes("CRAM-MD5")
+        ) {
+          // Pref has plaintext password, server claims to support encrypted
+          // password.
+          err = MsgUtils.NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT;
+        } else {
+          err = MsgUtils.NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED;
+        }
+        this._onNsError(err);
+        return;
+      }
+    }
+
+    // Ask user what to do.
+    let action = this._authenticator.promptAuthFailed();
+    if (action == 1) {
+      // Cancel button pressed.
+      this.logger.error(`Authentication failed: ${command.data}`);
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_AUTH_FAILURE);
+      return;
+    } else if (action == 2) {
+      // 'New password' button pressed. Forget cached password, new password
+      // will be asked.
+      this._authenticator.forgetPassword();
+    }
+
+    if (this._freed) {
+      // If connection is lost, reconnect.
+      this.connect();
+      return;
+    }
+
+    // Reset _nextAuthMethod to start again.
+    this._nextAuthMethod = this._possibleAuthMethods[0];
+    if (action == 2 || action == 0) {
+      // action = 0 means retry button pressed.
+      this._authenticateUser();
+    }
+  }
+
+  _getHelloArgument() {
+    let helloArgument = this._server.helloArgument;
+    if (helloArgument) {
+      return helloArgument;
+    }
+
+    try {
+      // The address format follows rfc5321#section-4.1.3.
+      let netAddr = this.socket?.transport.getScriptableSelfAddr();
+      let address = netAddr.address;
+      if (netAddr.family === Ci.nsINetAddr.FAMILY_INET6) {
+        return `[IPV6:${address}]`;
+      }
+      return `[${address}]`;
+    } catch (e) {}
+
+    return "[127.0.0.1]";
+  }
+
+  // ACTIONS FOR RESPONSES FROM THE SMTP SERVER
+
+  /**
+   * Initial response from the server, must have a status 220
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionGreeting(command) {
+    if (command.statusCode !== 220) {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_SERVER_ERROR, command.data);
+      return;
+    }
+
+    if (this.options.lmtp) {
+      this._currentAction = this._actionLHLO;
+      this._sendCommand("LHLO " + this._getHelloArgument());
+    } else {
+      this._currentAction = this._actionEHLO;
+      this._sendCommand("EHLO " + this._getHelloArgument());
+    }
+  }
+
+  /**
+   * Response to LHLO
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionLHLO(command) {
+    if (!command.success) {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_SERVER_ERROR, command.data);
+      return;
+    }
+
+    // Process as EHLO response
+    this._actionEHLO(command);
+  }
+
+  /**
+   * Response to EHLO. If the response is an error, try HELO instead
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionEHLO(command) {
+    if ([500, 502].includes(command.statusCode)) {
+      // EHLO is not implemented by the server.
+      if (this.options.alwaysSTARTTLS) {
+        // If alwaysSTARTTLS is set by the user, EHLO is required to advertise it.
+        this._onNsError(MsgUtils.NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS);
+        return;
+      }
+
+      // Try HELO instead
+      this.logger.warn(
+        "EHLO not successful, trying HELO " + this._getHelloArgument()
+      );
+      this._currentAction = this._actionHELO;
+      this._sendCommand("HELO " + this._getHelloArgument());
+      return;
+    } else if (!command.success) {
+      // 501 Syntax error or some other error.
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_SERVER_ERROR, command.data);
+      return;
+    }
+
+    this._supportedAuthMethods = [];
+
+    let lines = command.data.toUpperCase().split("\n");
+    // Skip the first greeting line.
+    for (let line of lines.slice(1)) {
+      if (line.startsWith("AUTH ")) {
+        this._supportedAuthMethods = line.slice(5).split(" ");
+      } else {
+        this._capabilities.push(line.split(" ")[0]);
+      }
+    }
+
+    if (!this._secureTransport && this.options.alwaysSTARTTLS) {
+      // STARTTLS is required by the user. Detect if the server supports it.
+      if (this._capabilities.includes("STARTTLS")) {
+        this._currentAction = this._actionSTARTTLS;
+        this._sendCommand("STARTTLS");
+        return;
+      }
+      // STARTTLS is required but not advertised.
+      this._onNsError(MsgUtils.NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS);
+      return;
+    }
+
+    // If a preferred method is not supported by the server, no need to try it.
+    this._possibleAuthMethods = this._preferredAuthMethods.filter(x =>
+      this._supportedAuthMethods.includes(x)
+    );
+    this.logger.debug(`Possible auth methods: ${this._possibleAuthMethods}`);
+    this._nextAuthMethod = this._possibleAuthMethods[0];
+
+    if (
+      this._capabilities.includes("CLIENTID") &&
+      (this._secureTransport ||
+        // For test purpose.
+        ["localhost", "127.0.0.1", "::1"].includes(this._server.hostname)) &&
+      this._server.clientidEnabled &&
+      this._server.clientid
+    ) {
+      // Client identity extension, still a draft.
+      this._currentAction = this._actionCLIENTID;
+      this._sendCommand("CLIENTID UUID " + this._server.clientid, true);
+    } else {
+      this._authenticateUser();
+    }
+  }
+
+  /**
+   * Handles server response for STARTTLS command. If there's an error
+   * try HELO instead, otherwise initiate TLS upgrade. If the upgrade
+   * succeeds restart the EHLO
+   *
+   * @param {string} command - Message from the server.
+   */
+  _actionSTARTTLS(command) {
+    if (!command.success) {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_SERVER_ERROR, command.data);
+      return;
+    }
+
+    this.socket.upgradeToSecure();
+    this._secureTransport = true;
+
+    // restart protocol flow
+    this._currentAction = this._actionEHLO;
+    this._sendCommand("EHLO " + this._getHelloArgument());
+  }
+
+  /**
+   * Response to HELO
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionHELO(command) {
+    if (!command.success) {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_SERVER_ERROR, command.data);
+      return;
+    }
+    this._authenticateUser();
+  }
+
+  /**
+   * Handles server response for CLIENTID command. If successful then will
+   * initiate the authenticateUser process.
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionCLIENTID(command) {
+    if (!command.success) {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_SERVER_ERROR, command.data);
+      return;
+    }
+    this._authenticateUser();
+  }
+
+  /**
+   * Returns the saved/cached server password, or show a password dialog. If the
+   * user cancels the dialog, abort sending.
+   *
+   * @returns {string} The server password.
+   */
+  _getPassword() {
+    try {
+      return this._authenticator.getPassword();
+    } catch (e) {
+      if (e.result == Cr.NS_ERROR_ABORT) {
+        this.quit();
+        this.onerror(e.result);
+      } else {
+        throw e;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Response to AUTH LOGIN, if successful expects base64 encoded username
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionAUTH_LOGIN_USER(command) {
+    if (command.statusCode !== 334 || command.data !== "VXNlcm5hbWU6") {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_AUTH_FAILURE, command.data);
+      return;
+    }
+    this.logger.debug("AUTH LOGIN USER");
+    this._currentAction = this._actionAUTH_LOGIN_PASS;
+    this._sendCommand(btoa(this._authenticator.username), true);
+  }
+
+  /**
+   * Process the response to AUTH LOGIN with a username. If successful, expects
+   * a base64-encoded password.
+   *
+   * @param {{statusCode: number, data: string}} command - Parsed command from
+   *   the server.
+   */
+  _actionAUTH_LOGIN_PASS(command) {
+    if (
+      command.statusCode !== 334 ||
+      (command.data !== btoa("Password:") && command.data !== btoa("password:"))
+    ) {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_AUTH_FAILURE, command.data);
+      return;
+    }
+    this.logger.debug("AUTH LOGIN PASS");
+    this._currentAction = this._actionAUTHComplete;
+    let password = this._getPassword();
+    if (
+      !Services.prefs.getBoolPref(
+        "mail.smtp_login_pop3_user_pass_auth_is_latin1",
+        true
+      ) ||
+      !/^[\x00-\xFF]+$/.test(password) // eslint-disable-line no-control-regex
+    ) {
+      // Unlike PLAIN auth, the payload of LOGIN auth is not standardized. When
+      // `mail.smtp_login_pop3_user_pass_auth_is_latin1` is true, we apply
+      // base64 encoding directly. Otherwise, we convert it to UTF-8
+      // BinaryString first.
+      password = MailStringUtils.stringToByteString(password);
+    }
+    this._sendCommand(btoa(password), true);
+  }
+
+  /**
+   * Response to AUTH CRAM, if successful expects base64 encoded challenge.
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  async _actionAUTH_CRAM(command) {
+    if (command.statusCode !== 334) {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_AUTH_FAILURE, command.data);
+      return;
+    }
+    this._currentAction = this._actionAUTHComplete;
+    this._sendCommand(
+      this._authenticator.getCramMd5Token(this._getPassword(), command.data),
+      true
+    );
+  }
+
+  /**
+   * Response to AUTH XOAUTH2 token, if error occurs send empty response
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionAUTH_XOAUTH2(command) {
+    if (!command.success) {
+      this.logger.warn("Error during AUTH XOAUTH2, sending empty response");
+      this._sendCommand("");
+      this._currentAction = this._actionAUTHComplete;
+    } else {
+      this._actionAUTHComplete(command);
+    }
+  }
+
+  /**
+   * Response to AUTH GSSAPI, if successful expects a base64 encoded challenge.
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionAUTH_GSSAPI(command) {
+    // GSSAPI auth can be multiple steps. We exchange tokens with the server
+    // until success or failure.
+    if (command.success) {
+      this._actionAUTHComplete(command);
+      return;
+    }
+    if (command.statusCode !== 334) {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_AUTH_GSSAPI, command.data);
+      return;
+    }
+    let token = this._authenticator.getNextGssapiToken(command.data);
+    this._currentAction = this._actionAUTH_GSSAPI;
+    this._sendCommand(token, true);
+  }
+
+  /**
+   * Response to AUTH NTLM, if successful expects a base64 encoded challenge.
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionAUTH_NTLM(command) {
+    // NTLM auth can be multiple steps. We exchange tokens with the server
+    // until success or failure.
+    if (command.success) {
+      this._actionAUTHComplete(command);
+      return;
+    }
+    if (command.statusCode !== 334) {
+      this._onNsError(MsgUtils.NS_ERROR_SMTP_AUTH_FAILURE, command.data);
+      return;
+    }
+    let token = this._authenticator.getNextNtlmToken(command.data);
+    this._currentAction = this._actionAUTH_NTLM;
+    this._sendCommand(token, true);
+  }
+
+  /**
+   * Checks if authentication succeeded or not. If successfully authenticated
+   * emit `idle` to indicate that an e-mail can be sent using this connection
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionAUTHComplete(command) {
+    this._authenticating = false;
+    if (!command.success) {
+      this._onAuthFailed(command);
+      return;
+    }
+
+    this.logger.debug("Authentication successful.");
+
+    this._currentAction = this._actionIdle;
+    this.onidle(); // ready to take orders
+  }
+
+  /**
+   * Used when the connection is idle, not expecting anything from the server.
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionIdle(command) {
+    this._onNsError(MsgUtils.NS_ERROR_SMTP_SERVER_ERROR, command.data);
+  }
+
+  /**
+   * Response to MAIL FROM command. Proceed to defining RCPT TO list if successful
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionMAIL(command) {
+    if (!command.success) {
+      let errorCode = MsgUtils.NS_ERROR_SENDING_FROM_COMMAND; // default code
+      if (command.statusCode == 552) {
+        // Too much mail data indicated by "size" parameter of MAIL FROM.
+        // @see https://datatracker.ietf.org/doc/html/rfc5321#section-4.5.3.1.9
+        errorCode = MsgUtils.NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2;
+      }
+      if (command.statusCode == 452 || command.statusCode == 451) {
+        // @see https://datatracker.ietf.org/doc/html/rfc5321#section-4.5.3.1.10
+        errorCode = MsgUtils.NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED;
+      }
+      this._onNsError(errorCode, command.data, null, command.statusCode);
+      return;
+    }
+    this.logger.debug(
+      "MAIL FROM successful, proceeding with " +
+        this._envelope.rcptQueue.length +
+        " recipients"
+    );
+    this.logger.debug("Adding recipient...");
+    this._envelope.curRecipient = this._envelope.rcptQueue.shift();
+    this._currentAction = this._actionRCPT;
+    this._sendCommand(
+      `RCPT TO:<${this._envelope.curRecipient}>${this._getRCPTParameters()}`
+    );
+  }
+
+  /**
+   * Prepare the RCPT params, currently only DSN params. If the server supports
+   * DSN and sender requested DSN, append DSN params to each RCPT TO command.
+   */
+  _getRCPTParameters() {
+    if (this._capabilities.includes("DSN") && this._envelope.requestDSN) {
+      let notify = [];
+      if (Services.prefs.getBoolPref("mail.dsn.request_never_on")) {
+        notify.push("NEVER");
+      } else {
+        if (Services.prefs.getBoolPref("mail.dsn.request_on_success_on")) {
+          notify.push("SUCCESS");
+        }
+        if (Services.prefs.getBoolPref("mail.dsn.request_on_failure_on")) {
+          notify.push("FAILURE");
+        }
+        if (Services.prefs.getBoolPref("mail.dsn.request_on_delay_on")) {
+          notify.push("DELAY");
+        }
+      }
+      if (notify.length > 0) {
+        return ` NOTIFY=${notify.join(",")}`;
+      }
+    }
+    return "";
+  }
+
+  /**
+   * Response to a RCPT TO command. If the command is unsuccessful, emit an
+   * error to abort the sending.
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionRCPT(command) {
+    if (!command.success) {
+      this._onNsError(
+        MsgUtils.NS_ERROR_SENDING_RCPT_COMMAND,
+        command.data,
+        this._envelope.curRecipient,
+        command.statusCode
+      );
+      return;
+    }
+    this.rcptCount++;
+    this._envelope.responseQueue.push(this._envelope.curRecipient);
+
+    if (this._envelope.rcptQueue.length) {
+      // Send the next recipient.
+      this._envelope.curRecipient = this._envelope.rcptQueue.shift();
+      this._currentAction = this._actionRCPT;
+      this._sendCommand(
+        `RCPT TO:<${this._envelope.curRecipient}>${this._getRCPTParameters()}`
+      );
+    } else {
+      this.logger.debug(
+        `Total RCPTs during this connection: ${this.rcptCount}`
+      );
+      this.logger.debug("RCPT TO done. Proceeding with payload.");
+      this._currentAction = this._actionDATA;
+      this._sendCommand("DATA");
+    }
+  }
+
+  /**
+   * Response to the DATA command. Server is now waiting for a message, so emit `onready`
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionDATA(command) {
+    // response should be 354 but according to this issue https://github.com/eleith/emailjs/issues/24
+    // some servers might use 250 instead
+    if (![250, 354].includes(command.statusCode)) {
+      this._onNsError(MsgUtils.NS_ERROR_SENDING_DATA_COMMAND, command.data);
+      return;
+    }
+
+    this._dataMode = true;
+    this._currentAction = this._actionIdle;
+    this.onready(this._envelope.rcptFailed);
+  }
+
+  /**
+   * Response from the server, once the message stream has ended with <CR><LF>.<CR><LF>
+   * Emits `ondone`.
+   *
+   * @param {object} command Parsed command from the server {statusCode, data}
+   */
+  _actionStream(command) {
+    var rcpt;
+
+    if (this.options.lmtp) {
+      // LMTP returns a response code for *every* successfully set recipient
+      // For every recipient the message might succeed or fail individually
+
+      rcpt = this._envelope.responseQueue.shift();
+      if (!command.success) {
+        this.logger.error("Local delivery to " + rcpt + " failed.");
+        this._envelope.rcptFailed.push(rcpt);
+      } else {
+        this.logger.error("Local delivery to " + rcpt + " succeeded.");
+      }
+
+      if (this._envelope.responseQueue.length) {
+        this._currentAction = this._actionStream;
+        return;
+      }
+
+      this._currentAction = this._actionIdle;
+      this.ondone(0);
+    } else {
+      // For SMTP the message either fails or succeeds, there is no information
+      // about individual recipients
+
+      if (!command.success) {
+        this.logger.error("Message sending failed.");
+      } else {
+        this.logger.debug("Message sent successfully.");
+        this.isRetry = false;
+      }
+
+      this._currentAction = this._actionIdle;
+      if (command.success) {
+        this.ondone(0);
+      } else {
+        this._onNsError(MsgUtils.NS_ERROR_SENDING_MESSAGE, command.data);
+      }
+    }
+
+    this._freed = true;
+    this.onFree();
+  }
+}
diff --git a/comm/mailnews/compose/src/SmtpServer.jsm b/comm/mailnews/compose/src/SmtpServer.jsm
new file mode 100644
index 0000000000..3ce81ff936
--- /dev/null
+++ b/comm/mailnews/compose/src/SmtpServer.jsm
@@ -0,0 +1,519 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["SmtpServer"];
+
+const { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+const lazy = {};
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  SmtpClient: "resource:///modules/SmtpClient.jsm",
+});
+
+/**
+ * This class represents a single SMTP server.
+ *
+ * @implements {nsISmtpServer}
+ * @implements {nsIObserver}
+ */
+
+class SmtpServer {
+  QueryInterface = ChromeUtils.generateQI(["nsISmtpServer", "nsIObserver"]);
+
+  constructor() {
+    this._key = "";
+    this._loadPrefs();
+
+    Services.obs.addObserver(this, "passwordmgr-storage-changed");
+  }
+
+  /**
+   * Observe() receives notifications for all accounts, not just this SMTP
+   * server's * account. So we ignore all notifications not intended for this
+   * server. When the state of the password manager changes we need to clear the
+   * this server's password from the cache in case the user just changed or
+   * removed the password or username.
+   * OAuth2 servers often automatically change the password manager's stored
+   * password (the token).
+   */
+  observe(subject, topic, data) {
+    if (topic == "passwordmgr-storage-changed") {
+      // Check that the notification is for this server and user.
+      let otherFullName = "";
+      let otherUsername = "";
+      if (subject instanceof Ci.nsILoginInfo) {
+        // The login info for a server has been removed with aData being
+        // "removeLogin" or "removeAllLogins".
+        otherFullName = subject.origin;
+        otherUsername = subject.username;
+      } else if (subject instanceof Ci.nsIArray) {
+        // Probably a 2 element array containing old and new login info due to
+        // aData being "modifyLogin". E.g., a user has modified the password or
+        // username in the password manager or an OAuth2 token string has
+        // automatically changed. Only need to look at names in first array
+        // element (login info before any modification) since the user might
+        // have changed the username as found in the 2nd elements. (The
+        // hostname can't be modified in the password manager.
+        otherFullName = subject.queryElementAt(0, Ci.nsISupports).origin;
+        otherUsername = subject.queryElementAt(0, Ci.nsISupports).username;
+      }
+      if (otherFullName) {
+        if (
+          otherFullName != "smtp://" + this.hostname ||
+          otherUsername != this.username
+        ) {
+          // Not for this account; keep this account's password.
+          return;
+        }
+      } else if (data != "hostSavingDisabled") {
+        // "hostSavingDisabled" only occurs during test_smtpServer.js and
+        // expects the password to be removed from memory cache. Otherwise, we
+        // don't have enough information to decide to remove the cached
+        // password, so keep it.
+        return;
+      }
+      // Remove the password for this server cached in memory.
+      this.password = "";
+    }
+  }
+
+  get key() {
+    return this._key;
+  }
+
+  set key(key) {
+    this._key = key;
+    this._loadPrefs();
+  }
+
+  get UID() {
+    let uid = this._prefs.getStringPref("uid", "");
+    if (uid) {
+      return uid;
+    }
+    return (this.UID = Services.uuid
+      .generateUUID()
+      .toString()
+      .substring(1, 37));
+  }
+
+  set UID(uid) {
+    if (this._prefs.prefHasUserValue("uid")) {
+      throw new Components.Exception("uid is already set", Cr.NS_ERROR_ABORT);
+    }
+    this._prefs.setStringPref("uid", uid);
+  }
+
+  get description() {
+    return this._prefs.getStringPref("description", "");
+  }
+
+  set description(value) {
+    this._prefs.setStringPref("description", value);
+  }
+
+  get hostname() {
+    return this._prefs.getStringPref("hostname", "");
+  }
+
+  set hostname(value) {
+    if (value.toLowerCase() != this.hostname.toLowerCase()) {
+      // Reset password so that users are prompted for new password for the new
+      // host.
+      this.forgetPassword();
+    }
+    this._prefs.setStringPref("hostname", value);
+  }
+
+  get port() {
+    return this._prefs.getIntPref("port", 0);
+  }
+
+  set port(value) {
+    if (value) {
+      this._prefs.setIntPref("port", value);
+    } else {
+      this._prefs.clearUserPref("port");
+    }
+  }
+
+  get displayname() {
+    return `${this.hostname}` + (this.port ? `:${this.port}` : "");
+  }
+
+  get username() {
+    return this._prefs.getCharPref("username", "");
+  }
+
+  set username(value) {
+    if (value != this.username) {
+      // Reset password so that users are prompted for new password for the new
+      // username.
+      this.forgetPassword();
+    }
+    this._setCharPref("username", value);
+  }
+
+  get clientid() {
+    return this._getCharPrefWithDefault("clientid");
+  }
+
+  set clientid(value) {
+    this._setCharPref("clientid", value);
+  }
+
+  get clientidEnabled() {
+    try {
+      return this._prefs.getBoolPref("clientidEnabled");
+    } catch (e) {
+      return this._defaultPrefs.getBoolPref("clientidEnabled", false);
+    }
+  }
+
+  set clientidEnabled(value) {
+    this._prefs.setBoolPref("clientidEnabled", value);
+  }
+
+  get authMethod() {
+    return this._getIntPrefWithDefault("authMethod", 3);
+  }
+
+  set authMethod(value) {
+    this._prefs.setIntPref("authMethod", value);
+  }
+
+  get socketType() {
+    return this._getIntPrefWithDefault("try_ssl", 0);
+  }
+
+  set socketType(value) {
+    this._prefs.setIntPref("try_ssl", value);
+  }
+
+  get helloArgument() {
+    return this._getCharPrefWithDefault("hello_argument");
+  }
+
+  get serverURI() {
+    return this._getServerURI(true);
+  }
+
+  /**
+   * If pref max_cached_connection is set to less than 1, allow only one
+   * connection and one message to be sent on that connection. Otherwise, allow
+   * up to max_cached_connection (default to 3) with each connection allowed to
+   * send multiple messages.
+   */
+  get maximumConnectionsNumber() {
+    let maxConnections = this._getIntPrefWithDefault(
+      "max_cached_connections",
+      3
+    );
+    // Always return a value >= 0.
+    return maxConnections > 0 ? maxConnections : 0;
+  }
+
+  set maximumConnectionsNumber(value) {
+    this._prefs.setIntPref("max_cached_connections", value);
+  }
+
+  get password() {
+    if (this._password) {
+      return this._password;
+    }
+    let incomingAccountKey = this._prefs.getCharPref("incomingAccount", "");
+    let incomingServer;
+    if (incomingAccountKey) {
+      incomingServer =
+        MailServices.accounts.getIncomingServer(incomingAccountKey);
+    } else {
+      let useMatchingHostNameServer = Services.prefs.getBoolPref(
+        "mail.smtp.useMatchingHostNameServer"
+      );
+      let useMatchingDomainServer = Services.prefs.getBoolPref(
+        "mail.smtp.useMatchingDomainServer"
+      );
+      if (useMatchingHostNameServer || useMatchingDomainServer) {
+        if (useMatchingHostNameServer) {
+          // Pass in empty type and port=0, to match imap and pop3.
+          incomingServer = MailServices.accounts.findServer(
+            this.username,
+            this.hostname,
+            "",
+            0
+          );
+        }
+        if (
+          !incomingServer &&
+          useMatchingDomainServer &&
+          this.hostname.includes(".")
+        ) {
+          let newHostname = this.hostname.slice(0, this.hostname.indexOf("."));
+          for (let server of MailServices.accounts.allServers) {
+            if (server.username == this.username) {
+              let serverHostName = server.hostName;
+              if (
+                serverHostName.includes(".") &&
+                serverHostName.slice(0, serverHostName.indexOf(".")) ==
+                  newHostname
+              ) {
+                incomingServer = server;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+    return incomingServer?.password || "";
+  }
+
+  set password(password) {
+    this._password = password;
+  }
+
+  getPasswordWithUI(promptMessage, promptTitle) {
+    let authPrompt;
+    try {
+      // This prompt has a checkbox for saving password.
+      authPrompt = Cc["@mozilla.org/messenger/msgAuthPrompt;1"].getService(
+        Ci.nsIAuthPrompt
+      );
+    } catch (e) {
+      // Often happens in tests. This prompt has no checkbox for saving password.
+      authPrompt = Services.ww.getNewAuthPrompter(null);
+    }
+    let password = this._getPasswordWithoutUI();
+    if (password) {
+      this.password = password;
+      return this.password;
+    }
+    let outUsername = {};
+    let outPassword = {};
+    let ok;
+    if (this.username) {
+      ok = authPrompt.promptPassword(
+        promptTitle,
+        promptMessage,
+        this.serverURI,
+        Ci.nsIAuthPrompt.SAVE_PASSWORD_PERMANENTLY,
+        outPassword
+      );
+    } else {
+      ok = authPrompt.promptUsernameAndPassword(
+        promptTitle,
+        promptMessage,
+        this.serverURI,
+        Ci.nsIAuthPrompt.SAVE_PASSWORD_PERMANENTLY,
+        outUsername,
+        outPassword
+      );
+    }
+    if (ok) {
+      if (outUsername.value) {
+        this.username = outUsername.value;
+      }
+      this.password = outPassword.value;
+    } else {
+      throw Components.Exception("Password dialog canceled", Cr.NS_ERROR_ABORT);
+    }
+    return this.password;
+  }
+
+  forgetPassword() {
+    let serverURI = this._getServerURI();
+    let logins = Services.logins.findLogins(serverURI, "", serverURI);
+    for (let login of logins) {
+      if (login.username == this.username) {
+        Services.logins.removeLogin(login);
+      }
+    }
+    this.password = "";
+  }
+
+  verifyLogon(urlListener, msgWindow) {
+    return MailServices.smtp.verifyLogon(this, urlListener, msgWindow);
+  }
+
+  clearAllValues() {
+    for (let prefName of this._prefs.getChildList("")) {
+      this._prefs.clearUserPref(prefName);
+    }
+  }
+
+  /**
+   * @returns {string}
+   */
+  _getPasswordWithoutUI() {
+    let serverURI = this._getServerURI();
+    let logins = Services.logins.findLogins(serverURI, "", serverURI);
+    for (let login of logins) {
+      if (login.username == this.username) {
+        return login.password;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get server URI in the form of smtp://[user@]hostname.
+   *
+   * @param {boolean} includeUsername - Whether to include the username.
+   * @returns {string}
+   */
+  _getServerURI(includeUsername) {
+    // When constructing nsIURI, need to wrap IPv6 address in [].
+    let hostname = this.hostname.includes(":")
+      ? `[${this.hostname}]`
+      : this.hostname;
+    return (
+      "smtp://" +
+      (includeUsername && this.username
+        ? `${encodeURIComponent(this.username)}@`
+        : "") +
+      hostname
+    );
+  }
+
+  /**
+   * Get the associated pref branch and the default SMTP server branch.
+   */
+  _loadPrefs() {
+    this._prefs = Services.prefs.getBranch(`mail.smtpserver.${this._key}.`);
+    this._defaultPrefs = Services.prefs.getBranch("mail.smtpserver.default.");
+  }
+
+  /**
+   * Set or clear a string preference.
+   *
+   * @param {string} name - The preference name.
+   * @param {string} value - The preference value.
+   */
+  _setCharPref(name, value) {
+    if (value) {
+      this._prefs.setCharPref(name, value);
+    } else {
+      this._prefs.clearUserPref(name);
+    }
+  }
+
+  /**
+   * Get the value of a char preference from this or default SMTP server.
+   *
+   * @param {string} name - The preference name.
+   * @param {number} [defaultValue=""] - The default value to return.
+   * @returns {string}
+   */
+  _getCharPrefWithDefault(name, defaultValue = "") {
+    try {
+      return this._prefs.getCharPref(name);
+    } catch (e) {
+      return this._defaultPrefs.getCharPref(name, defaultValue);
+    }
+  }
+
+  /**
+   * Get the value of an integer preference from this or default SMTP server.
+   *
+   * @param {string} name - The preference name.
+   * @param {number} defaultValue - The default value to return.
+   * @returns {number}
+   */
+  _getIntPrefWithDefault(name, defaultValue) {
+    try {
+      return this._prefs.getIntPref(name);
+    } catch (e) {
+      return this._defaultPrefs.getIntPref(name, defaultValue);
+    }
+  }
+
+  get wrappedJSObject() {
+    return this;
+  }
+
+  // @type {SmtpClient[]} - An array of connections can be used.
+  _freeConnections = [];
+  // @type {SmtpClient[]} - An array of connections in use.
+  _busyConnections = [];
+  // @type {Function[]} - An array of Promise.resolve functions.
+  _connectionWaitingQueue = [];
+
+  closeCachedConnections() {
+    // Close all connections.
+    for (let client of [...this._freeConnections, ...this._busyConnections]) {
+      client.quit();
+    }
+    // Cancel all waitings in queue.
+    for (let resolve of this._connectionWaitingQueue) {
+      resolve(false);
+    }
+    this._freeConnections = [];
+    this._busyConnections = [];
+  }
+
+  /**
+   * Get an idle connection that can be used.
+   *
+   * @returns {SmtpClient}
+   */
+  async _getNextClient() {
+    // The newest connection is the least likely to have timed out.
+    let client = this._freeConnections.pop();
+    if (client) {
+      this._busyConnections.push(client);
+      return client;
+    }
+    const maxConns = this.maximumConnectionsNumber
+      ? this.maximumConnectionsNumber
+      : 1;
+    if (
+      this._freeConnections.length + this._busyConnections.length <
+      maxConns
+    ) {
+      // Create a new client if the pool is not full.
+      client = new lazy.SmtpClient(this);
+      this._busyConnections.push(client);
+      return client;
+    }
+    // Wait until a connection is available.
+    await new Promise(resolve => this._connectionWaitingQueue.push(resolve));
+    return this._getNextClient();
+  }
+  /**
+   * Do some actions with a connection.
+   *
+   * @param {Function} handler - A callback function to take a SmtpClient
+   *   instance, and do some actions.
+   */
+  async withClient(handler) {
+    let client = await this._getNextClient();
+    client.onFree = () => {
+      this._busyConnections = this._busyConnections.filter(c => c != client);
+      // Per RFC, the minimum total number of recipients that MUST be buffered
+      // is 100 recipients.
+      // @see https://datatracker.ietf.org/doc/html/rfc5321#section-4.5.3.1.8
+      // So use a new connection for the next message to avoid running into
+      // recipient limits.
+      // If user has set SMTP pref max_cached_connection to less than 1,
+      // use a new connection for each message.
+      if (this.maximumConnectionsNumber == 0 || client.rcptCount > 99) {
+        // Send QUIT, server will then terminate the connection
+        client.quit();
+      } else {
+        // Keep using this connection
+        this._freeConnections.push(client);
+        // Resolve the first waiting in queue.
+        this._connectionWaitingQueue.shift()?.();
+      }
+    };
+    handler(client);
+    client.connect();
+  }
+}
diff --git a/comm/mailnews/compose/src/SmtpService.jsm b/comm/mailnews/compose/src/SmtpService.jsm
new file mode 100644
index 0000000000..d90983a213
--- /dev/null
+++ b/comm/mailnews/compose/src/SmtpService.jsm
@@ -0,0 +1,350 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["SmtpService"];
+
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+const { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+const lazy = {};
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  SmtpClient: "resource:///modules/SmtpClient.jsm",
+  MsgUtils: "resource:///modules/MimeMessageUtils.jsm",
+});
+
+/**
+ * The SMTP service.
+ *
+ * @implements {nsISmtpService}
+ */
+class SmtpService {
+  QueryInterface = ChromeUtils.generateQI(["nsISmtpService"]);
+
+  constructor() {
+    this._servers = [];
+    this._logger = lazy.MsgUtils.smtpLogger;
+  }
+
+  /**
+   * @see nsISmtpService
+   */
+  get defaultServer() {
+    let defaultServerKey = Services.prefs.getCharPref(
+      "mail.smtp.defaultserver",
+      ""
+    );
+    if (defaultServerKey) {
+      // Get it from the prefs.
+      return this.getServerByKey(defaultServerKey);
+    }
+
+    // No pref set, so set the first one as default, and return it.
+    if (this.servers.length > 0) {
+      this.defaultServer = this.servers[0];
+      return this.servers[0];
+    }
+    return null;
+  }
+
+  set defaultServer(server) {
+    Services.prefs.setCharPref("mail.smtp.defaultserver", server.key);
+  }
+
+  get servers() {
+    if (!this._servers.length) {
+      // Load SMTP servers from prefs.
+      this._servers = this._getSmtpServerKeys().map(key =>
+        this._keyToServer(key)
+      );
+    }
+    return this._servers;
+  }
+
+  get wrappedJSObject() {
+    return this;
+  }
+
+  /**
+   * @see nsISmtpService
+   */
+  async sendMailMessage(
+    messageFile,
+    recipients,
+    userIdentity,
+    sender,
+    password,
+    deliveryListener,
+    statusListener,
+    notificationCallbacks,
+    requestDSN,
+    messageId,
+    outURI,
+    outRequest
+  ) {
+    this._logger.debug(`Sending message ${messageId}`);
+    let server = this.getServerByIdentity(userIdentity);
+    if (!server) {
+      // Occurs for at least one unit test, but test does not fail if return
+      // here. This check for "server" can be removed if tests are fixed.
+      console.log(
+        `No server found for identity with email ${userIdentity.email} and ` +
+          `smtpServerKey ${userIdentity.smtpServerKey}`
+      );
+      return;
+    }
+    if (password) {
+      server.password = password;
+    }
+    let runningUrl = this._getRunningUri(server);
+    await server.wrappedJSObject.withClient(client => {
+      deliveryListener?.OnStartRunningUrl(runningUrl, 0);
+      let fresh = true;
+      client.onidle = () => {
+        // onidle can occur multiple times, but we should only init sending
+        // when sending a new message(fresh is true) or when a new connection
+        // replaces the original connection due to error 4xx response
+        // (client.isRetry is true).
+        if (!fresh && !client.isRetry) {
+          return;
+        }
+        // Init when fresh==true OR re-init sending when client.isRetry==true.
+        fresh = false;
+        let from = sender;
+        let to = MailServices.headerParser
+          .parseEncodedHeaderW(decodeURIComponent(recipients))
+          .map(rec => rec.email);
+
+        if (
+          !Services.prefs.getBoolPref(
+            "mail.smtp.useSenderForSmtpMailFrom",
+            false
+          )
+        ) {
+          from = userIdentity.email;
+        }
+        if (!messageId) {
+          messageId = Cc["@mozilla.org/messengercompose/computils;1"]
+            .createInstance(Ci.nsIMsgCompUtils)
+            .msgGenerateMessageId(userIdentity, null);
+        }
+        client.useEnvelope({
+          from: MailServices.headerParser.parseEncodedHeaderW(
+            decodeURIComponent(from)
+          )[0].email,
+          to,
+          size: messageFile.fileSize,
+          requestDSN,
+          messageId,
+        });
+      };
+      let socketOnDrain;
+      client.onready = async () => {
+        let fstream = Cc[
+          "@mozilla.org/network/file-input-stream;1"
+        ].createInstance(Ci.nsIFileInputStream);
+        // PR_RDONLY
+        fstream.init(messageFile, 0x01, 0, 0);
+
+        let sstream = Cc["@mozilla.org/scriptableinputstream;1"].createInstance(
+          Ci.nsIScriptableInputStream
+        );
+        sstream.init(fstream);
+
+        let sentSize = 0;
+        let totalSize = messageFile.fileSize;
+        let progressListener = statusListener?.QueryInterface(
+          Ci.nsIWebProgressListener
+        );
+
+        while (sstream.available()) {
+          let chunk = sstream.read(65536);
+          let canSendMore = client.send(chunk);
+          if (!canSendMore) {
+            // Socket buffer is full, wait for the ondrain event.
+            await new Promise(resolve => (socketOnDrain = resolve));
+          }
+          // In practice, chunks are buffered by TCPSocket, progress reaches 100%
+          // almost immediately unless message is larger than chunk size.
+          sentSize += chunk.length;
+          progressListener?.onProgressChange(
+            null,
+            null,
+            sentSize,
+            totalSize,
+            sentSize,
+            totalSize
+          );
+        }
+        sstream.close();
+        fstream.close();
+        client.end();
+
+        // Set progress to indeterminate.
+        progressListener?.onProgressChange(null, null, 0, -1, 0, -1);
+      };
+      client.ondrain = () => {
+        // Socket buffer is empty, safe to continue sending.
+        socketOnDrain();
+      };
+      client.ondone = exitCode => {
+        if (!AppConstants.MOZ_SUITE) {
+          Services.telemetry.scalarAdd("tb.mails.sent", 1);
+        }
+        deliveryListener?.OnStopRunningUrl(runningUrl, exitCode);
+      };
+      client.onerror = (nsError, errorMessage, secInfo) => {
+        runningUrl.QueryInterface(Ci.nsIMsgMailNewsUrl);
+        if (secInfo) {
+          // TODO(emilio): Passing the failed security info as part of the URI is
+          // quite a smell, but monkey see monkey do...
+          runningUrl.failedSecInfo = secInfo;
+        }
+        runningUrl.errorMessage = errorMessage;
+        deliveryListener?.OnStopRunningUrl(runningUrl, nsError);
+      };
+
+      outRequest.value = {
+        cancel() {
+          client.close(true);
+        },
+      };
+    });
+  }
+
+  /**
+   * @see nsISmtpService
+   */
+  verifyLogon(server, urlListener, msgWindow) {
+    let client = new lazy.SmtpClient(server);
+    client.connect();
+    let runningUrl = this._getRunningUri(server);
+    client.onerror = (nsError, errorMessage, secInfo) => {
+      runningUrl.QueryInterface(Ci.nsIMsgMailNewsUrl);
+      if (secInfo) {
+        runningUrl.failedSecInfo = secInfo;
+      }
+      runningUrl.errorMessage = errorMessage;
+      urlListener.OnStopRunningUrl(runningUrl, nsError);
+    };
+    client.onready = () => {
+      urlListener.OnStopRunningUrl(runningUrl, 0);
+      client.close();
+    };
+    return runningUrl;
+  }
+
+  /**
+   * @see nsISmtpService
+   */
+  getServerByIdentity(userIdentity) {
+    return userIdentity.smtpServerKey
+      ? this.getServerByKey(userIdentity.smtpServerKey)
+      : this.defaultServer;
+  }
+
+  /**
+   * @see nsISmtpService
+   */
+  getServerByKey(key) {
+    return this.servers.find(s => s.key == key);
+  }
+
+  /**
+   * @see nsISmtpService
+   */
+  createServer() {
+    let serverKeys = this._getSmtpServerKeys();
+    let i = 1;
+    let key;
+    do {
+      key = `smtp${i++}`;
+    } while (serverKeys.includes(key));
+
+    serverKeys.push(key);
+    this._saveSmtpServerKeys(serverKeys);
+    this._servers = []; // Reset to force repopulation of this.servers.
+    return this.servers.at(-1);
+  }
+
+  /**
+   * @see nsISmtpService
+   */
+  deleteServer(server) {
+    let serverKeys = this._getSmtpServerKeys().filter(k => k != server.key);
+    this._servers = this.servers.filter(s => s.key != server.key);
+    this._saveSmtpServerKeys(serverKeys);
+  }
+
+  /**
+   * @see nsISmtpService
+   */
+  findServer(username, hostname) {
+    username = username?.toLowerCase();
+    hostname = hostname?.toLowerCase();
+    return this.servers.find(server => {
+      if (
+        (username && server.username.toLowerCase() != username) ||
+        (hostname && server.hostname.toLowerCase() != hostname)
+      ) {
+        return false;
+      }
+      return true;
+    });
+  }
+
+  /**
+   * Get all SMTP server keys from prefs.
+   *
+   * @returns {string[]}
+   */
+  _getSmtpServerKeys() {
+    return Services.prefs
+      .getCharPref("mail.smtpservers", "")
+      .split(",")
+      .filter(Boolean);
+  }
+
+  /**
+   * Save SMTP server keys to prefs.
+   *
+   * @param {string[]} keys - The key list to save.
+   */
+  _saveSmtpServerKeys(keys) {
+    return Services.prefs.setCharPref("mail.smtpservers", keys.join(","));
+  }
+
+  /**
+   * Create an nsISmtpServer from a key.
+   *
+   * @param {string} key - The key for the SmtpServer.
+   * @returns {nsISmtpServer}
+   */
+  _keyToServer(key) {
+    let server = Cc["@mozilla.org/messenger/smtp/server;1"].createInstance(
+      Ci.nsISmtpServer
+    );
+    // Setting the server key will set up all of its other properties by
+    // reading them from the prefs.
+    server.key = key;
+    return server;
+  }
+
+  /**
+   * Get the server URI in the form of smtp://user@hostname:port.
+   *
+   * @param {nsISmtpServer} server - The SMTP server.
+   * @returns {nsIURI}
+   */
+  _getRunningUri(server) {
+    let spec = server.serverURI + (server.port ? `:${server.port}` : "");
+    return Services.io.newURI(spec);
+  }
+}
diff --git a/comm/mailnews/compose/src/components.conf b/comm/mailnews/compose/src/components.conf
new file mode 100644
index 0000000000..44754289f5
--- /dev/null
+++ b/comm/mailnews/compose/src/components.conf
@@ -0,0 +1,197 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+Classes = [
+    {
+        "cid": "{588595fe-1ada-11d3-a715-0060b0eb39b5}",
+        "contract_ids": [
+            "@mozilla.org/messengercompose;1",
+            "@mozilla.org/commandlinehandler/general-startup;1?type=compose",
+        ],
+        "type": "nsMsgComposeService",
+        "init_method": "Init",
+        "headers": ["/comm/mailnews/compose/src/nsMsgComposeService.h"],
+        "categories": {"command-line-handler": "m-compose"},
+        "name": "Compose",
+        "interfaces": ["nsIMsgComposeService"],
+    },
+    {
+        "cid": "{0b63fb80-bbba-11d4-9daa-91b657eb313c}",
+        "contract_ids": [
+            "@mozilla.org/uriloader/content-handler;1?type=application/x-mailto"
+        ],
+        "type": "nsMsgComposeContentHandler",
+        "headers": ["/comm/mailnews/compose/src/nsMsgComposeContentHandler.h"],
+    },
+    {
+        "cid": "{eb5bdaf8-bbc6-11d2-a6ec-0060b0eb39b5}",
+        "contract_ids": ["@mozilla.org/messengercompose/compose;1"],
+        "type": "nsMsgCompose",
+        "headers": ["/comm/mailnews/compose/src/nsMsgCompose.h"],
+    },
+    {
+        "cid": "{cb998a00-c079-11d4-9daa-8df64bab2efc}",
+        "contract_ids": ["@mozilla.org/messengercompose/composeparams;1"],
+        "type": "nsMsgComposeParams",
+        "headers": ["/comm/mailnews/compose/src/nsMsgComposeParams.h"],
+    },
+    {
+        "cid": "{acc72781-2cea-11d5-9daa-bacdeac1eefc}",
+        "contract_ids": ["@mozilla.org/messengercompose/composesendlistener;1"],
+        "type": "nsMsgComposeSendListener",
+        "headers": ["/comm/mailnews/compose/src/nsMsgCompose.h"],
+    },
+    {
+        "cid": "{1e0e7c01-3e4c-11d5-9daa-f88d288130fc}",
+        "contract_ids": ["@mozilla.org/messengercompose/composeprogressparameters;1"],
+        "type": "nsMsgComposeProgressParams",
+        "headers": ["/comm/mailnews/compose/src/nsMsgComposeProgressParams.h"],
+    },
+    {
+        "cid": "{e64b0f51-0d7b-4e2f-8c60-3862ee8c174f}",
+        "contract_ids": ["@mozilla.org/messengercompose/composefields;1"],
+        "type": "nsMsgCompFields",
+        "headers": ["/comm/mailnews/compose/src/nsMsgCompFields.h"],
+    },
+    {
+        "cid": "{27b8d045-8d9f-4fa8-bfb6-8a0f8d09ce89}",
+        "contract_ids": ["@mozilla.org/messengercompose/attachment;1"],
+        "type": "nsMsgAttachment",
+        "headers": ["/comm/mailnews/compose/src/nsMsgAttachment.h"],
+    },
+    {
+        "cid": "{9e16958d-d9e9-4cae-b723-a5bccf104998}",
+        "contract_ids": ["@mozilla.org/messengercompose/attachmentdata;1"],
+        "type": "nsMsgAttachmentData",
+        "headers": ["/comm/mailnews/compose/src/nsMsgAttachmentData.h"],
+    },
+    {
+        "cid": "{ef173501-4e14-42b9-ae1f-7770de235c29}",
+        "contract_ids": ["@mozilla.org/messengercompose/attachedfile;1"],
+        "type": "nsMsgAttachedFile",
+        "headers": ["/comm/mailnews/compose/src/nsMsgAttachedFile.h"],
+    },
+    {
+        "cid": "{e15c83f1-1cf4-11d3-8ef0-00a024a7d144}",
+        "contract_ids": ["@mozilla.org/messengercompose/sendlater;1"],
+        "type": "nsMsgSendLater",
+        "init_method": "Init",
+        "headers": ["/comm/mailnews/compose/src/nsMsgSendLater.h"],
+    },
+    {
+        "cid": "{be59dbf0-2812-11d3-80a3-006008128c4e}",
+        "contract_ids": ["@mozilla.org/messengercompose/smtpurl;1"],
+        "type": "nsSmtpUrl",
+        "headers": ["/comm/mailnews/compose/src/nsSmtpUrl.h"],
+    },
+    {
+        "cid": "{05bab5e7-9c7d-11d3-98a3-001083010e9b}",
+        "contract_ids": ["@mozilla.org/messengercompose/mailtourl;1"],
+        "type": "nsMailtoUrl",
+        "headers": ["/comm/mailnews/compose/src/nsSmtpUrl.h"],
+    },
+    {
+        "cid": "{1c7abf0c-21e5-11d3-8ef1-00a024a7d144}",
+        "contract_ids": ["@mozilla.org/messengercompose/quoting;1"],
+        "type": "nsMsgQuote",
+        "headers": ["/comm/mailnews/compose/src/nsMsgQuote.h"],
+    },
+    {
+        "cid": "{683728ac-88df-11d3-989d-001083010e9b}",
+        "contract_ids": ["@mozilla.org/messengercompose/quotinglistener;1"],
+        "type": "nsMsgQuoteListener",
+        "headers": ["/comm/mailnews/compose/src/nsMsgQuote.h"],
+    },
+    {
+        "cid": "{ceb0dca2-5e7d-4204-94d4-2ab925921fae}",
+        "contract_ids": ["@mozilla.org/messengercompose/computils;1"],
+        "type": "nsMsgCompUtils",
+        "headers": ["/comm/mailnews/compose/src/nsMsgCompUtils.h"],
+    },
+    {
+        "cid": "{0874c3b5-317d-11d3-8efb-00a024a7d144}",
+        "contract_ids": ["@mozilla.org/messengercompose/msgcopy;1"],
+        "type": "nsMsgCopy",
+        "headers": ["/comm/mailnews/compose/src/nsMsgCopy.h"],
+    },
+    {
+        "cid": "{e5872045-a87b-4ea0-b366-45ebd7dc89d9}",
+        "contract_ids": ["@mozilla.org/messengercompose/sendreport;1"],
+        "type": "nsMsgSendReport",
+        "headers": ["/comm/mailnews/compose/src/nsMsgSendReport.h"],
+    },
+    {
+        "cid": "{028b9c1e-8d0a-4518-80c2-842e07846eaa}",
+        "contract_ids": ["@mozilla.org/messengercompose/send;1"],
+        "jsm": "resource:///modules/MessageSend.jsm",
+        "constructor": "MessageSend",
+    },
+    {
+        "cid": "{b14c2b67-8680-4c11-8d63-9403c7d4f757}",
+        "contract_ids": ["@mozilla.org/network/protocol;1?name=smtp"],
+        "jsm": "resource:///modules/SMTPProtocolHandler.jsm",
+        "constructor": "SMTPProtocolHandler",
+        "protocol_config": {
+           "scheme": "smtp",
+            "flags": [
+                "URI_NORELATIVE",
+                "URI_DANGEROUS_TO_LOAD",
+                "ALLOWS_PROXY",
+                "URI_NON_PERSISTABLE",
+                "URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT",
+            ],
+            "default_port": 25,
+        },
+    },
+    {
+        "cid": "{057d0997-9e3a-411e-b4ee-2602f53fe05f}",
+        "contract_ids": ["@mozilla.org/network/protocol;1?name=smtps"],
+        "jsm": "resource:///modules/SMTPProtocolHandler.jsm",
+        "constructor": "SMTPSProtocolHandler",
+        "protocol_config": {
+           "scheme": "smtps",
+            "flags": [
+                "URI_NORELATIVE",
+                "URI_DANGEROUS_TO_LOAD",
+                "ALLOWS_PROXY",
+                "URI_NON_PERSISTABLE",
+                "URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT",
+            ],
+            "default_port": 465,
+        },
+    },
+    {
+        "cid": "{af314bd9-0b28-4f69-9bea-592ab4dc6811}",
+        "contract_ids": ["@mozilla.org/network/protocol;1?name=mailto"],
+        "jsm": "resource:///modules/MailtoProtocolHandler.jsm",
+        "constructor": "MailtoProtocolHandler",
+        "protocol_config": {
+           "scheme": "mailto",
+            "flags": [
+                "URI_NORELATIVE",
+                "ALLOWS_PROXY",
+                "URI_LOADABLE_BY_ANYONE",
+                "URI_NON_PERSISTABLE",
+                "URI_DOES_NOT_RETURN_DATA",
+                "URI_FORBIDS_COOKIE_ACCESS",
+            ],
+        },
+    },
+    {
+        "cid": "{acda6039-8b17-46c1-a8ed-ad50aa80f412}",
+        "contract_ids": ["@mozilla.org/messengercompose/smtp;1"],
+        "jsm": "resource:///modules/SmtpService.jsm",
+        "constructor": "SmtpService",
+        "name": "Smtp",
+        "interfaces": ["nsISmtpService"],
+    },
+    {
+        "cid": "{3a75f5ea-651e-4696-9813-848c03da8bbd}",
+        "contract_ids": ["@mozilla.org/messenger/smtp/server;1"],
+        "jsm": "resource:///modules/SmtpServer.jsm",
+        "constructor": "SmtpServer",
+    },
+]
diff --git a/comm/mailnews/compose/src/moz.build b/comm/mailnews/compose/src/moz.build
new file mode 100644
index 0000000000..60ff148540
--- /dev/null
+++ b/comm/mailnews/compose/src/moz.build
@@ -0,0 +1,60 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXPORTS += [
+    "nsComposeStrings.h",
+    "nsMsgAttachmentData.h",
+    "nsMsgCompFields.h",
+    "nsMsgCompose.h",
+]
+
+SOURCES += [
+    "nsComposeStrings.cpp",
+    "nsMsgAttachedFile.cpp",
+    "nsMsgAttachment.cpp",
+    "nsMsgAttachmentData.cpp",
+    "nsMsgCompFields.cpp",
+    "nsMsgCompose.cpp",
+    "nsMsgComposeContentHandler.cpp",
+    "nsMsgComposeParams.cpp",
+    "nsMsgComposeProgressParams.cpp",
+    "nsMsgComposeService.cpp",
+    "nsMsgCompUtils.cpp",
+    "nsMsgCopy.cpp",
+    "nsMsgPrompts.cpp",
+    "nsMsgQuote.cpp",
+    "nsMsgSendLater.cpp",
+    "nsMsgSendReport.cpp",
+    "nsSmtpUrl.cpp",
+]
+
+LOCAL_INCLUDES += [
+    "/dom/base",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "mail"
+
+# clang-cl rightly complains about switch on nsresult.
+if CONFIG["CC_TYPE"] == "clang-cl":
+    CXXFLAGS += ["-Wno-switch"]
+
+EXTRA_JS_MODULES += [
+    "MailtoProtocolHandler.jsm",
+    "MessageSend.jsm",
+    "MimeEncoder.jsm",
+    "MimeMessage.jsm",
+    "MimeMessageUtils.jsm",
+    "MimePart.jsm",
+    "SmtpClient.jsm",
+    "SMTPProtocolHandler.jsm",
+    "SmtpServer.jsm",
+    "SmtpService.jsm",
+]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
diff --git a/comm/mailnews/compose/src/nsComposeStrings.cpp b/comm/mailnews/compose/src/nsComposeStrings.cpp
new file mode 100644
index 0000000000..666cd14e07
--- /dev/null
+++ b/comm/mailnews/compose/src/nsComposeStrings.cpp
@@ -0,0 +1,106 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsComposeStrings.h"
+
+const char* errorStringNameForErrorCode(nsresult aCode) {
+#ifdef __GNUC__
+// Temporary workaround until bug 783526 is fixed.
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wswitch"
+#endif
+  switch (aCode) {
+    case NS_MSG_UNABLE_TO_OPEN_FILE:
+      return "unableToOpenFile";
+    case NS_MSG_UNABLE_TO_OPEN_TMP_FILE:
+      return "unableToOpenTmpFile";
+    case NS_MSG_UNABLE_TO_SAVE_TEMPLATE:
+      return "unableToSaveTemplate";
+    case NS_MSG_UNABLE_TO_SAVE_DRAFT:
+      return "unableToSaveDraft";
+    case NS_MSG_COULDNT_OPEN_FCC_FOLDER:
+      return "couldntOpenFccFolder";
+    case NS_MSG_NO_SENDER:
+      return "noSender";
+    case NS_MSG_NO_RECIPIENTS:
+      return "noRecipients";
+    case NS_MSG_ERROR_WRITING_FILE:
+      return "errorWritingFile";
+    case NS_ERROR_SENDING_FROM_COMMAND:
+      return "errorSendingFromCommand";
+    case NS_ERROR_SENDING_DATA_COMMAND:
+      return "errorSendingDataCommand";
+    case NS_ERROR_SENDING_MESSAGE:
+      return "errorSendingMessage";
+    case NS_ERROR_POST_FAILED:
+      return "postFailed";
+    case NS_ERROR_SMTP_SERVER_ERROR:
+      return "smtpServerError";
+    case NS_MSG_UNABLE_TO_SEND_LATER:
+      return "unableToSendLater";
+    case NS_ERROR_COMMUNICATIONS_ERROR:
+      return "communicationsError";
+    case NS_ERROR_BUT_DONT_SHOW_ALERT:
+      return "dontShowAlert";
+    case NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS:
+      return "couldNotGetUsersMailAddress2";
+    case NS_ERROR_COULD_NOT_GET_SENDERS_IDENTITY:
+      return "couldNotGetSendersIdentity";
+    case NS_ERROR_MIME_MPART_ATTACHMENT_ERROR:
+      return "mimeMpartAttachmentError";
+    case NS_ERROR_NNTP_NO_CROSS_POSTING:
+      return "nntpNoCrossPosting";
+    case NS_MSG_ERROR_READING_FILE:
+      return "errorReadingFile";
+    case NS_MSG_ERROR_ATTACHING_FILE:
+      return "errorAttachingFile";
+    case NS_ERROR_SMTP_GREETING:
+      return "incorrectSmtpGreeting";
+    case NS_ERROR_SENDING_RCPT_COMMAND:
+      return "errorSendingRcptCommand";
+    case NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS:
+      return "startTlsFailed";
+    case NS_ERROR_SMTP_PASSWORD_UNDEFINED:
+      return "smtpPasswordUndefined";
+    case NS_ERROR_SMTP_SEND_NOT_ALLOWED:
+      return "smtpSendNotAllowed";
+    case NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED:
+      return "smtpTooManyRecipients";
+    case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2:
+      return "smtpPermSizeExceeded2";
+    case NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER:
+      return "smtpSendFailedUnknownServer";
+    case NS_ERROR_SMTP_SEND_FAILED_REFUSED:
+      return "smtpSendRequestRefused";
+    case NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED:
+      return "smtpSendInterrupted";
+    case NS_ERROR_SMTP_SEND_FAILED_TIMEOUT:
+      return "smtpSendTimeout";
+    case NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON:
+      return "smtpSendFailedUnknownReason";
+    case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL:
+      return "smtpHintAuthEncryptToPlainNoSsl";
+    case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL:
+      return "smtpHintAuthEncryptToPlainSsl";
+    case NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT:
+      return "smtpHintAuthPlainToEncrypt";
+    case NS_ERROR_SMTP_AUTH_FAILURE:
+      return "smtpAuthFailure";
+    case NS_ERROR_SMTP_AUTH_GSSAPI:
+      return "smtpAuthGssapi";
+    case NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED:
+      return "smtpAuthMechNotSupported";
+    case NS_ERROR_ILLEGAL_LOCALPART:
+      return "errorIllegalLocalPart2";
+    case NS_ERROR_CLIENTID:
+      return "smtpClientid";
+    case NS_ERROR_CLIENTID_PERMISSION:
+      return "smtpClientidPermission";
+    default:
+      return "sendFailed";
+  }
+#ifdef __GNUC__
+#  pragma GCC diagnostic pop
+#endif
+}
diff --git a/comm/mailnews/compose/src/nsComposeStrings.h b/comm/mailnews/compose/src/nsComposeStrings.h
new file mode 100644
index 0000000000..3d6a24516f
--- /dev/null
+++ b/comm/mailnews/compose/src/nsComposeStrings.h
@@ -0,0 +1,76 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// clang-format off
+/**
+  String Ids used by mailnews\compose
+  To Do: Convert the callers to use names instead of ids and then make this file obsolete.
+ */
+
+#ifndef _nsComposeStrings_H__
+#define _nsComposeStrings_H__
+
+#include "msgCore.h"
+
+#define NS_MSG_UNABLE_TO_OPEN_FILE                  NS_MSG_GENERATE_FAILURE(12500)
+#define NS_MSG_UNABLE_TO_OPEN_TMP_FILE              NS_MSG_GENERATE_FAILURE(12501)
+#define NS_MSG_UNABLE_TO_SAVE_TEMPLATE              NS_MSG_GENERATE_FAILURE(12502)
+#define NS_MSG_UNABLE_TO_SAVE_DRAFT                 NS_MSG_GENERATE_FAILURE(12503)
+#define NS_MSG_COULDNT_OPEN_FCC_FOLDER              NS_MSG_GENERATE_FAILURE(12506)
+#define NS_MSG_NO_SENDER                            NS_MSG_GENERATE_FAILURE(12510)
+#define NS_MSG_NO_RECIPIENTS                        NS_MSG_GENERATE_FAILURE(12511)
+#define NS_MSG_ERROR_WRITING_FILE                   NS_MSG_GENERATE_FAILURE(12512)
+#define NS_ERROR_SENDING_FROM_COMMAND               NS_MSG_GENERATE_FAILURE(12514)
+#define NS_ERROR_SENDING_DATA_COMMAND               NS_MSG_GENERATE_FAILURE(12516)
+#define NS_ERROR_SENDING_MESSAGE                    NS_MSG_GENERATE_FAILURE(12517)
+#define NS_ERROR_POST_FAILED                        NS_MSG_GENERATE_FAILURE(12518)
+#define NS_ERROR_SMTP_SERVER_ERROR                  NS_MSG_GENERATE_FAILURE(12524)
+#define NS_MSG_UNABLE_TO_SEND_LATER                 NS_MSG_GENERATE_FAILURE(12525)
+#define NS_ERROR_COMMUNICATIONS_ERROR               NS_MSG_GENERATE_FAILURE(12526)
+#define NS_ERROR_BUT_DONT_SHOW_ALERT                NS_MSG_GENERATE_FAILURE(12527)
+#define NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS   NS_MSG_GENERATE_FAILURE(12529)
+#define NS_ERROR_COULD_NOT_GET_SENDERS_IDENTITY     NS_MSG_GENERATE_FAILURE(12530)
+#define NS_ERROR_MIME_MPART_ATTACHMENT_ERROR        NS_MSG_GENERATE_FAILURE(12531)
+
+/* 12554 is taken by NS_ERROR_NNTP_NO_CROSS_POSTING.  use 12555 as the next one */
+
+// For message sending report
+#define NS_MSG_ERROR_READING_FILE                   NS_MSG_GENERATE_FAILURE(12563)
+
+#define NS_MSG_ERROR_ATTACHING_FILE                 NS_MSG_GENERATE_FAILURE(12570)
+
+#define NS_ERROR_SMTP_GREETING                      NS_MSG_GENERATE_FAILURE(12572)
+
+#define NS_ERROR_SENDING_RCPT_COMMAND               NS_MSG_GENERATE_FAILURE(12575)
+
+#define NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS      NS_MSG_GENERATE_FAILURE(12582)
+
+#define NS_ERROR_SMTP_PASSWORD_UNDEFINED            NS_MSG_GENERATE_FAILURE(12584)
+#define NS_ERROR_SMTP_SEND_NOT_ALLOWED              NS_MSG_GENERATE_FAILURE(12585)
+#define NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED            NS_MSG_GENERATE_FAILURE(12586)
+#define NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2          NS_MSG_GENERATE_FAILURE(12588)
+
+#define NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER    NS_MSG_GENERATE_FAILURE(12589)
+#define NS_ERROR_SMTP_SEND_FAILED_REFUSED           NS_MSG_GENERATE_FAILURE(12590)
+#define NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED       NS_MSG_GENERATE_FAILURE(12591)
+#define NS_ERROR_SMTP_SEND_FAILED_TIMEOUT           NS_MSG_GENERATE_FAILURE(12592)
+#define NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON    NS_MSG_GENERATE_FAILURE(12593)
+
+#define NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL  NS_MSG_GENERATE_FAILURE(12594)
+#define NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL     NS_MSG_GENERATE_FAILURE(12595)
+#define NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT         NS_MSG_GENERATE_FAILURE(12596)
+#define NS_ERROR_SMTP_AUTH_FAILURE                  NS_MSG_GENERATE_FAILURE(12597)
+#define NS_ERROR_SMTP_AUTH_GSSAPI                   NS_MSG_GENERATE_FAILURE(12598)
+#define NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED       NS_MSG_GENERATE_FAILURE(12599)
+
+#define NS_ERROR_ILLEGAL_LOCALPART                  NS_MSG_GENERATE_FAILURE(12601)
+
+#define NS_ERROR_CLIENTID                           NS_MSG_GENERATE_FAILURE(12610)
+#define NS_ERROR_CLIENTID_PERMISSION                NS_MSG_GENERATE_FAILURE(12611)
+
+const char* errorStringNameForErrorCode(nsresult aCode);
+
+#endif /* _nsComposeStrings_H__ */
+
+// clang-format on
diff --git a/comm/mailnews/compose/src/nsMsgAttachedFile.cpp b/comm/mailnews/compose/src/nsMsgAttachedFile.cpp
new file mode 100644
index 0000000000..cb293ee964
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgAttachedFile.cpp
@@ -0,0 +1,179 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsMsgAttachedFile.h"
+
+NS_IMPL_ISUPPORTS(nsMsgAttachedFile, nsIMsgAttachedFile)
+
+nsMsgAttachedFile::nsMsgAttachedFile()
+    : m_size(0),
+      m_unprintableCount(0),
+      m_highbitCount(0),
+      m_ctlCount(0),
+      m_nullCount(0),
+      m_maxLineLength(0) {}
+
+nsMsgAttachedFile::~nsMsgAttachedFile() {}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetOrigUrl(nsIURI** aOrigUrl) {
+  NS_ENSURE_ARG_POINTER(aOrigUrl);
+  NS_IF_ADDREF(*aOrigUrl = m_origUrl);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetOrigUrl(nsIURI* aOrigUrl) {
+  m_origUrl = aOrigUrl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetTmpFile(nsIFile** aTmpFile) {
+  NS_ENSURE_ARG_POINTER(aTmpFile);
+  NS_IF_ADDREF(*aTmpFile = m_tmpFile);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetTmpFile(nsIFile* aTmpFile) {
+  m_tmpFile = aTmpFile;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetType(nsACString& aType) {
+  aType = m_type;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetType(const nsACString& aType) {
+  m_type = aType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetEncoding(nsACString& aEncoding) {
+  aEncoding = m_encoding;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetEncoding(const nsACString& aEncoding) {
+  m_encoding = aEncoding;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetDescription(nsACString& aDescription) {
+  aDescription = m_description;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetDescription(
+    const nsACString& aDescription) {
+  m_description = aDescription;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetCloudPartInfo(nsACString& aCloudPartInfo) {
+  aCloudPartInfo = m_cloudPartInfo;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetCloudPartInfo(
+    const nsACString& aCloudPartInfo) {
+  m_cloudPartInfo = aCloudPartInfo;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetXMacType(nsACString& aXMacType) {
+  aXMacType = m_xMacType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetXMacType(const nsACString& aXMacType) {
+  m_xMacType = aXMacType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetXMacCreator(nsACString& aXMacCreator) {
+  aXMacCreator = m_xMacCreator;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetXMacCreator(
+    const nsACString& aXMacCreator) {
+  m_xMacCreator = aXMacCreator;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetRealName(nsACString& aRealName) {
+  aRealName = m_realName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetRealName(const nsACString& aRealName) {
+  m_realName = aRealName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetSize(uint32_t* aSize) {
+  NS_ENSURE_ARG_POINTER(aSize);
+  *aSize = m_size;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetSize(uint32_t aSize) {
+  m_size = aSize;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetUnprintableCount(
+    uint32_t* aUnprintableCount) {
+  NS_ENSURE_ARG_POINTER(aUnprintableCount);
+  *aUnprintableCount = m_unprintableCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetUnprintableCount(
+    uint32_t aUnprintableCount) {
+  m_unprintableCount = aUnprintableCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetHighbitCount(uint32_t* aHighbitCount) {
+  NS_ENSURE_ARG_POINTER(aHighbitCount);
+  *aHighbitCount = m_highbitCount;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgAttachedFile::SetHighbitCount(uint32_t aHighbitCount) {
+  m_highbitCount = aHighbitCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetCtlCount(uint32_t* aCtlCount) {
+  NS_ENSURE_ARG_POINTER(aCtlCount);
+  *aCtlCount = m_ctlCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetCtlCount(uint32_t aCtlCount) {
+  m_ctlCount = aCtlCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetNullCount(uint32_t* aNullCount) {
+  NS_ENSURE_ARG_POINTER(aNullCount);
+  *aNullCount = m_nullCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetNullCount(uint32_t aNullCount) {
+  m_nullCount = aNullCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::GetMaxLineLength(uint32_t* aMaxLineLength) {
+  NS_ENSURE_ARG_POINTER(aMaxLineLength);
+  *aMaxLineLength = m_maxLineLength;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachedFile::SetMaxLineLength(uint32_t aMaxLineLength) {
+  m_maxLineLength = aMaxLineLength;
+  return NS_OK;
+}
diff --git a/comm/mailnews/compose/src/nsMsgAttachedFile.h b/comm/mailnews/compose/src/nsMsgAttachedFile.h
new file mode 100644
index 0000000000..5f68731927
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgAttachedFile.h
@@ -0,0 +1,13 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsMsgAttachedFile_H_
+#define _nsMsgAttachedFile_H_
+
+#include "nsCOMPtr.h"
+#include "nsIMsgSend.h"
+#include "nsMsgAttachmentData.h"
+
+#endif /* _nsMsgAttachedFile_H_ */
diff --git a/comm/mailnews/compose/src/nsMsgAttachment.cpp b/comm/mailnews/compose/src/nsMsgAttachment.cpp
new file mode 100644
index 0000000000..55edd348ca
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgAttachment.cpp
@@ -0,0 +1,263 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgAttachment.h"
+#include "nsIFile.h"
+#include "nsNetUtil.h"
+#include "nsMsgCompUtils.h"
+
+NS_IMPL_ISUPPORTS(nsMsgAttachment, nsIMsgAttachment)
+
+nsMsgAttachment::nsMsgAttachment() {
+  mTemporary = false;
+  mSendViaCloud = false;
+  mSize = -1;
+}
+
+nsMsgAttachment::~nsMsgAttachment() {
+  MOZ_LOG(Compose, mozilla::LogLevel::Debug, ("~nsMsgAttachment()"));
+}
+
+/* attribute wstring name; */
+NS_IMETHODIMP nsMsgAttachment::GetName(nsAString& aName) {
+  aName = mName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::SetName(const nsAString& aName) {
+  mName = aName;
+  return NS_OK;
+}
+
+/* attribute string url; */
+NS_IMETHODIMP nsMsgAttachment::GetUrl(nsACString& aUrl) {
+  aUrl = mUrl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::SetUrl(const nsACString& aUrl) {
+  mUrl = aUrl;
+  return NS_OK;
+}
+
+/* attribute string msgUri; */
+NS_IMETHODIMP nsMsgAttachment::GetMsgUri(nsACString& aMsgUri) {
+  aMsgUri = mMsgUri;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::SetMsgUri(const nsACString& aMsgUri) {
+  mMsgUri = aMsgUri;
+  return NS_OK;
+}
+
+/* attribute string urlCharset; */
+NS_IMETHODIMP nsMsgAttachment::GetUrlCharset(nsACString& aUrlCharset) {
+  aUrlCharset = mUrlCharset;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgAttachment::SetUrlCharset(const nsACString& aUrlCharset) {
+  mUrlCharset = aUrlCharset;
+  return NS_OK;
+}
+
+/* attribute boolean temporary; */
+NS_IMETHODIMP nsMsgAttachment::GetTemporary(bool* aTemporary) {
+  NS_ENSURE_ARG_POINTER(aTemporary);
+
+  *aTemporary = mTemporary;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgAttachment::SetTemporary(bool aTemporary) {
+  mTemporary = aTemporary;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::GetSendViaCloud(bool* aSendViaCloud) {
+  NS_ENSURE_ARG_POINTER(aSendViaCloud);
+
+  *aSendViaCloud = mSendViaCloud;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgAttachment::SetSendViaCloud(bool aSendViaCloud) {
+  mSendViaCloud = aSendViaCloud;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::SetHtmlAnnotation(
+    const nsACString& aAnnotation) {
+  mHtmlAnnotation = aAnnotation;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::GetHtmlAnnotation(nsACString& aAnnotation) {
+  aAnnotation = mHtmlAnnotation;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAttachment::SetCloudFileAccountKey(
+    const nsACString& aCloudFileAccountKey) {
+  mCloudFileAccountKey = aCloudFileAccountKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAttachment::GetCloudFileAccountKey(nsACString& aCloudFileAccountKey) {
+  aCloudFileAccountKey = mCloudFileAccountKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::GetCloudPartHeaderData(
+    nsACString& aCloudPartHeaderData) {
+  aCloudPartHeaderData = mCloudPartHeaderData;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::SetCloudPartHeaderData(
+    const nsACString& aCloudPartHeaderData) {
+  mCloudPartHeaderData = aCloudPartHeaderData;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::GetContentLocation(
+    nsACString& aContentLocation) {
+  aContentLocation = mContentLocation;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::SetContentLocation(
+    const nsACString& aContentLocation) {
+  mContentLocation = aContentLocation;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::GetContentType(char** aContentType) {
+  NS_ENSURE_ARG_POINTER(aContentType);
+
+  *aContentType = ToNewCString(mContentType);
+  return (*aContentType ? NS_OK : NS_ERROR_OUT_OF_MEMORY);
+}
+
+NS_IMETHODIMP nsMsgAttachment::SetContentType(const char* aContentType) {
+  mContentType = aContentType;
+  // a full content type could also contains parameters but we need to
+  // keep only the content type alone. Therefore we need to cleanup it.
+  int32_t offset = mContentType.FindChar(';');
+  if (offset >= 0) mContentType.SetLength(offset);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::GetContentTypeParam(char** aContentTypeParam) {
+  NS_ENSURE_ARG_POINTER(aContentTypeParam);
+
+  *aContentTypeParam = ToNewCString(mContentTypeParam);
+  return (*aContentTypeParam ? NS_OK : NS_ERROR_OUT_OF_MEMORY);
+}
+
+NS_IMETHODIMP nsMsgAttachment::SetContentTypeParam(
+    const char* aContentTypeParam) {
+  if (aContentTypeParam)
+    while (*aContentTypeParam == ';' || *aContentTypeParam == ' ')
+      aContentTypeParam++;
+  mContentTypeParam = aContentTypeParam;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::GetContentId(nsACString& aContentId) {
+  aContentId = mContentId;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::SetContentId(const nsACString& aContentId) {
+  mContentId = aContentId;
+  return NS_OK;
+}
+
+/* attribute string charset; */
+NS_IMETHODIMP nsMsgAttachment::GetCharset(char** aCharset) {
+  NS_ENSURE_ARG_POINTER(aCharset);
+
+  *aCharset = ToNewCString(mCharset);
+  return (*aCharset ? NS_OK : NS_ERROR_OUT_OF_MEMORY);
+}
+NS_IMETHODIMP nsMsgAttachment::SetCharset(const char* aCharset) {
+  mCharset = aCharset;
+  return NS_OK;
+}
+
+/* attribute string macType; */
+NS_IMETHODIMP nsMsgAttachment::GetMacType(char** aMacType) {
+  NS_ENSURE_ARG_POINTER(aMacType);
+
+  *aMacType = ToNewCString(mMacType);
+  return (*aMacType ? NS_OK : NS_ERROR_OUT_OF_MEMORY);
+}
+NS_IMETHODIMP nsMsgAttachment::SetMacType(const char* aMacType) {
+  mMacType = aMacType;
+  return NS_OK;
+}
+
+/* attribute string macCreator; */
+NS_IMETHODIMP nsMsgAttachment::GetMacCreator(char** aMacCreator) {
+  NS_ENSURE_ARG_POINTER(aMacCreator);
+
+  *aMacCreator = ToNewCString(mMacCreator);
+  return (*aMacCreator ? NS_OK : NS_ERROR_OUT_OF_MEMORY);
+}
+NS_IMETHODIMP nsMsgAttachment::SetMacCreator(const char* aMacCreator) {
+  mMacCreator = aMacCreator;
+  return NS_OK;
+}
+
+/* attribute int64_t size; */
+NS_IMETHODIMP nsMsgAttachment::GetSize(int64_t* aSize) {
+  NS_ENSURE_ARG_POINTER(aSize);
+
+  *aSize = mSize;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgAttachment::SetSize(int64_t aSize) {
+  mSize = aSize;
+  return NS_OK;
+}
+
+/* boolean equalsUrl (in nsIMsgAttachment attachment); */
+NS_IMETHODIMP nsMsgAttachment::EqualsUrl(nsIMsgAttachment* attachment,
+                                         bool* _retval) {
+  NS_ENSURE_ARG_POINTER(attachment);
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  nsAutoCString url;
+  attachment->GetUrl(url);
+
+  *_retval = mUrl.Equals(url);
+  return NS_OK;
+}
+
+nsresult nsMsgAttachment::DeleteAttachment() {
+  nsresult rv;
+  bool isAFile = false;
+
+  nsCOMPtr<nsIFile> urlFile;
+  rv = NS_GetFileFromURLSpec(mUrl, getter_AddRefs(urlFile));
+  NS_ASSERTION(NS_SUCCEEDED(rv), "Can't nsIFile from URL string");
+  if (NS_SUCCEEDED(rv)) {
+    bool bExists = false;
+    rv = urlFile->Exists(&bExists);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Exists() call failed!");
+    if (NS_SUCCEEDED(rv) && bExists) {
+      rv = urlFile->IsFile(&isAFile);
+      NS_ASSERTION(NS_SUCCEEDED(rv), "IsFile() call failed!");
+    }
+  }
+
+  // remove it if it's a valid file
+  if (isAFile) rv = urlFile->Remove(false);
+
+  return rv;
+}
diff --git a/comm/mailnews/compose/src/nsMsgAttachment.h b/comm/mailnews/compose/src/nsMsgAttachment.h
new file mode 100644
index 0000000000..d9e0de696e
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgAttachment.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsMsgAttachment_H_
+#define _nsMsgAttachment_H_
+
+#include "nsIMsgAttachment.h"
+#include "nsString.h"
+
+class nsMsgAttachment : public nsIMsgAttachment {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGATTACHMENT
+
+  nsMsgAttachment();
+
+ private:
+  virtual ~nsMsgAttachment();
+  nsresult DeleteAttachment();
+
+  nsString mName;
+  nsCString mUrl;
+  nsCString mMsgUri;
+  nsCString mUrlCharset;
+  bool mTemporary;
+  bool mSendViaCloud;
+  nsCString mCloudFileAccountKey;
+  nsCString mCloudPartHeaderData;
+  nsCString mContentLocation;
+  nsCString mContentType;
+  nsCString mContentTypeParam;
+  nsCString mContentId;
+  nsCString mCharset;
+  nsCString mMacType;
+  nsCString mMacCreator;
+  nsCString mHtmlAnnotation;
+  int64_t mSize;
+};
+
+#endif /* _nsMsgAttachment_H_ */
diff --git a/comm/mailnews/compose/src/nsMsgAttachmentData.cpp b/comm/mailnews/compose/src/nsMsgAttachmentData.cpp
new file mode 100644
index 0000000000..c32b31d0c1
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgAttachmentData.cpp
@@ -0,0 +1,103 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsMsgAttachmentData.h"
+
+NS_IMPL_ISUPPORTS(nsMsgAttachmentData, nsIMsgAttachmentData)
+
+nsMsgAttachmentData::nsMsgAttachmentData()
+    : m_size(0),
+      m_sizeExternalStr("-1"),
+      m_isExternalAttachment(false),
+      m_isExternalLinkAttachment(false),
+      m_isDownloaded(false),
+      m_hasFilename(false),
+      m_displayableInline(false) {}
+
+nsMsgAttachmentData::~nsMsgAttachmentData() {}
+
+NS_IMETHODIMP nsMsgAttachmentData::GetUrl(nsIURI** aUrl) {
+  NS_ENSURE_ARG_POINTER(aUrl);
+  NS_IF_ADDREF(*aUrl = m_url);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::SetUrl(nsIURI* aUrl) {
+  m_url = aUrl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::GetDesiredType(nsACString& aDesiredType) {
+  aDesiredType = m_desiredType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::SetDesiredType(
+    const nsACString& aDesiredType) {
+  m_desiredType = aDesiredType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::GetRealType(nsACString& aRealType) {
+  aRealType = m_realType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::SetRealType(const nsACString& aRealType) {
+  m_realType = aRealType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::GetRealEncoding(nsACString& aRealEncoding) {
+  aRealEncoding = m_realEncoding;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::SetRealEncoding(
+    const nsACString& aRealEncoding) {
+  m_realEncoding = aRealEncoding;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::GetRealName(nsACString& aRealName) {
+  aRealName = m_realName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::SetRealName(const nsACString& aRealName) {
+  m_realName = aRealName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::GetDescription(nsACString& aDescription) {
+  aDescription = m_description;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::SetDescription(
+    const nsACString& aDescription) {
+  m_description = aDescription;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::GetXMacType(nsACString& aXMacType) {
+  aXMacType = m_xMacType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::SetXMacType(const nsACString& aXMacType) {
+  m_xMacType = aXMacType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::GetXMacCreator(nsACString& aXMacCreator) {
+  aXMacCreator = m_xMacCreator;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentData::SetXMacCreator(
+    const nsACString& aXMacCreator) {
+  m_xMacCreator = aXMacCreator;
+  return NS_OK;
+}
diff --git a/comm/mailnews/compose/src/nsMsgAttachmentData.h b/comm/mailnews/compose/src/nsMsgAttachmentData.h
new file mode 100644
index 0000000000..763a4377e9
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgAttachmentData.h
@@ -0,0 +1,131 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __MSGATTACHMENTDATA_H__
+#define __MSGATTACHMENTDATA_H__
+
+#include "nsIURL.h"
+#include "nsString.h"
+#include "nsIMsgSend.h"
+
+// Attachment file/URL structures - we're letting libmime use this directly
+class nsMsgAttachmentData final : public nsIMsgAttachmentData {
+ public:
+  NS_DECL_NSIMSGATTACHMENTDATA
+  NS_DECL_ISUPPORTS
+
+  nsMsgAttachmentData();
+  virtual ~nsMsgAttachmentData();
+
+  nsCOMPtr<nsIURI> m_url;  // The URL to attach.
+
+  nsCString m_desiredType;  // The type to which this document should be
+                            // converted.  Legal values are NULL, TEXT_PLAIN
+                            // and APPLICATION_POSTSCRIPT (which are macros
+                            // defined in net.h); other values are ignored.
+
+  nsCString
+      m_realType;  // The type of the URL if known, otherwise NULL. For example,
+                   // if you were attaching a temp file which was known to
+                   // contain HTML data, you would pass in TEXT_HTML as the
+                   // real_type, to override whatever type the name of the tmp
+                   // file might otherwise indicate.
+
+  nsCString m_realEncoding;  // Goes along with real_type
+
+  nsCString
+      m_realName;  // The original name of this document, which will eventually
+                   // show up in the Content-Disposition header. For example, if
+                   // you had copied a document to a tmp file, this would be the
+                   // original, human-readable name of the document.
+
+  nsCString m_description;  // If you put a string here, it will show up as the
+                            // Content-Description header. This can be any
+                            // explanatory text; it's not a file name.
+
+  nsCString m_disposition;    // The Content-Disposition header (if any). a
+                              // nsMsgAttachmentData can very well have
+                              // Content-Disposition: inline value, instead of
+                              // "attachment".
+  nsCString m_cloudPartInfo;  // For X-Mozilla-Cloud-Part header, if any
+
+  // Mac-specific data that should show up as optional parameters
+  // to the content-type header.
+  nsCString m_xMacType;
+  nsCString m_xMacCreator;
+
+  int32_t m_size;  // The size of the attachment. May be 0.
+  nsCString
+      m_sizeExternalStr;  // The reported size of an external attachment.
+                          // Originally set at "-1" to mean an unknown value.
+  bool m_isExternalAttachment;      // Flag for determining if the attachment is
+                                    // external
+  bool m_isExternalLinkAttachment;  // Flag for determining if the attachment is
+                                    // external and an http link.
+  bool m_isDownloaded;  // Flag for determining if the attachment has already
+                        // been downloaded
+  bool m_hasFilename;   // Tells whether the name is provided by us or if it's a
+                        // Part 1.2-like attachment
+  bool m_displayableInline;  // Tells whether the attachment could be displayed
+                             // inline
+};
+
+class nsMsgAttachedFile final : public nsIMsgAttachedFile {
+ public:
+  NS_DECL_NSIMSGATTACHEDFILE
+  NS_DECL_ISUPPORTS
+
+  nsMsgAttachedFile();
+  virtual ~nsMsgAttachedFile();
+
+  nsCOMPtr<nsIURI> m_origUrl;  // Where it came from on the network (or even
+                               // elsewhere on the local disk.)
+
+  nsCOMPtr<nsIFile> m_tmpFile;  // The tmp file in which the (possibly
+                                // converted) data now resides.
+
+  nsCString m_type;  // The type of the data in file_name (not necessarily the
+                     // same as the type of orig_url.)
+
+  nsCString
+      m_encoding;  // Likewise, the encoding of the tmp file. This will be set
+                   // only if the original document had an encoding already; we
+                   // don't do base64 encoding and so forth until it's time to
+                   // assemble a full MIME message of all parts.
+
+  nsCString m_description;    // For Content-Description header
+  nsCString m_cloudPartInfo;  // For X-Mozilla-Cloud-Part header, if any
+  nsCString m_xMacType;       // mac-specific info
+  nsCString m_xMacCreator;    // mac-specific info
+  nsCString m_realName;       // The real name of the file.
+
+  // Some statistics about the data that was written to the file, so that when
+  // it comes time to compose a MIME message, we can make an informed decision
+  // about what Content-Transfer-Encoding would be best for this attachment.
+  // (If it's encoded already, we ignore this information and ship it as-is.)
+  uint32_t m_size;
+  uint32_t m_unprintableCount;
+  uint32_t m_highbitCount;
+  uint32_t m_ctlCount;
+  uint32_t m_nullCount;
+  uint32_t m_maxLineLength;
+};
+
+#undef MOZ_ASSERT_TYPE_OK_FOR_REFCOUNTING
+#ifdef MOZ_IS_DESTRUCTIBLE
+#  define MOZ_ASSERT_TYPE_OK_FOR_REFCOUNTING(X)                              \
+    static_assert(                                                           \
+        !MOZ_IS_DESTRUCTIBLE(X) ||                                           \
+            mozilla::IsSame<X, nsMsgAttachmentData>::value ||                \
+            mozilla::IsSame<X, nsMsgAttachedFile>::value,                    \
+        "Reference-counted class " #X                                        \
+        " should not have a public destructor. "                             \
+        "Try to make this class's destructor non-public. If that is really " \
+        "not possible, you can whitelist this class by providing a "         \
+        "HasDangerousPublicDestructor specialization for it.");
+#else
+#  define MOZ_ASSERT_TYPE_OK_FOR_REFCOUNTING(X)
+#endif
+#endif
diff --git a/comm/mailnews/compose/src/nsMsgCompFields.cpp b/comm/mailnews/compose/src/nsMsgCompFields.cpp
new file mode 100644
index 0000000000..9bfb66a253
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgCompFields.cpp
@@ -0,0 +1,559 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgCompose.h"
+#include "nsMsgCompFields.h"
+#include "nsMsgI18N.h"
+#include "nsMsgCompUtils.h"
+#include "nsMsgUtils.h"
+#include "prmem.h"
+#include "nsIFileChannel.h"
+#include "nsIMsgAttachment.h"
+#include "nsIMsgMdnGenerator.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMemory.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+
+using namespace mozilla::mailnews;
+
+struct HeaderInfo {
+  /// Header name
+  const char* mName;
+  /// If true, nsMsgCompFields should reflect the raw header value instead of
+  /// the unstructured header value.
+  bool mStructured;
+};
+
+// This is a mapping of the m_headers local set to the actual header name we
+// store on the structured header object.
+static HeaderInfo kHeaders[] = {
+    {"From", true},
+    {"Reply-To", true},
+    {"To", true},
+    {"Cc", true},
+    {"Bcc", true},
+    {nullptr, false},  // FCC
+    {nullptr, false},  // FCC2
+    {"Newsgroups", true},
+    {"Followup-To", true},
+    {"Subject", false},
+    {"Organization", false},
+    {"References", true},
+    {"X-Mozilla-News-Host", false},
+    {"X-Priority", false},
+    {nullptr, false},  // CHARACTER_SET
+    {"Message-Id", true},
+    {"X-Template", true},
+    {nullptr, false},  // DRAFT_ID
+    {nullptr, false},  // TEMPLATE_ID
+    {"Content-Language", true},
+    {nullptr, false}  // CREATOR IDENTITY KEY
+};
+
+static_assert(
+    MOZ_ARRAY_LENGTH(kHeaders) == nsMsgCompFields::MSG_MAX_HEADERS,
+    "These two arrays need to be kept in sync or bad things will happen!");
+
+NS_IMPL_ISUPPORTS(nsMsgCompFields, nsIMsgCompFields, msgIStructuredHeaders,
+                  msgIWritableStructuredHeaders)
+
+nsMsgCompFields::nsMsgCompFields()
+    : mStructuredHeaders(do_CreateInstance(NS_ISTRUCTUREDHEADERS_CONTRACTID)) {
+  m_body.Truncate();
+
+  m_attachVCard = false;
+  m_forcePlainText = false;
+  m_useMultipartAlternative = false;
+  m_returnReceipt = false;
+  m_receiptHeaderType = nsIMsgMdnGenerator::eDntType;
+  m_DSN = false;
+  m_bodyIsAsciiOnly = false;
+  m_forceMsgEncoding = false;
+  m_needToCheckCharset = true;
+  m_attachmentReminder = false;
+  m_deliveryFormat = nsIMsgCompSendFormat::Unset;
+}
+
+nsMsgCompFields::~nsMsgCompFields() {
+  MOZ_LOG(Compose, mozilla::LogLevel::Debug, ("~nsMsgCompFields()"));
+}
+
+nsresult nsMsgCompFields::SetAsciiHeader(MsgHeaderID header,
+                                         const char* value) {
+  NS_ASSERTION(header >= 0 && header < MSG_MAX_HEADERS,
+               "Invalid message header index!");
+
+  // If we are storing this on the structured header object, we need to set the
+  // value on that object as well. Note that the value may be null, which we'll
+  // take as an attempt to delete the header.
+  const char* headerName = kHeaders[header].mName;
+  if (headerName) {
+    if (!value || !*value) return mStructuredHeaders->DeleteHeader(headerName);
+
+    return mStructuredHeaders->SetRawHeader(headerName,
+                                            nsDependentCString(value));
+  }
+
+  // Not on the structurd header object, so save it locally.
+  m_headers[header] = value;
+
+  return NS_OK;
+}
+
+const char* nsMsgCompFields::GetAsciiHeader(MsgHeaderID header) {
+  NS_ASSERTION(header >= 0 && header < MSG_MAX_HEADERS,
+               "Invalid message header index!");
+
+  const char* headerName = kHeaders[header].mName;
+  if (headerName) {
+    // We may be out of sync with the structured header object. Retrieve the
+    // header value.
+    if (kHeaders[header].mStructured) {
+      mStructuredHeaders->GetRawHeader(headerName, m_headers[header]);
+    } else {
+      nsString value;
+      mStructuredHeaders->GetUnstructuredHeader(headerName, value);
+      CopyUTF16toUTF8(value, m_headers[header]);
+    }
+  }
+
+  return m_headers[header].get();
+}
+
+nsresult nsMsgCompFields::SetUnicodeHeader(MsgHeaderID header,
+                                           const nsAString& value) {
+  return SetAsciiHeader(header, NS_ConvertUTF16toUTF8(value).get());
+}
+
+nsresult nsMsgCompFields::GetUnicodeHeader(MsgHeaderID header,
+                                           nsAString& aResult) {
+  CopyUTF8toUTF16(nsDependentCString(GetAsciiHeader(header)), aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetFrom(const nsAString& value) {
+  return SetUnicodeHeader(MSG_FROM_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetFrom(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_FROM_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetReplyTo(const nsAString& value) {
+  return SetUnicodeHeader(MSG_REPLY_TO_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetReplyTo(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_REPLY_TO_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetTo(const nsAString& value) {
+  return SetUnicodeHeader(MSG_TO_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetTo(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_TO_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetCc(const nsAString& value) {
+  return SetUnicodeHeader(MSG_CC_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetCc(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_CC_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetBcc(const nsAString& value) {
+  return SetUnicodeHeader(MSG_BCC_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetBcc(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_BCC_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetFcc(const nsAString& value) {
+  return SetUnicodeHeader(MSG_FCC_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetFcc(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_FCC_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetFcc2(const nsAString& value) {
+  return SetUnicodeHeader(MSG_FCC2_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetFcc2(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_FCC2_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetNewsgroups(const nsAString& aValue) {
+  return SetUnicodeHeader(MSG_NEWSGROUPS_HEADER_ID, aValue);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetNewsgroups(nsAString& aGroup) {
+  return GetUnicodeHeader(MSG_NEWSGROUPS_HEADER_ID, aGroup);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetFollowupTo(const nsAString& aValue) {
+  return SetUnicodeHeader(MSG_FOLLOWUP_TO_HEADER_ID, aValue);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetFollowupTo(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_FOLLOWUP_TO_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetHasRecipients(bool* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  *_retval = NS_SUCCEEDED(mime_sanity_check_fields_recipients(
+      GetTo(), GetCc(), GetBcc(), GetNewsgroups()));
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetCreatorIdentityKey(const char* value) {
+  return SetAsciiHeader(MSG_CREATOR_IDENTITY_KEY_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetCreatorIdentityKey(char** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = strdup(GetAsciiHeader(MSG_CREATOR_IDENTITY_KEY_ID));
+  return *_retval ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetSubject(const nsAString& value) {
+  return SetUnicodeHeader(MSG_SUBJECT_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetSubject(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_SUBJECT_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetOrganization(const nsAString& value) {
+  return SetUnicodeHeader(MSG_ORGANIZATION_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetOrganization(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_ORGANIZATION_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetReferences(const char* value) {
+  return SetAsciiHeader(MSG_REFERENCES_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetReferences(char** _retval) {
+  *_retval = strdup(GetAsciiHeader(MSG_REFERENCES_HEADER_ID));
+  return *_retval ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetNewspostUrl(const char* value) {
+  return SetAsciiHeader(MSG_NEWSPOSTURL_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetNewspostUrl(char** _retval) {
+  *_retval = strdup(GetAsciiHeader(MSG_NEWSPOSTURL_HEADER_ID));
+  return *_retval ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetPriority(const char* value) {
+  return SetAsciiHeader(MSG_PRIORITY_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetPriority(char** _retval) {
+  *_retval = strdup(GetAsciiHeader(MSG_PRIORITY_HEADER_ID));
+  return *_retval ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetMessageId(const char* value) {
+  return SetAsciiHeader(MSG_MESSAGE_ID_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetMessageId(char** _retval) {
+  *_retval = strdup(GetAsciiHeader(MSG_MESSAGE_ID_HEADER_ID));
+  return *_retval ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetTemplateName(const nsAString& value) {
+  return SetUnicodeHeader(MSG_X_TEMPLATE_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetTemplateName(nsAString& _retval) {
+  return GetUnicodeHeader(MSG_X_TEMPLATE_HEADER_ID, _retval);
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetDraftId(const nsACString& value) {
+  return SetAsciiHeader(MSG_DRAFT_ID_HEADER_ID,
+                        PromiseFlatCString(value).get());
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetDraftId(nsACString& _retval) {
+  _retval.Assign(GetAsciiHeader(MSG_DRAFT_ID_HEADER_ID));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetTemplateId(const nsACString& value) {
+  return SetAsciiHeader(MSG_TEMPLATE_ID_HEADER_ID,
+                        PromiseFlatCString(value).get());
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetTemplateId(nsACString& _retval) {
+  _retval.Assign(GetAsciiHeader(MSG_TEMPLATE_ID_HEADER_ID));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetReturnReceipt(bool value) {
+  m_returnReceipt = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetReturnReceipt(bool* _retval) {
+  *_retval = m_returnReceipt;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetReceiptHeaderType(int32_t value) {
+  m_receiptHeaderType = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetReceiptHeaderType(int32_t* _retval) {
+  *_retval = m_receiptHeaderType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetDSN(bool value) {
+  m_DSN = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetDSN(bool* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = m_DSN;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetAttachVCard(bool value) {
+  m_attachVCard = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetAttachVCard(bool* _retval) {
+  *_retval = m_attachVCard;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetAttachmentReminder(bool* _retval) {
+  *_retval = m_attachmentReminder;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetAttachmentReminder(bool value) {
+  m_attachmentReminder = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetDeliveryFormat(int32_t value) {
+  switch (value) {
+    case nsIMsgCompSendFormat::Auto:
+    case nsIMsgCompSendFormat::PlainText:
+    case nsIMsgCompSendFormat::HTML:
+    case nsIMsgCompSendFormat::Both:
+      m_deliveryFormat = value;
+      break;
+    case nsIMsgCompSendFormat::Unset:
+    default:
+      m_deliveryFormat = nsIMsgCompSendFormat::Unset;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetDeliveryFormat(int32_t* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = m_deliveryFormat;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetContentLanguage(const char* value) {
+  return SetAsciiHeader(MSG_CONTENT_LANGUAGE_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetContentLanguage(char** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = strdup(GetAsciiHeader(MSG_CONTENT_LANGUAGE_ID));
+  return *_retval ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetForcePlainText(bool value) {
+  m_forcePlainText = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetForcePlainText(bool* _retval) {
+  *_retval = m_forcePlainText;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetForceMsgEncoding(bool value) {
+  m_forceMsgEncoding = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetForceMsgEncoding(bool* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = m_forceMsgEncoding;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetUseMultipartAlternative(bool value) {
+  m_useMultipartAlternative = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetUseMultipartAlternative(bool* _retval) {
+  *_retval = m_useMultipartAlternative;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetBodyIsAsciiOnly(bool value) {
+  m_bodyIsAsciiOnly = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetBodyIsAsciiOnly(bool* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  *_retval = m_bodyIsAsciiOnly;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetBody(const nsAString& value) {
+  m_body = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetBody(nsAString& _retval) {
+  _retval = m_body;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetAttachments(
+    nsTArray<RefPtr<nsIMsgAttachment>>& attachments) {
+  attachments = m_attachments.Clone();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::AddAttachment(nsIMsgAttachment* attachment) {
+  // Don't add the same attachment twice.
+  for (nsIMsgAttachment* a : m_attachments) {
+    bool sameUrl;
+    a->EqualsUrl(attachment, &sameUrl);
+    if (sameUrl) return NS_OK;
+  }
+  m_attachments.AppendElement(attachment);
+  return NS_OK;
+}
+
+/* void removeAttachment (in nsIMsgAttachment attachment); */
+NS_IMETHODIMP nsMsgCompFields::RemoveAttachment(nsIMsgAttachment* attachment) {
+  for (uint32_t i = 0; i < m_attachments.Length(); i++) {
+    bool sameUrl;
+    m_attachments[i]->EqualsUrl(attachment, &sameUrl);
+    if (sameUrl) {
+      m_attachments.RemoveElementAt(i);
+      break;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetOtherHeaders(
+    const nsTArray<nsString>& headers) {
+  m_otherHeaders = headers.Clone();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetOtherHeaders(nsTArray<nsString>& headers) {
+  headers = m_otherHeaders.Clone();
+  return NS_OK;
+}
+
+/* void removeAttachments (); */
+NS_IMETHODIMP nsMsgCompFields::RemoveAttachments() {
+  m_attachments.Clear();
+  return NS_OK;
+}
+
+// This method is called during the creation of a new window.
+NS_IMETHODIMP
+nsMsgCompFields::SplitRecipients(const nsAString& aRecipients,
+                                 bool aEmailAddressOnly,
+                                 nsTArray<nsString>& aResult) {
+  nsCOMArray<msgIAddressObject> header(EncodedHeaderW(aRecipients));
+  if (aEmailAddressOnly)
+    ExtractEmails(header, aResult);
+  else
+    ExtractDisplayAddresses(header, aResult);
+
+  return NS_OK;
+}
+
+// This method is called during the sending of message from
+// nsMsgCompose::CheckAndPopulateRecipients()
+nsresult nsMsgCompFields::SplitRecipientsEx(const nsAString& recipients,
+                                            nsTArray<nsMsgRecipient>& aResult) {
+  nsTArray<nsString> names, addresses;
+  ExtractAllAddresses(EncodedHeaderW(recipients), names, addresses);
+
+  uint32_t numAddresses = names.Length();
+  for (uint32_t i = 0; i < numAddresses; ++i) {
+    nsMsgRecipient msgRecipient;
+    msgRecipient.mEmail = addresses[i];
+    msgRecipient.mName = names[i];
+    aResult.AppendElement(msgRecipient);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::ConvertBodyToPlainText() {
+  nsresult rv = NS_OK;
+
+  if (!m_body.IsEmpty()) {
+    if (NS_SUCCEEDED(rv)) {
+      bool flowed, formatted;
+      GetSerialiserFlags(&flowed, &formatted);
+      rv = ConvertBufToPlainText(m_body, flowed, formatted, true);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetComposeSecure(
+    nsIMsgComposeSecure** aComposeSecure) {
+  NS_ENSURE_ARG_POINTER(aComposeSecure);
+  NS_IF_ADDREF(*aComposeSecure = mSecureCompFields);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetComposeSecure(
+    nsIMsgComposeSecure* aComposeSecure) {
+  mSecureCompFields = aComposeSecure;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetNeedToCheckCharset(bool* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = m_needToCheckCharset;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetNeedToCheckCharset(bool aCheck) {
+  m_needToCheckCharset = aCheck;
+  return NS_OK;
+}
diff --git a/comm/mailnews/compose/src/nsMsgCompFields.h b/comm/mailnews/compose/src/nsMsgCompFields.h
new file mode 100644
index 0000000000..312d19192c
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgCompFields.h
@@ -0,0 +1,212 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MsgCompFields_H_
+#define _MsgCompFields_H_
+
+#include "nsIMsgCompFields.h"
+#include "msgCore.h"
+#include "nsIAbCard.h"
+#include "nsIAbDirectory.h"
+#include "nsTArray.h"
+#include "nsCOMArray.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "nsIMsgComposeSecure.h"
+
+struct nsMsgRecipient {
+  nsString mName;
+  nsString mEmail;
+  nsCOMPtr<nsIAbCard> mCard;
+  nsCOMPtr<nsIAbDirectory> mDirectory;
+};
+
+/* Note that all the "Get" methods never return NULL (except in case of serious
+   error, like an illegal parameter); rather, they return "" if things were set
+   to NULL.  This makes it real handy for the callers. */
+
+class nsMsgCompFields : public nsIMsgCompFields {
+ public:
+  nsMsgCompFields();
+
+  /* this macro defines QueryInterface, AddRef and Release for this class */
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_FORWARD_MSGISTRUCTUREDHEADERS(mStructuredHeaders->)
+  NS_FORWARD_MSGIWRITABLESTRUCTUREDHEADERS(mStructuredHeaders->)
+  NS_DECL_NSIMSGCOMPFIELDS
+
+  typedef enum MsgHeaderID {
+    MSG_FROM_HEADER_ID = 0,
+    MSG_REPLY_TO_HEADER_ID,
+    MSG_TO_HEADER_ID,
+    MSG_CC_HEADER_ID,
+    MSG_BCC_HEADER_ID,
+    MSG_FCC_HEADER_ID,
+    MSG_FCC2_HEADER_ID,
+    MSG_NEWSGROUPS_HEADER_ID,
+    MSG_FOLLOWUP_TO_HEADER_ID,
+    MSG_SUBJECT_HEADER_ID,
+    MSG_ORGANIZATION_HEADER_ID,
+    MSG_REFERENCES_HEADER_ID,
+    MSG_NEWSPOSTURL_HEADER_ID,
+    MSG_PRIORITY_HEADER_ID,
+    MSG_CHARACTER_SET_HEADER_ID,
+    MSG_MESSAGE_ID_HEADER_ID,
+    MSG_X_TEMPLATE_HEADER_ID,
+    MSG_DRAFT_ID_HEADER_ID,
+    MSG_TEMPLATE_ID_HEADER_ID,
+    MSG_CONTENT_LANGUAGE_ID,
+    MSG_CREATOR_IDENTITY_KEY_ID,
+
+    MSG_MAX_HEADERS  // Must be the last one.
+  } MsgHeaderID;
+
+  nsresult SetAsciiHeader(MsgHeaderID header, const char* value);
+  const char* GetAsciiHeader(
+      MsgHeaderID header);  // just return the address of the internal header
+                            // variable, don't dispose it
+
+  nsresult SetUnicodeHeader(MsgHeaderID header, const nsAString& value);
+  nsresult GetUnicodeHeader(MsgHeaderID header, nsAString& _retval);
+
+  /* Convenience routines to get and set header's value...
+
+    IMPORTANT:
+    all routines const char* GetXxx(void) will return a pointer to the header,
+    please don't free it.
+  */
+
+  nsresult SetFrom(const char* value) {
+    return SetAsciiHeader(MSG_FROM_HEADER_ID, value);
+  }
+  const char* GetFrom(void) { return GetAsciiHeader(MSG_FROM_HEADER_ID); }
+
+  nsresult SetReplyTo(const char* value) {
+    return SetAsciiHeader(MSG_REPLY_TO_HEADER_ID, value);
+  }
+  const char* GetReplyTo() { return GetAsciiHeader(MSG_REPLY_TO_HEADER_ID); }
+
+  nsresult SetTo(const char* value) {
+    return SetAsciiHeader(MSG_TO_HEADER_ID, value);
+  }
+  const char* GetTo() { return GetAsciiHeader(MSG_TO_HEADER_ID); }
+
+  nsresult SetCc(const char* value) {
+    return SetAsciiHeader(MSG_CC_HEADER_ID, value);
+  }
+  const char* GetCc() { return GetAsciiHeader(MSG_CC_HEADER_ID); }
+
+  nsresult SetBcc(const char* value) {
+    return SetAsciiHeader(MSG_BCC_HEADER_ID, value);
+  }
+  const char* GetBcc() { return GetAsciiHeader(MSG_BCC_HEADER_ID); }
+
+  nsresult SetFcc(const char* value) {
+    return SetAsciiHeader(MSG_FCC_HEADER_ID, value);
+  }
+  const char* GetFcc() { return GetAsciiHeader(MSG_FCC_HEADER_ID); }
+
+  nsresult SetFcc2(const char* value) {
+    return SetAsciiHeader(MSG_FCC2_HEADER_ID, value);
+  }
+  const char* GetFcc2() { return GetAsciiHeader(MSG_FCC2_HEADER_ID); }
+
+  nsresult SetNewsgroups(const char* aValue) {
+    return SetAsciiHeader(MSG_NEWSGROUPS_HEADER_ID, aValue);
+  }
+  const char* GetNewsgroups() {
+    return GetAsciiHeader(MSG_NEWSGROUPS_HEADER_ID);
+  }
+
+  nsresult SetFollowupTo(const char* aValue) {
+    return SetAsciiHeader(MSG_FOLLOWUP_TO_HEADER_ID, aValue);
+  }
+  const char* GetFollowupTo() {
+    return GetAsciiHeader(MSG_FOLLOWUP_TO_HEADER_ID);
+  }
+
+  nsresult SetSubject(const char* value) {
+    return SetAsciiHeader(MSG_SUBJECT_HEADER_ID, value);
+  }
+  const char* GetSubject() { return GetAsciiHeader(MSG_SUBJECT_HEADER_ID); }
+
+  nsresult SetOrganization(const char* value) {
+    return SetAsciiHeader(MSG_ORGANIZATION_HEADER_ID, value);
+  }
+  const char* GetOrganization() {
+    return GetAsciiHeader(MSG_ORGANIZATION_HEADER_ID);
+  }
+
+  const char* GetReferences() {
+    return GetAsciiHeader(MSG_REFERENCES_HEADER_ID);
+  }
+
+  const char* GetNewspostUrl() {
+    return GetAsciiHeader(MSG_NEWSPOSTURL_HEADER_ID);
+  }
+
+  const char* GetPriority() { return GetAsciiHeader(MSG_PRIORITY_HEADER_ID); }
+
+  const char* GetCharacterSet() {
+    return GetAsciiHeader(MSG_CHARACTER_SET_HEADER_ID);
+  }
+
+  const char* GetMessageId() {
+    return GetAsciiHeader(MSG_MESSAGE_ID_HEADER_ID);
+  }
+
+  nsresult SetTemplateName(const char* value) {
+    return SetAsciiHeader(MSG_X_TEMPLATE_HEADER_ID, value);
+  }
+  const char* GetTemplateName() {
+    return GetAsciiHeader(MSG_X_TEMPLATE_HEADER_ID);
+  }
+
+  const char* GetDraftId() { return GetAsciiHeader(MSG_DRAFT_ID_HEADER_ID); }
+  const char* GetTemplateId() {
+    return GetAsciiHeader(MSG_TEMPLATE_ID_HEADER_ID);
+  }
+
+  const char* GetContentLanguage() {
+    return GetAsciiHeader(MSG_CONTENT_LANGUAGE_ID);
+  }
+
+  bool GetReturnReceipt() { return m_returnReceipt; }
+  bool GetDSN() { return m_DSN; }
+  bool GetAttachVCard() { return m_attachVCard; }
+  bool GetAttachmentReminder() { return m_attachmentReminder; }
+  int32_t GetDeliveryFormat() { return m_deliveryFormat; }
+  bool GetForcePlainText() { return m_forcePlainText; }
+  bool GetUseMultipartAlternative() { return m_useMultipartAlternative; }
+  bool GetBodyIsAsciiOnly() { return m_bodyIsAsciiOnly; }
+  bool GetForceMsgEncoding() { return m_forceMsgEncoding; }
+
+  nsresult SplitRecipientsEx(const nsAString& recipients,
+                             nsTArray<nsMsgRecipient>& aResult);
+
+ protected:
+  virtual ~nsMsgCompFields();
+  nsCString m_headers[MSG_MAX_HEADERS];
+  nsString m_body;
+  nsTArray<RefPtr<nsIMsgAttachment>> m_attachments;
+  nsTArray<nsString> m_otherHeaders;
+  bool m_attachVCard;
+  bool m_attachmentReminder;
+  int32_t m_deliveryFormat;
+  bool m_forcePlainText;
+  bool m_useMultipartAlternative;
+  bool m_returnReceipt;
+  bool m_DSN;
+  bool m_bodyIsAsciiOnly;
+  bool m_forceMsgEncoding;
+  int32_t m_receiptHeaderType; /* receipt header type */
+  nsCString m_DefaultCharacterSet;
+  bool m_needToCheckCharset;
+
+  nsCOMPtr<nsIMsgComposeSecure> mSecureCompFields;
+  nsCOMPtr<msgIWritableStructuredHeaders> mStructuredHeaders;
+};
+
+#endif /* _MsgCompFields_H_ */
diff --git a/comm/mailnews/compose/src/nsMsgCompUtils.cpp b/comm/mailnews/compose/src/nsMsgCompUtils.cpp
new file mode 100644
index 0000000000..50ce86497b
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgCompUtils.cpp
@@ -0,0 +1,1164 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsCOMPtr.h"
+#include "nsMsgCompUtils.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsStringFwd.h"
+#include "prmem.h"
+#include "nsIStringBundle.h"
+#include "nsIIOService.h"
+#include "nsIHttpProtocolHandler.h"
+#include "nsMailHeaders.h"
+#include "nsMsgI18N.h"
+#include "nsINntpService.h"
+#include "nsMimeTypes.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsIURI.h"
+#include "nsNetCID.h"
+#include "nsMsgPrompts.h"
+#include "nsMsgUtils.h"
+#include "nsCExternalHandlerService.h"
+#include "nsIMIMEService.h"
+#include "nsComposeStrings.h"
+#include "nsIMsgCompUtils.h"
+#include "nsIMsgMdnGenerator.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsMemory.h"
+#include "nsCRTGlue.h"
+#include <ctype.h>
+#include "mozilla/dom/Element.h"
+#include "mozilla/EncodingDetector.h"
+#include "mozilla/Components.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Unused.h"
+#include "mozilla/ContentIterator.h"
+#include "mozilla/dom/Document.h"
+#include "nsIMIMEInfo.h"
+#include "nsIMsgHeaderParser.h"
+#include "nsIMutableArray.h"
+#include "nsIRandomGenerator.h"
+#include "nsID.h"
+
+void msg_generate_message_id(nsIMsgIdentity* identity,
+                             const nsACString& customHost,
+                             nsACString& messageID);
+
+NS_IMPL_ISUPPORTS(nsMsgCompUtils, nsIMsgCompUtils)
+
+nsMsgCompUtils::nsMsgCompUtils() {}
+
+nsMsgCompUtils::~nsMsgCompUtils() {}
+
+NS_IMETHODIMP nsMsgCompUtils::MimeMakeSeparator(const char* prefix,
+                                                char** _retval) {
+  NS_ENSURE_ARG_POINTER(prefix);
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = mime_make_separator(prefix);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompUtils::MsgGenerateMessageId(nsIMsgIdentity* identity,
+                                                   const nsACString& host,
+                                                   nsACString& messageID) {
+  // We don't check `host` because it's allowed to be a null pointer (which
+  // means we should ignore it for message ID generation).
+  NS_ENSURE_ARG_POINTER(identity);
+  msg_generate_message_id(identity, host, messageID);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompUtils::GetMsgMimeConformToStandard(bool* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = nsMsgMIMEGetConformToStandard();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompUtils::DetectCharset(const nsACString& aContent,
+                              nsACString& aCharset) {
+  mozilla::UniquePtr<mozilla::EncodingDetector> detector =
+      mozilla::EncodingDetector::Create();
+  mozilla::Span<const uint8_t> src = mozilla::AsBytes(
+      mozilla::Span(ToNewCString(aContent), aContent.Length()));
+  mozilla::Unused << detector->Feed(src, true);
+  auto encoding = detector->Guess(nullptr, true);
+  encoding->Name(aCharset);
+  return NS_OK;
+}
+
+//
+// Create a file for the a unique temp file
+// on the local machine. Caller must free memory
+//
+nsresult nsMsgCreateTempFile(const char* tFileName, nsIFile** tFile) {
+  if ((!tFileName) || (!*tFileName)) tFileName = "nsmail.tmp";
+
+  nsresult rv =
+      GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR, tFileName, tFile);
+
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = (*tFile)->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
+  if (NS_FAILED(rv)) NS_RELEASE(*tFile);
+
+  return rv;
+}
+
+// This is the value a caller will Get if they don't Set first (like MDN
+// sending a return receipt), so init to the default value of the
+// mail.strictly_mime_headers preference.
+static bool mime_headers_use_quoted_printable_p = true;
+
+bool nsMsgMIMEGetConformToStandard(void) {
+  return mime_headers_use_quoted_printable_p;
+}
+
+void nsMsgMIMESetConformToStandard(bool conform_p) {
+  /*
+   * If we are conforming to mime standard no matter what we set
+   * for the headers preference when generating mime headers we should
+   * also conform to the standard. Otherwise, depends the preference
+   * we set. For now, the headers preference is not accessible from UI.
+   */
+  if (conform_p)
+    mime_headers_use_quoted_printable_p = true;
+  else {
+    nsresult rv;
+    nsCOMPtr<nsIPrefBranch> prefs(
+        do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    if (NS_SUCCEEDED(rv)) {
+      prefs->GetBoolPref("mail.strictly_mime_headers",
+                         &mime_headers_use_quoted_printable_p);
+    }
+  }
+}
+
+/**
+ * Checks if the recipient fields have sane values for message send.
+ */
+nsresult mime_sanity_check_fields_recipients(const char* to, const char* cc,
+                                             const char* bcc,
+                                             const char* newsgroups) {
+  if (to)
+    while (IS_SPACE(*to)) to++;
+  if (cc)
+    while (IS_SPACE(*cc)) cc++;
+  if (bcc)
+    while (IS_SPACE(*bcc)) bcc++;
+  if (newsgroups)
+    while (IS_SPACE(*newsgroups)) newsgroups++;
+
+  if ((!to || !*to) && (!cc || !*cc) && (!bcc || !*bcc) &&
+      (!newsgroups || !*newsgroups))
+    return NS_MSG_NO_RECIPIENTS;
+
+  return NS_OK;
+}
+
+/**
+ * Checks if the compose fields have sane values for message send.
+ */
+nsresult mime_sanity_check_fields(
+    const char* from, const char* reply_to, const char* to, const char* cc,
+    const char* bcc, const char* fcc, const char* newsgroups,
+    const char* followup_to, const char* /*subject*/,
+    const char* /*references*/, const char* /*organization*/,
+    const char* /*other_random_headers*/) {
+  if (from)
+    while (IS_SPACE(*from)) from++;
+  if (reply_to)
+    while (IS_SPACE(*reply_to)) reply_to++;
+  if (fcc)
+    while (IS_SPACE(*fcc)) fcc++;
+  if (followup_to)
+    while (IS_SPACE(*followup_to)) followup_to++;
+
+  // TODO: sanity check other_random_headers for newline conventions
+  if (!from || !*from) return NS_MSG_NO_SENDER;
+
+  return mime_sanity_check_fields_recipients(to, cc, bcc, newsgroups);
+}
+
+// Helper macro for generating the X-Mozilla-Draft-Info header.
+#define APPEND_BOOL(method, param)         \
+  do {                                     \
+    bool val = false;                      \
+    fields->Get##method(&val);             \
+    if (val)                               \
+      draftInfo.AppendLiteral(param "=1"); \
+    else                                   \
+      draftInfo.AppendLiteral(param "=0"); \
+  } while (false)
+
+nsresult mime_generate_headers(nsIMsgCompFields* fields,
+                               nsMsgDeliverMode deliver_mode,
+                               msgIWritableStructuredHeaders* finalHeaders) {
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool isDraft = deliver_mode == nsIMsgSend::nsMsgSaveAsDraft ||
+                 deliver_mode == nsIMsgSend::nsMsgSaveAsTemplate ||
+                 deliver_mode == nsIMsgSend::nsMsgQueueForLater ||
+                 deliver_mode == nsIMsgSend::nsMsgDeliverBackground;
+
+  bool hasDisclosedRecipient = false;
+
+  MOZ_ASSERT(fields, "null fields");
+  NS_ENSURE_ARG_POINTER(fields);
+
+  nsTArray<RefPtr<msgIAddressObject>> from;
+  fields->GetAddressingHeader("From", true, from);
+
+  // Copy all headers from the original compose field.
+  rv = finalHeaders->AddAllHeaders(fields);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool hasMessageId = false;
+  if (NS_SUCCEEDED(fields->HasHeader("Message-ID", &hasMessageId)) &&
+      hasMessageId) {
+    /* MDN request header requires to have MessageID header presented
+     * in the message in order to
+     * coorelate the MDN reports to the original message. Here will be
+     * the right place
+     */
+
+    bool returnReceipt = false;
+    fields->GetReturnReceipt(&returnReceipt);
+    if (returnReceipt && (deliver_mode != nsIMsgSend::nsMsgSaveAsDraft &&
+                          deliver_mode != nsIMsgSend::nsMsgSaveAsTemplate)) {
+      int32_t receipt_header_type = nsIMsgMdnGenerator::eDntType;
+      fields->GetReceiptHeaderType(&receipt_header_type);
+
+      // nsIMsgMdnGenerator::eDntType = MDN Disposition-Notification-To: ;
+      // nsIMsgMdnGenerator::eRrtType = Return-Receipt-To: ;
+      // nsIMsgMdnGenerator::eDntRrtType = both MDN DNT and RRT headers .
+      if (receipt_header_type != nsIMsgMdnGenerator::eRrtType)
+        finalHeaders->SetAddressingHeader("Disposition-Notification-To", from);
+      if (receipt_header_type != nsIMsgMdnGenerator::eDntType)
+        finalHeaders->SetAddressingHeader("Return-Receipt-To", from);
+    }
+  }
+
+  PRExplodedTime now;
+  PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &now);
+  int gmtoffset =
+      (now.tm_params.tp_gmt_offset + now.tm_params.tp_dst_offset) / 60;
+
+  // Use PR_FormatTimeUSEnglish() to format the date in US English format,
+  // then figure out what our local GMT offset is, and append it (since
+  // PR_FormatTimeUSEnglish() can't do that.) Generate four digit years as
+  // per RFC 1123 (superseding RFC 822.)
+  char dateString[130];
+  PR_FormatTimeUSEnglish(dateString, sizeof(dateString),
+                         "%a, %d %b %Y %H:%M:%S ", &now);
+
+  char* entryPoint = dateString + strlen(dateString);
+  PR_snprintf(entryPoint, sizeof(dateString) - (entryPoint - dateString),
+              "%c%02d%02d" CRLF, (gmtoffset >= 0 ? '+' : '-'),
+              ((gmtoffset >= 0 ? gmtoffset : -gmtoffset) / 60),
+              ((gmtoffset >= 0 ? gmtoffset : -gmtoffset) % 60));
+  finalHeaders->SetRawHeader("Date", nsDependentCString(dateString));
+
+  // X-Mozilla-Draft-Info
+  if (isDraft) {
+    nsAutoCString draftInfo;
+    draftInfo.AppendLiteral("internal/draft; ");
+    APPEND_BOOL(AttachVCard, "vcard");
+    draftInfo.AppendLiteral("; ");
+    bool hasReturnReceipt = false;
+    fields->GetReturnReceipt(&hasReturnReceipt);
+    if (hasReturnReceipt) {
+      // slight change compared to 4.x; we used to use receipt= to tell
+      // whether the draft/template has request for either MDN or DNS or both
+      // return receipt; since the DNS is out of the picture we now use the
+      // header type + 1 to tell whether user has requested the return receipt
+      int32_t headerType = 0;
+      fields->GetReceiptHeaderType(&headerType);
+      draftInfo.AppendLiteral("receipt=");
+      draftInfo.AppendInt(headerType + 1);
+    } else
+      draftInfo.AppendLiteral("receipt=0");
+    draftInfo.AppendLiteral("; ");
+    APPEND_BOOL(DSN, "DSN");
+    draftInfo.AppendLiteral("; ");
+    draftInfo.AppendLiteral("uuencode=0");
+    draftInfo.AppendLiteral("; ");
+    APPEND_BOOL(AttachmentReminder, "attachmentreminder");
+    draftInfo.AppendLiteral("; ");
+    int32_t deliveryFormat;
+    fields->GetDeliveryFormat(&deliveryFormat);
+    draftInfo.AppendLiteral("deliveryformat=");
+    draftInfo.AppendInt(deliveryFormat);
+
+    finalHeaders->SetRawHeader(HEADER_X_MOZILLA_DRAFT_INFO, draftInfo);
+  }
+
+  bool sendUserAgent = false;
+  if (prefs) {
+    prefs->GetBoolPref("mailnews.headers.sendUserAgent", &sendUserAgent);
+  }
+  if (sendUserAgent) {
+    bool useMinimalUserAgent = false;
+    if (prefs) {
+      prefs->GetBoolPref("mailnews.headers.useMinimalUserAgent",
+                         &useMinimalUserAgent);
+    }
+    if (useMinimalUserAgent) {
+      nsCOMPtr<nsIStringBundleService> bundleService =
+          mozilla::components::StringBundle::Service();
+      if (bundleService) {
+        nsCOMPtr<nsIStringBundle> brandBundle;
+        rv = bundleService->CreateBundle(
+            "chrome://branding/locale/brand.properties",
+            getter_AddRefs(brandBundle));
+        if (NS_SUCCEEDED(rv)) {
+          nsString brandName;
+          brandBundle->GetStringFromName("brandFullName", brandName);
+          if (!brandName.IsEmpty())
+            finalHeaders->SetUnstructuredHeader("User-Agent", brandName);
+        }
+      }
+    } else {
+      nsCOMPtr<nsIHttpProtocolHandler> pHTTPHandler =
+          do_GetService(NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "http", &rv);
+      if (NS_SUCCEEDED(rv) && pHTTPHandler) {
+        nsAutoCString userAgentString;
+        // Ignore error since we're testing the return value.
+        mozilla::Unused << pHTTPHandler->GetUserAgent(userAgentString);
+
+        if (!userAgentString.IsEmpty())
+          finalHeaders->SetUnstructuredHeader(
+              "User-Agent", NS_ConvertUTF8toUTF16(userAgentString));
+      }
+    }
+  }
+
+  finalHeaders->SetUnstructuredHeader("MIME-Version", u"1.0"_ns);
+
+  nsAutoCString newsgroups;
+  finalHeaders->GetRawHeader("Newsgroups", newsgroups);
+  if (!newsgroups.IsEmpty()) {
+    // Since the newsgroup header can contain data in the form of:
+    // "news://news.mozilla.org/netscape.test,news://news.mozilla.org/netscape.junk"
+    // we need to turn that into: "netscape.test,netscape.junk"
+    // (XXX: can it really?)
+    nsCOMPtr<nsINntpService> nntpService =
+        do_GetService("@mozilla.org/messenger/nntpservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCString newsgroupsHeaderVal;
+    nsCString newshostHeaderVal;
+    rv = nntpService->GenerateNewsHeaderValsForPosting(
+        newsgroups, getter_Copies(newsgroupsHeaderVal),
+        getter_Copies(newshostHeaderVal));
+    NS_ENSURE_SUCCESS(rv, rv);
+    finalHeaders->SetRawHeader("Newsgroups", newsgroupsHeaderVal);
+
+    // If we are here, we are NOT going to send this now. (i.e. it is a Draft,
+    // Send Later file, etc...). Because of that, we need to store what the user
+    // typed in on the original composition window for use later when rebuilding
+    // the headers
+    if (deliver_mode != nsIMsgSend::nsMsgDeliverNow &&
+        deliver_mode != nsIMsgSend::nsMsgSendUnsent) {
+      // This is going to be saved for later, that means we should just store
+      // what the user typed into the "Newsgroup" line in the
+      // HEADER_X_MOZILLA_NEWSHOST header for later use by "Send Unsent
+      // Messages", "Drafts" or "Templates"
+      finalHeaders->SetRawHeader(HEADER_X_MOZILLA_NEWSHOST, newshostHeaderVal);
+    }
+
+    // Newsgroups are a recipient...
+    hasDisclosedRecipient = true;
+  }
+
+  nsTArray<RefPtr<msgIAddressObject>> recipients;
+  finalHeaders->GetAddressingHeader("To", false, recipients);
+  hasDisclosedRecipient |= !recipients.IsEmpty();
+  finalHeaders->GetAddressingHeader("Cc", false, recipients);
+  hasDisclosedRecipient |= !recipients.IsEmpty();
+
+  // If we don't have disclosed recipient (only Bcc), address the message to
+  // undisclosed-recipients to prevent problem with some servers
+
+  // If we are saving the message as a draft, don't bother inserting the
+  // undisclosed recipients field. We'll take care of that when we really send
+  // the message.
+  if (!hasDisclosedRecipient &&
+      (!isDraft || deliver_mode == nsIMsgSend::nsMsgQueueForLater)) {
+    bool bAddUndisclosedRecipients = true;
+    prefs->GetBoolPref("mail.compose.add_undisclosed_recipients",
+                       &bAddUndisclosedRecipients);
+    if (bAddUndisclosedRecipients) {
+      bool hasBcc = false;
+      fields->HasHeader("Bcc", &hasBcc);
+      if (hasBcc) {
+        nsCOMPtr<nsIStringBundleService> stringService =
+            mozilla::components::StringBundle::Service();
+        if (stringService) {
+          nsCOMPtr<nsIStringBundle> composeStringBundle;
+          rv = stringService->CreateBundle(
+              "chrome://messenger/locale/messengercompose/"
+              "composeMsgs.properties",
+              getter_AddRefs(composeStringBundle));
+          if (NS_SUCCEEDED(rv)) {
+            nsString undisclosedRecipients;
+            rv = composeStringBundle->GetStringFromName("undisclosedRecipients",
+                                                        undisclosedRecipients);
+            if (NS_SUCCEEDED(rv) && !undisclosedRecipients.IsEmpty()) {
+              nsCOMPtr<nsIMsgHeaderParser> headerParser(
+                  mozilla::components::HeaderParser::Service());
+              nsCOMPtr<msgIAddressObject> group;
+              nsTArray<RefPtr<msgIAddressObject>> noRecipients;
+              headerParser->MakeGroupObject(undisclosedRecipients, noRecipients,
+                                            getter_AddRefs(group));
+              recipients.AppendElement(group);
+              finalHeaders->SetAddressingHeader("To", recipients);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // We don't want to emit a Bcc header to the output. If we are saving this to
+  // Drafts/Sent, this is re-added later in nsMsgSend.cpp.
+  finalHeaders->DeleteHeader("bcc");
+
+  // Skip no or empty priority.
+  nsAutoCString priority;
+  rv = fields->GetRawHeader("X-Priority", priority);
+  if (NS_SUCCEEDED(rv) && !priority.IsEmpty()) {
+    nsMsgPriorityValue priorityValue;
+
+    NS_MsgGetPriorityFromString(priority.get(), priorityValue);
+
+    // Skip default priority.
+    if (priorityValue != nsMsgPriority::Default) {
+      nsAutoCString priorityName;
+      nsAutoCString priorityValueString;
+
+      NS_MsgGetPriorityValueString(priorityValue, priorityValueString);
+      NS_MsgGetUntranslatedPriorityName(priorityValue, priorityName);
+
+      // Output format: [X-Priority: <pValue> (<pName>)]
+      priorityValueString.AppendLiteral(" (");
+      priorityValueString += priorityName;
+      priorityValueString.Append(')');
+      finalHeaders->SetRawHeader("X-Priority", priorityValueString);
+    }
+  }
+
+  nsAutoCString references;
+  finalHeaders->GetRawHeader("References", references);
+  if (!references.IsEmpty()) {
+    // The References header should be kept under 998 characters: if it's too
+    // long, trim out the earliest references to make it smaller.
+    if (references.Length() > 986) {
+      int32_t firstRef = references.FindChar('<');
+      int32_t secondRef = references.FindChar('<', firstRef + 1);
+      if (secondRef > 0) {
+        nsAutoCString newReferences(StringHead(references, secondRef));
+        int32_t bracket = references.FindChar(
+            '<', references.Length() + newReferences.Length() - 986);
+        if (bracket > 0) {
+          newReferences.Append(Substring(references, bracket));
+          finalHeaders->SetRawHeader("References", newReferences);
+        }
+      }
+    }
+    // The In-Reply-To header is the last entry in the references header...
+    int32_t bracket = references.RFind("<");
+    if (bracket >= 0)
+      finalHeaders->SetRawHeader("In-Reply-To", Substring(references, bracket));
+  }
+
+  return NS_OK;
+}
+
+#undef APPEND_BOOL  // X-Mozilla-Draft-Info helper macro
+
+static void GenerateGlobalRandomBytes(unsigned char* buf, int32_t len) {
+  // Attempt to generate bytes from system entropy-based RNG.
+  nsCOMPtr<nsIRandomGenerator> randomGenerator(
+      do_GetService("@mozilla.org/security/random-generator;1"));
+  MOZ_ASSERT(randomGenerator, "nsIRandomGenerator service not retrievable");
+  uint8_t* tempBuffer;
+  nsresult rv = randomGenerator->GenerateRandomBytes(len, &tempBuffer);
+  if (NS_SUCCEEDED(rv)) {
+    memcpy(buf, tempBuffer, len);
+    free(tempBuffer);
+    return;
+  }
+  // nsIRandomGenerator failed -- fall back to low entropy PRNG.
+  static bool firstTime = true;
+  if (firstTime) {
+    // Seed the random-number generator with current time so that
+    // the numbers will be different every time we run.
+    srand((unsigned)PR_Now());
+    firstTime = false;
+  }
+
+  for (int32_t i = 0; i < len; i++) buf[i] = rand() % 256;
+}
+
+char* mime_make_separator(const char* prefix) {
+  unsigned char rand_buf[13];
+  GenerateGlobalRandomBytes(rand_buf, 12);
+
+  return PR_smprintf(
+      "------------%s"
+      "%02X%02X%02X%02X"
+      "%02X%02X%02X%02X"
+      "%02X%02X%02X%02X",
+      prefix, rand_buf[0], rand_buf[1], rand_buf[2], rand_buf[3], rand_buf[4],
+      rand_buf[5], rand_buf[6], rand_buf[7], rand_buf[8], rand_buf[9],
+      rand_buf[10], rand_buf[11]);
+}
+
+// Tests if the content of a string is a valid host name.
+// In this case, a valid host name is any non-empty string that only contains
+// letters (a-z + A-Z), numbers (0-9) and the characters '-', '_' and '.'.
+static bool isValidHost(const nsCString& host) {
+  if (host.IsEmpty()) {
+    return false;
+  }
+
+  const auto* cur = host.BeginReading();
+  const auto* end = host.EndReading();
+  for (; cur < end; ++cur) {
+    if (!isalpha(*cur) && !isdigit(*cur) && *cur != '-' && *cur != '_' &&
+        *cur != '.') {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// Extract the domain name from an address.
+// If none could be found (i.e. the address does not contain an '@' sign, or
+// the value following it is not a valid domain), then nullptr is returned.
+void msg_domain_name_from_address(const nsACString& address, nsACString& host) {
+  auto atIndex = address.FindChar('@');
+
+  if (address.IsEmpty() || atIndex == kNotFound) {
+    return;
+  }
+
+  // Substring() should handle cases where we would go out of bounds (by
+  // preventing the index from exceeding the length of the source string), so we
+  // don't need to handle this here.
+  host = Substring(address, atIndex + 1);
+}
+
+// Generate a value for a Message-Id header using the identity and optional
+// hostname provided.
+void msg_generate_message_id(nsIMsgIdentity* identity,
+                             const nsACString& customHost,
+                             nsACString& messageID) {
+  nsCString host;
+
+  // Check if the identity forces host name. This is sometimes the case when
+  // using newsgroup.
+  nsCString forcedFQDN;
+  nsresult rv = identity->GetCharAttribute("FQDN", forcedFQDN);
+  if (NS_SUCCEEDED(rv) && !forcedFQDN.IsEmpty()) {
+    host = forcedFQDN;
+  }
+
+  // If no valid host name has been set, try using the value defined by the
+  // caller, if any.
+  if (!isValidHost(host)) {
+    host = customHost;
+  }
+
+  // If no valid host name has been set, try extracting one from the email
+  // address associated with the identity.
+  if (!isValidHost(host)) {
+    nsCString from;
+    rv = identity->GetEmail(from);
+    if (NS_SUCCEEDED(rv) && !from.IsEmpty()) {
+      msg_domain_name_from_address(from, host);
+    }
+  }
+
+  // If we still couldn't find a valid host name to use, we can't generate a
+  // valid message ID, so bail, and let NNTP and SMTP generate them.
+  if (!isValidHost(host)) {
+    return;
+  }
+
+  // Generate 128-bit UUID for the local part of the ID. `nsID` provides us with
+  // cryptographically-secure generation.
+  nsID uuid = nsID::GenerateUUID();
+  char uuidString[NSID_LENGTH];
+  uuid.ToProvidedString(uuidString);
+  // Drop first and last characters (curly braces).
+  uuidString[NSID_LENGTH - 2] = 0;
+
+  messageID.AppendPrintf("<%s@%s>", uuidString + 1, host.get());
+}
+
+// this is to guarantee the folded line will never be greater
+// than 78 = 75 + CRLFLWSP
+#define PR_MAX_FOLDING_LEN 75
+
+/*static */ char* RFC2231ParmFolding(const char* parmName,
+                                     const char* parmValue) {
+  NS_ENSURE_TRUE(parmName && *parmName && parmValue && *parmValue, nullptr);
+
+  bool needEscape;
+  nsCString dupParm;
+  nsCString charset("UTF-8");
+
+  if (!mozilla::IsAsciiNullTerminated(parmValue)) {
+    needEscape = true;
+    dupParm.Assign(parmValue);
+    MsgEscapeString(dupParm, nsINetUtil::ESCAPE_ALL, dupParm);
+  } else {
+    needEscape = false;
+    dupParm.Adopt(msg_make_filename_qtext(parmValue, true));
+  }
+
+  int32_t parmNameLen = PL_strlen(parmName);
+  int32_t parmValueLen = dupParm.Length();
+
+  parmNameLen += 5;  // *=__'__'___ or *[0]*=__'__'__ or *[1]*=___ or *[0]="___"
+
+  char* foldedParm = nullptr;
+
+  if ((parmValueLen + parmNameLen + strlen("UTF-8")) < PR_MAX_FOLDING_LEN) {
+    foldedParm = PL_strdup(parmName);
+    if (needEscape) {
+      NS_MsgSACat(&foldedParm, "*=");
+      NS_MsgSACat(&foldedParm, "UTF-8");
+      NS_MsgSACat(&foldedParm, "''");  // We don't support language.
+    } else
+      NS_MsgSACat(&foldedParm, "=\"");
+    NS_MsgSACat(&foldedParm, dupParm.get());
+    if (!needEscape) NS_MsgSACat(&foldedParm, "\"");
+  } else {
+    int curLineLen = 0;
+    int counter = 0;
+    char digits[32];
+    char* start = dupParm.BeginWriting();
+    char* end = NULL;
+    char tmp = 0;
+
+    while (parmValueLen > 0) {
+      curLineLen = 0;
+      if (counter == 0) {
+        PR_FREEIF(foldedParm)
+        foldedParm = PL_strdup(parmName);
+      } else {
+        NS_MsgSACat(&foldedParm, ";\r\n ");
+        NS_MsgSACat(&foldedParm, parmName);
+      }
+      PR_snprintf(digits, sizeof(digits), "*%d", counter);
+      NS_MsgSACat(&foldedParm, digits);
+      curLineLen += PL_strlen(digits);
+      if (needEscape) {
+        NS_MsgSACat(&foldedParm, "*=");
+        if (counter == 0) {
+          NS_MsgSACat(&foldedParm, "UTF-8");
+          NS_MsgSACat(&foldedParm, "''");  // We don't support language.
+          curLineLen += strlen("UTF-8");
+        }
+      } else {
+        NS_MsgSACat(&foldedParm, "=\"");
+      }
+      counter++;
+      curLineLen += parmNameLen;
+      if (parmValueLen <= PR_MAX_FOLDING_LEN - curLineLen)
+        end = start + parmValueLen;
+      else
+        end = start + (PR_MAX_FOLDING_LEN - curLineLen);
+
+      tmp = 0;
+      if (*end && needEscape) {
+        // Check to see if we are in the middle of escaped char.
+        // We use ESCAPE_ALL, so every third character is a '%'.
+        if (end - 1 > start && *(end - 1) == '%') {
+          end -= 1;
+        } else if (end - 2 > start && *(end - 2) == '%') {
+          end -= 2;
+        }
+        // *end is now a '%'.
+        // Check if the following UTF-8 octet is a continuation.
+        while (end - 3 > start && (*(end + 1) == '8' || *(end + 1) == '9' ||
+                                   *(end + 1) == 'A' || *(end + 1) == 'B')) {
+          end -= 3;
+        }
+        tmp = *end;
+        *end = 0;
+      } else {
+        tmp = *end;
+        *end = 0;
+      }
+      NS_MsgSACat(&foldedParm, start);
+      if (!needEscape) NS_MsgSACat(&foldedParm, "\"");
+
+      parmValueLen -= (end - start);
+      if (tmp) *end = tmp;
+      start = end;
+    }
+  }
+
+  return foldedParm;
+}
+
+bool mime_7bit_data_p(const char* string, uint32_t size) {
+  if ((!string) || (!*string)) return true;
+
+  char* ptr = (char*)string;
+  for (uint32_t i = 0; i < size; i++) {
+    if ((unsigned char)ptr[i] > 0x7F) return false;
+  }
+  return true;
+}
+
+// Strips whitespace, and expands newlines into newline-tab for use in
+// mail headers.  Returns a new string or 0 (if it would have been empty.)
+// If addr_p is true, the addresses will be parsed and reemitted as
+// rfc822 mailboxes.
+char* mime_fix_header_1(const char* string, bool addr_p, bool news_p) {
+  char* new_string;
+  const char* in;
+  char* out;
+  int32_t i, old_size, new_size;
+
+  if (!string || !*string) return 0;
+
+  if (addr_p) {
+    return strdup(string);
+  }
+
+  old_size = PL_strlen(string);
+  new_size = old_size;
+  for (i = 0; i < old_size; i++)
+    if (string[i] == '\r' || string[i] == '\n') new_size += 2;
+
+  new_string = (char*)PR_Malloc(new_size + 1);
+  if (!new_string) return 0;
+
+  in = string;
+  out = new_string;
+
+  /* strip leading whitespace. */
+  while (IS_SPACE(*in)) in++;
+
+  /* replace CR, LF, or CRLF with CRLF-TAB. */
+  while (*in) {
+    if (*in == '\r' || *in == '\n') {
+      if (*in == '\r' && in[1] == '\n') in++;
+      in++;
+      *out++ = '\r';
+      *out++ = '\n';
+      *out++ = '\t';
+    } else if (news_p && *in == ',') {
+      *out++ = *in++;
+      /* skip over all whitespace after a comma. */
+      while (IS_SPACE(*in)) in++;
+    } else
+      *out++ = *in++;
+  }
+  *out = 0;
+
+  /* strip trailing whitespace. */
+  while (out > in && IS_SPACE(out[-1])) *out-- = 0;
+
+  /* If we ended up throwing it all away, use 0 instead of "". */
+  if (!*new_string) {
+    PR_Free(new_string);
+    new_string = 0;
+  }
+
+  return new_string;
+}
+
+char* mime_fix_header(const char* string) {
+  return mime_fix_header_1(string, false, false);
+}
+
+char* mime_fix_addr_header(const char* string) {
+  return mime_fix_header_1(string, true, false);
+}
+
+char* mime_fix_news_header(const char* string) {
+  return mime_fix_header_1(string, false, true);
+}
+
+bool mime_type_requires_b64_p(const char* type) {
+  if (!type || !PL_strcasecmp(type, UNKNOWN_CONTENT_TYPE))
+    // Unknown types don't necessarily require encoding.  (Note that
+    // "unknown" and "application/octet-stream" aren't the same.)
+    return false;
+
+  else if (!PL_strncasecmp(type, "image/", 6) ||
+           !PL_strncasecmp(type, "audio/", 6) ||
+           !PL_strncasecmp(type, "video/", 6) ||
+           !PL_strncasecmp(type, "application/", 12)) {
+    // The following types are application/ or image/ types that are actually
+    // known to contain textual data (meaning line-based, not binary, where
+    // CRLF conversion is desired rather than disastrous.)  So, if the type
+    // is any of these, it does not *require* base64, and if we do need to
+    // encode it for other reasons, we'll probably use quoted-printable.
+    // But, if it's not one of these types, then we assume that any subtypes
+    // of the non-"text/" types are binary data, where CRLF conversion would
+    // corrupt it, so we use base64 right off the bat.
+
+    // The reason it's desirable to ship these as text instead of just using
+    // base64 all the time is mainly to preserve the readability of them for
+    // non-MIME users: if I mail a /bin/sh script to someone, it might not
+    // need to be encoded at all, so we should leave it readable if we can.
+
+    // This list of types was derived from the comp.mail.mime FAQ, section
+    // 10.2.2, "List of known unregistered MIME types" on 2-Feb-96.
+    static const char* app_and_image_types_which_are_really_text[] = {
+        "application/mac-binhex40", /* APPLICATION_BINHEX */
+        "application/pgp",          /* APPLICATION_PGP */
+        "application/pgp-keys",
+        "application/x-pgp-message", /* APPLICATION_PGP2 */
+        "application/postscript",    /* APPLICATION_POSTSCRIPT */
+        "application/x-uuencode",    /* APPLICATION_UUENCODE */
+        "application/x-uue",         /* APPLICATION_UUENCODE2 */
+        "application/uue",           /* APPLICATION_UUENCODE4 */
+        "application/uuencode",      /* APPLICATION_UUENCODE3 */
+        "application/sgml",
+        "application/x-csh",
+        "application/javascript",
+        "application/ecmascript",
+        "application/x-javascript",
+        "application/x-latex",
+        "application/x-macbinhex40",
+        "application/x-ns-proxy-autoconfig",
+        "application/x-www-form-urlencoded",
+        "application/x-perl",
+        "application/x-sh",
+        "application/x-shar",
+        "application/x-tcl",
+        "application/x-tex",
+        "application/x-texinfo",
+        "application/x-troff",
+        "application/x-troff-man",
+        "application/x-troff-me",
+        "application/x-troff-ms",
+        "application/x-troff-ms",
+        "application/x-wais-source",
+        "image/x-bitmap",
+        "image/x-pbm",
+        "image/x-pgm",
+        "image/x-portable-anymap",
+        "image/x-portable-bitmap",
+        "image/x-portable-graymap",
+        "image/x-portable-pixmap", /* IMAGE_PPM */
+        "image/x-ppm",
+        "image/x-xbitmap", /* IMAGE_XBM */
+        "image/x-xbm",     /* IMAGE_XBM2 */
+        "image/xbm",       /* IMAGE_XBM3 */
+        "image/x-xpixmap",
+        "image/x-xpm",
+        0};
+    const char** s;
+    for (s = app_and_image_types_which_are_really_text; *s; s++)
+      if (!PL_strcasecmp(type, *s)) return false;
+
+    /* All others must be assumed to be binary formats, and need Base64. */
+    return true;
+  }
+
+  else
+    return false;
+}
+
+//
+// Some types should have a "charset=" parameter, and some shouldn't.
+// This is what decides.
+//
+bool mime_type_needs_charset(const char* type) {
+  /* Only text types should have charset. */
+  if (!type || !*type)
+    return false;
+  else if (!PL_strncasecmp(type, "text", 4))
+    return true;
+  else
+    return false;
+}
+
+// Given a string, convert it to 'qtext' (quoted text) for RFC822 header
+// purposes.
+char* msg_make_filename_qtext(const char* srcText, bool stripCRLFs) {
+  /* newString can be at most twice the original string (every char quoted). */
+  char* newString = (char*)PR_Malloc(PL_strlen(srcText) * 2 + 1);
+  if (!newString) return NULL;
+
+  const char* s = srcText;
+  const char* end = srcText + PL_strlen(srcText);
+  char* d = newString;
+
+  while (*s) {
+    // Put backslashes in front of existing backslashes, or double quote
+    // characters.
+    // If stripCRLFs is true, don't write out CRs or LFs. Otherwise,
+    // write out a backslash followed by the CR but not
+    // linear-white-space.
+    // We might already have quoted pair of "\ " or "\\t" skip it.
+    if (*s == '\\' || *s == '"' ||
+        (!stripCRLFs &&
+         (*s == '\r' && (s[1] != '\n' ||
+                         (s[1] == '\n' && (s + 2) < end && !IS_SPACE(s[2]))))))
+      *d++ = '\\';
+
+    if (stripCRLFs && *s == '\r' && s[1] == '\n' && (s + 2) < end &&
+        IS_SPACE(s[2])) {
+      s += 3;  // skip CRLFLWSP
+    } else {
+      *d++ = *s++;
+    }
+  }
+  *d = 0;
+
+  return newString;
+}
+
+// Utility to create a nsIURI object...
+nsresult nsMsgNewURL(nsIURI** aInstancePtrResult, const nsCString& aSpec) {
+  nsresult rv = NS_OK;
+  if (nullptr == aInstancePtrResult) return NS_ERROR_NULL_POINTER;
+  nsCOMPtr<nsIIOService> pNetService = mozilla::components::IO::Service();
+  NS_ENSURE_TRUE(pNetService, NS_ERROR_UNEXPECTED);
+  if (aSpec.Find("://") == kNotFound && !StringBeginsWith(aSpec, "data:"_ns)) {
+    // XXXjag Temporary fix for bug 139362 until the real problem(bug 70083) get
+    // fixed
+    nsAutoCString uri("http://"_ns);
+    uri.Append(aSpec);
+    rv = pNetService->NewURI(uri, nullptr, nullptr, aInstancePtrResult);
+  } else
+    rv = pNetService->NewURI(aSpec, nullptr, nullptr, aInstancePtrResult);
+  return rv;
+}
+
+char* nsMsgGetLocalFileFromURL(const char* url) {
+  char* finalPath;
+  NS_ASSERTION(PL_strncasecmp(url, "file://", 7) == 0, "invalid url");
+  finalPath = (char*)PR_Malloc(strlen(url));
+  if (finalPath == NULL) return NULL;
+  strcpy(finalPath, url + 6 + 1);
+  return finalPath;
+}
+
+char* nsMsgParseURLHost(const char* url) {
+  nsIURI* workURI = nullptr;
+  nsresult rv;
+
+  rv = nsMsgNewURL(&workURI, nsDependentCString(url));
+  if (NS_FAILED(rv) || !workURI) return nullptr;
+
+  nsAutoCString host;
+  rv = workURI->GetHost(host);
+  NS_IF_RELEASE(workURI);
+  if (NS_FAILED(rv)) return nullptr;
+
+  return ToNewCString(host);
+}
+
+char* GenerateFileNameFromURI(nsIURI* aURL) {
+  nsresult rv;
+  nsCString file;
+  nsCString spec;
+  char* returnString;
+  char* cp = nullptr;
+  char* cp1 = nullptr;
+
+  rv = aURL->GetPathQueryRef(file);
+  if (NS_SUCCEEDED(rv) && !file.IsEmpty()) {
+    char* newFile = ToNewCString(file);
+    if (!newFile) return nullptr;
+
+    // strip '/'
+    cp = PL_strrchr(newFile, '/');
+    if (cp)
+      ++cp;
+    else
+      cp = newFile;
+
+    if (*cp) {
+      if ((cp1 = PL_strchr(cp, '/'))) *cp1 = 0;
+      if ((cp1 = PL_strchr(cp, '?'))) *cp1 = 0;
+      if ((cp1 = PL_strchr(cp, '>'))) *cp1 = 0;
+      if (*cp != '\0') {
+        returnString = PL_strdup(cp);
+        PR_FREEIF(newFile);
+        return returnString;
+      }
+    } else
+      return nullptr;
+  }
+
+  cp = nullptr;
+  cp1 = nullptr;
+
+  rv = aURL->GetSpec(spec);
+  if (NS_SUCCEEDED(rv) && !spec.IsEmpty()) {
+    char* newSpec = ToNewCString(spec);
+    if (!newSpec) return nullptr;
+
+    char *cp2 = NULL, *cp3 = NULL;
+
+    // strip '"'
+    cp2 = newSpec;
+    while (*cp2 == '"') cp2++;
+    if ((cp3 = PL_strchr(cp2, '"'))) *cp3 = 0;
+
+    char* hostStr = nsMsgParseURLHost(cp2);
+    if (!hostStr) hostStr = PL_strdup(cp2);
+
+    bool isHTTP = false;
+    if (NS_SUCCEEDED(aURL->SchemeIs("http", &isHTTP)) && isHTTP) {
+      returnString = PR_smprintf("%s.html", hostStr);
+      PR_FREEIF(hostStr);
+    } else
+      returnString = hostStr;
+
+    PR_FREEIF(newSpec);
+    return returnString;
+  }
+
+  return nullptr;
+}
+
+//
+// This routine will generate a content id for use in a mail part.
+// It will take the part number passed in as well as the email
+// address. If the email address is null or invalid, we will simply
+// use netscape.com for the interesting part. The content ID's will
+// look like the following:
+//
+//      Content-ID: <part1.36DF1DCE.73B5A330@netscape.com>
+//
+char* mime_gen_content_id(uint32_t aPartNum, const char* aEmailAddress) {
+  int32_t randLen = 5;
+  unsigned char rand_buf1[5];
+  unsigned char rand_buf2[5];
+  const char* domain = nullptr;
+  const char* defaultDomain = "@netscape.com";
+
+  memset(rand_buf1, 0, randLen - 1);
+  memset(rand_buf2, 0, randLen - 1);
+
+  GenerateGlobalRandomBytes(rand_buf1, randLen);
+  GenerateGlobalRandomBytes(rand_buf2, randLen);
+
+  // Find the @domain.com string...
+  if (aEmailAddress && *aEmailAddress)
+    domain = const_cast<const char*>(PL_strchr(aEmailAddress, '@'));
+
+  if (!domain) domain = defaultDomain;
+
+  char* retVal = PR_smprintf(
+      "part%d."
+      "%02X%02X%02X%02X"
+      "."
+      "%02X%02X%02X%02X"
+      "%s",
+      aPartNum, rand_buf1[0], rand_buf1[1], rand_buf1[2], rand_buf1[3],
+      rand_buf2[0], rand_buf2[1], rand_buf2[2], rand_buf2[3], domain);
+
+  return retVal;
+}
+
+void GetFolderURIFromUserPrefs(nsMsgDeliverMode aMode, nsIMsgIdentity* identity,
+                               nsCString& uri) {
+  nsresult rv;
+  uri.Truncate();
+
+  // QueueForLater (Outbox)
+  if (aMode == nsIMsgSend::nsMsgQueueForLater ||
+      aMode == nsIMsgSend::nsMsgDeliverBackground) {
+    nsCOMPtr<nsIPrefBranch> prefs(
+        do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    if (NS_FAILED(rv)) return;
+    rv = prefs->GetCharPref("mail.default_sendlater_uri", uri);
+    if (NS_FAILED(rv) || uri.IsEmpty())
+      uri.AssignLiteral(ANY_SERVER);
+    else {
+      // check if uri is unescaped, and if so, escape it and reset the pef.
+      if (uri.FindChar(' ') != kNotFound) {
+        uri.ReplaceSubstring(" ", "%20");
+        prefs->SetCharPref("mail.default_sendlater_uri", uri);
+      }
+    }
+    return;
+  }
+
+  if (!identity) return;
+
+  if (aMode == nsIMsgSend::nsMsgSaveAsDraft)  // SaveAsDraft (Drafts)
+    rv = identity->GetDraftFolder(uri);
+  else if (aMode ==
+           nsIMsgSend::nsMsgSaveAsTemplate)  // SaveAsTemplate (Templates)
+    rv = identity->GetStationeryFolder(uri);
+  else {
+    bool doFcc = false;
+    rv = identity->GetDoFcc(&doFcc);
+    if (doFcc) rv = identity->GetFccFolder(uri);
+  }
+  return;
+}
+
+/**
+ * Check if we should use format=flowed (RFC 2646) for a mail.
+ * We will use format=flowed unless the preference tells us not to do so.
+ * In this function we set all the serialiser flags.
+ * 'formatted' is always 'true'.
+ */
+void GetSerialiserFlags(bool* flowed, bool* formatted) {
+  *flowed = false;
+  *formatted = true;
+
+  // Set format=flowed as in RFC 2646 according to the preference.
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  if (NS_SUCCEEDED(rv)) {
+    prefs->GetBoolPref("mailnews.send_plaintext_flowed", flowed);
+  }
+}
+
+already_AddRefed<nsIArray> GetEmbeddedObjects(
+    mozilla::dom::Document* aDocument) {
+  nsCOMPtr<nsIMutableArray> nodes = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  if (NS_WARN_IF(!nodes)) {
+    return nullptr;
+  }
+
+  mozilla::PostContentIterator iter;
+  nsresult rv = iter.Init(aDocument->GetRootElement());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return nullptr;
+  }
+
+  // Loop through the content iterator for each content node.
+  while (!iter.IsDone()) {
+    nsINode* node = iter.GetCurrentNode();
+    if (node->IsElement()) {
+      mozilla::dom::Element* element = node->AsElement();
+
+      // See if it's an image or also include all links.
+      // Let mail decide which link to send or not
+      if (element->IsAnyOfHTMLElements(nsGkAtoms::img, nsGkAtoms::a) ||
+          (element->IsHTMLElement(nsGkAtoms::body) &&
+           element->HasAttr(kNameSpaceID_None, nsGkAtoms::background))) {
+        nodes->AppendElement(node);
+      }
+    }
+    iter.Next();
+  }
+
+  return nodes.forget();
+}
diff --git a/comm/mailnews/compose/src/nsMsgCompUtils.h b/comm/mailnews/compose/src/nsMsgCompUtils.h
new file mode 100644
index 0000000000..7197cde459
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgCompUtils.h
@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsMsgCompUtils_H_
+#define _nsMsgCompUtils_H_
+
+#include "nscore.h"
+#include "mozilla/dom/Document.h"
+#include "nsMsgCompFields.h"
+#include "nsIMsgSend.h"
+#include "nsIMsgCompUtils.h"
+
+class nsIArray;
+class nsIDocument;
+class nsIPrompt;
+
+#define ANY_SERVER "anyfolder://"
+
+// these are msg hdr property names for storing the original
+// msg uri's and disposition(replied/forwarded) when queuing
+// messages to send later.
+#define ORIG_URI_PROPERTY "origURIs"
+#define QUEUED_DISPOSITION_PROPERTY "queuedDisposition"
+
+extern mozilla::LazyLogModule Compose;
+
+class nsMsgCompUtils : public nsIMsgCompUtils {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGCOMPUTILS
+
+  nsMsgCompUtils();
+
+ private:
+  virtual ~nsMsgCompUtils();
+};
+
+already_AddRefed<nsIArray> GetEmbeddedObjects(
+    mozilla::dom::Document* aDocument);
+
+PR_BEGIN_EXTERN_C
+
+//
+// Create a file spec or file name using the name passed
+// in as a template
+//
+nsresult nsMsgCreateTempFile(const char* tFileName, nsIFile** tFile);
+char* nsMsgCreateTempFileName(const char* tFileName);
+
+//
+// Various utilities for building parts of MIME encoded
+// messages during message composition
+//
+
+nsresult mime_sanity_check_fields_recipients(const char* to, const char* cc,
+                                             const char* bcc,
+                                             const char* newsgroups);
+
+nsresult mime_sanity_check_fields(
+    const char* from, const char* reply_to, const char* to, const char* cc,
+    const char* bcc, const char* fcc, const char* newsgroups,
+    const char* followup_to, const char* /*subject*/,
+    const char* /*references*/, const char* /*organization*/,
+    const char* /*other_random_headers*/);
+
+nsresult mime_generate_headers(nsIMsgCompFields* fields,
+                               nsMsgDeliverMode deliver_mode,
+                               msgIWritableStructuredHeaders* headers);
+
+char* mime_make_separator(const char* prefix);
+char* mime_gen_content_id(uint32_t aPartNum, const char* aEmailAddress);
+
+bool mime_7bit_data_p(const char* string, uint32_t size);
+
+char* mime_fix_header_1(const char* string, bool addr_p, bool news_p);
+char* mime_fix_header(const char* string);
+char* mime_fix_addr_header(const char* string);
+char* mime_fix_news_header(const char* string);
+
+bool mime_type_requires_b64_p(const char* type);
+bool mime_type_needs_charset(const char* type);
+
+char* msg_make_filename_qtext(const char* srcText, bool stripCRLFs);
+
+char* RFC2231ParmFolding(const char* parmName, const char* parmValue);
+
+//
+// Informational calls...
+//
+void nsMsgMIMESetConformToStandard(bool conform_p);
+bool nsMsgMIMEGetConformToStandard(void);
+
+//
+// network service type calls...
+//
+nsresult nsMsgNewURL(nsIURI** aInstancePtrResult, const nsCString& aSpec);
+char* nsMsgGetLocalFileFromURL(const char* url);
+
+char* nsMsgParseURLHost(const char* url);
+
+char* GenerateFileNameFromURI(nsIURI* aURL);
+
+//
+// Folder calls...
+//
+void GetFolderURIFromUserPrefs(nsMsgDeliverMode aMode, nsIMsgIdentity* identity,
+                               nsCString& uri);
+
+// Check if we should use format=flowed
+void GetSerialiserFlags(bool* flowed, bool* formatted);
+
+PR_END_EXTERN_C
+
+#endif /* _nsMsgCompUtils_H_ */
diff --git a/comm/mailnews/compose/src/nsMsgCompose.cpp b/comm/mailnews/compose/src/nsMsgCompose.cpp
new file mode 100644
index 0000000000..2630852f5a
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgCompose.cpp
@@ -0,0 +1,5094 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgCompose.h"
+#include "mozilla/dom/Document.h"
+#include "nsPIDOMWindow.h"
+#include "mozIDOMWindow.h"
+#include "nsISelectionController.h"
+#include "nsMsgI18N.h"
+#include "nsMsgQuote.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIDocumentEncoder.h"  // for editor output flags
+#include "nsMsgCompUtils.h"
+#include "nsComposeStrings.h"
+#include "nsIMsgSend.h"
+#include "nsMailHeaders.h"
+#include "nsMsgPrompts.h"
+#include "nsMimeTypes.h"
+#include "nsICharsetConverterManager.h"
+#include "nsTextFormatter.h"
+#include "nsIHTMLEditor.h"
+#include "nsIEditor.h"
+#include "plstr.h"
+#include "prmem.h"
+#include "nsIDocShell.h"
+#include "nsCExternalHandlerService.h"
+#include "nsIMIMEService.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIWindowMediator.h"
+#include "nsIURL.h"
+#include "mozilla/intl/AppDateTimeFormat.h"
+#include "nsIMsgComposeService.h"
+#include "nsIMsgComposeProgressParams.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsImapCore.h"
+#include "nsUnicharUtils.h"
+#include "nsNetUtil.h"
+#include "nsIContentViewer.h"
+#include "nsIMsgMdnGenerator.h"
+#include "plbase64.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgAttachment.h"
+#include "nsIMsgProgress.h"
+#include "nsMsgFolderFlags.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMsgDatabase.h"
+#include "nsStringStream.h"
+#include "nsArrayUtils.h"
+#include "nsIMsgWindow.h"
+#include "nsITextToSubURI.h"
+#include "nsIAbManager.h"
+#include "nsCRT.h"
+#include "mozilla/HTMLEditor.h"
+#include "mozilla/Components.h"
+#include "mozilla/Services.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/dom/HTMLAnchorElement.h"
+#include "mozilla/dom/HTMLImageElement.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/dom/PromiseNativeHandler.h"
+#include "mozilla/Utf8.h"
+#include "nsStreamConverter.h"
+#include "nsIObserverService.h"
+#include "nsIProtocolHandler.h"
+#include "nsContentUtils.h"
+#include "nsStreamUtils.h"
+#include "nsIFileURL.h"
+#include "nsTextNode.h"  // from dom/base
+#include "nsIParserUtils.h"
+#include "nsIStringBundle.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::mailnews;
+
+LazyLogModule Compose("Compose");
+
+static nsresult GetReplyHeaderInfo(int32_t* reply_header_type,
+                                   nsString& reply_header_authorwrote,
+                                   nsString& reply_header_ondateauthorwrote,
+                                   nsString& reply_header_authorwroteondate,
+                                   nsString& reply_header_originalmessage) {
+  nsresult rv;
+  *reply_header_type = 0;
+  nsCOMPtr<nsIPrefBranch> prefBranch(
+      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If fetching any of the preferences fails,
+  // we return early with header_type = 0 meaning "no header".
+  rv = NS_GetLocalizedUnicharPreference(
+      prefBranch, "mailnews.reply_header_authorwrotesingle",
+      reply_header_authorwrote);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = NS_GetLocalizedUnicharPreference(
+      prefBranch, "mailnews.reply_header_ondateauthorwrote",
+      reply_header_ondateauthorwrote);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = NS_GetLocalizedUnicharPreference(
+      prefBranch, "mailnews.reply_header_authorwroteondate",
+      reply_header_authorwroteondate);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = NS_GetLocalizedUnicharPreference(prefBranch,
+                                        "mailnews.reply_header_originalmessage",
+                                        reply_header_originalmessage);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return prefBranch->GetIntPref("mailnews.reply_header_type",
+                                reply_header_type);
+}
+
+static void TranslateLineEnding(nsString& data) {
+  char16_t* rPtr;  // Read pointer
+  char16_t* wPtr;  // Write pointer
+  char16_t* sPtr;  // Start data pointer
+  char16_t* ePtr;  // End data pointer
+
+  rPtr = wPtr = sPtr = data.BeginWriting();
+  ePtr = rPtr + data.Length();
+
+  while (rPtr < ePtr) {
+    if (*rPtr == nsCRT::CR) {
+      *wPtr = nsCRT::LF;
+      if (rPtr + 1 < ePtr && *(rPtr + 1) == nsCRT::LF) rPtr++;
+    } else
+      *wPtr = *rPtr;
+
+    rPtr++;
+    wPtr++;
+  }
+
+  data.SetLength(wPtr - sPtr);
+}
+
+nsMsgCompose::nsMsgCompose() {
+  mQuotingToFollow = false;
+  mAllowRemoteContent = false;
+  mWhatHolder = 1;
+  m_window = nullptr;
+  m_editor = nullptr;
+  mQuoteStreamListener = nullptr;
+  mAutodetectCharset = false;
+  mDeleteDraft = false;
+  m_compFields =
+      nullptr;  // m_compFields will be set during nsMsgCompose::Initialize
+  mType = nsIMsgCompType::New;
+
+  // For TagConvertible
+  // Read and cache pref
+  mConvertStructs = false;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (prefBranch)
+    prefBranch->GetBoolPref("converter.html2txt.structs", &mConvertStructs);
+
+  m_composeHTML = false;
+
+  mTmpAttachmentsDeleted = false;
+  mDraftDisposition = nsIMsgFolder::nsMsgDispositionState_None;
+  mDeliverMode = 0;
+}
+
+nsMsgCompose::~nsMsgCompose() {
+  MOZ_LOG(Compose, LogLevel::Debug, ("~nsMsgCompose()"));
+  if (!m_compFields) {
+    // Uhoh. We're in an uninitialized state. Maybe initialize() failed, or
+    // was never even called.
+    return;
+  }
+  m_window = nullptr;
+  if (!mMsgSend) {
+    // This dtor can be called before mMsgSend->CreateAndSendMessage returns,
+    // tmp attachments are needed to create the message, so don't delete them.
+    DeleteTmpAttachments();
+  }
+}
+
+/* the following macro actually implement addref, release and query interface
+ * for our component. */
+NS_IMPL_ISUPPORTS(nsMsgCompose, nsIMsgCompose, nsIMsgSendListener,
+                  nsISupportsWeakReference)
+
+//
+// Once we are here, convert the data which we know to be UTF-8 to UTF-16
+// for insertion into the editor
+//
+nsresult GetChildOffset(nsINode* aChild, nsINode* aParent, int32_t& aOffset) {
+  NS_ASSERTION((aChild && aParent), "bad args");
+
+  if (!aChild || !aParent) return NS_ERROR_NULL_POINTER;
+
+  nsINodeList* childNodes = aParent->ChildNodes();
+  for (uint32_t i = 0; i < childNodes->Length(); i++) {
+    nsINode* childNode = childNodes->Item(i);
+    if (childNode == aChild) {
+      aOffset = i;
+      return NS_OK;
+    }
+  }
+
+  return NS_ERROR_NULL_POINTER;
+}
+
+nsresult GetNodeLocation(nsINode* inChild, nsCOMPtr<nsINode>* outParent,
+                         int32_t* outOffset) {
+  NS_ASSERTION((outParent && outOffset), "bad args");
+  nsresult result = NS_ERROR_NULL_POINTER;
+  if (inChild && outParent && outOffset) {
+    nsCOMPtr<nsINode> inChild2 = inChild;
+    *outParent = inChild2->GetParentNode();
+    if (*outParent) {
+      result = GetChildOffset(inChild2, *outParent, *outOffset);
+    }
+  }
+
+  return result;
+}
+
+bool nsMsgCompose::IsEmbeddedObjectSafe(const char* originalScheme,
+                                        const char* originalHost,
+                                        const char* originalPath,
+                                        Element* element) {
+  nsresult rv;
+
+  nsAutoString objURL;
+
+  if (!originalScheme || !originalPath)  // Having a null host is OK.
+    return false;
+
+  RefPtr<HTMLImageElement> image = HTMLImageElement::FromNode(element);
+  RefPtr<HTMLAnchorElement> anchor = HTMLAnchorElement::FromNode(element);
+
+  if (image)
+    image->GetSrc(objURL);
+  else if (anchor)
+    anchor->GetHref(objURL);
+  else
+    return false;
+
+  if (!objURL.IsEmpty()) {
+    nsCOMPtr<nsIURI> uri;
+    rv = NS_NewURI(getter_AddRefs(uri), objURL);
+    if (NS_SUCCEEDED(rv) && uri) {
+      nsAutoCString scheme;
+      rv = uri->GetScheme(scheme);
+      if (NS_SUCCEEDED(rv) &&
+          scheme.Equals(originalScheme, nsCaseInsensitiveCStringComparator)) {
+        nsAutoCString host;
+        rv = uri->GetAsciiHost(host);
+        // mailbox url don't have a host therefore don't be too strict.
+        if (NS_SUCCEEDED(rv) &&
+            (host.IsEmpty() || originalHost ||
+             host.Equals(originalHost, nsCaseInsensitiveCStringComparator))) {
+          nsAutoCString path;
+          rv = uri->GetPathQueryRef(path);
+          if (NS_SUCCEEDED(rv)) {
+            nsAutoCString orgPath(originalPath);
+            MsgRemoveQueryPart(orgPath);
+            MsgRemoveQueryPart(path);
+            // mailbox: and JS Account URLs have a message number in
+            // the query part of "path query ref". We removed this so
+            // we're not comparing down to the message but down to the folder.
+            // Code in the frontend (in the "error" event listener in
+            // MsgComposeCommands.js that deals with unblocking images) will
+            // prompt if a part of another message is referenced.
+            // A saved message opened for reply or forwarding has a
+            // mailbox: URL.
+            // imap: URLs don't have the message number in the query, so we do
+            // compare it here.
+            // news: URLs use group and key in the query, but it's OK to compare
+            // without them.
+            return path.Equals(orgPath, nsCaseInsensitiveCStringComparator);
+          }
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/* The purpose of this function is to mark any embedded object that wasn't a
+   RFC822 part of the original message as moz-do-not-send. That will prevent us
+   to attach data not specified by the user or not present in the original
+   message.
+*/
+nsresult nsMsgCompose::TagEmbeddedObjects(nsIEditor* aEditor) {
+  nsresult rv = NS_OK;
+  uint32_t count;
+  uint32_t i;
+
+  if (!aEditor) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<Document> document;
+  aEditor->GetDocument(getter_AddRefs(document));
+  if (!document) return NS_ERROR_FAILURE;
+  nsCOMPtr<nsIArray> aNodeList = GetEmbeddedObjects(document);
+  if (!aNodeList) return NS_ERROR_FAILURE;
+
+  if (NS_FAILED(aNodeList->GetLength(&count))) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIURI> originalUrl;
+  nsCString originalScheme;
+  nsCString originalHost;
+  nsCString originalPath;
+
+  // first, convert the rdf original msg uri into a url that represents the
+  // message...
+  nsCOMPtr<nsIMsgMessageService> msgService;
+  rv = GetMessageServiceFromURI(mOriginalMsgURI, getter_AddRefs(msgService));
+  if (NS_SUCCEEDED(rv)) {
+    rv = msgService->GetUrlForUri(mOriginalMsgURI, nullptr,
+                                  getter_AddRefs(originalUrl));
+    if (NS_SUCCEEDED(rv) && originalUrl) {
+      originalUrl->GetScheme(originalScheme);
+      originalUrl->GetAsciiHost(originalHost);
+      originalUrl->GetPathQueryRef(originalPath);
+    }
+  }
+
+  // Then compare the url of each embedded objects with the original message.
+  // If they a not coming from the original message, they should not be sent
+  // with the message.
+  for (i = 0; i < count; i++) {
+    nsCOMPtr<Element> domElement = do_QueryElementAt(aNodeList, i);
+    if (!domElement) continue;
+    if (IsEmbeddedObjectSafe(originalScheme.get(), originalHost.get(),
+                             originalPath.get(), domElement))
+      continue;  // Don't need to tag this object, it's safe to send it.
+
+    // The source of this object should not be sent with the message.
+    IgnoredErrorResult rv2;
+    domElement->SetAttribute(u"moz-do-not-send"_ns, u"true"_ns, rv2);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::GetAllowRemoteContent(bool* aAllowRemoteContent) {
+  NS_ENSURE_ARG_POINTER(aAllowRemoteContent);
+  *aAllowRemoteContent = mAllowRemoteContent;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::SetAllowRemoteContent(bool aAllowRemoteContent) {
+  mAllowRemoteContent = aAllowRemoteContent;
+  return NS_OK;
+}
+
+void nsMsgCompose::InsertDivWrappedTextAtSelection(const nsAString& aText,
+                                                   const nsAString& classStr) {
+  NS_ASSERTION(m_editor,
+               "InsertDivWrappedTextAtSelection called, but no editor exists");
+  if (!m_editor) return;
+
+  RefPtr<Element> divElem;
+  nsCOMPtr<nsIHTMLEditor> htmlEditor(do_QueryInterface(m_editor));
+
+  nsresult rv =
+      htmlEditor->CreateElementWithDefaults(u"div"_ns, getter_AddRefs(divElem));
+
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  // We need the document
+  nsCOMPtr<Document> doc;
+  rv = m_editor->GetDocument(getter_AddRefs(doc));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  // Break up the text by newlines, and then insert text nodes followed
+  // by <br> nodes.
+  int32_t start = 0;
+  int32_t end = aText.Length();
+
+  for (;;) {
+    int32_t delimiter = aText.FindChar('\n', start);
+    if (delimiter == kNotFound) delimiter = end;
+
+    RefPtr<nsTextNode> textNode =
+        doc->CreateTextNode(Substring(aText, start, delimiter - start));
+
+    IgnoredErrorResult rv2;
+    divElem->AppendChild(*textNode, rv2);
+    if (rv2.Failed()) {
+      return;
+    }
+
+    // Now create and insert a BR
+    RefPtr<Element> brElem;
+    rv =
+        htmlEditor->CreateElementWithDefaults(u"br"_ns, getter_AddRefs(brElem));
+    NS_ENSURE_SUCCESS_VOID(rv);
+    divElem->AppendChild(*brElem, rv2);
+    if (rv2.Failed()) {
+      return;
+    }
+
+    if (delimiter == end) break;
+    start = ++delimiter;
+    if (start == end) break;
+  }
+
+  htmlEditor->InsertElementAtSelection(divElem, true);
+  nsCOMPtr<nsINode> parent;
+  int32_t offset;
+
+  rv = GetNodeLocation(divElem, address_of(parent), &offset);
+  if (NS_SUCCEEDED(rv)) {
+    RefPtr<Selection> selection;
+    m_editor->GetSelection(getter_AddRefs(selection));
+
+    if (selection) selection->CollapseInLimiter(parent, offset + 1);
+  }
+  if (divElem) {
+    RefPtr<Element> divElem2 = divElem;
+    IgnoredErrorResult rv2;
+    divElem2->SetAttribute(u"class"_ns, classStr, rv2);
+  }
+}
+
+/*
+ * The following function replaces <plaintext> tags with <x-plaintext>.
+ * <plaintext> is a funny beast: It leads to everything following it
+ * being displayed verbatim, even a </plaintext> tag is ignored.
+ */
+static void remove_plaintext_tag(nsString& body) {
+  // Replace all <plaintext> and </plaintext> tags.
+  int32_t index = 0;
+  bool replaced = false;
+  while ((index = body.LowerCaseFindASCII("<plaintext", index)) != kNotFound) {
+    body.Insert(u"x-", index + 1);
+    index += 12;
+    replaced = true;
+  }
+  if (replaced) {
+    index = 0;
+    while ((index = body.LowerCaseFindASCII("</plaintext", index)) !=
+           kNotFound) {
+      body.Insert(u"x-", index + 2);
+      index += 13;
+    }
+  }
+}
+
+static void remove_conditional_CSS(const nsAString& in, nsAString& out) {
+  nsCOMPtr<nsIParserUtils> parserUtils =
+      do_GetService(NS_PARSERUTILS_CONTRACTID);
+  parserUtils->RemoveConditionalCSS(in, out);
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
+nsMsgCompose::ConvertAndLoadComposeWindow(nsString& aPrefix, nsString& aBuf,
+                                          nsString& aSignature, bool aQuoted,
+                                          bool aHTMLEditor) {
+  NS_ASSERTION(m_editor, "ConvertAndLoadComposeWindow but no editor");
+  NS_ENSURE_TRUE(m_editor && m_identity, NS_ERROR_NOT_INITIALIZED);
+
+  // First, get the nsIEditor interface for future use
+  nsCOMPtr<nsINode> nodeInserted;
+
+  TranslateLineEnding(aPrefix);
+  TranslateLineEnding(aBuf);
+  TranslateLineEnding(aSignature);
+
+  m_editor->EnableUndo(false);
+
+  // Ok - now we need to figure out the charset of the aBuf we are going to send
+  // into the editor shell. There are I18N calls to sniff the data and then we
+  // need to call the new routine in the editor that will allow us to send in
+  // the charset
+  //
+
+  // Now, insert it into the editor...
+  RefPtr<HTMLEditor> htmlEditor = m_editor->AsHTMLEditor();
+  int32_t reply_on_top = 0;
+  bool sig_bottom = true;
+  m_identity->GetReplyOnTop(&reply_on_top);
+  m_identity->GetSigBottom(&sig_bottom);
+  bool sigOnTop = (reply_on_top == 1 && !sig_bottom);
+  bool isForwarded = (mType == nsIMsgCompType::ForwardInline);
+
+  // When in paragraph mode, don't call InsertLineBreak() since that inserts
+  // a full paragraph instead of just a line break since we switched
+  // the default paragraph separator to "p".
+  bool paragraphMode =
+      mozilla::Preferences::GetBool("mail.compose.default_to_paragraph", false);
+
+  if (aQuoted) {
+    if (!aPrefix.IsEmpty()) {
+      if (!aHTMLEditor) aPrefix.AppendLiteral("\n");
+
+      int32_t reply_on_top = 0;
+      m_identity->GetReplyOnTop(&reply_on_top);
+      if (reply_on_top == 1) {
+        // HTML editor eats one line break but not a whole paragraph.
+        if (aHTMLEditor && !paragraphMode) htmlEditor->InsertLineBreak();
+
+        // add one newline if a signature comes before the quote, two otherwise
+        bool includeSignature = true;
+        bool sig_bottom = true;
+        bool attachFile = false;
+        nsString prefSigText;
+
+        m_identity->GetSigOnReply(&includeSignature);
+        m_identity->GetSigBottom(&sig_bottom);
+        m_identity->GetHtmlSigText(prefSigText);
+        nsresult rv = m_identity->GetAttachSignature(&attachFile);
+        if (!paragraphMode || !aHTMLEditor) {
+          if (includeSignature && !sig_bottom &&
+              ((NS_SUCCEEDED(rv) && attachFile) || !prefSigText.IsEmpty()))
+            htmlEditor->InsertLineBreak();
+          else {
+            htmlEditor->InsertLineBreak();
+            htmlEditor->InsertLineBreak();
+          }
+        }
+      }
+
+      InsertDivWrappedTextAtSelection(aPrefix, u"moz-cite-prefix"_ns);
+    }
+
+    if (!aBuf.IsEmpty()) {
+      // This leaves the caret at the right place to insert a bottom signature.
+      if (aHTMLEditor) {
+        nsAutoString body(aBuf);
+        remove_plaintext_tag(body);
+        htmlEditor->InsertAsCitedQuotation(body, mCiteReference, true,
+                                           getter_AddRefs(nodeInserted));
+      } else {
+        htmlEditor->InsertAsQuotation(aBuf, getter_AddRefs(nodeInserted));
+      }
+    }
+
+    (void)TagEmbeddedObjects(htmlEditor);
+
+    if (!aSignature.IsEmpty()) {
+      // we cannot add it on top earlier, because TagEmbeddedObjects will mark
+      // all images in the signature as "moz-do-not-send"
+      if (sigOnTop) MoveToBeginningOfDocument();
+
+      if (aHTMLEditor) {
+        bool oldAllow;
+        GetAllowRemoteContent(&oldAllow);
+        SetAllowRemoteContent(true);
+        htmlEditor->InsertHTML(aSignature);
+        SetAllowRemoteContent(oldAllow);
+      } else {
+        htmlEditor->InsertLineBreak();
+        InsertDivWrappedTextAtSelection(aSignature, u"moz-signature"_ns);
+      }
+
+      if (sigOnTop) htmlEditor->EndOfDocument();
+    }
+  } else {
+    if (aHTMLEditor) {
+      if (isForwarded &&
+          Substring(aBuf, 0, sizeof(MIME_FORWARD_HTML_PREFIX) - 1)
+              .EqualsLiteral(MIME_FORWARD_HTML_PREFIX)) {
+        // We assign the opening tag inside "<HTML><BODY><BR><BR>" before the
+        // two <br> elements.
+        // This is a bit hacky but we know that the MIME code prepares the
+        // forwarded content like this:
+        // <HTML><BODY><BR><BR> + forwarded header + header table.
+        // Note: We only do this when we prepare the message to be forwarded,
+        // a re-opened saved draft of a forwarded message does not repeat this.
+        nsString divTag;
+        divTag.AssignLiteral("<div class=\"moz-forward-container\">");
+        aBuf.Insert(divTag, sizeof(MIME_FORWARD_HTML_PREFIX) - 1 - 8);
+      }
+      remove_plaintext_tag(aBuf);
+
+      bool stripConditionalCSS = mozilla::Preferences::GetBool(
+          "mail.html_sanitize.drop_conditional_css", true);
+
+      if (stripConditionalCSS) {
+        nsString newBody;
+        remove_conditional_CSS(aBuf, newBody);
+        htmlEditor->RebuildDocumentFromSource(newBody);
+      } else {
+        htmlEditor->RebuildDocumentFromSource(aBuf);
+      }
+
+      // When forwarding a message as inline, or editing as new (which could
+      // contain unsanitized remote content), tag any embedded objects
+      // with moz-do-not-send=true so they don't get attached upon send.
+      if (isForwarded || mType == nsIMsgCompType::EditAsNew)
+        (void)TagEmbeddedObjects(htmlEditor);
+
+      if (!aSignature.IsEmpty()) {
+        if (isForwarded && sigOnTop) {
+          // Use our own function, nsEditor::BeginningOfDocument() would
+          // position into the <div class="moz-forward-container"> we've just
+          // created.
+          MoveToBeginningOfDocument();
+        } else {
+          // Use our own function, nsEditor::EndOfDocument() would position
+          // into the <div class="moz-forward-container"> we've just created.
+          MoveToEndOfDocument();
+        }
+
+        bool oldAllow;
+        GetAllowRemoteContent(&oldAllow);
+        SetAllowRemoteContent(true);
+        htmlEditor->InsertHTML(aSignature);
+        SetAllowRemoteContent(oldAllow);
+
+        if (isForwarded && sigOnTop) htmlEditor->EndOfDocument();
+      } else
+        htmlEditor->EndOfDocument();
+    } else {
+      bool sigOnTopInserted = false;
+      if (isForwarded && sigOnTop && !aSignature.IsEmpty()) {
+        htmlEditor->InsertLineBreak();
+        InsertDivWrappedTextAtSelection(aSignature, u"moz-signature"_ns);
+        htmlEditor->EndOfDocument();
+        sigOnTopInserted = true;
+      }
+
+      if (!aBuf.IsEmpty()) {
+        nsresult rv;
+        RefPtr<Element> divElem;
+        RefPtr<Element> extraBr;
+
+        if (isForwarded) {
+          // Special treatment for forwarded messages: Part 1.
+          // Create a <div> of the required class.
+          rv = htmlEditor->CreateElementWithDefaults(u"div"_ns,
+                                                     getter_AddRefs(divElem));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          nsAutoString attributeName;
+          nsAutoString attributeValue;
+          attributeName.AssignLiteral("class");
+          attributeValue.AssignLiteral("moz-forward-container");
+          IgnoredErrorResult rv1;
+          divElem->SetAttribute(attributeName, attributeValue, rv1);
+
+          // We can't insert an empty <div>, so fill it with something.
+          rv = htmlEditor->CreateElementWithDefaults(u"br"_ns,
+                                                     getter_AddRefs(extraBr));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          ErrorResult rv2;
+          divElem->AppendChild(*extraBr, rv2);
+          if (rv2.Failed()) {
+            return rv2.StealNSResult();
+          }
+
+          // Insert the non-empty <div> into the DOM.
+          rv = htmlEditor->InsertElementAtSelection(divElem, false);
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          // Position into the div, so out content goes there.
+          RefPtr<Selection> selection;
+          htmlEditor->GetSelection(getter_AddRefs(selection));
+          rv = selection->CollapseInLimiter(divElem, 0);
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+
+        rv = htmlEditor->InsertTextWithQuotations(aBuf);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        if (isForwarded) {
+          // Special treatment for forwarded messages: Part 2.
+          if (sigOnTopInserted) {
+            // Sadly the M-C editor inserts a <br> between the <div> for the
+            // signature and this <div>, so remove the <br> we don't want.
+            nsCOMPtr<nsINode> brBeforeDiv;
+            nsAutoString tagLocalName;
+            brBeforeDiv = divElem->GetPreviousSibling();
+            if (brBeforeDiv) {
+              tagLocalName = brBeforeDiv->LocalName();
+              if (tagLocalName.EqualsLiteral("br")) {
+                rv = htmlEditor->DeleteNode(brBeforeDiv);
+                NS_ENSURE_SUCCESS(rv, rv);
+              }
+            }
+          }
+
+          // Clean up the <br> we inserted.
+          rv = htmlEditor->DeleteNode(extraBr);
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+
+        // Use our own function instead of nsEditor::EndOfDocument() because
+        // we don't want to position at the end of the div we've just created.
+        // It's OK to use, even if we're not forwarding and didn't create a
+        // <div>.
+        rv = MoveToEndOfDocument();
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+
+      if ((!isForwarded || !sigOnTop) && !aSignature.IsEmpty()) {
+        htmlEditor->InsertLineBreak();
+        InsertDivWrappedTextAtSelection(aSignature, u"moz-signature"_ns);
+      }
+    }
+  }
+
+  if (aBuf.IsEmpty())
+    htmlEditor->BeginningOfDocument();
+  else {
+    switch (reply_on_top) {
+      // This should set the cursor after the body but before the sig
+      case 0: {
+        if (!htmlEditor) {
+          htmlEditor->BeginningOfDocument();
+          break;
+        }
+
+        RefPtr<Selection> selection;
+        nsCOMPtr<nsINode> parent;
+        int32_t offset;
+        nsresult rv;
+
+        // get parent and offset of mailcite
+        rv = GetNodeLocation(nodeInserted, address_of(parent), &offset);
+        if (NS_FAILED(rv) || (!parent)) {
+          htmlEditor->BeginningOfDocument();
+          break;
+        }
+
+        // get selection
+        htmlEditor->GetSelection(getter_AddRefs(selection));
+        if (!selection) {
+          htmlEditor->BeginningOfDocument();
+          break;
+        }
+
+        // place selection after mailcite
+        selection->CollapseInLimiter(parent, offset + 1);
+
+        // insert a break at current selection
+        if (!paragraphMode || !aHTMLEditor) htmlEditor->InsertLineBreak();
+
+        // i'm not sure if you need to move the selection back to before the
+        // break. expirement.
+        selection->CollapseInLimiter(parent, offset + 1);
+
+        break;
+      }
+
+      case 2: {
+        nsCOMPtr<nsIEditor> editor(htmlEditor);  // Strong reference.
+        editor->SelectAll();
+        break;
+      }
+
+      // This should set the cursor to the top!
+      default: {
+        MoveToBeginningOfDocument();
+        break;
+      }
+    }
+  }
+
+  nsCOMPtr<nsISelectionController> selCon;
+  htmlEditor->GetSelectionController(getter_AddRefs(selCon));
+
+  if (selCon)
+    selCon->ScrollSelectionIntoView(
+        nsISelectionController::SELECTION_NORMAL,
+        nsISelectionController::SELECTION_ANCHOR_REGION, true);
+
+  htmlEditor->EnableUndo(true);
+  SetBodyModified(false);
+
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+  nsCOMPtr<nsIMsgComposeService> composeService(
+      do_GetService("@mozilla.org/messengercompose;1"));
+  composeService->TimeStamp(
+      "Finished inserting data into the editor. The window is finally ready!",
+      false);
+#endif
+  return NS_OK;
+}
+
+/**
+ * Check the identity pref to include signature on replies and forwards.
+ */
+bool nsMsgCompose::CheckIncludeSignaturePrefs(nsIMsgIdentity* identity) {
+  bool includeSignature = true;
+  switch (mType) {
+    case nsIMsgCompType::ForwardInline:
+    case nsIMsgCompType::ForwardAsAttachment:
+      identity->GetSigOnForward(&includeSignature);
+      break;
+    case nsIMsgCompType::Reply:
+    case nsIMsgCompType::ReplyAll:
+    case nsIMsgCompType::ReplyToList:
+    case nsIMsgCompType::ReplyToGroup:
+    case nsIMsgCompType::ReplyToSender:
+    case nsIMsgCompType::ReplyToSenderAndGroup:
+      identity->GetSigOnReply(&includeSignature);
+      break;
+  }
+  return includeSignature;
+}
+
+nsresult nsMsgCompose::SetQuotingToFollow(bool aVal) {
+  mQuotingToFollow = aVal;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::GetQuotingToFollow(bool* quotingToFollow) {
+  NS_ENSURE_ARG(quotingToFollow);
+  *quotingToFollow = mQuotingToFollow;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::Initialize(nsIMsgComposeParams* aParams,
+                         mozIDOMWindowProxy* aWindow, nsIDocShell* aDocShell) {
+  NS_ENSURE_ARG_POINTER(aParams);
+  nsresult rv;
+
+  aParams->GetIdentity(getter_AddRefs(m_identity));
+
+  if (aWindow) {
+    m_window = aWindow;
+    nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aWindow);
+    NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
+
+    nsCOMPtr<nsIDocShellTreeItem> treeItem = window->GetDocShell();
+    nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
+    rv = treeItem->GetTreeOwner(getter_AddRefs(treeOwner));
+    if (NS_FAILED(rv)) return rv;
+
+    m_baseWindow = do_QueryInterface(treeOwner);
+  }
+
+  aParams->GetAutodetectCharset(&mAutodetectCharset);
+
+  MSG_ComposeFormat format;
+  aParams->GetFormat(&format);
+
+  MSG_ComposeType type;
+  aParams->GetType(&type);
+
+  nsCString originalMsgURI;
+  aParams->GetOriginalMsgURI(originalMsgURI);
+  aParams->GetOrigMsgHdr(getter_AddRefs(mOrigMsgHdr));
+
+  nsCOMPtr<nsIMsgCompFields> composeFields;
+  aParams->GetComposeFields(getter_AddRefs(composeFields));
+
+  nsCOMPtr<nsIMsgComposeService> composeService =
+      do_GetService("@mozilla.org/messengercompose;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = composeService->DetermineComposeHTML(m_identity, format, &m_composeHTML);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#ifndef MOZ_SUITE
+  if (m_composeHTML) {
+    Telemetry::ScalarAdd(Telemetry::ScalarID::TB_COMPOSE_FORMAT_HTML, 1);
+  } else {
+    Telemetry::ScalarAdd(Telemetry::ScalarID::TB_COMPOSE_FORMAT_PLAIN_TEXT, 1);
+  }
+  Telemetry::Accumulate(Telemetry::TB_COMPOSE_TYPE, type);
+#endif
+
+  if (composeFields) {
+    nsAutoCString draftId;  // will get set for drafts and templates
+    rv = composeFields->GetDraftId(draftId);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Set return receipt flag and type, and if we should attach a vCard
+    // by checking the identity prefs - but don't clobber the values for
+    // drafts and templates as they were set up already by mime when
+    // initializing the message.
+    if (m_identity && draftId.IsEmpty() && type != nsIMsgCompType::Template) {
+      bool requestReturnReceipt = false;
+      rv = m_identity->GetRequestReturnReceipt(&requestReturnReceipt);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = composeFields->SetReturnReceipt(requestReturnReceipt);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      int32_t receiptType = nsIMsgMdnGenerator::eDntType;
+      rv = m_identity->GetReceiptHeaderType(&receiptType);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = composeFields->SetReceiptHeaderType(receiptType);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      bool requestDSN = false;
+      rv = m_identity->GetRequestDSN(&requestDSN);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = composeFields->SetDSN(requestDSN);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      bool attachVCard;
+      rv = m_identity->GetAttachVCard(&attachVCard);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = composeFields->SetAttachVCard(attachVCard);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+
+  nsCOMPtr<nsIMsgSendListener> externalSendListener;
+  aParams->GetSendListener(getter_AddRefs(externalSendListener));
+  if (externalSendListener) AddMsgSendListener(externalSendListener);
+
+  nsString smtpPassword;
+  aParams->GetSmtpPassword(smtpPassword);
+  mSmtpPassword = smtpPassword;
+
+  aParams->GetHtmlToQuote(mHtmlToQuote);
+
+  if (aDocShell) {
+    mDocShell = aDocShell;
+    // register the compose object with the compose service
+    rv = composeService->RegisterComposeDocShell(aDocShell, this);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return CreateMessage(originalMsgURI, type, composeFields);
+}
+
+NS_IMETHODIMP
+nsMsgCompose::RegisterStateListener(
+    nsIMsgComposeStateListener* aStateListener) {
+  NS_ENSURE_ARG_POINTER(aStateListener);
+  mStateListeners.AppendElement(aStateListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::UnregisterStateListener(
+    nsIMsgComposeStateListener* aStateListener) {
+  NS_ENSURE_ARG_POINTER(aStateListener);
+  return mStateListeners.RemoveElement(aStateListener) ? NS_OK
+                                                       : NS_ERROR_FAILURE;
+}
+
+// Added to allow easier use of the nsIMsgSendListener
+NS_IMETHODIMP nsMsgCompose::AddMsgSendListener(
+    nsIMsgSendListener* aMsgSendListener) {
+  NS_ENSURE_ARG_POINTER(aMsgSendListener);
+  mExternalSendListeners.AppendElement(aMsgSendListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::RemoveMsgSendListener(
+    nsIMsgSendListener* aMsgSendListener) {
+  NS_ENSURE_ARG_POINTER(aMsgSendListener);
+  return mExternalSendListeners.RemoveElement(aMsgSendListener)
+             ? NS_OK
+             : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::SendMsgToServer(MSG_DeliverMode deliverMode,
+                              nsIMsgIdentity* identity, const char* accountKey,
+                              Promise** aPromise) {
+  nsresult rv = NS_OK;
+
+  // clear saved message id if sending, so we don't send out the same
+  // message-id.
+  if (deliverMode == nsIMsgCompDeliverMode::Now ||
+      deliverMode == nsIMsgCompDeliverMode::Later ||
+      deliverMode == nsIMsgCompDeliverMode::Background)
+    m_compFields->SetMessageId("");
+
+  if (m_compFields && identity) {
+    // Pref values are supposed to be stored as UTF-8, so no conversion
+    nsCString email;
+    nsString fullName;
+    nsString organization;
+
+    identity->GetEmail(email);
+    identity->GetFullName(fullName);
+    identity->GetOrganization(organization);
+
+    const char* pFrom = m_compFields->GetFrom();
+    if (!pFrom || !*pFrom) {
+      nsCString sender;
+      MakeMimeAddress(NS_ConvertUTF16toUTF8(fullName), email, sender);
+      m_compFields->SetFrom(sender.IsEmpty() ? email.get() : sender.get());
+    }
+
+    m_compFields->SetOrganization(organization);
+
+    // We need an nsIMsgSend instance to send the message. Allow extensions
+    // to override the default SMTP sender by observing mail-set-sender.
+    mMsgSend = nullptr;
+    mDeliverMode = deliverMode;  // save for possible access by observer.
+
+    // Allow extensions to specify an outgoing server.
+    nsCOMPtr<nsIObserverService> observerService =
+        mozilla::services::GetObserverService();
+    NS_ENSURE_STATE(observerService);
+
+    // Assemble a string with sending parameters.
+    nsAutoString sendParms;
+
+    // First parameter: account key. This may be null.
+    sendParms.AppendASCII(accountKey && *accountKey ? accountKey : "");
+    sendParms.Append(',');
+
+    // Second parameter: deliverMode.
+    sendParms.AppendInt(deliverMode);
+    sendParms.Append(',');
+
+    // Third parameter: identity (as identity key).
+    nsAutoCString identityKey;
+    identity->GetKey(identityKey);
+    sendParms.AppendASCII(identityKey.get());
+
+    observerService->NotifyObservers(NS_ISUPPORTS_CAST(nsIMsgCompose*, this),
+                                     "mail-set-sender", sendParms.get());
+
+    if (!mMsgSend)
+      mMsgSend = do_CreateInstance("@mozilla.org/messengercompose/send;1");
+
+    if (mMsgSend) {
+      nsString bodyString;
+      rv = m_compFields->GetBody(bodyString);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Create the listener for the send operation...
+      nsCOMPtr<nsIMsgComposeSendListener> composeSendListener =
+          do_CreateInstance(
+              "@mozilla.org/messengercompose/composesendlistener;1");
+      if (!composeSendListener) return NS_ERROR_OUT_OF_MEMORY;
+
+      // right now, AutoSaveAsDraft is identical to SaveAsDraft as
+      // far as the msg send code is concerned. This way, we don't have
+      // to add an nsMsgDeliverMode for autosaveasdraft, and add cases for
+      // it in the msg send code.
+      if (deliverMode == nsIMsgCompDeliverMode::AutoSaveAsDraft)
+        deliverMode = nsIMsgCompDeliverMode::SaveAsDraft;
+
+      RefPtr<nsIMsgCompose> msgCompose(this);
+      composeSendListener->SetMsgCompose(msgCompose);
+      composeSendListener->SetDeliverMode(deliverMode);
+
+      if (mProgress) {
+        nsCOMPtr<nsIWebProgressListener> progressListener =
+            do_QueryInterface(composeSendListener);
+        mProgress->RegisterListener(progressListener);
+      }
+
+      // If we are composing HTML, then this should be sent as
+      // multipart/related which means we pass the editor into the
+      // backend...if not, just pass nullptr
+      //
+      nsCOMPtr<nsIMsgSendListener> sendListener =
+          do_QueryInterface(composeSendListener);
+      RefPtr<mozilla::dom::Promise> promise;
+      rv = mMsgSend->CreateAndSendMessage(
+          m_composeHTML ? m_editor.get() : nullptr, identity, accountKey,
+          m_compFields, false, false, (nsMsgDeliverMode)deliverMode, nullptr,
+          m_composeHTML ? TEXT_HTML : TEXT_PLAIN, bodyString, m_window,
+          mProgress, sendListener, mSmtpPassword, mOriginalMsgURI, mType,
+          getter_AddRefs(promise));
+      promise.forget(aPromise);
+    } else
+      rv = NS_ERROR_FAILURE;
+  } else
+    rv = NS_ERROR_NOT_INITIALIZED;
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgCompose::SendMsg(MSG_DeliverMode deliverMode,
+                                    nsIMsgIdentity* identity,
+                                    const char* accountKey,
+                                    nsIMsgWindow* aMsgWindow,
+                                    nsIMsgProgress* progress,
+                                    Promise** aPromise) {
+  NS_ENSURE_TRUE(m_compFields, NS_ERROR_NOT_INITIALIZED);
+  nsresult rv = NS_OK;
+
+  // Set content type based on which type of compose window we had.
+  nsString contentType = (m_composeHTML) ? u"text/html"_ns : u"text/plain"_ns;
+  nsString msgBody;
+  if (m_editor) {
+    // Reset message body previously stored in the compose fields
+    m_compFields->SetBody(EmptyString());
+
+    uint32_t flags = nsIDocumentEncoder::OutputCRLineBreak |
+                     nsIDocumentEncoder::OutputLFLineBreak;
+
+    if (m_composeHTML) {
+      flags |= nsIDocumentEncoder::OutputFormatted |
+               nsIDocumentEncoder::OutputDisallowLineBreaking;
+    } else {
+      bool flowed, formatted;
+      GetSerialiserFlags(&flowed, &formatted);
+      if (flowed) flags |= nsIDocumentEncoder::OutputFormatFlowed;
+      if (formatted) flags |= nsIDocumentEncoder::OutputFormatted;
+      flags |= nsIDocumentEncoder::OutputDisallowLineBreaking;
+      // Don't lose NBSP in the plain text encoder.
+      flags |= nsIDocumentEncoder::OutputPersistNBSP;
+    }
+    nsresult rv = m_editor->OutputToString(contentType, flags, msgBody);
+    NS_ENSURE_SUCCESS(rv, rv);
+  } else {
+    m_compFields->GetBody(msgBody);
+  }
+  if (!msgBody.IsEmpty()) {
+    // Ensure body ends in CRLF to avoid SMTP server timeout when sent.
+    if (!StringEndsWith(msgBody, u"\r\n"_ns)) msgBody.AppendLiteral("\r\n");
+    bool isAsciiOnly = mozilla::IsAsciiNullTerminated(
+        static_cast<const char16_t*>(msgBody.get()));
+
+    if (m_compFields->GetForceMsgEncoding()) {
+      isAsciiOnly = false;
+    }
+
+    m_compFields->SetBodyIsAsciiOnly(isAsciiOnly);
+    m_compFields->SetBody(msgBody);
+  }
+
+  // Let's open the progress dialog
+  if (progress) {
+    mProgress = progress;
+
+    if (deliverMode != nsIMsgCompDeliverMode::AutoSaveAsDraft) {
+      nsAutoString msgSubject;
+      m_compFields->GetSubject(msgSubject);
+
+      bool showProgress = false;
+      nsCOMPtr<nsIPrefBranch> prefBranch(
+          do_GetService(NS_PREFSERVICE_CONTRACTID));
+      if (prefBranch) {
+        prefBranch->GetBoolPref("mailnews.show_send_progress", &showProgress);
+        if (showProgress) {
+          nsCOMPtr<nsIMsgComposeProgressParams> params = do_CreateInstance(
+              "@mozilla.org/messengercompose/composeprogressparameters;1", &rv);
+          if (NS_FAILED(rv) || !params) return NS_ERROR_FAILURE;
+
+          params->SetSubject(msgSubject.get());
+          params->SetDeliveryMode(deliverMode);
+
+          mProgress->OpenProgressDialog(
+              m_window, aMsgWindow,
+              "chrome://messenger/content/messengercompose/sendProgress.xhtml",
+              false, params);
+        }
+      }
+    }
+
+    mProgress->OnStateChange(nullptr, nullptr,
+                             nsIWebProgressListener::STATE_START, NS_OK);
+  }
+
+  bool attachVCard = false;
+  m_compFields->GetAttachVCard(&attachVCard);
+
+  if (attachVCard && identity &&
+      (deliverMode == nsIMsgCompDeliverMode::Now ||
+       deliverMode == nsIMsgCompDeliverMode::Later ||
+       deliverMode == nsIMsgCompDeliverMode::Background)) {
+    nsCString escapedVCard;
+    // make sure, if there is no card, this returns an empty string, or
+    // NS_ERROR_FAILURE
+    rv = identity->GetEscapedVCard(escapedVCard);
+
+    if (NS_SUCCEEDED(rv) && !escapedVCard.IsEmpty()) {
+      nsCString vCardUrl;
+      vCardUrl = "data:text/vcard;charset=utf-8;base64,";
+      nsCString unescapedData;
+      MsgUnescapeString(escapedVCard, 0, unescapedData);
+      char* result = PL_Base64Encode(unescapedData.get(), 0, nullptr);
+      vCardUrl += result;
+      PR_Free(result);
+
+      nsCOMPtr<nsIMsgAttachment> attachment =
+          do_CreateInstance("@mozilla.org/messengercompose/attachment;1", &rv);
+      if (NS_SUCCEEDED(rv) && attachment) {
+        // [comment from 4.x]
+        // Send the vCard out with a filename which distinguishes this user.
+        // e.g. jsmith.vcf The main reason to do this is for interop with
+        // Eudora, which saves off the attachments separately from the message
+        // body
+        nsCString userid;
+        (void)identity->GetEmail(userid);
+        int32_t index = userid.FindChar('@');
+        if (index != kNotFound) userid.SetLength(index);
+
+        if (userid.IsEmpty())
+          attachment->SetName(u"vcard.vcf"_ns);
+        else {
+          // Replace any dot with underscore to stop vCards
+          // generating false positives with some heuristic scanners
+          userid.ReplaceChar('.', '_');
+          userid.AppendLiteral(".vcf");
+          attachment->SetName(NS_ConvertASCIItoUTF16(userid));
+        }
+
+        attachment->SetUrl(vCardUrl);
+        m_compFields->AddAttachment(attachment);
+      }
+    }
+  }
+
+  // Save the identity being sent for later use.
+  m_identity = identity;
+
+  RefPtr<mozilla::dom::Promise> promise;
+  rv = SendMsgToServer(deliverMode, identity, accountKey,
+                       getter_AddRefs(promise));
+
+  RefPtr<nsMsgCompose> self = this;
+  auto handleFailure = [self = std::move(self), deliverMode](nsresult rv) {
+    self->NotifyStateListeners(
+        nsIMsgComposeNotificationType::ComposeProcessDone, rv);
+    nsCOMPtr<nsIMsgSendReport> sendReport;
+    if (self->mMsgSend)
+      self->mMsgSend->GetSendReport(getter_AddRefs(sendReport));
+    if (sendReport) {
+      nsresult theError;
+      sendReport->DisplayReport(self->m_window, true, true, &theError);
+    } else {
+      // If we come here it's because we got an error before we could initialize
+      // a send report! Let's try our best...
+      switch (deliverMode) {
+        case nsIMsgCompDeliverMode::Later:
+          nsMsgDisplayMessageByName(self->m_window, "unableToSendLater");
+          break;
+        case nsIMsgCompDeliverMode::AutoSaveAsDraft:
+        case nsIMsgCompDeliverMode::SaveAsDraft:
+          nsMsgDisplayMessageByName(self->m_window, "unableToSaveDraft");
+          break;
+        case nsIMsgCompDeliverMode::SaveAsTemplate:
+          nsMsgDisplayMessageByName(self->m_window, "unableToSaveTemplate");
+          break;
+
+        default:
+          nsMsgDisplayMessageByName(self->m_window, "sendFailed");
+          break;
+      }
+    }
+    if (self->mProgress) self->mProgress->CloseProgressDialog(true);
+
+    self->DeleteTmpAttachments();
+  };
+  if (promise) {
+    RefPtr<DomPromiseListener> listener = new DomPromiseListener(
+        [&](JSContext*, JS::Handle<JS::Value>) { DeleteTmpAttachments(); },
+        handleFailure);
+    promise->AppendNativeHandler(listener);
+    promise.forget(aPromise);
+  } else if (NS_FAILED(rv)) {
+    handleFailure(rv);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetDeleteDraft(bool* aDeleteDraft) {
+  NS_ENSURE_ARG_POINTER(aDeleteDraft);
+  *aDeleteDraft = mDeleteDraft;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::SetDeleteDraft(bool aDeleteDraft) {
+  mDeleteDraft = aDeleteDraft;
+  return NS_OK;
+}
+
+bool nsMsgCompose::IsLastWindow() {
+  nsresult rv;
+  bool more;
+  nsCOMPtr<nsIWindowMediator> windowMediator =
+      do_GetService(NS_WINDOWMEDIATOR_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsISimpleEnumerator> windowEnumerator;
+    rv = windowMediator->GetEnumerator(nullptr,
+                                       getter_AddRefs(windowEnumerator));
+    if (NS_SUCCEEDED(rv)) {
+      nsCOMPtr<nsISupports> isupports;
+
+      if (NS_SUCCEEDED(windowEnumerator->GetNext(getter_AddRefs(isupports))))
+        if (NS_SUCCEEDED(windowEnumerator->HasMoreElements(&more)))
+          return !more;
+    }
+  }
+  return true;
+}
+
+NS_IMETHODIMP nsMsgCompose::CloseWindow(void) {
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgComposeService> composeService =
+      do_GetService("@mozilla.org/messengercompose;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // unregister the compose object with the compose service
+  rv = composeService->UnregisterComposeDocShell(mDocShell);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mDocShell = nullptr;
+
+  // ensure that the destructor of nsMsgSend is invoked to remove
+  // temporary files.
+  mMsgSend = nullptr;
+
+  // We are going away for real, we need to do some clean up first
+  if (m_baseWindow) {
+    if (m_editor) {
+      // The editor will be destroyed during the close window.
+      // Set it to null to be sure we won't use it anymore.
+      m_editor = nullptr;
+    }
+    nsCOMPtr<nsIBaseWindow> window = m_baseWindow.forget();
+    rv = window->Destroy();
+  }
+
+  m_window = nullptr;
+  return rv;
+}
+
+nsresult nsMsgCompose::Abort() {
+  if (mMsgSend) mMsgSend->Abort();
+
+  if (mProgress) mProgress->CloseProgressDialog(true);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetEditor(nsIEditor** aEditor) {
+  NS_IF_ADDREF(*aEditor = m_editor);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::SetEditor(nsIEditor* aEditor) {
+  m_editor = aEditor;
+  return NS_OK;
+}
+
+// This used to be called BEFORE editor was created
+//  (it did the loadURI that triggered editor creation)
+// It is called from JS after editor creation
+//  (loadURI is done in JS)
+MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP nsMsgCompose::InitEditor(
+    nsIEditor* aEditor, mozIDOMWindowProxy* aContentWindow) {
+  NS_ENSURE_ARG_POINTER(aEditor);
+  NS_ENSURE_ARG_POINTER(aContentWindow);
+  nsresult rv;
+
+  m_editor = aEditor;
+
+  aEditor->SetDocumentCharacterSet("UTF-8"_ns);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window =
+      nsPIDOMWindowOuter::From(aContentWindow);
+
+  nsIDocShell* docShell = window->GetDocShell();
+  NS_ENSURE_TRUE(docShell, NS_ERROR_UNEXPECTED);
+
+  bool quotingToFollow = false;
+  GetQuotingToFollow(&quotingToFollow);
+  if (quotingToFollow)
+    return BuildQuotedMessageAndSignature();
+  else {
+    NotifyStateListeners(nsIMsgComposeNotificationType::ComposeFieldsReady,
+                         NS_OK);
+    rv = BuildBodyMessageAndSignature();
+    NotifyStateListeners(nsIMsgComposeNotificationType::ComposeBodyReady,
+                         NS_OK);
+    return rv;
+  }
+}
+
+nsresult nsMsgCompose::GetBodyModified(bool* modified) {
+  nsresult rv;
+
+  if (!modified) return NS_ERROR_NULL_POINTER;
+
+  *modified = true;
+
+  if (m_editor) {
+    rv = m_editor->GetDocumentModified(modified);
+    if (NS_FAILED(rv)) *modified = true;
+  }
+
+  return NS_OK;
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult
+nsMsgCompose::SetBodyModified(bool modified) {
+  nsresult rv = NS_OK;
+
+  if (m_editor) {
+    nsCOMPtr<nsIEditor> editor(m_editor);  // Strong reference.
+    if (modified) {
+      int32_t modCount = 0;
+      editor->GetModificationCount(&modCount);
+      if (modCount == 0) editor->IncrementModificationCount(1);
+    } else
+      editor->ResetModificationCount();
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::GetDomWindow(mozIDOMWindowProxy** aDomWindow) {
+  NS_IF_ADDREF(*aDomWindow = m_window);
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::GetCompFields(nsIMsgCompFields** aCompFields) {
+  NS_IF_ADDREF(*aCompFields = (nsIMsgCompFields*)m_compFields);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetComposeHTML(bool* aComposeHTML) {
+  *aComposeHTML = m_composeHTML;
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::GetWrapLength(int32_t* aWrapLength) {
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch(
+      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  if (NS_FAILED(rv)) return rv;
+
+  return prefBranch->GetIntPref("mailnews.wraplength", aWrapLength);
+}
+
+nsresult nsMsgCompose::CreateMessage(const nsACString& originalMsgURI,
+                                     MSG_ComposeType type,
+                                     nsIMsgCompFields* compFields) {
+  nsresult rv = NS_OK;
+  mType = type;
+  mDraftDisposition = nsIMsgFolder::nsMsgDispositionState_None;
+
+  mDeleteDraft = (type == nsIMsgCompType::Draft);
+  nsAutoCString msgUri(originalMsgURI);
+  bool fileUrl = StringBeginsWith(msgUri, "file:"_ns);
+  int32_t typeIndex = msgUri.Find("type=application/x-message-display");
+  if (typeIndex != kNotFound && typeIndex > 0) {
+    // Strip out type=application/x-message-display because it confuses libmime.
+    msgUri.Cut(typeIndex, sizeof("type=application/x-message-display"));
+    if (fileUrl)  // we're dealing with an .eml file msg
+    {
+      // We have now removed the type from the uri. Make sure we don't have
+      // an uri with "&&" now. If we do, remove the second '&'.
+      if (msgUri.CharAt(typeIndex) == '&') msgUri.Cut(typeIndex, 1);
+      // Remove possible trailing '?'.
+      if (msgUri.CharAt(msgUri.Length() - 1) == '?')
+        msgUri.Cut(msgUri.Length() - 1, 1);
+    } else  // we're dealing with a message/rfc822 attachment
+    {
+      // nsURLFetcher will check for "realtype=message/rfc822" and will set the
+      // content type to message/rfc822 in the forwarded message.
+      msgUri.AppendLiteral("&realtype=message/rfc822");
+    }
+  }
+
+  if (compFields) {
+    m_compFields = reinterpret_cast<nsMsgCompFields*>(compFields);
+  } else {
+    m_compFields = new nsMsgCompFields();
+  }
+
+  if (m_identity && mType != nsIMsgCompType::Draft) {
+    // Setup reply-to field.
+    nsCString replyTo;
+    m_identity->GetReplyTo(replyTo);
+    if (!replyTo.IsEmpty()) {
+      nsCString resultStr;
+      RemoveDuplicateAddresses(nsDependentCString(m_compFields->GetReplyTo()),
+                               replyTo, resultStr);
+      if (!resultStr.IsEmpty()) {
+        replyTo.Append(',');
+        replyTo.Append(resultStr);
+      }
+      m_compFields->SetReplyTo(replyTo.get());
+    }
+
+    // Setup auto-Cc field.
+    bool doCc;
+    m_identity->GetDoCc(&doCc);
+    if (doCc) {
+      nsCString ccList;
+      m_identity->GetDoCcList(ccList);
+
+      nsCString resultStr;
+      RemoveDuplicateAddresses(nsDependentCString(m_compFields->GetCc()),
+                               ccList, resultStr);
+      if (!resultStr.IsEmpty()) {
+        ccList.Append(',');
+        ccList.Append(resultStr);
+      }
+      m_compFields->SetCc(ccList.get());
+    }
+
+    // Setup auto-Bcc field.
+    bool doBcc;
+    m_identity->GetDoBcc(&doBcc);
+    if (doBcc) {
+      nsCString bccList;
+      m_identity->GetDoBccList(bccList);
+
+      nsCString resultStr;
+      RemoveDuplicateAddresses(nsDependentCString(m_compFields->GetBcc()),
+                               bccList, resultStr);
+      if (!resultStr.IsEmpty()) {
+        bccList.Append(',');
+        bccList.Append(resultStr);
+      }
+      m_compFields->SetBcc(bccList.get());
+    }
+  }
+
+  if (mType == nsIMsgCompType::Draft) {
+    nsCString curDraftIdURL;
+    rv = m_compFields->GetDraftId(curDraftIdURL);
+    // Skip if no draft id (probably a new draft msg).
+    if (NS_SUCCEEDED(rv) && !curDraftIdURL.IsEmpty()) {
+      nsCOMPtr<nsIMsgDBHdr> msgDBHdr;
+      rv = GetMsgDBHdrFromURI(curDraftIdURL, getter_AddRefs(msgDBHdr));
+      NS_ASSERTION(NS_SUCCEEDED(rv),
+                   "CreateMessage can't get msg header DB interface pointer.");
+      if (msgDBHdr) {
+        nsCString queuedDisposition;
+        msgDBHdr->GetStringProperty(QUEUED_DISPOSITION_PROPERTY,
+                                    queuedDisposition);
+        // We need to retrieve the original URI from the database so we can
+        // set the disposition flags correctly if the draft is a reply or
+        // forwarded message.
+        nsCString originalMsgURIfromDB;
+        msgDBHdr->GetStringProperty(ORIG_URI_PROPERTY, originalMsgURIfromDB);
+        mOriginalMsgURI = originalMsgURIfromDB;
+        if (!queuedDisposition.IsEmpty()) {
+          if (queuedDisposition.EqualsLiteral("replied"))
+            mDraftDisposition = nsIMsgFolder::nsMsgDispositionState_Replied;
+          else if (queuedDisposition.EqualsLiteral("forward"))
+            mDraftDisposition = nsIMsgFolder::nsMsgDispositionState_Forwarded;
+          else if (queuedDisposition.EqualsLiteral("redirected"))
+            mDraftDisposition = nsIMsgFolder::nsMsgDispositionState_Redirected;
+        }
+      }
+    } else {
+      NS_WARNING("CreateMessage can't get draft id");
+    }
+  }
+
+  // If we don't have an original message URI, nothing else to do...
+  if (msgUri.IsEmpty()) return NS_OK;
+
+  // store the original message URI so we can extract it after we send the
+  // message to properly mark any disposition flags like replied or forwarded on
+  // the message.
+  if (mOriginalMsgURI.IsEmpty()) mOriginalMsgURI = msgUri;
+
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // "Forward inline" and "Reply with template" processing.
+  // Note the early return at the end of the block.
+  if (type == nsIMsgCompType::ForwardInline ||
+      type == nsIMsgCompType::ReplyWithTemplate) {
+    // We want to treat this message as a reference too
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    rv = GetMsgDBHdrFromURI(msgUri, getter_AddRefs(msgHdr));
+    if (NS_SUCCEEDED(rv)) {
+      nsAutoCString messageId;
+      msgHdr->GetMessageId(getter_Copies(messageId));
+
+      nsAutoCString reference;
+      // When forwarding we only use the original message for "References:" -
+      // recipients don't have the other messages anyway.
+      // For reply with template we want to preserve all the references.
+      if (type == nsIMsgCompType::ReplyWithTemplate) {
+        uint16_t numReferences = 0;
+        msgHdr->GetNumReferences(&numReferences);
+        for (int32_t i = 0; i < numReferences; i++) {
+          nsAutoCString ref;
+          msgHdr->GetStringReference(i, ref);
+          if (!ref.IsEmpty()) {
+            reference.Append('<');
+            reference.Append(ref);
+            reference.AppendLiteral("> ");
+          }
+        }
+        reference.Trim(" ", false, true);
+      }
+      msgHdr->GetMessageId(getter_Copies(messageId));
+      reference.Append('<');
+      reference.Append(messageId);
+      reference.Append('>');
+      m_compFields->SetReferences(reference.get());
+
+      if (type == nsIMsgCompType::ForwardInline) {
+        nsString subject;
+        msgHdr->GetMime2DecodedSubject(subject);
+        nsCString fwdPrefix;
+        prefs->GetCharPrefWithDefault("mail.forward_subject_prefix", "Fwd"_ns,
+                                      1, fwdPrefix);
+        nsString unicodeFwdPrefix;
+        CopyUTF8toUTF16(fwdPrefix, unicodeFwdPrefix);
+        unicodeFwdPrefix.AppendLiteral(": ");
+        subject.Insert(unicodeFwdPrefix, 0);
+        m_compFields->SetSubject(subject);
+      }
+    }
+
+    // Early return for "ForwardInline" and "ReplyWithTemplate" processing.
+    return NS_OK;
+  }
+
+  // All other processing.
+
+  // Note the following:
+  // LoadDraftOrTemplate() is run in nsMsgComposeService::OpenComposeWindow()
+  // for five compose types: ForwardInline, ReplyWithTemplate (both covered
+  // in the code block above) and Draft, Template and Redirect. For these
+  // compose types, the charset is already correct (incl. MIME-applied override)
+  // unless the default charset should be used.
+
+  bool isFirstPass = true;
+  char* uriList = ToNewCString(msgUri);
+  char* uri = uriList;
+  char* nextUri;
+  do {
+    nextUri = strstr(uri, "://");
+    if (nextUri) {
+      // look for next ://, and then back up to previous ','
+      nextUri = strstr(nextUri + 1, "://");
+      if (nextUri) {
+        *nextUri = '\0';
+        char* saveNextUri = nextUri;
+        nextUri = strrchr(uri, ',');
+        if (nextUri) *nextUri = '\0';
+        *saveNextUri = ':';
+      }
+    }
+
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    if (mOrigMsgHdr)
+      msgHdr = mOrigMsgHdr;
+    else {
+      rv = GetMsgDBHdrFromURI(nsDependentCString(uri), getter_AddRefs(msgHdr));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    if (msgHdr) {
+      nsString subject;
+      rv = msgHdr->GetMime2DecodedSubject(subject);
+      if (NS_FAILED(rv)) return rv;
+
+      // Check if (was: is present in the subject
+      int32_t wasOffset = subject.RFind(u" (was:"_ns);
+      bool strip = true;
+
+      if (wasOffset >= 0) {
+        // Check the number of references, to check if was: should be stripped
+        // First, assume that it should be stripped; the variable will be set to
+        // false later if stripping should not happen.
+        uint16_t numRef;
+        msgHdr->GetNumReferences(&numRef);
+        if (numRef) {
+          // If there are references, look for the first message in the thread
+          // firstly, get the database via the folder
+          nsCOMPtr<nsIMsgFolder> folder;
+          msgHdr->GetFolder(getter_AddRefs(folder));
+          if (folder) {
+            nsCOMPtr<nsIMsgDatabase> db;
+            folder->GetMsgDatabase(getter_AddRefs(db));
+
+            if (db) {
+              nsAutoCString reference;
+              msgHdr->GetStringReference(0, reference);
+
+              nsCOMPtr<nsIMsgDBHdr> refHdr;
+              db->GetMsgHdrForMessageID(reference.get(),
+                                        getter_AddRefs(refHdr));
+
+              if (refHdr) {
+                nsCString refSubject;
+                rv = refHdr->GetSubject(refSubject);
+                if (NS_SUCCEEDED(rv)) {
+                  if (refSubject.Find(" (was:") >= 0) strip = false;
+                }
+              }
+            }
+          }
+        } else
+          strip = false;
+      }
+
+      if (strip && wasOffset >= 0) {
+        // Strip off the "(was: old subject)" part
+        subject.Assign(Substring(subject, 0, wasOffset));
+      }
+
+      switch (type) {
+        default:
+          break;
+        case nsIMsgCompType::Draft:
+        case nsIMsgCompType::Template:
+        case nsIMsgCompType::EditTemplate:
+        case nsIMsgCompType::EditAsNew: {
+          // If opening from file, preseve the subject already present, since
+          // we can't get a subject from db there.
+          if (mOriginalMsgURI.Find("&realtype=message/rfc822") != -1) {
+            break;
+          }
+          // Otherwise, set up the subject from db, with possible modifications.
+          uint32_t flags;
+          msgHdr->GetFlags(&flags);
+          if (flags & nsMsgMessageFlags::HasRe) {
+            subject.InsertLiteral(u"Re: ", 0);
+          }
+          // Set subject from db, where it's already decrypted. The raw
+          // header may be encrypted.
+          m_compFields->SetSubject(subject);
+          break;
+        }
+        case nsIMsgCompType::Reply:
+        case nsIMsgCompType::ReplyAll:
+        case nsIMsgCompType::ReplyToList:
+        case nsIMsgCompType::ReplyToGroup:
+        case nsIMsgCompType::ReplyToSender:
+        case nsIMsgCompType::ReplyToSenderAndGroup: {
+          if (!isFirstPass)  // safeguard, just in case...
+          {
+            PR_Free(uriList);
+            return rv;
+          }
+          mQuotingToFollow = true;
+
+          subject.InsertLiteral(u"Re: ", 0);
+          m_compFields->SetSubject(subject);
+
+          // Setup quoting callbacks for later...
+          mWhatHolder = 1;
+          break;
+        }
+        case nsIMsgCompType::ForwardAsAttachment: {
+          // Add the forwarded message in the references, first
+          nsAutoCString messageId;
+          msgHdr->GetMessageId(getter_Copies(messageId));
+          if (isFirstPass) {
+            nsAutoCString reference;
+            reference.Append('<');
+            reference.Append(messageId);
+            reference.Append('>');
+            m_compFields->SetReferences(reference.get());
+          } else {
+            nsAutoCString references;
+            m_compFields->GetReferences(getter_Copies(references));
+            references.AppendLiteral(" <");
+            references.Append(messageId);
+            references.Append('>');
+            m_compFields->SetReferences(references.get());
+          }
+
+          uint32_t flags;
+          msgHdr->GetFlags(&flags);
+          if (flags & nsMsgMessageFlags::HasRe)
+            subject.InsertLiteral(u"Re: ", 0);
+
+          // Setup quoting callbacks for later...
+          mQuotingToFollow =
+              false;  // We don't need to quote the original message.
+          nsCOMPtr<nsIMsgAttachment> attachment = do_CreateInstance(
+              "@mozilla.org/messengercompose/attachment;1", &rv);
+          if (NS_SUCCEEDED(rv) && attachment) {
+            bool addExtension = true;
+            nsString sanitizedSubj;
+            prefs->GetBoolPref("mail.forward_add_extension", &addExtension);
+
+            // copy subject string to sanitizedSubj, use default if empty
+            if (subject.IsEmpty()) {
+              nsresult rv;
+              nsCOMPtr<nsIStringBundleService> bundleService =
+                  mozilla::components::StringBundle::Service();
+              NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+              nsCOMPtr<nsIStringBundle> composeBundle;
+              rv = bundleService->CreateBundle(
+                  "chrome://messenger/locale/messengercompose/"
+                  "composeMsgs.properties",
+                  getter_AddRefs(composeBundle));
+              NS_ENSURE_SUCCESS(rv, rv);
+              composeBundle->GetStringFromName("messageAttachmentSafeName",
+                                               sanitizedSubj);
+            } else
+              sanitizedSubj.Assign(subject);
+
+            // set the file size
+            uint32_t messageSize;
+            msgHdr->GetMessageSize(&messageSize);
+            attachment->SetSize(messageSize);
+
+            // change all '.' to '_'  see bug #271211
+            sanitizedSubj.ReplaceChar(u".", u'_');
+            if (addExtension) sanitizedSubj.AppendLiteral(".eml");
+            attachment->SetName(sanitizedSubj);
+            attachment->SetUrl(nsDependentCString(uri));
+            m_compFields->AddAttachment(attachment);
+          }
+
+          if (isFirstPass) {
+            nsCString fwdPrefix;
+            prefs->GetCharPrefWithDefault("mail.forward_subject_prefix",
+                                          "Fwd"_ns, 1, fwdPrefix);
+            nsString unicodeFwdPrefix;
+            CopyUTF8toUTF16(fwdPrefix, unicodeFwdPrefix);
+            unicodeFwdPrefix.AppendLiteral(": ");
+            subject.Insert(unicodeFwdPrefix, 0);
+            m_compFields->SetSubject(subject);
+          }
+          break;
+        }
+        case nsIMsgCompType::Redirect: {
+          // For a redirect, set the Reply-To: header to what was in the
+          // original From: header...
+          nsAutoCString author;
+          msgHdr->GetAuthor(getter_Copies(author));
+          m_compFields->SetSubject(subject);
+          m_compFields->SetReplyTo(author.get());
+
+          // ... and empty out the various recipient headers
+          nsAutoString empty;
+          m_compFields->SetTo(empty);
+          m_compFields->SetCc(empty);
+          m_compFields->SetBcc(empty);
+          m_compFields->SetNewsgroups(empty);
+          m_compFields->SetFollowupTo(empty);
+
+          // Add the redirected message in the references so that threading
+          // will work when the new recipient eventually replies to the
+          // original sender.
+          nsAutoCString messageId;
+          msgHdr->GetMessageId(getter_Copies(messageId));
+          if (isFirstPass) {
+            nsAutoCString reference;
+            reference.Append('<');
+            reference.Append(messageId);
+            reference.Append('>');
+            m_compFields->SetReferences(reference.get());
+          } else {
+            nsAutoCString references;
+            m_compFields->GetReferences(getter_Copies(references));
+            references.AppendLiteral(" <");
+            references.Append(messageId);
+            references.Append('>');
+            m_compFields->SetReferences(references.get());
+          }
+          break;
+        }
+      }
+    }
+    isFirstPass = false;
+    uri = nextUri + 1;
+  } while (nextUri);
+  PR_Free(uriList);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetProgress(nsIMsgProgress** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  NS_IF_ADDREF(*_retval = mProgress);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetMessageSend(nsIMsgSend** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  NS_IF_ADDREF(*_retval = mMsgSend);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::SetMessageSend(nsIMsgSend* aMsgSend) {
+  mMsgSend = aMsgSend;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::ClearMessageSend() {
+  mMsgSend = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::SetCiteReference(nsString citeReference) {
+  mCiteReference = citeReference;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::SetSavedFolderURI(const nsACString& folderURI) {
+  m_folderName = folderURI;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetSavedFolderURI(nsACString& folderURI) {
+  folderURI = m_folderName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetOriginalMsgURI(nsACString& originalMsgURI) {
+  originalMsgURI = mOriginalMsgURI;
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// THIS IS THE CLASS THAT IS THE STREAM CONSUMER OF THE HTML OUTPUT
+// FROM LIBMIME. THIS IS FOR QUOTING
+////////////////////////////////////////////////////////////////////////////////////
+QuotingOutputStreamListener::~QuotingOutputStreamListener() {}
+
+QuotingOutputStreamListener::QuotingOutputStreamListener(
+    nsIMsgDBHdr* originalMsgHdr, bool quoteHeaders, bool headersOnly,
+    nsIMsgIdentity* identity, nsIMsgQuote* msgQuote, bool quoteOriginal,
+    const nsACString& htmlToQuote) {
+  nsresult rv;
+  mQuoteHeaders = quoteHeaders;
+  mHeadersOnly = headersOnly;
+  mIdentity = identity;
+  mOrigMsgHdr = originalMsgHdr;
+  mUnicodeBufferCharacterLength = 0;
+  mQuoteOriginal = quoteOriginal;
+  mHtmlToQuote = htmlToQuote;
+  mQuote = msgQuote;
+
+  if (!mHeadersOnly || !mHtmlToQuote.IsEmpty()) {
+    // Get header type, locale and strings from pref.
+    int32_t replyHeaderType;
+    nsString replyHeaderAuthorWrote;
+    nsString replyHeaderOnDateAuthorWrote;
+    nsString replyHeaderAuthorWroteOnDate;
+    nsString replyHeaderOriginalmessage;
+    GetReplyHeaderInfo(
+        &replyHeaderType, replyHeaderAuthorWrote, replyHeaderOnDateAuthorWrote,
+        replyHeaderAuthorWroteOnDate, replyHeaderOriginalmessage);
+
+    // For the built message body...
+    if (originalMsgHdr && !quoteHeaders) {
+      // Setup the cite information....
+      nsCString myGetter;
+      if (NS_SUCCEEDED(originalMsgHdr->GetMessageId(getter_Copies(myGetter)))) {
+        if (!myGetter.IsEmpty()) {
+          nsAutoCString buf;
+          mCiteReference.AssignLiteral("mid:");
+          MsgEscapeURL(myGetter,
+                       nsINetUtil::ESCAPE_URL_FILE_BASENAME |
+                           nsINetUtil::ESCAPE_URL_FORCED,
+                       buf);
+          mCiteReference.Append(NS_ConvertASCIItoUTF16(buf));
+        }
+      }
+
+      bool citingHeader;  // Do we have a header needing to cite any info from
+                          // original message?
+      bool headerDate;    // Do we have a header needing to cite date/time from
+                          // original message?
+      switch (replyHeaderType) {
+        case 0:  // No reply header at all (actually the "---- original message
+                 // ----" string, which is kinda misleading. TODO: Should there
+                 // be a "really no header" option?
+          mCitePrefix.Assign(replyHeaderOriginalmessage);
+          citingHeader = false;
+          headerDate = false;
+          break;
+
+        case 2:  // Insert both the original author and date in the reply header
+                 // (date followed by author)
+          mCitePrefix.Assign(replyHeaderOnDateAuthorWrote);
+          citingHeader = true;
+          headerDate = true;
+          break;
+
+        case 3:  // Insert both the original author and date in the reply header
+                 // (author followed by date)
+          mCitePrefix.Assign(replyHeaderAuthorWroteOnDate);
+          citingHeader = true;
+          headerDate = true;
+          break;
+
+        case 4:  // TODO bug 107884: implement a more featureful user specified
+                 // header
+        case 1:
+        default:  // Default is to only show the author.
+          mCitePrefix.Assign(replyHeaderAuthorWrote);
+          citingHeader = true;
+          headerDate = false;
+          break;
+      }
+
+      if (citingHeader) {
+        int32_t placeholderIndex = kNotFound;
+
+        if (headerDate) {
+          PRTime originalMsgDate;
+          rv = originalMsgHdr->GetDate(&originalMsgDate);
+          if (NS_SUCCEEDED(rv)) {
+            nsAutoString citeDatePart;
+            if ((placeholderIndex = mCitePrefix.Find(u"#2")) != kNotFound) {
+              mozilla::intl::DateTimeFormat::StyleBag style;
+              style.date =
+                  mozilla::Some(mozilla::intl::DateTimeFormat::Style::Short);
+              rv = mozilla::intl::AppDateTimeFormat::Format(
+                  style, originalMsgDate, citeDatePart);
+              if (NS_SUCCEEDED(rv))
+                mCitePrefix.Replace(placeholderIndex, 2, citeDatePart);
+            }
+            if ((placeholderIndex = mCitePrefix.Find(u"#3")) != kNotFound) {
+              mozilla::intl::DateTimeFormat::StyleBag style;
+              style.time =
+                  mozilla::Some(mozilla::intl::DateTimeFormat::Style::Short);
+              rv = mozilla::intl::AppDateTimeFormat::Format(
+                  style, originalMsgDate, citeDatePart);
+              if (NS_SUCCEEDED(rv))
+                mCitePrefix.Replace(placeholderIndex, 2, citeDatePart);
+            }
+          }
+        }
+
+        if ((placeholderIndex = mCitePrefix.Find(u"#1")) != kNotFound) {
+          nsAutoCString author;
+          rv = originalMsgHdr->GetAuthor(getter_Copies(author));
+          if (NS_SUCCEEDED(rv)) {
+            nsAutoString citeAuthor;
+            ExtractName(EncodedHeader(author), citeAuthor);
+            mCitePrefix.Replace(placeholderIndex, 2, citeAuthor);
+          }
+        }
+      }
+    }
+
+    // This should not happen, but just in case.
+    if (mCitePrefix.IsEmpty()) {
+      mCitePrefix.AppendLiteral("\n\n");
+      mCitePrefix.Append(replyHeaderOriginalmessage);
+      mCitePrefix.AppendLiteral("\n");
+    }
+  }
+}
+
+/**
+ * The formatflowed parameter directs if formatflowed should be used in the
+ * conversion. format=flowed (RFC 2646) is a way to represent flow in a plain
+ * text mail, without disturbing the plain text.
+ */
+nsresult QuotingOutputStreamListener::ConvertToPlainText(bool formatflowed,
+                                                         bool formatted,
+                                                         bool disallowBreaks) {
+  nsresult rv =
+      ConvertBufToPlainText(mMsgBody, formatflowed, formatted, disallowBreaks);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ConvertBufToPlainText(mSignature, formatflowed, formatted,
+                               disallowBreaks);
+}
+
+NS_IMETHODIMP QuotingOutputStreamListener::OnStartRequest(nsIRequest* request) {
+  return NS_OK;
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
+QuotingOutputStreamListener::OnStopRequest(nsIRequest* request,
+                                           nsresult status) {
+  nsresult rv = NS_OK;
+
+  if (!mHtmlToQuote.IsEmpty()) {
+    // If we had a selection in the original message to quote, we can add
+    // it now that we are done ignoring the original body of the message
+    mHeadersOnly = false;
+    rv = AppendToMsgBody(mHtmlToQuote);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCOMPtr<nsIMsgCompose> compose = do_QueryReferent(mWeakComposeObj);
+  NS_ENSURE_TRUE(compose, NS_ERROR_NULL_POINTER);
+
+  MSG_ComposeType type;
+  compose->GetType(&type);
+
+  // Assign cite information if available...
+  if (!mCiteReference.IsEmpty()) compose->SetCiteReference(mCiteReference);
+
+  bool overrideReplyTo =
+      mozilla::Preferences::GetBool("mail.override_list_reply_to", true);
+
+  if (mHeaders &&
+      (type == nsIMsgCompType::Reply || type == nsIMsgCompType::ReplyAll ||
+       type == nsIMsgCompType::ReplyToList ||
+       type == nsIMsgCompType::ReplyToSender ||
+       type == nsIMsgCompType::ReplyToGroup ||
+       type == nsIMsgCompType::ReplyToSenderAndGroup) &&
+      mQuoteOriginal) {
+    nsCOMPtr<nsIMsgCompFields> compFields;
+    compose->GetCompFields(getter_AddRefs(compFields));
+    if (compFields) {
+      nsAutoString from;
+      nsAutoString to;
+      nsAutoString cc;
+      nsAutoString bcc;
+      nsAutoString replyTo;
+      nsAutoString mailReplyTo;
+      nsAutoString mailFollowupTo;
+      nsAutoString newgroups;
+      nsAutoString followUpTo;
+      nsAutoString messageId;
+      nsAutoString references;
+      nsAutoString listPost;
+
+      nsCString outCString;  // Temp helper string.
+
+      bool needToRemoveDup = false;
+      if (!mMimeConverter) {
+        mMimeConverter =
+            do_GetService("@mozilla.org/messenger/mimeconverter;1", &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      nsCString charset("UTF-8");
+
+      mHeaders->ExtractHeader(HEADER_FROM, true, outCString);
+      nsMsgI18NConvertRawBytesToUTF16(outCString, charset, from);
+
+      mHeaders->ExtractHeader(HEADER_TO, true, outCString);
+      nsMsgI18NConvertRawBytesToUTF16(outCString, charset, to);
+
+      mHeaders->ExtractHeader(HEADER_CC, true, outCString);
+      nsMsgI18NConvertRawBytesToUTF16(outCString, charset, cc);
+
+      mHeaders->ExtractHeader(HEADER_BCC, true, outCString);
+      nsMsgI18NConvertRawBytesToUTF16(outCString, charset, bcc);
+
+      mHeaders->ExtractHeader(HEADER_MAIL_FOLLOWUP_TO, true, outCString);
+      nsMsgI18NConvertRawBytesToUTF16(outCString, charset, mailFollowupTo);
+
+      mHeaders->ExtractHeader(HEADER_REPLY_TO, false, outCString);
+      nsMsgI18NConvertRawBytesToUTF16(outCString, charset, replyTo);
+
+      mHeaders->ExtractHeader(HEADER_MAIL_REPLY_TO, true, outCString);
+      nsMsgI18NConvertRawBytesToUTF16(outCString, charset, mailReplyTo);
+
+      mHeaders->ExtractHeader(HEADER_NEWSGROUPS, false, outCString);
+      if (!outCString.IsEmpty())
+        mMimeConverter->DecodeMimeHeader(outCString.get(), charset.get(), false,
+                                         true, newgroups);
+
+      mHeaders->ExtractHeader(HEADER_FOLLOWUP_TO, false, outCString);
+      if (!outCString.IsEmpty())
+        mMimeConverter->DecodeMimeHeader(outCString.get(), charset.get(), false,
+                                         true, followUpTo);
+
+      mHeaders->ExtractHeader(HEADER_MESSAGE_ID, false, outCString);
+      if (!outCString.IsEmpty())
+        mMimeConverter->DecodeMimeHeader(outCString.get(), charset.get(), false,
+                                         true, messageId);
+
+      mHeaders->ExtractHeader(HEADER_REFERENCES, false, outCString);
+      if (!outCString.IsEmpty())
+        mMimeConverter->DecodeMimeHeader(outCString.get(), charset.get(), false,
+                                         true, references);
+
+      mHeaders->ExtractHeader(HEADER_LIST_POST, true, outCString);
+      if (!outCString.IsEmpty())
+        mMimeConverter->DecodeMimeHeader(outCString.get(), charset.get(), false,
+                                         true, listPost);
+      if (!listPost.IsEmpty()) {
+        int32_t startPos = listPost.Find(u"<mailto:");
+        int32_t endPos = listPost.FindChar('>', startPos);
+        // Extract the e-mail address.
+        if (endPos > startPos) {
+          const uint32_t mailtoLen = strlen("<mailto:");
+          listPost = Substring(listPost, startPos + mailtoLen,
+                               endPos - (startPos + mailtoLen));
+        }
+      }
+
+      nsCString fromEmailAddress;
+      ExtractEmail(EncodedHeaderW(from), fromEmailAddress);
+
+      nsTArray<nsCString> toEmailAddresses;
+      ExtractEmails(EncodedHeaderW(to), UTF16ArrayAdapter<>(toEmailAddresses));
+
+      nsTArray<nsCString> ccEmailAddresses;
+      ExtractEmails(EncodedHeaderW(cc), UTF16ArrayAdapter<>(ccEmailAddresses));
+
+      nsCOMPtr<nsIPrefBranch> prefs(
+          do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+      NS_ENSURE_SUCCESS(rv, rv);
+      bool replyToSelfCheckAll = false;
+      prefs->GetBoolPref("mailnews.reply_to_self_check_all_ident",
+                         &replyToSelfCheckAll);
+
+      nsCOMPtr<nsIMsgAccountManager> accountManager =
+          do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsTArray<RefPtr<nsIMsgIdentity>> identities;
+      nsCString accountKey;
+      mOrigMsgHdr->GetAccountKey(getter_Copies(accountKey));
+      if (replyToSelfCheckAll) {
+        // Check all available identities if the pref was set.
+        accountManager->GetAllIdentities(identities);
+      } else if (!accountKey.IsEmpty()) {
+        // Check headers to see which account the message came in from
+        // (only works for pop3).
+        nsCOMPtr<nsIMsgAccount> account;
+        accountManager->GetAccount(accountKey, getter_AddRefs(account));
+        if (account) {
+          rv = account->GetIdentities(identities);
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+      } else {
+        // Check identities only for the server of the folder that the message
+        // is in.
+        nsCOMPtr<nsIMsgFolder> msgFolder;
+        rv = mOrigMsgHdr->GetFolder(getter_AddRefs(msgFolder));
+
+        if (NS_SUCCEEDED(rv) && msgFolder) {
+          nsCOMPtr<nsIMsgIncomingServer> nsIMsgIncomingServer;
+          rv = msgFolder->GetServer(getter_AddRefs(nsIMsgIncomingServer));
+
+          if (NS_SUCCEEDED(rv) && nsIMsgIncomingServer) {
+            rv = accountManager->GetIdentitiesForServer(nsIMsgIncomingServer,
+                                                        identities);
+            NS_ENSURE_SUCCESS(rv, rv);
+          }
+        }
+      }
+
+      bool isReplyToSelf = false;
+      nsCOMPtr<nsIMsgIdentity> selfIdentity;
+      if (!identities.IsEmpty()) {
+        nsTArray<nsCString> toEmailAddressesLower(toEmailAddresses.Length());
+        for (auto email : toEmailAddresses) {
+          ToLowerCase(email);
+          toEmailAddressesLower.AppendElement(email);
+        }
+        nsTArray<nsCString> ccEmailAddressesLower(ccEmailAddresses.Length());
+        for (auto email : ccEmailAddresses) {
+          ToLowerCase(email);
+          ccEmailAddressesLower.AppendElement(email);
+        }
+
+        // Go through the identities to see if any of them is the author of
+        // the email.
+        for (auto lookupIdentity : identities) {
+          selfIdentity = lookupIdentity;
+
+          nsCString curIdentityEmail;
+          lookupIdentity->GetEmail(curIdentityEmail);
+
+          // See if it's a reply to own message, but not a reply between
+          // identities.
+          if (curIdentityEmail.Equals(fromEmailAddress,
+                                      nsCaseInsensitiveCStringComparator)) {
+            isReplyToSelf = true;
+            // For a true reply-to-self, none of your identities are normally in
+            // To or Cc. We need to avoid doing a reply-to-self for people that
+            // have multiple identities set and sometimes *uses* the other
+            // identity and sometimes *mails* the other identity.
+            // E.g. husband+wife or own-email+company-role-mail.
+            for (auto lookupIdentity2 : identities) {
+              nsCString curIdentityEmail2;
+              lookupIdentity2->GetEmail(curIdentityEmail2);
+              ToLowerCase(curIdentityEmail2);
+              if (toEmailAddressesLower.Contains(curIdentityEmail2)) {
+                // However, "From:me To:me" should be treated as
+                // reply-to-self if we have a Bcc. If we don't have a Bcc we
+                // might have the case of a generated mail of the style
+                // "From:me To:me Reply-To:customer". Then we need to to do a
+                // normal reply to the customer.
+                isReplyToSelf = !bcc.IsEmpty();  // true if bcc is set
+                break;
+              } else if (ccEmailAddressesLower.Contains(curIdentityEmail2)) {
+                // If you auto-Cc yourself your email would be in Cc - but we
+                // can't detect why it is in Cc so lets just treat it like a
+                // normal reply.
+                isReplyToSelf = false;
+                break;
+              }
+            }
+            break;
+          }
+        }
+      }
+      if (type == nsIMsgCompType::ReplyToSenderAndGroup ||
+          type == nsIMsgCompType::ReplyToSender ||
+          type == nsIMsgCompType::Reply) {
+        if (isReplyToSelf) {
+          // Cast to concrete class. We *only* what to change m_identity, not
+          // all the things compose->SetIdentity would do.
+          nsMsgCompose* _compose = static_cast<nsMsgCompose*>(compose.get());
+          _compose->m_identity = selfIdentity;
+          compFields->SetFrom(from);
+          compFields->SetTo(to);
+          compFields->SetReplyTo(replyTo);
+        } else if (!mailReplyTo.IsEmpty()) {
+          // handle Mail-Reply-To (http://cr.yp.to/proto/replyto.html)
+          compFields->SetTo(mailReplyTo);
+          needToRemoveDup = true;
+        } else if (!replyTo.IsEmpty()) {
+          // default reply behaviour then
+
+          if (overrideReplyTo && !listPost.IsEmpty() &&
+              replyTo.Find(listPost) != kNotFound) {
+            // Reply-To munging in this list post. Reply to From instead,
+            // as the user can choose Reply List if that's what he wants.
+            compFields->SetTo(from);
+          } else {
+            compFields->SetTo(replyTo);
+          }
+          needToRemoveDup = true;
+        } else {
+          compFields->SetTo(from);
+        }
+      } else if (type == nsIMsgCompType::ReplyAll) {
+        if (isReplyToSelf) {
+          // Cast to concrete class. We *only* what to change m_identity, not
+          // all the things compose->SetIdentity would do.
+          nsMsgCompose* _compose = static_cast<nsMsgCompose*>(compose.get());
+          _compose->m_identity = selfIdentity;
+          compFields->SetFrom(from);
+          compFields->SetTo(to);
+          compFields->SetCc(cc);
+          // In case it's a reply to self, but it's not the actual source of the
+          // sent message, then we won't know the Bcc header. So set it only if
+          // it's not empty. If you have auto-bcc and removed the auto-bcc for
+          // the original mail, you will have to do it manually for this reply
+          // too.
+          if (!bcc.IsEmpty()) compFields->SetBcc(bcc);
+          compFields->SetReplyTo(replyTo);
+          needToRemoveDup = true;
+        } else if (mailFollowupTo.IsEmpty()) {
+          // default reply-all behaviour then
+
+          nsAutoString allTo;
+          if (!replyTo.IsEmpty()) {
+            allTo.Assign(replyTo);
+            needToRemoveDup = true;
+            if (overrideReplyTo && !listPost.IsEmpty() &&
+                replyTo.Find(listPost) != kNotFound) {
+              // Reply-To munging in this list. Add From to recipients, it's the
+              // lesser evil...
+              allTo.AppendLiteral(", ");
+              allTo.Append(from);
+            }
+          } else {
+            allTo.Assign(from);
+          }
+
+          allTo.AppendLiteral(", ");
+          allTo.Append(to);
+          compFields->SetTo(allTo);
+
+          nsAutoString allCc;
+          compFields->GetCc(allCc);  // auto-cc
+          if (!allCc.IsEmpty()) allCc.AppendLiteral(", ");
+          allCc.Append(cc);
+          compFields->SetCc(allCc);
+
+          needToRemoveDup = true;
+        } else {
+          // Handle Mail-Followup-To (http://cr.yp.to/proto/replyto.html)
+          compFields->SetTo(mailFollowupTo);
+          needToRemoveDup = true;  // To remove possible self from To.
+
+          // If Cc is set a this point it's auto-Ccs, so we'll just keep those.
+        }
+      } else if (type == nsIMsgCompType::ReplyToList) {
+        compFields->SetTo(listPost);
+      }
+
+      if (!newgroups.IsEmpty()) {
+        if ((type != nsIMsgCompType::Reply) &&
+            (type != nsIMsgCompType::ReplyToSender))
+          compFields->SetNewsgroups(newgroups);
+        if (type == nsIMsgCompType::ReplyToGroup)
+          compFields->SetTo(EmptyString());
+      }
+
+      if (!followUpTo.IsEmpty()) {
+        // Handle "followup-to: poster" magic keyword here
+        if (followUpTo.EqualsLiteral("poster")) {
+          nsCOMPtr<mozIDOMWindowProxy> domWindow;
+          compose->GetDomWindow(getter_AddRefs(domWindow));
+          NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
+          nsMsgDisplayMessageByName(domWindow, "followupToSenderMessage");
+
+          if (!replyTo.IsEmpty()) {
+            compFields->SetTo(replyTo);
+          } else {
+            // If reply-to is empty, use the From header to fetch the original
+            // sender's email.
+            compFields->SetTo(from);
+          }
+
+          // Clear the newsgroup: header field, because followup-to: poster
+          // only follows up to the original sender
+          if (!newgroups.IsEmpty()) compFields->SetNewsgroups(EmptyString());
+        } else  // Process "followup-to: newsgroup-content" here
+        {
+          if (type != nsIMsgCompType::ReplyToSender)
+            compFields->SetNewsgroups(followUpTo);
+          if (type == nsIMsgCompType::Reply) {
+            compFields->SetTo(EmptyString());
+          }
+        }
+      }
+
+      if (!references.IsEmpty()) references.Append(char16_t(' '));
+      references += messageId;
+      compFields->SetReferences(NS_LossyConvertUTF16toASCII(references).get());
+
+      nsAutoCString resultStr;
+
+      // Cast interface to concrete class that has direct field getters etc.
+      nsMsgCompFields* _compFields =
+          static_cast<nsMsgCompFields*>(compFields.get());
+
+      // Remove duplicate addresses between To && Cc.
+      if (needToRemoveDup) {
+        nsCString addressesToRemoveFromCc;
+        if (mIdentity) {
+          bool removeMyEmailInCc = true;
+          nsCString myEmail;
+          // Get senders address from composeField or from identity,
+          nsAutoCString sender(_compFields->GetFrom());
+          ExtractEmail(EncodedHeader(sender), myEmail);
+          if (myEmail.IsEmpty()) mIdentity->GetEmail(myEmail);
+
+          // Remove my own address from To, unless it's a reply to self.
+          if (!isReplyToSelf) {
+            RemoveDuplicateAddresses(nsDependentCString(_compFields->GetTo()),
+                                     myEmail, resultStr);
+            _compFields->SetTo(resultStr.get());
+          }
+          addressesToRemoveFromCc.Assign(_compFields->GetTo());
+
+          // Remove own address from CC unless we want it in there
+          // through the automatic-CC-to-self (see bug 584962). There are
+          // three cases:
+          // - user has no automatic CC
+          // - user has automatic CC but own email is not in it
+          // - user has automatic CC and own email in it
+          // Only in the last case do we want our own email address to stay
+          // in the CC list.
+          bool automaticCc;
+          mIdentity->GetDoCc(&automaticCc);
+          if (automaticCc) {
+            nsCString autoCcList;
+            mIdentity->GetDoCcList(autoCcList);
+            nsTArray<nsCString> autoCcEmailAddresses;
+            ExtractEmails(EncodedHeader(autoCcList),
+                          UTF16ArrayAdapter<>(autoCcEmailAddresses));
+            if (autoCcEmailAddresses.Contains(myEmail)) {
+              removeMyEmailInCc = false;
+            }
+          }
+
+          if (removeMyEmailInCc) {
+            addressesToRemoveFromCc.AppendLiteral(", ");
+            addressesToRemoveFromCc.Append(myEmail);
+          }
+        }
+        RemoveDuplicateAddresses(nsDependentCString(_compFields->GetCc()),
+                                 addressesToRemoveFromCc, resultStr);
+        _compFields->SetCc(resultStr.get());
+        if (_compFields->GetBcc()) {
+          // Remove addresses already in Cc from Bcc.
+          RemoveDuplicateAddresses(nsDependentCString(_compFields->GetBcc()),
+                                   nsDependentCString(_compFields->GetCc()),
+                                   resultStr);
+          if (!resultStr.IsEmpty()) {
+            // Remove addresses already in To from Bcc.
+            RemoveDuplicateAddresses(
+                resultStr, nsDependentCString(_compFields->GetTo()), resultStr);
+          }
+          _compFields->SetBcc(resultStr.get());
+        }
+      }
+    }
+  }
+
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+  nsCOMPtr<nsIMsgComposeService> composeService(
+      do_GetService("@mozilla.org/messengercompose;1"));
+  composeService->TimeStamp(
+      "Done with MIME. Now we're updating the UI elements", false);
+#endif
+
+  if (mQuoteOriginal)
+    compose->NotifyStateListeners(
+        nsIMsgComposeNotificationType::ComposeFieldsReady, NS_OK);
+
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+  composeService->TimeStamp(
+      "Addressing widget, window title and focus are now set, time to insert "
+      "the body",
+      false);
+#endif
+
+  if (!mHeadersOnly) mMsgBody.AppendLiteral("</html>");
+
+  // Now we have an HTML representation of the quoted message.
+  // If we are in plain text mode, we need to convert this to plain
+  // text before we try to insert it into the editor. If we don't, we
+  // just get lots of HTML text in the message...not good.
+  //
+  // XXX not m_composeHTML? /BenB
+  bool composeHTML = true;
+  compose->GetComposeHTML(&composeHTML);
+  if (!composeHTML) {
+    // Downsampling.
+
+    // In plain text quotes we always allow line breaking to not end up with
+    // long lines. The quote is inserted into a span with style
+    // "white-space: pre;" which isn't be wrapped.
+    // Update: Bug 387687 changed this to "white-space: pre-wrap;".
+    // Note that the body of the plain text message is wrapped since it uses
+    // "white-space: pre-wrap; width: 72ch;".
+    // Look at it in the DOM Inspector to see it.
+    //
+    // If we're using format flowed, we need to pass it so the encoder
+    // can add a space at the end.
+    nsCOMPtr<nsIPrefBranch> pPrefBranch(
+        do_GetService(NS_PREFSERVICE_CONTRACTID));
+    bool flowed = false;
+    if (pPrefBranch) {
+      pPrefBranch->GetBoolPref("mailnews.send_plaintext_flowed", &flowed);
+    }
+
+    rv = ConvertToPlainText(flowed,
+                            true,    // formatted
+                            false);  // allow line breaks
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  compose->ProcessSignature(mIdentity, true, &mSignature);
+
+  nsCOMPtr<nsIEditor> editor;
+  if (NS_SUCCEEDED(compose->GetEditor(getter_AddRefs(editor))) && editor) {
+    if (mQuoteOriginal)
+      compose->ConvertAndLoadComposeWindow(mCitePrefix, mMsgBody, mSignature,
+                                           true, composeHTML);
+    else
+      InsertToCompose(editor, composeHTML);
+  }
+
+  if (mQuoteOriginal)
+    compose->NotifyStateListeners(
+        nsIMsgComposeNotificationType::ComposeBodyReady, NS_OK);
+  return rv;
+}
+
+NS_IMETHODIMP QuotingOutputStreamListener::OnDataAvailable(
+    nsIRequest* request, nsIInputStream* inStr, uint64_t sourceOffset,
+    uint32_t count) {
+  nsresult rv = NS_OK;
+  NS_ENSURE_ARG(inStr);
+
+  if (mHeadersOnly) return rv;
+
+  char* newBuf = (char*)PR_Malloc(count + 1);
+  if (!newBuf) return NS_ERROR_FAILURE;
+
+  uint32_t numWritten = 0;
+  rv = inStr->Read(newBuf, count, &numWritten);
+  if (rv == NS_BASE_STREAM_WOULD_BLOCK) rv = NS_OK;
+  newBuf[numWritten] = '\0';
+  if (NS_SUCCEEDED(rv) && numWritten > 0) {
+    rv = AppendToMsgBody(nsDependentCString(newBuf, numWritten));
+  }
+
+  PR_FREEIF(newBuf);
+  return rv;
+}
+
+nsresult QuotingOutputStreamListener::AppendToMsgBody(const nsCString& inStr) {
+  nsresult rv = NS_OK;
+  if (!inStr.IsEmpty()) {
+    nsAutoString tmp;
+    rv = UTF_8_ENCODING->DecodeWithoutBOMHandling(inStr, tmp);
+    if (NS_SUCCEEDED(rv)) mMsgBody.Append(tmp);
+  }
+  return rv;
+}
+
+nsresult QuotingOutputStreamListener::SetComposeObj(nsIMsgCompose* obj) {
+  mWeakComposeObj = do_GetWeakReference(obj);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+QuotingOutputStreamListener::SetMimeHeaders(nsIMimeHeaders* headers) {
+  mHeaders = headers;
+  return NS_OK;
+}
+
+nsresult QuotingOutputStreamListener::InsertToCompose(nsIEditor* aEditor,
+                                                      bool aHTMLEditor) {
+  NS_ENSURE_ARG(aEditor);
+  nsCOMPtr<nsINode> nodeInserted;
+
+  TranslateLineEnding(mMsgBody);
+
+  // Now, insert it into the editor...
+  aEditor->EnableUndo(true);
+
+  nsCOMPtr<nsIMsgCompose> compose = do_QueryReferent(mWeakComposeObj);
+  if (!mMsgBody.IsEmpty() && compose) {
+    compose->SetAllowRemoteContent(true);
+    if (!mCitePrefix.IsEmpty()) {
+      if (!aHTMLEditor) mCitePrefix.AppendLiteral("\n");
+      aEditor->InsertText(mCitePrefix);
+    }
+
+    RefPtr<mozilla::HTMLEditor> htmlEditor = aEditor->AsHTMLEditor();
+    if (aHTMLEditor) {
+      nsAutoString body(mMsgBody);
+      remove_plaintext_tag(body);
+      htmlEditor->InsertAsCitedQuotation(body, EmptyString(), true,
+                                         getter_AddRefs(nodeInserted));
+    } else {
+      htmlEditor->InsertAsQuotation(mMsgBody, getter_AddRefs(nodeInserted));
+    }
+    compose->SetAllowRemoteContent(false);
+  }
+
+  RefPtr<Selection> selection;
+  nsCOMPtr<nsINode> parent;
+  int32_t offset;
+  nsresult rv;
+
+  // get parent and offset of mailcite
+  rv = GetNodeLocation(nodeInserted, address_of(parent), &offset);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // get selection
+  aEditor->GetSelection(getter_AddRefs(selection));
+  if (selection) {
+    // place selection after mailcite
+    selection->CollapseInLimiter(parent, offset + 1);
+    // insert a break at current selection
+    aEditor->InsertLineBreak();
+    selection->CollapseInLimiter(parent, offset + 1);
+  }
+  nsCOMPtr<nsISelectionController> selCon;
+  aEditor->GetSelectionController(getter_AddRefs(selCon));
+
+  if (selCon)
+    // After ScrollSelectionIntoView(), the pending notifications might be
+    // flushed and PresShell/PresContext/Frames may be dead. See bug 418470.
+    selCon->ScrollSelectionIntoView(
+        nsISelectionController::SELECTION_NORMAL,
+        nsISelectionController::SELECTION_ANCHOR_REGION, true);
+
+  return NS_OK;
+}
+
+/**
+ * Returns true if the domain is a match for the given the domain list.
+ * Subdomains are also considered to match.
+ * @param aDomain - the domain name to check
+ * @param aDomainList - a comma separated string of domain names
+ */
+bool IsInDomainList(const nsAString& aDomain, const nsAString& aDomainList) {
+  if (aDomain.IsEmpty() || aDomainList.IsEmpty()) return false;
+
+  // Check plain text domains.
+  int32_t left = 0;
+  int32_t right = 0;
+  while (right != (int32_t)aDomainList.Length()) {
+    right = aDomainList.FindChar(',', left);
+    if (right == kNotFound) right = aDomainList.Length();
+    nsDependentSubstring domain = Substring(aDomainList, left, right);
+
+    if (aDomain.Equals(domain, nsCaseInsensitiveStringComparator)) return true;
+
+    nsAutoString dotDomain;
+    dotDomain.Assign(u'.');
+    dotDomain.Append(domain);
+    if (StringEndsWith(aDomain, dotDomain, nsCaseInsensitiveStringComparator))
+      return true;
+
+    left = right + 1;
+  }
+  return false;
+}
+
+NS_IMPL_ISUPPORTS(QuotingOutputStreamListener,
+                  nsIMsgQuotingOutputStreamListener, nsIRequestObserver,
+                  nsIStreamListener, nsISupportsWeakReference)
+
+////////////////////////////////////////////////////////////////////////////////////
+// END OF QUOTING LISTENER
+////////////////////////////////////////////////////////////////////////////////////
+
+/* attribute MSG_ComposeType type; */
+NS_IMETHODIMP nsMsgCompose::SetType(MSG_ComposeType aType) {
+  mType = aType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetType(MSG_ComposeType* aType) {
+  NS_ENSURE_ARG_POINTER(aType);
+
+  *aType = mType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::QuoteMessage(const nsACString& msgURI) {
+  nsresult rv;
+  mQuotingToFollow = false;
+
+  // Create a mime parser (nsIStreamConverter)!
+  mQuote = do_CreateInstance("@mozilla.org/messengercompose/quoting;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  rv = GetMsgDBHdrFromURI(msgURI, getter_AddRefs(msgHdr));
+
+  // Create the consumer output stream.. this will receive all the HTML from
+  // libmime
+  mQuoteStreamListener =
+      new QuotingOutputStreamListener(msgHdr, false, !mHtmlToQuote.IsEmpty(),
+                                      m_identity, mQuote, false, mHtmlToQuote);
+
+  mQuoteStreamListener->SetComposeObj(this);
+
+  rv = mQuote->QuoteMessage(msgURI, false, mQuoteStreamListener,
+                            mAutodetectCharset, false, msgHdr);
+  return rv;
+}
+
+nsresult nsMsgCompose::QuoteOriginalMessage()  // New template
+{
+  nsresult rv;
+
+  mQuotingToFollow = false;
+
+  // Create a mime parser (nsIStreamConverter)!
+  mQuote = do_CreateInstance("@mozilla.org/messengercompose/quoting;1", &rv);
+  if (NS_FAILED(rv) || !mQuote) return NS_ERROR_FAILURE;
+
+  bool bAutoQuote = true;
+  m_identity->GetAutoQuote(&bAutoQuote);
+
+  nsCOMPtr<nsIMsgDBHdr> originalMsgHdr = mOrigMsgHdr;
+  if (!originalMsgHdr) {
+    rv = GetMsgDBHdrFromURI(mOriginalMsgURI, getter_AddRefs(originalMsgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsAutoCString msgUri(mOriginalMsgURI);
+  bool fileUrl = StringBeginsWith(msgUri, "file:"_ns);
+  if (fileUrl) {
+    msgUri.Replace(0, 5, "mailbox:"_ns);
+    msgUri.AppendLiteral("?number=0");
+  }
+
+  // Create the consumer output stream.. this will receive all the HTML from
+  // libmime
+  mQuoteStreamListener = new QuotingOutputStreamListener(
+      originalMsgHdr, mWhatHolder != 1, !bAutoQuote || !mHtmlToQuote.IsEmpty(),
+      m_identity, mQuote, true, mHtmlToQuote);
+
+  mQuoteStreamListener->SetComposeObj(this);
+
+  rv = mQuote->QuoteMessage(msgUri, mWhatHolder != 1, mQuoteStreamListener,
+                            mAutodetectCharset, !bAutoQuote, originalMsgHdr);
+  return rv;
+}
+
+// CleanUpRecipient will remove un-necessary "<>" when a recipient as an address
+// without name
+void nsMsgCompose::CleanUpRecipients(nsString& recipients) {
+  uint16_t i;
+  bool startANewRecipient = true;
+  bool removeBracket = false;
+  nsAutoString newRecipient;
+  char16_t aChar;
+
+  for (i = 0; i < recipients.Length(); i++) {
+    aChar = recipients[i];
+    switch (aChar) {
+      case '<':
+        if (startANewRecipient)
+          removeBracket = true;
+        else
+          newRecipient += aChar;
+        startANewRecipient = false;
+        break;
+
+      case '>':
+        if (removeBracket)
+          removeBracket = false;
+        else
+          newRecipient += aChar;
+        break;
+
+      case ' ':
+        newRecipient += aChar;
+        break;
+
+      case ',':
+        newRecipient += aChar;
+        startANewRecipient = true;
+        removeBracket = false;
+        break;
+
+      default:
+        newRecipient += aChar;
+        startANewRecipient = false;
+        break;
+    }
+  }
+  recipients = newRecipient;
+}
+
+NS_IMETHODIMP nsMsgCompose::RememberQueuedDisposition() {
+  // need to find the msg hdr in the saved folder and then set a property on
+  // the header that we then look at when we actually send the message.
+  nsresult rv;
+  nsAutoCString dispositionSetting;
+
+  if (mType == nsIMsgCompType::Reply || mType == nsIMsgCompType::ReplyAll ||
+      mType == nsIMsgCompType::ReplyToList ||
+      mType == nsIMsgCompType::ReplyToGroup ||
+      mType == nsIMsgCompType::ReplyToSender ||
+      mType == nsIMsgCompType::ReplyToSenderAndGroup) {
+    dispositionSetting.AssignLiteral("replied");
+  } else if (mType == nsIMsgCompType::ForwardAsAttachment ||
+             mType == nsIMsgCompType::ForwardInline) {
+    dispositionSetting.AssignLiteral("forwarded");
+  } else if (mType == nsIMsgCompType::Redirect) {
+    dispositionSetting.AssignLiteral("redirected");
+  } else if (mType == nsIMsgCompType::Draft) {
+    nsAutoCString curDraftIdURL;
+    rv = m_compFields->GetDraftId(curDraftIdURL);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!curDraftIdURL.IsEmpty()) {
+      nsCOMPtr<nsIMsgDBHdr> draftHdr;
+      rv = GetMsgDBHdrFromURI(curDraftIdURL, getter_AddRefs(draftHdr));
+      NS_ENSURE_SUCCESS(rv, rv);
+      draftHdr->GetStringProperty(QUEUED_DISPOSITION_PROPERTY,
+                                  dispositionSetting);
+    }
+  }
+
+  nsMsgKey msgKey;
+  if (mMsgSend) {
+    mMsgSend->GetMessageKey(&msgKey);
+    nsCString identityKey;
+
+    m_identity->GetKey(identityKey);
+
+    nsCOMPtr<nsIMsgFolder> folder;
+    rv = GetOrCreateFolder(m_folderName, getter_AddRefs(folder));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    rv = folder->GetMessageHeader(msgKey, getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    uint32_t pseudoHdrProp = 0;
+    msgHdr->GetUint32Property("pseudoHdr", &pseudoHdrProp);
+    if (pseudoHdrProp) {
+      // Use SetAttributeOnPendingHdr for IMAP pseudo headers, as those
+      // will get deleted (and properties set using SetStringProperty lost.)
+      nsCOMPtr<nsIMsgFolder> folder;
+      rv = msgHdr->GetFolder(getter_AddRefs(folder));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr<nsIMsgDatabase> msgDB;
+      rv = folder->GetMsgDatabase(getter_AddRefs(msgDB));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCString messageId;
+      mMsgSend->GetMessageId(messageId);
+      msgHdr->SetMessageId(messageId.get());
+      if (!mOriginalMsgURI.IsEmpty()) {
+        msgDB->SetAttributeOnPendingHdr(msgHdr, ORIG_URI_PROPERTY,
+                                        mOriginalMsgURI.get());
+        if (!dispositionSetting.IsEmpty())
+          msgDB->SetAttributeOnPendingHdr(msgHdr, QUEUED_DISPOSITION_PROPERTY,
+                                          dispositionSetting.get());
+      }
+      msgDB->SetAttributeOnPendingHdr(msgHdr, HEADER_X_MOZILLA_IDENTITY_KEY,
+                                      identityKey.get());
+    } else if (msgHdr) {
+      if (!mOriginalMsgURI.IsEmpty()) {
+        msgHdr->SetStringProperty(ORIG_URI_PROPERTY, mOriginalMsgURI);
+        if (!dispositionSetting.IsEmpty())
+          msgHdr->SetStringProperty(QUEUED_DISPOSITION_PROPERTY,
+                                    dispositionSetting);
+      }
+      msgHdr->SetStringProperty(HEADER_X_MOZILLA_IDENTITY_KEY, identityKey);
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::ProcessReplyFlags() {
+  nsresult rv;
+  // check to see if we were doing a reply or a forward, if we were, set the
+  // answered field flag on the message folder for this URI.
+  if (mType == nsIMsgCompType::Reply || mType == nsIMsgCompType::ReplyAll ||
+      mType == nsIMsgCompType::ReplyToList ||
+      mType == nsIMsgCompType::ReplyToGroup ||
+      mType == nsIMsgCompType::ReplyToSender ||
+      mType == nsIMsgCompType::ReplyToSenderAndGroup ||
+      mType == nsIMsgCompType::ForwardAsAttachment ||
+      mType == nsIMsgCompType::ForwardInline ||
+      mType == nsIMsgCompType::Redirect ||
+      mDraftDisposition != nsIMsgFolder::nsMsgDispositionState_None) {
+    if (!mOriginalMsgURI.IsEmpty()) {
+      nsCString msgUri(mOriginalMsgURI);
+      char* newStr = msgUri.BeginWriting();
+      char* uri;
+      while (nullptr != (uri = NS_strtok(",", &newStr))) {
+        nsCOMPtr<nsIMsgDBHdr> msgHdr;
+        rv =
+            GetMsgDBHdrFromURI(nsDependentCString(uri), getter_AddRefs(msgHdr));
+        NS_ENSURE_SUCCESS(rv, rv);
+        if (msgHdr) {
+          // get the folder for the message resource
+          nsCOMPtr<nsIMsgFolder> msgFolder;
+          msgHdr->GetFolder(getter_AddRefs(msgFolder));
+          if (msgFolder) {
+            // If it's a draft with disposition, default to replied, otherwise,
+            // check if it's a forward.
+            nsMsgDispositionState dispositionSetting =
+                nsIMsgFolder::nsMsgDispositionState_Replied;
+            if (mDraftDisposition != nsIMsgFolder::nsMsgDispositionState_None)
+              dispositionSetting = mDraftDisposition;
+            else if (mType == nsIMsgCompType::ForwardAsAttachment ||
+                     mType == nsIMsgCompType::ForwardInline)
+              dispositionSetting =
+                  nsIMsgFolder::nsMsgDispositionState_Forwarded;
+            else if (mType == nsIMsgCompType::Redirect)
+              dispositionSetting =
+                  nsIMsgFolder::nsMsgDispositionState_Redirected;
+
+            msgFolder->AddMessageDispositionState(msgHdr, dispositionSetting);
+            if (mType != nsIMsgCompType::ForwardAsAttachment)
+              break;  // just safeguard
+          }
+        }
+      }
+    }
+  }
+
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgCompose::OnStartSending(const char* aMsgID,
+                                           uint32_t aMsgSize) {
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener>>::ForwardIterator iter(
+      mExternalSendListeners);
+  nsCOMPtr<nsIMsgSendListener> externalSendListener;
+
+  while (iter.HasMore()) {
+    externalSendListener = iter.GetNext();
+    externalSendListener->OnStartSending(aMsgID, aMsgSize);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::OnProgress(const char* aMsgID, uint32_t aProgress,
+                                       uint32_t aProgressMax) {
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener>>::ForwardIterator iter(
+      mExternalSendListeners);
+  nsCOMPtr<nsIMsgSendListener> externalSendListener;
+
+  while (iter.HasMore()) {
+    externalSendListener = iter.GetNext();
+    externalSendListener->OnProgress(aMsgID, aProgress, aProgressMax);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::OnStatus(const char* aMsgID, const char16_t* aMsg) {
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener>>::ForwardIterator iter(
+      mExternalSendListeners);
+  nsCOMPtr<nsIMsgSendListener> externalSendListener;
+
+  while (iter.HasMore()) {
+    externalSendListener = iter.GetNext();
+    externalSendListener->OnStatus(aMsgID, aMsg);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::OnStopSending(const char* aMsgID, nsresult aStatus,
+                                          const char16_t* aMsg,
+                                          nsIFile* returnFile) {
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener>>::ForwardIterator iter(
+      mExternalSendListeners);
+  nsCOMPtr<nsIMsgSendListener> externalSendListener;
+
+  while (iter.HasMore()) {
+    externalSendListener = iter.GetNext();
+    externalSendListener->OnStopSending(aMsgID, aStatus, aMsg, returnFile);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::OnTransportSecurityError(const char* msgID, nsresult status,
+                                       nsITransportSecurityInfo* secInfo,
+                                       nsACString const& location) {
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener>>::ForwardIterator iter(
+      mExternalSendListeners);
+  nsCOMPtr<nsIMsgSendListener> externalSendListener;
+
+  while (iter.HasMore()) {
+    externalSendListener = iter.GetNext();
+    externalSendListener->OnTransportSecurityError(msgID, status, secInfo,
+                                                   location);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::OnSendNotPerformed(const char* aMsgID,
+                                               nsresult aStatus) {
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener>>::ForwardIterator iter(
+      mExternalSendListeners);
+  nsCOMPtr<nsIMsgSendListener> externalSendListener;
+
+  while (iter.HasMore()) {
+    externalSendListener = iter.GetNext();
+    externalSendListener->OnSendNotPerformed(aMsgID, aStatus);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::OnGetDraftFolderURI(const char* aMsgID,
+                                                const nsACString& aFolderURI) {
+  m_folderName = aFolderURI;
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener>>::ForwardIterator iter(
+      mExternalSendListeners);
+  nsCOMPtr<nsIMsgSendListener> externalSendListener;
+
+  while (iter.HasMore()) {
+    externalSendListener = iter.GetNext();
+    externalSendListener->OnGetDraftFolderURI(aMsgID, aFolderURI);
+  }
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// This is the listener class for both the send operation and the copy
+// operation. We have to create this class to listen for message send completion
+// and deal with failures in both send and copy operations
+////////////////////////////////////////////////////////////////////////////////////
+NS_IMPL_ADDREF(nsMsgComposeSendListener)
+NS_IMPL_RELEASE(nsMsgComposeSendListener)
+
+/*
+NS_IMPL_QUERY_INTERFACE(nsMsgComposeSendListener,
+                         nsIMsgComposeSendListener,
+                         nsIMsgSendListener,
+                         nsIMsgCopyServiceListener,
+                         nsIWebProgressListener)
+*/
+NS_INTERFACE_MAP_BEGIN(nsMsgComposeSendListener)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMsgComposeSendListener)
+  NS_INTERFACE_MAP_ENTRY(nsIMsgComposeSendListener)
+  NS_INTERFACE_MAP_ENTRY(nsIMsgSendListener)
+  NS_INTERFACE_MAP_ENTRY(nsIMsgCopyServiceListener)
+  NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener)
+NS_INTERFACE_MAP_END
+
+nsMsgComposeSendListener::nsMsgComposeSendListener(void) { mDeliverMode = 0; }
+
+nsMsgComposeSendListener::~nsMsgComposeSendListener(void) {}
+
+NS_IMETHODIMP nsMsgComposeSendListener::SetMsgCompose(nsIMsgCompose* obj) {
+  mWeakComposeObj = do_GetWeakReference(obj);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeSendListener::SetDeliverMode(
+    MSG_DeliverMode deliverMode) {
+  mDeliverMode = deliverMode;
+  return NS_OK;
+}
+
+nsresult nsMsgComposeSendListener::OnStartSending(const char* aMsgID,
+                                                  uint32_t aMsgSize) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgSendListener> composeSendListener =
+      do_QueryReferent(mWeakComposeObj, &rv);
+  if (NS_SUCCEEDED(rv) && composeSendListener)
+    composeSendListener->OnStartSending(aMsgID, aMsgSize);
+
+  return NS_OK;
+}
+
+nsresult nsMsgComposeSendListener::OnProgress(const char* aMsgID,
+                                              uint32_t aProgress,
+                                              uint32_t aProgressMax) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgSendListener> composeSendListener =
+      do_QueryReferent(mWeakComposeObj, &rv);
+  if (NS_SUCCEEDED(rv) && composeSendListener)
+    composeSendListener->OnProgress(aMsgID, aProgress, aProgressMax);
+  return NS_OK;
+}
+
+nsresult nsMsgComposeSendListener::OnStatus(const char* aMsgID,
+                                            const char16_t* aMsg) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgSendListener> composeSendListener =
+      do_QueryReferent(mWeakComposeObj, &rv);
+  if (NS_SUCCEEDED(rv) && composeSendListener)
+    composeSendListener->OnStatus(aMsgID, aMsg);
+  return NS_OK;
+}
+
+nsresult nsMsgComposeSendListener::OnSendNotPerformed(const char* aMsgID,
+                                                      nsresult aStatus) {
+  // since OnSendNotPerformed is called in the case where the user aborts the
+  // operation by closing the compose window, we need not do the stuff required
+  // for closing the windows. However we would need to do the other operations
+  // as below.
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgCompose> msgCompose = do_QueryReferent(mWeakComposeObj, &rv);
+  if (msgCompose)
+    msgCompose->NotifyStateListeners(
+        nsIMsgComposeNotificationType::ComposeProcessDone, aStatus);
+
+  nsCOMPtr<nsIMsgSendListener> composeSendListener =
+      do_QueryReferent(mWeakComposeObj, &rv);
+  if (NS_SUCCEEDED(rv) && composeSendListener)
+    composeSendListener->OnSendNotPerformed(aMsgID, aStatus);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeSendListener::OnTransportSecurityError(
+    const char* msgID, nsresult status, nsITransportSecurityInfo* secInfo,
+    nsACString const& location) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgSendListener> composeSendListener =
+      do_QueryReferent(mWeakComposeObj, &rv);
+  if (NS_SUCCEEDED(rv) && composeSendListener)
+    composeSendListener->OnTransportSecurityError(msgID, status, secInfo,
+                                                  location);
+
+  return NS_OK;
+}
+
+nsresult nsMsgComposeSendListener::OnStopSending(const char* aMsgID,
+                                                 nsresult aStatus,
+                                                 const char16_t* aMsg,
+                                                 nsIFile* returnFile) {
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIMsgCompose> msgCompose = do_QueryReferent(mWeakComposeObj, &rv);
+  if (msgCompose) {
+    nsCOMPtr<nsIMsgProgress> progress;
+    msgCompose->GetProgress(getter_AddRefs(progress));
+
+    if (NS_SUCCEEDED(aStatus)) {
+      nsCOMPtr<nsIMsgCompFields> compFields;
+      msgCompose->GetCompFields(getter_AddRefs(compFields));
+
+      // only process the reply flags if we successfully sent the message
+      msgCompose->ProcessReplyFlags();
+
+      // See if there is a composer window
+      bool hasDomWindow = true;
+      nsCOMPtr<mozIDOMWindowProxy> domWindow;
+      rv = msgCompose->GetDomWindow(getter_AddRefs(domWindow));
+      if (NS_FAILED(rv) || !domWindow) hasDomWindow = false;
+
+      // Close the window ONLY if we are not going to do a save operation
+      nsAutoString fieldsFCC;
+      if (NS_SUCCEEDED(compFields->GetFcc(fieldsFCC))) {
+        if (!fieldsFCC.IsEmpty()) {
+          if (fieldsFCC.LowerCaseEqualsLiteral("nocopy://")) {
+            msgCompose->NotifyStateListeners(
+                nsIMsgComposeNotificationType::ComposeProcessDone, NS_OK);
+            if (progress) {
+              progress->UnregisterListener(this);
+              progress->CloseProgressDialog(false);
+            }
+            if (hasDomWindow) msgCompose->CloseWindow();
+          }
+        }
+      } else {
+        msgCompose->NotifyStateListeners(
+            nsIMsgComposeNotificationType::ComposeProcessDone, NS_OK);
+        if (progress) {
+          progress->UnregisterListener(this);
+          progress->CloseProgressDialog(false);
+        }
+        if (hasDomWindow)
+          msgCompose->CloseWindow();  // if we fail on the simple GetFcc call,
+                                      // close the window to be safe and avoid
+                                      // windows hanging around to prevent the
+                                      // app from exiting.
+      }
+
+      // Remove the current draft msg when sending draft is done.
+      bool deleteDraft;
+      msgCompose->GetDeleteDraft(&deleteDraft);
+      if (deleteDraft) RemoveCurrentDraftMessage(msgCompose, false, false);
+    } else {
+      msgCompose->NotifyStateListeners(
+          nsIMsgComposeNotificationType::ComposeProcessDone, aStatus);
+      if (progress) {
+        progress->CloseProgressDialog(true);
+        progress->UnregisterListener(this);
+      }
+    }
+  }
+
+  nsCOMPtr<nsIMsgSendListener> composeSendListener =
+      do_QueryReferent(mWeakComposeObj, &rv);
+  if (NS_SUCCEEDED(rv) && composeSendListener)
+    composeSendListener->OnStopSending(aMsgID, aStatus, aMsg, returnFile);
+
+  return rv;
+}
+
+nsresult nsMsgComposeSendListener::OnGetDraftFolderURI(
+    const char* aMsgID, const nsACString& aFolderURI) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgSendListener> composeSendListener =
+      do_QueryReferent(mWeakComposeObj, &rv);
+  if (NS_SUCCEEDED(rv) && composeSendListener)
+    composeSendListener->OnGetDraftFolderURI(aMsgID, aFolderURI);
+
+  return NS_OK;
+}
+
+nsresult nsMsgComposeSendListener::OnStartCopy() { return NS_OK; }
+
+nsresult nsMsgComposeSendListener::OnProgress(uint32_t aProgress,
+                                              uint32_t aProgressMax) {
+  return NS_OK;
+}
+
+nsresult nsMsgComposeSendListener::OnStopCopy(nsresult aStatus) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgCompose> msgCompose = do_QueryReferent(mWeakComposeObj, &rv);
+  if (msgCompose) {
+    if (mDeliverMode == nsIMsgSend::nsMsgQueueForLater ||
+        mDeliverMode == nsIMsgSend::nsMsgDeliverBackground ||
+        mDeliverMode == nsIMsgSend::nsMsgSaveAsDraft) {
+      msgCompose->RememberQueuedDisposition();
+    }
+
+    // Ok, if we are here, we are done with the send/copy operation so
+    // we have to do something with the window....SHOW if failed, Close
+    // if succeeded
+
+    nsCOMPtr<nsIMsgProgress> progress;
+    msgCompose->GetProgress(getter_AddRefs(progress));
+    if (progress) {
+      // Unregister ourself from msg compose progress
+      progress->UnregisterListener(this);
+      progress->CloseProgressDialog(NS_FAILED(aStatus));
+    }
+
+    msgCompose->NotifyStateListeners(
+        nsIMsgComposeNotificationType::ComposeProcessDone, aStatus);
+
+    if (NS_SUCCEEDED(aStatus)) {
+      // We should only close the window if we are done. Things like templates
+      // and drafts aren't done so their windows should stay open
+      if (mDeliverMode == nsIMsgSend::nsMsgSaveAsDraft ||
+          mDeliverMode == nsIMsgSend::nsMsgSaveAsTemplate) {
+        msgCompose->NotifyStateListeners(
+            nsIMsgComposeNotificationType::SaveInFolderDone, aStatus);
+        // Remove the current draft msg when saving as draft/template is done.
+        msgCompose->SetDeleteDraft(true);
+        RemoveCurrentDraftMessage(
+            msgCompose, true, mDeliverMode == nsIMsgSend::nsMsgSaveAsTemplate);
+      } else {
+        // Remove (possible) draft if we're in send later mode
+        if (mDeliverMode == nsIMsgSend::nsMsgQueueForLater ||
+            mDeliverMode == nsIMsgSend::nsMsgDeliverBackground) {
+          msgCompose->SetDeleteDraft(true);
+          RemoveCurrentDraftMessage(msgCompose, true, false);
+        }
+        msgCompose->CloseWindow();
+      }
+    }
+    msgCompose->ClearMessageSend();
+  }
+
+  return rv;
+}
+
+nsresult nsMsgComposeSendListener::GetMsgFolder(nsIMsgCompose* compObj,
+                                                nsIMsgFolder** msgFolder) {
+  nsCString folderUri;
+
+  nsresult rv = compObj->GetSavedFolderURI(folderUri);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return GetOrCreateFolder(folderUri, msgFolder);
+}
+
+nsresult nsMsgComposeSendListener::RemoveDraftOrTemplate(nsIMsgCompose* compObj,
+                                                         nsCString msgURI,
+                                                         bool isSaveTemplate) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  nsCOMPtr<nsIMsgDBHdr> msgDBHdr;
+  rv = GetMsgDBHdrFromURI(msgURI, getter_AddRefs(msgDBHdr));
+  NS_ASSERTION(
+      NS_SUCCEEDED(rv),
+      "RemoveDraftOrTemplate can't get msg header DB interface pointer");
+  if (NS_SUCCEEDED(rv) && msgDBHdr) {
+    do {  // Break on failure or removal not needed.
+      // Get the folder for the message resource.
+      rv = msgDBHdr->GetFolder(getter_AddRefs(msgFolder));
+      NS_ASSERTION(
+          NS_SUCCEEDED(rv),
+          "RemoveDraftOrTemplate can't get msg folder interface pointer");
+      if (NS_FAILED(rv) || !msgFolder) break;
+
+      // Only do this if it's a drafts or templates folder.
+      uint32_t flags;
+      msgFolder->GetFlags(&flags);
+      if (!(flags & (nsMsgFolderFlags::Drafts | nsMsgFolderFlags::Templates)))
+        break;
+      // Only delete a template when saving a new one, never delete a template
+      // when sending.
+      if (!isSaveTemplate && (flags & nsMsgFolderFlags::Templates)) break;
+
+      // Only remove if the message is actually in the db. It might have only
+      // been in the use cache.
+      nsMsgKey key;
+      rv = msgDBHdr->GetMessageKey(&key);
+      if (NS_FAILED(rv)) break;
+      nsCOMPtr<nsIMsgDatabase> db;
+      msgFolder->GetMsgDatabase(getter_AddRefs(db));
+      if (!db) break;
+      bool containsKey = false;
+      db->ContainsKey(key, &containsKey);
+      if (!containsKey) break;
+
+      // Ready to delete the msg.
+      rv = msgFolder->DeleteMessages({&*msgDBHdr}, nullptr, true, false,
+                                     nullptr, false /*allowUndo*/);
+      NS_ASSERTION(NS_SUCCEEDED(rv),
+                   "RemoveDraftOrTemplate can't delete message");
+    } while (false);
+  } else {
+    // If we get here we have the case where the draft folder is on the server
+    // and it's not currently open (in thread pane), so draft msgs are saved to
+    // the server but they're not in our local DB. In this case,
+    // GetMsgDBHdrFromURI() will never find the msg. If the draft folder is a
+    // local one then we'll not get here because the draft msgs are saved to the
+    // local folder and are in local DB. Make sure the msg folder is imap.  Even
+    // if we get here due to DB errors (worst case), we should still try to
+    // delete msg on the server because that's where the master copy of the msgs
+    // are stored, if draft folder is on the server. For local case, since DB is
+    // bad we can't do anything with it anyway so it'll be noop in this case.
+    rv = GetMsgFolder(compObj, getter_AddRefs(msgFolder));
+    if (NS_SUCCEEDED(rv) && msgFolder) {
+      nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(msgFolder);
+      NS_ASSERTION(imapFolder,
+                   "The draft folder MUST be an imap folder in order to mark "
+                   "the msg delete!");
+      if (NS_SUCCEEDED(rv) && imapFolder) {
+        // Only do this if it's a drafts or templates folder.
+        uint32_t flags;
+        msgFolder->GetFlags(&flags);
+        if (!(flags & (nsMsgFolderFlags::Drafts | nsMsgFolderFlags::Templates)))
+          return NS_OK;
+        // Only delete a template when saving a new one, never delete a template
+        // when sending.
+        if (!isSaveTemplate && (flags & nsMsgFolderFlags::Templates))
+          return NS_OK;
+
+        const char* str = PL_strchr(msgURI.get(), '#');
+        NS_ASSERTION(str, "Failed to get current draft id url");
+        if (str) {
+          nsAutoCString srcStr(str + 1);
+          nsresult err;
+          nsMsgKey messageID = srcStr.ToInteger(&err);
+          if (messageID != nsMsgKey_None) {
+            rv = imapFolder->StoreImapFlags(kImapMsgDeletedFlag, true,
+                                            {messageID}, nullptr);
+          }
+        }
+      }
+    }
+  }
+
+  return rv;
+}
+
+/**
+ * Remove the current draft message since a new one will be saved.
+ * When we're coming to save a template, also delete the original template.
+ * This is necessary since auto-save doesn't delete the original template.
+ */
+nsresult nsMsgComposeSendListener::RemoveCurrentDraftMessage(
+    nsIMsgCompose* compObj, bool calledByCopy, bool isSaveTemplate) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgCompFields> compFields = nullptr;
+
+  rv = compObj->GetCompFields(getter_AddRefs(compFields));
+  NS_ASSERTION(NS_SUCCEEDED(rv),
+               "RemoveCurrentDraftMessage can't get compose fields");
+  if (NS_FAILED(rv) || !compFields) return rv;
+
+  nsCString curDraftIdURL;
+  rv = compFields->GetDraftId(curDraftIdURL);
+
+  // Skip if no draft id (probably a new draft msg).
+  if (NS_SUCCEEDED(rv) && !curDraftIdURL.IsEmpty()) {
+    rv = RemoveDraftOrTemplate(compObj, curDraftIdURL, isSaveTemplate);
+    if (NS_FAILED(rv)) NS_WARNING("Removing current draft failed");
+  } else {
+    NS_WARNING("RemoveCurrentDraftMessage can't get draft id");
+  }
+
+  if (isSaveTemplate) {
+    nsCString templateIdURL;
+    rv = compFields->GetTemplateId(templateIdURL);
+    if (NS_SUCCEEDED(rv) && !templateIdURL.Equals(curDraftIdURL)) {
+      // Above we deleted an auto-saved draft, so here we need to delete
+      // the original template.
+      rv = RemoveDraftOrTemplate(compObj, templateIdURL, isSaveTemplate);
+      if (NS_FAILED(rv)) NS_WARNING("Removing original template failed");
+    }
+  }
+
+  // Now get the new uid so that next save will remove the right msg
+  // regardless whether or not the exiting msg can be deleted.
+  if (calledByCopy) {
+    nsMsgKey newUid = 0;
+    nsCOMPtr<nsIMsgFolder> savedToFolder;
+    nsCOMPtr<nsIMsgSend> msgSend;
+    rv = compObj->GetMessageSend(getter_AddRefs(msgSend));
+    NS_ASSERTION(msgSend, "RemoveCurrentDraftMessage msgSend is null.");
+    if (NS_FAILED(rv) || !msgSend) return rv;
+
+    rv = msgSend->GetMessageKey(&newUid);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Make sure we have a folder interface pointer
+    rv = GetMsgFolder(compObj, getter_AddRefs(savedToFolder));
+
+    // Reset draft (uid) url with the new uid.
+    if (savedToFolder && newUid != nsMsgKey_None) {
+      uint32_t folderFlags;
+      savedToFolder->GetFlags(&folderFlags);
+      if (folderFlags &
+          (nsMsgFolderFlags::Drafts | nsMsgFolderFlags::Templates)) {
+        nsCString newDraftIdURL;
+        rv = savedToFolder->GenerateMessageURI(newUid, newDraftIdURL);
+        NS_ENSURE_SUCCESS(rv, rv);
+        compFields->SetDraftId(newDraftIdURL);
+        if (isSaveTemplate) compFields->SetTemplateId(newDraftIdURL);
+      }
+    }
+  }
+  return rv;
+}
+
+nsresult nsMsgComposeSendListener::SetMessageKey(nsMsgKey aMessageKey) {
+  return NS_OK;
+}
+
+nsresult nsMsgComposeSendListener::GetMessageId(nsACString& messageId) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeSendListener::OnStateChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest, uint32_t aStateFlags,
+    nsresult aStatus) {
+  if (aStateFlags == nsIWebProgressListener::STATE_STOP) {
+    nsCOMPtr<nsIMsgCompose> msgCompose = do_QueryReferent(mWeakComposeObj);
+    if (msgCompose) {
+      nsCOMPtr<nsIMsgProgress> progress;
+      msgCompose->GetProgress(getter_AddRefs(progress));
+
+      // Time to stop any pending operation...
+      if (progress) {
+        // Unregister ourself from msg compose progress
+        progress->UnregisterListener(this);
+
+        bool bCanceled = false;
+        progress->GetProcessCanceledByUser(&bCanceled);
+        if (bCanceled) {
+          nsresult rv;
+          nsCOMPtr<nsIStringBundleService> bundleService =
+              mozilla::components::StringBundle::Service();
+          NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+          nsCOMPtr<nsIStringBundle> bundle;
+          rv = bundleService->CreateBundle(
+              "chrome://messenger/locale/messengercompose/"
+              "composeMsgs.properties",
+              getter_AddRefs(bundle));
+          NS_ENSURE_SUCCESS(rv, rv);
+          nsString msg;
+          bundle->GetStringFromName("msgCancelling", msg);
+          progress->OnStatusChange(nullptr, nullptr, NS_OK, msg.get());
+        }
+      }
+
+      nsCOMPtr<nsIMsgSend> msgSend;
+      msgCompose->GetMessageSend(getter_AddRefs(msgSend));
+      if (msgSend) msgSend->Abort();
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeSendListener::OnProgressChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest,
+    int32_t aCurSelfProgress, int32_t aMaxSelfProgress,
+    int32_t aCurTotalProgress, int32_t aMaxTotalProgress) {
+  /* Ignore this call */
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeSendListener::OnLocationChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest, nsIURI* location,
+    uint32_t aFlags) {
+  /* Ignore this call */
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeSendListener::OnStatusChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest, nsresult aStatus,
+    const char16_t* aMessage) {
+  /* Ignore this call */
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeSendListener::OnSecurityChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest, uint32_t state) {
+  /* Ignore this call */
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeSendListener::OnContentBlockingEvent(nsIWebProgress* aWebProgress,
+                                                 nsIRequest* aRequest,
+                                                 uint32_t aEvent) {
+  /* Ignore this call */
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::ConvertHTMLToText(nsIFile* aSigFile,
+                                         nsString& aSigData) {
+  nsAutoString origBuf;
+
+  nsresult rv = LoadDataFromFile(aSigFile, origBuf);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  ConvertBufToPlainText(origBuf, false, true, true);
+  aSigData = origBuf;
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::ConvertTextToHTML(nsIFile* aSigFile,
+                                         nsString& aSigData) {
+  nsresult rv;
+  nsAutoString origBuf;
+
+  rv = LoadDataFromFile(aSigFile, origBuf);
+  if (NS_FAILED(rv)) return rv;
+
+  // Ok, once we are here, we need to escape the data to make sure that
+  // we don't do HTML stuff with plain text sigs.
+  nsCString escapedUTF8;
+  nsAppendEscapedHTML(NS_ConvertUTF16toUTF8(origBuf), escapedUTF8);
+  aSigData.Append(NS_ConvertUTF8toUTF16(escapedUTF8));
+
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::LoadDataFromFile(nsIFile* file, nsString& sigData,
+                                        bool aAllowUTF8, bool aAllowUTF16) {
+  bool isDirectory = false;
+  file->IsDirectory(&isDirectory);
+  if (isDirectory) {
+    NS_ERROR("file is a directory");
+    return NS_MSG_ERROR_READING_FILE;
+  }
+
+  nsAutoCString data;
+  nsresult rv = nsMsgCompose::SlurpFileToString(file, data);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  const char* readBuf = data.get();
+  int32_t readSize = data.Length();
+
+  nsAutoCString sigEncoding(nsMsgI18NParseMetaCharset(file));
+  bool removeSigCharset = !sigEncoding.IsEmpty() && m_composeHTML;
+
+  if (sigEncoding.IsEmpty()) {
+    if (aAllowUTF8 && mozilla::IsUtf8(nsDependentCString(readBuf))) {
+      sigEncoding.AssignLiteral("UTF-8");
+    } else if (sigEncoding.IsEmpty() && aAllowUTF16 && readSize % 2 == 0 &&
+               readSize >= 2 &&
+               ((readBuf[0] == char(0xFE) && readBuf[1] == char(0xFF)) ||
+                (readBuf[0] == char(0xFF) && readBuf[1] == char(0xFE)))) {
+      sigEncoding.AssignLiteral("UTF-16");
+    } else {
+      // Autodetect encoding for plain text files w/o meta charset
+      nsAutoCString textFileCharset;
+      rv = MsgDetectCharsetFromFile(file, textFileCharset);
+      NS_ENSURE_SUCCESS(rv, rv);
+      sigEncoding.Assign(textFileCharset);
+    }
+  }
+
+  if (NS_FAILED(nsMsgI18NConvertToUnicode(sigEncoding, data, sigData)))
+    CopyASCIItoUTF16(data, sigData);
+
+  // remove sig meta charset to allow user charset override during composition
+  if (removeSigCharset) {
+    nsAutoCString metaCharset("charset=");
+    metaCharset.Append(sigEncoding);
+    int32_t pos = sigData.LowerCaseFindASCII(metaCharset);
+    if (pos != kNotFound) sigData.Cut(pos, metaCharset.Length());
+  }
+  return NS_OK;
+}
+
+/**
+ * If the data contains file URLs, convert them to data URLs instead.
+ * This is intended to be used in for signature files, so that we can make sure
+ * images loaded into the editor are available on send.
+ */
+nsresult nsMsgCompose::ReplaceFileURLs(nsString& aData) {
+  // XXX This code is rather incomplete since it looks for "file://" even
+  // outside tags.
+
+  int32_t offset = 0;
+  while (true) {
+    int32_t fPos = aData.LowerCaseFindASCII("file://", offset);
+    if (fPos == kNotFound) {
+      break;  // All done.
+    }
+    bool quoted = false;
+    char16_t q = 'x';  // initialise to anything to keep compilers happy.
+    if (fPos > 0) {
+      q = aData.CharAt(fPos - 1);
+      quoted = (q == '"' || q == '\'');
+    }
+    int32_t end = kNotFound;
+    if (quoted) {
+      end = aData.FindChar(q, fPos);
+    } else {
+      int32_t spacePos = aData.FindChar(' ', fPos);
+      int32_t gtPos = aData.FindChar('>', fPos);
+      if (gtPos != kNotFound && spacePos != kNotFound) {
+        end = (spacePos < gtPos) ? spacePos : gtPos;
+      } else if (gtPos == kNotFound && spacePos != kNotFound) {
+        end = spacePos;
+      } else if (gtPos != kNotFound && spacePos == kNotFound) {
+        end = gtPos;
+      }
+    }
+    if (end == kNotFound) {
+      break;
+    }
+    nsString fileURL;
+    fileURL = Substring(aData, fPos, end - fPos);
+    nsString dataURL;
+    nsresult rv = DataURLForFileURL(fileURL, dataURL);
+    if (NS_SUCCEEDED(rv)) {
+      aData.Replace(fPos, fileURL.Length(), dataURL);
+      offset = fPos + dataURL.Length();
+    } else {
+      // If this one failed, maybe because the file wasn't found,
+      // continue to process the next one.
+      offset = fPos + fileURL.Length();
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::DataURLForFileURL(const nsAString& aFileURL,
+                                         nsAString& aDataURL) {
+  nsresult rv;
+  nsCOMPtr<nsIMIMEService> mime = do_GetService("@mozilla.org/mime;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIURI> fileUri;
+  rv =
+      NS_NewURI(getter_AddRefs(fileUri), NS_ConvertUTF16toUTF8(aFileURL).get());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFileURL> fileUrl(do_QueryInterface(fileUri, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIFile> file;
+  rv = fileUrl->GetFile(getter_AddRefs(file));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString type;
+  rv = mime->GetTypeFromFile(file, type);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString data;
+  rv = nsMsgCompose::SlurpFileToString(file, data);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aDataURL.AssignLiteral("data:");
+  AppendUTF8toUTF16(type, aDataURL);
+
+  nsAutoString filename;
+  rv = file->GetLeafName(filename);
+  if (NS_SUCCEEDED(rv)) {
+    nsAutoCString fn;
+    MsgEscapeURL(
+        NS_ConvertUTF16toUTF8(filename),
+        nsINetUtil::ESCAPE_URL_FILE_BASENAME | nsINetUtil::ESCAPE_URL_FORCED,
+        fn);
+    if (!fn.IsEmpty()) {
+      aDataURL.AppendLiteral(";filename=");
+      aDataURL.Append(NS_ConvertUTF8toUTF16(fn));
+    }
+  }
+
+  aDataURL.AppendLiteral(";base64,");
+  char* result = PL_Base64Encode(data.get(), data.Length(), nullptr);
+  nsDependentCString base64data(result);
+  NS_ENSURE_SUCCESS(rv, rv);
+  AppendUTF8toUTF16(base64data, aDataURL);
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::SlurpFileToString(nsIFile* aFile, nsACString& aString) {
+  aString.Truncate();
+
+  nsCOMPtr<nsIURI> fileURI;
+  nsresult rv = NS_NewFileURI(getter_AddRefs(fileURI), aFile);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIChannel> channel;
+  rv = NS_NewChannel(getter_AddRefs(channel), fileURI,
+                     nsContentUtils::GetSystemPrincipal(),
+                     nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+                     nsIContentPolicy::TYPE_OTHER);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIInputStream> stream;
+  rv = channel->Open(getter_AddRefs(stream));
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  rv = NS_ConsumeStream(stream, UINT32_MAX, aString);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  rv = stream->Close();
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::BuildQuotedMessageAndSignature(void) {
+  //
+  // This should never happen...if it does, just bail out...
+  //
+  NS_ASSERTION(m_editor, "BuildQuotedMessageAndSignature but no editor!");
+  if (!m_editor) return NS_ERROR_FAILURE;
+
+  // We will fire off the quote operation and wait for it to
+  // finish before we actually do anything with Ender...
+  return QuoteOriginalMessage();
+}
+
+//
+// This will process the signature file for the user. This method
+// will always append the results to the mMsgBody member variable.
+//
+nsresult nsMsgCompose::ProcessSignature(nsIMsgIdentity* identity, bool aQuoted,
+                                        nsString* aMsgBody) {
+  nsresult rv = NS_OK;
+
+  // Now, we can get sort of fancy. This is the time we need to check
+  // for all sorts of user defined stuff, like signatures and editor
+  // types and the like!
+  //
+  //    user_pref(".....sig_file", "y:\\sig.html");
+  //    user_pref(".....attach_signature", true);
+  //    user_pref(".....htmlSigText", "unicode sig");
+  //
+  // Note: We will have intelligent signature behavior in that we
+  // look at the signature file first...if the extension is .htm or
+  // .html, we assume its HTML, otherwise, we assume it is plain text
+  //
+  // ...and that's not all! What we will also do now is look and see if
+  // the file is an image file. If it is an image file, then we should
+  // insert the correct HTML into the composer to have it work, but if we
+  // are doing plain text compose, we should insert some sort of message
+  // saying "Image Signature Omitted" or something (not done yet).
+  //
+  // If there's a sig pref, it will only be used if there is no sig file
+  // defined, thus if attach_signature is checked, htmlSigText is ignored (bug
+  // 324495). Plain-text signatures may or may not have a trailing line break
+  // (bug 428040).
+
+  bool attachFile = false;
+  bool useSigFile = false;
+  bool htmlSig = false;
+  bool imageSig = false;
+  nsAutoString sigData;
+  nsAutoString sigOutput;
+  int32_t reply_on_top = 0;
+  bool sig_bottom = true;
+  bool suppressSigSep = false;
+
+  nsCOMPtr<nsIFile> sigFile;
+  if (identity) {
+    if (!CheckIncludeSignaturePrefs(identity)) return NS_OK;
+
+    identity->GetReplyOnTop(&reply_on_top);
+    identity->GetSigBottom(&sig_bottom);
+    identity->GetSuppressSigSep(&suppressSigSep);
+
+    rv = identity->GetAttachSignature(&attachFile);
+    if (NS_SUCCEEDED(rv) && attachFile) {
+      rv = identity->GetSignature(getter_AddRefs(sigFile));
+      if (NS_SUCCEEDED(rv) && sigFile) {
+        if (!sigFile->NativePath().IsEmpty()) {
+          bool exists = false;
+          sigFile->Exists(&exists);
+          if (exists) {
+            useSigFile = true;  // ok, there's a signature file
+
+            // Now, most importantly, we need to figure out what the content
+            // type is for this signature...if we can't, we assume text
+            nsAutoCString sigContentType;
+            nsresult rv2;  // don't want to clobber the other rv
+            nsCOMPtr<nsIMIMEService> mimeFinder(
+                do_GetService(NS_MIMESERVICE_CONTRACTID, &rv2));
+            if (NS_SUCCEEDED(rv2)) {
+              rv2 = mimeFinder->GetTypeFromFile(sigFile, sigContentType);
+              if (NS_SUCCEEDED(rv2)) {
+                if (StringBeginsWith(sigContentType, "image/"_ns,
+                                     nsCaseInsensitiveCStringComparator))
+                  imageSig = true;
+                else if (sigContentType.Equals(
+                             TEXT_HTML, nsCaseInsensitiveCStringComparator))
+                  htmlSig = true;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Unless signature to be attached from file, use preference value;
+  // the htmlSigText value is always going to be treated as html if
+  // the htmlSigFormat pref is true, otherwise it is considered text
+  nsAutoString prefSigText;
+  if (identity && !attachFile) identity->GetHtmlSigText(prefSigText);
+  // Now, if they didn't even want to use a signature, we should
+  // just return nicely.
+  //
+  if ((!useSigFile && prefSigText.IsEmpty()) || NS_FAILED(rv)) return NS_OK;
+
+  static const char htmlBreak[] = "<br>";
+  static const char dashes[] = "-- ";
+  static const char htmlsigopen[] = "<div class=\"moz-signature\">";
+  static const char htmlsigclose[] = "</div>"; /* XXX: Due to a bug in
+                     4.x' HTML editor, it will not be able to
+                     break this HTML sig, if quoted (for the user to
+                     interleave a comment). */
+  static const char _preopen[] = "<pre class=\"moz-signature\" cols=%d>";
+  char* preopen;
+  static const char preclose[] = "</pre>";
+
+  int32_t wrapLength = 72;  // setup default value in case GetWrapLength failed
+  GetWrapLength(&wrapLength);
+  preopen = PR_smprintf(_preopen, wrapLength);
+  if (!preopen) return NS_ERROR_OUT_OF_MEMORY;
+
+  bool paragraphMode =
+      mozilla::Preferences::GetBool("mail.compose.default_to_paragraph", false);
+
+  if (imageSig) {
+    // We have an image signature. If we're using the in HTML composer, we
+    // should put in the appropriate HTML for inclusion, otherwise, do nothing.
+    if (m_composeHTML) {
+      if (!paragraphMode) sigOutput.AppendLiteral(htmlBreak);
+      sigOutput.AppendLiteral(htmlsigopen);
+      if ((mType == nsIMsgCompType::NewsPost || !suppressSigSep) &&
+          (reply_on_top != 1 || sig_bottom || !aQuoted)) {
+        sigOutput.AppendLiteral(dashes);
+      }
+
+      sigOutput.AppendLiteral(htmlBreak);
+      sigOutput.AppendLiteral("<img src='");
+
+      nsCOMPtr<nsIURI> fileURI;
+      nsresult rv = NS_NewFileURI(getter_AddRefs(fileURI), sigFile);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCString fileURL;
+      fileURI->GetSpec(fileURL);
+
+      nsString dataURL;
+      rv = DataURLForFileURL(NS_ConvertUTF8toUTF16(fileURL), dataURL);
+      if (NS_SUCCEEDED(rv)) {
+        sigOutput.Append(dataURL);
+      }
+      sigOutput.AppendLiteral("' border=0>");
+      sigOutput.AppendLiteral(htmlsigclose);
+    }
+  } else if (useSigFile) {
+    // is this a text sig with an HTML editor?
+    if ((m_composeHTML) && (!htmlSig)) {
+      ConvertTextToHTML(sigFile, sigData);
+    }
+    // is this a HTML sig with a text window?
+    else if ((!m_composeHTML) && (htmlSig)) {
+      ConvertHTMLToText(sigFile, sigData);
+    } else {                               // We have a match...
+      LoadDataFromFile(sigFile, sigData);  // Get the data!
+      ReplaceFileURLs(sigData);
+    }
+  }
+
+  // if we have a prefSigText, append it to sigData.
+  if (!prefSigText.IsEmpty()) {
+    // set htmlSig if the pref is supposed to contain HTML code, defaults to
+    // false
+    rv = identity->GetHtmlSigFormat(&htmlSig);
+    if (NS_FAILED(rv)) htmlSig = false;
+
+    if (!m_composeHTML) {
+      if (htmlSig) ConvertBufToPlainText(prefSigText, false, true, true);
+      sigData.Append(prefSigText);
+    } else {
+      if (!htmlSig) {
+        nsCString escapedUTF8;
+        nsAppendEscapedHTML(NS_ConvertUTF16toUTF8(prefSigText), escapedUTF8);
+        sigData.Append(NS_ConvertUTF8toUTF16(escapedUTF8));
+      } else {
+        ReplaceFileURLs(prefSigText);
+        sigData.Append(prefSigText);
+      }
+    }
+  }
+
+  // post-processing for plain-text signatures to ensure we end in CR, LF, or
+  // CRLF
+  if (!htmlSig && !m_composeHTML) {
+    int32_t sigLength = sigData.Length();
+    if (sigLength > 0 && !(sigData.CharAt(sigLength - 1) == '\r') &&
+        !(sigData.CharAt(sigLength - 1) == '\n'))
+      sigData.AppendLiteral(CRLF);
+  }
+
+  // Now that sigData holds data...if any, append it to the body in a nice
+  // looking manner
+  if (!sigData.IsEmpty()) {
+    if (m_composeHTML) {
+      if (!paragraphMode) sigOutput.AppendLiteral(htmlBreak);
+
+      if (htmlSig)
+        sigOutput.AppendLiteral(htmlsigopen);
+      else
+        sigOutput.Append(NS_ConvertASCIItoUTF16(preopen));
+    }
+
+    if ((reply_on_top != 1 || sig_bottom || !aQuoted) &&
+        sigData.Find(u"\r-- \r") < 0 && sigData.Find(u"\n-- \n") < 0 &&
+        sigData.Find(u"\n-- \r") < 0) {
+      nsDependentSubstring firstFourChars(sigData, 0, 4);
+
+      if ((mType == nsIMsgCompType::NewsPost || !suppressSigSep) &&
+          !(firstFourChars.EqualsLiteral("-- \n") ||
+            firstFourChars.EqualsLiteral("-- \r"))) {
+        sigOutput.AppendLiteral(dashes);
+
+        if (!m_composeHTML || !htmlSig)
+          sigOutput.AppendLiteral(CRLF);
+        else if (m_composeHTML)
+          sigOutput.AppendLiteral(htmlBreak);
+      }
+    }
+
+    // add CRLF before signature for plain-text mode if signature comes before
+    // quote
+    if (!m_composeHTML && reply_on_top == 1 && !sig_bottom && aQuoted)
+      sigOutput.AppendLiteral(CRLF);
+
+    sigOutput.Append(sigData);
+
+    if (m_composeHTML) {
+      if (htmlSig)
+        sigOutput.AppendLiteral(htmlsigclose);
+      else
+        sigOutput.AppendLiteral(preclose);
+    }
+  }
+
+  aMsgBody->Append(sigOutput);
+  PR_Free(preopen);
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::BuildBodyMessageAndSignature() {
+  nsresult rv = NS_OK;
+
+  //
+  // This should never happen...if it does, just bail out...
+  //
+  if (!m_editor) return NS_ERROR_FAILURE;
+
+  //
+  // Now, we have the body so we can just blast it into the
+  // composition editor window.
+  //
+  nsAutoString body;
+  m_compFields->GetBody(body);
+
+  // Some time we want to add a signature and sometime we won't.
+  // Let's figure that out now...
+  bool addSignature;
+  bool isQuoted = false;
+  switch (mType) {
+    case nsIMsgCompType::ForwardInline:
+      addSignature = true;
+      isQuoted = true;
+      break;
+    case nsIMsgCompType::New:
+    case nsIMsgCompType::MailToUrl:   /* same as New */
+    case nsIMsgCompType::Reply:       /* should not happen! but just in case */
+    case nsIMsgCompType::ReplyAll:    /* should not happen! but just in case */
+    case nsIMsgCompType::ReplyToList: /* should not happen! but just in case */
+    case nsIMsgCompType::ForwardAsAttachment: /* should not happen! but just in
+                                                 case */
+    case nsIMsgCompType::NewsPost:
+    case nsIMsgCompType::ReplyToGroup:
+    case nsIMsgCompType::ReplyToSender:
+    case nsIMsgCompType::ReplyToSenderAndGroup:
+      addSignature = true;
+      break;
+
+    case nsIMsgCompType::Draft:
+    case nsIMsgCompType::Template:
+    case nsIMsgCompType::Redirect:
+    case nsIMsgCompType::EditAsNew:
+      addSignature = false;
+      break;
+
+    default:
+      addSignature = false;
+      break;
+  }
+
+  nsAutoString tSignature;
+  if (addSignature) ProcessSignature(m_identity, isQuoted, &tSignature);
+
+  // if type is new, but we have body, this is probably a mapi send, so we need
+  // to replace '\n' with <br> so that the line breaks won't be lost by html. if
+  // mailtourl, do the same.
+  if (m_composeHTML &&
+      (mType == nsIMsgCompType::New || mType == nsIMsgCompType::MailToUrl))
+    body.ReplaceSubstring(u"\n"_ns, u"<br>"_ns);
+
+  // Restore flowed text wrapping for Drafts/Templates.
+  // Look for unquoted lines - if we have an unquoted line
+  // that ends in a space, join this line with the next one
+  // by removing the end of line char(s).
+  int32_t wrapping_enabled = 0;
+  GetWrapLength(&wrapping_enabled);
+  if (!m_composeHTML && wrapping_enabled) {
+    bool quote = false;
+    for (uint32_t i = 0; i < body.Length(); i++) {
+      if (i == 0 || body[i - 1] == '\n')  // newline
+      {
+        if (body[i] == '>') {
+          quote = true;
+          continue;
+        }
+        nsString s(Substring(body, i, 10));
+        if (StringBeginsWith(s, u"-- \r"_ns) ||
+            StringBeginsWith(s, u"-- \n"_ns)) {
+          i += 4;
+          continue;
+        }
+        if (StringBeginsWith(s, u"- -- \r"_ns) ||
+            StringBeginsWith(s, u"- -- \n"_ns)) {
+          i += 6;
+          continue;
+        }
+      }
+      if (body[i] == '\n' && i > 1) {
+        if (quote) {
+          quote = false;
+          continue;  // skip quoted lines
+        }
+        uint32_t j = i - 1;  // look backward for space
+        if (body[j] == '\r') j--;
+        if (body[j] == ' ')        // join this line with next one
+          body.Cut(j + 1, i - j);  // remove CRLF
+      }
+    }
+  }
+
+  nsString empty;
+  rv = ConvertAndLoadComposeWindow(empty, body, tSignature, false,
+                                   m_composeHTML);
+
+  return rv;
+}
+
+nsresult nsMsgCompose::NotifyStateListeners(int32_t aNotificationType,
+                                            nsresult aResult) {
+  nsTObserverArray<nsCOMPtr<nsIMsgComposeStateListener>>::ForwardIterator iter(
+      mStateListeners);
+  nsCOMPtr<nsIMsgComposeStateListener> thisListener;
+
+  while (iter.HasMore()) {
+    thisListener = iter.GetNext();
+
+    switch (aNotificationType) {
+      case nsIMsgComposeNotificationType::ComposeFieldsReady:
+        thisListener->NotifyComposeFieldsReady();
+        break;
+
+      case nsIMsgComposeNotificationType::ComposeProcessDone:
+        thisListener->ComposeProcessDone(aResult);
+        break;
+
+      case nsIMsgComposeNotificationType::SaveInFolderDone:
+        thisListener->SaveInFolderDone(m_folderName.get());
+        break;
+
+      case nsIMsgComposeNotificationType::ComposeBodyReady:
+        thisListener->NotifyComposeBodyReady();
+        break;
+
+      default:
+        MOZ_ASSERT_UNREACHABLE("Unknown notification");
+        break;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::AttachmentPrettyName(const nsACString& scheme,
+                                            const char* charset,
+                                            nsACString& _retval) {
+  nsresult rv;
+
+  if (StringHead(scheme, 5).LowerCaseEqualsLiteral("file:")) {
+    nsCOMPtr<nsIFile> file;
+    rv = NS_GetFileFromURLSpec(scheme, getter_AddRefs(file));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoString leafName;
+    rv = file->GetLeafName(leafName);
+    NS_ENSURE_SUCCESS(rv, rv);
+    CopyUTF16toUTF8(leafName, _retval);
+    return rv;
+  }
+
+  nsCOMPtr<nsITextToSubURI> textToSubURI =
+      do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoString retUrl;
+  rv = textToSubURI->UnEscapeURIForUI(scheme, retUrl);
+
+  if (NS_SUCCEEDED(rv)) {
+    CopyUTF16toUTF8(retUrl, _retval);
+  } else {
+    _retval.Assign(scheme);
+  }
+  if (StringHead(scheme, 5).LowerCaseEqualsLiteral("http:")) _retval.Cut(0, 7);
+
+  return NS_OK;
+}
+
+/**
+ * Retrieve address book directories and mailing lists.
+ *
+ * @param aDirUri               directory URI
+ * @param allDirectoriesArray   retrieved directories and sub-directories
+ * @param allMailListArray      retrieved maillists
+ */
+nsresult nsMsgCompose::GetABDirAndMailLists(
+    const nsACString& aDirUri, nsCOMArray<nsIAbDirectory>& aDirArray,
+    nsTArray<nsMsgMailList>& aMailListArray) {
+  static bool collectedAddressbookFound = false;
+
+  nsresult rv;
+  nsCOMPtr<nsIAbManager> abManager =
+      do_GetService("@mozilla.org/abmanager;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aDirUri.Equals(kAllDirectoryRoot)) {
+    nsTArray<RefPtr<nsIAbDirectory>> directories;
+    rv = abManager->GetDirectories(directories);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    uint32_t count = directories.Length();
+    nsCString uri;
+    for (uint32_t i = 0; i < count; i++) {
+      rv = directories[i]->GetURI(uri);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      int32_t pos;
+      if (uri.EqualsLiteral(kPersonalAddressbookUri)) {
+        pos = 0;
+      } else {
+        uint32_t count = aDirArray.Count();
+
+        if (uri.EqualsLiteral(kCollectedAddressbookUri)) {
+          collectedAddressbookFound = true;
+          pos = count;
+        } else {
+          if (collectedAddressbookFound && count > 1) {
+            pos = count - 1;
+          } else {
+            pos = count;
+          }
+        }
+      }
+
+      aDirArray.InsertObjectAt(directories[i], pos);
+      rv = GetABDirAndMailLists(uri, aDirArray, aMailListArray);
+    }
+
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIAbDirectory> directory;
+  rv = abManager->GetDirectory(aDirUri, getter_AddRefs(directory));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTArray<RefPtr<nsIAbDirectory>> subDirectories;
+  rv = directory->GetChildNodes(subDirectories);
+  NS_ENSURE_SUCCESS(rv, rv);
+  for (nsIAbDirectory* subDirectory : subDirectories) {
+    bool bIsMailList;
+    if (NS_SUCCEEDED(subDirectory->GetIsMailList(&bIsMailList)) &&
+        bIsMailList) {
+      aMailListArray.AppendElement(subDirectory);
+    }
+  }
+  return rv;
+}
+
+/**
+ * Comparator for use with nsTArray::IndexOf to find a recipient.
+ * This comparator will check if an "address" is a mail list or not.
+ */
+struct nsMsgMailListComparator {
+  // A mail list will have one of the formats
+  //  1) "mName <mDescription>" when the list has a description
+  //  2) "mName <mName>" when the list lacks description
+  // A recipient is of the form "mName <mEmail>" - for equality the list
+  // name must be the same. The recipient "email" must match the list name for
+  // case 1, and the list description for case 2.
+  bool Equals(const nsMsgMailList& mailList,
+              const nsMsgRecipient& recipient) const {
+    if (!mailList.mName.Equals(recipient.mName,
+                               nsCaseInsensitiveStringComparator))
+      return false;
+    return mailList.mDescription.IsEmpty()
+               ? mailList.mName.Equals(recipient.mEmail,
+                                       nsCaseInsensitiveStringComparator)
+               : mailList.mDescription.Equals(
+                     recipient.mEmail, nsCaseInsensitiveStringComparator);
+  }
+};
+
+/**
+ * Comparator for use with nsTArray::IndexOf to find a recipient.
+ */
+struct nsMsgRecipientComparator {
+  bool Equals(const nsMsgRecipient& recipient,
+              const nsMsgRecipient& recipientToFind) const {
+    if (!recipient.mEmail.Equals(recipientToFind.mEmail,
+                                 nsCaseInsensitiveStringComparator))
+      return false;
+
+    if (!recipient.mName.Equals(recipientToFind.mName,
+                                nsCaseInsensitiveStringComparator))
+      return false;
+
+    return true;
+  }
+};
+
+/**
+ * This function recursively resolves a mailing list and returns individual
+ * email addresses. Nested lists are supported. It maintains an array of
+ * already visited mailing lists to avoid endless recursion.
+ *
+ * @param aMailList             the list
+ * @param allDirectoriesArray   all directories
+ * @param allMailListArray      all maillists
+ * @param mailListProcessed     maillists processed (to avoid recursive lists)
+ * @param aListMembers          list members
+ */
+nsresult nsMsgCompose::ResolveMailList(
+    nsIAbDirectory* aMailList, nsCOMArray<nsIAbDirectory>& allDirectoriesArray,
+    nsTArray<nsMsgMailList>& allMailListArray,
+    nsTArray<nsMsgMailList>& mailListProcessed,
+    nsTArray<nsMsgRecipient>& aListMembers) {
+  nsresult rv = NS_OK;
+
+  nsTArray<RefPtr<nsIAbCard>> mailListAddresses;
+  rv = aMailList->GetChildCards(mailListAddresses);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (nsIAbCard* existingCard : mailListAddresses) {
+    nsMsgRecipient newRecipient;
+
+    rv = existingCard->GetDisplayName(newRecipient.mName);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = existingCard->GetPrimaryEmail(newRecipient.mEmail);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (newRecipient.mName.IsEmpty() && newRecipient.mEmail.IsEmpty()) {
+      continue;
+    }
+
+    // First check if it's a mailing list.
+    size_t index =
+        allMailListArray.IndexOf(newRecipient, 0, nsMsgMailListComparator());
+    if (index != allMailListArray.NoIndex &&
+        allMailListArray[index].mDirectory) {
+      // Check if maillist processed.
+      if (mailListProcessed.Contains(newRecipient, nsMsgMailListComparator())) {
+        continue;
+      }
+
+      nsCOMPtr<nsIAbDirectory> directory2(allMailListArray[index].mDirectory);
+
+      // Add mailList to mailListProcessed.
+      mailListProcessed.AppendElement(directory2);
+
+      // Resolve mailList members.
+      rv = ResolveMailList(directory2, allDirectoriesArray, allMailListArray,
+                           mailListProcessed, aListMembers);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      continue;
+    }
+
+    // Check if recipient is in aListMembers.
+    if (aListMembers.Contains(newRecipient, nsMsgRecipientComparator())) {
+      continue;
+    }
+
+    // Now we need to insert the new address into the list of recipients.
+    newRecipient.mCard = existingCard;
+    newRecipient.mDirectory = aMailList;
+
+    aListMembers.AppendElement(newRecipient);
+  }
+
+  return rv;
+}
+
+/**
+ * Lookup the recipients as specified in the compose fields (To, Cc, Bcc)
+ * in the address books and return an array of individual recipients.
+ * Mailing lists are replaced by the cards they contain, nested and recursive
+ * lists are taken care of, recipients contained in multiple lists are only
+ * added once.
+ *
+ * @param recipientsList        (out) recipient array
+ */
+nsresult nsMsgCompose::LookupAddressBook(RecipientsArray& recipientsList) {
+  nsresult rv = NS_OK;
+
+  // First, build some arrays with the original recipients.
+
+  nsAutoString originalRecipients[MAX_OF_RECIPIENT_ARRAY];
+  m_compFields->GetTo(originalRecipients[0]);
+  m_compFields->GetCc(originalRecipients[1]);
+  m_compFields->GetBcc(originalRecipients[2]);
+
+  for (uint32_t i = 0; i < MAX_OF_RECIPIENT_ARRAY; ++i) {
+    if (originalRecipients[i].IsEmpty()) continue;
+
+    rv = m_compFields->SplitRecipientsEx(originalRecipients[i],
+                                         recipientsList[i]);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Then look them up in the Addressbooks
+  bool stillNeedToSearch = true;
+  nsCOMPtr<nsIAbDirectory> abDirectory;
+  nsCOMPtr<nsIAbCard> existingCard;
+  nsTArray<nsMsgMailList> mailListArray;
+  nsTArray<nsMsgMailList> mailListProcessed;
+
+  nsCOMArray<nsIAbDirectory> addrbookDirArray;
+  rv = GetABDirAndMailLists(nsLiteralCString(kAllDirectoryRoot),
+                            addrbookDirArray, mailListArray);
+  if (NS_FAILED(rv)) return rv;
+
+  nsString dirPath;
+  uint32_t nbrAddressbook = addrbookDirArray.Count();
+
+  for (uint32_t k = 0; k < nbrAddressbook && stillNeedToSearch; ++k) {
+    // Avoid recursive mailing lists.
+    if (abDirectory && (addrbookDirArray[k] == abDirectory)) {
+      stillNeedToSearch = false;
+      break;
+    }
+
+    abDirectory = addrbookDirArray[k];
+    if (!abDirectory) continue;
+
+    stillNeedToSearch = false;
+    for (uint32_t i = 0; i < MAX_OF_RECIPIENT_ARRAY; i++) {
+      mailListProcessed.Clear();
+
+      // Note: We check this each time to allow for length changes.
+      for (uint32_t j = 0; j < recipientsList[i].Length(); j++) {
+        nsMsgRecipient& recipient = recipientsList[i][j];
+        if (!recipient.mDirectory) {
+          // First check if it's a mailing list.
+          size_t index =
+              mailListArray.IndexOf(recipient, 0, nsMsgMailListComparator());
+          if (index != mailListArray.NoIndex &&
+              mailListArray[index].mDirectory) {
+            // Check mailList Processed.
+            if (mailListProcessed.Contains(recipient,
+                                           nsMsgMailListComparator())) {
+              // Remove from recipientsList.
+              recipientsList[i].RemoveElementAt(j--);
+              continue;
+            }
+
+            nsCOMPtr<nsIAbDirectory> directory(mailListArray[index].mDirectory);
+
+            // Add mailList to mailListProcessed.
+            mailListProcessed.AppendElement(directory);
+
+            // Resolve mailList members.
+            nsTArray<nsMsgRecipient> members;
+            rv = ResolveMailList(directory, addrbookDirArray, mailListArray,
+                                 mailListProcessed, members);
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            // Remove mailList from recipientsList.
+            recipientsList[i].RemoveElementAt(j);
+
+            // Merge members into recipientsList[i].
+            uint32_t pos = 0;
+            for (uint32_t c = 0; c < members.Length(); c++) {
+              nsMsgRecipient& member = members[c];
+              if (!recipientsList[i].Contains(member,
+                                              nsMsgRecipientComparator())) {
+                recipientsList[i].InsertElementAt(j + pos, member);
+                pos++;
+              }
+            }
+          } else {
+            // Find a card that contains this e-mail address.
+            rv = abDirectory->CardForEmailAddress(
+                NS_ConvertUTF16toUTF8(recipient.mEmail),
+                getter_AddRefs(existingCard));
+            if (NS_SUCCEEDED(rv) && existingCard) {
+              recipient.mCard = existingCard;
+              recipient.mDirectory = abDirectory;
+            } else {
+              stillNeedToSearch = true;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::ExpandMailingLists() {
+  RecipientsArray recipientsList;
+  nsresult rv = LookupAddressBook(recipientsList);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Reset the final headers with the expanded mailing lists.
+  nsAutoString recipientsStr;
+
+  for (int i = 0; i < MAX_OF_RECIPIENT_ARRAY; ++i) {
+    uint32_t nbrRecipients = recipientsList[i].Length();
+    if (nbrRecipients == 0) continue;
+    recipientsStr.Truncate();
+
+    // Note: We check this each time to allow for length changes.
+    for (uint32_t j = 0; j < recipientsList[i].Length(); ++j) {
+      nsMsgRecipient& recipient = recipientsList[i][j];
+
+      if (!recipientsStr.IsEmpty()) recipientsStr.Append(char16_t(','));
+      nsAutoString address;
+      MakeMimeAddress(recipient.mName, recipient.mEmail, address);
+      recipientsStr.Append(address);
+
+      if (recipient.mCard) {
+        bool readOnly;
+        rv = recipient.mDirectory->GetReadOnly(&readOnly);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        // Bump the popularity index for this card since we are about to send
+        // e-mail to it.
+        if (!readOnly) {
+          uint32_t popularityIndex = 0;
+          if (NS_FAILED(recipient.mCard->GetPropertyAsUint32(
+                  kPopularityIndexProperty, &popularityIndex))) {
+            // TB 2 wrote the popularity value as hex, so if we get here,
+            // then we've probably got a hex value. We'll convert it back
+            // to decimal, as that's the best we can do.
+
+            nsCString hexPopularity;
+            if (NS_SUCCEEDED(recipient.mCard->GetPropertyAsAUTF8String(
+                    kPopularityIndexProperty, hexPopularity))) {
+              nsresult errorCode = NS_OK;
+              popularityIndex = hexPopularity.ToInteger(&errorCode, 16);
+              if (NS_FAILED(errorCode))
+                // We failed, just set it to zero.
+                popularityIndex = 0;
+            } else
+              // We couldn't get it as a string either, so just reset to zero.
+              popularityIndex = 0;
+          }
+
+          recipient.mCard->SetPropertyAsUint32(kPopularityIndexProperty,
+                                               ++popularityIndex);
+          recipient.mDirectory->ModifyCard(recipient.mCard);
+        }
+      }
+    }
+
+    switch (i) {
+      case 0:
+        m_compFields->SetTo(recipientsStr);
+        break;
+      case 1:
+        m_compFields->SetCc(recipientsStr);
+        break;
+      case 2:
+        m_compFields->SetBcc(recipientsStr);
+        break;
+    }
+  }
+
+  return NS_OK;
+}
+
+/**
+ * Decides which tags trigger which convertible mode,
+ * i.e. here is the logic for BodyConvertible.
+ * Note: Helper function. Parameters are not checked.
+ */
+void nsMsgCompose::TagConvertible(Element* node, int32_t* _retval) {
+  *_retval = nsIMsgCompConvertible::No;
+
+  nsAutoString element;
+  element = node->NodeName();
+
+  // A style attribute on any element can change layout in any way,
+  // so that is not convertible.
+  nsAutoString attribValue;
+  node->GetAttribute(u"style"_ns, attribValue);
+  if (!attribValue.IsEmpty()) {
+    *_retval = nsIMsgCompConvertible::No;
+    return;
+  }
+
+  // moz-* classes are used internally by the editor and mail composition
+  // (like moz-cite-prefix or moz-signature). Those can be discarded.
+  // But any other ones are unconvertible. Style can be attached to them or any
+  // other context (e.g. in microformats).
+  node->GetAttribute(u"class"_ns, attribValue);
+  if (!attribValue.IsEmpty()) {
+    if (StringBeginsWith(attribValue, u"moz-"_ns,
+                         nsCaseInsensitiveStringComparator)) {
+      // We assume that anything with a moz-* class is convertible regardless of
+      // the tag, because we add, for example, class="moz-signature" to HTML
+      // messages and we still want to be able to downgrade them.
+      *_retval = nsIMsgCompConvertible::Plain;
+    } else {
+      *_retval = nsIMsgCompConvertible::No;
+    }
+
+    return;
+  }
+
+  // ID attributes can contain attached style/context or be target of links
+  // so we should preserve them.
+  node->GetAttribute(u"id"_ns, attribValue);
+  if (!attribValue.IsEmpty()) {
+    *_retval = nsIMsgCompConvertible::No;
+    return;
+  }
+
+  // Alignment is not convertible to plaintext; editor currently uses this.
+  node->GetAttribute(u"align"_ns, attribValue);
+  if (!attribValue.IsEmpty()) {
+    *_retval = nsIMsgCompConvertible::No;
+    return;
+  }
+
+  // Title attribute is not convertible to plaintext;
+  // this also preserves any links with titles.
+  node->GetAttribute(u"title"_ns, attribValue);
+  if (!attribValue.IsEmpty()) {
+    *_retval = nsIMsgCompConvertible::No;
+    return;
+  }
+
+  // Treat <font face="monospace"> as converible to plaintext.
+  if (element.LowerCaseEqualsLiteral("font")) {
+    node->GetAttribute(u"size"_ns, attribValue);
+    if (!attribValue.IsEmpty()) {
+      *_retval = nsIMsgCompConvertible::No;
+      return;
+    }
+    node->GetAttribute(u"face"_ns, attribValue);
+    if (attribValue.LowerCaseEqualsLiteral("monospace")) {
+      *_retval = nsIMsgCompConvertible::Plain;
+    }
+  }
+
+  if (  // Considered convertible to plaintext: Some "simple" elements
+        // without non-convertible attributes like style, class, id,
+        // or align (see above).
+      element.LowerCaseEqualsLiteral("br") ||
+      element.LowerCaseEqualsLiteral("p") ||
+      element.LowerCaseEqualsLiteral("tt") ||
+      element.LowerCaseEqualsLiteral("html") ||
+      element.LowerCaseEqualsLiteral("head") ||
+      element.LowerCaseEqualsLiteral("meta") ||
+      element.LowerCaseEqualsLiteral("title")) {
+    *_retval = nsIMsgCompConvertible::Plain;
+  } else if (
+      // element.LowerCaseEqualsLiteral("blockquote") || // see below
+      element.LowerCaseEqualsLiteral("ul") ||
+      element.LowerCaseEqualsLiteral("ol") ||
+      element.LowerCaseEqualsLiteral("li") ||
+      element.LowerCaseEqualsLiteral("dl") ||
+      element.LowerCaseEqualsLiteral("dt") ||
+      element.LowerCaseEqualsLiteral("dd")) {
+    *_retval = nsIMsgCompConvertible::Yes;
+  } else if (
+      // element.LowerCaseEqualsLiteral("a") || // see below
+      element.LowerCaseEqualsLiteral("h1") ||
+      element.LowerCaseEqualsLiteral("h2") ||
+      element.LowerCaseEqualsLiteral("h3") ||
+      element.LowerCaseEqualsLiteral("h4") ||
+      element.LowerCaseEqualsLiteral("h5") ||
+      element.LowerCaseEqualsLiteral("h6") ||
+      element.LowerCaseEqualsLiteral("hr") ||
+      element.LowerCaseEqualsLiteral("pre") ||
+      (mConvertStructs && (element.LowerCaseEqualsLiteral("em") ||
+                           element.LowerCaseEqualsLiteral("strong") ||
+                           element.LowerCaseEqualsLiteral("code") ||
+                           element.LowerCaseEqualsLiteral("b") ||
+                           element.LowerCaseEqualsLiteral("i") ||
+                           element.LowerCaseEqualsLiteral("u")))) {
+    *_retval = nsIMsgCompConvertible::Altering;
+  } else if (element.LowerCaseEqualsLiteral("body")) {
+    *_retval = nsIMsgCompConvertible::Plain;
+
+    if (node->HasAttribute(u"background"_ns) ||  // There is a background image
+        node->HasAttribute(
+            u"dir"_ns)) {  // dir=rtl attributes should not downconvert
+      *_retval = nsIMsgCompConvertible::No;
+    } else {
+      nsAutoString color;
+      if (node->HasAttribute(u"text"_ns)) {
+        node->GetAttribute(u"text"_ns, color);
+        if (!color.EqualsLiteral("#000000"))
+          *_retval = nsIMsgCompConvertible::Altering;
+      }
+      if (*_retval != nsIMsgCompConvertible::Altering &&  // small optimization
+          node->HasAttribute(u"bgcolor"_ns)) {
+        node->GetAttribute(u"bgcolor"_ns, color);
+        if (!color.LowerCaseEqualsLiteral("#ffffff"))
+          *_retval = nsIMsgCompConvertible::Altering;
+      }
+    }
+
+    // ignore special color setting for link, vlink and alink at this point.
+  } else if (element.LowerCaseEqualsLiteral("blockquote")) {
+    // Skip <blockquote type="cite">
+    *_retval = nsIMsgCompConvertible::Yes;
+
+    node->GetAttribute(u"type"_ns, attribValue);
+    if (attribValue.LowerCaseEqualsLiteral("cite")) {
+      *_retval = nsIMsgCompConvertible::Plain;
+    }
+  } else if (element.LowerCaseEqualsLiteral("div") ||
+             element.LowerCaseEqualsLiteral("span") ||
+             element.LowerCaseEqualsLiteral("a")) {
+    // Do some special checks for these tags. They are inside this |else if|
+    // for performance reasons.
+
+    // Maybe, it's an <a> element inserted by another recognizer (e.g. 4.x')
+    if (element.LowerCaseEqualsLiteral("a")) {
+      // Ignore anchor tag, if the URI is the same as the text
+      // (as inserted by recognizers).
+      *_retval = nsIMsgCompConvertible::Altering;
+
+      nsAutoString hrefValue;
+      node->GetAttribute(u"href"_ns, hrefValue);
+      nsINodeList* children = node->ChildNodes();
+      if (children->Length() > 0) {
+        nsINode* pItem = children->Item(0);
+        nsAutoString textValue;
+        pItem->GetNodeValue(textValue);
+        if (textValue == hrefValue) *_retval = nsIMsgCompConvertible::Plain;
+      }
+    }
+
+    // Lastly, test, if it is just a "simple" <div> or <span>
+    else if (element.LowerCaseEqualsLiteral("div") ||
+             element.LowerCaseEqualsLiteral("span")) {
+      *_retval = nsIMsgCompConvertible::Plain;
+    }
+  }
+}
+
+/**
+ * Note: Helper function. Parameters are not checked.
+ */
+NS_IMETHODIMP
+nsMsgCompose::NodeTreeConvertible(Element* node, int32_t* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  int32_t result;
+
+  // Check this node
+  TagConvertible(node, &result);
+
+  // Walk tree recursively to check the children.
+  nsINodeList* children = node->ChildNodes();
+  for (uint32_t i = 0; i < children->Length(); i++) {
+    nsINode* pItem = children->Item(i);
+    // We assume all nodes that are not elements are convertible,
+    // so only test elements.
+    nsCOMPtr<Element> domElement = do_QueryInterface(pItem);
+    if (domElement) {
+      int32_t curresult;
+      NodeTreeConvertible(domElement, &curresult);
+
+      if (curresult > result) result = curresult;
+    }
+  }
+
+  *_retval = result;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::BodyConvertible(int32_t* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  NS_ENSURE_STATE(m_editor);
+
+  nsCOMPtr<Document> rootDocument;
+  nsresult rv = m_editor->GetDocument(getter_AddRefs(rootDocument));
+  if (NS_FAILED(rv)) return rv;
+  if (!rootDocument) return NS_ERROR_UNEXPECTED;
+
+  // get the top level element, which contains <html>
+  nsCOMPtr<Element> rootElement = rootDocument->GetDocumentElement();
+  if (!rootElement) return NS_ERROR_UNEXPECTED;
+  NodeTreeConvertible(rootElement, _retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::GetIdentity(nsIMsgIdentity** aIdentity) {
+  NS_ENSURE_ARG_POINTER(aIdentity);
+  NS_IF_ADDREF(*aIdentity = m_identity);
+  return NS_OK;
+}
+
+/**
+ * Position above the quote, that is either <blockquote> or
+ * <div class="moz-cite-prefix"> or <div class="moz-forward-container">
+ * in an inline-forwarded message.
+ */
+nsresult nsMsgCompose::MoveToAboveQuote(void) {
+  RefPtr<Element> rootElement;
+  nsresult rv = m_editor->GetRootElement(getter_AddRefs(rootElement));
+  if (NS_FAILED(rv) || !rootElement) {
+    return rv;
+  }
+
+  nsCOMPtr<nsINode> node;
+  nsAutoString attributeName;
+  nsAutoString attributeValue;
+  nsAutoString tagLocalName;
+  attributeName.AssignLiteral("class");
+
+  RefPtr<nsINode> rootElement2 = rootElement;
+  node = rootElement2->GetFirstChild();
+  while (node) {
+    nsCOMPtr<Element> element = do_QueryInterface(node);
+    if (element) {
+      // First check for <blockquote>. This will most likely not trigger
+      // since well-behaved quotes are preceded by a cite prefix.
+      tagLocalName = node->LocalName();
+      if (tagLocalName.EqualsLiteral("blockquote")) {
+        break;
+      }
+
+      // Get the class value.
+      element->GetAttribute(attributeName, attributeValue);
+
+      // Now check for the cite prefix, so an element with
+      // class="moz-cite-prefix".
+      if (attributeValue.LowerCaseFindASCII("moz-cite-prefix") != kNotFound) {
+        break;
+      }
+
+      // Next check for forwarded content.
+      // The forwarded part is inside an element with
+      // class="moz-forward-container".
+      if (attributeValue.LowerCaseFindASCII("moz-forward-container") !=
+          kNotFound) {
+        break;
+      }
+    }
+
+    node = node->GetNextSibling();
+    if (!node) {
+      // No further siblings found, so we didn't find what we were looking for.
+      rv = NS_OK;
+      break;
+    }
+  }
+
+  // Now position. If no quote was found, we position to the very front.
+  int32_t offset = 0;
+  if (node) {
+    rv = GetChildOffset(node, rootElement2, offset);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+  }
+  RefPtr<Selection> selection;
+  m_editor->GetSelection(getter_AddRefs(selection));
+  if (selection) rv = selection->CollapseInLimiter(rootElement, offset);
+
+  return rv;
+}
+
+/**
+ * nsEditor::BeginningOfDocument() will position to the beginning of the
+ * document before the first editable element. It will position into a
+ * container. We need to be at the very front.
+ */
+nsresult nsMsgCompose::MoveToBeginningOfDocument(void) {
+  RefPtr<Element> rootElement;
+  nsresult rv = m_editor->GetRootElement(getter_AddRefs(rootElement));
+  if (NS_FAILED(rv) || !rootElement) {
+    return rv;
+  }
+
+  RefPtr<Selection> selection;
+  m_editor->GetSelection(getter_AddRefs(selection));
+  if (selection) rv = selection->CollapseInLimiter(rootElement, 0);
+
+  return rv;
+}
+
+/**
+ * M-C's nsEditor::EndOfDocument() will position to the end of the document
+ * but it will position into a container. We really need to position
+ * after the last container so we don't accidentally position into a
+ * <blockquote>. That's why we use our own function.
+ */
+nsresult nsMsgCompose::MoveToEndOfDocument(void) {
+  int32_t offset;
+  RefPtr<Element> rootElement;
+  nsCOMPtr<nsINode> lastNode;
+  nsresult rv = m_editor->GetRootElement(getter_AddRefs(rootElement));
+  if (NS_FAILED(rv) || !rootElement) {
+    return rv;
+  }
+
+  RefPtr<nsINode> rootElement2 = rootElement;
+  lastNode = rootElement2->GetLastChild();
+  if (!lastNode) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  rv = GetChildOffset(lastNode, rootElement2, offset);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  RefPtr<Selection> selection;
+  m_editor->GetSelection(getter_AddRefs(selection));
+  if (selection) rv = selection->CollapseInLimiter(rootElement, offset + 1);
+
+  return rv;
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
+nsMsgCompose::SetIdentity(nsIMsgIdentity* aIdentity) {
+  NS_ENSURE_ARG_POINTER(aIdentity);
+
+  m_identity = aIdentity;
+
+  nsresult rv;
+
+  if (!m_editor) return NS_ERROR_FAILURE;
+
+  RefPtr<Element> rootElement;
+  rv = m_editor->GetRootElement(getter_AddRefs(rootElement));
+  if (NS_FAILED(rv) || !rootElement) return rv;
+
+  // First look for the current signature, if we have one
+  nsCOMPtr<nsINode> lastNode;
+  nsCOMPtr<nsINode> node;
+  nsCOMPtr<nsINode> tempNode;
+  nsAutoString tagLocalName;
+
+  RefPtr<nsINode> rootElement2 = rootElement;
+  lastNode = rootElement2->GetLastChild();
+  if (lastNode) {
+    node = lastNode;
+    // In html, the signature is inside an element with
+    // class="moz-signature"
+    bool signatureFound = false;
+    nsAutoString attributeName;
+    attributeName.AssignLiteral("class");
+
+    while (node) {
+      nsCOMPtr<Element> element = do_QueryInterface(node);
+      if (element) {
+        nsAutoString attributeValue;
+
+        element->GetAttribute(attributeName, attributeValue);
+
+        if (attributeValue.LowerCaseFindASCII("moz-signature") != kNotFound) {
+          signatureFound = true;
+          break;
+        }
+      }
+      node = node->GetPreviousSibling();
+    }
+
+    if (signatureFound) {
+      nsCOMPtr<nsIEditor> editor(m_editor);  // Strong reference.
+      editor->BeginTransaction();
+      tempNode = node->GetPreviousSibling();
+      rv = editor->DeleteNode(node);
+      if (NS_FAILED(rv)) {
+        editor->EndTransaction();
+        return rv;
+      }
+
+      // Also, remove the <br> right before the signature.
+      if (tempNode) {
+        tagLocalName = tempNode->LocalName();
+        if (tagLocalName.EqualsLiteral("br")) editor->DeleteNode(tempNode);
+      }
+      editor->EndTransaction();
+    }
+  }
+
+  if (!CheckIncludeSignaturePrefs(aIdentity)) return NS_OK;
+
+  // Then add the new one if needed
+  nsAutoString aSignature;
+
+  // No delimiter needed if not a compose window
+  bool isQuoted;
+  switch (mType) {
+    case nsIMsgCompType::New:
+    case nsIMsgCompType::NewsPost:
+    case nsIMsgCompType::MailToUrl:
+    case nsIMsgCompType::ForwardAsAttachment:
+      isQuoted = false;
+      break;
+    default:
+      isQuoted = true;
+      break;
+  }
+
+  ProcessSignature(aIdentity, isQuoted, &aSignature);
+
+  if (!aSignature.IsEmpty()) {
+    TranslateLineEnding(aSignature);
+    nsCOMPtr<nsIEditor> editor(m_editor);  // Strong reference.
+
+    editor->BeginTransaction();
+    int32_t reply_on_top = 0;
+    bool sig_bottom = true;
+    aIdentity->GetReplyOnTop(&reply_on_top);
+    aIdentity->GetSigBottom(&sig_bottom);
+    bool sigOnTop = (reply_on_top == 1 && !sig_bottom);
+    if (sigOnTop && isQuoted) {
+      rv = MoveToAboveQuote();
+    } else {
+      // Note: New messages aren't quoted so we always move to the end.
+      rv = MoveToEndOfDocument();
+    }
+
+    if (NS_SUCCEEDED(rv)) {
+      if (m_composeHTML) {
+        bool oldAllow;
+        GetAllowRemoteContent(&oldAllow);
+        SetAllowRemoteContent(true);
+        rv = MOZ_KnownLive(editor->AsHTMLEditor())->InsertHTML(aSignature);
+        SetAllowRemoteContent(oldAllow);
+      } else {
+        rv = editor->InsertLineBreak();
+        InsertDivWrappedTextAtSelection(aSignature, u"moz-signature"_ns);
+      }
+    }
+    editor->EndTransaction();
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgCompose::CheckCharsetConversion(nsIMsgIdentity* identity,
+                                                   char** fallbackCharset,
+                                                   bool* _retval) {
+  NS_ENSURE_ARG_POINTER(identity);
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  // Kept around for legacy reasons. This method is supposed to check that the
+  // headers can be converted to the appropriate charset, but we don't support
+  // encoding headers to non-UTF-8, so this is now moot.
+  if (fallbackCharset) *fallbackCharset = nullptr;
+  *_retval = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetDeliverMode(MSG_DeliverMode* aDeliverMode) {
+  NS_ENSURE_ARG_POINTER(aDeliverMode);
+  *aDeliverMode = mDeliverMode;
+  return NS_OK;
+}
+
+void nsMsgCompose::DeleteTmpAttachments() {
+  if (mTmpAttachmentsDeleted || m_window) {
+    // Don't delete tmp attachments if compose window is still open, e.g. saving
+    // a draft.
+    return;
+  }
+  mTmpAttachmentsDeleted = true;
+  // Remove temporary attachment files, e.g. key.asc when attaching public key.
+  nsTArray<RefPtr<nsIMsgAttachment>> attachments;
+  m_compFields->GetAttachments(attachments);
+  for (nsIMsgAttachment* attachment : attachments) {
+    bool isTemporary;
+    attachment->GetTemporary(&isTemporary);
+    bool sentViaCloud;
+    attachment->GetSendViaCloud(&sentViaCloud);
+    if (isTemporary && !sentViaCloud) {
+      nsCString url;
+      attachment->GetUrl(url);
+      nsCOMPtr<nsIFile> urlFile;
+      nsresult rv = NS_GetFileFromURLSpec(url, getter_AddRefs(urlFile));
+      if (NS_SUCCEEDED(rv)) {
+        urlFile->Remove(false);
+      }
+    }
+  }
+}
+
+nsMsgMailList::nsMsgMailList(nsIAbDirectory* directory)
+    : mDirectory(directory) {
+  mDirectory->GetDirName(mName);
+  mDirectory->GetDescription(mDescription);
+
+  if (mDescription.IsEmpty()) mDescription = mName;
+
+  mDirectory = directory;
+}
diff --git a/comm/mailnews/compose/src/nsMsgCompose.h b/comm/mailnews/compose/src/nsMsgCompose.h
new file mode 100644
index 0000000000..fe9b9724c8
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgCompose.h
@@ -0,0 +1,245 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsMsgCompose_H_
+#define _nsMsgCompose_H_
+
+#include "nsIMsgCompose.h"
+#include "nsCOMArray.h"
+#include "nsTObserverArray.h"
+#include "nsWeakReference.h"
+#include "nsMsgCompFields.h"
+#include "nsIOutputStream.h"
+#include "nsIMsgQuote.h"
+#include "nsIMsgCopyServiceListener.h"
+#include "nsIBaseWindow.h"
+#include "nsIAbDirectory.h"
+#include "nsIWebProgressListener.h"
+#include "nsIMimeConverter.h"
+#include "nsIMsgFolder.h"
+#include "mozIDOMWindow.h"
+#include "mozilla/dom/Element.h"
+
+// Forward declares
+class QuotingOutputStreamListener;
+class nsMsgComposeSendListener;
+class nsIEditor;
+class nsIArray;
+struct nsMsgMailList;
+
+class nsMsgCompose : public nsIMsgCompose, public nsSupportsWeakReference {
+ public:
+  nsMsgCompose();
+
+  /* this macro defines QueryInterface, AddRef and Release for this class */
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  /*** nsIMsgCompose pure virtual functions */
+  NS_DECL_NSIMSGCOMPOSE
+
+  /* nsIMsgSendListener interface */
+  NS_DECL_NSIMSGSENDLISTENER
+
+ protected:
+  virtual ~nsMsgCompose();
+
+  // Deal with quoting issues...
+  nsresult QuoteOriginalMessage();  // New template
+  nsresult SetQuotingToFollow(bool aVal);
+  nsresult ConvertHTMLToText(nsIFile* aSigFile, nsString& aSigData);
+  nsresult ConvertTextToHTML(nsIFile* aSigFile, nsString& aSigData);
+  bool IsEmbeddedObjectSafe(const char* originalScheme,
+                            const char* originalHost, const char* originalPath,
+                            mozilla::dom::Element* element);
+  nsresult TagEmbeddedObjects(nsIEditor* aEditor);
+
+  nsCString mOriginalMsgURI;  // used so we can mark message disposition flags
+                              // after we send the message
+
+  int32_t mWhatHolder;
+
+  nsresult LoadDataFromFile(nsIFile* file, nsString& sigData,
+                            bool aAllowUTF8 = true, bool aAllowUTF16 = true);
+
+  bool CheckIncludeSignaturePrefs(nsIMsgIdentity* identity);
+  // m_folderName to store the value of the saved drafts folder.
+  nsCString m_folderName;
+  MOZ_CAN_RUN_SCRIPT void InsertDivWrappedTextAtSelection(
+      const nsAString& aText, const nsAString& classStr);
+
+ protected:
+  nsresult CreateMessage(const nsACString& originalMsgURI, MSG_ComposeType type,
+                         nsIMsgCompFields* compFields);
+  void CleanUpRecipients(nsString& recipients);
+  nsresult GetABDirAndMailLists(const nsACString& aDirUri,
+                                nsCOMArray<nsIAbDirectory>& aDirArray,
+                                nsTArray<nsMsgMailList>& aMailListArray);
+  nsresult ResolveMailList(nsIAbDirectory* aMailList,
+                           nsCOMArray<nsIAbDirectory>& allDirectoriesArray,
+                           nsTArray<nsMsgMailList>& allMailListArray,
+                           nsTArray<nsMsgMailList>& mailListResolved,
+                           nsTArray<nsMsgRecipient>& aListMembers);
+  void TagConvertible(mozilla::dom::Element* node, int32_t* _retval);
+  MOZ_CAN_RUN_SCRIPT nsresult MoveToAboveQuote(void);
+  MOZ_CAN_RUN_SCRIPT nsresult MoveToBeginningOfDocument(void);
+  MOZ_CAN_RUN_SCRIPT nsresult MoveToEndOfDocument(void);
+  nsresult ReplaceFileURLs(nsString& sigData);
+  nsresult DataURLForFileURL(const nsAString& aFileURL, nsAString& aDataURL);
+
+  /**
+   * Given an nsIFile, attempts to read it into aString.
+   *
+   * Note: Use sparingly! This causes main-thread I/O, which causes jank and all
+   * other bad things.
+   */
+  static nsresult SlurpFileToString(nsIFile* aFile, nsACString& aString);
+
+// 3 = To, Cc, Bcc
+#define MAX_OF_RECIPIENT_ARRAY 3
+  typedef nsTArray<nsMsgRecipient> RecipientsArray[MAX_OF_RECIPIENT_ARRAY];
+  /**
+   * This method parses the compose fields and associates email addresses with
+   * the relevant cards from the address books.
+   */
+  nsresult LookupAddressBook(RecipientsArray& recipientList);
+  bool IsLastWindow();
+
+  // Helper function. Parameters are not checked.
+  bool mConvertStructs;  // for TagConvertible
+
+  nsCOMPtr<nsIEditor> m_editor;
+  mozIDOMWindowProxy* m_window;
+  nsCOMPtr<nsIDocShell> mDocShell;
+  nsCOMPtr<nsIBaseWindow> m_baseWindow;
+  RefPtr<nsMsgCompFields> m_compFields;
+  nsCOMPtr<nsIMsgIdentity> m_identity;
+  bool m_composeHTML;
+  RefPtr<QuotingOutputStreamListener> mQuoteStreamListener;
+  nsCOMPtr<nsIOutputStream> mBaseStream;
+
+  nsCOMPtr<nsIMsgSend> mMsgSend;  // for composition back end
+  nsCOMPtr<nsIMsgProgress>
+      mProgress;  // use by the back end to report progress to the front end
+
+  // Deal with quoting issues...
+  nsString mCiteReference;
+  nsCOMPtr<nsIMsgQuote> mQuote;
+  bool mQuotingToFollow;  // Quoting indicator
+  MSG_ComposeType mType;  // Message type
+  bool mAutodetectCharset;
+  bool mDeleteDraft;
+  nsMsgDispositionState mDraftDisposition;
+  nsCOMPtr<nsIMsgDBHdr> mOrigMsgHdr;
+
+  nsString mSmtpPassword;
+  nsCString mHtmlToQuote;
+
+  nsTObserverArray<nsCOMPtr<nsIMsgComposeStateListener> > mStateListeners;
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener> > mExternalSendListeners;
+
+  bool mAllowRemoteContent;
+  MSG_DeliverMode mDeliverMode;  // nsIMsgCompDeliverMode long.
+
+  friend class QuotingOutputStreamListener;
+  friend class nsMsgComposeSendListener;
+
+ private:
+  void DeleteTmpAttachments();
+  bool mTmpAttachmentsDeleted;
+};
+
+////////////////////////////////////////////////////////////////////////////////////
+// THIS IS THE CLASS THAT IS THE STREAM Listener OF THE HTML OUTPUT
+// FROM LIBMIME. THIS IS FOR QUOTING
+////////////////////////////////////////////////////////////////////////////////////
+class QuotingOutputStreamListener : public nsIMsgQuotingOutputStreamListener,
+                                    public nsSupportsWeakReference {
+ public:
+  QuotingOutputStreamListener(nsIMsgDBHdr* origMsgHdr, bool quoteHeaders,
+                              bool headersOnly, nsIMsgIdentity* identity,
+                              nsIMsgQuote* msgQuote, bool quoteOriginal,
+                              const nsACString& htmlToQuote);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSISTREAMLISTENER
+  NS_DECL_NSIMSGQUOTINGOUTPUTSTREAMLISTENER
+
+  nsresult SetComposeObj(nsIMsgCompose* obj);
+  nsresult ConvertToPlainText(bool formatflowed, bool formatted,
+                              bool disallowBreaks);
+  MOZ_CAN_RUN_SCRIPT nsresult InsertToCompose(nsIEditor* aEditor,
+                                              bool aHTMLEditor);
+  nsresult AppendToMsgBody(const nsCString& inStr);
+
+ private:
+  virtual ~QuotingOutputStreamListener();
+  nsWeakPtr mWeakComposeObj;
+  nsString mMsgBody;
+  nsString mCitePrefix;
+  nsString mSignature;
+  bool mQuoteHeaders;
+  bool mHeadersOnly;
+  nsCOMPtr<nsIMsgQuote> mQuote;
+  nsCOMPtr<nsIMimeHeaders> mHeaders;
+  nsCOMPtr<nsIMsgIdentity> mIdentity;
+  nsCOMPtr<nsIMsgDBHdr> mOrigMsgHdr;
+  nsString mCiteReference;
+  nsCOMPtr<nsIMimeConverter> mMimeConverter;
+  int32_t mUnicodeBufferCharacterLength;
+  bool mQuoteOriginal;
+  nsCString mHtmlToQuote;
+};
+
+////////////////////////////////////////////////////////////////////////////////////
+// This is the listener class for the send operation. We have to create this
+// class to listen for message send completion and eventually notify the caller
+////////////////////////////////////////////////////////////////////////////////////
+class nsMsgComposeSendListener : public nsIMsgComposeSendListener,
+                                 public nsIMsgSendListener,
+                                 public nsIMsgCopyServiceListener,
+                                 public nsIWebProgressListener {
+ public:
+  nsMsgComposeSendListener(void);
+
+  // nsISupports interface
+  NS_DECL_ISUPPORTS
+
+  // nsIMsgComposeSendListener interface
+  NS_DECL_NSIMSGCOMPOSESENDLISTENER
+
+  // nsIMsgSendListener interface
+  NS_DECL_NSIMSGSENDLISTENER
+
+  // nsIMsgCopyServiceListener interface
+  NS_DECL_NSIMSGCOPYSERVICELISTENER
+
+  // nsIWebProgressListener interface
+  NS_DECL_NSIWEBPROGRESSLISTENER
+
+  nsresult RemoveDraftOrTemplate(nsIMsgCompose* compObj, nsCString msgURI,
+                                 bool isSaveTemplate);
+  nsresult RemoveCurrentDraftMessage(nsIMsgCompose* compObj, bool calledByCopy,
+                                     bool isSaveTemplate);
+  nsresult GetMsgFolder(nsIMsgCompose* compObj, nsIMsgFolder** msgFolder);
+
+ private:
+  virtual ~nsMsgComposeSendListener();
+  nsWeakPtr mWeakComposeObj;
+  MSG_DeliverMode mDeliverMode;
+};
+
+/******************************************************************************
+ * nsMsgMailList
+ ******************************************************************************/
+struct nsMsgMailList {
+  explicit nsMsgMailList(nsIAbDirectory* directory);
+
+  nsString mName;
+  nsString mDescription;
+  nsCOMPtr<nsIAbDirectory> mDirectory;
+};
+
+#endif /* _nsMsgCompose_H_ */
diff --git a/comm/mailnews/compose/src/nsMsgComposeContentHandler.cpp b/comm/mailnews/compose/src/nsMsgComposeContentHandler.cpp
new file mode 100644
index 0000000000..7683d04d89
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgComposeContentHandler.cpp
@@ -0,0 +1,119 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgComposeContentHandler.h"
+#include "nsMsgComposeService.h"
+#include "nsIChannel.h"
+#include "nsIURI.h"
+#include "plstr.h"
+#include "nsServiceManagerUtils.h"
+#include "nsCOMPtr.h"
+#include "nsPIDOMWindow.h"
+#include "mozIDOMWindow.h"
+#include "mozilla/dom/Document.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsNetUtil.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIMsgAccountManager.h"
+
+#define NS_MSGCOMPOSESERVICE_CID                    \
+  { /* 588595FE-1ADA-11d3-A715-0060B0EB39B5 */      \
+    0x588595fe, 0x1ada, 0x11d3, {                   \
+      0xa7, 0x15, 0x0, 0x60, 0xb0, 0xeb, 0x39, 0xb5 \
+    }                                               \
+  }
+static NS_DEFINE_CID(kMsgComposeServiceCID, NS_MSGCOMPOSESERVICE_CID);
+
+nsMsgComposeContentHandler::nsMsgComposeContentHandler() {}
+
+// The following macro actually implement addref, release and query interface
+// for our component.
+NS_IMPL_ISUPPORTS(nsMsgComposeContentHandler, nsIContentHandler)
+
+nsMsgComposeContentHandler::~nsMsgComposeContentHandler() {}
+
+// Try to get an appropriate nsIMsgIdentity by going through the window, getting
+// the document's URI, then the corresponding nsIMsgDBHdr. Then find the server
+// associated with that header and get the first identity for it.
+nsresult nsMsgComposeContentHandler::GetBestIdentity(
+    nsIInterfaceRequestor* aWindowContext, nsIMsgIdentity** aIdentity) {
+  nsresult rv;
+
+  nsCOMPtr<mozIDOMWindowProxy> domWindow = do_GetInterface(aWindowContext);
+  NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
+  nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(domWindow);
+
+  nsAutoString documentURIString;
+  rv = window->GetDoc()->GetDocumentURI(documentURIString);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIURI> documentURI;
+  rv = NS_NewURI(getter_AddRefs(documentURI), documentURIString);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgMessageUrl> msgURI = do_QueryInterface(documentURI);
+  if (!msgURI) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  rv = msgURI->GetMessageHeader(getter_AddRefs(msgHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  rv = msgHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // nsIMsgDBHdrs from .eml messages have a null folder, so bail out if that's
+  // the case.
+  if (!folder) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = folder->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = accountManager->GetFirstIdentityForServer(server, aIdentity);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgComposeContentHandler::HandleContent(
+    const char* aContentType, nsIInterfaceRequestor* aWindowContext,
+    nsIRequest* request) {
+  nsresult rv = NS_OK;
+  if (!request) return NS_ERROR_NULL_POINTER;
+
+  // First of all, get the content type and make sure it is a content type we
+  // know how to handle!
+  if (PL_strcasecmp(aContentType, "application/x-mailto") == 0) {
+    nsCOMPtr<nsIMsgIdentity> identity;
+
+    if (aWindowContext)
+      GetBestIdentity(aWindowContext, getter_AddRefs(identity));
+
+    nsCOMPtr<nsIURI> aUri;
+    nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
+    if (!aChannel) return NS_ERROR_FAILURE;
+
+    rv = aChannel->GetURI(getter_AddRefs(aUri));
+    if (aUri) {
+      nsCOMPtr<nsIMsgComposeService> composeService =
+          do_GetService(kMsgComposeServiceCID, &rv);
+      if (NS_SUCCEEDED(rv))
+        rv = composeService->OpenComposeWindowWithURI(nullptr, aUri, identity);
+    }
+  } else {
+    // The content-type was not application/x-mailto...
+    return NS_ERROR_WONT_HANDLE_CONTENT;
+  }
+
+  return rv;
+}
diff --git a/comm/mailnews/compose/src/nsMsgComposeContentHandler.h b/comm/mailnews/compose/src/nsMsgComposeContentHandler.h
new file mode 100644
index 0000000000..158edfa09b
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgComposeContentHandler.h
@@ -0,0 +1,19 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIContentHandler.h"
+#include "nsIMsgIdentity.h"
+
+class nsMsgComposeContentHandler : public nsIContentHandler {
+ public:
+  nsMsgComposeContentHandler();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONTENTHANDLER
+ private:
+  virtual ~nsMsgComposeContentHandler();
+  nsresult GetBestIdentity(nsIInterfaceRequestor* aWindowContext,
+                           nsIMsgIdentity** identity);
+};
diff --git a/comm/mailnews/compose/src/nsMsgComposeParams.cpp b/comm/mailnews/compose/src/nsMsgComposeParams.cpp
new file mode 100644
index 0000000000..653ed11f46
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgComposeParams.cpp
@@ -0,0 +1,157 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgComposeParams.h"
+
+nsMsgComposeParams::nsMsgComposeParams()
+    : mType(nsIMsgCompType::New),
+      mFormat(nsIMsgCompFormat::Default),
+      mBodyIsLink(false),
+      mAutodetectCharset(false) {}
+
+/* the following macro actually implement addref, release and query interface
+ * for our component. */
+NS_IMPL_ISUPPORTS(nsMsgComposeParams, nsIMsgComposeParams)
+
+nsMsgComposeParams::~nsMsgComposeParams() {}
+
+/* attribute MSG_ComposeType type; */
+NS_IMETHODIMP nsMsgComposeParams::GetType(MSG_ComposeType* aType) {
+  NS_ENSURE_ARG_POINTER(aType);
+
+  *aType = mType;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetType(MSG_ComposeType aType) {
+  mType = aType;
+  return NS_OK;
+}
+
+/* attribute MSG_ComposeFormat format; */
+NS_IMETHODIMP nsMsgComposeParams::GetFormat(MSG_ComposeFormat* aFormat) {
+  NS_ENSURE_ARG_POINTER(aFormat);
+
+  *aFormat = mFormat;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetFormat(MSG_ComposeFormat aFormat) {
+  mFormat = aFormat;
+  return NS_OK;
+}
+
+/* attribute string originalMsgURI; */
+NS_IMETHODIMP nsMsgComposeParams::GetOriginalMsgURI(
+    nsACString& aOriginalMsgURI) {
+  aOriginalMsgURI = mOriginalMsgUri;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetOriginalMsgURI(
+    const nsACString& aOriginalMsgURI) {
+  mOriginalMsgUri = aOriginalMsgURI;
+  return NS_OK;
+}
+
+/* attribute nsIMsgIdentity identity; */
+NS_IMETHODIMP nsMsgComposeParams::GetIdentity(nsIMsgIdentity** aIdentity) {
+  NS_ENSURE_ARG_POINTER(aIdentity);
+  NS_IF_ADDREF(*aIdentity = mIdentity);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeParams::SetIdentity(nsIMsgIdentity* aIdentity) {
+  mIdentity = aIdentity;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeParams::SetOrigMsgHdr(nsIMsgDBHdr* aMsgHdr) {
+  mOrigMsgHdr = aMsgHdr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeParams::GetOrigMsgHdr(nsIMsgDBHdr** aMsgHdr) {
+  NS_ENSURE_ARG_POINTER(aMsgHdr);
+  NS_IF_ADDREF(*aMsgHdr = mOrigMsgHdr);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeParams::GetAutodetectCharset(
+    bool* aAutodetectCharset) {
+  NS_ENSURE_ARG_POINTER(aAutodetectCharset);
+  *aAutodetectCharset = mAutodetectCharset;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetAutodetectCharset(
+    bool aAutodetectCharset) {
+  mAutodetectCharset = aAutodetectCharset;
+  return NS_OK;
+}
+
+/* attribute ACString htmlToQuote; */
+NS_IMETHODIMP nsMsgComposeParams::GetHtmlToQuote(nsACString& aHtmlToQuote) {
+  aHtmlToQuote = mHtmlToQuote;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetHtmlToQuote(
+    const nsACString& aHtmlToQuote) {
+  mHtmlToQuote = aHtmlToQuote;
+  return NS_OK;
+}
+
+/* attribute nsIMsgCompFields composeFields; */
+NS_IMETHODIMP nsMsgComposeParams::GetComposeFields(
+    nsIMsgCompFields** aComposeFields) {
+  NS_ENSURE_ARG_POINTER(aComposeFields);
+
+  if (mComposeFields) {
+    NS_ADDREF(*aComposeFields = mComposeFields);
+  } else
+    *aComposeFields = nullptr;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetComposeFields(
+    nsIMsgCompFields* aComposeFields) {
+  mComposeFields = aComposeFields;
+  return NS_OK;
+}
+
+/* attribute boolean bodyIsLink; */
+NS_IMETHODIMP nsMsgComposeParams::GetBodyIsLink(bool* aBodyIsLink) {
+  NS_ENSURE_ARG_POINTER(aBodyIsLink);
+
+  *aBodyIsLink = mBodyIsLink;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetBodyIsLink(bool aBodyIsLink) {
+  mBodyIsLink = aBodyIsLink;
+  return NS_OK;
+}
+
+/* attribute nsIMsgSendLisneter sendListener; */
+NS_IMETHODIMP nsMsgComposeParams::GetSendListener(
+    nsIMsgSendListener** aSendListener) {
+  NS_ENSURE_ARG_POINTER(aSendListener);
+
+  if (mSendListener) {
+    NS_ADDREF(*aSendListener = mSendListener);
+  } else
+    *aSendListener = nullptr;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetSendListener(
+    nsIMsgSendListener* aSendListener) {
+  mSendListener = aSendListener;
+  return NS_OK;
+}
+
+/* attribute string smtpPassword; */
+NS_IMETHODIMP nsMsgComposeParams::GetSmtpPassword(nsAString& aSmtpPassword) {
+  aSmtpPassword = mSMTPPassword;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetSmtpPassword(
+    const nsAString& aSmtpPassword) {
+  mSMTPPassword = aSmtpPassword;
+  return NS_OK;
+}
diff --git a/comm/mailnews/compose/src/nsMsgComposeParams.h b/comm/mailnews/compose/src/nsMsgComposeParams.h
new file mode 100644
index 0000000000..b447304e30
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgComposeParams.h
@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIMsgComposeParams.h"
+#include "nsString.h"
+#include "nsIMsgHdr.h"
+#include "nsCOMPtr.h"
+class nsMsgComposeParams : public nsIMsgComposeParams {
+ public:
+  nsMsgComposeParams();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGCOMPOSEPARAMS
+
+ private:
+  virtual ~nsMsgComposeParams();
+  MSG_ComposeType mType;
+  MSG_ComposeFormat mFormat;
+  nsCString mOriginalMsgUri;
+  nsCOMPtr<nsIMsgIdentity> mIdentity;
+  nsCOMPtr<nsIMsgCompFields> mComposeFields;
+  bool mBodyIsLink;
+  nsCOMPtr<nsIMsgSendListener> mSendListener;
+  nsString mSMTPPassword;
+  nsCOMPtr<nsIMsgDBHdr> mOrigMsgHdr;
+  bool mAutodetectCharset;
+  nsCString mHtmlToQuote;
+};
diff --git a/comm/mailnews/compose/src/nsMsgComposeProgressParams.cpp b/comm/mailnews/compose/src/nsMsgComposeProgressParams.cpp
new file mode 100644
index 0000000000..d54355ab8f
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgComposeProgressParams.cpp
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgComposeProgressParams.h"
+#include "nsServiceManagerUtils.h"
+
+NS_IMPL_ISUPPORTS(nsMsgComposeProgressParams, nsIMsgComposeProgressParams)
+
+nsMsgComposeProgressParams::nsMsgComposeProgressParams()
+    : m_deliveryMode(nsIMsgCompDeliverMode::Now) {}
+
+nsMsgComposeProgressParams::~nsMsgComposeProgressParams() {}
+
+/* attribute wstring subject; */
+NS_IMETHODIMP nsMsgComposeProgressParams::GetSubject(char16_t** aSubject) {
+  NS_ENSURE_ARG(aSubject);
+
+  *aSubject = ToNewUnicode(m_subject);
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeProgressParams::SetSubject(const char16_t* aSubject) {
+  m_subject = aSubject;
+  return NS_OK;
+}
+
+/* attribute MSG_DeliverMode deliveryMode; */
+NS_IMETHODIMP nsMsgComposeProgressParams::GetDeliveryMode(
+    MSG_DeliverMode* aDeliveryMode) {
+  NS_ENSURE_ARG(aDeliveryMode);
+
+  *aDeliveryMode = m_deliveryMode;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeProgressParams::SetDeliveryMode(
+    MSG_DeliverMode aDeliveryMode) {
+  m_deliveryMode = aDeliveryMode;
+  return NS_OK;
+}
diff --git a/comm/mailnews/compose/src/nsMsgComposeProgressParams.h b/comm/mailnews/compose/src/nsMsgComposeProgressParams.h
new file mode 100644
index 0000000000..141d870195
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgComposeProgressParams.h
@@ -0,0 +1,19 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIMsgComposeProgressParams.h"
+
+class nsMsgComposeProgressParams : public nsIMsgComposeProgressParams {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGCOMPOSEPROGRESSPARAMS
+
+  nsMsgComposeProgressParams();
+
+ private:
+  virtual ~nsMsgComposeProgressParams();
+  nsString m_subject;
+  MSG_DeliverMode m_deliveryMode;
+};
diff --git a/comm/mailnews/compose/src/nsMsgComposeService.cpp b/comm/mailnews/compose/src/nsMsgComposeService.cpp
new file mode 100644
index 0000000000..be12fbbef4
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgComposeService.cpp
@@ -0,0 +1,1411 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgComposeService.h"
+#include "nsIMsgSend.h"
+#include "nsIServiceManager.h"
+#include "nsIObserverService.h"
+#include "nsIMsgIdentity.h"
+#include "nsISmtpUrl.h"
+#include "nsIURI.h"
+#include "nsMsgI18N.h"
+#include "nsIMsgComposeParams.h"
+#include "nsXPCOM.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIWindowWatcher.h"
+#include "mozIDOMWindow.h"
+#include "nsIContentViewer.h"
+#include "nsIMsgWindow.h"
+#include "nsIDocShell.h"
+#include "nsPIDOMWindow.h"
+#include "mozilla/dom/Document.h"
+#include "nsIAppWindow.h"
+#include "nsIWindowMediator.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIBaseWindow.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIStreamConverter.h"
+#include "nsToolkitCompsCID.h"
+#include "nsNetUtil.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIMsgDatabase.h"
+#include "nsIDocumentEncoder.h"
+#include "nsContentCID.h"
+#include "mozilla/dom/Selection.h"
+#include "nsUTF8Utils.h"
+#include "mozilla/intl/LineBreaker.h"
+#include "mimemoz2.h"
+#include "nsIURIMutator.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/XULFrameElement.h"
+#include "nsFrameLoader.h"
+#include "nsSmtpUrl.h"
+#include "nsUnicharUtils.h"
+#include "mozilla/NullPrincipal.h"
+
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+#  include "mozilla/Logging.h"
+#  include "nsIMsgHdr.h"
+#  include "nsIMsgMessageService.h"
+#  include "nsMsgUtils.h"
+#endif
+
+#include "nsICommandLine.h"
+#include "nsIAppStartup.h"
+#include "nsMsgUtils.h"
+#include "nsIPrincipal.h"
+#include "nsIMutableArray.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+#ifdef XP_WIN
+#  include <windows.h>
+#  include <shellapi.h>
+#  include "nsIWidget.h"
+#endif
+
+#define DEFAULT_CHROME \
+  "chrome://messenger/content/messengercompose/messengercompose.xhtml"_ns
+
+#define PREF_MAILNEWS_REPLY_QUOTING_SELECTION "mailnews.reply_quoting_selection"
+#define PREF_MAILNEWS_REPLY_QUOTING_SELECTION_MULTI_WORD \
+  "mailnews.reply_quoting_selection.multi_word"
+#define PREF_MAILNEWS_REPLY_QUOTING_SELECTION_ONLY_IF \
+  "mailnews.reply_quoting_selection.only_if_chars"
+
+#define MAIL_ROOT_PREF "mail."
+#define MAILNEWS_ROOT_PREF "mailnews."
+#define HTMLDOMAINUPDATE_VERSION_PREF_NAME "global_html_domains.version"
+#define HTMLDOMAINUPDATE_DOMAINLIST_PREF_NAME "global_html_domains"
+#define USER_CURRENT_HTMLDOMAINLIST_PREF_NAME "html_domains"
+#define USER_CURRENT_PLAINTEXTDOMAINLIST_PREF_NAME "plaintext_domains"
+#define DOMAIN_DELIMITER ','
+
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+static mozilla::LazyLogModule MsgComposeLogModule("MsgCompose");
+
+static uint32_t GetMessageSizeFromURI(const nsACString& originalMsgURI) {
+  uint32_t msgSize = 0;
+
+  if (!originalMsgURI.IsEmpty()) {
+    nsCOMPtr<nsIMsgDBHdr> originalMsgHdr;
+    GetMsgDBHdrFromURI(originalMsgURI, getter_AddRefs(originalMsgHdr));
+    if (originalMsgHdr) originalMsgHdr->GetMessageSize(&msgSize);
+  }
+
+  return msgSize;
+}
+#endif
+
+nsMsgComposeService::nsMsgComposeService() {
+  // Defaulting the value of mLogComposePerformance to FALSE to prevent logging.
+  mLogComposePerformance = false;
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+  mStartTime = PR_IntervalNow();
+  mPreviousTime = mStartTime;
+#endif
+}
+
+NS_IMPL_ISUPPORTS(nsMsgComposeService, nsIMsgComposeService,
+                  ICOMMANDLINEHANDLER, nsISupportsWeakReference)
+
+nsMsgComposeService::~nsMsgComposeService() { mOpenComposeWindows.Clear(); }
+
+nsresult nsMsgComposeService::Init() {
+  nsresult rv = NS_OK;
+
+  Reset();
+
+  AddGlobalHtmlDomains();
+  // Since the compose service should only be initialized once, we can
+  // be pretty sure there aren't any existing compose windows open.
+  MsgCleanupTempFiles("nsmail", "tmp");
+  MsgCleanupTempFiles("nscopy", "tmp");
+  MsgCleanupTempFiles("nsemail", "eml");
+  MsgCleanupTempFiles("nsemail", "tmp");
+  MsgCleanupTempFiles("nsqmail", "tmp");
+  return rv;
+}
+
+void nsMsgComposeService::Reset() {
+  mOpenComposeWindows.Clear();
+
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (prefs)
+    prefs->GetBoolPref("mailnews.logComposePerformance",
+                       &mLogComposePerformance);
+}
+
+// Function to open a message compose window and pass an nsIMsgComposeParams
+// parameter to it.
+NS_IMETHODIMP
+nsMsgComposeService::OpenComposeWindowWithParams(const char* chrome,
+                                                 nsIMsgComposeParams* params) {
+  NS_ENSURE_ARG_POINTER(params);
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+  if (mLogComposePerformance) {
+    TimeStamp("Start opening the window", true);
+  }
+#endif
+
+  nsresult rv;
+
+  NS_ENSURE_ARG_POINTER(params);
+
+  // Use default identity if no identity has been specified
+  nsCOMPtr<nsIMsgIdentity> identity;
+  params->GetIdentity(getter_AddRefs(identity));
+  if (!identity) {
+    GetDefaultIdentity(getter_AddRefs(identity));
+    params->SetIdentity(identity);
+  }
+
+  // Create a new window.
+  nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
+  if (!wwatch) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsISupportsInterfacePointer> msgParamsWrapper =
+      do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  msgParamsWrapper->SetData(params);
+  msgParamsWrapper->SetDataIID(&NS_GET_IID(nsIMsgComposeParams));
+
+  nsCOMPtr<mozIDOMWindowProxy> newWindow;
+  nsAutoCString chromeURL;
+  if (chrome && *chrome) {
+    chromeURL = nsDependentCString(chrome);
+  } else {
+    chromeURL = DEFAULT_CHROME;
+  }
+  rv = wwatch->OpenWindow(0, chromeURL, "_blank"_ns,
+                          "all,chrome,dialog=no,status,toolbar"_ns,
+                          msgParamsWrapper, getter_AddRefs(newWindow));
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::DetermineComposeHTML(nsIMsgIdentity* aIdentity,
+                                          MSG_ComposeFormat aFormat,
+                                          bool* aComposeHTML) {
+  NS_ENSURE_ARG_POINTER(aComposeHTML);
+
+  *aComposeHTML = true;
+  switch (aFormat) {
+    case nsIMsgCompFormat::HTML:
+      *aComposeHTML = true;
+      break;
+    case nsIMsgCompFormat::PlainText:
+      *aComposeHTML = false;
+      break;
+
+    default:
+      nsCOMPtr<nsIMsgIdentity> identity = aIdentity;
+      if (!identity) GetDefaultIdentity(getter_AddRefs(identity));
+
+      if (identity) {
+        identity->GetComposeHtml(aComposeHTML);
+        if (aFormat == nsIMsgCompFormat::OppositeOfDefault)
+          *aComposeHTML = !*aComposeHTML;
+      } else {
+        // default identity not found.  Use the mail.html_compose pref to
+        // determine message compose type (HTML or PlainText).
+        nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+        if (prefs) {
+          nsresult rv;
+          bool useHTMLCompose;
+          rv = prefs->GetBoolPref(MAIL_ROOT_PREF "html_compose",
+                                  &useHTMLCompose);
+          if (NS_SUCCEEDED(rv)) *aComposeHTML = useHTMLCompose;
+        }
+      }
+      break;
+  }
+
+  return NS_OK;
+}
+
+MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION nsresult
+nsMsgComposeService::GetOrigWindowSelection(MSG_ComposeType type,
+                                            mozilla::dom::Selection* selection,
+                                            nsACString& aSelHTML) {
+  nsresult rv;
+
+  // Good hygiene
+  aSelHTML.Truncate();
+
+  // Get the pref to see if we even should do reply quoting selection
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool replyQuotingSelection;
+  rv = prefs->GetBoolPref(PREF_MAILNEWS_REPLY_QUOTING_SELECTION,
+                          &replyQuotingSelection);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!replyQuotingSelection) return NS_ERROR_ABORT;
+
+  bool requireMultipleWords = true;
+  nsAutoCString charsOnlyIf;
+  prefs->GetBoolPref(PREF_MAILNEWS_REPLY_QUOTING_SELECTION_MULTI_WORD,
+                     &requireMultipleWords);
+  prefs->GetCharPref(PREF_MAILNEWS_REPLY_QUOTING_SELECTION_ONLY_IF,
+                     charsOnlyIf);
+  if (requireMultipleWords || !charsOnlyIf.IsEmpty()) {
+    nsAutoString selPlain;
+    selection->Stringify(selPlain);
+
+    // If "mailnews.reply_quoting_selection.multi_word" is on, then there must
+    // be at least two words selected in order to quote just the selected text
+    if (requireMultipleWords) {
+      if (selPlain.IsEmpty()) return NS_ERROR_ABORT;
+
+      if (NS_SUCCEEDED(rv)) {
+        const uint32_t length = selPlain.Length();
+        const char16_t* unicodeStr = selPlain.get();
+        int32_t endWordPos =
+            mozilla::intl::LineBreaker::Next(unicodeStr, length, 0);
+
+        // If there's not even one word, then there's not multiple words
+        if (endWordPos == NS_LINEBREAKER_NEED_MORE_TEXT) return NS_ERROR_ABORT;
+
+        // If after the first word is only space, then there's not multiple
+        // words
+        const char16_t* end;
+        for (end = unicodeStr + endWordPos; mozilla::intl::NS_IsSpace(*end);
+             end++)
+          ;
+        if (!*end) return NS_ERROR_ABORT;
+      }
+    }
+
+    if (!charsOnlyIf.IsEmpty()) {
+      if (selPlain.FindCharInSet(NS_ConvertUTF8toUTF16(charsOnlyIf)) ==
+          kNotFound) {
+        return NS_ERROR_ABORT;
+      }
+    }
+  }
+
+  nsAutoString selHTML;
+  IgnoredErrorResult rv2;
+  selection->ToStringWithFormat(u"text/html"_ns,
+                                nsIDocumentEncoder::SkipInvisibleContent, 0,
+                                selHTML, rv2);
+  if (rv2.Failed()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Now remove <span class="moz-txt-citetags">&gt; </span>.
+  nsAutoCString html(NS_ConvertUTF16toUTF8(selHTML).get());
+  int32_t spanInd = html.Find("<span class=\"moz-txt-citetags\">");
+  while (spanInd != kNotFound) {
+    nsAutoCString right0(Substring(html, spanInd));
+    int32_t endInd = right0.Find("</span>");
+    if (endInd == kNotFound) break;  // oops, where is the closing tag gone?
+    nsAutoCString right1(Substring(html, spanInd + endInd + 7));
+    html.SetLength(spanInd);
+    html.Append(right1);
+    spanInd = html.Find("<span class=\"moz-txt-citetags\">");
+  }
+
+  aSelHTML.Assign(html);
+
+  return rv;
+}
+
+MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION NS_IMETHODIMP
+nsMsgComposeService::OpenComposeWindow(
+    const nsACString& msgComposeWindowURL, nsIMsgDBHdr* origMsgHdr,
+    const nsACString& originalMsgURI, MSG_ComposeType type,
+    MSG_ComposeFormat format, nsIMsgIdentity* aIdentity, const nsACString& from,
+    nsIMsgWindow* aMsgWindow, mozilla::dom::Selection* selection,
+    bool autodetectCharset) {
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgIdentity> identity = aIdentity;
+  if (!identity) GetDefaultIdentity(getter_AddRefs(identity));
+
+  /* Actually, the only way to implement forward inline is to simulate a
+     template message. Maybe one day when we will have more time we can change
+     that
+  */
+  if (type == nsIMsgCompType::ForwardInline || type == nsIMsgCompType::Draft ||
+      type == nsIMsgCompType::EditTemplate ||
+      type == nsIMsgCompType::Template ||
+      type == nsIMsgCompType::ReplyWithTemplate ||
+      type == nsIMsgCompType::Redirect || type == nsIMsgCompType::EditAsNew) {
+    nsAutoCString uriToOpen(originalMsgURI);
+    char sep = (uriToOpen.FindChar('?') == kNotFound) ? '?' : '&';
+
+    // The compose type that gets transmitted to a compose window open in mime
+    // is communicated using url query parameters here.
+    if (type == nsIMsgCompType::Redirect) {
+      uriToOpen += sep;
+      uriToOpen.AppendLiteral("redirect=true");
+    } else if (type == nsIMsgCompType::EditAsNew) {
+      uriToOpen += sep;
+      uriToOpen.AppendLiteral("editasnew=true");
+    } else if (type == nsIMsgCompType::EditTemplate) {
+      uriToOpen += sep;
+      uriToOpen.AppendLiteral("edittempl=true");
+    }
+
+    return LoadDraftOrTemplate(
+        uriToOpen,
+        type == nsIMsgCompType::ForwardInline || type == nsIMsgCompType::Draft
+            ? nsMimeOutput::nsMimeMessageDraftOrTemplate
+            : nsMimeOutput::nsMimeMessageEditorTemplate,
+        identity, originalMsgURI, origMsgHdr,
+        type == nsIMsgCompType::ForwardInline,
+        format == nsIMsgCompFormat::OppositeOfDefault, aMsgWindow,
+        autodetectCharset);
+  }
+
+  nsCOMPtr<nsIMsgComposeParams> pMsgComposeParams(
+      do_CreateInstance("@mozilla.org/messengercompose/composeparams;1", &rv));
+  if (NS_SUCCEEDED(rv) && pMsgComposeParams) {
+    nsCOMPtr<nsIMsgCompFields> pMsgCompFields(do_CreateInstance(
+        "@mozilla.org/messengercompose/composefields;1", &rv));
+    if (NS_SUCCEEDED(rv) && pMsgCompFields) {
+      pMsgComposeParams->SetType(type);
+      pMsgComposeParams->SetFormat(format);
+      pMsgComposeParams->SetIdentity(identity);
+      pMsgComposeParams->SetAutodetectCharset(autodetectCharset);
+
+      // When doing a reply (except with a template) see if there's a selection
+      // that we should quote
+      if (selection &&
+          (type == nsIMsgCompType::Reply || type == nsIMsgCompType::ReplyAll ||
+           type == nsIMsgCompType::ReplyToSender ||
+           type == nsIMsgCompType::ReplyToGroup ||
+           type == nsIMsgCompType::ReplyToSenderAndGroup ||
+           type == nsIMsgCompType::ReplyToList)) {
+        nsAutoCString selHTML;
+        if (NS_SUCCEEDED(GetOrigWindowSelection(type, selection, selHTML))) {
+          nsCOMPtr<nsINode> node = selection->GetFocusNode();
+          NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
+          IgnoredErrorResult er;
+
+          if ((node->LocalName().IsEmpty() ||
+               node->LocalName().EqualsLiteral("pre")) &&
+              node->OwnerDoc()->QuerySelector(
+                  "body > div:first-of-type.moz-text-plain"_ns, er)) {
+            // Treat the quote as <pre> for selections in moz-text-plain bodies.
+            // If focusNode.localName isn't empty, we had e.g. body selected
+            // and should not add <pre>.
+            pMsgComposeParams->SetHtmlToQuote("<pre>"_ns + selHTML +
+                                              "</pre>"_ns);
+          } else {
+            pMsgComposeParams->SetHtmlToQuote(selHTML);
+          }
+        }
+      }
+
+      if (!originalMsgURI.IsEmpty()) {
+        if (type == nsIMsgCompType::NewsPost) {
+          nsAutoCString newsURI(originalMsgURI);
+          nsAutoCString group;
+          nsAutoCString host;
+
+          int32_t slashpos = newsURI.RFindChar('/');
+          if (slashpos > 0) {
+            // uri is "[s]news://host[:port]/group"
+            host = StringHead(newsURI, slashpos);
+            group = Substring(newsURI, slashpos + 1);
+
+          } else
+            group = originalMsgURI;
+
+          nsAutoCString unescapedName;
+          MsgUnescapeString(group,
+                            nsINetUtil::ESCAPE_URL_FILE_BASENAME |
+                                nsINetUtil::ESCAPE_URL_FORCED,
+                            unescapedName);
+          pMsgCompFields->SetNewsgroups(NS_ConvertUTF8toUTF16(unescapedName));
+          pMsgCompFields->SetNewspostUrl(host.get());
+        } else {
+          pMsgComposeParams->SetOriginalMsgURI(originalMsgURI);
+          pMsgComposeParams->SetOrigMsgHdr(origMsgHdr);
+          pMsgCompFields->SetFrom(NS_ConvertUTF8toUTF16(from));
+        }
+      }
+
+      pMsgComposeParams->SetComposeFields(pMsgCompFields);
+
+      if (mLogComposePerformance) {
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+        // ducarroz, properly fix this in the case of new message (not a reply)
+        if (type != nsIMsgCompType::NewsPost) {
+          char buff[256];
+          sprintf(buff, "Start opening the window, message size = %d",
+                  GetMessageSizeFromURI(originalMsgURI));
+          TimeStamp(buff, true);
+        }
+#endif
+      }  // end if(mLogComposePerformance)
+
+      rv = OpenComposeWindowWithParams(
+          PromiseFlatCString(msgComposeWindowURL).get(), pMsgComposeParams);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgComposeService::GetParamsForMailto(
+    nsIURI* aURI, nsIMsgComposeParams** aParams) {
+  nsresult rv = NS_OK;
+  if (aURI) {
+    nsCString spec;
+    aURI->GetSpec(spec);
+
+    nsCOMPtr<nsIURI> url;
+    rv = nsMailtoUrl::NewMailtoURI(spec, nullptr, getter_AddRefs(url));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIMailtoUrl> aMailtoUrl = do_QueryInterface(url, &rv);
+
+    if (NS_SUCCEEDED(rv)) {
+      MSG_ComposeFormat requestedComposeFormat = nsIMsgCompFormat::Default;
+      nsCString toPart;
+      nsCString ccPart;
+      nsCString bccPart;
+      nsCString subjectPart;
+      nsCString bodyPart;
+      nsCString newsgroup;
+      nsCString refPart;
+      nsCString HTMLBodyPart;
+
+      aMailtoUrl->GetMessageContents(toPart, ccPart, bccPart, subjectPart,
+                                     bodyPart, HTMLBodyPart, refPart, newsgroup,
+                                     &requestedComposeFormat);
+
+      nsAutoString sanitizedBody;
+
+      bool composeHTMLFormat;
+      DetermineComposeHTML(NULL, requestedComposeFormat, &composeHTMLFormat);
+
+      // If there was an 'html-body' param, finding it will have requested
+      // HTML format in GetMessageContents, so we try to use it first. If it's
+      // empty, but we are composing in HTML because of the user's prefs, the
+      // 'body' param needs to be escaped, since it's supposed to be plain
+      // text, but it then doesn't need to sanitized.
+      nsString rawBody;
+      if (HTMLBodyPart.IsEmpty()) {
+        if (composeHTMLFormat) {
+          nsCString escaped;
+          nsAppendEscapedHTML(bodyPart, escaped);
+          CopyUTF8toUTF16(escaped, sanitizedBody);
+        } else
+          CopyUTF8toUTF16(bodyPart, rawBody);
+      } else
+        CopyUTF8toUTF16(HTMLBodyPart, rawBody);
+
+      if (!rawBody.IsEmpty() && composeHTMLFormat) {
+        // For security reason, we must sanitize the message body before
+        // accepting any html...
+
+        rv = HTMLSanitize(rawBody, sanitizedBody);  // from mimemoz2.h
+
+        if (NS_FAILED(rv)) {
+          // Something went horribly wrong with parsing for html format
+          // in the body.  Set composeHTMLFormat to false so we show the
+          // plain text mail compose.
+          composeHTMLFormat = false;
+        }
+      }
+
+      nsCOMPtr<nsIMsgComposeParams> pMsgComposeParams(do_CreateInstance(
+          "@mozilla.org/messengercompose/composeparams;1", &rv));
+      if (NS_SUCCEEDED(rv) && pMsgComposeParams) {
+        pMsgComposeParams->SetType(nsIMsgCompType::MailToUrl);
+        pMsgComposeParams->SetFormat(composeHTMLFormat
+                                         ? nsIMsgCompFormat::HTML
+                                         : nsIMsgCompFormat::PlainText);
+
+        nsCOMPtr<nsIMsgCompFields> pMsgCompFields(do_CreateInstance(
+            "@mozilla.org/messengercompose/composefields;1", &rv));
+        if (pMsgCompFields) {
+          // ugghh more conversion work!!!!
+          pMsgCompFields->SetTo(NS_ConvertUTF8toUTF16(toPart));
+          pMsgCompFields->SetCc(NS_ConvertUTF8toUTF16(ccPart));
+          pMsgCompFields->SetBcc(NS_ConvertUTF8toUTF16(bccPart));
+          pMsgCompFields->SetNewsgroups(NS_ConvertUTF8toUTF16(newsgroup));
+          pMsgCompFields->SetReferences(refPart.get());
+          pMsgCompFields->SetSubject(NS_ConvertUTF8toUTF16(subjectPart));
+          pMsgCompFields->SetBody(composeHTMLFormat ? sanitizedBody : rawBody);
+          pMsgComposeParams->SetComposeFields(pMsgCompFields);
+
+          NS_ADDREF(*aParams = pMsgComposeParams);
+          return NS_OK;
+        }
+      }  // if we created msg compose params....
+    }    // if we had a mailto url
+  }      // if we had a url...
+
+  // if we got here we must have encountered an error
+  *aParams = nullptr;
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMsgComposeService::OpenComposeWindowWithURI(
+    const char* aMsgComposeWindowURL, nsIURI* aURI, nsIMsgIdentity* identity) {
+  nsCOMPtr<nsIMsgComposeParams> pMsgComposeParams;
+  nsresult rv = GetParamsForMailto(aURI, getter_AddRefs(pMsgComposeParams));
+  if (NS_SUCCEEDED(rv)) {
+    pMsgComposeParams->SetIdentity(identity);
+    rv = OpenComposeWindowWithParams(aMsgComposeWindowURL, pMsgComposeParams);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgComposeService::InitCompose(nsIMsgComposeParams* aParams,
+                                               mozIDOMWindowProxy* aWindow,
+                                               nsIDocShell* aDocShell,
+                                               nsIMsgCompose** _retval) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgCompose> msgCompose =
+      do_CreateInstance("@mozilla.org/messengercompose/compose;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = msgCompose->Initialize(aParams, aWindow, aDocShell);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_IF_ADDREF(*_retval = msgCompose);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::GetDefaultIdentity(nsIMsgIdentity** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = nullptr;
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgAccount> defaultAccount;
+  rv = accountManager->GetDefaultAccount(getter_AddRefs(defaultAccount));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return defaultAccount ? defaultAccount->GetDefaultIdentity(_retval) : NS_OK;
+}
+
+/* readonly attribute boolean logComposePerformance; */
+NS_IMETHODIMP nsMsgComposeService::GetLogComposePerformance(
+    bool* aLogComposePerformance) {
+  *aLogComposePerformance = mLogComposePerformance;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeService::TimeStamp(const char* label,
+                                             bool resetTime) {
+  if (!mLogComposePerformance) return NS_OK;
+
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+
+  PRIntervalTime now;
+
+  if (resetTime) {
+    MOZ_LOG(MsgComposeLogModule, mozilla::LogLevel::Info,
+            ("\n[process]: [totalTime][deltaTime]\n--------------------\n"));
+
+    mStartTime = PR_IntervalNow();
+    mPreviousTime = mStartTime;
+    now = mStartTime;
+  } else
+    now = PR_IntervalNow();
+
+  PRIntervalTime totalTime = PR_IntervalToMilliseconds(now - mStartTime);
+  PRIntervalTime deltaTime = PR_IntervalToMilliseconds(now - mPreviousTime);
+
+  MOZ_LOG(MsgComposeLogModule, mozilla::LogLevel::Info,
+          ("[%3.2f][%3.2f] - %s\n", ((double)totalTime / 1000.0) + 0.005,
+           ((double)deltaTime / 1000.0) + 0.005, label));
+
+  mPreviousTime = now;
+#endif
+  return NS_OK;
+}
+
+class nsMsgTemplateReplyHelper final : public nsIStreamListener,
+                                       public nsIUrlListener {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSISTREAMLISTENER
+  NS_DECL_NSIREQUESTOBSERVER
+
+  nsMsgTemplateReplyHelper();
+
+  nsCOMPtr<nsIMsgDBHdr> mHdrToReplyTo;
+  nsCOMPtr<nsIMsgDBHdr> mTemplateHdr;
+  nsCOMPtr<nsIMsgWindow> mMsgWindow;
+  nsCOMPtr<nsIMsgIdentity> mIdentity;
+  nsCString mTemplateBody;
+  bool mInMsgBody;
+  char mLastBlockChars[3];
+
+ private:
+  ~nsMsgTemplateReplyHelper();
+};
+
+NS_IMPL_ISUPPORTS(nsMsgTemplateReplyHelper, nsIStreamListener,
+                  nsIRequestObserver, nsIUrlListener)
+
+nsMsgTemplateReplyHelper::nsMsgTemplateReplyHelper() {
+  mInMsgBody = false;
+  memset(mLastBlockChars, 0, sizeof(mLastBlockChars));
+}
+
+nsMsgTemplateReplyHelper::~nsMsgTemplateReplyHelper() {}
+
+NS_IMETHODIMP nsMsgTemplateReplyHelper::OnStartRunningUrl(nsIURI* aUrl) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgTemplateReplyHelper::OnStopRunningUrl(nsIURI* aUrl,
+                                                         nsresult aExitCode) {
+  NS_ENSURE_SUCCESS(aExitCode, aExitCode);
+  nsresult rv;
+  nsCOMPtr<nsPIDOMWindowOuter> parentWindow;
+  if (mMsgWindow) {
+    nsCOMPtr<nsIDocShell> docShell;
+    rv = mMsgWindow->GetRootDocShell(getter_AddRefs(docShell));
+    NS_ENSURE_SUCCESS(rv, rv);
+    parentWindow = do_GetInterface(docShell);
+    NS_ENSURE_TRUE(parentWindow, NS_ERROR_FAILURE);
+  }
+
+  // create the compose params object
+  nsCOMPtr<nsIMsgComposeParams> pMsgComposeParams(
+      do_CreateInstance("@mozilla.org/messengercompose/composeparams;1", &rv));
+  if (NS_FAILED(rv) || (!pMsgComposeParams)) return rv;
+  nsCOMPtr<nsIMsgCompFields> compFields =
+      do_CreateInstance("@mozilla.org/messengercompose/composefields;1", &rv);
+
+  nsCString replyTo;
+  mHdrToReplyTo->GetStringProperty("replyTo", replyTo);
+  if (replyTo.IsEmpty()) mHdrToReplyTo->GetAuthor(getter_Copies(replyTo));
+  compFields->SetTo(NS_ConvertUTF8toUTF16(replyTo));
+
+  nsString body;
+  nsString templateSubject, replySubject;
+
+  mHdrToReplyTo->GetMime2DecodedSubject(replySubject);
+  mTemplateHdr->GetMime2DecodedSubject(templateSubject);
+  nsString subject(u"Auto: "_ns);  // RFC 3834 3.1.5.
+  subject.Append(templateSubject);
+  if (!replySubject.IsEmpty()) {
+    subject.AppendLiteral(u" (was: ");
+    subject.Append(replySubject);
+    subject.Append(u')');
+  }
+
+  compFields->SetSubject(subject);
+  compFields->SetRawHeader("Auto-Submitted", "auto-replied"_ns);
+
+  nsCString charset;
+  rv = mTemplateHdr->GetCharset(getter_Copies(charset));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = nsMsgI18NConvertToUnicode(charset, mTemplateBody, body);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "couldn't convert templ body to unicode");
+  compFields->SetBody(body);
+
+  nsCString msgUri;
+  nsCOMPtr<nsIMsgFolder> folder;
+  mHdrToReplyTo->GetFolder(getter_AddRefs(folder));
+  folder->GetUriForMsg(mHdrToReplyTo, msgUri);
+  // populate the compose params
+  pMsgComposeParams->SetType(nsIMsgCompType::ReplyWithTemplate);
+  pMsgComposeParams->SetFormat(nsIMsgCompFormat::Default);
+  pMsgComposeParams->SetIdentity(mIdentity);
+  pMsgComposeParams->SetComposeFields(compFields);
+  pMsgComposeParams->SetOriginalMsgURI(msgUri);
+
+  // create the nsIMsgCompose object to send the object
+  nsCOMPtr<nsIMsgCompose> pMsgCompose(
+      do_CreateInstance("@mozilla.org/messengercompose/compose;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  /** initialize nsIMsgCompose, Send the message, wait for send completion
+   * response **/
+
+  rv = pMsgCompose->Initialize(pMsgComposeParams, parentWindow, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<mozilla::dom::Promise> promise;
+  return pMsgCompose->SendMsg(nsIMsgSend::nsMsgDeliverNow, mIdentity, nullptr,
+                              nullptr, nullptr, getter_AddRefs(promise));
+}
+
+NS_IMETHODIMP
+nsMsgTemplateReplyHelper::OnStartRequest(nsIRequest* request) { return NS_OK; }
+
+NS_IMETHODIMP
+nsMsgTemplateReplyHelper::OnStopRequest(nsIRequest* request, nsresult status) {
+  if (NS_SUCCEEDED(status)) {
+    // now we've got the message body in mTemplateBody -
+    // need to set body in compose params and send the reply.
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgTemplateReplyHelper::OnDataAvailable(nsIRequest* request,
+                                          nsIInputStream* inStream,
+                                          uint64_t srcOffset, uint32_t count) {
+  nsresult rv = NS_OK;
+
+  char readBuf[1024];
+
+  uint64_t available;
+  uint32_t readCount;
+  uint32_t maxReadCount = sizeof(readBuf) - 1;
+
+  rv = inStream->Available(&available);
+  while (NS_SUCCEEDED(rv) && available > 0) {
+    uint32_t bodyOffset = 0, readOffset = 0;
+    if (!mInMsgBody && mLastBlockChars[0]) {
+      memcpy(readBuf, mLastBlockChars, 3);
+      readOffset = 3;
+      maxReadCount -= 3;
+    }
+    if (maxReadCount > available) maxReadCount = (uint32_t)available;
+    memset(readBuf, 0, sizeof(readBuf));
+    rv = inStream->Read(readBuf + readOffset, maxReadCount, &readCount);
+    available -= readCount;
+    readCount += readOffset;
+    // we're mainly interested in the msg body, so we need to
+    // find the header/body delimiter of a blank line. A blank line
+    // looks like <CR><CR>, <LF><LF>, or <CRLF><CRLF>
+    if (!mInMsgBody) {
+      for (uint32_t charIndex = 0; charIndex < readCount && !bodyOffset;
+           charIndex++) {
+        if (readBuf[charIndex] == '\r' || readBuf[charIndex] == '\n') {
+          if (charIndex + 1 < readCount) {
+            if (readBuf[charIndex] == readBuf[charIndex + 1]) {
+              // got header+body separator
+              bodyOffset = charIndex + 2;
+              break;
+            } else if ((charIndex + 3 < readCount) &&
+                       !strncmp(readBuf + charIndex, "\r\n\r\n", 4)) {
+              bodyOffset = charIndex + 4;
+              break;
+            }
+          }
+        }
+      }
+      mInMsgBody = bodyOffset != 0;
+      if (!mInMsgBody && readCount > 3)  // still in msg hdrs
+        strncpy(mLastBlockChars, readBuf + readCount - 3, 3);
+    }
+    mTemplateBody.Append(readBuf + bodyOffset);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeService::ReplyWithTemplate(
+    nsIMsgDBHdr* aMsgHdr, const nsACString& templateUri,
+    nsIMsgWindow* aMsgWindow, nsIMsgIncomingServer* aServer) {
+  // To reply with template, we need the message body of the template.
+  // I think we're going to need to stream the template message to ourselves,
+  // and construct the body, and call setBody on the compFields.
+  nsresult rv;
+  const nsPromiseFlatCString& templateUriFlat = PromiseFlatCString(templateUri);
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgAccount> account;
+  rv = accountManager->FindAccountForServer(aServer, getter_AddRefs(account));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTArray<RefPtr<nsIMsgIdentity>> identities;
+  rv = account->GetIdentities(identities);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString recipients;
+  aMsgHdr->GetRecipients(getter_Copies(recipients));
+
+  nsAutoCString ccList;
+  aMsgHdr->GetCcList(getter_Copies(ccList));
+
+  // Go through the identities to see to whom this was addressed.
+  // In case we get no match, this is likely a list/bulk/bcc/spam mail and we
+  // shouldn't reply. RFC 3834 2.
+  nsCOMPtr<nsIMsgIdentity> identity;  // identity to reply from
+  for (auto anIdentity : identities) {
+    nsAutoCString identityEmail;
+    anIdentity->GetEmail(identityEmail);
+
+    if (FindInReadable(identityEmail, recipients,
+                       nsCaseInsensitiveCStringComparator) ||
+        FindInReadable(identityEmail, ccList,
+                       nsCaseInsensitiveCStringComparator)) {
+      identity = anIdentity;
+      break;
+    }
+  }
+  if (!identity)  // Found no match -> don't reply.
+    return NS_ERROR_ABORT;
+
+  RefPtr<nsMsgTemplateReplyHelper> helper = new nsMsgTemplateReplyHelper;
+
+  helper->mHdrToReplyTo = aMsgHdr;
+  helper->mMsgWindow = aMsgWindow;
+  helper->mIdentity = identity;
+
+  nsAutoCString replyTo;
+  aMsgHdr->GetStringProperty("replyTo", replyTo);
+  if (replyTo.IsEmpty()) aMsgHdr->GetAuthor(getter_Copies(replyTo));
+  if (replyTo.IsEmpty()) return NS_ERROR_FAILURE;  // nowhere to send the reply
+
+  nsCOMPtr<nsIMsgFolder> templateFolder;
+  nsCOMPtr<nsIMsgDatabase> templateDB;
+  nsCString templateMsgHdrUri;
+  const char* query = PL_strstr(templateUriFlat.get(), "?messageId=");
+  if (!query) return NS_ERROR_FAILURE;
+
+  nsAutoCString folderUri(Substring(templateUriFlat.get(), query));
+  rv = GetExistingFolder(folderUri, getter_AddRefs(templateFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = templateFolder->GetMsgDatabase(getter_AddRefs(templateDB));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  const char* subject = PL_strstr(templateUriFlat.get(), "&subject=");
+  if (subject) {
+    const char* subjectEnd = subject + strlen(subject);
+    nsAutoCString messageId(Substring(query + 11, subject));
+    nsAutoCString subjectString(Substring(subject + 9, subjectEnd));
+    templateDB->GetMsgHdrForMessageID(messageId.get(),
+                                      getter_AddRefs(helper->mTemplateHdr));
+    if (helper->mTemplateHdr)
+      templateFolder->GetUriForMsg(helper->mTemplateHdr, templateMsgHdrUri);
+    // to use the subject, we'd need to expose a method to find a message by
+    // subject, or painfully iterate through messages...We'll try to make the
+    // message-id not change when saving a template first.
+  }
+  if (templateMsgHdrUri.IsEmpty()) {
+    // ### probably want to return a specific error and
+    // have the calling code disable the filter.
+    NS_ASSERTION(false, "failed to get msg hdr");
+    return NS_ERROR_FAILURE;
+  }
+  // we need to convert the template uri, which is of the form
+  // <folder uri>?messageId=<messageId>&subject=<subject>
+  nsCOMPtr<nsIMsgMessageService> msgService;
+  rv = GetMessageServiceFromURI(templateMsgHdrUri, getter_AddRefs(msgService));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISupports> listenerSupports;
+  helper->QueryInterface(NS_GET_IID(nsISupports),
+                         getter_AddRefs(listenerSupports));
+
+  nsCOMPtr<nsIURI> dummyNull;
+  rv = msgService->StreamMessage(
+      templateMsgHdrUri, listenerSupports, aMsgWindow, helper,
+      false,  // convert data
+      EmptyCString(), false, getter_AddRefs(dummyNull));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  aMsgHdr->GetFolder(getter_AddRefs(folder));
+  if (!folder) return NS_ERROR_NULL_POINTER;
+
+  // We're sending a new message. Conceptually it's a reply though, so mark the
+  // original message as replied.
+  return folder->AddMessageDispositionState(
+      aMsgHdr, nsIMsgFolder::nsMsgDispositionState_Replied);
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::ForwardMessage(const nsAString& forwardTo,
+                                    nsIMsgDBHdr* aMsgHdr,
+                                    nsIMsgWindow* aMsgWindow,
+                                    nsIMsgIncomingServer* aServer,
+                                    uint32_t aForwardType) {
+  NS_ENSURE_ARG_POINTER(aMsgHdr);
+
+  nsresult rv;
+  if (aForwardType == nsIMsgComposeService::kForwardAsDefault) {
+    int32_t forwardPref = 0;
+    nsCOMPtr<nsIPrefBranch> prefBranch(
+        do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    prefBranch->GetIntPref("mail.forward_message_mode", &forwardPref);
+    // 0=default as attachment 2=forward as inline with attachments,
+    // (obsolete 4.x value)1=forward as quoted (mapped to 2 in mozilla)
+    aForwardType = forwardPref == 0 ? nsIMsgComposeService::kForwardAsAttachment
+                                    : nsIMsgComposeService::kForwardInline;
+  }
+  nsCString msgUri;
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  aMsgHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_TRUE(folder, NS_ERROR_NULL_POINTER);
+
+  folder->GetUriForMsg(aMsgHdr, msgUri);
+
+  nsAutoCString uriToOpen(msgUri);
+
+  // get the MsgIdentity for the above key using AccountManager
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgAccount> account;
+  nsCOMPtr<nsIMsgIdentity> identity;
+
+  rv = accountManager->FindAccountForServer(aServer, getter_AddRefs(account));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = account->GetDefaultIdentity(getter_AddRefs(identity));
+  // Use default identity if no identity has been found on this account
+  if (NS_FAILED(rv) || !identity) {
+    rv = GetDefaultIdentity(getter_AddRefs(identity));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (aForwardType == nsIMsgComposeService::kForwardInline)
+    return RunMessageThroughMimeDraft(
+        uriToOpen, nsMimeOutput::nsMimeMessageDraftOrTemplate, identity,
+        uriToOpen, aMsgHdr, true, forwardTo, false, aMsgWindow, false);
+
+  nsCOMPtr<mozIDOMWindowProxy> parentWindow;
+  if (aMsgWindow) {
+    nsCOMPtr<nsIDocShell> docShell;
+    rv = aMsgWindow->GetRootDocShell(getter_AddRefs(docShell));
+    NS_ENSURE_SUCCESS(rv, rv);
+    parentWindow = do_GetInterface(docShell);
+    NS_ENSURE_TRUE(parentWindow, NS_ERROR_FAILURE);
+  }
+  // create the compose params object
+  nsCOMPtr<nsIMsgComposeParams> pMsgComposeParams(
+      do_CreateInstance("@mozilla.org/messengercompose/composeparams;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgCompFields> compFields =
+      do_CreateInstance("@mozilla.org/messengercompose/composefields;1", &rv);
+
+  compFields->SetTo(forwardTo);
+  // populate the compose params
+  pMsgComposeParams->SetType(nsIMsgCompType::ForwardAsAttachment);
+  pMsgComposeParams->SetFormat(nsIMsgCompFormat::Default);
+  pMsgComposeParams->SetIdentity(identity);
+  pMsgComposeParams->SetComposeFields(compFields);
+  pMsgComposeParams->SetOriginalMsgURI(uriToOpen);
+  // create the nsIMsgCompose object to send the object
+  nsCOMPtr<nsIMsgCompose> pMsgCompose(
+      do_CreateInstance("@mozilla.org/messengercompose/compose;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  /** initialize nsIMsgCompose, Send the message, wait for send completion
+   * response **/
+  rv = pMsgCompose->Initialize(pMsgComposeParams, parentWindow, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<Promise> promise;
+  rv = pMsgCompose->SendMsg(nsIMsgSend::nsMsgDeliverNow, identity, nullptr,
+                            nullptr, nullptr, getter_AddRefs(promise));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // nsMsgCompose::ProcessReplyFlags usually takes care of marking messages
+  // as forwarded. ProcessReplyFlags is normally called from
+  // nsMsgComposeSendListener::OnStopSending but for this case the msgCompose
+  // object is not set so ProcessReplyFlags won't get called.
+  // Therefore, let's just mark it here instead.
+  return folder->AddMessageDispositionState(
+      aMsgHdr, nsIMsgFolder::nsMsgDispositionState_Forwarded);
+}
+
+nsresult nsMsgComposeService::AddGlobalHtmlDomains() {
+  nsresult rv;
+  nsCOMPtr<nsIPrefService> prefs =
+      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch;
+  rv = prefs->GetBranch(MAILNEWS_ROOT_PREF, getter_AddRefs(prefBranch));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefBranch> defaultsPrefBranch;
+  rv = prefs->GetDefaultBranch(MAILNEWS_ROOT_PREF,
+                               getter_AddRefs(defaultsPrefBranch));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  /**
+   * Check to see if we need to add any global domains.
+   * If so, make sure the following prefs are added to mailnews.js
+   *
+   * 1. pref("mailnews.global_html_domains.version", version number);
+   * This pref registers the current version in the user prefs file. A default
+   * value is stored in mailnews file. Depending the changes we plan to make we
+   * can move the default version number. Comparing version number from user's
+   * prefs file and the default one from mailnews.js, we can effect ppropriate
+   * changes.
+   *
+   * 2. pref("mailnews.global_html_domains", <comma separated domain list>);
+   * This pref contains the list of html domains that ISP can add to make that
+   * user's contain all of these under the HTML domains in the
+   * Mail&NewsGrpus|Send Format under global preferences.
+   */
+  int32_t htmlDomainListCurrentVersion, htmlDomainListDefaultVersion;
+  rv = prefBranch->GetIntPref(HTMLDOMAINUPDATE_VERSION_PREF_NAME,
+                              &htmlDomainListCurrentVersion);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = defaultsPrefBranch->GetIntPref(HTMLDOMAINUPDATE_VERSION_PREF_NAME,
+                                      &htmlDomainListDefaultVersion);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Update the list as needed
+  if (htmlDomainListCurrentVersion <= htmlDomainListDefaultVersion) {
+    // Get list of global domains need to be added
+    nsCString globalHtmlDomainList;
+    rv = prefBranch->GetCharPref(HTMLDOMAINUPDATE_DOMAINLIST_PREF_NAME,
+                                 globalHtmlDomainList);
+
+    if (NS_SUCCEEDED(rv) && !globalHtmlDomainList.IsEmpty()) {
+      nsTArray<nsCString> domainArray;
+
+      // Get user's current HTML domain set for send format
+      nsCString currentHtmlDomainList;
+      rv = prefBranch->GetCharPref(USER_CURRENT_HTMLDOMAINLIST_PREF_NAME,
+                                   currentHtmlDomainList);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsAutoCString newHtmlDomainList(currentHtmlDomainList);
+      // Get the current html domain list into new list var
+      ParseString(currentHtmlDomainList, DOMAIN_DELIMITER, domainArray);
+
+      // Get user's current Plaintext domain set for send format
+      nsCString currentPlaintextDomainList;
+      rv = prefBranch->GetCharPref(USER_CURRENT_PLAINTEXTDOMAINLIST_PREF_NAME,
+                                   currentPlaintextDomainList);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Get the current plaintext domain list into new list var
+      ParseString(currentPlaintextDomainList, DOMAIN_DELIMITER, domainArray);
+
+      size_t i = domainArray.Length();
+      if (i > 0) {
+        // Append each domain in the preconfigured html domain list
+        globalHtmlDomainList.StripWhitespace();
+        ParseString(globalHtmlDomainList, DOMAIN_DELIMITER, domainArray);
+
+        // Now add each domain that does not already appear in
+        // the user's current html or plaintext domain lists
+        for (; i < domainArray.Length(); i++) {
+          if (domainArray.IndexOf(domainArray[i]) == i) {
+            if (!newHtmlDomainList.IsEmpty())
+              newHtmlDomainList += DOMAIN_DELIMITER;
+            newHtmlDomainList += domainArray[i];
+          }
+        }
+      } else {
+        // User has no domains listed either in html or plain text category.
+        // Assign the global list to be the user's current html domain list
+        newHtmlDomainList = globalHtmlDomainList;
+      }
+
+      // Set user's html domain pref with the updated list
+      rv = prefBranch->SetCharPref(USER_CURRENT_HTMLDOMAINLIST_PREF_NAME,
+                                   newHtmlDomainList);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Increase the version to avoid running the update code unless needed
+      // (based on default version)
+      rv = prefBranch->SetIntPref(HTMLDOMAINUPDATE_VERSION_PREF_NAME,
+                                  htmlDomainListCurrentVersion + 1);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::RegisterComposeDocShell(nsIDocShell* aDocShell,
+                                             nsIMsgCompose* aComposeObject) {
+  NS_ENSURE_ARG_POINTER(aDocShell);
+  NS_ENSURE_ARG_POINTER(aComposeObject);
+
+  nsresult rv;
+
+  // add the msg compose / dom window mapping to our hash table
+  nsWeakPtr weakDocShell = do_GetWeakReference(aDocShell, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsWeakPtr weakMsgComposePtr = do_GetWeakReference(aComposeObject);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mOpenComposeWindows.InsertOrUpdate(weakDocShell, weakMsgComposePtr);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::UnregisterComposeDocShell(nsIDocShell* aDocShell) {
+  NS_ENSURE_ARG_POINTER(aDocShell);
+
+  nsresult rv;
+  nsWeakPtr weakDocShell = do_GetWeakReference(aDocShell, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mOpenComposeWindows.Remove(weakDocShell);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::GetMsgComposeForDocShell(nsIDocShell* aDocShell,
+                                              nsIMsgCompose** aComposeObject) {
+  NS_ENSURE_ARG_POINTER(aDocShell);
+  NS_ENSURE_ARG_POINTER(aComposeObject);
+
+  if (!mOpenComposeWindows.Count()) return NS_ERROR_FAILURE;
+
+  // get the weak reference for our dom window
+  nsresult rv;
+  nsWeakPtr weakDocShell = do_GetWeakReference(aDocShell, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsWeakPtr weakMsgComposePtr;
+
+  if (!mOpenComposeWindows.Get(weakDocShell, getter_AddRefs(weakMsgComposePtr)))
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgCompose> msgCompose = do_QueryReferent(weakMsgComposePtr, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_IF_ADDREF(*aComposeObject = msgCompose);
+  return rv;
+}
+
+/**
+ * LoadDraftOrTemplate
+ *   Helper routine used to run msgURI through libmime in order to fetch the
+ * contents for a draft or template.
+ */
+nsresult nsMsgComposeService::LoadDraftOrTemplate(
+    const nsACString& aMsgURI, nsMimeOutputType aOutType,
+    nsIMsgIdentity* aIdentity, const nsACString& aOriginalMsgURI,
+    nsIMsgDBHdr* aOrigMsgHdr, bool aForwardInline, bool overrideComposeFormat,
+    nsIMsgWindow* aMsgWindow, bool autodetectCharset) {
+  return RunMessageThroughMimeDraft(
+      aMsgURI, aOutType, aIdentity, aOriginalMsgURI, aOrigMsgHdr,
+      aForwardInline, EmptyString(), overrideComposeFormat, aMsgWindow,
+      autodetectCharset);
+}
+
+/**
+ * Run the aMsgURI message through libmime. We set various attributes of the
+ * nsIMimeStreamConverter so mimedrft.cpp will know what to do with the message
+ * when its done streaming. Usually that will be opening a compose window
+ * with the contents of the message, but if forwardTo is non-empty, mimedrft.cpp
+ * will forward the contents directly.
+ *
+ * @param aMsgURI URI to stream, which is the msgUri + any extra terms, e.g.,
+ *                "redirect=true".
+ * @param aOutType  nsMimeOutput::nsMimeMessageDraftOrTemplate or
+ *                  nsMimeOutput::nsMimeMessageEditorTemplate
+ * @param aIdentity identity to use for the new message
+ * @param aOriginalMsgURI msgURI w/o any extra terms
+ * @param aOrigMsgHdr nsIMsgDBHdr corresponding to aOriginalMsgURI
+ * @param aForwardInline true if doing a forward inline
+ * @param aForwardTo  e-mail address to forward msg to. This is used for
+ *                     forward inline message filter actions.
+ * @param aOverrideComposeFormat True if the user had shift key down when
+                                 doing a command that opens the compose window,
+ *                               which means we switch the compose window used
+ *                               from the default.
+ * @param aMsgWindow msgWindow to pass into LoadMessage.
+ */
+nsresult nsMsgComposeService::RunMessageThroughMimeDraft(
+    const nsACString& aMsgURI, nsMimeOutputType aOutType,
+    nsIMsgIdentity* aIdentity, const nsACString& aOriginalMsgURI,
+    nsIMsgDBHdr* aOrigMsgHdr, bool aForwardInline, const nsAString& aForwardTo,
+    bool aOverrideComposeFormat, nsIMsgWindow* aMsgWindow,
+    bool autodetectCharset) {
+  nsCOMPtr<nsIMsgMessageService> messageService;
+  nsresult rv =
+      GetMessageServiceFromURI(aMsgURI, getter_AddRefs(messageService));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Create a mime parser (nsIMimeStreamConverter)to do the conversion.
+  nsCOMPtr<nsIMimeStreamConverter> mimeConverter = do_CreateInstance(
+      "@mozilla.org/streamconv;1?from=message/rfc822&to=application/xhtml+xml",
+      &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mimeConverter->SetMimeOutputType(
+      aOutType);  // Set the type of output for libmime
+  mimeConverter->SetForwardInline(aForwardInline);
+  if (!aForwardTo.IsEmpty()) {
+    mimeConverter->SetForwardInlineFilter(true);
+    mimeConverter->SetForwardToAddress(aForwardTo);
+  }
+  mimeConverter->SetOverrideComposeFormat(aOverrideComposeFormat);
+  mimeConverter->SetIdentity(aIdentity);
+  mimeConverter->SetOriginalMsgURI(aOriginalMsgURI);
+  mimeConverter->SetOrigMsgHdr(aOrigMsgHdr);
+
+  nsCOMPtr<nsIURI> url;
+  bool fileUrl = StringBeginsWith(aMsgURI, "file:"_ns);
+  nsCString mailboxUri(aMsgURI);
+  if (fileUrl) {
+    // We loaded a .eml file from a file: url. Construct equivalent mailbox url.
+    mailboxUri.Replace(0, 5, "mailbox:"_ns);
+    mailboxUri.AppendLiteral("&number=0");
+    // Need this to prevent nsMsgCompose::TagEmbeddedObjects from setting
+    // inline images as moz-do-not-send.
+    mimeConverter->SetOriginalMsgURI(mailboxUri);
+  }
+  if (fileUrl || PromiseFlatCString(aMsgURI).Find(
+                     "&type=application/x-message-display") >= 0)
+    rv = NS_NewURI(getter_AddRefs(url), mailboxUri);
+  else
+    rv = messageService->GetUrlForUri(aMsgURI, aMsgWindow, getter_AddRefs(url));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl = do_QueryInterface(url);
+  if (!mailnewsurl) {
+    NS_WARNING(
+        "Trying to run a message through MIME which doesn't have a "
+        "nsIMsgMailNewsUrl?");
+    return NS_ERROR_UNEXPECTED;
+  }
+  // SetSpecInternal must not fail, or else the URL won't have a base URL and
+  // we'll crash later.
+  rv = mailnewsurl->SetSpecInternal(mailboxUri);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // if we are forwarding a message and that message used a charset override
+  // then forward that as auto-detect flag, too.
+  nsCOMPtr<nsIMsgI18NUrl> i18nUrl(do_QueryInterface(url));
+  if (i18nUrl) (void)i18nUrl->SetAutodetectCharset(autodetectCharset);
+
+  nsCOMPtr<nsIPrincipal> nullPrincipal =
+      NullPrincipal::CreateWithoutOriginAttributes();
+
+  nsCOMPtr<nsIChannel> channel;
+  rv = NS_NewInputStreamChannel(
+      getter_AddRefs(channel), url, nullptr, nullPrincipal,
+      nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+      nsIContentPolicy::TYPE_OTHER);
+  NS_ASSERTION(NS_SUCCEEDED(rv), "NS_NewChannel failed.");
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIStreamConverter> converter = do_QueryInterface(mimeConverter);
+  rv = converter->AsyncConvertData(nullptr, nullptr, nullptr, channel);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Now, just plug the two together and get the hell out of the way!
+  nsCOMPtr<nsIStreamListener> streamListener = do_QueryInterface(mimeConverter);
+  return messageService->LoadMessage(aMsgURI, streamListener, aMsgWindow,
+                                     nullptr, autodetectCharset);
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::Handle(nsICommandLine* aCmdLine) {
+  NS_ENSURE_ARG_POINTER(aCmdLine);
+
+  nsresult rv;
+  int32_t found, end, count;
+  nsAutoString uristr;
+  bool composeShouldHandle = true;
+
+  rv = aCmdLine->FindFlag(u"compose"_ns, false, &found);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#ifndef MOZ_SUITE
+  // MAC OS X passes in -url mailto:mscott@mozilla.org into the command line
+  // instead of -compose.
+  if (found == -1) {
+    rv = aCmdLine->FindFlag(u"url"_ns, false, &found);
+    NS_ENSURE_SUCCESS(rv, rv);
+    // we don't want to consume the argument for -url unless we're sure it is a
+    // mailto url and we'll figure that out shortly.
+    composeShouldHandle = false;
+  }
+#endif
+
+  if (found == -1) return NS_OK;
+
+  end = found;
+
+  rv = aCmdLine->GetLength(&count);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (count > found + 1) {
+    aCmdLine->GetArgument(found + 1, uristr);
+    if (StringBeginsWith(uristr, u"mailto:"_ns) ||
+        StringBeginsWith(uristr, u"preselectid="_ns) ||
+        StringBeginsWith(uristr, u"to="_ns) ||
+        StringBeginsWith(uristr, u"cc="_ns) ||
+        StringBeginsWith(uristr, u"bcc="_ns) ||
+        StringBeginsWith(uristr, u"newsgroups="_ns) ||
+        StringBeginsWith(uristr, u"subject="_ns) ||
+        StringBeginsWith(uristr, u"format="_ns) ||
+        StringBeginsWith(uristr, u"body="_ns) ||
+        StringBeginsWith(uristr, u"attachment="_ns) ||
+        StringBeginsWith(uristr, u"message="_ns) ||
+        StringBeginsWith(uristr, u"from="_ns)) {
+      composeShouldHandle = true;  // the -url argument looks like mailto
+      end++;
+      // mailto: URIs are frequently passed with spaces in them. They should be
+      // escaped with %20, but we hack around broken clients. See bug 231032.
+      while (end + 1 < count) {
+        nsAutoString curarg;
+        aCmdLine->GetArgument(end + 1, curarg);
+        if (curarg.First() == '-') break;
+
+        uristr.Append(' ');
+        uristr.Append(curarg);
+        ++end;
+      }
+    } else {
+      uristr.Truncate();
+    }
+  }
+  if (composeShouldHandle) {
+    aCmdLine->RemoveArguments(found, end);
+
+    nsCOMPtr<nsIWindowWatcher> wwatch(
+        do_GetService(NS_WINDOWWATCHER_CONTRACTID));
+    NS_ENSURE_TRUE(wwatch, NS_ERROR_FAILURE);
+
+    nsCOMPtr<nsISupportsString> arg(
+        do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID));
+    if (arg) arg->SetData(uristr);
+
+    nsCOMPtr<nsIMutableArray> params(do_CreateInstance(NS_ARRAY_CONTRACTID));
+    params->AppendElement(arg);
+    params->AppendElement(aCmdLine);
+
+    nsCOMPtr<mozIDOMWindowProxy> opened;
+    wwatch->OpenWindow(nullptr, DEFAULT_CHROME, "_blank"_ns,
+                       "chrome,dialog=no,all"_ns, params,
+                       getter_AddRefs(opened));
+
+    aCmdLine->SetPreventDefault(true);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::GetHelpInfo(nsACString& aResult) {
+  // clang-format off
+  aResult.AssignLiteral(
+    "  -compose [ <options> ] Compose a mail or news message. Options are specified\n"
+    "                     as string \"option='value,...',option=value,...\" and\n"
+    "                     include: from, to, cc, bcc, newsgroups, subject, body,\n"
+    "                     message (file), attachment (file), format (html | text).\n"
+    "                     Example: \"to=john@example.com,subject='Dinner tonight?'\"\n");
+  return NS_OK;
+  // clang-format on
+}
diff --git a/comm/mailnews/compose/src/nsMsgComposeService.h b/comm/mailnews/compose/src/nsMsgComposeService.h
new file mode 100644
index 0000000000..97911fb71f
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgComposeService.h
@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#define MSGCOMP_TRACE_PERFORMANCE 1
+
+#include "nsIMsgComposeService.h"
+#include "nsCOMPtr.h"
+#include "mozIDOMWindow.h"
+#include "nsIAppWindow.h"
+#include "nsIObserver.h"
+#include "nsWeakReference.h"
+#include "nsIWeakReference.h"
+#include "nsIMimeStreamConverter.h"
+#include "nsInterfaceHashtable.h"
+
+#include "nsICommandLineHandler.h"
+#define ICOMMANDLINEHANDLER nsICommandLineHandler
+
+class nsMsgComposeService : public nsIMsgComposeService,
+                            public ICOMMANDLINEHANDLER,
+                            public nsSupportsWeakReference {
+ public:
+  nsMsgComposeService();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGCOMPOSESERVICE
+  NS_DECL_NSICOMMANDLINEHANDLER
+
+  nsresult Init();
+  void Reset();
+  void DeleteCachedWindows();
+  nsresult AddGlobalHtmlDomains();
+
+ private:
+  virtual ~nsMsgComposeService();
+  bool mLogComposePerformance;
+
+  nsresult LoadDraftOrTemplate(
+      const nsACString& aMsgURI, nsMimeOutputType aOutType,
+      nsIMsgIdentity* aIdentity, const nsACString& aOriginalMsgURI,
+      nsIMsgDBHdr* aOrigMsgHdr, bool aForwardInline, bool overrideComposeFormat,
+      nsIMsgWindow* aMsgWindow, bool autodetectCharset);
+
+  nsresult RunMessageThroughMimeDraft(
+      const nsACString& aMsgURI, nsMimeOutputType aOutType,
+      nsIMsgIdentity* aIdentity, const nsACString& aOriginalMsgURI,
+      nsIMsgDBHdr* aOrigMsgHdr, bool aForwardInline, const nsAString& forwardTo,
+      bool overrideComposeFormat, nsIMsgWindow* aMsgWindow,
+      bool autodetectCharset);
+
+  // hash table mapping dom windows to nsIMsgCompose objects
+  nsInterfaceHashtable<nsISupportsHashKey, nsIWeakReference>
+      mOpenComposeWindows;
+
+  // When doing a reply and the settings are enabled, get the HTML of the
+  // selected text in the original message window so that it can be quoted
+  // instead of the entire message.
+  nsresult GetOrigWindowSelection(MSG_ComposeType type,
+                                  mozilla::dom::Selection* selection,
+                                  nsACString& aSelHTML);
+
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+  PRIntervalTime mStartTime;
+  PRIntervalTime mPreviousTime;
+#endif
+};
diff --git a/comm/mailnews/compose/src/nsMsgCopy.cpp b/comm/mailnews/compose/src/nsMsgCopy.cpp
new file mode 100644
index 0000000000..0cccc108f9
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgCopy.cpp
@@ -0,0 +1,471 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsMsgCopy.h"
+
+#include "nsCOMPtr.h"
+#include "nsISupports.h"
+#include "nsIThread.h"
+#include "nscore.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Likely.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/RefCountType.h"
+#include "mozilla/RefPtr.h"
+#include "nsMsgFolderFlags.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIMsgProtocolInfo.h"
+#include "nsISupports.h"
+#include "nsIURL.h"
+#include "nsNetCID.h"
+#include "nsMsgCompUtils.h"
+#include "prcmon.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsThreadUtils.h"
+#include "nsIMsgWindow.h"
+#include "nsIMsgProgress.h"
+#include "nsComposeStrings.h"
+#include "prmem.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "nsIURIMutator.h"
+
+////////////////////////////////////////////////////////////////////////////////////
+// This is the listener class for the copy operation. We have to create this
+// class to listen for message copy completion and eventually notify the caller
+////////////////////////////////////////////////////////////////////////////////////
+NS_IMPL_ISUPPORTS(CopyListener, nsIMsgCopyServiceListener)
+
+CopyListener::CopyListener(void) { mCopyInProgress = false; }
+
+CopyListener::~CopyListener(void) {}
+
+nsresult CopyListener::OnStartCopy() {
+#ifdef NS_DEBUG
+  printf("CopyListener::OnStartCopy()\n");
+#endif
+
+  if (mComposeAndSend) mComposeAndSend->NotifyListenerOnStartCopy();
+  return NS_OK;
+}
+
+nsresult CopyListener::OnProgress(uint32_t aProgress, uint32_t aProgressMax) {
+#ifdef NS_DEBUG
+  printf("CopyListener::OnProgress() %d of %d\n", aProgress, aProgressMax);
+#endif
+
+  if (mComposeAndSend)
+    mComposeAndSend->NotifyListenerOnProgressCopy(aProgress, aProgressMax);
+
+  return NS_OK;
+}
+
+nsresult CopyListener::SetMessageKey(nsMsgKey aMessageKey) {
+  if (mComposeAndSend) mComposeAndSend->SetMessageKey(aMessageKey);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+CopyListener::GetMessageId(nsACString& aMessageId) {
+  if (mComposeAndSend) mComposeAndSend->GetMessageId(aMessageId);
+  return NS_OK;
+}
+
+nsresult CopyListener::OnStopCopy(nsresult aStatus) {
+  if (NS_SUCCEEDED(aStatus)) {
+#ifdef NS_DEBUG
+    printf("CopyListener: SUCCESSFUL ON THE COPY OPERATION!\n");
+#endif
+  } else {
+#ifdef NS_DEBUG
+    printf("CopyListener: COPY OPERATION FAILED!\n");
+#endif
+  }
+
+  if (mCopyInProgress) {
+    PR_CEnterMonitor(this);
+    PR_CNotifyAll(this);
+    mCopyInProgress = false;
+    PR_CExitMonitor(this);
+  }
+  if (mComposeAndSend) mComposeAndSend->NotifyListenerOnStopCopy(aStatus);
+
+  return NS_OK;
+}
+
+nsresult CopyListener::SetMsgComposeAndSendObject(nsIMsgSend* obj) {
+  if (obj) mComposeAndSend = obj;
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// END  END  END  END  END  END  END  END  END  END  END  END  END  END  END
+// This is the listener class for the copy operation. We have to create this
+// class to listen for message copy completion and eventually notify the caller
+////////////////////////////////////////////////////////////////////////////////////
+
+NS_IMPL_ISUPPORTS(nsMsgCopy, nsIMsgCopy, nsIUrlListener)
+
+nsMsgCopy::nsMsgCopy() {
+  mFile = nullptr;
+  mMode = nsIMsgSend::nsMsgDeliverNow;
+  mSavePref = nullptr;
+  mIsDraft = false;
+  mMsgFlags = nsMsgMessageFlags::Read;
+}
+
+nsMsgCopy::~nsMsgCopy() { PR_Free(mSavePref); }
+
+NS_IMETHODIMP
+nsMsgCopy::StartCopyOperation(nsIMsgIdentity* aUserIdentity, nsIFile* aFile,
+                              nsMsgDeliverMode aMode, nsIMsgSend* aMsgSendObj,
+                              const nsACString& aSavePref,
+                              nsIMsgDBHdr* aMsgToReplace) {
+  nsCOMPtr<nsIMsgFolder> dstFolder;
+  bool isDraft = false;
+  uint32_t msgFlags = nsMsgMessageFlags::Read;
+  bool waitForUrl = false;
+  nsresult rv;
+
+  if (!aMsgSendObj) return NS_ERROR_INVALID_ARG;
+
+  // Store away the server location...
+  if (!aSavePref.IsEmpty()) mSavePref = ToNewCString(aSavePref);
+
+  //
+  // Vars for implementation...
+  //
+
+  // QueueForLater (Outbox)
+  if (aMode == nsIMsgSend::nsMsgQueueForLater ||
+      aMode == nsIMsgSend::nsMsgDeliverBackground) {
+    rv = GetUnsentMessagesFolder(aUserIdentity, getter_AddRefs(dstFolder),
+                                 &waitForUrl);
+    isDraft = false;
+    // Do not mark outgoing messages as read.
+    msgFlags = 0;
+    if (!dstFolder || NS_FAILED(rv)) {
+      return NS_MSG_UNABLE_TO_SEND_LATER;
+    }
+  } else if (aMode == nsIMsgSend::nsMsgSaveAsDraft)  // SaveAsDraft (Drafts)
+  {
+    rv = GetDraftsFolder(aUserIdentity, getter_AddRefs(dstFolder), &waitForUrl);
+    isDraft = true;
+    // Do not mark drafts as read.
+    msgFlags = 0;
+    if (!dstFolder || NS_FAILED(rv)) return NS_MSG_UNABLE_TO_SAVE_DRAFT;
+  } else if (aMode ==
+             nsIMsgSend::nsMsgSaveAsTemplate)  // SaveAsTemplate (Templates)
+  {
+    rv = GetTemplatesFolder(aUserIdentity, getter_AddRefs(dstFolder),
+                            &waitForUrl);
+    // Mark saved templates as read.
+    isDraft = false;
+    msgFlags = nsMsgMessageFlags::Read;
+    if (!dstFolder || NS_FAILED(rv)) return NS_MSG_UNABLE_TO_SAVE_TEMPLATE;
+  } else  // SaveInSentFolder (Sent) -  nsMsgDeliverNow or nsMsgSendUnsent
+  {
+    rv = GetSentFolder(aUserIdentity, getter_AddRefs(dstFolder), &waitForUrl);
+    // Mark send messages as read.
+    isDraft = false;
+    msgFlags = nsMsgMessageFlags::Read;
+    if (!dstFolder || NS_FAILED(rv)) return NS_MSG_COULDNT_OPEN_FCC_FOLDER;
+  }
+
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+
+  if (aMsgSendObj) {
+    nsCOMPtr<nsIMsgProgress> progress;
+    aMsgSendObj->GetProgress(getter_AddRefs(progress));
+    if (progress) progress->GetMsgWindow(getter_AddRefs(msgWindow));
+  }
+
+  mMode = aMode;
+  mFile = aFile;
+  mDstFolder = dstFolder;
+  mMsgToReplace = aMsgToReplace;
+  mIsDraft = isDraft;
+  mMsgSendObj = aMsgSendObj;
+  mMsgFlags = msgFlags;
+  if (!waitForUrl) {
+    // cache info needed for DoCopy and call DoCopy when OnStopUrl is called.
+    rv = DoCopy(aFile, dstFolder, aMsgToReplace, isDraft, msgFlags, msgWindow,
+                aMsgSendObj);
+    // N.B. "this" may be deleted when this call returns.
+  }
+  return rv;
+}
+
+nsresult nsMsgCopy::DoCopy(nsIFile* aDiskFile, nsIMsgFolder* dstFolder,
+                           nsIMsgDBHdr* aMsgToReplace, bool aIsDraft,
+                           uint32_t aMsgFlags, nsIMsgWindow* msgWindow,
+                           nsIMsgSend* aMsgSendObj) {
+  nsresult rv = NS_OK;
+
+  // Check sanity
+  if ((!aDiskFile) || (!dstFolder)) return NS_ERROR_INVALID_ARG;
+
+  // Call copyservice with dstFolder, disk file, and txnManager
+  if (NS_SUCCEEDED(rv)) {
+    RefPtr<CopyListener> copyListener = new CopyListener();
+    if (!copyListener) return NS_ERROR_OUT_OF_MEMORY;
+
+    copyListener->SetMsgComposeAndSendObject(aMsgSendObj);
+    nsCOMPtr<nsIThread> thread;
+
+    if (aIsDraft) {
+      nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(dstFolder);
+      nsCOMPtr<nsIMsgAccountManager> accountManager =
+          do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+      if (NS_FAILED(rv)) return rv;
+      bool shutdownInProgress = false;
+      rv = accountManager->GetShutdownInProgress(&shutdownInProgress);
+
+      if (NS_SUCCEEDED(rv) && shutdownInProgress && imapFolder) {
+        // set the following only when we were in the middle of shutdown
+        // process
+        copyListener->mCopyInProgress = true;
+        thread = do_GetCurrentThread();
+      }
+    }
+    nsCOMPtr<nsIMsgCopyService> copyService =
+        do_GetService("@mozilla.org/messenger/messagecopyservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = copyService->CopyFileMessage(aDiskFile, dstFolder, aMsgToReplace,
+                                      aIsDraft, aMsgFlags, EmptyCString(),
+                                      copyListener, msgWindow);
+    // copyListener->mCopyInProgress can only be set when we are in the
+    // middle of the shutdown process
+    while (copyListener->mCopyInProgress) {
+      PR_CEnterMonitor(copyListener);
+      PR_CWait(copyListener, PR_MicrosecondsToInterval(1000UL));
+      PR_CExitMonitor(copyListener);
+      if (thread) NS_ProcessPendingEvents(thread);
+    }
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgCopy::GetDstFolder(nsIMsgFolder** aDstFolder) {
+  NS_ENSURE_ARG_POINTER(aDstFolder);
+  NS_IF_ADDREF(*aDstFolder = mDstFolder);
+  return NS_OK;
+}
+
+// nsIUrlListener methods
+NS_IMETHODIMP
+nsMsgCopy::OnStartRunningUrl(nsIURI* aUrl) { return NS_OK; }
+
+NS_IMETHODIMP
+nsMsgCopy::OnStopRunningUrl(nsIURI* aUrl, nsresult aExitCode) {
+  nsresult rv = aExitCode;
+  if (NS_SUCCEEDED(aExitCode)) {
+    rv = DoCopy(mFile, mDstFolder, mMsgToReplace, mIsDraft, mMsgFlags, nullptr,
+                mMsgSendObj);
+  }
+  return rv;
+}
+
+nsresult nsMsgCopy::GetUnsentMessagesFolder(nsIMsgIdentity* userIdentity,
+                                            nsIMsgFolder** folder,
+                                            bool* waitForUrl) {
+  nsresult ret = LocateMessageFolder(
+      userIdentity, nsIMsgSend::nsMsgQueueForLater, mSavePref, folder);
+  if (*folder) (*folder)->SetFlag(nsMsgFolderFlags::Queue);
+  CreateIfMissing(folder, waitForUrl);
+  return ret;
+}
+
+nsresult nsMsgCopy::GetDraftsFolder(nsIMsgIdentity* userIdentity,
+                                    nsIMsgFolder** folder, bool* waitForUrl) {
+  nsresult ret = LocateMessageFolder(userIdentity, nsIMsgSend::nsMsgSaveAsDraft,
+                                     mSavePref, folder);
+  if (*folder) (*folder)->SetFlag(nsMsgFolderFlags::Drafts);
+  CreateIfMissing(folder, waitForUrl);
+  return ret;
+}
+
+nsresult nsMsgCopy::GetTemplatesFolder(nsIMsgIdentity* userIdentity,
+                                       nsIMsgFolder** folder,
+                                       bool* waitForUrl) {
+  nsresult ret = LocateMessageFolder(
+      userIdentity, nsIMsgSend::nsMsgSaveAsTemplate, mSavePref, folder);
+  if (*folder) (*folder)->SetFlag(nsMsgFolderFlags::Templates);
+  CreateIfMissing(folder, waitForUrl);
+  return ret;
+}
+
+nsresult nsMsgCopy::GetSentFolder(nsIMsgIdentity* userIdentity,
+                                  nsIMsgFolder** folder, bool* waitForUrl) {
+  nsresult ret = LocateMessageFolder(userIdentity, nsIMsgSend::nsMsgDeliverNow,
+                                     mSavePref, folder);
+  if (*folder) {
+    // If mSavePref is the same as the identity's fcc folder, set the sent flag.
+    nsCString identityFccUri;
+    userIdentity->GetFccFolder(identityFccUri);
+    if (identityFccUri.Equals(mSavePref))
+      (*folder)->SetFlag(nsMsgFolderFlags::SentMail);
+  }
+  CreateIfMissing(folder, waitForUrl);
+  return ret;
+}
+
+nsresult nsMsgCopy::CreateIfMissing(nsIMsgFolder** folder, bool* waitForUrl) {
+  nsresult rv = NS_OK;
+  if (folder && *folder) {
+    nsCOMPtr<nsIMsgFolder> parent;
+    (*folder)->GetParent(getter_AddRefs(parent));
+    if (!parent) {
+      nsCOMPtr<nsIFile> folderPath;
+      // for local folders, path is to the berkeley mailbox.
+      // for imap folders, path needs to have .msf appended to the name
+      (*folder)->GetFilePath(getter_AddRefs(folderPath));
+
+      nsCOMPtr<nsIMsgIncomingServer> server;
+      rv = (*folder)->GetServer(getter_AddRefs(server));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIMsgProtocolInfo> protocolInfo;
+      rv = server->GetProtocolInfo(getter_AddRefs(protocolInfo));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      bool isAsyncFolder;
+      rv = protocolInfo->GetFoldersCreatedAsync(&isAsyncFolder);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // if we can't get the path from the folder, then try to create the
+      // storage. for imap, it doesn't matter if the .msf file exists - it still
+      // might not exist on the server, so we should try to create it
+      bool exists = false;
+      if (!isAsyncFolder && folderPath) folderPath->Exists(&exists);
+      if (!exists) {
+        (*folder)->CreateStorageIfMissing(this);
+        if (isAsyncFolder) *waitForUrl = true;
+
+        rv = NS_OK;
+      }
+    }
+  }
+  return rv;
+}
+////////////////////////////////////////////////////////////////////////////////////
+// Utility Functions for MsgFolders
+////////////////////////////////////////////////////////////////////////////////////
+nsresult LocateMessageFolder(nsIMsgIdentity* userIdentity,
+                             nsMsgDeliverMode aFolderType,
+                             const char* aFolderURI, nsIMsgFolder** msgFolder) {
+  nsresult rv = NS_OK;
+
+  if (!msgFolder) return NS_ERROR_NULL_POINTER;
+  *msgFolder = nullptr;
+
+  if (!aFolderURI || !*aFolderURI) return NS_ERROR_INVALID_ARG;
+
+  // as long as it doesn't start with anyfolder://
+  if (PL_strncasecmp(ANY_SERVER, aFolderURI, strlen(aFolderURI)) != 0) {
+    nsCOMPtr<nsIMsgFolder> folder;
+    rv = GetOrCreateFolder(nsDependentCString(aFolderURI),
+                           getter_AddRefs(folder));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // Don't check validity of folder - caller will handle creating it.
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    // make sure that folder hierarchy is built so that legitimate parent-child
+    // relationship is established.
+    rv = folder->GetServer(getter_AddRefs(server));
+    NS_ENSURE_SUCCESS(rv, rv);
+    return server->GetMsgFolderFromURI(folder, nsDependentCString(aFolderURI),
+                                       msgFolder);
+  } else {
+    if (!userIdentity) return NS_ERROR_INVALID_ARG;
+
+    // get the account manager
+    nsCOMPtr<nsIMsgAccountManager> accountManager =
+        do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // If any folder will do, go look for one.
+    nsTArray<RefPtr<nsIMsgIncomingServer>> servers;
+    rv = accountManager->GetServersForIdentity(userIdentity, servers);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Ok, we have to look through the servers and try to find the server that
+    // has a valid folder of the type that interests us...
+    for (auto inServer : servers) {
+      // Now that we have the server...we need to get the named message folder
+
+      // If aFolderURI is passed in, then the user has chosen a specific
+      // mail folder to save the message, but if it is null, just find the
+      // first one and make that work. The folder is specified as a URI, like
+      // the following:
+      //
+      //   mailbox://nobody@Local Folders/Sent
+      //                  imap://rhp@nsmail-2/Drafts
+      //                  newsgroup://news.mozilla.org/netscape.test
+      //
+      nsCString serverURI;
+      rv = inServer->GetServerURI(serverURI);
+      if (NS_FAILED(rv) || serverURI.IsEmpty()) continue;
+
+      nsCOMPtr<nsIMsgFolder> rootFolder;
+      rv = inServer->GetRootFolder(getter_AddRefs(rootFolder));
+
+      if (NS_FAILED(rv) || (!rootFolder)) continue;
+
+      // use the defaults by getting the folder by flags
+      if (aFolderType == nsIMsgSend::nsMsgQueueForLater ||
+          aFolderType == nsIMsgSend::nsMsgDeliverBackground) {
+        // QueueForLater (Outbox)
+        rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Queue, msgFolder);
+      } else if (aFolderType ==
+                 nsIMsgSend::nsMsgSaveAsDraft)  // SaveAsDraft (Drafts)
+      {
+        rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Drafts, msgFolder);
+      } else if (aFolderType ==
+                 nsIMsgSend::nsMsgSaveAsTemplate)  // SaveAsTemplate (Templates)
+      {
+        rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Templates, msgFolder);
+      } else  // SaveInSentFolder (Sent) -  nsMsgDeliverNow or nsMsgSendUnsent
+      {
+        rootFolder->GetFolderWithFlags(nsMsgFolderFlags::SentMail, msgFolder);
+      }
+
+      if (*msgFolder) {
+        return NS_OK;
+      }
+    }
+  }
+  return NS_ERROR_FAILURE;
+}
+
+//
+// Figure out if a folder is local or not and return a boolean to
+// say so.
+//
+nsresult MessageFolderIsLocal(nsIMsgIdentity* userIdentity,
+                              nsMsgDeliverMode aFolderType,
+                              const char* aFolderURI, bool* aResult) {
+  nsresult rv;
+
+  if (!aFolderURI) return NS_ERROR_NULL_POINTER;
+
+  nsCOMPtr<nsIURL> url;
+  rv = NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID)
+           .SetSpec(nsDependentCString(aFolderURI))
+           .Finalize(url);
+  if (NS_FAILED(rv)) return rv;
+
+  /* mailbox:/ means its local (on disk) */
+  rv = url->SchemeIs("mailbox", aResult);
+  if (NS_FAILED(rv)) return rv;
+  return NS_OK;
+}
diff --git a/comm/mailnews/compose/src/nsMsgCopy.h b/comm/mailnews/compose/src/nsMsgCopy.h
new file mode 100644
index 0000000000..4fa50bd8ac
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgCopy.h
@@ -0,0 +1,108 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsMsgCopy_H_
+#define _nsMsgCopy_H_
+
+#include "mozilla/Attributes.h"
+#include "nscore.h"
+#include "nsIFile.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgFolder.h"
+#include "nsITransactionManager.h"
+#include "nsIMsgCopy.h"
+#include "nsIMsgCopyServiceListener.h"
+#include "nsIMsgCopyService.h"
+
+// Forward declarations...
+class nsMsgCopy;
+
+////////////////////////////////////////////////////////////////////////////////////
+// This is the listener class for the copy operation. We have to create this
+// class to listen for message copy completion and eventually notify the caller
+////////////////////////////////////////////////////////////////////////////////////
+class CopyListener : public nsIMsgCopyServiceListener {
+ public:
+  CopyListener(void);
+
+  // nsISupports interface
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  NS_IMETHOD OnStartCopy() override;
+
+  NS_IMETHOD OnProgress(uint32_t aProgress, uint32_t aProgressMax) override;
+
+  NS_IMETHOD SetMessageKey(nsMsgKey aMessageKey) override;
+
+  NS_IMETHOD GetMessageId(nsACString& aMessageId) override;
+
+  NS_IMETHOD OnStopCopy(nsresult aStatus) override;
+
+  NS_IMETHOD SetMsgComposeAndSendObject(nsIMsgSend* obj);
+
+  bool mCopyInProgress;
+
+ private:
+  virtual ~CopyListener();
+  nsCOMPtr<nsIMsgSend> mComposeAndSend;
+};
+
+//
+// This is a class that deals with processing remote attachments. It implements
+// an nsIStreamListener interface to deal with incoming data
+//
+class nsMsgCopy : public nsIMsgCopy, public nsIUrlListener {
+ public:
+  nsMsgCopy();
+
+  // nsISupports interface
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGCOPY
+  NS_DECL_NSIURLLISTENER
+
+  //////////////////////////////////////////////////////////////////////
+  // Object methods...
+  //////////////////////////////////////////////////////////////////////
+  //
+  nsresult DoCopy(nsIFile* aDiskFile, nsIMsgFolder* dstFolder,
+                  nsIMsgDBHdr* aMsgToReplace, bool aIsDraft, uint32_t aMsgFlags,
+                  nsIMsgWindow* msgWindow, nsIMsgSend* aMsgSendObj);
+
+  nsresult GetUnsentMessagesFolder(nsIMsgIdentity* userIdentity,
+                                   nsIMsgFolder** msgFolder, bool* waitForUrl);
+  nsresult GetDraftsFolder(nsIMsgIdentity* userIdentity,
+                           nsIMsgFolder** msgFolder, bool* waitForUrl);
+  nsresult GetTemplatesFolder(nsIMsgIdentity* userIdentity,
+                              nsIMsgFolder** msgFolder, bool* waitForUrl);
+  nsresult GetSentFolder(nsIMsgIdentity* userIdentity, nsIMsgFolder** msgFolder,
+                         bool* waitForUrl);
+  nsresult CreateIfMissing(nsIMsgFolder** folder, bool* waitForUrl);
+
+  //
+  // Vars for implementation...
+  //
+  nsIFile* mFile;  // the file we are sending...
+  nsMsgDeliverMode mMode;
+  nsCOMPtr<nsIMsgFolder> mDstFolder;
+  nsCOMPtr<nsIMsgDBHdr> mMsgToReplace;
+  bool mIsDraft;
+  uint32_t mMsgFlags;
+  nsCOMPtr<nsIMsgSend> mMsgSendObj;
+  char* mSavePref;
+
+ private:
+  virtual ~nsMsgCopy();
+};
+
+// Useful function for the back end...
+nsresult LocateMessageFolder(nsIMsgIdentity* userIdentity,
+                             nsMsgDeliverMode aFolderType, const char* aSaveURI,
+                             nsIMsgFolder** msgFolder);
+
+nsresult MessageFolderIsLocal(nsIMsgIdentity* userIdentity,
+                              nsMsgDeliverMode aFolderType,
+                              const char* aSaveURI, bool* aResult);
+
+#endif /* _nsMsgCopy_H_ */
diff --git a/comm/mailnews/compose/src/nsMsgPrompts.cpp b/comm/mailnews/compose/src/nsMsgPrompts.cpp
new file mode 100644
index 0000000000..ff0f133285
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgPrompts.cpp
@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsMsgPrompts.h"
+
+#include "nsMsgCopy.h"
+#include "nsIPrompt.h"
+#include "nsIWindowWatcher.h"
+#include "nsComposeStrings.h"
+#include "nsIStringBundle.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Components.h"
+#include "nsIPromptService.h"
+#include "nsEmbedCID.h"
+
+nsresult nsMsgGetMessageByName(const char* aName, nsString& aResult) {
+  nsresult rv;
+  nsCOMPtr<nsIStringBundleService> bundleService =
+      mozilla::components::StringBundle::Service();
+  NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+
+  nsCOMPtr<nsIStringBundle> bundle;
+  rv = bundleService->CreateBundle(
+      "chrome://messenger/locale/messengercompose/composeMsgs.properties",
+      getter_AddRefs(bundle));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return bundle->GetStringFromName(aName, aResult);
+}
+
+static nsresult nsMsgBuildMessageByName(const char* aName, nsIFile* aFile,
+                                        nsString& aResult) {
+  NS_ENSURE_ARG_POINTER(aFile);
+  nsresult rv;
+  nsCOMPtr<nsIStringBundleService> bundleService =
+      mozilla::components::StringBundle::Service();
+  NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+
+  nsCOMPtr<nsIStringBundle> bundle;
+  rv = bundleService->CreateBundle(
+      "chrome://messenger/locale/messengercompose/composeMsgs.properties",
+      getter_AddRefs(bundle));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsString path;
+  aFile->GetPath(path);
+
+  AutoTArray<nsString, 1> params = {path};
+  return bundle->FormatStringFromName(aName, params, aResult);
+}
+
+nsresult nsMsgBuildMessageWithFile(nsIFile* aFile, nsString& aResult) {
+  return nsMsgBuildMessageByName("unableToOpenFile", aFile, aResult);
+}
+
+nsresult nsMsgBuildMessageWithTmpFile(nsIFile* aFile, nsString& aResult) {
+  return nsMsgBuildMessageByName("unableToOpenTmpFile", aFile, aResult);
+}
+
+nsresult nsMsgDisplayMessageByName(mozIDOMWindowProxy* window,
+                                   const char* aName,
+                                   const char16_t* windowTitle) {
+  nsString msg;
+  nsMsgGetMessageByName(aName, msg);
+  return nsMsgDisplayMessageByString(window, msg.get(), windowTitle);
+}
+
+nsresult nsMsgDisplayMessageByString(mozIDOMWindowProxy* window,
+                                     const char16_t* msg,
+                                     const char16_t* windowTitle) {
+  NS_ENSURE_ARG_POINTER(msg);
+
+  nsresult rv;
+  nsCOMPtr<nsIPromptService> dlgService(
+      do_GetService(NS_PROMPTSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return dlgService->Alert(window, windowTitle, msg);
+}
+
+nsresult nsMsgAskBooleanQuestionByString(mozIDOMWindowProxy* window,
+                                         const char16_t* msg, bool* answer,
+                                         const char16_t* windowTitle) {
+  NS_ENSURE_TRUE(msg && *msg, NS_ERROR_INVALID_ARG);
+
+  nsresult rv;
+  nsCOMPtr<nsIPromptService> dlgService(
+      do_GetService(NS_PROMPTSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return dlgService->Confirm(window, windowTitle, msg, answer);
+}
diff --git a/comm/mailnews/compose/src/nsMsgPrompts.h b/comm/mailnews/compose/src/nsMsgPrompts.h
new file mode 100644
index 0000000000..300b6ffee2
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgPrompts.h
@@ -0,0 +1,28 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsMsgPrompts_H_
+#define _nsMsgPrompts_H_
+
+#include "nscore.h"
+#include "nsError.h"
+#include "nsString.h"
+
+class mozIDOMWindowProxy;
+
+nsresult nsMsgGetMessageByName(const char* aName, nsString& aResult);
+nsresult nsMsgBuildMessageWithFile(nsIFile* aFile, nsString& aResult);
+nsresult nsMsgBuildMessageWithTmpFile(nsIFile* aFile, nsString& aResult);
+nsresult nsMsgDisplayMessageByName(mozIDOMWindowProxy* window,
+                                   const char* aName,
+                                   const char16_t* windowTitle = nullptr);
+nsresult nsMsgDisplayMessageByString(mozIDOMWindowProxy* window,
+                                     const char16_t* msg,
+                                     const char16_t* windowTitle = nullptr);
+nsresult nsMsgAskBooleanQuestionByString(mozIDOMWindowProxy* window,
+                                         const char16_t* msg, bool* answer,
+                                         const char16_t* windowTitle = nullptr);
+
+#endif /* _nsMsgPrompts_H_ */
diff --git a/comm/mailnews/compose/src/nsMsgQuote.cpp b/comm/mailnews/compose/src/nsMsgQuote.cpp
new file mode 100644
index 0000000000..75efbf67ca
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgQuote.cpp
@@ -0,0 +1,188 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIURL.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsIServiceManager.h"
+#include "nsIStreamListener.h"
+#include "nsIStreamConverter.h"
+#include "nsIStreamConverterService.h"
+#include "nsIMimeStreamConverter.h"
+#include "nsMimeTypes.h"
+#include "nsICharsetConverterManager.h"
+#include "prprf.h"
+#include "nsMsgQuote.h"
+#include "nsMsgCompUtils.h"
+#include "nsIMsgMessageService.h"
+#include "nsMsgUtils.h"
+#include "nsNetUtil.h"
+#include "nsMsgCompose.h"
+#include "nsMsgMailNewsUrl.h"
+#include "mozilla/Components.h"
+#include "nsContentUtils.h"
+
+NS_IMPL_ISUPPORTS(nsMsgQuoteListener, nsIMsgQuoteListener,
+                  nsIMimeStreamConverterListener)
+
+nsMsgQuoteListener::nsMsgQuoteListener() {}
+
+nsMsgQuoteListener::~nsMsgQuoteListener() {}
+
+NS_IMETHODIMP nsMsgQuoteListener::SetMsgQuote(nsIMsgQuote* msgQuote) {
+  mMsgQuote = do_GetWeakReference(msgQuote);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgQuoteListener::GetMsgQuote(nsIMsgQuote** aMsgQuote) {
+  nsresult rv = NS_OK;
+  if (aMsgQuote) {
+    nsCOMPtr<nsIMsgQuote> msgQuote = do_QueryReferent(mMsgQuote);
+    msgQuote.forget(aMsgQuote);
+  } else
+    rv = NS_ERROR_NULL_POINTER;
+
+  return rv;
+}
+
+nsresult nsMsgQuoteListener::OnHeadersReady(nsIMimeHeaders* headers) {
+  nsCOMPtr<nsIMsgQuotingOutputStreamListener> quotingOutputStreamListener;
+  nsCOMPtr<nsIMsgQuote> msgQuote = do_QueryReferent(mMsgQuote);
+
+  if (msgQuote)
+    msgQuote->GetStreamListener(getter_AddRefs(quotingOutputStreamListener));
+
+  if (quotingOutputStreamListener)
+    quotingOutputStreamListener->SetMimeHeaders(headers);
+  return NS_OK;
+}
+
+//
+// Implementation...
+//
+nsMsgQuote::nsMsgQuote() {
+  mQuoteHeaders = false;
+  mQuoteListener = nullptr;
+}
+
+nsMsgQuote::~nsMsgQuote() {}
+
+NS_IMPL_ISUPPORTS(nsMsgQuote, nsIMsgQuote, nsISupportsWeakReference)
+
+NS_IMETHODIMP nsMsgQuote::GetStreamListener(
+    nsIMsgQuotingOutputStreamListener** aStreamListener) {
+  if (!aStreamListener) {
+    return NS_ERROR_NULL_POINTER;
+  }
+  nsCOMPtr<nsIMsgQuotingOutputStreamListener> streamListener =
+      do_QueryReferent(mStreamListener);
+  if (!streamListener) {
+    return NS_ERROR_FAILURE;
+  }
+  NS_IF_ADDREF(*aStreamListener = streamListener);
+  return NS_OK;
+}
+
+nsresult nsMsgQuote::QuoteMessage(
+    const nsACString& msgURI, bool quoteHeaders,
+    nsIMsgQuotingOutputStreamListener* aQuoteMsgStreamListener,
+    bool aAutodetectCharset, bool headersOnly, nsIMsgDBHdr* aMsgHdr) {
+  nsresult rv;
+
+  mQuoteHeaders = quoteHeaders;
+  mStreamListener = do_GetWeakReference(aQuoteMsgStreamListener);
+
+  nsAutoCString msgUri(msgURI);
+  bool fileUrl = StringBeginsWith(msgUri, "file:"_ns);
+  bool forwardedMessage = msgUri.Find("&realtype=message/rfc822") >= 0;
+  nsCOMPtr<nsIURI> newURI;
+  if (fileUrl) {
+    msgUri.Replace(0, 5, "mailbox:"_ns);
+    msgUri.AppendLiteral("?number=0");
+    rv = NS_NewURI(getter_AddRefs(newURI), msgUri);
+  } else if (forwardedMessage)
+    rv = NS_NewURI(getter_AddRefs(newURI), msgURI);
+  else {
+    nsCOMPtr<nsIMsgMessageService> msgService;
+    rv = GetMessageServiceFromURI(msgURI, getter_AddRefs(msgService));
+    if (NS_FAILED(rv)) return rv;
+    rv = msgService->GetUrlForUri(msgURI, nullptr, getter_AddRefs(newURI));
+  }
+  if (NS_FAILED(rv)) return rv;
+
+  nsAutoCString queryPart;
+  rv = newURI->GetQuery(queryPart);
+  if (!queryPart.IsEmpty()) queryPart.Append('&');
+
+  if (headersOnly) /* We don't need to quote the message body but we still need
+                      to extract the headers */
+    queryPart.AppendLiteral("header=only");
+  else if (quoteHeaders)
+    queryPart.AppendLiteral("header=quote");
+  else
+    queryPart.AppendLiteral("header=quotebody");
+  rv = NS_MutateURI(newURI).SetQuery(queryPart).Finalize(newURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // if we were told to auto-detect the charset, pass that on.
+  if (aAutodetectCharset) {
+    nsCOMPtr<nsIMsgI18NUrl> i18nUrl(do_QueryInterface(newURI));
+    if (i18nUrl) i18nUrl->SetAutodetectCharset(true);
+  }
+
+  mQuoteListener =
+      do_CreateInstance("@mozilla.org/messengercompose/quotinglistener;1", &rv);
+  if (NS_FAILED(rv)) return rv;
+  mQuoteListener->SetMsgQuote(this);
+
+  // funky magic go get the isupports for this class which inherits from
+  // multiple interfaces.
+  nsISupports* supports;
+  QueryInterface(NS_GET_IID(nsISupports), (void**)&supports);
+  nsCOMPtr<nsISupports> quoteSupport = supports;
+  NS_IF_RELEASE(supports);
+
+  // now we want to create a necko channel for this url and we want to open it
+  mQuoteChannel = nullptr;
+  nsCOMPtr<nsIIOService> netService = mozilla::components::IO::Service();
+  NS_ENSURE_TRUE(netService, NS_ERROR_UNEXPECTED);
+  rv = netService->NewChannelFromURI(
+      newURI, nullptr, nsContentUtils::GetSystemPrincipal(), nullptr,
+      nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+      nsIContentPolicy::TYPE_OTHER, getter_AddRefs(mQuoteChannel));
+
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIStreamConverterService> streamConverterService =
+      do_GetService("@mozilla.org/streamConverters;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIStreamListener> convertedListener;
+  nsCOMPtr<nsIMsgQuotingOutputStreamListener> streamListener =
+      do_QueryReferent(mStreamListener);
+  rv = streamConverterService->AsyncConvertData(
+      "message/rfc822", "application/xhtml+xml", streamListener, quoteSupport,
+      getter_AddRefs(convertedListener));
+  if (NS_FAILED(rv)) return rv;
+
+  //  now try to open the channel passing in our display consumer as the
+  //  listener
+  rv = mQuoteChannel->AsyncOpen(convertedListener);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgQuote::GetQuoteListener(nsIMimeStreamConverterListener** aQuoteListener) {
+  if (!aQuoteListener || !mQuoteListener) return NS_ERROR_NULL_POINTER;
+  NS_ADDREF(*aQuoteListener = mQuoteListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgQuote::GetQuoteChannel(nsIChannel** aQuoteChannel) {
+  if (!aQuoteChannel || !mQuoteChannel) return NS_ERROR_NULL_POINTER;
+  NS_ADDREF(*aQuoteChannel = mQuoteChannel);
+  return NS_OK;
+}
diff --git a/comm/mailnews/compose/src/nsMsgQuote.h b/comm/mailnews/compose/src/nsMsgQuote.h
new file mode 100644
index 0000000000..27525a6dc1
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgQuote.h
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef __nsMsgQuote_h__
+#define __nsMsgQuote_h__
+
+#include "nsIMsgQuote.h"
+#include "nsIMsgMessageService.h"
+#include "nsIStreamListener.h"
+#include "nsIMimeStreamConverter.h"
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+#include "nsWeakReference.h"
+
+class nsMsgQuote;
+
+class nsMsgQuoteListener : public nsIMsgQuoteListener {
+ public:
+  nsMsgQuoteListener();
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  // nsIMimeStreamConverterListener support
+  NS_DECL_NSIMIMESTREAMCONVERTERLISTENER
+  NS_DECL_NSIMSGQUOTELISTENER
+
+ private:
+  virtual ~nsMsgQuoteListener();
+  nsWeakPtr mMsgQuote;
+};
+
+class nsMsgQuote : public nsIMsgQuote, public nsSupportsWeakReference {
+ public:
+  nsMsgQuote();
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIMSGQUOTE
+
+ private:
+  virtual ~nsMsgQuote();
+  //
+  // Implementation data...
+  //
+  nsWeakPtr mStreamListener;
+  bool mQuoteHeaders;
+  nsCOMPtr<nsIMsgQuoteListener> mQuoteListener;
+  nsCOMPtr<nsIChannel> mQuoteChannel;
+};
+
+#endif /* __nsMsgQuote_h__ */
diff --git a/comm/mailnews/compose/src/nsMsgSendLater.cpp b/comm/mailnews/compose/src/nsMsgSendLater.cpp
new file mode 100644
index 0000000000..8e3b8b0a5d
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgSendLater.cpp
@@ -0,0 +1,1406 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsMsgSendLater.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsMsgCopy.h"
+#include "nsIMsgSend.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIMsgMessageService.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgCompUtils.h"
+#include "nsMsgUtils.h"
+#include "nsMailHeaders.h"
+#include "nsMsgPrompts.h"
+#include "nsISmtpUrl.h"
+#include "nsIChannel.h"
+#include "nsNetUtil.h"
+#include "prlog.h"
+#include "prmem.h"
+#include "nsIMimeConverter.h"
+#include "nsComposeStrings.h"
+#include "nsIObserverService.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgDatabase.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsIMsgWindow.h"
+#include "nsMsgMessageFlags.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/Services.h"
+
+// Consts for checking and sending mail in milliseconds
+
+// 1 second from mail into the unsent messages folder to initially trying to
+// send it.
+const uint32_t kInitialMessageSendTime = 1000;
+
+NS_IMPL_ISUPPORTS(nsMsgSendLater, nsIMsgSendLater, nsIFolderListener,
+                  nsIRequestObserver, nsIStreamListener, nsIObserver,
+                  nsIUrlListener, nsIMsgShutdownTask)
+
+nsMsgSendLater::nsMsgSendLater() {
+  mSendingMessages = false;
+  mTimerSet = false;
+  mTotalSentSuccessfully = 0;
+  mTotalSendCount = 0;
+  mLeftoverBuffer = nullptr;
+
+  m_to = nullptr;
+  m_bcc = nullptr;
+  m_fcc = nullptr;
+  m_newsgroups = nullptr;
+  m_newshost = nullptr;
+  m_headers = nullptr;
+  m_flags = 0;
+  m_headersFP = 0;
+  m_inhead = true;
+  m_headersPosition = 0;
+
+  m_bytesRead = 0;
+  m_position = 0;
+  m_flagsPosition = 0;
+  m_headersSize = 0;
+
+  mIdentityKey = nullptr;
+  mAccountKey = nullptr;
+
+  mUserInitiated = false;
+}
+
+nsMsgSendLater::~nsMsgSendLater() {
+  PR_Free(m_to);
+  PR_Free(m_fcc);
+  PR_Free(m_bcc);
+  PR_Free(m_newsgroups);
+  PR_Free(m_newshost);
+  PR_Free(m_headers);
+  PR_Free(mLeftoverBuffer);
+  PR_Free(mIdentityKey);
+  PR_Free(mAccountKey);
+}
+
+nsresult nsMsgSendLater::Init() {
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool sendInBackground;
+  rv = prefs->GetBoolPref("mailnews.sendInBackground", &sendInBackground);
+  // If we're not sending in the background, don't do anything else
+  if (NS_FAILED(rv) || !sendInBackground) return NS_OK;
+
+  // We need to know when we're shutting down.
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  NS_ENSURE_TRUE(observerService, NS_ERROR_UNEXPECTED);
+
+  rv = observerService->AddObserver(this, "xpcom-shutdown", false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = observerService->AddObserver(this, "quit-application", false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = observerService->AddObserver(this, "msg-shutdown", false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Subscribe to the unsent messages folder
+  // XXX This code should be set up for multiple unsent folders, however we
+  // don't support that at the moment, so for now just assume one folder.
+  nsCOMPtr<nsIMsgFolder> folder;
+  rv = GetUnsentMessagesFolder(nullptr, getter_AddRefs(folder));
+  // There doesn't have to be a nsMsgQueueForLater flagged folder.
+  if (NS_FAILED(rv) || !folder) return NS_OK;
+
+  rv = folder->AddFolderListener(this);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // XXX may want to send messages X seconds after startup if there are any.
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::Observe(nsISupports* aSubject, const char* aTopic,
+                        const char16_t* aData) {
+  if (aSubject == mTimer && !strcmp(aTopic, "timer-callback")) {
+    if (mTimer)
+      mTimer->Cancel();
+    else
+      NS_ERROR("mTimer was null in nsMsgSendLater::Observe");
+
+    mTimerSet = false;
+    // If we've already started a send since the timer fired, don't start
+    // another
+    if (!mSendingMessages) InternalSendMessages(false, nullptr);
+  } else if (!strcmp(aTopic, "quit-application")) {
+    // If the timer is set, cancel it - we're quitting, the shutdown service
+    // interfaces will sort out sending etc.
+    if (mTimer) mTimer->Cancel();
+
+    mTimerSet = false;
+  } else if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
+    // We're shutting down. Unsubscribe from the unsentFolder notifications
+    // they aren't any use to us now, we don't want to start sending more
+    // messages.
+    nsresult rv;
+    if (mMessageFolder) {
+      nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mMessageFolder, &rv);
+      if (folder) {
+        rv = folder->RemoveFolderListener(this);
+        NS_ENSURE_SUCCESS(rv, rv);
+        folder->ForceDBClosed();
+      }
+    }
+
+    // Now remove ourselves from the observer service as well.
+    nsCOMPtr<nsIObserverService> observerService =
+        mozilla::services::GetObserverService();
+    NS_ENSURE_TRUE(observerService, NS_ERROR_UNEXPECTED);
+
+    rv = observerService->RemoveObserver(this, "xpcom-shutdown");
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = observerService->RemoveObserver(this, "quit-application");
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = observerService->RemoveObserver(this, "msg-shutdown");
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::SetStatusFeedback(nsIMsgStatusFeedback* aFeedback) {
+  mFeedback = aFeedback;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::GetStatusFeedback(nsIMsgStatusFeedback** aFeedback) {
+  NS_ENSURE_ARG_POINTER(aFeedback);
+  NS_IF_ADDREF(*aFeedback = mFeedback);
+  return NS_OK;
+}
+
+// Stream is done...drive on!
+NS_IMETHODIMP
+nsMsgSendLater::OnStopRequest(nsIRequest* request, nsresult status) {
+  nsresult rv;
+
+  // First, this shouldn't happen, but if
+  // it does, flush the buffer and move on.
+  if (mLeftoverBuffer) {
+    DeliverQueuedLine(mLeftoverBuffer, PL_strlen(mLeftoverBuffer));
+  }
+
+  if (mOutFile) mOutFile->Close();
+
+  // See if we succeeded on reading the message from the message store?
+  //
+  if (NS_SUCCEEDED(status)) {
+    // Message is done...send it!
+    rv = CompleteMailFileSend();
+
+#ifdef NS_DEBUG
+    printf("nsMsgSendLater: Success on getting message...\n");
+#endif
+
+    // If the send operation failed..try the next one...
+    if (NS_FAILED(rv)) {
+      rv = StartNextMailFileSend(rv);
+      if (NS_FAILED(rv))
+        EndSendMessages(rv, nullptr, mTotalSendCount, mTotalSentSuccessfully);
+    }
+  } else {
+    nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
+    if (!channel) return NS_ERROR_FAILURE;
+
+    // extract the prompt object to use for the alert from the url....
+    nsCOMPtr<nsIURI> uri;
+    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    if (channel) {
+      channel->GetURI(getter_AddRefs(uri));
+      nsCOMPtr<nsIMsgMailNewsUrl> msgUrl(do_QueryInterface(uri));
+      nsCOMPtr<nsIMsgWindow> msgWindow;
+      if (msgUrl) msgUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+      if (msgWindow) msgWindow->GetDomWindow(getter_AddRefs(domWindow));
+    }
+
+    nsMsgDisplayMessageByName(domWindow, "errorQueuedDeliveryFailed");
+
+    // Getting the data failed, but we will still keep trying to send the
+    // rest...
+    rv = StartNextMailFileSend(status);
+    if (NS_FAILED(rv))
+      EndSendMessages(rv, nullptr, mTotalSendCount, mTotalSentSuccessfully);
+  }
+
+  return rv;
+}
+
+char* FindEOL(char* inBuf, char* buf_end) {
+  char* buf = inBuf;
+  char* findLoc = nullptr;
+
+  while (buf <= buf_end)
+    if (*buf == 0)
+      return buf;
+    else if ((*buf == '\n') || (*buf == '\r')) {
+      findLoc = buf;
+      break;
+    } else
+      ++buf;
+
+  if (!findLoc)
+    return nullptr;
+  else if ((findLoc + 1) > buf_end)
+    return buf;
+
+  if ((*findLoc == '\n' && *(findLoc + 1) == '\r') ||
+      (*findLoc == '\r' && *(findLoc + 1) == '\n'))
+    findLoc++;  // possibly a pair.
+  return findLoc;
+}
+
+nsresult nsMsgSendLater::RebufferLeftovers(char* startBuf, uint32_t aLen) {
+  PR_FREEIF(mLeftoverBuffer);
+  mLeftoverBuffer = (char*)PR_Malloc(aLen + 1);
+  if (!mLeftoverBuffer) return NS_ERROR_OUT_OF_MEMORY;
+
+  memcpy(mLeftoverBuffer, startBuf, aLen);
+  mLeftoverBuffer[aLen] = '\0';
+  return NS_OK;
+}
+
+nsresult nsMsgSendLater::BuildNewBuffer(const char* aBuf, uint32_t aCount,
+                                        uint32_t* totalBufSize) {
+  // Only build a buffer when there are leftovers...
+  if (!mLeftoverBuffer) {
+    return NS_ERROR_FAILURE;
+  }
+
+  int32_t leftoverSize = PL_strlen(mLeftoverBuffer);
+  char* newBuffer = (char*)PR_Realloc(mLeftoverBuffer, aCount + leftoverSize);
+  NS_ENSURE_TRUE(newBuffer, NS_ERROR_OUT_OF_MEMORY);
+  mLeftoverBuffer = newBuffer;
+
+  memcpy(mLeftoverBuffer + leftoverSize, aBuf, aCount);
+  *totalBufSize = aCount + leftoverSize;
+  return NS_OK;
+}
+
+// Got data?
+NS_IMETHODIMP
+nsMsgSendLater::OnDataAvailable(nsIRequest* request, nsIInputStream* inStr,
+                                uint64_t sourceOffset, uint32_t count) {
+  NS_ENSURE_ARG_POINTER(inStr);
+
+  // This is a little bit tricky since we have to chop random
+  // buffers into lines and deliver the lines...plus keeping the
+  // leftovers for next time...some fun, eh?
+  //
+  nsresult rv = NS_OK;
+  char* startBuf;
+  char* endBuf;
+  char* lineEnd;
+  char* newbuf = nullptr;
+  uint32_t size;
+
+  uint32_t aCount = count;
+  char* aBuf = (char*)PR_Malloc(aCount + 1);
+
+  inStr->Read(aBuf, count, &aCount);
+
+  // First, create a new work buffer that will
+  if (NS_FAILED(BuildNewBuffer(aBuf, aCount, &size)))  // no leftovers...
+  {
+    startBuf = (char*)aBuf;
+    endBuf = (char*)(aBuf + aCount - 1);
+  } else  // yum, leftovers...new buffer created...sitting in mLeftoverBuffer
+  {
+    newbuf = mLeftoverBuffer;
+    startBuf = newbuf;
+    endBuf = startBuf + size - 1;
+    mLeftoverBuffer = nullptr;  // null out this
+  }
+
+  while (startBuf <= endBuf) {
+    lineEnd = FindEOL(startBuf, endBuf);
+    if (!lineEnd) {
+      rv = RebufferLeftovers(startBuf, (endBuf - startBuf) + 1);
+      break;
+    }
+
+    rv = DeliverQueuedLine(startBuf, (lineEnd - startBuf) + 1);
+    if (NS_FAILED(rv)) break;
+
+    startBuf = lineEnd + 1;
+  }
+
+  PR_Free(newbuf);
+  PR_Free(aBuf);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnStartRunningUrl(nsIURI* url) { return NS_OK; }
+
+NS_IMETHODIMP
+nsMsgSendLater::OnStopRunningUrl(nsIURI* url, nsresult aExitCode) {
+  if (NS_SUCCEEDED(aExitCode)) InternalSendMessages(mUserInitiated, mIdentity);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnStartRequest(nsIRequest* request) { return NS_OK; }
+
+////////////////////////////////////////////////////////////////////////////////////
+// This is the listener class for the send operation. We have to create this
+// class to listen for message send completion and eventually notify the caller
+////////////////////////////////////////////////////////////////////////////////////
+NS_IMPL_ISUPPORTS(SendOperationListener, nsIMsgSendListener,
+                  nsIMsgCopyServiceListener)
+
+SendOperationListener::SendOperationListener(nsMsgSendLater* aSendLater)
+    : mSendLater(aSendLater) {}
+
+SendOperationListener::~SendOperationListener(void) {}
+
+NS_IMETHODIMP
+SendOperationListener::OnGetDraftFolderURI(const char* aMsgID,
+                                           const nsACString& aFolderURI) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnStartSending(const char* aMsgID, uint32_t aMsgSize) {
+#ifdef NS_DEBUG
+  printf("SendOperationListener::OnStartSending()\n");
+#endif
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnProgress(const char* aMsgID, uint32_t aProgress,
+                                  uint32_t aProgressMax) {
+#ifdef NS_DEBUG
+  printf("SendOperationListener::OnProgress()\n");
+#endif
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnStatus(const char* aMsgID, const char16_t* aMsg) {
+#ifdef NS_DEBUG
+  printf("SendOperationListener::OnStatus()\n");
+#endif
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnSendNotPerformed(const char* aMsgID,
+                                          nsresult aStatus) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnStopSending(const char* aMsgID, nsresult aStatus,
+                                     const char16_t* aMsg,
+                                     nsIFile* returnFile) {
+  if (mSendLater && !mSendLater->OnSendStepFinished(aStatus))
+    mSendLater = nullptr;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnTransportSecurityError(
+    const char* msgID, nsresult status, nsITransportSecurityInfo* secInfo,
+    nsACString const& location) {
+  return NS_OK;
+}
+
+// nsIMsgCopyServiceListener
+
+NS_IMETHODIMP
+SendOperationListener::OnStartCopy(void) { return NS_OK; }
+
+NS_IMETHODIMP
+SendOperationListener::OnProgress(uint32_t aProgress, uint32_t aProgressMax) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::SetMessageKey(nsMsgKey aKey) {
+  MOZ_ASSERT_UNREACHABLE("SendOperationListener::SetMessageKey()");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+SendOperationListener::GetMessageId(nsACString& messageId) {
+  MOZ_ASSERT_UNREACHABLE("SendOperationListener::GetMessageId()");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnStopCopy(nsresult aStatus) {
+  if (mSendLater) {
+    mSendLater->OnCopyStepFinished(aStatus);
+    mSendLater = nullptr;
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMsgSendLater::CompleteMailFileSend() {
+  // get the identity from the key
+  // if no key, or we fail to find the identity
+  // use the default identity on the default account
+  nsCOMPtr<nsIMsgIdentity> identity;
+  nsresult rv = GetIdentityFromKey(mIdentityKey, getter_AddRefs(identity));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!identity) return NS_ERROR_UNEXPECTED;
+
+  // If for some reason the tmp file didn't get created, we've failed here
+  bool created;
+  mTempFile->Exists(&created);
+  if (!created) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgCompFields> compFields =
+      do_CreateInstance("@mozilla.org/messengercompose/composefields;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgSend> pMsgSend =
+      do_CreateInstance("@mozilla.org/messengercompose/send;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Since we have already parsed all of the headers, we are simply going to
+  // set the composition fields and move on.
+  nsCString author;
+  mMessage->GetAuthor(getter_Copies(author));
+
+  nsMsgCompFields* fields = (nsMsgCompFields*)compFields.get();
+
+  fields->SetFrom(author.get());
+
+  if (m_to) {
+    fields->SetTo(m_to);
+  }
+
+  if (m_bcc) {
+    fields->SetBcc(m_bcc);
+  }
+
+  if (m_fcc) {
+    fields->SetFcc(m_fcc);
+  }
+
+  if (m_newsgroups) fields->SetNewsgroups(m_newsgroups);
+
+#if 0
+  // needs cleanup. Is this needed?
+  if (m_newshost)
+    fields->SetNewspostUrl(m_newshost);
+#endif
+
+  // Create the listener for the send operation...
+  RefPtr<SendOperationListener> sendListener = new SendOperationListener(this);
+
+  RefPtr<mozilla::dom::Promise> promise;
+  rv = pMsgSend->SendMessageFile(
+      identity, mAccountKey,
+      compFields,                   // nsIMsgCompFields *fields,
+      mTempFile,                    // nsIFile *sendFile,
+      true,                         // bool deleteSendFileOnCompletion,
+      false,                        // bool digest_p,
+      nsIMsgSend::nsMsgSendUnsent,  // nsMsgDeliverMode mode,
+      nullptr,                      // nsIMsgDBHdr *msgToReplace,
+      sendListener, mFeedback, nullptr, getter_AddRefs(promise));
+  return rv;
+}
+
+nsresult nsMsgSendLater::StartNextMailFileSend(nsresult prevStatus) {
+  if (mTotalSendCount >= (uint32_t)mMessagesToSend.Count()) {
+    // Notify that this message has finished being sent.
+    NotifyListenersOnProgress(mTotalSendCount, mMessagesToSend.Count(), 100,
+                              100);
+
+    // EndSendMessages resets everything for us
+    EndSendMessages(prevStatus, nullptr, mTotalSendCount,
+                    mTotalSentSuccessfully);
+
+    // XXX Should we be releasing references so that we don't hold onto items
+    // unnecessarily.
+    return NS_OK;
+  }
+
+  // If we've already sent a message, and are sending more, send out a progress
+  // update with 100% for both send and copy as we must have finished by now.
+  if (mTotalSendCount > 0) {
+    NotifyListenersOnProgress(mTotalSendCount, mMessagesToSend.Count(), 100,
+                              100);
+  }
+
+  mMessage = mMessagesToSend[mTotalSendCount++];
+
+  if (!mMessageFolder) return NS_ERROR_UNEXPECTED;
+
+  nsCString messageURI;
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mMessageFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  folder->GetUriForMsg(mMessage, messageURI);
+
+  rv = nsMsgCreateTempFile("nsqmail.tmp", getter_AddRefs(mTempFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgMessageService> messageService;
+  rv = GetMessageServiceFromURI(messageURI, getter_AddRefs(messageService));
+  if (NS_FAILED(rv) && !messageService) return NS_ERROR_FACTORY_NOT_LOADED;
+
+  nsCString identityKey;
+  rv = mMessage->GetStringProperty(HEADER_X_MOZILLA_IDENTITY_KEY, identityKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgIdentity> identity;
+  rv = GetIdentityFromKey(identityKey.get(), getter_AddRefs(identity));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!identity) return NS_ERROR_UNEXPECTED;
+
+  // Notify that we're just about to start sending this message
+  NotifyListenersOnMessageStartSending(mTotalSendCount, mMessagesToSend.Count(),
+                                       identity);
+
+  // Setup what we need to parse the data stream correctly
+  m_inhead = true;
+  m_headersFP = 0;
+  m_headersPosition = 0;
+  m_bytesRead = 0;
+  m_position = 0;
+  m_flagsPosition = 0;
+  m_headersSize = 0;
+  PR_FREEIF(mLeftoverBuffer);
+
+  // Now, get our stream listener interface and plug it into the LoadMessage
+  // operation
+  rv = messageService->LoadMessage(messageURI,
+                                   static_cast<nsIStreamListener*>(this),
+                                   nullptr, nullptr, false);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::GetUnsentMessagesFolder(nsIMsgIdentity* aIdentity,
+                                        nsIMsgFolder** aFolder) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mMessageFolder);
+  if (!folder) {
+    nsCString uri;
+    GetFolderURIFromUserPrefs(nsIMsgSend::nsMsgQueueForLater, aIdentity, uri);
+    rv = LocateMessageFolder(aIdentity, nsIMsgSend::nsMsgQueueForLater,
+                             uri.get(), getter_AddRefs(folder));
+    mMessageFolder = do_GetWeakReference(folder);
+    if (!mMessageFolder) return NS_ERROR_FAILURE;
+  }
+  if (folder) folder.forget(aFolder);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::HasUnsentMessages(nsIMsgIdentity* aIdentity, bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = false;
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTArray<RefPtr<nsIMsgAccount>> accounts;
+  rv = accountManager->GetAccounts(accounts);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (accounts.IsEmpty())
+    return NS_OK;  // no account set up -> no unsent messages
+
+  // XXX This code should be set up for multiple unsent folders, however we
+  // don't support that at the moment, so for now just assume one folder.
+  if (!mMessageFolder) {
+    nsCOMPtr<nsIMsgFolder> folder;
+    rv = GetUnsentMessagesFolder(nullptr, getter_AddRefs(folder));
+    // There doesn't have to be a nsMsgQueueForLater flagged folder.
+    if (NS_FAILED(rv) || !folder) return NS_OK;
+  }
+  rv = ReparseDBIfNeeded(nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t totalMessages;
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mMessageFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = folder->GetTotalMessages(false, &totalMessages);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aResult = totalMessages > 0;
+  return NS_OK;
+}
+
+//
+// To really finalize this capability, we need to have the ability to get
+// the message from the mail store in a stream for processing. The flow
+// would be something like this:
+//
+//      foreach (message in Outbox folder)
+//         get stream of Nth message
+//         if (not done with headers)
+//            Tack on to current buffer of headers
+//         when done with headers
+//            BuildHeaders()
+//            Write Headers to Temp File
+//         after done with headers
+//            write rest of message body to temp file
+//
+//          when done with the message
+//            do send operation
+//
+//          when send is complete
+//            Copy from Outbox to FCC folder
+//            Delete from Outbox folder
+//
+//
+NS_IMETHODIMP
+nsMsgSendLater::SendUnsentMessages(nsIMsgIdentity* aIdentity) {
+  return InternalSendMessages(true, aIdentity);
+}
+
+// Returns NS_OK if the db is OK, an error otherwise, e.g., we had to reparse.
+nsresult nsMsgSendLater::ReparseDBIfNeeded(nsIUrlListener* aListener) {
+  // This will kick off a reparse, if needed. So the next time we check if
+  // there are unsent messages, the db will be up to date.
+  nsCOMPtr<nsIMsgDatabase> unsentDB;
+  nsresult rv;
+  nsCOMPtr<nsIMsgLocalMailFolder> locFolder(
+      do_QueryReferent(mMessageFolder, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return locFolder->GetDatabaseWithReparse(aListener, nullptr,
+                                           getter_AddRefs(unsentDB));
+}
+
+nsresult nsMsgSendLater::InternalSendMessages(bool aUserInitiated,
+                                              nsIMsgIdentity* aIdentity) {
+  if (WeAreOffline()) return NS_MSG_ERROR_OFFLINE;
+
+  // Protect against being called whilst we're already sending.
+  if (mSendingMessages) {
+    NS_ERROR("nsMsgSendLater is already sending messages");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv;
+
+  // XXX This code should be set up for multiple unsent folders, however we
+  // don't support that at the moment, so for now just assume one folder.
+  if (!mMessageFolder) {
+    nsCOMPtr<nsIMsgFolder> folder;
+    rv = GetUnsentMessagesFolder(nullptr, getter_AddRefs(folder));
+    if (NS_FAILED(rv) || !folder) return NS_ERROR_FAILURE;
+  }
+  nsCOMPtr<nsIMsgDatabase> unsentDB;
+  // Remember these in case we need to reparse the db.
+  mUserInitiated = aUserInitiated;
+  mIdentity = aIdentity;
+  rv = ReparseDBIfNeeded(this);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mIdentity = nullptr;  // don't hold onto the identity since we're a service.
+
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mMessageFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgEnumerator> enumerator;
+  rv = folder->GetMessages(getter_AddRefs(enumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Build mMessagesToSend array.
+  bool hasMoreElements = false;
+  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMoreElements)) &&
+         hasMoreElements) {
+    nsCOMPtr<nsIMsgDBHdr> messageHeader;
+    rv = enumerator->GetNext(getter_AddRefs(messageHeader));
+    if (NS_SUCCEEDED(rv)) {
+      if (aUserInitiated) {
+        // If the user initiated the send, add all messages
+        mMessagesToSend.AppendObject(messageHeader);
+      } else {
+        // Else just send those that are NOT marked as Queued.
+        uint32_t flags;
+        rv = messageHeader->GetFlags(&flags);
+        if (NS_SUCCEEDED(rv) && !(flags & nsMsgMessageFlags::Queued))
+          mMessagesToSend.AppendObject(messageHeader);
+      }
+    }
+  }
+
+  // We're now sending messages so its time to signal that and reset our counts.
+  mSendingMessages = true;
+  mTotalSentSuccessfully = 0;
+  mTotalSendCount = 0;
+
+  // Notify the listeners that we are starting a send.
+  NotifyListenersOnStartSending(mMessagesToSend.Count());
+
+  return StartNextMailFileSend(NS_OK);
+}
+
+nsresult nsMsgSendLater::SetOrigMsgDisposition() {
+  if (!mMessage) return NS_ERROR_NULL_POINTER;
+
+  // We're finished sending a queued message. We need to look at mMessage
+  // and see if we need to set replied/forwarded
+  // flags for the original message that this message might be a reply to
+  // or forward of.
+  nsCString originalMsgURIs;
+  nsCString queuedDisposition;
+  mMessage->GetStringProperty(ORIG_URI_PROPERTY, originalMsgURIs);
+  mMessage->GetStringProperty(QUEUED_DISPOSITION_PROPERTY, queuedDisposition);
+  if (!queuedDisposition.IsEmpty()) {
+    nsTArray<nsCString> uriArray;
+    ParseString(originalMsgURIs, ',', uriArray);
+    for (uint32_t i = 0; i < uriArray.Length(); i++) {
+      nsCOMPtr<nsIMsgDBHdr> msgHdr;
+      nsresult rv = GetMsgDBHdrFromURI(uriArray[i], getter_AddRefs(msgHdr));
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (msgHdr) {
+        // get the folder for the message resource
+        nsCOMPtr<nsIMsgFolder> msgFolder;
+        msgHdr->GetFolder(getter_AddRefs(msgFolder));
+        if (msgFolder) {
+          nsMsgDispositionState dispositionSetting =
+              nsIMsgFolder::nsMsgDispositionState_None;
+          if (queuedDisposition.EqualsLiteral("replied"))
+            dispositionSetting = nsIMsgFolder::nsMsgDispositionState_Replied;
+          else if (queuedDisposition.EqualsLiteral("forwarded"))
+            dispositionSetting = nsIMsgFolder::nsMsgDispositionState_Forwarded;
+          else if (queuedDisposition.EqualsLiteral("redirected"))
+            dispositionSetting = nsIMsgFolder::nsMsgDispositionState_Redirected;
+
+          msgFolder->AddMessageDispositionState(msgHdr, dispositionSetting);
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgSendLater::DeleteCurrentMessage() {
+  if (!mMessage) {
+    NS_ERROR("nsMsgSendLater: Attempt to delete an already deleted message");
+    return NS_OK;
+  }
+
+  // Get the composition fields interface
+  if (!mMessageFolder) return NS_ERROR_UNEXPECTED;
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mMessageFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = folder->DeleteMessages({&*mMessage}, nullptr, true, false, nullptr,
+                              false /*allowUndo*/);
+  if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
+
+  // Null out the message so we don't try and delete it again.
+  mMessage = nullptr;
+
+  return NS_OK;
+}
+
+//
+// This function parses the headers, and also deletes from the header block
+// any headers which should not be delivered in mail, regardless of whether
+// they were present in the queue file.  Such headers include: BCC, FCC,
+// Sender, X-Mozilla-Status, X-Mozilla-News-Host, and Content-Length.
+// (Content-Length is for the disk file only, and must not be allowed to
+// escape onto the network, since it depends on the local linebreak
+// representation.  Arguably, we could allow Lines to escape, but it's not
+// required by NNTP.)
+//
+nsresult nsMsgSendLater::BuildHeaders() {
+  char* buf = m_headers;
+  char* buf_end = buf + m_headersFP;
+
+  PR_FREEIF(m_to);
+  PR_FREEIF(m_bcc);
+  PR_FREEIF(m_newsgroups);
+  PR_FREEIF(m_newshost);
+  PR_FREEIF(m_fcc);
+  PR_FREEIF(mIdentityKey);
+  PR_FREEIF(mAccountKey);
+  m_flags = 0;
+
+  while (buf < buf_end) {
+    bool prune_p = false;
+    bool do_flags_p = false;
+    char* colon = PL_strchr(buf, ':');
+    char* end;
+    char* value = 0;
+    char** header = 0;
+    char* header_start = buf;
+
+    if (!colon) break;
+
+    end = colon;
+    while (end > buf && (*end == ' ' || *end == '\t')) end--;
+
+    switch (buf[0]) {
+      case 'B':
+      case 'b':
+        if (!PL_strncasecmp("BCC", buf, end - buf)) {
+          header = &m_bcc;
+        }
+        break;
+      case 'C':
+      case 'c':
+        if (!PL_strncasecmp("CC", buf, end - buf))
+          header = &m_to;
+        else if (!PL_strncasecmp(HEADER_CONTENT_LENGTH, buf, end - buf))
+          prune_p = true;
+        break;
+      case 'F':
+      case 'f':
+        if (!PL_strncasecmp("FCC", buf, end - buf)) {
+          header = &m_fcc;
+          prune_p = true;
+        }
+        break;
+      case 'L':
+      case 'l':
+        if (!PL_strncasecmp("Lines", buf, end - buf)) prune_p = true;
+        break;
+      case 'N':
+      case 'n':
+        if (!PL_strncasecmp("Newsgroups", buf, end - buf))
+          header = &m_newsgroups;
+        break;
+      case 'S':
+      case 's':
+        if (!PL_strncasecmp("Sender", buf, end - buf)) prune_p = true;
+        break;
+      case 'T':
+      case 't':
+        if (!PL_strncasecmp("To", buf, end - buf)) header = &m_to;
+        break;
+      case 'X':
+      case 'x': {
+        if (buf + strlen(HEADER_X_MOZILLA_STATUS2) == end &&
+            !PL_strncasecmp(HEADER_X_MOZILLA_STATUS2, buf, end - buf))
+          prune_p = true;
+        else if (buf + strlen(HEADER_X_MOZILLA_STATUS) == end &&
+                 !PL_strncasecmp(HEADER_X_MOZILLA_STATUS, buf, end - buf))
+          prune_p = do_flags_p = true;
+        else if (!PL_strncasecmp(HEADER_X_MOZILLA_DRAFT_INFO, buf, end - buf))
+          prune_p = true;
+        else if (!PL_strncasecmp(HEADER_X_MOZILLA_KEYWORDS, buf, end - buf))
+          prune_p = true;
+        else if (!PL_strncasecmp(HEADER_X_MOZILLA_NEWSHOST, buf, end - buf)) {
+          prune_p = true;
+          header = &m_newshost;
+        } else if (!PL_strncasecmp(HEADER_X_MOZILLA_IDENTITY_KEY, buf,
+                                   end - buf)) {
+          prune_p = true;
+          header = &mIdentityKey;
+        } else if (!PL_strncasecmp(HEADER_X_MOZILLA_ACCOUNT_KEY, buf,
+                                   end - buf)) {
+          prune_p = true;
+          header = &mAccountKey;
+        }
+        break;
+      }
+    }
+
+    buf = colon + 1;
+    while (*buf == ' ' || *buf == '\t') buf++;
+
+    value = buf;
+
+  SEARCH_NEWLINE:
+    while (*buf != 0 && *buf != '\r' && *buf != '\n') buf++;
+
+    if (buf + 1 >= buf_end)
+      ;
+    // If "\r\n " or "\r\n\t" is next, that doesn't terminate the header.
+    else if (buf + 2 < buf_end && (buf[0] == '\r' && buf[1] == '\n') &&
+             (buf[2] == ' ' || buf[2] == '\t')) {
+      buf += 3;
+      goto SEARCH_NEWLINE;
+    }
+    // If "\r " or "\r\t" or "\n " or "\n\t" is next, that doesn't terminate
+    // the header either.
+    else if ((buf[0] == '\r' || buf[0] == '\n') &&
+             (buf[1] == ' ' || buf[1] == '\t')) {
+      buf += 2;
+      goto SEARCH_NEWLINE;
+    }
+
+    if (header) {
+      int L = buf - value;
+      if (*header) {
+        char* newh = (char*)PR_Realloc((*header), PL_strlen(*header) + L + 10);
+        if (!newh) return NS_ERROR_OUT_OF_MEMORY;
+        *header = newh;
+        newh = (*header) + PL_strlen(*header);
+        *newh++ = ',';
+        *newh++ = ' ';
+        memcpy(newh, value, L);
+        newh[L] = 0;
+      } else {
+        *header = (char*)PR_Malloc(L + 1);
+        if (!*header) return NS_ERROR_OUT_OF_MEMORY;
+        memcpy((*header), value, L);
+        (*header)[L] = 0;
+      }
+    } else if (do_flags_p) {
+      char* s = value;
+      PR_ASSERT(*s != ' ' && *s != '\t');
+      NS_ASSERTION(MsgIsHex(s, 4), "Expected 4 hex digits for flags.");
+      m_flags = MsgUnhex(s, 4);
+    }
+
+    if (*buf == '\r' || *buf == '\n') {
+      if (*buf == '\r' && buf[1] == '\n') buf++;
+      buf++;
+    }
+
+    if (prune_p) {
+      char* to = header_start;
+      char* from = buf;
+      while (from < buf_end) *to++ = *from++;
+      buf = header_start;
+      buf_end = to;
+      m_headersFP = buf_end - m_headers;
+    }
+  }
+
+  m_headers[m_headersFP++] = '\r';
+  m_headers[m_headersFP++] = '\n';
+
+  // Now we have parsed out all of the headers we need and we
+  // can proceed.
+  return NS_OK;
+}
+
+nsresult DoGrowBuffer(int32_t desired_size, int32_t element_size,
+                      int32_t quantum, char** buffer, int32_t* size) {
+  if (*size <= desired_size) {
+    char* new_buf;
+    int32_t increment = desired_size - *size;
+    if (increment < quantum)  // always grow by a minimum of N bytes
+      increment = quantum;
+
+    new_buf =
+        (*buffer ? (char*)PR_Realloc(*buffer, (*size + increment) *
+                                                  (element_size / sizeof(char)))
+                 : (char*)PR_Malloc((*size + increment) *
+                                    (element_size / sizeof(char))));
+    if (!new_buf) return NS_ERROR_OUT_OF_MEMORY;
+    *buffer = new_buf;
+    *size += increment;
+  }
+  return NS_OK;
+}
+
+#define do_grow_headers(desired_size)                                 \
+  (((desired_size) >= m_headersSize)                                  \
+       ? DoGrowBuffer((desired_size), sizeof(char), 1024, &m_headers, \
+                      &m_headersSize)                                 \
+       : NS_OK)
+
+nsresult nsMsgSendLater::DeliverQueuedLine(const char* line, int32_t length) {
+  int32_t flength = length;
+
+  m_bytesRead += length;
+
+  // convert existing newline to CRLF
+  // Don't need this because the calling routine is taking care of it.
+  //  if (length > 0 && (line[length-1] == '\r' ||
+  //     (line[length-1] == '\n' && (length < 2 || line[length-2] != '\r'))))
+  //  {
+  //    line[length-1] = '\r';
+  //    line[length++] = '\n';
+  //  }
+  //
+  //
+  // We are going to check if we are looking at a "From - " line. If so,
+  // then just eat it and return NS_OK
+  //
+  if (!PL_strncasecmp(line, "From - ", 7)) return NS_OK;
+
+  if (m_inhead) {
+    if (m_headersPosition == 0) {
+      // This line is the first line in a header block.
+      // Remember its position.
+      m_headersPosition = m_position;
+
+      // Also, since we're now processing the headers, clear out the
+      // slots which we will parse data into, so that the values that
+      // were used the last time around do not persist.
+
+      // We must do that here, and not in the previous clause of this
+      // `else' (the "I've just seen a `From ' line clause") because
+      // that clause happens before delivery of the previous message is
+      // complete, whereas this clause happens after the previous msg
+      // has been delivered.  If we did this up there, then only the
+      // last message in the folder would ever be able to be both
+      // mailed and posted (or fcc'ed.)
+      PR_FREEIF(m_to);
+      PR_FREEIF(m_bcc);
+      PR_FREEIF(m_newsgroups);
+      PR_FREEIF(m_newshost);
+      PR_FREEIF(m_fcc);
+      PR_FREEIF(mIdentityKey);
+    }
+
+    if (line[0] == '\r' || line[0] == '\n' || line[0] == 0) {
+      // End of headers.  Now parse them; open the temp file;
+      // and write the appropriate subset of the headers out.
+      m_inhead = false;
+
+      nsresult rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mOutFile),
+                                                   mTempFile, -1, 00600);
+      if (NS_FAILED(rv)) return NS_MSG_ERROR_WRITING_FILE;
+
+      nsresult status = BuildHeaders();
+      if (NS_FAILED(status)) return status;
+
+      uint32_t n;
+      rv = mOutFile->Write(m_headers, m_headersFP, &n);
+      if (NS_FAILED(rv) || n != (uint32_t)m_headersFP)
+        return NS_MSG_ERROR_WRITING_FILE;
+    } else {
+      // Otherwise, this line belongs to a header.  So append it to the
+      // header data.
+
+      if (!PL_strncasecmp(line, HEADER_X_MOZILLA_STATUS,
+                          PL_strlen(HEADER_X_MOZILLA_STATUS)))
+        // Notice the position of the flags.
+        m_flagsPosition = m_position;
+      else if (m_headersFP == 0)
+        m_flagsPosition = 0;
+
+      nsresult status = do_grow_headers(length + m_headersFP + 10);
+      if (NS_FAILED(status)) return status;
+
+      memcpy(m_headers + m_headersFP, line, length);
+      m_headersFP += length;
+    }
+  } else {
+    // This is a body line.  Write it to the file.
+    PR_ASSERT(mOutFile);
+    if (mOutFile) {
+      uint32_t wrote;
+      nsresult rv = mOutFile->Write(line, length, &wrote);
+      if (NS_FAILED(rv) || wrote < (uint32_t)length)
+        return NS_MSG_ERROR_WRITING_FILE;
+    }
+  }
+
+  m_position += flength;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::AddListener(nsIMsgSendLaterListener* aListener) {
+  NS_ENSURE_ARG_POINTER(aListener);
+  mListenerArray.AppendElement(aListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::RemoveListener(nsIMsgSendLaterListener* aListener) {
+  NS_ENSURE_ARG_POINTER(aListener);
+  return mListenerArray.RemoveElement(aListener) ? NS_OK : NS_ERROR_INVALID_ARG;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::GetSendingMessages(bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = mSendingMessages;
+  return NS_OK;
+}
+
+#define NOTIFY_LISTENERS(propertyfunc_, params_)                             \
+  PR_BEGIN_MACRO                                                             \
+  nsTObserverArray<nsCOMPtr<nsIMsgSendLaterListener>>::ForwardIterator iter( \
+      mListenerArray);                                                       \
+  nsCOMPtr<nsIMsgSendLaterListener> listener;                                \
+  while (iter.HasMore()) {                                                   \
+    listener = iter.GetNext();                                               \
+    listener->propertyfunc_ params_;                                         \
+  }                                                                          \
+  PR_END_MACRO
+
+void nsMsgSendLater::NotifyListenersOnStartSending(
+    uint32_t aTotalMessageCount) {
+  NOTIFY_LISTENERS(OnStartSending, (aTotalMessageCount));
+}
+
+void nsMsgSendLater::NotifyListenersOnMessageStartSending(
+    uint32_t aCurrentMessage, uint32_t aTotalMessage,
+    nsIMsgIdentity* aIdentity) {
+  NOTIFY_LISTENERS(OnMessageStartSending,
+                   (aCurrentMessage, aTotalMessage, mMessage, aIdentity));
+}
+
+void nsMsgSendLater::NotifyListenersOnProgress(uint32_t aCurrentMessage,
+                                               uint32_t aTotalMessage,
+                                               uint32_t aSendPercent,
+                                               uint32_t aCopyPercent) {
+  NOTIFY_LISTENERS(OnMessageSendProgress, (aCurrentMessage, aTotalMessage,
+                                           aSendPercent, aCopyPercent));
+}
+
+void nsMsgSendLater::NotifyListenersOnMessageSendError(uint32_t aCurrentMessage,
+                                                       nsresult aStatus,
+                                                       const char16_t* aMsg) {
+  NOTIFY_LISTENERS(OnMessageSendError,
+                   (aCurrentMessage, mMessage, aStatus, aMsg));
+}
+
+/**
+ * This function is called to end sending of messages, it resets the send later
+ * system and notifies the relevant parties that we have finished.
+ */
+void nsMsgSendLater::EndSendMessages(nsresult aStatus, const char16_t* aMsg,
+                                     uint32_t aTotalTried,
+                                     uint32_t aSuccessful) {
+  // Catch-all, we may have had an issue sending, so we may not be calling
+  // StartNextMailFileSend to fully finish the sending. Therefore set
+  // mSendingMessages to false here so that we don't think we're still trying
+  // to send messages
+  mSendingMessages = false;
+
+  // Clear out our array of messages.
+  mMessagesToSend.Clear();
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(mMessageFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, );
+  // We don't need to keep hold of the database now we've finished sending.
+  (void)folder->SetMsgDatabase(nullptr);
+
+  // or temp file or output stream
+  mTempFile = nullptr;
+  mOutFile = nullptr;
+
+  NOTIFY_LISTENERS(OnStopSending, (aStatus, aMsg, aTotalTried, aSuccessful));
+
+  // If we've got a shutdown listener, notify it that we've finished.
+  if (mShutdownListener) {
+    mShutdownListener->OnStopRunningUrl(nullptr, NS_OK);
+    mShutdownListener = nullptr;
+  }
+}
+
+/**
+ * Called when the send part of sending a message is finished. This will set up
+ * for the next step or "end" depending on the status.
+ *
+ * @param aStatus  The success or fail result of the send step.
+ * @return         True if the copy process will continue, false otherwise.
+ */
+bool nsMsgSendLater::OnSendStepFinished(nsresult aStatus) {
+  if (NS_SUCCEEDED(aStatus)) {
+    SetOrigMsgDisposition();
+    DeleteCurrentMessage();
+
+    // Send finished, so that is now 100%, copy to proceed...
+    NotifyListenersOnProgress(mTotalSendCount, mMessagesToSend.Count(), 100, 0);
+
+    ++mTotalSentSuccessfully;
+    return true;
+  } else {
+    // XXX we don't currently get a message string from the send service.
+    NotifyListenersOnMessageSendError(mTotalSendCount, aStatus, nullptr);
+    nsresult rv = StartNextMailFileSend(aStatus);
+    // if this is the last message we're sending, we should report
+    // the status failure.
+    if (NS_FAILED(rv))
+      EndSendMessages(rv, nullptr, mTotalSendCount, mTotalSentSuccessfully);
+  }
+  return false;
+}
+
+/**
+ * Called when the copy part of sending a message is finished. This will send
+ * the next message or handle failure as appropriate.
+ *
+ * @param aStatus  The success or fail result of the copy step.
+ */
+void nsMsgSendLater::OnCopyStepFinished(nsresult aStatus) {
+  // Regardless of the success of the copy we will still keep trying
+  // to send the rest...
+  nsresult rv = StartNextMailFileSend(aStatus);
+  if (NS_FAILED(rv))
+    EndSendMessages(rv, nullptr, mTotalSendCount, mTotalSentSuccessfully);
+}
+
+// XXX todo
+// maybe this should just live in the account manager?
+nsresult nsMsgSendLater::GetIdentityFromKey(const char* aKey,
+                                            nsIMsgIdentity** aIdentity) {
+  NS_ENSURE_ARG_POINTER(aIdentity);
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aKey) {
+    nsTArray<RefPtr<nsIMsgIdentity>> identities;
+    if (NS_SUCCEEDED(accountManager->GetAllIdentities(identities))) {
+      for (auto lookupIdentity : identities) {
+        nsCString key;
+        lookupIdentity->GetKey(key);
+        if (key.Equals(aKey)) {
+          lookupIdentity.forget(aIdentity);
+          return NS_OK;
+        }
+      }
+    }
+  }
+
+  // If no aKey, or we failed to find the identity from the key
+  // use the identity from the default account.
+  nsCOMPtr<nsIMsgAccount> defaultAccount;
+  rv = accountManager->GetDefaultAccount(getter_AddRefs(defaultAccount));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (defaultAccount)
+    rv = defaultAccount->GetDefaultIdentity(aIdentity);
+  else
+    *aIdentity = nullptr;
+
+  return rv;
+}
+
+nsresult nsMsgSendLater::StartTimer() {
+  // No need to trigger if timer is already set
+  if (mTimerSet) return NS_OK;
+
+  // XXX only trigger for non-queued headers
+
+  // Items from this function return NS_OK because the callee won't care about
+  // the result anyway.
+  nsresult rv;
+  if (!mTimer) {
+    mTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
+    NS_ENSURE_SUCCESS(rv, NS_OK);
+  }
+
+  rv = mTimer->Init(static_cast<nsIObserver*>(this), kInitialMessageSendTime,
+                    nsITimer::TYPE_ONE_SHOT);
+  NS_ENSURE_SUCCESS(rv, NS_OK);
+
+  mTimerSet = true;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnFolderAdded(nsIMsgFolder* /*parent*/,
+                              nsIMsgFolder* /*child*/) {
+  return StartTimer();
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnMessageAdded(nsIMsgFolder* /*parent*/, nsIMsgDBHdr* /*msg*/) {
+  return StartTimer();
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnFolderRemoved(nsIMsgFolder* /*parent*/,
+                                nsIMsgFolder* /*child*/) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnMessageRemoved(nsIMsgFolder* /*parent*/,
+                                 nsIMsgDBHdr* /*msg*/) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnFolderPropertyChanged(nsIMsgFolder* aFolder,
+                                        const nsACString& aProperty,
+                                        const nsACString& aOldValue,
+                                        const nsACString& aNewValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnFolderIntPropertyChanged(nsIMsgFolder* aFolder,
+                                           const nsACString& aProperty,
+                                           int64_t aOldValue,
+                                           int64_t aNewValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnFolderBoolPropertyChanged(nsIMsgFolder* aFolder,
+                                            const nsACString& aProperty,
+                                            bool aOldValue, bool aNewValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnFolderUnicharPropertyChanged(nsIMsgFolder* aFolder,
+                                               const nsACString& aProperty,
+                                               const nsAString& aOldValue,
+                                               const nsAString& aNewValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnFolderPropertyFlagChanged(nsIMsgDBHdr* aMsg,
+                                            const nsACString& aProperty,
+                                            uint32_t aOldValue,
+                                            uint32_t aNewValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnFolderEvent(nsIMsgFolder* aFolder, const nsACString& aEvent) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::GetNeedsToRunTask(bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = mSendingMessages;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::DoShutdownTask(nsIUrlListener* aListener, nsIMsgWindow* aWindow,
+                               bool* aResult) {
+  if (mTimer) mTimer->Cancel();
+  // If we're already sending messages, nothing to do, but save the shutdown
+  // listener until we've finished.
+  if (mSendingMessages) {
+    mShutdownListener = aListener;
+    return NS_OK;
+  }
+  // Else we have pending messages, we need to throw up a dialog to find out
+  // if to send them or not.
+
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::GetCurrentTaskName(nsAString& aResult) {
+  // XXX Bug 440794 will localize this, left as non-localized whilst we decide
+  // on the actual strings and try out the UI.
+  aResult = u"Sending Messages"_ns;
+  return NS_OK;
+}
diff --git a/comm/mailnews/compose/src/nsMsgSendLater.h b/comm/mailnews/compose/src/nsMsgSendLater.h
new file mode 100644
index 0000000000..fcd8c53e38
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgSendLater.h
@@ -0,0 +1,142 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsMsgSendLater_H_
+#define _nsMsgSendLater_H_
+
+#include "nsCOMArray.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgSendListener.h"
+#include "nsIMsgSendLaterListener.h"
+#include "nsIMsgSendLater.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsTObserverArray.h"
+#include "nsIObserver.h"
+#include "nsITimer.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgShutdown.h"
+#include "nsIWeakReferenceUtils.h"
+
+////////////////////////////////////////////////////////////////////////////////////
+// This is the listener class for the send operation. We have to create this
+// class to listen for message send completion and eventually notify the caller
+////////////////////////////////////////////////////////////////////////////////////
+class nsMsgSendLater;
+
+class SendOperationListener : public nsIMsgSendListener,
+                              public nsIMsgCopyServiceListener {
+ public:
+  explicit SendOperationListener(nsMsgSendLater* aSendLater);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGSENDLISTENER
+  NS_DECL_NSIMSGCOPYSERVICELISTENER
+
+ private:
+  virtual ~SendOperationListener();
+  RefPtr<nsMsgSendLater> mSendLater;
+};
+
+class nsMsgSendLater : public nsIMsgSendLater,
+                       public nsIFolderListener,
+                       public nsIObserver,
+                       public nsIUrlListener,
+                       public nsIMsgShutdownTask
+
+{
+ public:
+  nsMsgSendLater();
+  nsresult Init();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGSENDLATER
+  NS_DECL_NSIFOLDERLISTENER
+  NS_DECL_NSISTREAMLISTENER
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSIMSGSHUTDOWNTASK
+
+  // Methods needed for implementing interface...
+  nsresult StartNextMailFileSend(nsresult prevStatus);
+  nsresult CompleteMailFileSend();
+
+  nsresult DeleteCurrentMessage();
+  nsresult SetOrigMsgDisposition();
+  // Necessary for creating a valid list of recipients
+  nsresult BuildHeaders();
+  nsresult DeliverQueuedLine(const char* line, int32_t length);
+  nsresult RebufferLeftovers(char* startBuf, uint32_t aLen);
+  nsresult BuildNewBuffer(const char* aBuf, uint32_t aCount,
+                          uint32_t* totalBufSize);
+
+  // methods for listener array processing...
+  void NotifyListenersOnStartSending(uint32_t aTotalMessageCount);
+  void NotifyListenersOnMessageStartSending(uint32_t aCurrentMessage,
+                                            uint32_t aTotalMessage,
+                                            nsIMsgIdentity* aIdentity);
+  void NotifyListenersOnProgress(uint32_t aCurrentMessage,
+                                 uint32_t aTotalMessage, uint32_t aSendPercent,
+                                 uint32_t aCopyPercent);
+  void NotifyListenersOnMessageSendError(uint32_t aCurrentMessage,
+                                         nsresult aStatus,
+                                         const char16_t* aMsg);
+  void EndSendMessages(nsresult aStatus, const char16_t* aMsg,
+                       uint32_t aTotalTried, uint32_t aSuccessful);
+
+  bool OnSendStepFinished(nsresult aStatus);
+  void OnCopyStepFinished(nsresult aStatus);
+
+ private:
+  // counters and things for enumeration
+  uint32_t mTotalSentSuccessfully;
+  uint32_t mTotalSendCount;
+  nsCOMArray<nsIMsgDBHdr> mMessagesToSend;
+  nsWeakPtr mMessageFolder;
+  nsCOMPtr<nsIMsgStatusFeedback> mFeedback;
+
+  virtual ~nsMsgSendLater();
+  nsresult GetIdentityFromKey(const char* aKey, nsIMsgIdentity** aIdentity);
+  nsresult ReparseDBIfNeeded(nsIUrlListener* aListener);
+  nsresult InternalSendMessages(bool aUserInitiated, nsIMsgIdentity* aIdentity);
+  nsresult StartTimer();
+
+  nsTObserverArray<nsCOMPtr<nsIMsgSendLaterListener> > mListenerArray;
+  nsCOMPtr<nsIMsgDBHdr> mMessage;
+  nsCOMPtr<nsITimer> mTimer;
+  bool mTimerSet;
+  nsCOMPtr<nsIUrlListener> mShutdownListener;
+
+  //
+  // File output stuff...
+  //
+  nsCOMPtr<nsIFile> mTempFile;
+  nsCOMPtr<nsIOutputStream> mOutFile;
+
+  // For building headers and stream parsing...
+  char* m_to;
+  char* m_bcc;
+  char* m_fcc;
+  char* m_newsgroups;
+  char* m_newshost;
+  char* m_headers;
+  int32_t m_flags;
+  int32_t m_headersFP;
+  bool m_inhead;
+  int32_t m_headersPosition;
+  int32_t m_bytesRead;
+  int32_t m_position;
+  int32_t m_flagsPosition;
+  int32_t m_headersSize;
+  char* mLeftoverBuffer;
+  char* mIdentityKey;
+  char* mAccountKey;
+
+  bool mSendingMessages;
+  bool mUserInitiated;
+  nsCOMPtr<nsIMsgIdentity> mIdentity;
+};
+
+#endif /* _nsMsgSendLater_H_ */
diff --git a/comm/mailnews/compose/src/nsMsgSendReport.cpp b/comm/mailnews/compose/src/nsMsgSendReport.cpp
new file mode 100644
index 0000000000..5cab724810
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgSendReport.cpp
@@ -0,0 +1,385 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgSendReport.h"
+
+#include "msgCore.h"
+#include "nsIMsgCompose.h"
+#include "nsMsgPrompts.h"
+#include "nsError.h"
+#include "nsComposeStrings.h"
+#include "nsIStringBundle.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Components.h"
+
+NS_IMPL_ISUPPORTS(nsMsgProcessReport, nsIMsgProcessReport)
+
+nsMsgProcessReport::nsMsgProcessReport() { Reset(); }
+
+nsMsgProcessReport::~nsMsgProcessReport() {}
+
+/* attribute boolean proceeded; */
+NS_IMETHODIMP nsMsgProcessReport::GetProceeded(bool* aProceeded) {
+  NS_ENSURE_ARG_POINTER(aProceeded);
+  *aProceeded = mProceeded;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgProcessReport::SetProceeded(bool aProceeded) {
+  mProceeded = aProceeded;
+  return NS_OK;
+}
+
+/* attribute nsresult error; */
+NS_IMETHODIMP nsMsgProcessReport::GetError(nsresult* aError) {
+  NS_ENSURE_ARG_POINTER(aError);
+  *aError = mError;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgProcessReport::SetError(nsresult aError) {
+  mError = aError;
+  return NS_OK;
+}
+
+/* attribute wstring message; */
+NS_IMETHODIMP nsMsgProcessReport::GetMessage(char16_t** aMessage) {
+  NS_ENSURE_ARG_POINTER(aMessage);
+  *aMessage = ToNewUnicode(mMessage);
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgProcessReport::SetMessage(const char16_t* aMessage) {
+  mMessage = aMessage;
+  return NS_OK;
+}
+
+/* void Reset (); */
+NS_IMETHODIMP nsMsgProcessReport::Reset() {
+  mProceeded = false;
+  mError = NS_OK;
+  mMessage.Truncate();
+
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsMsgSendReport, nsIMsgSendReport)
+
+nsMsgSendReport::nsMsgSendReport() {
+  uint32_t i;
+  for (i = 0; i <= SEND_LAST_PROCESS; i++)
+    mProcessReport[i] = new nsMsgProcessReport();
+
+  Reset();
+}
+
+nsMsgSendReport::~nsMsgSendReport() {
+  uint32_t i;
+  for (i = 0; i <= SEND_LAST_PROCESS; i++) mProcessReport[i] = nullptr;
+}
+
+/* attribute long currentProcess; */
+NS_IMETHODIMP nsMsgSendReport::GetCurrentProcess(int32_t* aCurrentProcess) {
+  NS_ENSURE_ARG_POINTER(aCurrentProcess);
+  *aCurrentProcess = mCurrentProcess;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgSendReport::SetCurrentProcess(int32_t aCurrentProcess) {
+  if (aCurrentProcess < 0 || aCurrentProcess > SEND_LAST_PROCESS)
+    return NS_ERROR_ILLEGAL_VALUE;
+
+  mCurrentProcess = aCurrentProcess;
+  if (mProcessReport[mCurrentProcess])
+    mProcessReport[mCurrentProcess]->SetProceeded(true);
+
+  return NS_OK;
+}
+
+/* attribute long deliveryMode; */
+NS_IMETHODIMP nsMsgSendReport::GetDeliveryMode(int32_t* aDeliveryMode) {
+  NS_ENSURE_ARG_POINTER(aDeliveryMode);
+  *aDeliveryMode = mDeliveryMode;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgSendReport::SetDeliveryMode(int32_t aDeliveryMode) {
+  mDeliveryMode = aDeliveryMode;
+  return NS_OK;
+}
+
+/* void Reset (); */
+NS_IMETHODIMP nsMsgSendReport::Reset() {
+  uint32_t i;
+  for (i = 0; i <= SEND_LAST_PROCESS; i++)
+    if (mProcessReport[i]) mProcessReport[i]->Reset();
+
+  mCurrentProcess = 0;
+  mDeliveryMode = 0;
+  mAlreadyDisplayReport = false;
+
+  return NS_OK;
+}
+
+/* void setProceeded (in long process, in boolean proceeded); */
+NS_IMETHODIMP nsMsgSendReport::SetProceeded(int32_t process, bool proceeded) {
+  if (process < process_Current || process > SEND_LAST_PROCESS)
+    return NS_ERROR_ILLEGAL_VALUE;
+
+  if (process == process_Current) process = mCurrentProcess;
+
+  if (!mProcessReport[process]) return NS_ERROR_NOT_INITIALIZED;
+
+  return mProcessReport[process]->SetProceeded(proceeded);
+}
+
+/* void setError (in long process, in nsresult error, in boolean
+ * overwriteError); */
+NS_IMETHODIMP nsMsgSendReport::SetError(int32_t process, nsresult newError,
+                                        bool overwriteError) {
+  if (process < process_Current || process > SEND_LAST_PROCESS)
+    return NS_ERROR_ILLEGAL_VALUE;
+
+  if (process == process_Current) {
+    if (mCurrentProcess == process_Current)
+      // We don't know what we're currently trying to do
+      return NS_ERROR_ILLEGAL_VALUE;
+
+    process = mCurrentProcess;
+  }
+
+  if (!mProcessReport[process]) return NS_ERROR_NOT_INITIALIZED;
+
+  nsresult currError = NS_OK;
+  mProcessReport[process]->GetError(&currError);
+  if (overwriteError || NS_SUCCEEDED(currError))
+    return mProcessReport[process]->SetError(newError);
+  else
+    return NS_OK;
+}
+
+/* void setMessage (in long process, in wstring message, in boolean
+ * overwriteMessage); */
+NS_IMETHODIMP nsMsgSendReport::SetMessage(int32_t process,
+                                          const char16_t* message,
+                                          bool overwriteMessage) {
+  if (process < process_Current || process > SEND_LAST_PROCESS)
+    return NS_ERROR_ILLEGAL_VALUE;
+
+  if (process == process_Current) {
+    if (mCurrentProcess == process_Current)
+      // We don't know what we're currently trying to do
+      return NS_ERROR_ILLEGAL_VALUE;
+
+    process = mCurrentProcess;
+  }
+
+  if (!mProcessReport[process]) return NS_ERROR_NOT_INITIALIZED;
+
+  nsString currMessage;
+  mProcessReport[process]->GetMessage(getter_Copies(currMessage));
+  if (overwriteMessage || currMessage.IsEmpty())
+    return mProcessReport[process]->SetMessage(message);
+  else
+    return NS_OK;
+}
+
+/* nsIMsgProcessReport getProcessReport (in long process); */
+NS_IMETHODIMP nsMsgSendReport::GetProcessReport(int32_t process,
+                                                nsIMsgProcessReport** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  if (process < process_Current || process > SEND_LAST_PROCESS)
+    return NS_ERROR_ILLEGAL_VALUE;
+
+  if (process == process_Current) {
+    if (mCurrentProcess == process_Current)
+      // We don't know what we're currently trying to do
+      return NS_ERROR_ILLEGAL_VALUE;
+
+    process = mCurrentProcess;
+  }
+
+  NS_IF_ADDREF(*_retval = mProcessReport[process]);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgSendReport::DisplayReport(mozIDOMWindowProxy* window,
+                                             bool showErrorOnly,
+                                             bool dontShowReportTwice,
+                                             nsresult* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  NS_ENSURE_TRUE(mCurrentProcess >= 0 && mCurrentProcess <= SEND_LAST_PROCESS,
+                 NS_ERROR_NOT_INITIALIZED);
+
+  nsresult currError = NS_OK;
+  mProcessReport[mCurrentProcess]->GetError(&currError);
+  *_retval = currError;
+
+  if (dontShowReportTwice && mAlreadyDisplayReport) return NS_OK;
+
+  if (showErrorOnly && NS_SUCCEEDED(currError)) return NS_OK;
+
+  nsString currMessage;
+  mProcessReport[mCurrentProcess]->GetMessage(getter_Copies(currMessage));
+
+  nsresult rv;  // don't step on currError.
+  nsCOMPtr<nsIStringBundleService> bundleService =
+      mozilla::components::StringBundle::Service();
+  NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+  nsCOMPtr<nsIStringBundle> bundle;
+  rv = bundleService->CreateBundle(
+      "chrome://messenger/locale/messengercompose/composeMsgs.properties",
+      getter_AddRefs(bundle));
+  if (NS_FAILED(rv)) {
+    // TODO need to display a generic hardcoded message
+    mAlreadyDisplayReport = true;
+    return NS_OK;
+  }
+
+  nsString dialogTitle;
+  nsString dialogMessage;
+
+  if (NS_SUCCEEDED(currError)) {
+    // TODO display a success error message
+    return NS_OK;
+  }
+
+  // Do we have an explanation of the error? if no, try to build one...
+  if (currMessage.IsEmpty()) {
+#ifdef __GNUC__
+// Temporary workaround until bug 783526 is fixed.
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wswitch"
+#endif
+    switch (currError) {
+      case NS_BINDING_ABORTED:
+      case NS_MSG_UNABLE_TO_SEND_LATER:
+      case NS_MSG_UNABLE_TO_SAVE_DRAFT:
+      case NS_MSG_UNABLE_TO_SAVE_TEMPLATE:
+        // Ignore, don't need to repeat ourself.
+        break;
+      default:
+        const char* errorString = errorStringNameForErrorCode(currError);
+        nsMsgGetMessageByName(errorString, currMessage);
+        break;
+    }
+#ifdef __GNUC__
+#  pragma GCC diagnostic pop
+#endif
+  }
+
+  if (mDeliveryMode == nsIMsgCompDeliverMode::Now ||
+      mDeliveryMode == nsIMsgCompDeliverMode::SendUnsent) {
+    // SMTP is taking care of it's own error message and will return
+    // NS_ERROR_BUT_DONT_SHOW_ALERT as error code. In that case, we must not
+    // show an alert ourself.
+    if (currError == NS_ERROR_BUT_DONT_SHOW_ALERT) {
+      mAlreadyDisplayReport = true;
+      return NS_OK;
+    }
+
+    bundle->GetStringFromName("sendMessageErrorTitle", dialogTitle);
+
+    const char* preStrName = "sendFailed";
+    bool askToGoBackToCompose = false;
+    switch (mCurrentProcess) {
+      case process_BuildMessage:
+        preStrName = "sendFailed";
+        askToGoBackToCompose = false;
+        break;
+      case process_NNTP:
+        preStrName = "sendFailed";
+        askToGoBackToCompose = false;
+        break;
+      case process_SMTP:
+        bool nntpProceeded;
+        mProcessReport[process_NNTP]->GetProceeded(&nntpProceeded);
+        if (nntpProceeded)
+          preStrName = "sendFailedButNntpOk";
+        else
+          preStrName = "sendFailed";
+        askToGoBackToCompose = false;
+        break;
+      case process_Copy:
+        preStrName = "failedCopyOperation";
+        askToGoBackToCompose = (mDeliveryMode == nsIMsgCompDeliverMode::Now);
+        break;
+      case process_FCC:
+        preStrName = "failedCopyOperation";
+        askToGoBackToCompose = (mDeliveryMode == nsIMsgCompDeliverMode::Now);
+        break;
+    }
+    bundle->GetStringFromName(preStrName, dialogMessage);
+
+    // Do we already have an error message?
+    if (!askToGoBackToCompose && currMessage.IsEmpty()) {
+      // we don't have an error description but we can put a generic explanation
+      bundle->GetStringFromName("genericFailureExplanation", currMessage);
+    }
+
+    if (!currMessage.IsEmpty()) {
+      // Don't need to repeat ourself!
+      if (!currMessage.Equals(dialogMessage)) {
+        if (!dialogMessage.IsEmpty()) dialogMessage.Append(char16_t('\n'));
+        dialogMessage.Append(currMessage);
+      }
+    }
+
+    if (askToGoBackToCompose) {
+      bool oopsGiveMeBackTheComposeWindow = true;
+      nsString text1;
+      bundle->GetStringFromName("returnToComposeWindowQuestion", text1);
+      if (!dialogMessage.IsEmpty()) dialogMessage.AppendLiteral("\n");
+      dialogMessage.Append(text1);
+      nsMsgAskBooleanQuestionByString(window, dialogMessage.get(),
+                                      &oopsGiveMeBackTheComposeWindow,
+                                      dialogTitle.get());
+      if (!oopsGiveMeBackTheComposeWindow) *_retval = NS_OK;
+    } else
+      nsMsgDisplayMessageByString(window, dialogMessage.get(),
+                                  dialogTitle.get());
+  } else {
+    const char* title;
+    const char* messageName;
+
+    switch (mDeliveryMode) {
+      case nsIMsgCompDeliverMode::Later:
+        title = "sendLaterErrorTitle";
+        messageName = "unableToSendLater";
+        break;
+
+      case nsIMsgCompDeliverMode::AutoSaveAsDraft:
+      case nsIMsgCompDeliverMode::SaveAsDraft:
+        title = "saveDraftErrorTitle";
+        messageName = "unableToSaveDraft";
+        break;
+
+      case nsIMsgCompDeliverMode::SaveAsTemplate:
+        title = "saveTemplateErrorTitle";
+        messageName = "unableToSaveTemplate";
+        break;
+
+      default:
+        /* This should never happen! */
+        title = "sendMessageErrorTitle";
+        messageName = "sendFailed";
+        break;
+    }
+
+    bundle->GetStringFromName(title, dialogTitle);
+    bundle->GetStringFromName(messageName, dialogMessage);
+
+    // Do we have an error message...
+    if (currMessage.IsEmpty()) {
+      // we don't have an error description but we can put a generic explanation
+      bundle->GetStringFromName("genericFailureExplanation", currMessage);
+    }
+
+    if (!currMessage.IsEmpty()) {
+      if (!dialogMessage.IsEmpty()) dialogMessage.Append(char16_t('\n'));
+      dialogMessage.Append(currMessage);
+    }
+    nsMsgDisplayMessageByString(window, dialogMessage.get(), dialogTitle.get());
+  }
+
+  mAlreadyDisplayReport = true;
+  return NS_OK;
+}
diff --git a/comm/mailnews/compose/src/nsMsgSendReport.h b/comm/mailnews/compose/src/nsMsgSendReport.h
new file mode 100644
index 0000000000..0fcc2f1c9f
--- /dev/null
+++ b/comm/mailnews/compose/src/nsMsgSendReport.h
@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsMsgSendReport_h__
+#define __nsMsgSendReport_h__
+
+#include "nsIMsgSendReport.h"
+#include "nsString.h"
+#include "nsCOMPtr.h"
+
+class nsMsgProcessReport : public nsIMsgProcessReport {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGPROCESSREPORT
+
+  nsMsgProcessReport();
+
+ private:
+  virtual ~nsMsgProcessReport();
+  bool mProceeded;
+  nsresult mError;
+  nsString mMessage;
+};
+
+class nsMsgSendReport : public nsIMsgSendReport {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGSENDREPORT
+
+  nsMsgSendReport();
+
+ protected:
+  virtual ~nsMsgSendReport();
+
+ private:
+#define SEND_LAST_PROCESS process_FCC
+  nsCOMPtr<nsIMsgProcessReport> mProcessReport[SEND_LAST_PROCESS + 1];
+  int32_t mDeliveryMode;
+  int32_t mCurrentProcess;
+  bool mAlreadyDisplayReport;
+};
+
+#endif
diff --git a/comm/mailnews/compose/src/nsSmtpUrl.cpp b/comm/mailnews/compose/src/nsSmtpUrl.cpp
new file mode 100644
index 0000000000..b9ac451650
--- /dev/null
+++ b/comm/mailnews/compose/src/nsSmtpUrl.cpp
@@ -0,0 +1,755 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"
+
+#include "nsIURI.h"
+#include "nsNetCID.h"
+#include "nsSmtpUrl.h"
+#include "nsString.h"
+#include "nsMsgUtils.h"
+#include "nsIMimeConverter.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsCRT.h"
+#include "mozilla/Encoding.h"
+
+/////////////////////////////////////////////////////////////////////////////////////
+// mailto url definition
+/////////////////////////////////////////////////////////////////////////////////////
+nsMailtoUrl::nsMailtoUrl() { mFormat = nsIMsgCompFormat::Default; }
+
+nsMailtoUrl::~nsMailtoUrl() {}
+
+NS_IMPL_ISUPPORTS(nsMailtoUrl, nsIMailtoUrl, nsIURI)
+
+static void UnescapeAndConvert(nsIMimeConverter* mimeConverter,
+                               const nsACString& escaped, nsACString& out) {
+  NS_ASSERTION(mimeConverter, "Set mimeConverter before calling!");
+  // If the string is empty, do absolutely nothing.
+  if (escaped.IsEmpty()) return;
+
+  MsgUnescapeString(escaped, 0, out);
+  nsAutoCString decodedString;
+  nsresult rv = mimeConverter->DecodeMimeHeaderToUTF8(out, "UTF_8", false, true,
+                                                      decodedString);
+  if (NS_SUCCEEDED(rv) && !decodedString.IsEmpty()) out = decodedString;
+}
+
+nsresult nsMailtoUrl::ParseMailtoUrl(char* searchPart) {
+  char* rest = searchPart;
+  nsCString escapedInReplyToPart;
+  nsCString escapedToPart;
+  nsCString escapedCcPart;
+  nsCString escapedSubjectPart;
+  nsCString escapedNewsgroupPart;
+  nsCString escapedNewsHostPart;
+  nsCString escapedReferencePart;
+  nsCString escapedBodyPart;
+  nsCString escapedBccPart;
+  nsCString escapedFollowUpToPart;
+  nsCString escapedFromPart;
+  nsCString escapedHtmlPart;
+  nsCString escapedOrganizationPart;
+  nsCString escapedReplyToPart;
+  nsCString escapedPriorityPart;
+
+  // okay, first, free up all of our old search part state.....
+  CleanupMailtoState();
+  // m_toPart has the escaped address from before the query string, copy it
+  // over so we can add on any additional to= addresses and unescape them all.
+  escapedToPart = m_toPart;
+
+  if (rest && *rest == '?') {
+    /* start past the '?' */
+    rest++;
+  }
+
+  if (rest) {
+    char* token = NS_strtok("&", &rest);
+    while (token && *token) {
+      char* value = 0;
+      char* eq = PL_strchr(token, '=');
+      if (eq) {
+        value = eq + 1;
+        *eq = 0;
+      }
+
+      nsCString decodedName;
+      MsgUnescapeString(nsDependentCString(token), 0, decodedName);
+
+      if (decodedName.IsEmpty()) break;
+
+      switch (NS_ToUpper(decodedName.First())) {
+          /* DO NOT support attachment= in mailto urls. This poses a security
+             fire hole!!! case 'A': if (!PL_strcasecmp (token, "attachment"))
+                            m_attachmentPart = value;
+                            break;
+                       */
+        case 'B':
+          if (decodedName.LowerCaseEqualsLiteral("bcc")) {
+            if (!escapedBccPart.IsEmpty()) {
+              escapedBccPart += ", ";
+              escapedBccPart += value;
+            } else
+              escapedBccPart = value;
+          } else if (decodedName.LowerCaseEqualsLiteral("body")) {
+            if (!escapedBodyPart.IsEmpty()) {
+              escapedBodyPart += "\n";
+              escapedBodyPart += value;
+            } else
+              escapedBodyPart = value;
+          }
+          break;
+        case 'C':
+          if (decodedName.LowerCaseEqualsLiteral("cc")) {
+            if (!escapedCcPart.IsEmpty()) {
+              escapedCcPart += ", ";
+              escapedCcPart += value;
+            } else
+              escapedCcPart = value;
+          }
+          break;
+        case 'F':
+          if (decodedName.LowerCaseEqualsLiteral("followup-to"))
+            escapedFollowUpToPart = value;
+          else if (decodedName.LowerCaseEqualsLiteral("from"))
+            escapedFromPart = value;
+          break;
+        case 'H':
+          if (decodedName.LowerCaseEqualsLiteral("html-part") ||
+              decodedName.LowerCaseEqualsLiteral("html-body")) {
+            // escapedHtmlPart holds the body for both html-part and html-body.
+            escapedHtmlPart = value;
+            mFormat = nsIMsgCompFormat::HTML;
+          }
+          break;
+        case 'I':
+          if (decodedName.LowerCaseEqualsLiteral("in-reply-to"))
+            escapedInReplyToPart = value;
+          break;
+
+        case 'N':
+          if (decodedName.LowerCaseEqualsLiteral("newsgroups"))
+            escapedNewsgroupPart = value;
+          else if (decodedName.LowerCaseEqualsLiteral("newshost"))
+            escapedNewsHostPart = value;
+          break;
+        case 'O':
+          if (decodedName.LowerCaseEqualsLiteral("organization"))
+            escapedOrganizationPart = value;
+          break;
+        case 'R':
+          if (decodedName.LowerCaseEqualsLiteral("references"))
+            escapedReferencePart = value;
+          else if (decodedName.LowerCaseEqualsLiteral("reply-to"))
+            escapedReplyToPart = value;
+          break;
+        case 'S':
+          if (decodedName.LowerCaseEqualsLiteral("subject"))
+            escapedSubjectPart = value;
+          break;
+        case 'P':
+          if (decodedName.LowerCaseEqualsLiteral("priority"))
+            escapedPriorityPart = PL_strdup(value);
+          break;
+        case 'T':
+          if (decodedName.LowerCaseEqualsLiteral("to")) {
+            if (!escapedToPart.IsEmpty()) {
+              escapedToPart += ", ";
+              escapedToPart += value;
+            } else
+              escapedToPart = value;
+          }
+          break;
+        default:
+          break;
+      }  // end of switch statement...
+
+      if (eq) *eq = '='; /* put it back */
+      token = NS_strtok("&", &rest);
+    }  // while we still have part of the url to parse...
+  }    // if rest && *rest
+
+  nsresult rv;
+  // Get a global converter
+  nsCOMPtr<nsIMimeConverter> mimeConverter =
+      do_GetService("@mozilla.org/messenger/mimeconverter;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Now unescape everything, and mime-decode the things that can be encoded.
+  UnescapeAndConvert(mimeConverter, escapedToPart, m_toPart);
+  UnescapeAndConvert(mimeConverter, escapedCcPart, m_ccPart);
+  UnescapeAndConvert(mimeConverter, escapedBccPart, m_bccPart);
+  UnescapeAndConvert(mimeConverter, escapedSubjectPart, m_subjectPart);
+  UnescapeAndConvert(mimeConverter, escapedNewsgroupPart, m_newsgroupPart);
+  UnescapeAndConvert(mimeConverter, escapedReferencePart, m_referencePart);
+  if (!escapedBodyPart.IsEmpty())
+    MsgUnescapeString(escapedBodyPart, 0, m_bodyPart);
+  if (!escapedHtmlPart.IsEmpty())
+    MsgUnescapeString(escapedHtmlPart, 0, m_htmlPart);
+  UnescapeAndConvert(mimeConverter, escapedNewsHostPart, m_newsHostPart);
+  UnescapeAndConvert(mimeConverter, escapedFollowUpToPart, m_followUpToPart);
+  UnescapeAndConvert(mimeConverter, escapedFromPart, m_fromPart);
+  UnescapeAndConvert(mimeConverter, escapedOrganizationPart,
+                     m_organizationPart);
+  UnescapeAndConvert(mimeConverter, escapedReplyToPart, m_replyToPart);
+  UnescapeAndConvert(mimeConverter, escapedPriorityPart, m_priorityPart);
+
+  nsCString inReplyToPart;  // Not a member like the others...
+  UnescapeAndConvert(mimeConverter, escapedInReplyToPart, inReplyToPart);
+
+  if (!inReplyToPart.IsEmpty()) {
+    // Ensure that References and In-Reply-To are consistent... The last
+    // reference will be used as In-Reply-To header.
+    if (m_referencePart.IsEmpty()) {
+      // If References is not set, set it to be the In-Reply-To.
+      m_referencePart = inReplyToPart;
+    } else {
+      // References is set. Add the In-Reply-To as last header unless it's
+      // set as last reference already.
+      int32_t lastRefStart = m_referencePart.RFindChar('<');
+      nsAutoCString lastReference;
+      if (lastRefStart != -1)
+        lastReference = StringTail(m_referencePart, lastRefStart);
+      else
+        lastReference = m_referencePart;
+
+      if (lastReference != inReplyToPart) {
+        m_referencePart += " ";
+        m_referencePart += inReplyToPart;
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMailtoUrl::SetSpecInternal(const nsACString& aSpec) {
+  nsresult rv = NS_MutateURI(NS_SIMPLEURIMUTATOR_CONTRACTID)
+                    .SetSpec(aSpec)
+                    .Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+nsresult nsMailtoUrl::CleanupMailtoState() {
+  m_ccPart = "";
+  m_subjectPart = "";
+  m_newsgroupPart = "";
+  m_newsHostPart = "";
+  m_referencePart = "";
+  m_bodyPart = "";
+  m_bccPart = "";
+  m_followUpToPart = "";
+  m_fromPart = "";
+  m_htmlPart = "";
+  m_organizationPart = "";
+  m_replyToPart = "";
+  m_priorityPart = "";
+  return NS_OK;
+}
+
+nsresult nsMailtoUrl::ParseUrl() {
+  // we can get the path from the simple url.....
+  nsCString escapedPath;
+  m_baseURL->GetPathQueryRef(escapedPath);
+
+  int32_t startOfSearchPart = escapedPath.FindChar('?');
+  if (startOfSearchPart >= 0) {
+    // now parse out the search field...
+    nsAutoCString searchPart(Substring(escapedPath, startOfSearchPart));
+
+    if (!searchPart.IsEmpty()) {
+      // now we need to strip off the search part from the
+      // to part....
+      escapedPath.SetLength(startOfSearchPart);
+      MsgUnescapeString(escapedPath, 0, m_toPart);
+      ParseMailtoUrl(searchPart.BeginWriting());
+    }
+  } else if (!escapedPath.IsEmpty()) {
+    MsgUnescapeString(escapedPath, 0, m_toPart);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetMessageContents(nsACString& aToPart, nsACString& aCcPart,
+                                nsACString& aBccPart, nsACString& aSubjectPart,
+                                nsACString& aBodyPart, nsACString& aHtmlPart,
+                                nsACString& aReferencePart,
+                                nsACString& aNewsgroupPart,
+                                MSG_ComposeFormat* aFormat) {
+  NS_ENSURE_ARG_POINTER(aFormat);
+
+  aToPart = m_toPart;
+  aCcPart = m_ccPart;
+  aBccPart = m_bccPart;
+  aSubjectPart = m_subjectPart;
+  aBodyPart = m_bodyPart;
+  aHtmlPart = m_htmlPart;
+  aReferencePart = m_referencePart;
+  aNewsgroupPart = m_newsgroupPart;
+  *aFormat = mFormat;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetFromPart(nsACString& aResult) {
+  aResult = m_fromPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetFollowUpToPart(nsACString& aResult) {
+  aResult = m_followUpToPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetOrganizationPart(nsACString& aResult) {
+  aResult = m_organizationPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetReplyToPart(nsACString& aResult) {
+  aResult = m_replyToPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetPriorityPart(nsACString& aResult) {
+  aResult = m_priorityPart;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetNewsHostPart(nsACString& aResult) {
+  aResult = m_newsHostPart;
+  return NS_OK;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Begin nsIURI support
+//////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP nsMailtoUrl::GetSpec(nsACString& aSpec) {
+  return m_baseURL->GetSpec(aSpec);
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPrePath(nsACString& aPrePath) {
+  return m_baseURL->GetPrePath(aPrePath);
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetScheme(nsACString& aScheme) {
+  return m_baseURL->GetScheme(aScheme);
+}
+
+nsresult nsMailtoUrl::SetScheme(const nsACString& aScheme) {
+  nsresult rv = NS_MutateURI(m_baseURL).SetScheme(aScheme).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetUserPass(nsACString& aUserPass) {
+  return m_baseURL->GetUserPass(aUserPass);
+}
+
+nsresult nsMailtoUrl::SetUserPass(const nsACString& aUserPass) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetUserPass(aUserPass).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetUsername(nsACString& aUsername) {
+  return m_baseURL->GetUsername(aUsername);
+}
+
+nsresult nsMailtoUrl::SetUsername(const nsACString& aUsername) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetUsername(aUsername).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPassword(nsACString& aPassword) {
+  return m_baseURL->GetPassword(aPassword);
+}
+
+nsresult nsMailtoUrl::SetPassword(const nsACString& aPassword) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetPassword(aPassword).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetHostPort(nsACString& aHostPort) {
+  return m_baseURL->GetHost(aHostPort);
+}
+
+nsresult nsMailtoUrl::SetHostPort(const nsACString& aHostPort) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetHostPort(aHostPort).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetHost(nsACString& aHost) {
+  return m_baseURL->GetHost(aHost);
+}
+
+nsresult nsMailtoUrl::SetHost(const nsACString& aHost) {
+  nsresult rv = NS_MutateURI(m_baseURL).SetHost(aHost).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPort(int32_t* aPort) {
+  return m_baseURL->GetPort(aPort);
+}
+
+nsresult nsMailtoUrl::SetPort(int32_t aPort) {
+  nsresult rv = NS_MutateURI(m_baseURL).SetPort(aPort).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPathQueryRef(nsACString& aPath) {
+  return m_baseURL->GetPathQueryRef(aPath);
+}
+
+nsresult nsMailtoUrl::SetPathQueryRef(const nsACString& aPath) {
+  nsresult rv =
+      NS_MutateURI(m_baseURL).SetPathQueryRef(aPath).Finalize(m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetAsciiHost(nsACString& aHostA) {
+  return m_baseURL->GetAsciiHost(aHostA);
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetAsciiHostPort(nsACString& aHostPortA) {
+  return m_baseURL->GetAsciiHostPort(aHostPortA);
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetAsciiSpec(nsACString& aSpecA) {
+  return m_baseURL->GetAsciiSpec(aSpecA);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SchemeIs(const char* aScheme, bool* _retval) {
+  return m_baseURL->SchemeIs(aScheme, _retval);
+}
+
+NS_IMETHODIMP nsMailtoUrl::Equals(nsIURI* other, bool* _retval) {
+  // The passed-in URI might be an nsMailtoUrl. Pass our inner URL to its
+  // Equals method. The other nsMailtoUrl will then pass its inner URL to
+  // to the Equals method of our inner URL. Other URIs will return false.
+  if (other) return other->Equals(m_baseURL, _retval);
+
+  return m_baseURL->Equals(other, _retval);
+}
+
+nsresult nsMailtoUrl::Clone(nsIURI** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  RefPtr<nsMailtoUrl> clone = new nsMailtoUrl();
+
+  NS_ENSURE_TRUE(clone, NS_ERROR_OUT_OF_MEMORY);
+
+  nsresult rv = NS_MutateURI(m_baseURL).Finalize(clone->m_baseURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+  clone->ParseUrl();
+  clone.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailtoUrl::Resolve(const nsACString& relativePath,
+                                   nsACString& result) {
+  return m_baseURL->Resolve(relativePath, result);
+}
+
+nsresult nsMailtoUrl::SetRef(const nsACString& aRef) {
+  return NS_MutateURI(m_baseURL).SetRef(aRef).Finalize(m_baseURL);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetRef(nsACString& result) { return m_baseURL->GetRef(result); }
+
+NS_IMETHODIMP nsMailtoUrl::EqualsExceptRef(nsIURI* other, bool* result) {
+  // The passed-in URI might be an nsMailtoUrl. Pass our inner URL to its
+  // Equals method. The other nsMailtoUrl will then pass its inner URL to
+  // to the Equals method of our inner URL. Other URIs will return false.
+  if (other) return other->EqualsExceptRef(m_baseURL, result);
+
+  return m_baseURL->EqualsExceptRef(other, result);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetSpecIgnoringRef(nsACString& result) {
+  return m_baseURL->GetSpecIgnoringRef(result);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetDisplaySpec(nsACString& aUnicodeSpec) {
+  return m_baseURL->GetDisplaySpec(aUnicodeSpec);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetDisplayHostPort(nsACString& aUnicodeHostPort) {
+  return m_baseURL->GetDisplayHostPort(aUnicodeHostPort);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetDisplayHost(nsACString& aUnicodeHost) {
+  return m_baseURL->GetDisplayHost(aUnicodeHost);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetDisplayPrePath(nsACString& aPrePath) {
+  return m_baseURL->GetDisplayPrePath(aPrePath);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetHasRef(bool* result) { return m_baseURL->GetHasRef(result); }
+
+NS_IMETHODIMP
+nsMailtoUrl::GetFilePath(nsACString& aFilePath) {
+  return m_baseURL->GetFilePath(aFilePath);
+}
+
+nsresult nsMailtoUrl::SetFilePath(const nsACString& aFilePath) {
+  return NS_MutateURI(m_baseURL).SetFilePath(aFilePath).Finalize(m_baseURL);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::GetQuery(nsACString& aQuery) {
+  return m_baseURL->GetQuery(aQuery);
+}
+
+nsresult nsMailtoUrl::SetQuery(const nsACString& aQuery) {
+  return NS_MutateURI(m_baseURL).SetQuery(aQuery).Finalize(m_baseURL);
+}
+
+nsresult nsMailtoUrl::SetQueryWithEncoding(const nsACString& aQuery,
+                                           const mozilla::Encoding* aEncoding) {
+  return NS_MutateURI(m_baseURL)
+      .SetQueryWithEncoding(aQuery, aEncoding)
+      .Finalize(m_baseURL);
+}
+
+NS_IMETHODIMP_(void)
+nsMailtoUrl::Serialize(mozilla::ipc::URIParams& aParams) {
+  m_baseURL->Serialize(aParams);
+}
+
+NS_IMPL_ISUPPORTS(nsMailtoUrl::Mutator, nsIURISetters, nsIURIMutator)
+
+NS_IMETHODIMP
+nsMailtoUrl::Mutate(nsIURIMutator** aMutator) {
+  RefPtr<nsMailtoUrl::Mutator> mutator = new nsMailtoUrl::Mutator();
+  nsresult rv = mutator->InitFromURI(this);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  mutator.forget(aMutator);
+  return NS_OK;
+}
+
+nsresult nsMailtoUrl::NewMailtoURI(const nsACString& aSpec, nsIURI* aBaseURI,
+                                   nsIURI** _retval) {
+  nsresult rv;
+
+  nsCOMPtr<nsIURI> mailtoUrl;
+  rv = NS_MutateURI(new Mutator()).SetSpec(aSpec).Finalize(mailtoUrl);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mailtoUrl.forget(_retval);
+  return NS_OK;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+// smtp url definition
+/////////////////////////////////////////////////////////////////////////////////////
+
+nsSmtpUrl::nsSmtpUrl() : nsMsgMailNewsUrl() {
+  // nsISmtpUrl specific state...
+
+  m_isPostMessage = true;
+  m_requestDSN = false;
+  m_verifyLogon = false;
+}
+
+nsSmtpUrl::~nsSmtpUrl() {}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsSmtpUrl, nsMsgMailNewsUrl, nsISmtpUrl)
+
+////////////////////////////////////////////////////////////////////////////////////
+// Begin nsISmtpUrl specific support
+
+////////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP
+nsSmtpUrl::SetRecipients(const char* aRecipientsList) {
+  NS_ENSURE_ARG(aRecipientsList);
+  MsgUnescapeString(nsDependentCString(aRecipientsList), 0, m_toPart);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetRecipients(char** aRecipientsList) {
+  NS_ENSURE_ARG_POINTER(aRecipientsList);
+  if (aRecipientsList) *aRecipientsList = ToNewCString(m_toPart);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetSender(const char* aSender) {
+  NS_ENSURE_ARG(aSender);
+  MsgUnescapeString(nsDependentCString(aSender), 0, m_fromPart);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetSender(char** aSender) {
+  NS_ENSURE_ARG_POINTER(aSender);
+  if (aSender) *aSender = ToNewCString(m_fromPart);
+  return NS_OK;
+}
+
+NS_IMPL_GETSET(nsSmtpUrl, PostMessage, bool, m_isPostMessage)
+
+NS_IMPL_GETSET(nsSmtpUrl, VerifyLogon, bool, m_verifyLogon)
+
+// the message can be stored in a file....allow accessors for getting and
+// setting the file name to post...
+NS_IMETHODIMP nsSmtpUrl::SetPostMessageFile(nsIFile* aFile) {
+  NS_ENSURE_ARG_POINTER(aFile);
+  m_fileName = aFile;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSmtpUrl::GetPostMessageFile(nsIFile** aFile) {
+  NS_ENSURE_ARG_POINTER(aFile);
+  if (m_fileName) {
+    // Clone the file so nsLocalFile stat caching doesn't make the caller get
+    // the wrong file size.
+    m_fileName->Clone(aFile);
+    return *aFile ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+  }
+  return NS_ERROR_NULL_POINTER;
+}
+
+NS_IMPL_GETSET(nsSmtpUrl, RequestDSN, bool, m_requestDSN)
+
+NS_IMETHODIMP
+nsSmtpUrl::SetDsnEnvid(const nsACString& aDsnEnvid) {
+  m_dsnEnvid = aDsnEnvid;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetDsnEnvid(nsACString& aDsnEnvid) {
+  aDsnEnvid = m_dsnEnvid;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetSenderIdentity(nsIMsgIdentity** aSenderIdentity) {
+  NS_ENSURE_ARG_POINTER(aSenderIdentity);
+  NS_ADDREF(*aSenderIdentity = m_senderIdentity);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetSenderIdentity(nsIMsgIdentity* aSenderIdentity) {
+  NS_ENSURE_ARG_POINTER(aSenderIdentity);
+  m_senderIdentity = aSenderIdentity;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetPrompt(nsIPrompt* aNetPrompt) {
+  NS_ENSURE_ARG_POINTER(aNetPrompt);
+  m_netPrompt = aNetPrompt;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetPrompt(nsIPrompt** aNetPrompt) {
+  NS_ENSURE_ARG_POINTER(aNetPrompt);
+  NS_ENSURE_TRUE(m_netPrompt, NS_ERROR_NULL_POINTER);
+  NS_ADDREF(*aNetPrompt = m_netPrompt);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetAuthPrompt(nsIAuthPrompt* aNetAuthPrompt) {
+  NS_ENSURE_ARG_POINTER(aNetAuthPrompt);
+  m_netAuthPrompt = aNetAuthPrompt;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetAuthPrompt(nsIAuthPrompt** aNetAuthPrompt) {
+  NS_ENSURE_ARG_POINTER(aNetAuthPrompt);
+  NS_ENSURE_TRUE(m_netAuthPrompt, NS_ERROR_NULL_POINTER);
+  NS_ADDREF(*aNetAuthPrompt = m_netAuthPrompt);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetNotificationCallbacks(nsIInterfaceRequestor* aCallbacks) {
+  NS_ENSURE_ARG_POINTER(aCallbacks);
+  m_callbacks = aCallbacks;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetNotificationCallbacks(nsIInterfaceRequestor** aCallbacks) {
+  NS_ENSURE_ARG_POINTER(aCallbacks);
+  NS_ENSURE_TRUE(m_callbacks, NS_ERROR_NULL_POINTER);
+  NS_ADDREF(*aCallbacks = m_callbacks);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::SetSmtpServer(nsISmtpServer* aSmtpServer) {
+  NS_ENSURE_ARG_POINTER(aSmtpServer);
+  m_smtpServer = aSmtpServer;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpUrl::GetSmtpServer(nsISmtpServer** aSmtpServer) {
+  NS_ENSURE_ARG_POINTER(aSmtpServer);
+  NS_ENSURE_TRUE(m_smtpServer, NS_ERROR_NULL_POINTER);
+  NS_ADDREF(*aSmtpServer = m_smtpServer);
+  return NS_OK;
+}
+
+nsresult nsSmtpUrl::NewSmtpURI(const nsACString& aSpec, nsIURI* aBaseURI,
+                               nsIURI** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = 0;
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailNewsUrl> aSmtpUri = new nsSmtpUrl();
+  if (aBaseURI) {
+    nsAutoCString newSpec;
+    rv = aBaseURI->Resolve(aSpec, newSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = aSmtpUri->SetSpecInternal(newSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+  } else {
+    rv = aSmtpUri->SetSpecInternal(aSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  aSmtpUri.forget(_retval);
+
+  return rv;
+}
diff --git a/comm/mailnews/compose/src/nsSmtpUrl.h b/comm/mailnews/compose/src/nsSmtpUrl.h
new file mode 100644
index 0000000000..bd205f119c
--- /dev/null
+++ b/comm/mailnews/compose/src/nsSmtpUrl.h
@@ -0,0 +1,144 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsSmtpUrl_h__
+#define nsSmtpUrl_h__
+
+#include "nsISmtpUrl.h"
+#include "nsIURI.h"
+#include "nsMsgMailNewsUrl.h"
+#include "nsIMsgIdentity.h"
+#include "nsCOMPtr.h"
+#include "nsIPrompt.h"
+#include "nsIAuthPrompt.h"
+#include "nsISmtpServer.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIURIMutator.h"
+
+class nsMailtoUrl : public nsIMailtoUrl, public nsIURI {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIURI
+  NS_DECL_NSIMAILTOURL
+
+  nsMailtoUrl();
+  static nsresult NewMailtoURI(const nsACString& aSpec, nsIURI* aBaseURI,
+                               nsIURI** _retval);
+
+ protected:
+  virtual nsresult Clone(nsIURI** _retval);
+  virtual nsresult SetSpecInternal(const nsACString& aSpec);
+  virtual nsresult SetScheme(const nsACString& aScheme);
+  virtual nsresult SetUserPass(const nsACString& aUserPass);
+  virtual nsresult SetUsername(const nsACString& aUsername);
+  virtual nsresult SetPassword(const nsACString& aPassword);
+  virtual nsresult SetHostPort(const nsACString& aHostPort);
+  virtual nsresult SetHost(const nsACString& aHost);
+  virtual nsresult SetPort(int32_t aPort);
+  virtual nsresult SetPathQueryRef(const nsACString& aPath);
+  virtual nsresult SetRef(const nsACString& aRef);
+  virtual nsresult SetFilePath(const nsACString& aFilePath);
+  virtual nsresult SetQuery(const nsACString& aQuery);
+  virtual nsresult SetQueryWithEncoding(const nsACString& aQuery,
+                                        const mozilla::Encoding* aEncoding);
+
+ public:
+  class Mutator : public nsIURIMutator, public BaseURIMutator<nsMailtoUrl> {
+    NS_DECL_ISUPPORTS
+    NS_FORWARD_SAFE_NSIURISETTERS_RET(mURI)
+
+    NS_IMETHOD Deserialize(const mozilla::ipc::URIParams& aParams) override {
+      return NS_ERROR_NOT_IMPLEMENTED;
+    }
+
+    NS_IMETHOD Finalize(nsIURI** aURI) override {
+      mURI.forget(aURI);
+      return NS_OK;
+    }
+
+    NS_IMETHOD SetSpec(const nsACString& aSpec,
+                       nsIURIMutator** aMutator) override {
+      if (aMutator) NS_ADDREF(*aMutator = this);
+      return InitFromSpec(aSpec);
+    }
+
+    explicit Mutator() {}
+
+   private:
+    virtual ~Mutator() {}
+
+    friend class nsMailtoUrl;
+  };
+  friend BaseURIMutator<nsMailtoUrl>;
+
+ protected:
+  virtual ~nsMailtoUrl();
+  nsresult ParseUrl();
+  nsresult CleanupMailtoState();
+  nsresult ParseMailtoUrl(char* searchPart);
+
+  nsCOMPtr<nsIURI> m_baseURL;
+
+  // data retrieved from parsing the url: (Note the url could be a post from
+  // file or it could be in the url)
+  nsCString m_toPart;
+  nsCString m_ccPart;
+  nsCString m_subjectPart;
+  nsCString m_newsgroupPart;
+  nsCString m_newsHostPart;
+  nsCString m_referencePart;
+  nsCString m_bodyPart;
+  nsCString m_bccPart;
+  nsCString m_followUpToPart;
+  nsCString m_fromPart;
+  nsCString m_htmlPart;
+  nsCString m_organizationPart;
+  nsCString m_replyToPart;
+  nsCString m_priorityPart;
+
+  MSG_ComposeFormat mFormat;
+};
+
+class nsSmtpUrl : public nsISmtpUrl, public nsMsgMailNewsUrl {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+
+  // From nsISmtpUrl
+  NS_DECL_NSISMTPURL
+
+  // nsSmtpUrl
+  nsSmtpUrl();
+  static nsresult NewSmtpURI(const nsACString& aSpec, nsIURI* aBaseURI,
+                             nsIURI** _retval);
+
+ protected:
+  virtual ~nsSmtpUrl();
+
+  // data retrieved from parsing the url: (Note the url could be a post from
+  // file or it could be in the url)
+  nsCString m_toPart;
+  nsCString m_fromPart;
+
+  bool m_isPostMessage;
+  bool m_requestDSN;
+  nsCString m_dsnEnvid;
+  bool m_verifyLogon;
+
+  // Smtp specific event sinks
+  nsCOMPtr<nsIFile> m_fileName;
+  nsCOMPtr<nsIMsgIdentity> m_senderIdentity;
+  nsCOMPtr<nsIPrompt> m_netPrompt;
+  nsCOMPtr<nsIAuthPrompt> m_netAuthPrompt;
+  nsCOMPtr<nsIInterfaceRequestor> m_callbacks;
+  nsCOMPtr<nsISmtpServer> m_smtpServer;
+
+  // it is possible to encode the message to parse in the form of a url.
+  // This function is used to decompose the search and path part into the bare
+  // message components (to, fcc, bcc, etc.)
+  nsresult ParseMessageToPost(char* searchPart);
+};
+
+#endif  // nsSmtpUrl_h__
diff --git a/comm/mailnews/compose/test/moz.build b/comm/mailnews/compose/test/moz.build
new file mode 100644
index 0000000000..512bee25fc
--- /dev/null
+++ b/comm/mailnews/compose/test/moz.build
@@ -0,0 +1,8 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPCSHELL_TESTS_MANIFESTS += [
+    "unit/xpcshell.ini",
+]
diff --git a/comm/mailnews/compose/test/unit/data/429891_testcase.eml b/comm/mailnews/compose/test/unit/data/429891_testcase.eml
new file mode 100644
index 0000000000..b4fb4164c9
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/429891_testcase.eml
@@ -0,0 +1,384 @@
+From: Invalid User <from_A@foo.invalid>

+To: =?UTF-8?B?RnLDqcOpZGxlLCBUZXN0?= <to_A@foo.invalid>

+Subject: Big email

+

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

+012345678901234567890123456789012345678901234567890123456789

diff --git a/comm/mailnews/compose/test/unit/data/binary-after-plain.txt b/comm/mailnews/compose/test/unit/data/binary-after-plain.txt
new file mode 100644
index 0000000000..cec0697428
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/binary-after-plain.txt
diff --git a/comm/mailnews/compose/test/unit/data/listexpansion.sql b/comm/mailnews/compose/test/unit/data/listexpansion.sql
new file mode 100644
index 0000000000..6c4f6491be
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/listexpansion.sql
@@ -0,0 +1,126 @@
+-- Address book with nested mailing lists for use in test_expandMailingLists.js.
+PRAGMA user_version = 1;
+
+CREATE TABLE cards (uid TEXT PRIMARY KEY, localId INTEGER);
+CREATE TABLE properties (card TEXT, name TEXT, value TEXT);
+CREATE TABLE lists (uid TEXT PRIMARY KEY, localId INTEGER, name TEXT, nickName TEXT, description TEXT);
+CREATE TABLE list_cards (list TEXT, card TEXT, PRIMARY KEY(list, card));
+
+INSERT INTO cards (uid, localId) VALUES
+  ('813155c6-924d-4751-95d0-70d8e64f16bc', 1), -- homer
+  ('b2cc8395-d959-45e4-9516-17457adb16fa', 2), -- marge
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 3), -- bart
+  ('4dd13a79-b70c-4b43-bdba-bacd4e977c1b', 4), -- lisa
+  ('c96402d7-1c7b-4242-a35c-b92c8ec9dfa2', 5), -- maggie
+  ('5ec12f1d-7ee9-403c-a617-48596dacbc18', 6), --simpson
+  ('18204ef9-e4e3-4cd5-9981-604c69bbb9ee', 7), --marge
+  ('ad305609-3535-4d51-8c96-cd82d93aed46', 8), --family
+  ('4808121d-ebad-4564-864d-8f1149aa053b', 9), --kids
+  ('4926ff7a-e929-475a-8aa8-2baac994390c', 10), --parents
+  ('84fa4513-9b60-4379-ade7-1e4b48d67c84', 11), --older-kids
+  ('8e88b9a4-2500-48e0-bcea-b1fa4eab6b72', 12), --bad-kids
+  ('34e60324-4fb6-4f10-ab1b-333b07680228', 13); --bad-younger-kids
+
+INSERT INTO properties (card, name, value) VALUES
+  ('813155c6-924d-4751-95d0-70d8e64f16bc', 'PrimaryEmail', 'homer@example.com'),
+  ('813155c6-924d-4751-95d0-70d8e64f16bc', 'PhotoType', 'generic'),
+  ('813155c6-924d-4751-95d0-70d8e64f16bc', 'LowercasePrimaryEmail', 'homer@example.com'),
+  ('813155c6-924d-4751-95d0-70d8e64f16bc', 'DisplayName', 'Simpson'),
+  ('813155c6-924d-4751-95d0-70d8e64f16bc', 'LastModifiedDate', '1473722922'),
+  ('813155c6-924d-4751-95d0-70d8e64f16bc', 'PopularityIndex', '0'),
+  ('813155c6-924d-4751-95d0-70d8e64f16bc', 'PreferMailFormat', '0'),
+  ('813155c6-924d-4751-95d0-70d8e64f16bc', 'PreferDisplayName', '1'),
+
+  ('b2cc8395-d959-45e4-9516-17457adb16fa', 'DisplayName', 'Marge'),
+  ('b2cc8395-d959-45e4-9516-17457adb16fa', 'PrimaryEmail', 'marge@example.com'),
+  ('b2cc8395-d959-45e4-9516-17457adb16fa', 'PhotoType', 'generic'),
+  ('b2cc8395-d959-45e4-9516-17457adb16fa', 'LowercasePrimaryEmail', 'marge@example.com'),
+  ('b2cc8395-d959-45e4-9516-17457adb16fa', 'LastModifiedDate', '1473723020'),
+  ('b2cc8395-d959-45e4-9516-17457adb16fa', 'PopularityIndex', '0'),
+  ('b2cc8395-d959-45e4-9516-17457adb16fa', 'PreferMailFormat', '0'),
+  ('b2cc8395-d959-45e4-9516-17457adb16fa', 'PreferDisplayName', '1'),
+
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'PhotoType', 'generic'),
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'PopularityIndex', '0'),
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'PreferMailFormat', '0'),
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'PreferDisplayName', '1'),
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'DisplayName', 'Bart'),
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'PrimaryEmail', 'bart@foobar.invalid'),
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'LowercasePrimaryEmail', 'bart@foobar.invalid'),
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'SecondEmail', 'bart@example.com'),
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'LowercaseSecondEmail', 'bart@example.com'),
+  ('979f194e-49f2-4bbb-b364-598cdc6a7d11', 'LastModifiedDate', '1473716192'),
+
+  ('4dd13a79-b70c-4b43-bdba-bacd4e977c1b', 'PrimaryEmail', 'lisa@example.com'),
+  ('4dd13a79-b70c-4b43-bdba-bacd4e977c1b', 'PhotoType', 'generic'),
+  ('4dd13a79-b70c-4b43-bdba-bacd4e977c1b', 'LowercasePrimaryEmail', 'lisa@example.com'),
+  ('4dd13a79-b70c-4b43-bdba-bacd4e977c1b', 'DisplayName', 'lisa@example.com'),
+  ('4dd13a79-b70c-4b43-bdba-bacd4e977c1b', 'PopularityIndex', '0'),
+  ('4dd13a79-b70c-4b43-bdba-bacd4e977c1b', 'PreferMailFormat', '0'),
+  ('4dd13a79-b70c-4b43-bdba-bacd4e977c1b', 'LastModifiedDate', '0'),
+  ('4dd13a79-b70c-4b43-bdba-bacd4e977c1b', 'PreferDisplayName', '1'),
+
+  ('c96402d7-1c7b-4242-a35c-b92c8ec9dfa2', 'DisplayName', 'Maggie'),
+  ('c96402d7-1c7b-4242-a35c-b92c8ec9dfa2', 'LastModifiedDate', '1473723047'),
+  ('c96402d7-1c7b-4242-a35c-b92c8ec9dfa2', 'PrimaryEmail', 'maggie@example.com'),
+  ('c96402d7-1c7b-4242-a35c-b92c8ec9dfa2', 'PhotoType', 'generic'),
+  ('c96402d7-1c7b-4242-a35c-b92c8ec9dfa2', 'LowercasePrimaryEmail', 'maggie@example.com'),
+  ('c96402d7-1c7b-4242-a35c-b92c8ec9dfa2', 'PopularityIndex', '0'),
+  ('c96402d7-1c7b-4242-a35c-b92c8ec9dfa2', 'PreferMailFormat', '0'),
+  ('c96402d7-1c7b-4242-a35c-b92c8ec9dfa2', 'PreferDisplayName', '1'),
+
+  ('5ec12f1d-7ee9-403c-a617-48596dacbc18', 'DisplayName', 'simpson'),
+  ('5ec12f1d-7ee9-403c-a617-48596dacbc18', 'PrimaryEmail', 'simpson'),
+  ('18204ef9-e4e3-4cd5-9981-604c69bbb9ee', 'DisplayName', 'marge'),
+  ('18204ef9-e4e3-4cd5-9981-604c69bbb9ee', 'PrimaryEmail', 'marge'),
+  ('ad305609-3535-4d51-8c96-cd82d93aed46', 'DisplayName', 'family'),
+  ('ad305609-3535-4d51-8c96-cd82d93aed46', 'PrimaryEmail', 'family'),
+  ('4808121d-ebad-4564-864d-8f1149aa053b', 'DisplayName', 'kids'),
+  ('4808121d-ebad-4564-864d-8f1149aa053b', 'PrimaryEmail', 'kids'),
+  ('4926ff7a-e929-475a-8aa8-2baac994390c', 'DisplayName', 'parents'),
+  ('4926ff7a-e929-475a-8aa8-2baac994390c', 'PrimaryEmail', 'parents'),
+  ('84fa4513-9b60-4379-ade7-1e4b48d67c84', 'PrimaryEmail', 'older-kids'),
+  ('84fa4513-9b60-4379-ade7-1e4b48d67c84', 'DisplayName', 'older-kids'),
+  ('8e88b9a4-2500-48e0-bcea-b1fa4eab6b72', 'DisplayName', 'bad-kids'),
+  ('8e88b9a4-2500-48e0-bcea-b1fa4eab6b72', 'PrimaryEmail', 'bad-kids'),
+  ('34e60324-4fb6-4f10-ab1b-333b07680228', 'DisplayName', 'bad-younger-kids'),
+  ('34e60324-4fb6-4f10-ab1b-333b07680228', 'PrimaryEmail', 'bad-younger-kids');
+
+INSERT INTO lists (uid, localId, name, nickName, description) VALUES
+  ('5ec12f1d-7ee9-403c-a617-48596dacbc18', 1, 'simpson', '', ''),
+  ('18204ef9-e4e3-4cd5-9981-604c69bbb9ee', 2, 'marge', '', 'marges own list'),
+  ('ad305609-3535-4d51-8c96-cd82d93aed46', 3, 'family', '', ''),
+  ('4808121d-ebad-4564-864d-8f1149aa053b', 4, 'kids', '', ''),
+  ('4926ff7a-e929-475a-8aa8-2baac994390c', 5, 'parents', '', ''),
+  ('84fa4513-9b60-4379-ade7-1e4b48d67c84', 6, 'older-kids', '', ''),
+  ('8e88b9a4-2500-48e0-bcea-b1fa4eab6b72', 7, 'bad-kids', '', ''),
+  ('34e60324-4fb6-4f10-ab1b-333b07680228', 8, 'bad-younger-kids', '', '');
+
+INSERT INTO list_cards (list, card) VALUES
+  -- simpson
+  ('5ec12f1d-7ee9-403c-a617-48596dacbc18', '813155c6-924d-4751-95d0-70d8e64f16bc'), -- homer
+  ('5ec12f1d-7ee9-403c-a617-48596dacbc18', 'b2cc8395-d959-45e4-9516-17457adb16fa'), -- marge
+  ('5ec12f1d-7ee9-403c-a617-48596dacbc18', '979f194e-49f2-4bbb-b364-598cdc6a7d11'), -- bart
+  ('5ec12f1d-7ee9-403c-a617-48596dacbc18', '4dd13a79-b70c-4b43-bdba-bacd4e977c1b'), -- lisa
+  -- marge
+  ('18204ef9-e4e3-4cd5-9981-604c69bbb9ee', '813155c6-924d-4751-95d0-70d8e64f16bc'), -- homer
+  ('18204ef9-e4e3-4cd5-9981-604c69bbb9ee', 'b2cc8395-d959-45e4-9516-17457adb16fa'), -- marge
+  -- family
+  ('ad305609-3535-4d51-8c96-cd82d93aed46', '4926ff7a-e929-475a-8aa8-2baac994390c'), -- parents
+  ('ad305609-3535-4d51-8c96-cd82d93aed46', '4808121d-ebad-4564-864d-8f1149aa053b'), -- kids
+  -- parents
+  ('4926ff7a-e929-475a-8aa8-2baac994390c', '813155c6-924d-4751-95d0-70d8e64f16bc'), -- homer
+  ('4926ff7a-e929-475a-8aa8-2baac994390c', 'b2cc8395-d959-45e4-9516-17457adb16fa'), -- marge
+  ('4926ff7a-e929-475a-8aa8-2baac994390c', '4926ff7a-e929-475a-8aa8-2baac994390c'), -- parents
+  -- kids
+  ('4808121d-ebad-4564-864d-8f1149aa053b', '84fa4513-9b60-4379-ade7-1e4b48d67c84'), -- older-kids
+  ('4808121d-ebad-4564-864d-8f1149aa053b', 'c96402d7-1c7b-4242-a35c-b92c8ec9dfa2'), -- maggie
+  -- older-kids
+  ('84fa4513-9b60-4379-ade7-1e4b48d67c84', '4dd13a79-b70c-4b43-bdba-bacd4e977c1b'), -- lisa
+  ('84fa4513-9b60-4379-ade7-1e4b48d67c84', '979f194e-49f2-4bbb-b364-598cdc6a7d11'), -- bart
+  -- bad-kids
+  ('8e88b9a4-2500-48e0-bcea-b1fa4eab6b72', '84fa4513-9b60-4379-ade7-1e4b48d67c84'), -- older-kids
+  ('8e88b9a4-2500-48e0-bcea-b1fa4eab6b72', '34e60324-4fb6-4f10-ab1b-333b07680228'), -- bad-younger-kids
+  -- bad-younger-kids
+  ('34e60324-4fb6-4f10-ab1b-333b07680228', 'c96402d7-1c7b-4242-a35c-b92c8ec9dfa2'), -- maggie
+  ('34e60324-4fb6-4f10-ab1b-333b07680228', '8e88b9a4-2500-48e0-bcea-b1fa4eab6b72'); -- bad-kids
diff --git a/comm/mailnews/compose/test/unit/data/message1.eml b/comm/mailnews/compose/test/unit/data/message1.eml
new file mode 100644
index 0000000000..7913f5f262
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/message1.eml
@@ -0,0 +1,7 @@
+From: from_B@foo.invalid

+To: to_B@foo.invalid

+Subject: test mail

+

+this email is in dos format because that is what the interface requires

+

+test message

diff --git a/comm/mailnews/compose/test/unit/data/shift-jis.eml b/comm/mailnews/compose/test/unit/data/shift-jis.eml
new file mode 100644
index 0000000000..58f583907d
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/shift-jis.eml
@@ -0,0 +1,13 @@
+To: test@example.com
+From: test@example.com
+Subject: ISO-2022-JP and 7bit containing =67 and hence looking like quoted-printable
+Message-ID: <10a2aa17-e92f-417c-864e-575d4e371702@example.com>
+Date: Tue, 3 Apr 2018 19:09:16 +0900
+User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101
+ Thunderbird/52.6.0
+MIME-Version: 1.0
+Content-Type: text/plain; charset=SHIFT-JIS; format=flowed
+Content-Language: ja-JP
+Content-Transfer-Encoding: 7bit
+
+����
diff --git a/comm/mailnews/compose/test/unit/data/test-ISO-2022-JP.txt b/comm/mailnews/compose/test/unit/data/test-ISO-2022-JP.txt
new file mode 100644
index 0000000000..cd370be3f8
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/test-ISO-2022-JP.txt
@@ -0,0 +1 @@
+$B%F%9%H%F%9%H%F%9%H%F%9%H%F%9%H%F%9%H%F%9%H%F%9%H%F%9%H%F%9%H%F%9%H%F%9%H(B 

diff --git a/comm/mailnews/compose/test/unit/data/test-KOI8-R.txt b/comm/mailnews/compose/test/unit/data/test-KOI8-R.txt
new file mode 100644
index 0000000000..91f77cae45
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/test-KOI8-R.txt
@@ -0,0 +1,2 @@
+�� ��� ������ �������� � ������, ���������, ������, �����������, ������� 

+� �������������.

diff --git a/comm/mailnews/compose/test/unit/data/test-SHIFT_JIS.txt b/comm/mailnews/compose/test/unit/data/test-SHIFT_JIS.txt
new file mode 100644
index 0000000000..7a7f267540
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/test-SHIFT_JIS.txt
@@ -0,0 +1 @@
+�����Shift_JIS�̃e�L�X�g�t�@�C���ł��B

diff --git a/comm/mailnews/compose/test/unit/data/test-UTF-16BE.txt b/comm/mailnews/compose/test/unit/data/test-UTF-16BE.txt
new file mode 100644
index 0000000000..dd5fd39ed2
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/test-UTF-16BE.txt
diff --git a/comm/mailnews/compose/test/unit/data/test-UTF-16LE.txt b/comm/mailnews/compose/test/unit/data/test-UTF-16LE.txt
new file mode 100644
index 0000000000..a13a8f09e1
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/test-UTF-16LE.txt
diff --git a/comm/mailnews/compose/test/unit/data/test-UTF-8.txt b/comm/mailnews/compose/test/unit/data/test-UTF-8.txt
new file mode 100644
index 0000000000..b5e9df9a45
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/test-UTF-8.txt
@@ -0,0 +1 @@
+测试文件
diff --git a/comm/mailnews/compose/test/unit/data/test-windows-1252.txt b/comm/mailnews/compose/test/unit/data/test-windows-1252.txt
new file mode 100644
index 0000000000..a98046517a
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/data/test-windows-1252.txt
@@ -0,0 +1,2 @@
+Buenos d�as - Fran�ois a �t� � Paris - Budapester Stra�e, Berlin.

+This is text in windows-1252.

diff --git a/comm/mailnews/compose/test/unit/head_compose.js b/comm/mailnews/compose/test/unit/head_compose.js
new file mode 100644
index 0000000000..6f874335e5
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/head_compose.js
@@ -0,0 +1,280 @@
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+var { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+var { mailTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/MailTestUtils.jsm"
+);
+var { localAccountUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/LocalAccountUtils.jsm"
+);
+
+var CC = Components.Constructor;
+
+// WebApps.jsm called by ProxyAutoConfig (PAC) requires a valid nsIXULAppInfo.
+var { getAppInfo, newAppInfo, updateAppInfo } = ChromeUtils.importESModule(
+  "resource://testing-common/AppInfo.sys.mjs"
+);
+updateAppInfo();
+
+// Ensure the profile directory is set up
+do_get_profile();
+
+var gDEPTH = "../../../../";
+
+// Import the required setup scripts.
+
+/* import-globals-from ../../../test/resources/abSetup.js */
+load("../../../resources/abSetup.js");
+
+// Import the smtp server scripts
+var {
+  nsMailServer,
+  gThreadManager,
+  fsDebugNone,
+  fsDebugAll,
+  fsDebugRecv,
+  fsDebugRecvSend,
+} = ChromeUtils.import("resource://testing-common/mailnews/Maild.jsm");
+var { SmtpDaemon, SMTP_RFC2821_handler } = ChromeUtils.import(
+  "resource://testing-common/mailnews/Smtpd.jsm"
+);
+var { AuthPLAIN, AuthLOGIN, AuthCRAM } = ChromeUtils.import(
+  "resource://testing-common/mailnews/Auth.jsm"
+);
+
+var gDraftFolder;
+
+// Setup the daemon and server
+function setupServerDaemon(handler) {
+  if (!handler) {
+    handler = function (d) {
+      return new SMTP_RFC2821_handler(d);
+    };
+  }
+  var server = new nsMailServer(handler, new SmtpDaemon());
+  return server;
+}
+
+function getBasicSmtpServer(port = 1, hostname = "localhost") {
+  let server = localAccountUtils.create_outgoing_server(
+    port,
+    "user",
+    "password",
+    hostname
+  );
+
+  // Override the default greeting so we get something predicitable
+  // in the ELHO message
+  Services.prefs.setCharPref("mail.smtpserver.default.hello_argument", "test");
+
+  return server;
+}
+
+function getSmtpIdentity(senderName, smtpServer) {
+  // Set up the identity
+  let identity = MailServices.accounts.createIdentity();
+  identity.email = senderName;
+  identity.smtpServerKey = smtpServer.key;
+
+  return identity;
+}
+
+var test;
+
+function do_check_transaction(real, expected) {
+  if (Array.isArray(real)) {
+    real = real.at(-1);
+  }
+  // real.them may have an extra QUIT on the end, where the stream is only
+  // closed after we have a chance to process it and not them. We therefore
+  // excise this from the list
+  if (real.them[real.them.length - 1] == "QUIT") {
+    real.them.pop();
+  }
+
+  Assert.equal(real.them.join(","), expected.join(","));
+  dump("Passed test " + test + "\n");
+}
+
+// This listener is designed just to call OnStopCopy() when its OnStopCopy
+// function is called - the rest of the functions are unneeded for a lot of
+// tests (but we can't use asyncCopyListener because we need the
+// nsIMsgSendListener interface as well).
+var copyListener = {
+  // nsIMsgSendListener
+  onStartSending(aMsgID, aMsgSize) {},
+  onProgress(aMsgID, aProgress, aProgressMax) {},
+  onStatus(aMsgID, aMsg) {},
+  onStopSending(aMsgID, aStatus, aMsg, aReturnFile) {},
+  onGetDraftFolderURI(aMsgID, aFolderURI) {},
+  onSendNotPerformed(aMsgID, aStatus) {},
+  onTransportSecurityError(msgID, status, secInfo, location) {},
+
+  // nsIMsgCopyServiceListener
+  OnStartCopy() {},
+  OnProgress(aProgress, aProgressMax) {},
+  SetMessageKey(aKey) {},
+  GetMessageId(aMessageId) {},
+  OnStopCopy(aStatus) {
+    /* globals OnStopCopy */
+    OnStopCopy(aStatus);
+  },
+
+  // QueryInterface
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIMsgSendListener",
+    "nsIMsgCopyServiceListener",
+  ]),
+};
+
+var progressListener = {
+  onStateChange(aWebProgress, aRequest, aStateFlags, aStatus) {
+    if (aStateFlags & Ci.nsIWebProgressListener.STATE_STOP) {
+      this.resolve(gDraftFolder && mailTestUtils.firstMsgHdr(gDraftFolder));
+    }
+  },
+
+  onProgressChange(
+    aWebProgress,
+    aRequest,
+    aCurSelfProgress,
+    aMaxSelfProgress,
+    aCurTotalProgress,
+    aMaxTotalProgress
+  ) {},
+  onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {},
+  onStatusChange(aWebProgress, aRequest, aStatus, aMessage) {},
+  onSecurityChange(aWebProgress, aRequest, state) {},
+  onContentBlockingEvent(aWebProgress, aRequest, aEvent) {},
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIWebProgressListener",
+    "nsISupportsWeakReference",
+  ]),
+};
+
+function createMessage(aAttachment) {
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  fields.from = "Nobody <nobody@tinderbox.test>";
+
+  let attachments = [];
+  if (aAttachment) {
+    let attachment = Cc[
+      "@mozilla.org/messengercompose/attachment;1"
+    ].createInstance(Ci.nsIMsgAttachment);
+    if (aAttachment instanceof Ci.nsIFile) {
+      attachment.url = "file://" + aAttachment.path;
+      attachment.contentType = "text/plain";
+      attachment.name = aAttachment.leafName;
+    } else {
+      attachment.url = "data:,sometext";
+      attachment.name = aAttachment;
+    }
+    attachments = [attachment];
+  }
+  return richCreateMessage(fields, attachments);
+}
+
+function richCreateMessage(
+  fields,
+  attachments = [],
+  identity = null,
+  account = null
+) {
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+  params.composeFields = fields;
+
+  let msgCompose = MailServices.compose.initCompose(params);
+  if (identity === null) {
+    identity = getSmtpIdentity(null, getBasicSmtpServer());
+  }
+
+  let rootFolder = localAccountUtils.rootFolder;
+  gDraftFolder = null;
+  // Make sure the drafts folder is empty
+  try {
+    gDraftFolder = rootFolder.getChildNamed("Drafts");
+  } catch (e) {
+    // we don't have to remove the folder because it doesn't exist yet
+    gDraftFolder = rootFolder.createLocalSubfolder("Drafts");
+  }
+  // Clear all messages
+  let msgs = [...gDraftFolder.msgDatabase.enumerateMessages()];
+  if (msgs.length > 0) {
+    gDraftFolder.deleteMessages(msgs, null, true, false, null, false);
+  }
+
+  // Set attachment
+  fields.removeAttachments();
+  for (let attachment of attachments) {
+    fields.addAttachment(attachment);
+  }
+
+  let progress = Cc["@mozilla.org/messenger/progress;1"].createInstance(
+    Ci.nsIMsgProgress
+  );
+  let promise = new Promise((resolve, reject) => {
+    progressListener.resolve = resolve;
+    progressListener.reject = reject;
+  });
+  progress.registerListener(progressListener);
+  msgCompose.sendMsg(
+    Ci.nsIMsgSend.nsMsgSaveAsDraft,
+    identity,
+    account ? account.key : "",
+    null,
+    progress
+  );
+  return promise;
+}
+
+function getAttachmentFromContent(aContent) {
+  function getBoundaryStringFromContent() {
+    let found = aContent.match(
+      /Content-Type: multipart\/mixed;\s+boundary="(.*?)"/
+    );
+    Assert.notEqual(found, null);
+    Assert.equal(found.length, 2);
+
+    return found[1];
+  }
+
+  let boundary = getBoundaryStringFromContent(aContent);
+  let regex = new RegExp(
+    "\\r\\n\\r\\n--" +
+      boundary +
+      "\\r\\n" +
+      "([\\s\\S]*?)\\r\\n" +
+      "--" +
+      boundary +
+      "--",
+    "m"
+  );
+  let attachments = aContent.match(regex);
+  Assert.notEqual(attachments, null);
+  Assert.equal(attachments.length, 2);
+  return attachments[1];
+}
+
+/**
+ * Get the body part of an MIME message.
+ *
+ * @param {string} content - The message content.
+ * @returns {string}
+ */
+function getMessageBody(content) {
+  let separatorIndex = content.indexOf("\r\n\r\n");
+  Assert.equal(content.slice(-2), "\r\n", "Should end with a line break.");
+  return content.slice(separatorIndex + 4, -2);
+}
+
+registerCleanupFunction(function () {
+  load(gDEPTH + "mailnews/resources/mailShutdown.js");
+});
diff --git a/comm/mailnews/compose/test/unit/test_accountKey.js b/comm/mailnews/compose/test/unit/test_accountKey.js
new file mode 100644
index 0000000000..440b2ea78a
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_accountKey.js
@@ -0,0 +1,80 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+let MockNntpService = {
+  QueryInterface: ChromeUtils.generateQI(["nsINntpService"]),
+  postMessage(messageFile, groupNames, accountKey, urlListener, msgWindow) {
+    this.messageFile = messageFile;
+    this.groupNames = groupNames;
+    this.accountKey = accountKey;
+  },
+};
+
+let MockNntpServiceFactory = {
+  createInstance(aIID) {
+    return MockNntpService;
+  },
+};
+
+add_setup(async function () {
+  let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+  registrar.registerFactory(
+    Components.ID("{4816dd44-fe15-4719-8cfb-a2f8ee46d787}"),
+    "Mock NntpService",
+    "@mozilla.org/messenger/nntpservice;1",
+    MockNntpServiceFactory
+  );
+});
+
+/**
+ * Test that when accountKey is not passed to sendMessageFile, MessageSend can
+ * get the right account key from identity.
+ */
+add_task(async function testAccountKey() {
+  // Set up the servers.
+  let server = setupServerDaemon();
+  localAccountUtils.loadLocalMailAccount();
+  server.start();
+  let smtpServer = getBasicSmtpServer(server.port);
+  let identity = getSmtpIdentity("from@foo.invalid", smtpServer);
+  let account = MailServices.accounts.createAccount();
+  account.addIdentity(identity);
+  account.incomingServer = MailServices.accounts.createIncomingServer(
+    "test",
+    "localhost",
+    "pop3"
+  );
+
+  // Init nsIMsgSend and fields.
+  let msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+  let compFields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  compFields.from = identity.email;
+  // Set the newsgroups filed so that the message will be passed to NntpService.
+  compFields.newsgroups = "foo.test";
+
+  let testFile = do_get_file("data/message1.eml");
+  // Notice the second argument is accountKey.
+  await msgSend.sendMessageFile(
+    identity,
+    "",
+    compFields,
+    testFile,
+    false,
+    false,
+    Ci.nsIMsgSend.nsMsgDeliverNow,
+    null,
+    copyListener,
+    null,
+    null
+  );
+
+  // Make sure the messageFile passed to NntpService is the file we set above.
+  equal(MockNntpService.messageFile, testFile);
+  // Test accountKey passed to NntpService is correct.
+  equal(MockNntpService.accountKey, account.key);
+});
diff --git a/comm/mailnews/compose/test/unit/test_attachment.js b/comm/mailnews/compose/test/unit/test_attachment.js
new file mode 100644
index 0000000000..f0c5a4d91d
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_attachment.js
@@ -0,0 +1,171 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Test suite for attachment file name.
+ */
+
+var input0 =
+  " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" +
+  "`abcdefghijklmnopqrstuvwxyz{|}~" +
+  "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf" +
+  "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf" +
+  "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" +
+  "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf" +
+  "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" +
+  "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff.txt";
+
+// ascii only
+var input1 =
+  "x!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" +
+  "`abcdefghijklmnopqrstuvwxyz{|}~.txt";
+
+var expectedCD0 = [
+  "Content-Disposition: attachment;",
+  " filename*0*=UTF-8''%20%21%22%23%24%25%26%27%28%29%2A%2B%2C%2D%2E%2F%30%31;",
+  " filename*1*=%32%33%34%35%36%37%38%39%3A%3B%3C%3D%3E%3F%40%41%42%43%44%45;",
+  " filename*2*=%46%47%48%49%4A%4B%4C%4D%4E%4F%50%51%52%53%54%55%56%57%58%59;",
+  " filename*3*=%5A%5B%5C%5D%5E%5F%60%61%62%63%64%65%66%67%68%69%6A%6B%6C%6D;",
+  " filename*4*=%6E%6F%70%71%72%73%74%75%76%77%78%79%7A%7B%7C%7D%7E%C2%A0;",
+  " filename*5*=%C2%A1%C2%A2%C2%A3%C2%A4%C2%A5%C2%A6%C2%A7%C2%A8%C2%A9%C2%AA;",
+  " filename*6*=%C2%AB%C2%AC%C2%AD%C2%AE%C2%AF%C2%B0%C2%B1%C2%B2%C2%B3%C2%B4;",
+  " filename*7*=%C2%B5%C2%B6%C2%B7%C2%B8%C2%B9%C2%BA%C2%BB%C2%BC%C2%BD%C2%BE;",
+  " filename*8*=%C2%BF%C3%80%C3%81%C3%82%C3%83%C3%84%C3%85%C3%86%C3%87%C3%88;",
+  " filename*9*=%C3%89%C3%8A%C3%8B%C3%8C%C3%8D%C3%8E%C3%8F%C3%90%C3%91%C3%92;",
+  " filename*10*=%C3%93%C3%94%C3%95%C3%96%C3%97%C3%98%C3%99%C3%9A%C3%9B;",
+  " filename*11*=%C3%9C%C3%9D%C3%9E%C3%9F%C3%A0%C3%A1%C3%A2%C3%A3%C3%A4;",
+  " filename*12*=%C3%A5%C3%A6%C3%A7%C3%A8%C3%A9%C3%AA%C3%AB%C3%AC%C3%AD;",
+  " filename*13*=%C3%AE%C3%AF%C3%B0%C3%B1%C3%B2%C3%B3%C3%B4%C3%B5%C3%B6;",
+  " filename*14*=%C3%B7%C3%B8%C3%B9%C3%BA%C3%BB%C3%BC%C3%BD%C3%BE%C3%BF%2E;",
+  " filename*15*=%74%78%74",
+  "",
+].join("\r\n");
+
+var expectedCD1 =
+  "Content-Disposition: attachment;\r\n" +
+  ' filename*0="x!\\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ";\r\n' +
+  ' filename*1="[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~.txt"\r\n';
+
+var ParamFoldingPref = {
+  // RFC2047: 0,
+  RFC2047WithCRLF: 1,
+  RFC2231: 2,
+};
+
+var expectedCTList0 = {
+  RFC2047:
+    "Content-Type: text/plain; charset=UTF-8;\r\n" +
+    ' name="=?UTF-8?B?ICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJ?=' +
+    "=?UTF-8?Q?JKLMNOPQRSTUVWXYZ=5b=5c=5d=5e=5f=60abcdefghijklmnopqrstuvwx?=" +
+    "=?UTF-8?B?eXp7fH1+wqDCocKiwqPCpMKlwqbCp8KowqnCqsKrwqzCrcKuwq/CsMKx?=" +
+    "=?UTF-8?B?wrLCs8K0wrXCtsK3wrjCucK6wrvCvMK9wr7Cv8OAw4HDgsODw4TDhcOG?=" +
+    "=?UTF-8?B?w4fDiMOJw4rDi8OMw43DjsOPw5DDkcOSw5PDlMOVw5bDl8OYw5nDmsOb?=" +
+    "=?UTF-8?B?w5zDncOew5/DoMOhw6LDo8Okw6XDpsOnw6jDqcOqw6vDrMOtw67Dr8Ow?=" +
+    '=?UTF-8?B?w7HDssOzw7TDtcO2w7fDuMO5w7rDu8O8w73DvsO/LnR4dA==?="\r\n',
+
+  RFC2047WithCRLF:
+    "Content-Type: text/plain; charset=UTF-8;\r\n" +
+    ' name="=?UTF-8?B?ICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJ?=\r\n' +
+    " =?UTF-8?Q?JKLMNOPQRSTUVWXYZ=5b=5c=5d=5e=5f=60abcdefghijklmnopqrstuvwx?=\r\n" +
+    " =?UTF-8?B?eXp7fH1+wqDCocKiwqPCpMKlwqbCp8KowqnCqsKrwqzCrcKuwq/CsMKx?=\r\n" +
+    " =?UTF-8?B?wrLCs8K0wrXCtsK3wrjCucK6wrvCvMK9wr7Cv8OAw4HDgsODw4TDhcOG?=\r\n" +
+    " =?UTF-8?B?w4fDiMOJw4rDi8OMw43DjsOPw5DDkcOSw5PDlMOVw5bDl8OYw5nDmsOb?=\r\n" +
+    " =?UTF-8?B?w5zDncOew5/DoMOhw6LDo8Okw6XDpsOnw6jDqcOqw6vDrMOtw67Dr8Ow?=\r\n" +
+    ' =?UTF-8?B?w7HDssOzw7TDtcO2w7fDuMO5w7rDu8O8w73DvsO/LnR4dA==?="\r\n',
+
+  RFC2231: "Content-Type: text/plain; charset=UTF-8\r\n",
+};
+
+var expectedCTList1 = {
+  RFC2047:
+    "Content-Type: text/plain; charset=UTF-8;\r\n" +
+    ' name="x!\\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~.txt"\r\n',
+
+  RFC2047WithCRLF:
+    "Content-Type: text/plain; charset=UTF-8;\r\n" +
+    ' name="x!\\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~.txt"\r\n',
+
+  RFC2231: "Content-Type: text/plain; charset=UTF-8\r\n",
+};
+
+function checkAttachment(expectedCD, expectedCT) {
+  let msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  let pos = msgData.indexOf("Content-Disposition:");
+  Assert.notEqual(pos, -1);
+  let contentDisposition = msgData.substr(pos);
+  pos = 0;
+  do {
+    pos = contentDisposition.indexOf("\n", pos);
+    Assert.notEqual(pos, -1);
+    pos++;
+  } while (contentDisposition.startsWith(" ", pos));
+  contentDisposition = contentDisposition.substr(0, pos);
+  Assert.equal(contentDisposition, expectedCD);
+
+  pos = msgData.indexOf("Content-Type:"); // multipart
+  Assert.notEqual(pos, -1);
+  msgData = msgData.substr(pos + 13);
+  pos = msgData.indexOf("Content-Type:"); // body
+  Assert.notEqual(pos, -1);
+  msgData = msgData.substr(pos + 13);
+  pos = msgData.indexOf("Content-Type:"); // first attachment
+  Assert.notEqual(pos, -1);
+  var contentType = msgData.substr(pos);
+  pos = 0;
+  do {
+    pos = contentType.indexOf("\n", pos);
+    Assert.notEqual(pos, -1);
+    pos++;
+  } while (contentType.startsWith(" ", pos));
+  contentType = contentType.substr(0, pos);
+  Assert.equal(contentType.toLowerCase(), expectedCT.toLowerCase());
+}
+
+async function testInput0() {
+  for (let folding in ParamFoldingPref) {
+    Services.prefs.setIntPref(
+      "mail.strictly_mime.parm_folding",
+      ParamFoldingPref[folding]
+    );
+    await createMessage(input0);
+    checkAttachment(expectedCD0, expectedCTList0[folding]);
+  }
+}
+
+async function testInput1() {
+  for (let folding in ParamFoldingPref) {
+    Services.prefs.setIntPref(
+      "mail.strictly_mime.parm_folding",
+      ParamFoldingPref[folding]
+    );
+    await createMessage(input1);
+    checkAttachment(expectedCD1, expectedCTList1[folding]);
+  }
+}
+
+var tests = [testInput0, testInput1];
+
+function run_test() {
+  localAccountUtils.loadLocalMailAccount();
+  tests.forEach(x => add_task(x));
+  run_next_test();
+}
+
+/**
+ * Test that the full attachment content is used to pick the CTE.
+ */
+add_task(async function testBinaryAfterPlainTextAttachment() {
+  let testFile = do_get_file("data/binary-after-plain.txt");
+  await createMessage(testFile);
+  let msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  // If only the first few chars are used, encoding will be incorrectly 7bit.
+  Assert.ok(
+    msgData.includes(
+      'Content-Disposition: attachment; filename="binary-after-plain.txt"\r\nContent-Transfer-Encoding: base64\r\n'
+    )
+  );
+});
diff --git a/comm/mailnews/compose/test/unit/test_attachment_intl.js b/comm/mailnews/compose/test/unit/test_attachment_intl.js
new file mode 100644
index 0000000000..6ce352d4df
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_attachment_intl.js
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * attachment test using non-ascii character
+ */
+
+let nonAsciiUrl = "http://\u65e5\u672c\u8a9e.jp";
+let prettyResult = "\u65e5\u672c\u8a9e.jp";
+
+function doAttachmentUrlTest() {
+  // handles non-ascii url in nsIMsgAttachment
+
+  let attachment = Cc[
+    "@mozilla.org/messengercompose/attachment;1"
+  ].createInstance(Ci.nsIMsgAttachment);
+  attachment.url = nonAsciiUrl;
+
+  Assert.equal(attachment.url, nonAsciiUrl);
+}
+
+function doPrettyNameTest() {
+  // handles non-ascii url in nsIMsgCompose
+
+  let msgCompose = Cc["@mozilla.org/messengercompose/compose;1"].createInstance(
+    Ci.nsIMsgCompose
+  );
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+  msgCompose.initialize(params);
+
+  Assert.equal(
+    msgCompose.AttachmentPrettyName(nonAsciiUrl, null),
+    prettyResult
+  );
+}
+
+function run_test() {
+  doAttachmentUrlTest();
+  doPrettyNameTest();
+
+  do_test_finished();
+}
diff --git a/comm/mailnews/compose/test/unit/test_autoReply.js b/comm/mailnews/compose/test/unit/test_autoReply.js
new file mode 100644
index 0000000000..a81dc7bcef
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_autoReply.js
@@ -0,0 +1,254 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Tests messages generated by ReplyWithTemplate.
+ */
+
+var { TestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TestUtils.sys.mjs"
+);
+const { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { MimeParser } = ChromeUtils.import("resource:///modules/mimeParser.jsm");
+
+load("../../../resources/logHelper.js"); // watch for errors in the error console
+
+const kSender = "from@foo.invalid";
+
+var gIncomingMailFile = do_get_file("../../../data/bugmail10"); // mail to reply to
+// reply-filter-testmail: mail to reply to (but not really)
+var gIncomingMailFile2 = do_get_file("../../../data/reply-filter-testmail");
+// mail to reply to (but not really, no from)
+var gIncomingMailFile3 = do_get_file("../../../data/mail-without-from");
+var gTemplateMailFile = do_get_file("../../../data/template-latin1"); // template
+var gTemplateMailFile2 = do_get_file("../../../data/template-utf8"); // template2
+var gTemplateFolder;
+
+var gServer;
+
+function run_test() {
+  localAccountUtils.loadLocalMailAccount();
+  gTemplateFolder =
+    localAccountUtils.rootFolder.createLocalSubfolder("Templates");
+
+  gServer = setupServerDaemon();
+  gServer.start();
+
+  run_next_test();
+}
+
+add_task(async function copy_gIncomingMailFile() {
+  let promiseCopyListener = new PromiseTestUtils.PromiseCopyListener();
+  // Copy gIncomingMailFile into the Inbox.
+  MailServices.copy.copyFileMessage(
+    gIncomingMailFile,
+    localAccountUtils.inboxFolder,
+    null,
+    false,
+    0,
+    "",
+    promiseCopyListener,
+    null
+  );
+  await promiseCopyListener.promise;
+});
+
+add_task(async function copy_gIncomingMailFile2() {
+  let promiseCopyListener = new PromiseTestUtils.PromiseCopyListener();
+  // Copy gIncomingMailFile2 into the Inbox.
+  MailServices.copy.copyFileMessage(
+    gIncomingMailFile2,
+    localAccountUtils.inboxFolder,
+    null,
+    false,
+    0,
+    "",
+    promiseCopyListener,
+    null
+  );
+  await promiseCopyListener.promise;
+});
+
+add_task(async function copy_gIncomingMailFile3() {
+  let promiseCopyListener = new PromiseTestUtils.PromiseCopyListener();
+  // Copy gIncomingMailFile3 into the Inbox.
+  MailServices.copy.copyFileMessage(
+    gIncomingMailFile3,
+    localAccountUtils.inboxFolder,
+    null,
+    false,
+    0,
+    "",
+    promiseCopyListener,
+    null
+  );
+  await promiseCopyListener.promise;
+});
+
+add_task(async function copy_gTemplateMailFile() {
+  let promiseCopyListener = new PromiseTestUtils.PromiseCopyListener();
+  // Copy gTemplateMailFile into the Templates folder.
+  MailServices.copy.copyFileMessage(
+    gTemplateMailFile,
+    gTemplateFolder,
+    null,
+    true,
+    0,
+    "",
+    promiseCopyListener,
+    null
+  );
+  await promiseCopyListener.promise;
+});
+
+add_task(async function copy_gTemplateMailFile2() {
+  let promiseCopyListener = new PromiseTestUtils.PromiseCopyListener();
+  // Copy gTemplateMailFile2 into the Templates folder.
+  MailServices.copy.copyFileMessage(
+    gTemplateMailFile2,
+    gTemplateFolder,
+    null,
+    true,
+    0,
+    "",
+    promiseCopyListener,
+    null
+  );
+  await promiseCopyListener.promise;
+});
+
+// Test that a reply is NOT sent when the message is not addressed to "me".
+add_task(async function testReplyingToUnaddressedFails() {
+  try {
+    await testReply(0); // mail 0 is not to us!
+    do_throw("Replied to a message not addressed to us!");
+  } catch (e) {
+    if (e.result != Cr.NS_ERROR_ABORT) {
+      throw e;
+    }
+    // Ok! We didn't reply to the message not specifically addressed to
+    // us (from@foo.invalid).
+  }
+});
+
+// Test that a reply is sent when the message is addressed to "me".
+add_task(async function testReplyingToAdressedWorksLatin1() {
+  try {
+    await testReply(1); // mail 1 is addressed to us, using template-latin1
+  } catch (e) {
+    do_throw("Didn't reply properly to a message addressed to us! " + e);
+  }
+});
+
+// Test that a reply is sent when the message is addressed to "me".
+add_task(async function testReplyingToAdressedWorksUTF8() {
+  try {
+    await testReply(1, 1); // mail 1 is addressed to us, template-utf8
+  } catch (e) {
+    do_throw("Didn't reply properly to a message addressed to us! " + e);
+  }
+});
+
+// Test that a reply is NOT even tried when the message has no From.
+add_task(async function testReplyingToMailWithNoFrom() {
+  try {
+    await testReply(2); // mail 2 has no From
+    do_throw(
+      "Shouldn't even have tried to reply reply to the message " +
+        "with no From and no Reply-To"
+    );
+  } catch (e) {
+    if (e.result != Cr.NS_ERROR_FAILURE) {
+      throw e;
+    }
+  }
+});
+
+// Test reply with template.
+async function testReply(aHrdIdx, aTemplateHdrIdx = 0) {
+  let smtpServer = getBasicSmtpServer();
+  smtpServer.port = gServer.port;
+
+  let identity = getSmtpIdentity(kSender, smtpServer);
+  localAccountUtils.msgAccount.addIdentity(identity);
+
+  let msgHdr = mailTestUtils.getMsgHdrN(localAccountUtils.inboxFolder, aHrdIdx);
+  info(
+    "Msg#" +
+      aHrdIdx +
+      " author=" +
+      msgHdr.author +
+      ", recipients=" +
+      msgHdr.recipients
+  );
+  let templateHdr = mailTestUtils.getMsgHdrN(gTemplateFolder, aTemplateHdrIdx);
+
+  // See <method name="getTemplates"> in searchWidgets.xml
+  let msgTemplateUri =
+    gTemplateFolder.URI +
+    "?messageId=" +
+    templateHdr.messageId +
+    "&subject=" +
+    templateHdr.mime2DecodedSubject;
+  MailServices.compose.replyWithTemplate(
+    msgHdr,
+    msgTemplateUri,
+    null,
+    localAccountUtils.incomingServer
+  );
+
+  await TestUtils.waitForCondition(() => gServer._daemon.post);
+  let headers, body;
+  [headers, body] = MimeParser.extractHeadersAndBody(gServer._daemon.post);
+  Assert.ok(headers.get("Subject").startsWith("Auto: "));
+  Assert.equal(headers.get("Auto-submitted"), "auto-replied");
+  Assert.equal(headers.get("In-Reply-To"), "<" + msgHdr.messageId + ">");
+  Assert.equal(headers.get("References"), "<" + msgHdr.messageId + ">");
+  // XXX: something's wrong with how the fake server gets the data.
+  // The text gets converted to UTF-8 (regardless of what it is) at some point.
+  // Suspect a bug with how BinaryInputStream handles the strings.
+  if (templateHdr.charset == "windows-1252") {
+    // XXX: should really check for "åäö xlatin1"
+    if (!body.includes("åäö xlatin1")) {
+      // template-latin1 contains this
+      do_throw(
+        "latin1 body didn't go through!  hdr msgid=" +
+          templateHdr.messageId +
+          ", msgbody=" +
+          body
+      );
+    }
+  } else if (templateHdr.charset == "utf-8") {
+    // XXX: should really check for "åäö xutf8"
+    if (!body.includes("åäö xutf8")) {
+      // template-utf8 contains this
+      do_throw(
+        "utf8 body didn't go through! hdr msgid=" +
+          templateHdr.messageId +
+          ", msgbody=" +
+          body
+      );
+    }
+  } else if (templateHdr.charset) {
+    do_throw(
+      "unexpected msg charset: " +
+        templateHdr.charset +
+        ", hdr msgid=" +
+        templateHdr.messageId
+    );
+  } else {
+    do_throw("didn't find a msg charset! hdr msgid=" + templateHdr.messageId);
+  }
+  gServer.resetTest();
+}
+
+add_task(function teardown() {
+  // fake server cleanup
+  gServer.stop();
+});
diff --git a/comm/mailnews/compose/test/unit/test_bcc.js b/comm/mailnews/compose/test/unit/test_bcc.js
new file mode 100644
index 0000000000..3689b920e7
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_bcc.js
@@ -0,0 +1,330 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Test that when bcc field is set, bcc header should not exist in the sent
+ * mail, but should exist in the mail copy (e.g. Sent folder).
+ */
+
+var { PromiseUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/PromiseUtils.sys.mjs"
+);
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+var gServer;
+var gSentFolder;
+
+function cleanUpSent() {
+  let messages = [...gSentFolder.msgDatabase.enumerateMessages()];
+  if (messages.length) {
+    gSentFolder.deleteMessages(messages, null, true, false, null, false);
+  }
+}
+
+/**
+ * Load local mail account and start fake SMTP server.
+ */
+add_setup(async function setup() {
+  localAccountUtils.loadLocalMailAccount();
+  gServer = setupServerDaemon();
+  gServer.start();
+  registerCleanupFunction(() => {
+    gServer.stop();
+  });
+  gSentFolder = localAccountUtils.rootFolder.createLocalSubfolder("Sent");
+});
+
+/**
+ * Send a msg with bcc field set, then check the sent mail doesn't contain bcc
+ * header, but the mail saved to the Sent folder contains bcc header.
+ */
+add_task(async function testBcc() {
+  gServer.resetTest();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer(gServer.port)
+  );
+
+  // Prepare the comp fields, including the bcc field.
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  fields.to = "Nobody <to@tinderbox.invalid>";
+  fields.subject = "Test bcc";
+  fields.bcc = "bcc@tinderbox.invalid";
+  fields.body = "A\r\nBcc: \r\n mail body\r\n.";
+
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+  params.composeFields = fields;
+
+  // Send the mail.
+  let msgCompose = MailServices.compose.initCompose(params);
+  msgCompose.type = Ci.nsIMsgCompType.New;
+  let progress = Cc["@mozilla.org/messenger/progress;1"].createInstance(
+    Ci.nsIMsgProgress
+  );
+  let promise = new Promise((resolve, reject) => {
+    progressListener.resolve = resolve;
+    progressListener.reject = reject;
+  });
+  progress.registerListener(progressListener);
+  msgCompose.sendMsg(
+    Ci.nsIMsgSend.nsMsgDeliverNow,
+    identity,
+    "",
+    null,
+    progress
+  );
+  await promise;
+
+  let expectedBody = `\r\n\r\n${fields.body}`;
+  // Should not contain extra \r\n between head and body.
+  let notExpectedBody = `\r\n\r\n\r\n${fields.body}`;
+
+  Assert.ok(gServer._daemon.post.includes("Subject: Test bcc"));
+  // Check that bcc header doesn't exist in the sent mail.
+  Assert.ok(!gServer._daemon.post.includes("Bcc: bcc@tinderbox.invalid"));
+  Assert.ok(gServer._daemon.post.includes(expectedBody));
+  Assert.ok(!gServer._daemon.post.includes(notExpectedBody));
+
+  let msgData = mailTestUtils.loadMessageToString(
+    gSentFolder,
+    mailTestUtils.getMsgHdrN(gSentFolder, 0)
+  );
+  Assert.ok(msgData.includes("Subject: Test bcc"));
+  // Check that bcc header exists in the mail copy.
+  Assert.ok(msgData.includes("Bcc: bcc@tinderbox.invalid"));
+  Assert.ok(msgData.includes(fields.body));
+  Assert.ok(msgData.includes(expectedBody));
+  Assert.ok(!msgData.includes(notExpectedBody));
+});
+
+/**
+ * Test that non-utf8 eml attachment is intact after sent to a bcc recipient.
+ */
+add_task(async function testBccWithNonUtf8EmlAttachment() {
+  gServer.resetTest();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer(gServer.port)
+  );
+
+  // Prepare the comp fields, including the bcc field.
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  fields.to = "Nobody <to@tinderbox.invalid>";
+  fields.subject = "Test bcc with non-utf8 eml attachment";
+  fields.bcc = "bcc@tinderbox.invalid";
+
+  let testFile = do_get_file("data/shift-jis.eml");
+  let attachment = Cc[
+    "@mozilla.org/messengercompose/attachment;1"
+  ].createInstance(Ci.nsIMsgAttachment);
+  attachment.url = "file://" + testFile.path;
+  attachment.contentType = "message/rfc822";
+  attachment.name = testFile.leafName;
+  fields.addAttachment(attachment);
+
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+  params.composeFields = fields;
+
+  // Send the mail.
+  let msgCompose = MailServices.compose.initCompose(params);
+  msgCompose.type = Ci.nsIMsgCompType.New;
+  let progress = Cc["@mozilla.org/messenger/progress;1"].createInstance(
+    Ci.nsIMsgProgress
+  );
+  let promise = new Promise((resolve, reject) => {
+    progressListener.resolve = resolve;
+    progressListener.reject = reject;
+  });
+  progress.registerListener(progressListener);
+  msgCompose.sendMsg(
+    Ci.nsIMsgSend.nsMsgDeliverNow,
+    identity,
+    "",
+    null,
+    progress
+  );
+  await promise;
+
+  Assert.ok(
+    gServer._daemon.post.includes(
+      "Subject: Test bcc with non-utf8 eml attachment"
+    )
+  );
+  // \x8C\xBB\x8B\xB5 is 現況 in SHIFT-JIS.
+  Assert.ok(gServer._daemon.post.includes("\r\n\r\n\x8C\xBB\x8B\xB5\r\n"));
+});
+
+add_task(async function testBccWithSendLater() {
+  gServer.resetTest();
+  cleanUpSent();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer(gServer.port)
+  );
+  let account = MailServices.accounts.createAccount();
+  account.addIdentity(identity);
+
+  // Prepare the comp fields, including the bcc field.
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  fields.to = "Nobody <to@tinderbox.invalid>";
+  fields.subject = "Test bcc with send later";
+  fields.bcc = "bcc@tinderbox.invalid";
+  fields.body = "A\r\nBcc: \r\n mail body\r\n.";
+
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+  params.composeFields = fields;
+
+  // Queue the mail to send later.
+  let msgCompose = MailServices.compose.initCompose(params);
+  msgCompose.type = Ci.nsIMsgCompType.New;
+  let progress = Cc["@mozilla.org/messenger/progress;1"].createInstance(
+    Ci.nsIMsgProgress
+  );
+  let promise = new Promise((resolve, reject) => {
+    progressListener.resolve = resolve;
+    progressListener.reject = reject;
+  });
+  progress.registerListener(progressListener);
+  msgCompose.sendMsg(
+    Ci.nsIMsgSend.nsMsgQueueForLater,
+    identity,
+    "",
+    null,
+    progress
+  );
+  await promise;
+
+  let onStopSendingPromise = PromiseUtils.defer();
+  let msgSendLater = Cc["@mozilla.org/messengercompose/sendlater;1"].getService(
+    Ci.nsIMsgSendLater
+  );
+  let sendLaterListener = {
+    onStartSending() {},
+    onMessageStartSending() {},
+    onMessageSendProgress() {},
+    onMessageSendError() {},
+    onStopSending() {
+      let expectedBody = `\r\n\r\n${fields.body}`;
+      // Should not contain extra \r\n between head and body.
+      let notExpectedBody = `\r\n\r\n\r\n${fields.body}`;
+
+      Assert.ok(gServer._daemon.post.includes(`Subject: ${fields.subject}`));
+      // Check that bcc header doesn't exist in the sent mail.
+      Assert.ok(!gServer._daemon.post.includes("Bcc: bcc@tinderbox.invalid"));
+      Assert.ok(gServer._daemon.post.includes(expectedBody));
+      Assert.ok(!gServer._daemon.post.includes(notExpectedBody));
+
+      let msgData = mailTestUtils.loadMessageToString(
+        gSentFolder,
+        mailTestUtils.getMsgHdrN(gSentFolder, 0)
+      );
+      Assert.ok(msgData.includes(`Subject: ${fields.subject}`));
+      // Check that bcc header exists in the mail copy.
+      Assert.ok(msgData.includes("Bcc: bcc@tinderbox.invalid"));
+      Assert.ok(msgData.includes(fields.body));
+      Assert.ok(msgData.includes(expectedBody));
+      Assert.ok(!msgData.includes(notExpectedBody));
+
+      msgSendLater.removeListener(sendLaterListener);
+      onStopSendingPromise.resolve();
+    },
+  };
+
+  msgSendLater.addListener(sendLaterListener);
+
+  // Actually send the message.
+  msgSendLater.sendUnsentMessages(identity);
+  await onStopSendingPromise.promise;
+});
+
+/**
+ * Test that sending bcc only message from Outbox works. With a bcc only
+ * message, nsMsgSendLater passes `To: undisclosed-recipients: ;` to
+ * SmtpService, but it should not be sent to the SMTP server.
+ */
+add_task(async function testBccOnlyWithSendLater() {
+  gServer.resetTest();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer(gServer.port)
+  );
+  let account = MailServices.accounts.createAccount();
+  account.addIdentity(identity);
+
+  // Prepare the comp fields, including the bcc field.
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  fields.subject = "Test bcc only with send later";
+  fields.bcc = "bcc@tinderbox.invalid";
+  fields.body = "A\r\nBcc: \r\n mail body\r\n.";
+
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+  params.composeFields = fields;
+
+  // Queue the mail to send later.
+  let msgCompose = MailServices.compose.initCompose(params);
+  msgCompose.type = Ci.nsIMsgCompType.New;
+  let progress = Cc["@mozilla.org/messenger/progress;1"].createInstance(
+    Ci.nsIMsgProgress
+  );
+  let promise = new Promise((resolve, reject) => {
+    progressListener.resolve = resolve;
+    progressListener.reject = reject;
+  });
+  progress.registerListener(progressListener);
+  msgCompose.sendMsg(
+    Ci.nsIMsgSend.nsMsgQueueForLater,
+    identity,
+    "",
+    null,
+    progress
+  );
+  await promise;
+
+  let onStopSendingPromise = PromiseUtils.defer();
+  let msgSendLater = Cc["@mozilla.org/messengercompose/sendlater;1"].getService(
+    Ci.nsIMsgSendLater
+  );
+  let sendLaterListener = {
+    onStartSending() {},
+    onMessageStartSending() {},
+    onMessageSendProgress() {},
+    onMessageSendError() {},
+    onStopSending() {
+      // Should not include RCPT TO:<undisclosed-recipients: ;>
+      do_check_transaction(gServer.playTransaction(), [
+        "EHLO test",
+        `MAIL FROM:<from@tinderbox.invalid> BODY=8BITMIME SIZE=${gServer._daemon.post.length}`,
+        "RCPT TO:<bcc@tinderbox.invalid>",
+        "DATA",
+      ]);
+
+      msgSendLater.removeListener(sendLaterListener);
+      onStopSendingPromise.resolve();
+    },
+  };
+
+  msgSendLater.addListener(sendLaterListener);
+
+  // Actually send the message.
+  msgSendLater.sendUnsentMessages(identity);
+  await onStopSendingPromise.promise;
+});
diff --git a/comm/mailnews/compose/test/unit/test_bug155172.js b/comm/mailnews/compose/test/unit/test_bug155172.js
new file mode 100644
index 0000000000..06c14416a7
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_bug155172.js
@@ -0,0 +1,140 @@
+/**
+ * Authentication tests for SMTP.
+ */
+
+/* import-globals-from ../../../test/resources/alertTestUtils.js */
+/* import-globals-from ../../../test/resources/passwordStorage.js */
+load("../../../resources/alertTestUtils.js");
+load("../../../resources/passwordStorage.js");
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+
+var gNewPassword = null;
+
+// for alertTestUtils.js
+function confirmExPS(
+  parent,
+  aDialogTitle,
+  aText,
+  aButtonFlags,
+  aButton0Title,
+  aButton1Title,
+  aButton2Title,
+  aCheckMsg,
+  aCheckState
+) {
+  // Just return 2 which will is pressing button 2 - enter a new password.
+  return 2;
+}
+
+function promptPasswordPS(
+  aParent,
+  aDialogTitle,
+  aText,
+  aPassword,
+  aCheckMsg,
+  aCheckState
+) {
+  aPassword.value = gNewPassword;
+  return true;
+}
+
+var server;
+
+var kIdentityMail = "identity@foo.invalid";
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+var kUsername = "test.smtp@fakeserver";
+// kPasswordSaved is the one defined in signons-smtp.json, the other one
+// is intentionally wrong.
+var kPasswordWrong = "wrong";
+var kPasswordSaved = "smtptest";
+
+add_task(async function () {
+  registerAlertTestUtils();
+
+  function createHandler(d) {
+    var handler = new SMTP_RFC2821_handler(d);
+    // Username needs to match the login information stored in the signons json
+    // file.
+    handler.kUsername = kUsername;
+    handler.kPassword = kPasswordWrong;
+    handler.kAuthRequired = true;
+    handler.kAuthSchemes = ["PLAIN", "LOGIN"]; // make match expected transaction below
+    return handler;
+  }
+
+  server = setupServerDaemon(createHandler);
+  server.setDebugLevel(fsDebugAll);
+
+  // Prepare files for passwords (generated by a script in bug 1018624).
+  await setupForPassword("signons-smtp.json");
+
+  // Test file
+  var testFile = do_get_file("data/message1.eml");
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // Start the fake SMTP server
+    server.start();
+    var smtpServer = getBasicSmtpServer(server.port);
+    var identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+    // This time with auth
+    test = "Auth sendMailMessage";
+
+    smtpServer.authMethod = Ci.nsMsgAuthMethod.passwordCleartext;
+    smtpServer.socketType = Ci.nsMsgSocketType.plain;
+    smtpServer.username = kUsername;
+
+    let urlListener = new PromiseTestUtils.PromiseUrlListener();
+    MailServices.smtp.sendMailMessage(
+      testFile,
+      kTo,
+      identity,
+      kSender,
+      null,
+      urlListener,
+      null,
+      null,
+      false,
+      "",
+      {},
+      {}
+    );
+
+    // Set the new password for when we get a prompt
+    gNewPassword = kPasswordWrong;
+
+    await urlListener.promise;
+
+    var transaction = server.playTransaction();
+    do_check_transaction(transaction, [
+      "EHLO test",
+      "AUTH PLAIN " + AuthPLAIN.encodeLine(kUsername, kPasswordSaved),
+      "AUTH LOGIN",
+      "AUTH PLAIN " + AuthPLAIN.encodeLine(kUsername, kPasswordWrong),
+      "MAIL FROM:<" + kSender + "> BODY=8BITMIME SIZE=159",
+      "RCPT TO:<" + kTo + ">",
+      "DATA",
+    ]);
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+});
diff --git a/comm/mailnews/compose/test/unit/test_bug474774.js b/comm/mailnews/compose/test/unit/test_bug474774.js
new file mode 100644
index 0000000000..ba0c20667c
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_bug474774.js
@@ -0,0 +1,253 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/**
+ * Tests bug 474774 - assertions when saving send later and when sending with
+ * FCC switched off.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+var server;
+var smtpServer;
+var originalData;
+var finished = false;
+var identity = null;
+
+var testFile = do_get_file("data/429891_testcase.eml");
+
+var kTestFileSender = "from_A@foo.invalid";
+var kTestFileRecipient = "to_A@foo.invalid";
+
+var kIdentityMail = "identity@foo.invalid";
+
+var msgSendLater = Cc["@mozilla.org/messengercompose/sendlater;1"].getService(
+  Ci.nsIMsgSendLater
+);
+
+// This listener handles the post-sending of the actual message and checks the
+// sequence and ensures the data is correct.
+function msll() {}
+
+msll.prototype = {
+  _initialTotal: 0,
+
+  // nsIMsgSendLaterListener
+  onStartSending(aTotalMessageCount) {
+    this._initialTotal = 1;
+    Assert.equal(msgSendLater.sendingMessages, true);
+  },
+  onMessageStartSending(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageHeader,
+    aIdentity
+  ) {},
+  onMessageSendProgress(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageSendPercent,
+    aMessageCopyPercent
+  ) {
+    // XXX Enable this function
+  },
+  onMessageSendError(aCurrentMessage, aMessageHeader, aStatus, aMsg) {
+    do_throw(
+      "onMessageSendError should not have been called, status: " + aStatus
+    );
+  },
+  onStopSending(aStatus, aMsg, aTotalTried, aSuccessful) {
+    print("msll onStopSending\n");
+    try {
+      Assert.equal(aSuccessful, 1);
+      Assert.equal(aStatus, 0);
+      Assert.equal(aTotalTried, 1);
+      Assert.equal(this._initialTotal, 1);
+      Assert.equal(msgSendLater.sendingMessages, false);
+
+      do_check_transaction(server.playTransaction(), [
+        "EHLO test",
+        "MAIL FROM:<" +
+          kTestFileSender +
+          "> BODY=8BITMIME SIZE=" +
+          originalData.length,
+        "RCPT TO:<" + kTestFileRecipient + ">",
+        "DATA",
+      ]);
+
+      // Compare data file to what the server received
+      Assert.equal(originalData, server._daemon.post);
+
+      // Now wait till the copy is finished for the sent message
+      do_test_pending();
+    } catch (e) {
+      do_throw(e);
+    } finally {
+      server.stop();
+
+      var thread = gThreadManager.currentThread;
+      while (thread.hasPendingEvents()) {
+        thread.processNextEvent(true);
+      }
+    }
+    do_test_finished();
+  },
+};
+
+/* exported OnStopCopy */
+// for head_compose.js
+function OnStopCopy(aStatus) {
+  do_test_finished();
+
+  try {
+    Assert.equal(aStatus, 0);
+
+    // Check this is false before we start sending
+    Assert.equal(msgSendLater.sendingMessages, false);
+
+    let folder = msgSendLater.getUnsentMessagesFolder(identity);
+
+    // Check we have a message in the unsent message folder
+    Assert.equal(folder.getTotalMessages(false), 1);
+
+    // Now do a comparison of what is in the sent mail folder
+    let msgData = mailTestUtils.loadMessageToString(
+      folder,
+      mailTestUtils.firstMsgHdr(folder)
+    );
+
+    // Skip the headers etc that mailnews adds
+    var pos = msgData.indexOf("From:");
+    Assert.notEqual(pos, -1);
+
+    msgData = msgData.substr(pos);
+
+    // Check the data is matching.
+    Assert.equal(originalData, msgData);
+
+    do_test_pending();
+    sendMessageLater();
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+
+    finished = true;
+  }
+}
+
+// This function does the actual send later
+function sendMessageLater() {
+  do_test_finished();
+
+  // Set up the SMTP server.
+  server = setupServerDaemon();
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // Start the fake SMTP server
+    server.start();
+    smtpServer.port = server.port;
+
+    // A test to check that we are sending files correctly, including checking
+    // what the server receives and what we output.
+    test = "sendMessageLater";
+
+    var messageListener = new msll();
+
+    msgSendLater.addListener(messageListener);
+
+    // Send the unsent message
+    msgSendLater.sendUnsentMessages(identity);
+
+    server.performTest();
+
+    do_timeout(10000, function () {
+      if (!finished) {
+        do_throw("Notifications of message send/copy not received");
+      }
+    });
+
+    do_test_pending();
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+}
+
+add_task(async function run_the_test() {
+  // Test file - for bug 429891
+  originalData = await IOUtils.readUTF8(testFile.path);
+
+  // Ensure we have a local mail account, an normal account and appropriate
+  // servers and identities.
+  localAccountUtils.loadLocalMailAccount();
+
+  MailServices.accounts.setSpecialFolders();
+
+  let account = MailServices.accounts.createAccount();
+  let incomingServer = MailServices.accounts.createIncomingServer(
+    "test",
+    "localhost",
+    "pop3"
+  );
+
+  smtpServer = getBasicSmtpServer(0);
+  identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+  account.addIdentity(identity);
+  account.defaultIdentity = identity;
+  account.incomingServer = incomingServer;
+  MailServices.accounts.defaultAccount = account;
+
+  localAccountUtils.rootFolder.createLocalSubfolder("Sent");
+
+  identity.doFcc = false;
+
+  // Now prepare to actually "send" the message later, i.e. dump it in the
+  // unsent messages folder.
+
+  var compFields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+
+  // Setting the compFields sender and recipient to any value is required to
+  // survive mime_sanity_check_fields in nsMsgCompUtils.cpp.
+  // Sender and recipient are required for sendMessageFile but SMTP
+  // transaction values will be used directly from mail body.
+  compFields.from = "irrelevant@foo.invalid";
+  compFields.to = "irrelevant@foo.invalid";
+
+  var msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+
+  msgSend.sendMessageFile(
+    identity,
+    "",
+    compFields,
+    testFile,
+    false,
+    false,
+    Ci.nsIMsgSend.nsMsgQueueForLater,
+    null,
+    copyListener,
+    null,
+    null
+  );
+
+  // Now we wait till we get copy notification of completion.
+  do_test_pending();
+});
diff --git a/comm/mailnews/compose/test/unit/test_createAndSendMessage.js b/comm/mailnews/compose/test/unit/test_createAndSendMessage.js
new file mode 100644
index 0000000000..41daecf2cc
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_createAndSendMessage.js
@@ -0,0 +1,170 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Test createAndSendMessage creates a mail file when not using the editor.
+ */
+
+var server;
+var sentFolder;
+const originalData = "createAndSendMessage utf-8 test åäöÅÄÖ";
+// This is the originalData converted to a byte string.
+const expectedData = "createAndSendMessage utf-8 test åäöÃ\x85Ã\x84Ã\x96";
+const expectedContentTypeHeaders =
+  "Content-Type: text/plain; charset=UTF-8; format=flowed\r\nContent-Transfer-Encoding: 8bit\r\n\r\n";
+var finished = false;
+
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+
+function checkData(msgData) {
+  // Skip the headers etc that mailnews adds
+  var pos = msgData.indexOf("Content-Type:");
+  Assert.notEqual(pos, -1);
+
+  msgData = msgData.substr(pos);
+
+  Assert.equal(msgData, expectedContentTypeHeaders + expectedData + "\r\n");
+}
+
+function MessageListener() {}
+
+MessageListener.prototype = {
+  // nsIMsgSendListener
+  onStartSending(aMsgID, aMsgSize) {},
+  onProgress(aMsgID, aProgress, aProgressMax) {},
+  onStatus(aMsgID, aMsg) {},
+  onStopSending(aMsgID, aStatus, aMsg, aReturnFile) {
+    try {
+      Assert.equal(aStatus, 0);
+
+      // Compare data file to what the server received
+      checkData(server._daemon.post);
+    } catch (e) {
+      do_throw(e);
+    } finally {
+      server.stop();
+
+      var thread = gThreadManager.currentThread;
+      while (thread.hasPendingEvents()) {
+        thread.processNextEvent(false);
+      }
+    }
+  },
+  onGetDraftFolderURI(aMsgID, aFolderURI) {},
+  onSendNotPerformed(aMsgID, aStatus) {},
+  onTransportSecurityError(msgID, status, secInfo, location) {},
+
+  // nsIMsgCopyServiceListener
+  OnStartCopy() {},
+  OnProgress(aProgress, aProgressMax) {},
+  SetMessageKey(aKey) {},
+  GetMessageId(aMessageId) {},
+  OnStopCopy(aStatus) {
+    Assert.equal(aStatus, 0);
+    try {
+      // Now do a comparison of what is in the sent mail folder
+      let msgData = mailTestUtils.loadMessageToString(
+        sentFolder,
+        mailTestUtils.firstMsgHdr(sentFolder)
+      );
+
+      checkData(msgData);
+    } catch (e) {
+      do_throw(e);
+    } finally {
+      finished = true;
+      do_test_finished();
+    }
+  },
+
+  // QueryInterface
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIMsgSendListener",
+    "nsIMsgCopyServiceListener",
+  ]),
+};
+
+/**
+ * Call createAndSendMessage, expect onStopSending to be called.
+ */
+add_task(async function testCreateAndSendMessage() {
+  server = setupServerDaemon();
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  MailServices.accounts.setSpecialFolders();
+
+  server.start();
+  var smtpServer = getBasicSmtpServer(server.port);
+  var identity = getSmtpIdentity(kSender, smtpServer);
+
+  sentFolder = localAccountUtils.rootFolder.createLocalSubfolder("Sent");
+
+  Assert.equal(identity.doFcc, true);
+
+  var msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // A test to check that we are sending files correctly, including checking
+    // what the server receives and what we output.
+    test = "sendMessageFile";
+
+    // Msg Comp Fields
+
+    var compFields = Cc[
+      "@mozilla.org/messengercompose/composefields;1"
+    ].createInstance(Ci.nsIMsgCompFields);
+
+    compFields.from = identity.email;
+    compFields.to = kTo;
+
+    var messageListener = new MessageListener();
+
+    msgSend.createAndSendMessage(
+      null,
+      identity,
+      "",
+      compFields,
+      false,
+      false,
+      Ci.nsIMsgSend.nsMsgDeliverNow,
+      null,
+      "text/plain",
+      // The following parameter is the message body, test that utf-8 is handled
+      // correctly.
+      originalData,
+      null,
+      null,
+      messageListener,
+      null,
+      null,
+      Ci.nsIMsgCompType.New
+    );
+
+    server.performTest();
+
+    do_timeout(10000, function () {
+      if (!finished) {
+        do_throw("Notifications of message send/copy not received");
+      }
+    });
+
+    do_test_pending();
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+});
diff --git a/comm/mailnews/compose/test/unit/test_createRFC822Message.js b/comm/mailnews/compose/test/unit/test_createRFC822Message.js
new file mode 100644
index 0000000000..9502031484
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_createRFC822Message.js
@@ -0,0 +1,68 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Test createRFC822Message creates a mail file.
+ */
+
+var { MailUtils } = ChromeUtils.import("resource:///modules/MailUtils.jsm");
+
+let customSendListener = {
+  ...copyListener,
+  OnStopCopy() {},
+
+  /**
+   * Test a mail file is created and has correct content.
+   */
+  async onStopSending(msgId, status, msg, returnFile) {
+    ok(returnFile.exists(), "createRFC822Message should create a mail file");
+    let content = await IOUtils.read(returnFile.path);
+    content = String.fromCharCode(...content);
+    ok(
+      content.includes("Subject: Test createRFC822Message\r\n"),
+      "Mail file should contain correct subject line"
+    );
+    ok(
+      content.includes(
+        "createRFC822Message is used by nsImportService \xe4\xe9"
+      ),
+      "Mail file should contain correct body"
+    );
+    do_test_finished();
+  },
+};
+
+/**
+ * Call createRFC822Message, expect onStopSending to be called.
+ */
+add_task(async function testCreateRFC822Message() {
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  fields.from = "Somebody <somebody@tinderbox.invalid>";
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Test createRFC822Message";
+
+  let msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+  msgSend.createRFC822Message(
+    identity,
+    fields,
+    "text/plain",
+    // The following parameter is the message body that can contain arbitrary
+    // binary data, let's try some windows-1252 data (äé).
+    "createRFC822Message is used by nsImportService \xe4\xe9",
+    true, // isDraft
+    [],
+    [],
+    customSendListener
+  );
+  do_test_pending();
+});
diff --git a/comm/mailnews/compose/test/unit/test_detectAttachmentCharset.js b/comm/mailnews/compose/test/unit/test_detectAttachmentCharset.js
new file mode 100644
index 0000000000..27e879d018
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_detectAttachmentCharset.js
@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Test suite for auto-detecting attachment file charset.
+ */
+
+function checkAttachmentCharset(expectedCharset) {
+  let msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  let attachmentData = getAttachmentFromContent(msgData);
+
+  Assert.equal(expectedCharset, getContentCharset(attachmentData));
+}
+
+function getContentCharset(aContent) {
+  let found = aContent.match(/^Content-Type: text\/plain; charset=(.*?);/);
+  if (found) {
+    Assert.equal(found.length, 2);
+    return found[1];
+  }
+  return null;
+}
+
+async function testUTF8() {
+  await createMessage(do_get_file("data/test-UTF-8.txt"));
+  checkAttachmentCharset("UTF-8");
+}
+
+async function testUTF16BE() {
+  await createMessage(do_get_file("data/test-UTF-16BE.txt"));
+  checkAttachmentCharset("UTF-16BE");
+}
+
+async function testUTF16LE() {
+  await createMessage(do_get_file("data/test-UTF-16LE.txt"));
+  checkAttachmentCharset("UTF-16LE");
+}
+
+async function testShiftJIS() {
+  await createMessage(do_get_file("data/test-SHIFT_JIS.txt"));
+  checkAttachmentCharset("Shift_JIS");
+}
+
+async function testISO2022JP() {
+  await createMessage(do_get_file("data/test-ISO-2022-JP.txt"));
+  checkAttachmentCharset("ISO-2022-JP");
+}
+
+async function testKOI8R() {
+  // NOTE: KOI8-R is detected as KOI8-U which is a superset covering both
+  // Russian and Ukrainian (a few box-drawing characters are repurposed).
+  await createMessage(do_get_file("data/test-KOI8-R.txt"));
+  checkAttachmentCharset("KOI8-U");
+}
+
+async function testWindows1252() {
+  await createMessage(do_get_file("data/test-windows-1252.txt"));
+  checkAttachmentCharset("windows-1252");
+}
+
+var tests = [
+  testUTF8,
+  testUTF16BE,
+  testUTF16LE,
+  testShiftJIS,
+  testISO2022JP,
+  testKOI8R,
+  testWindows1252,
+];
+
+function run_test() {
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+  Services.prefs.setIntPref("mail.strictly_mime.parm_folding", 0);
+
+  tests.forEach(x => add_task(x));
+  run_next_test();
+}
diff --git a/comm/mailnews/compose/test/unit/test_expandMailingLists.js b/comm/mailnews/compose/test/unit/test_expandMailingLists.js
new file mode 100644
index 0000000000..aa5998196f
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_expandMailingLists.js
@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+
+/**
+ * Tests nsMsgCompose expandMailingLists.
+ */
+
+var MsgComposeContractID = "@mozilla.org/messengercompose/compose;1";
+var MsgComposeParamsContractID =
+  "@mozilla.org/messengercompose/composeparams;1";
+var MsgComposeFieldsContractID =
+  "@mozilla.org/messengercompose/composefields;1";
+var nsIMsgCompose = Ci.nsIMsgCompose;
+var nsIMsgComposeParams = Ci.nsIMsgComposeParams;
+var nsIMsgCompFields = Ci.nsIMsgCompFields;
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+/**
+ * Helper to check population worked as expected.
+ *
+ * @param {string} aTo - Text in the To field.
+ * @param {string} aCheckTo - The expected To addresses (after possible list population).
+ */
+function checkPopulate(aTo, aCheckTo) {
+  let msgCompose = Cc[MsgComposeContractID].createInstance(nsIMsgCompose);
+
+  // Set up some basic fields for compose.
+  let fields = Cc[MsgComposeFieldsContractID].createInstance(nsIMsgCompFields);
+
+  fields.to = aTo;
+
+  // Set up some params
+  let params =
+    Cc[MsgComposeParamsContractID].createInstance(nsIMsgComposeParams);
+
+  params.composeFields = fields;
+
+  msgCompose.initialize(params);
+
+  msgCompose.expandMailingLists();
+  equal(fields.to, aCheckTo);
+}
+
+function run_test() {
+  loadABFile("data/listexpansion", kPABData.fileName);
+
+  // XXX Getting all directories ensures we create all ABs because mailing
+  // lists need help initialising themselves
+  MailServices.ab.directories;
+
+  // Test expansion of list with no description.
+  checkPopulate(
+    "simpson <simpson>",
+    'Simpson <homer@example.com>, Marge <marge@example.com>, Bart <bart@foobar.invalid>, "lisa@example.com" <lisa@example.com>'
+  );
+
+  // Test expansion fo list with description.
+  checkPopulate(
+    "marge <marges own list>",
+    "Simpson <homer@example.com>, Marge <marge@example.com>"
+  );
+
+  // Special tests for bug 1287726: Lists in list. This is what the data looks like:
+  // 1) family (list) = parents (list) + kids (list).
+  // 2) parents (list) = homer + marge + parents (list recursion).
+  // 3) kids (list) = older-kids (list) + maggie.
+  // 4) older-kids (list) = bart + lisa.
+  // 5) bad-kids (list) = older-kids + bad-younger-kids (list).
+  // 6) bad-younger-kids (list) = maggie + bad-kids (list recursion).
+  checkPopulate(
+    "family <family>",
+    "Simpson <homer@example.com>, Marge <marge@example.com>, " +
+      '"lisa@example.com" <lisa@example.com>, Bart <bart@foobar.invalid>, Maggie <maggie@example.com>'
+  );
+  checkPopulate(
+    "parents <parents>",
+    "Simpson <homer@example.com>, Marge <marge@example.com>"
+  );
+  checkPopulate(
+    "kids <kids>",
+    '"lisa@example.com" <lisa@example.com>, Bart <bart@foobar.invalid>, ' +
+      "Maggie <maggie@example.com>"
+  );
+  checkPopulate(
+    "older-kids <older-kids>",
+    '"lisa@example.com" <lisa@example.com>, Bart <bart@foobar.invalid>'
+  );
+  checkPopulate(
+    "bad-kids <bad-kids>",
+    '"lisa@example.com" <lisa@example.com>, Bart <bart@foobar.invalid>, ' +
+      "Maggie <maggie@example.com>"
+  );
+  checkPopulate(
+    "bad-younger-kids <bad-younger-kids>",
+    "Maggie <maggie@example.com>, " +
+      '"lisa@example.com" <lisa@example.com>, Bart <bart@foobar.invalid>'
+  );
+
+  // Test we don't mistake an email address for a list, with a few variations.
+  checkPopulate("Simpson <homer@example.com>", "Simpson <homer@example.com>");
+  checkPopulate("simpson <homer@example.com>", "simpson <homer@example.com>");
+  checkPopulate(
+    "simpson <homer@not-in-ab.invalid>",
+    "simpson <homer@not-in-ab.invalid>"
+  );
+
+  checkPopulate("Marge <marge@example.com>", "Marge <marge@example.com>");
+  checkPopulate("marge <marge@example.com>", "marge <marge@example.com>");
+  checkPopulate(
+    "marge <marge@not-in-ab.invalid>",
+    "marge <marge@not-in-ab.invalid>"
+  );
+}
diff --git a/comm/mailnews/compose/test/unit/test_fcc2.js b/comm/mailnews/compose/test/unit/test_fcc2.js
new file mode 100644
index 0000000000..e7f8d7aadf
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_fcc2.js
@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * Test that when fcc2 field is set, the mail is copied to the fcc2 folder.
+ */
+
+var { MailUtils } = ChromeUtils.import("resource:///modules/MailUtils.jsm");
+
+let fcc2Folder;
+
+add_setup(async function () {
+  localAccountUtils.loadLocalMailAccount();
+  fcc2Folder = localAccountUtils.rootFolder.createLocalSubfolder("fcc2");
+});
+
+/**
+ * Send a message with the fcc2 field set, then check the message in the fcc2
+ * folder.
+ */
+add_task(async function testFcc2() {
+  let CompFields = CC(
+    "@mozilla.org/messengercompose/composefields;1",
+    Ci.nsIMsgCompFields
+  );
+  let fields = new CompFields();
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Test fcc2";
+  fields.fcc2 = fcc2Folder.URI;
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  await richCreateMessage(fields, [], identity);
+
+  // Check the message shows up correctly in the fcc2 folder.
+  let msgData = mailTestUtils.loadMessageToString(
+    fcc2Folder,
+    mailTestUtils.firstMsgHdr(fcc2Folder)
+  );
+  Assert.ok(msgData.includes("Subject: Test fcc2"));
+});
+
+add_task(async function cleanup() {
+  fcc2Folder.deleteSelf(null);
+});
diff --git a/comm/mailnews/compose/test/unit/test_fccReply.js b/comm/mailnews/compose/test/unit/test_fccReply.js
new file mode 100644
index 0000000000..b7e44bce17
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_fccReply.js
@@ -0,0 +1,140 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * Test that when nsIMsgIdentity.fccReplyFollowsParent is true, the reply mail
+ * is copied to the same folder as the original mail.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+var { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+var { TestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TestUtils.sys.mjs"
+);
+
+var gServer;
+
+/**
+ * Send a reply to originalMsgURI.
+ */
+async function sendReply(identity, fields, originalMsgURI, compType) {
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+  params.composeFields = fields;
+  params.originalMsgURI = originalMsgURI;
+  let msgCompose = MailServices.compose.initCompose(params);
+  msgCompose.type = compType;
+  let progress = Cc["@mozilla.org/messenger/progress;1"].createInstance(
+    Ci.nsIMsgProgress
+  );
+  let promise = new Promise((resolve, reject) => {
+    progressListener.resolve = resolve;
+    progressListener.reject = reject;
+  });
+  progress.registerListener(progressListener);
+  msgCompose.sendMsg(
+    Ci.nsIMsgSend.nsMsgDeliverNow,
+    identity,
+    "",
+    null,
+    progress
+  );
+  return promise;
+}
+
+/**
+ * Load local mail account and start fake SMTP server.
+ */
+add_setup(function () {
+  localAccountUtils.loadLocalMailAccount();
+  gServer = setupServerDaemon();
+  gServer.start();
+  registerCleanupFunction(() => {
+    gServer.stop();
+  });
+});
+
+/**
+ * With fccReplyFollowsParent enabled, send a few replies then check the replies
+ * exists in the Inbox folder.
+ */
+add_task(async function testFccReply() {
+  // Turn on fccReplyFollowsParent.
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer(gServer.port)
+  );
+  identity.fccReplyFollowsParent = true;
+
+  // Copy a test mail into the Inbox.
+  let file = do_get_file("data/message1.eml"); // mail to reply to
+  let promiseCopyListener = new PromiseTestUtils.PromiseCopyListener();
+  MailServices.copy.copyFileMessage(
+    file,
+    localAccountUtils.inboxFolder,
+    null,
+    false,
+    0,
+    "",
+    promiseCopyListener,
+    null
+  );
+  await promiseCopyListener.promise;
+
+  let CompFields = CC(
+    "@mozilla.org/messengercompose/composefields;1",
+    Ci.nsIMsgCompFields
+  );
+  let msgHdr = mailTestUtils.firstMsgHdr(localAccountUtils.inboxFolder);
+  let originalMsgURI = msgHdr.folder.getUriForMsg(msgHdr);
+
+  // Test nsIMsgCompFields.Reply.
+  let fields = new CompFields();
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Test fcc reply";
+  await sendReply(identity, fields, originalMsgURI, Ci.nsIMsgCompType.Reply);
+  await TestUtils.waitForCondition(() => gServer._daemon.post);
+  let msgData = mailTestUtils.loadMessageToString(
+    localAccountUtils.inboxFolder,
+    mailTestUtils.getMsgHdrN(localAccountUtils.inboxFolder, 1)
+  );
+  Assert.ok(msgData.includes("Subject: Test fcc reply"));
+
+  // Test nsIMsgCompFields.ReplyToGroup.
+  gServer.resetTest();
+  fields.subject = "Test fccReplyToGroup";
+  await sendReply(
+    identity,
+    fields,
+    originalMsgURI,
+    Ci.nsIMsgCompType.ReplyToGroup
+  );
+  await TestUtils.waitForCondition(() => gServer._daemon.post);
+  msgData = mailTestUtils.loadMessageToString(
+    localAccountUtils.inboxFolder,
+    mailTestUtils.getMsgHdrN(localAccountUtils.inboxFolder, 2)
+  );
+  Assert.ok(msgData.includes("Subject: Test fccReplyToGroup"));
+
+  // Test nsIMsgCompFields.ReplyToList.
+  gServer.resetTest();
+  fields.subject = "Test fccReplyToList";
+  await sendReply(
+    identity,
+    fields,
+    originalMsgURI,
+    Ci.nsIMsgCompType.ReplyToList
+  );
+  await TestUtils.waitForCondition(() => gServer._daemon.post);
+  msgData = mailTestUtils.loadMessageToString(
+    localAccountUtils.inboxFolder,
+    mailTestUtils.getMsgHdrN(localAccountUtils.inboxFolder, 3)
+  );
+  Assert.ok(msgData.includes("Subject: Test fccReplyToList"));
+});
diff --git a/comm/mailnews/compose/test/unit/test_longLines.js b/comm/mailnews/compose/test/unit/test_longLines.js
new file mode 100644
index 0000000000..cd75e75d38
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_longLines.js
@@ -0,0 +1,232 @@
+/*
+ * Test ensuring that messages with "long lines" are transmitted correctly.
+ * Most of this test was copied from test_messageHeaders.js.
+ */
+
+const { MimeParser } = ChromeUtils.import("resource:///modules/mimeParser.jsm");
+
+var CompFields = CC(
+  "@mozilla.org/messengercompose/composefields;1",
+  Ci.nsIMsgCompFields
+);
+
+// Copied from jsmime.js.
+function stringToTypedArray(buffer) {
+  var typedarray = new Uint8Array(buffer.length);
+  for (var i = 0; i < buffer.length; i++) {
+    typedarray[i] = buffer.charCodeAt(i);
+  }
+  return typedarray;
+}
+
+function checkDraftHeadersAndBody(
+  expectedHeaders,
+  expectedBody,
+  charset = "UTF-8"
+) {
+  let msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  checkMessageHeaders(msgData, expectedHeaders);
+
+  // Get the message body, decode from base64 and check.
+  let endOfHeaders = msgData.indexOf("\r\n\r\n");
+  let body = msgData.slice(endOfHeaders + 4);
+  let endOfBody = body.indexOf("\r\n\r\n");
+
+  if (endOfBody > 0) {
+    body = body.slice(0, endOfBody);
+  } else {
+    body = body.slice(0, body.length);
+  }
+
+  // Remove line breaks and decode from base64 if required.
+  if (expectedHeaders["Content-Transfer-Encoding"] == "base64") {
+    body = atob(body.replace(/\r\n/g, ""));
+  }
+
+  if (charset == "UTF-8") {
+    let expectedBinary = String.fromCharCode.apply(
+      undefined,
+      new TextEncoder("UTF-8").encode(expectedBody)
+    );
+    Assert.equal(body, expectedBinary);
+  } else {
+    let strView = stringToTypedArray(body);
+    let decodedBody = new TextDecoder(charset).decode(strView);
+    Assert.equal(decodedBody, expectedBody);
+  }
+}
+
+function checkMessageHeaders(msgData, expectedHeaders, partNum = "") {
+  let seen = false;
+  let handler = {
+    startPart(part, headers) {
+      if (part != partNum) {
+        return;
+      }
+      seen = true;
+      for (let header in expectedHeaders) {
+        let expected = expectedHeaders[header];
+        if (expected === undefined) {
+          Assert.ok(!headers.has(header));
+        } else {
+          let value = headers.getRawHeader(header);
+          Assert.equal(value.length, 1);
+          value[0] = value[0].replace(/boundary=[^;]*(;|$)/, "boundary=.");
+          Assert.equal(value[0], expected);
+        }
+      }
+    },
+  };
+  MimeParser.parseSync(msgData, handler, {
+    onerror(e) {
+      throw e;
+    },
+  });
+  Assert.ok(seen);
+}
+
+// Create a line with 600 letters 'a' with acute accent, encoded as
+// two bytes c3a1 in UTF-8.
+let longMultibyteLine = "\u00E1".repeat(600);
+
+// And here a line with a Korean character, encoded as three bytes
+// ec9588 in UTF-8.
+let longMultibyteLineCJK = "안".repeat(400);
+
+// And some Japanese.
+let longMultibyteLineJapanese = "語".repeat(450);
+
+async function testBodyWithLongLine() {
+  // Lines in the message body are split by CRLF according to RFC 5322, should
+  // be independent of the system.
+  let newline = "\r\n";
+
+  let fields = new CompFields();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  identity.fullName = "Me";
+  identity.organization = "World Destruction Committee";
+  fields.from = "Nobody <nobody@tinderbox.invalid>";
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Message with 1200 byte line in body";
+  let htmlMessage =
+    "<html><head>" +
+    '<meta http-equiv="content-type" content="text/html; charset=utf-8">' +
+    "</head><body>" +
+    longMultibyteLine +
+    "</body></html>\r\n\r\n";
+  fields.body = htmlMessage;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeadersAndBody(
+    {
+      "Content-Type": "text/html; charset=UTF-8",
+      "Content-Transfer-Encoding": "base64",
+    },
+    htmlMessage
+  );
+
+  // Again, but this time as plain text.
+  fields.body = htmlMessage;
+  fields.forcePlainText = true;
+  fields.useMultipartAlternative = false;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeadersAndBody(
+    {
+      "Content-Type": "text/plain; charset=UTF-8; format=flowed",
+      "Content-Transfer-Encoding": "base64",
+    },
+    longMultibyteLine + " " + newline + newline // Expected body: The message without the tags.
+  );
+
+  // Now CJK.
+  fields.forcePlainText = false;
+  htmlMessage =
+    "<html><head>" +
+    '<meta http-equiv="content-type" content="text/html; charset=utf-8">' +
+    "</head><body>" +
+    longMultibyteLineCJK +
+    "</body></html>\r\n\r\n";
+  fields.body = htmlMessage;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeadersAndBody(
+    {
+      "Content-Type": "text/html; charset=UTF-8",
+      "Content-Transfer-Encoding": "base64",
+    },
+    htmlMessage
+  );
+
+  // Again, but this time as plain text.
+  fields.body = htmlMessage;
+  fields.forcePlainText = true;
+  fields.useMultipartAlternative = false;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeadersAndBody(
+    {
+      "Content-Type": "text/plain; charset=UTF-8; format=flowed",
+      "Content-Transfer-Encoding": "base64",
+    },
+    longMultibyteLineCJK + " " + newline + newline // Expected body: The message without the tags.
+  );
+
+  // Now a test for ISO-2022-JP.
+  fields.forcePlainText = false;
+  htmlMessage =
+    "<html><head>" +
+    '<meta http-equiv="content-type" content="text/html; charset=ISO-2022-JP">' +
+    "</head><body>" +
+    longMultibyteLineJapanese +
+    "</body></html>\r\n\r\n";
+  fields.body = htmlMessage;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeadersAndBody(
+    {
+      "Content-Type": "text/html; charset=UTF-8",
+      "Content-Transfer-Encoding": "base64",
+    },
+    htmlMessage
+  );
+
+  // Again, but this time as plain text.
+  fields.body = htmlMessage;
+  fields.forcePlainText = true;
+  fields.useMultipartAlternative = false;
+  await richCreateMessage(fields, [], identity);
+
+  let expectedBody = longMultibyteLineJapanese + " " + newline + newline;
+
+  checkDraftHeadersAndBody(
+    {
+      "Content-Type": "text/plain; charset=UTF-8; format=flowed",
+      "Content-Transfer-Encoding": "base64",
+    },
+    expectedBody
+  );
+
+  // Again, but this time not flowed.
+  fields.body = htmlMessage;
+  Services.prefs.setBoolPref("mailnews.send_plaintext_flowed", false);
+
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeadersAndBody(
+    {
+      "Content-Type": "text/plain; charset=UTF-8",
+      "Content-Transfer-Encoding": "base64",
+    },
+    expectedBody.replace(/ /g, "") // No spaces expected this time.
+  );
+}
+
+var tests = [testBodyWithLongLine];
+
+function run_test() {
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+  tests.forEach(x => add_task(x));
+  run_next_test();
+}
diff --git a/comm/mailnews/compose/test/unit/test_mailTelemetry.js b/comm/mailnews/compose/test/unit/test_mailTelemetry.js
new file mode 100644
index 0000000000..28959d508f
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_mailTelemetry.js
@@ -0,0 +1,79 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test telemetry related to mails sent.
+ */
+
+let { TelemetryTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TelemetryTestUtils.sys.mjs"
+);
+
+let server;
+
+let kIdentityMail = "identity@foo.invalid";
+let kSender = "from@foo.invalid";
+let kTo = "to@foo.invalid";
+
+const NUM_MAILS = 3;
+
+let deliveryListener = {
+  count: 0,
+  OnStartRunningUrl() {},
+  OnStopRunningUrl() {
+    if (++this.count == NUM_MAILS) {
+      let scalars = TelemetryTestUtils.getProcessScalars("parent");
+      Assert.equal(
+        scalars["tb.mails.sent"],
+        NUM_MAILS,
+        "Count of mails sent must be correct."
+      );
+    }
+  },
+};
+
+/**
+ * Check that we're counting mails sent.
+ */
+add_task(async function test_mails_sent() {
+  Services.telemetry.clearScalars();
+
+  server = setupServerDaemon();
+  registerCleanupFunction(() => {
+    server.stop();
+  });
+
+  // Test file
+  let testFile = do_get_file("data/message1.eml");
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // Start the fake SMTP server
+    server.start();
+    let smtpServer = getBasicSmtpServer(server.port);
+    let identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+    for (let i = 0; i < NUM_MAILS; i++) {
+      MailServices.smtp.sendMailMessage(
+        testFile,
+        kTo,
+        identity,
+        kSender,
+        null,
+        deliveryListener,
+        null,
+        null,
+        false,
+        "",
+        {},
+        {}
+      );
+    }
+  } catch (e) {
+    do_throw(e);
+  }
+});
diff --git a/comm/mailnews/compose/test/unit/test_mailtoURL.js b/comm/mailnews/compose/test/unit/test_mailtoURL.js
new file mode 100644
index 0000000000..a793c99974
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_mailtoURL.js
@@ -0,0 +1,810 @@
+/*
+ * Test suite for mailto: URLs
+ */
+
+var COMPOSE_HTML = Ci.nsIMsgCompFormat.HTML;
+var COMPOSE_DEFAULT = Ci.nsIMsgCompFormat.Default;
+
+function run_test() {
+  function test(aTest) {
+    var uri = Services.io.newURI(aTest.url);
+    uri = uri.QueryInterface(Ci.nsIMailtoUrl);
+
+    var to = {},
+      cc = {},
+      bcc = {},
+      subject = {},
+      body = {},
+      html = {},
+      reference = {},
+      newsgroup = {},
+      composeformat = {};
+    uri.getMessageContents(
+      to,
+      cc,
+      bcc,
+      subject,
+      body,
+      html,
+      reference,
+      newsgroup,
+      composeformat
+    );
+    Assert.equal(aTest.to, to.value);
+    Assert.equal(aTest.cc, cc.value);
+    Assert.equal(aTest.bcc, bcc.value);
+    Assert.equal(aTest.subject, subject.value);
+    Assert.equal(aTest.body, body.value);
+    Assert.equal(aTest.html, html.value);
+    Assert.equal(aTest.reference, reference.value);
+    Assert.equal(aTest.newsgroup, newsgroup.value);
+    Assert.equal(aTest.composeformat, composeformat.value);
+    Assert.equal(aTest.from, uri.fromPart);
+    Assert.equal(aTest.followupto, uri.followUpToPart);
+    Assert.equal(aTest.organization, uri.organizationPart);
+    Assert.equal(aTest.replyto, uri.replyToPart);
+    Assert.equal(aTest.priority, uri.priorityPart);
+    Assert.equal(aTest.newshost, uri.newsHostPart);
+    Assert.ok(uri.equals(uri));
+  }
+
+  for (var i = 0; i < tests.length; i++) {
+    test(tests[i]);
+  }
+
+  // Test cloning reparses the url by checking the to field.
+  let uri = Services.io.newURI(tests[0].url).QueryInterface(Ci.nsIMailtoUrl);
+  var to = {},
+    cc = {},
+    bcc = {},
+    subject = {},
+    body = {},
+    html = {},
+    reference = {},
+    newsgroup = {},
+    composeformat = {};
+  uri.getMessageContents(
+    to,
+    cc,
+    bcc,
+    subject,
+    body,
+    html,
+    reference,
+    newsgroup,
+    composeformat
+  );
+  Assert.equal(to.value, tests[0].to);
+}
+
+var tests = [
+  {
+    url: "mailto:one@example.com",
+    to: "one@example.com",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:two@example.com?",
+    to: "two@example.com",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  /* the heirarchical-part address shouldn't be mime-decoded */
+  {
+    url: "mailto:%3D%3FUTF-8%3FQ%3Fthree%3F%3D@example.com",
+    to: "=?UTF-8?Q?three?=@example.com",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  /* a to=address should be mime-decoded */
+  {
+    url: "mailto:?to=%3D%3FUTF-8%3FQ%3Ffour%3F%3D@example.com",
+    to: "four@example.com",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:fivea@example.com?to=%3D%3FUTF-8%3FQ%3Ffiveb%3F%3D@example.com",
+    to: "fivea@example.com, fiveb@example.com",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:sixa@example.com?to=sixb@example.com&to=sixc@example.com",
+    to: "sixa@example.com, sixb@example.com, sixc@example.com",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?cc=seven@example.com",
+    to: "",
+    cc: "seven@example.com",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?cc=%3D%3FUTF-8%3FQ%3Feight%3F%3D@example.com",
+    to: "",
+    cc: "eight@example.com",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?bcc=nine@example.com",
+    to: "",
+    cc: "",
+    bcc: "nine@example.com",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?bcc=%3D%3FUTF-8%3FQ%3Ften%3F%3D@example.com",
+    to: "",
+    cc: "",
+    bcc: "ten@example.com",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?subject=foo",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "foo",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?subject=%62%61%72",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "bar",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?subject=%3D%3Futf-8%3FQ%3F%3DC2%3DA1encoded_subject%21%3F%3D",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "¡encoded subject!",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?body=one%20body",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "one body",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?body=two%20bodies&body=two%20lines",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "two bodies\ntwo lines",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?html-part=html%20part",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "html part",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_HTML,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?html-body=html%20body",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "html body",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_HTML,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?html-part=html%20part&html-body=html-body%20trumps%20earlier%20html-part",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "html-body trumps earlier html-part",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_HTML,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?references=%3Cref1%40example.com%3E",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "<ref1@example.com>",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?in-reply-to=%3Crepl1%40example.com%3E",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "<repl1@example.com>",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url:
+      "mailto:?references=%3Cref2%40example.com%3E" +
+      "&in-reply-to=%3Crepl2%40example.com%3E",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "<ref2@example.com> <repl2@example.com>",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url:
+      "mailto:?references=%3Cref3%40example.com%3E%20%3Crepl3%40example.com%3E" +
+      "&in-reply-to=%3Crepl3%40example.com%3E",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "<ref3@example.com> <repl3@example.com>",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?newsgroups=mozilla.dev.apps.thunderbird",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "mozilla.dev.apps.thunderbird",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?newsgroups=%3D%3FUTF-8%3FQ%3Fmozilla.test.multimedia%3F%3D",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "mozilla.test.multimedia",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?from=notlikely@example.com",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "notlikely@example.com",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?from=%3D%3FUTF-8%3FQ%3Fme@example.com%3F%3D",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "me@example.com",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?followup-to=mozilla.dev.planning",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "mozilla.dev.planning",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?followup-to=%3D%3FUTF-8%3FQ%3Fmozilla.test%3F%3D",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "mozilla.test",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?organization=very%20little",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "very little",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?organization=%3D%3FUTF-8%3FQ%3Fmicroscopic%3F%3D",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "microscopic",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?reply-to=notme@example.com",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "notme@example.com",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?reply-to=%3D%3FUTF-8%3FB%3Fw4VrZQ%3D%3D%3F%3D%20%3Cake@example.org%3E",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "Åke <ake@example.org>",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?priority=1%20(People%20Are%20Dying!!1!)",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "1 (People Are Dying!!1!)",
+    newshost: "",
+  },
+  {
+    url: "mailto:?priority=%3D%3FUTF-8%3FQ%3F4%3F%3D",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "4",
+    newshost: "",
+  },
+  {
+    url: "mailto:?newshost=news.mozilla.org",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "news.mozilla.org",
+  },
+  {
+    url: "mailto:?newshost=%3D%3FUTF-8%3FQ%3Fnews.example.org%3F%3D",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "news.example.org",
+  },
+  {
+    url: "mailto:?%74%4F=to&%73%55%62%4A%65%43%74=subject&%62%4F%64%59=body&%63%43=cc&%62%43%63=bcc",
+    to: "to",
+    cc: "cc",
+    bcc: "bcc",
+    subject: "subject",
+    body: "body",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:to1?%74%4F=to2&to=to3&subject=&%73%55%62%4A%65%43%74=subject&%62%4F%64%59=line1&body=line2&%63%43=cc1&cc=cc2&%62%43%63=bcc1&bcc=bcc2",
+    to: "to1, to2, to3",
+    cc: "cc1, cc2",
+    bcc: "bcc1, bcc2",
+    subject: "subject",
+    body: "line1\nline2",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url: "mailto:?nto=1&nsubject=2&nbody=3&ncc=4&nbcc=5",
+    to: "",
+    cc: "",
+    bcc: "",
+    subject: "",
+    body: "",
+    html: "",
+    reference: "",
+    newsgroup: "",
+    composeformat: COMPOSE_DEFAULT,
+    from: "",
+    followupto: "",
+    organization: "",
+    replyto: "",
+    priority: "",
+    newshost: "",
+  },
+  {
+    url:
+      "mailto:%CE%B1?cc=%CE%B2&bcc=%CE%B3&subject=%CE%B4&body=%CE%B5" +
+      "&html-body=%CE%BE&newsgroups=%CE%B6&from=%CE%B7&followup-to=%CE%B8" +
+      "&organization=%CE%B9&reply-to=%CE%BA&priority=%CE%BB&newshost=%CE%BC",
+    to: "α",
+    cc: "β",
+    bcc: "γ",
+    subject: "δ",
+    body: "ε",
+    html: "ξ",
+    reference: "", // we expect this field to be ASCII-only
+    newsgroup: "ζ",
+    composeformat: COMPOSE_HTML,
+    from: "η",
+    followupto: "θ",
+    organization: "ι",
+    replyto: "κ",
+    priority: "λ",
+    newshost: "μ",
+  },
+];
diff --git a/comm/mailnews/compose/test/unit/test_messageBody.js b/comm/mailnews/compose/test/unit/test_messageBody.js
new file mode 100644
index 0000000000..14c44b59f8
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_messageBody.js
@@ -0,0 +1,206 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Test suite for message body.
+ */
+
+localAccountUtils.loadLocalMailAccount();
+
+/**
+ * Test trailing whitespace is QP encoded.
+ */
+add_task(async function testQP() {
+  // Together with fields.forceMsgEncoding, force quote-printable encoding.
+  Services.prefs.setBoolPref("mail.strictly_mime", true);
+
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  let CompFields = CC(
+    "@mozilla.org/messengercompose/composefields;1",
+    Ci.nsIMsgCompFields
+  );
+
+  // Test QP works for ascii text.
+
+  let fields = new CompFields();
+  fields.forceMsgEncoding = true;
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Test QP encoding for trailing whitespace";
+  fields.body = "A line with trailing whitespace\t ";
+  await richCreateMessage(fields, [], identity);
+
+  let msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  Assert.ok(
+    msgData.includes("A line with trailing whitespace\t=20"),
+    "QP for ascii should work"
+  );
+
+  // Test QP works for non-ascii text.
+
+  fields = new CompFields();
+  fields.forceMsgEncoding = true;
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Test QP encoding for non-ascii and trailing tab";
+  fields.body = "記: base64 is used if unprintable > 10% \t";
+  await richCreateMessage(fields, [], identity);
+
+  msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  Assert.ok(
+    msgData.includes("=E8=A8=98: base64 is used if unprintable > 10% =09"),
+    "QP for non-ascii should work"
+  );
+
+  // Test leading space is preserved.
+
+  fields = new CompFields();
+  fields.forceMsgEncoding = true;
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Leading space is valid in a quoted printable message";
+  fields.body = "123456789" + " 123456789".repeat(6) + "1234 56789";
+  await richCreateMessage(fields, [], identity);
+
+  msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  let endOfHeaders = msgData.indexOf("\r\n\r\n");
+  let body = msgData.slice(endOfHeaders + 4);
+
+  Assert.equal(
+    body.trimRight("\r\n"),
+    "123456789 123456789 123456789 123456789 123456789 123456789 1234567891234=\r\n 56789"
+  );
+
+  Services.prefs.clearUserPref("mail.strictly_mime");
+});
+
+/**
+ * Test QP is not used together with format=flowed.
+ */
+add_task(async function testNoQPWithFormatFlowed() {
+  // Together with fields.forceMsgEncoding, force quote-printable encoding.
+  Services.prefs.setBoolPref("mail.strictly_mime", true);
+
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  fields.forceMsgEncoding = true;
+  fields.forcePlainText = true;
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Test QP encoding for trailing whitespace";
+  fields.body = "A line with trailing whitespace\t ";
+  await richCreateMessage(fields, [], identity);
+
+  let msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  Assert.ok(
+    msgData.includes(
+      "Content-Type: text/plain; charset=UTF-8; format=flowed\r\nContent-Transfer-Encoding: base64"
+    ),
+    "format=flowed should be used"
+  );
+  Assert.ok(
+    !msgData.includes("quoted-printable"),
+    "quoted-printable should not be used"
+  );
+
+  Services.prefs.clearUserPref("mail.strictly_mime");
+});
+
+/**
+ * Test plain text body is wrapped correctly with different mailnews.wraplength
+ * pref value.
+ */
+add_task(async function testWrapLength() {
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  let CompFields = CC(
+    "@mozilla.org/messengercompose/composefields;1",
+    Ci.nsIMsgCompFields
+  );
+
+  let word = "abcd ";
+  let body = word.repeat(20);
+
+  let fields = new CompFields();
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Test text wrapping";
+  fields.body = `<html><body>${body}</body></html>`;
+  fields.forcePlainText = true;
+  await richCreateMessage(fields, [], identity);
+
+  let msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  Assert.equal(
+    getMessageBody(msgData),
+    // Default wrap length is 72.
+    word.repeat(14) + "\r\n" + word.repeat(6).trim(),
+    "Text wraps at 72 by default"
+  );
+
+  // 0 means no wrap.
+  Services.prefs.setIntPref("mailnews.wraplength", 0);
+
+  await richCreateMessage(fields, [], identity);
+
+  msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  Assert.equal(
+    getMessageBody(msgData),
+    body.trim(),
+    "Should not wrap when wraplength is 0"
+  );
+
+  Services.prefs.clearUserPref("mailnews.wraplength");
+});
+
+/**
+ * Test handling of trailing NBSP.
+ */
+add_task(async function testNBSP() {
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.subject = "Test text wrapping";
+  // The character after `test` is NBSP.
+  fields.body = "<html><body>åäö test <br></body></html>";
+  fields.forcePlainText = true;
+  await richCreateMessage(fields, [], identity);
+
+  let msgData = mailTestUtils.loadMessageToUTF16String(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  Assert.equal(
+    getMessageBody(msgData),
+    "åäö test",
+    "Trailing NBSP should be removed"
+  );
+});
diff --git a/comm/mailnews/compose/test/unit/test_messageHeaders.js b/comm/mailnews/compose/test/unit/test_messageHeaders.js
new file mode 100644
index 0000000000..58765e219f
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_messageHeaders.js
@@ -0,0 +1,812 @@
+/*
+ * Test suite for ensuring that the headers of messages are set properly.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { MimeParser } = ChromeUtils.import("resource:///modules/mimeParser.jsm");
+
+var CompFields = CC(
+  "@mozilla.org/messengercompose/composefields;1",
+  Ci.nsIMsgCompFields
+);
+
+function makeAttachment(opts = {}) {
+  let attachment = Cc[
+    "@mozilla.org/messengercompose/attachment;1"
+  ].createInstance(Ci.nsIMsgAttachment);
+  for (let key in opts) {
+    attachment[key] = opts[key];
+  }
+  return attachment;
+}
+
+function sendMessage(fieldParams, identity, opts = {}, attachments = []) {
+  // Initialize compose fields
+  let fields = new CompFields();
+  for (let key in fieldParams) {
+    fields[key] = fieldParams[key];
+  }
+  for (let attachment of attachments) {
+    fields.addAttachment(attachment);
+  }
+
+  // Initialize compose params
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+  params.composeFields = fields;
+  for (let key in opts) {
+    params[key] = opts[key];
+  }
+
+  // Send the message
+  let msgCompose = MailServices.compose.initCompose(params);
+  let progress = Cc["@mozilla.org/messenger/progress;1"].createInstance(
+    Ci.nsIMsgProgress
+  );
+  let promise = new Promise((resolve, reject) => {
+    progressListener.resolve = resolve;
+    progressListener.reject = reject;
+  });
+  progress.registerListener(progressListener);
+  msgCompose.sendMsg(
+    Ci.nsIMsgSend.nsMsgDeliverNow,
+    identity,
+    "",
+    null,
+    progress
+  );
+  return promise;
+}
+
+function checkDraftHeaders(expectedHeaders, partNum = "") {
+  let msgData = mailTestUtils.loadMessageToString(
+    gDraftFolder,
+    mailTestUtils.firstMsgHdr(gDraftFolder)
+  );
+  checkMessageHeaders(msgData, expectedHeaders, partNum);
+}
+
+function checkMessageHeaders(msgData, expectedHeaders, partNum = "") {
+  let seen = false;
+  let handler = {
+    startPart(part, headers) {
+      if (part != partNum) {
+        return;
+      }
+      seen = true;
+      for (let header in expectedHeaders) {
+        let expected = expectedHeaders[header];
+        if (expected === undefined) {
+          Assert.ok(
+            !headers.has(header),
+            `Should not have header named "${header}"`
+          );
+        } else {
+          let value = headers.getRawHeader(header);
+          Assert.equal(
+            value && value.length,
+            1,
+            `Should have exactly one header named "${header}"`
+          );
+          value[0] = value[0].replace(/boundary=[^;]*(;|$)/, "boundary=.");
+          Assert.equal(value[0], expected);
+        }
+      }
+    },
+  };
+  MimeParser.parseSync(msgData, handler, {
+    onerror(e) {
+      throw e;
+    },
+  });
+  Assert.ok(seen);
+}
+
+async function testEnvelope() {
+  let fields = new CompFields();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  identity.fullName = "Me";
+  identity.organization = "World Destruction Committee";
+  fields.from = "Nobody <nobody@tinderbox.invalid>";
+  fields.to = "Nobody <nobody@tinderbox.invalid>";
+  fields.cc = "Alex <alex@tinderbox.invalid>";
+  fields.bcc = "Boris <boris@tinderbox.invalid>";
+  fields.replyTo = "Charles <charles@tinderbox.invalid>";
+  fields.organization = "World Salvation Committee";
+  fields.subject = "This is an obscure reference";
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    // As of bug 87987, the identity does not override the from header.
+    From: "Nobody <nobody@tinderbox.invalid>",
+    // The identity should override the organization field here.
+    Organization: "World Destruction Committee",
+    To: "Nobody <nobody@tinderbox.invalid>",
+    Cc: "Alex <alex@tinderbox.invalid>",
+    Bcc: "Boris <boris@tinderbox.invalid>",
+    "Reply-To": "Charles <charles@tinderbox.invalid>",
+    Subject: "This is an obscure reference",
+  });
+}
+
+async function testI18NEnvelope() {
+  let fields = new CompFields();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  identity.fullName = "ケツァルコアトル";
+  identity.organization = "Comité de la destruction du monde";
+  fields.to = "Émile <nobody@tinderbox.invalid>";
+  fields.cc = "André Chopin <alex@tinderbox.invalid>";
+  fields.bcc = "Étienne <boris@tinderbox.invalid>";
+  fields.replyTo = "Frédéric <charles@tinderbox.invalid>";
+  fields.subject = "Ceci n'est pas un référence obscure";
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    From: "=?UTF-8?B?44Kx44OE44Kh44Or44Kz44Ki44OI44Or?= <from@tinderbox.invalid>",
+    Organization: "=?UTF-8?Q?Comit=C3=A9_de_la_destruction_du_monde?=",
+    To: "=?UTF-8?B?w4ltaWxl?= <nobody@tinderbox.invalid>",
+    Cc: "=?UTF-8?Q?Andr=C3=A9_Chopin?= <alex@tinderbox.invalid>",
+    Bcc: "=?UTF-8?Q?=C3=89tienne?= <boris@tinderbox.invalid>",
+    "Reply-To": "=?UTF-8?B?RnLDqWTDqXJpYw==?= <charles@tinderbox.invalid>",
+    Subject: "=?UTF-8?Q?Ceci_n=27est_pas_un_r=C3=A9f=C3=A9rence_obscure?=",
+  });
+}
+
+async function testIDNEnvelope() {
+  let fields = new CompFields();
+  let domain = "ケツァルコアトル.invalid";
+  // We match against rawHeaderText, so we need to encode the string as a binary
+  // string instead of a unicode string.
+  let utf8Domain = String.fromCharCode.apply(
+    undefined,
+    new TextEncoder("UTF-8").encode(domain)
+  );
+  // Bug 1034658: nsIMsgIdentity doesn't like IDN in its email addresses.
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  fields.to = "Nobody <nobody@" + domain + ">";
+  fields.cc = "Alex <alex@" + domain + ">";
+  fields.bcc = "Boris <boris@" + domain + ">";
+  fields.replyTo = "Charles <charles@" + domain + ">";
+  fields.subject = "This is an obscure reference";
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    // The identity sets the from field here.
+    From: "from@tinderbox.invalid",
+    To: "Nobody <nobody@" + utf8Domain + ">",
+    Cc: "Alex <alex@" + utf8Domain + ">",
+    Bcc: "Boris <boris@" + utf8Domain + ">",
+    "Reply-To": "Charles <charles@" + utf8Domain + ">",
+    Subject: "This is an obscure reference",
+  });
+}
+
+async function testDraftInfo() {
+  let fields = new CompFields();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    FCC: identity.fccFolder,
+    "X-Identity-Key": identity.key,
+    "X-Mozilla-Draft-Info":
+      "internal/draft; " +
+      "vcard=0; receipt=0; DSN=0; uuencode=0; attachmentreminder=0; deliveryformat=4",
+  });
+
+  fields.attachVCard = true;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "X-Mozilla-Draft-Info":
+      "internal/draft; " +
+      "vcard=1; receipt=0; DSN=0; uuencode=0; attachmentreminder=0; deliveryformat=4",
+  });
+
+  fields.returnReceipt = true;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "X-Mozilla-Draft-Info":
+      "internal/draft; " +
+      "vcard=1; receipt=1; DSN=0; uuencode=0; attachmentreminder=0; deliveryformat=4",
+  });
+
+  fields.DSN = true;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "X-Mozilla-Draft-Info":
+      "internal/draft; " +
+      "vcard=1; receipt=1; DSN=1; uuencode=0; attachmentreminder=0; deliveryformat=4",
+  });
+
+  fields.attachmentReminder = true;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "X-Mozilla-Draft-Info":
+      "internal/draft; " +
+      "vcard=1; receipt=1; DSN=1; uuencode=0; attachmentreminder=1; deliveryformat=4",
+  });
+
+  fields.deliveryFormat = Ci.nsIMsgCompSendFormat.Both;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "X-Mozilla-Draft-Info":
+      "internal/draft; " +
+      "vcard=1; receipt=1; DSN=1; uuencode=0; attachmentreminder=1; deliveryformat=3",
+  });
+}
+
+async function testOtherHeadersAgentParam(sendAgent, minimalAgent) {
+  Services.prefs.setBoolPref("mailnews.headers.sendUserAgent", sendAgent);
+  if (sendAgent) {
+    Services.prefs.setBoolPref(
+      "mailnews.headers.useMinimalUserAgent",
+      minimalAgent
+    );
+  }
+
+  let fields = new CompFields();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  fields.priority = "high";
+  fields.references = "<fake@tinderbox.invalid> <more@test.invalid>";
+  fields.setHeader("X-Fake-Header", "124");
+  let before = Date.now();
+  let msgHdr = await richCreateMessage(fields, [], identity);
+  let after = Date.now();
+  let msgData = mailTestUtils.loadMessageToString(msgHdr.folder, msgHdr);
+  let expectedAgent = undefined; // !sendAgent
+  if (sendAgent) {
+    if (minimalAgent) {
+      expectedAgent = Services.strings
+        .createBundle("chrome://branding/locale/brand.properties")
+        .GetStringFromName("brandFullName");
+    } else {
+      expectedAgent = Cc[
+        "@mozilla.org/network/protocol;1?name=http"
+      ].getService(Ci.nsIHttpProtocolHandler).userAgent;
+    }
+  }
+  checkMessageHeaders(msgData, {
+    "Mime-Version": "1.0",
+    "User-Agent": expectedAgent,
+    "X-Priority": "2 (High)",
+    References: "<fake@tinderbox.invalid> <more@test.invalid>",
+    "In-Reply-To": "<more@test.invalid>",
+    "X-Fake-Header": "124",
+  });
+
+  // Check headers with dynamic content
+  let headers = MimeParser.extractHeaders(msgData);
+  Assert.ok(headers.has("Message-Id"));
+  Assert.ok(
+    headers.getRawHeader("Message-Id")[0].endsWith("@tinderbox.invalid>")
+  );
+  // This is a very special crafted check. We don't know when the message was
+  // actually created, but we have bounds on it, from above. From
+  // experimentation, there are a few ways you can create dates that Date.parse
+  // can't handle (specifically related to how 2-digit years). However, the
+  // optimal RFC 5322 form is supported by Date.parse. If Date.parse fails, we
+  // have a form that we shouldn't be using anyways.
+  let date = new Date(headers.getRawHeader("Date")[0]);
+  // If we have clock skew within the test, then our results are going to be
+  // meaningless. Hopefully, this is only rarely the case.
+  if (before > after) {
+    info("Clock skew detected, skipping date check");
+  } else {
+    // In case this all took place within one second, remove sub-millisecond
+    // timing (Date headers only carry second-level precision).
+    before = before - (before % 1000);
+    after = after - (after % 1000);
+    info(before + " <= " + date + " <= " + after + "?");
+    Assert.ok(before <= date && date <= after);
+  }
+
+  // We truncate too-long References. Check this.
+  let references = [];
+  for (let i = 0; i < 100; i++) {
+    references.push("<" + i + "@test.invalid>");
+  }
+  let expected = references.slice(47);
+  expected.unshift(references[0]);
+  fields.references = references.join(" ");
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    References: expected.join(" "),
+    "In-Reply-To": references[references.length - 1],
+  });
+}
+
+/**
+ * Tests that the domain for the Message-Id header defaults to the domain of the
+ * identity's address.
+ */
+async function testMessageIdUseIdentityAddress() {
+  const expectedMessageIdHostname = "tinderbox.test";
+
+  const identity = getSmtpIdentity(
+    `from@${expectedMessageIdHostname}`,
+    getBasicSmtpServer()
+  );
+
+  await createMsgAndCompareMessageId(identity, null, expectedMessageIdHostname);
+}
+
+/**
+ * Tests that if a custom address (with a custom domain) is used when composing a
+ * message, the domain in this address takes precendence over the domain of the
+ * identity's address to generate the value for the Message-Id header.
+ */
+async function testMessageIdUseFromDomain() {
+  const expectedMessageIdHostname = "another-tinderbox.test";
+
+  const identity = getSmtpIdentity("from@tinderbox.test", getBasicSmtpServer());
+
+  // Set the From header to an address that uses a different domain than
+  // the identity.
+  const fields = new CompFields();
+  fields.from = `Nobody <nobody@${expectedMessageIdHostname}>`;
+
+  await createMsgAndCompareMessageId(
+    identity,
+    fields,
+    expectedMessageIdHostname
+  );
+}
+
+/**
+ * Tests that if the identity has a "FQDN" attribute, it takes precedence to use as the
+ * domain for the Message-Id header over any other domain or address.
+ */
+async function testMessageIdUseIdentityAttribute() {
+  const expectedMessageIdHostname = "my-custom-fqdn.test";
+
+  const identity = getSmtpIdentity("from@tinderbox.test", getBasicSmtpServer());
+  identity.setCharAttribute("FQDN", expectedMessageIdHostname);
+
+  // Set the From header to an address that uses a different domain than
+  // the identity.
+  const fields = new CompFields();
+  fields.from = "Nobody <nobody@another-tinderbox.test>";
+
+  await createMsgAndCompareMessageId(
+    identity,
+    fields,
+    expectedMessageIdHostname
+  );
+}
+
+/**
+ * Util function to create a message using the given identity and fields,
+ * and test that the message ID that was generated for it has the correct
+ * host name.
+ *
+ * @param {nsIMsgIdentity} identity - The identity to use to create the message.
+ * @param {?nsIMsgCompFields} fields - The compose fields to use. If not provided,
+ *   default fields are used.
+ * @param {string} expectedMessageIdHostname - The expected host name of the
+ *   Message-Id header.
+ */
+async function createMsgAndCompareMessageId(
+  identity,
+  fields,
+  expectedMessageIdHostname
+) {
+  if (!fields) {
+    fields = new CompFields();
+  }
+
+  let msgHdr = await richCreateMessage(fields, [], identity);
+  let msgData = mailTestUtils.loadMessageToString(msgHdr.folder, msgHdr);
+  let headers = MimeParser.extractHeaders(msgData);
+
+  // As of bug 1727181, the identity does not override the message-id header.
+  Assert.ok(headers.has("Message-Id"), "the message has a Message-Id header");
+  Assert.ok(
+    headers
+      .getRawHeader("Message-Id")[0]
+      .endsWith(`@${expectedMessageIdHostname}>`),
+    `the hostname for the Message-Id header should be ${expectedMessageIdHostname}`
+  );
+}
+
+async function testOtherHeadersFullAgent() {
+  await testOtherHeadersAgentParam(true, false);
+}
+
+async function testOtherHeadersMinimalAgent() {
+  await testOtherHeadersAgentParam(true, true);
+}
+
+async function testOtherHeadersNoAgent() {
+  await testOtherHeadersAgentParam(false, undefined);
+}
+
+async function testNewsgroups() {
+  let fields = new CompFields();
+  let nntpServer = localAccountUtils.create_incoming_server(
+    "nntp",
+    534,
+    "",
+    ""
+  );
+  nntpServer
+    .QueryInterface(Ci.nsINntpIncomingServer)
+    .subscribeToNewsgroup("mozilla.test");
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  fields.newsgroups = "mozilla.test, mozilla.test.multimedia";
+  fields.followupTo = "mozilla.test";
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    // The identity should override the compose fields here.
+    Newsgroups: "mozilla.test,mozilla.test.multimedia",
+    "Followup-To": "mozilla.test",
+    "X-Mozilla-News-Host": "localhost",
+  });
+}
+
+async function testSendHeaders() {
+  let fields = new CompFields();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  identity.setCharAttribute("headers", "bah,humbug");
+  identity.setCharAttribute(
+    "header.bah",
+    "X-Custom-1: A header value: with a colon"
+  );
+  identity.setUnicharAttribute("header.humbug", "X-Custom-2: Enchanté");
+  identity.setCharAttribute("subscribed_mailing_lists", "list@test.invalid");
+  identity.setCharAttribute(
+    "replyto_mangling_mailing_lists",
+    "replyto@test.invalid"
+  );
+  fields.to = "list@test.invalid";
+  fields.cc = "not-list@test.invalid";
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "X-Custom-1": "A header value: with a colon",
+    "X-Custom-2": "=?UTF-8?B?RW5jaGFudMOp?=",
+    "Mail-Followup-To": "list@test.invalid, not-list@test.invalid",
+    "Mail-Reply-To": undefined,
+  });
+
+  // Don't set the M-F-T header if there's no list.
+  fields.to = "replyto@test.invalid";
+  fields.cc = "";
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "X-Custom-1": "A header value: with a colon",
+    "X-Custom-2": "=?UTF-8?B?RW5jaGFudMOp?=",
+    "Mail-Reply-To": "from@tinderbox.invalid",
+    "Mail-Followup-To": undefined,
+  });
+}
+
+async function testContentHeaders() {
+  // Disable RFC 2047 fallback
+  Services.prefs.setIntPref("mail.strictly_mime.parm_folding", 2);
+  let fields = new CompFields();
+  fields.body = "A body";
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "Content-Type": "text/html; charset=UTF-8",
+    "Content-Transfer-Encoding": "7bit",
+  });
+
+  // non-ASCII body should be 8-bit...
+  fields.body = "Archæologist";
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "Content-Type": "text/html; charset=UTF-8",
+    "Content-Transfer-Encoding": "8bit",
+  });
+
+  // Attachments
+  fields.body = "";
+  let plainAttachment = makeAttachment({
+    url: "data:text/plain,oïl",
+    name: "attachment.txt",
+  });
+  let plainAttachmentHeaders = {
+    "Content-Type": "text/plain; charset=UTF-8",
+    "Content-Transfer-Encoding": "base64",
+    "Content-Disposition": 'attachment; filename="attachment.txt"',
+  };
+  await richCreateMessage(fields, [plainAttachment], identity);
+  checkDraftHeaders(
+    {
+      "Content-Type": "text/html; charset=UTF-8",
+      "Content-Transfer-Encoding": "7bit",
+    },
+    "1"
+  );
+  checkDraftHeaders(plainAttachmentHeaders, "2");
+
+  plainAttachment.name = "oïl.txt";
+  plainAttachmentHeaders["Content-Disposition"] =
+    "attachment; filename*=UTF-8''%6F%C3%AF%6C%2E%74%78%74";
+  await richCreateMessage(fields, [plainAttachment], identity);
+  checkDraftHeaders(plainAttachmentHeaders, "2");
+
+  plainAttachment.name = "\ud83d\udca9.txt";
+  plainAttachmentHeaders["Content-Disposition"] =
+    "attachment; filename*=UTF-8''%F0%9F%92%A9%2E%74%78%74";
+  await richCreateMessage(fields, [plainAttachment], identity);
+  checkDraftHeaders(plainAttachmentHeaders, "2");
+
+  let httpAttachment = makeAttachment({
+    url: "data:text/html,<html></html>",
+    name: "attachment.html",
+  });
+  let httpAttachmentHeaders = {
+    "Content-Type": "text/html; charset=UTF-8",
+    "Content-Disposition": 'attachment; filename="attachment.html"',
+    "Content-Location": "data:text/html,<html></html>",
+  };
+  await richCreateMessage(fields, [httpAttachment], identity);
+  checkDraftHeaders(
+    {
+      "Content-Location": undefined,
+    },
+    "1"
+  );
+  checkDraftHeaders(httpAttachmentHeaders, "2");
+
+  let cloudAttachment = makeAttachment({
+    url: Services.io.newFileURI(do_get_file("data/test-UTF-8.txt")).spec,
+    sendViaCloud: true,
+    htmlAnnotation:
+      "<html><body>This is an html placeholder file.</body></html>",
+    cloudFileAccountKey: "akey",
+    cloudPartHeaderData: "0123456789ABCDE",
+    name: "attachment.html",
+    contentLocation: "http://localhost.invalid/",
+  });
+  let cloudAttachmentHeaders = {
+    "Content-Type": "text/html; charset=utf-8",
+    "X-Mozilla-Cloud-Part":
+      "cloudFile; " +
+      "url=http://localhost.invalid/; " +
+      "provider=akey; " +
+      'data="0123456789ABCDE"',
+  };
+  await richCreateMessage(fields, [cloudAttachment], identity);
+  checkDraftHeaders(cloudAttachmentHeaders, "2");
+
+  // Cloud attachment with non-ascii file name.
+  cloudAttachment = makeAttachment({
+    url: Services.io.newFileURI(do_get_file("data/test-UTF-8.txt")).spec,
+    sendViaCloud: true,
+    htmlAnnotation:
+      "<html><body>This is an html placeholder file.</body></html>",
+    cloudFileAccountKey: "akey",
+    cloudPartHeaderData: "0123456789ABCDE",
+    name: "ファイル.txt",
+    contentLocation: "http://localhost.invalid/",
+  });
+  cloudAttachmentHeaders = {
+    "Content-Type": "text/html; charset=utf-8",
+    "X-Mozilla-Cloud-Part":
+      "cloudFile; " +
+      "url=http://localhost.invalid/; " +
+      "provider=akey; " +
+      'data="0123456789ABCDE"',
+  };
+  await richCreateMessage(fields, [cloudAttachment], identity);
+  checkDraftHeaders(cloudAttachmentHeaders, "2");
+
+  // Some multipart/alternative tests.
+  fields.body = "Some text";
+  fields.forcePlainText = false;
+  fields.useMultipartAlternative = true;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "Content-Type": "multipart/alternative; boundary=.",
+  });
+  checkDraftHeaders(
+    {
+      "Content-Type": "text/plain; charset=UTF-8; format=flowed",
+      "Content-Transfer-Encoding": "7bit",
+    },
+    "1"
+  );
+  checkDraftHeaders(
+    {
+      "Content-Type": "text/html; charset=UTF-8",
+      "Content-Transfer-Encoding": "7bit",
+    },
+    "2"
+  );
+
+  // multipart/mixed
+  // + multipart/alternative
+  //   + text/plain
+  //   + text/html
+  // + text/plain attachment
+  await richCreateMessage(fields, [plainAttachment], identity);
+  checkDraftHeaders({
+    "Content-Type": "multipart/mixed; boundary=.",
+  });
+  checkDraftHeaders(
+    {
+      "Content-Type": "multipart/alternative; boundary=.",
+    },
+    "1"
+  );
+  checkDraftHeaders(
+    {
+      "Content-Type": "text/plain; charset=UTF-8; format=flowed",
+      "Content-Transfer-Encoding": "7bit",
+    },
+    "1.1"
+  );
+  checkDraftHeaders(
+    {
+      "Content-Type": "text/html; charset=UTF-8",
+      "Content-Transfer-Encoding": "7bit",
+    },
+    "1.2"
+  );
+  checkDraftHeaders(plainAttachmentHeaders, "2");
+
+  // Three attachments, and a multipart/alternative. Oh the humanity!
+  await richCreateMessage(
+    fields,
+    [plainAttachment, httpAttachment, cloudAttachment],
+    identity
+  );
+  checkDraftHeaders({
+    "Content-Type": "multipart/mixed; boundary=.",
+  });
+  checkDraftHeaders(
+    {
+      "Content-Type": "multipart/alternative; boundary=.",
+    },
+    "1"
+  );
+  checkDraftHeaders(
+    {
+      "Content-Type": "text/plain; charset=UTF-8; format=flowed",
+      "Content-Transfer-Encoding": "7bit",
+    },
+    "1.1"
+  );
+  checkDraftHeaders(
+    {
+      "Content-Type": "text/html; charset=UTF-8",
+      "Content-Transfer-Encoding": "7bit",
+    },
+    "1.2"
+  );
+  checkDraftHeaders(plainAttachmentHeaders, "2");
+  checkDraftHeaders(httpAttachmentHeaders, "3");
+  checkDraftHeaders(cloudAttachmentHeaders, "4");
+
+  // Test a request for plain text with text/html.
+  fields.forcePlainText = true;
+  fields.useMultipartAlternative = false;
+  await richCreateMessage(fields, [], identity);
+  checkDraftHeaders({
+    "Content-Type": "text/plain; charset=UTF-8; format=flowed",
+    "Content-Transfer-Encoding": "7bit",
+  });
+}
+
+async function testSentMessage() {
+  let server = setupServerDaemon();
+  let daemon = server._daemon;
+  server.start();
+  try {
+    let localserver = getBasicSmtpServer(server.port);
+    let identity = getSmtpIdentity("test@tinderbox.invalid", localserver);
+    await sendMessage(
+      {
+        to: "Nobody <nobody@tinderbox.invalid>",
+        cc: "Alex <alex@tinderbox.invalid>",
+        bcc: "Boris <boris@tinderbox.invalid>",
+        replyTo: "Charles <charles@tinderbox.invalid>",
+      },
+      identity,
+      {},
+      []
+    );
+    checkMessageHeaders(daemon.post, {
+      From: "test@tinderbox.invalid",
+      To: "Nobody <nobody@tinderbox.invalid>",
+      Cc: "Alex <alex@tinderbox.invalid>",
+      Bcc: undefined,
+      "Reply-To": "Charles <charles@tinderbox.invalid>",
+      "X-Mozilla-Status": undefined,
+      "X-Mozilla-Keys": undefined,
+      "X-Mozilla-Draft-Info": undefined,
+      Fcc: undefined,
+    });
+    server.resetTest();
+    await sendMessage({ bcc: "Somebody <test@tinderbox.invalid" }, identity);
+    checkMessageHeaders(daemon.post, {
+      To: "undisclosed-recipients: ;",
+    });
+    server.resetTest();
+    await sendMessage(
+      {
+        to: "Somebody <test@tinderbox.invalid>",
+        returnReceipt: true,
+        receiptHeaderType: Ci.nsIMsgMdnGenerator.eDntRrtType,
+      },
+      identity
+    );
+    checkMessageHeaders(daemon.post, {
+      "Disposition-Notification-To": "test@tinderbox.invalid",
+      "Return-Receipt-To": "test@tinderbox.invalid",
+    });
+    server.resetTest();
+    let cloudAttachment = makeAttachment({
+      url: Services.io.newFileURI(do_get_file("data/test-UTF-8.txt")).spec,
+      sendViaCloud: true,
+      htmlAnnotation:
+        "<html><body>This is an html placeholder file.</body></html>",
+      cloudFileAccountKey: "akey",
+      cloudPartHeaderData: "0123456789ABCDE",
+      name: "attachment.html",
+      contentLocation: "http://localhost.invalid/",
+    });
+    await sendMessage({ to: "test@tinderbox.invalid" }, identity, {}, [
+      cloudAttachment,
+    ]);
+    checkMessageHeaders(
+      daemon.post,
+      {
+        "Content-Type": "text/html; charset=utf-8",
+        "X-Mozilla-Cloud-Part": "cloudFile; url=http://localhost.invalid/",
+      },
+      "2"
+    );
+  } finally {
+    server.stop();
+  }
+}
+
+var tests = [
+  testEnvelope,
+  testI18NEnvelope,
+  testIDNEnvelope,
+  testDraftInfo,
+  testOtherHeadersFullAgent,
+  testOtherHeadersMinimalAgent,
+  testOtherHeadersNoAgent,
+  testNewsgroups,
+  testSendHeaders,
+  testContentHeaders,
+  testSentMessage,
+  testMessageIdUseIdentityAddress,
+  testMessageIdUseFromDomain,
+  testMessageIdUseIdentityAttribute,
+];
+
+function run_test() {
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+  tests.forEach(x => add_task(x));
+  run_next_test();
+}
diff --git a/comm/mailnews/compose/test/unit/test_nsIMsgCompFields.js b/comm/mailnews/compose/test/unit/test_nsIMsgCompFields.js
new file mode 100644
index 0000000000..69c1b753b6
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_nsIMsgCompFields.js
@@ -0,0 +1,62 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Test that nsIMsgCompFields works properly
+
+var nsMsgCompFields = Components.Constructor(
+  "@mozilla.org/messengercompose/composefields;1",
+  Ci.nsIMsgCompFields
+);
+
+function check_headers(enumerator, container) {
+  let checkValues = new Set(container.map(header => header.toLowerCase()));
+  for (let value of enumerator) {
+    value = value.toLowerCase();
+    Assert.ok(checkValues.has(value));
+    checkValues.delete(value);
+  }
+  Assert.equal(checkValues.size, 0);
+}
+
+function run_test() {
+  let fields = new nsMsgCompFields();
+  Assert.ok(fields instanceof Ci.nsIMsgCompFields);
+  Assert.ok(fields instanceof Ci.msgIStructuredHeaders);
+  Assert.ok(fields instanceof Ci.msgIWritableStructuredHeaders);
+  check_headers(fields.headerNames, []);
+  Assert.ok(!fields.hasRecipients);
+
+  // Try some basic headers
+  fields.setHeader("From", [{ name: "", email: "a@test.invalid" }]);
+  let from = fields.getHeader("from");
+  Assert.equal(from.length, 1);
+  Assert.equal(from[0].email, "a@test.invalid");
+  check_headers(fields.headerNames, ["From"]);
+  Assert.ok(!fields.hasRecipients);
+
+  // Add a To header
+  fields.setHeader("To", [{ name: "", email: "b@test.invalid" }]);
+  check_headers(fields.headerNames, ["From", "To"]);
+  Assert.ok(fields.hasRecipients);
+
+  // Delete a header...
+  fields.deleteHeader("from");
+  Assert.equal(fields.getHeader("From"), undefined);
+  check_headers(fields.headerNames, ["To"]);
+
+  // Subject should work and not convert to RFC 2047.
+  fields.subject = "\u79c1\u306f\u4ef6\u540d\u5348\u524d";
+  Assert.equal(fields.subject, "\u79c1\u306f\u4ef6\u540d\u5348\u524d");
+  Assert.equal(
+    fields.getHeader("Subject"),
+    "\u79c1\u306f\u4ef6\u540d\u5348\u524d"
+  );
+
+  // Check header synchronization.
+  fields.from = "a@test.invalid";
+  Assert.equal(fields.from, "a@test.invalid");
+  Assert.equal(fields.getHeader("From")[0].email, "a@test.invalid");
+  fields.from = null;
+  Assert.equal(fields.getHeader("From"), undefined);
+}
diff --git a/comm/mailnews/compose/test/unit/test_nsMsgCompose1.js b/comm/mailnews/compose/test/unit/test_nsMsgCompose1.js
new file mode 100644
index 0000000000..700232b46e
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_nsMsgCompose1.js
@@ -0,0 +1,137 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+
+/**
+ * Tests nsMsgCompose expandMailingLists.
+ */
+
+/**
+ * Helper to check population worked as expected.
+ *
+ * @param {string} aTo - Text in the To field.
+ * @param {string} aCheckTo - The expected To addresses (after possible list population)
+ */
+function checkPopulate(aTo, aCheckTo) {
+  var msgCompose = Cc["@mozilla.org/messengercompose/compose;1"].createInstance(
+    Ci.nsIMsgCompose
+  );
+
+  // Set up some basic fields for compose.
+  var fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+
+  fields.to = aTo;
+
+  // Set up some params
+  var params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+
+  params.composeFields = fields;
+
+  msgCompose.initialize(params);
+
+  msgCompose.expandMailingLists();
+  let addresses = fields.getHeader("To");
+  let checkEmails = MailServices.headerParser.parseDecodedHeader(aCheckTo);
+  Assert.equal(addresses.length, checkEmails.length);
+  for (let i = 0; i < addresses.length; i++) {
+    Assert.equal(addresses[i].name, checkEmails[i].name);
+    Assert.equal(addresses[i].email, checkEmails[i].email);
+  }
+}
+
+function run_test() {
+  loadABFile("../../../data/abLists1", kPABData.fileName);
+  loadABFile("../../../data/abLists2", kCABData.fileName);
+
+  // Test - Check we can initialize with fewest specified
+  // parameters and don't fail/crash like we did in bug 411646.
+
+  var msgCompose = Cc["@mozilla.org/messengercompose/compose;1"].createInstance(
+    Ci.nsIMsgCompose
+  );
+
+  // Set up some params
+  var params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+
+  msgCompose.initialize(params);
+
+  // Test - expandMailingLists basic functionality.
+
+  // Re-initialize
+  msgCompose = Cc["@mozilla.org/messengercompose/compose;1"].createInstance(
+    Ci.nsIMsgCompose
+  );
+
+  // Set up some basic fields for compose.
+  var fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+
+  // These aren't in the address book copied above.
+  fields.from = "test1@foo1.invalid";
+  fields.to = "test2@foo1.invalid";
+  fields.cc = "test3@foo1.invalid";
+  fields.bcc = "test4@foo1.invalid";
+
+  // Set up some params
+  params = Cc["@mozilla.org/messengercompose/composeparams;1"].createInstance(
+    Ci.nsIMsgComposeParams
+  );
+
+  params.composeFields = fields;
+
+  msgCompose.initialize(params);
+
+  msgCompose.expandMailingLists();
+  Assert.equal(fields.to, "test2@foo1.invalid");
+  Assert.equal(fields.cc, "test3@foo1.invalid");
+  Assert.equal(fields.bcc, "test4@foo1.invalid");
+
+  // Test - expandMailingLists with plain text.
+
+  checkPopulate("test4@foo.invalid", "test4@foo.invalid");
+
+  // Test - expandMailingLists with html.
+
+  checkPopulate("test5@foo.invalid", "test5@foo.invalid");
+
+  // Test - expandMailingLists with a list of three items.
+
+  checkPopulate(
+    "TestList1 <TestList1>",
+    "test1@foo.invalid,test2@foo.invalid,test3@foo.invalid"
+  );
+
+  // Test - expandMailingLists with a list of one item.
+
+  checkPopulate("TestList2 <TestList2>", "test4@foo.invalid");
+
+  checkPopulate("TestList3 <TestList3>", "test5@foo.invalid");
+
+  // Test - expandMailingLists with items from multiple address books.
+
+  checkPopulate(
+    "TestList1 <TestList1>, test3@com.invalid",
+    "test1@foo.invalid,test2@foo.invalid,test3@foo.invalid,test3@com.invalid"
+  );
+
+  checkPopulate(
+    "TestList2 <TestList2>, ListTest2 <ListTest2>",
+    "test4@foo.invalid,test4@com.invalid"
+  );
+
+  checkPopulate(
+    "TestList3 <TestList3>, ListTest1 <ListTest1>",
+    "test5@foo.invalid,test1@com.invalid,test2@com.invalid,test3@com.invalid"
+  );
+
+  // test bug 254519 rfc 2047 encoding
+  checkPopulate(
+    "=?iso-8859-1?Q?Sure=F6name=2C_Forename_Dr=2E?= <pb@bieringer.invalid>",
+    '"Sure\u00F6name, Forename Dr." <pb@bieringer.invalid>'
+  );
+}
diff --git a/comm/mailnews/compose/test/unit/test_nsMsgCompose2.js b/comm/mailnews/compose/test/unit/test_nsMsgCompose2.js
new file mode 100644
index 0000000000..5f234444b8
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_nsMsgCompose2.js
@@ -0,0 +1,132 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Test suite for nsMsgCompose functions relating to send listeners.
+ */
+
+let gMsgCompose = null;
+let numSendListenerFunctions = 7;
+
+let gSLAll = new Array(numSendListenerFunctions + 1);
+
+function sendListener() {}
+
+sendListener.prototype = {
+  mReceived: 0,
+  mAutoRemoveItem: 0,
+
+  onStartSending(aMsgID, aMsgSize) {
+    this.mReceived |= 0x01;
+    if (this.mAutoRemoveItem == 0x01) {
+      gMsgCompose.removeMsgSendListener(this);
+    }
+  },
+  onProgress(aMsgID, aProgress, aProgressMax) {
+    this.mReceived |= 0x02;
+    if (this.mAutoRemoveItem == 0x02) {
+      gMsgCompose.removeMsgSendListener(this);
+    }
+  },
+  onStatus(aMsgID, aMsg) {
+    this.mReceived |= 0x04;
+    if (this.mAutoRemoveItem == 0x04) {
+      gMsgCompose.removeMsgSendListener(this);
+    }
+  },
+  onStopSending(aMsgID, aStatus, aMsg, aReturnFile) {
+    this.mReceived |= 0x08;
+    if (this.mAutoRemoveItem == 0x08) {
+      gMsgCompose.removeMsgSendListener(this);
+    }
+  },
+  onGetDraftFolderURI(aMsgID, aFolderURI) {
+    this.mReceived |= 0x10;
+    if (this.mAutoRemoveItem == 0x10) {
+      gMsgCompose.removeMsgSendListener(this);
+    }
+  },
+  onSendNotPerformed(aMsgID, aStatus) {
+    this.mReceived |= 0x20;
+    if (this.mAutoRemoveItem == 0x20) {
+      gMsgCompose.removeMsgSendListener(this);
+    }
+  },
+  onTransportSecurityError(msgID, status, secInfo, location) {
+    this.mReceived |= 0x40;
+    if (this.mAutoRemoveItem == 0x40) {
+      gMsgCompose.removeMsgSendListener(this);
+    }
+  },
+};
+
+function NotifySendListeners() {
+  gMsgCompose.onStartSending(null, null);
+  gMsgCompose.onProgress(null, null, null);
+  gMsgCompose.onStatus(null, null);
+  gMsgCompose.onStopSending(null, null, null, null);
+  gMsgCompose.onGetDraftFolderURI(null, null);
+  gMsgCompose.onSendNotPerformed(null, null);
+  gMsgCompose.onTransportSecurityError(null, null, null, "");
+}
+
+function run_test() {
+  gMsgCompose = Cc["@mozilla.org/messengercompose/compose;1"].createInstance(
+    Ci.nsIMsgCompose
+  );
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+  gMsgCompose.initialize(params);
+
+  Assert.ok(gMsgCompose != null);
+
+  // Test - Add a listener
+
+  for (let i = 0; i < numSendListenerFunctions + 1; ++i) {
+    gSLAll[i] = new sendListener();
+    gMsgCompose.addMsgSendListener(gSLAll[i]);
+  }
+
+  // Test - Notify all listeners
+
+  NotifySendListeners();
+
+  const bitMask = (1 << numSendListenerFunctions) - 1;
+  for (let i = 0; i < numSendListenerFunctions + 1; ++i) {
+    Assert.equal(gSLAll[i].mReceived, bitMask);
+    gSLAll[i].mReceived = 0;
+
+    // And prepare for test 3.
+    gSLAll[i].mAutoRemoveItem = 1 << i;
+  }
+
+  // Test - Remove some listeners as we go
+
+  NotifySendListeners();
+
+  let currentReceived = 0;
+
+  for (let i = 0; i < numSendListenerFunctions + 1; ++i) {
+    if (i < numSendListenerFunctions) {
+      currentReceived += 1 << i;
+    }
+
+    Assert.equal(gSLAll[i].mReceived, currentReceived);
+    gSLAll[i].mReceived = 0;
+  }
+
+  // Test - Ensure the listeners have been removed.
+
+  NotifySendListeners();
+
+  for (let i = 0; i < numSendListenerFunctions + 1; ++i) {
+    if (i < numSendListenerFunctions) {
+      Assert.equal(gSLAll[i].mReceived, 0);
+    } else {
+      Assert.equal(gSLAll[i].mReceived, bitMask);
+    }
+  }
+
+  // Test - Remove main listener
+
+  gMsgCompose.removeMsgSendListener(gSLAll[numSendListenerFunctions]);
+}
diff --git a/comm/mailnews/compose/test/unit/test_nsMsgCompose3.js b/comm/mailnews/compose/test/unit/test_nsMsgCompose3.js
new file mode 100644
index 0000000000..71521abff4
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_nsMsgCompose3.js
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Test suite for increasing the popularity of contacts via
+ * expandMailingLists.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+var TESTS = [
+  {
+    email: "em@test.invalid",
+    // TB 2 stored popularity as hex, so we need to check correct handling.
+    prePopularity: "a",
+    postPopularity: "11",
+  },
+  {
+    email: "e@test.invalid",
+    prePopularity: "0",
+    postPopularity: "1",
+  },
+  {
+    email: "e@test.invalid",
+    prePopularity: "1",
+    postPopularity: "2",
+  },
+  {
+    email: "em@test.invalid",
+    prePopularity: "11",
+    postPopularity: "12",
+  },
+];
+
+function checkPopulate(aTo, aCheckTo) {
+  let msgCompose = Cc["@mozilla.org/messengercompose/compose;1"].createInstance(
+    Ci.nsIMsgCompose
+  );
+
+  // Set up some basic fields for compose.
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+
+  fields.to = aTo;
+
+  // Set up some params
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+
+  params.composeFields = fields;
+
+  msgCompose.initialize(params);
+
+  Assert.ok(!msgCompose.expandMailingLists());
+
+  Assert.equal(fields.to, aCheckTo);
+}
+
+function run_test() {
+  loadABFile("../../../data/tb2hexpopularity", kPABData.fileName);
+
+  // Check the popularity index on a couple of cards.
+  let AB = MailServices.ab.getDirectory(kPABData.URI);
+
+  for (let i = 0; i < TESTS.length; ++i) {
+    let card = AB.cardForEmailAddress(TESTS[i].email);
+    Assert.ok(!!card);
+
+    // Thunderbird 2 stored its popularityIndexes as hex, hence when we read it
+    // now we're going to get a hex value. The AB has a value of "a".
+    Assert.equal(
+      card.getProperty("PopularityIndex", -1),
+      TESTS[i].prePopularity
+    );
+
+    // Call the check populate function.
+    checkPopulate(TESTS[i].email, TESTS[i].email);
+
+    // Now we've run check populate, check the popularityIndex has increased.
+    card = AB.cardForEmailAddress(TESTS[i].email);
+    Assert.ok(!!card);
+
+    // Thunderbird 2 stored its popularityIndexes as hex, hence when we read it
+    // now we're going to get a hex value. The AB has a value of "a".
+    Assert.equal(
+      card.getProperty("PopularityIndex", -1),
+      TESTS[i].postPopularity
+    );
+  }
+}
diff --git a/comm/mailnews/compose/test/unit/test_nsSmtpService1.js b/comm/mailnews/compose/test/unit/test_nsSmtpService1.js
new file mode 100644
index 0000000000..d062ef3f1e
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_nsSmtpService1.js
@@ -0,0 +1,127 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Test suite for nsSmtpService
+ */
+
+var SmtpServiceContractID = "@mozilla.org/messengercompose/smtp;1";
+var nsISmtpService = Ci.nsISmtpService;
+
+function run_test() {
+  var smtpService = Cc[SmtpServiceContractID].getService(nsISmtpService);
+
+  // Test - no servers
+
+  var smtpServers = smtpService.servers;
+  Assert.equal(smtpServers.length, 0);
+
+  Assert.equal(smtpService.defaultServer, null);
+
+  // Test - add single server, and check
+
+  var smtpServer = smtpService.createServer();
+
+  smtpServer.hostname = "localhost";
+  smtpServer.description = "test";
+
+  smtpService.defaultServer = smtpServer;
+
+  // Test - Check to see there is only one element in the server list
+  smtpServers = smtpService.servers;
+  Assert.ok(smtpServers.length == 1);
+
+  // Test - Find the server in different ways
+  Assert.equal(smtpServer, smtpService.findServer("", "localhost"));
+  Assert.equal(smtpServer, smtpService.getServerByKey(smtpServer.key));
+
+  // Test - Try finding one that doesn't exist.
+  Assert.equal(null, smtpService.findServer("", "test"));
+
+  // Test - Check default server is still ok
+  Assert.equal(smtpServer, smtpService.defaultServer);
+
+  // Test - Delete the only server
+  smtpService.deleteServer(smtpServer);
+
+  smtpServers = smtpService.servers;
+  Assert.ok(smtpServers.length == 0);
+
+  //    do_check_eq(null, smtpService.defaultServer);
+
+  // Test - add multiple servers
+
+  var smtpServerArray = new Array(3);
+
+  for (let i = 0; i < 3; ++i) {
+    smtpServerArray[i] = smtpService.createServer();
+  }
+
+  smtpServerArray[0].hostname = "localhost";
+  smtpServerArray[0].description = "test";
+  smtpServerArray[0].username = "user";
+
+  smtpServerArray[1].hostname = "localhost";
+  smtpServerArray[1].description = "test1";
+  smtpServerArray[1].username = "user1";
+
+  smtpServerArray[2].hostname = "localhost1";
+  smtpServerArray[2].description = "test2";
+  smtpServerArray[2].username = "";
+
+  // Now check them
+  smtpServers = smtpService.servers;
+
+  var found = [false, false, false];
+
+  for (smtpServer of smtpServers) {
+    for (let i = 0; i < 3; ++i) {
+      if (smtpServer.key == smtpServerArray[i].key) {
+        found[i] = true;
+      }
+    }
+  }
+
+  Assert.equal(found, "true,true,true");
+
+  // Test - Find the servers.
+
+  Assert.equal(
+    smtpServerArray[0].key,
+    smtpService.findServer("user", "localhost").key
+  );
+  Assert.equal(
+    smtpServerArray[1].key,
+    smtpService.findServer("user1", "localhost").key
+  );
+  Assert.equal(
+    smtpServerArray[2].key,
+    smtpService.findServer("", "localhost1").key
+  );
+
+  Assert.equal(null, smtpService.findServer("user2", "localhost"));
+
+  // XXX: FIXME
+  // do_check_eq(null, smtpService.findServer("", "localhost"));
+
+  for (let i = 0; i < 3; ++i) {
+    Assert.equal(
+      smtpServerArray[i].key,
+      smtpService.getServerByKey(smtpServerArray[i].key).key
+    );
+  }
+
+  smtpService.defaultServer = smtpServerArray[2];
+  Assert.equal(
+    smtpService.defaultServer.key,
+    smtpServerArray[2].key,
+    "Default server should be correctly set"
+  );
+
+  // Test - Delete the servers
+
+  for (let i = 0; i < 3; ++i) {
+    smtpService.deleteServer(smtpServerArray[i]);
+  }
+
+  smtpServers = smtpService.servers;
+  Assert.ok(smtpServers.length == 0);
+}
diff --git a/comm/mailnews/compose/test/unit/test_saveDraft.js b/comm/mailnews/compose/test/unit/test_saveDraft.js
new file mode 100644
index 0000000000..b3f7029bab
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_saveDraft.js
@@ -0,0 +1,15 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Test suite for checking correctly saved as draft with unread.
+ */
+
+add_task(async function checkDraft() {
+  await createMessage();
+  Assert.equal(gDraftFolder.getTotalMessages(false), 1);
+  Assert.equal(gDraftFolder.getNumUnread(false), 1);
+});
+
+function run_test() {
+  localAccountUtils.loadLocalMailAccount();
+  run_next_test();
+}
diff --git a/comm/mailnews/compose/test/unit/test_sendBackground.js b/comm/mailnews/compose/test/unit/test_sendBackground.js
new file mode 100644
index 0000000000..6d0a59f4f9
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_sendBackground.js
@@ -0,0 +1,223 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/**
+ * Tests sending a message in the background (checks auto-send works).
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+var server;
+var originalData;
+var finished = false;
+var identity = null;
+var testFile1 = do_get_file("data/429891_testcase.eml");
+var testFile2 = do_get_file("data/message1.eml");
+
+var kTestFile1Sender = "from_A@foo.invalid";
+var kTestFile1Recipient = "to_A@foo.invalid";
+
+var kIdentityMail = "identity@foo.invalid";
+
+var gMsgSendLater;
+
+// This listener handles the post-sending of the actual message and checks the
+// sequence and ensures the data is correct.
+function msll() {}
+
+msll.prototype = {
+  _initialTotal: 0,
+
+  // nsIMsgSendLaterListener
+  onStartSending(aTotal) {
+    this._initialTotal = 1;
+    Assert.equal(gMsgSendLater.sendingMessages, true);
+    Assert.equal(aTotal, 1);
+  },
+  onMessageStartSending(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageHeader,
+    aIdentity
+  ) {},
+  onMessageSendProgress(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageSendPercent,
+    aMessageCopyPercent
+  ) {},
+  onMessageSendError(aCurrentMessage, aMessageHeader, aStatus, aMsg) {
+    do_throw(
+      "onMessageSendError should not have been called, status: " + aStatus
+    );
+  },
+  onStopSending(aStatus, aMsg, aTotalTried, aSuccessful) {
+    do_test_finished();
+    print("msll onStopSending\n");
+    try {
+      Assert.equal(aStatus, 0);
+      Assert.equal(aTotalTried, 1);
+      Assert.equal(aSuccessful, 1);
+      Assert.equal(this._initialTotal, 1);
+      Assert.equal(gMsgSendLater.sendingMessages, false);
+
+      do_check_transaction(server.playTransaction(), [
+        "EHLO test",
+        "MAIL FROM:<" +
+          kTestFile1Sender +
+          "> BODY=8BITMIME SIZE=" +
+          originalData.length,
+        "RCPT TO:<" + kTestFile1Recipient + ">",
+        "DATA",
+      ]);
+
+      // Compare data file to what the server received
+      Assert.equal(originalData, server._daemon.post);
+
+      // check there's still one message left in the folder
+      Assert.equal(
+        gMsgSendLater.getUnsentMessagesFolder(null).getTotalMessages(false),
+        1
+      );
+
+      finished = true;
+    } catch (e) {
+      do_throw(e);
+    } finally {
+      server.stop();
+
+      var thread = gThreadManager.currentThread;
+      while (thread.hasPendingEvents()) {
+        thread.processNextEvent(true);
+      }
+    }
+  },
+};
+
+add_task(async function run_the_test() {
+  // The point of this test - send in background.
+  Services.prefs.setBoolPref("mailnews.sendInBackground", true);
+
+  // Ensure we have a local mail account, an normal account and appropriate
+  // servers and identities.
+  localAccountUtils.loadLocalMailAccount();
+
+  // Now load (and internally initialize) the send later service
+  gMsgSendLater = Cc["@mozilla.org/messengercompose/sendlater;1"].getService(
+    Ci.nsIMsgSendLater
+  );
+
+  // Test file - for bug 429891
+  originalData = await IOUtils.readUTF8(testFile1.path);
+
+  // Check that the send later service thinks we don't have messages to send
+  Assert.equal(gMsgSendLater.hasUnsentMessages(identity), false);
+
+  MailServices.accounts.setSpecialFolders();
+
+  let account = MailServices.accounts.createAccount();
+  let incomingServer = MailServices.accounts.createIncomingServer(
+    "test",
+    "localhost",
+    "pop3"
+  );
+
+  // Start the fake SMTP server
+  server = setupServerDaemon();
+  server.start();
+  var smtpServer = getBasicSmtpServer(server.port);
+  identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+  account.addIdentity(identity);
+  account.defaultIdentity = identity;
+  account.incomingServer = incomingServer;
+  MailServices.accounts.defaultAccount = account;
+
+  localAccountUtils.rootFolder.createLocalSubfolder("Sent");
+
+  Assert.equal(identity.doFcc, true);
+
+  // Now prepare to actually "send" the message later, i.e. dump it in the
+  // unsent messages folder.
+
+  var compFields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+
+  // Setting the compFields sender and recipient to any value is required to
+  // survive mime_sanity_check_fields in nsMsgCompUtils.cpp.
+  // Sender and recipient are required for sendMessageFile but SMTP
+  // transaction values will be used directly from mail body.
+  compFields.from = "irrelevant@foo.invalid";
+  compFields.to = "irrelevant@foo.invalid";
+
+  var msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+  var msgSend2 = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // A test to check that we are sending files correctly, including checking
+    // what the server receives and what we output.
+    test = "sendMessageLater";
+
+    var messageListener = new msll();
+
+    gMsgSendLater.addListener(messageListener);
+
+    // Send this message later - it shouldn't get sent
+    msgSend.sendMessageFile(
+      identity,
+      "",
+      compFields,
+      testFile2,
+      false,
+      false,
+      Ci.nsIMsgSend.nsMsgQueueForLater,
+      null,
+      null,
+      null,
+      null
+    );
+
+    // Send the unsent message in the background, because we have
+    // mailnews.sendInBackground set, nsMsgSendLater should just send it for
+    // us.
+    msgSend2.sendMessageFile(
+      identity,
+      "",
+      compFields,
+      testFile1,
+      false,
+      false,
+      Ci.nsIMsgSend.nsMsgDeliverBackground,
+      null,
+      null,
+      null,
+      null
+    );
+
+    server.performTest();
+
+    do_timeout(10000, function () {
+      if (!finished) {
+        do_throw("Notifications of message send/copy not received");
+      }
+    });
+
+    do_test_pending();
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+});
diff --git a/comm/mailnews/compose/test/unit/test_sendMailAddressIDN.js b/comm/mailnews/compose/test/unit/test_sendMailAddressIDN.js
new file mode 100644
index 0000000000..56ab77c303
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_sendMailAddressIDN.js
@@ -0,0 +1,231 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/**
+ * Tests sending messages to addresses with non-ASCII characters.
+ */
+/* import-globals-from ../../../test/resources/alertTestUtils.js */
+load("../../../resources/alertTestUtils.js");
+
+var test = null;
+var server;
+var finished = false;
+
+var sentFolder;
+
+var kSender = "from@foo.invalid";
+var kToASCII = "to@foo.invalid";
+var kToValid = "to@v\u00E4lid.foo.invalid";
+var kToValidACE = "to@xn--vlid-loa.foo.invalid";
+var kToInvalid = "b\u00F8rken.to@invalid.foo.invalid";
+var kToInvalidWithoutDomain = "b\u00F8rken.to";
+var NS_ERROR_ILLEGAL_LOCALPART = 0x80553139;
+
+// for alertTestUtils.js
+let resolveAlert;
+function alertPS(parent, aDialogText, aText) {
+  var composeProps = Services.strings.createBundle(
+    "chrome://messenger/locale/messengercompose/composeMsgs.properties"
+  );
+  var expectedAlertMessage =
+    composeProps.GetStringFromName("sendFailed") +
+    "\n" +
+    composeProps
+      .GetStringFromName("errorIllegalLocalPart2")
+      // Without the domain, we currently don't display any name in the
+      // message part.
+      .replace("%s", test == kToInvalidWithoutDomain ? "" : test);
+
+  // we should only get here for the kToInvalid test case
+  Assert.equal(aText, expectedAlertMessage);
+  resolveAlert();
+}
+
+// message listener implementations
+function MsgSendListener(aRecipient, originalData) {
+  this.rcpt = aRecipient;
+  this.originalData = originalData;
+}
+
+/**
+ * @implements {nsIMsgSendListener}
+ * @implements {nsIMsgCopyServiceListener}
+ */
+MsgSendListener.prototype = {
+  // nsIMsgSendListener
+  onStartSending(aMsgID, aMsgSize) {},
+  onProgress(aMsgID, aProgress, aProgressMax) {},
+  onStatus(aMsgID, aMsg) {},
+  onStopSending(aMsgID, aStatus, aMsg, aReturnFile) {
+    try {
+      if (test == kToValid || test == kToASCII) {
+        Assert.equal(aStatus, 0);
+        do_check_transaction(server.playTransaction(), [
+          "EHLO test",
+          "MAIL FROM:<" +
+            kSender +
+            "> BODY=8BITMIME SIZE=" +
+            this.originalData.length,
+          "RCPT TO:<" + this.rcpt + ">",
+          "DATA",
+        ]);
+        // Compare data file to what the server received
+        Assert.equal(this.originalData, server._daemon.post);
+      } else {
+        Assert.equal(aStatus, NS_ERROR_ILLEGAL_LOCALPART);
+        do_check_transaction(server.playTransaction(), ["EHLO test"]);
+        // Local address (before the @) has non-ascii char(s) or the @ is
+        // missing from the address. An alert is triggered after the EHLO is
+        // sent. Nothing else occurs so we "finish" the test to avoid
+        // NS_ERROR_ABORT test failure due to timeout waiting for the send
+        // (which doesn't occurs) to complete.
+      }
+    } catch (e) {
+      do_throw(e);
+    } finally {
+      server.stop();
+      var thread = gThreadManager.currentThread;
+      while (thread.hasPendingEvents()) {
+        thread.processNextEvent(false);
+      }
+      do_test_finished();
+    }
+  },
+  onGetDraftFolderURI(aMsgID, aFolderURI) {},
+  onSendNotPerformed(aMsgID, aStatus) {},
+  onTransportSecurityError(msgID, status, secInfo, location) {},
+
+  // nsIMsgCopyServiceListener
+  OnStartCopy() {},
+  OnProgress(aProgress, aProgressMax) {},
+  SetMessageKey(aKey) {},
+  GetMessageId(aMessageId) {},
+  OnStopCopy(aStatus) {
+    Assert.equal(aStatus, 0);
+    try {
+      // Now do a comparison of what is in the sent mail folder
+      let msgData = mailTestUtils.loadMessageToString(
+        sentFolder,
+        mailTestUtils.firstMsgHdr(sentFolder)
+      );
+      // Skip the headers etc that mailnews adds
+      var pos = msgData.indexOf("From:");
+      Assert.notEqual(pos, -1);
+      msgData = msgData.substr(pos);
+      Assert.equal(this.originalData, msgData);
+    } catch (e) {
+      do_throw(e);
+    } finally {
+      finished = true;
+    }
+  },
+
+  // QueryInterface
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIMsgSendListener",
+    "nsIMsgCopyServiceListener",
+  ]),
+};
+
+async function doSendTest(aRecipient, aRecipientExpected, waitForPrompt) {
+  info(`Testing send to ${aRecipient} will get sent to ${aRecipientExpected}`);
+  let promiseAlertReceived = new Promise(resolve => {
+    resolveAlert = resolve;
+  });
+  test = aRecipient;
+  server = setupServerDaemon();
+  server.start();
+  var smtpServer = getBasicSmtpServer(server.port);
+  var identity = getSmtpIdentity(kSender, smtpServer);
+  Assert.equal(identity.doFcc, true);
+
+  // Random test file with data we don't actually care about. ;-)
+  var testFile = do_get_file("data/message1.eml");
+  var originalData = await IOUtils.readUTF8(testFile.path);
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    do_test_pending();
+    var compFields = Cc[
+      "@mozilla.org/messengercompose/composefields;1"
+    ].createInstance(Ci.nsIMsgCompFields);
+    compFields.from = identity.email;
+    compFields.to = aRecipient;
+
+    var msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+      Ci.nsIMsgSend
+    );
+    msgSend.sendMessageFile(
+      identity,
+      "",
+      compFields,
+      testFile,
+      false,
+      false,
+      Ci.nsIMsgSend.nsMsgDeliverNow,
+      null,
+      new MsgSendListener(aRecipientExpected, originalData),
+      null,
+      null
+    );
+
+    server.performTest();
+    do_timeout(10000, function () {
+      if (!finished) {
+        do_throw("Notifications of message send/copy not received");
+      }
+    });
+    if (waitForPrompt) {
+      await promiseAlertReceived;
+    }
+  } catch (e) {
+    Assert.ok(false, "Send fail: " + e);
+  } finally {
+    server.stop();
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+}
+
+add_setup(function () {
+  registerAlertTestUtils();
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+  MailServices.accounts.setSpecialFolders();
+  sentFolder = localAccountUtils.rootFolder.createLocalSubfolder("Sent");
+});
+
+add_task(async function plainASCIIRecipient() {
+  // Test 1:
+  // Plain ASCII recipient address.
+  await doSendTest(kToASCII, kToASCII, false);
+});
+
+add_task(async function domainContainsNonAscii() {
+  // Test 2:
+  // The recipient's domain part contains a non-ASCII character, hence the
+  // address needs to be converted to ACE before sending.
+  // The old code would just strip the non-ASCII character and try to send
+  // the message to the remaining - wrong! - address.
+  // The new code will translate the domain part to ACE for the SMTP
+  // transaction (only), i.e. the To: header will stay as stated by the sender.
+  await doSendTest(kToValid, kToValidACE, false);
+});
+
+add_task(async function localContainsNonAscii() {
+  // Test 3:
+  // The recipient's local part contains a non-ASCII character, which is not
+  // allowed with unextended SMTP.
+  // The old code would just strip the invalid character and try to send the
+  // message to the remaining - wrong! - address.
+  // The new code will present an informational message box and deny sending.
+  await doSendTest(kToInvalid, kToInvalid, true);
+});
+
+add_task(async function invalidCharNoAt() {
+  // Test 4:
+  // Bug 856506. invalid char without '@' causes crash.
+  await doSendTest(kToInvalidWithoutDomain, kToInvalidWithoutDomain, true);
+});
diff --git a/comm/mailnews/compose/test/unit/test_sendMailMessage.js b/comm/mailnews/compose/test/unit/test_sendMailMessage.js
new file mode 100644
index 0000000000..ea294a0b92
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_sendMailMessage.js
@@ -0,0 +1,189 @@
+/**
+ * Protocol tests for SMTP.
+ *
+ * This test currently consists of verifying the correct protocol sequence
+ * between mailnews and SMTP server. It does not check the data of the message
+ * either side of the link, it will be extended later to do that.
+ */
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+
+var server;
+
+var kIdentityMail = "identity@foo.invalid";
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+var kUsername = "testsmtp";
+var kPassword = "smtptest";
+
+async function test_RFC2821() {
+  // Test file
+  var testFile = do_get_file("data/message1.eml");
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  server.start();
+  var smtpServer = getBasicSmtpServer(server.port);
+  var identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // Just a basic test to check we're sending mail correctly.
+    test = "Basic sendMailMessage";
+
+    // First do test with identity email address used for smtp MAIL FROM.
+    Services.prefs.setBoolPref("mail.smtp.useSenderForSmtpMailFrom", false);
+
+    let urlListener = new PromiseTestUtils.PromiseUrlListener();
+    MailServices.smtp.sendMailMessage(
+      testFile,
+      kTo,
+      identity,
+      kSender,
+      null,
+      urlListener,
+      null,
+      null,
+      false,
+      "",
+      {},
+      {}
+    );
+
+    await urlListener.promise;
+
+    var transaction = server.playTransaction();
+    do_check_transaction(transaction, [
+      "EHLO test",
+      "MAIL FROM:<" + kIdentityMail + "> BODY=8BITMIME SIZE=159",
+      "RCPT TO:<" + kTo + ">",
+      "DATA",
+    ]);
+
+    smtpServer.closeCachedConnections();
+    server.resetTest();
+
+    // Now do the same test with sender's email address used for smtp MAIL FROM.
+    Services.prefs.setBoolPref("mail.smtp.useSenderForSmtpMailFrom", true);
+
+    urlListener = new PromiseTestUtils.PromiseUrlListener();
+    MailServices.smtp.sendMailMessage(
+      testFile,
+      kTo,
+      identity,
+      kSender,
+      null,
+      urlListener,
+      null,
+      null,
+      false,
+      "",
+      {},
+      {}
+    );
+
+    await urlListener.promise;
+
+    transaction = server.playTransaction();
+    do_check_transaction(transaction, [
+      "EHLO test",
+      "MAIL FROM:<" + kSender + "> BODY=8BITMIME SIZE=159",
+      "RCPT TO:<" + kTo + ">",
+      "DATA",
+    ]);
+
+    smtpServer.closeCachedConnections();
+    server.resetTest();
+
+    // This time with auth.
+    test = "Auth sendMailMessage";
+
+    smtpServer.authMethod = Ci.nsMsgAuthMethod.passwordCleartext;
+    smtpServer.socketType = Ci.nsMsgSocketType.plain;
+    smtpServer.username = kUsername;
+    smtpServer.password = kPassword;
+
+    // First do test with identity email address used for smtp MAIL FROM.
+    Services.prefs.setBoolPref("mail.smtp.useSenderForSmtpMailFrom", false);
+
+    urlListener = new PromiseTestUtils.PromiseUrlListener();
+    MailServices.smtp.sendMailMessage(
+      testFile,
+      kTo,
+      identity,
+      kSender,
+      null,
+      urlListener,
+      null,
+      null,
+      false,
+      "",
+      {},
+      {}
+    );
+
+    await urlListener.promise;
+
+    transaction = server.playTransaction();
+    do_check_transaction(transaction, [
+      "EHLO test",
+      "AUTH PLAIN " + AuthPLAIN.encodeLine(kUsername, kPassword),
+      "MAIL FROM:<" + kIdentityMail + "> BODY=8BITMIME SIZE=159",
+      "RCPT TO:<" + kTo + ">",
+      "DATA",
+    ]);
+
+    smtpServer.closeCachedConnections();
+    server.resetTest();
+
+    // Now do the same test with sender's email address used for smtp MAIL FROM.
+    Services.prefs.setBoolPref("mail.smtp.useSenderForSmtpMailFrom", true);
+
+    urlListener = new PromiseTestUtils.PromiseUrlListener();
+    MailServices.smtp.sendMailMessage(
+      testFile,
+      kTo,
+      identity,
+      kSender,
+      null,
+      urlListener,
+      null,
+      null,
+      false,
+      "",
+      {},
+      {}
+    );
+
+    await urlListener.promise;
+
+    transaction = server.playTransaction();
+    do_check_transaction(transaction, [
+      "EHLO test",
+      "AUTH PLAIN " + AuthPLAIN.encodeLine(kUsername, kPassword),
+      "MAIL FROM:<" + kSender + "> BODY=8BITMIME SIZE=159",
+      "RCPT TO:<" + kTo + ">",
+      "DATA",
+    ]);
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+}
+
+add_task(async function run() {
+  server = setupServerDaemon();
+  await test_RFC2821();
+});
diff --git a/comm/mailnews/compose/test/unit/test_sendMessageFile.js b/comm/mailnews/compose/test/unit/test_sendMessageFile.js
new file mode 100644
index 0000000000..cb2882e88f
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_sendMessageFile.js
@@ -0,0 +1,172 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/**
+ * Protocol tests for SMTP.
+ *
+ * This test verifies:
+ * - Sending a message to an SMTP server (which is also covered elsewhere).
+ * - Correct reception of the message by the SMTP server.
+ * - Correct saving of the message to the sent folder.
+ *
+ * Originally written to test bug 429891 where saving to the sent folder was
+ * mangling the message.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+var server;
+var sentFolder;
+var originalData;
+var finished = false;
+
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+
+function msl() {}
+
+msl.prototype = {
+  // nsIMsgSendListener
+  onStartSending(aMsgID, aMsgSize) {},
+  onProgress(aMsgID, aProgress, aProgressMax) {},
+  onStatus(aMsgID, aMsg) {},
+  onStopSending(aMsgID, aStatus, aMsg, aReturnFile) {
+    try {
+      Assert.equal(aStatus, 0);
+
+      do_check_transaction(server.playTransaction(), [
+        "EHLO test",
+        "MAIL FROM:<" + kSender + "> BODY=8BITMIME SIZE=" + originalData.length,
+        "RCPT TO:<" + kTo + ">",
+        "DATA",
+      ]);
+
+      // Compare data file to what the server received
+      Assert.equal(originalData, server._daemon.post);
+    } catch (e) {
+      do_throw(e);
+    } finally {
+      server.stop();
+
+      var thread = gThreadManager.currentThread;
+      while (thread.hasPendingEvents()) {
+        thread.processNextEvent(false);
+      }
+    }
+  },
+  onGetDraftFolderURI(aMsgID, aFolderURI) {},
+  onSendNotPerformed(aMsgID, aStatus) {},
+  onTransportSecurityError(msgID, status, secInfo, location) {},
+
+  // nsIMsgCopyServiceListener
+  OnStartCopy() {},
+  OnProgress(aProgress, aProgressMax) {},
+  SetMessageKey(aKey) {},
+  GetMessageId(aMessageId) {},
+  OnStopCopy(aStatus) {
+    Assert.equal(aStatus, 0);
+    try {
+      // Now do a comparison of what is in the sent mail folder
+      let msgData = mailTestUtils.loadMessageToString(
+        sentFolder,
+        mailTestUtils.firstMsgHdr(sentFolder)
+      );
+
+      // Skip the headers etc that mailnews adds
+      var pos = msgData.indexOf("From:");
+      Assert.notEqual(pos, -1);
+
+      msgData = msgData.substr(pos);
+
+      Assert.equal(originalData, msgData);
+    } catch (e) {
+      do_throw(e);
+    } finally {
+      finished = true;
+      do_test_finished();
+    }
+  },
+
+  // QueryInterface
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIMsgSendListener",
+    "nsIMsgCopyServiceListener",
+  ]),
+};
+
+add_task(async function run_the_test() {
+  server = setupServerDaemon();
+
+  // Test file - for bug 429891
+  var testFile = do_get_file("data/429891_testcase.eml");
+  originalData = await IOUtils.readUTF8(testFile.path);
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  MailServices.accounts.setSpecialFolders();
+
+  server.start();
+  var smtpServer = getBasicSmtpServer(server.port);
+  var identity = getSmtpIdentity(kSender, smtpServer);
+
+  sentFolder = localAccountUtils.rootFolder.createLocalSubfolder("Sent");
+
+  Assert.equal(identity.doFcc, true);
+
+  var msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // A test to check that we are sending files correctly, including checking
+    // what the server receives and what we output.
+    test = "sendMessageFile";
+
+    // Msg Comp Fields
+
+    var compFields = Cc[
+      "@mozilla.org/messengercompose/composefields;1"
+    ].createInstance(Ci.nsIMsgCompFields);
+
+    compFields.from = identity.email;
+    compFields.to = kTo;
+
+    var messageListener = new msl();
+
+    msgSend.sendMessageFile(
+      identity,
+      "",
+      compFields,
+      testFile,
+      false,
+      false,
+      Ci.nsIMsgSend.nsMsgDeliverNow,
+      null,
+      messageListener,
+      null,
+      null
+    );
+
+    server.performTest();
+
+    do_timeout(10000, function () {
+      if (!finished) {
+        do_throw("Notifications of message send/copy not received");
+      }
+    });
+
+    do_test_pending();
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+});
diff --git a/comm/mailnews/compose/test/unit/test_sendMessageLater.js b/comm/mailnews/compose/test/unit/test_sendMessageLater.js
new file mode 100644
index 0000000000..7dcaf8ec32
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_sendMessageLater.js
@@ -0,0 +1,261 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/**
+ * Protocol tests for SMTP.
+ *
+ * This test verifies:
+ * - Sending a message to an SMTP server (which is also covered elsewhere).
+ * - Correct reception of the message by the SMTP server.
+ * - Correct saving of the message to the sent folder.
+ *
+ * Originally written to test bug 429891 where saving to the sent folder was
+ * mangling the message.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+var server;
+var smtpServer;
+var originalData;
+var finished = false;
+var identity = null;
+var testFile = do_get_file("data/429891_testcase.eml");
+var kTestFileSender = "from_A@foo.invalid";
+var kTestFileRecipient = "to_A@foo.invalid";
+
+var kIdentityMail = "identity@foo.invalid";
+
+var msgSendLater = Cc["@mozilla.org/messengercompose/sendlater;1"].getService(
+  Ci.nsIMsgSendLater
+);
+
+// This listener handles the post-sending of the actual message and checks the
+// sequence and ensures the data is correct.
+function msll() {}
+
+msll.prototype = {
+  _initialTotal: 0,
+  _startedSending: false,
+
+  // nsIMsgSendLaterListener
+  onStartSending(aTotalMessageCount) {
+    this._initialTotal = 1;
+    Assert.equal(msgSendLater.sendingMessages, true);
+  },
+  onMessageStartSending(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageHeader,
+    aIdentity
+  ) {
+    this._startedSending = true;
+  },
+  onMessageSendProgress(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageSendPercent,
+    aMessageCopyPercent
+  ) {
+    // XXX Enable this function
+  },
+  onMessageSendError(aCurrentMessage, aMessageHeader, aStatus, aMsg) {
+    do_throw(
+      "onMessageSendError should not have been called, status: " + aStatus
+    );
+  },
+  onStopSending(aStatus, aMsg, aTotalTried, aSuccessful) {
+    do_test_finished();
+    print("msll onStopSending\n");
+    try {
+      Assert.equal(this._startedSending, true);
+      Assert.equal(aStatus, 0);
+      Assert.equal(aTotalTried, 1);
+      Assert.equal(aSuccessful, 1);
+      Assert.equal(this._initialTotal, 1);
+      Assert.equal(msgSendLater.sendingMessages, false);
+
+      do_check_transaction(server.playTransaction(), [
+        "EHLO test",
+        "MAIL FROM:<" +
+          kTestFileSender +
+          "> BODY=8BITMIME SIZE=" +
+          originalData.length,
+        "RCPT TO:<" + kTestFileRecipient + ">",
+        "DATA",
+      ]);
+
+      // Compare data file to what the server received
+      Assert.equal(originalData, server._daemon.post);
+
+      finished = true;
+    } catch (e) {
+      do_throw(e);
+    } finally {
+      server.stop();
+
+      var thread = gThreadManager.currentThread;
+      while (thread.hasPendingEvents()) {
+        thread.processNextEvent(true);
+      }
+    }
+  },
+};
+
+/* exported OnStopCopy */
+// for head_compose.js
+function OnStopCopy(aStatus) {
+  dump("OnStopCopy()\n");
+
+  try {
+    Assert.equal(aStatus, 0);
+
+    // Check this is false before we start sending
+    Assert.equal(msgSendLater.sendingMessages, false);
+
+    let folder = msgSendLater.getUnsentMessagesFolder(identity);
+
+    // Check we have a message in the unsent message folder
+    Assert.equal(folder.getTotalMessages(false), 1);
+
+    // Check that the send later service thinks we have messages to send
+    Assert.equal(msgSendLater.hasUnsentMessages(identity), true);
+
+    // Now do a comparison of what is in the sent mail folder
+    let msgData = mailTestUtils.loadMessageToString(
+      folder,
+      mailTestUtils.firstMsgHdr(folder)
+    );
+    // Skip the headers etc that mailnews adds
+    var pos = msgData.indexOf("From:");
+    Assert.notEqual(pos, -1);
+
+    msgData = msgData.substr(pos);
+
+    // Check the data is matching.
+    Assert.equal(originalData, msgData);
+
+    sendMessageLater();
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+
+    finished = true;
+  }
+}
+
+// This function does the actual send later
+function sendMessageLater() {
+  // Set up the SMTP server.
+  server = setupServerDaemon();
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // Start the fake SMTP server
+    server.start();
+    smtpServer.port = server.port;
+
+    // A test to check that we are sending files correctly, including checking
+    // what the server receives and what we output.
+    test = "sendMessageLater";
+
+    var messageListener = new msll();
+
+    msgSendLater.addListener(messageListener);
+
+    // Send the unsent message
+    msgSendLater.sendUnsentMessages(identity);
+
+    server.performTest();
+
+    do_timeout(10000, function () {
+      if (!finished) {
+        do_throw("Notifications of message send/copy not received");
+      }
+    });
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+}
+
+add_task(async function run_the_test() {
+  // Test file - for bug 429891
+  originalData = await IOUtils.readUTF8(testFile.path);
+
+  // Ensure we have a local mail account, an normal account and appropriate
+  // servers and identities.
+  localAccountUtils.loadLocalMailAccount();
+
+  // Check that the send later service thinks we don't have messages to send
+  Assert.equal(msgSendLater.hasUnsentMessages(identity), false);
+
+  MailServices.accounts.setSpecialFolders();
+
+  let account = MailServices.accounts.createAccount();
+  let incomingServer = MailServices.accounts.createIncomingServer(
+    "test",
+    "localhost",
+    "pop3"
+  );
+
+  smtpServer = getBasicSmtpServer(1);
+  identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+  account.addIdentity(identity);
+  account.defaultIdentity = identity;
+  account.incomingServer = incomingServer;
+  MailServices.accounts.defaultAccount = account;
+
+  localAccountUtils.rootFolder.createLocalSubfolder("Sent");
+
+  Assert.equal(identity.doFcc, true);
+
+  // Now prepare to actually "send" the message later, i.e. dump it in the
+  // unsent messages folder.
+
+  var compFields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+
+  // Setting the compFields sender and recipient to any value is required to
+  // survive mime_sanity_check_fields in nsMsgCompUtils.cpp.
+  // Sender and recipient are required for sendMessageFile but SMTP
+  // transaction values will be used directly from mail body.
+  compFields.from = "irrelevant@foo.invalid";
+  compFields.to = "irrelevant@foo.invalid";
+
+  var msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+
+  msgSend.sendMessageFile(
+    identity,
+    "",
+    compFields,
+    testFile,
+    false,
+    false,
+    Ci.nsIMsgSend.nsMsgQueueForLater,
+    null,
+    copyListener,
+    null,
+    null
+  );
+
+  // Now we wait till we get copy notification of completion.
+  do_test_pending();
+});
diff --git a/comm/mailnews/compose/test/unit/test_sendMessageLater2.js b/comm/mailnews/compose/test/unit/test_sendMessageLater2.js
new file mode 100644
index 0000000000..bd0b974400
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_sendMessageLater2.js
@@ -0,0 +1,301 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Complex test for the send message later function - including sending multiple
+ * times in the same session.
+ *
+ * XXX: This test is intended to additionally test sending of multiple messages
+ * from one send later instance, however due to the fact we use one connection
+ * per message sent, it is very difficult to consistently get the fake server
+ * reconnected in time for the next connection. Thus, sending of multiple
+ * messages is currently disabled (but commented out for local testing if
+ * required), when we fix bug 136871 we should be able to enable the multiple
+ * messages option.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+var { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+var { PromiseUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/PromiseUtils.sys.mjs"
+);
+
+var server = null;
+var smtpServer;
+var gSentFolder;
+var identity = null;
+var gMsgFile = [
+  do_get_file("data/message1.eml"),
+  do_get_file("data/429891_testcase.eml"),
+];
+var kTestFileSender = ["from_B@foo.invalid", "from_A@foo.invalid"];
+var kTestFileRecipient = ["to_B@foo.invalid", "to_A@foo.invalid"];
+
+var gMsgFileData = [];
+var gMsgOrder = [];
+var gLastSentMessage = 0;
+
+var kIdentityMail = "identity@foo.invalid";
+
+var msgSendLater = Cc["@mozilla.org/messengercompose/sendlater;1"].getService(
+  Ci.nsIMsgSendLater
+);
+
+var messageListener;
+var onStopCopyPromise = PromiseUtils.defer();
+
+/* exported OnStopCopy */
+// for head_compose.js
+// This function is used to find out when the copying of the message to the
+// unsent message folder is completed, and hence can fire off the actual
+// sending of the message.
+function OnStopCopy(aStatus) {
+  Assert.equal(aStatus, 0);
+
+  // Check this is false before we start sending.
+  Assert.equal(msgSendLater.sendingMessages, false);
+
+  // Check that the send later service thinks we have messages to send.
+  Assert.equal(msgSendLater.hasUnsentMessages(identity), true);
+
+  // Check we have a message in the unsent message folder.
+  Assert.equal(gSentFolder.getTotalMessages(false), gMsgOrder.length);
+
+  // Start the next step after a brief time so that functions can finish
+  // properly.
+  onStopCopyPromise.resolve();
+}
+
+add_setup(async function () {
+  // Load in the test files so we have a record of length and their data.
+  for (var i = 0; i < gMsgFile.length; ++i) {
+    gMsgFileData[i] = await IOUtils.readUTF8(gMsgFile[i].path);
+  }
+
+  // Ensure we have a local mail account, an normal account and appropriate
+  // servers and identities.
+  localAccountUtils.loadLocalMailAccount();
+
+  // Check that the send later service thinks we don't have messages to send.
+  Assert.equal(msgSendLater.hasUnsentMessages(identity), false);
+
+  MailServices.accounts.setSpecialFolders();
+
+  let account = MailServices.accounts.createAccount();
+  let incomingServer = MailServices.accounts.createIncomingServer(
+    "test",
+    "localhost",
+    "pop3"
+  );
+
+  smtpServer = getBasicSmtpServer(1);
+  identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+  account.addIdentity(identity);
+  account.defaultIdentity = identity;
+  account.incomingServer = incomingServer;
+  MailServices.accounts.defaultAccount = account;
+
+  localAccountUtils.rootFolder.createLocalSubfolder("Sent");
+
+  gSentFolder = msgSendLater.getUnsentMessagesFolder(identity);
+
+  // Don't copy messages to sent folder for this test.
+  identity.doFcc = false;
+
+  // Create and add a listener.
+  messageListener = new MsgSendLaterListener();
+
+  msgSendLater.addListener(messageListener);
+
+  // Set up the server.
+  server = setupServerDaemon();
+  server.setDebugLevel(fsDebugRecv);
+});
+
+add_task(async function test_sendMessageLater2_message1() {
+  // Copy Message from file to folder.
+  await sendMessageLater(0);
+
+  // Send unsent message.
+  await sendUnsentMessages();
+
+  // Check sent folder is now empty.
+  Assert.equal(gSentFolder.getTotalMessages(false), 0);
+
+  // Reset the server.
+  server.stop();
+  server.resetTest();
+
+  // Reset counts.
+  resetCounts();
+});
+
+add_task(async function test_sendMessageLater2_429891_testcase() {
+  // Copy more messages.
+  await sendMessageLater(1);
+
+  // XXX Only do one the second time round, as described at the start of the
+  // file.
+  // await sendMessageLater(0);
+
+  // Test send again.
+  await sendUnsentMessages();
+});
+
+async function sendMessageLater(aTestFileIndex) {
+  gMsgOrder.push(aTestFileIndex);
+
+  // Prepare to actually "send" the message later, i.e. dump it in the
+  // unsent messages folder.
+
+  var compFields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+
+  // Setting the compFields sender and recipient to any value is required to
+  // survive mime_sanity_check_fields in nsMsgCompUtils.cpp.
+  // Sender and recipient are required for sendMessageFile but SMTP
+  // transaction values will be used directly from mail body.
+  compFields.from = "irrelevant@foo.invalid";
+  compFields.to = "irrelevant@foo.invalid";
+
+  var msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+
+  msgSend.sendMessageFile(
+    identity,
+    "",
+    compFields,
+    gMsgFile[aTestFileIndex],
+    false,
+    false,
+    Ci.nsIMsgSend.nsMsgQueueForLater,
+    null,
+    copyListener,
+    null,
+    null
+  );
+  await onStopCopyPromise.promise;
+  // Reset onStopCopyPromise.
+  onStopCopyPromise = PromiseUtils.defer();
+}
+
+function resetCounts() {
+  gMsgOrder = [];
+  gLastSentMessage = 0;
+}
+
+// This function does the actual send later.
+async function sendUnsentMessages() {
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // Start the fake SMTP server.
+    server.start();
+    smtpServer.port = server.port;
+
+    // Send the unsent message.
+    msgSendLater.sendUnsentMessages(identity);
+  } catch (e) {
+    throw new Error(e);
+  }
+  await messageListener.promise;
+  messageListener.deferPromise();
+}
+
+// This listener handles the post-sending of the actual message and checks the
+// sequence and ensures the data is correct.
+class MsgSendLaterListener {
+  constructor() {
+    this._deferredPromise = PromiseUtils.defer();
+  }
+
+  checkMessageSend(aCurrentMessage) {
+    do_check_transaction(server.playTransaction(), [
+      "EHLO test",
+      "MAIL FROM:<" +
+        kTestFileSender[gMsgOrder[aCurrentMessage - 1]] +
+        "> BODY=8BITMIME SIZE=" +
+        gMsgFileData[gMsgOrder[aCurrentMessage - 1]].length,
+      "RCPT TO:<" + kTestFileRecipient[gMsgOrder[aCurrentMessage - 1]] + ">",
+      "DATA",
+    ]);
+
+    // Compare data file to what the server received.
+    Assert.equal(
+      gMsgFileData[gMsgOrder[aCurrentMessage - 1]],
+      server._daemon.post
+    );
+  }
+
+  // nsIMsgSendLaterListener
+  onStartSending(aTotalMessageCount) {
+    Assert.equal(aTotalMessageCount, gMsgOrder.length);
+    Assert.equal(msgSendLater.sendingMessages, true);
+  }
+  onMessageStartSending(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageHeader,
+    aIdentity
+  ) {
+    if (gLastSentMessage > 0) {
+      this.checkMessageSend(aCurrentMessage);
+    }
+    Assert.equal(gLastSentMessage + 1, aCurrentMessage);
+    gLastSentMessage = aCurrentMessage;
+  }
+  onMessageSendProgress(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageSendPercent,
+    aMessageCopyPercent
+  ) {
+    Assert.equal(aTotalMessageCount, gMsgOrder.length);
+    Assert.equal(gLastSentMessage, aCurrentMessage);
+    Assert.equal(msgSendLater.sendingMessages, true);
+  }
+  onMessageSendError(aCurrentMessage, aMessageHeader, aStatus, aMsg) {
+    throw new Error(
+      "onMessageSendError should not have been called, status: " + aStatus
+    );
+  }
+  onStopSending(aStatus, aMsg, aTotalTried, aSuccessful) {
+    try {
+      Assert.equal(aStatus, 0);
+      Assert.equal(aTotalTried, aSuccessful);
+      Assert.equal(msgSendLater.sendingMessages, false);
+
+      // Check that the send later service now thinks we don't have messages to
+      // send.
+      Assert.equal(msgSendLater.hasUnsentMessages(identity), false);
+
+      this.checkMessageSend(gLastSentMessage);
+    } catch (e) {
+      throw new Error(e);
+    }
+    // The extra timeout here is to work around an issue where sometimes
+    // the sendUnsentMessages is completely synchronous up until onStopSending
+    // and sometimes it isn't. This protects us for the synchronous case to
+    // allow the sendUnsentMessages function to complete and exit before we
+    // resolve the promise.
+    PromiseTestUtils.promiseDelay(0).then(resolve => {
+      this._deferredPromise.resolve(true);
+    });
+  }
+
+  deferPromise() {
+    this._deferredPromise = PromiseUtils.defer();
+  }
+
+  get promise() {
+    return this._deferredPromise.promise;
+  }
+}
diff --git a/comm/mailnews/compose/test/unit/test_sendMessageLater3.js b/comm/mailnews/compose/test/unit/test_sendMessageLater3.js
new file mode 100644
index 0000000000..08e32481c6
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_sendMessageLater3.js
@@ -0,0 +1,188 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/**
+ * Protocol tests for SMTP.
+ *
+ * For trying to send a message later with no server connected, this test
+ * verifies:
+ *   - A correct status response.
+ *   - A correct state at the end of attempting to send.
+ */
+
+/* import-globals-from ../../../test/resources/alertTestUtils.js */
+load("../../../resources/alertTestUtils.js");
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+var originalData;
+var identity = null;
+var testFile = do_get_file("data/429891_testcase.eml");
+
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+
+var msgSendLater = Cc["@mozilla.org/messengercompose/sendlater;1"].getService(
+  Ci.nsIMsgSendLater
+);
+
+// for alertTestUtils.js
+function alertPS(parent, aDialogTitle, aText) {
+  dump("Hiding Alert {\n" + aText + "\n} End Alert\n");
+}
+
+// This listener handles the post-sending of the actual message and checks the
+// sequence and ensures the data is correct.
+function msll() {}
+
+msll.prototype = {
+  _initialTotal: 0,
+  _errorRaised: false,
+
+  // nsIMsgSendLaterListener
+  onStartSending(aTotal) {
+    this._initialTotal = 1;
+    Assert.equal(msgSendLater.sendingMessages, true);
+  },
+  onMessageStartSending(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageHeader,
+    aIdentity
+  ) {},
+  onMessageSendProgress(
+    aCurrentMessage,
+    aTotalMessageCount,
+    aMessageSendPercent,
+    aMessageCopyPercent
+  ) {},
+  onMessageSendError(aCurrentMessage, aMessageHeader, aStatus, aMsg) {
+    this._errorRaised = true;
+  },
+  onStopSending(aStatus, aMsg, aTotal, aSuccessful) {
+    print("msll onStopSending\n");
+
+    // NS_ERROR_SMTP_SEND_FAILED_REFUSED is 2153066798
+    Assert.equal(aStatus, 2153066798);
+    Assert.equal(aTotal, 1);
+    Assert.equal(aSuccessful, 0);
+    Assert.equal(this._initialTotal, 1);
+    Assert.equal(this._errorRaised, true);
+    Assert.equal(msgSendLater.sendingMessages, false);
+    // Check that the send later service still thinks we have messages to send.
+    Assert.equal(msgSendLater.hasUnsentMessages(identity), true);
+
+    do_test_finished();
+  },
+};
+
+/* exported OnStopCopy */
+// for head_compose.js
+function OnStopCopy(aStatus) {
+  Assert.equal(aStatus, 0);
+
+  // Check this is false before we start sending
+  Assert.equal(msgSendLater.sendingMessages, false);
+
+  let folder = msgSendLater.getUnsentMessagesFolder(identity);
+
+  // Check that the send later service thinks we have messages to send.
+  Assert.equal(msgSendLater.hasUnsentMessages(identity), true);
+
+  // Check we have a message in the unsent message folder
+  Assert.equal(folder.getTotalMessages(false), 1);
+
+  // Now do a comparison of what is in the unsent mail folder
+  let msgData = mailTestUtils.loadMessageToString(
+    folder,
+    mailTestUtils.firstMsgHdr(folder)
+  );
+
+  // Skip the headers etc that mailnews adds
+  var pos = msgData.indexOf("From:");
+  Assert.notEqual(pos, -1);
+
+  msgData = msgData.substr(pos);
+
+  // Check the data is matching.
+  Assert.equal(originalData, msgData);
+
+  do_timeout(0, sendMessageLater);
+}
+
+// This function does the actual send later
+function sendMessageLater() {
+  // No server for this test, just attempt to send unsent and wait.
+  var messageListener = new msll();
+
+  msgSendLater.addListener(messageListener);
+
+  // Send the unsent message
+  msgSendLater.sendUnsentMessages(identity);
+}
+
+add_task(async function run_the_test() {
+  registerAlertTestUtils();
+
+  // Test file - for bug 429891
+  originalData = await IOUtils.readUTF8(testFile.path);
+
+  // Ensure we have a local mail account, an normal account and appropriate
+  // servers and identities.
+  localAccountUtils.loadLocalMailAccount();
+
+  // Check that the send later service thinks we don't have messages to send.
+  Assert.equal(msgSendLater.hasUnsentMessages(identity), false);
+
+  MailServices.accounts.setSpecialFolders();
+
+  let account = MailServices.accounts.createAccount();
+  let incomingServer = MailServices.accounts.createIncomingServer(
+    "test",
+    "localhost",
+    "pop3"
+  );
+
+  var smtpServer = getBasicSmtpServer();
+  identity = getSmtpIdentity(kSender, smtpServer);
+
+  account.addIdentity(identity);
+  account.defaultIdentity = identity;
+  account.incomingServer = incomingServer;
+  MailServices.accounts.defaultAccount = account;
+
+  localAccountUtils.rootFolder.createLocalSubfolder("Sent");
+
+  identity.doFcc = false;
+
+  // Now prepare to actually "send" the message later, i.e. dump it in the
+  // unsent messages folder.
+
+  var compFields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+
+  compFields.from = identity.email;
+  compFields.to = kTo;
+
+  var msgSend = Cc["@mozilla.org/messengercompose/send;1"].createInstance(
+    Ci.nsIMsgSend
+  );
+
+  msgSend.sendMessageFile(
+    identity,
+    "",
+    compFields,
+    testFile,
+    false,
+    false,
+    Ci.nsIMsgSend.nsMsgQueueForLater,
+    null,
+    copyListener,
+    null,
+    null
+  );
+
+  // Now we wait till we get copy notification of completion.
+  do_test_pending();
+});
diff --git a/comm/mailnews/compose/test/unit/test_sendObserver.js b/comm/mailnews/compose/test/unit/test_sendObserver.js
new file mode 100644
index 0000000000..3640d1ca02
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_sendObserver.js
@@ -0,0 +1,52 @@
+/*
+ * Tests that the mail-set-sender observer, used by extensions to modify the
+ * outgoing server, works.
+ *
+ * This is adapted from test_messageHeaders.js
+ */
+
+var CompFields = CC(
+  "@mozilla.org/messengercompose/composefields;1",
+  Ci.nsIMsgCompFields
+);
+
+// nsIObserver implementation.
+var gData = "";
+var observer = {
+  observe(aSubject, aTopic, aData) {
+    if (aTopic == "mail-set-sender") {
+      Assert.ok(aSubject instanceof Ci.nsIMsgCompose);
+      gData = aData;
+    }
+  },
+};
+
+add_task(async function testObserver() {
+  let fields = new CompFields();
+  let identity = getSmtpIdentity(
+    "from@tinderbox.invalid",
+    getBasicSmtpServer()
+  );
+  identity.fullName = "Observer Tester";
+  fields.to = "Emile <nobody@tinderbox.invalid>";
+  fields.cc = "Alex <alex@tinderbox.invalid>";
+  fields.subject = "Let's test the observer";
+
+  await richCreateMessage(fields, [], identity);
+  // observer data should have:
+  // (no account), Ci.nsIMsgSend.nsMsgSaveAsDraft, identity.key
+  Assert.equal(gData, ",4,id1");
+
+  // Now try with an account
+  await richCreateMessage(fields, [], identity, localAccountUtils.msgAccount);
+  // observer data should have:
+  // (local account key), Ci.nsIMsgSend.nsMsgSaveAsDraft, identity.key
+  Assert.equal(gData, "account1,4,id1");
+});
+
+function run_test() {
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+  Services.obs.addObserver(observer, "mail-set-sender");
+  run_next_test();
+}
diff --git a/comm/mailnews/compose/test/unit/test_smtp8bitMime.js b/comm/mailnews/compose/test/unit/test_smtp8bitMime.js
new file mode 100644
index 0000000000..d763947154
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtp8bitMime.js
@@ -0,0 +1,105 @@
+/**
+ * 8BITMIME tests for SMTP.
+ *
+ * This test verifies that 8BITMIME is sent to the server only if the server
+ * advertises it AND if mail.strictly_mime doesn't force us to send 7bit.
+ * It does not check the data of the message on either side of the link.
+ */
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+
+var server;
+
+var kIdentityMail = "identity@foo.invalid";
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+
+// aStrictMime: Test if mail.strictly_mime omits the BODY=8BITMIME attribute.
+// aServer8bit: Test if BODY=8BITMIME is only sent if advertised by the server.
+
+async function test_8bitmime(aStrictMime, aServer8bit) {
+  // Test file
+  var testFile = do_get_file("data/message1.eml");
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  server.start();
+  var smtpServer = getBasicSmtpServer(server.port);
+  var identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    test =
+      "Strictly MIME" +
+      (aStrictMime ? "on (7bit" : "off (8bit") +
+      ", 8BITMIME " +
+      (aServer8bit ? "" : "not ") +
+      "advertised)";
+
+    Services.prefs.setBoolPref("mail.strictly_mime", aStrictMime);
+
+    let urlListener = new PromiseTestUtils.PromiseUrlListener();
+    MailServices.smtp.sendMailMessage(
+      testFile,
+      kTo,
+      identity,
+      kSender,
+      null,
+      urlListener,
+      null,
+      null,
+      false,
+      "",
+      {},
+      {}
+    );
+
+    await urlListener.promise;
+
+    var transaction = server.playTransaction();
+    do_check_transaction(transaction, [
+      "EHLO test",
+      "MAIL FROM:<" +
+        kSender +
+        (!aStrictMime && aServer8bit
+          ? "> BODY=8BITMIME SIZE=159"
+          : "> SIZE=159"),
+      "RCPT TO:<" + kTo + ">",
+      "DATA",
+    ]);
+
+    server.resetTest();
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+}
+
+add_task(async function run() {
+  // The default SMTP server advertises 8BITMIME capability.
+  server = setupServerDaemon();
+  await test_8bitmime(true, true);
+  await test_8bitmime(false, true);
+
+  // Now we need a server which does not advertise 8BITMIME capability.
+  function createHandler(d) {
+    var handler = new SMTP_RFC2821_handler(d);
+    handler.kCapabilities = ["SIZE"];
+    return handler;
+  }
+  server = setupServerDaemon(createHandler);
+  await test_8bitmime(true, false);
+  await test_8bitmime(false, false);
+});
diff --git a/comm/mailnews/compose/test/unit/test_smtpAuthMethods.js b/comm/mailnews/compose/test/unit/test_smtpAuthMethods.js
new file mode 100644
index 0000000000..24d5c6d554
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpAuthMethods.js
@@ -0,0 +1,166 @@
+/**
+ * Authentication tests for SMTP.
+ *
+ * Test code <copied from="test_pop3AuthMethods.js">
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { TestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TestUtils.sys.mjs"
+);
+const { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+
+var server;
+var kAuthSchemes;
+var smtpServer;
+var testFile;
+var identity;
+
+var kUsername = "fred";
+var kPassword = "wilma";
+var kIdentityMail = "identity@foo.invalid";
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+var MAILFROM = "MAIL FROM:<" + kSender + "> BODY=8BITMIME SIZE=159";
+var RCPTTO = "RCPT TO:<" + kTo + ">";
+var AUTHPLAIN = "AUTH PLAIN " + AuthPLAIN.encodeLine(kUsername, kPassword);
+
+var tests = [
+  {
+    title:
+      "Cleartext password, with server supporting AUTH PLAIN, LOGIN, and CRAM",
+    clientAuthMethod: Ci.nsMsgAuthMethod.passwordCleartext,
+    serverAuthMethods: ["PLAIN", "LOGIN", "CRAM-MD5"],
+    expectSuccess: true,
+    transaction: ["EHLO test", AUTHPLAIN, MAILFROM, RCPTTO, "DATA"],
+  },
+  {
+    title: "Cleartext password, with server only supporting AUTH LOGIN",
+    clientAuthMethod: Ci.nsMsgAuthMethod.passwordCleartext,
+    serverAuthMethods: ["LOGIN"],
+    expectSuccess: true,
+    transaction: ["EHLO test", "AUTH LOGIN", MAILFROM, RCPTTO, "DATA"],
+  },
+  {
+    title:
+      "Encrypted password, with server supporting AUTH PLAIN, LOGIN and CRAM",
+    clientAuthMethod: Ci.nsMsgAuthMethod.passwordEncrypted,
+    serverAuthMethods: ["PLAIN", "LOGIN", "CRAM-MD5"],
+    expectSuccess: true,
+    transaction: ["EHLO test", "AUTH CRAM-MD5", MAILFROM, RCPTTO, "DATA"],
+  },
+  {
+    title:
+      "Encrypted password, with server only supporting AUTH PLAIN (must fail)",
+    clientAuthMethod: Ci.nsMsgAuthMethod.passwordEncrypted,
+    serverAuthMethods: ["PLAIN"],
+    expectSuccess: false,
+    transaction: ["EHLO test"],
+  },
+  {
+    title:
+      "Any secure method, with server supporting AUTH PLAIN, LOGIN and CRAM",
+    clientAuthMethod: Ci.nsMsgAuthMethod.secure,
+    serverAuthMethods: ["PLAIN", "LOGIN", "CRAM-MD5"],
+    expectSuccess: true,
+    transaction: ["EHLO test", "AUTH CRAM-MD5", MAILFROM, RCPTTO, "DATA"],
+  },
+  {
+    title:
+      "Any secure method, with server only supporting AUTH PLAIN (must fail)",
+    clientAuthMethod: Ci.nsMsgAuthMethod.secure,
+    serverAuthMethods: ["PLAIN"],
+    expectSuccess: false,
+    transaction: ["EHLO test"],
+  },
+];
+
+function nextTest() {
+  if (tests.length == 0) {
+    // this is sync, so we run into endTest() at the end of run_test() now
+    return;
+  }
+  server.resetTest();
+
+  var curTest = tests.shift();
+  test = curTest.title;
+  dump("NEXT test: " + curTest.title + "\n");
+
+  // Adapt to curTest
+  kAuthSchemes = curTest.serverAuthMethods;
+  smtpServer.authMethod = curTest.clientAuthMethod;
+
+  // Run test
+  let urlListener = new PromiseTestUtils.PromiseUrlListener();
+  MailServices.smtp.sendMailMessage(
+    testFile,
+    kTo,
+    identity,
+    kSender,
+    null,
+    urlListener,
+    null,
+    null,
+    false,
+    "",
+    {},
+    {}
+  );
+  let resolved = false;
+  urlListener.promise.catch(e => {}).finally(() => (resolved = true));
+  Services.tm.spinEventLoopUntil("wait for sending", () => resolved);
+
+  do_check_transaction(server.playTransaction(), curTest.transaction);
+
+  smtpServer.closeCachedConnections();
+  nextTest();
+}
+
+function run_test() {
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    function createHandler(d) {
+      var handler = new SMTP_RFC2821_handler(d);
+      handler.kUsername = kUsername;
+      handler.kPassword = kPassword;
+      handler.kAuthRequired = true;
+      handler.kAuthSchemes = kAuthSchemes;
+      return handler;
+    }
+    server = setupServerDaemon(createHandler);
+    dump("AUTH PLAIN = " + AUTHPLAIN + "\n");
+    server.start();
+
+    localAccountUtils.loadLocalMailAccount();
+    smtpServer = getBasicSmtpServer(server.port);
+    smtpServer.socketType = Ci.nsMsgSocketType.plain;
+    smtpServer.username = kUsername;
+    smtpServer.password = kPassword;
+    identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+    testFile = do_get_file("data/message1.eml");
+
+    nextTest();
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    endTest();
+  }
+}
+
+function endTest() {
+  dump("endTest()\n");
+  server.stop();
+
+  dump("emptying event loop\n");
+  var thread = gThreadManager.currentThread;
+  while (thread.hasPendingEvents()) {
+    dump("next event\n");
+    thread.processNextEvent(true);
+  }
+}
diff --git a/comm/mailnews/compose/test/unit/test_smtpClient.js b/comm/mailnews/compose/test/unit/test_smtpClient.js
new file mode 100644
index 0000000000..b06ec48560
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpClient.js
@@ -0,0 +1,136 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+
+let server = setupServerDaemon();
+server.start();
+registerCleanupFunction(() => {
+  server.stop();
+});
+
+/**
+ * Test sending is aborted when alwaysSTARTTLS is set, but the server doesn't
+ * support STARTTLS.
+ */
+add_task(async function testAbort() {
+  server.resetTest();
+  let smtpServer = getBasicSmtpServer(server.port);
+  let identity = getSmtpIdentity("identity@foo.invalid", smtpServer);
+  // Set to always use STARTTLS.
+  smtpServer.socketType = Ci.nsMsgSocketType.alwaysSTARTTLS;
+
+  do_test_pending();
+
+  let urlListener = {
+    OnStartRunningUrl(url) {},
+    OnStopRunningUrl(url, status) {
+      // Test sending is aborted with NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS.
+      Assert.equal(status, 0x80553126);
+      do_test_finished();
+    },
+  };
+
+  // Send a message.
+  let testFile = do_get_file("data/message1.eml");
+  MailServices.smtp.sendMailMessage(
+    testFile,
+    "to@foo.invalid",
+    identity,
+    "from@foo.invalid",
+    null,
+    urlListener,
+    null,
+    null,
+    false,
+    "",
+    {},
+    {}
+  );
+  server.performTest();
+});
+
+/**
+ * Test client identity extension works.
+ */
+add_task(async function testClientIdentityExtension() {
+  server.resetTest();
+  let smtpServer = getBasicSmtpServer(server.port);
+  let identity = getSmtpIdentity("identity@foo.invalid", smtpServer);
+  // Enable and set clientid to the smtp server.
+  smtpServer.clientidEnabled = true;
+  smtpServer.clientid = "uuid-111";
+
+  // Send a message.
+  let asyncUrlListener = new PromiseTestUtils.PromiseUrlListener();
+  let testFile = do_get_file("data/message1.eml");
+  MailServices.smtp.sendMailMessage(
+    testFile,
+    "to@foo.invalid",
+    identity,
+    "from@foo.invalid",
+    null,
+    asyncUrlListener,
+    null,
+    null,
+    false,
+    "",
+    {},
+    {}
+  );
+
+  await asyncUrlListener.promise;
+
+  // Check CLIENTID command is sent.
+  let transaction = server.playTransaction();
+  do_check_transaction(transaction, [
+    "EHLO test",
+    "CLIENTID UUID uuid-111",
+    "MAIL FROM:<from@foo.invalid> BODY=8BITMIME SIZE=159",
+    "RCPT TO:<to@foo.invalid>",
+    "DATA",
+  ]);
+});
+
+/**
+ * Test that when To and Cc/Bcc contain the same address, should send only
+ * one RCPT TO per address.
+ */
+add_task(async function testDeduplicateRecipients() {
+  server.resetTest();
+  let smtpServer = getBasicSmtpServer(server.port);
+  let identity = getSmtpIdentity("identity@foo.invalid", smtpServer);
+
+  // Send a message, notice to1 appears twice in the recipients argument.
+  let asyncUrlListener = new PromiseTestUtils.PromiseUrlListener();
+  let testFile = do_get_file("data/message1.eml");
+  MailServices.smtp.sendMailMessage(
+    testFile,
+    "to1@foo.invalid,to2@foo.invalid,to1@foo.invalid",
+    identity,
+    "from@foo.invalid",
+    null,
+    asyncUrlListener,
+    null,
+    null,
+    false,
+    "",
+    {},
+    {}
+  );
+
+  await asyncUrlListener.promise;
+
+  // Check only one RCPT TO is sent for to1.
+  let transaction = server.playTransaction();
+  do_check_transaction(transaction, [
+    "EHLO test",
+    "MAIL FROM:<from@foo.invalid> BODY=8BITMIME SIZE=159",
+    "RCPT TO:<to1@foo.invalid>",
+    "RCPT TO:<to2@foo.invalid>",
+    "DATA",
+  ]);
+});
diff --git a/comm/mailnews/compose/test/unit/test_smtpPassword.js b/comm/mailnews/compose/test/unit/test_smtpPassword.js
new file mode 100644
index 0000000000..f4b8515df7
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpPassword.js
@@ -0,0 +1,97 @@
+/**
+ * Authentication tests for SMTP.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+
+/* import-globals-from ../../../test/resources/passwordStorage.js */
+load("../../../resources/passwordStorage.js");
+
+var server;
+
+var kIdentityMail = "identity@foo.invalid";
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+var kUsername = "testsmtp";
+// Password needs to match the login information stored in the signons json
+// file.
+var kPassword = "smtptest";
+
+add_task(async function () {
+  function createHandler(d) {
+    var handler = new SMTP_RFC2821_handler(d);
+    // Username needs to match the login information stored in the signons json
+    // file.
+    handler.kUsername = kUsername;
+    handler.kPassword = kPassword;
+    handler.kAuthRequired = true;
+    return handler;
+  }
+  server = setupServerDaemon(createHandler);
+
+  // Prepare files for passwords (generated by a script in bug 1018624).
+  await setupForPassword("signons-mailnews1.8.json");
+
+  // Test file
+  var testFile = do_get_file("data/message1.eml");
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // Start the fake SMTP server
+    server.start();
+    var smtpServer = getBasicSmtpServer(server.port);
+    var identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+    // This time with auth
+    test = "Auth sendMailMessage";
+
+    smtpServer.authMethod = Ci.nsMsgAuthMethod.passwordCleartext;
+    smtpServer.socketType = Ci.nsMsgSocketType.plain;
+    smtpServer.username = kUsername;
+
+    let urlListener = new PromiseTestUtils.PromiseUrlListener();
+    MailServices.smtp.sendMailMessage(
+      testFile,
+      kTo,
+      identity,
+      kSender,
+      null,
+      urlListener,
+      null,
+      null,
+      false,
+      "",
+      {},
+      {}
+    );
+
+    await urlListener.promise;
+
+    var transaction = server.playTransaction();
+    do_check_transaction(transaction, [
+      "EHLO test",
+      "AUTH PLAIN " + AuthPLAIN.encodeLine(kUsername, kPassword),
+      "MAIL FROM:<" + kSender + "> BODY=8BITMIME SIZE=159",
+      "RCPT TO:<" + kTo + ">",
+      "DATA",
+    ]);
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+});
diff --git a/comm/mailnews/compose/test/unit/test_smtpPassword2.js b/comm/mailnews/compose/test/unit/test_smtpPassword2.js
new file mode 100644
index 0000000000..a0445ad0a3
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpPassword2.js
@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/**
+ * Extra tests for SMTP passwords (forgetPassword)
+ */
+
+/* import-globals-from ../../../test/resources/passwordStorage.js */
+load("../../../resources/passwordStorage.js");
+
+var kUser1 = "testsmtp";
+var kUser2 = "testsmtpa";
+var kProtocol = "smtp";
+var kHostname = "localhost";
+var kServerUrl = kProtocol + "://" + kHostname;
+
+add_task(async function () {
+  // Prepare files for passwords (generated by a script in bug 1018624).
+  await setupForPassword("signons-mailnews1.8-multiple.json");
+
+  // Set up the basic accounts and folders.
+  localAccountUtils.loadLocalMailAccount();
+
+  var smtpServer1 = getBasicSmtpServer();
+  var smtpServer2 = getBasicSmtpServer();
+
+  smtpServer1.authMethod = 3;
+  smtpServer1.username = kUser1;
+  smtpServer2.authMethod = 3;
+  smtpServer2.username = kUser2;
+
+  // Test - Check there are two logins to begin with.
+  let logins = Services.logins.findLogins(kServerUrl, null, kServerUrl);
+
+  Assert.equal(logins.length, 2);
+
+  // These will either be one way around or the other.
+  if (logins[0].username == kUser1) {
+    Assert.equal(logins[1].username, kUser2);
+  } else {
+    Assert.equal(logins[0].username, kUser2);
+    Assert.equal(logins[1].username, kUser1);
+  }
+
+  // Test - Remove a login via the incoming server
+  smtpServer1.forgetPassword();
+
+  logins = Services.logins.findLogins(kServerUrl, null, kServerUrl);
+
+  // should be one login left for kUser2
+  Assert.equal(logins.length, 1);
+  Assert.equal(logins[0].username, kUser2);
+
+  // Test - Remove the other login via the incoming server
+  smtpServer2.forgetPassword();
+
+  logins = Services.logins.findLogins(kServerUrl, null, kServerUrl);
+
+  // There should be no login left.
+  Assert.equal(logins.length, 0);
+});
diff --git a/comm/mailnews/compose/test/unit/test_smtpPasswordFailure1.js b/comm/mailnews/compose/test/unit/test_smtpPasswordFailure1.js
new file mode 100644
index 0000000000..b7d7f1ef43
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpPasswordFailure1.js
@@ -0,0 +1,151 @@
+/**
+ * This test checks to see if the smtp password failure is handled correctly.
+ * The steps are:
+ *   - Have an invalid password in the password database.
+ *   - Check we get a prompt asking what to do.
+ *   - Check retry does what it should do.
+ *   - Check cancel does what it should do.
+ *
+ * XXX Due to problems with the fakeserver + smtp not using one connection for
+ * multiple sends, the rest of this test is in test_smtpPasswordFailure2.js.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+/* import-globals-from ../../../test/resources/alertTestUtils.js */
+/* import-globals-from ../../../test/resources/passwordStorage.js */
+load("../../../resources/alertTestUtils.js");
+load("../../../resources/passwordStorage.js");
+
+var server;
+var attempt = 0;
+
+var kIdentityMail = "identity@foo.invalid";
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+var kUsername = "testsmtp";
+// Login information needs to match the login information stored in the signons
+// json file.
+var kInvalidPassword = "smtptest";
+var kValidPassword = "smtptest1";
+
+/* exported alert, confirmEx */
+// for alertTestUtils.js
+function alert(aDialogText, aText) {
+  // The first few attempts may prompt about the password problem, the last
+  // attempt shouldn't.
+  Assert.ok(attempt < 4);
+
+  // Log the fact we've got an alert, but we don't need to test anything here.
+  dump("Alert Title: " + aDialogText + "\nAlert Text: " + aText + "\n");
+}
+
+function confirmExPS(
+  parent,
+  aDialogTitle,
+  aText,
+  aButtonFlags,
+  aButton0Title,
+  aButton1Title,
+  aButton2Title,
+  aCheckMsg,
+  aCheckState
+) {
+  switch (++attempt) {
+    // First attempt, retry.
+    case 1:
+      dump("\nAttempting retry\n");
+      return 0;
+    // Second attempt, cancel.
+    case 2:
+      dump("\nCancelling login attempt\n");
+      return 1;
+    default:
+      do_throw("unexpected attempt number " + attempt);
+      return 1;
+  }
+}
+
+add_task(async function () {
+  function createHandler(d) {
+    var handler = new SMTP_RFC2821_handler(d);
+    // Username needs to match the login information stored in the signons json
+    // file.
+    handler.kUsername = kUsername;
+    handler.kPassword = kValidPassword;
+    handler.kAuthRequired = true;
+    return handler;
+  }
+  server = setupServerDaemon(createHandler);
+
+  // Prepare files for passwords (generated by a script in bug 1018624).
+  await setupForPassword("signons-mailnews1.8.json");
+
+  registerAlertTestUtils();
+
+  // Test file
+  var testFile = do_get_file("data/message1.eml");
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  server.start();
+  var smtpServer = getBasicSmtpServer(server.port);
+  var identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // This time with auth
+    test = "Auth sendMailMessage";
+
+    smtpServer.authMethod = Ci.nsMsgAuthMethod.passwordCleartext;
+    smtpServer.socketType = Ci.nsMsgSocketType.plain;
+    smtpServer.username = kUsername;
+
+    dump("Send\n");
+
+    MailServices.smtp.sendMailMessage(
+      testFile,
+      kTo,
+      identity,
+      kSender,
+      null,
+      null,
+      null,
+      null,
+      false,
+      "",
+      {},
+      {}
+    );
+
+    server.performTest();
+
+    dump("End Send\n");
+
+    Assert.equal(attempt, 2);
+
+    // Check that we haven't forgetton the login even though we've retried and cancelled.
+    let logins = Services.logins.findLogins(
+      "smtp://localhost",
+      null,
+      "smtp://localhost"
+    );
+
+    Assert.equal(logins.length, 1);
+    Assert.equal(logins[0].username, kUsername);
+    Assert.equal(logins[0].password, kInvalidPassword);
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+});
diff --git a/comm/mailnews/compose/test/unit/test_smtpPasswordFailure2.js b/comm/mailnews/compose/test/unit/test_smtpPasswordFailure2.js
new file mode 100644
index 0000000000..f394db434d
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpPasswordFailure2.js
@@ -0,0 +1,178 @@
+/**
+ * This test checks to see if the pop3 password failure is handled correctly.
+ * The steps are:
+ *   - Have an invalid password in the password database.
+ *   - Re-initiate connection, this time select enter new password, check that
+ *     we get a new password prompt and can enter the password.
+ *
+ * XXX Due to problems with the fakeserver + smtp not using one connection for
+ * multiple sends, the first part of this test is in
+ * test_smtpPasswordFailure2.js.
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+
+/* import-globals-from ../../../test/resources/alertTestUtils.js */
+/* import-globals-from ../../../test/resources/passwordStorage.js */
+load("../../../resources/alertTestUtils.js");
+load("../../../resources/passwordStorage.js");
+
+var server;
+var attempt = 0;
+
+var kIdentityMail = "identity@foo.invalid";
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+var kUsername = "testsmtp";
+// Password needs to match the login information stored in the signons json
+// file.
+var kInvalidPassword = "smtptest";
+var kValidPassword = "smtptest1";
+
+function confirmExPS(
+  aDialogTitle,
+  aText,
+  aButtonFlags,
+  aButton0Title,
+  aButton1Title,
+  aButton2Title,
+  aCheckMsg,
+  aCheckState
+) {
+  switch (++attempt) {
+    // First attempt, retry.
+    case 1:
+      dump("\nAttempting Retry\n");
+      return 0;
+    // Second attempt, enter a new password.
+    case 2:
+      dump("\nEnter new password\n");
+      return 2;
+    default:
+      do_throw("unexpected attempt number " + attempt);
+      return 1;
+  }
+}
+
+function promptPasswordPS(
+  aParent,
+  aDialogTitle,
+  aText,
+  aPassword,
+  aCheckMsg,
+  aCheckState
+) {
+  if (attempt == 2) {
+    aPassword.value = kValidPassword;
+    aCheckState.value = true;
+    return true;
+  }
+  return false;
+}
+
+add_task(async function () {
+  function createHandler(d) {
+    var handler = new SMTP_RFC2821_handler(d);
+    // Username needs to match the login information stored in the signons json
+    // file.
+    handler.kUsername = kUsername;
+    handler.kPassword = kValidPassword;
+    handler.kAuthRequired = true;
+    handler.kAuthSchemes = ["PLAIN", "LOGIN"]; // make match expected transaction below
+    return handler;
+  }
+  server = setupServerDaemon(createHandler);
+
+  // Prepare files for passwords (generated by a script in bug 1018624).
+  await setupForPassword("signons-mailnews1.8.json");
+
+  registerAlertTestUtils();
+
+  // Test file
+  var testFile = do_get_file("data/message1.eml");
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  // Handle the server in a try/catch/finally loop so that we always will stop
+  // the server if something fails.
+  try {
+    // Start the fake SMTP server
+    server.start();
+    var smtpServer = getBasicSmtpServer(server.port);
+    var identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+    // This time with auth
+    test = "Auth sendMailMessage";
+
+    smtpServer.authMethod = Ci.nsMsgAuthMethod.passwordCleartext;
+    smtpServer.socketType = Ci.nsMsgSocketType.plain;
+    smtpServer.username = kUsername;
+
+    dump("Send\n");
+
+    let urlListener = new PromiseTestUtils.PromiseUrlListener();
+    MailServices.smtp.sendMailMessage(
+      testFile,
+      kTo,
+      identity,
+      kSender,
+      null,
+      urlListener,
+      null,
+      null,
+      false,
+      "",
+      {},
+      {}
+    );
+
+    await urlListener.promise;
+
+    dump("End Send\n");
+
+    Assert.equal(attempt, 2);
+
+    var transaction = server.playTransaction();
+    do_check_transaction(transaction, [
+      "EHLO test",
+      // attempt 3 invalid password
+      "AUTH PLAIN " + AuthPLAIN.encodeLine(kUsername, kInvalidPassword),
+      "AUTH LOGIN",
+      // attempt 4 which retries
+      "AUTH PLAIN " + AuthPLAIN.encodeLine(kUsername, kInvalidPassword),
+      "AUTH LOGIN",
+      // then we enter the correct password
+      "AUTH PLAIN " + AuthPLAIN.encodeLine(kUsername, kValidPassword),
+      "MAIL FROM:<" + kSender + "> BODY=8BITMIME SIZE=159",
+      "RCPT TO:<" + kTo + ">",
+      "DATA",
+    ]);
+
+    // Now check the new one has been saved.
+    let logins = Services.logins.findLogins(
+      "smtp://localhost",
+      null,
+      "smtp://localhost"
+    );
+
+    Assert.equal(logins.length, 1);
+    Assert.equal(logins[0].username, kUsername);
+    Assert.equal(logins[0].password, kValidPassword);
+    do_test_finished();
+  } catch (e) {
+    do_throw(e);
+  } finally {
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+  }
+});
diff --git a/comm/mailnews/compose/test/unit/test_smtpPasswordFailure3.js b/comm/mailnews/compose/test/unit/test_smtpPasswordFailure3.js
new file mode 100644
index 0000000000..27312b47a4
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpPasswordFailure3.js
@@ -0,0 +1,154 @@
+/**
+ * This test checks to see if the smtp password failure is handled correctly
+ * when the server drops the connection on an authentication error.
+ * The steps are:
+ *   - Have an invalid password in the password database.
+ *   - Re-initiate connection, this time select enter new password, check that
+ *     we get a new password prompt and can enter the password.
+ *
+ */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+/* import-globals-from ../../../test/resources/alertTestUtils.js */
+/* import-globals-from ../../../test/resources/passwordStorage.js */
+load("../../../resources/alertTestUtils.js");
+load("../../../resources/passwordStorage.js");
+
+var server;
+var attempt = 0;
+
+var kIdentityMail = "identity@foo.invalid";
+var kSender = "from@foo.invalid";
+var kTo = "to@foo.invalid";
+var kUsername = "testsmtp";
+// Password needs to match the login information stored in the signons json
+// file.
+var kValidPassword = "smtptest1";
+
+function confirmExPS(
+  aDialogTitle,
+  aText,
+  aButtonFlags,
+  aButton0Title,
+  aButton1Title,
+  aButton2Title,
+  aCheckMsg,
+  aCheckState
+) {
+  switch (++attempt) {
+    // First attempt, retry.
+    case 1:
+      dump("\nAttempting Retry\n");
+      return 0;
+    // Second attempt, enter a new password.
+    case 2:
+      dump("\nEnter new password\n");
+      return 2;
+    default:
+      do_throw("unexpected attempt number " + attempt);
+      return 1;
+  }
+}
+
+function promptPasswordPS(
+  aParent,
+  aDialogTitle,
+  aText,
+  aPassword,
+  aCheckMsg,
+  aCheckState
+) {
+  if (attempt == 2) {
+    aPassword.value = kValidPassword;
+    aCheckState.value = true;
+    return true;
+  }
+  return false;
+}
+
+add_task(async function () {
+  function createHandler(d) {
+    var handler = new SMTP_RFC2821_handler(d);
+    handler.dropOnAuthFailure = true;
+    // Username needs to match the login information stored in the signons json
+    // file.
+    handler.kUsername = kUsername;
+    handler.kPassword = kValidPassword;
+    handler.kAuthRequired = true;
+    handler.kAuthSchemes = ["PLAIN", "LOGIN"]; // make match expected transaction below
+    return handler;
+  }
+  server = setupServerDaemon(createHandler);
+
+  // Prepare files for passwords (generated by a script in bug 1018624).
+  await setupForPassword("signons-mailnews1.8.json");
+
+  registerAlertTestUtils();
+
+  // Test file
+  var testFile = do_get_file("data/message1.eml");
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  // Start the fake SMTP server
+  server.start();
+  var smtpServer = getBasicSmtpServer(server.port);
+  var identity = getSmtpIdentity(kIdentityMail, smtpServer);
+
+  // This time with auth
+  test = "Auth sendMailMessage";
+
+  smtpServer.authMethod = Ci.nsMsgAuthMethod.passwordCleartext;
+  smtpServer.socketType = Ci.nsMsgSocketType.plain;
+  smtpServer.username = kUsername;
+
+  do_test_pending();
+
+  MailServices.smtp.sendMailMessage(
+    testFile,
+    kTo,
+    identity,
+    kSender,
+    null,
+    URLListener,
+    null,
+    null,
+    false,
+    "",
+    {},
+    {}
+  );
+
+  server.performTest();
+});
+
+var URLListener = {
+  OnStartRunningUrl(url) {},
+  OnStopRunningUrl(url, rc) {
+    // Check for ok status.
+    Assert.equal(rc, 0);
+    // Now check the new password has been saved.
+    let logins = Services.logins.findLogins(
+      "smtp://localhost",
+      null,
+      "smtp://localhost"
+    );
+
+    Assert.equal(logins.length, 1);
+    Assert.equal(logins[0].username, kUsername);
+    Assert.equal(logins[0].password, kValidPassword);
+
+    server.stop();
+
+    var thread = gThreadManager.currentThread;
+    while (thread.hasPendingEvents()) {
+      thread.processNextEvent(true);
+    }
+
+    do_test_finished();
+  },
+};
diff --git a/comm/mailnews/compose/test/unit/test_smtpProtocols.js b/comm/mailnews/compose/test/unit/test_smtpProtocols.js
new file mode 100644
index 0000000000..bba7d55b6b
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpProtocols.js
@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Test suite for getting smtp urls via the protocol handler.
+ */
+
+var defaultProtocolFlags =
+  Ci.nsIProtocolHandler.URI_NORELATIVE |
+  Ci.nsIProtocolHandler.URI_DANGEROUS_TO_LOAD |
+  Ci.nsIProtocolHandler.URI_NON_PERSISTABLE |
+  Ci.nsIProtocolHandler.ALLOWS_PROXY |
+  Ci.nsIProtocolHandler.URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT;
+
+var protocols = [
+  {
+    protocol: "smtp",
+    urlSpec: "smtp://user@localhost/",
+    defaultPort: Ci.nsISmtpUrl.DEFAULT_SMTP_PORT,
+  },
+  {
+    protocol: "smtps",
+    urlSpec: "smtps://user@localhost/",
+    defaultPort: Ci.nsISmtpUrl.DEFAULT_SMTPS_PORT,
+  },
+];
+
+function run_test() {
+  for (var part = 0; part < protocols.length; ++part) {
+    print("protocol: " + protocols[part].protocol);
+
+    var pH = Cc[
+      "@mozilla.org/network/protocol;1?name=" + protocols[part].protocol
+    ].createInstance(Ci.nsIProtocolHandler);
+
+    Assert.equal(pH.scheme, protocols[part].protocol);
+    Assert.equal(
+      Services.io.getDefaultPort(pH.scheme),
+      protocols[part].defaultPort
+    );
+    Assert.equal(Services.io.getProtocolFlags(pH.scheme), defaultProtocolFlags);
+
+    // Whip through some of the ports to check we get the right results.
+    for (let i = 0; i < 1024; ++i) {
+      Assert.equal(pH.allowPort(i, ""), i == protocols[part].defaultPort);
+    }
+
+    // Check we get a URI when we ask for one
+    var uri = Services.io.newURI(protocols[part].urlSpec);
+
+    uri.QueryInterface(Ci.nsISmtpUrl);
+
+    Assert.equal(uri.spec, protocols[part].urlSpec);
+
+    try {
+      // This call should throw NS_ERROR_NOT_IMPLEMENTED. If it doesn't,
+      // then we should implement a new test for it.
+      pH.newChannel(uri, null);
+      // If it didn't throw, then shout about it.
+      do_throw("newChannel not throwing NS_ERROR_NOT_IMPLEMENTED.");
+    } catch (ex) {
+      Assert.equal(ex.result, Cr.NS_ERROR_NOT_IMPLEMENTED);
+    }
+  }
+}
diff --git a/comm/mailnews/compose/test/unit/test_smtpProxy.js b/comm/mailnews/compose/test/unit/test_smtpProxy.js
new file mode 100644
index 0000000000..7a008be001
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpProxy.js
@@ -0,0 +1,49 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+// Tests that SMTP over a SOCKS proxy works.
+
+const { NetworkTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/NetworkTestUtils.jsm"
+);
+const { PromiseTestUtils } = ChromeUtils.import(
+  "resource://testing-common/mailnews/PromiseTestUtils.jsm"
+);
+
+const PORT = 25;
+var daemon, localserver, server;
+
+add_setup(function () {
+  localAccountUtils.loadLocalMailAccount();
+  server = setupServerDaemon();
+  daemon = server._daemon;
+  server.start();
+  NetworkTestUtils.configureProxy("smtp.tinderbox.invalid", PORT, server.port);
+  localserver = getBasicSmtpServer(PORT, "smtp.tinderbox.invalid");
+});
+
+add_task(async function sendMessage() {
+  equal(daemon.post, undefined);
+  let identity = getSmtpIdentity("test@tinderbox.invalid", localserver);
+  var testFile = do_get_file("data/message1.eml");
+  var urlListener = new PromiseTestUtils.PromiseUrlListener();
+  MailServices.smtp.sendMailMessage(
+    testFile,
+    "somebody@example.org",
+    identity,
+    "me@example.org",
+    null,
+    urlListener,
+    null,
+    null,
+    false,
+    "",
+    {},
+    {}
+  );
+  await urlListener.promise;
+  notEqual(daemon.post, "");
+});
+
+add_task(async function cleanUp() {
+  NetworkTestUtils.shutdownServers();
+});
diff --git a/comm/mailnews/compose/test/unit/test_smtpServer.js b/comm/mailnews/compose/test/unit/test_smtpServer.js
new file mode 100644
index 0000000000..5e252a44f0
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpServer.js
@@ -0,0 +1,104 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Tests for nsISmtpServer implementation.
+ */
+
+/**
+ * Test that cached server password is cleared when password storage changed.
+ */
+add_task(async function test_passwordmgr_change() {
+  // Create an nsISmtpServer instance and set a password.
+  let server = Cc["@mozilla.org/messenger/smtp/server;1"].createInstance(
+    Ci.nsISmtpServer
+  );
+  server.password = "smtp-pass";
+  equal(server.password, "smtp-pass", "Password should be cached.");
+
+  // Trigger the change event of password manager.
+  Services.logins.setLoginSavingEnabled("smtp://localhost", false);
+  equal(server.password, "", "Password should be cleared.");
+});
+
+/**
+ * Test getter/setter of attributes.
+ */
+add_task(async function test_attributes() {
+  // Create an nsISmtpServer instance and set a password.
+  let server = Cc["@mozilla.org/messenger/smtp/server;1"].createInstance(
+    Ci.nsISmtpServer
+  );
+
+  server.description = "アイウ";
+  equal(server.description, "アイウ", "Description should be correctly set.");
+
+  server.hostname = "サービス.jp";
+  equal(server.hostname, "サービス.jp", "Hostname should be correctly set.");
+});
+
+/**
+ * Tests the UID attribute of servers.
+ */
+add_task(async function testUID() {
+  const UUID_REGEXP =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+  // Create a server and check it the UID is set when accessed.
+
+  let serverA = MailServices.smtp.createServer();
+  Assert.stringMatches(
+    serverA.UID,
+    UUID_REGEXP,
+    "server A's UID should exist and be a UUID"
+  );
+  Assert.equal(
+    Services.prefs.getStringPref(`mail.smtpserver.${serverA.key}.uid`),
+    serverA.UID,
+    "server A's UID should be saved to the preferences"
+  );
+  Assert.throws(
+    () => (serverA.UID = "00001111-2222-3333-4444-555566667777"),
+    /NS_ERROR_ABORT/,
+    "server A's UID should be unchangeable after it is set"
+  );
+
+  // Create a second server and check the two UIDs don't match.
+
+  let serverB = MailServices.smtp.createServer();
+  Assert.stringMatches(
+    serverB.UID,
+    UUID_REGEXP,
+    "server B's UID should exist and be a UUID"
+  );
+  Assert.equal(
+    Services.prefs.getStringPref(`mail.smtpserver.${serverB.key}.uid`),
+    serverB.UID,
+    "server B's UID should be saved to the preferences"
+  );
+  Assert.notEqual(
+    serverB.UID,
+    serverA.UID,
+    "server B's UID should not be the same as server A's"
+  );
+
+  // Create a third server and set the UID before it is accessed.
+
+  let serverC = MailServices.smtp.createServer();
+  serverC.UID = "11112222-3333-4444-5555-666677778888";
+  Assert.equal(
+    serverC.UID,
+    "11112222-3333-4444-5555-666677778888",
+    "server C's UID set correctly"
+  );
+  Assert.equal(
+    Services.prefs.getStringPref(`mail.smtpserver.${serverC.key}.uid`),
+    "11112222-3333-4444-5555-666677778888",
+    "server C's UID should be saved to the preferences"
+  );
+  Assert.throws(
+    () => (serverC.UID = "22223333-4444-5555-6666-777788889999"),
+    /NS_ERROR_ABORT/,
+    "server C's UID should be unchangeable after it is set"
+  );
+});
diff --git a/comm/mailnews/compose/test/unit/test_smtpURL.js b/comm/mailnews/compose/test/unit/test_smtpURL.js
new file mode 100644
index 0000000000..833ca91817
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_smtpURL.js
@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Test suite for checking SMTP URLs are working as expected.
+ * XXX this test needs extending as we fix up nsSmtpUrl.
+ */
+
+var smtpURLs = [
+  {
+    url: "smtp://user@localhost/",
+    spec: "smtp://user@localhost/",
+    username: "user",
+  },
+  {
+    url: "smtps://user@localhost/",
+    spec: "smtps://user@localhost/",
+    username: "user",
+  },
+];
+
+function run_test() {
+  var url;
+  for (var part = 0; part < smtpURLs.length; ++part) {
+    print("url: " + smtpURLs[part].url);
+
+    url = Services.io.newURI(smtpURLs[part].url);
+
+    Assert.equal(url.spec, smtpURLs[part].spec);
+    Assert.equal(url.username, smtpURLs[part].username);
+  }
+}
diff --git a/comm/mailnews/compose/test/unit/test_splitRecipients.js b/comm/mailnews/compose/test/unit/test_splitRecipients.js
new file mode 100644
index 0000000000..b51da1c7a2
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_splitRecipients.js
@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * Test suite for nsMsgCompFields functions.
+ * Currently only tests nsIMsgCompFields::SplitRecipients
+ */
+
+var splitRecipientsTests = [
+  {
+    recipients: "me@foo.invalid",
+    emailAddressOnly: false,
+    count: 1,
+    result: ["me@foo.invalid"],
+  },
+  {
+    recipients: "me@foo.invalid, me2@foo.invalid",
+    emailAddressOnly: false,
+    count: 2,
+    result: ["me@foo.invalid", "me2@foo.invalid"],
+  },
+  {
+    recipients: '"foo bar" <me@foo.invalid>',
+    emailAddressOnly: false,
+    count: 1,
+    result: ["foo bar <me@foo.invalid>"],
+  },
+  {
+    recipients: '"foo bar" <me@foo.invalid>',
+    emailAddressOnly: true,
+    count: 1,
+    result: ["me@foo.invalid"],
+  },
+  {
+    recipients: '"foo bar" <me@foo.invalid>, "bar foo" <me2@foo.invalid>',
+    emailAddressOnly: false,
+    count: 2,
+    result: ["foo bar <me@foo.invalid>", "bar foo <me2@foo.invalid>"],
+  },
+  {
+    recipients: '"foo bar" <me@foo.invalid>, "bar foo" <me2@foo.invalid>',
+    emailAddressOnly: true,
+    count: 2,
+    result: ["me@foo.invalid", "me2@foo.invalid"],
+  },
+  {
+    recipients:
+      "A Group:Ed Jones <c@a.invalid>,joe@where.invalid,John <jdoe@one.invalid>;",
+    emailAddressOnly: false,
+    count: 3,
+    result: [
+      "Ed Jones <c@a.invalid>",
+      "joe@where.invalid",
+      "John <jdoe@one.invalid>",
+    ],
+  },
+  {
+    recipients:
+      "mygroup:;, empty:;, foo@foo.invalid, othergroup:bar@foo.invalid, bar2@foo.invalid;,       y@y.invalid, empty:;",
+    emailAddressOnly: true,
+    count: 4,
+    result: [
+      "foo@foo.invalid",
+      "bar@foo.invalid",
+      "bar2@foo.invalid",
+      "y@y.invalid",
+    ],
+  },
+  {
+    recipients: "Undisclosed recipients:;;;;;;;;;;;;;;;;,,,,,,,,,,,,,,,,",
+    emailAddressOnly: true,
+    count: 0,
+    result: [],
+  },
+  {
+    recipients: "a@xxx.invalid; b@xxx.invalid",
+    emailAddressOnly: true,
+    count: 2,
+    result: ["a@xxx.invalid", "b@xxx.invalid"],
+  },
+  {
+    recipients: "a@xxx.invalid; B <b@xxx.invalid>",
+    emailAddressOnly: false,
+    count: 2,
+    result: ["a@xxx.invalid", "B <b@xxx.invalid>"],
+  },
+  {
+    recipients: '"A " <a@xxx.invalid>; b@xxx.invalid',
+    emailAddressOnly: false,
+    count: 2,
+    result: ["A <a@xxx.invalid>", "b@xxx.invalid"],
+  },
+  {
+    recipients: "A <a@xxx.invalid>; B <b@xxx.invalid>",
+    emailAddressOnly: false,
+    count: 2,
+    result: ["A <a@xxx.invalid>", "B <b@xxx.invalid>"],
+  },
+  {
+    recipients:
+      "A (this: is, a comment;) <a.invalid>; g:   (this: is, <a> comment;) C <c.invalid>, d.invalid;",
+    emailAddressOnly: false,
+    count: 3,
+    result: [
+      "A (this: is, a comment;) <a.invalid>",
+      "(this: is, <a> comment;) C <c.invalid>",
+      "d.invalid <>",
+    ],
+  },
+  {
+    recipients:
+      'Mary Smith <mary@x.invalid>, extra:;, group:jdoe@example.invalid; Who? <one@y.invalid>; <boss@nil.invalid>, "Giant; \\"Big\\" Box" <sysservices@example.invalid>,         ',
+    emailAddressOnly: false,
+    count: 5,
+    result: [
+      "Mary Smith <mary@x.invalid>",
+      "jdoe@example.invalid",
+      "Who? <one@y.invalid>",
+      "boss@nil.invalid",
+      'Giant; "Big" Box <sysservices@example.invalid>',
+    ],
+  },
+  {
+    recipients: "Undisclosed recipients: a@foo.invalid ;;extra:;",
+    emailAddressOnly: true,
+    count: 1,
+    result: ["a@foo.invalid"],
+  },
+  {
+    recipients: "Undisclosed recipients:;;extra:a@foo.invalid;",
+    emailAddressOnly: true,
+    count: 1,
+    result: ["a@foo.invalid"],
+  },
+  {
+    recipients: "",
+    emailAddressOnly: false,
+    count: 0,
+    result: [],
+  },
+];
+
+function run_test() {
+  var fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+
+  // As most of SplitRecipients functionality is in the nsIMsgHeaderParser
+  // functionality, here (at least initially), we're just interested in checking
+  // the basic argument/return combinations.
+
+  for (var part = 0; part < splitRecipientsTests.length; ++part) {
+    print("Test: " + splitRecipientsTests[part].recipients);
+    var result = fields.splitRecipients(
+      splitRecipientsTests[part].recipients,
+      splitRecipientsTests[part].emailAddressOnly
+    );
+
+    Assert.equal(splitRecipientsTests[part].count, result.length);
+
+    for (var item = 0; item < result.length; ++item) {
+      Assert.equal(splitRecipientsTests[part].result[item], result[item]);
+    }
+  }
+}
diff --git a/comm/mailnews/compose/test/unit/test_staleTemporaryFileCleanup.js b/comm/mailnews/compose/test/unit/test_staleTemporaryFileCleanup.js
new file mode 100644
index 0000000000..427c101914
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_staleTemporaryFileCleanup.js
@@ -0,0 +1,57 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * Test that stale temporary files are cleaned up when the msg compose service
+ * is initialized.
+ */
+
+var gExpectedFiles;
+
+function create_temporary_files_for(name) {
+  let file = Services.dirsvc.get("TmpD", Ci.nsIFile);
+  file.append(name);
+  file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o600);
+
+  return file;
+}
+
+function collect_expected_temporary_files() {
+  let files = [];
+
+  files.push(create_temporary_files_for("nsmail.tmp"));
+  files.push(create_temporary_files_for("nsmail.tmp"));
+  files.push(create_temporary_files_for("nsmail.tmp"));
+  files.push(create_temporary_files_for("nsemail.eml"));
+  files.push(create_temporary_files_for("nsemail.tmp"));
+  files.push(create_temporary_files_for("nsqmail.tmp"));
+  files.push(create_temporary_files_for("nscopy.tmp"));
+  files.push(create_temporary_files_for("nscopy.tmp"));
+
+  return files;
+}
+
+function check_files_not_exist(files) {
+  files.forEach(function (file) {
+    Assert.ok(!file.exists());
+  });
+}
+
+function run_test() {
+  gExpectedFiles = collect_expected_temporary_files();
+  registerCleanupFunction(function () {
+    gExpectedFiles.forEach(function (file) {
+      if (file.exists()) {
+        file.remove(false);
+      }
+    });
+  });
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+  MailServices.compose; // Initialise the compose service.
+  do_test_pending();
+  check_files_not_exist(gExpectedFiles);
+  do_test_finished();
+}
diff --git a/comm/mailnews/compose/test/unit/test_telemetry_compose.js b/comm/mailnews/compose/test/unit/test_telemetry_compose.js
new file mode 100644
index 0000000000..f48db07293
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_telemetry_compose.js
@@ -0,0 +1,109 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test telemetry related to message composition.
+ */
+
+ChromeUtils.defineESModuleGetters(this, {
+  TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs",
+});
+
+const HTML_SCALAR = "tb.compose.format_html";
+const PLAIN_TEXT_SCALAR = "tb.compose.format_plain_text";
+
+/**
+ * Check that we're counting HTML or Plain text when composing.
+ */
+add_task(async function test_compose_format() {
+  Services.telemetry.clearScalars();
+
+  // Bare-bones code to initiate composing a message in given format.
+  let createCompose = function (fmt) {
+    let msgCompose = Cc[
+      "@mozilla.org/messengercompose/compose;1"
+    ].createInstance(Ci.nsIMsgCompose);
+
+    let params = Cc[
+      "@mozilla.org/messengercompose/composeparams;1"
+    ].createInstance(Ci.nsIMsgComposeParams);
+
+    params.format = fmt;
+    msgCompose.initialize(params);
+  };
+
+  // Start composing arbitrary numbers of messages in each format.
+  const NUM_HTML = 7;
+  const NUM_PLAIN = 13;
+  for (let i = 0; i < NUM_HTML; i++) {
+    createCompose(Ci.nsIMsgCompFormat.HTML);
+  }
+  for (let i = 0; i < NUM_PLAIN; i++) {
+    createCompose(Ci.nsIMsgCompFormat.PlainText);
+  }
+
+  // Did we count them correctly?
+  const scalars = TelemetryTestUtils.getProcessScalars("parent");
+  Assert.equal(
+    scalars[HTML_SCALAR],
+    NUM_HTML,
+    HTML_SCALAR + " must have the correct value."
+  );
+  Assert.equal(
+    scalars[PLAIN_TEXT_SCALAR],
+    NUM_PLAIN,
+    PLAIN_TEXT_SCALAR + " must have the correct value."
+  );
+});
+
+/**
+ * Check that we're counting compose type (new/reply/fwd etc) when composing.
+ */
+add_task(async function test_compose_type() {
+  // Bare-bones code to initiate composing a message in given type.
+  let createCompose = function (type) {
+    let msgCompose = Cc[
+      "@mozilla.org/messengercompose/compose;1"
+    ].createInstance(Ci.nsIMsgCompose);
+
+    let params = Cc[
+      "@mozilla.org/messengercompose/composeparams;1"
+    ].createInstance(Ci.nsIMsgComposeParams);
+
+    params.type = type;
+    msgCompose.initialize(params);
+  };
+  const histogram = TelemetryTestUtils.getAndClearHistogram("TB_COMPOSE_TYPE");
+
+  // Start composing arbitrary numbers of messages in each format.
+  const NUM_NEW = 4;
+  const NUM_DRAFT = 7;
+  const NUM_EDIT_TEMPLATE = 3;
+  for (let i = 0; i < NUM_NEW; i++) {
+    createCompose(Ci.nsIMsgCompType.New);
+  }
+  for (let i = 0; i < NUM_DRAFT; i++) {
+    createCompose(Ci.nsIMsgCompType.Draft);
+  }
+  for (let i = 0; i < NUM_EDIT_TEMPLATE; i++) {
+    createCompose(Ci.nsIMsgCompType.EditTemplate);
+  }
+
+  // Did we count them correctly?
+  const snapshot = histogram.snapshot();
+  Assert.equal(
+    snapshot.values[Ci.nsIMsgCompType.New],
+    NUM_NEW,
+    "nsIMsgCompType.New count must be correct"
+  );
+  Assert.equal(
+    snapshot.values[Ci.nsIMsgCompType.Draft],
+    NUM_DRAFT,
+    "nsIMsgCompType.Draft count must be correct"
+  );
+  Assert.equal(
+    snapshot.values[Ci.nsIMsgCompType.EditTemplate],
+    NUM_EDIT_TEMPLATE,
+    "nsIMsgCompType.EditTemplate count must be correct"
+  );
+});
diff --git a/comm/mailnews/compose/test/unit/test_temporaryFilesRemoved.js b/comm/mailnews/compose/test/unit/test_temporaryFilesRemoved.js
new file mode 100644
index 0000000000..6a350ac64e
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/test_temporaryFilesRemoved.js
@@ -0,0 +1,123 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * Test that temporary files for draft are surely removed.
+ */
+
+var gMsgCompose;
+var gExpectedFiles;
+
+var progressListener = {
+  onStateChange(aWebProgress, aRequest, aStateFlags, aStatus) {
+    if (aStateFlags & Ci.nsIWebProgressListener.STATE_STOP) {
+      do_timeout(0, checkResult);
+    }
+  },
+
+  onProgressChange(
+    aWebProgress,
+    aRequest,
+    aCurSelfProgress,
+    aMaxSelfProgress,
+    aCurTotalProgress,
+    aMaxTotalProgress
+  ) {},
+  onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {},
+  onStatusChange(aWebProgress, aRequest, aStatus, aMessage) {},
+  onSecurityChange(aWebProgress, aRequest, state) {},
+  onContentBlockingEvent(aWebProgress, aRequest, aEvent) {},
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIWebProgressListener",
+    "nsISupportsWeakReference",
+  ]),
+};
+
+/**
+ * Get the count of temporary files. Because nsIFile.createUnique creates a random
+ * file name, we iterate the tmp dir and count the files that match filename
+ * patterns.
+ */
+async function getTemporaryFilesCount() {
+  let tmpDir = Services.dirsvc.get("TmpD", Ci.nsIFile).path;
+  let entries = await IOUtils.getChildren(tmpDir);
+  let tempFiles = {
+    "nsmail.tmp": 0,
+    "nscopy.tmp": 0,
+    "nsemail.eml": 0,
+    "nsemail.tmp": 0,
+    "nsqmail.tmp": 0,
+  };
+  for (const path of entries) {
+    for (let pattern of Object.keys(tempFiles)) {
+      let [name, extName] = pattern.split(".");
+      if (PathUtils.filename(path).startsWith(name) && path.endsWith(extName)) {
+        tempFiles[pattern]++;
+      }
+    }
+  }
+  return tempFiles;
+}
+
+/**
+ * Temp files should be deleted as soon as the draft is finished saving, so the
+ * counts should be the same as before.
+ */
+async function checkResult() {
+  let filesCount = await getTemporaryFilesCount();
+  for (let [pattern, count] of Object.entries(filesCount)) {
+    Assert.equal(
+      count,
+      gExpectedFiles[pattern],
+      `${pattern} should not exists`
+    );
+  }
+  do_test_finished();
+}
+
+add_task(async function () {
+  gExpectedFiles = await getTemporaryFilesCount();
+
+  // Ensure we have at least one mail account
+  localAccountUtils.loadLocalMailAccount();
+
+  gMsgCompose = Cc["@mozilla.org/messengercompose/compose;1"].createInstance(
+    Ci.nsIMsgCompose
+  );
+  let fields = Cc[
+    "@mozilla.org/messengercompose/composefields;1"
+  ].createInstance(Ci.nsIMsgCompFields);
+  let params = Cc[
+    "@mozilla.org/messengercompose/composeparams;1"
+  ].createInstance(Ci.nsIMsgComposeParams);
+
+  fields.from = "Nobody <nobody@tinderbox.test>";
+  fields.body = "body text";
+  fields.useMultipartAlternative = true;
+
+  params.composeFields = fields;
+  params.format = Ci.nsIMsgCompFormat.HTML;
+
+  gMsgCompose.initialize(params, null, null);
+
+  let identity = getSmtpIdentity(null, getBasicSmtpServer());
+
+  localAccountUtils.rootFolder.createLocalSubfolder("Drafts");
+
+  let progress = Cc["@mozilla.org/messenger/progress;1"].createInstance(
+    Ci.nsIMsgProgress
+  );
+  progress.registerListener(progressListener);
+
+  do_test_pending();
+
+  gMsgCompose.sendMsg(
+    Ci.nsIMsgSend.nsMsgSaveAsDraft,
+    identity,
+    "",
+    null,
+    progress
+  );
+});
diff --git a/comm/mailnews/compose/test/unit/xpcshell.ini b/comm/mailnews/compose/test/unit/xpcshell.ini
new file mode 100644
index 0000000000..687259c42a
--- /dev/null
+++ b/comm/mailnews/compose/test/unit/xpcshell.ini
@@ -0,0 +1,54 @@
+[DEFAULT]
+head = head_compose.js
+tail =
+support-files = data/*
+
+[test_accountKey.js]
+[test_attachment.js]
+[test_attachment_intl.js]
+[test_autoReply.js]
+skip-if = os == 'mac'
+[test_bcc.js]
+[test_bug155172.js]
+[test_bug474774.js]
+[test_createAndSendMessage.js]
+[test_createRFC822Message.js]
+[test_detectAttachmentCharset.js]
+[test_expandMailingLists.js]
+[test_fcc2.js]
+[test_fccReply.js]
+[test_longLines.js]
+[test_mailTelemetry.js]
+[test_mailtoURL.js]
+[test_messageBody.js]
+[test_messageHeaders.js]
+[test_nsIMsgCompFields.js]
+[test_nsMsgCompose1.js]
+[test_nsMsgCompose2.js]
+[test_nsMsgCompose3.js]
+[test_nsSmtpService1.js]
+[test_saveDraft.js]
+[test_sendBackground.js]
+[test_sendMailAddressIDN.js]
+[test_sendMailMessage.js]
+[test_sendMessageFile.js]
+[test_sendMessageLater.js]
+[test_sendMessageLater2.js]
+[test_sendMessageLater3.js]
+[test_sendObserver.js]
+[test_smtp8bitMime.js]
+[test_smtpAuthMethods.js]
+[test_smtpClient.js]
+[test_smtpPassword.js]
+[test_smtpPassword2.js]
+[test_smtpPasswordFailure1.js]
+[test_smtpPasswordFailure2.js]
+[test_smtpPasswordFailure3.js]
+[test_smtpProtocols.js]
+[test_smtpProxy.js]
+[test_smtpServer.js]
+[test_smtpURL.js]
+[test_splitRecipients.js]
+[test_telemetry_compose.js]
+[test_staleTemporaryFileCleanup.js]
+[test_temporaryFilesRemoved.js]