From 302bf1b523012e11b60425d6eee1221ebc2724eb Mon Sep 17 00:00:00 2001
From: "Matt A. Tobin" <email@mattatobin.com>
Date: Sun, 3 Nov 2019 00:17:46 -0400
Subject: Issue #1258 - Part 1: Import mailnews, ldap, and mork from
 comm-esr52.9.1

---
 mailnews/compose/content/askSendFormat.js          |   58 +
 mailnews/compose/content/askSendFormat.xul         |   46 +
 .../compose/content/mailComposeEditorOverlay.xul   |  157 +
 .../compose/content/menulistCompactBindings.xml    |   22 +
 mailnews/compose/content/sendProgress.js           |  171 +
 mailnews/compose/content/sendProgress.xul          |   50 +
 mailnews/compose/moz.build                         |   10 +
 mailnews/compose/public/moz.build                  |   35 +
 mailnews/compose/public/nsIMsgAttachment.idl       |  124 +
 .../compose/public/nsIMsgAttachmentHandler.idl     |   45 +
 mailnews/compose/public/nsIMsgCompFields.idl       |   97 +
 mailnews/compose/public/nsIMsgCompUtils.idl        |   14 +
 mailnews/compose/public/nsIMsgCompose.idl          |  307 +
 mailnews/compose/public/nsIMsgComposeParams.idl    |   81 +
 .../compose/public/nsIMsgComposeProgressParams.idl |   16 +
 mailnews/compose/public/nsIMsgComposeSecure.idl    |   25 +
 mailnews/compose/public/nsIMsgComposeService.idl   |  147 +
 mailnews/compose/public/nsIMsgQuote.idl            |   35 +
 .../public/nsIMsgQuotingOutputStreamListener.idl   |   16 +
 mailnews/compose/public/nsIMsgSend.idl             |  405 ++
 mailnews/compose/public/nsIMsgSendLater.idl        |   66 +
 .../compose/public/nsIMsgSendLaterListener.idl     |   86 +
 mailnews/compose/public/nsIMsgSendListener.idl     |   57 +
 mailnews/compose/public/nsIMsgSendReport.idl       |   47 +
 mailnews/compose/public/nsISmtpServer.idl          |  131 +
 mailnews/compose/public/nsISmtpService.idl         |  134 +
 mailnews/compose/public/nsISmtpUrl.idl             |  110 +
 mailnews/compose/public/nsIURLFetcher.idl          |   38 +
 mailnews/compose/public/nsMsgAttachmentData.h      |  115 +
 mailnews/compose/public/nsMsgCompCID.h             |  247 +
 mailnews/compose/src/moz.build                     |   55 +
 mailnews/compose/src/nsComposeStrings.cpp          |  116 +
 mailnews/compose/src/nsComposeStrings.h            |   77 +
 mailnews/compose/src/nsMsgAppleCodes.h             |  106 +
 mailnews/compose/src/nsMsgAppleDouble.h            |  207 +
 mailnews/compose/src/nsMsgAppleDoubleEncode.cpp    |  266 +
 mailnews/compose/src/nsMsgAppleEncode.cpp          |  703 +++
 mailnews/compose/src/nsMsgAttachment.cpp           |  262 +
 mailnews/compose/src/nsMsgAttachment.h             |   41 +
 mailnews/compose/src/nsMsgAttachmentHandler.cpp    | 1383 +++++
 mailnews/compose/src/nsMsgAttachmentHandler.h      |  194 +
 mailnews/compose/src/nsMsgCompFields.cpp           |  693 +++
 mailnews/compose/src/nsMsgCompFields.h             |  172 +
 mailnews/compose/src/nsMsgCompUtils.cpp            | 1803 ++++++
 mailnews/compose/src/nsMsgCompUtils.h              |  143 +
 mailnews/compose/src/nsMsgCompose.cpp              | 6052 ++++++++++++++++++++
 mailnews/compose/src/nsMsgCompose.h                |  246 +
 .../compose/src/nsMsgComposeContentHandler.cpp     |  125 +
 mailnews/compose/src/nsMsgComposeContentHandler.h  |   20 +
 mailnews/compose/src/nsMsgComposeParams.cpp        |  170 +
 mailnews/compose/src/nsMsgComposeParams.h          |   30 +
 .../compose/src/nsMsgComposeProgressParams.cpp     |   46 +
 mailnews/compose/src/nsMsgComposeProgressParams.h  |   20 +
 mailnews/compose/src/nsMsgComposeService.cpp       | 1479 +++++
 mailnews/compose/src/nsMsgComposeService.h         |   68 +
 mailnews/compose/src/nsMsgCopy.cpp                 |  553 ++
 mailnews/compose/src/nsMsgCopy.h                   |  120 +
 mailnews/compose/src/nsMsgPrompts.cpp              |  115 +
 mailnews/compose/src/nsMsgPrompts.h                |   22 +
 mailnews/compose/src/nsMsgQuote.cpp                |  233 +
 mailnews/compose/src/nsMsgQuote.h                  |   52 +
 mailnews/compose/src/nsMsgSend.cpp                 | 5218 +++++++++++++++++
 mailnews/compose/src/nsMsgSend.h                   |  405 ++
 mailnews/compose/src/nsMsgSendLater.cpp            | 1552 +++++
 mailnews/compose/src/nsMsgSendLater.h              |  144 +
 mailnews/compose/src/nsMsgSendPart.cpp             |  779 +++
 mailnews/compose/src/nsMsgSendPart.h               |  101 +
 mailnews/compose/src/nsMsgSendReport.cpp           |  437 ++
 mailnews/compose/src/nsMsgSendReport.h             |   46 +
 mailnews/compose/src/nsSMTPProtocolHandler.js      |   62 +
 .../compose/src/nsSMTPProtocolHandler.manifest     |    4 +
 mailnews/compose/src/nsSmtpProtocol.cpp            | 2249 ++++++++
 mailnews/compose/src/nsSmtpProtocol.h              |  225 +
 mailnews/compose/src/nsSmtpServer.cpp              |  629 ++
 mailnews/compose/src/nsSmtpServer.h                |   40 +
 mailnews/compose/src/nsSmtpService.cpp             |  772 +++
 mailnews/compose/src/nsSmtpService.h               |   63 +
 mailnews/compose/src/nsSmtpUrl.cpp                 |  778 +++
 mailnews/compose/src/nsSmtpUrl.h                   |  100 +
 mailnews/compose/src/nsURLFetcher.cpp              |  526 ++
 mailnews/compose/src/nsURLFetcher.h                |  101 +
 81 files changed, 32695 insertions(+)
 create mode 100644 mailnews/compose/content/askSendFormat.js
 create mode 100644 mailnews/compose/content/askSendFormat.xul
 create mode 100644 mailnews/compose/content/mailComposeEditorOverlay.xul
 create mode 100644 mailnews/compose/content/menulistCompactBindings.xml
 create mode 100644 mailnews/compose/content/sendProgress.js
 create mode 100644 mailnews/compose/content/sendProgress.xul
 create mode 100644 mailnews/compose/moz.build
 create mode 100644 mailnews/compose/public/moz.build
 create mode 100644 mailnews/compose/public/nsIMsgAttachment.idl
 create mode 100644 mailnews/compose/public/nsIMsgAttachmentHandler.idl
 create mode 100644 mailnews/compose/public/nsIMsgCompFields.idl
 create mode 100644 mailnews/compose/public/nsIMsgCompUtils.idl
 create mode 100644 mailnews/compose/public/nsIMsgCompose.idl
 create mode 100644 mailnews/compose/public/nsIMsgComposeParams.idl
 create mode 100644 mailnews/compose/public/nsIMsgComposeProgressParams.idl
 create mode 100644 mailnews/compose/public/nsIMsgComposeSecure.idl
 create mode 100644 mailnews/compose/public/nsIMsgComposeService.idl
 create mode 100644 mailnews/compose/public/nsIMsgQuote.idl
 create mode 100644 mailnews/compose/public/nsIMsgQuotingOutputStreamListener.idl
 create mode 100644 mailnews/compose/public/nsIMsgSend.idl
 create mode 100644 mailnews/compose/public/nsIMsgSendLater.idl
 create mode 100644 mailnews/compose/public/nsIMsgSendLaterListener.idl
 create mode 100644 mailnews/compose/public/nsIMsgSendListener.idl
 create mode 100644 mailnews/compose/public/nsIMsgSendReport.idl
 create mode 100644 mailnews/compose/public/nsISmtpServer.idl
 create mode 100644 mailnews/compose/public/nsISmtpService.idl
 create mode 100644 mailnews/compose/public/nsISmtpUrl.idl
 create mode 100644 mailnews/compose/public/nsIURLFetcher.idl
 create mode 100644 mailnews/compose/public/nsMsgAttachmentData.h
 create mode 100644 mailnews/compose/public/nsMsgCompCID.h
 create mode 100644 mailnews/compose/src/moz.build
 create mode 100644 mailnews/compose/src/nsComposeStrings.cpp
 create mode 100644 mailnews/compose/src/nsComposeStrings.h
 create mode 100644 mailnews/compose/src/nsMsgAppleCodes.h
 create mode 100644 mailnews/compose/src/nsMsgAppleDouble.h
 create mode 100644 mailnews/compose/src/nsMsgAppleDoubleEncode.cpp
 create mode 100644 mailnews/compose/src/nsMsgAppleEncode.cpp
 create mode 100644 mailnews/compose/src/nsMsgAttachment.cpp
 create mode 100644 mailnews/compose/src/nsMsgAttachment.h
 create mode 100644 mailnews/compose/src/nsMsgAttachmentHandler.cpp
 create mode 100644 mailnews/compose/src/nsMsgAttachmentHandler.h
 create mode 100644 mailnews/compose/src/nsMsgCompFields.cpp
 create mode 100644 mailnews/compose/src/nsMsgCompFields.h
 create mode 100644 mailnews/compose/src/nsMsgCompUtils.cpp
 create mode 100644 mailnews/compose/src/nsMsgCompUtils.h
 create mode 100644 mailnews/compose/src/nsMsgCompose.cpp
 create mode 100644 mailnews/compose/src/nsMsgCompose.h
 create mode 100644 mailnews/compose/src/nsMsgComposeContentHandler.cpp
 create mode 100644 mailnews/compose/src/nsMsgComposeContentHandler.h
 create mode 100644 mailnews/compose/src/nsMsgComposeParams.cpp
 create mode 100644 mailnews/compose/src/nsMsgComposeParams.h
 create mode 100644 mailnews/compose/src/nsMsgComposeProgressParams.cpp
 create mode 100644 mailnews/compose/src/nsMsgComposeProgressParams.h
 create mode 100644 mailnews/compose/src/nsMsgComposeService.cpp
 create mode 100644 mailnews/compose/src/nsMsgComposeService.h
 create mode 100644 mailnews/compose/src/nsMsgCopy.cpp
 create mode 100644 mailnews/compose/src/nsMsgCopy.h
 create mode 100644 mailnews/compose/src/nsMsgPrompts.cpp
 create mode 100644 mailnews/compose/src/nsMsgPrompts.h
 create mode 100644 mailnews/compose/src/nsMsgQuote.cpp
 create mode 100644 mailnews/compose/src/nsMsgQuote.h
 create mode 100644 mailnews/compose/src/nsMsgSend.cpp
 create mode 100644 mailnews/compose/src/nsMsgSend.h
 create mode 100644 mailnews/compose/src/nsMsgSendLater.cpp
 create mode 100644 mailnews/compose/src/nsMsgSendLater.h
 create mode 100644 mailnews/compose/src/nsMsgSendPart.cpp
 create mode 100644 mailnews/compose/src/nsMsgSendPart.h
 create mode 100644 mailnews/compose/src/nsMsgSendReport.cpp
 create mode 100644 mailnews/compose/src/nsMsgSendReport.h
 create mode 100644 mailnews/compose/src/nsSMTPProtocolHandler.js
 create mode 100644 mailnews/compose/src/nsSMTPProtocolHandler.manifest
 create mode 100644 mailnews/compose/src/nsSmtpProtocol.cpp
 create mode 100644 mailnews/compose/src/nsSmtpProtocol.h
 create mode 100644 mailnews/compose/src/nsSmtpServer.cpp
 create mode 100644 mailnews/compose/src/nsSmtpServer.h
 create mode 100644 mailnews/compose/src/nsSmtpService.cpp
 create mode 100644 mailnews/compose/src/nsSmtpService.h
 create mode 100644 mailnews/compose/src/nsSmtpUrl.cpp
 create mode 100644 mailnews/compose/src/nsSmtpUrl.h
 create mode 100644 mailnews/compose/src/nsURLFetcher.cpp
 create mode 100644 mailnews/compose/src/nsURLFetcher.h

(limited to 'mailnews/compose')

diff --git a/mailnews/compose/content/askSendFormat.js b/mailnews/compose/content/askSendFormat.js
new file mode 100644
index 000000000..17f4bafe4
--- /dev/null
+++ b/mailnews/compose/content/askSendFormat.js
@@ -0,0 +1,58 @@
+/* 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 gParam = null;
+
+/**
+ * This dialog should be opened with arguments like e.g.
+ * {action: nsIMsgCompSendFormat.AskUser, convertible: nsIMsgCompConvertible.Yes}
+ */
+function Startup()
+{
+  gParam = window.arguments[0];
+
+  const msgCompSendFormat = Components.interfaces.nsIMsgCompSendFormat;
+  const msgCompConvertible = Components.interfaces.nsIMsgCompConvertible;
+
+  var bundle = document.getElementById("askSendFormatStringBundle");
+
+  // If the user hits the close box, we will abort.
+  gParam.abort = true;
+
+  // Set the question label
+  var mailSendFormatExplanation = document.getElementById("mailSendFormatExplanation");
+  var icon = document.getElementById("convertDefault");
+
+  switch (gParam.convertible)
+  {
+    case msgCompConvertible.Altering:
+      mailSendFormatExplanation.textContent = bundle.getString("convertibleAltering");
+      icon.className = "question-icon";
+      break;
+    case msgCompConvertible.No:
+      mailSendFormatExplanation.textContent = bundle.getString("convertibleNo");
+      icon.className = "alert-icon";
+      break;
+    default: // msgCompConvertible.Yes
+      mailSendFormatExplanation.textContent = bundle.getString("convertibleYes");
+      // XXX change this to use class message-icon once bug 512173 is fixed
+      icon.className = "question-icon";
+      break;
+  }
+
+  // Set the default radio array value and recommendation.
+  var group = document.getElementById("mailDefaultHTMLAction");
+  if (gParam.action != msgCompSendFormat.AskUser)
+  {
+    group.value = gParam.action;
+    group.selectedItem.label += " " + bundle.getString("recommended");
+  }
+}
+
+function Send()
+{
+  // gParam.action should be an integer for when it is returned to MsgComposeCommands.js
+  gParam.action = parseInt(document.getElementById("mailDefaultHTMLAction").value);
+  gParam.abort = false;
+}
diff --git a/mailnews/compose/content/askSendFormat.xul b/mailnews/compose/content/askSendFormat.xul
new file mode 100644
index 000000000..751378bd8
--- /dev/null
+++ b/mailnews/compose/content/askSendFormat.xul
@@ -0,0 +1,46 @@
+<?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://global/skin/global.css" type="text/css"?>
+
+<!DOCTYPE dialog SYSTEM "chrome://messenger/locale/messengercompose/askSendFormat.dtd">
+
+<dialog id="askSendFormat"
+        title="&windowTitle.label;"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        buttonpack="center"
+        onload="Startup();"
+        ondialogaccept="Send();"
+        buttonlabelaccept="&send.label;"
+        buttonaccesskeyaccept="&send.accesskey;"
+        style="width: 75ch;">
+
+  <script type="application/javascript"
+          src="chrome://messenger/content/messengercompose/askSendFormat.js"/>
+
+  <stringbundle id="askSendFormatStringBundle"
+                src="chrome://messenger/locale/messengercompose/askSendFormat.properties"/>
+
+    <separator class="thin"/>
+    <hbox>
+      <separator orient="vertical"/>
+      <vbox id="askImageBox">
+        <image id="convertDefault"/>
+      </vbox>
+      <separator orient="vertical"/>
+      <vbox flex="1">
+        <description>&recipient.label;</description>
+        <description id="mailSendFormatExplanation"/>
+        <description>&question.label;</description>
+        <separator/>
+        <radiogroup id="mailDefaultHTMLAction">
+          <radio value="3" label="&plainTextAndHtml.label;" accesskey="&plainTextAndHtml.accesskey;"/>
+          <radio value="1" selected="true"
+                 label="&plainTextOnly.label;" accesskey="&plainTextOnly.accesskey;"/>
+          <radio value="2" label="&htmlOnly.label;" accesskey="&htmlOnly.accesskey;"/>
+        </radiogroup>
+      </vbox>
+    </hbox>
+</dialog>
diff --git a/mailnews/compose/content/mailComposeEditorOverlay.xul b/mailnews/compose/content/mailComposeEditorOverlay.xul
new file mode 100644
index 000000000..4304935e1
--- /dev/null
+++ b/mailnews/compose/content/mailComposeEditorOverlay.xul
@@ -0,0 +1,157 @@
+<?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/. -->
+
+<!DOCTYPE window SYSTEM "chrome://messenger/locale/messengercompose/mailComposeEditorOverlay.dtd" >
+
+<overlay id="mailComposeEditorOverlay"
+         xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+
+  <script type="application/javascript">
+  <![CDATA[
+    Components.utils.import("resource://gre/modules/Services.jsm");
+
+    var gMsgCompProcessLink = false;
+    var gMsgCompInputElement = null;
+    var gMsgCompPrevInputValue = null;
+    var gMsgCompPrevMozDoNotSendAttribute;
+    var gMsgCompAttachSourceElement = null;
+
+    function OnLoadOverlay()
+    {
+      gMsgCompAttachSourceElement = document.getElementById("AttachSourceToMail");
+      var editor = GetCurrentEditor();
+      if (gMsgCompAttachSourceElement && editor &&
+          (editor.flags & Components.interfaces.nsIPlaintextEditor.eEditorMailMask))
+      {
+        SetRelativeCheckbox = function() { SetAttachCheckbox();};
+        //initialize the AttachSourceToMail checkbox
+        gMsgCompAttachSourceElement.hidden = false;
+
+        switch (document.documentElement.id)
+        {
+          case "imageDlg":
+            gMsgCompInputElement = gDialog.srcInput;
+            gMsgCompProcessLink = false;
+            break;
+          case "linkDlg" :
+            gMsgCompInputElement =  gDialog.hrefInput;
+            gMsgCompProcessLink = true;
+            break;
+        }
+        if (gMsgCompInputElement)
+        {
+          SetAttachCheckbox();
+          gMsgCompPrevMozDoNotSendAttribute = globalElement.getAttribute("moz-do-not-send")
+        }
+      }
+    }
+    addEventListener("load", OnLoadOverlay, false);
+
+    function OnAcceptOverlay()
+    {
+      // Auto-convert file URLs to data URLs. If we're in the link properties
+      // dialog convert only when requested - for the image dialog do it always.
+      if (/^file:/i.test(gMsgCompInputElement.value.trim()) &&
+          (gMsgCompAttachSourceElement.checked || !gMsgCompProcessLink)) {
+        var dataURI = GenerateDataURL(gMsgCompInputElement.value.trim());
+        gMsgCompInputElement.value = dataURI;
+        gMsgCompAttachSourceElement.checked = true;
+      }
+      DoAttachSourceCheckbox();
+    }
+    addEventListener("dialogaccept", OnAcceptOverlay, false);
+
+    function SetAttachCheckbox()
+    {
+      var resetCheckbox = false;
+      var mozDoNotSend = globalElement.getAttribute("moz-do-not-send");
+
+      //In case somebody played with the advanced property and changed the moz-do-not-send attribute
+      if (mozDoNotSend != gMsgCompPrevMozDoNotSendAttribute)
+      {
+        gMsgCompPrevMozDoNotSendAttribute = mozDoNotSend;
+        resetCheckbox = true;
+      }
+
+      // Has the URL changed
+      if (gMsgCompInputElement && gMsgCompInputElement.value != gMsgCompPrevInputValue)
+      {
+        gMsgCompPrevInputValue = gMsgCompInputElement.value;
+        resetCheckbox = true;
+      }
+
+      if (gMsgCompInputElement && resetCheckbox)
+      {
+        // Here is the rule about how to set the checkbox Attach Source To Message:
+        // If the attribute "moz-do-not-send" has not been set, we look at the scheme of the URL
+        // and at some preference to decide what is the best for the user.
+        // If it is set to "false", the checkbox is checked, otherwise unchecked.
+        var attach = false;
+        if (mozDoNotSend == null)
+        {
+          // We haven't yet set the "moz-do-not-send" attribute.
+          var inputValue = gMsgCompInputElement.value.trim();
+          if (/^(file|data):/i.test(inputValue)) {
+            // For files or data URLs, default to attach them.
+            attach = true;
+          } else if (!gMsgCompProcessLink && // Implies image dialogue.
+                     /^https?:/i.test(inputValue)) {
+            // For images loaded via http(s) we default to the preference value.
+            attach = Services.prefs.getBoolPref("mail.compose.attach_http_images");
+          }
+        }
+        else
+        {
+          attach = (mozDoNotSend == "false");
+        }
+
+        gMsgCompAttachSourceElement.checked = attach;
+      }
+    }
+
+    function DoAttachSourceCheckbox()
+    {
+      gMsgCompPrevMozDoNotSendAttribute = (!gMsgCompAttachSourceElement.checked).toString();
+      globalElement.setAttribute("moz-do-not-send", gMsgCompPrevMozDoNotSendAttribute);
+    }
+
+    function GenerateDataURL(url) {
+      var file = Services.io.newURI(url, null, null)
+        .QueryInterface(Components.interfaces.nsIFileURL).file;
+      var contentType = Components.classes["@mozilla.org/mime;1"]
+        .getService(Components.interfaces.nsIMIMEService)
+        .getTypeFromFile(file);
+      var inputStream = Components.classes["@mozilla.org/network/file-input-stream;1"]
+        .createInstance(Components.interfaces.nsIFileInputStream);
+      inputStream.init(file, 0x01, 0o600, 0);
+      var stream = Components.classes["@mozilla.org/binaryinputstream;1"]
+        .createInstance(Components.interfaces.nsIBinaryInputStream);
+      stream.setInputStream(inputStream);
+      let data = "";
+      while (stream.available() > 0) {
+        data += stream.readBytes(stream.available());
+      }
+      let encoded = btoa(data);
+      stream.close();
+      return "data:" + contentType +
+        ";filename=" + encodeURIComponent(file.leafName) +
+        ";base64," + encoded;
+    }
+  ]]>
+  </script>
+
+  <hbox id="MakeRelativeHbox">
+    <checkbox id="AttachSourceToMail" hidden="true"
+              label="&attachImageSource.label;" accesskey="&attachImageSource.accesskey;"
+              insertafter="MakeRelativeCheckbox" oncommand="DoAttachSourceCheckbox()"/>
+  </hbox>
+
+  <groupbox id="LinkURLBox">
+    <checkbox id="AttachSourceToMail" hidden="true"
+              label="&attachLinkSource.label;" accesskey="&attachLinkSource.accesskey;"
+              insertafter="LinkLocationBox" oncommand="DoAttachSourceCheckbox()"/>
+  </groupbox>
+
+</overlay>
diff --git a/mailnews/compose/content/menulistCompactBindings.xml b/mailnews/compose/content/menulistCompactBindings.xml
new file mode 100644
index 000000000..5ca277347
--- /dev/null
+++ b/mailnews/compose/content/menulistCompactBindings.xml
@@ -0,0 +1,22 @@
+<?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/. -->
+
+<bindings id="menulistCompactBindings"
+   xmlns="http://www.mozilla.org/xbl"
+   xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+   xmlns:xbl="http://www.mozilla.org/xbl">
+
+  <binding id="menulist-compact" display="xul:menu"
+           extends="chrome://global/content/bindings/menulist.xml#menulist">
+    <content sizetopopup="false">
+      <xul:hbox class="menulist-label-box" flex="1">
+        <xul:image class="menulist-icon" xbl:inherits="src"/>
+        <xul:label class="menulist-label" xbl:inherits="value=label,crop,accesskey" crop="right" flex="1"/>
+      </xul:hbox>
+      <children includes="menupopup"/>
+    </content>
+  </binding>
+
+</bindings>
diff --git a/mailnews/compose/content/sendProgress.js b/mailnews/compose/content/sendProgress.js
new file mode 100644
index 000000000..8354cf953
--- /dev/null
+++ b/mailnews/compose/content/sendProgress.js
@@ -0,0 +1,171 @@
+/* -*- 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/. */
+
+var nsIMsgCompDeliverMode = Components.interfaces.nsIMsgCompDeliverMode;
+
+// 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 gSendProgressStringBundle;
+
+// all progress notifications are done through the nsIWebProgressListener implementation...
+var progressListener = {
+    onStateChange: function(aWebProgress, aRequest, aStateFlags, aStatus)
+    {
+      if (aStateFlags & Components.interfaces.nsIWebProgressListener.STATE_START)
+      {
+        // Put progress meter in undetermined mode.
+        dialog.progress.setAttribute("mode", "undetermined");
+      }
+
+      if (aStateFlags & Components.interfaces.nsIWebProgressListener.STATE_STOP)
+      {
+        // we are done sending/saving the message...
+        // Indicate completion in status area.
+        var msg;
+        if (itsASaveOperation)
+          msg = gSendProgressStringBundle.getString("messageSaved");
+        else
+          msg = gSendProgressStringBundle.getString("messageSent");
+        dialog.status.setAttribute("value", msg);
+
+        // Put progress meter at 100%.
+        dialog.progress.setAttribute("value", 100);
+        dialog.progress.setAttribute("mode", "normal");
+        var percentMsg = gSendProgressStringBundle.getFormattedString("percentMsg", [100]);
+        dialog.progressText.setAttribute("value", percentMsg);
+
+        window.close();
+      }
+    },
+
+    onProgressChange: function(aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress)
+    {
+      // Calculate percentage.
+      var percent;
+      if (aMaxTotalProgress > 0)
+      {
+        percent = Math.round(aCurTotalProgress / aMaxTotalProgress * 100);
+        if (percent > 100)
+          percent = 100;
+
+        dialog.progress.removeAttribute("mode");
+
+        // Advance progress meter.
+        dialog.progress.setAttribute("value", percent);
+
+        // Update percentage label on progress meter.
+        var percentMsg = gSendProgressStringBundle.getFormattedString("percentMsg", [percent]);
+        dialog.progressText.setAttribute("value", percentMsg);
+      }
+      else
+      {
+        // Progress meter should be barber-pole in this case.
+        dialog.progress.setAttribute("mode", "undetermined");
+        // Update percentage label on progress meter.
+        dialog.progressText.setAttribute("value", "");
+      }
+    },
+
+    onLocationChange: function(aWebProgress, aRequest, aLocation, aFlags)
+    {
+      // we can ignore this notification
+    },
+
+    onStatusChange: function(aWebProgress, aRequest, aStatus, aMessage)
+    {
+      if (aMessage != "")
+        dialog.status.setAttribute("value", aMessage);
+    },
+
+    onSecurityChange: function(aWebProgress, aRequest, state)
+    {
+      // we can ignore this notification
+    },
+
+    QueryInterface : function(iid)
+    {
+      if (iid.equals(Components.interfaces.nsIWebProgressListener) ||
+          iid.equals(Components.interfaces.nsISupportsWeakReference) ||
+          iid.equals(Components.interfaces.nsISupports))
+        return this;
+
+      throw Components.results.NS_NOINTERFACE;
+    }
+};
+
+function onLoad()
+{
+    // Set global variables.
+    let subject = "";
+    gSendProgressStringBundle = document.getElementById("sendProgressStringBundle");
+
+    msgProgress = window.arguments[0];
+    if (!msgProgress)
+    {
+      Components.utils.reportError("Invalid argument to sendProgress.xul.");
+      window.close();
+      return;
+    }
+
+    if (window.arguments[1])
+    {
+      let progressParams = window.arguments[1].QueryInterface(Components.interfaces.nsIMsgComposeProgressParams);
+      if (progressParams)
+      {
+        itsASaveOperation = (progressParams.deliveryMode != nsIMsgCompDeliverMode.Now);
+        subject = progressParams.subject;
+      }
+    }
+
+    if (subject) {
+      let title = itsASaveOperation ? "titleSaveMsgSubject" : "titleSendMsgSubject";
+      document.title = gSendProgressStringBundle.getFormattedString(title, [subject]);
+    } else {
+      let title = itsASaveOperation ? "titleSaveMsg" : "titleSendMsg";
+      document.title = gSendProgressStringBundle.getString(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()
+{
+  // Cancel app launcher.
+  try
+  {
+    msgProgress.processCanceledByUser = true;
+  } catch (e)
+  {
+    return true;
+  }
+
+  // don't Close up dialog by returning false, the backend will close the dialog when everything will be aborted.
+  return false;
+}
diff --git a/mailnews/compose/content/sendProgress.xul b/mailnews/compose/content/sendProgress.xul
new file mode 100644
index 000000000..45508387f
--- /dev/null
+++ b/mailnews/compose/content/sendProgress.xul
@@ -0,0 +1,50 @@
+<?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/dialogs.css" type="text/css"?>
+
+<!DOCTYPE dialog SYSTEM "chrome://messenger/locale/messengercompose/sendProgress.dtd">
+
+<dialog id="sendProgress"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        title="&sendDialog.title;"
+        style="width: 56ch;"
+        onload="onLoad();"
+        onunload="onUnload();"
+        buttons="cancel"
+        ondialogcancel="return onCancel();">
+
+  <script type="application/javascript"
+          src="chrome://messenger/content/messengercompose/sendProgress.js"/>
+  <stringbundle id="sendProgressStringBundle"
+                src="chrome://messenger/locale/messengercompose/sendProgress.properties"/>
+
+    <grid flex="1">
+      <columns>
+        <column/>
+        <column flex="1"/>
+      </columns>
+
+      <rows>
+        <row>
+          <hbox pack="end">
+            <label value="&status.label;"/>
+          </hbox>
+          <label id="dialog.status" crop="center"/>
+        </row>
+        <row class="thin-separator">
+          <hbox pack="end">
+            <label value="&progress.label;"/>
+          </hbox>
+          <progressmeter id="dialog.progress" mode="normal" value="0"/>
+          <hbox pack="end">
+            <label id="dialog.progressText"/>
+          </hbox>
+        </row>
+      </rows>
+    </grid>
+
+</dialog>
diff --git a/mailnews/compose/moz.build b/mailnews/compose/moz.build
new file mode 100644
index 000000000..023ca2fba
--- /dev/null
+++ b/mailnews/compose/moz.build
@@ -0,0 +1,10 @@
+# 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',
+]
+
diff --git a/mailnews/compose/public/moz.build b/mailnews/compose/public/moz.build
new file mode 100644
index 000000000..038ebfd60
--- /dev/null
+++ b/mailnews/compose/public/moz.build
@@ -0,0 +1,35 @@
+# 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',
+    'nsIMsgAttachmentHandler.idl',
+    'nsIMsgCompFields.idl',
+    'nsIMsgCompose.idl',
+    'nsIMsgComposeParams.idl',
+    'nsIMsgComposeProgressParams.idl',
+    'nsIMsgComposeSecure.idl',
+    'nsIMsgComposeService.idl',
+    'nsIMsgCompUtils.idl',
+    'nsIMsgQuote.idl',
+    'nsIMsgQuotingOutputStreamListener.idl',
+    'nsIMsgSend.idl',
+    'nsIMsgSendLater.idl',
+    'nsIMsgSendLaterListener.idl',
+    'nsIMsgSendListener.idl',
+    'nsIMsgSendReport.idl',
+    'nsISmtpServer.idl',
+    'nsISmtpService.idl',
+    'nsISmtpUrl.idl',
+    'nsIURLFetcher.idl',
+]
+
+XPIDL_MODULE = 'msgcompose'
+
+EXPORTS += [
+    'nsMsgAttachmentData.h',
+    'nsMsgCompCID.h',
+]
+
diff --git a/mailnews/compose/public/nsIMsgAttachment.idl b/mailnews/compose/public/nsIMsgAttachment.idl
new file mode 100644
index 000000000..9a9c74859
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgAttachment.idl
@@ -0,0 +1,124 @@
+/* -*- 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 (localy or remotely)
+   */
+  attribute AUTF8String  url;
+
+  /**
+   * 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 cloudProviderKey;
+
+  /**
+   * 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 AString 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.
+   */
+  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 ommitted, 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;
+  
+  /**
+   * 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/mailnews/compose/public/nsIMsgAttachmentHandler.idl b/mailnews/compose/public/nsIMsgAttachmentHandler.idl
new file mode 100644
index 000000000..ac7c4f825
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgAttachmentHandler.idl
@@ -0,0 +1,45 @@
+/* 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;
+
+// This interface provides minimal XPCONNECT access to objects of type
+// nsMsgAttachmentHandler. This is primarily for use with new account
+// types and JsAccount, so this is probably not the interface that you
+// want if you are working with standard account types.
+
+[scriptable, uuid(1731283c-60fe-4102-a804-622a84cc1a08)]
+interface nsIMsgAttachmentHandler : nsISupports
+{
+  /// The real type, once we know it.
+  readonly attribute ACString type;
+
+  /// URI with link to the attachment.
+  readonly attribute ACString uri;
+
+  /// The temp file to which we save it.
+  readonly attribute nsIFile tmpFile;
+
+  /// The name for the headers, if different from the URL.
+  readonly attribute AUTF8String name;
+
+  /// Size of the attachment, in bytes.
+  readonly attribute unsigned long size;
+
+  /// This is for multipart/related Content-ID's.
+  readonly attribute ACString contentId;
+
+  /// True if this should be sent as a link to a file.
+  readonly attribute boolean sendViaCloud;
+
+  /// Name of the character set for the attachment.
+  readonly attribute ACString charset;
+
+  /// The encoding, once we've decided.
+  readonly attribute ACString encoding;
+
+  /// Whether the attachment has been encoded, for example to base64.
+  readonly attribute boolean alreadyEncoded;
+};
diff --git a/mailnews/compose/public/nsIMsgCompFields.idl b/mailnews/compose/public/nsIMsgCompFields.idl
new file mode 100644
index 000000000..5562457d9
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgCompFields.idl
@@ -0,0 +1,97 @@
+/* -*- 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 nsISimpleEnumerator;
+
+/**
+ * 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 string  characterSet;
+  readonly attribute string defaultCharacterSet;
+
+  attribute AString templateName;
+  attribute string  draftId;
+
+  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 nsISimpleEnumerator attachments;
+  void addAttachment(in nsIMsgAttachment attachment);
+  void removeAttachment(in nsIMsgAttachment attachment);
+  void removeAttachments();
+
+  /**
+   * 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.
+   * @param aLength           The length of the aResult array.
+   * @param aResult           An array of the recipients.
+   */
+  void splitRecipients(in AString aRecipients, in boolean aEmailAddressOnly,
+                       out unsigned long aLength,
+                       [array, size_is(aLength), retval] out wstring aResult);
+
+  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;
+
+  attribute nsISupports securityInfo;
+};
+
diff --git a/mailnews/compose/public/nsIMsgCompUtils.idl b/mailnews/compose/public/nsIMsgCompUtils.idl
new file mode 100644
index 000000000..6d37a8474
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgCompUtils.idl
@@ -0,0 +1,14 @@
+/* -*- 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);
+  string msgGenerateMessageId(in nsIMsgIdentity identity);
+  readonly attribute boolean msgMimeConformToStandard;
+};
diff --git a/mailnews/compose/public/nsIMsgCompose.idl b/mailnews/compose/public/nsIMsgCompose.idl
new file mode 100644
index 000000000..cc98d2460
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgCompose.idl
@@ -0,0 +1,307 @@
+/* -*- 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 "nsStringGlue.h"
+%}
+
+interface nsIMsgSend;
+interface nsIMsgIdentity;
+interface nsIMsgProgress;
+interface nsIDocShell;
+interface mozIDOMWindowProxy;
+interface nsIEditor;
+interface nsIMsgWindow;
+
+typedef long MSG_ComposeSaveType;
+
+[scriptable, uuid(6953e50a-7531-11d3-85fe-006008948010)]
+interface nsIMsgCompSaveType {
+    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 {
+    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 {
+    const long AskUser = 4;     /* Hack: Bug 44512. If this is 0 and passed
+                                   as results.action to the askSendFormat
+                                   dialog, the args object gets destroyed.*/
+    const long PlainText = 1;
+    const long HTML = 2;
+    const long Both = 3;
+};
+
+[scriptable, uuid(9638af92-1dd1-11b2-bef1-ca5fee0abc62)]
+interface nsIMsgCompConvertible/*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
+{
+    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 SetDocumentCharset(in string charset);
+  
+  /* ... */
+  void RegisterStateListener(in nsIMsgComposeStateListener stateListener);
+
+  /* ... */
+  void UnregisterStateListener(in nsIMsgComposeStateListener stateListener);
+
+  /* ... */
+  void 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.
+   */
+  void sendMsgToServer(in MSG_DeliverMode deliverMode,
+                       in nsIMsgIdentity identity,
+                       in string accountKey);
+
+  /* ... */
+  void CloseWindow();
+
+  /* ... */
+  void abort();
+    
+  /* ... */
+  void quoteMessage(in string 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();
+
+  /**
+   * Returns how we should send this message in terms of HTML, plaintext, or
+   * both. Note that this method should not be called until after mailing lists
+   * have been expanded if correct results are desired.
+   *
+   * @param aConvertible The convertability of the body (from
+   *                     nsIMsgCompConvertible).
+   * @return             The HTML action to use (from nsIMsgCompSendFormat).
+   */
+  long determineHTMLAction(in long aConvertible);
+
+  /**
+   * The level of "convertibility" of the message body (whole HTML document)
+   * to plaintext.
+   *
+   * @return a value from nsIMsgCompConvertible.
+   */
+  long bodyConvertible();
+
+  /**
+   * 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 mofified
+     by the user. When you set this value to false, you reset the modification count
+     of the body to 0 (clean).
+  */
+  attribute boolean bodyModified;
+
+  /* The body string is stored as a byte string in comp fields, but is converted to
+   * UTF16 when fetched by GetBody(). Fetch the body without conversion.
+   */
+  readonly attribute ACString bodyRaw;
+
+  /**
+   *  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 string 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);
+
+  /* Retreive the progress object */
+  readonly attribute nsIMsgProgress progress;
+  
+	/* ... */
+  [noscript] void buildBodyMessageAndSignature();
+  
+	/* ... */
+  [noscript] void buildQuotedMessageAndSignature();
+
+ 	/* ... */
+  [noscript] void getQuotingToFollow(out boolean quotingToFollow);
+
+  readonly attribute string originalMsgURI;
+
+  attribute boolean deleteDraft;
+
+  /* true when the compose window is in the process of inserting quoted content
+     (i.e. via reply, forward inline or a quoting operation) into the document 
+   */
+  attribute boolean insertingQuotedContent;
+
+  /* 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/mailnews/compose/public/nsIMsgComposeParams.idl b/mailnews/compose/public/nsIMsgComposeParams.idl
new file mode 100644
index 000000000..87c15eac3
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgComposeParams.idl
@@ -0,0 +1,81 @@
+/* -*- 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 {
+    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;
+    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;
+
+    /**
+     * Add this value to a reply type to suppress quoting the current selection
+     * which may not belong to the message being replied to.
+     */
+    const long ReplyIgnoreQuote         = 100;
+};
+
+
+typedef long MSG_ComposeFormat;
+
+[scriptable, uuid(a28325e8-7531-11d3-8f1c-006008948010)]
+interface nsIMsgCompFormat {
+    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 string                originalMsgURI;
+  attribute nsIMsgIdentity        identity;
+
+  attribute nsIMsgCompFields      composeFields;
+  attribute boolean               bodyIsLink;
+
+  attribute nsIMsgSendListener	  sendListener;
+  attribute string                smtpPassword;
+  attribute nsIMsgDBHdr           origMsgHdr;
+
+  /**
+   * 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/mailnews/compose/public/nsIMsgComposeProgressParams.idl b/mailnews/compose/public/nsIMsgComposeProgressParams.idl
new file mode 100644
index 000000000..f3bb301bd
--- /dev/null
+++ b/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/mailnews/compose/public/nsIMsgComposeSecure.idl b/mailnews/compose/public/nsIMsgComposeSecure.idl
new file mode 100644
index 000000000..20981bea4
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgComposeSecure.idl
@@ -0,0 +1,25 @@
+/* -*- 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;
+
+/* Security interface */
+[scriptable, uuid(245f2adc-410e-4bdb-91e2-a7bb42d61787)]
+interface nsIMsgComposeSecure : nsISupports 
+{
+    // requiresCryptoEncapsulation --> returns true if the current message send requires us to go through
+	// some encryption work. In the case of false, you can disregard the compose secure object.
+    boolean requiresCryptoEncapsulation(in nsIMsgIdentity aIdentity, in nsIMsgCompFields aCompFields);
+
+    void beginCryptoEncapsulation(in nsIOutputStream aStream, in string aRecipients, in nsIMsgCompFields aCompFields, in nsIMsgIdentity aIdentity, in nsIMsgSendReport sendReport, in boolean aIsDraft);
+    void finishCryptoEncapsulation(in boolean aAbort, in nsIMsgSendReport sendReport);
+    void mimeCryptoWriteBlock(in string aBuf, in long aLen);
+};
diff --git a/mailnews/compose/public/nsIMsgComposeService.idl b/mailnews/compose/public/nsIMsgComposeService.idl
new file mode 100644
index 000000000..ce8cf4a1b
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgComposeService.idl
@@ -0,0 +1,147 @@
+/* -*- 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;
+
+[scriptable, uuid(041782bf-e523-444b-a268-d90868fd2b50)]
+interface nsIMsgComposeService : nsISupports {
+
+  /* we need a msg window because when we forward inline we may need progress */
+  void OpenComposeWindow(in string msgComposeWindowURL,
+                         in nsIMsgDBHdr msgHdr,
+                         in string originalMsgURI,
+                         in MSG_ComposeType type, 
+                         in MSG_ComposeFormat format,
+                         in nsIMsgIdentity identity, 
+                         in nsIMsgWindow aMsgWindow);
+
+  /**
+   * 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 initalizes 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 string 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/mailnews/compose/public/nsIMsgQuote.idl b/mailnews/compose/public/nsIMsgQuote.idl
new file mode 100644
index 000000000..9ec330d8e
--- /dev/null
+++ b/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 string msgURI, in boolean quoteHeaders,
+                    in nsIMsgQuotingOutputStreamListener streamListener,
+                    in string charset, 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/mailnews/compose/public/nsIMsgQuotingOutputStreamListener.idl b/mailnews/compose/public/nsIMsgQuotingOutputStreamListener.idl
new file mode 100644
index 000000000..ac86361ab
--- /dev/null
+++ b/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/mailnews/compose/public/nsIMsgSend.idl b/mailnews/compose/public/nsIMsgSend.idl
new file mode 100644
index 000000000..d1bda4abf
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgSend.idl
@@ -0,0 +1,405 @@
+/* -*- 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 nsIArray;
+interface nsIMsgAttachmentHandler;
+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;
+};
+
+%{ C++
+// Forward declaration
+class nsMsgAttachmentHandler;
+#include "nsAutoPtr.h"
+#include "nsTArray.h"
+%}
+
+[ptr] native nsMsgAttachedFile(nsMsgAttachedFile);
+[ptr] native nsMsgAttachmentHandlerArray(nsTArray<RefPtr<nsMsgAttachmentHandler>>);
+
+[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 aAttachments Array of nsIMsgAttachmentData
+   * @param aPreloadedAttachments Array of nsIMsgAttachedFile
+   * @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
+   */
+    void 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 ACString aBody,
+                              in nsIArray aAttachments,
+                              in nsIArray aPreloadedAttachments,
+                              in mozIDOMWindowProxy aParentWindow,
+                              in nsIMsgProgress aProgress,
+                              in nsIMsgSendListener aListener,
+                              in string 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 nsIMsgAttachmentData
+   * @param aEmbeddedObjects Array of nsIDomNode objects for MHTML messages.
+   *                         Primarily used for embedded images.
+   *                         Almost all methods can be noops, but
+   *                         GetNodeValue should return the
+   *                         cid of the embedded object.
+   * @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 nsIArray aAttachments,
+                           in nsIArray 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_p        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.
+   */
+  void sendMessageFile(in nsIMsgIdentity       aUserIdentity,
+                       in string               aAccountKey,
+                       in nsIMsgCompFields     aFields,
+                       in nsIFile              aSendIFile,
+                       in boolean              aDeleteSendFileOnCompletion,
+                       in boolean              aDigest_p,
+                       in nsMsgDeliverMode     aMode,
+                       in nsIMsgDBHdr          aMsgToReplace,
+                       in nsIMsgSendListener   aListener,
+                       in nsIMsgStatusFeedback aStatusFeedback,
+                       in string               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();
+
+    /* retreive 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 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 ACString 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;
+
+    nsIPrompt getDefaultPrompt();
+
+    /* process attachment */
+    void gatherMimeAttachments();
+    readonly attribute boolean processAttachmentsSynchronously;
+    [noscript] nsMsgAttachmentHandlerArray getAttachmentHandlers();
+    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;
+
+    /**
+     * Get a handler for an attachment by its index.
+     * The lifetime of the attachment is dependent on the existence
+     * of the underlying send object, so do not hold onto these
+     * attachment handlers.
+     *
+     * @param index  Index used to specify a particular attachment.
+     *
+     * @return       Attachment handler with information about the attachment.
+     */
+    nsIMsgAttachmentHandler getAttachment(in unsigned long index);
+
+    /// 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/mailnews/compose/public/nsIMsgSendLater.idl b/mailnews/compose/public/nsIMsgSendLater.idl
new file mode 100644
index 000000000..524bb867f
--- /dev/null
+++ b/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/mailnews/compose/public/nsIMsgSendLaterListener.idl b/mailnews/compose/public/nsIMsgSendLaterListener.idl
new file mode 100644
index 000000000..6e6e29a79
--- /dev/null
+++ b/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/mailnews/compose/public/nsIMsgSendListener.idl b/mailnews/compose/public/nsIMsgSendListener.idl
new file mode 100644
index 000000000..4facebc05
--- /dev/null
+++ b/mailnews/compose/public/nsIMsgSendListener.idl
@@ -0,0 +1,57 @@
+/* -*- 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;
+
+[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 folder uri before the draft is copied.
+     */
+    void onGetDraftFolderURI(in string 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);
+
+};
diff --git a/mailnews/compose/public/nsIMsgSendReport.idl b/mailnews/compose/public/nsIMsgSendReport.idl
new file mode 100644
index 000000000..65507a511
--- /dev/null
+++ b/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"
+#include "nsIPrompt.idl"
+
+
+[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 nsIPrompt prompt, in boolean showErrorOnly, in boolean dontShowReportTwice);
+};
diff --git a/mailnews/compose/public/nsISmtpServer.idl b/mailnews/compose/public/nsISmtpServer.idl
new file mode 100644
index 000000000..8ff3d1aa9
--- /dev/null
+++ b/mailnews/compose/public/nsISmtpServer.idl
@@ -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/. */
+
+#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 user supplied description for the server.
+  attribute AUTF8String description;
+
+  /// The server's hostname.
+  attribute ACString hostname;
+
+  /// The server's port.
+  attribute int32_t port;
+
+  /// The username to access the server with (if required)
+  attribute ACString username;
+
+  /**
+   * 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 ACString 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 string helloArgument;
+
+  /// Returns the URI of the server (smtp:///)
+  readonly attribute ACString serverURI;
+
+  /**
+   * 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.
+   * @param netPrompt     An nsIAuthPrompt instance to use for the password
+   *                      prompt.
+   * @return              The password to use (may be null if no password was
+   *                      obtained).
+   */  
+  ACString getPasswordWithUI(in wstring promptString, in wstring promptTitle,
+                           in nsIAuthPrompt netPrompt);
+
+  /**
+   * 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 ACString 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/mailnews/compose/public/nsISmtpService.idl b/mailnews/compose/public/nsISmtpService.idl
new file mode 100644
index 000000000..fcd6602de
--- /dev/null
+++ b/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 nsISimpleEnumerator;
+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 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 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 aPassword,
+                       in nsIUrlListener aUrlListener, 
+                       in nsIMsgStatusFeedback aStatusListener, 
+                       in nsIInterfaceRequestor aNotificationCallbacks,
+                       in boolean aRequestDSN,
+                       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
+   * @param  aServer           the SMTP server
+   */
+  void getServerByIdentity(in nsIMsgIdentity aSenderIdentity,
+                           out nsISmtpServer aServer);
+
+  /**
+   * A copy of the array of SMTP servers, as stored in the preferences
+   */
+  readonly attribute nsISimpleEnumerator 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
+   * If the server does not exist, create it and add it to our list
+   */
+  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/mailnews/compose/public/nsISmtpUrl.idl b/mailnews/compose/public/nsISmtpUrl.idl
new file mode 100644
index 000000000..be2af7cb7
--- /dev/null
+++ b/mailnews/compose/public/nsISmtpUrl.idl
@@ -0,0 +1,110 @@
+/* -*- 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;
+
+  /**
+   * 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/mailnews/compose/public/nsIURLFetcher.idl b/mailnews/compose/public/nsIURLFetcher.idl
new file mode 100644
index 000000000..fadb3abbc
--- /dev/null
+++ b/mailnews/compose/public/nsIURLFetcher.idl
@@ -0,0 +1,38 @@
+/* -*- 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"
+#include "nsIURI.idl"
+#include "nsIFileStreams.idl"
+#include "nsIFile.idl"
+
+%{ C++
+
+//
+// Callback declarations for URL completion
+//
+// For completion of send/message creation operations...
+typedef nsresult (*nsAttachSaveCompletionCallback) (nsresult aStatus,
+                                                    const nsACString &aContentType,
+                                                    const nsACString &aCharset,
+                                                    int32_t totalSize, const char16_t* aMsg, 
+                                                    void *tagData);
+
+class nsMsgAttachmentHandler;
+%}
+
+native nsAttachSaveCompletionCallback(nsAttachSaveCompletionCallback);
+[ptr] native nsMsgAttachmentHandler(nsMsgAttachmentHandler);
+
+
+[noscript, uuid(7316af6b-050d-4697-9d39-b0b358514f5c)]
+interface nsIURLFetcher : nsISupports
+{
+  boolean stillRunning();
+
+  void fireURLRequest(in nsIURI aURL, in nsIFile localFile, in nsIOutputStream fileStream, in nsAttachSaveCompletionCallback cb, in nsMsgAttachmentHandler tagData);
+
+  void initialize(in nsIFile localFile, in nsIOutputStream fileStream, in nsAttachSaveCompletionCallback cb, in nsMsgAttachmentHandler tagData);
+};
diff --git a/mailnews/compose/public/nsMsgAttachmentData.h b/mailnews/compose/public/nsMsgAttachmentData.h
new file mode 100644
index 000000000..0f15d3764
--- /dev/null
+++ b/mailnews/compose/public/nsMsgAttachmentData.h
@@ -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/. */
+
+#ifndef __MSGATTACHMENTDATA_H__
+#define __MSGATTACHMENTDATA_H__
+
+#include "nsIURL.h"
+#include "nsStringGlue.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/mailnews/compose/public/nsMsgCompCID.h b/mailnews/compose/public/nsMsgCompCID.h
new file mode 100644
index 000000000..9fad52638
--- /dev/null
+++ b/mailnews/compose/public/nsMsgCompCID.h
@@ -0,0 +1,247 @@
+/* -*- 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 nsMessageCompCID_h__
+#define nsMessageCompCID_h__
+
+#include "nsISupports.h"
+#include "nsIFactory.h"
+#include "nsIComponentManager.h"
+
+//
+// nsMsgComposeService
+//
+#define NS_MSGCOMPOSESERVICE_CID          \
+{ /* 588595FE-1ADA-11d3-A715-0060B0EB39B5 */      \
+ 0x588595fe, 0x1ada, 0x11d3,                      \
+ {0xa7, 0x15, 0x0, 0x60, 0xb0, 0xeb, 0x39, 0xb5}}
+
+#define NS_MSGCOMPOSESERVICE_CONTRACTID     \
+  "@mozilla.org/messengercompose;1"
+#define NS_MSGCOMPOSESTARTUPHANDLER_CONTRACTID \
+  "@mozilla.org/commandlinehandler/general-startup;1?type=compose"
+
+//
+// nsMsgComposeContentHandler
+//
+#define NS_MSGCOMPOSECONTENTHANDLER_CID         \
+{ /* 0B63FB80-BBBA-11D4-9DAA-91B657EB313C */    \
+0x0b63fb80, 0xbbba, 0x11d4,                     \
+ {0x9d, 0xaa, 0x91, 0xb6, 0x57, 0xeb, 0x31, 0x3c}}
+
+#define NS_MSGCOMPOSECONTENTHANDLER_CONTRACTID  \
+  NS_CONTENT_HANDLER_CONTRACTID_PREFIX"application/x-mailto"
+
+//
+// nsMsgCompose
+//
+#define NS_MSGCOMPOSE_CONTRACTID \
+  "@mozilla.org/messengercompose/compose;1"
+
+#define NS_MSGCOMPOSE_CID             \
+{ /* EB5BDAF8-BBC6-11d2-A6EC-0060B0EB39B5 */      \
+ 0xeb5bdaf8, 0xbbc6, 0x11d2,                      \
+ {0xa6, 0xec, 0x0, 0x60, 0xb0, 0xeb, 0x39, 0xb5}}
+
+//
+// nsMsgComposeSecure
+//
+#define NS_MSGCOMPOSESECURE_CONTRACTID \
+  "@mozilla.org/messengercompose/composesecure;1"
+
+//
+// nsMsgComposeParams
+//
+#define NS_MSGCOMPOSEPARAMS_CONTRACTID \
+  "@mozilla.org/messengercompose/composeparams;1"
+
+#define NS_MSGCOMPOSEPARAMS_CID             \
+{ /* CB998A00-C079-11D4-9DAA-8DF64BAB2EFC */      \
+ 0xcb998a00, 0xc079, 0x11d4,                      \
+ {0x9d, 0xaa, 0x8d, 0xf6, 0x4b, 0xab, 0x2e, 0xfc}}
+
+//
+// nsMsgComposeSendListener
+//
+#define NS_MSGCOMPOSESENDLISTENER_CONTRACTID \
+  "@mozilla.org/messengercompose/composesendlistener;1"
+
+#define NS_MSGCOMPOSESENDLISTENER_CID             \
+{ /* acc72781-2cea-11d5-9daa-bacdeac1eefc */      \
+ 0xacc72781, 0x2cea, 0x11d5,                      \
+ {0x9d, 0xaa, 0xba, 0xcd, 0xea, 0xc1, 0xee, 0xfc}}
+
+//
+// nsMsgComposeProgressParams
+//
+#define NS_MSGCOMPOSEPROGRESSPARAMS_CONTRACTID \
+  "@mozilla.org/messengercompose/composeprogressparameters;1"
+
+#define NS_MSGCOMPOSEPROGRESSPARAMS_CID             \
+{ /* 1e0e7c01-3e4c-11d5-9daa-f88d288130fc */      \
+ 0x1e0e7c01, 0x3e4c, 0x11d5,                      \
+ {0x9d, 0xaa, 0xf8, 0x8d, 0x28, 0x81, 0x30, 0xfc}}
+
+//
+// nsMsgCompFields
+//
+#define NS_MSGCOMPFIELDS_CONTRACTID \
+  "@mozilla.org/messengercompose/composefields;1"
+
+#define NS_MSGCOMPFIELDS_CID                    \
+{ /* 6D222BA0-BD46-11d2-8293-000000000000 */      \
+ 0x6d222ba0, 0xbd46, 0x11d2,                      \
+ {0x82, 0x93, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}}
+
+//
+// nsMsgAttachment
+//
+#define NS_MSGATTACHMENT_CONTRACTID \
+  "@mozilla.org/messengercompose/attachment;1"
+
+#define NS_MSGATTACHMENT_CID                    \
+{ /* 27B8D045-8D9F-4fa8-BFB6-8A0F8D09CE89 */    \
+ 0x27b8d045, 0x8d9f, 0x4fa8,                    \
+ {0xbf, 0xb6, 0x8a, 0xf, 0x8d, 0x9, 0xce, 0x89}}
+
+//
+// nsMsgAttachmentData
+//
+#define NS_MSGATTACHMENTDATA_CONTRACTID \
+  "@mozilla.org/messengercompose/attachmentdata;1"
+
+#define NS_MSGATTACHMENTDATA_CID                    \
+{ /* 9e16958d-d9e9-4cae-b723-a5bccf104998 */ \
+ 0x9e16958d, 0xd9e9, 0x4cae, \
+ {0xb7, 0x23, 0xa5, 0xbc, 0xcf, 0x10, 0x49, 0x98}}
+
+//
+// nsMsgAttachedFile
+//
+#define NS_MSGATTACHEDFILE_CONTRACTID \
+  "@mozilla.org/messengercompose/attachedfile;1"
+
+#define NS_MSGATTACHEDFILE_CID                    \
+{ /* ef173501-4e14-42b9-ae1f-7770de235c29 */ \
+ 0xef173501, 0x4e14, 0x42b9, \
+ {0xae, 0x1f, 0x77, 0x70, 0xde, 0x23, 0x5c, 0x29}}
+
+//
+// nsMsgSend
+//
+#define NS_MSGSEND_CONTRACTID \
+  "@mozilla.org/messengercompose/send;1"
+
+#define NS_MSGSEND_CID                \
+{ /* 935284E0-C5D8-11d2-8297-000000000000 */      \
+ 0x935284e0, 0xc5d8, 0x11d2,                      \
+ {0x82, 0x97, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}}
+
+//
+// nsMsgSendLater
+//
+#define NS_MSGSENDLATER_CONTRACTID                            \
+  "@mozilla.org/messengercompose/sendlater;1"
+
+#define NS_MSGSENDLATER_CID                           \
+{ /* E15C83F1-1CF4-11d3-8EF0-00A024A7D144 */      \
+ 0xe15c83f1, 0x1cf4, 0x11d3,                      \
+ {0x8e, 0xf0, 0x0, 0xa0, 0x24, 0xa7, 0xd1, 0x44 }}
+
+//
+// nsSmtpUrl
+//
+#define NS_SMTPURL_CONTRACTID \
+  "@mozilla.org/messengercompose/smtpurl;1"
+
+#define NS_SMTPURL_CID                            \
+{ /* BE59DBF0-2812-11d3-80A3-006008128C4E} */      \
+ 0xbe59dbf0, 0x2812, 0x11d3,                      \
+ {0x80, 0xa3, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e}}
+
+//
+// nsMailtoUrl
+//
+#define NS_MAILTOURL_CONTRACTID \
+  "@mozilla.org/messengercompose/mailtourl;1"
+
+#define NS_MAILTOURL_CID                            \
+{ /* 05BAB5E7-9C7D-11d3-98A3-001083010E9B} */       \
+ 0x5bab5e7, 0x9c7d, 0x11d3,                         \
+ {0x98, 0xa3, 0x0, 0x10, 0x83, 0x1, 0xe, 0x9b}}
+
+//
+// nsSmtpServer
+//
+#define NS_SMTPSERVER_CONTRACTID \
+  "@mozilla.org/messenger/smtp/server;1"
+
+#define NS_SMTPSERVER_CID                      \
+{ /* 60dc861a-56ce-11d3-9118-00a0c900d445 */   \
+  0x60dc861a,0x56ce,0x11d3,                   \
+  {0x91,0x18, 0x0, 0xa0, 0xc9, 0x0, 0xd4, 0x45 }}
+
+//
+// nsSmtpService
+//
+#define NS_SMTPSERVICE_CONTRACTID \
+  "@mozilla.org/messengercompose/smtp;1"
+
+#define NS_MAILTOHANDLER_CONTRACTID \
+  NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "mailto"
+
+#define NS_SMTPSERVICE_CID              \
+{ /* 5B6419F1-CA9B-11d2-8063-006008128C4E */      \
+ 0x5b6419f1, 0xca9b, 0x11d2,                      \
+ {0x80, 0x63, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e}}
+
+//
+// nsMsgQuote
+//
+#define NS_MSGQUOTE_CONTRACTID \
+  "@mozilla.org/messengercompose/quoting;1"
+#define NS_MSGQUOTE_CID \
+  {0x1C7ABF0C, 0x21E5, 0x11d3, \
+    { 0x8E, 0xF1, 0x00, 0xA0, 0x24, 0xA7, 0xD1, 0x44 }}
+
+#define NS_MSGQUOTELISTENER_CONTRACTID \
+  "@mozilla.org/messengercompose/quotinglistener;1"
+#define NS_MSGQUOTELISTENER_CID \
+  {0x683728ac, 0x88df, 0x11d3, \
+    { 0x98, 0x9d, 0x0, 0x10, 0x83, 0x1, 0xe, 0x9b }}
+
+//
+// nsMsgDraft
+//
+#define NS_MSGDRAFT_CONTRACTID \
+  "@mozilla.org/messengercompose/drafts;1"
+#define NS_MSGDRAFT_CID \
+  { 0xa623746c, 0x453b, 0x11d3, \
+  { 0x8f, 0xf, 0x0, 0xa0, 0x24, 0xa7, 0xd1, 0x44 } }
+
+//
+// nsURLFetcher
+//
+#define NS_URLFETCHER_CONTRACTID  \
+  "@mozilla.org/messengercompose/urlfetcher;1"
+
+// {01B8A701-2F52-11D5-9DAA-F78DA781A1FC}
+#define NS_URLFETCHER_CID \
+{ 0x01b8a701, 0x2f52, 0x11d5, \
+ { 0x9d, 0xaa, 0xf7, 0x8d, 0xa7, 0x81, 0xa1, 0xfc } }
+
+//
+// nsMsgCompUtils
+//
+#define NS_MSGCOMPUTILS_CONTRACTID  \
+  "@mozilla.org/messengercompose/computils;1"
+
+// {ceb0dca2-5e7d-4204-94d4-2ab925921fae}
+#define NS_MSGCOMPUTILS_CID \
+{ 0xceb0dca2, 0x5e7d, 0x4204, \
+  { 0x94, 0xd4, 0x2a, 0xb9, 0x25, 0x92, 0x1f, 0xae } }
+
+
+#endif // nsMessageCompCID_h__
diff --git a/mailnews/compose/src/moz.build b/mailnews/compose/src/moz.build
new file mode 100644
index 000000000..33b62c444
--- /dev/null
+++ b/mailnews/compose/src/moz.build
@@ -0,0 +1,55 @@
+# 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',
+    'nsMsgAttachmentHandler.h',
+    'nsMsgCompFields.h',
+    'nsMsgCompose.h',
+    'nsMsgSend.h',
+]
+
+SOURCES += [
+    'nsComposeStrings.cpp',
+    'nsMsgAttachment.cpp',
+    'nsMsgAttachmentHandler.cpp',
+    'nsMsgCompFields.cpp',
+    'nsMsgCompose.cpp',
+    'nsMsgComposeContentHandler.cpp',
+    'nsMsgComposeParams.cpp',
+    'nsMsgComposeProgressParams.cpp',
+    'nsMsgComposeService.cpp',
+    'nsMsgCompUtils.cpp',
+    'nsMsgCopy.cpp',
+    'nsMsgPrompts.cpp',
+    'nsMsgQuote.cpp',
+    'nsMsgSend.cpp',
+    'nsMsgSendLater.cpp',
+    'nsMsgSendPart.cpp',
+    'nsMsgSendReport.cpp',
+    'nsSmtpProtocol.cpp',
+    'nsSmtpServer.cpp',
+    'nsSmtpService.cpp',
+    'nsSmtpUrl.cpp',
+    'nsURLFetcher.cpp',
+]
+
+if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    SOURCES += [
+        'nsMsgAppleDoubleEncode.cpp',
+        'nsMsgAppleEncode.cpp',
+    ]
+    EXPORTS += [
+        'nsMsgAppleCodes.h',
+        'nsMsgAppleDouble.h',
+    ]
+
+EXTRA_COMPONENTS += [
+    'nsSMTPProtocolHandler.js',
+    'nsSMTPProtocolHandler.manifest',
+]
+
+FINAL_LIBRARY = 'mail'
+
diff --git a/mailnews/compose/src/nsComposeStrings.cpp b/mailnews/compose/src/nsComposeStrings.cpp
new file mode 100644
index 000000000..5c8565805
--- /dev/null
+++ b/mailnews/compose/src/nsComposeStrings.cpp
@@ -0,0 +1,116 @@
+/* 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 char16_t* errorStringNameForErrorCode(nsresult aCode)
+{
+#ifdef __GNUC__
+// Temporary workaroung 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 u"unableToOpenFile";
+    case NS_MSG_UNABLE_TO_OPEN_TMP_FILE:
+      return u"unableToOpenTmpFile";
+    case NS_MSG_UNABLE_TO_SAVE_TEMPLATE:
+      return u"unableToSaveTemplate";
+    case NS_MSG_UNABLE_TO_SAVE_DRAFT:
+      return u"unableToSaveDraft";
+    case NS_MSG_COULDNT_OPEN_FCC_FOLDER:
+      return u"couldntOpenFccFolder";
+    case NS_MSG_NO_SENDER:
+      return u"noSender";
+    case NS_MSG_NO_RECIPIENTS:
+      return u"noRecipients";
+    case NS_MSG_ERROR_WRITING_FILE:
+      return u"errorWritingFile";
+    case NS_ERROR_SENDING_FROM_COMMAND:
+      return u"errorSendingFromCommand";
+    case NS_ERROR_SENDING_DATA_COMMAND:
+      return u"errorSendingDataCommand";
+    case NS_ERROR_SENDING_MESSAGE:
+      return u"errorSendingMessage";
+    case NS_ERROR_POST_FAILED:
+      return u"postFailed";
+    case NS_ERROR_QUEUED_DELIVERY_FAILED:
+      return u"errorQueuedDeliveryFailed";
+    case NS_ERROR_SEND_FAILED:
+      return u"sendFailed";
+    case NS_ERROR_SMTP_SERVER_ERROR:
+      return u"smtpServerError";
+    case NS_MSG_UNABLE_TO_SEND_LATER:
+      return u"unableToSendLater";
+    case NS_ERROR_COMMUNICATIONS_ERROR:
+      return u"communicationsError";
+    case NS_ERROR_BUT_DONT_SHOW_ALERT:
+      return u"dontShowAlert";
+    case NS_ERROR_TCP_READ_ERROR:
+      return u"tcpReadError";
+    case NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS:
+      return u"couldNotGetUsersMailAddress";
+    case NS_ERROR_MIME_MPART_ATTACHMENT_ERROR:
+      return u"mimeMpartAttachmentError";
+    case NS_MSG_FAILED_COPY_OPERATION:
+      return u"failedCopyOperation";
+    case NS_ERROR_NNTP_NO_CROSS_POSTING:
+      return u"nntpNoCrossPosting";
+    case NS_MSG_CANCELLING:
+      return u"msgCancelling";
+    case NS_ERROR_SEND_FAILED_BUT_NNTP_OK:
+      return u"sendFailedButNntpOk";
+    case NS_MSG_ERROR_READING_FILE:
+      return u"errorReadingFile";
+    case NS_MSG_ERROR_ATTACHING_FILE:
+      return u"errorAttachingFile";
+    case NS_ERROR_SMTP_GREETING:
+      return u"incorrectSmtpGreeting";
+    case NS_ERROR_SENDING_RCPT_COMMAND:
+      return u"errorSendingRcptCommand";
+    case NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS:
+      return u"startTlsFailed";
+    case NS_ERROR_SMTP_PASSWORD_UNDEFINED:
+      return u"smtpPasswordUndefined";
+    case NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED:
+      return u"smtpTempSizeExceeded";
+    case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_1:
+      return u"smtpPermSizeExceeded1";
+    case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2:
+      return u"smtpPermSizeExceeded2";
+    case NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER:
+      return u"smtpSendFailedUnknownServer";
+    case NS_ERROR_SMTP_SEND_FAILED_REFUSED:
+      return u"smtpSendRequestRefused";
+    case NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED:
+      return u"smtpSendInterrupted";
+    case NS_ERROR_SMTP_SEND_FAILED_TIMEOUT:
+      return u"smtpSendTimeout";
+    case NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON:
+      return u"smtpSendFailedUnknownReason";
+    case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL:
+      return u"smtpHintAuthEncryptToPlainNoSsl";
+    case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL:
+      return u"smtpHintAuthEncryptToPlainSsl";
+    case NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT:
+      return u"smtpHintAuthPlainToEncrypt";
+    case NS_ERROR_SMTP_AUTH_FAILURE:
+      return u"smtpAuthFailure";
+    case NS_ERROR_SMTP_AUTH_GSSAPI:
+      return u"smtpAuthGssapi";
+    case NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED:
+      return u"smtpAuthMechNotSupported";
+    case NS_ERROR_SMTP_AUTH_NOT_SUPPORTED:
+      return u"smtpAuthenticationNotSupported";
+    case NS_ERROR_ILLEGAL_LOCALPART:
+      return u"illegalLocalPart";
+    default:
+      return u"sendFailed";
+  }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+}
diff --git a/mailnews/compose/src/nsComposeStrings.h b/mailnews/compose/src/nsComposeStrings.h
new file mode 100644
index 000000000..2a8754493
--- /dev/null
+++ b/mailnews/compose/src/nsComposeStrings.h
@@ -0,0 +1,77 @@
+/* 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/. */
+
+/**
+  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_QUEUED_DELIVERY_FAILED             NS_MSG_GENERATE_FAILURE(12519)
+#define NS_ERROR_SEND_FAILED                        NS_MSG_GENERATE_FAILURE(12520)
+#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_TCP_READ_ERROR                     NS_MSG_GENERATE_FAILURE(12528)
+#define NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS   NS_MSG_GENERATE_FAILURE(12529)
+#define NS_ERROR_MIME_MPART_ATTACHMENT_ERROR        NS_MSG_GENERATE_FAILURE(12531)
+#define NS_MSG_FAILED_COPY_OPERATION                NS_MSG_GENERATE_FAILURE(12532)
+
+/* 12554 is taken by NS_ERROR_NNTP_NO_CROSS_POSTING.  use 12555 as the next one */
+
+#define NS_MSG_CANCELLING                           NS_MSG_GENERATE_SUCCESS(12555)
+
+// For message sending report
+#define NS_ERROR_SEND_FAILED_BUT_NNTP_OK            NS_MSG_GENERATE_FAILURE(12560)
+#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_TEMP_SIZE_EXCEEDED            NS_MSG_GENERATE_FAILURE(12586)
+#define NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_1          NS_MSG_GENERATE_FAILURE(12587)
+#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_SMTP_AUTH_NOT_SUPPORTED            NS_MSG_GENERATE_FAILURE(12600)
+
+#define NS_ERROR_ILLEGAL_LOCALPART                  NS_MSG_GENERATE_FAILURE(12601)
+
+const char16_t* errorStringNameForErrorCode(nsresult aCode);
+
+#endif /* _nsComposeStrings_H__ */
diff --git a/mailnews/compose/src/nsMsgAppleCodes.h b/mailnews/compose/src/nsMsgAppleCodes.h
new file mode 100644
index 000000000..d8ca2f327
--- /dev/null
+++ b/mailnews/compose/src/nsMsgAppleCodes.h
@@ -0,0 +1,106 @@
+/* -*- 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/. */
+
+/*
+**	AD_Codes.h
+**
+**	---------------
+**
+**		Head file for Apple Decode/Encode essential codes.
+**
+**
+*/
+
+#ifndef ad_codes_h
+#define ad_codes_h
+
+/*
+** applefile definitions used 
+*/
+#if PRAGMA_STRUCT_ALIGN
+  #pragma options align=mac68k
+#endif
+
+#define APPLESINGLE_MAGIC	0x00051600L
+#define APPLEDOUBLE_MAGIC 	0x00051607L
+#define VERSION 			0x00020000
+
+#define NUM_ENTRIES 		6
+
+#define ENT_DFORK   		1L
+#define ENT_RFORK   		2L
+#define ENT_NAME    		3L
+#define ENT_COMMENT 		4L
+#define ENT_DATES   		8L
+#define ENT_FINFO   		9L
+#define CONVERT_TIME 		1265437696L
+
+/*
+** data type used in the encoder/decoder.
+*/
+typedef struct ap_header 
+{
+	int32_t 	magic;
+	int32_t	version;
+	char 	fill[16];
+	int16_t 	entries;
+
+} ap_header;
+
+typedef struct ap_entry 
+{
+	int32_t  id;
+	int32_t	offset;
+	int32_t	length;
+	
+} ap_entry;
+
+typedef struct ap_dates 
+{
+	int32_t create, modify, backup, access;
+
+} ap_dates;
+
+typedef struct myFInfo			/* the mac FInfo structure for the cross platform. */
+{	
+	int32_t	fdType, fdCreator;
+	int16_t	fdFlags;
+	int32_t	fdLocation;			/* it really should  be a pointer, but just a place-holder  */
+	int16_t	fdFldr;	
+
+}	myFInfo;
+
+PR_BEGIN_EXTERN_C
+/*
+**	string utils.
+*/
+int write_stream(appledouble_encode_object *p_ap_encode_obj, const char *s,int len);
+
+int fill_apple_mime_header(appledouble_encode_object *p_ap_encode_obj);
+int ap_encode_file_infor(appledouble_encode_object *p_ap_encode_obj);
+int ap_encode_header(appledouble_encode_object* p_ap_encode_obj, bool firstTime);
+int ap_encode_data(  appledouble_encode_object* p_ap_encode_obj, bool firstTime);
+
+/*
+**	the prototypes for the ap_decoder.
+*/
+int  fetch_a_line(appledouble_decode_object* p_ap_decode_obj, char *buff);
+int  ParseFileHeader(appledouble_decode_object* p_ap_decode_obj);
+int  ap_seek_part_start(appledouble_decode_object* p_ap_decode_obj);
+void parse_param(char *p, char **param, char**define, char **np);
+int  ap_seek_to_boundary(appledouble_decode_object* p_ap_decode_obj, bool firstime);
+int  ap_parse_header(appledouble_decode_object* p_ap_decode_obj,bool firstime);
+int  ap_decode_file_infor(appledouble_decode_object* p_ap_decode_obj);
+int  ap_decode_process_header(appledouble_decode_object* p_ap_decode_obj, bool firstime);
+int  ap_decode_process_data(  appledouble_decode_object* p_ap_decode_obj, bool firstime);
+
+PR_END_EXTERN_C
+ 
+#if PRAGMA_STRUCT_ALIGN
+  #pragma options align=reset
+#endif
+
+#endif /* ad_codes_h */
diff --git a/mailnews/compose/src/nsMsgAppleDouble.h b/mailnews/compose/src/nsMsgAppleDouble.h
new file mode 100644
index 000000000..f4ae934ad
--- /dev/null
+++ b/mailnews/compose/src/nsMsgAppleDouble.h
@@ -0,0 +1,207 @@
+/* -*- 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/. */
+
+/* 
+*   AppleDouble.h
+*	-------------
+*
+*  	  The header file for a stream based apple single/double encodor/decodor.
+*		
+*		2aug95	mym		
+*		
+*/
+
+
+#ifndef AppleDouble_h
+#define AppleDouble_h
+
+#include "msgCore.h"
+#include "nsComposeStrings.h"
+#include "nsIOutputStream.h"
+#include "nsCOMPtr.h"
+
+#include <CoreServices/CoreServices.h>
+
+#define NOERR			0
+#define errDone			1
+								/* Done with current operation.	*/
+#define errEOB			2
+								/* 	End of a buffer.			*/
+#define errEOP			3	
+								/* 	End of a Part.				*/
+
+					
+#define errFileOpen	NS_ERROR_GET_CODE(NS_MSG_UNABLE_TO_OPEN_TMP_FILE)
+#define errFileWrite	-202 /*Error writing temporary file.*/
+#define errUsrCancel	-2  /*MK_INTERRUPTED */
+#define errDecoding		-1
+
+/*
+** The envirment block data type. 
+*/
+enum 
+{ 
+	kInit, 
+	kDoingHeaderPortion, 
+	kDoneHeaderPortion, 
+	kDoingDataPortion, 
+	kDoneDataPortion 
+};
+
+typedef struct _appledouble_encode_object 
+{
+    char    fname[256];
+    FSIORefNum fileId;				/* the id for the open file (data/resource fork) */
+
+	int 	state;
+	int		text_file_type;		/* if the file has a text file type with it.	*/
+	char	*boundary;			/* the boundary string.							*/
+
+	int		status;				/* the error code if anyerror happens.			*/
+	char 	b_overflow[200];
+	int		s_overflow;
+	
+	int		state64;			/* the left over state of base64 enocding 		*/
+	int		ct;					/* the character count of base64 encoding		*/
+	int 	c1, c2;				/* the left of the last base64 encoding 		*/		
+
+	char 	*outbuff;			/* the outbuff by the caller.           		*/
+	int		s_outbuff;			/* the size of the buffer.						*/
+	int		pos_outbuff;		/* the offset in the current buffer.			*/ 
+
+} appledouble_encode_object;
+
+/* The possible content transfer encodings */
+
+enum 
+{ 
+	kEncodeNone,
+	kEncodeQP,
+	kEncodeBase64,
+	kEncodeUU
+};
+
+enum 
+{ 
+	kGeneralMine,
+	kAppleDouble,
+	kAppleSingle
+};
+
+enum 
+{ 
+	kInline,
+	kDontCare
+};
+
+enum 
+{ 
+	kHeaderPortion,
+	kDataPortion
+};
+
+/* the decode states.	*/
+enum 
+{ 
+	kBeginParseHeader = 3,
+	kParsingHeader,
+	kBeginSeekBoundary,
+	kSeekingBoundary,
+	kBeginHeaderPortion, 
+	kProcessingHeaderPortion, 
+	kBeginDataPortion, 
+	kProcessingDataPortion, 
+	kFinishing
+};
+
+/* uuencode states */
+enum
+{
+	kWaitingForBegin = (int) 0,
+	kBegin,
+	kMainBody,
+	kEnd
+};
+
+typedef struct _appledouble_decode_object 
+{
+	int		is_binary;
+	int		is_apple_single;	/* if the object encoded is in apple single		*/
+	int		write_as_binhex;
+	
+	int		messagetype;
+	char*	boundary0;			/* the boundary for the enclosure.				*/
+	int		deposition;			/* the deposition.								*/
+	int		encoding;			/* the encoding method.							*/
+	int		which_part;
+	
+	char	fname[256];
+	// nsIOFileStream *fileSpec;					/* the stream for data fork work.					 */
+
+	int 	state;
+	
+	int		rksize;				/* the resource fork size count.				*/
+	int		dksize;				/* the data fork size count.					*/
+	 
+	int		status;				/* the error code if anyerror happens.			*/
+	char 	b_leftover[256];
+	int		s_leftover;
+	
+	int		encode;				/* the encode type of the message.				*/
+	int		state64;			/* the left over state of base64 enocding 		*/
+	int		left;				/* the character count of base64 encoding		*/
+	int 	c[4];				/* the left of the last base64 encoding 		*/		
+	int		uu_starts_line;		/* is decoder at the start of a line? (uuencode)	*/
+	int		uu_state;			/* state w/r/t the uuencode body */
+	int		uu_bytes_written;	/* bytes written from the current tuple (uuencode) */
+	int		uu_line_bytes;		/* encoded bytes remaining in the current line (uuencode) */
+
+	char 	*inbuff;			/* the outbuff by the caller.           		*/
+	int		s_inbuff;			/* the size of the buffer.						*/
+	int		pos_inbuff;			/* the offset in the current buffer.			*/ 
+
+
+	nsCOMPtr <nsIFile> tmpFile;		/* the temp file to hold the decode data fork 	*/
+								                      /* when doing the binhex exporting.				*/
+  nsCOMPtr <nsIOutputStream> tmpFileStream; /* The output File Stream */
+	int32_t	            data_size;			/* the size of the data in the tmp file.		*/
+
+} appledouble_decode_object;
+
+
+/*
+**	The protypes.
+*/
+
+PR_BEGIN_EXTERN_C
+
+int ap_encode_init(appledouble_encode_object *p_ap_encode_obj, 
+					const char* fname,
+					char* separator);
+
+int ap_encode_next(appledouble_encode_object* p_ap_encode_obj, 
+					char 	*to_buff,
+					int32_t 	buff_size,
+					int32_t*	real_size);
+
+int ap_encode_end(appledouble_encode_object* p_ap_encode_obj,
+					bool	is_aborting);
+
+int ap_decode_init(appledouble_decode_object* p_ap_decode_obj,
+					bool	is_apple_single,
+					bool	write_as_bin_hex,
+					void  	*closure);
+
+int ap_decode_next(appledouble_decode_object* p_ap_decode_obj, 
+					char 	*in_buff, 
+					int32_t 	buff_size);
+
+int ap_decode_end(appledouble_decode_object* p_ap_decode_obj, 
+				 	bool is_aborting);
+
+PR_END_EXTERN_C
+
+#endif
diff --git a/mailnews/compose/src/nsMsgAppleDoubleEncode.cpp b/mailnews/compose/src/nsMsgAppleDoubleEncode.cpp
new file mode 100644
index 000000000..4d7178123
--- /dev/null
+++ b/mailnews/compose/src/nsMsgAppleDoubleEncode.cpp
@@ -0,0 +1,266 @@
+/* -*- 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/. */
+
+/*
+*
+*   apple-double.c
+*	--------------
+*
+*  	  The codes to do apple double encoding/decoding.
+*		
+*		02aug95		mym		created.
+*		
+*/
+#include "nsID.h"
+#include "nscore.h"
+#include "nsStringGlue.h"
+#include "nsMsgAppleDouble.h"
+#include "nsMsgAppleCodes.h"
+#include "nsMsgCompUtils.h"
+#include "nsCExternalHandlerService.h"
+#include "nsIMIMEService.h"
+#include "nsMimeTypes.h"
+#include "prmem.h"
+#include "nsNetUtil.h"
+
+
+void	
+MacGetFileType(nsIFile   *fs, 
+               bool         *useDefault, 
+               char         **fileType, 
+               char         **encoding)
+{
+	if ((fs == NULL) || (fileType == NULL) || (encoding == NULL))
+		return;
+
+  bool exists = false;
+  fs->Exists(&exists);
+  if (!exists)
+    return;
+
+	*useDefault = TRUE;
+	*fileType = NULL;
+	*encoding = NULL;
+
+  nsCOMPtr<nsILocalFileMac> macFile = do_QueryInterface(fs);
+  FSRef fsRef;
+  FSCatalogInfo catalogInfo;
+  OSErr err = errFileOpen;
+  if (NS_SUCCEEDED(macFile->GetFSRef(&fsRef)))
+    err = ::FSGetCatalogInfo(&fsRef, kFSCatInfoFinderInfo, &catalogInfo, nullptr, nullptr, nullptr);
+
+  if ( (err != noErr) || (((FileInfo*)(&catalogInfo.finderInfo))->fileType == 'TEXT') )
+    *fileType = strdup(APPLICATION_OCTET_STREAM);
+  else
+  {
+    // At this point, we should call the mime service and
+    // see what we can find out?
+    nsresult      rv;
+    nsCOMPtr <nsIURI> tURI;
+    if (NS_SUCCEEDED(NS_NewFileURI(getter_AddRefs(tURI), fs)) && tURI)
+    {
+      nsCOMPtr<nsIMIMEService> mimeFinder (do_GetService(NS_MIMESERVICE_CONTRACTID, &rv));
+      if (NS_SUCCEEDED(rv) && mimeFinder) 
+      {
+        nsAutoCString mimeType;
+        rv = mimeFinder->GetTypeFromURI(tURI, mimeType);
+        if (NS_SUCCEEDED(rv)) 
+        {
+          *fileType = ToNewCString(mimeType);
+          return;
+        }        
+      }
+    }
+
+    // If we hit here, return something...default to this...
+    *fileType = strdup(APPLICATION_OCTET_STREAM);
+  }
+}
+
+//#pragma cplusplus reset
+
+/*
+*	ap_encode_init
+*	--------------
+*	
+*	Setup the encode envirment
+*/
+
+int ap_encode_init( appledouble_encode_object *p_ap_encode_obj,
+                    const char                *fname,
+                    char                      *separator)
+{
+  nsCOMPtr <nsIFile> myFile;
+  NS_NewNativeLocalFile(nsDependentCString(fname), true, getter_AddRefs(myFile));
+  bool exists;
+  if (myFile && NS_SUCCEEDED(myFile->Exists(&exists)) && !exists)
+    return -1;
+
+  nsCOMPtr<nsILocalFileMac> macFile = do_QueryInterface(myFile);
+  nsAutoCString path;
+  macFile->GetNativePath(path);
+
+	memset(p_ap_encode_obj, 0, sizeof(appledouble_encode_object));
+	
+	/*
+	**	Fill out the source file inforamtion.
+	*/	
+  memcpy(p_ap_encode_obj->fname, path.get(), path.Length());
+  p_ap_encode_obj->fname[path.Length()] = '\0';
+	
+	p_ap_encode_obj->boundary = strdup(separator);
+	return noErr;
+}
+
+/*
+**	ap_encode_next
+**	--------------
+**		
+**		return :
+**			noErr	:	everything is ok
+**			errDone	:	when encoding is done.
+**			errors	:	otherwise.
+*/
+int ap_encode_next(
+	appledouble_encode_object* p_ap_encode_obj, 
+	char 	*to_buff, 
+	int32_t 	buff_size, 
+	int32_t* 	real_size)
+{
+	int status;
+	
+	/*
+	** 	install the out buff now.
+	*/
+	p_ap_encode_obj->outbuff     = to_buff;
+	p_ap_encode_obj->s_outbuff 	 = buff_size;
+	p_ap_encode_obj->pos_outbuff = 0;
+	
+	/*
+	**	first copy the outstandind data in the overflow buff to the out buffer. 
+	*/
+	if (p_ap_encode_obj->s_overflow)
+	{
+		status = write_stream(p_ap_encode_obj,
+		                      (const char*)(p_ap_encode_obj->b_overflow),
+		                      p_ap_encode_obj->s_overflow);
+		if (status != noErr)
+			return status;
+				
+		p_ap_encode_obj->s_overflow = 0;
+	}
+
+	/*
+	** go the next processing stage based on the current state. 
+	*/
+	switch (p_ap_encode_obj->state)
+	{
+		case kInit:
+			/*
+			** We are in the  starting position, fill out the header.
+			*/
+			status = fill_apple_mime_header(p_ap_encode_obj); 
+			if (status != noErr)
+				break;					/* some error happens */
+				
+			p_ap_encode_obj->state = kDoingHeaderPortion;
+			status = ap_encode_header(p_ap_encode_obj, true); 
+										/* it is the first time to calling 		*/							
+			if (status == errDone)
+			{
+				p_ap_encode_obj->state = kDoneHeaderPortion;
+			}
+			else
+			{
+				break;					/* we need more work on header portion.	*/
+			}			
+				
+			/*
+			** we are done with the header, so let's go to the data port.
+			*/
+			p_ap_encode_obj->state = kDoingDataPortion;
+			status = ap_encode_data(p_ap_encode_obj, true);		 	
+										/* it is first time call do data portion */
+							
+			if (status == errDone)
+			{
+				p_ap_encode_obj->state  = kDoneDataPortion;
+				status = noErr;
+			}
+			break;
+
+		case kDoingHeaderPortion:
+		
+			status = ap_encode_header(p_ap_encode_obj, false); 			
+										/* continue with the header portion.	*/
+			if (status == errDone)
+			{
+				p_ap_encode_obj->state = kDoneHeaderPortion;
+			}
+			else
+			{
+				break;					/* we need more work on header portion.	*/				
+			}
+			
+			/*
+			** start the data portion.
+			*/
+			p_ap_encode_obj->state = kDoingDataPortion;
+			status = ap_encode_data(p_ap_encode_obj, true); 					
+										/* it is the first time calling 		*/
+			if (status == errDone)
+			{
+				p_ap_encode_obj->state  = kDoneDataPortion;
+				status = noErr;
+			}
+			break;
+
+		case kDoingDataPortion:
+		
+			status = ap_encode_data(p_ap_encode_obj, false); 				
+										/* it is not the first time				*/
+													
+			if (status == errDone)
+			{
+				p_ap_encode_obj->state = kDoneDataPortion;
+				status = noErr;
+			}
+			break;
+
+		case kDoneDataPortion:
+				status = errDone;		/* we are really done.					*/
+
+			break;
+	}
+	
+	*real_size = p_ap_encode_obj->pos_outbuff;
+	return status;
+}
+
+/*
+**	ap_encode_end
+**	-------------
+**
+**	clear the apple encoding.
+*/
+
+int ap_encode_end(
+	appledouble_encode_object *p_ap_encode_obj, 
+	bool is_aborting)
+{
+	/*
+	** clear up the apple doubler.
+	*/
+	if (p_ap_encode_obj == NULL)
+		return noErr;
+
+	if (p_ap_encode_obj->fileId)			/* close the file if it is open.	*/
+    ::FSCloseFork(p_ap_encode_obj->fileId);
+
+	PR_FREEIF(p_ap_encode_obj->boundary);		/* the boundary string.				*/
+	
+	return noErr;
+}
diff --git a/mailnews/compose/src/nsMsgAppleEncode.cpp b/mailnews/compose/src/nsMsgAppleEncode.cpp
new file mode 100644
index 000000000..27e39a8cd
--- /dev/null
+++ b/mailnews/compose/src/nsMsgAppleEncode.cpp
@@ -0,0 +1,703 @@
+/* -*- 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/. */
+
+/*
+ *
+ *   apple_double_encode.c
+ *	 ---------------------
+ *
+ *    The routines doing the Apple Double Encoding.
+ *		
+ *			2aug95	mym	Created.
+ *		
+ */
+
+#include "nscore.h"
+#include "nsStringGlue.h"
+#include "nsMimeTypes.h"
+#include "prprf.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMsgAppleDouble.h"
+#include "nsMsgAppleCodes.h"
+#include "nsILocalFileMac.h"
+
+/*
+**	Local Functions prototypes.
+*/
+static int output64chunk( appledouble_encode_object* p_ap_encode_obj, 
+				int c1, int c2, int c3, int pads);
+				
+static int to64(appledouble_encode_object* p_ap_encode_obj, 
+				char	*p, 
+				int 	in_size);
+ 
+static int finish64(appledouble_encode_object* p_ap_encode_obj);
+
+
+#define BUFF_LEFT(p)	((p)->s_outbuff - (p)->pos_outbuff)	
+
+/*
+**	write_stream.
+*/
+int write_stream(
+	appledouble_encode_object *p_ap_encode_obj,
+	const char *out_string,
+	int len)
+{	
+	if (p_ap_encode_obj->pos_outbuff + len < p_ap_encode_obj->s_outbuff)
+	{
+		memcpy(p_ap_encode_obj->outbuff + p_ap_encode_obj->pos_outbuff, 
+		       out_string, 
+		       len);
+		p_ap_encode_obj->pos_outbuff += len;
+		return noErr;
+	}
+	else
+	{
+		/*
+		**	If the buff doesn't have enough space, use the overflow buffer then.
+		*/
+		int s_len = p_ap_encode_obj->s_outbuff - p_ap_encode_obj->pos_outbuff;
+		
+		memcpy(p_ap_encode_obj->outbuff + p_ap_encode_obj->pos_outbuff, 
+		       out_string, 
+		       s_len);
+		memcpy(p_ap_encode_obj->b_overflow + p_ap_encode_obj->s_overflow,
+		       out_string + s_len,
+		       p_ap_encode_obj->s_overflow += (len - s_len));
+		p_ap_encode_obj->pos_outbuff += s_len;
+		return errEOB;
+	}
+}
+
+int fill_apple_mime_header(
+	appledouble_encode_object *p_ap_encode_obj)
+{
+	int  status;
+	
+	char tmpstr[266];
+	
+#if 0	
+//	strcpy(tmpstr, "Content-Type: multipart/mixed; boundary=\"-\"\n\n---\n");
+//	status = write_stream(p_ap_encode_env, 
+//						tmpstr,
+//						strlen(tmpstr));
+//	if (status != noErr)
+//		return status;
+
+	PR_snprintf(tmpstr, sizeof(tmpstr),
+			"Content-Type: multipart/appledouble; boundary=\"=\"; name=\"");
+	status = write_stream(p_ap_encode_obj, (const char*)tmpstr, strlen(tmpstr));
+	if (status != noErr)
+		return status;
+		
+	status = write_stream(p_ap_encode_obj,
+						p_ap_encode_obj->fname,
+						strlen(p_ap_encode_obj->fname));
+	if (status != noErr)
+		return status;
+		
+	PR_snprintf(tmpstr, sizeof(tmpstr),
+			"\"\r\nContent-Disposition: inline; filename=\"%s\"\r\n\r\n\r\n--=\r\n",
+			p_ap_encode_obj->fname);
+#endif /* 0 */
+	PR_snprintf(tmpstr, sizeof(tmpstr), "--%s" CRLF, p_ap_encode_obj->boundary);
+	status = write_stream(p_ap_encode_obj, (const char*)tmpstr, strlen(tmpstr));
+	return status;
+} 
+
+int ap_encode_file_infor(
+	appledouble_encode_object *p_ap_encode_obj)
+{
+	ap_header	head;
+	ap_entry 	entries[NUM_ENTRIES];
+	ap_dates 	dates;
+	short 		i;
+	long 		comlen;
+	char 		comment[256];
+	int	 		status;
+    
+    nsCOMPtr <nsIFile> resFile;
+    NS_NewNativeLocalFile(nsDependentCString(p_ap_encode_obj->fname), true,
+                          getter_AddRefs(resFile));
+    if (!resFile)
+        return errFileOpen;
+
+    FSRef ref;
+    nsCOMPtr <nsILocalFileMac> macFile = do_QueryInterface(resFile);
+    if (NS_FAILED(macFile->GetFSRef(&ref)))
+        return errFileOpen;
+
+    FSCatalogInfo catalogInfo;
+    if (::FSGetCatalogInfo(&ref, kFSCatInfoFinderInfo, &catalogInfo, nullptr, nullptr, nullptr) != noErr)
+	{
+		return errFileOpen;
+	}
+
+	/* get a file comment, if possible */
+#if 1
+    // Carbon doesn't support GetWDInfo(). (Bug 555684)
+
+    // not sure why working directories are needed here...
+    comlen = 0;
+#else
+	long 		procID;
+	procID = 0;
+	GetWDInfo(p_ap_encode_obj->vRefNum, &fpb->ioVRefNum, &fpb->ioDirID, &procID);
+	IOParam 	vinfo;
+	memset((void *) &vinfo, '\0', sizeof (vinfo));
+	GetVolParmsInfoBuffer vp;
+	vinfo.ioCompletion  = nil;
+	vinfo.ioVRefNum 	= fpb->ioVRefNum;
+	vinfo.ioBuffer 		= (Ptr) &vp;
+	vinfo.ioReqCount 	= sizeof (vp);
+	comlen = 0;
+	if (PBHGetVolParmsSync((HParmBlkPtr) &vinfo) == noErr &&
+		((vp.vMAttrib >> bHasDesktopMgr) & 1)) 
+	{
+		DTPBRec 	dtp;
+		memset((void *) &dtp, '\0', sizeof (dtp));
+		dtp.ioVRefNum = fpb->ioVRefNum;
+		if (PBDTGetPath(&dtp) == noErr) 
+		{
+			dtp.ioCompletion = nil;
+			dtp.ioDTBuffer = (Ptr) comment;
+			dtp.ioNamePtr  = fpb->ioNamePtr;
+			dtp.ioDirID    = fpb->ioFlParID;
+			if (PBDTGetCommentSync(&dtp) == noErr) 
+				comlen = dtp.ioDTActCount;
+		}
+	}
+#endif /* ! 1 */
+	
+	/* write header */
+//	head.magic = dfork ? APPLESINGLE_MAGIC : APPLEDOUBLE_MAGIC;
+	head.magic   = APPLEDOUBLE_MAGIC;		/* always do apple double */
+	head.version = VERSION;
+	memset(head.fill, '\0', sizeof (head.fill));
+	head.entries = NUM_ENTRIES - 1;
+	status = to64(p_ap_encode_obj,
+					(char *) &head,
+					sizeof (head));				
+	if (status != noErr)
+		return status;
+
+	/* write entry descriptors */
+    nsAutoCString leafname;
+    macFile->GetNativeLeafName(leafname);
+	entries[0].offset = sizeof (head) + sizeof (ap_entry) * head.entries;
+	entries[0].id 	= ENT_NAME;
+    entries[0].length = leafname.Length();
+	entries[1].id 	= ENT_FINFO;
+	entries[1].length = sizeof (FInfo) + sizeof (FXInfo);
+	entries[2].id 	= ENT_DATES;
+	entries[2].length = sizeof (ap_dates);
+	entries[3].id 	= ENT_COMMENT;
+	entries[3].length = comlen;
+	entries[4].id 	= ENT_RFORK;
+    entries[4].length = catalogInfo.rsrcLogicalSize;
+	entries[5].id 	= ENT_DFORK;
+    entries[5].length = catalogInfo.dataLogicalSize;
+
+	/* correct the link in the entries. */
+	for (i = 1; i < NUM_ENTRIES; ++i) 
+	{
+		entries[i].offset = entries[i-1].offset + entries[i-1].length;
+	}
+	status = to64(p_ap_encode_obj,
+					(char *) entries,
+					sizeof (ap_entry) * head.entries); 
+	if (status != noErr)
+		return status;
+
+	/* write name */
+	status = to64(p_ap_encode_obj,
+					(char *) leafname.get(),
+					leafname.Length()); 
+	if (status != noErr)
+		return status;
+	
+	/* write finder info */
+	status = to64(p_ap_encode_obj,
+					(char *) &catalogInfo.finderInfo,
+					sizeof (FInfo));
+	if (status != noErr)
+		return status;
+					  
+	status = to64(p_ap_encode_obj,
+					(char *) &catalogInfo.extFinderInfo,
+					sizeof (FXInfo));
+	if (status != noErr)
+		return status;
+
+	/* write dates */
+    dates.create = catalogInfo.createDate.lowSeconds + CONVERT_TIME;
+    dates.modify = catalogInfo.contentModDate.lowSeconds + CONVERT_TIME;
+    dates.backup = catalogInfo.backupDate.lowSeconds + CONVERT_TIME;
+    dates.access = catalogInfo.accessDate.lowSeconds + CONVERT_TIME;
+	status = to64(p_ap_encode_obj,
+					(char *) &dates,
+					sizeof (ap_dates)); 
+	if (status != noErr)
+		return status;
+	
+	/* write comment */
+	if (comlen)
+	{
+		status = to64(p_ap_encode_obj,
+					comment,
+					comlen * sizeof(char));
+	}
+	/*
+	**	Get some help information on deciding the file type.
+	*/
+    if (((FileInfo*)(&catalogInfo.finderInfo))->fileType == 'TEXT' ||
+        ((FileInfo*)(&catalogInfo.finderInfo))->fileType == 'text')
+	{
+		p_ap_encode_obj->text_file_type = true;
+	}
+	
+	return status;	
+}
+/*
+**	ap_encode_header
+**
+**		encode the file header and the resource fork.
+**
+*/
+int ap_encode_header(
+	appledouble_encode_object* p_ap_encode_obj, 
+	bool    firstime)
+{
+	char   	rd_buff[256];
+    FSIORefNum fileId;
+	OSErr	retval = noErr;
+	int    	status;
+    ByteCount inCount;
+	
+	if (firstime)
+	{
+    PL_strcpy(rd_buff, 
+			"Content-Type: application/applefile\r\nContent-Transfer-Encoding: base64\r\n\r\n");
+		status = write_stream(p_ap_encode_obj, (const char*)rd_buff, strlen(rd_buff));
+		if (status != noErr)
+			return status;
+			
+		status = ap_encode_file_infor(p_ap_encode_obj); 
+		if (status != noErr)
+			return status;
+		
+		/*
+		** preparing to encode the resource fork.
+		*/
+        nsCOMPtr <nsIFile> myFile;
+        NS_NewNativeLocalFile(nsDependentCString(p_ap_encode_obj->fname), true, getter_AddRefs(myFile));
+        if (!myFile)
+            return errFileOpen;
+
+        FSRef ref;
+        nsCOMPtr <nsILocalFileMac> macFile = do_QueryInterface(myFile);
+        if (NS_FAILED(macFile->GetFSRef(&ref)))
+            return errFileOpen;
+
+        HFSUniStr255 forkName;
+        ::FSGetResourceForkName(&forkName);
+        retval = ::FSOpenFork(&ref, forkName.length, forkName.unicode, fsRdPerm, &p_ap_encode_obj->fileId);
+        if (retval != noErr)
+            return retval;
+	}
+
+	fileId = p_ap_encode_obj->fileId;
+	while (retval == noErr)
+	{
+		if (BUFF_LEFT(p_ap_encode_obj) < 400)
+			break;
+			
+        inCount = 0;
+        retval = ::FSReadFork(fileId, fsAtMark, 0, 256, rd_buff, &inCount);
+		if (inCount)
+		{
+			status = to64(p_ap_encode_obj,
+							rd_buff,
+							inCount);
+			if (status != noErr)
+				return status;
+		}
+	}
+	
+	if (retval == eofErr)
+	{
+        ::FSCloseFork(fileId);
+        p_ap_encode_obj->fileId = 0;
+
+		status = finish64(p_ap_encode_obj);
+		if (status != noErr)
+			return status;
+		
+		/*
+		** write out the boundary 
+		*/
+		PR_snprintf(rd_buff, sizeof(rd_buff),
+						CRLF "--%s" CRLF, 
+						p_ap_encode_obj->boundary);
+					
+		status = write_stream(p_ap_encode_obj, (const char*)rd_buff, strlen(rd_buff));
+		if (status == noErr)
+			status = errDone;
+	}
+	return status;
+}
+
+#if 0
+// This is unused for now and Clang complains about that is it is ifdefed out
+static void replace(char *p, int len, char frm, char to)
+{
+	for (; len > 0; len--, p++)
+		if (*p == frm)	*p = to;
+}
+#endif
+
+/* Description of the various file formats and their magic numbers 		*/
+struct magic
+{
+    const char *name;			/* Name of the file format */
+    const char *num;			/* The magic number */
+    int        len;			/* Length (0 means strlen(magicnum)) */
+};
+
+/* The magic numbers of the file formats we know about */
+static struct magic magic[] =
+{
+    { "image/gif", 	"GIF", 			  0 },
+    { "image/jpeg", "\377\330\377",   0 },
+    { "video/mpeg", "\0\0\001\263",	  4 },
+    { "application/postscript", "%!", 0 },
+};
+static int num_magic = MOZ_ARRAY_LENGTH(magic);
+
+static const char *text_type    = TEXT_PLAIN;					/* the text file type. */
+static const char *default_type = APPLICATION_OCTET_STREAM;
+
+
+/*
+ * Determins the format of the file "inputf".  The name
+ * of the file format (or NULL on error) is returned.
+ */
+static const char *magic_look(char *inbuff, int numread)
+{
+    int i, j;
+
+	for (i=0; i<num_magic; i++) 
+	{
+	   	if (magic[i].len == 0) 
+	   		magic[i].len = strlen(magic[i].num);
+	}
+
+    for (i=0; i<num_magic; i++) 
+    {
+		if (numread >= magic[i].len) 
+		{
+	    	for (j=0; j<magic[i].len; j++) 
+	    	{
+				if (inbuff[j] != magic[i].num[j]) break;
+	    	}
+	    	
+	    	if (j == magic[i].len) 
+	    		return magic[i].name;
+		}
+    }
+
+    return default_type;
+}
+/*
+**	ap_encode_data
+**
+**	---------------
+**
+**		encode on the data fork.
+**
+*/
+int ap_encode_data(
+	appledouble_encode_object* p_ap_encode_obj, 
+	bool firstime)
+{
+	char   		rd_buff[256];
+    FSIORefNum fileId;
+	OSErr		retval = noErr;
+    ByteCount in_count;
+	int			status;
+	
+	if (firstime)
+	{	
+		const char* magic_type;
+			
+		/*
+		** preparing to encode the data fork.
+		*/
+        nsCOMPtr <nsIFile> resFile;
+        NS_NewNativeLocalFile(nsDependentCString(p_ap_encode_obj->fname), true,
+                              getter_AddRefs(resFile));
+        if (!resFile)
+            return errFileOpen;
+
+        FSRef ref;
+        nsCOMPtr <nsILocalFileMac> macFile = do_QueryInterface(resFile);
+        if (NS_FAILED(macFile->GetFSRef(&ref)))
+            return errFileOpen;
+
+        HFSUniStr255 forkName;
+        ::FSGetDataForkName(&forkName);
+        retval = ::FSOpenFork(&ref, forkName.length, forkName.unicode, fsRdPerm, &fileId);
+        if (retval != noErr)
+            return retval;
+
+		p_ap_encode_obj->fileId = fileId;
+			
+		
+		if (!p_ap_encode_obj->text_file_type)
+		{	
+      /*
+      **	do a smart check for the file type.
+      */
+      in_count = 0;
+      retval = ::FSReadFork(fileId, fsFromStart, 0, 256, rd_buff, &in_count);
+      magic_type = magic_look(rd_buff, in_count);
+      
+      /* don't forget to rewind the index to start point. */ 
+      ::FSSetForkPosition(fileId, fsFromStart, 0);
+      /* and reset retVal just in case... */
+      if (retval == eofErr)
+        retval = noErr;
+		}
+		else
+		{
+			magic_type = text_type;		/* we already know it is a text type.	*/
+		}
+
+		/*
+		**	the data portion header information.
+		*/
+        nsAutoCString leafName;
+        resFile->GetNativeLeafName(leafName);
+		PR_snprintf(rd_buff, sizeof(rd_buff),
+			"Content-Type: %s; name=\"%s\"" CRLF "Content-Transfer-Encoding: base64" CRLF "Content-Disposition: inline; filename=\"%s\"" CRLF CRLF,
+			magic_type,
+			leafName.get(),
+			leafName.get());
+			
+		status = write_stream(p_ap_encode_obj, (const char*)rd_buff, strlen(rd_buff));
+		if (status != noErr)
+			return status;
+	}
+	
+	while (retval == noErr)
+	{
+		if (BUFF_LEFT(p_ap_encode_obj) < 400)
+			break;
+			
+        in_count = 0;
+        retval = ::FSReadFork(p_ap_encode_obj->fileId, fsAtMark, 0, 256, rd_buff, &in_count);
+		if (in_count)
+		{
+#if 0
+/*			replace(rd_buff, in_count, '\r', '\n');	 						*/
+#endif
+/* ** may be need to do character set conversion here for localization.	**  */		
+			status = to64(p_ap_encode_obj,
+						rd_buff,
+						in_count);
+			if (status != noErr)
+				return status;
+		}
+	}
+	
+	if (retval == eofErr)
+	{
+        ::FSCloseFork(p_ap_encode_obj->fileId);
+        p_ap_encode_obj->fileId = 0;
+
+		status = finish64(p_ap_encode_obj);
+		if (status != noErr)
+			return status;
+		
+		/* write out the boundary 	*/
+		
+		PR_snprintf(rd_buff, sizeof(rd_buff),
+						CRLF "--%s--" CRLF CRLF, 
+						p_ap_encode_obj->boundary);
+	
+		status = write_stream(p_ap_encode_obj, (const char*)rd_buff, strlen(rd_buff));
+	
+		if (status == noErr)				
+			status = errDone;
+	}
+	return status;
+}
+
+static char basis_64[] =
+   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/* 
+**	convert the stream in the inbuff to 64 format and put it in the out buff.
+**  To make the life easier, the caller will responcable of the cheking of the outbuff's bundary.
+*/
+static int 
+to64(appledouble_encode_object* p_ap_encode_obj, 
+	char	*p, 
+	int 	in_size) 
+{
+	int 	status;
+    int c1, c2, c3, ct;
+    unsigned char *inbuff = (unsigned char*)p;
+    
+	ct = p_ap_encode_obj->ct;			/* the char count left last time. */
+	
+	/*
+	**	 resume the left state of the last conversion.
+	*/
+	switch (p_ap_encode_obj->state64)
+	{
+		case 0:
+			p_ap_encode_obj->c1 = c1 = *inbuff ++;
+			if (--in_size <= 0)
+			{
+				p_ap_encode_obj->state64 = 1;
+				return noErr;
+			}
+			p_ap_encode_obj->c2 = c2 = *inbuff ++;
+			if (--in_size <= 0)
+			{
+				p_ap_encode_obj->state64 = 2;
+				return noErr;
+			}
+			c3 = *inbuff ++;		--in_size;
+			break;
+		case 1:
+			c1 = p_ap_encode_obj->c1;
+			p_ap_encode_obj->c2 = c2 = *inbuff ++;
+			if (--in_size <= 0)
+			{
+				p_ap_encode_obj->state64 = 2;
+				return noErr;
+			}
+			c3 = *inbuff ++;		--in_size;
+			break;
+		case 2:
+			c1 = p_ap_encode_obj->c1;
+			c2 = p_ap_encode_obj->c2;
+			c3 = *inbuff ++;		--in_size;
+			break;
+	}
+	
+    while (in_size >= 0) 
+    {
+    	status = output64chunk(p_ap_encode_obj, 
+    							c1, 
+    							c2, 
+    							c3, 
+    							0);
+    	if (status != noErr)
+    		return status;
+    		
+    	ct += 4;
+        if (ct > 71) 
+        { 
+        	status = write_stream(p_ap_encode_obj, 
+        						CRLF, 
+        						2);
+        	if (status != noErr)
+        		return status;
+        		
+            ct = 0;
+        }
+
+		if (in_size <= 0)
+		{
+			p_ap_encode_obj->state64 = 0;
+			break;
+		}
+		
+		c1 = (int)*inbuff++;
+		if (--in_size <= 0)
+		{
+			p_ap_encode_obj->c1 = c1;
+			p_ap_encode_obj->state64 = 1;
+			break;
+		}
+		c2 = *inbuff++;
+		if (--in_size <= 0)
+		{
+			p_ap_encode_obj->c1 	 = c1;
+			p_ap_encode_obj->c2 	 = c2;
+			p_ap_encode_obj->state64 = 2;
+			break;
+		}
+		c3 = *inbuff++;
+		in_size--;
+    }
+    p_ap_encode_obj->ct = ct;
+    return status;
+}
+
+/*
+** clear the left base64 encodes.
+*/
+static int 
+finish64(appledouble_encode_object* p_ap_encode_obj)
+{
+	int status;
+	
+	switch (p_ap_encode_obj->state64)
+	{
+		case 0:
+			break;
+		case 1:
+			status = output64chunk(p_ap_encode_obj, 
+									p_ap_encode_obj->c1, 
+									0, 
+									0, 
+									2);
+			break;
+		case 2:
+			status = output64chunk(p_ap_encode_obj, 
+									p_ap_encode_obj->c1, 
+									p_ap_encode_obj->c2, 
+									0, 
+									1);
+			break;
+	}
+	status = write_stream(p_ap_encode_obj, CRLF, 2);
+	p_ap_encode_obj->state64 = 0;
+	p_ap_encode_obj->ct	  	 = 0;
+	return status;
+}
+
+static int output64chunk(
+	appledouble_encode_object* p_ap_encode_obj, 
+	int c1, int c2, int c3, int pads)
+{
+	char tmpstr[32];
+	char *p = tmpstr;
+	
+    *p++ = basis_64[c1>>2];
+    *p++ = basis_64[((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4)];
+    if (pads == 2) 
+    {
+        *p++ = '=';
+        *p++ = '=';
+    } 
+    else if (pads) 
+    {
+        *p++ = basis_64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
+        *p++ = '=';
+    } 
+    else 
+    {
+        *p++ = basis_64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
+        *p++ = basis_64[c3 & 0x3F];
+    }
+    return write_stream(p_ap_encode_obj, (const char*) tmpstr, p-tmpstr);
+}
diff --git a/mailnews/compose/src/nsMsgAttachment.cpp b/mailnews/compose/src/nsMsgAttachment.cpp
new file mode 100644
index 000000000..3a828c3b0
--- /dev/null
+++ b/mailnews/compose/src/nsMsgAttachment.cpp
@@ -0,0 +1,262 @@
+/* -*- 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"
+
+NS_IMPL_ISUPPORTS(nsMsgAttachment, nsIMsgAttachment)
+
+nsMsgAttachment::nsMsgAttachment()
+{
+  mTemporary = false;
+  mSendViaCloud = false;
+  mSize = -1;
+}
+
+nsMsgAttachment::~nsMsgAttachment()
+{
+  if (mTemporary && !mSendViaCloud)
+    (void)DeleteAttachment();
+}
+
+/* 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 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 nsAString &aAnnotation)
+{
+  mHtmlAnnotation = aAnnotation;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachment::GetHtmlAnnotation(nsAString &aAnnotation)
+{
+  aAnnotation = mHtmlAnnotation;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAttachment::SetCloudProviderKey(const nsACString &aCloudProviderKey)
+{
+  mCloudProviderKey = aCloudProviderKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAttachment::GetCloudProviderKey(nsACString &aCloudProviderKey)
+{
+  aCloudProviderKey = mCloudProviderKey;
+  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;
+}
+
+/* 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/mailnews/compose/src/nsMsgAttachment.h b/mailnews/compose/src/nsMsgAttachment.h
new file mode 100644
index 000000000..9f0d0a3b0
--- /dev/null
+++ b/mailnews/compose/src/nsMsgAttachment.h
@@ -0,0 +1,41 @@
+/* -*- 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 "nsStringGlue.h"
+
+class nsMsgAttachment : public nsIMsgAttachment
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGATTACHMENT
+
+  nsMsgAttachment();
+
+private:
+  virtual ~nsMsgAttachment();
+  nsresult DeleteAttachment();
+
+  nsString    mName;
+  nsCString   mUrl;
+  nsCString   mUrlCharset;
+  bool        mTemporary;
+  bool        mSendViaCloud;
+  nsCString   mCloudProviderKey;
+  nsCString   mContentLocation;
+  nsCString   mContentType;
+  nsCString   mContentTypeParam;
+  nsCString   mCharset;
+  nsCString   mMacType;
+  nsCString   mMacCreator;
+  nsString    mHtmlAnnotation;
+  int64_t     mSize;
+};
+
+
+#endif /* _nsMsgAttachment_H_ */
diff --git a/mailnews/compose/src/nsMsgAttachmentHandler.cpp b/mailnews/compose/src/nsMsgAttachmentHandler.cpp
new file mode 100644
index 000000000..f36f2e29b
--- /dev/null
+++ b/mailnews/compose/src/nsMsgAttachmentHandler.cpp
@@ -0,0 +1,1383 @@
+/* -*- 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 "nsIPrefLocalizedString.h"
+#include "nsILineInputStream.h"
+#include "nsMsgAttachmentHandler.h"
+#include "prmem.h"
+#include "nsMsgCopy.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsMsgSend.h"
+#include "nsMsgCompUtils.h"
+#include "nsMsgI18N.h"
+#include "nsURLFetcher.h"
+#include "nsMimeTypes.h"
+#include "nsMsgCompCID.h"
+#include "nsIMsgMessageService.h"
+#include "nsMsgUtils.h"
+#include "nsMsgPrompts.h"
+#include "nsTextFormatter.h"
+#include "nsIPrompt.h"
+#include "nsITextToSubURI.h"
+#include "nsIURL.h"
+#include "nsIFileURL.h"
+#include "nsNetCID.h"
+#include "nsIMimeStreamConverter.h"
+#include "nsMsgMimeCID.h"
+#include "nsNetUtil.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsComposeStrings.h"
+#include "nsIZipWriter.h"
+#include "nsIDirectoryEnumerator.h"
+#include "mozilla/Services.h"
+#include "mozilla/mailnews/MimeEncoder.h"
+#include "nsIPrincipal.h"
+
+///////////////////////////////////////////////////////////////////////////
+// Mac Specific Attachment Handling for AppleDouble Encoded Files
+///////////////////////////////////////////////////////////////////////////
+#ifdef XP_MACOSX
+
+#define AD_WORKING_BUFF_SIZE FILE_IO_BUFFER_SIZE
+
+extern void         MacGetFileType(nsIFile *fs, bool *useDefault, char **type, char **encoding);
+
+#include "nsILocalFileMac.h"
+
+/* static */
+nsresult nsSimpleZipper::Zip(nsIFile *aInputFile, nsIFile *aOutputFile)
+{
+  // create zipwriter object
+  nsresult rv;
+  nsCOMPtr<nsIZipWriter> zipWriter = do_CreateInstance("@mozilla.org/zipwriter;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  rv = zipWriter->Open(aOutputFile, PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE);
+  NS_ENSURE_SUCCESS(rv, rv); 
+  
+  rv = AddToZip(zipWriter, aInputFile, EmptyCString());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // we're done.
+  zipWriter->Close();
+  return rv;
+}
+
+/* static */
+nsresult nsSimpleZipper::AddToZip(nsIZipWriter *aZipWriter, 
+                                  nsIFile *aFile,
+                                  const nsACString &aPath)
+{
+  // find out the path this file/dir should have in the zip
+  nsCString leafName;
+  aFile->GetNativeLeafName(leafName);
+  nsCString currentPath(aPath);
+  currentPath += leafName;
+    
+  bool isDirectory;
+  aFile->IsDirectory(&isDirectory);
+  // append slash for a directory entry
+  if (isDirectory)
+    currentPath.Append('/');
+  
+  // add the file or directory entry to the zip
+  nsresult rv = aZipWriter->AddEntryFile(currentPath, nsIZipWriter::COMPRESSION_DEFAULT, aFile, false);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  // if it's a directory, add all its contents too
+  if (isDirectory) {
+    nsCOMPtr<nsISimpleEnumerator> e;
+    nsresult rv = aFile->GetDirectoryEntries(getter_AddRefs(e));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIDirectoryEnumerator> dirEnumerator = do_QueryInterface(e, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIFile> currentFile;
+    while (NS_SUCCEEDED(dirEnumerator->GetNextFile(getter_AddRefs(currentFile))) && currentFile) {
+      rv = AddToZip(aZipWriter, currentFile, currentPath);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  
+  return NS_OK;
+}
+#endif // XP_MACOSX
+
+//
+// Class implementation...
+//
+nsMsgAttachmentHandler::nsMsgAttachmentHandler() :
+  mRequest(nullptr),
+  mCompFields(nullptr),   // Message composition fields for the sender
+  m_bogus_attachment(false),
+  m_done(false),
+  m_already_encoded_p(false),
+  m_decrypted_p(false),
+  mDeleteFile(false),
+  mMHTMLPart(false),
+  mPartUserOmissionOverride(false),
+  mMainBody(false),
+  mSendViaCloud(false),
+  mNodeIndex(-1),
+  // For analyzing the attachment file...
+  m_size(0),
+  m_unprintable_count(0),
+  m_highbit_count(0),
+  m_ctl_count(0),
+  m_null_count(0),
+  m_have_cr(0), 
+  m_have_lf(0), 
+  m_have_crlf(0),
+  m_prev_char_was_cr(false),
+  m_current_column(0),
+  m_max_column(0),
+  m_lines(0),
+  m_file_analyzed(false),
+
+  // Mime
+  m_encoder(nullptr)
+{
+}
+
+nsMsgAttachmentHandler::~nsMsgAttachmentHandler()
+{
+  if (mTmpFile && mDeleteFile)
+    mTmpFile->Remove(false);
+
+  if (mOutFile)
+    mOutFile->Close();
+
+  CleanupTempFile();
+}
+
+NS_IMPL_ISUPPORTS(nsMsgAttachmentHandler, nsIMsgAttachmentHandler)
+
+// nsIMsgAttachmentHandler implementation.
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetType(nsACString& aType)
+{
+  aType.Assign(m_type);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetUri(nsACString& aUri)
+{
+  nsAutoCString turl;
+  if (!mURL)
+  {
+    if (!m_uri.IsEmpty())
+      turl = m_uri;
+  }
+  else
+  {
+    nsresult rv = mURL->GetSpec(turl);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  aUri.Assign(turl);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetTmpFile(nsIFile **aTmpFile)
+{
+  NS_ENSURE_ARG_POINTER(aTmpFile);
+  if (!mTmpFile)
+    return NS_ERROR_FAILURE;
+  NS_ADDREF(*aTmpFile = mTmpFile);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetName(nsACString& aName)
+{
+  aName.Assign(m_realName);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetSize(uint32_t *aSize)
+{
+  NS_ENSURE_ARG_POINTER(aSize);
+  *aSize = m_size;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetContentId(nsACString& aContentId)
+{
+  aContentId.Assign(m_contentId);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetSendViaCloud(bool* aSendViaCloud)
+{
+  NS_ENSURE_ARG_POINTER(aSendViaCloud);
+  *aSendViaCloud = mSendViaCloud;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetCharset(nsACString& aCharset)
+{
+  aCharset.Assign(m_charset);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetEncoding(nsACString& aEncoding)
+{
+  aEncoding.Assign(m_encoding);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAttachmentHandler::GetAlreadyEncoded(bool* aAlreadyEncoded)
+{
+  NS_ENSURE_ARG_POINTER(aAlreadyEncoded);
+  *aAlreadyEncoded = m_already_encoded_p;
+  return NS_OK;
+}
+
+// Local methods.
+
+void
+nsMsgAttachmentHandler::CleanupTempFile()
+{
+#ifdef XP_MACOSX
+  if (mEncodedWorkingFile) {
+    mEncodedWorkingFile->Remove(false);
+    mEncodedWorkingFile = nullptr;
+  }
+#endif // XP_MACOSX
+}
+
+void
+nsMsgAttachmentHandler::AnalyzeDataChunk(const char *chunk, int32_t length)
+{
+  unsigned char *s = (unsigned char *) chunk;
+  unsigned char *end = s + length;
+  for (; s < end; s++)
+  {
+    if (*s > 126)
+    {
+      m_highbit_count++;
+      m_unprintable_count++;
+    }
+    else if (*s < ' ' && *s != '\t' && *s != '\r' && *s != '\n')
+    {
+      m_unprintable_count++;
+      m_ctl_count++;
+      if (*s == 0)
+        m_null_count++;
+    }
+
+    if (*s == '\r' || *s == '\n')
+    {
+      if (*s == '\r')
+      {
+        if (m_prev_char_was_cr)
+          m_have_cr = 1;
+        else
+          m_prev_char_was_cr = true;
+      }
+      else
+      {
+        if (m_prev_char_was_cr)
+        {
+          if (m_current_column == 0)
+          {
+            m_have_crlf = 1;
+            m_lines--;
+          }
+          else
+            m_have_cr = m_have_lf = 1;
+          m_prev_char_was_cr = false;
+        }
+        else
+          m_have_lf = 1;
+      }
+      if (m_max_column < m_current_column)
+        m_max_column = m_current_column;
+      m_current_column = 0;
+      m_lines++;
+    }
+    else
+    {
+      m_current_column++;
+    }
+  }
+  // Check one last time for the last line. This is also important if there
+  // is only one line that doesn't terminate in \n.
+  if (m_max_column < m_current_column)
+    m_max_column = m_current_column;
+}
+
+void
+nsMsgAttachmentHandler::AnalyzeSnarfedFile(void)
+{
+  char chunk[1024];
+  uint32_t numRead = 0;
+
+  if (m_file_analyzed)
+    return;
+
+  if (mTmpFile)
+  {
+    int64_t fileSize;
+    mTmpFile->GetFileSize(&fileSize);
+    m_size = (uint32_t) fileSize;
+    nsCOMPtr <nsIInputStream> inputFile;
+    nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputFile), mTmpFile);
+    if (NS_FAILED(rv))
+      return;
+    {
+      do
+      {
+        rv = inputFile->Read(chunk, sizeof(chunk), &numRead);
+        if (numRead)
+          AnalyzeDataChunk(chunk, numRead);
+      }
+      while (numRead && NS_SUCCEEDED(rv));
+      if (m_prev_char_was_cr)
+        m_have_cr = 1;
+
+      inputFile->Close();
+      m_file_analyzed = true;
+    }
+  }
+}
+
+//
+// Given a content-type and some info about the contents of the document,
+// decide what encoding it should have.
+//
+nsresult
+nsMsgAttachmentHandler::PickEncoding(const char *charset, nsIMsgSend *mime_delivery_state)
+{
+  nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+
+  bool needsB64 = false;
+  bool forceB64 = false;
+  bool isUsingQP = false;
+
+  if (mSendViaCloud)
+  {
+    m_encoding = ENCODING_7BIT;
+    return NS_OK;
+  }
+  if (m_already_encoded_p)
+    goto DONE;
+
+  AnalyzeSnarfedFile();
+
+  // Allow users to override our percentage-wise guess on whether
+  // the file is text or binary.
+  if (pPrefBranch)
+    pPrefBranch->GetBoolPref ("mail.file_attach_binary", &forceB64);
+
+  // 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 (!mMainBody &&
+      (forceB64 || mime_type_requires_b64_p(m_type.get()) ||
+                   m_have_cr + m_have_lf + m_have_crlf != 1) &&
+      !m_type.LowerCaseEqualsLiteral(MESSAGE_RFC822))
+  {
+    needsB64 = true;
+  }
+  else
+  {
+    // Otherwise, we need to pick an encoding based on the contents of the
+    // document.
+    bool encode_p;
+    bool force_p = false;
+
+    // Force quoted-printable if the sender does not allow conversion to 7bit.
+    if (mCompFields) {
+      if (mCompFields->GetForceMsgEncoding())
+        force_p = true;
+    } else if (mime_delivery_state) {
+      if (((nsMsgComposeAndSend *)mime_delivery_state)->mCompFields->GetForceMsgEncoding()) {
+        force_p = true;
+      }
+    }
+
+    if (force_p || (m_max_column > LINELENGTH_ENCODING_THRESHOLD)) {
+      encode_p = true;
+    } else if (UseQuotedPrintable() && m_unprintable_count) {
+      encode_p = true;
+    } else if (m_null_count) {
+      // If there are nulls, we must always encode, because sendmail will
+      // blow up.
+      encode_p = true;
+    } else {
+      encode_p = false;
+    }
+
+    // MIME requires a special case that these types never be encoded.
+    if (StringBeginsWith(m_type, NS_LITERAL_CSTRING("message"),
+                         nsCaseInsensitiveCStringComparator()) ||
+        StringBeginsWith(m_type, NS_LITERAL_CSTRING("multipart"),
+                         nsCaseInsensitiveCStringComparator()))
+    {
+      encode_p = false;
+      if (m_desiredType.LowerCaseEqualsLiteral(TEXT_PLAIN))
+        m_desiredType.Truncate();
+    }
+
+    // If the Mail charset is multibyte, we force it to use Base64 for attachments.
+    if ((!mMainBody && charset && nsMsgI18Nmultibyte_charset(charset)) &&
+        (m_type.LowerCaseEqualsLiteral(TEXT_HTML) ||
+         m_type.LowerCaseEqualsLiteral(TEXT_MDL) ||
+         m_type.LowerCaseEqualsLiteral(TEXT_PLAIN) ||
+         m_type.LowerCaseEqualsLiteral(TEXT_RICHTEXT) ||
+         m_type.LowerCaseEqualsLiteral(TEXT_ENRICHED) ||
+         m_type.LowerCaseEqualsLiteral(TEXT_VCARD) ||
+         m_type.LowerCaseEqualsLiteral(APPLICATION_DIRECTORY) || /* text/x-vcard synonym */
+         m_type.LowerCaseEqualsLiteral(TEXT_CSS) ||
+         m_type.LowerCaseEqualsLiteral(TEXT_JSSS))) {
+      needsB64 = true;
+    } else if (charset && nsMsgI18Nstateful_charset(charset)) {
+      m_encoding = ENCODING_7BIT;
+    } else if (encode_p &&
+      m_unprintable_count > (m_size / 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 (encode_p) {
+      m_encoding = ENCODING_QUOTED_PRINTABLE;
+      isUsingQP = true;
+    } else if (m_highbit_count > 0) {
+      m_encoding = ENCODING_8BIT;
+    } else {
+      m_encoding = ENCODING_7BIT;
+    }
+  }
+
+  // Always base64 binary data.
+  if (needsB64)
+    m_encoding = 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 (!m_type.LowerCaseEqualsLiteral(MESSAGE_RFC822) &&
+      m_max_column > LINELENGTH_ENCODING_THRESHOLD && !isUsingQP)
+    m_encoding = ENCODING_BASE64;
+
+  // Now that we've picked an encoding, initialize the filter.
+  NS_ASSERTION(!m_encoder, "not-null m_encoder");
+  if (m_encoding.LowerCaseEqualsLiteral(ENCODING_BASE64))
+  {
+    m_encoder = MimeEncoder::GetBase64Encoder(mime_encoder_output_fn,
+      mime_delivery_state);
+  }
+  else if (m_encoding.LowerCaseEqualsLiteral(ENCODING_QUOTED_PRINTABLE))
+  {
+    m_encoder = MimeEncoder::GetQPEncoder(mime_encoder_output_fn,
+      mime_delivery_state);
+  }
+  else
+  {
+    m_encoder = nullptr;
+  }
+
+  /* Do some cleanup for documents with unknown content type.
+    There are two issues: how they look to MIME users, and how they look to
+    non-MIME users.
+
+      If the user attaches a "README" file, which has unknown type because it
+      has no extension, we still need to send it with no encoding, so that it
+      is readable to non-MIME users.
+
+        But if the user attaches some random binary file, then base64 encoding
+        will have been chosen for it (above), and in this case, it won't be
+        immediately readable by non-MIME users.  However, if we type it as
+        text/plain instead of application/octet-stream, it will show up inline
+        in a MIME viewer, which will probably be ugly, and may possibly have
+        bad charset things happen as well.
+
+          So, the heuristic we use is, if the type is unknown, then the type is
+          set to application/octet-stream for data which needs base64 (binary data)
+          and is set to text/plain for data which didn't need base64 (unencoded or
+          lightly encoded data.)
+  */
+DONE:
+  if (m_type.IsEmpty() || m_type.LowerCaseEqualsLiteral(UNKNOWN_CONTENT_TYPE))
+  {
+    if (m_already_encoded_p)
+      m_type = APPLICATION_OCTET_STREAM;
+    else if (m_encoding.LowerCaseEqualsLiteral(ENCODING_BASE64) ||
+             m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE))
+      m_type = APPLICATION_OCTET_STREAM;
+    else
+      m_type = TEXT_PLAIN;
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgAttachmentHandler::PickCharset()
+{
+  if (!m_charset.IsEmpty() || !m_type.LowerCaseEqualsLiteral(TEXT_PLAIN))
+    return NS_OK;
+
+  nsCOMPtr<nsIFile> tmpFile =
+    do_QueryInterface(mTmpFile);
+  if (!tmpFile)
+    return NS_OK;
+  
+  return MsgDetectCharsetFromFile(tmpFile, m_charset);
+}
+    
+static nsresult
+FetcherURLDoneCallback(nsresult aStatus,
+                       const nsACString &aContentType,
+                       const nsACString &aCharset,
+                       int32_t totalSize,
+                       const char16_t* aMsg, void *tagData)
+{
+  nsMsgAttachmentHandler *ma = (nsMsgAttachmentHandler *) tagData;
+  NS_ASSERTION(ma != nullptr, "not-null mime attachment");
+
+  if (ma != nullptr)
+  {
+    ma->m_size = totalSize;
+    if (!aContentType.IsEmpty())
+    {
+#ifdef XP_MACOSX
+      //Do not change the type if we are dealing with an encoded (e.g., appledouble or zip) file
+      if (!ma->mEncodedWorkingFile)
+#else
+        // can't send appledouble on non-macs
+      if (!aContentType.EqualsLiteral("multipart/appledouble"))
+#endif
+        ma->m_type = aContentType;
+    }
+
+    if (!aCharset.IsEmpty())
+      ma->m_charset = aCharset;
+
+    return ma->UrlExit(aStatus, aMsg);
+  }
+  else
+    return NS_OK;
+}
+
+nsresult
+nsMsgAttachmentHandler::SnarfMsgAttachment(nsMsgCompFields *compFields)
+{
+  nsresult rv = NS_ERROR_INVALID_ARG;
+  nsCOMPtr <nsIMsgMessageService> messageService;
+
+  if (m_uri.Find("-message:", CaseInsensitiveCompare) != -1)
+  {
+    nsCOMPtr <nsIFile> tmpFile;
+    rv = nsMsgCreateTempFile("nsmail.tmp", getter_AddRefs(tmpFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+    mTmpFile = do_QueryInterface(tmpFile);
+    mDeleteFile = true;
+    mCompFields = compFields;
+    m_type = MESSAGE_RFC822;
+    m_overrideType = MESSAGE_RFC822;
+    if (!mTmpFile)
+    {
+      rv = NS_ERROR_FAILURE;
+      goto done;
+    }
+
+    rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mOutFile), mTmpFile, -1, 00600);
+    if (NS_FAILED(rv) || !mOutFile)
+    {
+      if (m_mime_delivery_state)
+      {
+        nsCOMPtr<nsIMsgSendReport> sendReport;
+        m_mime_delivery_state->GetSendReport(getter_AddRefs(sendReport));
+        if (sendReport)
+        {
+          nsAutoString error_msg;
+          nsMsgBuildMessageWithTmpFile(mTmpFile, error_msg);
+          sendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), false);
+        }
+      }
+      rv =  NS_MSG_UNABLE_TO_OPEN_TMP_FILE;
+      goto done;
+    }
+
+    nsCOMPtr<nsIURLFetcher> fetcher = do_CreateInstance(NS_URLFETCHER_CONTRACTID, &rv);
+    if (NS_FAILED(rv) || !fetcher)
+    {
+      if (NS_SUCCEEDED(rv))
+        rv =  NS_ERROR_UNEXPECTED;
+      goto done;
+    }
+
+    rv = fetcher->Initialize(mTmpFile, mOutFile, FetcherURLDoneCallback, this);
+    rv = GetMessageServiceFromURI(m_uri, getter_AddRefs(messageService));
+    if (NS_SUCCEEDED(rv) && messageService)
+    {
+      nsAutoCString uri(m_uri);
+      uri += (uri.FindChar('?') == kNotFound) ? '?' : '&';
+      uri.Append("fetchCompleteMessage=true");
+      nsCOMPtr<nsIStreamListener> strListener;
+      fetcher->QueryInterface(NS_GET_IID(nsIStreamListener), getter_AddRefs(strListener));
+
+      // initialize a new stream converter, that uses the strListener as its input
+      // obtain the input stream listener from the new converter,
+      // and pass the converter's input stream listener to DisplayMessage
+
+      m_mime_parser = do_CreateInstance(NS_MAILNEWS_MIME_STREAM_CONVERTER_CONTRACTID, &rv);
+      if (NS_FAILED(rv))
+        goto done;
+
+      // Set us as the output stream for HTML data from libmime...
+      nsCOMPtr<nsIMimeStreamConverter> mimeConverter = do_QueryInterface(m_mime_parser);
+      if (mimeConverter)
+      {
+        mimeConverter->SetMimeOutputType(nsMimeOutput::nsMimeMessageDecrypt);
+        mimeConverter->SetForwardInline(false);
+        mimeConverter->SetIdentity(nullptr);
+        mimeConverter->SetOriginalMsgURI(nullptr);
+      }
+
+      nsCOMPtr<nsIStreamListener> convertedListener = do_QueryInterface(m_mime_parser, &rv);
+      if (NS_FAILED(rv))
+        goto done;
+
+      nsCOMPtr<nsIURI> aURL;
+      rv = messageService->GetUrlForUri(uri.get(), getter_AddRefs(aURL), nullptr);
+      if (NS_FAILED(rv))
+        goto done;
+
+
+      nsCOMPtr<nsIPrincipal> nullPrincipal =
+        do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
+      NS_ASSERTION(NS_SUCCEEDED(rv), "CreateInstance of nullprincipal failed.");
+      if (NS_FAILED(rv))
+        goto done;
+
+      rv = NS_NewInputStreamChannel(getter_AddRefs(m_converter_channel),
+                                    aURL,
+                                    nullptr,
+                                    nullPrincipal,
+                                    nsILoadInfo::SEC_NORMAL,
+                                    nsIContentPolicy::TYPE_OTHER);
+      if (NS_FAILED(rv))
+        goto done;
+
+      rv = m_mime_parser->AsyncConvertData("message/rfc822", "message/rfc822",
+                                           strListener, m_converter_channel);
+      if (NS_FAILED(rv))
+        goto done;
+
+      nsCOMPtr<nsIURI> dummyNull;
+      rv = messageService->DisplayMessage(uri.get(), convertedListener, nullptr, nullptr, nullptr,
+                                          getter_AddRefs(dummyNull));
+    }
+  }
+done:
+  if (NS_FAILED(rv))
+  {
+      if (mOutFile)
+      {
+        mOutFile->Close();
+        mOutFile = nullptr;
+      }
+
+      if (mTmpFile)
+      {
+        mTmpFile->Remove(false);
+        mTmpFile = nullptr;
+      }
+  }
+
+  return rv;
+}
+
+#ifdef XP_MACOSX
+bool nsMsgAttachmentHandler::HasResourceFork(FSRef *fsRef)
+{
+  FSCatalogInfo catalogInfo;
+  OSErr err = FSGetCatalogInfo(fsRef, kFSCatInfoDataSizes + kFSCatInfoRsrcSizes, &catalogInfo, nullptr, nullptr, nullptr);
+  return (err == noErr && catalogInfo.rsrcLogicalSize != 0);
+}
+#endif
+
+nsresult
+nsMsgAttachmentHandler::SnarfAttachment(nsMsgCompFields *compFields)
+{
+  NS_ASSERTION (! m_done, "Already done");
+
+  if (!mURL)
+    return SnarfMsgAttachment(compFields);
+
+  mCompFields = compFields;
+
+  // First, get as file spec and create the stream for the
+  // temp file where we will save this data
+  nsCOMPtr <nsIFile> tmpFile;
+  nsresult rv = nsMsgCreateTempFile("nsmail.tmp", getter_AddRefs(tmpFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  mTmpFile = do_QueryInterface(tmpFile);
+  mDeleteFile = true;
+
+  rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mOutFile), mTmpFile, -1, 00600);
+  if (NS_FAILED(rv) || !mOutFile)
+  {
+    if (m_mime_delivery_state)
+    {
+      nsCOMPtr<nsIMsgSendReport> sendReport;
+      m_mime_delivery_state->GetSendReport(getter_AddRefs(sendReport));
+      if (sendReport)
+      {
+        nsAutoString error_msg;
+        nsMsgBuildMessageWithTmpFile(mTmpFile, error_msg);
+        sendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), false);
+      }
+    }
+    mTmpFile->Remove(false);
+    mTmpFile = nullptr;
+    return NS_MSG_UNABLE_TO_OPEN_TMP_FILE;
+  }
+
+  nsCString sourceURISpec;
+  rv = mURL->GetSpec(sourceURISpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+#ifdef XP_MACOSX
+  if (!m_bogus_attachment && StringBeginsWith(sourceURISpec, NS_LITERAL_CSTRING("file://")))
+  {
+    // Unescape the path (i.e. un-URLify it) before making a FSSpec
+    nsAutoCString filePath;
+    filePath.Adopt(nsMsgGetLocalFileFromURL(sourceURISpec.get()));
+    nsAutoCString unescapedFilePath;
+    MsgUnescapeString(filePath, 0, unescapedFilePath);
+
+    nsCOMPtr<nsIFile> sourceFile;
+    NS_NewNativeLocalFile(unescapedFilePath, true, getter_AddRefs(sourceFile));
+    if (!sourceFile)
+      return NS_ERROR_FAILURE;
+      
+    // check if it is a bundle. if it is, we'll zip it. 
+    // if not, we'll apple encode it (applesingle or appledouble)
+    nsCOMPtr<nsILocalFileMac> macFile(do_QueryInterface(sourceFile));
+    bool isPackage;
+    macFile->IsPackage(&isPackage);
+    if (isPackage)
+      rv = ConvertToZipFile(macFile);
+    else
+      rv = ConvertToAppleEncoding(sourceURISpec, unescapedFilePath, macFile);
+    
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+#endif /* XP_MACOSX */
+
+  //
+  // Ok, here we are, we need to fire the URL off and get the data
+  // in the temp file
+  //
+  // Create a fetcher for the URL attachment...
+  
+  nsCOMPtr<nsIURLFetcher> fetcher = do_CreateInstance(NS_URLFETCHER_CONTRACTID, &rv);
+  if (NS_FAILED(rv) || !fetcher)
+  {
+    if (NS_SUCCEEDED(rv))
+      return NS_ERROR_UNEXPECTED;
+    else
+      return rv;
+  }
+
+  return fetcher->FireURLRequest(mURL, mTmpFile, mOutFile, FetcherURLDoneCallback, this);
+}
+
+#ifdef XP_MACOSX
+nsresult
+nsMsgAttachmentHandler::ConvertToZipFile(nsILocalFileMac *aSourceFile)
+{
+  // append ".zip" to the real file name
+  nsAutoCString zippedName;
+  nsresult rv = aSourceFile->GetNativeLeafName(zippedName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  zippedName.AppendLiteral(".zip");
+
+  // create a temporary file that we'll work on
+  nsCOMPtr <nsIFile> tmpFile;
+  rv = nsMsgCreateTempFile(zippedName.get(), getter_AddRefs(tmpFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  mEncodedWorkingFile = do_QueryInterface(tmpFile);
+
+  // point our URL at the zipped temp file
+  NS_NewFileURI(getter_AddRefs(mURL), mEncodedWorkingFile);
+
+  // zip it!
+  rv = nsSimpleZipper::Zip(aSourceFile, mEncodedWorkingFile);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // set some metadata for this attachment, that will affect the MIME headers.
+  m_type = APPLICATION_ZIP;
+  m_realName = zippedName.get();
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgAttachmentHandler::ConvertToAppleEncoding(const nsCString &aFileURI, 
+                                               const nsCString &aFilePath, 
+                                               nsILocalFileMac *aSourceFile)
+{
+  // convert the apple file to AppleDouble first, and then patch the
+  // address in the url.
+  
+  //We need to retrieve the file type and creator...
+
+  char fileInfo[32];
+  OSType type, creator;
+
+  nsresult rv = aSourceFile->GetFileType(&type);
+  if (NS_FAILED(rv))
+    return rv;
+  PR_snprintf(fileInfo, sizeof(fileInfo), "%X", type);
+  m_xMacType = fileInfo;
+
+  rv = aSourceFile->GetFileCreator(&creator);
+  if (NS_FAILED(rv))
+    return rv;
+  PR_snprintf(fileInfo, sizeof(fileInfo), "%X", creator);
+  m_xMacCreator = fileInfo;
+
+  FSRef fsRef;
+  aSourceFile->GetFSRef(&fsRef);
+  bool sendResourceFork = HasResourceFork(&fsRef);
+
+  // if we have a resource fork, check the filename extension, maybe we don't need the resource fork!
+  if (sendResourceFork)
+  {
+    nsCOMPtr<nsIURL> fileUrl(do_CreateInstance(NS_STANDARDURL_CONTRACTID));
+    if (fileUrl)
+    {
+      rv = fileUrl->SetSpec(aFileURI);
+      if (NS_SUCCEEDED(rv))
+      {
+        nsAutoCString ext;
+        rv = fileUrl->GetFileExtension(ext);
+        if (NS_SUCCEEDED(rv) && !ext.IsEmpty())
+        {
+          sendResourceFork =
+          PL_strcasecmp(ext.get(), "TXT") &&
+          PL_strcasecmp(ext.get(), "JPG") &&
+          PL_strcasecmp(ext.get(), "GIF") &&
+          PL_strcasecmp(ext.get(), "TIF") &&
+          PL_strcasecmp(ext.get(), "HTM") &&
+          PL_strcasecmp(ext.get(), "HTML") &&
+          PL_strcasecmp(ext.get(), "ART") &&
+          PL_strcasecmp(ext.get(), "XUL") &&
+          PL_strcasecmp(ext.get(), "XML") &&
+          PL_strcasecmp(ext.get(), "CSS") &&
+          PL_strcasecmp(ext.get(), "JS");
+        }
+      }
+    }
+  }
+
+  // Only use appledouble if we aren't uuencoding.
+  if( sendResourceFork )
+  {
+    char *separator;
+
+    separator = mime_make_separator("ad");
+    if (!separator)
+      return NS_ERROR_OUT_OF_MEMORY;
+
+    nsCOMPtr <nsIFile> tmpFile;
+    nsresult rv = nsMsgCreateTempFile("appledouble", getter_AddRefs(tmpFile));
+    if (NS_SUCCEEDED(rv))
+      mEncodedWorkingFile = do_QueryInterface(tmpFile);
+    if (!mEncodedWorkingFile)
+    {
+      PR_FREEIF(separator);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    //
+    // RICHIE_MAC - ok, here's the deal, we have a file that we need
+    // to encode in appledouble encoding for the resource fork and put that
+    // into the mEncodedWorkingFile location. Then, we need to patch the new file
+    // spec into the array and send this as part of the 2 part appledouble/mime
+    // encoded mime part.
+    //
+    AppleDoubleEncodeObject     *obj = new (AppleDoubleEncodeObject);
+    if (obj == NULL)
+    {
+      mEncodedWorkingFile = nullptr;
+      PR_FREEIF(separator);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    rv = MsgGetFileStream(mEncodedWorkingFile, getter_AddRefs(obj->fileStream));
+    if (NS_FAILED(rv) || !obj->fileStream)
+    {
+      PR_FREEIF(separator);
+      delete obj;
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    char *working_buff = (char *) PR_Malloc(AD_WORKING_BUFF_SIZE);
+    if (!working_buff)
+    {
+      PR_FREEIF(separator);
+      delete obj;
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    obj->buff = working_buff;
+    obj->s_buff = AD_WORKING_BUFF_SIZE;
+
+    //
+    //  Setup all the need information on the apple double encoder.
+    //
+    ap_encode_init(&(obj->ap_encode_obj), aFilePath.get(), separator);
+
+    int32_t count;
+
+    OSErr status = noErr;
+    m_size = 0;
+    while (status == noErr)
+    {
+      status = ap_encode_next(&(obj->ap_encode_obj), obj->buff, obj->s_buff, &count);
+      if (status == noErr || status == errDone)
+      {
+        //
+        // we got the encode data, so call the next stream to write it to the disk.
+        //
+        uint32_t bytesWritten;
+        obj->fileStream->Write(obj->buff, count, &bytesWritten);
+        if (bytesWritten != (uint32_t) count)
+          status = errFileWrite;
+      }
+    }
+
+    ap_encode_end(&(obj->ap_encode_obj), (status >= 0)); // if this is true, ok, false abort
+    if (obj->fileStream)
+      obj->fileStream->Close();
+
+    PR_FREEIF(obj->buff);               /* free the working buff.   */
+    PR_FREEIF(obj);
+
+    nsCOMPtr <nsIURI> fileURI;
+    NS_NewFileURI(getter_AddRefs(fileURI), mEncodedWorkingFile);
+
+    nsCOMPtr<nsIFileURL> theFileURL = do_QueryInterface(fileURI, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    nsCString newURLSpec;
+    rv = fileURI->GetSpec(newURLSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (newURLSpec.IsEmpty())
+    {
+      PR_FREEIF(separator);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    if (NS_FAILED(nsMsgNewURL(getter_AddRefs(mURL), newURLSpec.get())))
+    {
+      PR_FREEIF(separator);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    // Now after conversion, also patch the types.
+    char        tmp[128];
+    PR_snprintf(tmp, sizeof(tmp), MULTIPART_APPLEDOUBLE ";\r\n boundary=\"%s\"", separator);
+    PR_FREEIF(separator);
+    m_type = tmp;
+  }
+  else
+  {
+    if ( sendResourceFork )
+    {
+      // For now, just do the encoding, but in the old world we would ask the
+      // user about doing this conversion
+      printf("...we could ask the user about this conversion, but for now, nahh..\n");
+    }
+
+    bool      useDefault;
+    char      *macType, *macEncoding;
+    if (m_type.IsEmpty() || m_type.LowerCaseEqualsLiteral(TEXT_PLAIN))
+    {
+# define TEXT_TYPE  0x54455854  /* the characters 'T' 'E' 'X' 'T' */
+# define text_TYPE  0x74657874  /* the characters 't' 'e' 'x' 't' */
+
+      if (type != TEXT_TYPE && type != text_TYPE)
+      {
+        MacGetFileType(aSourceFile, &useDefault, &macType, &macEncoding);
+        m_type = macType;
+      }
+    }
+    // don't bother to set the types if we failed in getting the file info.
+  }
+
+  return NS_OK;
+}
+#endif // XP_MACOSX
+
+nsresult
+nsMsgAttachmentHandler::LoadDataFromFile(nsIFile *file, nsString &sigData, bool charsetConversion)
+{
+  int32_t       readSize;
+  char          *readBuf;
+
+  nsCOMPtr <nsIInputStream> inputFile;
+  nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputFile), file);
+  if (NS_FAILED(rv))
+    return NS_MSG_ERROR_WRITING_FILE;
+
+  int64_t fileSize;
+  file->GetFileSize(&fileSize);
+  readSize = (uint32_t) fileSize;
+
+  readBuf = (char *)PR_Malloc(readSize + 1);
+  if (!readBuf)
+    return NS_ERROR_OUT_OF_MEMORY;
+  memset(readBuf, 0, readSize + 1);
+
+  uint32_t bytesRead;
+  inputFile->Read(readBuf, readSize, &bytesRead);
+  inputFile->Close();
+
+  nsDependentCString cstringReadBuf(readBuf, bytesRead);
+  if (charsetConversion)
+  {
+    if (NS_FAILED(ConvertToUnicode(m_charset.get(), cstringReadBuf, sigData)))
+      CopyASCIItoUTF16(cstringReadBuf, sigData);
+  }
+  else
+    CopyASCIItoUTF16(cstringReadBuf, sigData);
+
+  PR_FREEIF(readBuf);
+  return NS_OK;
+}
+
+nsresult
+nsMsgAttachmentHandler::Abort()
+{
+  nsCOMPtr<nsIRequest> saveRequest;
+  saveRequest.swap(mRequest);
+
+  if (mTmpFile)
+  {
+    if (mDeleteFile)
+      mTmpFile->Remove(false);
+    mTmpFile = nullptr;
+  }
+
+  NS_ASSERTION(m_mime_delivery_state != nullptr, "not-null m_mime_delivery_state");
+
+  if (m_done)
+    return NS_OK;
+
+  if (saveRequest)
+    return saveRequest->Cancel(NS_ERROR_ABORT);
+  else
+    if (m_mime_delivery_state)
+    {
+      m_mime_delivery_state->SetStatus(NS_ERROR_ABORT);
+      m_mime_delivery_state->NotifyListenerOnStopSending(nullptr, NS_ERROR_ABORT, 0, nullptr);
+    }
+  return NS_OK;
+
+}
+
+nsresult
+nsMsgAttachmentHandler::UrlExit(nsresult status, const char16_t* aMsg)
+{
+  NS_ASSERTION(m_mime_delivery_state != nullptr, "not-null m_mime_delivery_state");
+
+  // Close the file, but don't delete the disk file (or the file spec.)
+  if (mOutFile)
+  {
+    mOutFile->Close();
+    mOutFile = nullptr;
+  }
+  // this silliness is because Windows nsIFile caches its file size
+  // so if an output stream writes to it, it will still return the original
+  // cached size.
+  if (mTmpFile)
+  {
+    nsCOMPtr <nsIFile> tmpFile;
+    mTmpFile->Clone(getter_AddRefs(tmpFile));
+    mTmpFile = do_QueryInterface(tmpFile);
+  }
+  mRequest = nullptr;
+
+  // First things first, we are now going to see if this is an HTML
+  // Doc and if it is, we need to see if we can determine the charset
+  // for this part by sniffing the HTML file.
+  // This is needed only when the charset is not set already.
+  // (e.g. a charset may be specified in HTTP header)
+  //
+  if (!m_type.IsEmpty() && m_charset.IsEmpty() &&
+      m_type.LowerCaseEqualsLiteral(TEXT_HTML))
+    m_charset = nsMsgI18NParseMetaCharset(mTmpFile);
+
+  nsresult mimeDeliveryStatus;
+  m_mime_delivery_state->GetStatus(&mimeDeliveryStatus);
+
+  if (mimeDeliveryStatus == NS_ERROR_ABORT)
+    status = NS_ERROR_ABORT;
+
+  // If the attachment is empty, let's call that a failure.
+  if (!m_size)
+    status = NS_ERROR_FAILURE;
+
+  if (NS_FAILED(status) && status != NS_ERROR_ABORT && NS_SUCCEEDED(mimeDeliveryStatus))
+  {
+    // At this point, we should probably ask a question to the user
+    // if we should continue without this attachment.
+    //
+    bool              keepOnGoing = true;
+    nsCString    turl;
+    nsString     msg;
+    nsresult rv;
+    nsCOMPtr<nsIStringBundleService> bundleService =
+      mozilla::services::GetStringBundleService();
+    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);
+    nsMsgDeliverMode mode = nsIMsgSend::nsMsgDeliverNow;
+    m_mime_delivery_state->GetDeliveryMode(&mode);
+    nsCString params;
+    if (!m_realName.IsEmpty())
+      params = m_realName;
+    else if (NS_SUCCEEDED(mURL->GetSpec(turl)) && !turl.IsEmpty())
+    {
+      nsAutoCString unescapedUrl;
+      MsgUnescapeString(turl, 0, unescapedUrl);
+      if (unescapedUrl.IsEmpty())
+        params = turl;
+      else
+        params = unescapedUrl;
+    }
+    else
+      params.AssignLiteral("?");
+
+    NS_ConvertUTF8toUTF16 UTF16params(params);
+    const char16_t* formatParams[] = { UTF16params.get() };
+    if (mode == nsIMsgSend::nsMsgSaveAsDraft || mode == nsIMsgSend::nsMsgSaveAsTemplate)
+      bundle->FormatStringFromName(u"failureOnObjectEmbeddingWhileSaving",
+                                   formatParams, 1, getter_Copies(msg));
+    else
+      bundle->FormatStringFromName(u"failureOnObjectEmbeddingWhileSending",
+                                   formatParams, 1, getter_Copies(msg));
+
+    nsCOMPtr<nsIPrompt> aPrompt;
+    if (m_mime_delivery_state)
+      m_mime_delivery_state->GetDefaultPrompt(getter_AddRefs(aPrompt));
+    nsMsgAskBooleanQuestionByString(aPrompt, msg.get(), &keepOnGoing);
+
+    if (keepOnGoing)
+    {
+      status = NS_OK;
+      m_bogus_attachment = true; //That will cause this attachment to be ignored.
+    }
+    else
+    {
+      status = NS_ERROR_ABORT;
+      m_mime_delivery_state->SetStatus(status);
+      nsresult ignoreMe;
+      m_mime_delivery_state->Fail(status, nullptr, &ignoreMe);
+      m_mime_delivery_state->NotifyListenerOnStopSending(nullptr, status, 0, nullptr);
+      SetMimeDeliveryState(nullptr);
+      return status;
+    }
+  }
+
+  m_done = true;
+
+  //
+  // Ok, now that we have the file here on disk, we need to see if there was
+  // a need to do conversion to plain text...if so, the magic happens here,
+  // otherwise, just move on to other attachments...
+  //
+  if (NS_SUCCEEDED(status) && !m_type.LowerCaseEqualsLiteral(TEXT_PLAIN) &&
+      m_desiredType.LowerCaseEqualsLiteral(TEXT_PLAIN))
+  {
+    //
+    // Conversion to plain text desired.
+    // Now use the converter service here to do the right
+    // thing and convert this data to plain text for us!
+    //
+    nsAutoString      conData;
+
+    if (NS_SUCCEEDED(LoadDataFromFile(mTmpFile, conData, true)))
+    {
+      bool flowed, delsp, formatted, disallowBreaks;
+      GetSerialiserFlags(m_charset.get(), &flowed, &delsp, &formatted, &disallowBreaks);
+
+      if (NS_SUCCEEDED(ConvertBufToPlainText(conData, flowed, delsp, formatted, disallowBreaks)))
+      {
+        if (mDeleteFile)
+          mTmpFile->Remove(false);
+
+        nsCOMPtr<nsIOutputStream> outputStream;
+        nsresult rv = MsgNewBufferedFileOutputStream(getter_AddRefs(outputStream), mTmpFile,
+                                                     PR_WRONLY | PR_CREATE_FILE, 00600);
+
+        if (NS_SUCCEEDED(rv))
+        {
+          nsAutoCString tData;
+          if (NS_FAILED(ConvertFromUnicode(m_charset.get(), conData, tData)))
+            LossyCopyUTF16toASCII(conData, tData);
+          if (!tData.IsEmpty())
+          {
+            uint32_t bytesWritten;
+            (void) outputStream->Write(tData.get(), tData.Length(), &bytesWritten);
+          }
+          outputStream->Close();
+          // this silliness is because Windows nsIFile caches its file size
+          // so if an output stream writes to it, it will still return the original
+          // cached size.
+          if (mTmpFile)
+          {
+            nsCOMPtr <nsIFile> tmpFile;
+            mTmpFile->Clone(getter_AddRefs(tmpFile));
+            mTmpFile = do_QueryInterface(tmpFile);
+          }
+
+        }
+      }
+    }
+
+    m_type = m_desiredType;
+    m_desiredType.Truncate();
+    m_encoding.Truncate();
+  }
+
+  uint32_t pendingAttachmentCount = 0;
+  m_mime_delivery_state->GetPendingAttachmentCount(&pendingAttachmentCount);
+  NS_ASSERTION (pendingAttachmentCount > 0, "no more pending attachment");
+
+  m_mime_delivery_state->SetPendingAttachmentCount(pendingAttachmentCount - 1);
+
+  bool processAttachmentsSynchronously = false;
+  m_mime_delivery_state->GetProcessAttachmentsSynchronously(&processAttachmentsSynchronously);
+  if (NS_SUCCEEDED(status) && processAttachmentsSynchronously)
+  {
+    /* Find the next attachment which has not yet been loaded,
+     if any, and start it going.
+     */
+    uint32_t i;
+    nsMsgAttachmentHandler *next = 0;
+    nsTArray<RefPtr<nsMsgAttachmentHandler>> *attachments;
+
+    m_mime_delivery_state->GetAttachmentHandlers(&attachments);
+
+    for (i = 0; i < attachments->Length(); i++)
+    {
+      if (!(*attachments)[i]->m_done)
+      {
+        next = (*attachments)[i];
+        //
+        // rhp: We need to get a little more understanding to failed URL
+        // requests. So, at this point if most of next is NULL, then we
+        // should just mark it fetched and move on! We probably ignored
+        // this earlier on in the send process.
+        //
+        if ( (!next->mURL) && (next->m_uri.IsEmpty()) )
+        {
+          (*attachments)[i]->m_done = true;
+          (*attachments)[i]->SetMimeDeliveryState(nullptr);
+          m_mime_delivery_state->GetPendingAttachmentCount(&pendingAttachmentCount);
+          m_mime_delivery_state->SetPendingAttachmentCount(pendingAttachmentCount - 1);
+          next->mPartUserOmissionOverride = true;
+          next = nullptr;
+          continue;
+        }
+
+        break;
+      }
+    }
+
+    if (next)
+    {
+      nsresult status = next->SnarfAttachment(mCompFields);
+      if (NS_FAILED(status))
+      {
+        nsresult ignoreMe;
+        m_mime_delivery_state->Fail(status, nullptr, &ignoreMe);
+        m_mime_delivery_state->NotifyListenerOnStopSending(nullptr, status, 0, nullptr);
+        SetMimeDeliveryState(nullptr);
+        return NS_ERROR_UNEXPECTED;
+      }
+    }
+  }
+
+  m_mime_delivery_state->GetPendingAttachmentCount(&pendingAttachmentCount);
+  if (pendingAttachmentCount == 0)
+  {
+    // If this is the last attachment, then either complete the
+    // delivery (if successful) or report the error by calling
+    // the exit routine and terminating the delivery.
+    if (NS_FAILED(status))
+    {
+      nsresult ignoreMe;
+      m_mime_delivery_state->Fail(status, aMsg, &ignoreMe);
+      m_mime_delivery_state->NotifyListenerOnStopSending(nullptr, status, aMsg, nullptr);
+      SetMimeDeliveryState(nullptr);
+      return NS_ERROR_UNEXPECTED;
+    }
+    else
+    {
+      status = m_mime_delivery_state->GatherMimeAttachments ();
+      if (NS_FAILED(status))
+      {
+        nsresult ignoreMe;
+        m_mime_delivery_state->Fail(status, aMsg, &ignoreMe);
+        m_mime_delivery_state->NotifyListenerOnStopSending(nullptr, status, aMsg, nullptr);
+        SetMimeDeliveryState(nullptr);
+        return NS_ERROR_UNEXPECTED;
+      }
+    }
+  }
+  else
+  {
+    // If this is not the last attachment, but it got an error,
+    // then report that error and continue
+    if (NS_FAILED(status))
+    {
+      nsresult ignoreMe;
+      m_mime_delivery_state->Fail(status, aMsg, &ignoreMe);
+    }
+  }
+
+  SetMimeDeliveryState(nullptr);
+  return NS_OK;
+}
+
+
+nsresult
+nsMsgAttachmentHandler::GetMimeDeliveryState(nsIMsgSend** _retval)
+{
+  NS_ENSURE_ARG(_retval);
+  *_retval = m_mime_delivery_state;
+  NS_IF_ADDREF(*_retval);
+  return NS_OK;
+}
+
+nsresult
+nsMsgAttachmentHandler::SetMimeDeliveryState(nsIMsgSend* mime_delivery_state)
+{
+  /*
+    Because setting m_mime_delivery_state to null could destroy ourself as
+    m_mime_delivery_state it's our parent, we need to protect ourself against
+    that!
+
+    This extra comptr is necessary,
+    see bug http://bugzilla.mozilla.org/show_bug.cgi?id=78967
+  */
+  nsCOMPtr<nsIMsgSend> temp = m_mime_delivery_state; /* Should lock our parent until the end of the function */
+  m_mime_delivery_state = mime_delivery_state;
+  return NS_OK;
+}
diff --git a/mailnews/compose/src/nsMsgAttachmentHandler.h b/mailnews/compose/src/nsMsgAttachmentHandler.h
new file mode 100644
index 000000000..79e526627
--- /dev/null
+++ b/mailnews/compose/src/nsMsgAttachmentHandler.h
@@ -0,0 +1,194 @@
+/* -*- 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 _nsMsgAttachmentHandler_H_
+#define _nsMsgAttachmentHandler_H_
+
+#include "nsIURL.h"
+#include "nsMsgCompFields.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsIChannel.h"
+#include "nsIMsgSend.h"
+#include "nsIFileStreams.h"
+#include "nsIStreamConverter.h"
+#include "nsAutoPtr.h"
+#include "nsIMsgAttachmentHandler.h"
+
+#ifdef XP_MACOSX
+
+#include "nsMsgAppleDouble.h"
+#include "nsILocalFileMac.h"
+
+class AppleDoubleEncodeObject
+{
+public:
+  appledouble_encode_object   ap_encode_obj;
+  char                        *buff;          // the working buff
+  int32_t                     s_buff;         // the working buff size
+  nsCOMPtr <nsIOutputStream>  fileStream;    // file to hold the encoding
+};
+
+class nsILocalFileMac;
+class nsIZipWriter;
+
+/* Simple utility class that will synchronously zip any file 
+   (or folder hierarchy) you give it. */
+class nsSimpleZipper
+{
+  public:
+    
+    // Synchronously zips the input file/folder and writes all
+    // data to the output file.
+    static nsresult Zip(nsIFile *aInputFile, nsIFile *aOutputFile);
+  
+  private:
+    
+    // Recursively adds the file or folder to aZipWriter.
+    static nsresult AddToZip(nsIZipWriter *aZipWriter,
+                             nsIFile *aFile,
+                             const nsACString &aPath);
+};
+#endif  // XP_MACOSX
+
+namespace mozilla {
+namespace mailnews {
+class MimeEncoder;
+}
+}
+
+//
+// This is a class that deals with processing remote attachments. It implements
+// an nsIStreamListener interface to deal with incoming data
+//
+class nsMsgAttachmentHandler : public nsIMsgAttachmentHandler
+{
+
+  typedef mozilla::mailnews::MimeEncoder MimeEncoder;
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIMSGATTACHMENTHANDLER
+
+  nsMsgAttachmentHandler();
+public:
+  nsresult              SnarfAttachment(nsMsgCompFields *compFields);
+  nsresult              PickEncoding(const char *charset, nsIMsgSend* mime_delivery_state);
+  nsresult              PickCharset();
+  void                  AnalyzeSnarfedFile ();      // Analyze a previously-snarfed file.
+                                                    // (Currently only used for plaintext
+                                                    // converted from HTML.) 
+  nsresult              Abort();
+  nsresult              UrlExit(nsresult status, const char16_t* aMsg);
+  
+  // if there's an intermediate temp file left, takes care to remove it from disk.
+  //
+  // NOTE: this takes care of the mEncodedWorkingFile temp file, but not mTmpFile which seems
+  // to be used by lots of other classes at the moment.
+  void                  CleanupTempFile();
+
+private:
+  virtual ~nsMsgAttachmentHandler();
+
+  // use when a message (e.g. original message in a reply) is attached as a rfc822 attachment.
+  nsresult              SnarfMsgAttachment(nsMsgCompFields *compFields);
+  bool                  UseUUEncode_p(void);
+  void                  AnalyzeDataChunk (const char *chunk, int32_t chunkSize);
+  nsresult              LoadDataFromFile(nsIFile *file, nsString &sigData, bool charsetConversion); //A similar function already exist in nsMsgCompose!
+#ifdef XP_MACOSX
+  nsresult              ConvertToAppleEncoding(const nsCString &aFileSpecURI, 
+                                               const nsCString &aFilePath, 
+                                               nsILocalFileMac *aSourceFile);
+  // zips this attachment and does the work to make this attachment handler handle it properly.
+  nsresult ConvertToZipFile(nsILocalFileMac *aSourceFile);
+  bool HasResourceFork(FSRef *fsRef);
+#endif
+
+  //
+public:
+  nsCOMPtr<nsIURI> mURL;
+  nsCOMPtr<nsIFile>        mTmpFile;         // The temp file to which we save it 
+  nsCOMPtr<nsIOutputStream>  mOutFile;          
+  nsCOMPtr<nsIRequest> mRequest; // The live request used while fetching an attachment
+  nsMsgCompFields       *mCompFields;       // Message composition fields for the sender
+  bool                  m_bogus_attachment; // This is to catch problem children...
+  
+#ifdef XP_MACOSX
+  // if we need to encode this file into for example an appledouble, or zip file,
+  // this file is our working file. currently only needed on mac.
+  nsCOMPtr<nsIFile> mEncodedWorkingFile;
+#endif
+
+  nsCString m_xMacType;      // Mac file type
+  nsCString m_xMacCreator;   // Mac file creator
+
+  bool m_done;
+  nsCString m_charset;         // charset name 
+  nsCString m_contentId;      // This is for mutipart/related Content-ID's
+  nsCString m_type;            // The real type, once we know it.
+  nsCString m_typeParam;      // Any addition parameters to add to the content-type (other than charset, macType and maccreator)
+  nsCString m_overrideType;   // The type we should assume it to be
+                                            // or 0, if we should get it from the
+                                            // server)
+  nsCString m_overrideEncoding; // Goes along with override_type 
+
+  nsCString m_desiredType;    // The type it should be converted to. 
+  nsCString m_description;     // For Content-Description header
+  nsCString m_realName;       // The name for the headers, if different
+                                            // from the URL. 
+  nsCString m_encoding;        // The encoding, once we've decided. */
+  bool                  m_already_encoded_p; // If we attach a document that is already
+                                             // encoded, we just pass it through.
+
+  bool                  m_decrypted_p;  /* S/MIME -- when attaching a message that was
+                                           encrypted, it's necessary to decrypt it first
+                                           (since nobody but the original recipient can
+                                           read it -- if you forward it to someone in the
+                                           raw, it will be useless to them.)  This flag
+                                           indicates whether decryption occurred, so that
+                                           libmsg can issue appropriate warnings about
+                                           doing a cleartext forward of a message that was
+                                           originally encrypted. */
+
+  bool                  mDeleteFile;      // If this is true, Delete the file...its 
+                                          // NOT the original file!
+
+  bool                  mMHTMLPart;           // This is true if its an MHTML part, otherwise, false
+  bool                  mPartUserOmissionOverride;  // This is true if the user send send the email without this part
+  bool                  mMainBody;            // True if this is a main body.
+   // true if this should be sent as a link to a file.
+  bool                  mSendViaCloud;
+  nsString              mHtmlAnnotation;
+  nsCString             mCloudProviderKey;
+  nsCString             mCloudUrl;
+  int32_t mNodeIndex; //If this is an embedded image, this is the index of the
+                      // corresponding domNode in the editor's
+                      //GetEmbeddedObjects. Otherwise, it will be -1.
+  //
+  // Vars for analyzing file data...
+  //
+  uint32_t              m_size;         /* Some state used while filtering it */
+  uint32_t              m_unprintable_count;
+  uint32_t              m_highbit_count;
+  uint32_t              m_ctl_count;
+  uint32_t              m_null_count;
+  uint8_t               m_have_cr, m_have_lf, m_have_crlf; 
+  bool                  m_prev_char_was_cr;
+  uint32_t              m_current_column;
+  uint32_t              m_max_column;
+  uint32_t              m_lines;
+  bool                  m_file_analyzed;
+
+  nsAutoPtr<MimeEncoder> m_encoder;
+  nsCString             m_uri; // original uri string
+
+  nsresult              GetMimeDeliveryState(nsIMsgSend** _retval);
+  nsresult              SetMimeDeliveryState(nsIMsgSend* mime_delivery_state);
+private:
+  nsCOMPtr<nsIMsgSend>  m_mime_delivery_state;
+  nsCOMPtr<nsIStreamConverter> m_mime_parser;
+  nsCOMPtr<nsIChannel>  m_converter_channel;
+};
+
+
+#endif /* _nsMsgAttachmentHandler_H_ */
diff --git a/mailnews/compose/src/nsMsgCompFields.cpp b/mailnews/compose/src/nsMsgCompFields.cpp
new file mode 100644
index 000000000..c65e6ca17
--- /dev/null
+++ b/mailnews/compose/src/nsMsgCompFields.cpp
@@ -0,0 +1,693 @@
+/* -*- 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 "nsMsgMimeCID.h"
+#include "nsArrayEnumerator.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
+  { "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::AskUser;
+
+  // Get the default charset from pref, use this as a mail charset.
+  nsString charset;
+  NS_GetLocalizedUnicharPreferenceWithDefault(nullptr, "mailnews.send_default_charset",
+                                              NS_LITERAL_STRING("UTF-8"), charset);
+
+  LossyCopyUTF16toASCII(charset, m_DefaultCharacterSet); // Charsets better be ASCII
+  SetCharacterSet(m_DefaultCharacterSet.get());
+}
+
+nsMsgCompFields::~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), "UTF-8");
+  }
+
+  // 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::SetCharacterSet(const char *value)
+{
+  return SetAsciiHeader(MSG_CHARACTER_SET_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetCharacterSet(char **_retval)
+{
+  *_retval = strdup(GetAsciiHeader(MSG_CHARACTER_SET_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 char *value)
+{
+  return SetAsciiHeader(MSG_DRAFT_ID_HEADER_ID, value);
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetDraftId(char **_retval)
+{
+  *_retval = strdup(GetAsciiHeader(MSG_DRAFT_ID_HEADER_ID));
+  return *_retval ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+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::AskUser:
+    case nsIMsgCompSendFormat::PlainText:
+    case nsIMsgCompSendFormat::HTML:
+    case nsIMsgCompSendFormat::Both:
+      m_deliveryFormat = value;
+      break;
+    default:
+      m_deliveryFormat = nsIMsgCompSendFormat::AskUser;
+  }
+
+  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)
+{
+  CopyUTF16toUTF8(value, m_body);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetBody(nsAString &_retval)
+{
+  CopyUTF8toUTF16(m_body, _retval);
+  return NS_OK;
+}
+
+nsresult nsMsgCompFields::SetBody(const char *value)
+{
+  if (value)
+    m_body = value;
+  else
+    m_body.Truncate();
+  return NS_OK;
+}
+
+const char* nsMsgCompFields::GetBody()
+{
+    return m_body.get();
+}
+
+/* readonly attribute nsISimpleEnumerator attachmentsArray; */
+NS_IMETHODIMP nsMsgCompFields::GetAttachments(nsISimpleEnumerator * *aAttachmentsEnum)
+{
+  return aAttachmentsEnum ? NS_NewArrayEnumerator(aAttachmentsEnum, m_attachments) : NS_ERROR_NULL_POINTER;
+}
+
+/* void addAttachment (in nsIMsgAttachment attachment); */
+NS_IMETHODIMP nsMsgCompFields::AddAttachment(nsIMsgAttachment *attachment)
+{
+  int32_t attachmentCount = m_attachments.Count();
+
+  //Don't add twice the same attachment.
+  nsCOMPtr<nsIMsgAttachment> element;
+  bool sameUrl;
+  for (int32_t i = 0; i < attachmentCount; i ++)
+  {
+    m_attachments[i]->EqualsUrl(attachment, &sameUrl);
+    if (sameUrl)
+      return NS_OK;
+  }
+  m_attachments.AppendObject(attachment);
+
+  return NS_OK;
+}
+
+/* void removeAttachment (in nsIMsgAttachment attachment); */
+NS_IMETHODIMP nsMsgCompFields::RemoveAttachment(nsIMsgAttachment *attachment)
+{
+  int32_t attachmentCount = m_attachments.Count();
+
+  nsCOMPtr<nsIMsgAttachment> element;
+  bool sameUrl;
+  for (int32_t i = 0; i < attachmentCount; i ++)
+  {
+    m_attachments[i]->EqualsUrl(attachment, &sameUrl);
+    if (sameUrl)
+    {
+      m_attachments.RemoveObjectAt(i);
+      break;
+    }
+  }
+
+  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,
+                                 uint32_t *aLength,
+                                 char16_t*** aResult)
+{
+  NS_ENSURE_ARG_POINTER(aLength);
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  *aLength = 0;
+  *aResult = nullptr;
+
+  nsCOMArray<msgIAddressObject> header(EncodedHeader(NS_ConvertUTF16toUTF8(aRecipients)));
+  nsTArray<nsString> results;
+  if (aEmailAddressOnly)
+    ExtractEmails(header, results);
+  else
+    ExtractDisplayAddresses(header, results);
+
+  uint32_t count = results.Length();
+  char16_t **result = (char16_t **)NS_Alloc(sizeof(char16_t *) * count);
+  for (uint32_t i = 0; i < count; ++i)
+    result[i] = ToNewUnicode(results[i]);
+
+  *aResult = result;
+  *aLength = count;
+  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(EncodedHeader(NS_ConvertUTF16toUTF8(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())
+  {
+    nsAutoString body;
+    rv = GetBody(body);
+    if (NS_SUCCEEDED(rv))
+    {
+      bool flowed, delsp, formatted, disallowBreaks;
+      GetSerialiserFlags(GetCharacterSet(), &flowed, &delsp, &formatted, &disallowBreaks);
+      rv = ConvertBufToPlainText(body, flowed, delsp, formatted, disallowBreaks);
+      if (NS_SUCCEEDED(rv))
+        rv = SetBody(body);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetSecurityInfo(nsISupports ** aSecurityInfo)
+{
+  NS_ENSURE_ARG_POINTER(aSecurityInfo);
+  *aSecurityInfo = mSecureCompFields;
+  NS_IF_ADDREF(*aSecurityInfo);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::SetSecurityInfo(nsISupports * aSecurityInfo)
+{
+  mSecureCompFields = aSecurityInfo;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompFields::GetDefaultCharacterSet(char * *aDefaultCharacterSet)
+{
+  NS_ENSURE_ARG_POINTER(aDefaultCharacterSet);
+  *aDefaultCharacterSet = ToNewCString(m_DefaultCharacterSet);
+  return *aDefaultCharacterSet ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+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/mailnews/compose/src/nsMsgCompFields.h b/mailnews/compose/src/nsMsgCompFields.h
new file mode 100644
index 000000000..ecc562499
--- /dev/null
+++ b/mailnews/compose/src/nsMsgCompFields.h
@@ -0,0 +1,172 @@
+/* -*- 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 "nsStringGlue.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
+
+  // Allow the C++ utility methods for people who use a concrete class instead
+  // of the interfaces.
+  using msgIStructuredHeaders::GetAddressingHeader;
+  using msgIWritableStructuredHeaders::SetAddressingHeader;
+
+  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_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* 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 SetBody(const char *value);
+  const char* GetBody();
+
+  nsresult SplitRecipientsEx(const nsAString &recipients,
+                             nsTArray<nsMsgRecipient> &aResult);
+
+protected:
+  virtual ~nsMsgCompFields();
+  nsCString m_headers[MSG_MAX_HEADERS];
+  nsCString   m_body;
+  nsCOMArray<nsIMsgAttachment> m_attachments;
+  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<nsISupports> mSecureCompFields;
+  nsCOMPtr<msgIWritableStructuredHeaders> mStructuredHeaders;
+};
+
+
+#endif /* _MsgCompFields_H_ */
diff --git a/mailnews/compose/src/nsMsgCompUtils.cpp b/mailnews/compose/src/nsMsgCompUtils.cpp
new file mode 100644
index 000000000..4615f0f36
--- /dev/null
+++ b/mailnews/compose/src/nsMsgCompUtils.cpp
@@ -0,0 +1,1803 @@
+/* -*- 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 "prmem.h"
+#include "nsMsgSend.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/mailnews/Services.h"
+#include "mozilla/Services.h"
+#include "nsIMIMEInfo.h"
+#include "nsIMsgHeaderParser.h"
+#include "nsIRandomGenerator.h"
+#include "nsID.h"
+
+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,
+                                                    char **_retval)
+{
+  NS_ENSURE_ARG_POINTER(identity);
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = msg_generate_message_id(identity);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompUtils::GetMsgMimeConformToStandard(bool *_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = nsMsgMIMEGetConformToStandard();
+  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;
+}
+
+//
+// Create a file spec for the a unique temp file
+// on the local machine. Caller must free memory
+// returned
+//
+char *
+nsMsgCreateTempFileName(const char *tFileName)
+{
+  if ((!tFileName) || (!*tFileName))
+    tFileName = "nsmail.tmp";
+
+  nsCOMPtr<nsIFile> tmpFile;
+
+  nsresult rv = GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR,
+                                                tFileName,
+                                                getter_AddRefs(tmpFile));
+  if (NS_FAILED(rv))
+    return nullptr;
+
+  rv = tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
+  if (NS_FAILED(rv))
+    return nullptr;
+
+  nsCString tempString;
+  rv = tmpFile->GetNativePath(tempString);
+  if (NS_FAILED(rv))
+    return nullptr;
+
+  char *tString = ToNewCString(tempString);
+  if (!tString)
+    return PL_strdup("mozmail.tmp");  // No need to I18N
+
+  return tString;
+}
+
+// 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);
+}
+
+//
+// Generate the message headers for the new RFC822 message
+//
+#define UA_PREF_PREFIX "general.useragent."
+
+// 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);
+
+  nsCOMArray<msgIAddressObject> from;
+  fields->GetAddressingHeader("From", from, true);
+
+  // 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 (superceding 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), nullptr);
+
+  // 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, nullptr);
+  }
+
+  nsCOMPtr<nsIHttpProtocolHandler> pHTTPHandler = do_GetService(NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "http", &rv);
+  if (NS_SUCCEEDED(rv) && pHTTPHandler)
+  {
+    nsAutoCString userAgentString;
+    pHTTPHandler->GetUserAgent(userAgentString);
+
+    if (!userAgentString.IsEmpty())
+      finalHeaders->SetUnstructuredHeader("User-Agent",
+        NS_ConvertUTF8toUTF16(userAgentString));
+  }
+
+  finalHeaders->SetUnstructuredHeader("MIME-Version", NS_LITERAL_STRING("1.0"));
+
+  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, nullptr);
+
+    // 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,
+        nullptr);
+    }
+
+    // Newsgroups are a recipient...
+    hasDisclosedRecipient = true;
+  }
+
+  nsCOMArray<msgIAddressObject> recipients;
+  finalHeaders->GetAddressingHeader("To", recipients);
+  hasDisclosedRecipient |= !recipients.IsEmpty();
+  finalHeaders->GetAddressingHeader("Cc", 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)
+  {
+    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::services::GetStringBundleService();
+        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(u"undisclosedRecipients",
+                                                        getter_Copies(undisclosedRecipients));
+            if (NS_SUCCEEDED(rv) && !undisclosedRecipients.IsEmpty())
+            {
+              nsCOMPtr<nsIMsgHeaderParser> headerParser(
+                mozilla::services::GetHeaderParser());
+              nsCOMPtr<msgIAddressObject> group;
+              headerParser->MakeGroupObject(undisclosedRecipients,
+                nullptr, 0, 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 readded 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.AppendLiteral(")");
+      finalHeaders->SetRawHeader("X-Priority", priorityValueString, nullptr);
+    }
+  }
+
+  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, nullptr);
+        }
+      }
+    }
+    // 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),
+        nullptr);
+  }
+
+  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]);
+}
+
+static char *
+RFC2231ParmFolding(const char *parmName, const nsCString& charset,
+                   const char *language, const nsString& parmValue);
+
+static char *
+LegacyParmFolding(const nsCString& aCharset,
+                  const nsCString& aFileName, int32_t aParmFolding);
+
+char *
+mime_generate_attachment_headers (const char *type,
+                  const char *type_param,
+                  const char *encoding,
+                  const char *description,
+                  const char *x_mac_type,
+                  const char *x_mac_creator,
+                  const char *real_name,
+                  const char *base_url,
+                  bool /*digest_p*/,
+                  nsMsgAttachmentHandler * /*ma*/,
+                  const char *attachmentCharset,
+                  const char *bodyCharset,
+                  bool bodyIsAsciiOnly,
+                  const char *content_id,
+                  bool        aBodyDocument)
+{
+  NS_ASSERTION (encoding, "null encoding");
+
+  int32_t parmFolding = 2; // RFC 2231-compliant
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (prefs)
+    prefs->GetIntPref("mail.strictly_mime.parm_folding", &parmFolding);
+
+  /* Let's encode the real name */
+  char *encodedRealName = nullptr;
+  nsCString charset;   // actual charset used for MIME encode
+  nsAutoString realName;
+  if (real_name)
+  {
+    // first try main body's charset to encode the file name,
+    // then try local file system charset if fails
+    CopyUTF8toUTF16(nsDependentCString(real_name), realName);
+    if (bodyCharset && *bodyCharset &&
+        nsMsgI18Ncheck_data_in_charset_range(bodyCharset, realName.get()))
+      charset.Assign(bodyCharset);
+    else
+    {
+      charset.Assign(nsMsgI18NFileSystemCharset());
+      if (!nsMsgI18Ncheck_data_in_charset_range(charset.get(), realName.get()))
+        charset.Assign("UTF-8"); // set to UTF-8 if fails again
+    }
+
+    encodedRealName = RFC2231ParmFolding("filename", charset, nullptr,
+                                         realName);
+    // somehow RFC2231ParamFolding failed. fall back to legacy method
+    if (!encodedRealName || !*encodedRealName) {
+      PR_FREEIF(encodedRealName);
+      parmFolding = 0;
+      // Not RFC 2231 style encoding (it's not standard-compliant)
+      encodedRealName =
+        LegacyParmFolding(charset, nsDependentCString(real_name), parmFolding);
+    }
+  }
+
+  nsCString buf;  // very likely to be longer than 64 characters
+  buf.Append("Content-Type: ");
+  buf.Append(type);
+  if (type_param && *type_param)
+  {
+    if (*type_param != ';')
+      buf.Append("; ");
+    buf.Append(type_param);
+  }
+
+  if (mime_type_needs_charset (type))
+  {
+
+    char charset_label[65] = "";   // Content-Type: charset
+    if (attachmentCharset)
+    {
+      PL_strncpy(charset_label, attachmentCharset, sizeof(charset_label)-1);
+      charset_label[sizeof(charset_label)-1] = '\0';
+    }
+
+    /* If the characters are all 7bit, arguably it's better to
+    claim the charset to be US-ASCII. However, it causes
+    a major 'interoperability problem' with MS OE, which makes it hard
+    to sell Mozilla/TB to people most of whose correspondents use
+    MS OE. MS OE turns all non-ASCII characters to question marks
+    in replies to messages labeled as US-ASCII if users select 'send as is'
+    with MIME turned on. (with MIME turned off, this happens without
+    any warning.) To avoid this, we use the label 'US-ASCII' only when
+    it's explicitly requested by setting the hidden pref.
+    'mail.label_ascii_only_mail_as_us_ascii'. (bug 247958) */
+    bool labelAsciiAsAscii = false;
+    if (prefs)
+      prefs->GetBoolPref("mail.label_ascii_only_mail_as_us_ascii",
+                         &labelAsciiAsAscii);
+    if (labelAsciiAsAscii && encoding &&
+        !PL_strcasecmp (encoding, "7bit") && bodyIsAsciiOnly)
+      PL_strcpy (charset_label, "us-ascii");
+
+    // If charset is multibyte then no charset to be specified (apply base64 instead).
+    // The list of file types match with PickEncoding() where we put base64 label.
+    if ( ((attachmentCharset && !nsMsgI18Nmultibyte_charset(attachmentCharset)) ||
+         ((PL_strcasecmp(type, TEXT_HTML) == 0) ||
+         (PL_strcasecmp(type, TEXT_MDL) == 0) ||
+         (PL_strcasecmp(type, TEXT_PLAIN) == 0) ||
+         (PL_strcasecmp(type, TEXT_RICHTEXT) == 0) ||
+         (PL_strcasecmp(type, TEXT_ENRICHED) == 0) ||
+         (PL_strcasecmp(type, TEXT_VCARD) == 0) ||
+         (PL_strcasecmp(type, APPLICATION_DIRECTORY) == 0) || /* text/x-vcard synonym */
+         (PL_strcasecmp(type, TEXT_CSS) == 0) ||
+         (PL_strcasecmp(type, TEXT_JSSS) == 0)) ||
+         (PL_strcasecmp(encoding, ENCODING_BASE64) != 0)) &&
+         (*charset_label))
+    {
+      buf.Append("; charset=");
+      buf.Append(charset_label);
+    }
+  }
+
+  // Only do this if we are in the body of a message
+  if (aBodyDocument)
+  {
+    // Add format=flowed as in RFC 2646 if we are using that
+    if(type && !PL_strcasecmp(type, "text/plain"))
+    {
+      bool flowed, delsp, formatted, disallowBreaks;
+      GetSerialiserFlags(bodyCharset, &flowed, &delsp, &formatted, &disallowBreaks);
+      if(flowed)
+        buf.Append("; format=flowed");
+      if (delsp)
+        buf.Append("; delsp=yes");
+      // else
+      // {
+      // Don't add a markup. Could use
+      //        PUSH_STRING ("; format=fixed");
+      // but it is equivalent to nothing at all and we do want
+      // to save bandwidth. Don't we?
+      // }
+    }
+  }
+
+  if (x_mac_type && *x_mac_type) {
+    buf.Append("; x-mac-type=\"");
+    buf.Append(x_mac_type);
+    buf.Append("\"");
+  }
+
+  if (x_mac_creator && *x_mac_creator) {
+    buf.Append("; x-mac-creator=\"");
+    buf.Append(x_mac_creator);
+    buf.Append("\"");
+  }
+
+#ifdef EMIT_NAME_IN_CONTENT_TYPE
+  if (encodedRealName && *encodedRealName) {
+    // Note that we don't need to output the name field if the name encoding is
+    // RFC 2231. If the MUA knows the RFC 2231, it should know the RFC 2183 too.
+    if (parmFolding != 2) {
+      // The underlying JS MIME code will only handle UTF-8 here.
+      char *nameValue = LegacyParmFolding(NS_LITERAL_CSTRING("UTF-8"),
+                                          nsDependentCString(real_name),
+                                          parmFolding);
+      if (!nameValue || !*nameValue) {
+        PR_FREEIF(nameValue);
+        nameValue = encodedRealName;
+      }
+      buf.Append(";\r\n name=\"");
+      buf.Append(nameValue);
+      buf.Append("\"");
+      if (nameValue != encodedRealName)
+        PR_FREEIF(nameValue);
+    }
+  }
+#endif /* EMIT_NAME_IN_CONTENT_TYPE */
+  buf.Append(CRLF);
+
+  buf.Append("Content-Transfer-Encoding: ");
+  buf.Append(encoding);
+  buf.Append(CRLF);
+
+  if (description && *description) {
+    char *s = mime_fix_header (description);
+    if (s) {
+      buf.Append("Content-Description: ");
+      buf.Append(s);
+      buf.Append(CRLF);
+      PR_Free(s);
+    }
+  }
+
+  if ( (content_id) && (*content_id) )
+  {
+    buf.Append("Content-ID: <");
+    buf.Append(content_id);
+    buf.Append(">");
+    buf.Append(CRLF);
+  }
+
+  if (encodedRealName && *encodedRealName) {
+    char *period = PL_strrchr(encodedRealName, '.');
+    int32_t pref_content_disposition = 0;
+
+    if (prefs) {
+      mozilla::DebugOnly<nsresult> rv = prefs->GetIntPref("mail.content_disposition_type",
+                                                          &pref_content_disposition);
+      NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get mail.content_disposition_type");
+    }
+
+    buf.Append("Content-Disposition: ");
+
+    // If this is an attachment which is part of the message body and therefore has a
+    // Content-ID (e.g, image in HTML msg), then Content-Disposition has to be inline
+    if (content_id && *content_id)
+      buf.Append("inline");
+    else if (pref_content_disposition == 1)
+      buf.Append("attachment");
+    else
+      if (pref_content_disposition == 2 &&
+          (!PL_strcasecmp(type, TEXT_PLAIN) ||
+          (period && !PL_strcasecmp(period, ".txt"))))
+        buf.Append("attachment");
+
+      /* If this document is an anonymous binary file or a vcard,
+      then always show it as an attachment, never inline. */
+      else
+        if (!PL_strcasecmp(type, APPLICATION_OCTET_STREAM) ||
+            !PL_strcasecmp(type, TEXT_VCARD) ||
+            !PL_strcasecmp(type, APPLICATION_DIRECTORY)) /* text/x-vcard synonym */
+          buf.Append("attachment");
+        else
+          buf.Append("inline");
+
+    buf.Append(";\r\n ");
+    buf.Append(encodedRealName);
+    buf.Append(CRLF);
+  }
+  else
+    if (type &&
+        (!PL_strcasecmp (type, MESSAGE_RFC822) ||
+        !PL_strcasecmp (type, MESSAGE_NEWS)))
+      buf.Append("Content-Disposition: inline" CRLF);
+
+#ifdef GENERATE_CONTENT_BASE
+  /* If this is an HTML document, and we know the URL it originally
+     came from, write out a Content-Base header. */
+  if (type &&
+      (!PL_strcasecmp (type, TEXT_HTML) ||
+      !PL_strcasecmp (type, TEXT_MDL)) &&
+      base_url && *base_url)
+  {
+    int32_t col = 0;
+    const char *s = base_url;
+    const char *colon = PL_strchr (s, ':');
+    bool useContentLocation = false;   /* rhp - add this  */
+
+    if (!colon)
+      goto GIVE_UP_ON_CONTENT_BASE;  /* malformed URL? */
+
+    /* Don't emit a content-base that points to (or into) a news or
+       mail message. */
+    if (!PL_strncasecmp (s, "news:", 5) ||
+        !PL_strncasecmp (s, "snews:", 6) ||
+        !PL_strncasecmp (s, "IMAP:", 5) ||
+        !PL_strncasecmp (s, "file:", 5) ||    /* rhp: fix targets from included HTML files */
+        !PL_strncasecmp (s, "mailbox:", 8))
+      goto GIVE_UP_ON_CONTENT_BASE;
+
+    /* rhp - Put in a pref for using Content-Location instead of Content-Base.
+           This will get tweaked to default to true in 5.0
+    */
+    if (prefs)
+      prefs->GetBoolPref("mail.use_content_location_on_send", &useContentLocation);
+
+    if (useContentLocation)
+      buf.Append("Content-Location: \"");
+    else
+      buf.Append("Content-Base: \"");
+    /* rhp - Pref for Content-Location usage */
+
+/* rhp: this is to work with the Content-Location stuff */
+CONTENT_LOC_HACK:
+
+    while (*s != 0 && *s != '#')
+    {
+      uint32_t ot=buf.Length();
+      char tmp[]="\x00\x00";
+      /* URLs must be wrapped at 40 characters or less. */
+      if (col >= 38) {
+        buf.Append(CRLF "\t");
+        col = 0;
+      }
+
+      if (*s == ' ')
+        buf.Append("%20");
+      else if (*s == '\t')
+        buf.Append("%09");
+      else if (*s == '\n')
+        buf.Append("%0A");
+      else if (*s == '\r')
+        buf.Append("%0D");
+      else {
+	      tmp[0]=*s;
+	      buf.Append(tmp);
+      }
+      s++;
+      col += (buf.Length() - ot);
+    }
+    buf.Append("\"" CRLF);
+
+    /* rhp: this is to try to get around this fun problem with Content-Location */
+    if (!useContentLocation) {
+      buf.Append("Content-Location: \"");
+      s = base_url;
+      col = 0;
+      useContentLocation = true;
+      goto CONTENT_LOC_HACK;
+    }
+    /* rhp: this is to try to get around this fun problem with Content-Location */
+
+GIVE_UP_ON_CONTENT_BASE:
+    ;
+  }
+#endif /* GENERATE_CONTENT_BASE */
+
+  /* realloc it smaller... */
+
+#ifdef DEBUG_jungshik
+  printf ("header=%s\n", buf.get());
+#endif
+  PR_Free(encodedRealName);
+  return PL_strdup(buf.get());
+}
+
+static bool isValidHost( const char* host )
+{
+  if ( host )
+    for (const char *s = host; *s; ++s)
+      if  (  !isalpha(*s)
+         && !isdigit(*s)
+         && *s != '-'
+         && *s != '_'
+         && *s != '.'
+         )
+      {
+       host = nullptr;
+       break;
+      }
+
+  return nullptr != host;
+}
+
+char *
+msg_generate_message_id (nsIMsgIdentity *identity)
+{
+  const char *host = 0;
+
+  nsCString forcedFQDN;
+  nsCString from;
+  nsresult rv = NS_OK;
+
+  rv = identity->GetCharAttribute("FQDN", forcedFQDN);
+
+  if (NS_SUCCEEDED(rv) && !forcedFQDN.IsEmpty())
+    host = forcedFQDN.get();
+
+  if (!isValidHost(host))
+  {
+    nsresult rv = identity->GetEmail(from);
+    if (NS_SUCCEEDED(rv) && !from.IsEmpty())
+      host = strchr(from.get(),'@');
+
+    // No '@'? Munged address, anti-spam?
+    // see bug #197203
+    if (host)
+      ++host;
+  }
+
+  if (!isValidHost(host))
+  /* If we 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. */
+    return 0;
+
+  // Generate 128-bit UUID for the local part. We use the high-entropy
+  // GenerateGlobalRandomBytes to make tracking more difficult.
+  nsID uuid;
+  GenerateGlobalRandomBytes((unsigned char*) &uuid, sizeof(nsID));
+  char uuidString[NSID_LENGTH];
+  uuid.ToProvidedString(uuidString);
+  // Drop first and last characters (curly braces).
+  uuidString[NSID_LENGTH - 2] = 0;
+  return PR_smprintf("<%s@%s>", uuidString + 1, host);
+}
+
+
+inline static bool is7bitCharset(const nsCString& charset)
+{
+  // charset name is canonical (no worry about case-sensitivity)
+  return Substring(charset, 0, 8).EqualsLiteral("ISO-2022-");
+}
+
+#define PR_MAX_FOLDING_LEN 75     // this is to gurantee the folded line will
+                                  // never be greater than 78 = 75 + CRLFLWSP
+/*static */ char *
+RFC2231ParmFolding(const char *parmName, const nsCString& charset,
+                   const char *language, const nsString& parmValue)
+{
+  NS_ENSURE_TRUE(parmName && *parmName && !parmValue.IsEmpty(), nullptr);
+
+  bool needEscape;
+  nsCString dupParm;
+
+  if (!NS_IsAscii(parmValue.get()) || is7bitCharset(charset)) {
+    needEscape = true;
+    nsAutoCString nativeParmValue;
+    ConvertFromUnicode(charset.get(), parmValue, nativeParmValue);
+    MsgEscapeString(nativeParmValue, nsINetUtil::ESCAPE_ALL, dupParm);
+  }
+  else {
+    needEscape = false;
+    dupParm.Adopt(
+      msg_make_filename_qtext(NS_LossyConvertUTF16toASCII(parmValue).get(),
+                              true));
+  }
+
+  if (dupParm.IsEmpty())
+    return nullptr;
+
+  int32_t parmNameLen = PL_strlen(parmName);
+  int32_t parmValueLen = dupParm.Length();
+
+  parmNameLen += 5;  // *=__'__'___ or *[0]*=__'__'__ or *[1]*=___ or *[0]="___"
+
+  int32_t languageLen = language ?  PL_strlen(language) : 0;
+  int32_t charsetLen = charset.Length();
+  char *foldedParm = nullptr;
+
+  if ((parmValueLen + parmNameLen + charsetLen + languageLen) <
+      PR_MAX_FOLDING_LEN)
+  {
+    foldedParm = PL_strdup(parmName);
+    if (needEscape)
+    {
+      NS_MsgSACat(&foldedParm, "*=");
+      if (charsetLen)
+        NS_MsgSACat(&foldedParm, charset.get());
+      NS_MsgSACat(&foldedParm, "'");
+      if (languageLen)
+        NS_MsgSACat(&foldedParm, language);
+      NS_MsgSACat(&foldedParm, "'");
+    }
+    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)
+        {
+          if (charsetLen)
+            NS_MsgSACat(&foldedParm, charset.get());
+          NS_MsgSACat(&foldedParm, "'");
+          if (languageLen)
+            NS_MsgSACat(&foldedParm, language);
+          NS_MsgSACat(&foldedParm, "'");
+          curLineLen += charsetLen;
+          curLineLen += languageLen;
+        }
+      }
+      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
+        if (*end == '%')
+        {
+          tmp = '%'; *end = 0;
+        }
+        else if (end-1 > start && *(end-1) == '%')
+        {
+          end -= 1; tmp = '%'; *end = 0;
+        }
+        else if (end-2 > start && *(end-2) == '%')
+        {
+          end -= 2; tmp = '%'; *end = 0;
+        }
+        else
+        {
+          tmp = *end; *end = 0;
+        }
+      }
+      else
+      {
+        // XXX should check if we are in the middle of escaped char (RFC 822)
+        tmp = *end; *end = 0;
+      }
+      NS_MsgSACat(&foldedParm, start);
+      if (!needEscape)
+        NS_MsgSACat(&foldedParm, "\"");
+
+      parmValueLen -= (end-start);
+      if (tmp)
+        *end = tmp;
+      start = end;
+    }
+  }
+
+  return foldedParm;
+}
+
+/*static */ char *
+LegacyParmFolding(const nsCString& aCharset,
+                  const nsCString& aFileName, int32_t aParmFolding)
+{
+  bool usemime = nsMsgMIMEGetConformToStandard();
+  char *encodedRealName =
+    nsMsgI18NEncodeMimePartIIStr(aFileName.get(), false, aCharset.get(),
+                                 0, usemime);
+
+  if (!encodedRealName || !*encodedRealName) {
+    PR_FREEIF(encodedRealName);
+    encodedRealName = (char *) PR_Malloc(aFileName.Length() + 1);
+    if (encodedRealName)
+      PL_strcpy(encodedRealName, aFileName.get());
+  }
+
+  // Now put backslashes before special characters per RFC 822
+  char *qtextName =
+    msg_make_filename_qtext(encodedRealName, aParmFolding == 0);
+  if (qtextName) {
+    PR_FREEIF(encodedRealName);
+    encodedRealName = qtextName;
+  }
+  return encodedRealName;
+}
+
+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 disasterous.)  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;
+}
+
+/* Rip apart the URL and extract a reasonable value for the `real_name' slot.
+ */
+void
+msg_pick_real_name (nsMsgAttachmentHandler *attachment, const char16_t *proposedName, const char *charset)
+{
+  const char *s, *s2;
+
+  if (!attachment->m_realName.IsEmpty())
+    return;
+
+  if (proposedName && *proposedName)
+  {
+    attachment->m_realName.Adopt(ToNewUTF8String(nsAutoString(proposedName)));
+  }
+  else //Let's extract the name from the URL
+  {
+    nsCString url;
+    nsresult rv = attachment->mURL->GetSpec(url);
+    if (NS_FAILED(rv))
+      return;
+
+    s = url.get();
+    s2 = PL_strchr (s, ':');
+    if (s2)
+      s = s2 + 1;
+    /* If we know the URL doesn't have a sensible file name in it,
+     don't bother emitting a content-disposition. */
+    if (StringBeginsWith (url, NS_LITERAL_CSTRING("news:"), nsCaseInsensitiveCStringComparator()) ||
+        StringBeginsWith (url, NS_LITERAL_CSTRING("snews:"), nsCaseInsensitiveCStringComparator()) ||
+        StringBeginsWith (url, NS_LITERAL_CSTRING("IMAP:"), nsCaseInsensitiveCStringComparator()) ||
+        StringBeginsWith (url, NS_LITERAL_CSTRING("mailbox:"), nsCaseInsensitiveCStringComparator()))
+      return;
+
+    if (StringBeginsWith(url, NS_LITERAL_CSTRING("data:"),
+                         nsCaseInsensitiveCStringComparator()))
+    {
+      int32_t endNonData = url.FindChar(',');
+      if (endNonData == -1)
+        return;
+      nsCString nonDataPart(Substring(url, 5, endNonData - 5));
+      int32_t filenamePos = nonDataPart.Find("filename=");
+      if (filenamePos != -1)
+      {
+        filenamePos += 9;
+        int32_t endFilename = nonDataPart.FindChar(';', filenamePos);
+        if (endFilename == -1)
+          endFilename = endNonData;
+        attachment->m_realName = Substring(nonDataPart, filenamePos,
+                                           endFilename - filenamePos);
+      }
+      else
+      {
+        // no filename; need to construct one based on the content type.
+        nsCOMPtr<nsIMIMEService> mimeService(do_GetService(NS_MIMESERVICE_CONTRACTID));
+        if (!mimeService)
+          return;
+        nsCOMPtr<nsIMIMEInfo> mimeInfo;
+        nsCString mediaType(Substring(nonDataPart, 0, nonDataPart.FindChar(';')));
+        mimeService->GetFromTypeAndExtension(mediaType, EmptyCString(), getter_AddRefs(mimeInfo));
+        if (!mimeInfo)
+          return;
+        nsCString filename;
+        nsCString extension;
+        mimeInfo->GetPrimaryExtension(extension);
+        unsigned char filePrefixBytes[8];
+        GenerateGlobalRandomBytes(filePrefixBytes, 8);
+        // Create a filename prefix with 16 lowercase letters,
+        // representing 8 bytes.
+        for (int32_t i = 0; i < 8; i++)
+        {
+          // A pair of letters, each any of (a-p).
+          filename.Append((filePrefixBytes[i] & 0xF) + 'a');
+          filename.Append((filePrefixBytes[i] >> 4) + 'a');
+        }
+        filename.Append('.');
+        filename.Append(extension);
+        attachment->m_realName = filename;
+      }
+    }
+    else
+    {
+      /* Take the part of the file name after the last / or \ */
+      s2 = PL_strrchr (s, '/');
+      if (s2) s = s2+1;
+      s2 = PL_strrchr (s, '\\');
+
+      if (s2) s = s2+1;
+      /* Copy it into the attachment struct. */
+      attachment->m_realName = s;
+      int32_t charPos = attachment->m_realName.FindChar('?');
+      if (charPos != -1)
+        attachment->m_realName.SetLength(charPos);
+      /* Now trim off any named anchors or search data. */
+      charPos = attachment->m_realName.FindChar('#');
+      if (charPos != -1)
+        attachment->m_realName.SetLength(charPos);
+    }
+    /* Now lose the %XX crap. */
+    nsCString unescaped_real_name;
+    MsgUnescapeString(attachment->m_realName, 0, unescaped_real_name);
+    attachment->m_realName = unescaped_real_name;
+  }
+
+  /* Now a special case for attaching uuencoded files...
+
+   If we attach a file "foo.txt.uu", we will send it out with
+   Content-Type: text/plain; Content-Transfer-Encoding: x-uuencode.
+   When saving such a file, a mail reader will generally decode it first
+   (thus removing the uuencoding.)  So, let's make life a little easier by
+   removing the indication of uuencoding from the file name itself.  (This
+   will presumably make the file name in the Content-Disposition header be
+   the same as the file name in the "begin" line of the uuencoded data.)
+
+   However, since there are mailers out there (including earlier versions of
+   Mozilla) that will use "foo.txt.uu" as the file name, we still need to
+   cope with that; the code which copes with that is in the MIME parser, in
+   libmime/mimei.c.
+   */
+  if (attachment->m_already_encoded_p && !attachment->m_encoding.IsEmpty())
+  {
+    /* #### TOTAL KLUDGE.
+     I'd like to ask the mime.types file, "what extensions correspond
+     to obj->encoding (which happens to be "x-uuencode") but doing that
+     in a non-sphagetti way would require brain surgery.  So, since
+     currently uuencode is the only content-transfer-encoding which we
+     understand which traditionally has an extension, we just special-
+     case it here!
+
+     Note that it's special-cased in a similar way in libmime/mimei.c.
+     */
+    if (attachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE) ||
+        attachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE2) ||
+        attachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE3) ||
+        attachment->m_encoding.LowerCaseEqualsLiteral(ENCODING_UUENCODE4))
+    {
+      if (StringEndsWith(attachment->m_realName, NS_LITERAL_CSTRING(".uu")))
+        attachment->m_realName.Cut(attachment->m_realName.Length() - 3, 3);
+      else if (StringEndsWith(attachment->m_realName, NS_LITERAL_CSTRING(".uue")))
+        attachment->m_realName.Cut(attachment->m_realName.Length() - 4, 4);
+    }
+  }
+}
+
+// Utility to create a nsIURI object...
+nsresult
+nsMsgNewURL(nsIURI** aInstancePtrResult, const char * aSpec)
+{
+  nsresult rv = NS_OK;
+  if (nullptr == aInstancePtrResult)
+    return NS_ERROR_NULL_POINTER;
+  nsCOMPtr<nsIIOService> pNetService =
+    mozilla::services::GetIOService();
+  NS_ENSURE_TRUE(pNetService, NS_ERROR_UNEXPECTED);
+  if (PL_strstr(aSpec, "://") == nullptr && strncmp(aSpec, "data:", 5))
+  {
+    //XXXjag Temporary fix for bug 139362 until the real problem(bug 70083) get fixed
+    nsAutoCString uri(NS_LITERAL_CSTRING("http://"));
+    uri.Append(aSpec);
+    rv = pNetService->NewURI(uri, nullptr, nullptr, aInstancePtrResult);
+  }
+  else
+    rv = pNetService->NewURI(nsDependentCString(aSpec), nullptr, nullptr, aInstancePtrResult);
+  return rv;
+}
+
+bool
+nsMsgIsLocalFile(const char *url)
+{
+  /*
+    A url is considered as a local file if it's start with file://
+    But on Window, we need to filter UNC file url because there
+    are not really local file. Those start with file:////
+  */
+  if (PL_strncasecmp(url, "file://", 7) == 0)
+  {
+#ifdef XP_WIN
+    if (PL_strncasecmp(url, "file:////", 9) == 0)
+      return false;
+#endif
+    return true;
+  }
+  else
+    return false;
+}
+
+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, 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->GetPath(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", getter_Copies(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)
+      {
+        MsgReplaceSubstring(uri, " ", "%20");
+        prefs->SetCharPref("mail.default_sendlater_uri", uri.get());
+      }
+    }
+    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(const char* charset, bool* flowed, bool* delsp, bool* formatted, bool* disallowBreaks)
+{
+  *flowed = false;
+  *delsp = false;
+  *formatted = true;
+  *disallowBreaks = 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);
+  }
+
+  // We could test statefulCharset(charset) here, but since ISO-2022-JP is the
+  // only one left we support, we might as well check for it directly.
+  if (PL_strcasecmp(charset, "ISO-2022-JP") == 0) {
+    // Make sure we honour RFC 1468. For encoding in ISO-2022-JP we need to
+    // send short lines to allow 7bit transfer encoding.
+    *disallowBreaks = false;
+    if (*flowed)
+      *delsp = true;
+  }
+}
diff --git a/mailnews/compose/src/nsMsgCompUtils.h b/mailnews/compose/src/nsMsgCompUtils.h
new file mode 100644
index 000000000..13d6ddd83
--- /dev/null
+++ b/mailnews/compose/src/nsMsgCompUtils.h
@@ -0,0 +1,143 @@
+/* -*- 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 "nsMsgSend.h"
+#include "nsMsgCompFields.h"
+#include "nsIMsgSend.h"
+#include "nsIMsgCompUtils.h"
+
+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"
+
+class nsMsgCompUtils : public nsIMsgCompUtils
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGCOMPUTILS
+
+  nsMsgCompUtils();
+
+private:
+  virtual ~nsMsgCompUtils();
+};
+
+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);
+
+char        *mime_generate_attachment_headers (
+                           const char *type,
+                           const char *type_param,
+                           const char *encoding,
+                           const char *description,
+                           const char *x_mac_type,
+                           const char *x_mac_creator,
+                           const char *real_name,
+                           const char *base_url,
+                           bool digest_p,
+                           nsMsgAttachmentHandler *ma,
+                           const char *attachmentCharset, // charset of the attachment (can be null)
+                           const char *bodyCharset,       // charset of the main body
+                           bool bodyIsAsciiOnly,
+                           const char *content_id,
+                           bool       aBodyDocument);
+
+char        *msg_generate_message_id (nsIMsgIdentity*);
+
+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);
+
+// Rip apart the URL and extract a reasonable value for the `real_name' slot.
+void        msg_pick_real_name (nsMsgAttachmentHandler *attachment, const char16_t *proposedName, const char *charset);
+
+//
+// Informational calls...
+//
+void        nsMsgMIMESetConformToStandard (bool conform_p);
+bool        nsMsgMIMEGetConformToStandard (void);
+
+//
+// network service type calls...
+//
+nsresult    nsMsgNewURL(nsIURI** aInstancePtrResult, const char * aSpec);
+bool        nsMsgIsLocalFile(const char *url);
+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(const char *charset, bool *flowed, bool *delsp, bool *formatted, bool *disallowBreaks);
+
+
+PR_END_EXTERN_C
+
+
+#endif /* _nsMsgCompUtils_H_ */
+
diff --git a/mailnews/compose/src/nsMsgCompose.cpp b/mailnews/compose/src/nsMsgCompose.cpp
new file mode 100644
index 000000000..58340bffa
--- /dev/null
+++ b/mailnews/compose/src/nsMsgCompose.cpp
@@ -0,0 +1,6052 @@
+/* -*- 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 "nsIDOMDocument.h"
+#include "nsIDOMNode.h"
+#include "nsIDOMNodeList.h"
+#include "nsIDOMText.h"
+#include "nsIDOMHTMLImageElement.h"
+#include "nsIDOMHTMLLinkElement.h"
+#include "nsIDOMHTMLAnchorElement.h"
+#include "nsPIDOMWindow.h"
+#include "mozIDOMWindow.h"
+#include "nsISelectionController.h"
+#include "nsMsgI18N.h"
+#include "nsMsgCompCID.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 "nsIPlaintextEditor.h"
+#include "nsIHTMLEditor.h"
+#include "nsIEditorMailSupport.h"
+#include "plstr.h"
+#include "prmem.h"
+#include "nsIDocShell.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "nsAbBaseCID.h"
+#include "nsIAbMDBDirectory.h"
+#include "nsCExternalHandlerService.h"
+#include "nsIMIMEService.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIWindowMediator.h"
+#include "nsIURL.h"
+#include "nsIMsgMailSession.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgMimeCID.h"
+#include "nsDateTimeFormatCID.h"
+#include "nsIDateTimeFormat.h"
+#include "nsILocaleService.h"
+#include "nsILocale.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 "nsUConvCID.h"
+#include "nsIUnicodeNormalizer.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgAttachment.h"
+#include "nsIMsgProgress.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIMsgDatabase.h"
+#include "nsStringStream.h"
+#include "nsIMutableArray.h"
+#include "nsArrayUtils.h"
+#include "nsIMsgWindow.h"
+#include "nsITextToSubURI.h"
+#include "nsIAbManager.h"
+#include "nsCRT.h"
+#include "mozilla/Services.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+#include "mozilla/Preferences.h"
+#include "nsStreamConverter.h"
+#include "nsISelection.h"
+#include "nsJSEnvironment.h"
+#include "nsIObserverService.h"
+#include "nsIProtocolHandler.h"
+#include "nsContentUtils.h"
+#include "nsIFileURL.h"
+
+using namespace mozilla;
+using namespace mozilla::mailnews;
+
+static nsresult GetReplyHeaderInfo(int32_t* reply_header_type,
+                                   nsString& reply_header_locale,
+                                   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_GetUnicharPreferenceWithDefault(prefBranch, "mailnews.reply_header_locale", EmptyString(), reply_header_locale);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  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);
+}
+
+static void GetTopmostMsgWindowCharacterSet(nsCString& charset, bool* charsetOverride)
+{
+  // HACK: if we are replying to a message and that message used a charset over ride
+  // (as specified in the top most window (assuming the reply originated from that window)
+  // then use that over ride charset instead of the charset specified in the message
+  nsCOMPtr <nsIMsgMailSession> mailSession (do_GetService(NS_MSGMAILSESSION_CONTRACTID));
+  if (mailSession)
+  {
+    nsCOMPtr<nsIMsgWindow>    msgWindow;
+    mailSession->GetTopmostMsgWindow(getter_AddRefs(msgWindow));
+    if (msgWindow)
+    {
+      msgWindow->GetMailCharacterSet(charset);
+      msgWindow->GetCharsetOverride(charsetOverride);
+    }
+  }
+}
+
+nsMsgCompose::nsMsgCompose()
+{
+
+  mQuotingToFollow = false;
+  mInsertingQuotedContent = false;
+  mWhatHolder = 1;
+  m_window = nullptr;
+  m_editor = nullptr;
+  mQuoteStreamListener=nullptr;
+  mCharsetOverride = false;
+  mAnswerDefaultCharset = 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;
+}
+
+
+nsMsgCompose::~nsMsgCompose()
+{
+  NS_IF_RELEASE(m_compFields);
+  NS_IF_RELEASE(mQuoteStreamListener);
+}
+
+/* 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(nsIDOMNode *aChild, nsIDOMNode *aParent, int32_t &aOffset)
+{
+  NS_ASSERTION((aChild && aParent), "bad args");
+  nsresult result = NS_ERROR_NULL_POINTER;
+  if (aChild && aParent)
+  {
+    nsCOMPtr<nsIDOMNodeList> childNodes;
+    result = aParent->GetChildNodes(getter_AddRefs(childNodes));
+    if ((NS_SUCCEEDED(result)) && (childNodes))
+    {
+      int32_t i=0;
+      for ( ; NS_SUCCEEDED(result); i++)
+      {
+        nsCOMPtr<nsIDOMNode> childNode;
+        result = childNodes->Item(i, getter_AddRefs(childNode));
+        if ((NS_SUCCEEDED(result)) && (childNode))
+        {
+          if (childNode.get()==aChild)
+          {
+            aOffset = i;
+            break;
+          }
+        }
+        else if (!childNode)
+          result = NS_ERROR_NULL_POINTER;
+      }
+    }
+    else if (!childNodes)
+      result = NS_ERROR_NULL_POINTER;
+  }
+  return result;
+}
+
+nsresult
+GetNodeLocation(nsIDOMNode *inChild, nsCOMPtr<nsIDOMNode> *outParent, int32_t *outOffset)
+{
+  NS_ASSERTION((outParent && outOffset), "bad args");
+  nsresult result = NS_ERROR_NULL_POINTER;
+  if (inChild && outParent && outOffset)
+  {
+    result = inChild->GetParentNode(getter_AddRefs(*outParent));
+    if ( (NS_SUCCEEDED(result)) && (*outParent) )
+    {
+      result = GetChildOffset(inChild, *outParent, *outOffset);
+    }
+  }
+
+  return result;
+}
+
+bool nsMsgCompose::IsEmbeddedObjectSafe(const char * originalScheme,
+                                          const char * originalHost,
+                                          const char * originalPath,
+                                          nsIDOMNode * object)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIDOMHTMLImageElement> image;
+  nsCOMPtr<nsIDOMHTMLLinkElement> link;
+  nsCOMPtr<nsIDOMHTMLAnchorElement> anchor;
+  nsAutoString objURL;
+
+  if (!object || !originalScheme || !originalPath) //having a null host is ok...
+    return false;
+
+  if ((image = do_QueryInterface(object)))
+  {
+    if (NS_FAILED(image->GetSrc(objURL)))
+      return false;
+  }
+  else if ((link = do_QueryInterface(object)))
+  {
+    if (NS_FAILED(link->GetHref(objURL)))
+      return false;
+  }
+  else if ((anchor = do_QueryInterface(object)))
+  {
+    if (NS_FAILED(anchor->GetHref(objURL)))
+      return false;
+  }
+  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->GetPath(path);
+          if (NS_SUCCEEDED(rv))
+          {
+            const char * query = strrchr(path.get(), '?');
+            if (query && PL_strncasecmp(path.get(), originalPath, query - path.get()) == 0)
+                return true; //This object is a part of the original message, we can send it safely.
+          }
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/* Reset the uri's of embedded objects because we've saved the draft message, and the
+   original message doesn't exist anymore.
+ */
+nsresult nsMsgCompose::ResetUrisForEmbeddedObjects()
+{
+  nsCOMPtr<nsIArray> aNodeList;
+  uint32_t numNodes;
+  uint32_t i;
+
+  nsCOMPtr<nsIEditorMailSupport> mailEditor (do_QueryInterface(m_editor));
+  if (!mailEditor)
+    return NS_ERROR_FAILURE;
+
+  nsresult rv = mailEditor->GetEmbeddedObjects(getter_AddRefs(aNodeList));
+  if (NS_FAILED(rv) || !aNodeList)
+    return NS_ERROR_FAILURE;
+
+  if (NS_FAILED(aNodeList->GetLength(&numNodes)))
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDOMNode> node;
+  nsCString curDraftIdURL;
+
+  rv = m_compFields->GetDraftId(getter_Copies(curDraftIdURL));
+
+  // Skip if no draft id (probably a new draft msg).
+  if (NS_SUCCEEDED(rv) && mMsgSend && !curDraftIdURL.IsEmpty())
+  {
+    nsCOMPtr <nsIMsgDBHdr> msgDBHdr;
+    rv = GetMsgDBHdrFromURI(curDraftIdURL.get(), getter_AddRefs(msgDBHdr));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "RemoveCurrentDraftMessage can't get msg header DB interface pointer.");
+    if (NS_SUCCEEDED(rv) && msgDBHdr)
+    {
+      // build up the old and new ?number= parts. This code assumes it is
+      // called *before* RemoveCurrentDraftMessage, so that curDraftIdURL
+      // is the previous draft.
+      // This code works for both imap and local messages.
+      nsMsgKey newMsgKey;
+      nsCString folderUri;
+      nsCString baseMsgUri;
+      mMsgSend->GetMessageKey(&newMsgKey);
+      mMsgSend->GetFolderUri(folderUri);
+      nsCOMPtr<nsIMsgFolder> folder;
+      rv = GetExistingFolder(folderUri, getter_AddRefs(folder));
+      NS_ENSURE_SUCCESS(rv, rv);
+      folder->GetBaseMessageURI(baseMsgUri);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIDOMElement> domElement;
+      for (i = 0; i < numNodes; i ++)
+      {
+        domElement = do_QueryElementAt(aNodeList, i);
+        if (!domElement)
+          continue;
+
+        nsCOMPtr<nsIDOMHTMLImageElement> image = do_QueryInterface(domElement);
+        if (!image)
+          continue;
+        nsCString partNum;
+        mMsgSend->GetPartForDomIndex(i, partNum);
+        // do we care about anything besides images?
+        nsAutoString objURL;
+        image->GetSrc(objURL);
+
+        // First we need to make sure that the URL is associated with a message
+        // protocol so we don't accidentally manipulate a URL like:
+        // http://www.site.com/retrieve.html?C=image.jpg.
+        nsCOMPtr<nsIIOService> ioService = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        nsAutoCString scheme;
+        ioService->ExtractScheme(NS_ConvertUTF16toUTF8(objURL), scheme);
+
+        // Detect message protocols where attachments can occur.
+        nsCOMPtr<nsIProtocolHandler> handler;
+        ioService->GetProtocolHandler(scheme.get(), getter_AddRefs(handler));
+        if (!handler)
+          continue;
+        nsCOMPtr<nsIMsgMessageFetchPartService> mailHandler = do_QueryInterface(handler);
+        if (!mailHandler)
+          continue;
+
+        // the objURL is the full path to the embedded content. We need
+        // to update it with uri for the folder we just saved to, and the new
+        // msg key.
+        int32_t restOfUrlIndex = objURL.Find("?number=");
+        if (restOfUrlIndex == kNotFound)
+          restOfUrlIndex = objURL.FindChar('?');
+        else
+          restOfUrlIndex = objURL.FindChar('&', restOfUrlIndex);
+
+        if (restOfUrlIndex == kNotFound)
+          continue;
+
+        nsCString newURI(baseMsgUri);
+        newURI.Append('#');
+        newURI.AppendInt(newMsgKey);
+        nsString restOfUrl(Substring(objURL, restOfUrlIndex, objURL.Length() - restOfUrlIndex));
+        int32_t partIndex = restOfUrl.Find("part=");
+        if (partIndex != kNotFound)
+        {
+          partIndex += 5;
+          int32_t endPart = restOfUrl.FindChar('&', partIndex);
+          int32_t existingPartLen = (endPart == kNotFound) ? -1 : endPart - partIndex;
+          restOfUrl.Replace(partIndex, existingPartLen, NS_ConvertASCIItoUTF16(partNum));
+        }
+
+        nsCOMPtr<nsIMsgMessageService> msgService;
+        rv = GetMessageServiceFromURI(newURI, getter_AddRefs(msgService));
+        if (NS_FAILED(rv))
+          continue;
+        nsCOMPtr<nsIURI> newUrl;
+        rv = msgService->GetUrlForUri(newURI.get(), getter_AddRefs(newUrl), nullptr);
+        if (!newUrl)
+          continue;
+        nsCString spec;
+        rv = newUrl->GetSpec(spec);
+        NS_ENSURE_SUCCESS(rv, rv);
+        nsString newSrc;
+        // mailbox urls will have ?number=xxx; imap urls won't. We need to
+        // handle both cases because we may be going from a mailbox url to
+        // and imap url, or vice versa, depending on the original folder,
+        // and the destination drafts folder.
+        bool specHasQ = (spec.FindChar('?') != kNotFound);
+        if (specHasQ && restOfUrl.CharAt(0) == '?')
+          restOfUrl.SetCharAt('&', 0);
+        else if (!specHasQ && restOfUrl.CharAt(0) == '&')
+          restOfUrl.SetCharAt('?', 0);
+        AppendUTF8toUTF16(spec, newSrc);
+        newSrc.Append(restOfUrl);
+        image->SetSrc(newSrc);
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+
+/* 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(nsIEditorMailSupport *aEditor)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIArray> aNodeList;
+  uint32_t count;
+  uint32_t i;
+
+  if (!aEditor)
+    return NS_ERROR_FAILURE;
+
+  rv = aEditor->GetEmbeddedObjects(getter_AddRefs(aNodeList));
+  if (NS_FAILED(rv) || !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.get(), getter_AddRefs(originalUrl), nullptr);
+    if (NS_SUCCEEDED(rv) && originalUrl)
+    {
+      originalUrl->GetScheme(originalScheme);
+      originalUrl->GetAsciiHost(originalHost);
+      originalUrl->GetPath(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<nsIDOMNode> node = do_QueryElementAt(aNodeList, i);
+    if (!node)
+      continue;
+    if (IsEmbeddedObjectSafe(originalScheme.get(), originalHost.get(),
+                             originalPath.get(), node))
+      continue; //Don't need to tag this object, it safe to send it.
+
+    //The source of this object should not be sent with the message
+    nsCOMPtr<nsIDOMElement> domElement = do_QueryInterface(node);
+    if (domElement)
+      domElement->SetAttribute(NS_LITERAL_STRING("moz-do-not-send"), NS_LITERAL_STRING("true"));
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::GetInsertingQuotedContent(bool * aInsertingQuotedText)
+{
+  NS_ENSURE_ARG_POINTER(aInsertingQuotedText);
+  *aInsertingQuotedText = mInsertingQuotedContent;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::SetInsertingQuotedContent(bool aInsertingQuotedText)
+{
+  mInsertingQuotedContent = aInsertingQuotedText;
+  return NS_OK;
+}
+
+void
+nsMsgCompose::InsertDivWrappedTextAtSelection(const nsAString &aText,
+                                              const nsAString &classStr)
+{
+  NS_ASSERTION(m_editor, "InsertDivWrappedTextAtSelection called, but no editor exists\n");
+  if (!m_editor)
+    return;
+
+  nsCOMPtr<nsIDOMElement> divElem;
+  nsCOMPtr<nsIHTMLEditor> htmlEditor(do_QueryInterface(m_editor));
+
+  nsresult rv = htmlEditor->CreateElementWithDefaults(NS_LITERAL_STRING("div"),
+                                                      getter_AddRefs(divElem));
+
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIDOMNode> divNode (do_QueryInterface(divElem));
+
+  // We need the document
+  nsCOMPtr<nsIDOMDocument> 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;
+
+    nsCOMPtr<nsIDOMText> textNode;
+    rv = doc->CreateTextNode(Substring(aText, start, delimiter - start), getter_AddRefs(textNode));
+    NS_ENSURE_SUCCESS_VOID(rv);
+
+    nsCOMPtr<nsIDOMNode> newTextNode = do_QueryInterface(textNode);
+    nsCOMPtr<nsIDOMNode> resultNode;
+    rv = divElem->AppendChild(newTextNode, getter_AddRefs(resultNode));
+    NS_ENSURE_SUCCESS_VOID(rv);
+
+    // Now create and insert a BR
+    nsCOMPtr<nsIDOMElement> brElem;
+    rv = htmlEditor->CreateElementWithDefaults(NS_LITERAL_STRING("br"),
+                                               getter_AddRefs(brElem));
+    rv = divElem->AppendChild(brElem, getter_AddRefs(resultNode));
+    NS_ENSURE_SUCCESS_VOID(rv);
+
+    if (delimiter == end)
+      break;
+    start = ++delimiter;
+    if (start == end)
+      break;
+  }
+
+  htmlEditor->InsertElementAtSelection(divElem, true);
+  nsCOMPtr<nsIDOMNode> parent;
+  int32_t offset;
+
+  rv = GetNodeLocation(divNode, address_of(parent), &offset);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsISelection> selection;
+    m_editor->GetSelection(getter_AddRefs(selection));
+
+    if (selection)
+      selection->Collapse(parent, offset + 1);
+  }
+  if (divElem)
+    divElem->SetAttribute(NS_LITERAL_STRING("class"), classStr);
+}
+
+/*
+ * 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.Find("<plaintext", /* ignoreCase = */ true, index)) != kNotFound) {
+    body.Insert(u"x-", index+1);
+    index += 12;
+    replaced = true;
+  }
+  if (replaced) {
+    index = 0;
+    while ((index = body.Find("</plaintext", /* ignoreCase = */ true, index)) != kNotFound) {
+      body.Insert(u"x-", index+2);
+      index += 13;
+    }
+  }
+}
+
+NS_IMETHODIMP
+nsMsgCompose::ConvertAndLoadComposeWindow(nsString& aPrefix,
+                                          nsString& aBuf,
+                                          nsString& aSignature,
+                                          bool aQuoted,
+                                          bool aHTMLEditor)
+{
+  NS_ASSERTION(m_editor, "ConvertAndLoadComposeWindow but no editor\n");
+  NS_ENSURE_TRUE(m_editor && m_identity, NS_ERROR_NOT_INITIALIZED);
+
+  // First, get the nsIEditor interface for future use
+  nsCOMPtr<nsIDOMNode> 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...
+  nsCOMPtr<nsIHTMLEditor> htmlEditor (do_QueryInterface(m_editor));
+  nsCOMPtr<nsIPlaintextEditor> textEditor (do_QueryInterface(m_editor));
+  nsCOMPtr<nsIEditorMailSupport> mailEditor (do_QueryInterface(m_editor));
+  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);
+
+  if (aQuoted)
+  {
+    mInsertingQuotedContent = true;
+    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
+        if (aHTMLEditor)
+          textEditor->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 (includeSignature && !sig_bottom &&
+            ((NS_SUCCEEDED(rv) && attachFile) || !prefSigText.IsEmpty()))
+          textEditor->InsertLineBreak();
+        else {
+          textEditor->InsertLineBreak();
+          textEditor->InsertLineBreak();
+        }
+      }
+
+      InsertDivWrappedTextAtSelection(aPrefix,
+                                      NS_LITERAL_STRING("moz-cite-prefix"));
+    }
+
+    if (!aBuf.IsEmpty() && mailEditor)
+    {
+      // This leaves the caret at the right place to insert a bottom signature.
+      if (aHTMLEditor) {
+        nsAutoString body(aBuf);
+        remove_plaintext_tag(body);
+        mailEditor->InsertAsCitedQuotation(body,
+                                           mCiteReference,
+                                           true,
+                                           getter_AddRefs(nodeInserted));
+      } else {
+        mailEditor->InsertAsQuotation(aBuf,
+                                      getter_AddRefs(nodeInserted));
+      }
+    }
+
+    mInsertingQuotedContent = false;
+
+    (void)TagEmbeddedObjects(mailEditor);
+
+    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 )
+        m_editor->BeginningOfDocument();
+
+      if (aHTMLEditor && htmlEditor)
+        htmlEditor->InsertHTML(aSignature);
+      else if (htmlEditor)
+      {
+        textEditor->InsertLineBreak();
+        InsertDivWrappedTextAtSelection(aSignature,
+                                        NS_LITERAL_STRING("moz-signature"));
+      }
+
+      if( sigOnTop )
+        m_editor->EndOfDocument();
+    }
+  }
+  else
+  {
+    if (aHTMLEditor && htmlEditor)
+    {
+      mInsertingQuotedContent = true;
+      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 newBody(aBuf);
+        nsString divTag;
+        divTag.AssignLiteral("<div class=\"moz-forward-container\">");
+        newBody.Insert(divTag, sizeof(MIME_FORWARD_HTML_PREFIX)-1-8);
+        remove_plaintext_tag(newBody);
+        htmlEditor->RebuildDocumentFromSource(newBody);
+      } else {
+        htmlEditor->RebuildDocumentFromSource(aBuf);
+      }
+      mInsertingQuotedContent = false;
+
+      // when forwarding a message as inline, tag any embedded objects
+      // which refer to local images or files so we know not to include
+      // send them
+      if (isForwarded)
+        (void)TagEmbeddedObjects(mailEditor);
+
+      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();
+        }
+        htmlEditor->InsertHTML(aSignature);
+        if (isForwarded && sigOnTop)
+          m_editor->EndOfDocument();
+      }
+      else
+        m_editor->EndOfDocument();
+    }
+    else if (htmlEditor)
+    {
+      bool sigOnTopInserted = false;
+      if (isForwarded && sigOnTop && !aSignature.IsEmpty())
+      {
+        textEditor->InsertLineBreak();
+        InsertDivWrappedTextAtSelection(aSignature,
+                                        NS_LITERAL_STRING("moz-signature"));
+        m_editor->EndOfDocument();
+        sigOnTopInserted = true;
+      }
+
+      if (!aBuf.IsEmpty())
+      {
+        nsresult rv;
+        nsCOMPtr<nsIDOMElement> divElem;
+        nsCOMPtr<nsIDOMNode> extraBr;
+
+        if (isForwarded) {
+          // Special treatment for forwarded messages: Part 1.
+          // Create a <div> of the required class.
+          rv = htmlEditor->CreateElementWithDefaults(NS_LITERAL_STRING("div"),
+                                                     getter_AddRefs(divElem));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          nsAutoString attributeName;
+          nsAutoString attributeValue;
+          attributeName.AssignLiteral("class");
+          attributeValue.AssignLiteral("moz-forward-container");
+          divElem->SetAttribute(attributeName, attributeValue);
+
+          // We can't insert an empty <div>, so fill it with something.
+          nsCOMPtr<nsIDOMElement> brElem;
+          rv = htmlEditor->CreateElementWithDefaults(NS_LITERAL_STRING("br"),
+                                                     getter_AddRefs(brElem));
+          NS_ENSURE_SUCCESS(rv, rv);
+          rv = divElem->AppendChild(brElem, getter_AddRefs(extraBr));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          // 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.
+          nsCOMPtr<nsISelection> selection;
+          m_editor->GetSelection(getter_AddRefs(selection));
+          rv = selection->Collapse(divElem, 0);
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+
+        if (mailEditor) {
+          rv = mailEditor->InsertTextWithQuotations(aBuf);
+        } else {
+          // Will we ever get here?
+          rv = textEditor->InsertText(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<nsIDOMNode> brBeforeDiv;
+            nsAutoString tagLocalName;
+            rv = divElem->GetPreviousSibling(getter_AddRefs(brBeforeDiv));
+            if (NS_SUCCEEDED(rv) && brBeforeDiv) {
+              brBeforeDiv->GetLocalName(tagLocalName);
+              if (tagLocalName.EqualsLiteral("br")) {
+                rv = m_editor->DeleteNode(brBeforeDiv);
+                NS_ENSURE_SUCCESS(rv, rv);
+              }
+            }
+          }
+
+          // Clean up the <br> we inserted.
+          rv = m_editor->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()) {
+        textEditor->InsertLineBreak();
+        InsertDivWrappedTextAtSelection(aSignature,
+                                        NS_LITERAL_STRING("moz-signature"));
+      }
+    }
+  }
+
+  if (aBuf.IsEmpty())
+    m_editor->BeginningOfDocument();
+  else
+  {
+    switch (reply_on_top)
+    {
+      // This should set the cursor after the body but before the sig
+      case 0:
+      {
+        if (!textEditor)
+        {
+          m_editor->BeginningOfDocument();
+          break;
+        }
+
+        nsCOMPtr<nsISelection> selection = nullptr;
+        nsCOMPtr<nsIDOMNode>      parent = nullptr;
+        int32_t                   offset;
+        nsresult                  rv;
+
+        // get parent and offset of mailcite
+        rv = GetNodeLocation(nodeInserted, address_of(parent), &offset);
+        if (NS_FAILED(rv) || (!parent))
+        {
+          m_editor->BeginningOfDocument();
+          break;
+        }
+
+        // get selection
+        m_editor->GetSelection(getter_AddRefs(selection));
+        if (!selection)
+        {
+          m_editor->BeginningOfDocument();
+          break;
+        }
+
+        // place selection after mailcite
+        selection->Collapse(parent, offset+1);
+
+        // insert a break at current selection
+        textEditor->InsertLineBreak();
+
+        // i'm not sure if you need to move the selection back to before the
+        // break. expirement.
+        selection->Collapse(parent, offset+1);
+
+        break;
+      }
+
+      case 2:
+      {
+        m_editor->SelectAll();
+        break;
+      }
+
+      // This should set the cursor to the top!
+      default:
+      {
+        m_editor->BeginningOfDocument();
+        break;
+      }
+    }
+  }
+
+  nsCOMPtr<nsISelectionController> selCon;
+  m_editor->GetSelectionController(getter_AddRefs(selCon));
+
+  if (selCon)
+    selCon->ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL, nsISelectionController::SELECTION_ANCHOR_REGION, true);
+
+  m_editor->EnableUndo(true);
+  SetBodyModified(false);
+
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+  nsCOMPtr<nsIMsgComposeService> composeService (do_GetService(NS_MSGCOMPOSESERVICE_CONTRACTID));
+  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 =
+      do_QueryInterface(window->GetDocShell());
+    nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
+    rv = treeItem->GetTreeOwner(getter_AddRefs(treeOwner));
+    if (NS_FAILED(rv)) return rv;
+
+    m_baseWindow = do_QueryInterface(treeOwner);
+  }
+
+  MSG_ComposeFormat format;
+  aParams->GetFormat(&format);
+
+  MSG_ComposeType type;
+  aParams->GetType(&type);
+
+  nsCString originalMsgURI;
+  aParams->GetOriginalMsgURI(getter_Copies(originalMsgURI));
+  aParams->GetOrigMsgHdr(getter_AddRefs(mOrigMsgHdr));
+
+  nsCOMPtr<nsIMsgCompFields> composeFields;
+  aParams->GetComposeFields(getter_AddRefs(composeFields));
+
+  nsCOMPtr<nsIMsgComposeService> composeService = do_GetService(NS_MSGCOMPOSESERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = composeService->DetermineComposeHTML(m_identity, format, &m_composeHTML);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  if (composeFields)
+  {
+    nsAutoCString draftId; // will get set for drafts and templates
+    rv = composeFields->GetDraftId(getter_Copies(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 );
+
+  nsCString smtpPassword;
+  aParams->GetSmtpPassword(getter_Copies(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.get(), type, composeFields);
+}
+
+nsresult nsMsgCompose::SetDocumentCharset(const char *aCharset)
+{
+  NS_ENSURE_TRUE(m_compFields && m_editor, NS_ERROR_NOT_INITIALIZED);
+
+  // Set charset, this will be used for the MIME charset labeling.
+  m_compFields->SetCharacterSet(aCharset);
+
+  // notify the change to editor
+  nsCString charset;
+  if (aCharset)
+    charset = nsDependentCString(aCharset);
+  if (m_editor)
+    m_editor->SetDocumentCharacterSet(charset);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::RegisterStateListener(nsIMsgComposeStateListener *aStateListener)
+{
+  NS_ENSURE_ARG_POINTER(aStateListener);
+
+  return mStateListeners.AppendElement(aStateListener) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+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);
+  return mExternalSendListeners.AppendElement(aMsgSendListener) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+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)
+{
+  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.AppendLiteral(",");
+
+    // Second parameter: deliverMode.
+    sendParms.AppendInt(deliverMode);
+    sendParms.AppendLiteral(",");
+
+    // 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(NS_MSGSEND_CONTRACTID);
+
+    if (mMsgSend)
+    {
+      nsCString bodyString(m_compFields->GetBody());
+
+      // Create the listener for the send operation...
+      nsCOMPtr<nsIMsgComposeSendListener> composeSendListener = do_CreateInstance(NS_MSGCOMPOSESENDLISTENER_CONTRACTID);
+      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);
+      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,
+                    nullptr,
+                    nullptr,
+                    m_window,
+                    mProgress,
+                    sendListener,
+                    mSmtpPassword.get(),
+                    mOriginalMsgURI,
+                    mType);
+    }
+    else
+        rv = NS_ERROR_FAILURE;
+  }
+  else
+    rv = NS_ERROR_NOT_INITIALIZED;
+
+  if (NS_FAILED(rv))
+    NotifyStateListeners(nsIMsgComposeNotificationType::ComposeProcessDone, rv);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgCompose::SendMsg(MSG_DeliverMode deliverMode, nsIMsgIdentity *identity, const char *accountKey, nsIMsgWindow *aMsgWindow, nsIMsgProgress *progress)
+{
+  NS_ENSURE_TRUE(m_compFields, NS_ERROR_NOT_INITIALIZED);
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIPrompt> prompt;
+
+  // i'm assuming the compose window is still up at this point...
+  if (m_window) {
+    nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(m_window);
+    window->GetPrompter(getter_AddRefs(prompt));
+  }
+
+  // Set content type based on which type of compose window we had.
+  nsString contentType = (m_composeHTML) ? NS_LITERAL_STRING("text/html"):
+                                           NS_LITERAL_STRING("text/plain");
+  nsString msgBody;
+  if (m_editor)
+  {
+    // Reset message body previously stored in the compose fields
+    // There is 2 nsIMsgCompFields::SetBody() functions using a pointer as argument,
+    // therefore a casting is required.
+    m_compFields->SetBody((const char *)nullptr);
+
+    const char *charset = m_compFields->GetCharacterSet();
+
+    uint32_t flags = nsIDocumentEncoder::OutputCRLineBreak |
+                     nsIDocumentEncoder::OutputLFLineBreak;
+
+    if (m_composeHTML) {
+      flags |= nsIDocumentEncoder::OutputFormatted |
+               nsIDocumentEncoder::OutputDisallowLineBreaking;
+    } else {
+      bool flowed, delsp, formatted, disallowBreaks;
+      GetSerialiserFlags(charset, &flowed, &delsp, &formatted, &disallowBreaks);
+      if (flowed)
+        flags |= nsIDocumentEncoder::OutputFormatFlowed;
+      if (delsp)
+        flags |= nsIDocumentEncoder::OutputFormatDelSp;
+      if (formatted)
+        flags |= nsIDocumentEncoder::OutputFormatted;
+      if (disallowBreaks)
+        flags |= nsIDocumentEncoder::OutputDisallowLineBreaking;
+      // Don't lose NBSP in the plain text encoder.
+      flags |= nsIDocumentEncoder::OutputPersistNBSP;
+    }
+    rv = m_editor->OutputToString(contentType, flags, msgBody);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  else
+  {
+    m_compFields->GetBody(msgBody);
+  }
+  if (!msgBody.IsEmpty())
+  {
+    // Convert body to mail charset
+    nsCString outCString;
+    rv = nsMsgI18NConvertFromUnicode(m_compFields->GetCharacterSet(),
+      msgBody, outCString, false, true);
+    bool isAsciiOnly = NS_IsAscii(outCString.get()) &&
+      !nsMsgI18Nstateful_charset(m_compFields->GetCharacterSet());
+    if (m_compFields->GetForceMsgEncoding())
+      isAsciiOnly = false;
+    if (NS_SUCCEEDED(rv) && !outCString.IsEmpty())
+    {
+      // If the body contains characters outside the repertoire of the current
+      // charset, just convert to UTF-8 and be done with it
+      // unless disable_fallback_to_utf8 is set for this charset.
+      if (NS_ERROR_UENC_NOMAPPING == rv)
+      {
+        bool needToCheckCharset;
+        m_compFields->GetNeedToCheckCharset(&needToCheckCharset);
+        if (needToCheckCharset)
+        {
+          bool disableFallback = false;
+          nsCOMPtr<nsIPrefBranch> prefBranch (do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+          if (prefBranch)
+          {
+            nsCString prefName("mailnews.disable_fallback_to_utf8.");
+            prefName.Append(m_compFields->GetCharacterSet());
+            prefBranch->GetBoolPref(prefName.get(), &disableFallback);
+          }
+          if (!disableFallback)
+          {
+            CopyUTF16toUTF8(msgBody, outCString);
+            m_compFields->SetCharacterSet("UTF-8");
+            SetDocumentCharset("UTF-8");
+          }
+        }
+      }
+      m_compFields->SetBodyIsAsciiOnly(isAsciiOnly);
+      m_compFields->SetBody(outCString.get());
+    }
+    else
+    {
+      m_compFields->SetBody(NS_ConvertUTF16toUTF8(msgBody).get());
+      m_compFields->SetCharacterSet("UTF-8");
+      SetDocumentCharset("UTF-8");
+    }
+  }
+
+  // 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(NS_MSGCOMPOSEPROGRESSPARAMS_CONTRACTID, &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.xul",
+                                        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/x-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(NS_MSGATTACHMENT_CONTRACTID, &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(NS_LITERAL_STRING("vcard.vcf"));
+              else
+              {
+                  // Replace any dot with underscore to stop vCards
+                  // generating false positives with some heuristic scanners
+                  MsgReplaceChar(userid, '.', '_');
+                  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;
+
+  rv = SendMsgToServer(deliverMode, identity, accountKey);
+  if (NS_FAILED(rv))
+  {
+    nsCOMPtr<nsIMsgSendReport> sendReport;
+    if (mMsgSend)
+      mMsgSend->GetSendReport(getter_AddRefs(sendReport));
+    if (sendReport)
+    {
+      nsresult theError;
+      sendReport->DisplayReport(prompt, true, true, &theError);
+    }
+    else
+    {
+      /* If we come here it's because we got an error before we could intialize a
+         send report! Let's try our best...
+      */
+      switch (deliverMode)
+      {
+        case nsIMsgCompDeliverMode::Later:
+          nsMsgDisplayMessageByName(prompt, u"unableToSendLater");
+          break;
+        case nsIMsgCompDeliverMode::AutoSaveAsDraft:
+        case nsIMsgCompDeliverMode::SaveAsDraft:
+          nsMsgDisplayMessageByName(prompt, u"unableToSaveDraft");
+          break;
+        case nsIMsgCompDeliverMode::SaveAsTemplate:
+          nsMsgDisplayMessageByName(prompt, u"unableToSaveTemplate");
+          break;
+
+        default:
+          nsMsgDisplayMessageByName(prompt, u"sendFailed");
+          break;
+      }
+    }
+
+    if (progress)
+      progress->CloseProgressDialog(true);
+  }
+
+  return rv;
+}
+
+/* attribute boolean deleteDraft */
+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(NS_MSGCOMPOSESERVICE_CONTRACTID, &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;
+    }
+    nsIBaseWindow * window = m_baseWindow;
+    m_baseWindow = nullptr;
+    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;
+}
+
+static nsresult fixCharset(nsCString &aCharset)
+{
+  // No matter what, we should block x-windows-949 (our internal name)
+  // from being used for outgoing emails (bug 234958).
+  if (aCharset.Equals("x-windows-949", nsCaseInsensitiveCStringComparator()))
+    aCharset = "EUC-KR";
+
+  // Convert to a canonical charset name.
+  // Bug 1297118 will revisit this call site.
+  nsresult rv;
+  nsCOMPtr<nsICharsetConverterManager> ccm =
+    do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString charset(aCharset);
+  rv = ccm->GetCharsetAlias(charset.get(), aCharset);
+
+  // Don't accept UTF-16 ever. UTF-16 should never be selected as an
+  // outgoing encoding for e-mail. MIME can't handle those messages
+  // encoded in ASCII-incompatible encodings.
+  if (NS_FAILED(rv) ||
+      StringBeginsWith(aCharset, NS_LITERAL_CSTRING("UTF-16"))) {
+    aCharset.AssignLiteral("UTF-8");
+  }
+  return NS_OK;
+}
+
+// This used to be called BEFORE editor was created
+//  (it did the loadUrl that triggered editor creation)
+// It is called from JS after editor creation
+//  (loadUrl is done in JS)
+NS_IMETHODIMP nsMsgCompose::InitEditor(nsIEditor* aEditor, mozIDOMWindowProxy* aContentWindow)
+{
+  NS_ENSURE_ARG_POINTER(aEditor);
+  NS_ENSURE_ARG_POINTER(aContentWindow);
+  nsresult rv;
+
+  m_editor = aEditor;
+
+  nsAutoCString msgCharSet(m_compFields->GetCharacterSet());
+  rv = fixCharset(msgCharSet);
+  NS_ENSURE_SUCCESS(rv, rv);
+  m_compFields->SetCharacterSet(msgCharSet.get());
+  m_editor->SetDocumentCharacterSet(msgCharSet);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aContentWindow);
+
+  nsIDocShell *docShell = window->GetDocShell();
+  NS_ENSURE_TRUE(docShell, NS_ERROR_UNEXPECTED);
+
+  nsCOMPtr<nsIContentViewer> childCV;
+  NS_ENSURE_SUCCESS(docShell->GetContentViewer(getter_AddRefs(childCV)), NS_ERROR_FAILURE);
+  if (childCV)
+  {
+    // SetForceCharacterSet will complain about "UTF-7" or "x-mac-croatian"
+    // (see test-charset-edit.js), but we deal with this elsewhere.
+    rv = childCV->SetForceCharacterSet(msgCharSet);
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "SetForceCharacterSet() failed");
+  }
+
+  // This is what used to be done in mDocumentListener,
+  //   nsMsgDocumentStateListener::NotifyDocumentCreated()
+  bool quotingToFollow = false;
+  GetQuotingToFollow(&quotingToFollow);
+  if (quotingToFollow)
+    return BuildQuotedMessageAndSignature();
+  else
+  {
+    NotifyStateListeners(nsIMsgComposeNotificationType::ComposeFieldsReady, NS_OK);
+    rv = BuildBodyMessageAndSignature();
+    NotifyStateListeners(nsIMsgComposeNotificationType::ComposeBodyReady, NS_OK);
+    return rv;
+  }
+}
+
+NS_IMETHODIMP nsMsgCompose::GetBodyRaw(nsACString& aBodyRaw)
+{
+  aBodyRaw.Assign((char *)m_compFields->GetBody());
+  return NS_OK;
+}
+
+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;
+}
+
+nsresult nsMsgCompose::SetBodyModified(bool modified)
+{
+  nsresult  rv = NS_OK;
+
+  if (m_editor)
+  {
+    if (modified)
+    {
+      int32_t  modCount = 0;
+      m_editor->GetModificationCount(&modCount);
+      if (modCount == 0)
+        m_editor->IncrementModificationCount(1);
+    }
+    else
+      m_editor->ResetModificationCount();
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::GetDomWindow(mozIDOMWindowProxy * *aDomWindow)
+{
+  NS_IF_ADDREF(*aDomWindow = m_window);
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::GetCompFields(nsIMsgCompFields * *aCompFields)
+{
+  *aCompFields = (nsIMsgCompFields*)m_compFields;
+  NS_IF_ADDREF(*aCompFields);
+  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 char * 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, NS_LITERAL_CSTRING("file:"));
+  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.Append("&realtype=message/rfc822");
+    }
+    originalMsgURI = msgUri.get();
+  }
+
+  if (compFields)
+  {
+    NS_IF_RELEASE(m_compFields);
+    m_compFields = reinterpret_cast<nsMsgCompFields*>(compFields);
+    NS_ADDREF(m_compFields);
+  }
+  else
+  {
+    m_compFields = new nsMsgCompFields();
+    if (m_compFields)
+      NS_ADDREF(m_compFields);
+    else
+      return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  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(getter_Copies(curDraftIdURL));
+    NS_ASSERTION(NS_SUCCEEDED(rv) && !curDraftIdURL.IsEmpty(), "CreateMessage can't get draft id");
+
+    // Skip if no draft id (probably a new draft msg).
+    if (NS_SUCCEEDED(rv) && !curDraftIdURL.IsEmpty())
+    {
+      nsCOMPtr <nsIMsgDBHdr> msgDBHdr;
+      rv = GetMsgDBHdrFromURI(curDraftIdURL.get(), 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, getter_Copies(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, getter_Copies(originalMsgURIfromDB));
+        mOriginalMsgURI = originalMsgURIfromDB;
+        if (!queuedDisposition.IsEmpty())
+        {
+          if (queuedDisposition.Equals("replied"))
+             mDraftDisposition = nsIMsgFolder::nsMsgDispositionState_Replied;
+          else if (queuedDisposition.Equals("forward"))
+             mDraftDisposition = nsIMsgFolder::nsMsgDispositionState_Forwarded;
+        }
+      }
+    }
+  }
+
+  // If we don't have an original message URI, nothing else to do...
+  if (!originalMsgURI || *originalMsgURI == 0)
+    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 = originalMsgURI;
+
+  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)
+  {
+    // Use charset set up in the compose fields by MIME unless we should
+    // use the default charset.
+    bool replyInDefault = false;
+    prefs->GetBoolPref("mailnews.reply_in_default_charset",
+                        &replyInDefault);
+    // Use send_default_charset if reply_in_default_charset is on.
+    if (replyInDefault)
+    {
+      nsString str;
+      nsCString charset;
+      NS_GetLocalizedUnicharPreferenceWithDefault(prefs, "mailnews.send_default_charset",
+                                                  EmptyString(), str);
+      if (!str.IsEmpty())
+      {
+        LossyCopyUTF16toASCII(str, charset);
+        m_compFields->SetCharacterSet(charset.get());
+        mAnswerDefaultCharset = true;
+      }
+    }
+
+    // We want to treat this message as a reference too
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    rv = GetMsgDBHdrFromURI(originalMsgURI, 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.AppendLiteral("<");
+            reference.Append(ref);
+            reference.AppendLiteral("> ");
+          }
+        }
+        reference.Trim(" ", false, true);
+      }
+      msgHdr->GetMessageId(getter_Copies(messageId));
+      reference.AppendLiteral("<");
+      reference.Append(messageId);
+      reference.AppendLiteral(">");
+      m_compFields->SetReferences(reference.get());
+    }
+
+    // Early return for "Forward inline" and "Reply with template" processing.
+    return NS_OK;
+  }
+
+  // All other processing.
+  char *uriList = PL_strdup(originalMsgURI);
+  if (!uriList)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  // Resulting charset for this message.
+  nsCString charset;
+
+  // Check for the charset of the last displayed message, it
+  // will be used for quoting and as override.
+  nsCString windowCharset;
+  mCharsetOverride = false;
+  mAnswerDefaultCharset = false;
+  GetTopmostMsgWindowCharacterSet(windowCharset, &mCharsetOverride);
+  if (!windowCharset.IsEmpty()) {
+    // Although the charset in which to send the message might change,
+    // the original message will be parsed for quoting using the charset it is
+    // now displayed with.
+    mQuoteCharset = windowCharset;
+
+    if (mCharsetOverride) {
+      // Use override charset.
+      charset = windowCharset;
+    }
+  }
+
+  // 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 *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(uri, getter_AddRefs(msgHdr));
+      NS_ENSURE_SUCCESS(rv,rv);
+    }
+    if (msgHdr)
+    {
+      nsCString decodedCString;
+
+      bool replyInDefault = false;
+      prefs->GetBoolPref("mailnews.reply_in_default_charset",
+                          &replyInDefault);
+      // Use send_default_charset if reply_in_default_charset is on.
+      if (replyInDefault)
+      {
+        nsString str;
+        NS_GetLocalizedUnicharPreferenceWithDefault(prefs, "mailnews.send_default_charset",
+                                                    EmptyString(), str);
+        if (!str.IsEmpty()) {
+          LossyCopyUTF16toASCII(str, charset);
+          mAnswerDefaultCharset = true;
+        }
+      }
+
+      // Set the charset we determined, if any, in the comp fields.
+      // For replies, the charset will be set after processing the message
+      // through MIME in QuotingOutputStreamListener::OnStopRequest().
+      if (isFirstPass && !charset.IsEmpty())
+        m_compFields->SetCharacterSet(charset.get());
+
+      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(NS_LITERAL_STRING(" (was:"));
+      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(getter_Copies(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::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.Insert(NS_LITERAL_STRING("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(NS_LITERAL_CSTRING("<"));
+              reference.Append(messageId);
+              reference.Append(NS_LITERAL_CSTRING(">"));
+              m_compFields->SetReferences(reference.get());
+            }
+            else
+            {
+              nsAutoCString references;
+              m_compFields->GetReferences(getter_Copies(references));
+              references.Append(NS_LITERAL_CSTRING(" <"));
+              references.Append(messageId);
+              references.Append(NS_LITERAL_CSTRING(">"));
+              m_compFields->SetReferences(references.get());
+            }
+
+            uint32_t flags;
+
+            msgHdr->GetFlags(&flags);
+            if (flags & nsMsgMessageFlags::HasRe)
+              subject.Insert(NS_LITERAL_STRING("Re: "), 0);
+
+            // Setup quoting callbacks for later...
+            mQuotingToFollow = false;  //We don't need to quote the original message.
+            nsCOMPtr<nsIMsgAttachment> attachment = do_CreateInstance(NS_MSGATTACHMENT_CONTRACTID, &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::services::GetStringBundleService();
+                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(u"messageAttachmentSafeName",
+                                                 getter_Copies(sanitizedSubj));
+              }
+              else
+                sanitizedSubj.Assign(subject);
+
+              // set the file size
+              uint32_t messageSize;
+              msgHdr->GetMessageSize(&messageSize);
+              attachment->SetSize(messageSize);
+
+              // change all '.' to '_'  see bug #271211
+              MsgReplaceChar(sanitizedSubj, ".", '_');
+              if (addExtension)
+                sanitizedSubj.AppendLiteral(".eml");
+              attachment->SetName(sanitizedSubj);
+              attachment->SetUrl(nsDependentCString(uri));
+              m_compFields->AddAttachment(attachment);
+            }
+
+            if (isFirstPass)
+            {
+              nsCString fwdPrefix;
+              prefs->GetCharPref("mail.forward_subject_prefix", getter_Copies(fwdPrefix));
+              if (!fwdPrefix.IsEmpty())
+              {
+                nsString unicodeFwdPrefix;
+                CopyUTF8toUTF16(fwdPrefix, unicodeFwdPrefix);
+                unicodeFwdPrefix.AppendLiteral(": ");
+                subject.Insert(unicodeFwdPrefix, 0);
+              }
+              else
+              {
+                subject.Insert(NS_LITERAL_STRING("Fwd: "), 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->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);
+            break;
+          }
+      }
+    }
+    isFirstPass = false;
+    uri = nextUri + 1;
+  }
+  while (nextUri);
+  PR_Free(uriList);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetProgress(nsIMsgProgress **_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = mProgress;
+  NS_IF_ADDREF(*_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetMessageSend(nsIMsgSend **_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = mMsgSend;
+  NS_IF_ADDREF(*_retval);
+  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 char *folderURI)
+{
+  m_folderName = folderURI;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetSavedFolderURI(char ** folderURI)
+{
+  NS_ENSURE_ARG_POINTER(folderURI);
+  *folderURI = ToNewCString(m_folderName);
+  return (*folderURI) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsMsgCompose::GetOriginalMsgURI(char ** originalMsgURI)
+{
+  NS_ENSURE_ARG_POINTER(originalMsgURI);
+  *originalMsgURI = ToNewCString(mOriginalMsgURI);
+  return (*originalMsgURI) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// THIS IS THE CLASS THAT IS THE STREAM CONSUMER OF THE HTML OUPUT
+// FROM LIBMIME. THIS IS FOR QUOTING
+////////////////////////////////////////////////////////////////////////////////////
+QuotingOutputStreamListener::~QuotingOutputStreamListener()
+{
+  if (mUnicodeConversionBuffer)
+    free(mUnicodeConversionBuffer);
+}
+
+QuotingOutputStreamListener::QuotingOutputStreamListener(const char * originalMsgURI,
+                                                         nsIMsgDBHdr *originalMsgHdr,
+                                                         bool quoteHeaders,
+                                                         bool headersOnly,
+                                                         nsIMsgIdentity *identity,
+                                                         nsIMsgQuote* msgQuote,
+                                                         bool charsetFixed,
+                                                         bool quoteOriginal,
+                                                         const nsACString& htmlToQuote)
+{
+  nsresult rv;
+  mQuoteHeaders = quoteHeaders;
+  mHeadersOnly = headersOnly;
+  mIdentity = identity;
+  mOrigMsgHdr = originalMsgHdr;
+  mUnicodeBufferCharacterLength = 0;
+  mUnicodeConversionBuffer = nullptr;
+  mQuoteOriginal = quoteOriginal;
+  mHtmlToQuote = htmlToQuote;
+  mQuote = msgQuote;
+  mCharsetFixed = charsetFixed;
+
+  if (!mHeadersOnly || !mHtmlToQuote.IsEmpty())
+  {
+    // Get header type, locale and strings from pref.
+    int32_t replyHeaderType;
+    nsAutoString replyHeaderLocale;
+    nsString replyHeaderAuthorWrote;
+    nsString replyHeaderOnDateAuthorWrote;
+    nsString replyHeaderAuthorWroteOnDate;
+    nsString replyHeaderOriginalmessage;
+    GetReplyHeaderInfo(&replyHeaderType,
+                       replyHeaderLocale,
+                       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)
+        {
+          nsCOMPtr<nsIDateTimeFormat> dateFormatter = do_CreateInstance(NS_DATETIMEFORMAT_CONTRACTID, &rv);
+          if (NS_SUCCEEDED(rv))
+          {
+            PRTime originalMsgDate;
+            rv = originalMsgHdr->GetDate(&originalMsgDate);
+            if (NS_SUCCEEDED(rv))
+            {
+              nsCOMPtr<nsILocale> locale;
+              nsCOMPtr<nsILocaleService> localeService(do_GetService(NS_LOCALESERVICE_CONTRACTID));
+
+              // Format date using "mailnews.reply_header_locale", if empty then use application default locale.
+              if (!replyHeaderLocale.IsEmpty())
+                rv = localeService->NewLocale(replyHeaderLocale, getter_AddRefs(locale));
+              if (NS_SUCCEEDED(rv))
+              {
+                nsAutoString citeDatePart;
+                if ((placeholderIndex = mCitePrefix.Find("#2")) != kNotFound)
+                {
+                  rv = dateFormatter->FormatPRTime(locale,
+                                                   kDateFormatShort,
+                                                   kTimeFormatNone,
+                                                   originalMsgDate,
+                                                   citeDatePart);
+                  if (NS_SUCCEEDED(rv))
+                    mCitePrefix.Replace(placeholderIndex, 2, citeDatePart);
+                }
+                if ((placeholderIndex = mCitePrefix.Find("#3")) != kNotFound)
+                {
+                  rv = dateFormatter->FormatPRTime(locale,
+                                                   kDateFormatNone,
+                                                   kTimeFormatNoSeconds,
+                                                   originalMsgDate,
+                                                   citeDatePart);
+                  if (NS_SUCCEEDED(rv))
+                    mCitePrefix.Replace(placeholderIndex, 2, citeDatePart);
+                }
+              }
+            }
+          }
+        }
+
+        if ((placeholderIndex = mCitePrefix.Find("#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 delsp,
+                                                bool formatted,
+                                                bool disallowBreaks)
+{
+  nsresult rv = ConvertBufToPlainText(mMsgBody, formatflowed,
+                                                delsp,
+                                                formatted,
+                                                disallowBreaks);
+  NS_ENSURE_SUCCESS (rv, rv);
+  return ConvertBufToPlainText(mSignature, formatflowed,
+                                           delsp,
+                                           formatted,
+                                           disallowBreaks);
+}
+
+NS_IMETHODIMP QuotingOutputStreamListener::OnStartRequest(nsIRequest *request, nsISupports * /* ctxt */)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP QuotingOutputStreamListener::OnStopRequest(nsIRequest *request, nsISupports *ctxt, 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(NS_MIME_CONVERTER_CONTRACTID, &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      nsCString charset;
+      compFields->GetCharacterSet(getter_Copies(charset));
+
+      if (!mCharsetFixed) {
+        // Get the charset from the channel where MIME left it.
+        if (mQuote) {
+          nsCOMPtr<nsIChannel> quoteChannel;
+          mQuote->GetQuoteChannel(getter_AddRefs(quoteChannel));
+          if (quoteChannel) {
+            quoteChannel->GetContentCharset(charset);
+            if (!charset.IsEmpty()) {
+              rv = fixCharset(charset);
+              NS_ENSURE_SUCCESS(rv, rv);
+              compFields->SetCharacterSet(charset.get());
+            }
+          }
+        }
+      }
+
+      mHeaders->ExtractHeader(HEADER_FROM, true, outCString);
+      ConvertRawBytesToUTF16(outCString, charset.get(), from);
+
+      mHeaders->ExtractHeader(HEADER_TO, true, outCString);
+      ConvertRawBytesToUTF16(outCString, charset.get(), to);
+
+      mHeaders->ExtractHeader(HEADER_CC, true, outCString);
+      ConvertRawBytesToUTF16(outCString, charset.get(), cc);
+
+      mHeaders->ExtractHeader(HEADER_BCC, true, outCString);
+      ConvertRawBytesToUTF16(outCString, charset.get(), bcc);
+
+      mHeaders->ExtractHeader(HEADER_MAIL_FOLLOWUP_TO, true, outCString);
+      ConvertRawBytesToUTF16(outCString, charset.get(), mailFollowupTo);
+
+      mHeaders->ExtractHeader(HEADER_REPLY_TO, false, outCString);
+      ConvertRawBytesToUTF16(outCString, charset.get(), replyTo);
+
+      mHeaders->ExtractHeader(HEADER_MAIL_REPLY_TO, true, outCString);
+      ConvertRawBytesToUTF16(outCString, charset.get(), 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("<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(EncodedHeader(NS_ConvertUTF16toUTF8(from)), fromEmailAddress);
+
+      nsTArray<nsCString> toEmailAddresses;
+      ExtractEmails(EncodedHeader(NS_ConvertUTF16toUTF8(to)),
+        UTF16ArrayAdapter<>(toEmailAddresses));
+
+      nsTArray<nsCString> ccEmailAddresses;
+      ExtractEmails(EncodedHeader(NS_ConvertUTF16toUTF8(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(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+      NS_ENSURE_SUCCESS(rv,rv);
+
+      nsCOMPtr<nsIArray> identities;
+      nsCString accountKey;
+      mOrigMsgHdr->GetAccountKey(getter_Copies(accountKey));
+      if (replyToSelfCheckAll)
+      {
+        // Check all avaliable identities if the pref was set.
+        accountManager->GetAllIdentities(getter_AddRefs(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)
+          account->GetIdentities(getter_AddRefs(identities));
+      }
+      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)
+            accountManager->GetIdentitiesForServer(nsIMsgIncomingServer, getter_AddRefs(identities));
+        }
+      }
+
+      bool isReplyToSelf = false;
+      nsCOMPtr<nsIMsgIdentity> selfIdentity;
+      if (identities)
+      {
+        // Go through the identities to see if any of them is the author of
+        // the email.
+        nsCOMPtr<nsIMsgIdentity> lookupIdentity;
+
+        uint32_t count = 0;
+        identities->GetLength(&count);
+
+        for (uint32_t i = 0; i < count; i++)
+        {
+          lookupIdentity = do_QueryElementAt(identities, i, &rv);
+          if (NS_FAILED(rv))
+            continue;
+
+          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))
+          {
+            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 (uint32_t j = 0; j < count; j++)
+            {
+              nsCOMPtr<nsIMsgIdentity> lookupIdentity2;
+              rv = identities->QueryElementAt(j, NS_GET_IID(nsIMsgIdentity),
+                                              getter_AddRefs(lookupIdentity2));
+              if (NS_FAILED(rv))
+                continue;
+
+              nsCString curIdentityEmail2;
+              lookupIdentity2->GetEmail(curIdentityEmail2);
+              if (toEmailAddresses.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 (ccEmailAddresses.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::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;
+          nsCOMPtr<nsIPrompt> prompt;
+          compose->GetDomWindow(getter_AddRefs(domWindow));
+          NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
+          nsCOMPtr<nsPIDOMWindowOuter> composeWindow = nsPIDOMWindowOuter::From(domWindow);
+          if (composeWindow)
+            composeWindow->GetPrompter(getter_AddRefs(prompt));
+          nsMsgDisplayMessageByName(prompt, u"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;
+          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(NS_MSGCOMPOSESERVICE_CONTRACTID));
+  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,
+                            false,  // delsp makes no sense in this context
+                            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,
+                              nsISupports *ctxt, 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;
+}
+
+NS_IMETHODIMP QuotingOutputStreamListener::AppendToMsgBody(const nsCString &inStr)
+{
+  nsresult rv = NS_OK;
+
+  if (!inStr.IsEmpty())
+  {
+    // Create unicode decoder.
+    if (!mUnicodeDecoder)
+    {
+      nsCOMPtr<nsICharsetConverterManager> ccm =
+               do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
+      if (NS_SUCCEEDED(rv))
+      {
+        rv = ccm->GetUnicodeDecoderRaw("UTF-8",
+                                       getter_AddRefs(mUnicodeDecoder));
+      }
+    }
+
+    if (NS_SUCCEEDED(rv))
+    {
+      int32_t unicharLength;
+      int32_t inputLength = inStr.Length();
+      rv = mUnicodeDecoder->GetMaxLength(inStr.get(), inStr.Length(), &unicharLength);
+      if (NS_SUCCEEDED(rv))
+      {
+        // Use this local buffer if possible.
+        const int32_t kLocalBufSize = 4096;
+        char16_t localBuf[kLocalBufSize];
+        char16_t *unichars = localBuf;
+
+        if (unicharLength > kLocalBufSize)
+        {
+          // Otherwise, use the buffer of the class.
+          if (!mUnicodeConversionBuffer ||
+              unicharLength > mUnicodeBufferCharacterLength)
+          {
+            if (mUnicodeConversionBuffer)
+              free(mUnicodeConversionBuffer);
+            mUnicodeConversionBuffer = (char16_t *) moz_xmalloc(unicharLength * sizeof(char16_t));
+            if (!mUnicodeConversionBuffer)
+            {
+              mUnicodeBufferCharacterLength = 0;
+              return NS_ERROR_OUT_OF_MEMORY;
+            }
+            mUnicodeBufferCharacterLength = unicharLength;
+          }
+          unichars = mUnicodeConversionBuffer;
+        }
+
+        int32_t consumedInputLength = 0;
+        int32_t originalInputLength = inputLength;
+        const char *inputBuffer = inStr.get();
+        int32_t convertedOutputLength = 0;
+        int32_t outputBufferLength = unicharLength;
+        char16_t *originalOutputBuffer = unichars;
+        do
+        {
+          rv = mUnicodeDecoder->Convert(inputBuffer, &inputLength, unichars, &unicharLength);
+          if (NS_SUCCEEDED(rv))
+          {
+            convertedOutputLength += unicharLength;
+            break;
+          }
+
+          // if we failed, we consume one byte, replace it with a question mark
+          // and try the conversion again.
+          unichars += unicharLength;
+          *unichars = (char16_t)'?';
+          unichars++;
+          unicharLength++;
+
+          mUnicodeDecoder->Reset();
+
+          inputBuffer += ++inputLength;
+          consumedInputLength += inputLength;
+          inputLength = originalInputLength - consumedInputLength;  // update input length to convert
+          convertedOutputLength += unicharLength;
+          unicharLength = outputBufferLength - unicharLength;       // update output length
+
+        } while (NS_FAILED(rv) &&
+                 (originalInputLength > consumedInputLength) &&
+                 (outputBufferLength > convertedOutputLength));
+
+        if (convertedOutputLength > 0)
+          mMsgBody.Append(originalOutputBuffer, convertedOutputLength);
+      }
+    }
+  }
+
+  return rv;
+}
+
+nsresult
+QuotingOutputStreamListener::SetComposeObj(nsIMsgCompose *obj)
+{
+  mWeakComposeObj = do_GetWeakReference(obj);
+  return NS_OK;
+}
+
+nsresult
+QuotingOutputStreamListener::SetMimeHeaders(nsIMimeHeaders * headers)
+{
+  mHeaders = headers;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+QuotingOutputStreamListener::InsertToCompose(nsIEditor *aEditor,
+                                             bool aHTMLEditor)
+{
+  // First, get the nsIEditor interface for future use
+  nsCOMPtr<nsIDOMNode> nodeInserted;
+
+  TranslateLineEnding(mMsgBody);
+
+  // Now, insert it into the editor...
+  if (aEditor)
+    aEditor->EnableUndo(true);
+
+  nsCOMPtr<nsIMsgCompose> compose = do_QueryReferent(mWeakComposeObj);
+  if (!mMsgBody.IsEmpty() && compose)
+  {
+    compose->SetInsertingQuotedContent(true);
+    if (!mCitePrefix.IsEmpty())
+    {
+      if (!aHTMLEditor)
+        mCitePrefix.AppendLiteral("\n");
+      nsCOMPtr<nsIPlaintextEditor> textEditor (do_QueryInterface(aEditor));
+      if (textEditor)
+        textEditor->InsertText(mCitePrefix);
+    }
+
+    nsCOMPtr<nsIEditorMailSupport> mailEditor (do_QueryInterface(aEditor));
+    if (mailEditor)
+    {
+      if (aHTMLEditor) {
+        nsAutoString body(mMsgBody);
+        remove_plaintext_tag(body);
+        mailEditor->InsertAsCitedQuotation(body, EmptyString(), true,
+                                           getter_AddRefs(nodeInserted));
+      } else {
+        mailEditor->InsertAsQuotation(mMsgBody, getter_AddRefs(nodeInserted));
+      }
+    }
+    compose->SetInsertingQuotedContent(false);
+  }
+
+  if (aEditor)
+  {
+    nsCOMPtr<nsIPlaintextEditor> textEditor = do_QueryInterface(aEditor);
+    if (textEditor)
+    {
+      nsCOMPtr<nsISelection> selection;
+      nsCOMPtr<nsIDOMNode>   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->Collapse(parent, offset+1);
+        // insert a break at current selection
+        textEditor->InsertLineBreak();
+        selection->Collapse(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 comman 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(NS_LITERAL_STRING("."));
+    dotDomain.Append(domain);
+    if (StringEndsWith(aDomain, dotDomain, nsCaseInsensitiveStringComparator()))
+      return true;
+
+    left = right + 1;
+  }
+  return false;
+}
+
+NS_IMPL_ISUPPORTS(QuotingOutputStreamListener,
+                   nsIMsgQuotingOutputStreamListener,
+                   nsIRequestObserver,
+                   nsIStreamListener)
+
+////////////////////////////////////////////////////////////////////////////////////
+// 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 char *msgURI)
+{
+  NS_ENSURE_ARG_POINTER(msgURI);
+
+  nsresult rv;
+  mQuotingToFollow = false;
+
+  // Create a mime parser (nsIStreamConverter)!
+  mQuote = do_CreateInstance(NS_MSGQUOTE_CONTRACTID, &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(msgURI,
+                                    msgHdr,
+                                    false,
+                                    !mHtmlToQuote.IsEmpty(),
+                                    m_identity,
+                                    mQuote,
+                                    mCharsetOverride || mAnswerDefaultCharset,
+                                    false,
+                                    mHtmlToQuote);
+
+  if (!mQuoteStreamListener)
+    return NS_ERROR_FAILURE;
+  NS_ADDREF(mQuoteStreamListener);
+
+  mQuoteStreamListener->SetComposeObj(this);
+
+  rv = mQuote->QuoteMessage(msgURI, false, mQuoteStreamListener,
+                            mCharsetOverride ? m_compFields->GetCharacterSet() : "",
+                            false, msgHdr);
+  return rv;
+}
+
+nsresult
+nsMsgCompose::QuoteOriginalMessage() // New template
+{
+  nsresult    rv;
+
+  mQuotingToFollow = false;
+
+  // Create a mime parser (nsIStreamConverter)!
+  mQuote = do_CreateInstance(NS_MSGQUOTE_CONTRACTID, &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.get(), getter_AddRefs(originalMsgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  bool fileUrl = StringBeginsWith(mOriginalMsgURI, NS_LITERAL_CSTRING("file:"));
+  if (fileUrl)
+  {
+    mOriginalMsgURI.Replace(0, 5, NS_LITERAL_CSTRING("mailbox:"));
+    mOriginalMsgURI.AppendLiteral("?number=0");
+  }
+
+  // Create the consumer output stream.. this will receive all the HTML from libmime
+  mQuoteStreamListener =
+    new QuotingOutputStreamListener(mOriginalMsgURI.get(),
+                                    originalMsgHdr,
+                                    mWhatHolder != 1,
+                                    !bAutoQuote || !mHtmlToQuote.IsEmpty(),
+                                    m_identity,
+                                    mQuote,
+                                    mCharsetOverride || mAnswerDefaultCharset,
+                                    true,
+                                    mHtmlToQuote);
+
+  if (!mQuoteStreamListener)
+    return NS_ERROR_FAILURE;
+  NS_ADDREF(mQuoteStreamListener);
+
+  mQuoteStreamListener->SetComposeObj(this);
+
+  rv = mQuote->QuoteMessage(mOriginalMsgURI.get(), mWhatHolder != 1, mQuoteStreamListener,
+                            mCharsetOverride ? mQuoteCharset.get() : "",
+                            !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::Draft)
+  {
+    nsAutoCString curDraftIdURL;
+    rv = m_compFields->GetDraftId(getter_Copies(curDraftIdURL));
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!curDraftIdURL.IsEmpty()) {
+      nsCOMPtr <nsIMsgDBHdr> draftHdr;
+      rv = GetMsgDBHdrFromURI(curDraftIdURL.get(), getter_AddRefs(draftHdr));
+      NS_ENSURE_SUCCESS(rv, rv);
+      draftHdr->GetStringProperty(QUEUED_DISPOSITION_PROPERTY, getter_Copies(dispositionSetting));
+    }
+  }
+
+  nsMsgKey msgKey;
+  if (mMsgSend)
+  {
+    mMsgSend->GetMessageKey(&msgKey);
+    nsAutoCString msgUri(m_folderName);
+    nsCString identityKey;
+
+    m_identity->GetKey(identityKey);
+
+    int32_t insertIndex = StringBeginsWith(msgUri, NS_LITERAL_CSTRING("mailbox")) ? 7 : 4;
+    msgUri.Insert("-message", insertIndex); // "mailbox/imap: -> "mailbox/imap-message:"
+    msgUri.Append('#');
+    msgUri.AppendInt(msgKey);
+    nsCOMPtr <nsIMsgDBHdr> msgHdr;
+    rv = GetMsgDBHdrFromURI(msgUri.get(), 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.get());
+        if (!dispositionSetting.IsEmpty())
+          msgHdr->SetStringProperty(QUEUED_DISPOSITION_PROPERTY, dispositionSetting.get());
+      }
+      msgHdr->SetStringProperty(HEADER_X_MOZILLA_IDENTITY_KEY, identityKey.get());
+    }
+  }
+  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 ||
+      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(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;
+
+            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::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 *aFolderURI)
+{
+  m_folderName = aFolderURI;
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener> >::ForwardIterator iter(mExternalSendListeners);
+  nsCOMPtr<nsIMsgSendListener> externalSendListener;
+
+  while (iter.HasMore())
+  {
+    externalSendListener = iter.GetNext();
+    externalSendListener->OnGetDraftFolderURI(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;
+}
+
+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);
+    }
+    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 *aFolderURI)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgSendListener> composeSendListener = do_QueryReferent(mWeakComposeObj, &rv);
+  if (NS_SUCCEEDED(rv) && composeSendListener)
+    composeSendListener->OnGetDraftFolderURI(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);
+      }
+      else
+      {
+        // Remove (possible) draft if we're in send later mode
+        if (mDeliverMode == nsIMsgSend::nsMsgQueueForLater ||
+            mDeliverMode == nsIMsgSend::nsMsgDeliverBackground)
+        {
+          msgCompose->SetDeleteDraft(true);
+          RemoveCurrentDraftMessage(msgCompose, true);
+        }
+        msgCompose->CloseWindow();
+      }
+    }
+    msgCompose->ClearMessageSend();
+  }
+
+  return rv;
+}
+
+nsresult
+nsMsgComposeSendListener::GetMsgFolder(nsIMsgCompose *compObj, nsIMsgFolder **msgFolder)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> aMsgFolder;
+  nsCString folderUri;
+
+  rv = compObj->GetSavedFolderURI(getter_Copies(folderUri));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIRDFService> rdfService (do_GetService("@mozilla.org/rdf/rdf-service;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr <nsIRDFResource> resource;
+  rv = rdfService->GetResource(folderUri, getter_AddRefs(resource));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aMsgFolder = do_QueryInterface(resource, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_IF_ADDREF(*msgFolder = aMsgFolder);
+  return rv;
+}
+
+nsresult
+nsMsgComposeSendListener::RemoveCurrentDraftMessage(nsIMsgCompose *compObj, bool calledByCopy)
+{
+  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;
+  nsMsgKey newUid = 0;
+  nsCString newDraftIdURL;
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+
+  rv = compFields->GetDraftId(getter_Copies(curDraftIdURL));
+  NS_ASSERTION(NS_SUCCEEDED(rv), "RemoveCurrentDraftMessage can't get draft id");
+
+  // Skip if no draft id (probably a new draft msg).
+  if (NS_SUCCEEDED(rv) && !curDraftIdURL.IsEmpty())
+  {
+    nsCOMPtr <nsIMsgDBHdr> msgDBHdr;
+    rv = GetMsgDBHdrFromURI(curDraftIdURL.get(), getter_AddRefs(msgDBHdr));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "RemoveCurrentDraftMessage 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), "RemoveCurrentDraftMessage can't get msg folder interface pointer.");
+        if (NS_FAILED(rv) || !msgFolder)
+          break;
+
+        // Only do this if it's a drafts folder.
+        bool isDraft;
+        msgFolder->GetFlag(nsMsgFolderFlags::Drafts, &isDraft);
+        if (!isDraft)
+          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;
+
+        // Build the msg array.
+        nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "RemoveCurrentDraftMessage can't allocate array.");
+        if (NS_FAILED(rv) || !messageArray)
+          break;
+        rv = messageArray->AppendElement(msgDBHdr, false);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "RemoveCurrentDraftMessage can't append msg header to array.");
+        if (NS_FAILED(rv))
+          break;
+
+        // Ready to delete the msg.
+        rv = msgFolder->DeleteMessages(messageArray, nullptr, true, false, nullptr, false /*allowUndo*/);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "RemoveCurrentDraftMessage 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)
+        {
+          const char * str = PL_strchr(curDraftIdURL.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, 1, nullptr);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 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)
+  {
+    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)
+      {
+        rv = savedToFolder->GenerateMessageURI(newUid, newDraftIdURL);
+        NS_ENSURE_SUCCESS(rv, rv);
+        compFields->SetDraftId(newDraftIdURL.get());
+      }
+    }
+  }
+  return rv;
+}
+
+nsresult
+nsMsgComposeSendListener::SetMessageKey(nsMsgKey aMessageKey)
+{
+  return NS_OK;
+}
+
+nsresult
+nsMsgComposeSendListener::GetMessageId(nsACString& messageId)
+{
+  return NS_OK;
+}
+
+/* void onStateChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aStateFlags, in nsresult aStatus); */
+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::services::GetStringBundleService();
+          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(u"msgCancelling", getter_Copies(msg));
+          progress->OnStatusChange(nullptr, nullptr, NS_OK, msg.get());
+        }
+      }
+
+      nsCOMPtr<nsIMsgSend> msgSend;
+      msgCompose->GetMessageSend(getter_AddRefs(msgSend));
+      if (msgSend)
+        msgSend->Abort();
+    }
+  }
+  return NS_OK;
+}
+
+/* void onProgressChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aCurSelfProgress, in long aMaxSelfProgress, in long aCurTotalProgress, in long aMaxTotalProgress); */
+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;
+}
+
+/* void onLocationChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsIURI location, in unsigned long aFlags); */
+NS_IMETHODIMP nsMsgComposeSendListener::OnLocationChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, nsIURI *location, uint32_t aFlags)
+{
+  /* Ignore this call */
+  return NS_OK;
+}
+
+/* void onStatusChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsresult aStatus, in wstring aMessage); */
+NS_IMETHODIMP nsMsgComposeSendListener::OnStatusChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, nsresult aStatus, const char16_t *aMessage)
+{
+  /* Ignore this call */
+  return NS_OK;
+}
+
+/* void onSecurityChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long state); */
+NS_IMETHODIMP nsMsgComposeSendListener::OnSecurityChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, uint32_t state)
+{
+  /* 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, 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.
+  //
+  char16_t *escaped = MsgEscapeHTML2(origBuf.get(), origBuf.Length());
+  if (escaped)
+  {
+    aSigData.Append(escaped);
+    NS_Free(escaped);
+  }
+  else
+    aSigData.Append(origBuf);
+  return NS_OK;
+}
+
+nsresult
+nsMsgCompose::LoadDataFromFile(nsIFile *file, nsString &sigData,
+                               bool aAllowUTF8, bool aAllowUTF16)
+{
+  int32_t       readSize;
+  uint32_t       nGot;
+  char          *readBuf;
+  char          *ptr;
+
+  bool isDirectory = false;
+  file->IsDirectory(&isDirectory);
+  if (isDirectory) {
+    NS_ERROR("file is a directory");
+    return NS_MSG_ERROR_READING_FILE;
+  }
+
+
+  nsCOMPtr <nsIInputStream> inputFile;
+  nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputFile), file);
+  if (NS_FAILED(rv))
+    return NS_MSG_ERROR_READING_FILE;
+
+  int64_t fileSize;
+  file->GetFileSize(&fileSize);
+  readSize = (uint32_t) fileSize;
+
+
+  ptr = readBuf = (char *)PR_Malloc(readSize + 1);  if (!readBuf)
+    return NS_ERROR_OUT_OF_MEMORY;
+  memset(readBuf, 0, readSize + 1);
+
+  while (readSize) {
+    inputFile->Read(ptr, readSize, &nGot);
+    if (nGot) {
+      readSize -= nGot;
+      ptr += nGot;
+    }
+    else {
+      readSize = 0;
+    }
+  }
+  inputFile->Close();
+
+  readSize = (uint32_t) fileSize;
+
+  nsAutoCString sigEncoding(nsMsgI18NParseMetaCharset(file));
+  bool removeSigCharset = !sigEncoding.IsEmpty() && m_composeHTML;
+
+  if (sigEncoding.IsEmpty()) {
+    if (aAllowUTF8 && MsgIsUTF8(nsDependentCString(readBuf))) {
+      sigEncoding.Assign("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.Assign("UTF-16");
+    }
+    else {
+      //default to platform encoding for plain text files w/o meta charset
+      nsAutoCString textFileCharset;
+      nsMsgI18NTextFileCharset(textFileCharset);
+      sigEncoding.Assign(textFileCharset);
+    }
+  }
+
+  nsAutoCString readStr(readBuf, (int32_t) fileSize);
+  PR_FREEIF(readBuf);
+
+  // XXX: ^^^ could really use nsContentUtils::SlurpFileToString instead!
+
+  if (NS_FAILED(ConvertToUnicode(sigEncoding.get(), readStr, sigData)))
+    CopyASCIItoUTF16(readStr, sigData);
+
+  //remove sig meta charset to allow user charset override during composition
+  if (removeSigCharset)
+  {
+    nsAutoCString metaCharset("charset=");
+    metaCharset.Append(sigEncoding);
+    int32_t pos = sigData.Find(metaCharset.BeginReading(), true);
+    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(nsAutoString &aData)
+{
+  int32_t fPos;
+  int32_t offset = -1;
+  while ((fPos = aData.RFind("file://", true, offset)) != kNotFound) {
+    if (fPos != kNotFound && fPos > 0) {
+      char16_t q = aData.CharAt(fPos - 1);
+      bool 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 this one failed, maybe because the file wasn't found,
+      // continue to process the next one.
+      if (NS_SUCCEEDED(rv)) {
+        aData.Replace(fPos, end - fPos, dataURL);
+      }
+      offset = fPos - 1;
+    }
+  }
+  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 = nsContentUtils::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::BuildQuotedMessageAndSignature(void)
+{
+  //
+  // This should never happen...if it does, just bail out...
+  //
+  NS_ASSERTION(m_editor, "BuildQuotedMessageAndSignature but no editor!\n");
+  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).
+
+  nsAutoCString sigNativePath;
+  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) {
+        rv = sigFile->GetNativePath(sigNativePath);
+        if (NS_SUCCEEDED(rv) && !sigNativePath.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, NS_LITERAL_CSTRING("image/"), 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, false, true, true);
+      sigData.Append(prefSigText);
+    }
+    else
+    {
+      if (!htmlSig)
+      {
+        char16_t* escaped = MsgEscapeHTML2(prefSigText.get(), prefSigText.Length());
+        if (escaped)
+        {
+          sigData.Append(escaped);
+          NS_Free(escaped);
+        }
+        else
+          sigData.Append(prefSigText);
+      }
+      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("\r-- \r", true) < 0 &&
+        sigData.Find("\n-- \n", true) < 0 &&
+        sigData.Find("\n-- \r", true) < 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 wont. Let's figure that 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 :
+      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))
+    MsgReplaceSubstring(body, NS_LITERAL_STRING("\n"), NS_LITERAL_STRING("<br>"));
+
+  // 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, NS_LITERAL_STRING("-- \r")) ||
+            StringBeginsWith(s, NS_LITERAL_STRING("-- \n")))
+        {
+          i += 4;
+          continue;
+        }
+        if (StringBeginsWith(s, NS_LITERAL_STRING("- -- \r")) ||
+            StringBeginsWith(s, NS_LITERAL_STRING("- -- \n")))
+        {
+          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)
+{
+
+  if (aNotificationType == nsIMsgComposeNotificationType::SaveInFolderDone)
+    ResetUrisForEmbeddedObjects();
+
+  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:
+      NS_NOTREACHED("Unknown notification");
+      break;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMsgCompose::AttachmentPrettyName(const nsACString & scheme, const char* charset, nsACString& _retval)
+{
+  nsresult rv;
+
+  if (MsgLowerCaseEqualsLiteral(StringHead(scheme, 5), "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;
+  }
+
+  // To work around a mysterious bug in VC++ 6.
+  const char* cset = (!charset || !*charset) ? "UTF-8" : charset;
+
+  nsCOMPtr<nsITextToSubURI> textToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoString retUrl;
+  rv = textToSubURI->UnEscapeURIForUI(nsDependentCString(cset), scheme, retUrl);
+
+  if (NS_SUCCEEDED(rv)) {
+    CopyUTF16toUTF8(retUrl, _retval);
+  } else {
+    _retval.Assign(scheme);
+  }
+  if (MsgLowerCaseEqualsLiteral(StringHead(scheme, 5), "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;
+  if (aDirUri.EqualsLiteral(kMDBDirectoryRoot))
+    collectedAddressbookFound = false;
+
+  nsresult rv;
+  nsCOMPtr<nsIAbManager> abManager = do_GetService(NS_ABMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAbDirectory> directory;
+  rv = abManager->GetDirectory(aDirUri, getter_AddRefs(directory));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISimpleEnumerator> subDirectories;
+  if (NS_SUCCEEDED(directory->GetChildNodes(getter_AddRefs(subDirectories))) && subDirectories)
+  {
+    nsCOMPtr<nsISupports> item;
+    bool hasMore;
+    while (NS_SUCCEEDED(rv = subDirectories->HasMoreElements(&hasMore)) && hasMore)
+    {
+      if (NS_SUCCEEDED(subDirectories->GetNext(getter_AddRefs(item))))
+      {
+        directory = do_QueryInterface(item, &rv);
+        if (NS_SUCCEEDED(rv))
+        {
+          bool bIsMailList;
+
+          if (NS_SUCCEEDED(directory->GetIsMailList(&bIsMailList)) && bIsMailList)
+          {
+            aMailListArray.AppendElement(directory);
+            continue;
+          }
+
+          nsCString uri;
+          rv = directory->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(directory, pos);
+          rv = GetABDirAndMailLists(uri, aDirArray, aMailListArray);
+        }
+      }
+    }
+  }
+  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;
+
+  nsCOMPtr<nsIMutableArray> mailListAddresses;
+  rv = aMailList->GetAddressLists(getter_AddRefs(mailListAddresses));
+  if (NS_FAILED(rv))
+    return rv;
+
+  uint32_t nbrAddresses = 0;
+  mailListAddresses->GetLength(&nbrAddresses);
+  for (uint32_t i = 0; i < nbrAddresses; i++)
+  {
+    nsCOMPtr<nsIAbCard> existingCard(do_QueryElementAt(mailListAddresses, i, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    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(NS_LITERAL_CSTRING(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 rv;
+}
+
+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;
+}
+
+/**
+ * This function implements the decision logic for delivery format 'Auto-Detect',
+ * including optional 'Auto-Downgrade' behaviour for HTML messages considered
+ * convertible (silent, "lossless" conversion to plain text).
+ * @param aConvertible  the result of analysing message body convertibility:
+ *                      nsIMsgCompConvertible::Plain | Yes | Altering | No
+ * @return              nsIMsgCompSendFormat::AskUser | PlainText | HTML | Both
+ */
+NS_IMETHODIMP
+nsMsgCompose::DetermineHTMLAction(int32_t aConvertible, int32_t *result)
+{
+  NS_ENSURE_ARG_POINTER(result);
+  nsresult rv;
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // *** Message-centric Auto-Downgrade ***
+  // If the message has practically no HTML formatting,
+  // AND if user accepts auto-downgrading (send options pref),
+  // bypass auto-detection of recipients' preferences and just
+  // send the message as plain text (silent, "lossless" conversion);
+  // which will also avoid asking for newsgroups for this typical scenario.
+  bool autoDowngrade = true;
+  rv = prefBranch->GetBoolPref("mailnews.sendformat.auto_downgrade", &autoDowngrade);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (autoDowngrade && (aConvertible == nsIMsgCompConvertible::Plain))
+  {
+    *result = nsIMsgCompSendFormat::PlainText;
+    return NS_OK;
+  }
+
+  // *** Newsgroups ***
+  // Right now, we don't have logic for newsgroups for intelligent send
+  // preferences. Therefore, bail out early and save us a lot of work if there
+  // are newsgroups.
+
+  nsAutoString newsgroups;
+  m_compFields->GetNewsgroups(newsgroups);
+
+  if (!newsgroups.IsEmpty())
+  {
+    *result = nsIMsgCompSendFormat::AskUser;
+    return NS_OK;
+  }
+
+  // *** Recipient-Centric Auto-Detect ***
+
+  RecipientsArray recipientsList;
+  rv = LookupAddressBook(recipientsList);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Finally return the list of non-HTML recipients if requested and/or rebuilt
+  // the recipient field. Also, check for domain preference when preferFormat
+  // is unknown.
+  nsString plaintextDomains;
+  nsString htmlDomains;
+
+  if (prefBranch)
+  {
+    NS_GetUnicharPreferenceWithDefault(prefBranch, "mailnews.plaintext_domains",
+                                       EmptyString(), plaintextDomains);
+    NS_GetUnicharPreferenceWithDefault(prefBranch, "mailnews.html_domains",
+                                       EmptyString(), htmlDomains);
+  }
+
+  // allHTML and allPlain are summary recipient scopes of format preference
+  // according to address book and send options for recipient-centric Auto-Detect,
+  // used by Auto-Detect to determine the appropriate message delivery format.
+
+  // allHtml: All recipients prefer HTML.
+  bool allHtml = true;
+
+  // allPlain: All recipients prefer Plain Text.
+  bool allPlain = true;
+
+  // Exit the loop early if allHtml and allPlain both decay to false to save us
+  // some work.
+  for (int i = 0; i < MAX_OF_RECIPIENT_ARRAY && (allHtml || allPlain); ++i)
+  {
+    uint32_t nbrRecipients = recipientsList[i].Length();
+    for (uint32_t j = 0; j < nbrRecipients && (allHtml || allPlain); ++j)
+    {
+      nsMsgRecipient &recipient = recipientsList[i][j];
+      uint32_t preferFormat = nsIAbPreferMailFormat::unknown;
+      if (recipient.mCard)
+      {
+        recipient.mCard->GetPropertyAsUint32(kPreferMailFormatProperty,
+          &preferFormat);
+      }
+
+      // if we don't have a prefer format for a recipient, check the domain in
+      // case we have a format defined for it
+      if (preferFormat == nsIAbPreferMailFormat::unknown &&
+          (!plaintextDomains.IsEmpty() || !htmlDomains.IsEmpty()))
+      {
+        int32_t atPos = recipient.mEmail.FindChar('@');
+        if (atPos < 0)
+          continue;
+
+        nsDependentSubstring emailDomain = Substring(recipient.mEmail,
+                                                     atPos + 1);
+        if (IsInDomainList(emailDomain, plaintextDomains))
+          preferFormat = nsIAbPreferMailFormat::plaintext;
+        else if (IsInDomainList(emailDomain, htmlDomains))
+          preferFormat = nsIAbPreferMailFormat::html;
+      }
+
+      // Determine the delivery format preference of this recipient and adjust
+      // the summary recipient scopes of the message accordingly.
+      switch (preferFormat)
+      {
+      case nsIAbPreferMailFormat::html:
+        allPlain = false;
+        break;
+
+      case nsIAbPreferMailFormat::plaintext:
+        allHtml = false;
+        break;
+
+      default: // nsIAbPreferMailFormat::unknown
+        allHtml = false;
+        allPlain = false;
+        break;
+      }
+    }
+  }
+
+  // Here's the final part of recipient-centric Auto-Detect logic where we set
+  // the actual send format (aka delivery format) after analysing recipients'
+  // format preferences above.
+
+  // If all recipients prefer HTML, then return HTML.
+  if (allHtml)
+  {
+    *result = nsIMsgCompSendFormat::HTML;
+    return NS_OK;
+  }
+
+  // If all recipients prefer plaintext, silently strip *all* HTML formatting,
+  // regardless of (non-)convertibility, and send the message as plaintext.
+  // **ToDo: UX-error-prevention, UX-wysiwyg: warn against dataloss potential.**
+  if (allPlain)
+  {
+    *result = nsIMsgCompSendFormat::PlainText;
+    return NS_OK;
+  }
+
+  // Otherwise, check the preference to see what action we should default to.
+  // This pref covers all recipient scopes involving prefers-plain (except allplain)
+  // and prefers-unknown. So we are mixing format conflict resolution options for
+  // prefers-plain with default format setting for prefers-unknown; not ideal.
+  int32_t action = nsIMsgCompSendFormat::AskUser;
+  rv = prefBranch->GetIntPref("mail.default_html_action", &action);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If the action is a known send format, return the value to send in that format.
+  // Otherwise, ask the user.
+  // Note that the preference may default to 0 (Ask), which is not a valid value
+  // for the following enum.
+  if (action == nsIMsgCompSendFormat::PlainText ||
+      action == nsIMsgCompSendFormat::HTML ||
+      action == nsIMsgCompSendFormat::Both)
+  {
+    *result = action;
+    return NS_OK;
+  }
+
+  // At this point, ask the user.
+  *result = nsIMsgCompSendFormat::AskUser;
+  return NS_OK;
+}
+
+/* Decides which tags trigger which convertible mode, i.e. here is the logic
+   for BodyConvertible */
+// Helper function. Parameters are not checked.
+nsresult nsMsgCompose::TagConvertible(nsIDOMElement *node,  int32_t *_retval)
+{
+    nsresult rv;
+
+    *_retval = nsIMsgCompConvertible::No;
+
+    uint16_t nodeType;
+    rv = node->GetNodeType(&nodeType);
+    if (NS_FAILED(rv))
+      return rv;
+
+    nsAutoString element;
+    rv = node->GetNodeName(element);
+    if (NS_FAILED(rv))
+      return rv;
+
+    nsCOMPtr<nsIDOMNode> pItem;
+
+    // style attribute on any element can change layout in any way, so that is not convertible.
+    nsAutoString attribValue;
+    if (NS_SUCCEEDED(node->GetAttribute(NS_LITERAL_STRING("style"), attribValue)) &&
+        !attribValue.IsEmpty())
+    {
+      *_retval = nsIMsgCompConvertible::No;
+      return NS_OK;
+    }
+
+    // moz-* classes are used internally by the editor and mail composition
+    // (like moz-cite 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).
+    if (NS_SUCCEEDED(node->GetAttribute(NS_LITERAL_STRING("class"), attribValue)) &&
+        !attribValue.IsEmpty() &&
+        !StringBeginsWith(attribValue, NS_LITERAL_STRING("moz-"), nsCaseInsensitiveStringComparator()))
+    {
+      *_retval = nsIMsgCompConvertible::No;
+      return NS_OK;
+    }
+    // ID attributes can contain attached style/context or be target of links
+    // so we should preserve them.
+    if (NS_SUCCEEDED(node->GetAttribute(NS_LITERAL_STRING("id"), attribValue)) &&
+        !attribValue.IsEmpty())
+    {
+      *_retval = nsIMsgCompConvertible::No;
+      return NS_OK;
+    }
+    if      ( // some "simple" elements without "style" attribute
+              element.LowerCaseEqualsLiteral("br") ||
+              element.LowerCaseEqualsLiteral("p") ||
+              element.LowerCaseEqualsLiteral("pre") ||
+              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") ||
+              (
+                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;
+
+        bool hasAttribute;
+        nsAutoString color;
+        if (NS_SUCCEEDED(node->HasAttribute(NS_LITERAL_STRING("background"), &hasAttribute))
+            && hasAttribute)  // There is a background image
+          *_retval = nsIMsgCompConvertible::No;
+        else if (NS_SUCCEEDED(node->HasAttribute(NS_LITERAL_STRING("text"), &hasAttribute)) &&
+                 hasAttribute &&
+                 NS_SUCCEEDED(node->GetAttribute(NS_LITERAL_STRING("text"), color)) &&
+                 !color.EqualsLiteral("#000000")) {
+          *_retval = nsIMsgCompConvertible::Altering;
+        }
+        else if (NS_SUCCEEDED(node->HasAttribute(NS_LITERAL_STRING("bgcolor"), &hasAttribute)) &&
+                 hasAttribute &&
+                 NS_SUCCEEDED(node->GetAttribute(NS_LITERAL_STRING("bgcolor"), color)) &&
+                 !color.LowerCaseEqualsLiteral("#ffffff")) {
+          *_retval = nsIMsgCompConvertible::Altering;
+        }
+        else if (NS_SUCCEEDED(node->HasAttribute(NS_LITERAL_STRING("dir"), &hasAttribute))
+            && hasAttribute)  // dir=rtl attributes should not downconvert
+          *_retval = nsIMsgCompConvertible::No;
+
+        //ignore special color setting for link, vlink and alink at this point.
+    }
+    else if (element.LowerCaseEqualsLiteral("blockquote"))
+    {
+      // Skip <blockquote type="cite">
+      *_retval = nsIMsgCompConvertible::Yes;
+
+      if (NS_SUCCEEDED(node->GetAttribute(NS_LITERAL_STRING("type"), attribValue)) &&
+          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;
+          bool hasChild;
+          if (NS_SUCCEEDED(node->GetAttribute(NS_LITERAL_STRING("href"), hrefValue)) &&
+              NS_SUCCEEDED(node->HasChildNodes(&hasChild)) && hasChild)
+          {
+            nsCOMPtr<nsIDOMNodeList> children;
+            if (NS_SUCCEEDED(node->GetChildNodes(getter_AddRefs(children))) &&
+                children &&
+                NS_SUCCEEDED(children->Item(0, getter_AddRefs(pItem))) &&
+                pItem)
+            {
+              nsAutoString textValue;
+              if (NS_SUCCEEDED(pItem->GetNodeValue(textValue)) &&
+                  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;
+      }
+    }
+
+    return rv;
+}
+
+nsresult nsMsgCompose::_NodeTreeConvertible(nsIDOMElement *node, int32_t *_retval)
+{
+    NS_ENSURE_TRUE(node && _retval, NS_ERROR_NULL_POINTER);
+
+    nsresult rv;
+    int32_t result;
+
+    // Check this node
+    rv = TagConvertible(node, &result);
+    if (NS_FAILED(rv))
+        return rv;
+
+    // Walk tree recursively to check the children
+    bool hasChild;
+    if (NS_SUCCEEDED(node->HasChildNodes(&hasChild)) && hasChild)
+    {
+      nsCOMPtr<nsIDOMNodeList> children;
+      if (NS_SUCCEEDED(node->GetChildNodes(getter_AddRefs(children)))
+          && children)
+      {
+        uint32_t nbrOfElements;
+        rv = children->GetLength(&nbrOfElements);
+        for (uint32_t i = 0; NS_SUCCEEDED(rv) && i < nbrOfElements; i++)
+        {
+          nsCOMPtr<nsIDOMNode> pItem;
+          if (NS_SUCCEEDED(children->Item(i, getter_AddRefs(pItem)))
+              && pItem)
+          {
+            // We assume all nodes that are not elements are convertible,
+            // so only test elements.
+            nsCOMPtr<nsIDOMElement> domElement = do_QueryInterface(pItem);
+            if (domElement) {
+              int32_t curresult;
+              rv = _NodeTreeConvertible(domElement, &curresult);
+
+              if (NS_SUCCEEDED(rv) && curresult > result)
+                result = curresult;
+            }
+          }
+        }
+      }
+    }
+
+    *_retval = result;
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::BodyConvertible(int32_t *_retval)
+{
+    NS_ENSURE_ARG_POINTER(_retval);
+    NS_ENSURE_STATE(m_editor);
+
+    nsCOMPtr<nsIDOMDocument> rootDocument;
+    nsresult rv = m_editor->GetDocument(getter_AddRefs(rootDocument));
+    if (NS_FAILED(rv) || !rootDocument)
+      return rv;
+
+    // get the top level element, which contains <html>
+    nsCOMPtr<nsIDOMElement> rootElement;
+    rv = rootDocument->GetDocumentElement(getter_AddRefs(rootElement));
+    if (NS_FAILED(rv) || !rootElement)
+      return rv;
+
+    return _NodeTreeConvertible(rootElement, _retval);
+}
+
+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)
+{
+  nsCOMPtr<nsIDOMElement> rootElement;
+  nsresult rv = m_editor->GetRootElement(getter_AddRefs(rootElement));
+  if (NS_FAILED(rv) || !rootElement) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIDOMNode> node;
+  nsAutoString attributeName;
+  nsAutoString attributeValue;
+  nsAutoString tagLocalName;
+  attributeName.AssignLiteral("class");
+
+  rv = rootElement->GetFirstChild(getter_AddRefs(node));
+  while (NS_SUCCEEDED(rv) && node) {
+    nsCOMPtr<nsIDOMElement> 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.
+      node->GetLocalName(tagLocalName);
+      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.Find("moz-cite-prefix", true) != kNotFound) {
+        break;
+      }
+
+      // Next check for forwarded content.
+      // The forwarded part is inside an element with
+      // class="moz-forward-container".
+      if (attributeValue.Find("moz-forward-container", true) != kNotFound) {
+        break;
+      }
+    }
+
+    rv = node->GetNextSibling(getter_AddRefs(node));
+    if (NS_FAILED(rv) || !node) {
+      // No further siblings found, so we didn't find what we were looking for.
+      rv = NS_OK;
+      node = nullptr;
+      break;
+    }
+  }
+
+  // Now position. If no quote was found, we position to the very front.
+  int32_t offset = 0;
+  if (node) {
+    rv = GetChildOffset(node, rootElement, offset);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+  }
+  nsCOMPtr<nsISelection> selection;
+  m_editor->GetSelection(getter_AddRefs(selection));
+  if (selection)
+    rv = selection->Collapse(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)
+{
+  nsCOMPtr<nsIDOMElement> rootElement;
+  nsresult rv = m_editor->GetRootElement(getter_AddRefs(rootElement));
+  if (NS_FAILED(rv) || !rootElement) {
+    return rv;
+  }
+
+  nsCOMPtr<nsISelection> selection;
+  m_editor->GetSelection(getter_AddRefs(selection));
+  if (selection)
+    rv = selection->Collapse(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;
+  nsCOMPtr<nsIDOMElement> rootElement;
+  nsCOMPtr<nsIDOMNode> lastNode;
+  nsresult rv = m_editor->GetRootElement(getter_AddRefs(rootElement));
+  if (NS_FAILED(rv) || !rootElement) {
+    return rv;
+  }
+
+  rv = rootElement->GetLastChild(getter_AddRefs(lastNode));
+  if (NS_FAILED(rv) || !lastNode) {
+    return rv;
+  }
+
+  rv = GetChildOffset(lastNode, rootElement, offset);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsCOMPtr<nsISelection> selection;
+  m_editor->GetSelection(getter_AddRefs(selection));
+  if (selection)
+    rv = selection->Collapse(rootElement, offset + 1);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgCompose::SetIdentity(nsIMsgIdentity *aIdentity)
+{
+  NS_ENSURE_ARG_POINTER(aIdentity);
+
+  m_identity = aIdentity;
+
+  nsresult rv;
+
+  if (! m_editor)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDOMElement> 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<nsIDOMNode> lastNode;
+  nsCOMPtr<nsIDOMNode> node;
+  nsCOMPtr<nsIDOMNode> tempNode;
+  nsAutoString tagLocalName;
+
+  rv = rootElement->GetLastChild(getter_AddRefs(lastNode));
+  if (NS_SUCCEEDED(rv) && lastNode)
+  {
+    node = lastNode;
+    // In html, the signature is inside an element with
+    // class="moz-signature"
+    bool signatureFound = false;
+    nsAutoString attributeName;
+    attributeName.AssignLiteral("class");
+
+    do
+    {
+      nsCOMPtr<nsIDOMElement> element = do_QueryInterface(node);
+      if (element)
+      {
+        nsAutoString attributeValue;
+
+        rv = element->GetAttribute(attributeName, attributeValue);
+
+        if (attributeValue.Find("moz-signature", true) != kNotFound) {
+          signatureFound = true;
+          break;
+        }
+      }
+    } while (!signatureFound &&
+             node &&
+             NS_SUCCEEDED(node->GetPreviousSibling(getter_AddRefs(node))));
+
+    if (signatureFound)
+    {
+      m_editor->BeginTransaction();
+      node->GetPreviousSibling(getter_AddRefs(tempNode));
+      rv = m_editor->DeleteNode(node);
+      if (NS_FAILED(rv))
+      {
+        m_editor->EndTransaction();
+        return rv;
+      }
+
+      // Also, remove the <br> right before the signature.
+      if (tempNode)
+      {
+        tempNode->GetLocalName(tagLocalName);
+        if (tagLocalName.EqualsLiteral("br"))
+          m_editor->DeleteNode(tempNode);
+      }
+      m_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);
+
+    m_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) {
+        nsCOMPtr<nsIHTMLEditor> htmlEditor (do_QueryInterface(m_editor));
+        rv = htmlEditor->InsertHTML(aSignature);
+      } else {
+        nsCOMPtr<nsIPlaintextEditor> textEditor (do_QueryInterface(m_editor));
+        rv = textEditor->InsertLineBreak();
+        InsertDivWrappedTextAtSelection(aSignature, NS_LITERAL_STRING("moz-signature"));
+      }
+    }
+    m_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;
+}
+
+nsMsgMailList::nsMsgMailList(nsIAbDirectory* directory) :
+  mDirectory(directory)
+{
+  mDirectory->GetDirName(mName);
+  mDirectory->GetDescription(mDescription);
+
+  if (mDescription.IsEmpty())
+    mDescription = mName;
+
+  mDirectory = directory;
+}
diff --git a/mailnews/compose/src/nsMsgCompose.h b/mailnews/compose/src/nsMsgCompose.h
new file mode 100644
index 000000000..19609228f
--- /dev/null
+++ b/mailnews/compose/src/nsMsgCompose.h
@@ -0,0 +1,246 @@
+/* -*- 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 "nsIUnicodeDecoder.h"
+#include "nsIMsgFolder.h"
+#include "nsIDOMNode.h"
+#include "mozIDOMWindow.h"
+
+// Forward declares
+class QuotingOutputStreamListener;
+class nsMsgComposeSendListener;
+class nsIEditorMailSupport;
+class nsIRDFService;
+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,
+                                                     nsIDOMNode * object);
+  nsresult                      ResetUrisForEmbeddedObjects();
+  nsresult                      TagEmbeddedObjects(nsIEditorMailSupport *aMailEditor);
+
+  nsCString                     mQuoteCharset;
+  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;
+  void InsertDivWrappedTextAtSelection(const nsAString &aText,
+                                       const nsAString &classStr);
+
+ protected:
+  nsresult CreateMessage(const char * 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);
+  nsresult TagConvertible(nsIDOMElement *node,  int32_t *_retval);
+  nsresult _NodeTreeConvertible(nsIDOMElement *node, int32_t *_retval);
+  nsresult MoveToAboveQuote(void);
+  nsresult MoveToBeginningOfDocument(void);
+  nsresult MoveToEndOfDocument(void);
+  nsresult ReplaceFileURLs(nsAutoString &sigData);
+  nsresult DataURLForFileURL(const nsAString &aFileURL, nsAString &aDataURL);
+
+// 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;
+  nsMsgCompFields                           *m_compFields;
+  nsCOMPtr<nsIMsgIdentity>                  m_identity;
+  bool                                      m_composeHTML;
+  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                                      mCharsetOverride;
+  bool                                      mAnswerDefaultCharset;
+  bool                                      mDeleteDraft;
+  nsMsgDispositionState                     mDraftDisposition;
+  nsCOMPtr <nsIMsgDBHdr>                    mOrigMsgHdr;
+
+  nsCString                                 mSmtpPassword;
+  nsCString                                 mHtmlToQuote;
+
+  nsTObserverArray<nsCOMPtr<nsIMsgComposeStateListener> > mStateListeners;
+  nsTObserverArray<nsCOMPtr<nsIMsgSendListener> > mExternalSendListeners;
+
+  bool                                      mInsertingQuotedContent;
+  MSG_DeliverMode                           mDeliverMode;  // nsIMsgCompDeliverMode long.
+
+  friend class QuotingOutputStreamListener;
+  friend class nsMsgComposeSendListener;
+};
+
+////////////////////////////////////////////////////////////////////////////////////
+// THIS IS THE CLASS THAT IS THE STREAM Listener OF THE HTML OUPUT
+// FROM LIBMIME. THIS IS FOR QUOTING
+////////////////////////////////////////////////////////////////////////////////////
+class QuotingOutputStreamListener : public nsIMsgQuotingOutputStreamListener
+{
+public:
+    QuotingOutputStreamListener(const char *originalMsgURI,
+                                nsIMsgDBHdr *origMsgHdr,
+                                bool quoteHeaders,
+                                bool headersOnly,
+                                nsIMsgIdentity *identity,
+                                nsIMsgQuote* msgQuote,
+                                bool charsetFixed,
+                                bool quoteOriginal,
+                                const nsACString& htmlToQuote);
+
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIREQUESTOBSERVER
+    NS_DECL_NSISTREAMLISTENER
+    NS_DECL_NSIMSGQUOTINGOUTPUTSTREAMLISTENER
+
+    NS_IMETHOD SetComposeObj(nsIMsgCompose *obj);
+    NS_IMETHOD ConvertToPlainText(bool formatflowed,
+                                  bool delsp,
+                                  bool formatted,
+                                  bool disallowBreaks);
+    NS_IMETHOD InsertToCompose(nsIEditor *aEditor, bool aHTMLEditor);
+    NS_IMETHOD AppendToMsgBody(const nsCString &inStr);
+
+private:
+    virtual ~QuotingOutputStreamListener();
+    nsWeakPtr                   mWeakComposeObj;
+    nsString                    mMsgBody;
+    nsString                    mCitePrefix;
+    nsString                    mSignature;
+    bool                        mQuoteHeaders;
+    bool                        mHeadersOnly;
+    bool                        mCharsetFixed;
+    nsCOMPtr<nsIMsgQuote>       mQuote;
+    nsCOMPtr<nsIMimeHeaders>    mHeaders;
+    nsCOMPtr<nsIMsgIdentity>    mIdentity;
+    nsCOMPtr<nsIMsgDBHdr>       mOrigMsgHdr;
+    nsString                    mCiteReference;
+    nsCOMPtr<nsIMimeConverter>  mMimeConverter;
+    nsCOMPtr<nsIUnicodeDecoder> mUnicodeDecoder;
+    int32_t                     mUnicodeBufferCharacterLength;
+    char16_t*                   mUnicodeConversionBuffer;
+    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    RemoveCurrentDraftMessage(nsIMsgCompose *compObj, bool calledByCopy);
+  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/mailnews/compose/src/nsMsgComposeContentHandler.cpp b/mailnews/compose/src/nsMsgComposeContentHandler.cpp
new file mode 100644
index 000000000..cc52bcb67
--- /dev/null
+++ b/mailnews/compose/src/nsMsgComposeContentHandler.cpp
@@ -0,0 +1,125 @@
+/* -*- 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 "nsMsgBaseCID.h"
+#include "nsMsgCompCID.h"
+#include "nsIChannel.h"
+#include "nsIURI.h"
+#include "plstr.h"
+#include "nsServiceManagerUtils.h"
+#include "nsCOMPtr.h"
+#include "nsPIDOMWindow.h"
+#include "mozIDOMWindow.h"
+#include "nsIDocument.h"
+#include "nsIDOMDocument.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsNetUtil.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIMsgAccountManager.h"
+
+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(
+    NS_MSGACCOUNTMANAGER_CONTRACTID, &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/mailnews/compose/src/nsMsgComposeContentHandler.h b/mailnews/compose/src/nsMsgComposeContentHandler.h
new file mode 100644
index 000000000..360a83608
--- /dev/null
+++ b/mailnews/compose/src/nsMsgComposeContentHandler.h
@@ -0,0 +1,20 @@
+/* -*- 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/mailnews/compose/src/nsMsgComposeParams.cpp b/mailnews/compose/src/nsMsgComposeParams.cpp
new file mode 100644
index 000000000..46f964cee
--- /dev/null
+++ b/mailnews/compose/src/nsMsgComposeParams.cpp
@@ -0,0 +1,170 @@
+/* -*- 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)
+{
+}
+
+/* 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(char * *aOriginalMsgURI)
+{
+  NS_ENSURE_ARG_POINTER(aOriginalMsgURI);
+  
+  *aOriginalMsgURI = ToNewCString(mOriginalMsgUri);
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetOriginalMsgURI(const char * 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;
+}
+
+/* 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)
+  {
+     *aComposeFields = mComposeFields;
+     NS_ADDREF(*aComposeFields);
+  }
+  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)
+  {
+     *aSendListener = mSendListener;
+     NS_ADDREF(*aSendListener);
+  }
+  else
+    *aSendListener = nullptr;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetSendListener(nsIMsgSendListener * aSendListener)
+{
+  mSendListener = aSendListener;
+  return NS_OK;
+}
+
+/* attribute string smtpPassword; */
+NS_IMETHODIMP nsMsgComposeParams::GetSmtpPassword(char * *aSmtpPassword)
+{
+  NS_ENSURE_ARG_POINTER(aSmtpPassword);
+  
+  *aSmtpPassword = ToNewCString(mSMTPPassword);
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeParams::SetSmtpPassword(const char * aSmtpPassword)
+{
+  mSMTPPassword = aSmtpPassword;
+  return NS_OK;
+}
+
diff --git a/mailnews/compose/src/nsMsgComposeParams.h b/mailnews/compose/src/nsMsgComposeParams.h
new file mode 100644
index 000000000..00eaaa335
--- /dev/null
+++ b/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 "nsStringGlue.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;
+  nsCString                     mSMTPPassword;
+  nsCOMPtr<nsIMsgDBHdr>         mOrigMsgHdr;
+  nsCString                     mHtmlToQuote;
+};
diff --git a/mailnews/compose/src/nsMsgComposeProgressParams.cpp b/mailnews/compose/src/nsMsgComposeProgressParams.cpp
new file mode 100644
index 000000000..23c5507c5
--- /dev/null
+++ b/mailnews/compose/src/nsMsgComposeProgressParams.cpp
@@ -0,0 +1,46 @@
+/* -*- 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/mailnews/compose/src/nsMsgComposeProgressParams.h b/mailnews/compose/src/nsMsgComposeProgressParams.h
new file mode 100644
index 000000000..6d9598f16
--- /dev/null
+++ b/mailnews/compose/src/nsMsgComposeProgressParams.h
@@ -0,0 +1,20 @@
+/* -*- 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/mailnews/compose/src/nsMsgComposeService.cpp b/mailnews/compose/src/nsMsgComposeService.cpp
new file mode 100644
index 000000000..944f7dbe3
--- /dev/null
+++ b/mailnews/compose/src/nsMsgComposeService.cpp
@@ -0,0 +1,1479 @@
+/* -*- 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 "nsMsgCompCID.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 "nsIDOMDocument.h"
+#include "nsIDOMHTMLDocument.h"
+#include "nsIDOMElement.h"
+#include "nsIXULWindow.h"
+#include "nsIWindowMediator.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIBaseWindow.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMimeMiscStatus.h"
+#include "nsIStreamConverter.h"
+#include "nsMsgMimeCID.h"
+#include "nsToolkitCompsCID.h"
+#include "nsNetUtil.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIMsgDatabase.h"
+#include "nsIDocumentEncoder.h"
+#include "nsContentCID.h"
+#include "nsISelection.h"
+#include "nsUTF8Utils.h"
+#include "nsILineBreaker.h"
+#include "nsLWBrkCIID.h"
+#include "mozilla/Services.h"
+#include "mimemoz2.h"
+#include "nsIArray.h"
+#include "nsArrayUtils.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"
+
+#ifdef XP_WIN32
+#include <windows.h>
+#include <shellapi.h>
+#include "nsIWidget.h"
+#endif
+
+#define DEFAULT_CHROME  "chrome://messenger/content/messengercompose/messengercompose.xul"
+
+#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 PRLogModuleInfo *MsgComposeLogModule = nullptr;
+
+static uint32_t GetMessageSizeFromURI(const char * originalMsgURI)
+{
+  uint32_t msgSize = 0;
+
+  if (originalMsgURI && *originalMsgURI)
+  {
+    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
+  if (!MsgComposeLogModule)
+      MsgComposeLogModule = PR_NewLogModule("msgcompose");
+
+  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("nsemail", "html");
+  MsgCleanupTempFiles("nscopy", "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;
+  rv = wwatch->OpenWindow(0, chrome && *chrome ? chrome : DEFAULT_CHROME,
+                 "_blank", "all,chrome,dialog=no,status,toolbar", 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;
+}
+
+nsresult
+nsMsgComposeService::GetOrigWindowSelection(MSG_ComposeType type, nsIMsgWindow *aMsgWindow, 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;
+
+  // Now delve down in to the message to get the HTML representation of the selection
+  nsCOMPtr<nsIDocShell> rootDocShell;
+  rv = aMsgWindow->GetRootDocShell(getter_AddRefs(rootDocShell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDocShellTreeItem> childAsItem;
+  rv = rootDocShell->FindChildWithName(NS_LITERAL_STRING("messagepane"),
+                                       true, false, nullptr, nullptr, getter_AddRefs(childAsItem));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(childAsItem, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<mozIDOMWindowProxy> domWindow(do_GetInterface(childAsItem));
+  NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
+  nsCOMPtr<nsPIDOMWindowOuter> privateWindow = nsPIDOMWindowOuter::From(domWindow);
+  nsCOMPtr<nsISelection> sel = privateWindow->GetSelection();
+  NS_ENSURE_TRUE(sel, NS_ERROR_FAILURE);
+
+  bool requireMultipleWords = true;
+  nsAutoCString charsOnlyIf;
+  prefs->GetBoolPref(PREF_MAILNEWS_REPLY_QUOTING_SELECTION_MULTI_WORD, &requireMultipleWords);
+  prefs->GetCharPref(PREF_MAILNEWS_REPLY_QUOTING_SELECTION_ONLY_IF, getter_Copies(charsOnlyIf));
+  if (sel && (requireMultipleWords || !charsOnlyIf.IsEmpty()))
+  {
+    nsAutoString selPlain;
+    rv = sel->ToString(selPlain);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // 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;
+
+      nsCOMPtr<nsILineBreaker> lineBreaker = do_GetService(NS_LBRK_CONTRACTID, &rv);
+
+      if (NS_SUCCEEDED(rv))
+      {
+        const uint32_t length = selPlain.Length();
+        const char16_t* unicodeStr = selPlain.get();
+        int32_t endWordPos = 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; NS_IsSpace(*end); end++)
+          ;
+        if (!*end)
+          return NS_ERROR_ABORT;
+      }
+    }
+
+    if (!charsOnlyIf.IsEmpty())
+    {
+      if (MsgFindCharInSet(selPlain, charsOnlyIf.get()) < 0)
+        return NS_ERROR_ABORT;
+    }
+  }
+
+  nsCOMPtr<nsIContentViewer> contentViewer;
+  rv = docShell->GetContentViewer(getter_AddRefs(contentViewer));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDOMDocument> domDocument;
+  rv = contentViewer->GetDOMDocument(getter_AddRefs(domDocument));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDocumentEncoder> docEncoder(do_CreateInstance(NS_HTMLCOPY_ENCODER_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = docEncoder->Init(domDocument, NS_LITERAL_STRING("text/html"), 0);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = docEncoder->SetSelection(sel);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoString selHTML;
+  rv = docEncoder->EncodeToString(selHTML);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // 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;
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::OpenComposeWindow(const char *msgComposeWindowURL, nsIMsgDBHdr *origMsgHdr, const char *originalMsgURI,
+  MSG_ComposeType type, MSG_ComposeFormat format, nsIMsgIdentity * aIdentity, nsIMsgWindow *aMsgWindow)
+{
+  nsresult rv;
+
+  // Check for any reply type that wants to ignore the quote.
+  bool ignoreQuote = false;
+  if (type >= nsIMsgCompType::ReplyIgnoreQuote) {
+    type -= nsIMsgCompType::ReplyIgnoreQuote;
+    ignoreQuote = true;
+  }
+
+  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::Template
+    || type == nsIMsgCompType::ReplyWithTemplate || type == nsIMsgCompType::Redirect)
+  {
+    nsAutoCString uriToOpen(originalMsgURI);
+    uriToOpen += (uriToOpen.FindChar('?') == kNotFound) ? '?' : '&';
+    uriToOpen.Append("fetchCompleteMessage=true");
+    if (type == nsIMsgCompType::Redirect)
+      uriToOpen.Append("&redirect=true");
+
+    return LoadDraftOrTemplate(uriToOpen, type == nsIMsgCompType::ForwardInline || type == nsIMsgCompType::Draft ?
+                               nsMimeOutput::nsMimeMessageDraftOrTemplate : nsMimeOutput::nsMimeMessageEditorTemplate,
+                               identity, originalMsgURI, origMsgHdr, type == nsIMsgCompType::ForwardInline,
+                               format == nsIMsgCompFormat::OppositeOfDefault, aMsgWindow);
+  }
+
+  nsCOMPtr<nsIMsgComposeParams> pMsgComposeParams (do_CreateInstance(NS_MSGCOMPOSEPARAMS_CONTRACTID, &rv));
+  if (NS_SUCCEEDED(rv) && pMsgComposeParams)
+  {
+    nsCOMPtr<nsIMsgCompFields> pMsgCompFields (do_CreateInstance(NS_MSGCOMPFIELDS_CONTRACTID, &rv));
+    if (NS_SUCCEEDED(rv) && pMsgCompFields)
+    {
+      pMsgComposeParams->SetType(type);
+      pMsgComposeParams->SetFormat(format);
+      pMsgComposeParams->SetIdentity(identity);
+
+      // When doing a reply (except with a template) see if there's a selection that we should quote
+      if (!ignoreQuote &&
+          (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, aMsgWindow, selHTML)))
+          pMsgComposeParams->SetHtmlToQuote(selHTML);
+      }
+
+      if (originalMsgURI && *originalMsgURI)
+      {
+        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);
+        }
+      }
+
+      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(msgComposeWindowURL, pMsgComposeParams);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgComposeService::GetParamsForMailto(nsIURI * aURI, nsIMsgComposeParams ** aParams)
+{
+  nsresult rv = NS_OK;
+  if (aURI)
+  {
+    nsCOMPtr<nsIMailtoUrl> aMailtoUrl;
+    rv = aURI->QueryInterface(NS_GET_IID(nsIMailtoUrl), getter_AddRefs(aMailtoUrl));
+    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)
+        {
+          char *escaped = MsgEscapeHTML(bodyPart.get());
+          if (!escaped)
+            return NS_ERROR_OUT_OF_MEMORY;
+
+          CopyUTF8toUTF16(nsDependentCString(escaped), sanitizedBody);
+          free(escaped);
+        }
+        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(NS_MSGCOMPOSEPARAMS_CONTRACTID, &rv));
+      if (NS_SUCCEEDED(rv) && pMsgComposeParams)
+      {
+        pMsgComposeParams->SetType(nsIMsgCompType::MailToUrl);
+        pMsgComposeParams->SetFormat(composeHTMLFormat ? nsIMsgCompFormat::HTML : nsIMsgCompFormat::PlainText);
+
+
+        nsCOMPtr<nsIMsgCompFields> pMsgCompFields (do_CreateInstance(NS_MSGCOMPFIELDS_CONTRACTID, &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(NS_MSGCOMPOSE_CONTRACTID, &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(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgAccount> defaultAccount;
+  rv = accountManager->GetDefaultAccount(getter_AddRefs(defaultAccount));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return defaultAccount->GetDefaultIdentity(_retval);
+}
+
+/* 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(NS_MSGCOMPOSEPARAMS_CONTRACTID, &rv));
+  if (NS_FAILED(rv) || (!pMsgComposeParams) ) return rv ;
+  nsCOMPtr<nsIMsgCompFields> compFields = do_CreateInstance(NS_MSGCOMPFIELDS_CONTRACTID, &rv) ;
+
+  nsCString replyTo;
+  mHdrToReplyTo->GetStringProperty("replyTo", getter_Copies(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(NS_LITERAL_STRING("Auto: ")); // RFC 3834 3.1.5.
+  subject.Append(templateSubject);
+  if (!replySubject.IsEmpty())
+  {
+    subject.Append(NS_LITERAL_STRING(" (was: "));
+    subject.Append(replySubject);
+    subject.Append(NS_LITERAL_STRING(")"));
+  }
+
+  compFields->SetSubject(subject);
+  compFields->SetRawHeader("Auto-Submitted", NS_LITERAL_CSTRING("auto-replied"), nullptr);
+
+  nsCString charset;
+  rv = mTemplateHdr->GetCharset(getter_Copies(charset));
+  NS_ENSURE_SUCCESS(rv, rv);
+  compFields->SetCharacterSet(charset.get());
+  rv = nsMsgI18NConvertToUnicode(charset.get(), 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.get());
+
+  // create the nsIMsgCompose object to send the object
+  nsCOMPtr<nsIMsgCompose> pMsgCompose (do_CreateInstance(NS_MSGCOMPOSE_CONTRACTID, &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);
+
+  return pMsgCompose->SendMsg(nsIMsgSend::nsMsgDeliverNow, mIdentity, nullptr, nullptr, nullptr) ;
+}
+
+NS_IMETHODIMP
+nsMsgTemplateReplyHelper::OnStartRequest(nsIRequest* request, nsISupports* aSupport)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgTemplateReplyHelper::OnStopRequest(nsIRequest* request, nsISupports* aSupport,
+                                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,
+                                  nsISupports* aSupport,
+                                  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 char *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;
+  nsCOMPtr <nsIMsgAccountManager> accountManager =
+    do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgAccount> account;
+  rv = accountManager->FindAccountForServer(aServer, getter_AddRefs(account));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIArray> identities;
+  rv = account->GetIdentities(getter_AddRefs(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
+  uint32_t count = 0;
+  identities->GetLength(&count);
+  for (uint32_t i = 0; i < count; i++)
+  {
+    nsCOMPtr<nsIMsgIdentity> anIdentity(do_QueryElementAt(identities, i, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoCString identityEmail;
+    anIdentity->GetEmail(identityEmail);
+
+    if (recipients.Find(identityEmail, CaseInsensitiveCompare) != kNotFound ||
+        ccList.Find(identityEmail, CaseInsensitiveCompare) != kNotFound)
+    {
+      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", getter_Copies(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(templateUri, "?messageId=");
+  if (!query)
+    return NS_ERROR_FAILURE;
+
+  nsAutoCString folderUri(Substring(templateUri, 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(templateUri, "&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.get(), 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);
+  uriToOpen += (uriToOpen.FindChar('?') == kNotFound) ? '?' : '&';
+  uriToOpen.Append("fetchCompleteMessage=true");
+
+  // get the MsgIdentity for the above key using AccountManager
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+    do_GetService (NS_MSGACCOUNTMANAGER_CONTRACTID, &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.get(), aMsgHdr,
+                                      true, forwardTo,
+                                      false, aMsgWindow);
+
+  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(NS_MSGCOMPOSEPARAMS_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgCompFields> compFields = do_CreateInstance(NS_MSGCOMPFIELDS_CONTRACTID, &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.get());
+  // create the nsIMsgCompose object to send the object
+  nsCOMPtr<nsIMsgCompose> pMsgCompose (do_CreateInstance(NS_MSGCOMPOSE_CONTRACTID, &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);
+
+  rv = pMsgCompose->SendMsg(nsIMsgSend::nsMsgDeliverNow, identity, nullptr, nullptr, nullptr);
+  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, getter_Copies(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, getter_Copies(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, getter_Copies(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.get());
+      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
+  nsCOMPtr<nsIWeakReference> weakDocShell = do_GetWeakReference(aDocShell, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  nsCOMPtr<nsIWeakReference> weakMsgComposePtr = do_GetWeakReference(aComposeObject);
+  NS_ENSURE_SUCCESS(rv,rv);
+  mOpenComposeWindows.Put(weakDocShell, weakMsgComposePtr);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::UnregisterComposeDocShell(nsIDocShell *aDocShell)
+{
+  NS_ENSURE_ARG_POINTER(aDocShell);
+
+  nsresult rv;
+  nsCOMPtr<nsIWeakReference> 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;
+  nsCOMPtr<nsIWeakReference> weakDocShell = do_GetWeakReference(aDocShell, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIWeakReference> 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 char * aOriginalMsgURI,
+                                         nsIMsgDBHdr * aOrigMsgHdr,
+                                         bool aForwardInline,
+                                         bool overrideComposeFormat,
+                                         nsIMsgWindow *aMsgWindow)
+{
+  return RunMessageThroughMimeDraft(aMsgURI, aOutType, aIdentity,
+                                    aOriginalMsgURI, aOrigMsgHdr,
+                                    aForwardInline, EmptyString(),
+                                    overrideComposeFormat, aMsgWindow);
+}
+
+/**
+ * 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 DisplayMessage.
+ */
+nsresult
+nsMsgComposeService::RunMessageThroughMimeDraft(
+            const nsACString& aMsgURI, nsMimeOutputType aOutType,
+            nsIMsgIdentity * aIdentity, const char * aOriginalMsgURI,
+            nsIMsgDBHdr * aOrigMsgHdr,
+            bool aForwardInline,
+            const nsAString &aForwardTo,
+            bool aOverrideComposeFormat,
+            nsIMsgWindow *aMsgWindow)
+{
+  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(NS_MAILNEWS_MIME_STREAM_CONVERTER_CONTRACTID, &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, NS_LITERAL_CSTRING("file:"));
+  nsCString mailboxUri(aMsgURI);
+  if (fileUrl)
+  {
+    // We loaded a .eml file from a file: url. Construct equivalent mailbox url.
+    mailboxUri.Replace(0, 5, NS_LITERAL_CSTRING("mailbox:"));
+    mailboxUri.Append(NS_LITERAL_CSTRING("&number=0"));
+    // Need this to prevent nsMsgCompose::TagEmbeddedObjects from setting
+    // inline images as moz-do-not-send.
+    mimeConverter->SetOriginalMsgURI(mailboxUri.get());
+  }
+  if (fileUrl || PromiseFlatCString(aMsgURI).Find("&type=application/x-message-display") >= 0)
+    rv = NS_NewURI(getter_AddRefs(url), mailboxUri);
+  else
+    rv = messageService->GetUrlForUri(PromiseFlatCString(aMsgURI).get(), getter_AddRefs(url), aMsgWindow);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // ignore errors here - it's not fatal, and in the case of mailbox messages,
+  // we're always passing in an invalid spec...
+  (void )url->SetSpec(mailboxUri);
+
+  // if we are forwarding a message and that message used a charset over ride
+  // then use that over ride charset instead of the charset specified in the message
+  nsCString mailCharset;
+  if (aMsgWindow)
+  {
+    bool charsetOverride;
+    if (NS_SUCCEEDED(aMsgWindow->GetCharsetOverride(&charsetOverride)) && charsetOverride)
+    {
+      if (NS_SUCCEEDED(aMsgWindow->GetMailCharacterSet(mailCharset)))
+      {
+        nsCOMPtr<nsIMsgI18NUrl> i18nUrl(do_QueryInterface(url));
+        if (i18nUrl)
+          (void) i18nUrl->SetCharsetOverRide(mailCharset.get());
+      }
+    }
+  }
+
+  nsCOMPtr<nsIPrincipal> nullPrincipal =
+    do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
+  NS_ASSERTION(NS_SUCCEEDED(rv), "CreateInstance of nullprincipal failed");
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCOMPtr<nsIChannel> channel;
+  rv = NS_NewInputStreamChannel(getter_AddRefs(channel),
+                     url,
+                     nullptr,
+                     nullPrincipal,
+                     nsILoadInfo::SEC_NORMAL,
+                     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);
+  nsCOMPtr<nsIURI> dummyNull;
+  return messageService->DisplayMessage(PromiseFlatCString(aMsgURI).get(), streamListener,
+                                        aMsgWindow, nullptr, mailCharset.get(),
+                                        getter_AddRefs(dummyNull));
+}
+
+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(NS_LITERAL_STRING("compose"), 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(NS_LITERAL_STRING("url"), false, &found);
+    // 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, NS_LITERAL_STRING("mailto:"))  ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("preselectid=")) ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("to="))  ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("cc="))  ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("bcc=")) ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("newsgroups=")) ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("subject=")) ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("format=")) ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("body="))  ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("attachment=")) ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("message=")) ||
+        StringBeginsWith(uristr, NS_LITERAL_STRING("from="))) {
+      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<mozIDOMWindowProxy> opened;
+    wwatch->OpenWindow(nullptr, DEFAULT_CHROME, "_blank",
+                       "chrome,dialog=no,all", arg, getter_AddRefs(opened));
+
+    aCmdLine->SetPreventDefault(true);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeService::GetHelpInfo(nsACString& aResult)
+{
+  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;
+}
diff --git a/mailnews/compose/src/nsMsgComposeService.h b/mailnews/compose/src/nsMsgComposeService.h
new file mode 100644
index 000000000..6ba029050
--- /dev/null
+++ b/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 "nsIXULWindow.h"
+#include "nsIObserver.h"
+#include "nsWeakReference.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 char * aOriginalMsgURI, 
+                               nsIMsgDBHdr * aOrigMsgHdr, bool aForwardInline,
+                               bool overrideComposeFormat,
+                               nsIMsgWindow *aMsgWindow);
+
+  nsresult RunMessageThroughMimeDraft(const nsACString& aMsgURI,
+                                      nsMimeOutputType aOutType,
+                                      nsIMsgIdentity * aIdentity,
+                                      const char * aOriginalMsgURI,
+                                      nsIMsgDBHdr * aOrigMsgHdr,
+                                      bool aForwardInline,
+                                      const nsAString &forwardTo,
+                                      bool overrideComposeFormat,
+                                      nsIMsgWindow *aMsgWindow);
+
+  // 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, nsIMsgWindow *aMsgWindow, nsACString& aSelHTML);
+
+#ifdef MSGCOMP_TRACE_PERFORMANCE
+  PRIntervalTime            mStartTime;
+  PRIntervalTime            mPreviousTime;
+#endif
+};
diff --git a/mailnews/compose/src/nsMsgCopy.cpp b/mailnews/compose/src/nsMsgCopy.cpp
new file mode 100644
index 000000000..5c441b0c1
--- /dev/null
+++ b/mailnews/compose/src/nsMsgCopy.cpp
@@ -0,0 +1,553 @@
+/* -*- 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 "nsMsgBaseCID.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIMsgProtocolInfo.h"
+#include "nsISupports.h"
+#include "nsIRDFService.h"
+#include "nsIRDFResource.h"
+#include "nsRDFCID.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 "nsArrayUtils.h"
+
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+
+////////////////////////////////////////////////////////////////////////////////////
+// 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, nsIUrlListener)
+
+nsMsgCopy::nsMsgCopy()
+{
+  mFile = nullptr;
+  mMode = nsIMsgSend::nsMsgDeliverNow;
+  mSavePref = nullptr;
+}
+
+nsMsgCopy::~nsMsgCopy()
+{
+  PR_Free(mSavePref);
+}
+
+nsresult
+nsMsgCopy::StartCopyOperation(nsIMsgIdentity       *aUserIdentity,
+                              nsIFile          *aFile,
+                              nsMsgDeliverMode     aMode,
+                              nsIMsgSend           *aMsgSendObj,
+                              const char           *aSavePref,
+                              nsIMsgDBHdr            *aMsgToReplace)
+{
+  nsCOMPtr<nsIMsgFolder>  dstFolder;
+  bool                    isDraft = false;
+  bool                    waitForUrl = false;
+  nsresult                rv;
+
+  if (!aMsgSendObj)
+    return NS_ERROR_INVALID_ARG;
+
+  // Store away the server location...
+  if (aSavePref)
+    mSavePref = PL_strdup(aSavePref);
+
+  //
+  // Vars for implementation...
+  //
+
+  // QueueForLater (Outbox)
+  if (aMode == nsIMsgSend::nsMsgQueueForLater ||
+      aMode == nsIMsgSend::nsMsgDeliverBackground)
+  {
+    rv = GetUnsentMessagesFolder(aUserIdentity, getter_AddRefs(dstFolder), &waitForUrl);
+    isDraft = false;
+    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;
+    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);
+    isDraft = false;
+    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);
+    isDraft = false;
+    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;
+  if (!waitForUrl)
+  {
+    // cache info needed for DoCopy and call DoCopy when OnStopUrl is called.
+    rv = DoCopy(aFile, dstFolder, aMsgToReplace, isDraft, 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,
+                  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(NS_MSGACCOUNTMANAGER_CONTRACTID, &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(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = copyService->CopyFileMessage(aDiskFile, dstFolder, aMsgToReplace,
+                                      aIsDraft,
+                                      aIsDraft ? 0 : nsMsgMessageFlags::Read,
+                                      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;
+}
+
+// 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, 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<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+    if (NS_FAILED(rv)) return rv;
+
+    // get the corresponding RDF resource
+    // RDF will create the folder resource if it doesn't already exist
+    nsCOMPtr<nsIRDFResource> resource;
+    rv = rdf->GetResource(nsDependentCString(aFolderURI), getter_AddRefs(resource));
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr <nsIMsgFolder> folderResource;
+    folderResource = do_QueryInterface(resource, &rv);
+    if (NS_SUCCEEDED(rv) && folderResource)
+    {
+      // 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 = folderResource->GetServer(getter_AddRefs(server));
+      NS_ENSURE_SUCCESS(rv,rv);
+      return server->GetMsgFolderFromURI(folderResource, nsDependentCString(aFolderURI), msgFolder);
+    }
+    else
+    {
+      return NS_ERROR_FAILURE;
+    }
+  }
+  else
+  {
+    uint32_t                  cnt = 0;
+    uint32_t                  i;
+
+    if (!userIdentity)
+      return NS_ERROR_INVALID_ARG;
+
+    // get the account manager
+    nsCOMPtr<nsIMsgAccountManager> accountManager =
+             do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    // If any folder will do, go look for one.
+    nsCOMPtr<nsIArray> retval;
+    accountManager->GetServersForIdentity(userIdentity, getter_AddRefs(retval));
+    if (!retval) return NS_ERROR_FAILURE;
+
+    // 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...
+    rv = retval->GetLength(&cnt);
+    if (NS_FAILED(rv)) return rv;
+
+    for (i=0; i<cnt; i++) {
+      // Now that we have the server...we need to get the named message folder
+      nsCOMPtr<nsIMsgIncomingServer> inServer;
+
+      inServer = do_QueryElementAt(retval, i, &rv);
+      if(NS_FAILED(rv) || (!inServer))
+        continue;
+
+      //
+      // 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 = do_CreateInstance(NS_STANDARDURL_CONTRACTID, &rv);
+  if (NS_FAILED(rv)) return rv;
+
+  rv = url->SetSpec(nsDependentCString(aFolderURI));
+  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/mailnews/compose/src/nsMsgCopy.h b/mailnews/compose/src/nsMsgCopy.h
new file mode 100644
index 000000000..7b559d754
--- /dev/null
+++ b/mailnews/compose/src/nsMsgCopy.h
@@ -0,0 +1,120 @@
+/* -*- 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 "nsMsgSend.h"
+#include "nsIMsgFolder.h"
+#include "nsITransactionManager.h"
+#include "nsIMsgCopyServiceListener.h"
+#include "nsIMsgCopyService.h"
+
+// {0874C3B5-317D-11d3-8EFB-00A024A7D144}
+#define NS_IMSGCOPY_IID           \
+{ 0x874c3b5, 0x317d, 0x11d3,      \
+{ 0x8e, 0xfb, 0x0, 0xa0, 0x24, 0xa7, 0xd1, 0x44 } };
+
+// 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 nsIUrlListener
+{
+public:
+  nsMsgCopy();
+
+  // nsISupports interface
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIURLLISTENER
+
+
+  //////////////////////////////////////////////////////////////////////
+  // Object methods...
+  //////////////////////////////////////////////////////////////////////
+  //
+  nsresult              StartCopyOperation(nsIMsgIdentity       *aUserIdentity,
+                                           nsIFile          *aFile, 
+                                           nsMsgDeliverMode     aMode,
+                                           nsIMsgSend           *aMsgSendObj,
+                                           const char           *aSavePref,
+                                           nsIMsgDBHdr          *aMsgToReplace);
+
+  nsresult              DoCopy(nsIFile *aDiskFile, nsIMsgFolder *dstFolder,
+                               nsIMsgDBHdr *aMsgToReplace, bool aIsDraft,
+                               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;
+  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/mailnews/compose/src/nsMsgPrompts.cpp b/mailnews/compose/src/nsMsgPrompts.cpp
new file mode 100644
index 000000000..473469f16
--- /dev/null
+++ b/mailnews/compose/src/nsMsgPrompts.cpp
@@ -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 "nsMsgPrompts.h"
+
+#include "nsMsgCopy.h"
+#include "nsIPrompt.h"
+#include "nsIWindowWatcher.h"
+#include "nsMsgCompCID.h"
+#include "nsComposeStrings.h"
+#include "nsIStringBundle.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Services.h"
+
+nsresult
+nsMsgGetMessageByName(const char16_t* aName, nsString& aResult)
+{
+  nsresult rv;
+  nsCOMPtr<nsIStringBundleService> bundleService =
+    mozilla::services::GetStringBundleService();
+  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, getter_Copies(aResult));
+}
+
+static nsresult
+nsMsgBuildMessageByName(const char16_t *aName, nsIFile *aFile, nsString& aResult)
+{
+  NS_ENSURE_ARG_POINTER(aFile);
+  nsresult rv;
+  nsCOMPtr<nsIStringBundleService> bundleService =
+    mozilla::services::GetStringBundleService();
+  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);
+
+  const char16_t *params[1] = {path.get()};
+  return bundle->FormatStringFromName(aName, params, 1, getter_Copies(aResult));
+}
+
+nsresult
+nsMsgBuildMessageWithFile(nsIFile *aFile, nsString& aResult)
+{
+  return nsMsgBuildMessageByName(u"unableToOpenFile", aFile, aResult);
+}
+
+nsresult
+nsMsgBuildMessageWithTmpFile(nsIFile *aFile, nsString& aResult)
+{
+  return nsMsgBuildMessageByName(u"unableToOpenTmpFile", aFile, aResult);
+}
+
+nsresult
+nsMsgDisplayMessageByName(nsIPrompt *aPrompt, const char16_t* aName, const char16_t *windowTitle)
+{
+  nsString msg;
+  nsMsgGetMessageByName(aName, msg);
+  return nsMsgDisplayMessageByString(aPrompt, msg.get(), windowTitle);
+}
+
+nsresult
+nsMsgDisplayMessageByString(nsIPrompt * aPrompt, const char16_t * msg, const char16_t * windowTitle)
+{
+  NS_ENSURE_ARG_POINTER(msg);
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIPrompt> prompt = aPrompt;
+
+  if (!prompt)
+  {
+    nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
+    if (wwatch)
+      wwatch->GetNewPrompter(0, getter_AddRefs(prompt));
+  }
+
+  if (prompt)
+    rv = prompt->Alert(windowTitle, msg);
+
+  return rv;
+}
+
+nsresult
+nsMsgAskBooleanQuestionByString(nsIPrompt * aPrompt, const char16_t * msg, bool *answer, const char16_t * windowTitle)
+{
+  NS_ENSURE_TRUE(msg && *msg, NS_ERROR_INVALID_ARG);
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIPrompt> dialog = aPrompt;
+
+  if (!dialog)
+  {
+    nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
+    if (wwatch)
+      wwatch->GetNewPrompter(0, getter_AddRefs(dialog));
+  }
+
+  if (dialog) {
+    rv = dialog->Confirm(windowTitle, msg, answer);
+  }
+
+  return rv;
+}
diff --git a/mailnews/compose/src/nsMsgPrompts.h b/mailnews/compose/src/nsMsgPrompts.h
new file mode 100644
index 000000000..9aed5252e
--- /dev/null
+++ b/mailnews/compose/src/nsMsgPrompts.h
@@ -0,0 +1,22 @@
+/* -*- 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 "nsStringGlue.h"
+
+class nsIPrompt;
+
+nsresult      nsMsgGetMessageByName(const char16_t* aName, nsString& aResult);
+nsresult      nsMsgBuildMessageWithFile(nsIFile * aFile, nsString& aResult);
+nsresult      nsMsgBuildMessageWithTmpFile(nsIFile * aFile, nsString& aResult);
+nsresult      nsMsgDisplayMessageByName(nsIPrompt *aPrompt, const char16_t *aName, const char16_t *windowTitle = nullptr);
+nsresult      nsMsgDisplayMessageByString(nsIPrompt * aPrompt, const char16_t * msg, const char16_t * windowTitle = nullptr);
+nsresult      nsMsgAskBooleanQuestionByString(nsIPrompt * aPrompt, const char16_t * msg, bool *answer, const char16_t * windowTitle = nullptr);
+
+#endif /* _nsMsgPrompts_H_ */
diff --git a/mailnews/compose/src/nsMsgQuote.cpp b/mailnews/compose/src/nsMsgQuote.cpp
new file mode 100644
index 000000000..ce8e1b5d0
--- /dev/null
+++ b/mailnews/compose/src/nsMsgQuote.cpp
@@ -0,0 +1,233 @@
+/* -*- 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 "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 "nsMsgMimeCID.h"
+#include "nsMsgCompCID.h"
+#include "nsMsgCompose.h"
+#include "nsMsgMailNewsUrl.h"
+#include "mozilla/Services.h"
+#include "nsIScriptSecurityManager.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);
+    *aMsgQuote = msgQuote;
+    NS_IF_ADDREF(*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)
+{
+  nsresult rv = NS_OK;
+  if (aStreamListener)
+  {
+    *aStreamListener = mStreamListener;
+    NS_IF_ADDREF(*aStreamListener);
+  }
+  else
+    rv = NS_ERROR_NULL_POINTER;
+
+  return rv;
+}
+
+nsresult
+nsMsgQuote::QuoteMessage(const char *msgURI, bool quoteHeaders,
+                         nsIMsgQuotingOutputStreamListener * aQuoteMsgStreamListener,
+                         const char * aMsgCharSet, bool headersOnly,
+                         nsIMsgDBHdr *aMsgHdr)
+{
+  nsresult  rv;
+  if (!msgURI)
+    return NS_ERROR_INVALID_ARG;
+
+  mQuoteHeaders = quoteHeaders;
+  mStreamListener = aQuoteMsgStreamListener;
+
+  nsAutoCString msgUri(msgURI);
+  bool fileUrl = !strncmp(msgURI, "file:", 5);
+  bool forwardedMessage = PL_strstr(msgURI, "&realtype=message/rfc822") != nullptr;
+  nsCOMPtr<nsIURI> aURL;
+  if (fileUrl)
+  {
+    msgUri.Replace(0, 5, NS_LITERAL_CSTRING("mailbox:"));
+    msgUri.AppendLiteral("?number=0");
+    rv = NS_NewURI(getter_AddRefs(aURL), msgUri);
+    nsCOMPtr<nsIMsgMessageUrl> mailUrl(do_QueryInterface(aURL));
+    if (mailUrl)
+      mailUrl->SetMessageHeader(aMsgHdr);
+  }
+  else if (forwardedMessage)
+    rv = NS_NewURI(getter_AddRefs(aURL), msgURI);
+  else
+  {
+    nsCOMPtr <nsIMsgMessageService> msgService;
+    rv = GetMessageServiceFromURI(nsDependentCString(msgURI), getter_AddRefs(msgService));
+    if (NS_FAILED(rv)) return rv;
+    rv = msgService->GetUrlForUri(msgURI, getter_AddRefs(aURL), nullptr);
+  }
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr <nsIURL> mailNewsUrl = do_QueryInterface(aURL, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsAutoCString queryPart;
+  rv = mailNewsUrl->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.Append("header=only");
+  else if (quoteHeaders)
+    queryPart.Append("header=quote");
+  else
+    queryPart.Append("header=quotebody");
+  rv = mailNewsUrl->SetQuery(queryPart);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // if we were given a non empty charset, then use it
+  if (aMsgCharSet && *aMsgCharSet)
+  {
+    nsCOMPtr<nsIMsgI18NUrl> i18nUrl (do_QueryInterface(aURL));
+    if (i18nUrl)
+      i18nUrl->SetCharsetOverRide(aMsgCharSet);
+  }
+
+  mQuoteListener = do_CreateInstance(NS_MSGQUOTELISTENER_CONTRACTID, &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
+  nsCOMPtr<nsIScriptSecurityManager> secMan(
+      do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIPrincipal> systemPrincipal;
+  rv = secMan->GetSystemPrincipal(getter_AddRefs(systemPrincipal));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  mQuoteChannel = nullptr;
+  nsCOMPtr<nsIIOService> netService = mozilla::services::GetIOService();
+  NS_ENSURE_TRUE(netService, NS_ERROR_UNEXPECTED);
+  rv = netService->NewChannelFromURI2(aURL,
+                                      nullptr,
+                                      systemPrincipal,
+                                      nullptr,
+                                      nsILoadInfo::SEC_NORMAL,
+                                      nsIContentPolicy::TYPE_OTHER,
+                                      getter_AddRefs(mQuoteChannel));
+
+  if (NS_FAILED(rv)) return rv;
+  nsCOMPtr<nsISupports> ctxt = do_QueryInterface(aURL);
+
+  nsCOMPtr<nsIStreamConverterService> streamConverterService = 
+           do_GetService("@mozilla.org/streamConverters;1", &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIStreamListener> convertedListener;
+  rv = streamConverterService->AsyncConvertData("message/rfc822",
+                                                "application/vnd.mozilla.xul+xml",
+                                                mStreamListener,
+                                                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, ctxt);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgQuote::GetQuoteListener(nsIMimeStreamConverterListener** aQuoteListener)
+{
+    if (!aQuoteListener || !mQuoteListener)
+        return NS_ERROR_NULL_POINTER;
+    *aQuoteListener = mQuoteListener;
+    NS_ADDREF(*aQuoteListener);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgQuote::GetQuoteChannel(nsIChannel** aQuoteChannel)
+{
+    if (!aQuoteChannel || !mQuoteChannel)
+        return NS_ERROR_NULL_POINTER;
+    *aQuoteChannel = mQuoteChannel;
+    NS_ADDREF(*aQuoteChannel);
+    return NS_OK;
+}
diff --git a/mailnews/compose/src/nsMsgQuote.h b/mailnews/compose/src/nsMsgQuote.h
new file mode 100644
index 000000000..2151828ef
--- /dev/null
+++ b/mailnews/compose/src/nsMsgQuote.h
@@ -0,0 +1,52 @@
+/* -*- 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...
+  //
+  nsCOMPtr<nsIMsgQuotingOutputStreamListener> mStreamListener;
+  bool			mQuoteHeaders;
+  nsCOMPtr<nsIMsgQuoteListener> mQuoteListener;
+  nsCOMPtr<nsIChannel> mQuoteChannel;
+};
+
+#endif /* __nsMsgQuote_h__ */
diff --git a/mailnews/compose/src/nsMsgSend.cpp b/mailnews/compose/src/nsMsgSend.cpp
new file mode 100644
index 000000000..c0f74e11c
--- /dev/null
+++ b/mailnews/compose/src/nsMsgSend.cpp
@@ -0,0 +1,5218 @@
+/* -*- 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 "nsMsgSend.h"
+#include "prmem.h"
+#include "nsMsgLocalFolderHdrs.h"
+#include "nsMsgSendPart.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgNewsCID.h"
+#include "nsISmtpService.h"  // for actually sending the message...
+#include "nsINntpService.h"  // for actually posting the message...
+#include "nsIMsgMailSession.h"
+#include "nsIMsgIdentity.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsMsgCompUtils.h"
+#include "nsMsgI18N.h"
+#include "nsICharsetConverterManager.h"
+#include "nsIMsgSendListener.h"
+#include "nsIMsgCopyServiceListener.h"
+#include "nsIFile.h"
+#include "nsIURL.h"
+#include "nsNetUtil.h"
+#include "nsIFileURL.h"
+#include "nsMsgCopy.h"
+#include "nsUnicharUtils.h"
+#include "nsMsgPrompts.h"
+#include "nsIDOMHTMLBodyElement.h"
+#include "nsIDOMHTMLImageElement.h"
+#include "nsIDOMHTMLLinkElement.h"
+#include "nsIDOMHTMLAnchorElement.h"
+#include "nsCExternalHandlerService.h"
+#include "nsIMIMEService.h"
+#include "nsIDocument.h"
+#include "nsIDOMDocument.h"
+#include "nsMsgCompCID.h"
+#include "nsIAbAddressCollector.h"
+#include "nsAbBaseCID.h"
+#include "nsCOMPtr.h"
+#include "mozITXTToHTMLConv.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsIMsgWindow.h"
+#include "nsTextFormatter.h"
+#include "nsIPrompt.h"
+#include "nsMailHeaders.h"
+#include "nsIDocShell.h"
+#include "nsMimeTypes.h"
+#include "nsISmtpUrl.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIEditorMailSupport.h"
+#include "nsIDocumentEncoder.h"    // for editor output flags
+#include "nsILoadGroup.h"
+#include "nsMsgSendReport.h"
+#include "nsNetCID.h"
+#include "nsError.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgMdnGenerator.h"
+#include "nsISmtpServer.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "nsIMsgAccountManager.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsIAbCard.h"
+#include "nsIMsgAttachment.h"
+#include "nsIMsgProgress.h"
+#include "nsIMsgMessageService.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgFolder.h"
+#include "nsComposeStrings.h"
+#include "nsStringGlue.h"
+#include "nsMsgUtils.h"
+#include "nsIArray.h"
+#include "nsArrayUtils.h"
+#include "mozilla/Services.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/mailnews/MimeEncoder.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+#include "nsIMutableArray.h"
+#include "nsIMsgFilterService.h"
+#include "nsIMsgProtocolInfo.h"
+#include "mozIDOMWindow.h"
+#include "mozilla/Preferences.h"
+
+using namespace mozilla;
+using namespace mozilla::mailnews;
+
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+
+#define PREF_MAIL_SEND_STRUCT "mail.send_struct"
+#define PREF_MAIL_STRICTLY_MIME "mail.strictly_mime"
+#define PREF_MAIL_MESSAGE_WARNING_SIZE "mailnews.message_warning_size"
+#define PREF_MAIL_COLLECT_EMAIL_ADDRESS_OUTGOING "mail.collect_email_address_outgoing"
+
+#define ATTR_MOZ_DO_NOT_SEND "moz-do-not-send"
+
+enum  { kDefaultMode = (PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE) };
+
+static bool mime_use_quoted_printable_p = false;
+
+//
+// Ugh, we need to do this currently to access this boolean.
+//
+bool
+UseQuotedPrintable(void)
+{
+  return mime_use_quoted_printable_p;
+}
+
+/* This function will parse a list of email addresses and groups and just
+ * return a list of email addresses (recipient)
+ *
+ * The input could be:
+ *    [recipient | group] *[,recipient | group]
+ *
+ * The group syntax is:
+ *    group-name:[recipient *[,recipient]];
+ *
+ * the output will be:
+ *    recipient *[, recipient]
+ *
+ * As the result will always be equal or smaller than the input string,
+ * the extraction will be made in place. Don't need to create a new buffer.
+ */
+static nsresult StripOutGroupNames(char * addresses)
+{
+  char aChar;
+  char * readPtr = addresses;           // current read position
+  char * writePtr = addresses;          // current write position
+  char * previousSeparator = addresses; // remember last time we wrote a recipient separator
+  char * endPtr = addresses + PL_strlen(addresses);
+
+  bool quoted = false;   // indicate if we are between double quote
+  bool group = false;   // indicate if we found a group prefix
+  bool atFound = false;  // indicate if we found an @ in the current recipient. group name should not have an @
+
+  while (readPtr < endPtr)
+  {
+    aChar = *readPtr;
+    readPtr ++;
+    switch(aChar)
+    {
+      case '\\':
+        if (*readPtr == '"') //ignore escaped quote
+          readPtr ++;
+        continue;
+
+      case '"':
+        quoted = !quoted;
+        break;
+
+      case '@':
+        if (!quoted)
+          atFound = true;
+        break;
+
+      case ':':
+        if (!quoted && !atFound)
+        {
+          // ok, we found a group name
+          // let's backup the write cursor to remove the group name
+          writePtr = previousSeparator + 1;
+          group = true;
+          continue;
+        }
+        break;
+
+      case ';':
+        if (quoted || !group)
+          break;
+        else
+          group = false;
+          //end of the group, act like a recipient separator now...
+        /* NO BREAK */
+        MOZ_FALLTHROUGH;
+      case ',':
+        if (!quoted)
+        {
+          atFound = false;
+          //let check if we already have a comma separator in the output string
+          if (writePtr > addresses && *(writePtr - 1) == ',')
+            writePtr --;
+          *writePtr = ',';
+          previousSeparator = writePtr;
+          writePtr ++;
+          continue;
+        }
+        break;
+    }
+    *writePtr = aChar;
+    writePtr ++;
+  }
+
+  if (writePtr > addresses && *(writePtr - 1) == ',')
+    writePtr --;
+  *writePtr = '\0';
+
+  return NS_OK;
+}
+
+
+// This private class just provides us an external URL listener, with callback functionality.
+
+class MsgDeliveryListener : public nsIUrlListener
+{
+public:
+  MsgDeliveryListener(nsIMsgSend *aMsgSend, bool inIsNewsDelivery);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIURLLISTENER
+
+private:
+  virtual ~MsgDeliveryListener();
+  nsCOMPtr<nsIMsgSend> mMsgSend;
+  bool                 mIsNewsDelivery;
+};
+
+NS_IMPL_ISUPPORTS(MsgDeliveryListener, nsIUrlListener)
+
+MsgDeliveryListener::MsgDeliveryListener(nsIMsgSend *aMsgSend, bool inIsNewsDelivery)
+{
+  mMsgSend = aMsgSend;
+  mIsNewsDelivery = inIsNewsDelivery;
+}
+
+MsgDeliveryListener::~MsgDeliveryListener()
+{
+}
+
+NS_IMETHODIMP MsgDeliveryListener::OnStartRunningUrl(nsIURI *url)
+{
+  if (mMsgSend)
+    mMsgSend->NotifyListenerOnStartSending(nullptr, 0);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP MsgDeliveryListener::OnStopRunningUrl(nsIURI *url, nsresult aExitCode)
+{
+  if (url)
+  {
+    nsCOMPtr<nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(url);
+    if (mailUrl)
+      mailUrl->UnRegisterListener(this);
+  }
+
+  // Let mMsgSend sort out the OnStopSending notification - it knows more about
+  // the messages than we do.
+  if (mMsgSend)
+    mMsgSend->SendDeliveryCallback(url, mIsNewsDelivery, aExitCode);
+
+  return NS_OK;
+}
+
+
+/* the following macro actually implement addref, release and query interface for our component. */
+NS_IMPL_ISUPPORTS(nsMsgComposeAndSend, nsIMsgSend, nsIMsgOperationListener,
+                  nsISupportsWeakReference)
+
+nsMsgComposeAndSend::nsMsgComposeAndSend() :
+    m_messageKey(nsMsgKey_None)
+{
+  mGUINotificationEnabled = true;
+  mAbortInProcess = false;
+  mMultipartRelatedAttachmentCount = -1;
+  mSendMailAlso = false;
+
+  m_dont_deliver_p = false;
+  m_deliver_mode = nsMsgDeliverNow;
+
+  m_pre_snarfed_attachments_p = false;
+  m_digest_p = false;
+  m_be_synchronous_p = false;
+  m_attachment1_type = 0;
+  m_attachment1_encoding = 0;
+  m_attachment1_body = 0;
+  m_attachment1_body_length = 0;
+  m_attachment_count = 0;
+  m_attachment_pending_count = 0;
+  m_status = NS_OK;
+  m_plaintext = nullptr;
+  m_related_part = nullptr;
+  m_related_body_part = nullptr;
+  mOriginalHTMLBody = nullptr;
+
+  mNeedToPerformSecondFCC = false;
+  mPerformingSecondFCC = false;
+
+  mPreloadedAttachmentCount = 0;
+  mRemoteAttachmentCount = 0;
+  mCompFieldLocalAttachments = 0;
+  mCompFieldRemoteAttachments = 0;
+  mMessageWarningSize = 0;
+
+  mSendReport = new nsMsgSendReport();
+}
+
+nsMsgComposeAndSend::~nsMsgComposeAndSend()
+{
+  PR_Free(m_attachment1_type);
+  PR_Free(m_attachment1_encoding);
+  PR_Free(m_attachment1_body);
+  PR_Free(mOriginalHTMLBody);
+
+  if (m_plaintext)
+  {
+    if (m_plaintext->mTmpFile)
+      m_plaintext->mTmpFile->Remove(false);
+
+    m_plaintext = nullptr;
+  }
+
+  if (mHTMLFile)
+    mHTMLFile->Remove(false);
+
+  if (mCopyFile)
+    mCopyFile->Remove(false);
+
+  if (mCopyFile2)
+    mCopyFile2->Remove(false);
+
+  if (mTempFile && !mReturnFile)
+    mTempFile->Remove(false);
+
+  m_attachments.Clear();
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetDefaultPrompt(nsIPrompt ** aPrompt)
+{
+  NS_ENSURE_ARG(aPrompt);
+  *aPrompt = nullptr;
+
+  nsresult rv = NS_OK;
+
+  if (mParentWindow)
+  {
+    rv = mParentWindow->GetPrompter(aPrompt);
+    if (NS_SUCCEEDED(rv) && *aPrompt)
+      return NS_OK;
+  }
+
+  /* If we cannot find a prompter, try the mail3Pane window */
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+  nsCOMPtr <nsIMsgMailSession> mailSession (do_GetService(NS_MSGMAILSESSION_CONTRACTID));
+  if (mailSession)
+  {
+    mailSession->GetTopmostMsgWindow(getter_AddRefs(msgWindow));
+    if (msgWindow)
+      rv = msgWindow->GetPromptDialog(aPrompt);
+  }
+
+  return rv;
+}
+
+nsresult nsMsgComposeAndSend::GetNotificationCallbacks(nsIInterfaceRequestor** aCallbacks)
+{
+// TODO: stop using mail3pane window!
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+  nsCOMPtr<nsIMsgMailSession> mailSession(do_GetService(NS_MSGMAILSESSION_CONTRACTID));
+  mailSession->GetTopmostMsgWindow(getter_AddRefs(msgWindow));
+  if (msgWindow) {
+    nsCOMPtr<nsIDocShell> docShell;
+    msgWindow->GetRootDocShell(getter_AddRefs(docShell));
+    nsCOMPtr<nsIInterfaceRequestor> ir(do_QueryInterface(docShell));
+    nsCOMPtr<nsIInterfaceRequestor> notificationCallbacks;
+    msgWindow->GetNotificationCallbacks(getter_AddRefs(notificationCallbacks));
+    if (notificationCallbacks) {
+      nsCOMPtr<nsIInterfaceRequestor> aggregrateIR;
+      MsgNewInterfaceRequestorAggregation(notificationCallbacks, ir, getter_AddRefs(aggregrateIR));
+      ir = aggregrateIR;
+    }
+    if (ir) {
+      NS_ADDREF(*aCallbacks = ir);
+      return NS_OK;
+    }
+  }
+  return NS_ERROR_FAILURE;
+}
+
+
+static char *mime_mailto_stream_read_buffer = 0;
+static char *mime_mailto_stream_write_buffer = 0;
+
+
+char * mime_get_stream_write_buffer(void)
+{
+  if (!mime_mailto_stream_write_buffer)
+    mime_mailto_stream_write_buffer = (char *) PR_Malloc(MIME_BUFFER_SIZE);
+  return mime_mailto_stream_write_buffer;
+}
+
+static bool isEmpty(const char* aString)
+{
+  return (!aString) || (!*aString);
+}
+
+void nsMsgComposeAndSend::GenerateMessageId()
+{
+  if (isEmpty(mCompFields->GetMessageId()))
+  {
+    if (isEmpty(mCompFields->GetTo()) &&
+        isEmpty(mCompFields->GetCc()) &&
+        isEmpty(mCompFields->GetBcc()) &&
+        !isEmpty(mCompFields->GetNewsgroups()))
+    {
+      bool generateNewsMessageId = false;
+      mUserIdentity->GetBoolAttribute("generate_news_message_id", &generateNewsMessageId);
+      if (!generateNewsMessageId)
+        return;
+    }
+
+    char* msgID = msg_generate_message_id(mUserIdentity);
+    mCompFields->SetMessageId(msgID);
+    PR_Free(msgID);
+  }
+}
+
+// Don't I18N this line...this is per the spec!
+#define   MIME_MULTIPART_BLURB     "This is a multi-part message in MIME format."
+
+/* All of the desired attachments have been written to individual temp files,
+   and we know what's in them.  Now we need to make a final temp file of the
+   actual mail message, containing all of the other files after having been
+   encoded as appropriate.
+ */
+NS_IMETHODIMP
+nsMsgComposeAndSend::GatherMimeAttachments()
+{
+  bool shouldDeleteDeliveryState = true;
+  nsresult status;
+  uint32_t    i;
+  PRFileDesc  *in_file = 0;
+  char *buffer = 0;
+  nsString msg;
+  bool body_is_us_ascii = true;
+  bool isUsingQP = false;
+
+  nsMsgSendPart* toppart = nullptr;      // The very top most container of the message
+                      // that we are going to send.
+
+  nsMsgSendPart* mainbody = nullptr;     // The leaf node that contains the text of the
+                      // message we're going to contain.
+
+  nsMsgSendPart* maincontainer = nullptr;  // The direct child of toppart that will
+                      // contain the mainbody.  If mainbody is
+                      // the same as toppart, then this is
+                      // also the same.  But if mainbody is
+                      // to end up somewhere inside of a
+                      // multipart/alternative or a
+                      // multipart/related, then this is that
+                      // multipart object.
+
+  nsMsgSendPart* plainpart = nullptr;    // If we converted HTML into plaintext,
+                      // the message or child containing the plaintext
+                      // goes here. (Need to use this to determine
+                      // what headers to append/set to the main
+                      // message body.)
+
+  uint32_t multipartRelatedCount = GetMultipartRelatedCount(); // The number of related part we will have to generate
+
+  nsCOMPtr<nsIPrompt> promptObject; // only used if we have to show an alert here....
+  GetDefaultPrompt(getter_AddRefs(promptObject));
+
+  char *hdrs = 0;
+  bool maincontainerISrelatedpart = false;
+  const char * toppart_type = nullptr;
+
+  status = m_status;
+  if (NS_FAILED(status))
+    goto FAIL;
+
+  if (!m_attachment1_type) {
+    m_attachment1_type = PL_strdup(TEXT_PLAIN);
+    if (!m_attachment1_type)
+      goto FAILMEM;
+  }
+
+  nsresult rv;
+
+  // If we have a text/html main part, and we need a plaintext attachment, then
+  // we'll do so now.  This is an asynchronous thing, so we'll kick it off and
+  // count on getting back here when it finishes.
+
+  if (m_plaintext == nullptr &&
+      (mCompFields->GetForcePlainText() ||
+       mCompFields->GetUseMultipartAlternative()) &&
+       m_attachment1_body && PL_strcmp(m_attachment1_type, TEXT_HTML) == 0)
+  {
+    //
+    // If we get here, we have an HTML body, but we really need to send
+    // a text/plain message, so we will write the HTML out to a disk file,
+    // fire off another URL request for this local disk file and that will
+    // take care of the conversion...
+    //
+    rv = nsMsgCreateTempFile("nsemail.html", getter_AddRefs(mHTMLFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIOutputStream> tempfile;
+    rv = MsgNewBufferedFileOutputStream(getter_AddRefs(tempfile), mHTMLFile, -1, 00600);
+    if (NS_FAILED(rv))
+    {
+      if (mSendReport)
+      {
+        nsAutoString error_msg;
+        nsMsgBuildMessageWithTmpFile(mHTMLFile, error_msg);
+        mSendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), false);
+      }
+      status = NS_MSG_UNABLE_TO_OPEN_TMP_FILE;
+      goto FAIL;
+    }
+
+    if (mOriginalHTMLBody)
+    {
+      uint32_t origLen = strlen(mOriginalHTMLBody);
+      uint32_t n;
+      nsresult rv = tempfile->Write(mOriginalHTMLBody, origLen, &n);
+      if (NS_FAILED(rv) || n != origLen)
+      {
+        status = NS_MSG_ERROR_WRITING_FILE;
+        goto FAIL;
+      }
+    }
+
+    if (NS_FAILED(tempfile->Flush()))
+    {
+      status = NS_MSG_ERROR_WRITING_FILE;
+      goto FAIL;
+    }
+
+    tempfile->Close();
+
+    m_plaintext = new nsMsgAttachmentHandler;
+    if (!m_plaintext)
+      goto FAILMEM;
+    m_plaintext->SetMimeDeliveryState(this);
+    m_plaintext->m_bogus_attachment = true;
+
+    nsAutoCString tempURL;
+    rv = NS_GetURLSpecFromFile(mHTMLFile, tempURL);
+    if (NS_FAILED(rv) || NS_FAILED(nsMsgNewURL(getter_AddRefs(m_plaintext->mURL), tempURL.get())))
+    {
+      m_plaintext = nullptr;
+      goto FAILMEM;
+    }
+
+    m_plaintext->m_type = TEXT_HTML;
+    m_plaintext->m_charset = mCompFields->GetCharacterSet();
+    m_plaintext->m_desiredType = TEXT_PLAIN;
+    m_attachment_pending_count ++;
+    status = m_plaintext->SnarfAttachment(mCompFields);
+    if (NS_FAILED(status))
+      goto FAIL;
+    if (m_attachment_pending_count > 0)
+      return NS_OK;
+  }
+
+  /* Kludge to avoid having to allocate memory on the toy computers... */
+  buffer = mime_get_stream_write_buffer();
+  if (! buffer)
+    goto FAILMEM;
+
+  NS_ASSERTION (m_attachment_pending_count == 0, "m_attachment_pending_count != 0");
+
+  mComposeBundle->GetStringFromName(u"assemblingMessage",
+                                    getter_Copies(msg));
+  SetStatusMessage( msg );
+
+  /* First, open the message file.
+  */
+  rv = nsMsgCreateTempFile("nsemail.eml", getter_AddRefs(mTempFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mOutputFile), mTempFile, -1, 00600);
+  if (NS_FAILED(rv))
+  {
+    status = NS_MSG_UNABLE_TO_OPEN_TMP_FILE;
+    if (mSendReport)
+    {
+      nsAutoString error_msg;
+      nsMsgBuildMessageWithTmpFile(mTempFile, error_msg);
+      mSendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), false);
+    }
+    goto FAIL;
+  }
+
+  // generate a message id, if necessary
+  GenerateMessageId( );
+
+  mainbody = new nsMsgSendPart(this, mCompFields->GetCharacterSet());
+  if (!mainbody)
+    goto FAILMEM;
+
+  mainbody->SetMainPart(true);
+  mainbody->SetType(m_attachment1_type ? m_attachment1_type : TEXT_PLAIN);
+
+  NS_ASSERTION(mainbody->GetBuffer() == nullptr, "not-null buffer");
+  status = mainbody->SetBuffer(m_attachment1_body ? m_attachment1_body : "");
+  if (NS_FAILED(status))
+    goto FAIL;
+
+  // Determine the encoding of the main message body before we free it.
+  PR_FREEIF(m_attachment1_encoding);
+  if (m_attachment1_body)
+    mCompFields->GetBodyIsAsciiOnly(&body_is_us_ascii);
+
+  if (!mCompFields->GetForceMsgEncoding() && (body_is_us_ascii ||
+      nsMsgI18Nstateful_charset(mCompFields->GetCharacterSet()))) {
+    m_attachment1_encoding = PL_strdup (ENCODING_7BIT);
+  } else if (mime_use_quoted_printable_p) {
+    m_attachment1_encoding = PL_strdup (ENCODING_QUOTED_PRINTABLE);
+    isUsingQP = true;
+  } else {
+    m_attachment1_encoding = PL_strdup (ENCODING_8BIT);
+  }
+
+  // Make sure the lines don't get to long.
+  if (m_attachment1_body) {
+    uint32_t max_column = 0;
+    uint32_t cur_column = 0;
+    for (char* c = m_attachment1_body; *c; c++) {
+      if (*c == '\n') {
+        if (cur_column > max_column)
+          max_column = cur_column;
+        cur_column = 0;
+      } else if (*c != '\r') {
+        cur_column++;
+      }
+    }
+    // Check one last time for the last line.
+    if (cur_column > max_column)
+      max_column = cur_column;
+    if (max_column > LINELENGTH_ENCODING_THRESHOLD && !isUsingQP) {
+      // To encode "long lines" use a CTE that will transmit shorter lines.
+      // Switch to base64 if we are not already using "quoted printable".
+      PR_FREEIF(m_attachment1_encoding);
+      m_attachment1_encoding = PL_strdup (ENCODING_BASE64);
+    }
+  }
+  PR_FREEIF (m_attachment1_body);
+
+  maincontainer = mainbody;
+
+  // If we were given a pre-saved collection of HTML and contained images,
+  // then we want mainbody to point to the HTML lump therein.
+  if (m_related_part)
+  {
+    // If m_related_part is of type text/html, set both maincontainer
+    // and mainbody to point to it. If m_related_part is multipart/related,
+    // however, set mainbody to be the first child within m_related_part.
+    delete mainbody;
+
+    // No matter what, maincontainer points to the outermost related part.
+    maincontainer = m_related_part;
+    maincontainerISrelatedpart = true;
+
+    mainbody = m_related_part->GetChild(0);
+    mainbody->SetMainPart(true);
+  }
+  if (m_plaintext)
+  {
+    //
+    // OK.  We have a plaintext version of the main body that we want to
+    // send instead of or with the text/html.  Shove it in.
+    //
+    plainpart = new nsMsgSendPart(this, mCompFields->GetCharacterSet());
+    if (!plainpart)
+      goto FAILMEM;
+    status = plainpart->SetType(TEXT_PLAIN);
+    if (NS_FAILED(status))
+      goto FAIL;
+    status = plainpart->SetFile(m_plaintext->mTmpFile);
+    if (NS_FAILED(status))
+      goto FAIL;
+
+    m_plaintext->mMainBody = true;
+
+    // Determine Content-Transfer-Encoding for the attachments.
+    m_plaintext->PickEncoding(mCompFields->GetCharacterSet(), this);
+    const char *charset = mCompFields->GetCharacterSet();
+    hdrs = mime_generate_attachment_headers(m_plaintext->m_type.get(),
+                        nullptr,
+                        m_plaintext->m_encoding.get(),
+                        m_plaintext->m_description.get(),
+                        m_plaintext->m_xMacType.get(),
+                        m_plaintext->m_xMacCreator.get(),
+                        nullptr, 0,
+                        m_digest_p,
+                        m_plaintext,
+                        charset,
+                        charset,
+                        body_is_us_ascii,
+                        nullptr,
+                        true);
+    if (!hdrs)
+      goto FAILMEM;
+    status = plainpart->SetOtherHeaders(hdrs);
+    PR_Free(hdrs);
+    hdrs = nullptr;
+    if (NS_FAILED(status))
+      goto FAIL;
+
+    if (mCompFields->GetUseMultipartAlternative())
+    {
+      nsMsgSendPart* htmlpart = maincontainer;
+      maincontainer = new nsMsgSendPart(this);
+      if (!maincontainer)
+        goto FAILMEM;
+
+      // Setup the maincontainer stuff...
+      status = maincontainer->SetType(MULTIPART_ALTERNATIVE);
+      if (NS_FAILED(status))
+        goto FAIL;
+
+      status = maincontainer->AddChild(plainpart);
+      if (NS_FAILED(status))
+        goto FAIL;
+
+      status = maincontainer->AddChild(htmlpart);
+      if (NS_FAILED(status))
+        goto FAIL;
+
+      // Create the encoder for the plaintext part here,
+      // because we aren't the main part (attachment1).
+      // (This, along with the rest of the routine, should really
+      // be restructured so that no special treatment is given to
+      // the main body text that came in. Best to put attachment1_text
+      // etc. into a nsMsgSendPart, then reshuffle the parts. Sigh.)
+      if (m_plaintext->m_encoding.LowerCaseEqualsLiteral(ENCODING_QUOTED_PRINTABLE))
+      {
+        plainpart->SetEncoder(MimeEncoder::GetQPEncoder(
+          mime_encoder_output_fn, this));
+      }
+      else if (m_plaintext->m_encoding.LowerCaseEqualsLiteral(ENCODING_BASE64))
+      {
+        plainpart->SetEncoder(MimeEncoder::GetBase64Encoder(
+          mime_encoder_output_fn, this));
+      }
+    }
+    else
+    {
+      delete maincontainer;
+      if (maincontainerISrelatedpart)
+        m_related_part = nullptr; // in that case, m_related_part == maincontainer which we have just deleted!
+      maincontainer = plainpart;
+      mainbody = maincontainer;
+      PR_FREEIF(m_attachment1_type);
+      m_attachment1_type = PL_strdup(TEXT_PLAIN);
+      if (!m_attachment1_type)
+        goto FAILMEM;
+
+      // Override attachment1_encoding here. We do this blindly since we are
+      // sending plaintext only at this point.
+      PR_FREEIF(m_attachment1_encoding);
+      m_attachment1_encoding = ToNewCString(m_plaintext->m_encoding);
+    }
+  }
+
+  // check if we need to encapsulate the message in a multipart/mixed or multipart/digest
+  if (m_attachment_count > multipartRelatedCount)
+  {
+    toppart = new nsMsgSendPart(this);
+    if (!toppart)
+      goto FAILMEM;
+
+    status = toppart->SetType(m_digest_p ? MULTIPART_DIGEST : MULTIPART_MIXED);
+    if (NS_FAILED(status))
+      goto FAIL;
+
+    status = toppart->AddChild(maincontainer);
+    if (NS_FAILED(status))
+      goto FAIL;
+  }
+  else
+    toppart = maincontainer;
+
+  // Is the top part a multipart container?
+  // can't use m_attachment_count because it's not reliable for that
+  // instead use type of main part. See bug #174396
+  toppart_type = toppart->GetType(); // GetType return directly the member variable, don't free it!
+  if (!m_crypto_closure && toppart_type && !PL_strncasecmp(toppart_type, "multipart/", 10))
+  {
+    status = toppart->SetBuffer(MIME_MULTIPART_BLURB);
+    if (NS_FAILED(status))
+      goto FAIL;
+  }
+
+  {
+    nsCOMPtr<msgIWritableStructuredHeaders> outputHeaders =
+      do_CreateInstance(NS_ISTRUCTUREDHEADERS_CONTRACTID);
+    status = mime_generate_headers(mCompFields, m_deliver_mode, outputHeaders);
+    if (NS_FAILED(status))
+      goto FAIL;
+
+    // Convert the blocks of headers into a single string for emission.
+    nsAutoCString headers;
+    outputHeaders->BuildMimeText(headers);
+
+    // If we converted HTML into plaintext, the plaintext part (plainpart)
+    // already has its content-type and content-transfer-encoding ("other")
+    // headers set.
+    //
+    // In the specific case where such a plaintext part is the top-level message
+    // part (iff an HTML message is being sent as text only and no other
+    // attachments exist) we want to preserve the original plainpart headers,
+    // since they contain accurate transfer encoding and Mac type/creator
+    // information.
+    //
+    // So, in the above case we append the main message headers, otherwise we
+    // overwrite whatever headers may have existed.
+    if (plainpart && plainpart == toppart)
+      status = toppart->AppendOtherHeaders(headers.get());
+    else
+      status = toppart->SetOtherHeaders(headers.get());
+  }
+
+  if (NS_FAILED(status))
+    goto FAIL;
+
+  // Set up the first part (user-typed.)  For now, do it even if the first
+  // part is empty; we need to add things to skip it if this part is empty.
+
+  // Set up encoder for the first part (message body.)
+  //
+  NS_ASSERTION(!m_attachment1_encoder, "not-null m_attachment1_encoder");
+  if (!PL_strcasecmp(m_attachment1_encoding, ENCODING_BASE64))
+  {
+    m_attachment1_encoder = MimeEncoder::GetBase64Encoder(
+      mime_encoder_output_fn, this);
+  }
+  else if (!PL_strcasecmp(m_attachment1_encoding, ENCODING_QUOTED_PRINTABLE))
+  {
+    m_attachment1_encoder = MimeEncoder::GetQPEncoder(mime_encoder_output_fn,
+      this);
+  }
+
+  // If we converted HTML into plaintext, the plaintext part
+  // already has its type/encoding headers set. So, in the specific
+  // case where such a plaintext part is the main message body
+  // (iff an HTML message is being sent as text only)
+  // we want to avoid generating type/encoding/digest headers;
+  // in all other cases, generate such headers here.
+  //
+  // We really want to set up headers as a dictionary of some sort
+  // so that we need not worry about duplicate header lines.
+  //
+  if ((!plainpart) || (plainpart != mainbody))
+  {
+    const char *charset = mCompFields->GetCharacterSet();
+    hdrs = mime_generate_attachment_headers (m_attachment1_type,
+                         nullptr,
+                         m_attachment1_encoding,
+                         0, 0, 0, 0, 0,
+                         m_digest_p,
+                         nullptr, /* no "ma"! */
+                         charset,
+                         charset,
+                         mCompFields->GetBodyIsAsciiOnly(),
+                         nullptr,
+                         true);
+    if (!hdrs)
+      goto FAILMEM;
+    status = mainbody->AppendOtherHeaders(hdrs);
+    if (NS_FAILED(status))
+      goto FAIL;
+  }
+
+  PR_FREEIF(hdrs);
+
+  mainbody->SetEncoder(m_attachment1_encoder.forget());
+
+  //
+  // Now we need to process attachments and slot them in the
+  // correct hierarchy.
+  //
+  if (m_attachment_count > 0)
+  {
+    // Kludge to avoid having to allocate memory on the toy computers...
+    if (! mime_mailto_stream_read_buffer)
+      mime_mailto_stream_read_buffer = (char *) PR_Malloc (MIME_BUFFER_SIZE);
+    buffer = mime_mailto_stream_read_buffer;
+    if (! buffer)
+      goto FAILMEM;
+
+    // Gather all of the attachments for this message that are NOT
+    // part of an enclosed MHTML message!
+    for (i = 0; i < m_attachment_count; i++)
+    {
+      nsMsgAttachmentHandler *ma = m_attachments[i];
+      if (!ma->mMHTMLPart)
+        PreProcessPart(ma, toppart);
+    }
+
+    //
+    // If we have a m_related_part as a container for children, then we have to
+    // tack on these children for the part
+    //
+    if (m_related_part)
+    {
+      for (i = 0; i < m_attachment_count; i++)
+      {
+        //
+        // look for earlier part with the same content id. If we find it,
+        // need to remember the mapping between our node index and the
+        // part num of the earlier part.
+        int32_t nodeIndex = m_attachments[i]->mNodeIndex;
+        if (nodeIndex != -1)
+        {
+          for (uint32_t j = 0; j < i; j++)
+          {
+            if (m_attachments[j]->mNodeIndex != -1 &&
+                m_attachments[j]->m_contentId.Equals(m_attachments[i]->m_contentId))
+              m_partNumbers[nodeIndex] = m_partNumbers[m_attachments[j]->mNodeIndex];
+          }
+        }
+        // rhp: This is here because we could get here after saying OK
+        // to a lot of prompts about not being able to fetch this part!
+        //
+        if (m_attachments[i]->mPartUserOmissionOverride)
+          continue;
+
+        // Now, we need to add this part to the m_related_part member so the
+        // message will be generated correctly.
+        if (m_attachments[i]->mMHTMLPart)
+          PreProcessPart(m_attachments[i], m_related_part);
+      }
+    }
+
+  }
+
+  // Tell the user we are creating the message...
+  mComposeBundle->GetStringFromName(u"creatingMailMessage",
+                                    getter_Copies(msg));
+  SetStatusMessage( msg );
+
+  // OK, now actually write the structure we've carefully built up.
+  status = toppart->Write();
+  if (NS_FAILED(status))
+    goto FAIL;
+
+  /* Close down encryption stream */
+  if (m_crypto_closure)
+  {
+    status = m_crypto_closure->FinishCryptoEncapsulation(false, mSendReport);
+    m_crypto_closure = nullptr;
+    if (NS_FAILED(status)) goto FAIL;
+  }
+
+  if (mOutputFile)
+  {
+    if (NS_FAILED(mOutputFile->Flush()))
+    {
+      status = NS_MSG_ERROR_WRITING_FILE;
+      goto FAIL;
+    }
+
+    mOutputFile->Close();
+    mOutputFile = nullptr;
+
+    // mTempFile is stale because we wrote to it.  Get another copy to refresh.
+    nsCOMPtr<nsIFile> tempFileCopy;
+    mTempFile->Clone(getter_AddRefs(tempFileCopy));
+    mTempFile = tempFileCopy;
+    tempFileCopy = nullptr;
+    /* If we don't do this check...ZERO length files can be sent */
+    int64_t fileSize;
+    rv = mTempFile->GetFileSize(&fileSize);
+    if (NS_FAILED(rv) || fileSize == 0)
+    {
+      status = NS_MSG_ERROR_WRITING_FILE;
+      goto FAIL;
+    }
+  }
+
+  mComposeBundle->GetStringFromName(u"assemblingMessageDone",
+                                    getter_Copies(msg));
+  SetStatusMessage(msg);
+
+  if (m_dont_deliver_p && mListener)
+  {
+    //
+    // Need to ditch the file spec here so that we don't delete the
+    // file, since in this case, the caller wants the file
+    //
+    mReturnFile = mTempFile;
+    mTempFile = nullptr;
+    if (!mReturnFile)
+      NotifyListenerOnStopSending(nullptr, NS_ERROR_OUT_OF_MEMORY, nullptr, nullptr);
+    else
+    {
+      NotifyListenerOnStopSending(nullptr, NS_OK, nullptr, mReturnFile);
+    }
+  }
+  else
+  {
+    status = DeliverMessage();
+    if (NS_SUCCEEDED(status))
+      shouldDeleteDeliveryState = false;
+  }
+  goto FAIL;
+
+FAILMEM:
+  status = NS_ERROR_OUT_OF_MEMORY;
+
+FAIL:
+  if (toppart)
+    delete toppart;
+  toppart = nullptr;
+  mainbody = nullptr;
+  maincontainer = nullptr;
+
+  if (in_file)
+  {
+    PR_Close (in_file);
+    in_file = nullptr;
+  }
+
+  if (shouldDeleteDeliveryState)
+  {
+    if (NS_FAILED(status))
+    {
+      m_status = status;
+      nsresult ignoreMe;
+      Fail(status, nullptr, &ignoreMe);
+    }
+  }
+
+  return status;
+}
+
+int32_t
+nsMsgComposeAndSend::PreProcessPart(nsMsgAttachmentHandler  *ma,
+                                    nsMsgSendPart           *toppart) // The very top most container of the message
+{
+  nsresult        status;
+  char            *hdrs = 0;
+  nsMsgSendPart   *part = nullptr;
+
+  // If this was one of those dead parts from a quoted web page,
+  // then just return safely.
+  //
+  if (ma->m_bogus_attachment)
+    return 0;
+
+  // If at this point we *still* don't have a content-type, then
+  // we're never going to get one.
+  if (ma->m_type.IsEmpty())
+    ma->m_type = UNKNOWN_CONTENT_TYPE;
+
+  ma->PickEncoding(mCompFields->GetCharacterSet(), this);
+  ma->PickCharset();
+
+  part = new nsMsgSendPart(this);
+  if (!part)
+    return 0;
+  status = toppart->AddChild(part);
+  // Remember the part number if it has a node index.
+  if (ma->mNodeIndex != -1)
+    m_partNumbers[ma->mNodeIndex] = part->m_partNum;
+
+  if (NS_FAILED(status))
+    return 0;
+  status = part->SetType(ma->m_type.get());
+  if (NS_FAILED(status))
+    return 0;
+
+  if (ma->mSendViaCloud)
+    ma->m_encoding = ENCODING_7BIT;
+
+  nsCString turl;
+  if (!ma->mURL)
+  {
+    if (!ma->m_uri.IsEmpty())
+      turl = ma->m_uri;
+  }
+  else {
+    status = ma->mURL->GetSpec(turl);
+    if (NS_FAILED(status))
+      return 0;
+  }
+
+  nsCString type(ma->m_type);
+  nsCString realName(ma->m_realName);
+
+  // for cloud attachments, make the part an html part with no name,
+  // so we don't show it as an attachment.
+  if (ma->mSendViaCloud)
+  {
+    type.Assign("application/octet-stream");
+    realName.Truncate();
+  }
+  hdrs = mime_generate_attachment_headers (type.get(),
+                                           ma->m_typeParam.get(),
+                                           ma->m_encoding.get(),
+                                           ma->m_description.get(),
+                                           ma->m_xMacType.get(),
+                                           ma->m_xMacCreator.get(),
+                                           realName.get(),
+                                           turl.get(),
+                                           m_digest_p,
+                                           ma,
+                                           ma->m_charset.get(), // rhp - this needs
+                                                          // to be the charset
+                                                          // we determine from
+                                                          // the file or none
+                                                          // at all!
+                                           mCompFields->GetCharacterSet(),
+                                           false,      // bodyIsAsciiOnly to false
+                                                          // for attachments
+                                           ma->m_contentId.get(),
+                                           false);
+  if (!hdrs)
+    return 0;
+
+  status = part->SetOtherHeaders(hdrs);
+  PR_FREEIF(hdrs);
+  if (ma->mSendViaCloud)
+  {
+    nsCString urlSpec;
+    status = ma->mURL->GetSpec(urlSpec);
+    if (NS_FAILED(status))
+      return 0;
+
+    // Need to add some headers so that libmime can restore the cloud info
+    // when loading a draft message.
+    nsCString draftInfo(HEADER_X_MOZILLA_CLOUD_PART": cloudFile; url=");
+    draftInfo.Append(ma->mCloudUrl.get());
+    // don't leak user file paths or account keys to recipients.
+    if (m_deliver_mode == nsMsgSaveAsDraft)
+    {
+      draftInfo.Append("; provider=");
+      draftInfo.Append(ma->mCloudProviderKey.get());
+      draftInfo.Append("; file=");
+      draftInfo.Append(urlSpec.get());
+    }
+    draftInfo.Append("; name=");
+    draftInfo.Append(ma->m_realName.get());
+    draftInfo.Append(CRLF);
+    part->AppendOtherHeaders(draftInfo.get());
+    part->SetType("application/octet-stream");
+    part->SetBuffer("");
+  }
+  if (NS_FAILED(status))
+    return 0;
+  status = part->SetFile(ma->mTmpFile);
+  if (NS_FAILED(status))
+    return 0;
+  if (ma->m_encoder)
+  {
+    part->SetEncoder(ma->m_encoder.forget());
+  }
+
+  ma->m_current_column = 0;
+
+  if (ma->m_type.LowerCaseEqualsLiteral(MESSAGE_RFC822) ||
+      ma->m_type.LowerCaseEqualsLiteral(MESSAGE_NEWS)) {
+    part->SetStripSensitiveHeaders(true);
+  }
+
+  return 1;
+}
+
+# define FROB(X) \
+    if (X && *X) \
+    { \
+      if (*recipients) PL_strcat(recipients, ","); \
+      PL_strcat(recipients, X); \
+    }
+
+nsresult nsMsgComposeAndSend::BeginCryptoEncapsulation ()
+{
+  // Try to create a secure compose object. If we can create it, then query to see
+  // if we need to use it for this send transaction.
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgComposeSecure> secureCompose;
+  secureCompose = do_CreateInstance(NS_MSGCOMPOSESECURE_CONTRACTID, &rv);
+  // it's not an error scenario of there is secure compose
+  if (NS_FAILED(rv))
+    return NS_OK;
+
+  if (secureCompose)
+  {
+    bool requiresEncryptionWork = false;
+    secureCompose->RequiresCryptoEncapsulation(mUserIdentity, mCompFields, &requiresEncryptionWork);
+    if (requiresEncryptionWork)
+    {
+      m_crypto_closure = secureCompose;
+      // bah i'd like to move the following blurb into the implementation of BeginCryptoEncapsulation; however
+      // the apis for nsIMsgComposeField just aren't rich enough. It requires the implementor to jump through way
+      // too many string conversions....
+      char * recipients = (char *)
+      PR_MALLOC((mCompFields->GetTo()  ? strlen(mCompFields->GetTo())  : 0) +
+         (mCompFields->GetCc()  ? strlen(mCompFields->GetCc())  : 0) +
+         (mCompFields->GetBcc() ? strlen(mCompFields->GetBcc()) : 0) +
+         (mCompFields->GetNewsgroups() ? strlen(mCompFields->GetNewsgroups()) : 0) + 20);
+      if (!recipients) return NS_ERROR_OUT_OF_MEMORY;
+
+      *recipients = 0;
+
+      FROB(mCompFields->GetTo())
+      FROB(mCompFields->GetCc())
+      FROB(mCompFields->GetBcc())
+      FROB(mCompFields->GetNewsgroups())
+
+      // end section of code I'd like to move to the implementor.....
+      rv = m_crypto_closure->BeginCryptoEncapsulation(mOutputFile,
+                                                      recipients,
+                                                      mCompFields,
+                                                      mUserIdentity,
+                                                      mSendReport,
+                                                      (m_deliver_mode == nsMsgSaveAsDraft));
+
+      PR_FREEIF(recipients);
+    }
+
+  }
+
+  return rv;
+}
+
+nsresult
+mime_write_message_body(nsIMsgSend *state, const char *buf, uint32_t size)
+{
+  NS_ENSURE_ARG_POINTER(state);
+
+  nsCOMPtr<nsIOutputStream> output;
+  nsCOMPtr<nsIMsgComposeSecure> crypto_closure;
+
+  state->GetOutputStream(getter_AddRefs(output));
+  if (!output)
+    return NS_MSG_ERROR_WRITING_FILE;
+
+  state->GetCryptoclosure(getter_AddRefs(crypto_closure));
+  if (crypto_closure)
+  {
+    // Copy to new null-terminated string so JS glue doesn't crash when
+    // MimeCryptoWriteBlock() is implemented in JS.
+    nsCString bufWithNull;
+    bufWithNull.Assign(buf, size);
+    return crypto_closure->MimeCryptoWriteBlock(bufWithNull.get(), size);
+  }
+
+  uint32_t n;
+  nsresult rv = output->Write(buf, size, &n);
+  if (NS_FAILED(rv) || n != size)
+  {
+    return NS_MSG_ERROR_WRITING_FILE;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+mime_encoder_output_fn(const char *buf, int32_t size, void *closure)
+{
+  nsMsgComposeAndSend *state = (nsMsgComposeAndSend *) closure;
+  return mime_write_message_body (state, (char *) buf, (uint32_t)size);
+}
+
+nsresult
+nsMsgComposeAndSend::GetEmbeddedObjectInfo(nsIDOMNode *node, nsMsgAttachmentData *attachment, bool *acceptObject)
+{
+  NS_ENSURE_ARG_POINTER(node);
+  NS_ENSURE_ARG_POINTER(attachment);
+  NS_ENSURE_ARG_POINTER(acceptObject);
+
+  // GetEmbeddedObjectInfo will determine if we need to attach the source of the
+  // embedded object with the message. The decision is made automatically unless
+  // the attribute moz-do-not-send has been set to true or false.
+  nsresult rv = NS_OK;
+
+  // Reset this structure to null!
+  *acceptObject = false;
+
+  // We're only interested in body, image, link and anchors which are all
+  // elements.
+  nsCOMPtr<nsIDOMElement> domElement = do_QueryInterface(node);
+  if (!domElement)
+    return NS_OK;
+
+  bool isImage = false;
+  nsAutoString mozDoNotSendAttr;
+  domElement->GetAttribute(NS_LITERAL_STRING(ATTR_MOZ_DO_NOT_SEND), mozDoNotSendAttr);
+
+  // Only empty or moz-do-not-send="false" may be accepted later.
+  if (!(mozDoNotSendAttr.IsEmpty() || mozDoNotSendAttr.LowerCaseEqualsLiteral("false")))
+    return NS_OK;
+
+  // Now, we know the types of objects this node can be, so we will do
+  // our query interface here and see what we come up with
+  nsCOMPtr<nsIDOMHTMLBodyElement>     body = (do_QueryInterface(node));
+  // XXX convert to use nsIImageLoadingContent?
+  nsCOMPtr<nsIDOMHTMLImageElement>    image = (do_QueryInterface(node));
+  nsCOMPtr<nsIDOMHTMLLinkElement>     link = (do_QueryInterface(node));
+  nsCOMPtr<nsIDOMHTMLAnchorElement>   anchor = (do_QueryInterface(node));
+
+  // First, try to see if the body as a background image
+  if (body)
+  {
+    nsAutoString    tUrl;
+    if (NS_SUCCEEDED(body->GetBackground(tUrl)))
+    {
+      nsAutoCString turlC;
+      CopyUTF16toUTF8(tUrl, turlC);
+      if (NS_FAILED(nsMsgNewURL(getter_AddRefs(attachment->m_url), turlC.get())))
+        return NS_OK;
+    }
+    isImage = true;
+  }
+  else if (image)        // Is this an image?
+  {
+    nsString    tUrl;
+    nsString    tName;
+    nsString    tDesc;
+
+    // Create the URI
+    if (NS_FAILED(image->GetSrc(tUrl)))
+      return NS_ERROR_FAILURE;
+    if (tUrl.IsEmpty())
+      return NS_OK;
+
+    nsAutoCString turlC;
+    CopyUTF16toUTF8(tUrl, turlC);
+    if (NS_FAILED(nsMsgNewURL(getter_AddRefs(attachment->m_url), turlC.get())))
+    {
+      // Well, the first time failed...which means we probably didn't get
+      // the full path name...
+      //
+      nsIDOMDocument    *ownerDocument = nullptr;
+      node->GetOwnerDocument(&ownerDocument);
+      if (ownerDocument)
+      {
+        nsIDocument     *doc = nullptr;
+        if (NS_FAILED(ownerDocument->QueryInterface(NS_GET_IID(nsIDocument),(void**)&doc)) || !doc)
+          return NS_ERROR_OUT_OF_MEMORY;
+
+        nsAutoCString spec;
+        nsIURI *uri = doc->GetDocumentURI();
+
+        if (!uri)
+          return NS_ERROR_OUT_OF_MEMORY;
+
+        rv = uri->GetSpec(spec);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        // Ok, now get the path to the root doc and tack on the name we
+        // got from the GetSrc() call....
+        NS_ConvertUTF8toUTF16 workURL(spec);
+
+        int32_t loc = workURL.RFindChar('/');
+        if (loc >= 0)
+          workURL.SetLength(loc+1);
+        workURL.Append(tUrl);
+        NS_ConvertUTF16toUTF8 workurlC(workURL);
+        if (NS_FAILED(nsMsgNewURL(getter_AddRefs(attachment->m_url), workurlC.get())))
+          return NS_OK; // Continue and send it without this image.
+      }
+    }
+    isImage = true;
+
+    rv = image->GetName(tName);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    LossyCopyUTF16toASCII(tName, attachment->m_realName);
+    rv = image->GetLongDesc(tDesc);
+    NS_ENSURE_SUCCESS(rv, rv);
+    attachment->m_description = NS_LossyConvertUTF16toASCII(tDesc); // XXX i18n
+  }
+  else if (link)        // Is this a link?
+  {
+    nsString    tUrl;
+
+    // Create the URI
+    rv = link->GetHref(tUrl);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (tUrl.IsEmpty())
+      return NS_OK;
+    nsAutoCString turlC;
+    CopyUTF16toUTF8(tUrl, turlC);
+    if (NS_FAILED(nsMsgNewURL(getter_AddRefs(attachment->m_url), turlC.get())))
+      return NS_OK;
+  }
+  else if (anchor)
+  {
+    nsString    tUrl;
+    nsString    tName;
+
+    // Create the URI
+    rv = anchor->GetHref(tUrl);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (tUrl.IsEmpty())
+      return NS_OK;
+    nsAutoCString turlC;
+    CopyUTF16toUTF8(tUrl, turlC);
+    // This can fail since the URL might not be recognised, for example:
+    // <a href="skype:some-name?call" title="Skype">Some Name</a>
+    if (NS_FAILED(nsMsgNewURL(getter_AddRefs(attachment->m_url), turlC.get())))
+      return NS_OK;
+    rv = anchor->GetName(tName);
+    NS_ENSURE_SUCCESS(rv, rv);
+    LossyCopyUTF16toASCII(tName, attachment->m_realName);
+  }
+  else
+  {
+    // If we get here, we got something we didn't expect!
+    // Just try to continue and send it without this thing.
+    return NS_OK;
+  }
+
+  // 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.
+  bool isHttp =
+    (NS_SUCCEEDED(attachment->m_url->SchemeIs("http", &isHttp)) && isHttp) ||
+    (NS_SUCCEEDED(attachment->m_url->SchemeIs("https", &isHttp)) && isHttp);
+  // Attach (= create cid: part) http resources if moz-do-not-send is set to
+  // "false". Special processing for images: We attach if the preference says so.
+  // Note that moz-do-not-send="true" is already processed above so the preference
+  // doesn't override this.
+  if (isHttp)
+  {
+    *acceptObject =
+      (isImage && Preferences::GetBool("mail.compose.attach_http_images", false)) ||
+      mozDoNotSendAttr.LowerCaseEqualsLiteral("false");
+    return NS_OK;
+  }
+
+  bool isData =
+    (NS_SUCCEEDED(attachment->m_url->SchemeIs("data", &isData)) && isData);
+  bool isNews =
+    (NS_SUCCEEDED(attachment->m_url->SchemeIs("news", &isNews)) && isNews) ||
+    (NS_SUCCEEDED(attachment->m_url->SchemeIs("snews", &isNews)) && isNews) ||
+    (NS_SUCCEEDED(attachment->m_url->SchemeIs("nntp", &isNews)) && isNews);
+  // Attach (= create cid: part) data resources if moz-do-not-send is not
+  // specified or set to "false".
+  if (isData || isNews)
+  {
+    *acceptObject = mozDoNotSendAttr.IsEmpty() ||
+      mozDoNotSendAttr.LowerCaseEqualsLiteral("false");
+    return NS_OK;
+  }
+
+  return NS_OK;
+}
+
+
+uint32_t
+nsMsgComposeAndSend::GetMultipartRelatedCount(bool forceToBeCalculated /*=false*/)
+{
+  nsresult                  rv = NS_OK;
+  uint32_t                  count;
+
+  if (mMultipartRelatedAttachmentCount != -1 && !forceToBeCalculated)
+    return (uint32_t)mMultipartRelatedAttachmentCount;
+
+  //First time here, let's calculate the correct number of related part we need to generate
+  mMultipartRelatedAttachmentCount = 0;
+  if (mEditor)
+  {
+    nsCOMPtr<nsIEditorMailSupport> mailEditor (do_QueryInterface(mEditor));
+    if (!mailEditor)
+      return 0;
+
+    rv = mailEditor->GetEmbeddedObjects(getter_AddRefs(mEmbeddedObjectList));
+    if (NS_FAILED(rv))
+      return 0;
+  }
+  if (!mEmbeddedObjectList)
+    return 0;
+
+  if (NS_SUCCEEDED(mEmbeddedObjectList->GetLength(&count)))
+  {
+    if (count > 0)
+    {
+      // preallocate space for part numbers
+      m_partNumbers.SetLength(count);
+      // Let parse the list to count the number of valid objects. BTW, we can remove the others from the list
+      RefPtr<nsMsgAttachmentData> attachment(new nsMsgAttachmentData);
+
+      int32_t i;
+      nsCOMPtr<nsIDOMNode> node;
+
+      for (i = count - 1, count = 0; i >= 0; i --)
+      {
+        // Reset this structure to null!
+
+        // now we need to get the element in the array and do the magic
+        // to process this element.
+        //
+        node = do_QueryElementAt(mEmbeddedObjectList, i, &rv);
+        bool acceptObject = false;
+        if (node)
+        {
+          rv = GetEmbeddedObjectInfo(node, attachment, &acceptObject);
+        }
+        else // outlook import case
+        {
+          nsCOMPtr<nsIMsgEmbeddedImageData> imageData =
+            do_QueryElementAt(mEmbeddedObjectList, i, &rv);
+          if (!imageData)
+            continue;
+          acceptObject = true;
+        }
+        if (NS_SUCCEEDED(rv) && acceptObject)
+          count ++;
+      }
+    }
+    mMultipartRelatedAttachmentCount = (int32_t)count;
+    return count;
+  }
+  else
+    return 0;
+}
+
+nsresult
+nsMsgComposeAndSend::GetBodyFromEditor()
+{
+  //
+  // Now we have to fix up and get the HTML from the editor. After we
+  // get the HTML data, we need to store it in the m_attachment_1_body
+  // member variable after doing the necessary charset conversion.
+  //
+
+  //
+  // Query the editor, get the body of HTML!
+  //
+  uint32_t flags = nsIDocumentEncoder::OutputFormatted |
+                   nsIDocumentEncoder::OutputNoFormattingInPre |
+                   nsIDocumentEncoder::OutputDisallowLineBreaking;
+  nsAutoString bodyStr;
+  char16_t* bodyText = nullptr;
+  nsresult rv;
+  char16_t *origHTMLBody = nullptr;
+
+  // Ok, get the body...the DOM should have been whacked with
+  // Content ID's already
+  if (mEditor)
+    mEditor->OutputToString(NS_LITERAL_STRING(TEXT_HTML), flags, bodyStr);
+  else
+    bodyStr = NS_ConvertASCIItoUTF16(m_attachment1_body);
+
+  // If we really didn't get a body, just return NS_OK
+  if (bodyStr.IsEmpty())
+    return NS_OK;
+  bodyText = ToNewUnicode(bodyStr);
+  if (!bodyText)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  // If we are forcing this to be plain text, we should not be
+  // doing this conversion.
+  bool doConversion = true;
+
+  if ( (mCompFields) && mCompFields->GetForcePlainText() )
+    doConversion = false;
+
+  if (doConversion)
+  {
+    nsCOMPtr<mozITXTToHTMLConv> conv = do_CreateInstance(MOZ_TXTTOHTMLCONV_CONTRACTID, &rv);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      uint32_t whattodo = mozITXTToHTMLConv::kURLs;
+      bool enable_structs = false;
+      nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+      if (pPrefBranch)
+      {
+        rv = pPrefBranch->GetBoolPref(PREF_MAIL_SEND_STRUCT, &enable_structs);
+        if (enable_structs)
+          whattodo = whattodo | mozITXTToHTMLConv::kStructPhrase;
+      }
+
+      char16_t* wresult;
+      rv = conv->ScanHTML(bodyText, whattodo, &wresult);
+      if (NS_SUCCEEDED(rv))
+      {
+        // Save the original body for possible attachment as plain text
+        // We should have what the user typed in stored in mOriginalHTMLBody
+        origHTMLBody = bodyText;
+        bodyText = wresult;
+      }
+    }
+  }
+
+  nsCString attachment1_body;
+
+  // Convert body to mail charset
+  nsCString    outCString;
+  const char  *aCharset = mCompFields->GetCharacterSet();
+
+  if (aCharset && *aCharset)
+  {
+    rv = nsMsgI18NConvertFromUnicode(aCharset, nsDependentString(bodyText), outCString, false, true);
+    bool isAsciiOnly = NS_IsAscii(outCString.get()) &&
+      !nsMsgI18Nstateful_charset(mCompFields->GetCharacterSet());
+    if (mCompFields->GetForceMsgEncoding())
+      isAsciiOnly = false;
+    mCompFields->SetBodyIsAsciiOnly(isAsciiOnly);
+
+    // If the body contains characters outside the current mail charset,
+    // convert to UTF-8.
+    if (NS_ERROR_UENC_NOMAPPING == rv)
+    {
+      bool needToCheckCharset;
+      mCompFields->GetNeedToCheckCharset(&needToCheckCharset);
+      if (needToCheckCharset)
+      {
+        // Just use UTF-8 and be done with it
+        // unless disable_fallback_to_utf8 is set for this charset.
+        bool disableFallback = false;
+        nsCOMPtr<nsIPrefBranch> prefBranch (do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+        if (prefBranch)
+        {
+          nsCString prefName("mailnews.disable_fallback_to_utf8.");
+          prefName.Append(aCharset);
+          prefBranch->GetBoolPref(prefName.get(), &disableFallback);
+        }
+        if (!disableFallback)
+        {
+          CopyUTF16toUTF8(nsDependentString(bodyText), outCString);
+          mCompFields->SetCharacterSet("UTF-8");
+        }
+      }
+    }
+
+    if (NS_SUCCEEDED(rv))
+      attachment1_body = outCString;
+
+    // If we have an origHTMLBody that is not null, this means that it is
+    // different than the bodyText because of formatting conversions. Because of
+    // this we need to do the charset conversion on this part separately
+    if (origHTMLBody)
+    {
+      nsCString newBody;
+      rv = nsMsgI18NConvertFromUnicode(aCharset,
+        nsDependentString(origHTMLBody), newBody, false, true);
+      if (NS_SUCCEEDED(rv))
+      {
+        mOriginalHTMLBody = ToNewCString(newBody);
+      }
+    }
+    else {
+      mOriginalHTMLBody = ToNewCString(attachment1_body);
+    }
+
+    NS_Free(bodyText);    //Don't need it anymore
+  }
+  else
+    return NS_ERROR_FAILURE;
+
+  rv = SnarfAndCopyBody(attachment1_body, TEXT_HTML);
+
+  return rv;
+}
+
+//
+// This is the routine that does the magic of generating the body and the
+// attachments for the multipart/related email message.
+//
+typedef struct
+{
+  nsIDOMNode    *node;
+  char          *url;
+} domSaveStruct;
+
+nsresult
+nsMsgComposeAndSend::ProcessMultipartRelated(int32_t *aMailboxCount, int32_t *aNewsCount)
+{
+  uint32_t                  multipartCount = GetMultipartRelatedCount();
+  nsresult                  rv = NS_OK;
+  uint32_t                  i;
+  int32_t                   j = -1;
+  uint32_t                  k;
+  int32_t                   duplicateOf;
+  domSaveStruct             *domSaveArray = nullptr;
+
+   if (!mEmbeddedObjectList)
+    return NS_ERROR_MIME_MPART_ATTACHMENT_ERROR;
+
+  RefPtr<nsMsgAttachmentData> attachment(new nsMsgAttachmentData);
+  int32_t               locCount = -1;
+
+  if (multipartCount > 0)
+  {
+    domSaveArray = (domSaveStruct *)PR_MALLOC(sizeof(domSaveStruct) * multipartCount);
+    if (!domSaveArray)
+      return NS_ERROR_MIME_MPART_ATTACHMENT_ERROR;
+    memset(domSaveArray, 0, sizeof(domSaveStruct) * multipartCount);
+  }
+
+  nsCOMPtr<nsIDOMNode> node;
+  for (i = mPreloadedAttachmentCount; i < (mPreloadedAttachmentCount + multipartCount);)
+  {
+    // Ok, now we need to get the element in the array and do the magic
+    // to process this element.
+    //
+
+    locCount++;
+    mEmbeddedObjectList->QueryElementAt(locCount, NS_GET_IID(nsIDOMNode), getter_AddRefs(node));
+    if (node)
+    {
+      bool acceptObject = false;
+      rv = GetEmbeddedObjectInfo(node, attachment, &acceptObject);
+      NS_ENSURE_SUCCESS(rv, NS_ERROR_MIME_MPART_ATTACHMENT_ERROR);
+      if (!acceptObject)
+        continue;
+      nsString nodeValue;
+      node->GetNodeValue(nodeValue);
+      LossyCopyUTF16toASCII(nodeValue, m_attachments[i]->m_contentId);
+    }
+    else
+    {
+      nsCOMPtr<nsIMsgEmbeddedImageData> imageData = do_QueryElementAt(mEmbeddedObjectList, locCount, &rv);
+      if (!imageData)
+        return NS_ERROR_MIME_MPART_ATTACHMENT_ERROR;
+      imageData->GetUri(getter_AddRefs(attachment->m_url));
+      if (!attachment->m_url)
+        return NS_ERROR_MIME_MPART_ATTACHMENT_ERROR;
+      imageData->GetCid(m_attachments[i]->m_contentId);
+      imageData->GetName(attachment->m_realName);
+    }
+
+
+    // MUST set this to get placed in the correct part of the message
+    m_attachments[i]->mMHTMLPart = true;
+
+    m_attachments[i]->mDeleteFile = true;
+    m_attachments[i]->m_done = false;
+    m_attachments[i]->SetMimeDeliveryState(this);
+    m_attachments[i]->mNodeIndex = locCount;
+
+    j++;
+    domSaveArray[j].node = node;
+
+    // check if we have alreay attached this object, don't need to attach it twice
+    duplicateOf = -1;
+    for (k = mPreloadedAttachmentCount; k < i; k++)
+    {
+      bool isEqual = false;
+      NS_ASSERTION(attachment->m_url, "null attachment url!");
+      if (attachment->m_url)
+        (void)attachment->m_url->Equals(m_attachments[k]->mURL, &isEqual);
+      if (isEqual)
+      {
+        duplicateOf = k;
+        break;
+      }
+    }
+
+    if (duplicateOf == -1)
+    {
+      //
+      // Now we have to get all of the interesting information from
+      // the nsIDOMNode we have in hand...
+      m_attachments[i]->mURL = attachment->m_url;
+
+      m_attachments[i]->m_overrideType = attachment->m_realType;
+      m_attachments[i]->m_overrideEncoding = attachment->m_realEncoding;
+      m_attachments[i]->m_desiredType = attachment->m_desiredType;
+      m_attachments[i]->m_description = attachment->m_description;
+      m_attachments[i]->m_realName = attachment->m_realName;
+      m_attachments[i]->m_xMacType = attachment->m_xMacType;
+      m_attachments[i]->m_xMacCreator = attachment->m_xMacCreator;
+
+      m_attachments[i]->m_charset = mCompFields->GetCharacterSet();
+      m_attachments[i]->m_encoding = ENCODING_7BIT;
+
+      if (m_attachments[i]->mURL)
+        msg_pick_real_name(m_attachments[i], nullptr, mCompFields->GetCharacterSet());
+
+      if (m_attachments[i]->m_contentId.IsEmpty())
+      {
+        //
+        // Next, generate a content id for use with this part
+        //
+        nsCString email;
+        mUserIdentity->GetEmail(email);
+        m_attachments[i]->m_contentId = mime_gen_content_id(locCount+1, email.get());
+      }
+
+      //
+      // Start counting the attachments which are going to come from mail folders
+      // and from NNTP servers.
+      //
+      if (m_attachments[i]->mURL)
+      {
+        nsIURI *uri = m_attachments[i]->mURL;
+        bool match = false;
+        if ((NS_SUCCEEDED(uri->SchemeIs("mailbox", &match)) && match) ||
+            (NS_SUCCEEDED(uri->SchemeIs("imap", &match)) && match))
+          (*aMailboxCount)++;
+        else if ((NS_SUCCEEDED(uri->SchemeIs("news", &match)) && match) ||
+                 (NS_SUCCEEDED(uri->SchemeIs("snews", &match)) && match))
+          (*aNewsCount)++;
+        else
+        {
+          // Additional account types need a mechanism to report that they are
+          // message protocols. If there is an nsIMsgProtocolInfo component
+          // registered for this scheme, we'll consider it a mailbox
+          // attachment.
+          nsAutoCString contractID;
+          contractID.Assign(
+            NS_LITERAL_CSTRING("@mozilla.org/messenger/protocol/info;1"));
+          nsAutoCString scheme;
+          uri->GetScheme(scheme);
+          contractID.Append(scheme);
+          nsCOMPtr<nsIMsgProtocolInfo> msgProtocolInfo =
+            do_CreateInstance(contractID.get());
+          if (msgProtocolInfo)
+            (*aMailboxCount)++;
+        }
+
+      }
+    }
+    else
+    {
+      m_attachments[i]->m_contentId = m_attachments[duplicateOf]->m_contentId;
+      m_attachments[i]->SetMimeDeliveryState(nullptr);
+    }
+
+    //
+    // Ok, while we are here, we should whack the DOM with the generated
+    // Content-ID for this object. This will be necessary for generating
+    // the HTML we need.
+    //
+    nsString domURL;
+    if (!m_attachments[duplicateOf == -1 ? i : duplicateOf]->m_contentId.IsEmpty())
+    {
+      nsString   newSpec(NS_LITERAL_STRING("cid:"));
+      newSpec.AppendASCII(m_attachments[duplicateOf == -1 ? i : duplicateOf]->m_contentId.get());
+
+      // Now, we know the types of objects this node can be, so we will do
+      // our query interface here and see what we come up with
+      nsCOMPtr<nsIDOMHTMLBodyElement>     body = (do_QueryInterface(domSaveArray[j].node));
+      nsCOMPtr<nsIDOMHTMLImageElement>    image = (do_QueryInterface(domSaveArray[j].node));
+      nsCOMPtr<nsIDOMHTMLLinkElement>     link = (do_QueryInterface(domSaveArray[j].node));
+      nsCOMPtr<nsIDOMHTMLAnchorElement>   anchor = (do_QueryInterface(domSaveArray[j].node));
+
+      if (anchor)
+      {
+        anchor->GetHref(domURL);
+        anchor->SetHref(newSpec);
+      }
+      else if (link)
+      {
+        link->GetHref(domURL);
+        link->SetHref(newSpec);
+      }
+      else if (image)
+      {
+        image->GetSrc(domURL);
+        image->SetSrc(newSpec);
+      }
+      else if (body)
+      {
+        body->GetBackground(domURL);
+        body->SetBackground(newSpec);
+      }
+
+      if (!domURL.IsEmpty())
+        domSaveArray[j].url = ToNewCString(NS_LossyConvertUTF16toASCII(domURL));
+    }
+    i++;
+  }
+
+  rv = GetBodyFromEditor();
+
+  //
+  // Ok, now we need to un-whack the DOM or we have a screwed up document on
+  // Send failure.
+  //
+  for (i = 0; i < multipartCount; i++)
+  {
+    if ( (!domSaveArray[i].node) || (!domSaveArray[i].url) )
+      continue;
+
+    // Now, we know the types of objects this node can be, so we will do
+    // our query interface here and see what we come up with
+    nsCOMPtr<nsIDOMHTMLBodyElement>     body = (do_QueryInterface(domSaveArray[i].node));
+    nsCOMPtr<nsIDOMHTMLImageElement>    image = (do_QueryInterface(domSaveArray[i].node));
+    nsCOMPtr<nsIDOMHTMLLinkElement>     link = (do_QueryInterface(domSaveArray[i].node));
+    nsCOMPtr<nsIDOMHTMLAnchorElement>   anchor = (do_QueryInterface(domSaveArray[i].node));
+
+      // STRING USE WARNING: hoisting the following conversion might save code-space, since it happens along every path
+
+    if (anchor)
+      anchor->SetHref(NS_ConvertASCIItoUTF16(domSaveArray[i].url));
+    else if (link)
+      link->SetHref(NS_ConvertASCIItoUTF16(domSaveArray[i].url));
+    else if (image)
+      image->SetSrc(NS_ConvertASCIItoUTF16(domSaveArray[i].url));
+    else if (body)
+      body->SetBackground(NS_ConvertASCIItoUTF16(domSaveArray[i].url));
+
+    free(domSaveArray[i].url);
+  }
+
+  PR_FREEIF(domSaveArray);
+
+  //
+  // Now, we have to create that first child node for the multipart
+  // message that holds the body as well as the attachment handler
+  // for this body part.
+  //
+  // If we ONLY have multipart objects, then we don't need the container
+  // for the multipart section...
+  //
+  m_related_part = new nsMsgSendPart(this);
+  if (!m_related_part)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  m_related_part->SetMimeDeliveryState(this);
+  m_related_part->SetType(MULTIPART_RELATED);
+  // We are now going to use the m_related_part as a way to store the
+  // MHTML message for this email.
+  //
+  m_related_body_part = new nsMsgSendPart(this);
+  if (!m_related_body_part)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  // Set the body contents...
+  m_related_body_part->SetBuffer(m_attachment1_body);
+  m_related_body_part->SetType(m_attachment1_type);
+
+  m_related_part->AddChild(m_related_body_part);
+
+  return rv;
+}
+
+nsresult
+nsMsgComposeAndSend::CountCompFieldAttachments()
+{
+  //Reset the counters
+  mCompFieldLocalAttachments = 0;
+  mCompFieldRemoteAttachments = 0;
+
+  //Get the attachments array
+  nsCOMPtr<nsISimpleEnumerator> attachments;
+  mCompFields->GetAttachments(getter_AddRefs(attachments));
+  if (!attachments)
+    return NS_OK;
+
+  nsresult rv;
+
+  // Parse the attachments array
+  bool moreAttachments;
+  nsCString url;
+  nsCOMPtr<nsISupports> element;
+  while (NS_SUCCEEDED(attachments->HasMoreElements(&moreAttachments)) && moreAttachments) {
+    rv = attachments->GetNext(getter_AddRefs(element));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgAttachment> attachment = do_QueryInterface(element, &rv);
+    if (NS_SUCCEEDED(rv) && attachment)
+    {
+      attachment->GetUrl(url);
+      if (!url.IsEmpty())
+      {
+        // Check to see if this is a file URL, if so, don't retrieve
+        // like a remote URL...
+        if (nsMsgIsLocalFile(url.get()))
+          mCompFieldLocalAttachments++;
+        else    // This is a remote URL...
+          mCompFieldRemoteAttachments++;
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+//
+// Since we are at the head of the list, we start from ZERO.
+//
+nsresult
+nsMsgComposeAndSend::AddCompFieldLocalAttachments()
+{
+  // If none, just return...
+  if (mCompFieldLocalAttachments <= 0)
+    return NS_OK;
+
+  //Get the attachments array
+  nsCOMPtr<nsISimpleEnumerator> attachments;
+  mCompFields->GetAttachments(getter_AddRefs(attachments));
+  if (!attachments)
+    return NS_OK;
+
+  uint32_t  newLoc = 0;
+  nsresult rv;
+  nsCString url;
+
+  //Parse the attachments array
+  bool moreAttachments;
+  nsCOMPtr<nsISupports> element;
+  while (NS_SUCCEEDED(attachments->HasMoreElements(&moreAttachments)) && moreAttachments) {
+    rv = attachments->GetNext(getter_AddRefs(element));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgAttachment> attachment = do_QueryInterface(element, &rv);
+    if (NS_SUCCEEDED(rv) && attachment)
+    {
+      bool sendViaCloud = false;
+      attachment->GetSendViaCloud(&sendViaCloud);
+      m_attachments[newLoc]->mSendViaCloud = sendViaCloud;
+      attachment->GetUrl(url);
+      if (!url.IsEmpty())
+      {
+        bool sendViaCloud;
+        attachment->GetSendViaCloud(&sendViaCloud);
+        if (sendViaCloud)
+        {
+          nsCString cloudProviderKey;
+          // We'd like to output a part for the attachment, just an html part
+          // with information about how to download the attachment.
+          // m_attachments[newLoc]->m_done = true;
+          attachment->GetHtmlAnnotation(m_attachments[newLoc]->mHtmlAnnotation);
+          m_attachments[newLoc]->m_type.AssignLiteral("text/html");
+          attachment->GetCloudProviderKey(m_attachments[newLoc]->mCloudProviderKey);
+          attachment->GetContentLocation(m_attachments[newLoc]->mCloudUrl);
+        }
+        // Just look for local file:// attachments and do the right thing.
+        if (nsMsgIsLocalFile(url.get()))
+        {
+          //
+          // Now we have to setup the m_attachments entry for the file://
+          // URL that is passed in...
+          //
+          m_attachments[newLoc]->mDeleteFile = false;
+
+          nsMsgNewURL(getter_AddRefs(m_attachments[newLoc]->mURL), url.get());
+
+          if (m_attachments[newLoc]->mTmpFile)
+          {
+            if (m_attachments[newLoc]->mDeleteFile)
+              m_attachments[newLoc]->mTmpFile->Remove(false);
+            m_attachments[newLoc]->mTmpFile =nullptr;
+          }
+          nsresult rv;
+          nsCOMPtr<nsIIOService> ioService =
+            mozilla::services::GetIOService();
+          NS_ENSURE_TRUE(ioService, NS_ERROR_UNEXPECTED);
+          nsCOMPtr <nsIURI> uri;
+          rv = ioService->NewURI(url, nullptr, nullptr, getter_AddRefs(uri));
+          NS_ENSURE_SUCCESS(rv, rv);
+          nsCOMPtr <nsIFileURL> fileURL = do_QueryInterface(uri);
+          NS_ENSURE_SUCCESS(rv, rv);
+          nsCOMPtr <nsIFile> fileURLFile;
+          fileURL->GetFile(getter_AddRefs(fileURLFile));
+          m_attachments[newLoc]->mTmpFile = do_QueryInterface(fileURLFile);
+          m_attachments[newLoc]->mDeleteFile = false;
+          if (m_attachments[newLoc]->mURL)
+          {
+            nsAutoString proposedName;
+            attachment->GetName(proposedName);
+            msg_pick_real_name(m_attachments[newLoc], proposedName.get(), mCompFields->GetCharacterSet());
+          }
+
+          // Now, most importantly, we need to figure out what the content type is for
+          // this attachment...If we can't, then just make it application/octet-stream
+
+  #ifdef MAC_OSX
+          //Mac always need to snarf the file to figure out how to send it, maybe we need to use apple double...
+          //  unless caller has already set the content type, in which case, trust them.
+          bool mustSnarfAttachment = true;
+  #else
+          bool mustSnarfAttachment = false;
+  #endif
+          if (sendViaCloud)
+            mustSnarfAttachment = false;
+
+          attachment->GetContentType(getter_Copies(m_attachments[newLoc]->m_type));
+          if (m_attachments[newLoc]->m_type.IsEmpty())
+          {
+            nsresult  rv = NS_OK;
+            nsCOMPtr<nsIMIMEService> mimeFinder (do_GetService(NS_MIMESERVICE_CONTRACTID, &rv));
+            if (NS_SUCCEEDED(rv) && mimeFinder)
+            {
+              nsCOMPtr<nsIURL> fileUrl(do_CreateInstance(NS_STANDARDURL_CONTRACTID));
+              if (fileUrl)
+              {
+                nsAutoCString fileExt;
+                //First try using the real file name
+                rv = fileUrl->SetFileName(m_attachments[newLoc]->m_realName);
+                if (NS_SUCCEEDED(rv))
+                {
+                  rv = fileUrl->GetFileExtension(fileExt);
+                  if (NS_SUCCEEDED(rv) && !fileExt.IsEmpty()) {
+                    nsAutoCString type;
+                    mimeFinder->GetTypeFromExtension(fileExt, type);
+  #ifndef XP_MACOSX
+                    if (!type.Equals("multipart/appledouble"))  // can't do apple double on non-macs
+  #endif
+                    m_attachments[newLoc]->m_type = type;
+                  }
+                }
+
+                //Then try using the url if we still haven't figured out the content type
+                if (m_attachments[newLoc]->m_type.IsEmpty())
+                {
+                  rv = fileUrl->SetSpec(url);
+                  if (NS_SUCCEEDED(rv))
+                  {
+                    rv = fileUrl->GetFileExtension(fileExt);
+                    if (NS_SUCCEEDED(rv) && !fileExt.IsEmpty()) {
+                      nsAutoCString type;
+                      mimeFinder->GetTypeFromExtension(fileExt, type);
+  #ifndef XP_MACOSX
+                    if (!type.Equals("multipart/appledouble"))  // can't do apple double on non-macs
+  #endif
+                      m_attachments[newLoc]->m_type = type;
+                    // rtf and vcs files may look like text to sniffers,
+                    // but they're not human readable.
+                    if (type.IsEmpty() && !fileExt.IsEmpty() &&
+                         (MsgLowerCaseEqualsLiteral(fileExt, "rtf") ||
+                          MsgLowerCaseEqualsLiteral(fileExt, "vcs")))
+                      m_attachments[newLoc]->m_type = APPLICATION_OCTET_STREAM;
+                    }
+                  }
+                }
+              }
+            }
+          }
+          else
+          {
+            attachment->GetContentTypeParam(getter_Copies(m_attachments[newLoc]->m_typeParam));
+            mustSnarfAttachment = false;
+          }
+
+          //We need to snarf the file to figure out how to send it only if we don't have a content type...
+          if (mustSnarfAttachment || m_attachments[newLoc]->m_type.IsEmpty())
+          {
+            m_attachments[newLoc]->m_done = false;
+            m_attachments[newLoc]->SetMimeDeliveryState(this);
+          }
+          else
+          {
+            m_attachments[newLoc]->m_done = true;
+            m_attachments[newLoc]->SetMimeDeliveryState(nullptr);
+          }
+          // For local files, if they are HTML docs and we don't have a charset, we should
+          // sniff the file and see if we can figure it out.
+          if (!m_attachments[newLoc]->m_type.IsEmpty())
+          {
+            if (m_attachments[newLoc]->m_type.LowerCaseEqualsLiteral(TEXT_HTML))
+            {
+              char *tmpCharset = (char *)nsMsgI18NParseMetaCharset(m_attachments[newLoc]->mTmpFile);
+              if (tmpCharset[0] != '\0')
+                m_attachments[newLoc]->m_charset = tmpCharset;
+            }
+          }
+
+          attachment->GetMacType(getter_Copies(m_attachments[newLoc]->m_xMacType));
+          attachment->GetMacCreator(getter_Copies(m_attachments[newLoc]->m_xMacCreator));
+
+          ++newLoc;
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgComposeAndSend::AddCompFieldRemoteAttachments(uint32_t   aStartLocation,
+                                                   int32_t    *aMailboxCount,
+                                                   int32_t    *aNewsCount)
+{
+  // If none, just return...
+  if (mCompFieldRemoteAttachments <= 0)
+    return NS_OK;
+
+  //Get the attachments array
+  nsCOMPtr<nsISimpleEnumerator> attachments;
+  mCompFields->GetAttachments(getter_AddRefs(attachments));
+  if (!attachments)
+    return NS_OK;
+
+  uint32_t  newLoc = aStartLocation;
+
+  nsresult rv;
+  bool moreAttachments;
+  nsCString url;
+  nsCOMPtr<nsISupports> element;
+  while (NS_SUCCEEDED(attachments->HasMoreElements(&moreAttachments)) && moreAttachments) {
+    rv = attachments->GetNext(getter_AddRefs(element));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgAttachment> attachment = do_QueryInterface(element, &rv);
+     if (NS_SUCCEEDED(rv) && attachment)
+    {
+      attachment->GetUrl(url);
+      if (!url.IsEmpty())
+      {
+        // Just look for files that are NOT local file attachments and do
+        // the right thing.
+        if (! nsMsgIsLocalFile(url.get()))
+        {
+          // Check for message attachment, see nsMsgMailNewsUrl::GetIsMessageUri.
+          nsCOMPtr<nsIURI> nsiuri = do_CreateInstance(NS_STANDARDURL_CONTRACTID);
+          NS_ENSURE_STATE(nsiuri);
+          nsiuri->SetSpec(url);
+          nsAutoCString scheme;
+          nsiuri->GetScheme(scheme);
+          bool isAMessageAttachment =
+            StringEndsWith(scheme, NS_LITERAL_CSTRING("-message"));
+
+          m_attachments[newLoc]->mDeleteFile = true;
+          m_attachments[newLoc]->m_done = false;
+          m_attachments[newLoc]->SetMimeDeliveryState(this);
+
+          if (!isAMessageAttachment)
+            nsMsgNewURL(getter_AddRefs(m_attachments[newLoc]->mURL), url.get());
+
+          m_attachments[newLoc]->m_encoding = ENCODING_7BIT;
+
+          attachment->GetMacType(getter_Copies(m_attachments[newLoc]->m_xMacType));
+          attachment->GetMacCreator(getter_Copies(m_attachments[newLoc]->m_xMacCreator));
+
+          /* Count up attachments which are going to come from mail folders
+             and from NNTP servers. */
+          bool do_add_attachment = false;
+          if (isAMessageAttachment)
+          {
+            do_add_attachment = true;
+            if (!PL_strncasecmp(url.get(), "news-message://", 15))
+              (*aNewsCount)++;
+            else
+              (*aMailboxCount)++;
+
+            m_attachments[newLoc]->m_uri = url;
+            m_attachments[newLoc]->mURL = nullptr;
+          }
+          else
+            do_add_attachment = (nullptr != m_attachments[newLoc]->mURL);
+          m_attachments[newLoc]->mSendViaCloud = false;
+          if (do_add_attachment)
+          {
+            nsAutoString proposedName;
+            attachment->GetName(proposedName);
+            msg_pick_real_name(m_attachments[newLoc], proposedName.get(), mCompFields->GetCharacterSet());
+            ++newLoc;
+          }
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgComposeAndSend::HackAttachments(nsIArray *attachments,
+                                     nsIArray *preloadedAttachments)
+{
+  //
+  // First, count the total number of attachments we are going to process
+  // for this operation! This is a little more complicated than you might
+  // think because we have a few ways to specify attachments. Via the nsMsgAttachmentData
+  // as well as the composition fields.
+  //
+  CountCompFieldAttachments();
+
+  // Count the preloaded attachments!
+  mPreloadedAttachmentCount = 0;
+
+  // For now, manually add the local attachments in the comp field!
+  mPreloadedAttachmentCount += mCompFieldLocalAttachments;
+  uint32_t numAttachments = 0, numPreloadedAttachments = 0;
+  if (attachments)
+    attachments->GetLength(&numAttachments);
+  if (preloadedAttachments)
+    preloadedAttachments->GetLength(&numPreloadedAttachments);
+  mPreloadedAttachmentCount += numPreloadedAttachments;
+
+  // Count the attachments we have to go retrieve! Keep in mind, that these
+  // will be APPENDED to the current list of URL's that we have gathered if
+  // this is a multpart/related send operation
+  mRemoteAttachmentCount = GetMultipartRelatedCount();
+
+  // For now, manually add the remote attachments in the comp field!
+  mRemoteAttachmentCount += mCompFieldRemoteAttachments;
+
+  mRemoteAttachmentCount += numAttachments;
+
+  m_attachment_count = mPreloadedAttachmentCount + mRemoteAttachmentCount;
+
+  uint32_t i; // counter for location in attachment array...
+  // Now create the array of attachment handlers...
+  for (i = 0; i < m_attachment_count; i++) {
+    RefPtr<nsMsgAttachmentHandler> handler = new nsMsgAttachmentHandler;
+    m_attachments.AppendElement(handler);
+  }
+
+  //
+  // First, we need to attach the files that are defined in the comp fields...
+  if (NS_FAILED(AddCompFieldLocalAttachments()))
+    return NS_ERROR_INVALID_ARG;
+
+  // Now handle the preloaded attachments...
+  if (numPreloadedAttachments > 0)
+  {
+    // These are attachments which have already been downloaded to tmp files.
+    // We merely need to point the internal attachment data at those tmp
+    // files.
+    m_pre_snarfed_attachments_p = true;
+
+    for (i = mCompFieldLocalAttachments; i < mPreloadedAttachmentCount; i++)
+    {
+      nsCOMPtr<nsIMsgAttachedFile> attachedFile = do_QueryElementAt(preloadedAttachments, i);
+      if (!attachedFile)
+        continue;
+
+      /* These attachments are already "snarfed". */
+      m_attachments[i]->mDeleteFile = false;
+      m_attachments[i]->SetMimeDeliveryState(nullptr);
+      m_attachments[i]->m_done = true;
+
+      attachedFile->GetOrigUrl(getter_AddRefs(m_attachments[i]->mURL));
+
+      attachedFile->GetType(m_attachments[i]->m_type);
+
+      // Set it to the compose fields for a default...
+      m_attachments[i]->m_charset = mCompFields->GetCharacterSet();
+
+      // If we still don't have a content type, we should really try sniff one out!
+      if (m_attachments[i]->m_type.IsEmpty())
+        m_attachments[i]->PickEncoding(mCompFields->GetCharacterSet(), this);
+
+      // For local files, if they are HTML docs and we don't have a charset, we should
+      // sniff the file and see if we can figure it out.
+      if (!m_attachments[i]->m_type.IsEmpty())
+      {
+        nsCOMPtr<nsIFile> tmpFile;
+        attachedFile->GetTmpFile(getter_AddRefs(tmpFile));
+        if (m_attachments[i]->m_type.LowerCaseEqualsLiteral(TEXT_HTML) && tmpFile)
+        {
+          char *tmpCharset = (char *)nsMsgI18NParseMetaCharset(tmpFile);
+          if (tmpCharset[0] != '\0')
+            m_attachments[i]->m_charset = tmpCharset;
+        }
+      }
+
+      attachedFile->GetDescription(m_attachments[i]->m_description);
+      attachedFile->GetRealName(m_attachments[i]->m_realName);
+      attachedFile->GetXMacType(m_attachments[i]->m_xMacType);
+      attachedFile->GetXMacCreator(m_attachments[i]->m_xMacCreator);
+      attachedFile->GetEncoding(m_attachments[i]->m_encoding);
+
+      if (m_attachments[i]->mTmpFile)
+      {
+        if (m_attachments[i]->mDeleteFile)
+          m_attachments[i]->mTmpFile->Remove(false);
+        m_attachments[i]->mTmpFile = nullptr;
+      }
+      attachedFile->GetTmpFile(getter_AddRefs(m_attachments[i]->mTmpFile));
+
+      attachedFile->GetSize(&m_attachments[i]->m_size);
+      attachedFile->GetUnprintableCount(&m_attachments[i]->m_unprintable_count);
+      attachedFile->GetHighbitCount(&m_attachments[i]->m_highbit_count);
+      attachedFile->GetCtlCount(&m_attachments[i]->m_ctl_count);
+      attachedFile->GetNullCount(&m_attachments[i]->m_null_count);
+      attachedFile->GetMaxLineLength(&m_attachments[i]->m_max_column);
+
+      /* If the attachment has an encoding, and it's not one of
+      the "null" encodings, then keep it. */
+      if (!m_attachments[i]->m_encoding.IsEmpty() &&
+          !m_attachments[i]->m_encoding.LowerCaseEqualsLiteral(ENCODING_7BIT) &&
+          !m_attachments[i]->m_encoding.LowerCaseEqualsLiteral(ENCODING_8BIT) &&
+          !m_attachments[i]->m_encoding.LowerCaseEqualsLiteral(ENCODING_BINARY))
+        m_attachments[i]->m_already_encoded_p = true;
+
+      if (m_attachments[i]->mURL)
+        msg_pick_real_name(m_attachments[i], nullptr, mCompFields->GetCharacterSet());
+    }
+  }
+
+  // First, handle the multipart related attachments if any...
+  //
+  int32_t mailbox_count = 0, news_count = 0;
+  int32_t multipartRelatedCount = GetMultipartRelatedCount();
+
+  if (multipartRelatedCount > 0)
+  {
+    nsresult rv = ProcessMultipartRelated(&mailbox_count, &news_count);
+    if (NS_FAILED(rv))
+    {
+      // The destructor will take care of the m_attachment array
+      return rv;
+    }
+  }
+
+  //
+  // Now add the comp field remote attachments...
+  //
+  if (NS_FAILED( AddCompFieldRemoteAttachments( (mPreloadedAttachmentCount + multipartRelatedCount),
+                                                 &mailbox_count, &news_count) ))
+    return NS_ERROR_INVALID_ARG;
+
+  //
+  // Now deal remote attachments and attach multipart/related attachments (url's and such..)
+  // first!
+  //
+  if (attachments)
+  {
+    int32_t     locCount = -1;
+
+    for (i = (mPreloadedAttachmentCount + GetMultipartRelatedCount() + mCompFieldRemoteAttachments); i < m_attachment_count; i++)
+    {
+      locCount++;
+      nsCOMPtr<nsIMsgAttachmentData> attachment(do_QueryElementAt(attachments, i));
+      if (!attachment)
+        continue;
+      m_attachments[i]->mDeleteFile = true;
+      m_attachments[i]->m_done = false;
+      m_attachments[i]->SetMimeDeliveryState(this);
+
+      attachment->GetUrl(getter_AddRefs(m_attachments[i]->mURL));
+
+      attachment->GetRealType(m_attachments[i]->m_overrideType);
+      m_attachments[i]->m_charset = mCompFields->GetCharacterSet();
+      attachment->GetRealEncoding(m_attachments[i]->m_overrideEncoding);
+      attachment->GetDesiredType(m_attachments[i]->m_desiredType);
+      attachment->GetDescription(m_attachments[i]->m_description);
+      attachment->GetRealName(m_attachments[i]->m_realName);
+      attachment->GetXMacType(m_attachments[i]->m_xMacType);
+      attachment->GetXMacCreator(m_attachments[i]->m_xMacCreator);
+      m_attachments[i]->m_encoding = ENCODING_7BIT;
+
+      // real name is set in the case of vcard so don't change it.  XXX STILL NEEDED?
+      // m_attachments[i]->m_real_name = 0;
+
+      /* Count up attachments which are going to come from mail folders
+      and from NNTP servers. */
+      if (m_attachments[i]->mURL)
+      {
+        nsIURI *uri = m_attachments[i]->mURL;
+        bool match = false;
+        if ((NS_SUCCEEDED(uri->SchemeIs("mailbox", &match)) && match) ||
+            (NS_SUCCEEDED(uri->SchemeIs("imap", &match)) && match))
+          mailbox_count++;
+        else if ((NS_SUCCEEDED(uri->SchemeIs("news", &match)) && match) ||
+                 (NS_SUCCEEDED(uri->SchemeIs("snews", &match)) && match))
+            news_count++;
+        else
+        {
+          // Additional account types need a mechanism to report that they are
+          // message protocols. If there is an nsIMsgProtocolInfo component
+          // registered for this scheme, we'll consider it a mailbox
+          // attachment.
+          nsAutoCString contractID;
+          contractID.Assign(
+            NS_LITERAL_CSTRING("@mozilla.org/messenger/protocol/info;1"));
+          nsAutoCString scheme;
+          uri->GetScheme(scheme);
+          contractID.Append(scheme);
+          nsCOMPtr<nsIMsgProtocolInfo> msgProtocolInfo =
+            do_CreateInstance(contractID.get());
+          if (msgProtocolInfo)
+            mailbox_count++;
+        }
+        if (uri)
+          msg_pick_real_name(m_attachments[i], nullptr, mCompFields->GetCharacterSet());
+      }
+    }
+  }
+
+  bool needToCallGatherMimeAttachments = true;
+
+  if (m_attachment_count > 0)
+  {
+    // If there is more than one mailbox URL, or more than one NNTP url,
+    // do the load in serial rather than parallel, for efficiency.
+    if (mailbox_count > 1 || news_count > 1)
+      m_be_synchronous_p = true;
+
+    m_attachment_pending_count = m_attachment_count;
+
+    // Start the URL attachments loading (eventually, an exit routine will
+    // call the done_callback).
+
+    for (i = 0; i < m_attachment_count; i++)
+    {
+      if (m_attachments[i]->m_done || m_attachments[i]->mSendViaCloud)
+      {
+        m_attachment_pending_count--;
+        continue;
+      }
+
+      //
+      //  IF we get here and the URL is NULL, just dec the pending count and move on!!!
+      //
+      if ( (!m_attachments[i]->mURL) && (!m_attachments[i]->m_uri.Length()) )
+      {
+        m_attachments[i]->m_bogus_attachment = true;
+        m_attachments[i]->m_done = true;
+        m_attachments[i]->SetMimeDeliveryState(nullptr);
+        m_attachment_pending_count--;
+        continue;
+      }
+
+      //
+      // This only returns a failure code if NET_GetURL was not called
+      // (and thus no exit routine was or will be called.)
+      //
+
+      // Display some feedback to user...
+      nsString msg;
+      nsAutoString attachmentFileName;
+      NS_ConvertUTF8toUTF16 params(m_attachments[i]->m_realName);
+      const char16_t *formatParams[1];
+      if (!params.IsEmpty()) {
+        formatParams[0] = params.get();
+      } else if (m_attachments[i]->mURL) {
+        nsCString asciiSpec;
+        m_attachments[i]->mURL->GetAsciiSpec(asciiSpec);
+        attachmentFileName.AssignASCII(asciiSpec.get());
+        formatParams[0] = attachmentFileName.get();
+      }
+      mComposeBundle->FormatStringFromName(u"gatheringAttachment",
+                                           formatParams, 1, getter_Copies(msg));
+
+      if (!msg.IsEmpty())
+      {
+        SetStatusMessage(msg);
+      }
+
+      /* As SnarfAttachment will call GatherMimeAttachments when it will be done (this is an async process),
+         we need to avoid to call it ourself.
+      */
+      needToCallGatherMimeAttachments = false;
+
+      nsresult status = m_attachments[i]->SnarfAttachment(mCompFields);
+      if (NS_FAILED(status))
+      {
+        nsString errorMsg;
+        nsresult rv = ConvertToUnicode(nsMsgI18NFileSystemCharset(), m_attachments[i]->m_realName, attachmentFileName);
+        if (attachmentFileName.IsEmpty() && m_attachments[i]->mURL) {
+          nsCString asciiSpec;
+          m_attachments[i]->mURL->GetAsciiSpec(asciiSpec);
+          attachmentFileName.AssignASCII(asciiSpec.get());
+          rv = NS_OK;
+        }
+        if (NS_SUCCEEDED(rv))
+        {
+          nsCOMPtr<nsIStringBundle> bundle;
+          const char16_t *params[] = { attachmentFileName.get() };
+          mComposeBundle->FormatStringFromName(u"errorAttachingFile",
+                                               params, 1,
+                                               getter_Copies(errorMsg));
+          mSendReport->SetMessage(nsIMsgSendReport::process_Current, errorMsg.get(), false);
+          mSendReport->SetError(nsIMsgSendReport::process_Current,
+                                NS_MSG_ERROR_ATTACHING_FILE,
+                                false);
+        }
+        return NS_MSG_ERROR_ATTACHING_FILE;
+      }
+      if (m_be_synchronous_p)
+        break;
+    }
+  }
+
+  // If no attachments - finish now (this will call the done_callback).
+  if (needToCallGatherMimeAttachments)
+    return GatherMimeAttachments();
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgComposeAndSend::InitCompositionFields(nsMsgCompFields *fields,
+                                           const nsACString &aOriginalMsgURI,
+                                           MSG_ComposeType aType)
+{
+  nsresult        rv = NS_OK;
+  const char      *pStr = nullptr;
+
+  mCompFields = new nsMsgCompFields();
+  if (!mCompFields)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  const char *cset = fields->GetCharacterSet();
+  // Make sure charset is sane...
+  if (!cset || !*cset)
+  {
+    mCompFields->SetCharacterSet("UTF-8");
+  }
+  else
+  {
+    mCompFields->SetCharacterSet(fields->GetCharacterSet());
+  }
+
+  // Now, we will look for a URI defined as the default FCC pref. If this is set,
+  // then SetFcc will use this value. The FCC field is a URI for the server that
+  // will hold the "Sent" folder...the
+  //
+  // First, look at what was passed in via the "fields" structure...if that was
+  // set then use it, otherwise, fall back to what is set in the prefs...
+  //
+  // But even before that, pay attention to the new OVERRIDE pref that will cancel
+  // any and all copy operations!
+  //
+  bool      doFcc = true;
+  rv = mUserIdentity->GetDoFcc(&doFcc);
+  if (!doFcc)
+  {
+    // If the identity pref "fcc" is set to false, then we will not do
+    // any FCC operation!
+    mCompFields->SetFcc("");
+  }
+  else
+  {
+    bool useDefaultFCC = true;
+    const char *fieldsFCC = fields->GetFcc();
+    if (fieldsFCC && *fieldsFCC)
+    {
+      if (PL_strcasecmp(fieldsFCC, "nocopy://") == 0)
+      {
+        useDefaultFCC = false;
+        mCompFields->SetFcc("");
+      }
+      else
+      {
+        nsCOMPtr<nsIMsgFolder> folder;
+        GetExistingFolder(nsDependentCString(fieldsFCC), getter_AddRefs(folder));
+        if (folder)
+        {
+          useDefaultFCC = false;
+          mCompFields->SetFcc(mime_fix_header(fieldsFCC));
+        }
+      }
+    }
+
+    // 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 (!aOriginalMsgURI.IsEmpty() && (
+            aType == nsIMsgCompType::Reply ||
+            aType == nsIMsgCompType::ReplyAll ||
+            aType == nsIMsgCompType::ReplyToGroup ||
+            aType == nsIMsgCompType::ReplyToSender ||
+            aType == nsIMsgCompType::ReplyToSenderAndGroup ||
+            aType == nsIMsgCompType::ReplyWithTemplate )
+         )
+      {
+        nsCOMPtr <nsIMsgAccountManager> accountManager =
+            do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+        if (NS_SUCCEEDED(rv))
+        {
+          nsCOMPtr <nsIMsgDBHdr> msgHdr;
+          rv = GetMsgDBHdrFromURI(PromiseFlatCString(aOriginalMsgURI).get(),
+                                  getter_AddRefs(msgHdr));
+          if (NS_SUCCEEDED(rv))
+          {
+            nsCOMPtr <nsIMsgFolder> folder;
+            msgHdr->GetFolder(getter_AddRefs(folder));
+            if (NS_SUCCEEDED(rv))
+            {
+              bool canFileMessages;
+              rv = folder->GetCanFileMessages(&canFileMessages);
+              if (NS_SUCCEEDED(rv) && canFileMessages)
+              {
+                nsCOMPtr <nsIMsgIncomingServer> incomingServer;
+                rv = folder->GetServer(getter_AddRefs(incomingServer));
+                if (NS_SUCCEEDED(rv))
+                {
+                  nsCString incomingServerType;
+                  rv = incomingServer->GetCharValue("type", incomingServerType);
+                  // Exclude RSS accounts, as they falsely report
+                  // 'canFileMessages' = true
+                  if (NS_SUCCEEDED(rv) && !incomingServerType.Equals("rss"))
+                  {
+                    bool fccReplyFollowsParent;
+                    rv = mUserIdentity->GetFccReplyFollowsParent(
+                             &fccReplyFollowsParent);
+                    if (NS_SUCCEEDED(rv) && fccReplyFollowsParent)
+                    {
+                      nsCString folderURI;
+                      rv = folder->GetURI(folderURI);
+                      if (NS_SUCCEEDED(rv))
+                      {
+                        mCompFields->SetFcc(folderURI.get());
+                        useDefaultFCC = false;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      if (useDefaultFCC)
+      {
+        nsCString uri;
+        GetFolderURIFromUserPrefs(nsMsgDeliverNow, mUserIdentity, uri);
+        mCompFields->SetFcc(MsgLowerCaseEqualsLiteral(uri, "nocopy://") ? "" : uri.get());
+      }
+    }
+  }
+
+  //
+  // Deal with an additional FCC operation for this email.
+  //
+  const char *fieldsFCC2 = fields->GetFcc2();
+  if ( (fieldsFCC2) && (*fieldsFCC2) )
+  {
+    if (PL_strcasecmp(fieldsFCC2, "nocopy://") == 0)
+    {
+      mCompFields->SetFcc2("");
+      mNeedToPerformSecondFCC = false;
+    }
+    else
+    {
+      mCompFields->SetFcc2(fieldsFCC2);
+      mNeedToPerformSecondFCC = true;
+    }
+  }
+
+  // Copy the main bodies of headers over.
+  rv = mCompFields->AddAllHeaders(fields);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISimpleEnumerator> srcAttachments;
+  fields->GetAttachments(getter_AddRefs(srcAttachments));
+  if (srcAttachments)
+  {
+    bool moreAttachments;
+    nsCOMPtr<nsISupports> element;
+    while (NS_SUCCEEDED(srcAttachments->HasMoreElements(&moreAttachments)) && moreAttachments) {
+      rv = srcAttachments->GetNext(getter_AddRefs(element));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIMsgAttachment> attachment = do_QueryInterface(element, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      mCompFields->AddAttachment(attachment);
+    }
+  }
+
+  AddDefaultCustomHeaders();
+
+  AddMailFollowupToHeader();
+  AddMailReplyToHeader();
+
+  if (aType == nsIMsgCompType::ForwardInline ||
+      aType == nsIMsgCompType::ForwardAsAttachment)
+    AddXForwardedMessageIdHeader();
+
+  pStr = fields->GetPriority();
+  if (pStr)
+    mCompFields->SetPriority((char *) pStr);
+
+  mCompFields->SetAttachVCard(fields->GetAttachVCard());
+  mCompFields->SetForcePlainText(fields->GetForcePlainText());
+  mCompFields->SetUseMultipartAlternative(fields->GetUseMultipartAlternative());
+  int32_t receiptType = nsIMsgMdnGenerator::eDntType;
+  fields->GetReceiptHeaderType(&receiptType);
+
+  mCompFields->SetReturnReceipt(fields->GetReturnReceipt());
+  mCompFields->SetAttachmentReminder(fields->GetAttachmentReminder());
+  mCompFields->SetDeliveryFormat(fields->GetDeliveryFormat());
+  mCompFields->SetContentLanguage(fields->GetContentLanguage());
+  mCompFields->SetReceiptHeaderType(receiptType);
+
+  mCompFields->SetDSN(fields->GetDSN());
+
+  mCompFields->SetBodyIsAsciiOnly(fields->GetBodyIsAsciiOnly());
+  mCompFields->SetForceMsgEncoding(fields->GetForceMsgEncoding());
+
+  nsCOMPtr<nsISupports> secInfo;
+  fields->GetSecurityInfo(getter_AddRefs(secInfo));
+
+  mCompFields->SetSecurityInfo(secInfo);
+
+  bool needToCheckCharset;
+  fields->GetNeedToCheckCharset(&needToCheckCharset);
+  mCompFields->SetNeedToCheckCharset(needToCheckCharset);
+
+  if ( m_deliver_mode != nsMsgSaveAsDraft && m_deliver_mode != nsMsgSaveAsTemplate )
+  {
+    // Check the fields for legitimacy...
+    return mime_sanity_check_fields (
+                    mCompFields->GetFrom(), mCompFields->GetReplyTo(),
+                    mCompFields->GetTo(), mCompFields->GetCc(),
+                    mCompFields->GetBcc(), mCompFields->GetFcc(),
+                    mCompFields->GetNewsgroups(), mCompFields->GetFollowupTo(),
+                    mCompFields->GetSubject(), mCompFields->GetReferences(),
+                    mCompFields->GetOrganization(), "");
+  }
+  return NS_OK;
+}
+
+// Add default headers to outgoing messages see Bug #61520
+// mail.identity.<id#>.headers pref is a comma separated value of pref names
+// containging headers to add headers are stored in
+// mail.identity.<id#>.header.<header name> grab all the headers, mime encode
+// them and add them to the other custom headers.
+nsresult
+nsMsgComposeAndSend::AddDefaultCustomHeaders() {
+  nsCString headersList;
+  // get names of prefs containing headers to add
+  nsresult rv = mUserIdentity->GetCharAttribute("headers", headersList);
+  if (NS_SUCCEEDED(rv) && !headersList.IsEmpty()) {
+    int32_t start = 0;
+    int32_t end = 0;
+    int32_t len = 0;
+    while (end != -1) {
+      end = headersList.FindChar(',', start);
+      if (end == -1) {
+        len = headersList.Length() - start;
+      } else {
+        len = end - start;
+      }
+      // grab the name of the current header pref
+      nsAutoCString headerName("header.");
+      headerName.Append(Substring(headersList, start, len));
+      start = end + 1;
+
+      nsCString headerVal;
+      rv = mUserIdentity->GetCharAttribute(headerName.get(), headerVal);
+      if (NS_SUCCEEDED(rv)) {
+        int32_t colonIdx = headerVal.FindChar(':');
+        if (colonIdx > 0) { // check that the header is *most likely* valid.
+          nsCString name(Substring(headerVal, 0, colonIdx));
+          mCompFields->SetRawHeader(name.get(),
+            Substring(headerVal, colonIdx + 1), nullptr);
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+// Add Mail-Followup-To header
+// See bug #204339 and http://cr.yp.to/proto/replyto.html for details
+nsresult
+nsMsgComposeAndSend::AddMailFollowupToHeader() {
+  nsresult rv;
+
+  // If there's already a Mail-Followup-To header, don't need to do anything.
+  nsAutoCString mftHeader;
+  mCompFields->GetRawHeader(HEADER_MAIL_FOLLOWUP_TO, mftHeader);
+  if (!mftHeader.IsEmpty())
+  {
+    return NS_OK;
+  }
+
+  // Get list of subscribed mailing lists
+  nsAutoCString mailing_lists;
+  rv = mUserIdentity->GetCharAttribute("subscribed_mailing_lists", mailing_lists);
+  // Stop here if this list is missing or empty
+  if (NS_FAILED(rv) || mailing_lists.IsEmpty())
+    return NS_OK;
+
+  // Get a list of all recipients excluding bcc
+  nsDependentCString to(mCompFields->GetTo());
+  nsDependentCString cc(mCompFields->GetCc());
+  nsAutoCString recipients;
+
+  if (to.IsEmpty() && cc.IsEmpty())
+    // We have bcc recipients only, so we don't add the Mail-Followup-To header
+    return NS_OK;
+
+  if (!to.IsEmpty() && cc.IsEmpty())
+    recipients = to;
+  else if (to.IsEmpty() && !cc.IsEmpty())
+    recipients = cc;
+  else
+  {
+    recipients.Assign(to);
+    recipients.AppendLiteral(", ");
+    recipients.Append(cc);
+  }
+
+  // Remove duplicate addresses in recipients
+  nsAutoCString recipients_no_dups;
+  RemoveDuplicateAddresses(recipients, EmptyCString(), recipients_no_dups);
+
+  // Remove subscribed mailing lists from recipients...
+  nsAutoCString recipients_without_mailing_lists;
+  RemoveDuplicateAddresses(recipients_no_dups, mailing_lists,
+                           recipients_without_mailing_lists);
+
+  // ... If the result is equal to the input, we don't write to a subscribed
+  // mailing list and therefore we don't add Mail-Followup-To
+  if (recipients_no_dups == recipients_without_mailing_lists)
+    return NS_OK;
+
+  // Set Mail-Followup-To
+  return mCompFields->SetRawHeader(HEADER_MAIL_FOLLOWUP_TO, recipients,
+    mCompFields->GetCharacterSet());
+}
+
+// Add Mail-Reply-To header
+// See bug #204339 and http://cr.yp.to/proto/replyto.html for details
+nsresult
+nsMsgComposeAndSend::AddMailReplyToHeader() {
+  nsresult rv;
+
+  // If there's already a Mail-Reply-To header, don't need to do anything.
+  nsAutoCString mrtHeader;
+  mCompFields->GetRawHeader(HEADER_MAIL_REPLY_TO, mrtHeader);
+  if (!mrtHeader.IsEmpty())
+    return NS_OK;
+
+  // Get list of reply-to mangling mailing lists
+  nsAutoCString mailing_lists;
+  rv = mUserIdentity->GetCharAttribute("replyto_mangling_mailing_lists", mailing_lists);
+  // Stop here if this list is missing or empty
+  if (NS_FAILED(rv) || mailing_lists.IsEmpty())
+    return NS_OK;
+
+  // MRT will be set if the recipients of the message contains at least one
+  // of the addresses in mailing_lists or if mailing_lists has '*' as first
+  // character.  The latter case gives the user an easy way to always set
+  // the MRT header.  Notice that this behaviour wouldn't make sense for MFT
+  // in AddMailFollowupToHeader() above.
+
+  if (mailing_lists[0] != '*') {
+    // Get a list of all recipients excluding bcc
+    nsDependentCString to(mCompFields->GetTo());
+    nsDependentCString cc(mCompFields->GetCc());
+    nsAutoCString recipients;
+
+    if (to.IsEmpty() && cc.IsEmpty())
+      // We have bcc recipients only, so we don't add the Mail-Reply-To header
+      return NS_OK;
+
+    if (!to.IsEmpty() && cc.IsEmpty())
+      recipients = to;
+    else if (to.IsEmpty() && !cc.IsEmpty())
+      recipients = cc;
+    else
+    {
+      recipients.Assign(to);
+      recipients.AppendLiteral(", ");
+      recipients.Append(cc);
+    }
+
+    // Remove duplicate addresses in recipients
+    nsAutoCString recipients_no_dups;
+    RemoveDuplicateAddresses(recipients, EmptyCString(), recipients_no_dups);
+
+    // Remove reply-to mangling mailing lists from recipients...
+    nsAutoCString recipients_without_mailing_lists;
+    RemoveDuplicateAddresses(recipients_no_dups, mailing_lists,
+                             recipients_without_mailing_lists);
+
+    // ... If the result is equal to the input, none of the recipients
+    // occure in the MRT addresses and therefore we stop here.
+    if (recipients_no_dups == recipients_without_mailing_lists)
+      return NS_OK;
+  }
+
+  // Set Mail-Reply-To
+  nsAutoCString replyTo, mailReplyTo;
+  replyTo = mCompFields->GetReplyTo();
+  if (replyTo.IsEmpty())
+    mailReplyTo = mCompFields->GetFrom();
+  else
+    mailReplyTo = replyTo;
+
+  mCompFields->SetRawHeader(HEADER_MAIL_REPLY_TO, mailReplyTo,
+    mCompFields->GetCharacterSet());
+  return NS_OK;
+}
+
+nsresult
+nsMsgComposeAndSend::AddXForwardedMessageIdHeader() {
+  return mCompFields->SetRawHeader("X-Forwarded-Message-Id",
+    nsDependentCString(mCompFields->GetReferences()), nullptr);
+}
+
+nsresult
+nsMsgComposeAndSend::SnarfAndCopyBody(const nsACString &attachment1_body,
+                                      const char  *attachment1_type)
+{
+  //
+  // If we are here, then just process the body from what was
+  // passed in the attachment1_body field.
+  //
+  // strip out whitespaces from the end of body ONLY.
+  nsAutoCString body(attachment1_body);
+  body.Trim(" ", false, true);
+
+  if (body.Length() > 0)
+  {
+    m_attachment1_body = ToNewCString(body);
+    if (!m_attachment1_body) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    m_attachment1_body_length = body.Length();
+  }
+
+  PR_FREEIF(m_attachment1_type);
+  m_attachment1_type = PL_strdup (attachment1_type);
+  PR_FREEIF(m_attachment1_encoding);
+  m_attachment1_encoding = PL_strdup (ENCODING_8BIT);
+  return NS_OK;
+}
+
+nsresult
+nsMsgComposeAndSend::Init(
+              nsIMsgIdentity  *aUserIdentity,
+              const char *aAccountKey,
+              nsMsgCompFields *fields,
+              nsIFile      *sendFile,
+              bool digest_p,
+              bool dont_deliver_p,
+              nsMsgDeliverMode mode,
+              nsIMsgDBHdr *msgToReplace,
+              const char *attachment1_type,
+              const nsACString &attachment1_body,
+              nsIArray *attachments,
+              nsIArray *preloaded_attachments,
+              const char *password,
+              const nsACString &aOriginalMsgURI,
+              MSG_ComposeType aType)
+{
+  nsresult      rv = NS_OK;
+
+  //Let make sure we retreive the correct number of related parts. It may have changed since last time
+  GetMultipartRelatedCount(true);
+
+  nsString msg;
+  if (!mComposeBundle)
+  {
+    nsCOMPtr<nsIStringBundleService> bundleService =
+      mozilla::services::GetStringBundleService();
+    NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+    nsCOMPtr<nsIStringBundle> bundle;
+    rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(mComposeBundle));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Tell the user we are assembling the message...
+  mComposeBundle->GetStringFromName(u"assemblingMailInformation", getter_Copies(msg));
+  SetStatusMessage(msg);
+  if (mSendReport)
+    mSendReport->SetCurrentProcess(nsIMsgSendReport::process_BuildMessage);
+
+  //
+  // The Init() method should initialize a send operation for full
+  // blown create and send operations as well as just the "send a file"
+  // operations.
+  //
+  m_dont_deliver_p = dont_deliver_p;
+  m_deliver_mode = mode;
+  mMsgToReplace = msgToReplace;
+
+  mUserIdentity = aUserIdentity;
+  mAccountKey = aAccountKey;
+  NS_ASSERTION(mUserIdentity, "Got null identity!\n");
+  if (!mUserIdentity) return NS_ERROR_UNEXPECTED;
+
+  //
+  // First sanity check the composition fields parameter and
+  // see if we should continue
+  //
+  if (!fields)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  m_digest_p = digest_p;
+
+  //
+  // Needed for mime encoding!
+  //
+  bool strictly_mime = true;
+  nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (pPrefBranch)
+  {
+    rv = pPrefBranch->GetBoolPref(PREF_MAIL_STRICTLY_MIME, &strictly_mime);
+    rv = pPrefBranch->GetIntPref(PREF_MAIL_MESSAGE_WARNING_SIZE, (int32_t *) &mMessageWarningSize);
+  }
+
+  nsCOMPtr<nsIMsgComposeSecure> secureCompose
+    = do_CreateInstance(NS_MSGCOMPOSESECURE_CONTRACTID, &rv);
+  // It's not an error scenario if there is no secure compose.
+  // The S/MIME extension may be unavailable.
+  if (NS_SUCCEEDED(rv) && secureCompose)
+  {
+    bool requiresEncryptionWork = false;
+    rv = secureCompose->RequiresCryptoEncapsulation(aUserIdentity, fields,
+                                                    &requiresEncryptionWork);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (requiresEncryptionWork)
+    {
+      strictly_mime = true;
+      // RFC2633 3.1.3 doesn't require multipart/signed entities to have
+      // transfer encoding applied for ascii, but do it anyway to make sure
+      // the content (e.g. line endings) isn't mangled along the way.
+      fields->SetForceMsgEncoding(true);
+    }
+  }
+
+  nsMsgMIMESetConformToStandard(strictly_mime);
+  mime_use_quoted_printable_p = strictly_mime;
+
+  rv = InitCompositionFields(fields, aOriginalMsgURI, aType);
+  if (NS_FAILED(rv))
+    return rv;
+
+  //
+  // At this point, if we are only creating this object to do
+  // send operations on externally created RFC822 disk files,
+  // make sure we have setup the appropriate nsIFile and
+  // move on with life.
+  //
+  //
+  // First check to see if we are doing a send operation on an external file
+  // or creating the file itself.
+  //
+  if (sendFile)
+  {
+    mTempFile = sendFile;
+    return NS_OK;
+  }
+
+  // Ok, now watch me pull a rabbit out of my hat....what we need
+  // to do here is figure out what the body will be. If this is a
+  // MHTML request, then we need to do some processing of the document
+  // and figure out what we need to package along with this message
+  // to send. See ProcessMultipartRelated() for further details.
+  //
+
+  //
+  // If we don't have an editor, then we won't be doing multipart related processing
+  // for the body, so make a copy of the one passed in.
+  //
+  if (!mEditor)
+  {
+    SnarfAndCopyBody(attachment1_body, attachment1_type);
+    mOriginalHTMLBody = ToNewCString(attachment1_body);
+  }
+  else if (GetMultipartRelatedCount() == 0) // Only do this if there are not embedded objects
+  {
+    rv = GetBodyFromEditor();
+    if (NS_FAILED(rv))
+      return rv;
+  }
+
+  mSmtpPassword = password;
+
+  return HackAttachments(attachments, preloaded_attachments);
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::SendDeliveryCallback(nsIURI *aUrl, bool inIsNewsDelivery, nsresult aExitCode)
+{
+  if (inIsNewsDelivery)
+  {
+    if (NS_FAILED(aExitCode))
+      if (aExitCode != NS_ERROR_ABORT && !NS_IS_MSG_ERROR(aExitCode))
+        aExitCode = NS_ERROR_POST_FAILED;
+
+    DeliverAsNewsExit(aUrl, aExitCode);
+  }
+  else
+  {
+    if (NS_FAILED(aExitCode))
+    {
+#ifdef __GNUC__
+// Temporary workaroung until bug 783526 is fixed.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wswitch"
+#endif
+      switch (aExitCode)
+      {
+        case NS_ERROR_UNKNOWN_HOST:
+        case NS_ERROR_UNKNOWN_PROXY_HOST:
+          aExitCode = NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER;
+          break;
+        case NS_ERROR_CONNECTION_REFUSED:
+        case NS_ERROR_PROXY_CONNECTION_REFUSED:
+          aExitCode = NS_ERROR_SMTP_SEND_FAILED_REFUSED;
+          break;
+        case NS_ERROR_NET_INTERRUPT:
+          aExitCode = NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED;
+          break;
+        case NS_ERROR_NET_TIMEOUT:
+        case NS_ERROR_NET_RESET:
+          aExitCode = NS_ERROR_SMTP_SEND_FAILED_TIMEOUT;
+          break;
+        case NS_ERROR_SMTP_PASSWORD_UNDEFINED:
+            // nothing to do, just keep the code
+          break;
+        default:
+          if (aExitCode != NS_ERROR_ABORT && !NS_IS_MSG_ERROR(aExitCode))
+            aExitCode = NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON;
+          break;
+      }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+    DeliverAsMailExit(aUrl, aExitCode);
+  }
+
+  return aExitCode;
+}
+
+nsresult
+nsMsgComposeAndSend::DeliverMessage()
+{
+  if (mSendProgress)
+  {
+    bool canceled = false;
+    mSendProgress->GetProcessCanceledByUser(&canceled);
+    if (canceled)
+      return NS_ERROR_ABORT;
+  }
+
+  bool mail_p = ((mCompFields->GetTo() && *mCompFields->GetTo()) ||
+          (mCompFields->GetCc() && *mCompFields->GetCc()) ||
+          (mCompFields->GetBcc() && *mCompFields->GetBcc()));
+  bool news_p = mCompFields->GetNewsgroups() && *(mCompFields->GetNewsgroups());
+  NS_ASSERTION(!( m_deliver_mode != nsMsgSaveAsDraft && m_deliver_mode != nsMsgSaveAsTemplate)  || (mail_p || news_p), "message without destination");
+  if (m_deliver_mode == nsMsgQueueForLater ||
+      m_deliver_mode == nsMsgDeliverBackground ||
+      m_deliver_mode == nsMsgSaveAsDraft ||
+      m_deliver_mode == nsMsgSaveAsTemplate)
+    return SendToMagicFolder(m_deliver_mode);
+
+  //
+  // Ok, we are about to send the file that we have built up...but what
+  // if this is a mongo email...we should have a way to warn the user that
+  // they are about to do something they may not want to do.
+  //
+  int64_t fileSize;
+  nsresult rv = mTempFile->GetFileSize(&fileSize);
+  if (NS_FAILED(rv))
+    return NS_ERROR_FAILURE;
+
+  if ((mMessageWarningSize > 0) && (fileSize > mMessageWarningSize) && (mGUINotificationEnabled))
+  {
+    bool abortTheSend = false;
+    nsString msg;
+    nsAutoString formattedFileSize;
+    FormatFileSize(fileSize, true, formattedFileSize);
+    const char16_t* params[] = { formattedFileSize.get() };
+    mComposeBundle->FormatStringFromName(u"largeMessageSendWarning",
+                                         params, 1, getter_Copies(msg));
+
+    if (!msg.IsEmpty())
+    {
+      nsCOMPtr<nsIPrompt> prompt;
+      GetDefaultPrompt(getter_AddRefs(prompt));
+      nsMsgAskBooleanQuestionByString(prompt, msg.get(), &abortTheSend);
+      if (!abortTheSend)
+      {
+        nsresult ignoreMe;
+        Fail(NS_ERROR_BUT_DONT_SHOW_ALERT, msg.get(), &ignoreMe);
+        return NS_ERROR_FAILURE;
+      }
+    }
+  }
+
+  if (news_p)
+  {
+    if (mail_p)
+      mSendMailAlso = true;
+
+    return DeliverFileAsNews();   /* will call DeliverFileAsMail if it needs to */
+  }
+  else if (mail_p)
+    return DeliverFileAsMail();
+  else
+    return NS_ERROR_UNEXPECTED;
+  return NS_OK;
+}
+
+
+nsresult
+nsMsgComposeAndSend::DeliverFileAsMail()
+{
+  char *buf, *buf2;
+  buf = (char *) PR_Malloc ((mCompFields->GetTo() ? PL_strlen (mCompFields->GetTo())  + 10 : 0) +
+               (mCompFields->GetCc() ? PL_strlen (mCompFields->GetCc())  + 10 : 0) +
+               (mCompFields->GetBcc() ? PL_strlen (mCompFields->GetBcc()) + 10 : 0) +
+               10);
+
+  if (mSendReport)
+    mSendReport->SetCurrentProcess(nsIMsgSendReport::process_SMTP);
+
+  nsCOMPtr<nsIPrompt> promptObject;
+  GetDefaultPrompt(getter_AddRefs(promptObject));
+
+  if (!buf)
+  {
+    nsresult ignoreMe;
+    Fail(NS_ERROR_OUT_OF_MEMORY, nullptr, &ignoreMe);
+    NotifyListenerOnStopSending(nullptr, NS_ERROR_OUT_OF_MEMORY, nullptr, nullptr);
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  bool collectOutgoingAddresses = true;
+  nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (pPrefBranch)
+    pPrefBranch->GetBoolPref(PREF_MAIL_COLLECT_EMAIL_ADDRESS_OUTGOING, &collectOutgoingAddresses);
+
+  nsCOMPtr<nsIAbAddressCollector> addressCollector =
+           do_GetService(NS_ABADDRESSCOLLECTOR_CONTRACTID);
+
+  bool collectAddresses = (collectOutgoingAddresses && addressCollector);
+  uint32_t sendFormat = nsIAbPreferMailFormat::unknown;
+
+  // this code is not ready yet
+  // see bug #44494 for more details
+  // so for now, just pass in nsIAbPreferMailFormat::unknown
+  // which will have no effect on the "prefers" attribute in the ab
+#if 0
+  bool forcePlainText = mCompFields->GetForcePlainText();
+  bool useMultipartAlternative = mCompFields->GetUseMultipartAlternative();
+  // see GenericSendMessage() in MsgComposeCommands.js for the reverse logic
+  // if we choose to send both (html and plain) remember html.
+  if (forcePlainText && !useMultipartAlternative)
+  {
+    // for now, don't remember the "plaintext" decision.
+    // we could get in here because while sending html mail
+    // the body was "convertible", but that doesn't mean
+    // we intended to force plain text here.
+    // so for now, use "unknown" which will have no effect on the
+    // "prefers" attribute in the ab.
+    // see bug #245520 for more details
+    // sendFormat = nsIAbPreferMailFormat::plaintext;
+    sendFormat = nsIAbPreferMailFormat::unknown;
+  }
+  else if (!forcePlainText)
+    sendFormat = nsIAbPreferMailFormat::html;
+  else
+    NS_ERROR("unknown send format, should not happen");
+#endif
+
+  PL_strcpy (buf, "");
+  buf2 = buf + PL_strlen (buf);
+  if (mCompFields->GetTo() && *mCompFields->GetTo())
+  {
+    PL_strcat (buf2, mCompFields->GetTo());
+    if (addressCollector)
+      addressCollector->CollectAddress(nsCString(mCompFields->GetTo()),
+            collectAddresses /* create card if one doesn't exist */, sendFormat);
+  }
+  if (mCompFields->GetCc() && *mCompFields->GetCc()) {
+    if (*buf2) PL_strcat (buf2, ",");
+      PL_strcat (buf2, mCompFields->GetCc());
+    if (addressCollector)
+      addressCollector->CollectAddress(nsCString(mCompFields->GetCc()),
+            collectAddresses /* create card if one doesn't exist */, sendFormat);
+  }
+  if (mCompFields->GetBcc() && *mCompFields->GetBcc()) {
+    if (*buf2) PL_strcat (buf2, ",");
+      PL_strcat (buf2, mCompFields->GetBcc());
+    if (addressCollector)
+      addressCollector->CollectAddress(nsCString(mCompFields->GetBcc()),
+            collectAddresses /* create card if one doesn't exist */, sendFormat);
+  }
+
+  // We need undo groups to keep only the addresses
+  nsresult rv = StripOutGroupNames(buf);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Ok, now MIME II encode this to prevent 8bit problems...
+  char *convbuf = nsMsgI18NEncodeMimePartIIStr(buf, true,
+            mCompFields->GetCharacterSet(), 0, nsMsgMIMEGetConformToStandard());
+  if (convbuf)
+  {
+    // MIME-PartII conversion
+    PR_FREEIF(buf);
+    buf = convbuf;
+  }
+
+  nsCString escaped_buf;
+  MsgEscapeString(nsDependentCString(buf), nsINetUtil::ESCAPE_URL_PATH, escaped_buf);
+
+  if (!escaped_buf.IsEmpty())
+  {
+    NS_Free(buf);
+    buf = ToNewCString(escaped_buf);
+  }
+
+  nsCOMPtr<nsISmtpService> smtpService(do_GetService(NS_SMTPSERVICE_CONTRACTID, &rv));
+  if (NS_SUCCEEDED(rv) && smtpService)
+  {
+    MsgDeliveryListener *deliveryListener = new MsgDeliveryListener(this, false);
+    if (!deliveryListener)
+      return NS_ERROR_OUT_OF_MEMORY;
+
+    // we used to get the prompt from the compose window and we'd pass that in
+    // to the smtp protocol as the prompt to use. But when you send a message,
+    // we dismiss the compose window.....so you are parenting off of a window that
+    // isn't there. To have it work correctly I think we want the alert dialogs to be modal
+    // to the top most mail window...after all, that's where we are going to be sending status
+    // update information too....
+
+    nsCOMPtr<nsIInterfaceRequestor> callbacks;
+    GetNotificationCallbacks(getter_AddRefs(callbacks));
+
+    // Tell the user we are sending the message!
+    nsString msg;
+    mComposeBundle->GetStringFromName(u"sendingMessage", getter_Copies(msg));
+    SetStatusMessage(msg);
+    nsCOMPtr<nsIMsgStatusFeedback> msgStatus (do_QueryInterface(mSendProgress));
+    // if the sendProgress isn't set, let's use the member variable.
+    if (!msgStatus)
+      msgStatus = do_QueryInterface(mStatusFeedback);
+
+    nsCOMPtr<nsIURI> runningUrl;
+    rv = smtpService->SendMailMessage(mTempFile, buf, mUserIdentity,
+                                      mSmtpPassword.get(), deliveryListener, msgStatus,
+                                      callbacks, mCompFields->GetDSN(),
+                                      getter_AddRefs(runningUrl),
+                                      getter_AddRefs(mRunningRequest));
+    // set envid on the returned URL
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsISmtpUrl> smtpUrl(do_QueryInterface(runningUrl, &rv));
+      if (NS_SUCCEEDED(rv))
+        smtpUrl->SetDsnEnvid(nsDependentCString(mCompFields->GetMessageId()));
+    }
+  }
+
+  PR_FREEIF(buf); // free the buf because we are done with it....
+  return rv;
+}
+
+nsresult
+nsMsgComposeAndSend::DeliverFileAsNews()
+{
+  nsresult rv = NS_OK;
+  if (!(mCompFields->GetNewsgroups()))
+    return rv;
+
+  if (mSendReport)
+    mSendReport->SetCurrentProcess(nsIMsgSendReport::process_NNTP);
+
+  nsCOMPtr<nsIPrompt> promptObject;
+  GetDefaultPrompt(getter_AddRefs(promptObject));
+
+  nsCOMPtr<nsINntpService> nntpService(do_GetService(NS_NNTPSERVICE_CONTRACTID, &rv));
+
+  if (NS_SUCCEEDED(rv) && nntpService)
+  {
+    MsgDeliveryListener *deliveryListener = new MsgDeliveryListener(this, true);
+    if (!deliveryListener)
+      return NS_ERROR_OUT_OF_MEMORY;
+
+    // Tell the user we are posting the message!
+    nsString msg;
+    mComposeBundle->GetStringFromName(u"postingMessage",
+                                      getter_Copies(msg));
+    SetStatusMessage(msg);
+
+    nsCOMPtr <nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // JFD TODO: we should use GetDefaultPrompt instead
+    nsCOMPtr<nsIMsgWindow> msgWindow;
+    rv = mailSession->GetTopmostMsgWindow(getter_AddRefs(msgWindow));
+    // see bug #163139
+    // we might not have a msg window if only the compose window is open.
+    if(NS_FAILED(rv))
+      msgWindow = nullptr;
+
+    rv = nntpService->PostMessage(mTempFile, mCompFields->GetNewsgroups(), mAccountKey.get(),
+                                  deliveryListener, msgWindow, nullptr);
+    if (NS_FAILED(rv)) return rv;
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::Fail(nsresult aFailureCode, const char16_t *aErrorMsg,
+                          nsresult *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = aFailureCode;
+
+  if (NS_FAILED(aFailureCode))
+  {
+    nsCOMPtr<nsIPrompt> prompt;
+    GetDefaultPrompt(getter_AddRefs(prompt));
+
+    if (mSendReport)
+    {
+      int32_t process;
+      if (NS_SUCCEEDED(mSendReport->GetCurrentProcess(&process)) && process == nsIMsgSendReport::process_Current)
+      {
+        // currentProcess isn't set yet, so we need another value.
+        mSendReport->SetCurrentProcess(nsIMsgSendReport::process_BuildMessage);
+      }
+      mSendReport->SetError(nsIMsgSendReport::process_Current, aFailureCode, false);
+      mSendReport->SetMessage(nsIMsgSendReport::process_Current, aErrorMsg, false);
+      mSendReport->DisplayReport(prompt, true, true, aResult);
+    }
+    else
+    {
+      if (aFailureCode != NS_ERROR_BUT_DONT_SHOW_ALERT)
+        nsMsgDisplayMessageByName(prompt, u"sendFailed");
+    }
+  }
+
+  if (NS_SUCCEEDED(m_status))
+    m_status = NS_ERROR_BUT_DONT_SHOW_ALERT;
+
+  //Stop any pending process...
+  Abort();
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgComposeAndSend::FormatStringWithSMTPHostNameByName(const char16_t* aMsgName, char16_t **aString)
+{
+  NS_ENSURE_ARG(aString);
+
+  nsresult rv;
+  nsCOMPtr<nsISmtpService> smtpService(do_GetService(NS_SMTPSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // Get the smtp hostname and format the string.
+  nsCString smtpHostName;
+  nsCOMPtr<nsISmtpServer> smtpServer;
+  rv = smtpService->GetServerByIdentity(mUserIdentity, getter_AddRefs(smtpServer));
+  if (NS_SUCCEEDED(rv))
+    smtpServer->GetHostname(smtpHostName);
+
+  nsAutoString hostStr;
+  CopyASCIItoUTF16(smtpHostName, hostStr);
+  const char16_t *params[] = { hostStr.get() };
+  if (NS_SUCCEEDED(rv))
+    mComposeBundle->FormatStringFromName(aMsgName, params, 1, aString);
+  return rv;
+}
+
+void
+nsMsgComposeAndSend::DoDeliveryExitProcessing(nsIURI * aUri, nsresult aExitCode, bool aCheckForMail)
+{
+  // If we fail on the news delivery, no sense in going on so just notify
+  // the user and exit.
+  if (NS_FAILED(aExitCode))
+  {
+    const char16_t* exitString = errorStringNameForErrorCode(aExitCode);
+    nsString eMsg;
+    if (aExitCode == NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_SERVER ||
+        aExitCode == NS_ERROR_SMTP_SEND_FAILED_UNKNOWN_REASON ||
+        aExitCode == NS_ERROR_SMTP_SEND_FAILED_REFUSED ||
+        aExitCode == NS_ERROR_SMTP_SEND_FAILED_INTERRUPTED ||
+        aExitCode == NS_ERROR_SMTP_SEND_FAILED_TIMEOUT ||
+        aExitCode == NS_ERROR_SMTP_PASSWORD_UNDEFINED ||
+        aExitCode == NS_ERROR_SMTP_AUTH_FAILURE ||
+        aExitCode == NS_ERROR_SMTP_AUTH_GSSAPI ||
+        aExitCode == NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED ||
+        aExitCode == NS_ERROR_SMTP_AUTH_NOT_SUPPORTED ||
+        aExitCode == NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL ||
+        aExitCode == NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL ||
+        aExitCode == NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT ||
+        aExitCode == NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS) {
+      FormatStringWithSMTPHostNameByName(exitString, getter_Copies(eMsg));
+    } else {
+      mComposeBundle->GetStringFromName(exitString, getter_Copies(eMsg));
+    }
+
+    Fail(aExitCode, eMsg.get(), &aExitCode);
+    NotifyListenerOnStopSending(nullptr, aExitCode, nullptr, nullptr);
+    return;
+  }
+
+  if (aCheckForMail)
+  {
+    if ((mCompFields->GetTo() && *mCompFields->GetTo()) ||
+        (mCompFields->GetCc() && *mCompFields->GetCc()) ||
+        (mCompFields->GetBcc() && *mCompFields->GetBcc()))
+    {
+      // If we're sending this news message to mail as well, start it now.
+      // Completion and further errors will be handled there.
+      DeliverFileAsMail();
+      return;
+    }
+  }
+
+  //
+  // Tell the listeners that we are done with the sending operation...
+  //
+  NotifyListenerOnStopSending(mCompFields->GetMessageId(),
+                              aExitCode,
+                              nullptr,
+                              nullptr);
+
+  // If we hit here, we are done with delivery!
+  //
+  // Just call the DoFCC() method and if that fails, then we should just
+  // cleanup and get out. If DoFCC "succeeds", then all that means is the
+  // async copy operation has been started and we will be notified later
+  // when it is done. DON'T cleanup until the copy is complete and don't
+  // notify the listeners with OnStop() until we are done.
+  //
+  // For now, we don't need to do anything here, but the code will stay this
+  // way until later...
+  //
+
+  DoFcc();
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::DeliverAsMailExit(nsIURI *aUrl, nsresult aExitCode)
+{
+  DoDeliveryExitProcessing(aUrl, aExitCode, false);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::DeliverAsNewsExit(nsIURI *aUrl, nsresult aExitCode)
+{
+  DoDeliveryExitProcessing(aUrl, aExitCode, mSendMailAlso);
+  return NS_OK;
+}
+
+bool nsMsgComposeAndSend::CanSaveMessagesToFolder(const char *folderURL)
+{
+  nsresult rv;
+  nsCOMPtr<nsIRDFService> rdf(do_GetService("@mozilla.org/rdf/rdf-service;1", &rv));
+  if (NS_FAILED(rv))
+    return false;
+
+  nsCOMPtr<nsIRDFResource> resource;
+  rv = rdf->GetResource(nsDependentCString(folderURL), getter_AddRefs(resource));
+  if (NS_FAILED(rv))
+    return false;
+
+  nsCOMPtr <nsIMsgFolder> thisFolder;
+  thisFolder = do_QueryInterface(resource, &rv);
+  if (NS_FAILED(rv) || !thisFolder)
+    return false;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = thisFolder->GetServer(getter_AddRefs(server));
+  if (NS_FAILED(rv) || !server)
+    return false;
+
+  // See if we are allowed to save/file msgs to this folder.
+  bool canSave;
+  rv = server->GetCanFileMessagesOnServer(&canSave);
+  return canSave;
+}
+
+//
+// Now, start the appropriate copy operation.
+//
+nsresult
+nsMsgComposeAndSend::DoFcc()
+{
+  //
+  // Just cleanup and return success if we're not allowed to save msgs to FCC folder.
+  //
+  const char* fcc = mCompFields->GetFcc();
+  if (!fcc || !*fcc || !CanSaveMessagesToFolder(fcc))
+  {
+
+    // It is the caller's responsibility to say we've stopped sending, so just
+    // let the listeners know we're not doing a copy.
+    NotifyListenerOnStopCopy(NS_OK);  // For closure of compose window...
+    return NS_OK;
+  }
+
+  if (mSendReport)
+    mSendReport->SetCurrentProcess(nsIMsgSendReport::process_Copy);
+
+  //
+  // If we are here, then we need to save off the FCC file to save and
+  // start the copy operation. MimeDoFCC() will take care of all of this
+  // for us.
+  //
+  nsresult rv = MimeDoFCC(mTempFile,
+                          nsMsgDeliverNow,
+                          mCompFields->GetBcc(),
+                          mCompFields->GetFcc(),
+                          mCompFields->GetNewspostUrl());
+  if (NS_FAILED(rv))
+  {
+    //
+    // If we hit here, the copy operation FAILED and we should at least tell the
+    // user that it did fail but the send operation has already succeeded.
+    //
+    NotifyListenerOnStopCopy(rv);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::NotifyListenerOnStartSending(const char *aMsgID, uint32_t aMsgSize)
+{
+  if (mListener)
+    mListener->OnStartSending(aMsgID, aMsgSize);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::NotifyListenerOnProgress(const char *aMsgID, uint32_t aProgress, uint32_t aProgressMax)
+{
+  if (mListener)
+    mListener->OnProgress(aMsgID, aProgress, aProgressMax);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::NotifyListenerOnStatus(const char *aMsgID, const char16_t *aMsg)
+{
+  if (mListener)
+    mListener->OnStatus(aMsgID, aMsg);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::NotifyListenerOnStopSending(const char *aMsgID, nsresult aStatus, const char16_t *aMsg,
+                                                  nsIFile *returnFile)
+{
+  if (mListener != nullptr)
+    mListener->OnStopSending(aMsgID, aStatus, aMsg, returnFile);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::NotifyListenerOnStartCopy()
+{
+  nsCOMPtr<nsIMsgCopyServiceListener> copyListener;
+
+  if (mListener)
+  {
+    copyListener = do_QueryInterface(mListener);
+    if (copyListener)
+      copyListener->OnStartCopy();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::NotifyListenerOnProgressCopy(uint32_t aProgress,
+                                                   uint32_t aProgressMax)
+{
+  nsCOMPtr<nsIMsgCopyServiceListener> copyListener;
+
+  if (mListener)
+  {
+    copyListener = do_QueryInterface(mListener);
+    if (copyListener)
+      copyListener->OnProgress(aProgress, aProgressMax);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::SetMessageKey(nsMsgKey aMessageKey)
+{
+    m_messageKey = aMessageKey;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetMessageKey(nsMsgKey *aMessageKey)
+{
+    *aMessageKey = m_messageKey;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetFolderUri(nsACString &aFolderUri)
+{
+  aFolderUri = m_folderName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetPartForDomIndex(int32_t aDomIndex, nsACString &aPartNum)
+{
+  aPartNum = m_partNumbers.SafeElementAt(aDomIndex, EmptyCString());
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetMessageId(nsACString& aMessageId)
+{
+  nsresult rv = NS_OK;
+  if (mCompFields)
+    aMessageId = mCompFields->GetMessageId();
+  else
+    rv = NS_ERROR_NULL_POINTER;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::NotifyListenerOnStopCopy(nsresult aStatus)
+{
+  // This is one per copy so make sure we clean this up first.
+  mCopyObj = nullptr;
+
+  // Set a status message...
+  nsString msg;
+  if (NS_SUCCEEDED(aStatus))
+    mComposeBundle->GetStringFromName(u"copyMessageComplete", getter_Copies(msg));
+  else
+    mComposeBundle->GetStringFromName(u"copyMessageFailed", getter_Copies(msg));
+
+  SetStatusMessage(msg);
+  nsCOMPtr<nsIPrompt> prompt;
+  GetDefaultPrompt(getter_AddRefs(prompt));
+
+  if (NS_FAILED(aStatus))
+  {
+    nsresult rv;
+    nsCOMPtr<nsIStringBundleService> bundleService =
+      mozilla::services::GetStringBundleService();
+    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;
+    const char16_t *formatStrings[] = { mSavedToFolderName.get() };
+
+    rv = bundle->FormatStringFromName(u"errorSavingMsg",
+                                      formatStrings, 1,
+                                      getter_Copies(msg));
+    if (NS_SUCCEEDED(rv))
+    {
+      bool retry = false;
+      nsMsgAskBooleanQuestionByString(prompt, msg.get(), &retry, nullptr);
+      if (retry)
+      {
+        mSendProgress = nullptr; // this was cancelled, so we need to clear it.
+        return SendToMagicFolder(m_deliver_mode);
+      }
+    }
+
+    // We failed, and the user decided not to retry. So we're just going to
+    // fail out. However, give Fail a success code so that it doesn't prompt
+    // the user a second time as they already know about the failure.
+    Fail(NS_OK, nullptr, &aStatus);
+  }
+
+  if (NS_SUCCEEDED(aStatus) &&
+      !mPerformingSecondFCC && m_messageKey != nsMsgKey_None &&
+      (m_deliver_mode == nsMsgDeliverNow || m_deliver_mode == nsMsgSendUnsent))
+  {
+    nsresult rv = FilterSentMessage();
+    if (NS_FAILED(rv))
+      OnStopOperation(rv);
+    return rv;
+  }
+
+  return MaybePerformSecondFCC(aStatus);
+}
+
+nsresult
+nsMsgComposeAndSend::FilterSentMessage()
+{
+  if (mSendReport)
+    mSendReport->SetCurrentProcess(nsIMsgSendReport::process_Filter);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = GetExistingFolder(m_folderName, getter_AddRefs(folder));
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  rv = folder->GetMessageHeader(m_messageKey, getter_AddRefs(msgHdr));
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCOMPtr<nsIMutableArray> msgArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCOMPtr<nsIMsgFilterService> filterSvc = do_GetService(NS_MSGFILTERSERVICE_CONTRACTID, &rv);
+  if (NS_FAILED(rv))
+    return rv;
+
+  rv = msgArray->AppendElement(msgHdr, false);
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+  if (mSendProgress)
+    mSendProgress->GetMsgWindow(getter_AddRefs(msgWindow));
+
+  return filterSvc->ApplyFilters(nsMsgFilterType::PostOutgoing, msgArray, folder, msgWindow, this);
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::OnStopOperation(nsresult aStatus)
+{
+  // Set a status message...
+  nsString msg;
+  if (NS_SUCCEEDED(aStatus))
+    mComposeBundle->GetStringFromName(u"filterMessageComplete", getter_Copies(msg));
+  else
+    mComposeBundle->GetStringFromName(u"filterMessageFailed", getter_Copies(msg));
+
+  SetStatusMessage(msg);
+
+  if (NS_FAILED(aStatus))
+  {
+    nsresult rv = mComposeBundle->GetStringFromName(u"errorFilteringMsg", getter_Copies(msg));
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIPrompt> prompt;
+      GetDefaultPrompt(getter_AddRefs(prompt));
+      nsMsgDisplayMessageByString(prompt, msg.get(), nullptr);
+    }
+
+    // We failed, however, give Fail a success code so that it doesn't prompt
+    // the user a second time as they already know about the failure.
+    Fail(NS_OK, nullptr, &aStatus);
+  }
+
+  return MaybePerformSecondFCC(aStatus);
+}
+
+nsresult
+nsMsgComposeAndSend::MaybePerformSecondFCC(nsresult aStatus)
+{
+  // Ok, now to support a second copy operation, we need to figure
+  // out which copy request just finished. If the user has requested
+  // a second copy operation, then we need to fire that off, but if they
+  // just wanted a single copy operation, we can tell everyone we are done
+  // and move on with life. Only do the second copy if the first one worked.
+  //
+  if ( NS_SUCCEEDED(aStatus) && (mNeedToPerformSecondFCC) )
+  {
+    if (mSendReport)
+      mSendReport->SetCurrentProcess(nsIMsgSendReport::process_FCC);
+
+    mNeedToPerformSecondFCC = false;
+    mPerformingSecondFCC = true;
+
+    const char *fcc2 = mCompFields->GetFcc2();
+    if (fcc2 && *fcc2)
+    {
+      nsresult rv = MimeDoFCC(mTempFile,
+                              nsMsgDeliverNow,
+                              mCompFields->GetBcc(),
+                              fcc2,
+                              mCompFields->GetNewspostUrl());
+      if (NS_FAILED(rv))
+        Fail(rv, nullptr, &aStatus);
+      else
+        return NS_OK;
+    }
+  }
+
+  // If we are here, its real cleanup time!
+  if (mListener)
+  {
+    nsCOMPtr<nsIMsgCopyServiceListener> copyListener =
+      do_QueryInterface(mListener);
+    if (copyListener)
+      copyListener->OnStopCopy(aStatus);
+  }
+
+  return aStatus;
+}
+
+/* This is the main driving function of this module.  It generates a
+   document of type message/rfc822, which contains the stuff provided.
+   The first few arguments are the standard header fields that the
+   generated document should have.
+
+   `other_random_headers' is a string of additional headers that should
+   be inserted beyond the standard ones.  If provided, it is just tacked
+   on to the end of the header block, so it should have newlines at the
+   end of each line, shouldn't have blank lines, multi-line headers
+   should be properly continued, etc.
+
+   `digest_p' says that most of the documents we are attaching are
+   themselves messages, and so we should generate a multipart/digest
+   container instead of multipart/mixed.  (It's a minor difference.)
+
+   The full text of the first attachment is provided via `attachment1_type'
+   and `attachment1_body'. These may all be 0 if all attachments are
+   provided externally.
+
+   Subsequent attachments are provided as URLs to load, described in the
+   nsMsgAttachmentData structures.
+
+   If `dont_deliver_p' is false, then we actually deliver the message to the
+   SMTP and/or NNTP server, and the message_delivery_done_callback will be
+   invoked with the status.
+
+   If `dont_deliver_p' is true, then we just generate the message, we don't
+   actually deliver it, and the message_delivery_done_callback will be called
+   with the name of the generated file.  The callback is responsible for both
+   freeing the file name string, and deleting the file when it is done with
+   it.  If an error occurred, then `status' will be negative and
+   `error_message' may be an error message to display.  If status is non-
+   negative, then `error_message' contains the file name (this is kind of
+   a kludge...)
+ */
+NS_IMETHODIMP
+nsMsgComposeAndSend::CreateAndSendMessage(
+              nsIEditor                         *aEditor,
+              nsIMsgIdentity                    *aUserIdentity,
+              const char                        *aAccountKey,
+              nsIMsgCompFields                  *fields,
+              bool                              digest_p,
+              bool                              dont_deliver_p,
+              nsMsgDeliverMode                  mode,
+              nsIMsgDBHdr                       *msgToReplace,
+              const char                        *attachment1_type,
+              const nsACString                  &attachment1_body,
+              nsIArray *attachments,
+              nsIArray *preloaded_attachments,
+              mozIDOMWindowProxy                *parentWindow,
+              nsIMsgProgress                    *progress,
+              nsIMsgSendListener                *aListener,
+              const char                        *password,
+              const nsACString                  &aOriginalMsgURI,
+              MSG_ComposeType                   aType
+              )
+{
+  nsresult      rv;
+  /* First thing to do is to reset the send errors report */
+  mSendReport->Reset();
+  mSendReport->SetDeliveryMode(mode);
+
+  mParentWindow = do_QueryInterface(parentWindow);
+  mSendProgress = progress;
+  mListener = aListener;
+
+  // Set the editor for MHTML operations if necessary
+  if (aEditor)
+    mEditor = aEditor;
+
+  rv = Init(aUserIdentity, aAccountKey, (nsMsgCompFields *)fields, nullptr,
+          digest_p, dont_deliver_p, mode, msgToReplace,
+          attachment1_type, attachment1_body,
+          attachments, preloaded_attachments,
+          password, aOriginalMsgURI, aType);
+
+  if (NS_FAILED(rv) && mSendReport)
+    mSendReport->SetError(nsIMsgSendReport::process_Current, rv, false);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::CreateRFC822Message(
+              nsIMsgIdentity *aUserIdentity,
+              nsIMsgCompFields *aFields,
+              const char *aMsgType,
+              const nsACString &aMsgBody,
+              bool aIsDraft,
+              nsIArray *aAttachments,
+              nsIArray *aEmbeddedObjects,
+              nsIMsgSendListener *aListener
+              )
+{
+  nsresult rv;
+  nsMsgDeliverMode mode = aIsDraft ? nsIMsgSend::nsMsgSaveAsDraft :
+                                     nsIMsgSend::nsMsgDeliverNow;
+
+  /* First thing to do is to reset the send errors report */
+  mSendReport->Reset();
+  mSendReport->SetDeliveryMode(mode);
+
+  mParentWindow = nullptr;
+  mSendProgress = nullptr;
+  mListener = aListener;
+  mEmbeddedObjectList = aEmbeddedObjects;
+
+  rv = Init(aUserIdentity, nullptr, (nsMsgCompFields *)aFields, nullptr,
+            false, true, mode, nullptr,
+            aMsgType,
+            aMsgBody,
+            nullptr, aAttachments,
+            nullptr, EmptyCString(), nsIMsgCompType::New);
+
+  if (NS_FAILED(rv) && mSendReport)
+    mSendReport->SetError(nsIMsgSendReport::process_Current, rv, false);
+
+  return rv;
+}
+
+nsresult
+nsMsgComposeAndSend::SendMessageFile(
+              nsIMsgIdentity                    *aUserIndentity,
+              const char                        *aAccountKey,
+              nsIMsgCompFields                  *fields,
+              nsIFile                           *sendIFile,
+              bool                              deleteSendFileOnCompletion,
+              bool                              digest_p,
+              nsMsgDeliverMode                  mode,
+              nsIMsgDBHdr                       *msgToReplace,
+              nsIMsgSendListener                *aListener,
+              nsIMsgStatusFeedback              *aStatusFeedback,
+              const char                        *password
+              )
+{
+  NS_ENSURE_ARG_POINTER(fields);
+  NS_ENSURE_ARG_POINTER(sendIFile);
+
+  nsresult      rv;
+
+  /* First thing to do is to reset the send errors report */
+  mSendReport->Reset();
+  mSendReport->SetDeliveryMode(mode);
+
+  mStatusFeedback = aStatusFeedback;
+  //
+  // First check to see if the external file we are sending is a valid file.
+  //
+  bool exists;
+  if (NS_FAILED(sendIFile->Exists(&exists)))
+    return NS_ERROR_INVALID_ARG;
+
+  if (!exists)
+    return NS_ERROR_INVALID_ARG;
+
+  // Setup the listener...
+  mListener = aListener;
+
+  // Should we delete the temp file when done?
+  if (!deleteSendFileOnCompletion)
+    mReturnFile = sendIFile;
+
+  rv = Init(aUserIndentity, aAccountKey, (nsMsgCompFields *)fields, sendIFile,
+            digest_p, false, mode, msgToReplace,
+            nullptr, EmptyCString(),
+            nullptr, nullptr,
+            password, EmptyCString(), nsIMsgCompType::New);
+
+  if (NS_SUCCEEDED(rv))
+    rv = DeliverMessage();
+
+  if (NS_FAILED(rv) && mSendReport)
+    mSendReport->SetError(nsIMsgSendReport::process_Current, rv, false);
+
+  return rv;
+}
+
+//
+// Send the message to the magic folder, and runs the completion/failure
+// callback.
+//
+nsresult
+nsMsgComposeAndSend::SendToMagicFolder(nsMsgDeliverMode mode)
+{
+    nsresult rv = MimeDoFCC(mTempFile,
+                            mode,
+                            mCompFields->GetBcc(),
+                            mCompFields->GetFcc(),
+                            mCompFields->GetNewspostUrl());
+    //
+    // The caller of MimeDoFCC needs to deal with failure.
+    //
+    if (NS_FAILED(rv))
+      rv = NotifyListenerOnStopCopy(rv);
+
+    return rv;
+}
+
+char*
+nsMsgGetEnvelopeLine(void)
+{
+  static char       result[75] = "";
+  PRExplodedTime    now;
+  char              buffer[128] = "";
+
+  // Generate envelope line in format of:  From - Sat Apr 18 20:01:49 1998
+  //
+  // 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 (superceding RFC 822.)
+  //
+  PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &now);
+  PR_FormatTimeUSEnglish(buffer, sizeof(buffer),
+               "%a %b %d %H:%M:%S %Y",
+               &now);
+
+  // This value must be in ctime() format, with English abbreviations.
+  // PL_strftime("... %c ...") is no good, because it is localized.
+  //
+  PL_strcpy(result, "From - ");
+  PL_strcpy(result + 7, buffer);
+  PL_strcpy(result + 7 + 24, CRLF);
+  return result;
+}
+
+#define ibuffer_size FILE_IO_BUFFER_SIZE
+nsresult
+nsMsgComposeAndSend::MimeDoFCC(nsIFile          *input_file,
+                               nsMsgDeliverMode mode,
+                               const char       *bcc_header,
+                               const char       *fcc_header,
+                               const char       *news_url)
+{
+  nsresult      status = NS_OK;
+  char          *ibuffer = nullptr;
+  uint32_t      n;
+  bool          folderIsLocal = true;
+  nsCString     turi;
+  char16_t     *printfString = nullptr;
+  nsString msg;
+  nsCOMPtr<nsIMsgFolder> folder;
+
+  // Before continuing, just check the user has not cancel the operation
+  if (mSendProgress)
+  {
+    bool canceled = false;
+    mSendProgress->GetProcessCanceledByUser(&canceled);
+    if (canceled)
+      return NS_ERROR_ABORT;
+    else
+      mSendProgress->OnProgressChange(nullptr, nullptr, 0, 0, 0, -1);
+  }
+
+  //
+  // Ok, this is here to keep track of this for 2 copy operations...
+  //
+  if (mCopyFile)
+  {
+    mCopyFile2 = mCopyFile;
+    mCopyFile = nullptr;
+  }
+
+  //
+  // Create the file that will be used for the copy service!
+  //
+  nsresult rv = nsMsgCreateTempFile("nscopy.tmp", getter_AddRefs(mCopyFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIOutputStream> tempOutfile;
+  rv = MsgNewBufferedFileOutputStream(getter_AddRefs(tempOutfile), mCopyFile, -1, 00600);
+  if (NS_FAILED(rv))
+  {
+    if (mSendReport)
+    {
+      nsAutoString error_msg;
+      nsMsgBuildMessageWithTmpFile(mCopyFile, error_msg);
+      mSendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), false);
+    }
+    status = NS_MSG_UNABLE_TO_OPEN_TMP_FILE;
+
+    mCopyFile = nullptr;
+    return status;
+  }
+
+  //
+  // Get our files ready...
+  //
+  nsCOMPtr<nsIInputStream> inputFile;
+  rv = NS_NewLocalFileInputStream(getter_AddRefs(inputFile), input_file);
+  if (NS_FAILED(rv))
+  {
+    if (mSendReport)
+    {
+      nsAutoString error_msg;
+      nsMsgBuildMessageWithFile(input_file, error_msg);
+      mSendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), false);
+    }
+    status = NS_MSG_UNABLE_TO_OPEN_FILE;
+    goto FAIL;
+  }
+
+  // now the buffers...
+  ibuffer = (char *) PR_Malloc(ibuffer_size);
+  if (!ibuffer)
+  {
+    status = NS_ERROR_OUT_OF_MEMORY;
+    goto FAIL;
+  }
+
+  //
+  // First, we we need to put a Berkeley "From - " delimiter at the head of
+  // the file for parsing...
+  //
+
+  if (fcc_header && *fcc_header)
+    GetExistingFolder(nsDependentCString(fcc_header), getter_AddRefs(folder));
+
+  if ((mode == nsMsgDeliverNow || mode == nsMsgSendUnsent) && folder)
+    turi = fcc_header;
+  else
+    GetFolderURIFromUserPrefs(mode, mUserIdentity, turi);
+  status = MessageFolderIsLocal(mUserIdentity, mode, turi.get(), &folderIsLocal);
+  if (NS_FAILED(status))
+    goto FAIL;
+
+  // Tell the user we are copying the message...
+  mComposeBundle->GetStringFromName(u"copyMessageStart",
+                                    getter_Copies(msg));
+  if (!msg.IsEmpty())
+  {
+    nsCOMPtr<nsIRDFService> rdfService = do_GetService(kRDFServiceCID);
+    if (rdfService)
+    {
+      nsCOMPtr<nsIRDFResource> res;
+      rdfService->GetResource(turi, getter_AddRefs(res));
+      nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(res);
+      if (folder)
+        folder->GetName(mSavedToFolderName);
+    }
+    if (!mSavedToFolderName.IsEmpty())
+      printfString = nsTextFormatter::smprintf(msg.get(), mSavedToFolderName.get());
+    else
+      printfString = nsTextFormatter::smprintf(msg.get(), "?");
+    if (printfString)
+    {
+      SetStatusMessage(nsDependentString(printfString));
+      PR_Free(printfString);
+    }
+  }
+
+  if (folderIsLocal)
+  {
+    char *envelopeLine = nsMsgGetEnvelopeLine();
+    uint32_t   len = PL_strlen(envelopeLine);
+
+    rv = tempOutfile->Write(envelopeLine, len, &n);
+    if (NS_FAILED(rv) || n != len)
+    {
+      status = NS_ERROR_FAILURE;
+      goto FAIL;
+    }
+  }
+
+  //
+  // Write out an X-Mozilla-Status header.
+  //
+  // This is required for the queue file, so that we can overwrite it once
+  // the messages have been delivered, and so that the nsMsgMessageFlags::Queued bit
+  // is set.
+  //
+  // For FCC files, we don't necessarily need one, but we might as well put
+  // one in so that it's marked as read already.
+  //
+  //
+  // Need to add these lines for POP3 ONLY! IMAP servers will handle
+  // this status information for summary file regeneration for us.
+  if ((mode == nsMsgQueueForLater || mode == nsMsgSaveAsDraft ||
+       mode == nsMsgSaveAsTemplate || mode == nsMsgDeliverNow ||
+       mode == nsMsgSendUnsent || mode == nsMsgDeliverBackground) &&
+      folderIsLocal)
+  {
+    char       *buf = 0;
+    uint16_t   flags = 0;
+
+    // for save as draft and send later, we want to leave the message as unread.
+    // See Bug #198087
+    // Messages sent with mode nsMsgDeliverBackground must not have the Queued
+    // flag sent so that they get picked up by the background send function.
+    if (mode == nsMsgQueueForLater)
+      flags |= nsMsgMessageFlags::Queued;
+    else if (mode != nsMsgSaveAsDraft && mode != nsMsgDeliverBackground)
+      flags |= nsMsgMessageFlags::Read;
+    buf = PR_smprintf(X_MOZILLA_STATUS_FORMAT CRLF, flags);
+    if (buf)
+    {
+      uint32_t   len = PL_strlen(buf);
+      rv = tempOutfile->Write(buf, len, &n);
+      PR_Free(buf);
+      if (NS_FAILED(rv) || n != len)
+      {
+        status = NS_ERROR_FAILURE;
+        goto FAIL;
+      }
+    }
+
+    uint32_t flags2 = 0;
+    if (mode == nsMsgSaveAsTemplate)
+      flags2 |= nsMsgMessageFlags::Template;
+    if (mode == nsMsgDeliverNow || mode == nsMsgSendUnsent)
+    {
+      flags2 &= ~nsMsgMessageFlags::MDNReportNeeded;
+      flags2 |= nsMsgMessageFlags::MDNReportSent;
+    }
+    buf = PR_smprintf(X_MOZILLA_STATUS2_FORMAT CRLF, flags2);
+    if (buf)
+    {
+      uint32_t   len = PL_strlen(buf);
+      rv = tempOutfile->Write(buf, len, &n);
+      PR_Free(buf);
+      if (NS_FAILED(rv) || n != len)
+      {
+        status = NS_ERROR_FAILURE;
+        goto FAIL;
+      }
+    }
+    tempOutfile->Write(X_MOZILLA_KEYWORDS, sizeof(X_MOZILLA_KEYWORDS) - 1, &n);
+  }
+
+  // Write out the FCC and BCC headers.
+  // When writing to the Queue file, we *must* write the FCC and BCC
+  // headers, or else that information would be lost.  Because, when actually
+  // delivering the message (with "deliver now") we do FCC/BCC right away;
+  // but when queueing for later delivery, we do FCC/BCC at delivery-time.
+  //
+  // The question remains of whether FCC and BCC should be written into normal
+  // BCC folders (like the Sent Mail folder.)
+  //
+  // For FCC, there seems no point to do that; it's not information that one
+  // would want to refer back to.
+  //
+  // For BCC, the question isn't as clear.  On the one hand, if I send someone
+  // a BCC'ed copy of the message, and save a copy of it for myself (with FCC)
+  // I might want to be able to look at that message later and see the list of
+  // people to whom I had BCC'ed it.
+  //
+  // On the other hand, the contents of the BCC header is sensitive
+  // information, and should perhaps not be stored at all.
+  //
+  // Thus the consultation of the #define SAVE_BCC_IN_FCC_FILE.
+  //
+  // (Note that, if there is a BCC header present in a message in some random
+  // folder, and that message is forwarded to someone, then the attachment
+  // code will strip out the BCC header before forwarding it.)
+  //
+  if ((mode == nsMsgQueueForLater || mode == nsMsgDeliverBackground ||
+       mode == nsMsgSaveAsDraft || mode == nsMsgSaveAsTemplate) &&
+      fcc_header && *fcc_header)
+  {
+    int32_t L = PL_strlen(fcc_header) + 20;
+    char  *buf = (char *) PR_Malloc (L);
+    if (!buf)
+    {
+      status = NS_ERROR_OUT_OF_MEMORY;
+      goto FAIL;
+    }
+
+    PR_snprintf(buf, L-1, "FCC: %s" CRLF, fcc_header);
+
+    uint32_t   len = PL_strlen(buf);
+    rv = tempOutfile->Write(buf, len, &n);
+    if (NS_FAILED(rv) || n != len)
+    {
+      status = NS_ERROR_FAILURE;
+      goto FAIL;
+    }
+  }
+
+  //
+  // Ok, now I want to get the identity key and write it out if this is for a
+  // nsMsgQueueForLater operation!
+  //
+  if ((nsMsgQueueForLater == mode || nsMsgSaveAsDraft == mode ||
+       nsMsgDeliverBackground == mode || nsMsgSaveAsTemplate == mode) &&
+      mUserIdentity)
+  {
+    char *buf = nullptr;
+    nsCString key;
+
+    if (NS_SUCCEEDED(mUserIdentity->GetKey(key)) && !key.IsEmpty())
+    {
+      buf = PR_smprintf(HEADER_X_MOZILLA_IDENTITY_KEY ": %s" CRLF, key.get());
+      if (buf)
+      {
+        uint32_t len = strlen(buf);
+        rv = tempOutfile->Write(buf, len, &n);
+        PR_Free(buf);
+        if (NS_FAILED(rv) || n != len)
+        {
+          status = NS_ERROR_FAILURE;
+          goto FAIL;
+        }
+      }
+    }
+
+    if (!mAccountKey.IsEmpty())
+    {
+      buf = PR_smprintf(HEADER_X_MOZILLA_ACCOUNT_KEY ": %s" CRLF, mAccountKey.get());
+      if (buf)
+      {
+        uint32_t len = strlen(buf);
+        rv = tempOutfile->Write(buf, len, &n);
+        PR_Free(buf);
+        if (NS_FAILED(rv) || n != len)
+        {
+          status = NS_ERROR_FAILURE;
+          goto FAIL;
+        }
+      }
+    }
+  }
+
+  if (bcc_header && *bcc_header
+#ifndef SAVE_BCC_IN_FCC_FILE
+      && (mode == MSG_QueueForLater || mode == MSG_SaveAsDraft ||
+          mode == MSG_SaveAsTemplate)
+#endif
+    )
+  {
+    char *convBcc;
+    convBcc = nsMsgI18NEncodeMimePartIIStr(bcc_header, true,
+                    mCompFields->GetCharacterSet(), sizeof("BCC: "),
+                    nsMsgMIMEGetConformToStandard());
+
+    int32_t L = strlen(convBcc ? convBcc : bcc_header) + 20;
+    char *buf = (char *) PR_Malloc (L);
+    if (!buf)
+    {
+      status = NS_ERROR_OUT_OF_MEMORY;
+      goto FAIL;
+    }
+
+    PR_snprintf(buf, L-1, "BCC: %s" CRLF, convBcc ? convBcc : bcc_header);
+    uint32_t   len = strlen(buf);
+    rv = tempOutfile->Write(buf, len, &n);
+    PR_Free(buf);
+    PR_Free(convBcc);
+    if (NS_FAILED(rv) || n != len)
+    {
+      status = NS_ERROR_FAILURE;
+      goto FAIL;
+    }
+  }
+
+  //
+  // Write out the X-Mozilla-News-Host header.
+  // This is done only when writing to the queue file, not the FCC file.
+  // We need this to complement the "Newsgroups" header for the case of
+  // queueing a message for a non-default news host.
+  //
+  // Convert a URL like "snews://host:123/" to the form "host:123/secure"
+  // or "news://user@host:222" to simply "host:222".
+  //
+  if ((mode == nsMsgQueueForLater || mode == nsMsgSaveAsDraft ||
+       mode == nsMsgSaveAsTemplate || mode == nsMsgDeliverBackground) &&
+      news_url && *news_url)
+  {
+    bool secure_p = (news_url[0] == 's' || news_url[0] == 'S');
+    char *orig_hap = nsMsgParseURLHost (news_url);
+    char *host_and_port = orig_hap;
+    if (host_and_port)
+    {
+      // There may be authinfo at the front of the host - it could be of
+      // the form "user:password@host:port", so take off everything before
+      // the first at-sign.  We don't want to store authinfo in the queue
+      // folder, I guess, but would want it to be re-prompted-for at
+      // delivery-time.
+      //
+      char *at = PL_strchr (host_and_port, '@');
+      if (at)
+        host_and_port = at + 1;
+    }
+
+    if ((host_and_port && *host_and_port) || !secure_p)
+    {
+      char *line = PR_smprintf(X_MOZILLA_NEWSHOST ": %s%s" CRLF,
+                   host_and_port ? host_and_port : "",
+                   secure_p ? "/secure" : "");
+      PR_FREEIF(orig_hap);
+      if (!line)
+      {
+        status = NS_ERROR_OUT_OF_MEMORY;
+        goto FAIL;
+      }
+
+      uint32_t   len = PL_strlen(line);
+      rv = tempOutfile->Write(line, len, &n);
+      PR_Free(line);
+      if (NS_FAILED(rv) || n != len)
+      {
+        status = NS_ERROR_FAILURE;
+        goto FAIL;
+      }
+    }
+
+    PR_Free(orig_hap);
+  }
+
+  //
+  // Read from the message file, and write to the FCC or Queue file.
+  // There are two tricky parts: the first is that the message file
+  // uses CRLF, and the FCC file should use LINEBREAK.  The second
+  // is that the message file may have lines beginning with "From "
+  // but the FCC file must have those lines mangled.
+  //
+  // It's unfortunate that we end up writing the FCC file a line
+  // at a time, but it's the easiest way...
+  //
+  uint64_t available;
+  rv = inputFile->Available(&available);
+  NS_ENSURE_SUCCESS(rv, rv);
+  while (available > 0)
+  {
+    // check *ibuffer in case that ibuffer isn't big enough
+    uint32_t readCount;
+    rv = inputFile->Read(ibuffer, ibuffer_size, &readCount);
+    if (NS_FAILED(rv) || readCount == 0 || *ibuffer == 0)
+    {
+      status = NS_ERROR_FAILURE;
+      goto FAIL;
+    }
+
+    rv = tempOutfile->Write(ibuffer, readCount, &n);
+    if (NS_FAILED(rv) || n != readCount) // write failed
+    {
+      status = NS_MSG_ERROR_WRITING_FILE;
+      goto FAIL;
+    }
+
+    rv = inputFile->Available(&available);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+FAIL:
+  PR_Free(ibuffer);
+
+  if (NS_FAILED(tempOutfile->Flush()))
+    status = NS_MSG_ERROR_WRITING_FILE;
+
+  tempOutfile->Close();
+
+  if (inputFile)
+    inputFile->Close();
+
+
+  // here we should clone mCopyFile, since it has changed on disk.
+  nsCOMPtr <nsIFile> clonedFile;
+  mCopyFile->Clone(getter_AddRefs(clonedFile));
+  mCopyFile = clonedFile;
+
+  // When we get here, we have to see if we have been successful so far.
+  // If we have, then we should start up the async copy service operation.
+  // If we weren't successful, then we should just return the error and
+  // bail out.
+  if (NS_SUCCEEDED(status))
+  {
+    // If we are here, time to start the async copy service operation!
+    status = StartMessageCopyOperation(mCopyFile, mode, turi);
+  }
+  return status;
+}
+
+//
+// This is pretty much a wrapper to the functionality that lives in the
+// nsMsgCopy class
+//
+nsresult
+nsMsgComposeAndSend::StartMessageCopyOperation(nsIFile          *aFile,
+                                               nsMsgDeliverMode mode,
+                                               const nsCString& dest_uri)
+{
+  mCopyObj = new nsMsgCopy();
+  if (!mCopyObj)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  //
+  // Actually, we need to pick up the proper folder from the prefs and not
+  // default to the default "Flagged" folder choices
+  //
+  nsresult    rv;
+  if (!dest_uri.IsEmpty())
+    m_folderName = dest_uri;
+  else
+    GetFolderURIFromUserPrefs(mode, mUserIdentity, m_folderName);
+
+  if (mListener)
+    mListener->OnGetDraftFolderURI(m_folderName.get());
+
+  rv = mCopyObj->StartCopyOperation(mUserIdentity, aFile, mode,
+                                    this, m_folderName.get(), mMsgToReplace);
+  return rv;
+}
+
+//I'm getting this each time without holding onto the feedback so that 3 pane windows can be closed
+//without any chance of crashing due to holding onto a deleted feedback.
+nsresult
+nsMsgComposeAndSend::SetStatusMessage(const nsString &aMsgString)
+{
+  if (mSendProgress)
+    mSendProgress->OnStatusChange(nullptr, nullptr, NS_OK, aMsgString.get());
+  return NS_OK;
+}
+
+// For GUI notification...
+nsresult
+nsMsgComposeAndSend::SetGUINotificationState(bool aEnableFlag)
+{
+  mGUINotificationEnabled = aEnableFlag;
+  return NS_OK;
+}
+
+/* readonly attribute nsIMsgSendReport sendReport; */
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetSendReport(nsIMsgSendReport * *aSendReport)
+{
+  NS_ENSURE_ARG_POINTER(aSendReport);
+  NS_IF_ADDREF(*aSendReport = mSendReport);
+  return NS_OK;
+}
+
+nsresult nsMsgComposeAndSend::Abort()
+{
+  uint32_t i;
+  nsresult rv;
+
+  if (mAbortInProcess)
+    return NS_OK;
+
+  mAbortInProcess = true;
+
+  if (m_plaintext)
+    rv = m_plaintext->Abort();
+
+  for (i = 0; i < m_attachment_count; i ++)
+  {
+    nsMsgAttachmentHandler *ma = m_attachments[i];
+    if (ma)
+      rv = ma->Abort();
+  }
+
+  /* stop the current running url */
+  if (mRunningRequest)
+  {
+    mRunningRequest->Cancel(NS_ERROR_ABORT);
+    mRunningRequest = nullptr;
+  }
+
+  if (mCopyObj)
+  {
+    nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    copyService->NotifyCompletion(mCopyFile, mCopyObj->mDstFolder, NS_ERROR_ABORT);
+  }
+  mAbortInProcess = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetProcessAttachmentsSynchronously(bool *_retval)
+{
+  NS_ENSURE_ARG(_retval);
+  *_retval = m_be_synchronous_p;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetAttachmentHandlers(nsTArray<RefPtr<nsMsgAttachmentHandler>> **_retval)
+{
+  NS_ENSURE_ARG(_retval);
+  *_retval = &m_attachments;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetAttachmentCount(uint32_t *aAttachmentCount)
+{
+  NS_ENSURE_ARG(aAttachmentCount);
+  *aAttachmentCount = m_attachment_count;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetPendingAttachmentCount(uint32_t *aPendingAttachmentCount)
+{
+  NS_ENSURE_ARG(aPendingAttachmentCount);
+  *aPendingAttachmentCount = m_attachment_pending_count;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeAndSend::SetPendingAttachmentCount(uint32_t aPendingAttachmentCount)
+{
+  m_attachment_pending_count = aPendingAttachmentCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetDeliveryMode(nsMsgDeliverMode *aDeliveryMode)
+{
+  NS_ENSURE_ARG(aDeliveryMode);
+  *aDeliveryMode = m_deliver_mode;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetProgress(nsIMsgProgress **_retval)
+{
+  NS_ENSURE_ARG(_retval);
+  NS_IF_ADDREF(*_retval = mSendProgress);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetOutputStream(nsIOutputStream **_retval)
+{
+  NS_ENSURE_ARG(_retval);
+  NS_IF_ADDREF(*_retval = mOutputFile);
+  return NS_OK;
+}
+
+
+/* [noscript] attribute nsIURI runningURL; */
+NS_IMETHODIMP nsMsgComposeAndSend::GetRunningRequest(nsIRequest **request)
+{
+  NS_ENSURE_ARG(request);
+  NS_IF_ADDREF(*request = mRunningRequest);
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgComposeAndSend::SetRunningRequest(nsIRequest *request)
+{
+  mRunningRequest = request;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetStatus(nsresult *aStatus)
+{
+  NS_ENSURE_ARG(aStatus);
+  *aStatus = m_status;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::SetStatus(nsresult aStatus)
+{
+  m_status = aStatus;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::GetCryptoclosure(nsIMsgComposeSecure ** aCryptoclosure)
+{
+  NS_ENSURE_ARG(aCryptoclosure);
+  NS_IF_ADDREF(*aCryptoclosure = m_crypto_closure);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgComposeAndSend::SetCryptoclosure(nsIMsgComposeSecure * aCryptoclosure)
+{
+  m_crypto_closure = aCryptoclosure;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetSendCompFields(nsIMsgCompFields** aCompFields)
+{
+  NS_ENSURE_ARG_POINTER(aCompFields);
+  nsCOMPtr<nsIMsgCompFields> qiCompFields(mCompFields);
+  NS_ENSURE_STATE(qiCompFields);
+  qiCompFields.forget(aCompFields);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetSendBody(nsAString& aBody)
+{
+  nsCString charSet;
+  if (mCompFields)
+    mCompFields->GetCharacterSet(getter_Copies(charSet));
+  if (!m_attachment1_body) {
+    aBody.Truncate();
+    return NS_OK;
+  }
+  return ConvertToUnicode(charSet.get(), m_attachment1_body, aBody);
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetSendBodyType(nsACString& aBodyType)
+{
+  if (m_attachment1_type && *m_attachment1_type)
+    aBodyType.Assign(nsDependentCString(m_attachment1_type));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetIdentity(nsIMsgIdentity **aIdentity)
+{
+  NS_ENSURE_ARG_POINTER(aIdentity);
+  *aIdentity = mUserIdentity;
+  NS_IF_ADDREF(*aIdentity);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetAttachment(uint32_t aIndex,
+                                   nsIMsgAttachmentHandler **aAttachment)
+{
+  NS_ENSURE_ARG_POINTER(aAttachment);
+  if (aIndex >= m_attachment_count)
+    return NS_ERROR_ILLEGAL_VALUE;
+  *aAttachment = m_attachments[aIndex];
+  NS_IF_ADDREF(*aAttachment);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::SetSavedToFolderName(const nsAString& aName)
+{
+  mSavedToFolderName.Assign(aName);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetSavedToFolderName(nsAString& aName)
+{
+  aName.Assign(mSavedToFolderName);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgComposeAndSend::SetDontDeliver(bool aDontDeliver)
+{
+  m_dont_deliver_p = aDontDeliver;
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsMsgComposeAndSend::GetDontDeliver(bool *aDontDeliver)
+{
+  NS_ENSURE_ARG_POINTER(aDontDeliver);
+  *aDontDeliver = m_dont_deliver_p;
+  return NS_OK;
+}
+
+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;
+}
+
+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/mailnews/compose/src/nsMsgSend.h b/mailnews/compose/src/nsMsgSend.h
new file mode 100644
index 000000000..558c8e53e
--- /dev/null
+++ b/mailnews/compose/src/nsMsgSend.h
@@ -0,0 +1,405 @@
+/* -*- 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 __MSGSEND_H__
+#define __MSGSEND_H__
+
+/* Asynchronous mailing of messages with attached URLs.
+
+   - If there are any attachments, start their URLs going, and write each
+     of them to a temp file.
+
+   - While writing to their files, examine the data going by and decide
+     what kind of encoding, if any, they need.  Also remember their content
+     types.
+
+   - Once that URLs has been saved to a temp file (or, if there were no
+     attachments) generate a final temp file, of the actual message:
+
+   -  Generate a string of the headers.
+   -  Open the final temp file.
+   -  Write the headers.
+     -  Examine the first part, and decide whether to encode it.
+   -  Write the first part to the file, possibly encoded.
+   -  Write the second and subsequent parts to the file, possibly encoded.
+        (Open the first temp file and copy it to the final temp file, and so
+         on, through an encoding filter.)
+
+   - Delete the attachment temp file(s) as we finish with them.
+   - Close the final temp file.
+   - Open the news: url.
+   - Send the final temp file to NNTP.
+     If there's an error, run the callback with "failure" status.
+   - If mail succeeded, open the mailto: url.
+   - Send the final temp file to SMTP.
+     If there's an error, run the callback with "failure" status.
+   - Otherwise, run the callback with "success" status.
+   - Free everything, delete the final temp file.
+
+  The theory behind the encoding logic:
+  =====================================
+
+  If the document is of type text/html, and the user has asked to attach it
+  as source or postscript, it will be run through the appropriate converter
+  (which will result in a document of type text/plain.)
+
+  An attachment will be encoded if:
+
+   - it is of a non-text type (in which case we will use base64); or
+   - The "use QP" option has been selected and high-bit characters exist; or
+   - any NULLs exist in the document; or
+   - any line is longer than 990 bytes (see LINELENGTH_ENCODING_THRESHOLD below)
+     and it is not of type message/rfc822.
+
+   - If we are encoding, and more than 10% of the document consists of
+     non-ASCII characters, then we always use base64 instead of QP.
+
+  We eschew quoted-printable in favor of base64 for documents which are likely
+  to always be binary (images, sound) because, on the off chance that a GIF
+  file (for example) might contain primarily bytes in the ASCII range, using
+  the quoted-printable representation might cause corruption due to the
+  translation of CR or LF to CRLF.  So, when we don't know that the document
+  has "lines", we don't use quoted-printable.
+ */
+
+/* For maximal compatibility, it helps to emit both
+      Content-Type: <type>; name="<original-file-name>"
+   as well as
+      Content-Disposition: inline; filename="<original-file-name>"
+
+  The lossage here is, RFC1341 defined the "name" parameter to Content-Type,
+  but then RFC1521 deprecated it in anticipation of RFC1806, which defines
+  Content-Type and the "filename" parameter.  But, RFC1521 is "Standards Track"
+  while RFC1806 is still "Experimental."  So, it's probably best to just
+  implement both.
+ */
+#define EMIT_NAME_IN_CONTENT_TYPE
+
+/* Whether the contents of the BCC header should be preserved in the FCC'ed
+   copy of a message.  See comments below, in mime_do_fcc_1().
+ */
+#define SAVE_BCC_IN_FCC_FILE
+
+/* When attaching an HTML document, one must indicate the original URL of
+   that document, if the receiver is to have any chance of being able to
+   retreive and display the inline images, or to click on any links in the
+   HTML.
+
+   The way we have done this in the past is by inserting a <BASE> tag as the
+   first line of all HTML documents we attach.  (This is kind of bad in that
+   we're actually modifying the document, and it really isn't our place to
+   do that.)
+
+   The sanctioned *new* way of doing this is to insert a Content-Base header
+   field on the attachment.  This is (will be) a part of the forthcoming MHTML
+   spec.
+
+   If GENERATE_CONTENT_BASE, we generate a Content-Base header.
+
+   We used to have a MANGLE_HTML_ATTACHMENTS_WITH_BASE_TAG symbol that we
+   defined, which added a BASE tag to the bodies.  We stopped doing this in
+   4.0.  */
+#define GENERATE_CONTENT_BASE
+
+
+//
+// Necessary includes
+//
+#include "nsCOMPtr.h"
+#include "nsIMsgSend.h"
+#include "nsIStringBundle.h"
+#include "msgCore.h"
+#include "prprf.h"
+#include "nsIOutputStream.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIURL.h"
+#include "nsMsgAttachmentHandler.h"
+#include "nsMsgCompFields.h"
+#include "nsIMsgSendListener.h"
+#include "nsIDOMNode.h"
+#include "nsIEditor.h"
+#include "nsIUrlListener.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsIMsgIdentity.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgIdentity.h"
+#include "nsWeakReference.h"
+#include "nsPIDOMWindow.h"
+#include "nsIDOMWindow.h"
+#include "nsIMsgComposeSecure.h"
+#include "nsAutoPtr.h"
+#include "nsMsgAttachmentData.h"
+#include "nsIMsgFilterService.h"
+#include "nsIMsgOperationListener.h"
+
+//
+// Some necessary defines...
+//
+#define MIME_BUFFER_SIZE      4096 // must be greater than 1000
+                                   // SMTP (RFC821) limit
+// Maximum number of bytes we allow in a line before we force
+// encoding to base64 if not already QR-encoded or of type message/rfc822.
+#define LINELENGTH_ENCODING_THRESHOLD 990
+
+//
+// Utilities for string handling
+//
+#define PUSH_STRING(S) \
+ do { PL_strcpy (buffer_tail, S); buffer_tail += PL_strlen (S); } while(0)
+#define PUSH_STRINGN(S,N) \
+ do { memcpy(buffer_tail, (S), (N)); buffer_tail += (N); } while(0)
+#define PUSH_NEWLINE() \
+ do { *buffer_tail++ = '\r'; *buffer_tail++ = '\n'; *buffer_tail = '\0'; } while(0)
+
+//
+// Forward declarations...
+//
+class nsMsgSendPart;
+class nsMsgCopy;
+class nsIPrompt;
+class nsIInterfaceRequestor;
+
+namespace mozilla {
+namespace mailnews {
+class MimeEncoder;
+}
+}
+
+class nsMsgComposeAndSend : public nsIMsgSend,
+                            public nsIMsgOperationListener,
+                            public nsSupportsWeakReference
+{
+  typedef mozilla::mailnews::MimeEncoder MimeEncoder;
+public:
+  //
+  // Define QueryInterface, AddRef and Release for this class
+  //
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIMSGSEND
+  NS_DECL_NSIMSGOPERATIONLISTENER
+
+  nsMsgComposeAndSend();
+
+
+  // Delivery and completion callback routines...
+  NS_IMETHOD  DeliverMessage();
+  NS_IMETHOD  DeliverFileAsMail();
+  NS_IMETHOD  DeliverFileAsNews();
+  void        DoDeliveryExitProcessing(nsIURI * aUrl, nsresult aExitCode, bool aCheckForMail);
+  nsresult    FormatStringWithSMTPHostNameByName(const char16_t* aMsgName, char16_t **aString);
+
+  nsresult    DoFcc();
+  nsresult    StartMessageCopyOperation(nsIFile          *aFileSpec,
+                                        nsMsgDeliverMode mode,
+                                        const nsCString& dest_uri);
+
+
+  nsresult SendToMagicFolder(nsMsgDeliverMode flag);
+
+  // Check to see if it's ok to save msgs to the configured folder.
+  bool CanSaveMessagesToFolder(const char *folderURL);
+
+  //
+  // FCC operations...
+  //
+  nsresult    MimeDoFCC (nsIFile *input_file,
+    nsMsgDeliverMode mode,
+    const char *bcc_header,
+    const char *fcc_header,
+    const char *news_url);
+
+  // Init() will allow for either message creation without delivery or full
+  // message creation and send operations
+  //
+  nsresult    Init(
+                   nsIMsgIdentity   *aUserIdentity,
+                   const char       *aAccountKey,
+                   nsMsgCompFields  *fields,
+                   nsIFile          *sendFile,
+                   bool             digest_p,
+                   bool             dont_deliver_p,
+                   nsMsgDeliverMode mode,
+                   nsIMsgDBHdr      *msgToReplace,
+                   const char       *attachment1_type,
+                   const nsACString &attachment1_body,
+                   nsIArray   *attachments,
+                   nsIArray     *preloaded_attachments,
+                   const char       *password,
+                   const nsACString &aOriginalMsgURI,
+                   MSG_ComposeType  aType);
+
+  //
+  // Setup the composition fields
+  //
+  nsresult    InitCompositionFields(nsMsgCompFields *fields,
+                                    const nsACString &aOriginalMsgURI,
+                                    MSG_ComposeType aType);
+
+  NS_IMETHOD  GetBodyFromEditor();
+
+
+  //
+  // Attachment processing...
+  //
+  nsresult    HackAttachments(nsIArray *attachments,
+                              nsIArray *preloaded_attachments);
+  nsresult    CountCompFieldAttachments();
+  nsresult    AddCompFieldLocalAttachments();
+  nsresult    AddCompFieldRemoteAttachments(uint32_t  aStartLocation, int32_t *aMailboxCount, int32_t *aNewsCount);
+
+  // Deal with multipart related data
+  nsresult    ProcessMultipartRelated(int32_t *aMailboxCount, int32_t *aNewsCount);
+  nsresult    GetEmbeddedObjectInfo(nsIDOMNode *node, nsMsgAttachmentData *attachment, bool *acceptObject);
+  uint32_t    GetMultipartRelatedCount(bool forceToBeCalculated = false);
+  nsCOMPtr<nsIArray> mEmbeddedObjectList; // it's initialized when calling GetMultipartRelatedCount
+
+  // Body processing
+  nsresult    SnarfAndCopyBody(const nsACString &attachment1_body,
+                               const char  *attachment1_type);
+
+  int32_t     PreProcessPart(nsMsgAttachmentHandler  *ma,
+                             nsMsgSendPart           *toppart); // The very top most container of the message
+                                                                // For part processing
+
+  nsresult    SetStatusMessage(const nsString &aMsgString);     // Status message method
+
+  //
+  // All vars necessary for this implementation
+  //
+  nsMsgKey                  m_messageKey;        // jt -- Draft/Template support; newly created key
+  nsCOMPtr<nsIMsgIdentity>  mUserIdentity;
+  nsCString                 mAccountKey;
+  RefPtr<nsMsgCompFields> mCompFields;         // All needed composition fields (header, etc...)
+  nsCOMPtr<nsIFile>         mTempFile;           // our temporary file
+
+  nsCOMPtr<nsIOutputStream> mOutputFile;         // the actual output file stream
+  uint32_t                  mMessageWarningSize; // Warn if a message is over this size!
+
+  bool                      m_dont_deliver_p;    // If set, we just return the nsIFile of the file
+                                                 // created, instead of actually delivering message.
+  nsMsgDeliverMode          m_deliver_mode;      // nsMsgDeliverNow, nsMsgQueueForLater, nsMsgSaveAsDraft,
+                                                 // nsMsgSaveAsTemplate and nsMsgSendUnsent
+  nsCOMPtr<nsIMsgDBHdr>     mMsgToReplace;       // If the mode is nsMsgSaveAsDraft, this is the message it will
+                                                 // replace
+  nsString mSavedToFolderName; // Name of folder we're saving to, used when
+                               // displaying error on save.
+  // These are needed for callbacks to the FE...
+  nsCOMPtr<nsPIDOMWindowOuter>    mParentWindow;
+  nsCOMPtr<nsIMsgProgress>        mSendProgress;
+  nsCOMPtr<nsIMsgSendListener>    mListener;
+  nsCOMPtr<nsIMsgStatusFeedback>  mStatusFeedback;
+  nsCOMPtr<nsIRequest>      mRunningRequest;
+  bool                      mSendMailAlso;
+  nsCOMPtr<nsIFile>         mReturnFile;     // a holder for file spec's to be returned to caller
+
+  // File where we stored our HTML so that we could make the plaintext form.
+  nsCOMPtr<nsIFile>         mHTMLFile;
+
+  // Variable for storing the draft name;
+  nsCString                  m_folderName;
+
+  // mapping between editor dom node indexes and saved mime part numbers.
+  nsTArray<nsCString> m_partNumbers;
+  //
+  // These variables are needed for message Copy operations!
+  //
+  nsCOMPtr<nsIFile>         mCopyFile;
+  nsCOMPtr<nsIFile>         mCopyFile2;
+  RefPtr<nsMsgCopy>       mCopyObj;
+  bool                      mNeedToPerformSecondFCC;
+  bool                      mPerformingSecondFCC;
+
+  // For MHTML message creation
+  nsCOMPtr<nsIEditor>       mEditor;
+
+  //
+  // The first attachment, if any (typed in by the user.)
+  //
+  char                    *m_attachment1_type;
+  char                    *m_attachment1_encoding;
+  nsAutoPtr<MimeEncoder>  m_attachment1_encoder;
+  char                    *m_attachment1_body;
+  uint32_t                m_attachment1_body_length;
+  char                    *mOriginalHTMLBody;
+
+  // The plaintext form of the first attachment, if needed.
+  RefPtr<nsMsgAttachmentHandler>  m_plaintext;
+
+  // The multipart/related save object for HTML text.
+  nsMsgSendPart           *m_related_part;
+  nsMsgSendPart           *m_related_body_part;
+
+  //
+  // Subsequent attachments, if any.
+  //
+  uint32_t                m_attachment_count;
+  uint32_t                m_attachment_pending_count;
+  nsTArray< RefPtr<nsMsgAttachmentHandler> >  m_attachments;
+  nsresult                m_status; // in case some attachments fail but not all
+
+  uint32_t                mPreloadedAttachmentCount;
+  uint32_t                mRemoteAttachmentCount;
+  int32_t                 mMultipartRelatedAttachmentCount; // the number of mpart related attachments, -1 means it has not been yet initialized
+
+  uint32_t                mCompFieldLocalAttachments;     // the number of file:// attachments in the comp fields
+  uint32_t                mCompFieldRemoteAttachments;    // the number of remote attachments in the comp fields
+
+  //
+  // attachment states and other info...
+  //
+  bool                    m_pre_snarfed_attachments_p;  // If true, then the attachments were
+                                                        // loaded by in the background and therefore
+                                                        // we shouldn't delete the tmp files (but should
+                                                        // leave that to the caller.)
+
+  bool                    m_digest_p;                   // Whether to be multipart/digest instead of
+                                                        // multipart/mixed.
+
+  bool                    m_be_synchronous_p;            // If true, we will load one URL after another,
+                                                        // rather than starting all URLs going at once
+                                                        // and letting them load in parallel.  This is
+                                                        // more efficient if (for example) all URLs are
+                                                        // known to be coming from the same news server
+                                                        // or mailbox: loading them in parallel would
+                                                        // cause multiple connections to the news
+                                                        // server to be opened, or would cause much seek()ing.
+
+  bool                    mGUINotificationEnabled;      // Should we throw up the GUI alerts on errors?
+  bool                    mAbortInProcess;              // Used by Abort to avoid reentrance.
+
+  nsCOMPtr<nsIMsgComposeSecure> m_crypto_closure;
+
+protected:
+  nsCOMPtr<nsIStringBundle> mComposeBundle;
+  nsresult GetNotificationCallbacks(nsIInterfaceRequestor** aCallbacks);
+
+  virtual ~nsMsgComposeAndSend();
+  nsresult FilterSentMessage();
+  nsresult MaybePerformSecondFCC(nsresult aStatus);
+
+  // generates a message id for our message, if necessary
+  void GenerateMessageId( );
+
+  // add default custom headers to the message
+  nsresult AddDefaultCustomHeaders();
+
+  // add Mail-Followup-To and Mail-Reply-To header
+  nsresult AddMailFollowupToHeader();
+  nsresult AddMailReplyToHeader();
+  nsresult AddXForwardedMessageIdHeader();
+
+  nsCOMPtr<nsIMsgSendReport>  mSendReport;
+  nsCString                   mSmtpPassword;            // store the smtp Password use during a send
+};
+
+//
+// These C routines should only be used by the nsMsgSendPart class.
+//
+extern nsresult mime_write_message_body(nsIMsgSend *state, const char *buf, uint32_t size);
+extern char   *mime_get_stream_write_buffer(void);
+extern nsresult mime_encoder_output_fn (const char *buf, int32_t size, void *closure);
+extern bool UseQuotedPrintable(void);
+
+#endif /*  __MSGSEND_H__ */
diff --git a/mailnews/compose/src/nsMsgSendLater.cpp b/mailnews/compose/src/nsMsgSendLater.cpp
new file mode 100644
index 000000000..97206f12b
--- /dev/null
+++ b/mailnews/compose/src/nsMsgSendLater.cpp
@@ -0,0 +1,1552 @@
+/* -*- 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 "nsMsgCopy.h"
+#include "nsIMsgSend.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIMsgMessageService.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgCompCID.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 "nsMsgMimeCID.h"
+#include "nsComposeStrings.h"
+#include "nsIMutableArray.h"
+#include "nsArrayEnumerator.h"
+#include "nsIObserverService.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgDatabase.h"
+#include "mozilla/Services.h"
+#include "nsArrayUtils.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;
+}
+
+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.
+  rv = GetUnsentMessagesFolder(nullptr, getter_AddRefs(mMessageFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mMessageFolder->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, "xpcom-shutdown"))
+  {
+    // 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)
+    {
+      rv = mMessageFolder->RemoveFolderListener(this);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    // 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, nsISupports *ctxt, 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<nsIPrompt> promptObject;
+    if (channel)
+    {
+      channel->GetURI(getter_AddRefs(uri));
+      nsCOMPtr<nsISmtpUrl> smtpUrl (do_QueryInterface(uri));
+      if (smtpUrl)
+        smtpUrl->GetPrompt(getter_AddRefs(promptObject));
+    }
+    nsMsgDisplayMessageByName(promptObject, u"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...
+  NS_ENSURE_TRUE(mLeftoverBuffer, 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, nsISupports *ctxt, 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, nsISupports *ctxt)
+{
+  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 *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))
+      NS_RELEASE(mSendLater);
+
+  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)
+{
+  NS_NOTREACHED("SendOperationListener::SetMessageKey()");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+SendOperationListener::GetMessageId(nsACString& messageId)
+{
+  NS_NOTREACHED("SendOperationListener::GetMessageId()\n");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnStopCopy(nsresult aStatus)
+{
+  if (mSendLater)
+  {
+    mSendLater->OnCopyStepFinished(aStatus);
+    NS_RELEASE(mSendLater);
+  }
+
+  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 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(NS_MSGCOMPFIELDS_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIMsgSend> pMsgSend = do_CreateInstance(NS_MSGSEND_CONTRACTID, &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...
+  SendOperationListener *sendListener = new SendOperationListener(this);
+  if (!sendListener)
+    return NS_ERROR_OUT_OF_MEMORY;
+  
+  NS_ADDREF(sendListener);
+
+  NS_ADDREF(this);  //TODO: We should remove this!!!
+  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); 
+  NS_RELEASE(sendListener);
+  return rv;
+}
+
+nsresult
+nsMsgSendLater::StartNextMailFileSend(nsresult prevStatus)
+{
+  bool hasMoreElements = false;
+  if ((!mEnumerator) ||
+      NS_FAILED(mEnumerator->HasMoreElements(&hasMoreElements)) ||
+      !hasMoreElements)
+  {
+    // 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)
+    NotifyListenersOnProgress(mTotalSendCount, mMessagesToSend.Count(), 100, 100);
+
+  nsCOMPtr<nsISupports> currentItem;
+  nsresult rv = mEnumerator->GetNext(getter_AddRefs(currentItem));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mMessage = do_QueryInterface(currentItem); 
+  if (!mMessage)
+    return NS_ERROR_NOT_AVAILABLE;
+
+  if (!mMessageFolder)
+    return NS_ERROR_UNEXPECTED;
+
+  nsCString messageURI;
+  mMessageFolder->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;
+
+  ++mTotalSendCount;
+
+  nsCString identityKey;
+  rv = mMessage->GetStringProperty(HEADER_X_MOZILLA_IDENTITY_KEY,
+                                   getter_Copies(identityKey));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgIdentity> identity;
+  rv = GetIdentityFromKey(identityKey.get(), getter_AddRefs(identity));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // 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 DisplayMessage
+  // operation
+  AddRef();
+
+  nsCOMPtr<nsIURI> dummyNull;
+  rv = messageService->DisplayMessage(messageURI.get(),
+                                      static_cast<nsIStreamListener*>(this),
+                                      nullptr, nullptr, nullptr,
+                                      getter_AddRefs(dummyNull));
+
+  Release();
+
+  return rv;
+}
+
+NS_IMETHODIMP 
+nsMsgSendLater::GetUnsentMessagesFolder(nsIMsgIdentity *aIdentity, nsIMsgFolder **folder)
+{
+  nsCString uri;
+  GetFolderURIFromUserPrefs(nsIMsgSend::nsMsgQueueForLater, aIdentity, uri);
+  return LocateMessageFolder(aIdentity, nsIMsgSend::nsMsgQueueForLater,
+                             uri.get(), folder);
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::HasUnsentMessages(nsIMsgIdentity *aIdentity, bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+    do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIArray> accounts;
+  accountManager->GetAccounts(getter_AddRefs(accounts));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t cnt = 0;
+  rv = accounts->GetLength(&cnt);
+  if (cnt == 0) {
+    *aResult = false;
+    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)
+  {
+    rv = GetUnsentMessagesFolder(nullptr,
+                                 getter_AddRefs(mMessageFolder));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  rv = ReparseDBIfNeeded(nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t totalMessages;
+  rv = mMessageFolder->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_QueryInterface(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\n");
+    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)
+  {
+    rv = GetUnsentMessagesFolder(nullptr,
+                                 getter_AddRefs(mMessageFolder));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  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<nsISimpleEnumerator> enumerator;
+  rv = mMessageFolder->GetMessages(getter_AddRefs(enumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // copy all the elements in the enumerator into our isupports array....
+
+  nsCOMPtr<nsISupports> currentItem;
+  nsCOMPtr<nsIMsgDBHdr> messageHeader;
+  bool hasMoreElements = false;
+  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMoreElements)) && hasMoreElements)
+  {
+    rv = enumerator->GetNext(getter_AddRefs(currentItem));
+    if (NS_SUCCEEDED(rv))
+    {
+      messageHeader = do_QueryInterface(currentItem, &rv);
+      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);
+        }  
+      }
+    }
+  }
+
+  // Now get an enumerator for our array.
+  rv = NS_NewArrayEnumerator(getter_AddRefs(mEnumerator), mMessagesToSend);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // 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, getter_Copies(originalMsgURIs));
+  mMessage->GetStringProperty(QUEUED_DISPOSITION_PROPERTY, getter_Copies(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].get(), 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_Replied;
+          if (queuedDisposition.Equals("forwarded"))
+            dispositionSetting = nsIMsgFolder::nsMsgDispositionState_Forwarded;
+          
+          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
+  nsCOMPtr<nsIMutableArray> msgArray(do_CreateInstance(NS_ARRAY_CONTRACTID));
+  if (!msgArray)
+    return NS_ERROR_FACTORY_NOT_LOADED;
+
+  if (!mMessageFolder)
+    return NS_ERROR_UNEXPECTED;
+
+  msgArray->InsertElementAt(mMessage, 0, false);
+
+  nsresult res = mMessageFolder->DeleteMessages(msgArray, nullptr, true, false, nullptr, false /*allowUndo*/);
+  if (NS_FAILED(res))
+    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;
+        prune_p = true;
+      }
+      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(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();
+
+  // We don't need to keep hold of the database now we've finished sending.
+  (void)mMessageFolder->SetMsgDatabase(nullptr);
+
+  // or the enumerator, temp file or output stream
+  mEnumerator = nullptr;
+  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(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  if (aKey)
+  {
+    nsCOMPtr<nsIArray> identities;
+    if (NS_SUCCEEDED(accountManager->GetAllIdentities(getter_AddRefs(identities))))
+    {
+      nsCOMPtr<nsIMsgIdentity> lookupIdentity;
+      uint32_t count = 0;
+
+      identities->GetLength(&count);
+      for (uint32_t i = 0; i < count; i++)
+      {
+        lookupIdentity = do_QueryElementAt(identities, i, &rv);
+        if (NS_FAILED(rv))
+          continue;
+
+        nsCString key;
+        lookupIdentity->GetKey(key);
+        if (key.Equals(aKey))
+        {
+          NS_IF_ADDREF(*aIdentity = lookupIdentity);
+          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);
+  
+  rv = defaultAccount->GetDefaultIdentity(aIdentity);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemAdded(nsIMsgFolder *aParentItem, nsISupports *aItem)
+{
+  // 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::OnItemRemoved(nsIMsgFolder *aParentItem, nsISupports *aItem)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemPropertyChanged(nsIMsgFolder *aItem, nsIAtom *aProperty,
+                                      const char* aOldValue,
+                                      const char* aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemIntPropertyChanged(nsIMsgFolder *aItem, nsIAtom *aProperty,
+                                         int64_t aOldValue, int64_t aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemBoolPropertyChanged(nsIMsgFolder *aItem, nsIAtom *aProperty,
+                                          bool aOldValue, bool aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemUnicharPropertyChanged(nsIMsgFolder *aItem,
+                                             nsIAtom *aProperty,
+                                             const char16_t* aOldValue,
+                                             const char16_t* aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemPropertyFlagChanged(nsIMsgDBHdr *aItem, nsIAtom *aProperty,
+                                          uint32_t aOldValue, uint32_t aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemEvent(nsIMsgFolder* aItem, nsIAtom *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 = NS_LITERAL_STRING("Sending Messages");
+  return NS_OK;
+}
diff --git a/mailnews/compose/src/nsMsgSendLater.h b/mailnews/compose/src/nsMsgSendLater.h
new file mode 100644
index 000000000..734396acc
--- /dev/null
+++ b/mailnews/compose/src/nsMsgSendLater.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 _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 "nsIMsgShutdown.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:
+  SendOperationListener(nsMsgSendLater *aSendLater);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGSENDLISTENER
+  NS_DECL_NSIMSGCOPYSERVICELISTENER
+
+private:
+  virtual ~SendOperationListener();
+  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(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);
+
+  // counters and things for enumeration 
+  uint32_t                  mTotalSentSuccessfully;
+  uint32_t                  mTotalSendCount;
+  nsCOMArray<nsIMsgDBHdr> mMessagesToSend;
+  nsCOMPtr<nsISimpleEnumerator> mEnumerator;
+  nsCOMPtr<nsIMsgFolder>    mMessageFolder;
+  nsCOMPtr<nsIMsgStatusFeedback> mFeedback;
+ 
+  // Private Information
+private:
+  virtual ~nsMsgSendLater();
+  nsresult GetIdentityFromKey(const char *aKey, nsIMsgIdentity **aIdentity);
+  nsresult ReparseDBIfNeeded(nsIUrlListener *aListener);
+  nsresult InternalSendMessages(bool aUserInitiated,
+                                nsIMsgIdentity *aIdentity);
+
+  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/mailnews/compose/src/nsMsgSendPart.cpp b/mailnews/compose/src/nsMsgSendPart.cpp
new file mode 100644
index 000000000..a33dabf33
--- /dev/null
+++ b/mailnews/compose/src/nsMsgSendPart.cpp
@@ -0,0 +1,779 @@
+/* -*- 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 "nsMsgLocalFolderHdrs.h"
+#include "nsMsgSend.h"
+#include "nsMsgSendPart.h"
+#include "nsIMimeConverter.h"
+#include "nsCOMPtr.h"
+#include "nsIComponentManager.h"
+#include "nsMsgI18N.h"
+#include "nsMsgCompUtils.h"
+#include "nsMsgMimeCID.h"
+#include "nsMimeTypes.h"
+#include "prmem.h"
+#include "nsMsgPrompts.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsNetUtil.h"
+#include "nsISeekableStream.h"
+#include "nsReadLine.h"
+#include "nsILineInputStream.h"
+#include "nsComposeStrings.h"
+#include "mozilla/mailnews/MimeEncoder.h"
+
+static char *mime_mailto_stream_read_buffer = 0;
+
+int32_t nsMsgSendPart::M_counter = 0;
+
+nsMsgSendPart::nsMsgSendPart(nsIMsgSend* state, const char *part_charset)
+{
+  PL_strncpy(m_charset_name, (part_charset ? part_charset : "UTF-8"), sizeof(m_charset_name)-1);
+  m_charset_name[sizeof(m_charset_name)-1] = '\0';
+  m_children = nullptr;
+  m_numchildren = 0;
+  // if we're not added as a child, the default part number will be "1".
+  m_partNum = "1";
+  SetMimeDeliveryState(state);
+
+  m_parent = nullptr;
+  m_buffer = nullptr;
+  m_type = nullptr;
+  m_other = nullptr;
+  m_strip_sensitive_headers = false;
+  
+  m_firstBlock = false;
+  m_needIntlConversion = false;
+  
+  m_mainpart = false;
+  m_just_hit_CR = false;
+}
+
+
+nsMsgSendPart::~nsMsgSendPart()
+{
+  for (int i=0 ; i < m_numchildren; i++)
+    delete m_children[i];
+
+  delete [] m_children;
+    PR_FREEIF(m_buffer);
+  PR_FREEIF(m_other);
+  PR_FREEIF(m_type);
+}
+
+nsresult nsMsgSendPart::CopyString(char** dest, const char* src)
+{
+  NS_ASSERTION(src, "src null");
+  
+  PR_FREEIF(*dest);
+  if (!src)
+    *dest = PL_strdup("");
+  else
+    *dest = PL_strdup(src);
+  
+  return *dest? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+
+nsresult nsMsgSendPart::SetFile(nsIFile *file)
+{
+  m_file = file;
+  return NS_OK;
+}
+
+
+nsresult nsMsgSendPart::SetBuffer(const char* buffer)
+{
+  PR_FREEIF(m_buffer);
+  return CopyString(&m_buffer, buffer);
+}
+
+
+nsresult nsMsgSendPart::SetType(const char* type)
+{
+  PR_FREEIF(m_type);
+  m_type = PL_strdup(type);
+  return m_type ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+
+nsresult nsMsgSendPart::SetOtherHeaders(const char* other)
+{
+  return CopyString(&m_other, other);
+}
+
+nsresult nsMsgSendPart::SetMimeDeliveryState(nsIMsgSend *state)
+{
+  m_state = state;
+  if (GetNumChildren() > 0)
+  {
+    for (int i = 0; i < GetNumChildren(); i++)
+    {
+      nsMsgSendPart *part = GetChild(i);
+      if (part) 
+        part->SetMimeDeliveryState(state);
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgSendPart::AppendOtherHeaders(const char* more)
+{
+  if (!m_other)
+    return SetOtherHeaders(more);
+
+  if (!more || !*more)
+    return NS_OK;
+
+  char* tmp = (char *) PR_Malloc(sizeof(char) * (PL_strlen(m_other) + PL_strlen(more) + 2));
+  if (!tmp)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  PL_strcpy(tmp, m_other);
+  PL_strcat(tmp, more);
+  PR_FREEIF(m_other);
+  m_other = tmp;
+
+  return NS_OK;
+}
+
+
+nsresult nsMsgSendPart::SetMainPart(bool value)
+{
+  m_mainpart = value;
+  return NS_OK;
+}
+
+nsresult nsMsgSendPart::AddChild(nsMsgSendPart* child)
+{
+  m_numchildren++;
+  nsMsgSendPart** tmp = new nsMsgSendPart* [m_numchildren];
+  if (tmp == nullptr) return NS_ERROR_OUT_OF_MEMORY;
+  for (int i=0 ; i<m_numchildren-1 ; i++) {
+    tmp[i] = m_children[i];
+  }
+  delete [] m_children;
+  m_children = tmp;
+  m_children[m_numchildren - 1] = child;
+  child->m_parent = this;
+  nsCString partNum(m_partNum);
+  partNum.Append(".");
+  partNum.AppendInt(m_numchildren);
+  child->m_partNum = partNum;
+  return NS_OK;
+}
+
+nsMsgSendPart * nsMsgSendPart::DetachChild(int32_t whichOne)
+{
+  nsMsgSendPart *returnValue = nullptr;
+  
+  NS_ASSERTION(whichOne >= 0 && whichOne < m_numchildren, "parameter out of range");
+  if (whichOne >= 0 && whichOne < m_numchildren) 
+  {
+    returnValue = m_children[whichOne];
+    
+    if (m_numchildren > 1)
+    {
+      nsMsgSendPart** tmp = new nsMsgSendPart* [m_numchildren-1];
+      if (tmp != nullptr) 
+      {
+        // move all the other kids over
+        for (int i=0 ; i<m_numchildren-1 ; i++) 
+        {
+          if (i >= whichOne)
+            tmp[i] = m_children[i+1];
+          else
+            tmp[i] = m_children[i];
+        }
+        delete [] m_children;
+        m_children = tmp;
+        m_numchildren--;
+      }
+    }
+    else 
+    {
+      delete [] m_children;
+      m_children = nullptr;
+      m_numchildren = 0;
+    }
+  }
+  
+  if (returnValue)
+    returnValue->m_parent = nullptr;
+  
+  return returnValue;
+}
+
+nsMsgSendPart* nsMsgSendPart::GetChild(int32_t which)
+{
+  NS_ASSERTION(which >= 0 && which < m_numchildren, "parameter out of range");
+  if (which >= 0 && which < m_numchildren) {
+    return m_children[which];
+  }
+  return nullptr;
+}
+
+
+
+nsresult nsMsgSendPart::PushBody(const char* buffer, int32_t length)
+{
+  nsresult status = NS_OK;
+  const char* encoded_data = buffer;
+
+  if (m_encoder)
+  {
+    status = m_encoder->Write(encoded_data, length);
+  }
+  else
+  {
+    // Merely translate all linebreaks to CRLF.
+    const char *in = encoded_data;
+    const char *end = in + length;
+    char *buffer, *out;
+
+
+    buffer = mime_get_stream_write_buffer();
+    // XXX -1 is not a valid nsresult
+    NS_ENSURE_TRUE(buffer, static_cast<nsresult>(-1));
+
+    NS_ASSERTION(encoded_data != buffer, "encoded_data == buffer");
+    out = buffer;
+
+    for (; in < end; in++) {
+      if (m_just_hit_CR) {
+        m_just_hit_CR = false;
+        if (*in == '\n') {
+          // The last thing we wrote was a CRLF from hitting a CR.
+          // So, we don't want to do anything from a following LF;
+          // we want to ignore it.
+          continue;
+        }
+      }
+      if (*in == '\r' || *in == '\n') {
+        /* Write out the newline. */
+        *out++ = '\r';
+        *out++ = '\n';
+        
+        status = mime_write_message_body(m_state, buffer,
+          out - buffer);
+        if (NS_FAILED(status)) return status;
+        out = buffer;
+        
+        if (*in == '\r') {
+          m_just_hit_CR = true;
+        }
+        
+        out = buffer;
+      } else {
+        
+      /*  Fix for bug #95985. We can't assume that all lines are shorter
+      than 4096 chars (MIME_BUFFER_SIZE), so we need to test
+      for this here. sfraser.
+        */
+        if (out - buffer >= MIME_BUFFER_SIZE)
+        {
+          status = mime_write_message_body(m_state, buffer, out - buffer);
+          if (NS_FAILED(status)) return status;
+          
+          out = buffer;
+        }
+        
+        *out++ = *in;
+      }
+    }
+    
+    /* Flush the last line. */
+    if (out > buffer) {
+      status = mime_write_message_body(m_state, buffer, out - buffer);
+      if (NS_FAILED(status)) return status;
+      out = buffer;
+    }
+  }
+  
+  if (encoded_data && encoded_data != buffer) {
+    PR_Free((char *) encoded_data);
+  }
+  
+  return status;
+}
+
+
+/* Partition the headers into those which apply to the message as a whole;
+those which apply to the message's contents; and the Content-Type header
+itself.  (This relies on the fact that all body-related headers begin with
+"Content-".)
+
+  (How many header parsers are in this program now?)
+  */
+static nsresult
+divide_content_headers(const char *headers,
+                        char **message_headers,
+                        char **content_headers,
+                        char **content_type_header)
+{
+    const char *tail;
+    char *message_tail, *content_tail, *type_tail;
+    int L = 0;
+    if (headers)
+      L = PL_strlen(headers);
+    
+    if (L == 0)
+      return NS_OK;
+    
+    *message_headers = (char *)PR_Malloc(L+1);
+    if (!*message_headers)
+      return NS_ERROR_OUT_OF_MEMORY;
+    
+    *content_headers = (char *)PR_Malloc(L+1);
+    if (!*content_headers) {
+      PR_Free(*message_headers);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    
+    *content_type_header = (char *)PR_Malloc(L+1);
+    if (!*content_type_header) {
+      PR_Free(*message_headers);
+      PR_Free(*content_headers);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    
+    message_tail = *message_headers;
+    content_tail = *content_headers;
+    type_tail    = *content_type_header;
+    tail = headers;
+    
+    while (*tail)
+    {
+      const char *head = tail;
+      char **out;
+      while(true) {
+      /* Loop until we reach a newline that is not followed by whitespace.
+        */
+        if (tail[0] == 0 ||
+          ((tail[0] == '\r' || tail[0] == '\n') &&
+          !(tail[1] == ' ' || tail[1] == '\t' || tail[1] == '\n')))
+        {
+          /* Swallow the whole newline. */
+          if (tail[0] == '\r' && tail[1] == '\n')
+            tail++;
+          if (*tail)
+            tail++;
+          break;
+        }
+        tail++;
+      }
+      
+      /* Decide which block this header goes into.
+      */
+      if (!PL_strncasecmp(head, "Content-Type:", 13))
+        out = &type_tail;
+      else
+        if (!PL_strncasecmp(head, "Content-", 8))
+          out = &content_tail;
+        else
+          out = &message_tail;
+        
+        memcpy(*out, head, (tail-head));
+        *out += (tail-head);
+    }
+    
+    *message_tail = 0;
+    *content_tail = 0;
+    *type_tail = 0;
+    
+    if (!**message_headers) {
+      PR_Free(*message_headers);
+      *message_headers = 0;
+    }
+    
+    if (!**content_headers) {
+      PR_Free(*content_headers);
+      *content_headers = 0;
+    }
+    
+    if (!**content_type_header) {
+      PR_Free(*content_type_header);
+      *content_type_header = 0;
+    }
+    
+#ifdef DEBUG
+    // ### mwelch Because of the extreme difficulty we've had with
+    //      duplicate part headers, I'm going to put in an
+    //      ASSERT here which makes sure that no duplicate
+    //      Content-Type or Content-Transfer-Encoding headers
+    //      leave here undetected.
+    const char* tmp;
+    if (*content_type_header) {
+      tmp = PL_strstr(*content_type_header, "Content-Type");
+      if (tmp) {
+        tmp++; // get past the first occurrence
+        NS_ASSERTION(!PL_strstr(tmp, "Content-Type"), "Content-part already present");
+      }
+    }
+    
+    if (*content_headers) {
+      tmp = PL_strstr(*content_headers, "Content-Transfer-Encoding");
+      if (tmp) {
+        tmp++; // get past the first occurrence
+        NS_ASSERTION(!PL_strstr(tmp, "Content-Transfer-Encoding"), "Content-Transfert already present");
+      }
+    }
+#endif // DEBUG
+    
+    return NS_OK;
+}
+
+#define     SKIP_EMPTY_PART   1966
+
+nsresult
+nsMsgSendPart::Write()
+{
+  nsresult status = NS_OK;
+  char    *separator = nullptr;
+  bool    needToWriteCRLFAfterEncodedBody  = false;
+
+#define PUSHLEN(str, length)                  \
+  do {                            \
+    status = mime_write_message_body(m_state, str, length); \
+    if (NS_FAILED(status)) goto FAIL;                \
+  } while (0)                         \
+
+#define PUSH(str) PUSHLEN(str, PL_strlen(str))
+
+  // rhp: Suppress the output of parts that are empty!
+  if ( (m_parent) &&
+       (m_numchildren == 0) &&
+       ( (!m_buffer) || (!*m_buffer) ) &&
+       (!m_file) &&
+       (!m_mainpart) )
+    // XXX SKIP_EMPTY_PART (= 1966) is not a valid nsresult
+    return static_cast<nsresult>(SKIP_EMPTY_PART);
+
+  if (m_mainpart && m_type && PL_strcmp(m_type, TEXT_HTML) == 0) 
+  {     
+    if (m_file) 
+    {
+      // The "insert HTML links" code requires a memory buffer,
+      // so read the file into memory.
+      NS_ASSERTION(m_buffer == nullptr, "not-null buffer");
+      int32_t           length = 0;
+      int64_t fileSize;
+      if (NS_SUCCEEDED(m_file->GetFileSize(&fileSize)))
+          length = fileSize;
+      
+      m_buffer = (char *) PR_Malloc(sizeof(char) * (length + 1));
+      if (m_buffer) 
+      {
+        nsCOMPtr<nsIInputStream> inputFile;
+        nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputFile), m_file);
+        if (NS_SUCCEEDED(rv)) 
+        {
+          uint32_t bytesRead;
+          rv = inputFile->Read(m_buffer, length, &bytesRead);
+          inputFile->Close();
+          m_buffer[length] = '\0';
+        }
+        else 
+          PR_Free(m_buffer);
+      }
+    }
+  }
+  
+  if (m_parent && m_parent->m_type &&
+        !PL_strcasecmp(m_parent->m_type, MULTIPART_DIGEST) &&
+        m_type &&
+        (!PL_strcasecmp(m_type, MESSAGE_RFC822) ||
+        !PL_strcasecmp(m_type, MESSAGE_NEWS))) 
+  {
+    // If we're in a multipart/digest, and this document is of type
+    // message/rfc822, then it's appropriate to emit no headers.
+    //
+  }
+  else 
+  {
+    char *message_headers = 0;
+    char *content_headers = 0;
+    char *content_type_header = 0;
+    status = divide_content_headers(m_other,
+                                    &message_headers,
+                                    &content_headers,
+                                    &content_type_header);
+    if (NS_FAILED(status))
+      goto FAIL;
+    
+      /* First, write out all of the headers that refer to the message
+      itself (From, Subject, MIME-Version, etc.)
+    */
+    if (message_headers) 
+    {
+      PUSH(message_headers);
+      PR_Free(message_headers);
+      message_headers = 0;
+    }
+
+    /* Now allow the crypto library to (potentially) insert some text
+       (it may want to wrap the body in an envelope.)           */
+    if (!m_parent) {
+      status = m_state->BeginCryptoEncapsulation();
+      if (NS_FAILED(status)) goto FAIL;
+    }
+          
+    /* Now make sure there's a Content-Type header.
+    */
+    if (!content_type_header) 
+    {
+      NS_ASSERTION(m_type && *m_type, "null ptr");
+      bool needsCharset = mime_type_needs_charset(m_type ? m_type : TEXT_PLAIN);
+      if (needsCharset) 
+      {
+        content_type_header = PR_smprintf("Content-Type: %s; charset=%s" CRLF,
+                                          (m_type ? m_type : TEXT_PLAIN), m_charset_name);
+      }
+      else
+        content_type_header = PR_smprintf("Content-Type: %s" CRLF,
+                                          (m_type ? m_type : TEXT_PLAIN));
+      if (!content_type_header) 
+      {
+        if (content_headers)
+          PR_Free(content_headers);
+        status = NS_ERROR_OUT_OF_MEMORY;
+        goto FAIL;
+      }
+    }
+    
+    /* If this is a compound object, tack a boundary string onto the
+    Content-Type header. this
+    */
+    if (m_numchildren > 0)
+    {
+      int L;
+      char *ct2;
+      NS_ASSERTION(m_type, "null ptr");
+
+      if (!separator)
+      {
+        separator = mime_make_separator("");
+        if (!separator)
+        {
+          status = NS_ERROR_OUT_OF_MEMORY;
+          goto FAIL;
+        }
+      }
+
+      L = PL_strlen(content_type_header);
+      
+      if (content_type_header[L-1] == '\n')
+        content_type_header[--L] = 0;
+      if (content_type_header[L-1] == '\r')
+        content_type_header[--L] = 0;
+      
+      ct2 = PR_smprintf("%s;\r\n boundary=\"%s\"" CRLF, content_type_header, separator);
+      PR_Free(content_type_header);
+      if (!ct2) 
+      {
+        if (content_headers)
+          PR_Free(content_headers);
+        status = NS_ERROR_OUT_OF_MEMORY;
+        goto FAIL;
+      }
+      
+      content_type_header = ct2;
+    }
+    
+    // Now write out the Content-Type header...
+    NS_ASSERTION(content_type_header && *content_type_header, "null ptr");
+    PUSH(content_type_header);
+    PR_Free(content_type_header);
+    content_type_header = 0;
+    
+    /* ...followed by all of the other headers that refer to the body of
+    the message (Content-Transfer-Encoding, Content-Dispositon, etc.)
+    */
+    if (content_headers) 
+    {
+      PUSH(content_headers);
+      PR_Free(content_headers);
+      content_headers = 0;
+    }
+  }
+
+  PUSH(CRLF);         // A blank line, to mark the end of headers.
+
+  m_firstBlock = true;
+  /* only convert if we need to tag charset */
+  m_needIntlConversion = mime_type_needs_charset(m_type);
+  
+  if (m_buffer) 
+  {
+    status = PushBody(m_buffer, PL_strlen(m_buffer));
+    if (NS_FAILED(status))
+      goto FAIL;
+  }
+  else if (m_file) 
+  {
+    nsCOMPtr<nsIInputStream> inputStream;
+    nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), m_file);
+    if (NS_FAILED(rv))
+    {
+      // mysteriously disappearing?
+      nsCOMPtr<nsIMsgSendReport> sendReport;
+      m_state->GetSendReport(getter_AddRefs(sendReport));
+      if (sendReport)
+      {
+        nsAutoString error_msg;
+        nsMsgBuildMessageWithTmpFile(m_file, error_msg);
+        sendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), false);
+      }
+      status = NS_MSG_UNABLE_TO_OPEN_TMP_FILE;
+      goto FAIL;
+    }
+
+    nsCString curLine;
+    bool more = true;
+
+    /* Kludge to avoid having to allocate memory on the toy computers... */
+    if (!mime_mailto_stream_read_buffer) 
+    {
+      mime_mailto_stream_read_buffer = (char *) PR_Malloc(MIME_BUFFER_SIZE);
+      if (!mime_mailto_stream_read_buffer) 
+      {
+        status = NS_ERROR_OUT_OF_MEMORY;
+        goto FAIL;
+      }
+    }
+
+    char    *buffer = mime_mailto_stream_read_buffer;
+    if (m_strip_sensitive_headers) 
+    {
+      // We are attaching a message, so we should be careful to
+      // strip out certain sensitive internal header fields.
+      bool skipping = false;
+      nsAutoPtr<nsLineBuffer<char> > lineBuffer(new nsLineBuffer<char>);
+      NS_ENSURE_TRUE(lineBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+      while (more)
+      {
+        // NS_ReadLine doesn't return line termination chars.
+        rv = NS_ReadLine(inputStream.get(), lineBuffer.get(), curLine, &more);
+
+        curLine.Append(CRLF);
+
+        char *line = (char *) curLine.get();
+        if (skipping) {
+          if (*line == ' ' || *line == '\t')
+            continue;
+          else
+            skipping = false;
+        }
+                
+        if (!PL_strncasecmp(line, "From -", 6) ||
+            !PL_strncasecmp(line, "BCC:", 4) ||
+            !PL_strncasecmp(line, "FCC:", 4) ||
+            !PL_strncasecmp(line, CONTENT_LENGTH ":", CONTENT_LENGTH_LEN+1) ||
+            !PL_strncasecmp(line, "Lines:", 6) ||
+            !PL_strncasecmp(line, "Status:", 7) ||
+            !PL_strncasecmp(line, X_MOZILLA_STATUS ":", X_MOZILLA_STATUS_LEN+1) ||
+            !PL_strncasecmp(line, X_MOZILLA_STATUS2 ":", X_MOZILLA_STATUS2_LEN+1) ||
+            !PL_strncasecmp(line, X_MOZILLA_DRAFT_INFO ":", X_MOZILLA_DRAFT_INFO_LEN+1) ||
+            !PL_strncasecmp(line, X_MOZILLA_NEWSHOST ":", X_MOZILLA_NEWSHOST_LEN+1) ||
+            !PL_strncasecmp(line, X_UIDL ":", X_UIDL_LEN+1) ||
+            !PL_strncasecmp(line, "X-VM-", 5)) /* hi Kyle */
+        {
+          skipping = true;
+          continue;
+        }
+        
+        PUSH(line);
+        
+        if (curLine.Length() == 2) {
+          nsCOMPtr <nsISeekableStream> seekableStream = do_QueryInterface(inputStream);
+          // seek back the amount of data left in the line buffer...
+          seekableStream->Seek(nsISeekableStream::NS_SEEK_CUR, lineBuffer->start - lineBuffer->end);
+          break;  // Now can do normal reads for the body.
+        }
+      }
+      lineBuffer = nullptr;
+    }
+
+    while (NS_SUCCEEDED(status))
+    {
+      uint32_t bytesRead;
+      nsresult rv = inputStream->Read(buffer, MIME_BUFFER_SIZE, &bytesRead);
+      if (NS_FAILED(rv))
+      {  
+        nsCOMPtr<nsIMsgSendReport> sendReport;
+        m_state->GetSendReport(getter_AddRefs(sendReport));
+        if (sendReport)
+        {
+          nsAutoString error_msg;
+          nsMsgBuildMessageWithFile(m_file, error_msg);
+          sendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), false);
+          status = NS_MSG_UNABLE_TO_OPEN_FILE;
+          goto FAIL;
+        }
+      }
+      status = PushBody(buffer, bytesRead);
+      if (NS_FAILED(status))
+        goto FAIL;
+      if (bytesRead < MIME_BUFFER_SIZE)
+        break;
+    }
+  }
+
+  if (m_encoder)
+  {
+    nsresult rv = m_encoder->Flush();
+    m_encoder = nullptr;
+    needToWriteCRLFAfterEncodedBody = !m_parent;
+    if (NS_FAILED(rv))
+    {
+      // XXX -1 is not a valid nsresult
+      status = static_cast<nsresult>(-1);
+      goto FAIL;
+    }
+  }
+
+  //
+  // Ok, from here we loop and drive the the output of all children 
+  // for this message.
+  //
+  if (m_numchildren > 0) 
+  {
+    bool    writeSeparator = true;
+
+    for (int i = 0 ; i < m_numchildren ; i ++) 
+    {
+      if (writeSeparator)
+      {
+        PUSH(CRLF);
+        PUSH("--");
+
+        PUSH(separator);
+        PUSH(CRLF);
+      }
+
+      status = m_children[i]->Write();
+      if (NS_FAILED(status))
+        goto FAIL;
+
+      // XXX SKIP_EMPTY_PART (= 1966) is not a valid nsresult
+      if (status == static_cast<nsresult>(SKIP_EMPTY_PART))
+        writeSeparator = false;
+      else
+        writeSeparator = true;
+    }
+
+    PUSH(CRLF);
+    PUSH("--");
+    PUSH(separator);
+    PUSH("--");
+    PUSH(CRLF);
+  }
+  else if (needToWriteCRLFAfterEncodedBody)
+    PUSH(CRLF);
+
+FAIL:
+  PR_FREEIF(separator);
+  return status;
+}
+
diff --git a/mailnews/compose/src/nsMsgSendPart.h b/mailnews/compose/src/nsMsgSendPart.h
new file mode 100644
index 000000000..edb5422ea
--- /dev/null
+++ b/mailnews/compose/src/nsMsgSendPart.h
@@ -0,0 +1,101 @@
+/* -*- 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 _MsgSendPart_H_
+#define _MsgSendPart_H_
+
+#include "msgCore.h"
+#include "prprf.h" /* should be defined into msgCore.h? */
+#include "nsMsgSend.h"
+
+namespace mozilla {
+namespace mailnews {
+class MimeEncoder;
+}
+}
+
+typedef int (*MSG_SendPartWriteFunc)(const char* line, int32_t size,
+									                   bool isheader, void* closure);
+
+class nsMsgSendPart {
+  typedef mozilla::mailnews::MimeEncoder MimeEncoder;
+public:
+    nsMsgSendPart(nsIMsgSend* state, const char *part_charset = NULL);
+    virtual ~nsMsgSendPart();	  // Note that the destructor also destroys
+								                // any children that were added.
+
+    virtual nsresult  Write();
+
+    virtual nsresult    SetFile(nsIFile *filename);
+    const nsIFile  *GetFile() {return m_file;}
+
+    virtual nsresult  SetBuffer(const char* buffer);
+    const char        *GetBuffer() {return m_buffer;}
+
+    virtual nsresult  SetType(const char* type);
+    const char        *GetType() {return m_type;}
+    
+    const char        *GetCharsetName() {return m_charset_name;}
+
+    virtual nsresult  SetOtherHeaders(const char* other);
+    const char        *SetOtherHeaders() {return m_other;}
+	  virtual nsresult  AppendOtherHeaders(const char* moreother);
+
+	  virtual nsresult  SetMimeDeliveryState(nsIMsgSend* state);
+
+  // Note that the nsMsgSendPart class will take over ownership of the
+  // MimeEncoderData* object, deleting it when it chooses.  (This is
+  // necessary because deleting these objects is the only current way to
+  // flush out the data in them.)
+  void                SetEncoder(MimeEncoder* encoder) {m_encoder = encoder;}
+  MimeEncoder         *GetEncoder() {return m_encoder;}
+
+	void                SetStripSensitiveHeaders(bool value)
+                      {
+		                    m_strip_sensitive_headers = value;
+	                    }
+	bool                GetStripSensitiveHeaders() {return m_strip_sensitive_headers;}
+
+  virtual nsresult    AddChild(nsMsgSendPart* child);
+
+	int32_t             GetNumChildren() {return m_numchildren;}
+	nsMsgSendPart       *GetChild(int32_t which);
+	nsMsgSendPart       *DetachChild(int32_t which);
+
+	virtual nsresult    SetMainPart(bool value);
+	bool                IsMainPart() 
+                      {
+                        return m_mainpart;
+                      }
+  nsCString           m_partNum;
+protected:
+	nsresult            CopyString(char** dest, const char* src);
+	nsresult            PushBody(const char* buffer, int32_t length);
+
+	nsCOMPtr<nsIMsgSend> m_state;
+	nsMsgSendPart       *m_parent;
+  nsCOMPtr <nsIFile>   m_file;
+	char                *m_buffer;
+  char                *m_type;
+  char                *m_other;
+  char                m_charset_name[64+1];        // charset name associated with this part
+	bool                m_strip_sensitive_headers;
+  nsAutoPtr<MimeEncoder> m_encoder;
+
+	nsMsgSendPart       **m_children;
+	int32_t             m_numchildren;
+
+	// Data used while actually writing.
+  bool                m_firstBlock;
+  bool                m_needIntlConversion;
+
+	bool                m_mainpart;
+
+	bool                m_just_hit_CR;
+
+	static int32_t      M_counter;
+};
+
+#endif /* _MsgSendPart_H_ */
diff --git a/mailnews/compose/src/nsMsgSendReport.cpp b/mailnews/compose/src/nsMsgSendReport.cpp
new file mode 100644
index 000000000..1bc26ca8a
--- /dev/null
+++ b/mailnews/compose/src/nsMsgSendReport.cpp
@@ -0,0 +1,437 @@
+/* -*- 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 "nsMsgCompCID.h"
+#include "nsMsgPrompts.h"
+#include "nsError.h"
+#include "nsComposeStrings.h"
+#include "nsIStringBundle.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Services.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;
+}
+
+/* nsresult displayReport (in nsIPrompt prompt, in boolean showErrorOnly, in boolean dontShowReportTwice); */
+NS_IMETHODIMP nsMsgSendReport::DisplayReport(nsIPrompt *prompt, 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::services::GetStringBundleService();
+  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 workaroung until bug 783526 is fixed.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wswitch"
+#endif
+    switch (currError)
+    {
+      case NS_BINDING_ABORTED:
+      case NS_ERROR_SEND_FAILED:
+      case NS_ERROR_SEND_FAILED_BUT_NNTP_OK:
+      case NS_MSG_FAILED_COPY_OPERATION:
+      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 char16_t* 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(u"sendMessageErrorTitle",
+                              getter_Copies(dialogTitle));
+
+    const char16_t* preStrName = u"sendFailed";
+    bool askToGoBackToCompose = false;
+    switch (mCurrentProcess)
+    {
+      case process_BuildMessage :
+        preStrName = u"sendFailed";
+        askToGoBackToCompose = false;
+        break;
+      case process_NNTP :
+        preStrName = u"sendFailed";
+        askToGoBackToCompose = false;
+        break;
+      case process_SMTP :
+        bool nntpProceeded;
+        mProcessReport[process_NNTP]->GetProceeded(&nntpProceeded);
+        if (nntpProceeded)
+          preStrName = u"sendFailedButNntpOk";
+        else
+          preStrName = u"sendFailed";
+        askToGoBackToCompose = false;
+        break;
+      case process_Copy:
+        preStrName = u"failedCopyOperation";
+        askToGoBackToCompose = (mDeliveryMode == nsIMsgCompDeliverMode::Now);
+        break;
+      case process_FCC:
+        preStrName = u"failedCopyOperation";
+        askToGoBackToCompose = (mDeliveryMode == nsIMsgCompDeliverMode::Now);
+        break;
+    }
+    bundle->GetStringFromName(preStrName, getter_Copies(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(u"genericFailureExplanation",
+                                getter_Copies(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(u"returnToComposeWindowQuestion",
+                                getter_Copies(text1));
+      if (!dialogMessage.IsEmpty())
+        dialogMessage.AppendLiteral("\n");
+      dialogMessage.Append(text1);
+      nsMsgAskBooleanQuestionByString(prompt, dialogMessage.get(), &oopsGiveMeBackTheComposeWindow, dialogTitle.get());
+      if (!oopsGiveMeBackTheComposeWindow)
+        *_retval = NS_OK;
+    }
+    else
+      nsMsgDisplayMessageByString(prompt, dialogMessage.get(), dialogTitle.get());
+  }
+  else
+  {
+    const char16_t* title;
+    const char16_t* messageName;
+
+    switch (mDeliveryMode)
+    {
+      case nsIMsgCompDeliverMode::Later:
+        title = u"sendLaterErrorTitle";
+        messageName = u"unableToSendLater";
+        break;
+
+      case nsIMsgCompDeliverMode::AutoSaveAsDraft:
+      case nsIMsgCompDeliverMode::SaveAsDraft:
+        title = u"saveDraftErrorTitle";
+        messageName = u"unableToSaveDraft";
+        break;
+
+      case nsIMsgCompDeliverMode::SaveAsTemplate:
+        title = u"saveTemplateErrorTitle";
+        messageName = u"unableToSaveTemplate";
+        break;
+
+      default:
+        /* This should never happen! */
+        title = u"sendMessageErrorTitle";
+        messageName = u"sendFailed";
+        break;
+    }
+
+    bundle->GetStringFromName(title, getter_Copies(dialogTitle));
+    bundle->GetStringFromName(messageName,
+                              getter_Copies(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(u"genericFailureExplanation",
+                                getter_Copies(currMessage));
+    }
+
+    if (!currMessage.IsEmpty())
+    {
+      if (!dialogMessage.IsEmpty())
+        dialogMessage.Append(char16_t('\n'));
+      dialogMessage.Append(currMessage);
+    }
+    nsMsgDisplayMessageByString(prompt, dialogMessage.get(), dialogTitle.get());
+  }
+
+  mAlreadyDisplayReport = true;
+  return NS_OK;
+}
+
diff --git a/mailnews/compose/src/nsMsgSendReport.h b/mailnews/compose/src/nsMsgSendReport.h
new file mode 100644
index 000000000..3e344f628
--- /dev/null
+++ b/mailnews/compose/src/nsMsgSendReport.h
@@ -0,0 +1,46 @@
+/* -*- 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 "nsStringGlue.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();
+
+private:
+  virtual ~nsMsgSendReport();
+  #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/mailnews/compose/src/nsSMTPProtocolHandler.js b/mailnews/compose/src/nsSMTPProtocolHandler.js
new file mode 100644
index 000000000..9b9e3ead0
--- /dev/null
+++ b/mailnews/compose/src/nsSMTPProtocolHandler.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/. */
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+var kNetworkProtocolCIDPrefix = "@mozilla.org/network/protocol;1?name=";
+var nsIProtocolHandler = Components.interfaces.nsIProtocolHandler;
+
+function makeProtocolHandler(aProtocol, aDefaultPort, aClassID) {
+  return {
+    classID: Components.ID(aClassID),
+    QueryInterface: XPCOMUtils.generateQI([nsIProtocolHandler]),
+
+    scheme: aProtocol,
+    defaultPort: aDefaultPort,
+    protocolFlags: nsIProtocolHandler.URI_NORELATIVE |
+                   nsIProtocolHandler.URI_DANGEROUS_TO_LOAD |
+      nsIProtocolHandler.URI_NON_PERSISTABLE |
+      nsIProtocolHandler.ALLOWS_PROXY |
+      nsIProtocolHandler.URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT,
+
+    newURI: function (aSpec, aOriginCharset, aBaseURI) {
+      var url = Components.classes["@mozilla.org/messengercompose/smtpurl;1"]
+                          .createInstance(Components.interfaces.nsIURI);
+
+      url.spec = aSpec;
+
+      return url;
+    },
+
+    newChannel: function (aURI) {
+      throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
+    },
+
+    newChannel2: function(aURI, aLoadInfo)
+    {
+      throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
+    },
+
+    allowPort: function (port, scheme) {
+      return port == aDefaultPort;
+    }
+  };
+}
+
+function nsSMTPProtocolHandler() {}
+
+nsSMTPProtocolHandler.prototype =
+  makeProtocolHandler("smtp",
+                      Components.interfaces.nsISmtpUrl.DEFAULT_SMTP_PORT,
+                      "b14c2b67-8680-4c11-8d63-9403c7d4f757");
+
+function nsSMTPSProtocolHandler() {}
+
+nsSMTPSProtocolHandler.prototype =
+  makeProtocolHandler("smtps",
+                      Components.interfaces.nsISmtpUrl.DEFAULT_SMTPS_PORT,
+                      "057d0997-9e3a-411e-b4ee-2602f53fe05f");
+
+var components = [nsSMTPProtocolHandler, nsSMTPSProtocolHandler];
+var NSGetFactory = XPCOMUtils.generateNSGetFactory(components);
diff --git a/mailnews/compose/src/nsSMTPProtocolHandler.manifest b/mailnews/compose/src/nsSMTPProtocolHandler.manifest
new file mode 100644
index 000000000..4d371163f
--- /dev/null
+++ b/mailnews/compose/src/nsSMTPProtocolHandler.manifest
@@ -0,0 +1,4 @@
+component {b14c2b67-8680-4c11-8d63-9403c7d4f757} nsSMTPProtocolHandler.js
+contract @mozilla.org/network/protocol;1?name=smtp {b14c2b67-8680-4c11-8d63-9403c7d4f757}
+component {057d0997-9e3a-411e-b4ee-2602f53fe05f} nsSMTPProtocolHandler.js
+contract @mozilla.org/network/protocol;1?name=smtps {057d0997-9e3a-411e-b4ee-2602f53fe05f}
diff --git a/mailnews/compose/src/nsSmtpProtocol.cpp b/mailnews/compose/src/nsSmtpProtocol.cpp
new file mode 100644
index 000000000..d525d3f7f
--- /dev/null
+++ b/mailnews/compose/src/nsSmtpProtocol.cpp
@@ -0,0 +1,2249 @@
+/* -*- 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 "nsSmtpProtocol.h"
+#include "nscore.h"
+#include "nsIStreamListener.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsISocketTransport.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgCompCID.h"
+#include "nsIPrompt.h"
+#include "nsIAuthPrompt.h"
+#include "nsStringGlue.h"
+#include "nsTextFormatter.h"
+#include "nsIMsgIdentity.h"
+#include "nsISmtpServer.h"
+#include "prtime.h"
+#include "mozilla/Logging.h"
+#include "prerror.h"
+#include "prprf.h"
+#include "prmem.h"
+#include "plbase64.h"
+#include "prnetdb.h"
+#include "prsystem.h"
+#include "nsMsgUtils.h"
+#include "nsIPipe.h"
+#include "nsNetUtil.h"
+#include "nsIPrefService.h"
+#include "nsISSLSocketControl.h"
+#include "nsComposeStrings.h"
+#include "nsIStringBundle.h"
+#include "nsMsgCompUtils.h"
+#include "nsIMsgWindow.h"
+#include "MailNewsTypes2.h" // for nsMsgSocketType and nsMsgAuthMethod
+#include "nsIIDNService.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+#include "mozilla/Services.h"
+#include "mozilla/Attributes.h"
+#include "nsINetAddr.h"
+#include "nsIProxyInfo.h"
+
+#ifndef XP_UNIX
+#include <stdarg.h>
+#endif /* !XP_UNIX */
+
+#undef PostMessage // avoid to collision with WinUser.h
+
+static PRLogModuleInfo *SMTPLogModule = nullptr;
+
+using namespace mozilla::mailnews;
+
+/* the output_buffer_size must be larger than the largest possible line
+ * 2000 seems good for news
+ *
+ * jwz: I increased this to 4k since it must be big enough to hold the
+ * entire button-bar HTML, and with the new "mailto" format, that can
+ * contain arbitrarily long header fields like "references".
+ *
+ * fortezza: proxy auth is huge, buffer increased to 8k (sigh).
+ */
+#define OUTPUT_BUFFER_SIZE (4096*2)
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// TEMPORARY HARD CODED FUNCTIONS
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/* based on in NET_ExplainErrorDetails in mkmessag.c */
+nsresult nsExplainErrorDetails(nsISmtpUrl * aSmtpUrl, nsresult aCode, ...)
+{
+  NS_ENSURE_ARG(aSmtpUrl);
+
+  va_list args;
+
+  nsCOMPtr<nsIPrompt> dialog;
+  aSmtpUrl->GetPrompt(getter_AddRefs(dialog));
+  NS_ENSURE_TRUE(dialog, NS_ERROR_FAILURE);
+
+  char16_t *  msg;
+  nsString eMsg;
+  nsCOMPtr<nsIStringBundleService> bundleService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+  nsCOMPtr<nsIStringBundle> bundle;
+  nsresult rv = bundleService->CreateBundle(
+    "chrome://messenger/locale/messengercompose/composeMsgs.properties",
+    getter_AddRefs(bundle));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  va_start (args, aCode);
+
+  const char16_t* exitString;
+#ifdef __GNUC__
+// Temporary workaroung until bug 783526 is fixed.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wswitch"
+#endif
+  switch (aCode)
+  {
+    case NS_ERROR_ILLEGAL_LOCALPART:
+      bundle->GetStringFromName(u"errorIllegalLocalPart",
+                                getter_Copies(eMsg));
+      msg = nsTextFormatter::vsmprintf(eMsg.get(), args);
+      break;
+    case NS_ERROR_SMTP_SERVER_ERROR:
+    case NS_ERROR_TCP_READ_ERROR:
+    case NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED:
+    case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_1:
+    case NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2:
+    case NS_ERROR_SENDING_FROM_COMMAND:
+    case NS_ERROR_SENDING_RCPT_COMMAND:
+    case NS_ERROR_SENDING_DATA_COMMAND:
+    case NS_ERROR_SENDING_MESSAGE:
+    case NS_ERROR_SMTP_GREETING:
+      exitString = errorStringNameForErrorCode(aCode);
+      bundle->GetStringFromName(exitString, getter_Copies(eMsg));
+      msg = nsTextFormatter::vsmprintf(eMsg.get(), args);
+      break;
+    default:
+      NS_WARNING("falling to default error code");
+      bundle->GetStringFromName(u"communicationsError", getter_Copies(eMsg));
+      msg = nsTextFormatter::smprintf(eMsg.get(), aCode);
+      break;
+  }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+  if (msg)
+  {
+    rv = dialog->Alert(nullptr, msg);
+    nsTextFormatter::smprintf_free(msg);
+  }
+
+  va_end (args);
+
+  return rv;
+}
+
+/* RFC 1891 -- extended smtp value encoding scheme
+
+  5. Additional parameters for RCPT and MAIL commands
+
+     The extended RCPT and MAIL commands are issued by a client when it wishes to request a DSN from the
+     server, under certain conditions, for a particular recipient. The extended RCPT and MAIL commands are
+     identical to the RCPT and MAIL commands defined in [1], except that one or more of the following parameters
+     appear after the sender or recipient address, respectively. The general syntax for extended SMTP commands is
+     defined in [4].
+
+     NOTE: Although RFC 822 ABNF is used to describe the syntax of these parameters, they are not, in the
+     language of that document, "structured field bodies". Therefore, while parentheses MAY appear within an
+     emstp-value, they are not recognized as comment delimiters.
+
+     The syntax for "esmtp-value" in [4] does not allow SP, "=", control characters, or characters outside the
+     traditional ASCII range of 1- 127 decimal to be transmitted in an esmtp-value. Because the ENVID and
+     ORCPT parameters may need to convey values outside this range, the esmtp-values for these parameters are
+     encoded as "xtext". "xtext" is formally defined as follows:
+
+     xtext = *( xchar / hexchar )
+
+     xchar = any ASCII CHAR between "!" (33) and "~" (126) inclusive, except for "+" and "=".
+
+	; "hexchar"s are intended to encode octets that cannot appear
+	; as ASCII characters within an esmtp-value.
+
+		 hexchar = ASCII "+" immediately followed by two upper case hexadecimal digits
+
+	When encoding an octet sequence as xtext:
+
+	+ Any ASCII CHAR between "!" and "~" inclusive, except for "+" and "=",
+		 MAY be encoded as itself. (A CHAR in this range MAY instead be encoded as a "hexchar", at the
+		 implementor's discretion.)
+
+	+ ASCII CHARs that fall outside the range above must be encoded as
+		 "hexchar".
+
+ */
+/* caller must free the return buffer */
+static char *
+esmtp_value_encode(const char *addr)
+{
+  char *buffer = (char *) PR_Malloc(512); /* esmtp ORCPT allow up to 500 chars encoded addresses */
+  char *bp = buffer, *bpEnd = buffer+500;
+  int len, i;
+
+  if (!buffer) return NULL;
+
+  *bp=0;
+  if (! addr || *addr == 0) /* this will never happen */
+    return buffer;
+
+  for (i=0, len=PL_strlen(addr); i < len && bp < bpEnd; i++)
+  {
+    if (*addr >= 0x21 &&
+      *addr <= 0x7E &&
+      *addr != '+' &&
+      *addr != '=')
+    {
+      *bp++ = *addr++;
+    }
+    else
+    {
+      PR_snprintf(bp, bpEnd-bp, "+%.2X", ((int)*addr++));
+      bp += PL_strlen(bp);
+    }
+  }
+  *bp=0;
+  return buffer;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// END OF TEMPORARY HARD CODED FUNCTIONS
+///////////////////////////////////////////////////////////////////////////////////////////
+
+NS_IMPL_ISUPPORTS_INHERITED(nsSmtpProtocol, nsMsgAsyncWriteProtocol,
+                            msgIOAuth2ModuleListener)
+
+nsSmtpProtocol::nsSmtpProtocol(nsIURI * aURL)
+    : nsMsgAsyncWriteProtocol(aURL)
+{
+}
+
+nsSmtpProtocol::~nsSmtpProtocol()
+{
+  // free our local state
+  PR_Free(m_dataBuf);
+  delete m_lineStreamBuffer;
+}
+
+void nsSmtpProtocol::Initialize(nsIURI * aURL)
+{
+    NS_PRECONDITION(aURL, "invalid URL passed into Smtp Protocol");
+    nsresult rv = NS_OK;
+
+    m_flags = 0;
+    m_prefAuthMethods = 0;
+    m_failedAuthMethods = 0;
+    m_currentAuthMethod = 0;
+    m_usernamePrompted = false;
+    m_prefSocketType = nsMsgSocketType::trySTARTTLS;
+    m_tlsInitiated = false;
+
+    m_urlErrorState = NS_ERROR_FAILURE;
+
+    if (!SMTPLogModule)
+        SMTPLogModule = PR_NewLogModule("SMTP");
+
+    if (aURL)
+        m_runningURL = do_QueryInterface(aURL);
+
+    // extract out message feedback if there is any.
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(aURL);
+    if (mailnewsUrl)
+        mailnewsUrl->GetStatusFeedback(getter_AddRefs(m_statusFeedback));
+
+    m_dataBuf = (char *) PR_Malloc(sizeof(char) * OUTPUT_BUFFER_SIZE);
+    m_dataBufSize = OUTPUT_BUFFER_SIZE;
+
+    m_nextState = SMTP_START_CONNECT;
+    m_nextStateAfterResponse = SMTP_START_CONNECT;
+    m_responseCode = 0;
+    m_previousResponseCode = 0;
+    m_continuationResponse = -1;
+    m_tlsEnabled = false;
+    m_addressesLeft = 0;
+
+    m_sendDone = false;
+
+    m_sizelimit = 0;
+    m_totalMessageSize = 0;
+    nsCOMPtr<nsIFile> file;
+    m_runningURL->GetPostMessageFile(getter_AddRefs(file));
+    if (file)
+        file->GetFileSize(&m_totalMessageSize);
+
+    m_originalContentLength = 0;
+    m_totalAmountRead = 0;
+
+    m_lineStreamBuffer = new nsMsgLineStreamBuffer(OUTPUT_BUFFER_SIZE, true);
+    // ** may want to consider caching the server capability to save lots of
+    // round trip communication between the client and server
+    int32_t authMethod = 0;
+    nsCOMPtr<nsISmtpServer> smtpServer;
+    m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer));
+    if (smtpServer) {
+        smtpServer->GetAuthMethod(&authMethod);
+        smtpServer->GetSocketType(&m_prefSocketType);
+        smtpServer->GetHelloArgument(getter_Copies(m_helloArgument));
+
+        // Query for OAuth2 support. If the SMTP server preferences don't allow
+        // for OAuth2, then don't carry around the OAuth2 module any longer
+        // since we won't need it.
+        mOAuth2Support = do_CreateInstance(MSGIOAUTH2MODULE_CONTRACTID);
+        if (mOAuth2Support)
+        {
+          bool supportsOAuth = false;
+          mOAuth2Support->InitFromSmtp(smtpServer, &supportsOAuth);
+          if (!supportsOAuth)
+            mOAuth2Support = nullptr;
+        }
+    }
+    InitPrefAuthMethods(authMethod);
+
+    nsAutoCString hostName;
+    int32_t port = 0;
+
+    aURL->GetPort(&port);
+    aURL->GetAsciiHost(hostName);
+
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("SMTP Connecting to: %s", hostName.get()));
+
+    // When we are making a secure connection, we need to make sure that we
+    // pass an interface requestor down to the socket transport so that PSM can
+    // retrieve a nsIPrompt instance if needed.
+    nsCOMPtr<nsIInterfaceRequestor> callbacks;
+    nsCOMPtr<nsISmtpUrl> smtpUrl(do_QueryInterface(aURL));
+    if (smtpUrl)
+        smtpUrl->GetNotificationCallbacks(getter_AddRefs(callbacks));
+
+    nsCOMPtr<nsIProxyInfo> proxyInfo;
+    rv = MsgExamineForProxy(this, getter_AddRefs(proxyInfo));
+    if (NS_FAILED(rv)) proxyInfo = nullptr;
+
+    if (m_prefSocketType == nsMsgSocketType::SSL)
+        rv = OpenNetworkSocketWithInfo(hostName.get(), port, "ssl", proxyInfo,
+            callbacks);
+    else if (m_prefSocketType != nsMsgSocketType::plain)
+    {
+        rv = OpenNetworkSocketWithInfo(hostName.get(), port, "starttls",
+            proxyInfo, callbacks);
+        if (NS_FAILED(rv) && m_prefSocketType == nsMsgSocketType::trySTARTTLS)
+        {
+            m_prefSocketType = nsMsgSocketType::plain;
+            rv = OpenNetworkSocketWithInfo(hostName.get(), port, nullptr,
+                proxyInfo, callbacks);
+        }
+    }
+    else
+        rv = OpenNetworkSocketWithInfo(hostName.get(), port, nullptr, proxyInfo,
+            callbacks);
+}
+
+void nsSmtpProtocol::AppendHelloArgument(nsACString& aResult)
+{
+  nsresult rv;
+
+  // is a custom EHLO/HELO argument configured for the transport to be used?
+  if (!m_helloArgument.IsEmpty())
+  {
+      aResult += m_helloArgument;
+  }
+  else
+  {
+      // is a FQDN known for this system?
+      char hostName[256];
+      PR_GetSystemInfo(PR_SI_HOSTNAME_UNTRUNCATED, hostName, sizeof hostName);
+      if ((hostName[0] != '\0') && (strchr(hostName, '.') != NULL))
+      {
+          nsDependentCString cleanedHostName(hostName);
+          // avoid problems with hostnames containing newlines/whitespace
+          cleanedHostName.StripWhitespace();
+          aResult += cleanedHostName;
+      }
+      else
+      {
+          nsCOMPtr<nsINetAddr> iaddr; // IP address for this connection
+          // our transport is always a nsISocketTransport
+          nsCOMPtr<nsISocketTransport> socketTransport = do_QueryInterface(m_transport);
+          // should return the interface ip of the SMTP connection
+          // minimum case - see bug 68877 and RFC 2821, chapter 4.1.1.1
+          rv = socketTransport->GetScriptableSelfAddr(getter_AddRefs(iaddr));
+
+          if (NS_SUCCEEDED(rv))
+          {
+              // turn it into a string
+              nsCString ipAddressString;
+              rv = iaddr->GetAddress(ipAddressString);
+              if (NS_SUCCEEDED(rv))
+              {
+#ifdef DEBUG
+                  bool v4mapped = false;
+                  iaddr->GetIsV4Mapped(&v4mapped);
+                  NS_ASSERTION(!v4mapped,
+                               "unexpected IPv4-mapped IPv6 address");
+#endif
+
+                  uint16_t family = nsINetAddr::FAMILY_INET;
+                  iaddr->GetFamily(&family);
+
+                  if (family == nsINetAddr::FAMILY_INET6) // IPv6 style address?
+                      aResult.AppendLiteral("[IPv6:");
+                  else
+                      aResult.AppendLiteral("[");
+
+                  aResult.Append(ipAddressString);
+                  aResult.Append(']');
+              }
+          }
+      }
+  }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// we suppport the nsIStreamListener interface
+////////////////////////////////////////////////////////////////////////////////////////////
+
+// stop binding is a "notification" informing us that the stream
+// associated with aURL is going away.
+NS_IMETHODIMP nsSmtpProtocol::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
+                                            nsresult aStatus)
+{
+  bool connDroppedDuringAuth = NS_SUCCEEDED(aStatus) && !m_sendDone &&
+      (m_nextStateAfterResponse == SMTP_AUTH_LOGIN_STEP0_RESPONSE ||
+       m_nextStateAfterResponse == SMTP_AUTH_LOGIN_RESPONSE);
+  // ignore errors handling the QUIT command so fcc can continue.
+  if (m_sendDone && NS_FAILED(aStatus))
+  {
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info,
+     ("SMTP connection error quitting %lx, ignoring ", aStatus));
+    aStatus = NS_OK;
+  }
+  if (NS_SUCCEEDED(aStatus) && !m_sendDone) {
+    // if we are getting OnStopRequest() with NS_OK,
+    // but we haven't finished clean, that's spells trouble.
+    // it means that the server has dropped us before we could send the whole mail
+    // for example, see bug #200647
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info,
+ ("SMTP connection dropped after %ld total bytes read", m_totalAmountRead));
+    if (!connDroppedDuringAuth)
+      nsMsgAsyncWriteProtocol::OnStopRequest(nullptr, ctxt, NS_ERROR_NET_INTERRUPT);
+  }
+  else
+    nsMsgAsyncWriteProtocol::OnStopRequest(nullptr, ctxt, aStatus);
+
+  // okay, we've been told that the send is done and the connection is going away. So
+  // we need to release all of our state
+  nsresult rv = nsMsgAsyncWriteProtocol::CloseSocket();
+  // If the server dropped the connection when we were expecting
+  // a login response, reprompt for password, and if the user asks,
+  // retry the url.
+  if (connDroppedDuringAuth)
+  {
+    nsCOMPtr<nsIURI> runningURI = do_QueryInterface(m_runningURL);
+    nsresult rv = AuthLoginResponse(nullptr, 0);
+    if (NS_FAILED(rv))
+      return rv;
+    return LoadUrl(runningURI, ctxt);
+  }
+
+  return rv;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// End of nsIStreamListenerSupport
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+void nsSmtpProtocol::UpdateStatus(const char16_t* aStatusName)
+{
+  if (m_statusFeedback)
+  {
+    nsCOMPtr<nsIStringBundleService> bundleService =
+      mozilla::services::GetStringBundleService();
+    if (!bundleService) return;
+    nsCOMPtr<nsIStringBundle> bundle;
+    nsresult rv = bundleService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(bundle));
+    if (NS_FAILED(rv)) return;
+    nsString msg;
+    bundle->GetStringFromName(aStatusName, getter_Copies(msg));
+    UpdateStatusWithString(msg.get());
+  }
+}
+
+void nsSmtpProtocol::UpdateStatusWithString(const char16_t * aStatusString)
+{
+  if (m_statusFeedback && aStatusString)
+    m_statusFeedback->ShowStatusString(nsDependentString(aStatusString));
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Begin protocol state machine functions...
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+/*
+ * gets the response code from the SMTP server and the
+ * response line
+ */
+nsresult nsSmtpProtocol::SmtpResponse(nsIInputStream * inputStream, uint32_t length)
+{
+  char * line = nullptr;
+  char cont_char;
+  uint32_t ln = 0;
+  bool pauseForMoreData = false;
+
+  if (!m_lineStreamBuffer)
+    // this will force an error and at least we won't crash
+    return NS_ERROR_NULL_POINTER;
+
+  line = m_lineStreamBuffer->ReadNextLine(inputStream, ln, pauseForMoreData);
+
+  if (pauseForMoreData || !line)
+  {
+    SetFlag(SMTP_PAUSE_FOR_READ); /* pause */
+    PR_Free(line);
+    return NS_OK;
+  }
+
+  m_totalAmountRead += ln;
+
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("SMTP Response: %s", line));
+  cont_char = ' '; /* default */
+  // sscanf() doesn't update m_responseCode if line doesn't start
+  // with a number. That can be dangerous. So be sure to set
+  // m_responseCode to 0 if no items read.
+  if (PR_sscanf(line, "%d%c", &m_responseCode, &cont_char) <= 0)
+    m_responseCode = 0;
+
+  if (m_continuationResponse == -1)
+  {
+    if (cont_char == '-')  /* begin continuation */
+      m_continuationResponse = m_responseCode;
+
+    // display the whole message if no valid response code or
+    // message shorter than 4 chars
+    m_responseText = (m_responseCode >= 100 && PL_strlen(line) > 3) ? line + 4 : line;
+  }
+  else
+  { /* have to continue */
+    if (m_continuationResponse == m_responseCode && cont_char == ' ')
+      m_continuationResponse = -1;    /* ended */
+
+    if (m_responseText.IsEmpty() || m_responseText.Last() != '\n')
+      m_responseText += "\n";
+
+    m_responseText += (PL_strlen(line) > 3) ? line + 4 : line;
+  }
+
+  if (m_responseCode == 220 && m_responseText.Length() && !m_tlsInitiated &&
+     !m_sendDone)
+    m_nextStateAfterResponse = SMTP_EXTN_LOGIN_RESPONSE;
+
+  if (m_continuationResponse == -1)  /* all done with this response? */
+  {
+    m_nextState = m_nextStateAfterResponse;
+    ClearFlag(SMTP_PAUSE_FOR_READ); /* don't pause */
+  }
+
+  PR_Free(line);
+  return NS_OK;
+}
+
+nsresult nsSmtpProtocol::ExtensionLoginResponse(nsIInputStream * inputStream, uint32_t length)
+{
+  nsresult status = NS_OK;
+
+  if (m_responseCode != 220)
+  {
+#ifdef DEBUG
+    nsresult rv =
+#endif
+    nsExplainErrorDetails(m_runningURL, NS_ERROR_SMTP_GREETING,
+                          m_responseText.get());
+    NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error");
+
+    m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
+    return NS_ERROR_SMTP_AUTH_FAILURE;
+  }
+
+  nsAutoCString buffer("EHLO ");
+  AppendHelloArgument(buffer);
+  buffer += CRLF;
+
+  status = SendData(buffer.get());
+
+  m_nextState = SMTP_RESPONSE;
+  m_nextStateAfterResponse = SMTP_SEND_EHLO_RESPONSE;
+  SetFlag(SMTP_PAUSE_FOR_READ);
+
+  return(status);
+}
+
+nsresult nsSmtpProtocol::SendHeloResponse(nsIInputStream * inputStream, uint32_t length)
+{
+  nsresult status = NS_OK;
+  nsAutoCString buffer;
+  nsresult rv;
+
+  if (m_responseCode != 250)
+  {
+#ifdef DEBUG
+    rv =
+#endif
+    nsExplainErrorDetails(m_runningURL, NS_ERROR_SMTP_SERVER_ERROR,
+                          m_responseText.get());
+    NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error");
+
+    m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
+    return NS_ERROR_SMTP_AUTH_FAILURE;
+  }
+
+  // check if we're just verifying the ability to logon
+  nsCOMPtr<nsISmtpUrl> smtpUrl = do_QueryInterface(m_runningURL, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool verifyingLogon = false;
+  smtpUrl->GetVerifyLogon(&verifyingLogon);
+  if (verifyingLogon)
+    return SendQuit();
+
+  // extract the email address from the identity
+  nsCString emailAddress;
+  nsCOMPtr <nsIMsgIdentity> senderIdentity;
+  rv = m_runningURL->GetSenderIdentity(getter_AddRefs(senderIdentity));
+  if (NS_FAILED(rv) || !senderIdentity)
+  {
+    m_urlErrorState = NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS;
+    return(NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS);
+  }
+  senderIdentity->GetEmail(emailAddress);
+
+  if (emailAddress.IsEmpty())
+  {
+    m_urlErrorState = NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS;
+    return(NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS);
+  }
+
+  nsCString fullAddress;
+  // Quote the email address before passing it to the SMTP server.
+  MakeMimeAddress(EmptyCString(), emailAddress, fullAddress);
+
+  buffer = "MAIL FROM:<";
+  buffer += fullAddress;
+  buffer += ">";
+
+  nsCOMPtr<nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch;
+  rv = prefs->GetBranch(nullptr, getter_AddRefs(prefBranch));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (TestFlag(SMTP_EHLO_DSN_ENABLED))
+  {
+    bool requestDSN = false;
+    rv = m_runningURL->GetRequestDSN(&requestDSN);
+
+    if (requestDSN)
+    {
+      bool requestRetFull = false;
+      rv = prefBranch->GetBoolPref("mail.dsn.ret_full_on", &requestRetFull);
+
+      buffer += requestRetFull ? " RET=FULL" : " RET=HDRS";
+
+      nsCString dsnEnvid;
+
+      // get the envid from the smtpUrl
+      rv = m_runningURL->GetDsnEnvid(dsnEnvid);
+
+      if (dsnEnvid.IsEmpty())
+          dsnEnvid.Adopt(msg_generate_message_id(senderIdentity));
+
+      buffer += " ENVID=";
+      buffer += dsnEnvid;
+    }
+  }
+
+  if (TestFlag(SMTP_EHLO_8BIT_ENABLED))
+  {
+    bool strictlyMime = false;
+    rv = prefBranch->GetBoolPref("mail.strictly_mime", &strictlyMime);
+
+    if (!strictlyMime)
+      buffer.Append(" BODY=8BITMIME");
+  }
+
+  if (TestFlag(SMTP_EHLO_SIZE_ENABLED))
+  {
+    buffer.Append(" SIZE=");
+    buffer.AppendInt(m_totalMessageSize);
+  }
+  buffer += CRLF;
+
+  status = SendData(buffer.get());
+
+  m_nextState = SMTP_RESPONSE;
+
+
+  m_nextStateAfterResponse = SMTP_SEND_MAIL_RESPONSE;
+  SetFlag(SMTP_PAUSE_FOR_READ);
+
+  return(status);
+}
+
+nsresult nsSmtpProtocol::SendEhloResponse(nsIInputStream * inputStream, uint32_t length)
+{
+    nsresult status = NS_OK;
+
+    if (m_responseCode != 250)
+    {
+        /* EHLO must not be implemented by the server, so fall back to the HELO case
+         * if command is unrecognized or unimplemented.
+         */
+        if (m_responseCode == 500 || m_responseCode == 502)
+        {
+            /* If STARTTLS is requested by the user, EHLO is required to advertise it.
+             * But only if TLS handshake is not already accomplished.
+             */
+            if (m_prefSocketType == nsMsgSocketType::alwaysSTARTTLS &&
+                !m_tlsEnabled)
+            {
+                m_nextState = SMTP_ERROR_DONE;
+                m_urlErrorState = NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS;
+                return(NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS);
+            }
+
+            nsAutoCString buffer("HELO ");
+            AppendHelloArgument(buffer);
+            buffer += CRLF;
+
+            status = SendData(buffer.get());
+
+            m_nextState = SMTP_RESPONSE;
+            m_nextStateAfterResponse = SMTP_SEND_HELO_RESPONSE;
+            SetFlag(SMTP_PAUSE_FOR_READ);
+            return (status);
+        }
+        /* e.g. getting 421 "Server says unauthorized, bye" or
+         * 501 "Syntax error in EHLOs parameters or arguments"
+         */
+        else
+        {
+#ifdef DEBUG
+            nsresult rv =
+#endif
+            nsExplainErrorDetails(m_runningURL, NS_ERROR_SMTP_SERVER_ERROR,
+                                  m_responseText.get());
+            NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error");
+
+            m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
+            return NS_ERROR_SMTP_AUTH_FAILURE;
+        }
+    }
+
+    int32_t responseLength = m_responseText.Length();
+    int32_t startPos = 0;
+    int32_t endPos;
+    do
+    {
+        endPos = m_responseText.FindChar('\n', startPos + 1);
+        nsAutoCString responseLine;
+        responseLine.Assign(Substring(m_responseText, startPos,
+            (endPos >= 0 ? endPos : responseLength) - startPos));
+
+        MsgCompressWhitespace(responseLine);
+        if (responseLine.LowerCaseEqualsLiteral("starttls"))
+        {
+            SetFlag(SMTP_EHLO_STARTTLS_ENABLED);
+        }
+        else if (responseLine.LowerCaseEqualsLiteral("dsn"))
+        {
+            SetFlag(SMTP_EHLO_DSN_ENABLED);
+        }
+        else if (StringBeginsWith(responseLine, NS_LITERAL_CSTRING("AUTH"), nsCaseInsensitiveCStringComparator()))
+        {
+          SetFlag(SMTP_AUTH);
+
+          if (responseLine.Find(NS_LITERAL_CSTRING("GSSAPI"),
+                                CaseInsensitiveCompare) >= 0)
+            SetFlag(SMTP_AUTH_GSSAPI_ENABLED);
+
+          if (responseLine.Find(NS_LITERAL_CSTRING("CRAM-MD5"),
+                                CaseInsensitiveCompare) >= 0)
+            SetFlag(SMTP_AUTH_CRAM_MD5_ENABLED);
+
+          if (responseLine.Find(NS_LITERAL_CSTRING("NTLM"),
+                                CaseInsensitiveCompare) >= 0)
+            SetFlag(SMTP_AUTH_NTLM_ENABLED);
+
+          if (responseLine.Find(NS_LITERAL_CSTRING("MSN"),
+                                CaseInsensitiveCompare) >= 0)
+            SetFlag(SMTP_AUTH_MSN_ENABLED);
+
+          if (responseLine.Find(NS_LITERAL_CSTRING("PLAIN"),
+                                CaseInsensitiveCompare) >= 0)
+            SetFlag(SMTP_AUTH_PLAIN_ENABLED);
+
+          if (responseLine.Find(NS_LITERAL_CSTRING("LOGIN"),
+                                CaseInsensitiveCompare) >= 0)
+            SetFlag(SMTP_AUTH_LOGIN_ENABLED);
+
+          if (responseLine.Find(NS_LITERAL_CSTRING("EXTERNAL"),
+                                CaseInsensitiveCompare) >= 0)
+            SetFlag(SMTP_AUTH_EXTERNAL_ENABLED);
+
+          if (responseLine.Find(NS_LITERAL_CSTRING("XOAUTH2"),
+                                CaseInsensitiveCompare) >= 0)
+            SetFlag(SMTP_AUTH_OAUTH2_ENABLED);
+        }
+        else if (StringBeginsWith(responseLine, NS_LITERAL_CSTRING("SIZE"), nsCaseInsensitiveCStringComparator()))
+        {
+            SetFlag(SMTP_EHLO_SIZE_ENABLED);
+
+            m_sizelimit = atol((responseLine.get()) + 4);
+        }
+        else if (StringBeginsWith(responseLine, NS_LITERAL_CSTRING("8BITMIME"), nsCaseInsensitiveCStringComparator()))
+        {
+            SetFlag(SMTP_EHLO_8BIT_ENABLED);
+        }
+
+        startPos = endPos + 1;
+    } while (endPos >= 0);
+
+    if (TestFlag(SMTP_EHLO_SIZE_ENABLED) &&
+       m_sizelimit > 0 && (int32_t)m_totalMessageSize > m_sizelimit)
+    {
+#ifdef DEBUG
+        nsresult rv =
+#endif
+        nsExplainErrorDetails(m_runningURL,
+                              NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_1, m_sizelimit);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error");
+
+        m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
+        return(NS_ERROR_SENDING_FROM_COMMAND);
+    }
+
+    m_nextState = SMTP_AUTH_PROCESS_STATE;
+    return status;
+}
+
+
+nsresult nsSmtpProtocol::SendTLSResponse()
+{
+  // only tear down our existing connection and open a new one if we received a 220 response
+  // from the smtp server after we issued the STARTTLS
+  nsresult rv = NS_OK;
+  if (m_responseCode == 220)
+  {
+      nsCOMPtr<nsISupports> secInfo;
+      nsCOMPtr<nsISocketTransport> strans = do_QueryInterface(m_transport, &rv);
+      if (NS_FAILED(rv)) return rv;
+
+      rv = strans->GetSecurityInfo(getter_AddRefs(secInfo));
+
+      if (NS_SUCCEEDED(rv) && secInfo) {
+          nsCOMPtr<nsISSLSocketControl> sslControl = do_QueryInterface(secInfo, &rv);
+
+          if (NS_SUCCEEDED(rv) && sslControl)
+              rv = sslControl->StartTLS();
+      }
+
+      if (NS_SUCCEEDED(rv))
+      {
+          m_nextState = SMTP_EXTN_LOGIN_RESPONSE;
+          m_nextStateAfterResponse = SMTP_EXTN_LOGIN_RESPONSE;
+          m_tlsEnabled = true;
+          m_flags = 0; // resetting the flags
+          return rv;
+      }
+  }
+
+  ClearFlag(SMTP_EHLO_STARTTLS_ENABLED);
+  m_tlsInitiated = false;
+  m_nextState = SMTP_AUTH_PROCESS_STATE;
+
+  return rv;
+}
+
+void nsSmtpProtocol::InitPrefAuthMethods(int32_t authMethodPrefValue)
+{
+  // for m_prefAuthMethods, using the same flags as server capablities.
+  switch (authMethodPrefValue)
+  {
+    case nsMsgAuthMethod::none:
+      m_prefAuthMethods = SMTP_AUTH_NONE_ENABLED;
+      break;
+    //case nsMsgAuthMethod::old -- no such thing for SMTP
+    case nsMsgAuthMethod::passwordCleartext:
+      m_prefAuthMethods = SMTP_AUTH_LOGIN_ENABLED |
+        SMTP_AUTH_PLAIN_ENABLED;
+      break;
+    case nsMsgAuthMethod::passwordEncrypted:
+      m_prefAuthMethods = SMTP_AUTH_CRAM_MD5_ENABLED;
+      break;
+    case nsMsgAuthMethod::NTLM:
+      m_prefAuthMethods = SMTP_AUTH_NTLM_ENABLED |
+          SMTP_AUTH_MSN_ENABLED;
+      break;
+    case nsMsgAuthMethod::GSSAPI:
+      m_prefAuthMethods = SMTP_AUTH_GSSAPI_ENABLED;
+      break;
+    case nsMsgAuthMethod::OAuth2:
+      m_prefAuthMethods = SMTP_AUTH_OAUTH2_ENABLED;
+      break;
+    case nsMsgAuthMethod::secure:
+      m_prefAuthMethods = SMTP_AUTH_CRAM_MD5_ENABLED |
+          SMTP_AUTH_GSSAPI_ENABLED |
+          SMTP_AUTH_NTLM_ENABLED | SMTP_AUTH_MSN_ENABLED |
+          SMTP_AUTH_EXTERNAL_ENABLED; // TODO: Expose EXTERNAL? How?
+      break;
+    default:
+      NS_ASSERTION(false, "SMTP: authMethod pref invalid");
+      // TODO log to error console
+      MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error,
+          ("SMTP: bad pref authMethod = %d\n", authMethodPrefValue));
+      // fall to any
+      MOZ_FALLTHROUGH;
+    case nsMsgAuthMethod::anything:
+      m_prefAuthMethods =
+          SMTP_AUTH_LOGIN_ENABLED | SMTP_AUTH_PLAIN_ENABLED |
+          SMTP_AUTH_CRAM_MD5_ENABLED | SMTP_AUTH_GSSAPI_ENABLED |
+          SMTP_AUTH_NTLM_ENABLED | SMTP_AUTH_MSN_ENABLED |
+          SMTP_AUTH_OAUTH2_ENABLED |
+          SMTP_AUTH_EXTERNAL_ENABLED;
+      break;
+  }
+
+  // Only enable OAuth2 support if we can do the lookup.
+  if ((m_prefAuthMethods & SMTP_AUTH_OAUTH2_ENABLED) && !mOAuth2Support)
+    m_prefAuthMethods &= ~SMTP_AUTH_OAUTH2_ENABLED;
+
+  NS_ASSERTION(m_prefAuthMethods != 0, "SMTP:InitPrefAuthMethods() failed");
+}
+
+/**
+ * Changes m_currentAuthMethod to pick the next-best one
+ * which is allowed by server and prefs and not marked failed.
+ * The order of preference and trying of auth methods is encoded here.
+ */
+nsresult nsSmtpProtocol::ChooseAuthMethod()
+{
+  int32_t serverCaps = m_flags; // from nsMsgProtocol::TestFlag()
+  int32_t availCaps = serverCaps & m_prefAuthMethods & ~m_failedAuthMethods;
+
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug,
+        ("SMTP auth: server caps 0x%X, pref 0x%X, failed 0x%X, avail caps 0x%X",
+        serverCaps, m_prefAuthMethods, m_failedAuthMethods, availCaps));
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel:: Debug,
+        ("(GSSAPI = 0x%X, CRAM = 0x%X, NTLM = 0x%X, "
+        "MSN =  0x%X, PLAIN = 0x%X, LOGIN = 0x%X, EXTERNAL = 0x%X)",
+        SMTP_AUTH_GSSAPI_ENABLED, SMTP_AUTH_CRAM_MD5_ENABLED,
+        SMTP_AUTH_NTLM_ENABLED, SMTP_AUTH_MSN_ENABLED, SMTP_AUTH_PLAIN_ENABLED,
+        SMTP_AUTH_LOGIN_ENABLED, SMTP_AUTH_EXTERNAL_ENABLED));
+
+  if (SMTP_AUTH_GSSAPI_ENABLED & availCaps)
+    m_currentAuthMethod = SMTP_AUTH_GSSAPI_ENABLED;
+  else if (SMTP_AUTH_CRAM_MD5_ENABLED & availCaps)
+    m_currentAuthMethod = SMTP_AUTH_CRAM_MD5_ENABLED;
+  else if (SMTP_AUTH_NTLM_ENABLED & availCaps)
+    m_currentAuthMethod = SMTP_AUTH_NTLM_ENABLED;
+  else if (SMTP_AUTH_MSN_ENABLED & availCaps)
+    m_currentAuthMethod = SMTP_AUTH_MSN_ENABLED;
+  else if (SMTP_AUTH_OAUTH2_ENABLED & availCaps)
+    m_currentAuthMethod = SMTP_AUTH_OAUTH2_ENABLED;
+  else if (SMTP_AUTH_PLAIN_ENABLED & availCaps)
+    m_currentAuthMethod = SMTP_AUTH_PLAIN_ENABLED;
+  else if (SMTP_AUTH_LOGIN_ENABLED & availCaps)
+    m_currentAuthMethod = SMTP_AUTH_LOGIN_ENABLED;
+  else if (SMTP_AUTH_EXTERNAL_ENABLED & availCaps)
+    m_currentAuthMethod = SMTP_AUTH_EXTERNAL_ENABLED;
+  else
+  {
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("no auth method remaining"));
+    m_currentAuthMethod = 0;
+    return NS_ERROR_SMTP_AUTH_FAILURE;
+  }
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("trying auth method 0x%X", m_currentAuthMethod));
+  return NS_OK;
+}
+
+void nsSmtpProtocol::MarkAuthMethodAsFailed(int32_t failedAuthMethod)
+{
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug,
+      ("marking auth method 0x%X failed", failedAuthMethod));
+  m_failedAuthMethods |= failedAuthMethod;
+}
+
+/**
+ * Start over, trying all auth methods again
+ */
+void nsSmtpProtocol::ResetAuthMethods()
+{
+  m_currentAuthMethod = 0;
+  m_failedAuthMethods = 0;
+}
+
+nsresult nsSmtpProtocol::ProcessAuth()
+{
+    nsresult status = NS_OK;
+    nsAutoCString buffer;
+
+    if (!m_tlsEnabled)
+    {
+        if (TestFlag(SMTP_EHLO_STARTTLS_ENABLED))
+        {
+            // Do not try to combine SMTPS with STARTTLS.
+            // If nsMsgSocketType::SSL is set,
+            // we are alrady using a secure connection.
+            // Do not attempt to do STARTTLS,
+            // even if server offers it.
+            if (m_prefSocketType == nsMsgSocketType::trySTARTTLS ||
+                m_prefSocketType == nsMsgSocketType::alwaysSTARTTLS)
+            {
+                buffer = "STARTTLS";
+                buffer += CRLF;
+
+                status = SendData(buffer.get());
+
+                m_tlsInitiated = true;
+
+                m_nextState = SMTP_RESPONSE;
+                m_nextStateAfterResponse = SMTP_TLS_RESPONSE;
+                SetFlag(SMTP_PAUSE_FOR_READ);
+                return status;
+            }
+        }
+        else if (m_prefSocketType == nsMsgSocketType::alwaysSTARTTLS)
+        {
+            m_nextState = SMTP_ERROR_DONE;
+            m_urlErrorState = NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS;
+            return NS_ERROR_STARTTLS_FAILED_EHLO_STARTTLS;
+        }
+    }
+  // (wrong indention until here)
+
+  (void) ChooseAuthMethod(); // advance m_currentAuthMethod
+
+   // We don't need to auth, per pref, or the server doesn't advertise AUTH,
+  // so skip auth and try to send message.
+  if (m_prefAuthMethods == SMTP_AUTH_NONE_ENABLED || !TestFlag(SMTP_AUTH))
+  {
+    m_nextState = SMTP_SEND_HELO_RESPONSE;
+    // fake to 250 because SendHeloResponse() tests for this
+    m_responseCode = 250;
+  }
+  else if (m_currentAuthMethod == SMTP_AUTH_EXTERNAL_ENABLED)
+  {
+    buffer = "AUTH EXTERNAL =";
+    buffer += CRLF;
+    SendData(buffer.get());
+    m_nextState = SMTP_RESPONSE;
+    m_nextStateAfterResponse = SMTP_AUTH_EXTERNAL_RESPONSE;
+    SetFlag(SMTP_PAUSE_FOR_READ);
+    return NS_OK;
+  }
+  else if (m_currentAuthMethod == SMTP_AUTH_GSSAPI_ENABLED)
+  {
+    m_nextState = SMTP_SEND_AUTH_GSSAPI_FIRST;
+  }
+  else if (m_currentAuthMethod == SMTP_AUTH_CRAM_MD5_ENABLED ||
+           m_currentAuthMethod == SMTP_AUTH_PLAIN_ENABLED ||
+           m_currentAuthMethod == SMTP_AUTH_NTLM_ENABLED)
+  {
+    m_nextState = SMTP_SEND_AUTH_LOGIN_STEP1;
+  }
+  else if (m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED ||
+           m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED)
+  {
+    m_nextState = SMTP_SEND_AUTH_LOGIN_STEP0;
+  }
+  else if (m_currentAuthMethod == SMTP_AUTH_OAUTH2_ENABLED)
+  {
+    m_nextState = SMTP_AUTH_OAUTH2_STEP;
+  }
+  else // All auth methods failed
+  {
+    // show an appropriate error msg
+    if (m_failedAuthMethods == 0)
+    {
+      // we didn't even try anything, so we had a non-working config:
+      // pref doesn't match server
+      MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error,
+          ("no working auth mech - pref doesn't match server capas"));
+
+      // pref has encrypted pw & server claims to support plaintext pw
+      if (m_prefAuthMethods == SMTP_AUTH_CRAM_MD5_ENABLED &&
+          m_flags & (SMTP_AUTH_LOGIN_ENABLED | SMTP_AUTH_PLAIN_ENABLED))
+      {
+        // have SSL
+        if (m_prefSocketType == nsMsgSocketType::SSL ||
+            m_prefSocketType == nsMsgSocketType::alwaysSTARTTLS)
+          // tell user to change to plaintext pw
+          m_urlErrorState = NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL;
+        else
+          // tell user to change to plaintext pw, with big warning
+          m_urlErrorState = NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL;
+      }
+      // pref has plaintext pw & server claims to support encrypted pw
+      else if (m_prefAuthMethods == (SMTP_AUTH_LOGIN_ENABLED |
+                   SMTP_AUTH_PLAIN_ENABLED) &&
+               m_flags & SMTP_AUTH_CRAM_MD5_ENABLED)
+        // tell user to change to encrypted pw
+        m_urlErrorState = NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT;
+      else
+      {
+        // just "change auth method"
+        m_urlErrorState = NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED;
+      }
+    }
+    else if (m_failedAuthMethods == SMTP_AUTH_GSSAPI_ENABLED)
+    {
+      // We have only GSSAPI, and it failed, so nothing left to do.
+      MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("GSSAPI only and it failed"));
+      m_urlErrorState = NS_ERROR_SMTP_AUTH_GSSAPI;
+    }
+    else
+    {
+      // we tried to login, but it all failed
+      MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("All auth attempts failed"));
+      m_urlErrorState = NS_ERROR_SMTP_AUTH_FAILURE;
+    }
+    m_nextState = SMTP_ERROR_DONE;
+    return NS_ERROR_SMTP_AUTH_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+
+
+nsresult nsSmtpProtocol::AuthLoginResponse(nsIInputStream * stream, uint32_t length)
+{
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP Login response, code %d", m_responseCode));
+  nsresult status = NS_OK;
+
+  switch (m_responseCode/100)
+  {
+    case 2:
+      m_nextState = SMTP_SEND_HELO_RESPONSE;
+      // fake to 250 because SendHeloResponse() tests for this
+      m_responseCode = 250;
+      break;
+    case 3:
+      m_nextState = SMTP_SEND_AUTH_LOGIN_STEP2;
+      break;
+    case 5:
+    default:
+      nsCOMPtr<nsISmtpServer> smtpServer;
+      m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer));
+      if (smtpServer)
+      {
+        // If one authentication failed, mark it failed, so that we're going to
+        // fall back on a less secure login method.
+        MarkAuthMethodAsFailed(m_currentAuthMethod);
+
+        bool allFailed = NS_FAILED(ChooseAuthMethod());
+        if (allFailed && m_failedAuthMethods > 0 &&
+            m_failedAuthMethods != SMTP_AUTH_GSSAPI_ENABLED &&
+            m_failedAuthMethods != SMTP_AUTH_EXTERNAL_ENABLED)
+        {
+          // We've tried all avail. methods, and they all failed, and we have no mechanism left.
+          // Ask user to try with a new password.
+          MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Warning,
+              ("SMTP: ask user what to do (after login failed): new password, retry or cancel"));
+
+          nsCOMPtr<nsISmtpServer> smtpServer;
+          nsresult rv = m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          nsCString hostname;
+          rv = smtpServer->GetHostname(hostname);
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          int32_t buttonPressed = 1;
+          if (NS_SUCCEEDED(MsgPromptLoginFailed(nullptr, hostname,
+                                                &buttonPressed)))
+          {
+            if (buttonPressed == 1) // Cancel button
+            {
+              MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Warning, ("cancel button pressed"));
+              // abort and get out of here
+              status = NS_ERROR_ABORT;
+              break;
+            }
+            else if (buttonPressed == 2) // 'New password' button
+            {
+              MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Warning, ("new password button pressed"));
+              // Change password was pressed. For now, forget the stored
+              // password and we'll prompt for a new one next time around.
+              smtpServer->ForgetPassword();
+              if (m_usernamePrompted)
+                smtpServer->SetUsername(EmptyCString());
+
+              // Let's restore the original auth flags from SendEhloResponse
+              // so we can try them again with new password and username
+              ResetAuthMethods();
+              // except for GSSAPI and EXTERNAL, which don't care about passwords.
+              MarkAuthMethodAsFailed(SMTP_AUTH_GSSAPI_ENABLED);
+              MarkAuthMethodAsFailed(SMTP_AUTH_EXTERNAL_ENABLED);
+            }
+            else if (buttonPressed == 0) // Retry button
+            {
+              MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Warning, ("retry button pressed"));
+              // try all again, including GSSAPI
+              ResetAuthMethods();
+            }
+          }
+        }
+        MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error,
+            ("SMTP: login failed: failed %X, current %X", m_failedAuthMethods, m_currentAuthMethod));
+
+        m_nextState = SMTP_AUTH_PROCESS_STATE; // try auth (ProcessAuth()) again, with other method
+      }
+      else
+          status = NS_ERROR_SMTP_PASSWORD_UNDEFINED;
+      break;
+  }
+
+  return (status);
+}
+
+nsresult nsSmtpProtocol::AuthGSSAPIFirst()
+{
+  NS_ASSERTION(m_currentAuthMethod == SMTP_AUTH_GSSAPI_ENABLED, "called in invalid state");
+  nsAutoCString command("AUTH GSSAPI ");
+  nsAutoCString resp;
+  nsAutoCString service("smtp@");
+  nsCString hostName;
+  nsCString userName;
+  nsresult rv;
+  nsCOMPtr<nsISmtpServer> smtpServer;
+  rv = m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer));
+  if (NS_FAILED(rv))
+    return NS_ERROR_FAILURE;
+
+  rv = smtpServer->GetUsername(userName);
+  if (NS_FAILED(rv))
+    return NS_ERROR_FAILURE;
+
+  rv = smtpServer->GetHostname(hostName);
+  if (NS_FAILED(rv))
+    return NS_ERROR_FAILURE;
+  service.Append(hostName);
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP: GSSAPI step 1 for user %s at server %s, service %s",
+      userName.get(), hostName.get(), service.get()));
+
+  rv = DoGSSAPIStep1(service.get(), userName.get(), resp);
+  if (NS_FAILED(rv))
+  {
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("SMTP: GSSAPI step 1 failed early"));
+    MarkAuthMethodAsFailed(SMTP_AUTH_GSSAPI_ENABLED);
+    m_nextState = SMTP_AUTH_PROCESS_STATE;
+    return NS_OK;
+  }
+  else
+    command.Append(resp);
+  command.Append(CRLF);
+  m_nextState = SMTP_RESPONSE;
+  m_nextStateAfterResponse = SMTP_SEND_AUTH_GSSAPI_STEP;
+  SetFlag(SMTP_PAUSE_FOR_READ);
+  return SendData(command.get());
+}
+
+// GSSAPI may consist of multiple round trips
+
+nsresult nsSmtpProtocol::AuthGSSAPIStep()
+{
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP: GSSAPI auth step 2"));
+  NS_ASSERTION(m_currentAuthMethod == SMTP_AUTH_GSSAPI_ENABLED, "called in invalid state");
+  nsresult rv;
+  nsAutoCString cmd;
+
+  // Check to see what the server said
+  if (m_responseCode / 100 != 3) {
+    m_nextState = SMTP_AUTH_LOGIN_RESPONSE;
+    return NS_OK;
+  }
+
+  rv = DoGSSAPIStep2(m_responseText, cmd);
+  if (NS_FAILED(rv))
+    cmd = "*";
+  cmd += CRLF;
+
+  m_nextStateAfterResponse = (rv == NS_SUCCESS_AUTH_FINISHED)?SMTP_AUTH_LOGIN_RESPONSE:SMTP_SEND_AUTH_GSSAPI_STEP;
+  m_nextState = SMTP_RESPONSE;
+  SetFlag(SMTP_PAUSE_FOR_READ);
+
+  return SendData(cmd.get());
+}
+
+
+// LOGIN and MSN consist of three steps (MSN not through the mechanism
+// but by non-RFC2821 compliant implementation in MS servers) not two as
+// PLAIN or CRAM-MD5, so we've to start here and continue with AuthStep1
+// if the server responds with with a 3xx code to "AUTH LOGIN" or "AUTH MSN"
+nsresult nsSmtpProtocol::AuthLoginStep0()
+{
+    NS_ASSERTION(m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED ||
+        m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED,
+        "called in invalid state");
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP: MSN or LOGIN auth, step 0"));
+    nsAutoCString command(m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED
+        ? "AUTH MSN" CRLF : "AUTH LOGIN" CRLF);
+    m_nextState = SMTP_RESPONSE;
+    m_nextStateAfterResponse = SMTP_AUTH_LOGIN_STEP0_RESPONSE;
+    SetFlag(SMTP_PAUSE_FOR_READ);
+
+    return SendData(command.get());
+}
+
+void nsSmtpProtocol::AuthLoginStep0Response()
+{
+    NS_ASSERTION(m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED ||
+        m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED,
+        "called in invalid state");
+    // need the test to be here instead in AuthLoginResponse() to
+    // continue with step 1 instead of 2 in case of a code 3xx
+    m_nextState = (m_responseCode/100 == 3) ?
+                  SMTP_SEND_AUTH_LOGIN_STEP1 : SMTP_AUTH_LOGIN_RESPONSE;
+}
+
+nsresult nsSmtpProtocol::AuthLoginStep1()
+{
+  char buffer[512]; // TODO nsAutoCString
+  nsresult rv;
+  nsresult status = NS_OK;
+  nsCString username;
+  char *base64Str = nullptr;
+  nsAutoCString password;
+  nsCOMPtr<nsISmtpServer> smtpServer;
+  rv = m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer));
+  if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
+
+  rv = smtpServer->GetUsername(username);
+  if (username.IsEmpty())
+  {
+    rv = GetUsernamePassword(username, password);
+    m_usernamePrompted = true;
+    if (username.IsEmpty() || password.IsEmpty())
+      return NS_ERROR_SMTP_PASSWORD_UNDEFINED;
+  }
+
+  nsCString hostname;
+  smtpServer->GetHostname(hostname);
+
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP AuthLoginStep1() for %s@%s",
+      username.get(), hostname.get()));
+
+  GetPassword(password);
+  if (password.IsEmpty())
+  {
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("SMTP: password undefined"));
+    m_urlErrorState = NS_ERROR_SMTP_PASSWORD_UNDEFINED;
+    return NS_ERROR_SMTP_PASSWORD_UNDEFINED;
+  }
+
+  if (m_currentAuthMethod == SMTP_AUTH_CRAM_MD5_ENABLED)
+  {
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Error, ("CRAM auth, step 1"));
+    PR_snprintf(buffer, sizeof(buffer), "AUTH CRAM-MD5" CRLF);
+  }
+  else if (m_currentAuthMethod == SMTP_AUTH_NTLM_ENABLED ||
+           m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED)
+  {
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("NTLM/MSN auth, step 1"));
+    nsAutoCString response;
+    rv = DoNtlmStep1(username.get(), password.get(), response);
+    PR_snprintf(buffer, sizeof(buffer), TestFlag(SMTP_AUTH_NTLM_ENABLED) ?
+                                        "AUTH NTLM %.256s" CRLF :
+                                        "%.256s" CRLF, response.get());
+  }
+  else if (m_currentAuthMethod == SMTP_AUTH_PLAIN_ENABLED)
+  {
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("PLAIN auth"));
+    char plain_string[512];
+    int len = 1; /* first <NUL> char */
+
+    memset(plain_string, 0, 512);
+    PR_snprintf(&plain_string[1], 510, "%s", username.get());
+    len += username.Length();
+    len++; /* second <NUL> char */
+    PR_snprintf(&plain_string[len], 511-len, "%s", password.get());
+    len += password.Length();
+
+    base64Str = PL_Base64Encode(plain_string, len, nullptr);
+    PR_snprintf(buffer, sizeof(buffer), "AUTH PLAIN %.256s" CRLF, base64Str);
+  }
+  else if (m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED)
+  {
+    MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("LOGIN auth"));
+    base64Str = PL_Base64Encode(username.get(),
+        username.Length(), nullptr);
+    PR_snprintf(buffer, sizeof(buffer), "%.256s" CRLF, base64Str);
+  }
+  else
+    return (NS_ERROR_COMMUNICATIONS_ERROR);
+
+  status = SendData(buffer, true);
+  m_nextState = SMTP_RESPONSE;
+  m_nextStateAfterResponse = SMTP_AUTH_LOGIN_RESPONSE;
+  SetFlag(SMTP_PAUSE_FOR_READ);
+  NS_Free(base64Str);
+
+  return (status);
+}
+
+nsresult nsSmtpProtocol::AuthLoginStep2()
+{
+  /* use cached smtp password first
+  * if not then use cached pop password
+  * if pop password undefined
+  * sync with smtp password
+  */
+  nsresult status = NS_OK;
+  nsresult rv;
+  nsAutoCString password;
+
+  GetPassword(password);
+  if (password.IsEmpty())
+  {
+    m_urlErrorState = NS_ERROR_SMTP_PASSWORD_UNDEFINED;
+    return NS_ERROR_SMTP_PASSWORD_UNDEFINED;
+  }
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("SMTP AuthLoginStep2"));
+
+  if (!password.IsEmpty())
+  {
+    char buffer[512];
+    if (m_currentAuthMethod == SMTP_AUTH_CRAM_MD5_ENABLED)
+    {
+      MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("CRAM auth, step 2"));
+      unsigned char digest[DIGEST_LENGTH];
+      char * decodedChallenge = PL_Base64Decode(m_responseText.get(),
+        m_responseText.Length(), nullptr);
+
+      if (decodedChallenge)
+        rv = MSGCramMD5(decodedChallenge, strlen(decodedChallenge), password.get(), password.Length(), digest);
+      else
+        rv = NS_ERROR_FAILURE;
+
+      PR_Free(decodedChallenge);
+      if (NS_SUCCEEDED(rv))
+      {
+        nsAutoCString encodedDigest;
+        char hexVal[8];
+
+        for (uint32_t j=0; j<16; j++)
+        {
+          PR_snprintf (hexVal,8, "%.2x", 0x0ff & (unsigned short)digest[j]);
+          encodedDigest.Append(hexVal);
+        }
+
+        nsCOMPtr<nsISmtpServer> smtpServer;
+        rv = m_runningURL->GetSmtpServer(getter_AddRefs(smtpServer));
+        if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
+
+        nsCString userName;
+        rv = smtpServer->GetUsername(userName);
+
+        PR_snprintf(buffer, sizeof(buffer), "%s %s", userName.get(), encodedDigest.get());
+        char *base64Str = PL_Base64Encode(buffer, strlen(buffer), nullptr);
+        PR_snprintf(buffer, sizeof(buffer), "%s" CRLF, base64Str);
+        NS_Free(base64Str);
+      }
+      if (NS_FAILED(rv))
+        PR_snprintf(buffer, sizeof(buffer), "*" CRLF);
+    }
+    else if (m_currentAuthMethod == SMTP_AUTH_NTLM_ENABLED ||
+             m_currentAuthMethod == SMTP_AUTH_MSN_ENABLED)
+    {
+      MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("NTLM/MSN auth, step 2"));
+      nsAutoCString response;
+      rv = DoNtlmStep2(m_responseText, response);
+      PR_snprintf(buffer, sizeof(buffer), "%.509s" CRLF, response.get());
+    }
+    else if (m_currentAuthMethod == SMTP_AUTH_PLAIN_ENABLED ||
+             m_currentAuthMethod == SMTP_AUTH_LOGIN_ENABLED)
+    {
+      MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("PLAIN/LOGIN auth, step 2"));
+      char *base64Str = PL_Base64Encode(password.get(), password.Length(), nullptr);
+      PR_snprintf(buffer, sizeof(buffer), "%.256s" CRLF, base64Str);
+      NS_Free(base64Str);
+    }
+    else
+      return NS_ERROR_COMMUNICATIONS_ERROR;
+
+    status = SendData(buffer, true);
+    m_nextState = SMTP_RESPONSE;
+    m_nextStateAfterResponse = SMTP_AUTH_LOGIN_RESPONSE;
+    SetFlag(SMTP_PAUSE_FOR_READ);
+    return (status);
+  }
+
+  // XXX -1 is not a valid nsresult
+  return static_cast<nsresult>(-1);
+}
+
+nsresult nsSmtpProtocol::AuthOAuth2Step1()
+{
+  MOZ_ASSERT(mOAuth2Support, "Can't do anything without OAuth2 support");
+
+  nsresult rv = mOAuth2Support->Connect(true, this);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  m_nextState = SMTP_SUSPENDED;
+  return NS_OK;
+}
+
+nsresult nsSmtpProtocol::OnSuccess(const nsACString &aAccessToken)
+{
+  MOZ_ASSERT(mOAuth2Support, "Can't do anything without OAuth2 support");
+
+  nsCString base64Str;
+  mOAuth2Support->BuildXOAuth2String(base64Str);
+
+  // Send the AUTH XOAUTH2 command, and then siphon us back to the regular
+  // authentication login stream.
+  nsAutoCString buffer;
+  buffer.AppendLiteral("AUTH XOAUTH2 ");
+  buffer += base64Str;
+  buffer += CRLF;
+  nsresult rv = SendData(buffer.get(), true);
+  if (NS_FAILED(rv))
+  {
+    m_nextState = SMTP_ERROR_DONE;
+  }
+  else
+  {
+    m_nextState = SMTP_RESPONSE;
+    m_nextStateAfterResponse = SMTP_AUTH_LOGIN_RESPONSE;
+  }
+
+  SetFlag(SMTP_PAUSE_FOR_READ);
+
+  ProcessProtocolState(nullptr, nullptr, 0, 0);
+  return NS_OK;
+}
+
+nsresult nsSmtpProtocol::OnFailure(nsresult aError)
+{
+  MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Debug, ("OAuth2 login error %08x",
+    (uint32_t)aError));
+  m_urlErrorState = aError;
+  m_nextState = SMTP_ERROR_DONE;
+  return ProcessProtocolState(nullptr, nullptr, 0, 0);
+}
+
+
+nsresult nsSmtpProtocol::SendMailResponse()
+{
+  nsresult status = NS_OK;
+  nsAutoCString buffer;
+  nsresult rv;
+
+  if (m_responseCode/10 != 25)
+  {
+    nsresult errorcode;
+    if (TestFlag(SMTP_EHLO_SIZE_ENABLED))
+      errorcode = (m_responseCode == 452) ? NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED :
+                  (m_responseCode == 552) ? NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2 :
+                  NS_ERROR_SENDING_FROM_COMMAND;
+    else
+      errorcode = NS_ERROR_SENDING_FROM_COMMAND;
+
+    rv = nsExplainErrorDetails(m_runningURL, errorcode, m_responseText.get());
+    NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error");
+
+    m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
+    return(NS_ERROR_SENDING_FROM_COMMAND);
+  }
+
+  /* Send the RCPT TO: command */
+  bool requestDSN = false;
+  rv = m_runningURL->GetRequestDSN(&requestDSN);
+
+  nsCOMPtr <nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch;
+  rv = prefs->GetBranch(nullptr, getter_AddRefs(prefBranch));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  bool requestOnSuccess = false;
+  rv = prefBranch->GetBoolPref("mail.dsn.request_on_success_on", &requestOnSuccess);
+
+  bool requestOnFailure = false;
+  rv = prefBranch->GetBoolPref("mail.dsn.request_on_failure_on", &requestOnFailure);
+
+  bool requestOnDelay = false;
+  rv = prefBranch->GetBoolPref("mail.dsn.request_on_delay_on", &requestOnDelay);
+
+  bool requestOnNever = false;
+  rv = prefBranch->GetBoolPref("mail.dsn.request_never_on", &requestOnNever);
+
+  nsCString &address = m_addresses[m_addressesLeft - 1];
+  if (TestFlag(SMTP_EHLO_DSN_ENABLED) && requestDSN && (requestOnSuccess || requestOnFailure || requestOnDelay || requestOnNever))
+    {
+      char *encodedAddress = esmtp_value_encode(address.get());
+      nsAutoCString dsnBuffer;
+
+      if (encodedAddress)
+      {
+        buffer = "RCPT TO:<";
+        buffer += address;
+        buffer += "> NOTIFY=";
+
+        if (requestOnNever)
+          dsnBuffer += "NEVER";
+        else
+        {
+          if (requestOnSuccess)
+            dsnBuffer += "SUCCESS";
+
+          if (requestOnFailure)
+            dsnBuffer += dsnBuffer.IsEmpty() ? "FAILURE" : ",FAILURE";
+
+          if (requestOnDelay)
+            dsnBuffer += dsnBuffer.IsEmpty() ? "DELAY" : ",DELAY";
+        }
+
+        buffer += dsnBuffer;
+        buffer += " ORCPT=rfc822;";
+        buffer += encodedAddress;
+        buffer += CRLF;
+        PR_FREEIF(encodedAddress);
+      }
+      else
+      {
+        m_urlErrorState = NS_ERROR_OUT_OF_MEMORY;
+        return (NS_ERROR_OUT_OF_MEMORY);
+      }
+    }
+    else
+    {
+      buffer = "RCPT TO:<";
+      buffer += address;
+      buffer += ">";
+      buffer += CRLF;
+    }
+    status = SendData(buffer.get());
+
+    m_nextState = SMTP_RESPONSE;
+    m_nextStateAfterResponse = SMTP_SEND_RCPT_RESPONSE;
+    SetFlag(SMTP_PAUSE_FOR_READ);
+
+    return(status);
+}
+
+nsresult nsSmtpProtocol::SendRecipientResponse()
+{
+  nsresult status = NS_OK;
+  nsAutoCString buffer;
+  nsresult rv;
+
+  if (m_responseCode / 10 != 25)
+  {
+    nsresult errorcode;
+    if (TestFlag(SMTP_EHLO_SIZE_ENABLED))
+      errorcode = (m_responseCode == 452) ? NS_ERROR_SMTP_TEMP_SIZE_EXCEEDED :
+                  (m_responseCode == 552) ? NS_ERROR_SMTP_PERM_SIZE_EXCEEDED_2 :
+                  NS_ERROR_SENDING_RCPT_COMMAND;
+    else
+      errorcode = NS_ERROR_SENDING_RCPT_COMMAND;
+
+    if (errorcode == NS_ERROR_SENDING_RCPT_COMMAND) {
+      rv = nsExplainErrorDetails(
+        m_runningURL, errorcode, NS_ConvertUTF8toUTF16(m_responseText).get(),
+        NS_ConvertUTF8toUTF16(m_addresses[m_addressesLeft - 1]).get());
+    } else {
+      rv = nsExplainErrorDetails(m_runningURL, errorcode,
+                                 m_responseText.get(),
+                                 m_addresses[m_addressesLeft - 1].get());
+    }
+
+    if (!NS_SUCCEEDED(rv))
+      NS_ASSERTION(false, "failed to explain SMTP error");
+
+    m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
+    return(NS_ERROR_SENDING_RCPT_COMMAND);
+  }
+
+  if (--m_addressesLeft > 0)
+  {
+    // more senders to RCPT to
+    // fake to 250 because SendMailResponse() can't handle 251
+    m_responseCode = 250;
+    m_nextState = SMTP_SEND_MAIL_RESPONSE;
+    return NS_OK;
+  }
+
+  /* else send the DATA command */
+  buffer = "DATA";
+  buffer += CRLF;
+  status = SendData(buffer.get());
+
+  m_nextState = SMTP_RESPONSE;
+  m_nextStateAfterResponse = SMTP_SEND_DATA_RESPONSE;
+  SetFlag(SMTP_PAUSE_FOR_READ);
+
+  return(status);
+}
+
+
+nsresult nsSmtpProtocol::SendData(const char *dataBuffer, bool aSuppressLogging)
+{
+  // XXX -1 is not a valid nsresult
+  if (!dataBuffer) return static_cast<nsresult>(-1);
+
+  if (!aSuppressLogging) {
+      MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("SMTP Send: %s", dataBuffer));
+  } else {
+      MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("Logging suppressed for this command (it probably contained authentication information)"));
+  }
+  return nsMsgAsyncWriteProtocol::SendData(dataBuffer);
+}
+
+
+nsresult nsSmtpProtocol::SendDataResponse()
+{
+  nsresult status = NS_OK;
+
+  if (m_responseCode != 354)
+  {
+    mozilla::DebugOnly<nsresult> rv = nsExplainErrorDetails(m_runningURL,
+                                                            NS_ERROR_SENDING_DATA_COMMAND,
+                                                            m_responseText.get());
+    NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error");
+
+    m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
+    return(NS_ERROR_SENDING_DATA_COMMAND);
+  }
+
+  m_nextState = SMTP_SEND_POST_DATA;
+  ClearFlag(SMTP_PAUSE_FOR_READ);   /* send data directly */
+
+  UpdateStatus(u"smtpDeliveringMail");
+
+  {
+//      m_runningURL->GetBodySize(&m_totalMessageSize);
+  }
+  return(status);
+}
+
+void nsSmtpProtocol::SendMessageInFile()
+{
+  nsCOMPtr<nsIFile> file;
+  nsCOMPtr<nsIURI> url = do_QueryInterface(m_runningURL);
+  m_runningURL->GetPostMessageFile(getter_AddRefs(file));
+  if (url && file)
+    // need to fully qualify to avoid getting overwritten by a #define
+    // in some windows header file
+    nsMsgAsyncWriteProtocol::PostMessage(url, file);
+
+  SetFlag(SMTP_PAUSE_FOR_READ);
+
+  // for now, we are always done at this point..we aren't making multiple calls
+  // to post data...
+
+  UpdateStatus(u"smtpDeliveringMail");
+  m_nextState = SMTP_RESPONSE;
+  m_nextStateAfterResponse = SMTP_SEND_MESSAGE_RESPONSE;
+}
+
+void nsSmtpProtocol::SendPostData()
+{
+	// mscott: as a first pass, I'm writing everything at once and am not
+	// doing it in chunks...
+
+	/* returns 0 on done and negative on error
+	 * positive if it needs to continue.
+	 */
+
+	// check to see if url is a file..if it is...call our file handler...
+	bool postMessageInFile = true;
+	m_runningURL->GetPostMessage(&postMessageInFile);
+	if (postMessageInFile)
+	{
+		SendMessageInFile();
+	}
+
+	/* Update the thermo and the status bar.  This is done by hand, rather
+	   than using the FE_GraphProgress* functions, because there seems to be
+	   no way to make FE_GraphProgress shut up and not display anything more
+	   when all the data has arrived.  At the end, we want to show the
+	   "message sent; waiting for reply" status; FE_GraphProgress gets in
+	   the way of that.  See bug #23414. */
+}
+
+
+
+nsresult nsSmtpProtocol::SendMessageResponse()
+{
+  if((m_responseCode/10 != 25))
+  {
+    mozilla::DebugOnly<nsresult> rv = nsExplainErrorDetails(m_runningURL,
+                                                            NS_ERROR_SENDING_MESSAGE,
+                                                            m_responseText.get());
+    NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain SMTP error");
+
+    m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
+    return(NS_ERROR_SENDING_MESSAGE);
+  }
+
+  UpdateStatus(u"smtpMailSent");
+
+  /* else */
+  return SendQuit();
+}
+
+nsresult nsSmtpProtocol::SendQuit(SmtpState aNextStateAfterResponse)
+{
+  m_sendDone = true;
+  m_nextState = SMTP_RESPONSE;
+  m_nextStateAfterResponse = aNextStateAfterResponse;
+
+  return SendData("QUIT" CRLF); // send a quit command to close the connection with the server.
+}
+
+nsresult nsSmtpProtocol::LoadUrl(nsIURI * aURL, nsISupports * aConsumer )
+{
+  if (!aURL)
+    return NS_OK;
+
+  Initialize(aURL);
+
+  m_continuationResponse = -1;  /* init */
+  m_runningURL = do_QueryInterface(aURL);
+  if (!m_runningURL)
+    return NS_ERROR_FAILURE;
+
+  // we had a bug where we failed to bring up an alert if the host
+  // name was empty....so throw up an alert saying we don't have
+  // a host name and inform the caller that we are not going to
+  // run the url...
+  nsAutoCString hostName;
+  aURL->GetHost(hostName);
+  if (hostName.IsEmpty())
+  {
+    nsCOMPtr <nsIMsgMailNewsUrl> aMsgUrl = do_QueryInterface(aURL);
+    if (aMsgUrl)
+    {
+      aMsgUrl->SetUrlState(true, NS_OK);
+      // set the url as a url currently being run...
+      aMsgUrl->SetUrlState(false /* we aren't running the url */,
+                           NS_ERROR_SMTP_AUTH_FAILURE);
+    }
+    return NS_ERROR_BUT_DONT_SHOW_ALERT;
+  }
+
+  bool postMessage = false;
+  m_runningURL->GetPostMessage(&postMessage);
+
+  if (postMessage)
+  {
+    m_nextState = SMTP_RESPONSE;
+    m_nextStateAfterResponse = SMTP_EXTN_LOGIN_RESPONSE;
+
+    // compile a minimal list of valid target addresses by
+    // - looking only at mailboxes
+    // - dropping addresses with invalid localparts (until we implement RFC 6532)
+    // - using ACE for IDN domainparts
+    // - stripping duplicates
+    nsCString addresses;
+    m_runningURL->GetRecipients(getter_Copies(addresses));
+
+    ExtractEmails(EncodedHeader(addresses), UTF16ArrayAdapter<>(m_addresses));
+
+    nsCOMPtr<nsIIDNService> converter = do_GetService(NS_IDNSERVICE_CONTRACTID);
+    addresses.Truncate();
+    uint32_t count = m_addresses.Length();
+    for (uint32_t i = 0; i < count; i++)
+    {
+      const char *start = m_addresses[i].get();
+      // Location of the @ character
+      const char *lastAt = nullptr;
+      const char *ch = start;
+      for (; *ch; ch++)
+      {
+        if (*ch == '@')
+          lastAt = ch;
+        // Check for first illegal character (outside 0x09,0x20-0x7e)
+        else if ((*ch < ' ' || *ch > '~') && (*ch != '\t'))
+        {
+          break;
+        }
+      }
+      // validate the just parsed address
+      if (*ch || m_addresses[i].IsEmpty())
+      {
+        // Fortunately, we will always have an @ in each mailbox address.
+        // We try to fix illegal character in the domain part by converting
+        // that to ACE. Illegal characters in the local part are not fixable
+        // (which charset would it be anyway?), hence we error out in that
+        // case as well.
+        nsresult rv = NS_ERROR_FAILURE; // anything but NS_OK
+        if (lastAt)
+        {
+          // Illegal char in the domain part, hence use ACE
+          nsAutoCString domain;
+          domain.Assign(lastAt + 1);
+          rv = converter->ConvertUTF8toACE(domain, domain);
+          if (NS_SUCCEEDED(rv))
+          {
+            m_addresses[i].SetLength(lastAt - start + 1);
+            m_addresses[i] += domain;
+          }
+        }
+        if (NS_FAILED(rv))
+        {
+          // Throw an error, including the broken address
+          m_nextState = SMTP_ERROR_DONE;
+          ClearFlag(SMTP_PAUSE_FOR_READ);
+          // Unfortunately, nsExplainErrorDetails will show the error above
+          // the mailnews main window, because we don't necessarily get
+          // passed down a compose window - we might be sending in the
+          // background!
+          rv = nsExplainErrorDetails(m_runningURL,
+                                     NS_ERROR_ILLEGAL_LOCALPART, start);
+          NS_ASSERTION(NS_SUCCEEDED(rv), "failed to explain illegal localpart");
+          m_urlErrorState = NS_ERROR_BUT_DONT_SHOW_ALERT;
+          return NS_ERROR_BUT_DONT_SHOW_ALERT;
+        }
+      }
+    }
+
+    // final cleanup
+    m_addressesLeft = m_addresses.Length();
+
+    // hmm no addresses to send message to...
+    if (m_addressesLeft == 0)
+    {
+      m_nextState = SMTP_ERROR_DONE;
+      ClearFlag(SMTP_PAUSE_FOR_READ);
+      m_urlErrorState = NS_MSG_NO_RECIPIENTS;
+      return NS_MSG_NO_RECIPIENTS;
+    }
+  } // if post message
+
+  return nsMsgProtocol::LoadUrl(aURL, aConsumer);
+}
+
+/*
+ * returns negative if the transfer is finished or error'd out
+ *
+ * returns zero or more if the transfer needs to be continued.
+ */
+nsresult nsSmtpProtocol::ProcessProtocolState(nsIURI * url, nsIInputStream * inputStream,
+                                              uint64_t sourceOffset, uint32_t length)
+ {
+   nsresult status = NS_OK;
+   ClearFlag(SMTP_PAUSE_FOR_READ); /* already paused; reset */
+
+   while(!TestFlag(SMTP_PAUSE_FOR_READ))
+   {
+     MOZ_LOG(SMTPLogModule, mozilla::LogLevel::Info, ("SMTP entering state: %d",
+       m_nextState));
+     switch(m_nextState)
+     {
+     case SMTP_RESPONSE:
+       if (inputStream == nullptr)
+         SetFlag(SMTP_PAUSE_FOR_READ);
+       else
+         status = SmtpResponse(inputStream, length);
+       break;
+
+     case SMTP_START_CONNECT:
+       SetFlag(SMTP_PAUSE_FOR_READ);
+       m_nextState = SMTP_RESPONSE;
+       m_nextStateAfterResponse = SMTP_EXTN_LOGIN_RESPONSE;
+       break;
+     case SMTP_FINISH_CONNECT:
+       SetFlag(SMTP_PAUSE_FOR_READ);
+       break;
+     case SMTP_TLS_RESPONSE:
+       if (inputStream == nullptr)
+         SetFlag(SMTP_PAUSE_FOR_READ);
+       else
+         status = SendTLSResponse();
+       break;
+     case SMTP_EXTN_LOGIN_RESPONSE:
+       if (inputStream == nullptr)
+         SetFlag(SMTP_PAUSE_FOR_READ);
+       else
+         status = ExtensionLoginResponse(inputStream, length);
+       break;
+
+     case SMTP_SEND_HELO_RESPONSE:
+       if (inputStream == nullptr)
+         SetFlag(SMTP_PAUSE_FOR_READ);
+       else
+         status = SendHeloResponse(inputStream, length);
+       break;
+     case SMTP_SEND_EHLO_RESPONSE:
+       if (inputStream == nullptr)
+         SetFlag(SMTP_PAUSE_FOR_READ);
+       else
+         status = SendEhloResponse(inputStream, length);
+       break;
+     case SMTP_AUTH_PROCESS_STATE:
+       status = ProcessAuth();
+       break;
+
+      case SMTP_SEND_AUTH_GSSAPI_FIRST:
+        status = AuthGSSAPIFirst();
+        break;
+
+      case SMTP_SEND_AUTH_GSSAPI_STEP:
+        status = AuthGSSAPIStep();
+        break;
+
+      case SMTP_SEND_AUTH_LOGIN_STEP0:
+        status = AuthLoginStep0();
+        break;
+
+      case SMTP_AUTH_LOGIN_STEP0_RESPONSE:
+        AuthLoginStep0Response();
+        status = NS_OK;
+        break;
+
+      case SMTP_AUTH_EXTERNAL_RESPONSE:
+      case SMTP_AUTH_LOGIN_RESPONSE:
+        if (inputStream == nullptr)
+          SetFlag(SMTP_PAUSE_FOR_READ);
+        else
+          status = AuthLoginResponse(inputStream, length);
+        break;
+
+      case SMTP_SEND_AUTH_LOGIN_STEP1:
+        status = AuthLoginStep1();
+        break;
+
+      case SMTP_SEND_AUTH_LOGIN_STEP2:
+        status = AuthLoginStep2();
+        break;
+
+      case SMTP_AUTH_OAUTH2_STEP:
+        status = AuthOAuth2Step1();
+        break;
+
+
+      case SMTP_SEND_MAIL_RESPONSE:
+        if (inputStream == nullptr)
+          SetFlag(SMTP_PAUSE_FOR_READ);
+        else
+          status = SendMailResponse();
+        break;
+
+      case SMTP_SEND_RCPT_RESPONSE:
+        if (inputStream == nullptr)
+          SetFlag(SMTP_PAUSE_FOR_READ);
+        else
+          status = SendRecipientResponse();
+        break;
+
+      case SMTP_SEND_DATA_RESPONSE:
+        if (inputStream == nullptr)
+          SetFlag(SMTP_PAUSE_FOR_READ);
+        else
+          status = SendDataResponse();
+        break;
+
+      case SMTP_SEND_POST_DATA:
+        SendPostData();
+        status = NS_OK;
+        break;
+
+      case SMTP_SEND_MESSAGE_RESPONSE:
+        if (inputStream == nullptr)
+          SetFlag(SMTP_PAUSE_FOR_READ);
+        else
+          status = SendMessageResponse();
+        break;
+      case SMTP_DONE:
+        {
+          nsCOMPtr <nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(m_runningURL);
+          mailNewsUrl->SetUrlState(false, NS_OK);
+        }
+
+        m_nextState = SMTP_FREE;
+        break;
+
+      case SMTP_ERROR_DONE:
+        {
+          nsCOMPtr <nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(m_runningURL);
+          // propagate the right error code
+          mailNewsUrl->SetUrlState(false, m_urlErrorState);
+        }
+
+        m_nextState = SMTP_FREE;
+        break;
+
+      case SMTP_FREE:
+        // smtp is a one time use connection so kill it if we get here...
+        nsMsgAsyncWriteProtocol::CloseSocket();
+        return NS_OK; /* final end */
+
+      // This state means we're going into an async loop and waiting for
+      // something (say auth) to happen. ProcessProtocolState will be
+      // retriggered when necessary.
+      case SMTP_SUSPENDED:
+        return NS_OK;
+
+      default: /* should never happen !!! */
+        m_nextState = SMTP_ERROR_DONE;
+        break;
+    }
+
+    /* check for errors during load and call error
+    * state if found
+    */
+    if (NS_FAILED(status) && m_nextState != SMTP_FREE) {
+      // send a quit command to close the connection with the server.
+      if (NS_FAILED(SendQuit(SMTP_ERROR_DONE)))
+      {
+        m_nextState = SMTP_ERROR_DONE;
+        // Don't exit - loop around again and do the free case
+        ClearFlag(SMTP_PAUSE_FOR_READ);
+      }
+    }
+  } /* while(!SMTP_PAUSE_FOR_READ) */
+
+  return NS_OK;
+}
+
+nsresult
+nsSmtpProtocol::GetPassword(nsCString &aPassword)
+{
+    nsresult rv;
+    nsCOMPtr<nsISmtpUrl> smtpUrl = do_QueryInterface(m_runningURL, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    nsCOMPtr<nsISmtpServer> smtpServer;
+    rv = smtpUrl->GetSmtpServer(getter_AddRefs(smtpServer));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = smtpServer->GetPassword(aPassword);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    if (!aPassword.IsEmpty())
+        return rv;
+    // empty password
+
+    nsCOMPtr <nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    nsCOMPtr<nsIPrefBranch> prefBranch;
+    rv = prefs->GetBranch(nullptr, getter_AddRefs(prefBranch));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    nsCString username;
+    rv = smtpServer->GetUsername(username);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    NS_ConvertASCIItoUTF16 usernameUTF16(username);
+
+    nsCString hostname;
+    rv = smtpServer->GetHostname(hostname);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString hostnameUTF16;
+    CopyASCIItoUTF16(hostname, hostnameUTF16);
+
+    const char16_t *formatStrings[] =
+    {
+      hostnameUTF16.get(),
+      usernameUTF16.get()
+    };
+
+    rv = PromptForPassword(smtpServer, smtpUrl, formatStrings, aPassword);
+    NS_ENSURE_SUCCESS(rv,rv);
+    return rv;
+}
+
+/**
+ * formatStrings is an array for the prompts, item 0 is the hostname, item 1
+ * is the username.
+ */
+nsresult
+nsSmtpProtocol::PromptForPassword(nsISmtpServer *aSmtpServer, nsISmtpUrl *aSmtpUrl, const char16_t **formatStrings, nsACString &aPassword)
+{
+  nsCOMPtr<nsIStringBundleService> stringService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(stringService, NS_ERROR_UNEXPECTED);
+
+  nsCOMPtr<nsIStringBundle> composeStringBundle;
+  nsresult rv = stringService->CreateBundle("chrome://messenger/locale/messengercompose/composeMsgs.properties", getter_AddRefs(composeStringBundle));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsString passwordPromptString;
+  if(formatStrings[1])
+    rv = composeStringBundle->FormatStringFromName(
+      u"smtpEnterPasswordPromptWithUsername",
+      formatStrings, 2, getter_Copies(passwordPromptString));
+  else
+    rv = composeStringBundle->FormatStringFromName(
+      u"smtpEnterPasswordPrompt",
+      formatStrings, 1, getter_Copies(passwordPromptString));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAuthPrompt> netPrompt;
+  rv = aSmtpUrl->GetAuthPrompt(getter_AddRefs(netPrompt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsString passwordTitle;
+  rv = composeStringBundle->GetStringFromName(
+    u"smtpEnterPasswordPromptTitle",
+    getter_Copies(passwordTitle));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = aSmtpServer->GetPasswordWithUI(passwordPromptString.get(), passwordTitle.get(),
+    netPrompt, aPassword);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return rv;
+}
+
+nsresult
+nsSmtpProtocol::GetUsernamePassword(nsACString &aUsername,
+                                    nsACString &aPassword)
+{
+    nsresult rv;
+    nsCOMPtr<nsISmtpUrl> smtpUrl = do_QueryInterface(m_runningURL, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    nsCOMPtr<nsISmtpServer> smtpServer;
+    rv = smtpUrl->GetSmtpServer(getter_AddRefs(smtpServer));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = smtpServer->GetPassword(aPassword);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    if (!aPassword.IsEmpty())
+    {
+        rv = smtpServer->GetUsername(aUsername);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        if (!aUsername.IsEmpty())
+          return rv;
+    }
+    // empty password
+
+    aPassword.Truncate();
+
+    nsCString hostname;
+    rv = smtpServer->GetHostname(hostname);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    const char16_t *formatStrings[] =
+    {
+      NS_ConvertASCIItoUTF16(hostname).get(),
+      nullptr
+    };
+
+    rv = PromptForPassword(smtpServer, smtpUrl, formatStrings, aPassword);
+    NS_ENSURE_SUCCESS(rv,rv);
+    return rv;
+}
+
diff --git a/mailnews/compose/src/nsSmtpProtocol.h b/mailnews/compose/src/nsSmtpProtocol.h
new file mode 100644
index 000000000..c23b35dda
--- /dev/null
+++ b/mailnews/compose/src/nsSmtpProtocol.h
@@ -0,0 +1,225 @@
+/* -*- 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 nsSmtpProtocol_h___
+#define nsSmtpProtocol_h___
+
+#include "mozilla/Attributes.h"
+#include "msgIOAuth2Module.h"
+#include "nsMsgProtocol.h"
+#include "nsIStreamListener.h"
+#include "nsISmtpUrl.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsMsgLineBuffer.h"
+#include "nsIAuthModule.h"
+#include "MailNewsTypes2.h" // for nsMsgSocketType
+
+#include "nsCOMPtr.h"
+#include "nsTArray.h"
+
+class nsIVariant;
+class nsIWritableVariant;
+
+ /* states of the machine
+ */
+typedef enum _SmtpState {
+SMTP_RESPONSE = 0,                                  // 0
+SMTP_START_CONNECT,                                 // 1
+SMTP_FINISH_CONNECT,                                // 2
+SMTP_SEND_HELO_RESPONSE,                            // 3
+SMTP_SEND_EHLO_RESPONSE,                            // 4
+SMTP_SEND_MAIL_RESPONSE,                            // 5
+SMTP_SEND_RCPT_RESPONSE,                            // 6
+SMTP_SEND_DATA_RESPONSE,                            // 7
+SMTP_SEND_POST_DATA,                                // 8
+SMTP_SEND_MESSAGE_RESPONSE,                         // 9
+SMTP_DONE,                                          // 10
+SMTP_ERROR_DONE,                                    // 11
+SMTP_FREE,                                          // 12
+SMTP_AUTH_LOGIN_STEP0_RESPONSE,                     // 13
+SMTP_EXTN_LOGIN_RESPONSE,                           // 14
+SMTP_SEND_AUTH_LOGIN_STEP0,                         // 15
+SMTP_SEND_AUTH_LOGIN_STEP1,                         // 16
+SMTP_SEND_AUTH_LOGIN_STEP2,                         // 17
+SMTP_AUTH_LOGIN_RESPONSE,                           // 18
+SMTP_TLS_RESPONSE,                                  // 19
+SMTP_AUTH_EXTERNAL_RESPONSE,                        // 20
+SMTP_AUTH_PROCESS_STATE,                            // 21
+SMTP_AUTH_CRAM_MD5_CHALLENGE_RESPONSE,              // 22
+SMTP_SEND_AUTH_GSSAPI_FIRST,                        // 23
+SMTP_SEND_AUTH_GSSAPI_STEP,                         // 24
+SMTP_SUSPENDED,                                     // 25
+SMTP_AUTH_OAUTH2_STEP,                              // 26
+SMTP_AUTH_OAUTH2_RESPONSE,                          // 27
+} SmtpState;
+
+// State Flags (Note, I use the word state in terms of storing 
+// state information about the connection (authentication, have we sent
+// commands, etc. I do not intend it to refer to protocol state)
+#define SMTP_PAUSE_FOR_READ             0x00000001  /* should we pause for the next read */
+#define SMTP_ESMTP_SERVER               0x00000002
+#define SMTP_EHLO_DSN_ENABLED           0x00000004
+#define SMTP_EHLO_STARTTLS_ENABLED      0x00000008
+#define SMTP_EHLO_SIZE_ENABLED          0x00000010
+#define SMTP_EHLO_8BIT_ENABLED          0x00000020
+
+// insecure mechanisms follow
+#define SMTP_AUTH_LOGIN_ENABLED         0x00000100
+#define SMTP_AUTH_PLAIN_ENABLED         0x00000200
+#define SMTP_AUTH_EXTERNAL_ENABLED      0x00000400
+// secure mechanisms follow
+#define SMTP_AUTH_GSSAPI_ENABLED        0x00000800
+#define SMTP_AUTH_DIGEST_MD5_ENABLED    0x00001000
+#define SMTP_AUTH_CRAM_MD5_ENABLED      0x00002000
+#define SMTP_AUTH_NTLM_ENABLED          0x00004000
+#define SMTP_AUTH_MSN_ENABLED           0x00008000
+#define SMTP_AUTH_OAUTH2_ENABLED        0x00010000
+// sum of all above auth mechanisms
+#define SMTP_AUTH_ANY                   0x0001FF00
+// indicates that AUTH has been advertised
+#define SMTP_AUTH                       0x00020000
+// No login necessary (pref)
+#define SMTP_AUTH_NONE_ENABLED          0x00040000
+
+class nsSmtpProtocol : public nsMsgAsyncWriteProtocol,
+                       public msgIOAuth2ModuleListener
+{
+public:
+    NS_DECL_ISUPPORTS_INHERITED
+    NS_DECL_MSGIOAUTH2MODULELISTENER
+
+    // Creating a protocol instance requires the URL which needs to be run.
+    nsSmtpProtocol(nsIURI * aURL);
+
+    virtual nsresult LoadUrl(nsIURI * aURL, nsISupports * aConsumer = nullptr) override;
+    virtual nsresult SendData(const char * dataBuffer, bool aSuppressLogging = false) override;
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+    // we suppport the nsIStreamListener interface 
+    ////////////////////////////////////////////////////////////////////////////////////////
+
+    // stop binding is a "notification" informing us that the stream associated with aURL is going away. 
+    NS_IMETHOD OnStopRequest(nsIRequest *request, nsISupports *ctxt, nsresult status) override;
+
+private:
+    virtual ~nsSmtpProtocol();
+    // if we are asked to load a url while we are blocked waiting for redirection information,
+    // then we'll store the url consumer in mPendingConsumer until we can actually load
+    // the url.
+    nsCOMPtr<nsISupports> mPendingConsumer;
+
+    // the nsISmtpURL that is currently running
+    nsCOMPtr<nsISmtpUrl> m_runningURL;
+
+    // the error state we want to set on the url
+    nsresult m_urlErrorState;
+    nsCOMPtr<nsIMsgStatusFeedback> m_statusFeedback;
+
+    // Generic state information -- What state are we in? What state do we want to go to
+    // after the next response? What was the last response code? etc. 
+    SmtpState m_nextState;
+    SmtpState m_nextStateAfterResponse;
+    int32_t m_responseCode;    /* code returned from Smtp server */
+    int32_t m_previousResponseCode; 
+    int32_t m_continuationResponse;
+    nsCString m_responseText;   /* text returned from Smtp server */
+    nsMsgLineStreamBuffer *m_lineStreamBuffer; // used to efficiently extract lines from the incoming data stream
+
+    nsTArray<nsCString> m_addresses;
+    uint32_t       m_addressesLeft;
+    nsCString m_mailAddr;
+    nsCString m_helloArgument;
+    int32_t        m_sizelimit;
+
+    // *** the following should move to the smtp server when we support
+    // multiple smtp servers
+    bool m_usernamePrompted;
+    int32_t m_prefSocketType;
+    bool m_tlsEnabled;
+
+    bool m_tlsInitiated;
+
+    bool m_sendDone;
+
+    int32_t m_totalAmountRead;
+    int64_t m_totalMessageSize;
+
+    char *m_dataBuf;
+    uint32_t m_dataBufSize;
+
+    int32_t   m_originalContentLength; /* the content length at the time of calling graph progress */
+
+    // initialization function given a new url and transport layer
+    void Initialize(nsIURI * aURL);
+    virtual nsresult ProcessProtocolState(nsIURI * url, nsIInputStream * inputStream, 
+                                          uint64_t sourceOffset, uint32_t length) override;
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+    // Communication methods --> Reading and writing protocol
+    ////////////////////////////////////////////////////////////////////////////////////////
+
+    void UpdateStatus(const char16_t* aStatusName);
+    void UpdateStatusWithString(const char16_t * aStatusString);
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+    // Protocol Methods --> This protocol is state driven so each protocol method is 
+    //						designed to re-act to the current "state". I've attempted to 
+    //						group them together based on functionality. 
+    ////////////////////////////////////////////////////////////////////////////////////////
+
+    nsresult SmtpResponse(nsIInputStream * inputStream, uint32_t length); 
+    nsresult ExtensionLoginResponse(nsIInputStream * inputStream, uint32_t length);
+    nsresult SendHeloResponse(nsIInputStream * inputStream, uint32_t length);
+    nsresult SendEhloResponse(nsIInputStream * inputStream, uint32_t length);	
+    nsresult SendQuit(SmtpState aNextStateAfterResponse = SMTP_DONE);
+
+    nsresult AuthGSSAPIFirst();
+    nsresult AuthGSSAPIStep();
+    nsresult AuthLoginStep0();
+    void     AuthLoginStep0Response();
+    nsresult AuthLoginStep1();
+    nsresult AuthLoginStep2();
+    nsresult AuthLoginResponse(nsIInputStream * stream, uint32_t length);
+    nsresult AuthOAuth2Step1();
+
+    nsresult SendTLSResponse();
+    nsresult SendMailResponse();
+    nsresult SendRecipientResponse();
+    nsresult SendDataResponse();
+    void     SendPostData();
+    nsresult SendMessageResponse();
+    nsresult ProcessAuth();
+
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+    // End of Protocol Methods
+    ////////////////////////////////////////////////////////////////////////////////////////
+
+    void SendMessageInFile();
+
+    void AppendHelloArgument(nsACString& aResult);
+    nsresult GetPassword(nsCString &aPassword);
+    nsresult GetUsernamePassword(nsACString &aUsername, nsACString &aPassword);
+    nsresult PromptForPassword(nsISmtpServer *aSmtpServer, nsISmtpUrl *aSmtpUrl, 
+                               const char16_t **formatStrings, 
+                               nsACString &aPassword);
+
+    void    InitPrefAuthMethods(int32_t authMethodPrefValue);
+    nsresult ChooseAuthMethod();
+    void    MarkAuthMethodAsFailed(int32_t failedAuthMethod);
+    void    ResetAuthMethods();
+
+    virtual const char* GetType() override {return "smtp";}
+
+    int32_t m_prefAuthMethods; // set of capability flags for auth methods
+    int32_t m_failedAuthMethods; // ditto
+    int32_t m_currentAuthMethod; // exactly one capability flag, or 0
+
+    // The support module for OAuth2 logon, only present if OAuth2 is enabled
+    // and working.
+    nsCOMPtr<msgIOAuth2Module> mOAuth2Support;
+};
+
+#endif  // nsSmtpProtocol_h___
diff --git a/mailnews/compose/src/nsSmtpServer.cpp b/mailnews/compose/src/nsSmtpServer.cpp
new file mode 100644
index 000000000..4dc3e1f64
--- /dev/null
+++ b/mailnews/compose/src/nsSmtpServer.cpp
@@ -0,0 +1,629 @@
+/* -*- 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 "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsSmtpServer.h"
+#include "nsNetUtil.h"
+#include "nsIAuthPrompt.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsISmtpService.h"
+#include "nsMsgCompCID.h"
+#include "nsILoginInfo.h"
+#include "nsILoginManager.h"
+#include "nsIArray.h"
+#include "nsArrayUtils.h"
+
+NS_IMPL_ADDREF(nsSmtpServer)
+NS_IMPL_RELEASE(nsSmtpServer)
+NS_INTERFACE_MAP_BEGIN(nsSmtpServer)
+    NS_INTERFACE_MAP_ENTRY(nsISmtpServer)
+    NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsISmtpServer)
+NS_INTERFACE_MAP_END
+
+nsSmtpServer::nsSmtpServer():
+    mKey("")
+{
+    m_logonFailed = false;
+    getPrefs();
+}
+
+nsSmtpServer::~nsSmtpServer()
+{
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetKey(char * *aKey)
+{
+    if (!aKey) return NS_ERROR_NULL_POINTER;
+    if (mKey.IsEmpty())
+        *aKey = nullptr;
+    else
+        *aKey = ToNewCString(mKey);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::SetKey(const char * aKey)
+{
+    NS_ASSERTION(aKey, "Bad key pointer");
+    mKey = aKey;
+    return getPrefs();
+}
+
+nsresult nsSmtpServer::getPrefs()
+{
+    nsresult rv;
+    nsCOMPtr<nsIPrefService> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    if (NS_FAILED(rv))
+        return rv;
+
+    nsAutoCString branchName;
+    branchName.AssignLiteral("mail.smtpserver.");
+    branchName += mKey;
+    branchName.Append('.');
+    rv = prefs->GetBranch(branchName.get(), getter_AddRefs(mPrefBranch));
+    if (NS_FAILED(rv))
+        return rv;
+
+    if(!mDefPrefBranch) {
+        branchName.AssignLiteral("mail.smtpserver.default.");
+        rv = prefs->GetBranch(branchName.get(), getter_AddRefs(mDefPrefBranch));
+        if (NS_FAILED(rv))
+            return rv;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetHostname(nsACString &aHostname)
+{
+  nsCString result;
+  nsresult rv = mPrefBranch->GetCharPref("hostname", getter_Copies(result));
+  if (NS_FAILED(rv))
+    aHostname.Truncate();
+  else
+    aHostname = result;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::SetHostname(const nsACString &aHostname)
+{
+  if (!aHostname.IsEmpty())
+    return mPrefBranch->SetCharPref("hostname", PromiseFlatCString(aHostname).get());
+
+  // If the pref value is already empty, ClearUserPref will return
+  // NS_ERROR_UNEXPECTED, so don't check the rv here.
+  mPrefBranch->ClearUserPref("hostname");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetDescription(nsACString &aDescription)
+{
+    nsCString temp;
+    mPrefBranch->GetCharPref("description", getter_Copies(temp));
+    aDescription.Assign(temp);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::SetDescription(const nsACString &aDescription)
+{
+    if (!aDescription.IsEmpty())
+        return mPrefBranch->SetCharPref("description", PromiseFlatCString(aDescription).get());
+    else
+        mPrefBranch->ClearUserPref("description");
+    return NS_OK;
+}
+
+// if GetPort returns 0, it means default port
+NS_IMETHODIMP
+nsSmtpServer::GetPort(int32_t *aPort)
+{
+  NS_ENSURE_ARG_POINTER(aPort);
+  if (NS_FAILED(mPrefBranch->GetIntPref("port", aPort)))
+    *aPort = 0;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::SetPort(int32_t aPort)
+{
+  if (aPort)
+    return mPrefBranch->SetIntPref("port", aPort);
+
+  mPrefBranch->ClearUserPref("port");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetDisplayname(char * *aDisplayname)
+{
+    nsresult rv;
+    NS_ENSURE_ARG_POINTER(aDisplayname);
+
+    nsCString hostname;
+    rv = mPrefBranch->GetCharPref("hostname", getter_Copies(hostname));
+    if (NS_FAILED(rv)) {
+        *aDisplayname=nullptr;
+        return NS_OK;
+    }
+    int32_t port;
+    rv = mPrefBranch->GetIntPref("port", &port);
+    if (NS_FAILED(rv))
+        port = 0;
+
+    if (port) {
+        hostname.Append(':');
+        hostname.AppendInt(port);
+    }
+
+    *aDisplayname = ToNewCString(hostname);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetSocketType(int32_t *socketType)
+{
+  NS_ENSURE_ARG_POINTER(socketType);
+  getIntPrefWithDefault("try_ssl", socketType, 0);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::SetSocketType(int32_t socketType)
+{
+    return mPrefBranch->SetIntPref("try_ssl", socketType);
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetHelloArgument(char * *aHelloArgument)
+{
+    nsresult rv;
+    NS_ENSURE_ARG_POINTER(aHelloArgument);
+    rv = mPrefBranch->GetCharPref("hello_argument", aHelloArgument);
+    if (NS_FAILED(rv))
+    {
+        rv = mDefPrefBranch->GetCharPref("hello_argument", aHelloArgument);
+        if (NS_FAILED(rv))
+            *aHelloArgument = nullptr;
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetAuthMethod(int32_t *authMethod)
+{
+  NS_ENSURE_ARG_POINTER(authMethod);
+  getIntPrefWithDefault("authMethod", authMethod, 3);
+  return NS_OK;
+}
+
+void
+nsSmtpServer::getIntPrefWithDefault(const char *prefName,
+                                    int32_t *val,
+                                    int32_t defVal)
+{
+  nsresult rv = mPrefBranch->GetIntPref(prefName, val);
+  if (NS_SUCCEEDED(rv))
+    return;
+
+  rv = mDefPrefBranch->GetIntPref(prefName, val);
+  if (NS_FAILED(rv))
+    // last resort
+    *val = defVal;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::SetAuthMethod(int32_t authMethod)
+{
+    return mPrefBranch->SetIntPref("authMethod", authMethod);
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetUsername(nsACString &aUsername)
+{
+  nsCString result;
+  nsresult rv = mPrefBranch->GetCharPref("username", getter_Copies(result));
+  if (NS_FAILED(rv))
+    aUsername.Truncate();
+  else
+    aUsername = result;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::SetUsername(const nsACString &aUsername)
+{
+  if (!aUsername.IsEmpty())
+    return mPrefBranch->SetCharPref("username", PromiseFlatCString(aUsername).get());
+
+  // If the pref value is already empty, ClearUserPref will return
+  // NS_ERROR_UNEXPECTED, so don't check the rv here.
+  mPrefBranch->ClearUserPref("username");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetPassword(nsACString& aPassword)
+{
+    if (m_password.IsEmpty() && !m_logonFailed)
+    {
+      // try to avoid prompting the user for another password. If the user has set
+      // the appropriate pref, we'll use the password from an incoming server, if
+      // the user has already logged onto that server.
+
+      // if this is set, we'll only use this, and not the other prefs
+      // user_pref("mail.smtpserver.smtp1.incomingAccount", "server1");
+
+      // if this is set, we'll accept an exact match of user name and server
+      // user_pref("mail.smtp.useMatchingHostNameServer", true);
+
+      // if this is set, and we don't find an exact match of user and host name,
+      // we'll accept a match of username and domain, where domain
+      // is everything after the first '.'
+      // user_pref("mail.smtp.useMatchingDomainServer", true);
+
+      nsCString accountKey;
+      bool useMatchingHostNameServer = false;
+      bool useMatchingDomainServer = false;
+      mPrefBranch->GetCharPref("incomingAccount", getter_Copies(accountKey));
+
+      nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID);
+      nsCOMPtr<nsIMsgIncomingServer> incomingServerToUse;
+      if (accountManager)
+      {
+        if (!accountKey.IsEmpty())
+          accountManager->GetIncomingServer(accountKey, getter_AddRefs(incomingServerToUse));
+        else
+        {
+          nsresult rv;
+          nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+          NS_ENSURE_SUCCESS(rv,rv);
+          prefBranch->GetBoolPref("mail.smtp.useMatchingHostNameServer", &useMatchingHostNameServer);
+          prefBranch->GetBoolPref("mail.smtp.useMatchingDomainServer", &useMatchingDomainServer);
+          if (useMatchingHostNameServer || useMatchingDomainServer)
+          {
+            nsCString userName;
+            nsCString hostName;
+            GetHostname(hostName);
+            GetUsername(userName);
+            if (useMatchingHostNameServer)
+              // pass in empty type and port=0, to match imap and pop3.
+              accountManager->FindRealServer(userName, hostName, EmptyCString(), 0, getter_AddRefs(incomingServerToUse));
+            int32_t dotPos = -1;
+            if (!incomingServerToUse && useMatchingDomainServer
+              && (dotPos = hostName.FindChar('.')) != kNotFound)
+            {
+              hostName.Cut(0, dotPos);
+              nsCOMPtr<nsIArray> allServers;
+              accountManager->GetAllServers(getter_AddRefs(allServers));
+              if (allServers)
+              {
+                uint32_t count = 0;
+                allServers->GetLength(&count);
+                uint32_t i;
+                for (i = 0; i < count; i++)
+                {
+                  nsCOMPtr<nsIMsgIncomingServer> server = do_QueryElementAt(allServers, i);
+                  if (server)
+                  {
+                    nsCString serverUserName;
+                    nsCString serverHostName;
+                    server->GetRealUsername(serverUserName);
+                    server->GetRealHostName(serverHostName);
+                    if (serverUserName.Equals(userName))
+                    {
+                      int32_t serverDotPos = serverHostName.FindChar('.');
+                      if (serverDotPos != kNotFound)
+                      {
+                        serverHostName.Cut(0, serverDotPos);
+                        if (serverHostName.Equals(hostName))
+                        {
+                          incomingServerToUse = server;
+                          break;
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (incomingServerToUse)
+        return incomingServerToUse->GetPassword(aPassword);
+    }
+    aPassword = m_password;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::VerifyLogon(nsIUrlListener *aUrlListener, nsIMsgWindow *aMsgWindow,
+                          nsIURI **aURL)
+{
+  nsresult rv;
+  nsCOMPtr<nsISmtpService> smtpService(do_GetService(NS_SMTPSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return smtpService->VerifyLogon(this, aUrlListener, aMsgWindow, aURL);
+}
+
+
+NS_IMETHODIMP
+nsSmtpServer::SetPassword(const nsACString& aPassword)
+{
+  m_password = aPassword;
+  return NS_OK;
+}
+
+nsresult
+nsSmtpServer::GetPasswordWithoutUI()
+{
+  nsresult rv;
+  nsCOMPtr<nsILoginManager> loginMgr(do_GetService(NS_LOGINMANAGER_CONTRACTID,
+                                                   &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ConvertASCIItoUTF16 serverUri(GetServerURIInternal(false));
+
+  uint32_t numLogins = 0;
+  nsILoginInfo** logins = nullptr;
+  rv = loginMgr->FindLogins(&numLogins, serverUri, EmptyString(),
+                            serverUri, &logins);
+  // Login manager can produce valid fails, e.g. NS_ERROR_ABORT when a user
+  // cancels the master password dialog. Therefore handle that here, but don't
+  // warn about it.
+  if (NS_FAILED(rv))
+    return rv;
+
+  // Don't abort here, if we didn't find any or failed, then we'll just have
+  // to prompt.
+  if (numLogins > 0)
+  {
+    nsCString serverCUsername;
+    rv = GetUsername(serverCUsername);
+    NS_ConvertASCIItoUTF16 serverUsername(serverCUsername);
+
+    nsString username;
+    for (uint32_t i = 0; i < numLogins; ++i)
+    {
+      rv = logins[i]->GetUsername(username);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (username.Equals(serverUsername))
+      {
+        nsString password;
+        rv = logins[i]->GetPassword(password);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        LossyCopyUTF16toASCII(password, m_password);
+        break;
+      }
+    }
+  }
+  NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(numLogins, logins);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetPasswordWithUI(const char16_t *aPromptMessage,
+                                const char16_t *aPromptTitle,
+                                nsIAuthPrompt* aDialog,
+                                nsACString &aPassword)
+{
+  if (!m_password.IsEmpty())
+    return GetPassword(aPassword);
+
+  // We need to get a password, but see if we can get it from the password
+  // manager without requiring a prompt.
+  nsresult rv = GetPasswordWithoutUI();
+  if (rv == NS_ERROR_ABORT)
+    return NS_MSG_PASSWORD_PROMPT_CANCELLED;
+
+  // Now re-check if we've got a password or not, if we have, then we
+  // don't need to prompt the user.
+  if (!m_password.IsEmpty())
+  {
+    aPassword = m_password;
+    return NS_OK;
+  }
+
+  NS_ENSURE_ARG_POINTER(aDialog);
+
+  // PromptPassword needs the username as well.
+  nsCString serverUri(GetServerURIInternal(true));
+
+  bool okayValue = true;
+  nsString uniPassword;
+
+  rv = aDialog->PromptPassword(aPromptTitle, aPromptMessage,
+                               NS_ConvertASCIItoUTF16(serverUri).get(),
+                               nsIAuthPrompt::SAVE_PASSWORD_PERMANENTLY,
+                               getter_Copies(uniPassword), &okayValue);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If the user pressed cancel, just return an empty string.
+  if (!okayValue)
+  {
+    aPassword.Truncate();
+    return NS_MSG_PASSWORD_PROMPT_CANCELLED;
+  }
+
+  NS_LossyConvertUTF16toASCII password(uniPassword);
+
+  rv = SetPassword(password);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aPassword = password;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetUsernamePasswordWithUI(const char16_t * aPromptMessage, const
+                                char16_t *aPromptTitle,
+                                nsIAuthPrompt* aDialog,
+                                nsACString &aUsername,
+                                nsACString &aPassword)
+{
+  nsresult rv;
+  if (!m_password.IsEmpty())
+  {
+    rv = GetUsername(aUsername);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return GetPassword(aPassword);
+  }
+
+  NS_ENSURE_ARG_POINTER(aDialog);
+
+  nsCString serverUri;
+  rv = GetServerURI(serverUri);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsString uniUsername;
+  nsString uniPassword;
+  bool okayValue = true;
+
+  rv = aDialog->PromptUsernameAndPassword(aPromptTitle, aPromptMessage,
+                                          NS_ConvertASCIItoUTF16(serverUri).get(),
+                                          nsIAuthPrompt::SAVE_PASSWORD_PERMANENTLY,
+                                          getter_Copies(uniUsername),
+                                          getter_Copies(uniPassword),
+                                          &okayValue);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If the user pressed cancel, just return emtpy strings.
+  if (!okayValue)
+  {
+    aUsername.Truncate();
+    aPassword.Truncate();
+    return rv;
+  }
+
+  // We got a username and password back...so remember them.
+  NS_LossyConvertUTF16toASCII username(uniUsername);
+
+  rv = SetUsername(username);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_LossyConvertUTF16toASCII password(uniPassword);
+
+  rv = SetPassword(password);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aUsername = username;
+  aPassword = password;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::ForgetPassword()
+{
+  nsresult rv;
+  nsCOMPtr<nsILoginManager> loginMgr =
+    do_GetService(NS_LOGINMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get the current server URI without the username
+  nsAutoCString serverUri(NS_LITERAL_CSTRING("smtp://"));
+
+  nsCString hostname;
+  rv = GetHostname(hostname);
+
+  if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) {
+    nsCString escapedHostname;
+    MsgEscapeString(hostname, nsINetUtil::ESCAPE_URL_PATH, escapedHostname);
+    // not all servers have a hostname
+    serverUri.Append(escapedHostname);
+  }
+
+  uint32_t count;
+  nsILoginInfo** logins;
+
+  NS_ConvertUTF8toUTF16 currServer(serverUri);
+
+  nsCString serverCUsername;
+  rv = GetUsername(serverCUsername);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ConvertUTF8toUTF16 serverUsername(serverCUsername);
+
+  rv = loginMgr->FindLogins(&count, currServer, EmptyString(),
+                            currServer, &logins);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // There should only be one-login stored for this url, however just in case
+  // there isn't.
+  nsString username;
+  for (uint32_t i = 0; i < count; ++i)
+  {
+    if (NS_SUCCEEDED(logins[i]->GetUsername(username)) &&
+        username.Equals(serverUsername))
+    {
+      // If this fails, just continue, we'll still want to remove the password
+      // from our local cache.
+      loginMgr->RemoveLogin(logins[i]);
+    }
+  }
+  NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(count, logins);
+
+  rv = SetPassword(EmptyCString());
+  m_logonFailed = true;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::GetServerURI(nsACString &aResult)
+{
+  aResult = GetServerURIInternal(true);
+  return NS_OK;
+}
+
+nsCString
+nsSmtpServer::GetServerURIInternal(const bool aIncludeUsername)
+{
+  nsCString uri(NS_LITERAL_CSTRING("smtp://"));
+  nsresult rv;
+
+  if (aIncludeUsername)
+  {
+    nsCString username;
+    rv = GetUsername(username);
+
+    if (NS_SUCCEEDED(rv) && !username.IsEmpty()) {
+      nsCString escapedUsername;
+      MsgEscapeString(username, nsINetUtil::ESCAPE_XALPHAS, escapedUsername);
+      // not all servers have a username
+      uri.Append(escapedUsername);
+      uri.AppendLiteral("@");
+    }
+  }
+
+  nsCString hostname;
+  rv = GetHostname(hostname);
+
+  if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) {
+    nsCString escapedHostname;
+    MsgEscapeString(hostname, nsINetUtil::ESCAPE_URL_PATH, escapedHostname);
+    // not all servers have a hostname
+    uri.Append(escapedHostname);
+  }
+
+  return uri;
+}
+
+NS_IMETHODIMP
+nsSmtpServer::ClearAllValues()
+{
+  return mPrefBranch->DeleteBranch("");
+}
diff --git a/mailnews/compose/src/nsSmtpServer.h b/mailnews/compose/src/nsSmtpServer.h
new file mode 100644
index 000000000..cbd7dba67
--- /dev/null
+++ b/mailnews/compose/src/nsSmtpServer.h
@@ -0,0 +1,40 @@
+/* -*- 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 __nsSmtpServer_h_
+#define __nsSmtpServer_h_
+
+
+#include "nsStringGlue.h"
+#include "nsISmtpServer.h"
+#include "nsIPrefBranch.h"
+#include "nsWeakReference.h"
+
+class nsSmtpServer : public nsISmtpServer,
+                     public nsSupportsWeakReference
+{
+public:
+    nsSmtpServer();
+    
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSISMTPSERVER
+
+private:
+    virtual ~nsSmtpServer();
+    nsCString mKey;
+    nsCOMPtr<nsIPrefBranch> mPrefBranch;
+    nsCOMPtr<nsIPrefBranch> mDefPrefBranch;
+                                                                                                                                               
+    nsresult getPrefs();
+    void getIntPrefWithDefault(const char *prefName, int32_t *val,
+                               int32_t defval);
+    nsresult GetPasswordWithoutUI();
+    nsCString GetServerURIInternal(const bool aIncludeUsername);
+
+    nsCString m_password;
+    bool m_logonFailed;
+};
+
+#endif
diff --git a/mailnews/compose/src/nsSmtpService.cpp b/mailnews/compose/src/nsSmtpService.cpp
new file mode 100644
index 000000000..9f9295934
--- /dev/null
+++ b/mailnews/compose/src/nsSmtpService.cpp
@@ -0,0 +1,772 @@
+/* -*- 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"    // precompiled header...
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIIOService.h"
+#include "nsIPipe.h"
+#include "nsNetCID.h"
+#include "nsMsgUtils.h"
+#include "nsNetUtil.h"
+#include "nsSmtpService.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgCompCID.h"
+#include "nsArrayEnumerator.h"
+#include "nsSmtpUrl.h"
+#include "nsSmtpProtocol.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgIdentity.h"
+#include "nsIPrompt.h"
+#include "nsIWindowWatcher.h"
+#include "nsIUTF8ConverterService.h"
+#include "nsUConvCID.h"
+#include "nsAutoPtr.h"
+#include "nsComposeStrings.h"
+#include "nsIAsyncInputStream.h"
+#include "nsIPrincipal.h"
+
+#define SERVER_DELIMITER ','
+#define APPEND_SERVERS_VERSION_PREF_NAME "append_preconfig_smtpservers.version"
+#define MAIL_ROOT_PREF "mail."
+#define PREF_MAIL_SMTPSERVERS "mail.smtpservers"
+#define PREF_MAIL_SMTPSERVERS_APPEND_SERVERS "mail.smtpservers.appendsmtpservers"
+#define PREF_MAIL_SMTP_DEFAULTSERVER "mail.smtp.defaultserver"
+
+typedef struct _findServerByKeyEntry {
+    const char *key;
+    nsISmtpServer *server;
+} findServerByKeyEntry;
+
+typedef struct _findServerByHostnameEntry {
+    nsCString hostname;
+    nsCString username;
+    nsISmtpServer *server;
+} findServerByHostnameEntry;
+
+static NS_DEFINE_CID(kCSmtpUrlCID, NS_SMTPURL_CID);
+static NS_DEFINE_CID(kCMailtoUrlCID, NS_MAILTOURL_CID);
+
+// foward declarations...
+nsresult
+NS_MsgBuildSmtpUrl(nsIFile * aFilePath,
+                   nsISmtpServer *aServer,
+                   const char* aRecipients, 
+                   nsIMsgIdentity * aSenderIdentity,
+                   nsIUrlListener * aUrlListener,
+                   nsIMsgStatusFeedback *aStatusFeedback,
+                   nsIInterfaceRequestor* aNotificationCallbacks,
+                   nsIURI ** aUrl,
+                   bool aRequestDSN);
+
+nsresult NS_MsgLoadSmtpUrl(nsIURI * aUrl, nsISupports * aConsumer, nsIRequest ** aRequest);
+
+nsSmtpService::nsSmtpService() :
+    mSmtpServersLoaded(false)
+{
+}
+
+nsSmtpService::~nsSmtpService()
+{
+    // save the SMTP servers to disk
+
+}
+
+NS_IMPL_ISUPPORTS(nsSmtpService, nsISmtpService, nsIProtocolHandler)
+
+
+NS_IMETHODIMP nsSmtpService::SendMailMessage(nsIFile * aFilePath,
+                                        const char * aRecipients, 
+                                        nsIMsgIdentity * aSenderIdentity,
+                                        const char * aPassword,
+                                        nsIUrlListener * aUrlListener, 
+                                        nsIMsgStatusFeedback *aStatusFeedback,
+                                        nsIInterfaceRequestor* aNotificationCallbacks,
+                                        bool aRequestDSN,
+                                        nsIURI ** aURL,
+                                        nsIRequest ** aRequest)
+{
+  nsIURI * urlToRun = nullptr;
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsISmtpServer> smtpServer;
+  rv = GetServerByIdentity(aSenderIdentity, getter_AddRefs(smtpServer));
+
+  if (NS_SUCCEEDED(rv) && smtpServer)
+  {
+    if (aPassword && *aPassword)
+      smtpServer->SetPassword(nsDependentCString(aPassword));
+
+    // this ref counts urlToRun
+    rv = NS_MsgBuildSmtpUrl(aFilePath, smtpServer, aRecipients, aSenderIdentity,
+                            aUrlListener, aStatusFeedback, 
+                            aNotificationCallbacks, &urlToRun, aRequestDSN);
+    if (NS_SUCCEEDED(rv) && urlToRun)	
+      rv = NS_MsgLoadSmtpUrl(urlToRun, nullptr, aRequest);
+
+    if (aURL) // does the caller want a handle on the url?
+      *aURL = urlToRun; // transfer our ref count to the caller....
+    else
+      NS_IF_RELEASE(urlToRun);
+  }
+
+  return rv;
+}
+
+
+// The following are two convience functions I'm using to help expedite building and running a mail to url...
+
+// short cut function for creating a mailto url...
+nsresult NS_MsgBuildSmtpUrl(nsIFile * aFilePath,
+                            nsISmtpServer *aSmtpServer,
+                            const char * aRecipients, 
+                            nsIMsgIdentity * aSenderIdentity,
+                            nsIUrlListener * aUrlListener, 
+                            nsIMsgStatusFeedback *aStatusFeedback,
+                            nsIInterfaceRequestor* aNotificationCallbacks,
+                            nsIURI ** aUrl,
+                            bool aRequestDSN)
+{
+  // mscott: this function is a convience hack until netlib actually dispatches
+  // smtp urls. in addition until we have a session to get a password, host and
+  // other stuff from, we need to use default values....
+  // ..for testing purposes....
+
+    nsCString smtpHostName;
+    nsCString smtpUserName;
+    int32_t smtpPort;
+    int32_t socketType;
+
+    aSmtpServer->GetHostname(smtpHostName);
+    aSmtpServer->GetUsername(smtpUserName);
+    aSmtpServer->GetPort(&smtpPort);
+    aSmtpServer->GetSocketType(&socketType);
+
+    if (!smtpPort)
+      smtpPort = (socketType == nsMsgSocketType::SSL) ?
+        nsISmtpUrl::DEFAULT_SMTPS_PORT :  nsISmtpUrl::DEFAULT_SMTP_PORT;
+
+  nsresult rv;
+  nsCOMPtr<nsISmtpUrl> smtpUrl(do_CreateInstance(kCSmtpUrlCID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString urlSpec("smtp://");
+
+  if (!smtpUserName.IsEmpty())
+  {
+    nsCString escapedUsername;
+    MsgEscapeString(smtpUserName, nsINetUtil::ESCAPE_XALPHAS,
+                    escapedUsername);
+    urlSpec.Append(escapedUsername);
+    urlSpec.Append('@');
+  }
+
+  urlSpec.Append(smtpHostName);
+  if (smtpHostName.FindChar(':') == -1)
+  {
+    urlSpec.Append(':');
+    urlSpec.AppendInt(smtpPort);
+  }
+
+  nsCOMPtr<nsIMsgMailNewsUrl> url(do_QueryInterface(smtpUrl, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = url->SetSpec(urlSpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  smtpUrl->SetRecipients(aRecipients);
+  smtpUrl->SetRequestDSN(aRequestDSN);
+  smtpUrl->SetPostMessageFile(aFilePath);
+  smtpUrl->SetSenderIdentity(aSenderIdentity);
+  if (aNotificationCallbacks)
+    smtpUrl->SetNotificationCallbacks(aNotificationCallbacks);
+  smtpUrl->SetSmtpServer(aSmtpServer);
+
+  nsCOMPtr<nsIPrompt> smtpPrompt(do_GetInterface(aNotificationCallbacks));
+  nsCOMPtr<nsIAuthPrompt> smtpAuthPrompt(do_GetInterface(aNotificationCallbacks));
+  if (!smtpPrompt || !smtpAuthPrompt)
+  {
+    nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!smtpPrompt)
+      wwatch->GetNewPrompter(0, getter_AddRefs(smtpPrompt));
+    if (!smtpAuthPrompt)
+      wwatch->GetNewAuthPrompter(0, getter_AddRefs(smtpAuthPrompt));
+  }
+
+  smtpUrl->SetPrompt(smtpPrompt);            
+  smtpUrl->SetAuthPrompt(smtpAuthPrompt);
+
+  if (aUrlListener)
+    url->RegisterListener(aUrlListener);
+  if (aStatusFeedback)
+    url->SetStatusFeedback(aStatusFeedback);
+
+  return CallQueryInterface(smtpUrl, aUrl);
+}
+
+nsresult NS_MsgLoadSmtpUrl(nsIURI * aUrl, nsISupports * aConsumer, nsIRequest ** aRequest)
+{
+  NS_ENSURE_ARG_POINTER(aUrl);
+
+  // For now, assume the url is an smtp url and load it.
+  nsresult rv;
+  nsCOMPtr<nsISmtpUrl> smtpUrl(do_QueryInterface(aUrl, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Create a smtp protocol instance to run the url in.
+  RefPtr<nsSmtpProtocol> smtpProtocol = new nsSmtpProtocol(aUrl);
+  if (!smtpProtocol)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  // Protocol will get destroyed when url is completed.
+  rv = smtpProtocol->LoadUrl(aUrl, aConsumer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return CallQueryInterface(smtpProtocol.get(), aRequest);
+}
+
+NS_IMETHODIMP nsSmtpService::VerifyLogon(nsISmtpServer *aServer,
+                                         nsIUrlListener *aUrlListener,
+                                         nsIMsgWindow *aMsgWindow,
+                                         nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aServer);
+  nsCString popHost;
+  nsCString popUser;
+  nsCOMPtr <nsIURI> urlToRun;
+
+  nsresult rv = NS_MsgBuildSmtpUrl(nullptr, aServer,
+                          nullptr, nullptr, aUrlListener, nullptr,
+                          nullptr , getter_AddRefs(urlToRun), false);
+  if (NS_SUCCEEDED(rv) && urlToRun)
+  {
+    nsCOMPtr<nsIMsgMailNewsUrl> url(do_QueryInterface(urlToRun, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    url->SetMsgWindow(aMsgWindow);
+    rv = NS_MsgLoadSmtpUrl(urlToRun, nullptr, nullptr /* aRequest */);
+    if (aURL)
+      urlToRun.forget(aURL);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsSmtpService::GetScheme(nsACString &aScheme)
+{
+    aScheme = "mailto";
+    return NS_OK; 
+}
+
+NS_IMETHODIMP nsSmtpService::GetDefaultPort(int32_t *aDefaultPort)
+{
+    nsresult rv = NS_OK;
+    if (aDefaultPort)
+        *aDefaultPort = nsISmtpUrl::DEFAULT_SMTP_PORT;
+    else
+        rv = NS_ERROR_NULL_POINTER;
+    return rv;
+}
+
+NS_IMETHODIMP 
+nsSmtpService::AllowPort(int32_t port, const char *scheme, bool *_retval)
+{
+    // allow smtp to run on any port
+    *_retval = true;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsSmtpService::GetProtocolFlags(uint32_t *result)
+{
+    *result = URI_NORELATIVE | ALLOWS_PROXY | URI_LOADABLE_BY_ANYONE |
+      URI_NON_PERSISTABLE | URI_DOES_NOT_RETURN_DATA |
+      URI_FORBIDS_COOKIE_ACCESS;
+    return NS_OK;
+}
+
+// the smtp service is also the protocol handler for mailto urls....
+
+NS_IMETHODIMP nsSmtpService::NewURI(const nsACString &aSpec,
+                                    const char *aOriginCharset,
+                                    nsIURI *aBaseURI,
+                                    nsIURI **_retval)
+{
+  // get a new smtp url
+  nsresult rv;
+  nsCOMPtr<nsIURI> mailtoUrl = do_CreateInstance(kCMailtoUrlCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString utf8Spec;
+  if (aOriginCharset)
+  {
+    nsCOMPtr<nsIUTF8ConverterService>
+      utf8Converter(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID, &rv));
+    if (NS_SUCCEEDED(rv))
+      rv = utf8Converter->ConvertURISpecToUTF8(aSpec, aOriginCharset, utf8Spec);
+  }
+
+  // utf8Spec is filled up only when aOriginCharset is specified and
+  // the conversion is successful. Otherwise, fall back to aSpec.
+  if (aOriginCharset && NS_SUCCEEDED(rv))
+    rv = mailtoUrl->SetSpec(utf8Spec);
+  else
+    rv = mailtoUrl->SetSpec(aSpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mailtoUrl.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSmtpService::NewChannel(nsIURI *aURI, nsIChannel **_retval)
+{
+  return NewChannel2(aURI, nullptr, _retval);
+}
+
+NS_IMETHODIMP nsSmtpService::NewChannel2(nsIURI *aURI,
+                                         nsILoadInfo* aLoadInfo,
+                                         nsIChannel **_retval)
+{
+  NS_ENSURE_ARG_POINTER(aURI);
+  // create an empty pipe for use with the input stream channel.
+  nsCOMPtr<nsIAsyncInputStream> pipeIn;
+  nsCOMPtr<nsIAsyncOutputStream> pipeOut;
+  nsCOMPtr<nsIPipe> pipe = do_CreateInstance("@mozilla.org/pipe;1");
+  nsresult rv = pipe->Init(false, false, 0, 0);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // These always succeed because the pipe is initialized above.
+  MOZ_ALWAYS_SUCCEEDS(pipe->GetInputStream(getter_AddRefs(pipeIn)));
+  MOZ_ALWAYS_SUCCEEDS(pipe->GetOutputStream(getter_AddRefs(pipeOut)));
+
+  pipeOut->Close();
+
+  if (aLoadInfo) {
+    return NS_NewInputStreamChannelInternal(_retval,
+                                            aURI,
+                                            pipeIn,
+                                            NS_LITERAL_CSTRING("application/x-mailto"),
+                                            EmptyCString(),
+                                            aLoadInfo);
+  }
+
+  nsCOMPtr<nsIPrincipal> nullPrincipal =
+    do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
+  NS_ASSERTION(NS_SUCCEEDED(rv), "CreateInstance of nullprincipal failed.");
+  if (NS_FAILED(rv))
+    return rv;
+
+  return NS_NewInputStreamChannel(_retval, aURI, pipeIn,
+                                  nullPrincipal, nsILoadInfo::SEC_NORMAL,
+                                  nsIContentPolicy::TYPE_OTHER,
+                                  NS_LITERAL_CSTRING("application/x-mailto"));
+}
+
+NS_IMETHODIMP
+nsSmtpService::GetServers(nsISimpleEnumerator **aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  // now read in the servers from prefs if necessary
+  uint32_t serverCount = mSmtpServers.Count();
+
+  if (serverCount <= 0)
+    loadSmtpServers();
+
+  return NS_NewArrayEnumerator(aResult, mSmtpServers);
+}
+
+nsresult
+nsSmtpService::loadSmtpServers()
+{
+  if (mSmtpServersLoaded)
+    return NS_OK;
+    
+  nsresult rv;
+  nsCOMPtr<nsIPrefService> prefService(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  if (NS_FAILED(rv))
+    return rv;
+  nsCOMPtr<nsIPrefBranch> prefRootBranch;
+  prefService->GetBranch(nullptr, getter_AddRefs(prefRootBranch));
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCString serverList;
+  rv = prefRootBranch->GetCharPref(PREF_MAIL_SMTPSERVERS, getter_Copies(serverList));
+  serverList.StripWhitespace();
+
+  nsTArray<nsCString> servers;
+  ParseString(serverList, SERVER_DELIMITER, servers);
+
+  /**
+   * Check to see if we need to add pre-configured smtp servers.
+   * Following prefs are important to note in understanding the procedure here.
+   *
+   * 1. pref("mailnews.append_preconfig_smtpservers.version", version number);
+   * This pref registers the current version in the user prefs file. A default value
+   * is stored in mailnews.js file. If a given vendor needs to add more preconfigured
+   * smtp servers, the default version number can be increased. Comparing version
+   * number from user's prefs file and the default one from mailnews.js, we
+   * can add new smtp servers and any other version level changes that need to be done.
+   *
+   * 2. pref("mail.smtpservers.appendsmtpservers", <comma separated servers list>);
+   * This pref contains the list of pre-configured smp servers that ISP/Vendor wants to
+   * to add to the existing servers list.
+   */
+  nsCOMPtr<nsIPrefBranch> defaultsPrefBranch;
+  rv = prefService->GetDefaultBranch(MAIL_ROOT_PREF, getter_AddRefs(defaultsPrefBranch));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch;
+  rv = prefService->GetBranch(MAIL_ROOT_PREF, getter_AddRefs(prefBranch));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  int32_t appendSmtpServersCurrentVersion = 0;
+  int32_t appendSmtpServersDefaultVersion = 0;
+  rv = prefBranch->GetIntPref(APPEND_SERVERS_VERSION_PREF_NAME, &appendSmtpServersCurrentVersion);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = defaultsPrefBranch->GetIntPref(APPEND_SERVERS_VERSION_PREF_NAME, &appendSmtpServersDefaultVersion);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // Update the smtp server list if needed
+  if (appendSmtpServersCurrentVersion <= appendSmtpServersDefaultVersion) {
+    // If there are pre-configured servers, add them to the existing server list
+    nsCString appendServerList;
+    rv = prefRootBranch->GetCharPref(PREF_MAIL_SMTPSERVERS_APPEND_SERVERS, getter_Copies(appendServerList));
+    appendServerList.StripWhitespace();
+    ParseString(appendServerList, SERVER_DELIMITER, servers);
+
+    // Increase the version number so that updates will happen as and when needed
+    prefBranch->SetIntPref(APPEND_SERVERS_VERSION_PREF_NAME, appendSmtpServersCurrentVersion + 1);
+  }
+
+  // use GetServerByKey to check if the key (pref) is already in
+  // in the list. If not it calls createKeyedServer directly.
+
+  for (uint32_t i = 0; i < servers.Length(); i++) {
+    nsCOMPtr<nsISmtpServer> server;
+    GetServerByKey(servers[i].get(), getter_AddRefs(server));
+  }
+
+  saveKeyList();
+
+  mSmtpServersLoaded = true;
+  return NS_OK;
+}
+
+// save the list of keys
+nsresult
+nsSmtpService::saveKeyList()
+{
+    nsresult rv;
+    nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    if (NS_FAILED(rv)) return rv;
+    
+    return prefBranch->SetCharPref(PREF_MAIL_SMTPSERVERS, mServerKeyList.get());
+}
+
+nsresult
+nsSmtpService::createKeyedServer(const char *key, nsISmtpServer** aResult)
+{
+    if (!key) return NS_ERROR_NULL_POINTER;
+    
+    nsresult rv;
+    nsCOMPtr<nsISmtpServer> server = do_CreateInstance(NS_SMTPSERVER_CONTRACTID, &rv);
+    if (NS_FAILED(rv)) return rv;
+    
+    server->SetKey(key);
+    mSmtpServers.AppendObject(server);
+
+    if (mServerKeyList.IsEmpty())
+        mServerKeyList = key;
+    else {
+        mServerKeyList.Append(',');
+        mServerKeyList += key;
+    }
+
+    if (aResult) 
+       server.swap(*aResult);
+    
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpService::GetSessionDefaultServer(nsISmtpServer **aServer)
+{
+    NS_ENSURE_ARG_POINTER(aServer);
+    
+    if (!mSessionDefaultServer)
+        return GetDefaultServer(aServer);
+
+    NS_ADDREF(*aServer = mSessionDefaultServer);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpService::SetSessionDefaultServer(nsISmtpServer *aServer)
+{
+    mSessionDefaultServer = aServer;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpService::GetDefaultServer(nsISmtpServer **aServer)
+{
+  NS_ENSURE_ARG_POINTER(aServer);
+
+  loadSmtpServers();
+  
+  *aServer = nullptr;
+  // always returns NS_OK, just leaving *aServer at nullptr
+  if (!mDefaultSmtpServer) {
+      nsresult rv;
+      nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+      if (NS_FAILED(rv)) return rv;
+
+      // try to get it from the prefs
+      nsCString defaultServerKey;
+      rv = prefBranch->GetCharPref(PREF_MAIL_SMTP_DEFAULTSERVER, getter_Copies(defaultServerKey));
+      if (NS_SUCCEEDED(rv) &&
+          !defaultServerKey.IsEmpty()) {
+
+          nsCOMPtr<nsISmtpServer> server;
+          rv = GetServerByKey(defaultServerKey.get(),
+                              getter_AddRefs(mDefaultSmtpServer));
+      } else {
+        // no pref set, so just return the first one, and set the pref
+
+        // Ensure the list of servers is loaded
+        loadSmtpServers();
+
+        // nothing in the array, we had better create a new server
+        // (which will add it to the array & prefs anyway)
+        if (mSmtpServers.Count() == 0)
+          // if there are no smtp servers then don't create one for the default.
+          return NS_OK;
+
+        mDefaultSmtpServer = mSmtpServers[0];
+        NS_ENSURE_TRUE(mDefaultSmtpServer, NS_ERROR_NULL_POINTER);
+          
+        // now we have a default server, set the prefs correctly
+        nsCString serverKey;
+        mDefaultSmtpServer->GetKey(getter_Copies(serverKey));
+        if (NS_SUCCEEDED(rv))
+          prefBranch->SetCharPref(PREF_MAIL_SMTP_DEFAULTSERVER, serverKey.get());
+      }
+  }
+
+  // at this point:
+  // * mDefaultSmtpServer has a valid server
+  // * the key has been set in the prefs
+    
+  NS_IF_ADDREF(*aServer = mDefaultSmtpServer);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpService::SetDefaultServer(nsISmtpServer *aServer)
+{
+    NS_ENSURE_ARG_POINTER(aServer);
+
+    mDefaultSmtpServer = aServer;
+
+    nsCString serverKey;
+    nsresult rv = aServer->GetKey(getter_Copies(serverKey));
+    NS_ENSURE_SUCCESS(rv,rv);
+    
+    nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv,rv);
+    prefBranch->SetCharPref(PREF_MAIL_SMTP_DEFAULTSERVER, serverKey.get());
+    return NS_OK;
+}
+
+bool
+nsSmtpService::findServerByKey(nsISmtpServer *aServer, void *aData)
+{
+  findServerByKeyEntry *entry = (findServerByKeyEntry*) aData;
+
+  nsCString key;
+  nsresult rv = aServer->GetKey(getter_Copies(key));
+  if (NS_FAILED(rv))
+    return true;
+
+  if (key.Equals(entry->key)) 
+  {
+    entry->server = aServer;
+    return false;
+  }
+    
+  return true;
+}
+
+NS_IMETHODIMP
+nsSmtpService::CreateServer(nsISmtpServer **aResult)
+{
+    if (!aResult) return NS_ERROR_NULL_POINTER;
+
+    loadSmtpServers();
+    nsresult rv;
+    int32_t i = 0;
+    bool unique = false;
+
+    findServerByKeyEntry entry;
+    nsAutoCString key;
+
+    do {
+        key = "smtp";
+        key.AppendInt(++i);
+        entry.key = key.get();
+        entry.server = nullptr;
+
+        mSmtpServers.EnumerateForwards(findServerByKey, (void *)&entry);
+        if (!entry.server) unique=true;
+
+    } while (!unique);
+
+    rv = createKeyedServer(key.get(), aResult);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return saveKeyList();
+}
+
+
+nsresult
+nsSmtpService::GetServerByKey(const char* aKey, nsISmtpServer **aResult)
+{
+    NS_ENSURE_ARG_POINTER(aResult);
+
+    if (!aKey || !*aKey)
+    {
+      NS_ASSERTION(false, "bad key");
+      return NS_ERROR_FAILURE;
+    }
+    findServerByKeyEntry entry;
+    entry.key = aKey;
+    entry.server = nullptr;
+    mSmtpServers.EnumerateForwards(findServerByKey, (void *)&entry);
+
+    if (entry.server) {
+        NS_ADDREF(*aResult = entry.server);
+        return NS_OK;
+    }
+
+    // not found in array, I guess we load it
+    return createKeyedServer(aKey, aResult);
+}
+
+NS_IMETHODIMP
+nsSmtpService::DeleteServer(nsISmtpServer *aServer)
+{
+    if (!aServer) return NS_OK;
+
+    int32_t idx = mSmtpServers.IndexOf(aServer);
+    if (idx == -1)
+      return NS_OK;
+
+    nsCString serverKey;
+    aServer->GetKey(getter_Copies(serverKey));
+    
+    mSmtpServers.RemoveObjectAt(idx);
+
+    if (mDefaultSmtpServer.get() == aServer)
+        mDefaultSmtpServer = nullptr;
+    if (mSessionDefaultServer.get() == aServer)
+        mSessionDefaultServer = nullptr;
+    
+    nsAutoCString newServerList;
+    nsCString tmpStr = mServerKeyList;
+    char *newStr = tmpStr.BeginWriting();
+    char *token = NS_strtok(",", &newStr);
+    while (token) {
+      // only re-add the string if it's not the key
+      if (strcmp(token, serverKey.get()) != 0) {
+          if (newServerList.IsEmpty())
+              newServerList = token;
+          else {
+            newServerList += ',';
+            newServerList += token;
+          }
+      }
+      token = NS_strtok(",", &newStr);
+    }
+
+    // make sure the server clears out it's values....
+    aServer->ClearAllValues();
+
+    mServerKeyList = newServerList;
+    saveKeyList();
+    return NS_OK;
+}
+
+bool
+nsSmtpService::findServerByHostname(nsISmtpServer *aServer, void *aData)
+{
+  findServerByHostnameEntry *entry = (findServerByHostnameEntry*)aData;
+
+  nsCString hostname;
+  nsresult rv = aServer->GetHostname(hostname);
+  if (NS_FAILED(rv))
+    return true;
+
+  nsCString username;
+  rv = aServer->GetUsername(username);
+  if (NS_FAILED(rv))
+    return true;
+
+  bool checkHostname = !entry->hostname.IsEmpty();
+  bool checkUsername = !entry->username.IsEmpty();
+    
+  if ((!checkHostname ||
+       (entry->hostname.Equals(hostname, nsCaseInsensitiveCStringComparator()))) &&
+       (!checkUsername ||
+        entry->username.Equals(username, nsCaseInsensitiveCStringComparator())))
+  {
+    entry->server = aServer;
+    return false;        // stop when found
+  }
+  return true;
+}
+
+NS_IMETHODIMP
+nsSmtpService::FindServer(const char *aUsername,
+                          const char *aHostname, nsISmtpServer ** aResult)
+{
+    NS_ENSURE_ARG_POINTER(aResult);
+
+    findServerByHostnameEntry entry;
+    entry.server = nullptr;
+    entry.hostname = aHostname;
+    entry.username = aUsername;
+
+    mSmtpServers.EnumerateForwards(findServerByHostname, (void *)&entry);
+
+    // entry.server may be null, but that's ok.
+    // just return null if no server is found
+    NS_IF_ADDREF(*aResult = entry.server);
+    
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSmtpService::GetServerByIdentity(nsIMsgIdentity *aSenderIdentity,
+                                   nsISmtpServer **aSmtpServer)
+{
+  NS_ENSURE_ARG_POINTER(aSmtpServer);
+  nsresult rv = NS_ERROR_FAILURE;
+
+  // First try the identity's preferred server
+  if (aSenderIdentity) 
+  {
+      nsCString smtpServerKey;
+      rv = aSenderIdentity->GetSmtpServerKey(smtpServerKey);
+      if (NS_SUCCEEDED(rv) && !(smtpServerKey.IsEmpty()))
+          rv = GetServerByKey(smtpServerKey.get(), aSmtpServer);
+  }
+
+  // Fallback to the default
+  if (NS_FAILED(rv) || !(*aSmtpServer))
+      rv = GetDefaultServer(aSmtpServer);
+  return rv;
+}
diff --git a/mailnews/compose/src/nsSmtpService.h b/mailnews/compose/src/nsSmtpService.h
new file mode 100644
index 000000000..8aca6e7ef
--- /dev/null
+++ b/mailnews/compose/src/nsSmtpService.h
@@ -0,0 +1,63 @@
+/* -*- 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 nsSmtpService_h___
+#define nsSmtpService_h___
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsCOMArray.h"
+#include "nsISmtpService.h"
+#include "nsISmtpServer.h"
+#include "nsIProtocolHandler.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Smtp Service is an interfaced designed to make building and running mail to urls
+// easier. I'm not sure if this service will go away when the new networking model comes
+// on line (as part of the N2 project). So I reserve the right to change my mind and take
+// this service away =).
+////////////////////////////////////////////////////////////////////////////////////////
+
+class nsSmtpService : public nsISmtpService, public nsIProtocolHandler
+{
+public:
+
+	nsSmtpService();
+	
+	NS_DECL_ISUPPORTS
+
+	////////////////////////////////////////////////////////////////////////
+	// we suppport the nsISmtpService interface 
+	////////////////////////////////////////////////////////////////////////    
+	NS_DECL_NSISMTPSERVICE
+
+	//////////////////////////////////////////////////////////////////////////
+	// we suppport the nsIProtocolHandler interface 
+	//////////////////////////////////////////////////////////////////////////
+  NS_DECL_NSIPROTOCOLHANDLER
+
+protected:
+    nsresult loadSmtpServers();
+
+    
+private:
+	virtual ~nsSmtpService();
+    static bool findServerByKey(nsISmtpServer *aServer, void *aData);
+    static bool findServerByHostname(nsISmtpServer *aServer, void *aData);
+    
+    nsresult createKeyedServer(const char* key,
+                               nsISmtpServer **aResult = nullptr);
+    nsresult saveKeyList();
+    
+    nsCOMArray<nsISmtpServer> mSmtpServers;
+    nsCOMPtr<nsISmtpServer> mDefaultSmtpServer;
+    nsCOMPtr<nsISmtpServer> mSessionDefaultServer;
+
+    nsCString mServerKeyList;
+
+    bool mSmtpServersLoaded;
+};
+
+#endif /* nsSmtpService_h___ */
diff --git a/mailnews/compose/src/nsSmtpUrl.cpp b/mailnews/compose/src/nsSmtpUrl.cpp
new file mode 100644
index 000000000..cd40bd6cc
--- /dev/null
+++ b/mailnews/compose/src/nsSmtpUrl.cpp
@@ -0,0 +1,778 @@
+/* -*- 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 "nsStringGlue.h"
+#include "nsMsgUtils.h"
+#include "nsIMimeConverter.h"
+#include "nsMsgMimeCID.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsCRT.h"
+#include "nsAutoPtr.h"
+
+/////////////////////////////////////////////////////////////////////////////////////
+// mailto url definition
+/////////////////////////////////////////////////////////////////////////////////////
+nsMailtoUrl::nsMailtoUrl()
+{
+  mFormat = nsIMsgCompFormat::Default;
+  m_baseURL = do_CreateInstance(NS_SIMPLEURI_CONTRACTID);
+}
+
+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.Length() == 0)
+        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
+
+  // Get a global converter
+  nsCOMPtr<nsIMimeConverter> mimeConverter =
+    do_GetService(NS_MIME_CONVERTER_CONTRACTID);
+
+  // 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;
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetSpec(const nsACString &aSpec)
+{
+  nsresult rv = m_baseURL->SetSpec(aSpec);
+  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->GetPath(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);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetScheme(const nsACString &aScheme)
+{
+	m_baseURL->SetScheme(aScheme);
+	return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetUserPass(nsACString &aUserPass)
+{
+	return m_baseURL->GetUserPass(aUserPass);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetUserPass(const nsACString &aUserPass)
+{
+	m_baseURL->SetUserPass(aUserPass);
+	return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetUsername(nsACString &aUsername)
+{
+	return m_baseURL->GetUsername(aUsername);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetUsername(const nsACString &aUsername)
+{
+	m_baseURL->SetUsername(aUsername);
+	return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPassword(nsACString &aPassword)
+{
+	return m_baseURL->GetPassword(aPassword);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetPassword(const nsACString &aPassword)
+{
+	m_baseURL->SetPassword(aPassword);
+	return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetHostPort(nsACString &aHostPort)
+{
+	return m_baseURL->GetHost(aHostPort);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetHostPort(const nsACString &aHostPort)
+{
+	m_baseURL->SetHost(aHostPort);
+	return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetHostAndPort(const nsACString &aHostPort)
+{
+	m_baseURL->SetHostAndPort(aHostPort);
+	return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetHost(nsACString &aHost)
+{
+	return m_baseURL->GetHost(aHost);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetHost(const nsACString &aHost)
+{
+	m_baseURL->SetHost(aHost);
+	return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPort(int32_t *aPort)
+{
+	return m_baseURL->GetPort(aPort);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetPort(int32_t aPort)
+{
+	m_baseURL->SetPort(aPort);
+	return ParseUrl();
+}
+
+NS_IMETHODIMP nsMailtoUrl::GetPath(nsACString &aPath)
+{
+	return m_baseURL->GetPath(aPath);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetPath(const nsACString &aPath)
+{
+	m_baseURL->SetPath(aPath);
+	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::GetOriginCharset(nsACString &aOriginCharset)
+{
+    return m_baseURL->GetOriginCharset(aOriginCharset);
+}
+
+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::CloneInternal(RefHandlingEnum aRefHandlingMode,
+                           const nsACString& newRef, nsIURI** _retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  RefPtr<nsMailtoUrl> clone = new nsMailtoUrl();
+
+  NS_ENSURE_TRUE(clone, NS_ERROR_OUT_OF_MEMORY);
+
+  nsresult rv;
+  if (aRefHandlingMode == eHonorRef) {
+    rv = m_baseURL->Clone(getter_AddRefs(clone->m_baseURL));
+  } else if (aRefHandlingMode == eReplaceRef) {
+    rv = m_baseURL->CloneWithNewRef(newRef, getter_AddRefs(clone->m_baseURL));
+  } else {
+    rv = m_baseURL->CloneIgnoringRef(getter_AddRefs(clone->m_baseURL));
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+  clone->ParseUrl();
+  clone.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::Clone(nsIURI **_retval)
+{
+  return CloneInternal(eHonorRef, EmptyCString(), _retval);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::CloneIgnoringRef(nsIURI** _retval)
+{
+  return CloneInternal(eIgnoreRef, EmptyCString(), _retval);
+}
+
+NS_IMETHODIMP
+nsMailtoUrl::CloneWithNewRef(const nsACString& newRef, nsIURI** _retval)
+{
+  return CloneInternal(eReplaceRef, newRef, _retval);
+}
+
+NS_IMETHODIMP nsMailtoUrl::Resolve(const nsACString &relativePath, nsACString &result)
+{
+  return m_baseURL->Resolve(relativePath, result);
+}
+
+NS_IMETHODIMP nsMailtoUrl::SetRef(const nsACString &aRef)
+{
+  return m_baseURL->SetRef(aRef);
+}
+
+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::GetHasRef(bool *result)
+{
+  return m_baseURL->GetHasRef(result);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+// 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_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);
+  *aSenderIdentity = m_senderIdentity;
+  NS_ADDREF(*aSenderIdentity);
+  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);
+    *aNetPrompt = m_netPrompt;
+    NS_ADDREF(*aNetPrompt);
+    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);
+    *aNetAuthPrompt = m_netAuthPrompt;
+    NS_ADDREF(*aNetAuthPrompt);
+    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);
+    *aCallbacks = m_callbacks;
+    NS_ADDREF(*aCallbacks);
+    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);
+    *aSmtpServer = m_smtpServer;
+    NS_ADDREF(*aSmtpServer);
+    return NS_OK;
+}
diff --git a/mailnews/compose/src/nsSmtpUrl.h b/mailnews/compose/src/nsSmtpUrl.h
new file mode 100644
index 000000000..d603fa365
--- /dev/null
+++ b/mailnews/compose/src/nsSmtpUrl.h
@@ -0,0 +1,100 @@
+/* -*- 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"
+
+class nsMailtoUrl : public nsIMailtoUrl, public nsIURI
+{
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIURI
+    NS_DECL_NSIMAILTOURL
+
+    nsMailtoUrl();
+
+protected:
+  enum RefHandlingEnum {
+    eIgnoreRef,
+    eHonorRef,
+    eReplaceRef
+  };
+  virtual ~nsMailtoUrl();
+  nsresult ParseUrl();
+  nsresult CleanupMailtoState();
+  nsresult ParseMailtoUrl(char * searchPart);
+  nsresult CloneInternal(RefHandlingEnum aRefHandlingMode,
+                         const nsACString& newRef, nsIURI** _retval);
+
+  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();
+
+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;
+
+  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/mailnews/compose/src/nsURLFetcher.cpp b/mailnews/compose/src/nsURLFetcher.cpp
new file mode 100644
index 000000000..b564ab9a4
--- /dev/null
+++ b/mailnews/compose/src/nsURLFetcher.cpp
@@ -0,0 +1,526 @@
+/* -*- 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 "nsURLFetcher.h"
+
+#include "msgCore.h" // for pre-compiled headers
+#include "nsCOMPtr.h"
+#include "nsNullPrincipal.h"
+#include <stdio.h>
+#include "nscore.h"
+#include "nsIFactory.h"
+#include "nsISupports.h"
+#include "prmem.h"
+#include "plstr.h"
+#include "nsIComponentManager.h"
+#include "nsStringGlue.h"
+#include "nsIIOService.h"
+#include "nsIChannel.h"
+#include "nsNetUtil.h"
+#include "nsMimeTypes.h"
+#include "nsIHttpChannel.h"
+#include "nsIWebProgress.h"
+#include "nsMsgAttachmentHandler.h"
+#include "nsMsgSend.h"
+#include "nsISeekableStream.h"
+#include "nsIStreamConverterService.h"
+#include "nsIMsgProgress.h"
+#include "nsMsgUtils.h"
+
+NS_IMPL_ISUPPORTS(nsURLFetcher,
+                   nsIURLFetcher,
+                   nsIStreamListener,
+                   nsIRequestObserver,
+                   nsIURIContentListener,
+                   nsIInterfaceRequestor,
+                   nsIWebProgressListener,
+                   nsISupportsWeakReference)
+
+
+/* 
+ * Inherited methods for nsMimeConverter
+ */
+nsURLFetcher::nsURLFetcher()
+{
+  // Init member variables...
+  mTotalWritten = 0;
+  mBuffer = nullptr;
+  mBufferSize = 0;
+  mStillRunning = true;
+  mCallback = nullptr;
+  mOnStopRequestProcessed = false;
+  mIsFile=false;
+  nsURLFetcherStreamConsumer *consumer = new nsURLFetcherStreamConsumer(this);
+  mConverter = do_QueryInterface(consumer);
+}
+
+nsURLFetcher::~nsURLFetcher()
+{
+  mStillRunning = false;
+  
+  PR_FREEIF(mBuffer);
+  // Remove the DocShell as a listener of the old WebProgress...
+  if (mLoadCookie) 
+  {
+    nsCOMPtr<nsIWebProgress> webProgress(do_QueryInterface(mLoadCookie));
+
+    if (webProgress)
+      webProgress->RemoveProgressListener(this);
+  }
+}
+
+NS_IMETHODIMP nsURLFetcher::GetInterface(const nsIID & aIID, void * *aInstancePtr)
+{
+   NS_ENSURE_ARG_POINTER(aInstancePtr);
+   return QueryInterface(aIID, aInstancePtr);
+}
+
+// nsIURIContentListener support
+NS_IMETHODIMP 
+nsURLFetcher::OnStartURIOpen(nsIURI* aURI, bool* aAbortOpen)
+{
+   return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsURLFetcher::IsPreferred(const char * aContentType,
+                                char ** aDesiredContentType,
+                                bool * aCanHandleContent)
+
+{
+  return CanHandleContent(aContentType, true, aDesiredContentType,
+                          aCanHandleContent);
+}
+
+NS_IMETHODIMP 
+nsURLFetcher::CanHandleContent(const char * aContentType,
+                                bool aIsContentPreferred,
+                                char ** aDesiredContentType,
+                                bool * aCanHandleContent)
+
+{
+    if (!mIsFile && PL_strcasecmp(aContentType, MESSAGE_RFC822) == 0)
+      *aDesiredContentType = strdup("text/html");
+
+    // since we explicilty loaded the url, we always want to handle it!
+    *aCanHandleContent = true;
+  return NS_OK;
+} 
+
+NS_IMETHODIMP 
+nsURLFetcher::DoContent(const nsACString& aContentType,
+                      bool aIsContentPreferred,
+                      nsIRequest *request,
+                      nsIStreamListener ** aContentHandler,
+                      bool * aAbortProcess)
+{
+  nsresult rv = NS_OK;
+
+  if (aAbortProcess)
+    *aAbortProcess = false;
+  QueryInterface(NS_GET_IID(nsIStreamListener), (void **) aContentHandler);
+
+  /*
+    Check the content-type to see if we need to insert a converter
+  */
+  if (PL_strcasecmp(PromiseFlatCString(aContentType).get(), UNKNOWN_CONTENT_TYPE) == 0 ||
+      PL_strcasecmp(PromiseFlatCString(aContentType).get(), MULTIPART_MIXED_REPLACE) == 0 ||
+      PL_strcasecmp(PromiseFlatCString(aContentType).get(), MULTIPART_MIXED) == 0 ||
+      PL_strcasecmp(PromiseFlatCString(aContentType).get(), MULTIPART_BYTERANGES) == 0)
+  {
+    rv = InsertConverter(PromiseFlatCString(aContentType).get());
+    if (NS_SUCCEEDED(rv))
+      mConverterContentType = PromiseFlatCString(aContentType).get();
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP 
+nsURLFetcher::GetParentContentListener(nsIURIContentListener** aParent)
+{
+  *aParent = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsURLFetcher::SetParentContentListener(nsIURIContentListener* aParent)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsURLFetcher::GetLoadCookie(nsISupports ** aLoadCookie)
+{
+  *aLoadCookie = mLoadCookie;
+  NS_IF_ADDREF(*aLoadCookie);
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsURLFetcher::SetLoadCookie(nsISupports * aLoadCookie)
+{
+  // Remove the DocShell as a listener of the old WebProgress...
+  if (mLoadCookie) 
+  {
+    nsCOMPtr<nsIWebProgress> webProgress(do_QueryInterface(mLoadCookie));
+
+    if (webProgress)
+      webProgress->RemoveProgressListener(this);
+  }
+
+  mLoadCookie = aLoadCookie;
+
+  // Add the DocShell as a listener to the new WebProgress...
+  if (mLoadCookie) 
+  {
+    nsCOMPtr<nsIWebProgress> webProgress(do_QueryInterface(mLoadCookie));
+
+    if (webProgress) 
+      webProgress->AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_ALL);
+  }
+  return NS_OK;
+
+}
+
+nsresult
+nsURLFetcher::StillRunning(bool *running)
+{
+  *running = mStillRunning;
+  return NS_OK;
+}
+
+
+// Methods for nsIStreamListener...
+nsresult
+nsURLFetcher::OnDataAvailable(nsIRequest *request, nsISupports * ctxt, nsIInputStream *aIStream, 
+                              uint64_t sourceOffset, uint32_t aLength)
+{
+  /* let our converter or consumer process the data */
+  if (!mConverter)
+    return NS_ERROR_FAILURE;
+
+  return mConverter->OnDataAvailable(request, ctxt, aIStream, sourceOffset, aLength);
+}
+
+
+// Methods for nsIStreamObserver 
+nsresult
+nsURLFetcher::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
+{
+  /* check if the user has canceld the operation */
+  if (mTagData)
+  {
+    nsCOMPtr<nsIMsgSend> sendPtr;
+    mTagData->GetMimeDeliveryState(getter_AddRefs(sendPtr));
+    if (sendPtr)
+    {
+      nsCOMPtr<nsIMsgProgress> progress;
+      sendPtr->GetProgress(getter_AddRefs(progress));
+      if (progress)
+      {
+        bool cancel = false;
+        progress->GetProcessCanceledByUser(&cancel);
+        if (cancel)
+          return request->Cancel(NS_ERROR_ABORT);
+      }
+    }
+    mTagData->mRequest = request;
+  }
+
+  /* call our converter or consumer */
+  if (mConverter)
+    return mConverter->OnStartRequest(request, ctxt);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsURLFetcher::OnStopRequest(nsIRequest *request, nsISupports * ctxt, nsresult aStatus)
+{
+  // it's possible we could get in here from the channel calling us with an OnStopRequest and from our
+  // onStatusChange method (in the case of an error). So we should protect against this to make sure we
+  // don't process the on stop request twice...
+
+  if (mOnStopRequestProcessed)
+    return NS_OK;
+
+  mOnStopRequestProcessed = true;
+
+  /* first, call our converter or consumer */
+  if (mConverter)
+    (void) mConverter->OnStopRequest(request, ctxt, aStatus);
+
+  if (mTagData)
+    mTagData->mRequest = nullptr;
+
+  //
+  // Now complete the stream!
+  //
+  mStillRunning = false;
+
+  // time to close the output stream...
+  if (mOutStream)
+  {
+    mOutStream->Close();
+    mOutStream = nullptr;
+  
+    /* In case of multipart/x-mixed-replace, we need to truncate the file to the current part size */
+    if (MsgLowerCaseEqualsLiteral(mConverterContentType, MULTIPART_MIXED_REPLACE))
+    {
+      mLocalFile->SetFileSize(mTotalWritten);
+    }
+  }
+
+  // Now if there is a callback, we need to call it...
+  if (mCallback)
+    mCallback (aStatus, mContentType, mCharset, mTotalWritten, nullptr, mTagData);
+
+  // Time to return...
+  return NS_OK;
+}
+
+nsresult 
+nsURLFetcher::Initialize(nsIFile *localFile, 
+                         nsIOutputStream *outputStream,
+                         nsAttachSaveCompletionCallback cb, 
+                         nsMsgAttachmentHandler *tagData)
+{
+  if (!outputStream || !localFile)
+    return NS_ERROR_INVALID_ARG;
+
+  mOutStream = outputStream;
+  mLocalFile = localFile;
+  mCallback = cb;     //JFD: Please, no more callback, use a listener...
+  mTagData = tagData;
+  return NS_OK;
+}
+
+nsresult
+nsURLFetcher::FireURLRequest(nsIURI *aURL, nsIFile *localFile, nsIOutputStream *outputStream, 
+                             nsAttachSaveCompletionCallback cb, nsMsgAttachmentHandler *tagData)
+{
+  nsresult rv;
+
+  rv = Initialize(localFile, outputStream, cb, tagData);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  //check to see if aURL is a local file or not
+  aURL->SchemeIs("file", &mIsFile);
+  
+  // we're about to fire a new url request so make sure the on stop request flag is cleared...
+  mOnStopRequestProcessed = false;
+
+  // let's try uri dispatching...
+  nsCOMPtr<nsIURILoader> pURILoader (do_GetService(NS_URI_LOADER_CONTRACTID));
+  NS_ENSURE_TRUE(pURILoader, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIPrincipal> nullPrincipal =
+    do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIChannel> channel;
+  rv = NS_NewChannel(getter_AddRefs(channel),
+                     aURL,
+                     nullPrincipal,
+                     nsILoadInfo::SEC_NORMAL,
+                     nsIContentPolicy::TYPE_OTHER,
+                     nullptr, // aLoadGroup
+                     this); // aCallbacks
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return pURILoader->OpenURI(channel, false, this);
+}
+
+nsresult
+nsURLFetcher::InsertConverter(const char * aContentType)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIStreamConverterService> convServ(do_GetService("@mozilla.org/streamConverters;1", &rv));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIStreamListener> toListener(mConverter);
+    nsCOMPtr<nsIStreamListener> fromListener;
+
+    rv = convServ->AsyncConvertData(aContentType,
+                                    "*/*",
+                                    toListener,
+                                    nullptr,
+                                    getter_AddRefs(fromListener));
+    if (NS_SUCCEEDED(rv))
+      mConverter = fromListener;
+  }
+
+  return rv;
+}
+
+// web progress listener implementation
+
+NS_IMETHODIMP
+nsURLFetcher::OnProgressChange(nsIWebProgress *aProgress, nsIRequest *aRequest,
+                             int32_t aCurSelfProgress, int32_t aMaxSelfProgress,
+                             int32_t aCurTotalProgress, int32_t aMaxTotalProgress)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsURLFetcher::OnStateChange(nsIWebProgress *aProgress, nsIRequest *aRequest,
+                          uint32_t aStateFlags, nsresult aStatus)
+{
+  // all we care about is the case where an error occurred (as in we were unable to locate the
+  // the url....
+
+  if (NS_FAILED(aStatus))
+    OnStopRequest(aRequest, nullptr, aStatus);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsURLFetcher::OnLocationChange(nsIWebProgress* aWebProgress,
+                               nsIRequest* aRequest,
+                               nsIURI *aURI,
+                               uint32_t aFlags)
+{
+  NS_NOTREACHED("notification excluded in AddProgressListener(...)");
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsURLFetcher::OnStatusChange(nsIWebProgress* aWebProgress,
+                             nsIRequest* aRequest,
+                             nsresult aStatus,
+                             const char16_t* aMessage)
+{
+  NS_NOTREACHED("notification excluded in AddProgressListener(...)");
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsURLFetcher::OnSecurityChange(nsIWebProgress *aWebProgress, 
+                               nsIRequest *aRequest, 
+                               uint32_t state)
+{
+  NS_NOTREACHED("notification excluded in AddProgressListener(...)");
+  return NS_OK;
+}
+
+
+/**
+ * Stream consumer used for handling special content type like multipart/x-mixed-replace
+ */
+
+NS_IMPL_ISUPPORTS(nsURLFetcherStreamConsumer, nsIStreamListener, nsIRequestObserver)
+
+nsURLFetcherStreamConsumer::nsURLFetcherStreamConsumer(nsURLFetcher* urlFetcher) :
+  mURLFetcher(urlFetcher)
+{
+}
+
+nsURLFetcherStreamConsumer::~nsURLFetcherStreamConsumer()
+{
+}
+
+/** nsIRequestObserver methods **/
+
+/* void onStartRequest (in nsIRequest request, in nsISupports ctxt); */
+NS_IMETHODIMP nsURLFetcherStreamConsumer::OnStartRequest(nsIRequest *aRequest, nsISupports *ctxt)
+{
+  if (!mURLFetcher || !mURLFetcher->mOutStream)
+    return NS_ERROR_FAILURE;
+
+  /* In case of multipart/x-mixed-replace, we need to erase the output file content */
+  if (MsgLowerCaseEqualsLiteral(mURLFetcher->mConverterContentType, MULTIPART_MIXED_REPLACE))
+  {
+    nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(mURLFetcher->mOutStream);
+    if (seekStream)
+      seekStream->Seek(nsISeekableStream::NS_SEEK_SET, 0);
+    mURLFetcher->mTotalWritten = 0;
+  }
+
+  return NS_OK;
+}
+
+/* void onStopRequest (in nsIRequest request, in nsISupports ctxt, in nsresult status); */
+NS_IMETHODIMP nsURLFetcherStreamConsumer::OnStopRequest(nsIRequest *aRequest, nsISupports *ctxt, nsresult status)
+{
+  if (!mURLFetcher)
+    return NS_ERROR_FAILURE;
+
+  // Check the content type!
+  nsAutoCString contentType;
+  nsAutoCString charset;
+
+  nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+  if(!channel) return NS_ERROR_FAILURE;
+
+  if (NS_SUCCEEDED(channel->GetContentType(contentType)) &&
+      !contentType.EqualsLiteral(UNKNOWN_CONTENT_TYPE))
+  {
+    nsAutoCString uriSpec;
+    nsCOMPtr <nsIURI> channelURI;
+    channel->GetURI(getter_AddRefs(channelURI));
+    nsresult rv = channelURI->GetSpec(uriSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (uriSpec.Find("&realtype=message/rfc822") >= 0)
+      mURLFetcher->mContentType = MESSAGE_RFC822;
+    else
+      mURLFetcher->mContentType = contentType;
+  }
+
+  if (NS_SUCCEEDED(channel->GetContentCharset(charset)) && !charset.IsEmpty())
+  {
+    mURLFetcher->mCharset = charset;
+  }
+
+  return NS_OK;
+}
+
+/** nsIStreamListener methods **/
+
+/* void onDataAvailable (in nsIRequest request, in nsISupports ctxt, in nsIInputStream inStr, in unsigned long long sourceOffset, in unsigned long count); */
+NS_IMETHODIMP nsURLFetcherStreamConsumer::OnDataAvailable(nsIRequest *aRequest, nsISupports *ctxt, nsIInputStream *inStr, uint64_t sourceOffset, uint32_t count)
+{
+  uint32_t        readLen = count;
+  uint32_t        wroteIt;
+
+  if (!mURLFetcher)
+    return NS_ERROR_FAILURE;
+
+  if (!mURLFetcher->mOutStream)
+    return NS_ERROR_INVALID_ARG;
+
+  if (mURLFetcher->mBufferSize < count)
+  {
+    PR_FREEIF(mURLFetcher->mBuffer);
+
+    if (count > 0x1000)
+      mURLFetcher->mBufferSize = count;
+    else
+      mURLFetcher->mBufferSize = 0x1000;
+
+    mURLFetcher->mBuffer = (char *)PR_Malloc(mURLFetcher->mBufferSize);
+    if (!mURLFetcher->mBuffer)
+      return NS_ERROR_OUT_OF_MEMORY; /* we couldn't allocate the object */
+  }
+
+  // read the data from the input stram...
+  nsresult rv = inStr->Read(mURLFetcher->mBuffer, count, &readLen);
+  if (NS_FAILED(rv))
+    return rv;
+
+  // write to the output file...
+  mURLFetcher->mOutStream->Write(mURLFetcher->mBuffer, readLen, &wroteIt);
+
+  if (wroteIt != readLen)
+    return NS_ERROR_FAILURE;
+  else
+  {
+    mURLFetcher->mTotalWritten += wroteIt;
+    return NS_OK;
+  }
+}
diff --git a/mailnews/compose/src/nsURLFetcher.h b/mailnews/compose/src/nsURLFetcher.h
new file mode 100644
index 000000000..d252b014b
--- /dev/null
+++ b/mailnews/compose/src/nsURLFetcher.h
@@ -0,0 +1,101 @@
+/* -*- 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/. */
+#ifndef nsURLFetcher_h_
+#define nsURLFetcher_h_
+
+#include "nsIURLFetcher.h"
+
+#include "nsCOMPtr.h"
+#include "nsAutoPtr.h"
+#include "nsIInputStream.h"
+#include "nsIStreamListener.h"
+
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsCURILoader.h"
+#include "nsIURIContentListener.h"
+#include "nsIWebProgressListener.h"
+#include "nsWeakReference.h"
+#include "nsStringGlue.h"
+
+class nsMsgAttachmentHandler;
+
+class nsURLFetcher : public nsIURLFetcher,
+                     public nsIStreamListener,
+                     public nsIURIContentListener, 
+                     public nsIInterfaceRequestor,
+                     public nsIWebProgressListener,
+                     public nsSupportsWeakReference
+{ 
+public: 
+  nsURLFetcher();
+
+  /* this macro defines QueryInterface, AddRef and Release for this class */
+  NS_DECL_ISUPPORTS
+
+  // Methods for nsIURLFetcher
+  NS_DECL_NSIURLFETCHER
+
+  // Methods for nsIStreamListener
+  NS_DECL_NSISTREAMLISTENER
+
+  // Methods for nsIRequestObserver
+  NS_DECL_NSIREQUESTOBSERVER
+  
+  // Methods for nsIURICOntentListener
+  NS_DECL_NSIURICONTENTLISTENER
+
+  // Methods for nsIInterfaceRequestor
+  NS_DECL_NSIINTERFACEREQUESTOR
+
+  // Methods for nsIWebProgressListener
+  NS_DECL_NSIWEBPROGRESSLISTENER
+
+protected:
+  nsresult InsertConverter(const char * aContentType);
+
+private:
+  virtual ~nsURLFetcher();
+  nsCOMPtr<nsIOutputStream>       mOutStream;               // the output file stream
+  nsCOMPtr<nsIFile>          mLocalFile;               // the output file itself
+  nsCOMPtr<nsIStreamListener>     mConverter;               // the stream converter, if needed
+  nsCString                  mConverterContentType;    // The content type of the converter
+  bool                            mStillRunning;  // Are we still running?
+  int32_t                         mTotalWritten;  // Size counter variable
+  char                            *mBuffer;                 // Buffer used for reading the data
+  uint32_t                        mBufferSize;              // Buffer size;
+  nsCString                  mContentType;             // The content type retrieved from the server
+  nsCString                  mCharset;                 // The charset retrieved from the server
+  RefPtr<nsMsgAttachmentHandler> mTagData;      // Tag data for callback...
+  nsAttachSaveCompletionCallback  mCallback;      // Callback to call once the file is saved...
+  nsCOMPtr<nsISupports>           mLoadCookie;    // load cookie used by the uri loader when we fetch the url
+  bool                            mOnStopRequestProcessed; // used to prevent calling OnStopRequest multiple times
+  bool                            mIsFile;        // This is used to check whether the URI is a local file.
+
+  friend class nsURLFetcherStreamConsumer;
+}; 
+
+
+/**
+ * Stream consumer used for handling special content type like multipart/x-mixed-replace
+ */
+
+class nsURLFetcherStreamConsumer : public nsIStreamListener
+{
+public:
+  nsURLFetcherStreamConsumer(nsURLFetcher* urlFetcher);
+
+  /* additional members */
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSISTREAMLISTENER
+  NS_DECL_NSIREQUESTOBSERVER
+
+private:
+  virtual ~nsURLFetcherStreamConsumer();
+  nsURLFetcher* mURLFetcher;
+}; 
+
+
+#endif /* nsURLFetcher_h_ */
-- 
cgit v1.2.3