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

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

44 files changed, 16766 insertions, 0 deletions

diff --git a/comm/mailnews/local/src/Pop3Channel.jsm b/comm/mailnews/local/src/Pop3Channel.jsm
new file mode 100644
index 0000000000..4fae72894b
--- /dev/null
+++ b/comm/mailnews/local/src/Pop3Channel.jsm
@@ -0,0 +1,105 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["Pop3Channel"];
+
+const { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+const { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+const lazy = {};
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  Pop3Client: "resource:///modules/Pop3Client.jsm",
+});
+
+/**
+ * A channel to interact with POP3 server.
+ *
+ * @implements {nsIChannel}
+ * @implements {nsIRequest}
+ */
+class Pop3Channel {
+  QueryInterface = ChromeUtils.generateQI(["nsIChannel", "nsIRequest"]);
+
+  _logger = console.createInstance({
+    prefix: "mailnews.pop3",
+    maxLogLevel: "Warn",
+    maxLogLevelPref: "mailnews.pop3.loglevel",
+  });
+
+  /**
+   * @param {nsIURI} uri - The uri to construct the channel from.
+   * @param {nsILoadInfo} loadInfo - The loadInfo associated with the channel.
+   */
+  constructor(uri, loadInfo) {
+    this._server = MailServices.accounts
+      .findServerByURI(uri)
+      .QueryInterface(Ci.nsIPop3IncomingServer);
+
+    // nsIChannel attributes.
+    this.originalURI = uri;
+    this.URI = uri;
+    this.loadInfo = loadInfo;
+    this.contentLength = 0;
+  }
+
+  /**
+   * @see nsIRequest
+   */
+  get status() {
+    return Cr.NS_OK;
+  }
+
+  /**
+   * @see nsIChannel
+   */
+  get contentType() {
+    return this._contentType || "message/rfc822";
+  }
+
+  set contentType(value) {
+    this._contentType = value;
+  }
+
+  get isDocument() {
+    return true;
+  }
+
+  open() {
+    throw Components.Exception(
+      "Pop3Channel.open() not implemented",
+      Cr.NS_ERROR_NOT_IMPLEMENTED
+    );
+  }
+
+  asyncOpen(listener) {
+    this._logger.debug(`asyncOpen ${this.URI.spec}`);
+    let match = this.URI.spec.match(/pop3?:\/\/.+\/(?:\?|&)uidl=([^&]+)/);
+    let uidl = decodeURIComponent(match?.[1] || "");
+    if (!uidl) {
+      throw Components.Exception(
+        `Unrecognized url=${this.URI.spec}`,
+        Cr.NS_ERROR_ILLEGAL_VALUE
+      );
+    }
+
+    let client = new lazy.Pop3Client(this._server);
+    client.runningUri = this.URI;
+    client.connect();
+    client.onOpen = () => {
+      listener.onStartRequest(this);
+      client.fetchBodyForUidl(
+        this.URI.QueryInterface(Ci.nsIPop3URL).pop3Sink,
+        uidl
+      );
+    };
+    client.onDone = status => {
+      listener.onStopRequest(this, status);
+    };
+  }
+}
diff --git a/comm/mailnews/local/src/Pop3Client.jsm b/comm/mailnews/local/src/Pop3Client.jsm
new file mode 100644
index 0000000000..59e21a66f7
--- /dev/null
+++ b/comm/mailnews/local/src/Pop3Client.jsm
@@ -0,0 +1,1570 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["Pop3Client"];
+
+var { setTimeout } = ChromeUtils.importESModule(
+  "resource://gre/modules/Timer.sys.mjs"
+);
+var { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+var { CommonUtils } = ChromeUtils.importESModule(
+  "resource://services-common/utils.sys.mjs"
+);
+var { CryptoUtils } = ChromeUtils.importESModule(
+  "resource://services-crypto/utils.sys.mjs"
+);
+var { LineReader } = ChromeUtils.import("resource:///modules/LineReader.jsm");
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+var { MailStringUtils } = ChromeUtils.import(
+  "resource:///modules/MailStringUtils.jsm"
+);
+var { Pop3Authenticator } = ChromeUtils.import(
+  "resource:///modules/MailAuthenticator.jsm"
+);
+
+/**
+ * A structure to represent a response received from the server. A response can
+ * be a single status line of a multi-line data block.
+ *
+ * @typedef {object} Pop3Response
+ * @property {boolean} success - True for a positive status indicator ("+OK","+").
+ * @property {string} status - The status indicator, can be "+OK", "-ERR" or "+".
+ * @property {string} statusText - The status line of the response excluding the
+ *   status indicator.
+ * @property {string} data - The part of a multi-line data block excluding the
+ *   status line.
+ *
+ * A single char to represent a uidl status, possible values are:
+ *   - 'k'=KEEP,
+ *   - 'd'=DELETE
+ *   - 'b'=TOO_BIG
+ *   - 'f'=FETCH_BODY
+ * @typedef {string} UidlStatus
+ */
+
+const UIDL_KEEP = "k";
+const UIDL_DELETE = "d";
+const UIDL_TOO_BIG = "b";
+const UIDL_FETCH_BODY = "f";
+
+// There can be multiple Pop3Client running concurrently, assign each logger a
+// unique prefix.
+let loggerId = 0;
+
+function getLoggerId() {
+  return loggerId++ % 1000;
+}
+
+/**
+ * A class to interact with POP3 server.
+ */
+class Pop3Client {
+  /**
+   * @param {nsIPop3IncomingServer} server - The associated server instance.
+   */
+  constructor(server) {
+    this._server = server.QueryInterface(Ci.nsIMsgIncomingServer);
+    this._server.wrappedJSObject.runningClient = this;
+    this._authenticator = new Pop3Authenticator(server);
+    this._lineReader = new LineReader();
+
+    // Somehow, Services.io.newURI("pop3://localhost") doesn't work, what we
+    // need is just a valid nsIMsgMailNewsUrl to propagate OnStopRunningUrl and
+    // secInfo.
+    this.runningUri = Services.io
+      .newURI(`smtp://${this._server.hostName}:${this._server.port}`)
+      .mutate()
+      .setScheme("pop3")
+      .finalize()
+      .QueryInterface(Ci.nsIMsgMailNewsUrl);
+
+    // A list of auth methods detected from the EHLO response.
+    this._supportedAuthMethods = [];
+    // A list of auth methods that worth a try.
+    this._possibleAuthMethods = [];
+    // Auth method set by user preference.
+    this._preferredAuthMethods =
+      {
+        [Ci.nsMsgAuthMethod.passwordCleartext]: ["USERPASS", "PLAIN", "LOGIN"],
+        [Ci.nsMsgAuthMethod.passwordEncrypted]: ["CRAM-MD5"],
+        [Ci.nsMsgAuthMethod.GSSAPI]: ["GSSAPI"],
+        [Ci.nsMsgAuthMethod.NTLM]: ["NTLM"],
+        [Ci.nsMsgAuthMethod.OAuth2]: ["XOAUTH2"],
+        [Ci.nsMsgAuthMethod.secure]: ["CRAM-MD5", "GSSAPI"],
+      }[server.authMethod] || [];
+    // The next auth method to try if the current failed.
+    this._nextAuthMethod = null;
+
+    this._sink = Cc["@mozilla.org/messenger/pop3-sink;1"].createInstance(
+      Ci.nsIPop3Sink
+    );
+    this._sink.popServer = server;
+
+    this._logger = console.createInstance({
+      prefix: `mailnews.pop3.${getLoggerId()}`,
+      maxLogLevel: "Warn",
+      maxLogLevelPref: "mailnews.pop3.loglevel",
+    });
+
+    this.onReady = () => {};
+
+    this._cutOffTimestamp = -1;
+    if (
+      this._server.deleteByAgeFromServer &&
+      this._server.numDaysToLeaveOnServer
+    ) {
+      // We will send DELE request for messages received before this timestamp.
+      this._cutOffTimestamp =
+        Date.now() / 1000 - this._server.numDaysToLeaveOnServer * 24 * 60 * 60;
+    }
+
+    this._maxMessageSize = Infinity;
+    if (this._server.limitOfflineMessageSize) {
+      this._maxMessageSize = this._server.maxMessageSize
+        ? this._server.maxMessageSize * 1024
+        : 50 * 1024;
+    }
+
+    this._messagesToHandle = [];
+  }
+
+  /**
+   * Initiate a connection to the server
+   */
+  connect() {
+    let hostname = this._server.hostName.toLowerCase();
+    this._logger.debug(`Connecting to pop://${hostname}:${this._server.port}`);
+    this.runningUri
+      .QueryInterface(Ci.nsIMsgMailNewsUrl)
+      .SetUrlState(true, Cr.NS_OK);
+    this._server.serverBusy = true;
+    this._secureTransport = this._server.socketType == Ci.nsMsgSocketType.SSL;
+    this._socket = new TCPSocket(hostname, this._server.port, {
+      binaryType: "arraybuffer",
+      useSecureTransport: this._secureTransport,
+    });
+    this._socket.onopen = this._onOpen;
+    this._socket.onerror = this._onError;
+
+    this._authenticating = false;
+    // Indicates if the connection has been closed and can't be used anymore.
+    this._destroyed = false;
+    // Save the incomplete server payload, start parsing after seeing \r\n.
+    this._pendingPayload = "";
+  }
+
+  /**
+   * Check and fetch new mails.
+   *
+   * @param {boolean} downloadMail - Whether to download mails using TOP/RETR.
+   * @param {nsIMsgWindow} msgWindow - The associated msg window.
+   * @param {nsIMsgFolder} folder - The folder to save the messages to.
+   */
+  async getMail(downloadMail, msgWindow, folder) {
+    this._downloadMail = downloadMail;
+    this._msgWindow = msgWindow;
+    this._sink.folder = folder;
+    this._actionAfterAuth = this._actionStat;
+    this.urlListener.OnStartRunningUrl(this.runningUri, Cr.NS_OK);
+
+    await this._loadUidlState();
+    this._actionCapa();
+  }
+
+  /**
+   * Verify that we can logon to the server. Exit after auth success/failure.
+   *
+   * @param {nsIMsgWindow} msgWindow - The associated msg window.
+   */
+  verifyLogon(msgWindow) {
+    this._msgWindow = msgWindow;
+    this._verifyLogon = true;
+    this._actionAfterAuth = this._actionDone;
+    this._actionCapa();
+  }
+
+  /**
+   * Fetch the full message of a uidl.
+   *
+   * @param {nsIPop3Sink} sink - The sink to use for this request.
+   * @param {string} uidl - The uidl of the message to fetch.
+   */
+  async fetchBodyForUidl(sink, uidl) {
+    this._logger.debug(`Fetching body for uidl=${uidl}`);
+
+    this._downloadMail = true;
+    this._sink = sink;
+    this._sink.buildMessageUri = true;
+    this.urlListener = sink.folder.QueryInterface(Ci.nsIUrlListener);
+    this.urlListener.OnStartRunningUrl(this.runningUri, Cr.NS_OK);
+
+    await this._loadUidlState();
+
+    let uidlState = this._uidlMap.get(uidl);
+    if (!uidlState) {
+      // This uidl is no longer on the server, use this._sink to delete the
+      // msgHdr.
+      try {
+        this._sink.beginMailDelivery(true, null);
+        this._folderLocked = true;
+        this._logger.debug(
+          `Folder lock acquired uri=${this._sink.folder.URI}.`
+        );
+        this._sink.incorporateBegin(uidl, 0);
+        this._actionDone(Cr.NS_ERROR_FAILURE);
+      } catch (e) {
+        this._actionError("pop3MessageWriteError");
+      }
+      return;
+    }
+    if (uidlState.status != UIDL_TOO_BIG) {
+      this._actionDone(Cr.NS_ERROR_FAILURE);
+      return;
+    }
+
+    this._singleUidlToDownload = uidl;
+    this._uidlMap.set(uidl, {
+      ...uidlState,
+      status: UIDL_FETCH_BODY,
+    });
+    this._actionAfterAuth = this._actionStat;
+    this._actionCapa();
+  }
+
+  /**
+   * Mark uidl status by a passed in Map, then write to popstate.dat.
+   *
+   * @param {Map<string, UidlStatus>} uidlsToMark - A Map from uidl to status.
+   */
+  async markMessages(uidlsToMark) {
+    this._logger.debug("markMessages", uidlsToMark);
+    if (!this._uidlMap) {
+      this._loadUidlState();
+    }
+    // Callers of nsIPop3IncomingServer.markMessages (e.g. filters) expect it to
+    // act as a sync function, otherwise, the flags set by filters may not take
+    // effect.
+    Services.tm.spinEventLoopUntil(
+      "nsIPop3IncomingServer.markMessages is a synchronous function",
+      () => {
+        return this._uidlMap;
+      }
+    );
+    for (let [uidl, status] of uidlsToMark) {
+      let uidlState = this._uidlMap.get(uidl);
+      this._uidlMap.set(uidl, {
+        ...uidlState,
+        status,
+      });
+      this._uidlMapChanged = true;
+    }
+    await this._writeUidlState(true);
+  }
+
+  /**
+   * Send `QUIT` request to the server.
+   * @param {Function} nextAction - Callback function after QUIT response.
+   */
+  quit(nextAction) {
+    this._onData = () => {};
+    this._onError = () => {};
+    if (this._socket?.readyState == "open") {
+      this._send("QUIT");
+      this._nextAction = nextAction || this.close;
+    } else if (nextAction) {
+      nextAction();
+    }
+  }
+
+  /**
+   * Close the socket.
+   */
+  close = () => {
+    this._socket.close();
+  };
+
+  /**
+   * The open event handler.
+   */
+  _onOpen = () => {
+    this._logger.debug("Connected");
+    this._socket.ondata = this._onData;
+    this._socket.onclose = this._onClose;
+    this._nextAction = res => {
+      // See if there is an APOP timestamp.
+      // eslint-disable-next-line no-control-regex
+      let matches = res.statusText.match(/<[\x00-\x7F]+@[\x00-\x7F]+>/);
+      if (matches?.[0]) {
+        this._apopTimestamp = matches[0];
+      }
+      this.onOpen();
+    };
+    this._socket.transport.setTimeout(
+      Ci.nsISocketTransport.TIMEOUT_READ_WRITE,
+      Services.prefs.getIntPref("mailnews.tcptimeout")
+    );
+  };
+
+  /**
+   * Parse the server response.
+   *
+   * @param {string} str - Response received from the server.
+   * @returns {Pop3Response}
+   */
+  _parse(str) {
+    if (this._lineReader.processingMultiLineResponse) {
+      // When processing multi-line response, no parsing should happen. If
+      // `+something` is treated as status line, _actionRetrResponse will treat
+      // it as a new message.
+      return { data: str };
+    }
+    let matches = /^(\+OK|-ERR|\+) ?(.*)\r\n([^]*)/.exec(str);
+    if (matches) {
+      let [, status, statusText, data] = matches;
+      return { success: status != "-ERR", status, statusText, data };
+    }
+    return { data: str };
+  }
+
+  /**
+   * The data event handler.
+   *
+   * @param {TCPSocketEvent} event - The data event.
+   */
+  _onData = async event => {
+    // Some servers close the socket on invalid username/password, this line
+    // guarantees onclose is handled before we try another AUTH method. See the
+    // same handling in SmtpClient.jsm.
+    await new Promise(resolve => setTimeout(resolve));
+
+    let stringPayload = CommonUtils.arrayBufferToByteString(
+      new Uint8Array(event.data)
+    );
+    this._logger.debug(`S: ${stringPayload}`);
+    if (this._pendingPayload) {
+      stringPayload = this._pendingPayload + stringPayload;
+    }
+    if (stringPayload.includes("\r\n")) {
+      // Start parsing if the payload contains at least one line break.
+      this._pendingPayload = "";
+      let res = this._parse(stringPayload);
+      this._nextAction?.(res);
+    } else {
+      // Save the incomplete payload for the next ondata event.
+      this._pendingPayload = stringPayload;
+    }
+  };
+
+  /**
+   * The error event handler.
+   *
+   * @param {TCPSocketErrorEvent} event - The error event.
+   */
+  _onError = async event => {
+    this._logger.error(`${event.name}: a ${event.message} error occurred`);
+    this._server.serverBusy = false;
+    this.quit();
+    let secInfo =
+      await event.target.transport?.tlsSocketControl?.asyncGetSecurityInfo();
+    if (secInfo) {
+      this._logger.error(`SecurityError info: ${secInfo.errorCodeString}`);
+      if (secInfo.failedCertChain.length) {
+        let chain = secInfo.failedCertChain.map(c => {
+          return c.commonName + "; serial# " + c.serialNumber;
+        });
+        this._logger.error(`SecurityError cert chain: ${chain.join(" <- ")}`);
+      }
+      this.runningUri.failedSecInfo = secInfo;
+      // Notify about the error directly. Due to the await above, the _onClose
+      // event is likely to complete before we get here, which means _actionDone
+      // ran and won't run again.
+      this.urlListener.OnStopRunningUrl(this.runningUri, event.errorCode);
+    }
+    this._actionDone(event.errorCode);
+  };
+
+  /**
+   * The close event handler.
+   */
+  _onClose = () => {
+    this._logger.debug("Connection closed.");
+    this._server.serverBusy = false;
+    this._destroyed = true;
+    if (this._authenticating) {
+      // In some cases, socket is closed for invalid username/password.
+      this._actionAuthResponse({ success: false });
+    } else {
+      this._actionDone();
+    }
+  };
+
+  _lineSeparator = AppConstants.platform == "win" ? "\r\n" : "\n";
+
+  /**
+   * Read popstate.dat into this._uidlMap.
+   */
+  async _loadUidlState() {
+    let stateFile = this._server.localPath;
+    stateFile.append("popstate.dat");
+    if (!(await IOUtils.exists(stateFile.path))) {
+      this._uidlMap = new Map();
+      return;
+    }
+
+    let content = await IOUtils.readUTF8(stateFile.path);
+    this._uidlMap = new Map();
+    let uidlLine = false;
+    for (let line of content.split(this._lineSeparator)) {
+      if (!line) {
+        continue;
+      }
+      if (uidlLine) {
+        let [status, uidl, receivedAt] = line.split(" ");
+        this._uidlMap.set(uidl, {
+          status, // @type {UidlStatus}
+          uidl,
+          receivedAt,
+        });
+      }
+      if (line.startsWith("#")) {
+        // A comment line.
+        continue;
+      }
+      if (line.startsWith("*")) {
+        // The host & user line.
+        uidlLine = true;
+      }
+    }
+  }
+
+  /**
+   * Write this._uidlMap into popstate.dat.
+   *
+   * @param {boolean} [resetFlag] - If true, reset _uidlMapChanged to false.
+   */
+  async _writeUidlState(resetFlag) {
+    if (!this._uidlMapChanged) {
+      return;
+    }
+
+    let stateFile = this._server.localPath;
+    stateFile.append("popstate.dat");
+    let content = [
+      "# POP3 State File",
+      "# This is a generated file!  Do not edit.",
+      "",
+      `*${this._server.hostName} ${this._server.username}`,
+    ];
+    for (let msg of this._messagesToHandle) {
+      // _messagesToHandle is not empty means an error happened, put them back
+      // to _uidlMap to prevent loss of popstate.
+      this._uidlMap.set(msg.uidl, msg);
+    }
+    for (let { status, uidl, receivedAt } of this._uidlMap.values()) {
+      if (receivedAt) {
+        content.push(`${status} ${uidl} ${receivedAt}`);
+      }
+    }
+    this._writeUidlPromise = IOUtils.writeUTF8(
+      stateFile.path,
+      content.join(this._lineSeparator)
+    );
+    await this._writeUidlPromise;
+    this._writeUidlPromise = null;
+
+    if (resetFlag) {
+      this._uidlMapChanged = false;
+    }
+  }
+
+  /**
+   * Send a command to the server.
+   *
+   * @param {string} str - The command string to send.
+   * @param {boolean} [suppressLogging=false] - Whether to suppress logging the str.
+   */
+  _send(str, suppressLogging) {
+    if (this._socket?.readyState != "open") {
+      if (str != "QUIT") {
+        this._logger.warn(
+          `Socket state is ${this._socket?.readyState} - won't send command.`
+        );
+      }
+      return;
+    }
+
+    if (suppressLogging && AppConstants.MOZ_UPDATE_CHANNEL != "default") {
+      this._logger.debug(
+        "C: Logging suppressed (it probably contained auth information)"
+      );
+    } else {
+      // Do not suppress for non-release builds, so that debugging auth problems
+      // is easier.
+      this._logger.debug(`C: ${str}`);
+    }
+
+    this._socket.send(CommonUtils.byteStringToArrayBuffer(str + "\r\n").buffer);
+  }
+
+  /**
+   * Send `CAPA` request to the server.
+   */
+  _actionCapa = () => {
+    this._nextAction = this._actionCapaResponse;
+    this._capabilities = [];
+    this._newMessageDownloaded = 0;
+    this._newMessageTotal = 0;
+    this._send("CAPA");
+  };
+
+  /**
+   * Handle `CAPA` response.
+   *
+   * @param {Pop3Response} res - CAPA response received from the server.
+   */
+  _actionCapaResponse = res => {
+    if (res.status && !res.success) {
+      this._actionChooseFirstAuthMethod();
+      return;
+    }
+    this._lineReader.read(
+      res.data,
+      line => {
+        line = line.trim().toUpperCase();
+        if (line == "USER") {
+          this._supportedAuthMethods.push("USERPASS");
+        } else if (line.startsWith("SASL ")) {
+          this._supportedAuthMethods.push(...line.slice(5).split(" "));
+        } else {
+          this._capabilities.push(line.split(" ")[0]);
+        }
+      },
+      () => this._actionChooseFirstAuthMethod()
+    );
+  };
+
+  /**
+   * Decide the first auth method to try.
+   */
+  _actionChooseFirstAuthMethod = () => {
+    if (
+      [
+        Ci.nsMsgSocketType.trySTARTTLS,
+        Ci.nsMsgSocketType.alwaysSTARTTLS,
+      ].includes(this._server.socketType) &&
+      !this._secureTransport
+    ) {
+      if (this._capabilities.includes("STLS")) {
+        // Init STARTTLS negotiation if required by user pref and supported.
+        this._nextAction = this._actionStlsResponse;
+        // STLS is the POP3 command to init STARTTLS.
+        this._send("STLS");
+      } else {
+        // Abort if not supported.
+        this._logger.error("Server doesn't support STLS. Aborting.");
+        this._actionError("nsErrorCouldNotConnectViaTls");
+      }
+      return;
+    }
+
+    // If a preferred method is not supported by the server, no need to try it.
+    this._possibleAuthMethods = this._preferredAuthMethods.filter(x =>
+      this._supportedAuthMethods.includes(x)
+    );
+    if (!this._possibleAuthMethods.length) {
+      if (this._server.authMethod == Ci.nsMsgAuthMethod.passwordCleartext) {
+        this._possibleAuthMethods.unshift("USERPASS");
+      } else if (
+        this._server.authMethod == Ci.nsMsgAuthMethod.passwordEncrypted
+      ) {
+        this._possibleAuthMethods.unshift(
+          this._apopTimestamp ? "APOP" : "CRAM-MD5"
+        );
+      } else if (this._server.authMethod == Ci.nsMsgAuthMethod.GSSAPI) {
+        this._possibleAuthMethods.unshift("GSSAPI");
+      } else if (this._server.authMethod == Ci.nsMsgAuthMethod.NTLM) {
+        this._possibleAuthMethods.unshift("NTLM");
+      } else if (this._server.authMethod == Ci.nsMsgAuthMethod.OAuth2) {
+        // Some servers don't return XOAUTH2 in CAPA correctly.
+        this._possibleAuthMethods.unshift("XOAUTH2");
+      }
+    }
+    this._logger.debug(`Possible auth methods: ${this._possibleAuthMethods}`);
+    this._nextAuthMethod = this._nextAuthMethod || this._possibleAuthMethods[0];
+
+    if (this._nextAuthMethod) {
+      this._updateStatus("hostContact");
+      this._actionAuth();
+      return;
+    }
+
+    // Preferred auth methods don't match any supported auth methods. Give user
+    // some hints to change the config.
+    if (
+      this._server.authMethod == Ci.nsMsgAuthMethod.passwordCleartext &&
+      this._supportedAuthMethods.includes("CRAM-MD5")
+    ) {
+      // Suggest changing from plain password to encrypted password.
+      this._actionError("pop3AuthChangePlainToEncrypt");
+    } else if (
+      this._server.authMethod == Ci.nsMsgAuthMethod.passwordEncrypted &&
+      (this._supportedAuthMethods.includes("PLAIN") ||
+        this._supportedAuthMethods.includes("LOGIN"))
+    ) {
+      // Suggest changing from encrypted password to plain password.
+      this._actionError(
+        this._secureTransport
+          ? "pop3AuthChangeEncryptToPlainSSL"
+          : "pop3AuthChangeEncryptToPlainNoSSL"
+      );
+    } else {
+      // General suggestion about changing auth method.
+      this._actionError("pop3AuthMechNotSupported");
+    }
+  };
+
+  /**
+   * Handle STLS response. STLS is the POP3 command to init STARTTLS.
+   *
+   * @param {Pop3Response} res - STLS response received from the server.
+   */
+  _actionStlsResponse = res => {
+    if (!res.success) {
+      this._actionDone(Cr.NS_ERROR_FAILURE);
+      return;
+    }
+    this._socket.upgradeToSecure();
+    this._secureTransport = true;
+    this._actionCapa();
+  };
+
+  /**
+   * Init authentication depending on server capabilities and user prefs.
+   */
+  _actionAuth = async () => {
+    if (!this._nextAuthMethod) {
+      this._actionDone(Cr.NS_ERROR_FAILURE);
+      return;
+    }
+
+    if (this._destroyed) {
+      // If connection is lost, reconnect.
+      this.connect();
+      return;
+    }
+
+    this._authenticating = true;
+
+    this._currentAuthMethod = this._nextAuthMethod;
+    this._nextAuthMethod =
+      this._possibleAuthMethods[
+        this._possibleAuthMethods.indexOf(this._currentAuthMethod) + 1
+      ];
+    this._logger.debug(`Current auth method: ${this._currentAuthMethod}`);
+    this._nextAction = this._actionAuthResponse;
+
+    switch (this._currentAuthMethod) {
+      case "USERPASS":
+        this._nextAction = this._actionAuthUserPass;
+        this._send(`USER ${this._authenticator.username}`);
+        break;
+      case "PLAIN":
+        this._nextAction = this._actionAuthPlain;
+        this._send("AUTH PLAIN");
+        break;
+      case "LOGIN":
+        this._nextAction = this._actionAuthLoginUser;
+        this._send("AUTH LOGIN");
+        break;
+      case "CRAM-MD5":
+        this._nextAction = this._actionAuthCramMd5;
+        this._send("AUTH CRAM-MD5");
+        break;
+      case "APOP": {
+        let hasher = Cc["@mozilla.org/security/hash;1"].createInstance(
+          Ci.nsICryptoHash
+        );
+        hasher.init(hasher.MD5);
+        let data =
+          this._apopTimestamp +
+          (await this._authenticator.getByteStringPassword());
+        let digest = CommonUtils.bytesAsHex(
+          CryptoUtils.digestBytes(data, hasher)
+        );
+        this._send(`APOP ${this._authenticator.username} ${digest}`, true);
+        break;
+      }
+      case "GSSAPI": {
+        this._authenticator.initGssapiAuth("pop");
+        try {
+          let token = this._authenticator.getNextGssapiToken("");
+          this._nextAction = res => this._actionAuthGssapi(res, token);
+        } catch (e) {
+          this._logger.error(e);
+          this._actionError("pop3GssapiFailure");
+          return;
+        }
+        this._send("AUTH GSSAPI");
+        break;
+      }
+      case "NTLM": {
+        this._authenticator.initNtlmAuth("pop");
+        try {
+          let token = this._authenticator.getNextNtlmToken("");
+          this._nextAction = res => this._actionAuthNtlm(res, token);
+        } catch (e) {
+          this._logger.error(e);
+          this._actionDone(Cr.NS_ERROR_FAILURE);
+          return;
+        }
+        this._send("AUTH NTLM");
+        break;
+      }
+      case "XOAUTH2":
+        this._nextAction = this._actionAuthXoauth;
+        this._send("AUTH XOAUTH2");
+        break;
+      default:
+        this._actionDone();
+    }
+  };
+
+  /**
+   * Handle authentication response.
+   *
+   * @param {Pop3Response} res - Authentication response received from the server.
+   */
+  _actionAuthResponse = res => {
+    this._authenticating = false;
+    if (res.success) {
+      this._actionAfterAuth();
+      return;
+    }
+
+    if (this._nextAuthMethod) {
+      // Try the next auth method.
+      this._actionAuth();
+      return;
+    }
+
+    if (this._verifyLogon) {
+      this.runningUri.errorCode = "pop3PasswordFailed";
+      this._actionDone(Cr.NS_ERROR_FAILURE);
+      return;
+    }
+
+    if (
+      ["USERPASS", "PLAIN", "LOGIN", "CRAM-MD5"].includes(
+        this._currentAuthMethod
+      )
+    ) {
+      this._actionError(
+        "pop3PasswordFailed",
+        [this._server.username],
+        res.statusText
+      );
+
+      // Ask user what to do.
+      let action = this._authenticator.promptAuthFailed();
+      if (action == 1) {
+        // Cancel button pressed.
+        this._actionDone(Cr.NS_ERROR_FAILURE);
+        return;
+      }
+      if (action == 2) {
+        // 'New password' button pressed.
+        this._authenticator.forgetPassword();
+      }
+
+      // Retry.
+      this._nextAuthMethod = this._possibleAuthMethods[0];
+      this._actionAuth();
+    } else if (this._currentAuthMethod == "GSSAPI") {
+      this._actionError("pop3GssapiFailure", [], res.statusText);
+    }
+  };
+
+  /**
+   * The second step of USER/PASS auth, send the password to the server.
+   */
+  _actionAuthUserPass = async res => {
+    if (!res.success) {
+      this._actionError("pop3UsernameFailure", [], res.statusText);
+      return;
+    }
+    this._nextAction = this._actionAuthResponse;
+    this._send(
+      `PASS ${await this._authenticator.getByteStringPassword()}`,
+      true
+    );
+  };
+
+  /**
+   * The second step of PLAIN auth, send the auth token to the server.
+   */
+  _actionAuthPlain = async res => {
+    if (!res.success) {
+      this._actionError("pop3UsernameFailure", [], res.statusText);
+      return;
+    }
+    this._nextAction = this._actionAuthResponse;
+    this._send(await this._authenticator.getPlainToken(), true);
+  };
+
+  /**
+   * The second step of LOGIN auth, send the username to the server.
+   */
+  _actionAuthLoginUser = () => {
+    this._nextAction = this._actionAuthLoginPass;
+    this._logger.debug("AUTH LOGIN USER");
+    this._send(btoa(this._authenticator.username), true);
+  };
+
+  /**
+   * The third step of LOGIN auth, send the password to the server.
+   */
+  _actionAuthLoginPass = async res => {
+    if (!res.success) {
+      this._actionError("pop3UsernameFailure", [], res.statusText);
+      return;
+    }
+    this._nextAction = this._actionAuthResponse;
+    this._logger.debug("AUTH LOGIN PASS");
+    let password = await this._authenticator.getPassword();
+    if (
+      !Services.prefs.getBoolPref(
+        "mail.smtp_login_pop3_user_pass_auth_is_latin1",
+        true
+      ) ||
+      !/^[\x00-\xFF]+$/.test(password) // eslint-disable-line no-control-regex
+    ) {
+      // Unlike PLAIN auth, the payload of LOGIN auth is not standardized. When
+      // `mail.smtp_login_pop3_user_pass_auth_is_latin1` is true, we apply
+      // base64 encoding directly. Otherwise, we convert it to UTF-8
+      // BinaryString first, to make it work with btoa().
+      password = MailStringUtils.stringToByteString(password);
+    }
+    this._send(btoa(password), true);
+  };
+
+  /**
+   * The second step of CRAM-MD5 auth, send a HMAC-MD5 signature to the server.
+   *
+   * @param {Pop3Response} res - AUTH response received from the server.
+   */
+  _actionAuthCramMd5 = async res => {
+    if (!res.success) {
+      this._actionError("pop3UsernameFailure", [], res.statusText);
+      return;
+    }
+    this._nextAction = this._actionAuthResponse;
+    this._send(
+      this._authenticator.getCramMd5Token(
+        await this._authenticator.getPassword(),
+        res.statusText
+      ),
+      true
+    );
+  };
+
+  /**
+   * The second and next step of GSSAPI auth.
+   *
+   * @param {Pop3Response} res - AUTH response received from the server.
+   * @param {string} firstToken - The first GSSAPI token to send.
+   */
+  _actionAuthGssapi = (res, firstToken) => {
+    if (res.status != "+") {
+      this._actionAuthResponse(res);
+      return;
+    }
+
+    if (firstToken) {
+      this._nextAction = this._actionAuthGssapi;
+      this._send(firstToken, true);
+      return;
+    }
+
+    // Server returns a challenge, we send a new token. Can happen multiple times.
+    let token;
+    try {
+      token = this._authenticator.getNextGssapiToken(res.statusText);
+    } catch (e) {
+      this._logger.error(e);
+      this._actionAuthResponse({ success: false, data: "AUTH GSSAPI" });
+      return;
+    }
+    this._send(token, true);
+  };
+
+  /**
+   * The second and next step of NTLM auth.
+   *
+   * @param {Pop3Response} res - AUTH response received from the server.
+   * @param {string} firstToken - The first NTLM token to send.
+   */
+  _actionAuthNtlm = (res, firstToken) => {
+    if (res.status != "+") {
+      this._actionAuthResponse(res);
+      return;
+    }
+
+    if (firstToken) {
+      this._nextAction = this._actionAuthNtlm;
+      this._send(firstToken, true);
+      return;
+    }
+
+    // Server returns a challenge, we send a new token. Can happen multiple times.
+    let token;
+    try {
+      token = this._authenticator.getNextNtlmToken(res.statusText);
+    } catch (e) {
+      this._logger.error(e);
+      this._actionAuthResponse({ success: false, data: "AUTH NTLM" });
+      return;
+    }
+    this._send(token, true);
+  };
+
+  /**
+   * The second step of XOAUTH2 auth.
+   *
+   * @param {Pop3Response} res - AUTH response received from the server.
+   */
+  _actionAuthXoauth = async res => {
+    if (res.status != "+") {
+      this._actionAuthResponse(res);
+      return;
+    }
+    this._nextAction = this._actionAuthResponse;
+    let token = await this._authenticator.getOAuthToken();
+    this._send(token, true);
+  };
+
+  /**
+   * Send `STAT` request to the server.
+   */
+  _actionStat = () => {
+    this._nextAction = this._actionStatResponse;
+    this._send("STAT");
+  };
+
+  /**
+   * Handle `STAT` response.
+   *
+   * @param {Pop3Response} res - STAT response received from the server.
+   */
+  _actionStatResponse = res => {
+    if (!res.success) {
+      this._actionError("pop3StatFail", [], res.statusText);
+      return;
+    }
+
+    let numberOfMessages = Number.parseInt(res.statusText);
+    if (!numberOfMessages) {
+      if (this._uidlMap.size) {
+        this._uidlMap.clear();
+        this._uidlMapChanged = true;
+      }
+      // Finish if there is no message.
+      MailServices.pop3.notifyDownloadCompleted(this._sink.folder, 0);
+      this._actionDone();
+      return;
+    }
+    if (!this._downloadMail && !this._server.leaveMessagesOnServer) {
+      // We are not downloading new mails, so finish now.
+      this._sink.setBiffStateAndUpdateFE(
+        Ci.nsIMsgFolder.nsMsgBiffState_NewMail,
+        numberOfMessages,
+        true
+      );
+      this._actionDone();
+      return;
+    }
+
+    if (this._downloadMail) {
+      try {
+        this._sink.beginMailDelivery(
+          this._singleUidlToDownload,
+          this._msgWindow
+        );
+        this._folderLocked = true;
+        this._logger.debug(
+          `Folder lock acquired uri=${this._sink.folder.URI}.`
+        );
+      } catch (e) {
+        const NS_MSG_FOLDER_BUSY = 2153054218;
+        if (e.result == NS_MSG_FOLDER_BUSY) {
+          this._actionError("pop3ServerBusy", [this._server.prettyName]);
+        } else {
+          this._actionError("pop3MessageWriteError");
+        }
+        return;
+      }
+    }
+    this._actionList();
+  };
+
+  /**
+   * Send `LIST` request to the server.
+   */
+  _actionList = () => {
+    this._messageSizeMap = new Map();
+    this._nextAction = this._actionListResponse;
+    this._send("LIST");
+  };
+
+  /**
+   * Handle `LIST` response.
+   *
+   * @param {Pop3Response} res - LIST response received from the server.
+   */
+  _actionListResponse = res => {
+    if (res.status && !res.success) {
+      this._actionError("pop3ListFailure", [], res.statusText);
+      return;
+    }
+    this._lineReader.read(
+      res.data,
+      line => {
+        let [messageNumber, messageSize] = line.split(" ");
+        this._messageSizeMap.set(messageNumber, Number(messageSize));
+      },
+      () => {
+        this._actionUidl();
+      }
+    );
+  };
+
+  /**
+   * Send `UIDL` request to the server.
+   */
+  _actionUidl = () => {
+    this._messagesToHandle = [];
+    this._newUidlMap = new Map();
+    this._nextAction = this._actionUidlResponse;
+    this._send("UIDL");
+  };
+
+  /**
+   * Handle `UIDL` response.
+   *
+   * @param {Pop3Response} res - UIDL response received from the server.
+   */
+  _actionUidlResponse = ({ status, success, data }) => {
+    if (status && !success) {
+      this._actionNoUidl();
+      return;
+    }
+    this._lineReader.read(
+      data,
+      line => {
+        let [messageNumber, uidl] = line.split(" ");
+        uidl = uidl.trim();
+        let uidlState = this._uidlMap.get(uidl);
+        if (uidlState) {
+          if (
+            uidlState.status == UIDL_KEEP &&
+            (!this._server.leaveMessagesOnServer ||
+              uidlState.receivedAt < this._cutOffTimestamp)
+          ) {
+            // Delete this message.
+            this._messagesToHandle.push({
+              ...uidlState,
+              messageNumber,
+              status: UIDL_DELETE,
+            });
+          } else if (
+            [UIDL_FETCH_BODY, UIDL_DELETE].includes(uidlState.status)
+          ) {
+            // Fetch the full message.
+            this._messagesToHandle.push({
+              ...uidlState,
+              messageNumber,
+              status: uidlState.status,
+            });
+          } else {
+            // Do nothing to this message.
+            this._newUidlMap.set(uidl, uidlState);
+          }
+        } else {
+          this._newMessageTotal++;
+          // Fetch the full message or only headers depending on server settings
+          // and message size.
+          let status =
+            this._server.headersOnly ||
+            this._messageSizeMap.get(messageNumber) > this._maxMessageSize
+              ? UIDL_TOO_BIG
+              : UIDL_FETCH_BODY;
+          this._messagesToHandle.push({
+            messageNumber,
+            uidl,
+            status,
+          });
+        }
+      },
+      () => {
+        if (!this._downloadMail) {
+          let numberOfMessages = this._messagesToHandle.filter(
+            // No receivedAt means we're seeing it for the first time.
+            msg => !msg.receivedAt
+          ).length;
+          if (numberOfMessages) {
+            this._sink.setBiffStateAndUpdateFE(
+              Ci.nsIMsgFolder.nsMsgBiffState_NewMail,
+              numberOfMessages,
+              true
+            );
+          }
+          this._actionDone();
+          return;
+        }
+
+        if (this._singleUidlToDownload) {
+          this._messagesToHandle = this._messagesToHandle.filter(
+            msg => msg.uidl == this._singleUidlToDownload
+          );
+          this._newUidlMap = this._uidlMap;
+        }
+
+        this._messagesToDownload = this._messagesToHandle.filter(msg =>
+          [UIDL_FETCH_BODY, UIDL_TOO_BIG].includes(msg.status)
+        );
+        this._totalDownloadSize = this._messagesToDownload.reduce(
+          (acc, msg) => acc + this._messageSizeMap.get(msg.messageNumber),
+          0
+        );
+        this._totalReceivedSize = 0;
+        try {
+          let localFolder = this._sink.folder.QueryInterface(
+            Ci.nsIMsgLocalMailFolder
+          );
+          if (
+            localFolder.warnIfLocalFileTooBig(
+              this._msgWindow,
+              this._totalDownloadSize
+            )
+          ) {
+            throw new Error("Not enough disk space");
+          }
+        } catch (e) {
+          this._logger.error(e);
+          this._actionDone(Cr.NS_ERROR_FAILURE);
+          return;
+        }
+
+        this._uidlMapChanged =
+          this._uidlMap.size != this._newUidlMap.size ||
+          this._messagesToHandle.length;
+        // This discards staled uidls that are no longer on the server.
+        this._uidlMap = this._newUidlMap;
+
+        this._sink.setMsgsToDownload(this._messagesToDownload.length);
+        this._actionHandleMessage();
+        this._updateProgress();
+      }
+    );
+  };
+
+  /**
+   * If the server doesn't support UIDL, leaveMessagesOnServer and headersOnly
+   * feature can't be used.
+   */
+  _actionNoUidl = () => {
+    if (
+      this._server.leaveMessagesOnServer ||
+      this._server.headersOnly ||
+      this._server.limitOfflineMessageSize ||
+      this._singleUidlToDownload
+    ) {
+      this._actionError("pop3ServerDoesNotSupportUidlEtc", [
+        this._server.hostName,
+      ]);
+      return;
+    }
+    for (let [messageNumber] of this._messageSizeMap) {
+      // Send RETR for each message.
+      this._messagesToHandle.push({
+        status: UIDL_FETCH_BODY,
+        messageNumber,
+      });
+    }
+    this._actionHandleMessage();
+  };
+
+  /**
+   * Consume a message from this._messagesToHandle, decide to send TOP, RETR or
+   * DELE request.
+   */
+  _actionHandleMessage = () => {
+    this._currentMessage = this._messagesToHandle.shift();
+    if (
+      this._messagesToHandle.length > 0 &&
+      this._messagesToHandle.length % 20 == 0 &&
+      !this._writeUidlPromise
+    ) {
+      // Update popstate.dat every 20 messages, so that even if an error
+      // happens, no need to re-download all messages.
+      this._writeUidlState();
+    }
+    if (this._currentMessage) {
+      switch (this._currentMessage.status) {
+        case UIDL_TOO_BIG:
+          if (this._topFailed) {
+            this._actionRetr();
+          } else {
+            this._actionTop();
+          }
+          break;
+        case UIDL_FETCH_BODY:
+          this._actionRetr();
+          break;
+        case UIDL_DELETE:
+          this._actionDelete();
+          break;
+        default:
+          break;
+      }
+    } else {
+      this._sink.setBiffStateAndUpdateFE(
+        Ci.nsIMsgFolder.nsMsgBiffState_NewMail,
+        this._messagesToDownload
+          ? this._messagesToDownload.length
+          : // No UIDL support, every message is new.
+            this._messageSizeMap.size,
+        false
+      );
+      try {
+        this._sink.endMailDelivery(this);
+        this._folderLocked = false;
+        this._logger.debug("Folder lock released.");
+      } catch (e) {
+        this._logger.error("endMailDelivery failed", e);
+        this._actionDone(e.result || Cr.NS_ERROR_FAILURE);
+        return;
+      }
+      this._actionDone();
+    }
+  };
+
+  /**
+   * Send `TOP` request to the server.
+   */
+  _actionTop = () => {
+    this._nextAction = this._actionTopResponse;
+    let lineNumber = this._server.headersOnly ? 0 : 20;
+    this._send(`TOP ${this._currentMessage.messageNumber} ${lineNumber}`);
+    this._updateStatus("receivingMessages", [
+      ++this._newMessageDownloaded,
+      this._newMessageTotal,
+    ]);
+  };
+
+  /**
+   * Handle `TOP` response.
+   *
+   * @param {Pop3Response} res - TOP response received from the server.
+   */
+  _actionTopResponse = res => {
+    if (res.status) {
+      if (res.success) {
+        try {
+          // Call incorporateBegin only once for each message.
+          this._sink.incorporateBegin(
+            this._currentMessage.uidl,
+            Ci.nsMsgMessageFlags.Partial
+          );
+        } catch (e) {
+          this._actionError("pop3MessageWriteError");
+          return;
+        }
+      } else {
+        // TOP is not supported.
+        this._topFailed = true;
+        this._actionRetr();
+        return;
+      }
+    }
+    this._lineReader.read(
+      res.data,
+      line => {
+        // Remove \r\n and use the OS native line ending.
+        line = line.slice(0, -2) + this._lineSeparator;
+        try {
+          this._sink.incorporateWrite(line, line.length);
+        } catch (e) {
+          this._actionError("pop3MessageWriteError");
+          throw e; // Stop reading.
+        }
+      },
+      () => {
+        try {
+          this._sink.incorporateComplete(
+            this._msgWindow,
+            // Set size because it's a partial message.
+            this._messageSizeMap.get(this._currentMessage.messageNumber)
+          );
+        } catch (e) {
+          this._actionError("pop3MessageWriteError");
+          return;
+        }
+
+        let state = this._uidlMap.get(this._currentMessage.uidl);
+        if (state?.status == UIDL_FETCH_BODY) {
+          this._actionRetr();
+          return;
+        }
+        if (state?.status == UIDL_DELETE) {
+          this._actionDelete();
+          return;
+        }
+        this._uidlMap.set(this._currentMessage.uidl, {
+          status: UIDL_TOO_BIG,
+          uidl: this._currentMessage.uidl,
+          receivedAt: Math.floor(Date.now() / 1000),
+        });
+        this._uidlMapChanged = true;
+        this._actionHandleMessage();
+      }
+    );
+  };
+
+  /**
+   * Send `RETR` request to the server.
+   */
+  _actionRetr = () => {
+    this._nextAction = this._actionRetrResponse;
+    this._send(`RETR ${this._currentMessage.messageNumber}`);
+    this._updateStatus("receivingMessages", [
+      ++this._newMessageDownloaded,
+      this._newMessageTotal,
+    ]);
+  };
+
+  /**
+   * Handle `RETR` response.
+   *
+   * @param {Pop3Response} res - RETR response received from the server.
+   */
+  _actionRetrResponse = res => {
+    if (res.status) {
+      if (!res.success) {
+        this._actionError("pop3RetrFailure", [], res.statusText);
+        return;
+      }
+      try {
+        // Call incorporateBegin only once for each message.
+        this._sink.incorporateBegin(this._currentMessage.uidl, 0);
+      } catch (e) {
+        this._actionError("pop3MessageWriteError");
+        return;
+      }
+    }
+    this._lineReader.read(
+      res.data,
+      line => {
+        line = line.slice(0, -2) + this._lineSeparator;
+        try {
+          this._sink.incorporateWrite(line, line.length);
+        } catch (e) {
+          this._actionError("pop3MessageWriteError");
+          throw e; // Stop reading.
+        }
+      },
+      () => {
+        // Don't count the ending indicator.
+        this._totalReceivedSize -= ".\r\n".length;
+        try {
+          this._sink.incorporateComplete(
+            this._msgWindow,
+            0 // Set size only when it's a partial message.
+          );
+        } catch (e) {
+          this._actionError("pop3MessageWriteError");
+          return;
+        }
+        if (this._server.leaveMessagesOnServer) {
+          let state = this._uidlMap.get(this._currentMessage.uidl);
+          if (state?.status == UIDL_DELETE) {
+            this._actionDelete();
+          } else {
+            this._uidlMap.set(this._currentMessage.uidl, {
+              status: UIDL_KEEP,
+              uidl: this._currentMessage.uidl,
+              receivedAt: Math.floor(Date.now() / 1000),
+            });
+            this._uidlMapChanged = true;
+            this._actionHandleMessage();
+          }
+        } else {
+          this._actionDelete();
+        }
+      }
+    );
+
+    this._totalReceivedSize += res.data.length;
+    this._updateProgress();
+  };
+
+  /**
+   * Send `DELE` request to the server.
+   */
+  _actionDelete = () => {
+    this._nextAction = this._actionDeleteResponse;
+    this._send(`DELE ${this._currentMessage.messageNumber}`);
+  };
+
+  /**
+   * Handle `DELE` response.
+   *
+   * @param {Pop3Response} res - DELE response received from the server.
+   */
+  _actionDeleteResponse = res => {
+    if (!res.success) {
+      this._actionError("pop3DeleFailure", [], res.statusText);
+      return;
+    }
+    this._actionHandleMessage();
+  };
+
+  /**
+   * Show an error prompt.
+   *
+   * @param {string} errorName - An error name corresponds to an entry of
+   *   localMsgs.properties.
+   * @param {string[]} errorParams - Params to construct the error message.
+   * @param {string} serverErrorMsg - Error message returned by the server.
+   */
+  _actionError(errorName, errorParams, serverErrorMsg) {
+    this._logger.error(`Got an error name=${errorName}`);
+    if (errorName != "pop3PasswordFailed") {
+      this._actionDone(Cr.NS_ERROR_FAILURE);
+    }
+
+    if (!this._msgWindow) {
+      return;
+    }
+    let bundle = Services.strings.createBundle(
+      "chrome://messenger/locale/localMsgs.properties"
+    );
+    let errorMsg;
+    if (errorParams) {
+      errorMsg = bundle.formatStringFromName(errorName, errorParams);
+    } else {
+      errorMsg = bundle.GetStringFromName(errorName);
+    }
+    if (serverErrorMsg) {
+      let serverSaidPrefix = bundle.formatStringFromName("pop3ServerSaid", [
+        this._server.hostName,
+      ]);
+      errorMsg += ` ${serverSaidPrefix} ${serverErrorMsg}`;
+    }
+
+    let errorTitle = bundle.formatStringFromName("pop3ErrorDialogTitle", [
+      this._server.prettyName,
+    ]);
+    Services.prompt.alert(this._msgWindow.domWindow, errorTitle, errorMsg);
+  }
+
+  /**
+   * Save popstate.dat when necessary, send QUIT.
+   * @param {nsresult} status - Indicate if the last action succeeded.
+   */
+  _actionDone = (status = Cr.NS_OK) => {
+    if (this._done) {
+      return;
+    }
+    this._done = true;
+    this._logger.debug(`Done with status=${status}`);
+    this._authenticating = false;
+    if (status == Cr.NS_OK) {
+      if (this._newMessageTotal) {
+        this._updateStatus("receivedMsgs", [
+          this._newMessageTotal,
+          this._newMessageTotal,
+        ]);
+      } else {
+        this._updateStatus("noNewMessages");
+      }
+    } else if (this._currentMessage) {
+      // Put _currentMessage back to the queue to prevent loss of popstate.
+      this._messagesToHandle.unshift(this._currentMessage);
+    }
+    this._writeUidlState(true);
+    // Normally we clean up after QUIT response.
+    this.quit(() => this._cleanUp(status));
+    // If we didn't receive QUIT response after 3 seconds, clean up anyway.
+    setTimeout(() => {
+      if (!this._cleanedUp) {
+        this._cleanUp(status);
+      }
+    }, 3000);
+  };
+
+  /**
+   * Notify listeners, close the socket and rest states.
+   * @param {nsresult} status - Indicate if the last action succeeded.
+   */
+  _cleanUp = status => {
+    this._cleanedUp = true;
+    this.close();
+    this.urlListener.OnStopRunningUrl(this.runningUri, status);
+    this.runningUri.SetUrlState(false, Cr.NS_OK);
+    this.onDone?.(status);
+    if (this._folderLocked) {
+      this._sink.abortMailDelivery(this);
+      this._folderLocked = false;
+      this._logger.debug("Folder lock released.");
+    }
+    this._server.wrappedJSObject.runningClient = null;
+  };
+
+  /**
+   * Show a status message in the status bar.
+   *
+   * @param {string} statusName - A string name in localMsgs.properties.
+   * @param {string[]} [params] - Params to format the string.
+   */
+  _updateStatus(statusName, params) {
+    if (!this._msgWindow?.statusFeedback) {
+      return;
+    }
+    if (!this._localBundle) {
+      this._localBundle = Services.strings.createBundle(
+        "chrome://messenger/locale/localMsgs.properties"
+      );
+      this._messengerBundle = Services.strings.createBundle(
+        "chrome://messenger/locale/messenger.properties"
+      );
+    }
+    let status = params
+      ? this._localBundle.formatStringFromName(statusName, params)
+      : this._localBundle.GetStringFromName(statusName);
+    this._msgWindow.statusFeedback.showStatusString(
+      this._messengerBundle.formatStringFromName("statusMessage", [
+        this._server.prettyName,
+        status,
+      ])
+    );
+  }
+
+  /**
+   * Show a progress bar in the status bar.
+   */
+  _updateProgress() {
+    this._msgWindow?.statusFeedback?.showProgress(
+      Math.floor((this._totalReceivedSize * 100) / this._totalDownloadSize)
+    );
+  }
+
+  /** @see nsIPop3Protocol */
+  checkMessage(uidl) {
+    return this._uidlMap.has(uidl);
+  }
+}
diff --git a/comm/mailnews/local/src/Pop3IncomingServer.jsm b/comm/mailnews/local/src/Pop3IncomingServer.jsm
new file mode 100644
index 0000000000..b8c147a022
--- /dev/null
+++ b/comm/mailnews/local/src/Pop3IncomingServer.jsm
@@ -0,0 +1,308 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["Pop3IncomingServer"];
+
+var { MsgIncomingServer } = ChromeUtils.import(
+  "resource:///modules/MsgIncomingServer.jsm"
+);
+const { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+const { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+const lazy = {};
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  Pop3Client: "resource:///modules/Pop3Client.jsm",
+});
+
+/**
+ * @implements {nsIPop3IncomingServer}
+ * @implements {nsILocalMailIncomingServer}
+ * @implements {nsIMsgIncomingServer}
+ * @implements {nsISupportsWeakReference}
+ */
+class Pop3IncomingServer extends MsgIncomingServer {
+  QueryInterface = ChromeUtils.generateQI([
+    "nsIPop3IncomingServer",
+    "nsILocalMailIncomingServer",
+    "nsIMsgIncomingServer",
+    "nsISupportsWeakReference",
+  ]);
+
+  constructor() {
+    super();
+
+    // nsIMsgIncomingServer attributes.
+    this.localStoreType = "mailbox";
+    this.localDatabaseType = "mailbox";
+    this.downloadMessagesAtStartup = true;
+    this.canBeDefaultServer = true;
+
+    Object.defineProperty(this, "canCreateFoldersOnServer", {
+      get: () => !this.deferredToAccount,
+    });
+    Object.defineProperty(this, "canFileMessagesOnServer", {
+      get: () => !this.deferredToAccount,
+    });
+
+    // nsIPop3IncomingServer attributes that map directly to pref values.
+    this._mapAttrsToPrefs([
+      ["Bool", "leaveMessagesOnServer", "leave_on_server"],
+      ["Bool", "headersOnly", "headers_only"],
+      ["Bool", "deleteMailLeftOnServer", "delete_mail_left_on_server"],
+      ["Bool", "deleteByAgeFromServer", "delete_by_age_from_server"],
+      ["Bool", "deferGetNewMail", "defer_get_new_mail"],
+      ["Int", "numDaysToLeaveOnServer", "num_days_to_leave_on_server"],
+    ]);
+
+    // @type {Map<string,string>} - A map from uidl to status.
+    this._uidlsToMark = new Map();
+  }
+
+  /** @see nsIMsgIncomingServer */
+  get rootMsgFolder() {
+    if (this._rootMsgFolder) {
+      return this._rootMsgFolder;
+    }
+
+    if (!this.deferredToAccount) {
+      this._rootMsgFolder = this.rootFolder;
+      return this._rootMsgFolder;
+    }
+
+    let incomingServer = MailServices.accounts.getAccount(
+      this.deferredToAccount
+    ).incomingServer;
+    if (incomingServer.equals(this)) {
+      // Make sure we're not deferred to ourself.
+      throw Components.Exception(
+        `${incomingServer.prettyName} cannot be deferred to itself`,
+        Cr.NS_ERROR_FAILURE
+      );
+    }
+
+    this._rootMsgFolder = incomingServer.rootMsgFolder;
+    return this._rootMsgFolder;
+  }
+
+  get canSearchMessages() {
+    return this.canFileMessagesOnServer;
+  }
+
+  getNewMessages(folder, msgWindow, urlListener) {
+    let inbox = this.rootMsgFolder.getFolderWithFlags(
+      Ci.nsMsgFolderFlags.Inbox
+    );
+    if (!this.deferredToAccount) {
+      let deferredServers = this._getDeferedServers(folder.server);
+      if (deferredServers.length) {
+        // If other servers are deferred to this server, get new mail for them
+        // as well.
+        return this.downloadMailFromServers(
+          [...deferredServers, this],
+          msgWindow,
+          inbox,
+          urlListener
+        );
+      }
+    }
+    return MailServices.pop3.GetNewMail(msgWindow, urlListener, inbox, this);
+  }
+
+  verifyLogon(urlListener, msgWindow) {
+    return MailServices.pop3.verifyLogon(this, urlListener, msgWindow);
+  }
+
+  performBiff(msgWindow) {
+    this.performingBiff = true;
+    let inbox = this.rootMsgFolder.getFolderWithFlags(
+      Ci.nsMsgFolderFlags.Inbox
+    );
+    let urlListener = inbox.QueryInterface(Ci.nsIUrlListener);
+    if (this.downloadOnBiff) {
+      MailServices.pop3.GetNewMail(msgWindow, urlListener, inbox, this);
+    } else {
+      MailServices.pop3.CheckForNewMail(msgWindow, urlListener, inbox, this);
+    }
+  }
+
+  /** @see nsILocalMailIncomingServer */
+  createDefaultMailboxes() {
+    for (let name of ["Inbox", "Trash"]) {
+      let folderUri = this.rootFolder.URI + "/" + name;
+      // Check by URI instead of by name, because folder name can be localized.
+      if (!this.rootFolder.getChildWithURI(folderUri, false, false)) {
+        this.msgStore.createFolder(this.rootFolder, name);
+      }
+    }
+  }
+
+  setFlagsOnDefaultMailboxes() {
+    this.rootFolder
+      .QueryInterface(Ci.nsIMsgLocalMailFolder)
+      // POP3 account gets an inbox, but no queue (unsent messages).
+      .setFlagsOnDefaultMailboxes(
+        Ci.nsMsgFolderFlags.SpecialUse & ~Ci.nsMsgFolderFlags.Queue
+      );
+  }
+
+  getNewMail(msgWindow, urlListener, inbox) {
+    return MailServices.pop3.GetNewMail(msgWindow, urlListener, inbox, this);
+  }
+
+  /** @see nsIPop3IncomingServer */
+  get deferredToAccount() {
+    let accountKey = this.getCharValue("deferred_to_account");
+    if (!accountKey) {
+      return "";
+    }
+
+    let account = MailServices.accounts.getAccount(accountKey);
+    // If currently deferred to an invalid or hidden server, change to defer to
+    // the local folders inbox.
+    if (!account || !account.incomingServer || account.incomingServer.hidden) {
+      let localAccount;
+      try {
+        localAccount = MailServices.accounts.FindAccountForServer(
+          MailServices.accounts.localFoldersServer
+        );
+      } catch (e) {
+        // MailServices.accounts.localFoldersServer throws if no Local Folders.
+        return "";
+      }
+      accountKey = localAccount.key;
+      this.setCharValue("deferred_to_account", accountKey);
+    }
+
+    return accountKey;
+  }
+
+  set deferredToAccount(accountKey) {
+    this._rootMsgFolder = null;
+
+    let wasDeferred = Boolean(this.deferredToAccount);
+    this.setCharValue("deferred_to_account", accountKey);
+
+    // If isDeferred state has changed, send notification.
+    if (Boolean(accountKey) != wasDeferred) {
+      let folderListenerManager = MailServices.mailSession.QueryInterface(
+        Ci.nsIFolderListener
+      );
+      folderListenerManager.onFolderBoolPropertyChanged(
+        this.rootFolder,
+        "isDeferred",
+        wasDeferred,
+        !wasDeferred
+      );
+      folderListenerManager.onFolderBoolPropertyChanged(
+        this.rootFolder,
+        "CanFileMessages",
+        !wasDeferred,
+        wasDeferred
+      );
+    }
+
+    if (!accountKey) {
+      return;
+    }
+    // Check if we are deferred to the local folders, and create INBOX if needed.
+    let server = MailServices.accounts.getAccount(accountKey).incomingServer;
+    if (server instanceof Ci.nsILocalMailIncomingServer) {
+      // Check by URI instead of by name, because folder name can be localized.
+      if (
+        !this.rootFolder.getChildWithURI(
+          `${this.rootFolder.URI}/Inbox`,
+          false,
+          false
+        )
+      ) {
+        server.rootFolder.createSubfolder("Inbox", null);
+      }
+    }
+  }
+
+  addUidlToMark(uidl, mark) {
+    // @see nsIMsgLocalMailFolder
+    const POP3_DELETE = 1;
+    const POP3_FETCH_BODY = 2;
+    let status = "k";
+    if (mark == POP3_DELETE) {
+      status = "d";
+    } else if (mark == POP3_FETCH_BODY) {
+      status = "f";
+    }
+    this._uidlsToMark.set(uidl, status);
+  }
+
+  markMessages() {
+    if (!this._uidlsToMark.size) {
+      return;
+    }
+
+    let client = this.runningClient || new lazy.Pop3Client(this);
+    // Pass a clone of this._uidlsToMark to client.markMessages, because
+    // this._uidlsToMark may be changed before markMessages finishes.
+    client.markMessages(new Map(this._uidlsToMark));
+    this._uidlsToMark = new Map();
+  }
+
+  downloadMailFromServers(servers, msgWindow, folder, urlListener) {
+    let server = servers.shift();
+    if (!server) {
+      urlListener?.OnStopRunningUrl(null, Cr.NS_OK);
+      return;
+    }
+
+    // If server != folder.server, it means server is deferred to folder.server,
+    // so if server.deferGetNewMail is false, no need to call GetNewMail.
+    if (server == folder.server || server.deferGetNewMail) {
+      MailServices.pop3.GetNewMail(
+        msgWindow,
+        {
+          OnStartRunningUrl() {},
+          OnStopRunningUrl: () => {
+            // Call GetNewMail for the next server only after it is finished for
+            // the current server.
+            this.downloadMailFromServers(
+              servers,
+              msgWindow,
+              folder,
+              urlListener
+            );
+          },
+        },
+        folder,
+        server
+      );
+      return;
+    }
+    this.downloadMailFromServers(servers, msgWindow, folder, urlListener);
+  }
+
+  /**
+   * Get all the servers that defer to the passed in server.
+   *
+   * @param {nsIMsgIncomingServer} dstServer - The server that others servers
+   *   are deferred to.
+   */
+  _getDeferedServers(dstServer) {
+    let dstAccount = MailServices.accounts.FindAccountForServer(dstServer);
+    if (!dstAccount) {
+      return [];
+    }
+    return MailServices.accounts.allServers.filter(
+      server =>
+        server instanceof Ci.nsIPop3IncomingServer &&
+        server.deferredToAccount == dstAccount.key
+    );
+  }
+}
+
+Pop3IncomingServer.prototype.classID = Components.ID(
+  "{f99fdbf7-2e79-4ce3-9d94-7af3763b82fc}"
+);
diff --git a/comm/mailnews/local/src/Pop3ProtocolHandler.jsm b/comm/mailnews/local/src/Pop3ProtocolHandler.jsm
new file mode 100644
index 0000000000..51b1d5bf22
--- /dev/null
+++ b/comm/mailnews/local/src/Pop3ProtocolHandler.jsm
@@ -0,0 +1,40 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var EXPORTED_SYMBOLS = ["Pop3ProtocolHandler"];
+
+var { Pop3Channel } = ChromeUtils.import("resource:///modules/Pop3Channel.jsm");
+
+/**
+ * @implements {nsIProtocolHandler}
+ */
+class Pop3ProtocolHandler {
+  QueryInterface = ChromeUtils.generateQI(["nsIProtocolHandler"]);
+
+  scheme = "pop3";
+
+  newChannel(uri, loadInfo) {
+    let channel = new Pop3Channel(uri, loadInfo);
+    let spec = uri.spec;
+    if (
+      spec.includes("part=") &&
+      !spec.includes("type=message/rfc822") &&
+      !spec.includes("type=application/x-message-display") &&
+      !spec.includes("type=application/pdf")
+    ) {
+      channel.contentDisposition = Ci.nsIChannel.DISPOSITION_ATTACHMENT;
+    } else {
+      channel.contentDisposition = Ci.nsIChannel.DISPOSITION_INLINE;
+    }
+    return channel;
+  }
+
+  allowPort(port, scheme) {
+    return true;
+  }
+}
+
+Pop3ProtocolHandler.prototype.classID = Components.ID(
+  "{eed38573-d01b-4c13-9f9d-f69963095a4d}"
+);
diff --git a/comm/mailnews/local/src/Pop3ProtocolInfo.jsm b/comm/mailnews/local/src/Pop3ProtocolInfo.jsm
new file mode 100644
index 0000000000..57fc9b07d9
--- /dev/null
+++ b/comm/mailnews/local/src/Pop3ProtocolInfo.jsm
@@ -0,0 +1,44 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const EXPORTED_SYMBOLS = ["Pop3ProtocolInfo"];
+
+var { MsgProtocolInfo } = ChromeUtils.importESModule(
+  "resource:///modules/MsgProtocolInfo.sys.mjs"
+);
+
+/**
+ * @implements {nsIMsgProtocolInfo}
+ */
+class Pop3ProtocolInfo extends MsgProtocolInfo {
+  QueryInterface = ChromeUtils.generateQI(["nsIMsgProtocolInfo"]);
+
+  serverIID = Components.ID("{f99fdbf7-2e79-4ce3-9d94-7af3763b82fc}");
+
+  requiresUsername = true;
+  preflightPrettyNameWithEmailAddress = true;
+  canDelete = true;
+  canLoginAtStartUp = true;
+  canDuplicate = true;
+  canGetMessages = true;
+  canGetIncomingMessages = true;
+  defaultDoBiff = true;
+  showComposeMsgLink = true;
+  foldersCreatedAsync = false;
+
+  getDefaultServerPort(isSecure) {
+    return isSecure
+      ? Ci.nsIPop3URL.DEFAULT_POP3S_PORT
+      : Ci.nsIPop3URL.DEFAULT_POP3_PORT;
+  }
+
+  // @see MsgProtocolInfo.sys.mjs
+  RELATIVE_PREF = "mail.root.pop3-rel";
+  ABSOLUTE_PREF = "mail.root.pop3";
+  DIR_SERVICE_PROP = "MailD";
+}
+
+Pop3ProtocolInfo.prototype.classID = Components.ID(
+  "{7689942f-cbd1-42ad-87b9-44128354f55d}"
+);
diff --git a/comm/mailnews/local/src/Pop3Service.jsm b/comm/mailnews/local/src/Pop3Service.jsm
new file mode 100644
index 0000000000..0270489fcd
--- /dev/null
+++ b/comm/mailnews/local/src/Pop3Service.jsm
@@ -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/. */
+
+const EXPORTED_SYMBOLS = ["Pop3Service"];
+
+var { Pop3Client } = ChromeUtils.import("resource:///modules/Pop3Client.jsm");
+
+/**
+ * @implements {nsIPop3Service}
+ */
+class Pop3Service {
+  QueryInterface = ChromeUtils.generateQI(["nsIPop3Service"]);
+
+  constructor() {
+    this._listeners = new Set();
+  }
+
+  GetNewMail(msgWindow, urlListener, inbox, server) {
+    return this._getMail(true, msgWindow, urlListener, inbox, server);
+  }
+
+  CheckForNewMail(msgWindow, urlListener, inbox, server) {
+    return this._getMail(false, msgWindow, urlListener, inbox, server);
+  }
+
+  verifyLogon(server, urlListener, msgWindow) {
+    let client = new Pop3Client(server);
+    client.urlListener = urlListener;
+    client.connect();
+    client.onOpen = () => {
+      client.verifyLogon(msgWindow);
+    };
+    return client.runningUri;
+  }
+
+  addListener(listener) {
+    this._listeners.add(listener);
+  }
+
+  removeListener(listener) {
+    this._listeners.remove(listener);
+  }
+
+  notifyDownloadStarted(folder) {
+    for (let listener of this._listeners) {
+      listener.onDownloadStarted(folder);
+    }
+  }
+
+  notifyDownloadProgress(folder, numMessages, numTotalMessages) {
+    for (let listener of this._listeners) {
+      listener.onDownloadProgress(folder, numMessages, numTotalMessages);
+    }
+  }
+
+  notifyDownloadCompleted(folder, numMessages) {
+    for (let listener of this._listeners) {
+      listener.onDownloadCompleted(folder, numMessages);
+    }
+  }
+
+  _getMail(downloadNewMail, msgWindow, urlListener, inbox, server) {
+    let client = new Pop3Client(server);
+    client.runningUri.msgWindow = msgWindow;
+    client.urlListener = urlListener;
+    client.connect();
+    client.onOpen = () => {
+      client.getMail(downloadNewMail, msgWindow, inbox);
+    };
+    return client.runningUri;
+  }
+}
+
+Pop3Service.prototype.classID = Components.ID(
+  "{1e8f21c3-32c3-4114-9ea4-3d74006fb351}"
+);
diff --git a/comm/mailnews/local/src/components.conf b/comm/mailnews/local/src/components.conf
new file mode 100644
index 0000000000..00f814f5df
--- /dev/null
+++ b/comm/mailnews/local/src/components.conf
@@ -0,0 +1,150 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+Classes = [
+    {
+        "cid": "{060e684a-0acd-41f1-b36b-12de686f201e}",
+        "contract_ids": ["@mozilla.org/messenger/pop3-sink;1"],
+        "type": "nsPop3Sink",
+        "headers": ["/comm/mailnews/local/src/nsPop3Sink.h"],
+    },
+    {
+        "cid": "{f99fdbf7-2e79-4ce3-9d94-7af3763b82fc}",
+        "contract_ids": ["@mozilla.org/messenger/server;1?type=pop3"],
+        "jsm": "resource:///modules/Pop3IncomingServer.jsm",
+        "constructor": "Pop3IncomingServer",
+    },
+    {
+        "cid": "{1e8f21c3-32c3-4114-9ea4-3d74006fb351}",
+        "contract_ids": ["@mozilla.org/messenger/popservice;1"],
+        "jsm": "resource:///modules/Pop3Service.jsm",
+        "constructor": "Pop3Service",
+    },
+    {
+        "cid": "{7689942f-cbd1-42ad-87b9-44128354f55d}",
+        "contract_ids": ["@mozilla.org/messenger/protocol/info;1?type=pop3"],
+        "jsm": "resource:///modules/Pop3ProtocolInfo.jsm",
+        "constructor": "Pop3ProtocolInfo",
+    },
+    {
+        "cid": "{eed38573-d01b-4c13-9f9d-f69963095a4d}",
+        "contract_ids": ["@mozilla.org/network/protocol;1?name=pop"],
+        "jsm": "resource:///modules/Pop3ProtocolHandler.jsm",
+        "constructor": "Pop3ProtocolHandler",
+        "protocol_config": {
+            "scheme": "pop3",
+            "flags": [
+                "URI_NORELATIVE",
+                "URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT",
+                "URI_DANGEROUS_TO_LOAD",
+                "ALLOWS_PROXY",
+                "URI_FORBIDS_COOKIE_ACCESS",
+            ],
+            "default_port": 110,
+        },
+    },
+    {
+        "cid": "{46efcb10-cb6d-11d2-8065-006008128c4e}",
+        "contract_ids": ["@mozilla.org/messenger/mailboxurl;1"],
+        "type": "nsMailboxUrl",
+        "headers": ["/comm/mailnews/local/src/nsMailboxUrl.h"],
+    },
+    {
+        "cid": "{3fdae3ab-4ac1-4ad4-b28a-28d0fa363929}",
+        "contract_ids": ["@mozilla.org/messenger/msgmailnewsurl;1"],
+        "type": "nsMsgMailNewsUrl",
+        "headers": ["/comm/mailnews/base/src/nsMsgMailNewsUrl.h"],
+    },
+    {
+        "cid": "{eef82462-cb69-11d2-8065-006008128c4e}",
+        "contract_ids": [
+            "@mozilla.org/messenger/mailboxservice;1",
+            "@mozilla.org/messenger/messageservice;1?type=mailbox",
+            "@mozilla.org/messenger/messageservice;1?type=mailbox-message",
+            "@mozilla.org/network/protocol;1?name=mailbox",
+        ],
+        "type": "nsMailboxService",
+        "headers": ["/comm/mailnews/local/src/nsMailboxService.h"],
+        "protocol_config": {
+            "scheme": "mailbox",
+            "flags": [
+                "URI_NORELATIVE",
+                "URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT",
+                "URI_DANGEROUS_TO_LOAD",
+                "URI_FORBIDS_COOKIE_ACCESS",
+                "ORIGIN_IS_FULL_SPEC",
+            ],
+        },
+    },
+    {
+        "cid": "{d17e0e22-285b-4239-863c-2eebb008b5cd}",
+        "contract_ids": ["@mozilla.org/messenger/mailboxparser;1"],
+        "type": "nsMsgMailboxParser",
+        "headers": ["/comm/mailnews/local/src/nsParseMailbox.h"],
+    },
+    {
+        "cid": "{ea1b0a11-e6f4-11d2-8070-006008128c4e}",
+        "contract_ids": ["@mozilla.org/messenger/popurl;1"],
+        "type": "nsPop3URL",
+        "headers": ["/comm/mailnews/local/src/nsPop3URL.h"],
+    },
+    {
+        "cid": "{75b63b46-1dd2-11b2-9873-bb375e1550fa}",
+        "contract_ids": [
+            "@mozilla.org/messenger/noneservice;1",
+            "@mozilla.org/messenger/protocol/info;1?type=none",
+        ],
+        "type": "nsNoneService",
+        "headers": ["/comm/mailnews/local/src/nsNoneService.h"],
+    },
+    {
+        "cid": "{e490d22c-cd67-11d2-8cca-0060b0fc14a3}",
+        "contract_ids": ["@mozilla.org/mail/folder-factory;1?name=mailbox"],
+        "type": "nsMsgLocalMailFolder",
+        "headers": ["/comm/mailnews/local/src/nsLocalMailFolder.h"],
+    },
+    {
+        "cid": "{36358199-a0e4-4b68-929f-77c01de34c67}",
+        "contract_ids": ["@mozilla.org/msgstore/berkeleystore;1"],
+        "type": "nsMsgBrkMBoxStore",
+        "headers": ["/comm/mailnews/local/src/nsMsgBrkMBoxStore.h"],
+    },
+    {
+        "cid": "{1f993eda-7dd9-11df-819a-6257dfd72085}",
+        "contract_ids": ["@mozilla.org/msgstore/maildirstore;1"],
+        "type": "nsMsgMaildirStore",
+        "headers": ["/comm/mailnews/local/src/nsMsgMaildirStore.h"],
+    },
+    {
+        "cid": "{ca5ffe7e-5f47-11d3-9a51-004005263078}",
+        "contract_ids": ["@mozilla.org/messenger/server;1?type=none"],
+        "type": "nsNoIncomingServer",
+        "init_method": "Init",
+        "headers": ["/comm/mailnews/local/src/nsNoIncomingServer.h"],
+    },
+    {
+        "cid": "{2b79ac51-1459-11d3-8097-006008128c4e}",
+        "contract_ids": ["@mozilla.org/messenger/messagestateparser;1"],
+        "type": "nsParseMailMessageState",
+        "headers": ["/comm/mailnews/local/src/nsParseMailbox.h"],
+    },
+    {
+        "cid": "{44aef4ce-475b-42e3-bc42-7730d5ce7365}",
+        "contract_ids": [
+            "@mozilla.org/messenger/rssservice;1",
+            "@mozilla.org/messenger/protocol/info;1?type=rss",
+        ],
+        "type": "nsRssService",
+        "headers": ["/comm/mailnews/local/src/nsRssService.h"],
+    },
+    {
+        "cid": "{3a874285-5520-41a0-bcda-a3dee3dbf4f3}",
+        "contract_ids": ["@mozilla.org/messenger/server;1?type=rss"],
+        "type": "nsRssIncomingServer",
+        "init_method": "Init",
+        "headers": ["/comm/mailnews/local/src/nsRssIncomingServer.h"],
+    },
+]
diff --git a/comm/mailnews/local/src/moz.build b/comm/mailnews/local/src/moz.build
new file mode 100644
index 0000000000..f530740b80
--- /dev/null
+++ b/comm/mailnews/local/src/moz.build
@@ -0,0 +1,40 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+SOURCES += [
+    "nsLocalMailFolder.cpp",
+    "nsLocalUndoTxn.cpp",
+    "nsLocalUtils.cpp",
+    "nsMailboxProtocol.cpp",
+    "nsMailboxServer.cpp",
+    "nsMailboxService.cpp",
+    "nsMailboxUrl.cpp",
+    "nsMsgBrkMBoxStore.cpp",
+    "nsMsgFileHdr.cpp",
+    "nsMsgLocalStoreUtils.cpp",
+    "nsMsgMaildirStore.cpp",
+    "nsNoIncomingServer.cpp",
+    "nsNoneService.cpp",
+    "nsParseMailbox.cpp",
+    "nsPop3Sink.cpp",
+    "nsPop3URL.cpp",
+    "nsRssIncomingServer.cpp",
+    "nsRssService.cpp",
+]
+
+FINAL_LIBRARY = "mail"
+
+EXTRA_JS_MODULES += [
+    "Pop3Channel.jsm",
+    "Pop3Client.jsm",
+    "Pop3IncomingServer.jsm",
+    "Pop3ProtocolHandler.jsm",
+    "Pop3ProtocolInfo.jsm",
+    "Pop3Service.jsm",
+]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
diff --git a/comm/mailnews/local/src/nsLocalMailFolder.cpp b/comm/mailnews/local/src/nsLocalMailFolder.cpp
new file mode 100644
index 0000000000..2602c40046
--- /dev/null
+++ b/comm/mailnews/local/src/nsLocalMailFolder.cpp
@@ -0,0 +1,3468 @@
+/* -*- 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 "prlog.h"
+
+#include "msgCore.h"  // precompiled header...
+#include "nsLocalMailFolder.h"
+#include "nsMsgLocalFolderHdrs.h"
+#include "nsMsgFolderFlags.h"
+#include "nsMsgMessageFlags.h"
+#include "prprf.h"
+#include "prmem.h"
+#include "nsITransactionManager.h"
+#include "nsParseMailbox.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgWindow.h"
+#include "nsCOMPtr.h"
+#include "nsMsgUtils.h"
+#include "nsLocalUtils.h"
+#include "nsIPop3IncomingServer.h"
+#include "nsILocalMailIncomingServer.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsString.h"
+#include "nsIMsgFolderCacheElement.h"
+#include "nsUnicharUtils.h"
+#include "nsICopyMessageStreamListener.h"
+#include "nsIMsgCopyService.h"
+#include "nsMsgTxn.h"
+#include "nsIMessenger.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsIDocShell.h"
+#include "nsIPrompt.h"
+#include "nsIPop3URL.h"
+#include "nsIMsgMailSession.h"
+#include "nsIMsgFolderCompactor.h"
+#include "nsNetCID.h"
+#include "nsISpamSettings.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsMailHeaders.h"
+#include "nsCOMArray.h"
+#include "nsIRssIncomingServer.h"
+#include "nsNetUtil.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsReadLine.h"
+#include "nsIStringEnumerator.h"
+#include "nsIURIMutator.h"
+#include "mozilla/Components.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/SlicedInputStream.h"
+
+//////////////////////////////////////////////////////////////////////////////
+// nsLocal
+/////////////////////////////////////////////////////////////////////////////
+
+nsLocalMailCopyState::nsLocalMailCopyState()
+    : m_flags(0),
+      m_lastProgressTime(PR_IntervalToMilliseconds(PR_IntervalNow())),
+      m_curDstKey(nsMsgKey_None),
+      m_curCopyIndex(0),
+      m_totalMsgCount(0),
+      m_dataBufferSize(0),
+      m_leftOver(0),
+      m_isMove(false),
+      m_dummyEnvelopeNeeded(false),
+      m_fromLineSeen(false),
+      m_writeFailed(false),
+      m_notifyFolderLoaded(false) {}
+
+nsLocalMailCopyState::~nsLocalMailCopyState() {
+  PR_Free(m_dataBuffer);
+  if (m_fileStream) m_fileStream->Close();
+  if (m_messageService) {
+    nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryInterface(m_srcSupport);
+    if (srcFolder && m_message) {
+      nsCString uri;
+      srcFolder->GetUriForMsg(m_message, uri);
+    }
+  }
+}
+
+nsLocalFolderScanState::nsLocalFolderScanState() : m_uidl(nullptr) {}
+
+nsLocalFolderScanState::~nsLocalFolderScanState() {}
+
+///////////////////////////////////////////////////////////////////////////////
+// nsMsgLocalMailFolder interface
+///////////////////////////////////////////////////////////////////////////////
+
+nsMsgLocalMailFolder::nsMsgLocalMailFolder(void)
+    : mCopyState(nullptr),
+      mHaveReadNameFromDB(false),
+      mInitialized(false),
+      mCheckForNewMessagesAfterParsing(false),
+      m_parsingFolder(false),
+      mDownloadState(DOWNLOAD_STATE_NONE) {}
+
+nsMsgLocalMailFolder::~nsMsgLocalMailFolder(void) {}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsMsgLocalMailFolder, nsMsgDBFolder,
+                            nsICopyMessageListener, nsIMsgLocalMailFolder)
+
+////////////////////////////////////////////////////////////////////////////////
+
+nsresult nsMsgLocalMailFolder::CreateChildFromURI(const nsACString& uri,
+                                                  nsIMsgFolder** folder) {
+  nsMsgLocalMailFolder* newFolder = new nsMsgLocalMailFolder;
+  if (!newFolder) return NS_ERROR_OUT_OF_MEMORY;
+
+  NS_ADDREF(*folder = newFolder);
+  newFolder->Init(uri);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::CreateLocalSubfolder(
+    const nsAString& aFolderName, nsIMsgFolder** aChild) {
+  NS_ENSURE_ARG_POINTER(aChild);
+  nsresult rv = CreateSubfolderInternal(aFolderName, nullptr, aChild);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+      do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+  if (notifier) notifier->NotifyFolderAdded(*aChild);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::GetManyHeadersToDownload(bool* retval) {
+  bool isLocked;
+  // if the folder is locked, we're probably reparsing - let's build the
+  // view when we've finished reparsing.
+  GetLocked(&isLocked);
+  if (isLocked) {
+    *retval = true;
+    return NS_OK;
+  }
+
+  return nsMsgDBFolder::GetManyHeadersToDownload(retval);
+}
+
+// run the url to parse the mailbox
+NS_IMETHODIMP nsMsgLocalMailFolder::ParseFolder(nsIMsgWindow* aMsgWindow,
+                                                nsIUrlListener* aListener) {
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  nsresult rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (aListener != this) mReparseListener = aListener;
+  // if parsing is synchronous, we need to set m_parsingFolder to
+  // true before starting. And we need to open the db before
+  // setting m_parsingFolder to true.
+  //  OpenDatabase();
+  rv = msgStore->RebuildIndex(this, mDatabase, aMsgWindow, this);
+  if (NS_SUCCEEDED(rv)) m_parsingFolder = true;
+
+  return rv;
+}
+
+// this won't force a reparse of the folder if the db is invalid.
+NS_IMETHODIMP
+nsMsgLocalMailFolder::GetMsgDatabase(nsIMsgDatabase** aMsgDatabase) {
+  return GetDatabaseWOReparse(aMsgDatabase);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::GetSubFolders(nsTArray<RefPtr<nsIMsgFolder>>& folders) {
+  if (!mInitialized) {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    nsresult rv = GetServer(getter_AddRefs(server));
+    NS_ENSURE_SUCCESS(rv, NS_MSG_INVALID_OR_MISSING_SERVER);
+    nsCOMPtr<nsIMsgPluggableStore> msgStore;
+    // need to set this flag here to avoid infinite recursion
+    mInitialized = true;
+    rv = server->GetMsgStore(getter_AddRefs(msgStore));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // This should add all existing folders as sub-folders of this folder.
+    rv = msgStore->DiscoverSubFolders(this, true);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIFile> path;
+    rv = GetFilePath(getter_AddRefs(path));
+    if (NS_FAILED(rv)) return rv;
+
+    bool directory;
+    path->IsDirectory(&directory);
+    if (directory) {
+      SetFlag(nsMsgFolderFlags::Mail | nsMsgFolderFlags::Elided |
+              nsMsgFolderFlags::Directory);
+
+      bool isServer;
+      GetIsServer(&isServer);
+      if (isServer) {
+        nsCOMPtr<nsIMsgIncomingServer> server;
+        rv = GetServer(getter_AddRefs(server));
+        NS_ENSURE_SUCCESS(rv, NS_MSG_INVALID_OR_MISSING_SERVER);
+
+        nsCOMPtr<nsILocalMailIncomingServer> localMailServer;
+        localMailServer = do_QueryInterface(server, &rv);
+        NS_ENSURE_SUCCESS(rv, NS_MSG_INVALID_OR_MISSING_SERVER);
+
+        // first create the folders on disk (as empty files)
+        rv = localMailServer->CreateDefaultMailboxes();
+        if (NS_FAILED(rv) && rv != NS_MSG_FOLDER_EXISTS) return rv;
+
+        // must happen after CreateSubFolders, or the folders won't exist.
+        rv = localMailServer->SetFlagsOnDefaultMailboxes();
+        if (NS_FAILED(rv)) return rv;
+      }
+    }
+    UpdateSummaryTotals(false);
+  }
+
+  return nsMsgDBFolder::GetSubFolders(folders);
+}
+
+nsresult nsMsgLocalMailFolder::GetDatabase() {
+  nsCOMPtr<nsIMsgDatabase> msgDB;
+  return GetDatabaseWOReparse(getter_AddRefs(msgDB));
+}
+
+// we treat failure as null db returned
+NS_IMETHODIMP nsMsgLocalMailFolder::GetDatabaseWOReparse(
+    nsIMsgDatabase** aDatabase) {
+  NS_ENSURE_ARG(aDatabase);
+  if (m_parsingFolder) return NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE;
+
+  nsresult rv = NS_OK;
+  if (!mDatabase) {
+    rv = OpenDatabase();
+    if (mDatabase) {
+      mDatabase->AddListener(this);
+      UpdateNewMessages();
+    }
+  }
+  NS_IF_ADDREF(*aDatabase = mDatabase);
+  if (mDatabase) mDatabase->SetLastUseTime(PR_Now());
+  return rv;
+}
+
+// Makes sure the database is open and exists.  If the database is out of date,
+// then this call will return NS_ERROR_NOT_INITIALIZED and run an async url
+// to reparse the folder. The passed in url listener will get called when the
+// url is done.
+NS_IMETHODIMP nsMsgLocalMailFolder::GetDatabaseWithReparse(
+    nsIUrlListener* aReparseUrlListener, nsIMsgWindow* aMsgWindow,
+    nsIMsgDatabase** aMsgDatabase) {
+  nsresult rv = NS_OK;
+  // if we're already reparsing, just remember the listener so we can notify it
+  // when we've finished.
+  if (m_parsingFolder) {
+    NS_ASSERTION(!mReparseListener, "can't have an existing listener");
+    mReparseListener = aReparseUrlListener;
+    return NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE;
+  }
+
+  if (!mDatabase) {
+    nsCOMPtr<nsIFile> pathFile;
+    rv = GetFilePath(getter_AddRefs(pathFile));
+    if (NS_FAILED(rv)) return rv;
+
+    bool exists;
+    rv = pathFile->Exists(&exists);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!exists)
+      return NS_ERROR_NULL_POINTER;  // mDatabase will be null at this point.
+
+    nsCOMPtr<nsIMsgDBService> msgDBService =
+        do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsresult folderOpen =
+        msgDBService->OpenFolderDB(this, true, getter_AddRefs(mDatabase));
+    if (folderOpen == NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE) {
+      nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+      nsCOMPtr<nsIDBFolderInfo> transferInfo;
+      if (mDatabase) {
+        mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+        if (dbFolderInfo) {
+          dbFolderInfo->SetNumMessages(0);
+          dbFolderInfo->SetNumUnreadMessages(0);
+          dbFolderInfo->GetTransferInfo(getter_AddRefs(transferInfo));
+        }
+        dbFolderInfo = nullptr;
+
+        // A backup message database might have been created earlier, for
+        // example if the user requested a reindex. We'll use the earlier one if
+        // we can, otherwise we'll try to backup at this point.
+        if (NS_FAILED(OpenBackupMsgDatabase())) {
+          CloseAndBackupFolderDB(EmptyCString());
+          if (NS_FAILED(OpenBackupMsgDatabase()) && mBackupDatabase) {
+            mBackupDatabase->RemoveListener(this);
+            mBackupDatabase = nullptr;
+          }
+        } else
+          mDatabase->ForceClosed();
+
+        mDatabase = nullptr;
+      }
+      nsCOMPtr<nsIFile> summaryFile;
+      rv = GetSummaryFileLocation(pathFile, getter_AddRefs(summaryFile));
+      NS_ENSURE_SUCCESS(rv, rv);
+      // Remove summary file.
+      summaryFile->Remove(false);
+
+      // if it's out of date then reopen with upgrade.
+      rv = msgDBService->CreateNewDB(this, getter_AddRefs(mDatabase));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (transferInfo && mDatabase) {
+        SetDBTransferInfo(transferInfo);
+        mDatabase->SetSummaryValid(false);
+      }
+    } else if (folderOpen == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING) {
+      rv = msgDBService->CreateNewDB(this, getter_AddRefs(mDatabase));
+    }
+
+    if (mDatabase) {
+      if (mAddListener) mDatabase->AddListener(this);
+
+      // if we have to regenerate the folder, run the parser url.
+      if (folderOpen == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING ||
+          folderOpen == NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE) {
+        if (NS_FAILED(rv = ParseFolder(aMsgWindow, aReparseUrlListener))) {
+          if (rv == NS_MSG_FOLDER_BUSY) {
+            // we need to null out the db so that parsing gets kicked off again.
+            mDatabase->RemoveListener(this);
+            mDatabase = nullptr;
+            ThrowAlertMsg("parsingFolderFailed", aMsgWindow);
+          }
+          return rv;
+        }
+
+        return NS_ERROR_NOT_INITIALIZED;
+      }
+
+      // We have a valid database so lets extract necessary info.
+      UpdateSummaryTotals(true);
+    }
+  }
+  NS_IF_ADDREF(*aMsgDatabase = mDatabase);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::UpdateFolder(nsIMsgWindow* aWindow) {
+  (void)RefreshSizeOnDisk();
+  nsresult rv;
+
+  if (!PromptForMasterPasswordIfNecessary()) return NS_ERROR_FAILURE;
+
+  // If we don't currently have a database, get it.  Otherwise, the folder has
+  // been updated (presumably this changes when we download headers when opening
+  // inbox).  If it's updated, send NotifyFolderLoaded.
+  if (!mDatabase) {
+    // return of NS_ERROR_NOT_INITIALIZED means running parsing URL
+    // We don't need the return value, and assigning it to mDatabase which
+    // is already set internally leaks.
+    nsCOMPtr<nsIMsgDatabase> returnedDb;
+    rv = GetDatabaseWithReparse(this, aWindow, getter_AddRefs(returnedDb));
+    if (NS_SUCCEEDED(rv)) NotifyFolderEvent(kFolderLoaded);
+  } else {
+    bool valid;
+    rv = mDatabase->GetSummaryValid(&valid);
+    // don't notify folder loaded or try compaction if db isn't valid
+    // (we're probably reparsing or copying msgs to it)
+    if (NS_SUCCEEDED(rv) && valid)
+      NotifyFolderEvent(kFolderLoaded);
+    else if (mCopyState)
+      mCopyState->m_notifyFolderLoaded =
+          true;                 // defer folder loaded notification
+    else if (!m_parsingFolder)  // if the db was already open, it's probably OK
+                                // to load it if not parsing
+      NotifyFolderEvent(kFolderLoaded);
+  }
+  bool filtersRun;
+  bool hasNewMessages;
+  GetHasNewMessages(&hasNewMessages);
+  if (mDatabase) ApplyRetentionSettings();
+  // if we have new messages, try the filter plugins.
+  if (NS_SUCCEEDED(rv) && hasNewMessages)
+    (void)CallFilterPlugins(aWindow, &filtersRun);
+  // Callers should rely on folder loaded event to ensure completion of loading.
+  // So we'll return NS_OK even if parsing is still in progress
+  if (rv == NS_ERROR_NOT_INITIALIZED) rv = NS_OK;
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::GetFolderURL(nsACString& aUrl) {
+  nsresult rv;
+  nsCOMPtr<nsIFile> path;
+  rv = GetFilePath(getter_AddRefs(path));
+  if (NS_FAILED(rv)) return rv;
+
+  rv = NS_GetURLSpecFromFile(path, aUrl);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aUrl.Replace(0, strlen("file:"), "mailbox:");
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::CreateStorageIfMissing(
+    nsIUrlListener* aUrlListener) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgFolder> msgParent;
+  GetParent(getter_AddRefs(msgParent));
+
+  // parent is probably not set because *this* was probably created by rdf
+  // and not by folder discovery. So, we have to compute the parent.
+  if (!msgParent) {
+    nsAutoCString folderName(mURI);
+    nsAutoCString uri;
+    int32_t leafPos = folderName.RFindChar('/');
+    nsAutoCString parentName(folderName);
+    if (leafPos > 0) {
+      // If there is a hierarchy, there is a parent.
+      // Don't strip off slash if it's the first character
+      parentName.SetLength(leafPos);
+      rv = GetOrCreateFolder(parentName, getter_AddRefs(msgParent));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+
+  if (msgParent) {
+    nsString folderName;
+    GetName(folderName);
+    rv = msgParent->CreateSubfolder(folderName, nullptr);
+    // by definition, this is OK.
+    if (rv == NS_MSG_FOLDER_EXISTS) return NS_OK;
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::CreateSubfolder(const nsAString& folderName,
+                                      nsIMsgWindow* msgWindow) {
+  nsCOMPtr<nsIMsgFolder> newFolder;
+  nsresult rv =
+      CreateSubfolderInternal(folderName, msgWindow, getter_AddRefs(newFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+      do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+  if (notifier) notifier->NotifyFolderAdded(newFolder);
+
+  return NS_OK;
+}
+
+nsresult nsMsgLocalMailFolder::CreateSubfolderInternal(
+    const nsAString& folderName, nsIMsgWindow* msgWindow,
+    nsIMsgFolder** aNewFolder) {
+  nsresult rv = CheckIfFolderExists(folderName, this, msgWindow);
+  // No need for an assertion: we already throw an alert.
+  if (NS_FAILED(rv)) return rv;
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = msgStore->CreateFolder(this, folderName, aNewFolder);
+  if (rv == NS_MSG_ERROR_INVALID_FOLDER_NAME) {
+    ThrowAlertMsg("folderCreationFailed", msgWindow);
+  } else if (rv == NS_MSG_FOLDER_EXISTS) {
+    ThrowAlertMsg("folderExists", msgWindow);
+  }
+
+  if (NS_SUCCEEDED(rv)) {
+    // we need to notify explicitly the flag change because it failed when we
+    // did AddSubfolder
+    (*aNewFolder)->OnFlagChange(mFlags);
+    (*aNewFolder)
+        ->SetPrettyName(
+            folderName);  // because empty trash will create a new trash folder
+    NotifyFolderAdded(*aNewFolder);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::CompactAll(nsIUrlListener* aListener,
+                                               nsIMsgWindow* aMsgWindow) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  rv = GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool storeSupportsCompaction;
+  msgStore->GetSupportsCompaction(&storeSupportsCompaction);
+  nsTArray<RefPtr<nsIMsgFolder>> folderArray;
+  if (storeSupportsCompaction) {
+    nsTArray<RefPtr<nsIMsgFolder>> allDescendants;
+    rv = rootFolder->GetDescendants(allDescendants);
+    NS_ENSURE_SUCCESS(rv, rv);
+    int64_t expungedBytes = 0;
+    for (auto folder : allDescendants) {
+      expungedBytes = 0;
+      if (folder) rv = folder->GetExpungedBytes(&expungedBytes);
+
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (expungedBytes > 0) folderArray.AppendElement(folder);
+    }
+  }
+
+  if (folderArray.IsEmpty()) {
+    // Nothing to do - early out.
+    if (aListener) {
+      aListener->OnStopRunningUrl(nullptr, NS_OK);
+    }
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIMsgFolderCompactor> folderCompactor =
+      do_CreateInstance("@mozilla.org/messenger/foldercompactor;1", &rv);
+  return folderCompactor->CompactFolders(folderArray, aListener, aMsgWindow);
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::Compact(nsIUrlListener* aListener,
+                                            nsIMsgWindow* aMsgWindow) {
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  nsresult rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  int64_t expungedBytes = 0;
+  GetExpungedBytes(&expungedBytes);
+  bool supportsCompaction;
+  msgStore->GetSupportsCompaction(&supportsCompaction);
+  if (!supportsCompaction || expungedBytes == 0) {
+    // Nothing to do. Early out.
+    if (aListener) {
+      aListener->OnStopRunningUrl(nullptr, NS_OK);
+    }
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIMsgFolderCompactor> folderCompactor =
+      do_CreateInstance("@mozilla.org/messenger/foldercompactor;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return folderCompactor->CompactFolders({this}, aListener, aMsgWindow);
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::EmptyTrash(nsIUrlListener* aListener) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> trashFolder;
+  rv = GetTrashFolder(getter_AddRefs(trashFolder));
+  if (NS_SUCCEEDED(rv)) {
+    uint32_t flags;
+    trashFolder->GetFlags(&flags);
+    int32_t totalMessages = 0;
+    rv = trashFolder->GetTotalMessages(true, &totalMessages);
+    if (totalMessages <= 0) {
+      // Any folders to deal with?
+      nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+      rv = trashFolder->GetSubFolders(subFolders);
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (subFolders.IsEmpty()) {
+        return NS_OK;
+      }
+    }
+    nsCOMPtr<nsIMsgFolder> parentFolder;
+    rv = trashFolder->GetParent(getter_AddRefs(parentFolder));
+    if (NS_SUCCEEDED(rv) && parentFolder) {
+      nsCOMPtr<nsIDBFolderInfo> transferInfo;
+      trashFolder->GetDBTransferInfo(getter_AddRefs(transferInfo));
+      trashFolder->SetParent(nullptr);
+      parentFolder->PropagateDelete(trashFolder, true);
+      parentFolder->CreateSubfolder(u"Trash"_ns, nullptr);
+      nsCOMPtr<nsIMsgFolder> newTrashFolder;
+      rv = GetTrashFolder(getter_AddRefs(newTrashFolder));
+      if (NS_SUCCEEDED(rv) && newTrashFolder) {
+        nsCOMPtr<nsIMsgLocalMailFolder> localTrash =
+            do_QueryInterface(newTrashFolder);
+        if (transferInfo) newTrashFolder->SetDBTransferInfo(transferInfo);
+        if (localTrash) localTrash->RefreshSizeOnDisk();
+        // update the summary totals so the front end will
+        // show the right thing for the new trash folder
+        // see bug #161999
+        nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+        nsCOMPtr<nsIMsgDatabase> db;
+        newTrashFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo),
+                                             getter_AddRefs(db));
+        if (dbFolderInfo) {
+          dbFolderInfo->SetNumUnreadMessages(0);
+          dbFolderInfo->SetNumMessages(0);
+        }
+        newTrashFolder->UpdateSummaryTotals(true);
+      }
+    }
+  }
+  return rv;
+}
+
+nsresult nsMsgLocalMailFolder::IsChildOfTrash(bool* result) {
+  NS_ENSURE_ARG_POINTER(result);
+  uint32_t parentFlags = 0;
+  *result = false;
+  bool isServer;
+  nsresult rv = GetIsServer(&isServer);
+  if (NS_FAILED(rv) || isServer) return NS_OK;
+
+  rv = GetFlags(&parentFlags);  // this is the parent folder
+  if (parentFlags & nsMsgFolderFlags::Trash) {
+    *result = true;
+    return rv;
+  }
+
+  nsCOMPtr<nsIMsgFolder> parentFolder;
+  nsCOMPtr<nsIMsgFolder> thisFolder;
+  rv = QueryInterface(NS_GET_IID(nsIMsgFolder), getter_AddRefs(thisFolder));
+
+  while (!isServer) {
+    thisFolder->GetParent(getter_AddRefs(parentFolder));
+    if (!parentFolder) return NS_OK;
+
+    rv = parentFolder->GetIsServer(&isServer);
+    if (NS_FAILED(rv) || isServer) return NS_OK;
+
+    rv = parentFolder->GetFlags(&parentFlags);
+    if (NS_FAILED(rv)) return NS_OK;
+
+    if (parentFlags & nsMsgFolderFlags::Trash) {
+      *result = true;
+      return rv;
+    }
+
+    thisFolder = parentFolder;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::DeleteSelf(nsIMsgWindow* msgWindow) {
+  nsresult rv;
+  bool isChildOfTrash;
+  IsChildOfTrash(&isChildOfTrash);
+
+  uint32_t folderFlags = 0;
+  GetFlags(&folderFlags);
+  // when deleting from trash, or virtual folder, just delete it.
+  if (isChildOfTrash || folderFlags & nsMsgFolderFlags::Virtual)
+    return nsMsgDBFolder::DeleteSelf(msgWindow);
+
+  nsCOMPtr<nsIMsgFolder> trashFolder;
+  rv = GetTrashFolder(getter_AddRefs(trashFolder));
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsIMsgCopyService> copyService(
+        do_GetService("@mozilla.org/messenger/messagecopyservice;1", &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = copyService->CopyFolder(this, trashFolder, true, nullptr, msgWindow);
+  }
+  return rv;
+}
+
+nsresult nsMsgLocalMailFolder::ConfirmFolderDeletion(nsIMsgWindow* aMsgWindow,
+                                                     nsIMsgFolder* aFolder,
+                                                     bool* aResult) {
+  NS_ENSURE_ARG(aResult);
+  NS_ENSURE_ARG(aMsgWindow);
+  NS_ENSURE_ARG(aFolder);
+  nsCOMPtr<nsIDocShell> docShell;
+  aMsgWindow->GetRootDocShell(getter_AddRefs(docShell));
+  if (docShell) {
+    bool confirmDeletion = true;
+    nsresult rv;
+    nsCOMPtr<nsIPrefBranch> pPrefBranch(
+        do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    pPrefBranch->GetBoolPref("mailnews.confirm.moveFoldersToTrash",
+                             &confirmDeletion);
+    if (confirmDeletion) {
+      nsCOMPtr<nsIStringBundleService> bundleService =
+          mozilla::components::StringBundle::Service();
+      NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+      nsCOMPtr<nsIStringBundle> bundle;
+      rv = bundleService->CreateBundle(
+          "chrome://messenger/locale/localMsgs.properties",
+          getter_AddRefs(bundle));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsAutoString folderName;
+      rv = aFolder->GetName(folderName);
+      NS_ENSURE_SUCCESS(rv, rv);
+      AutoTArray<nsString, 1> formatStrings = {folderName};
+
+      nsAutoString deleteFolderDialogTitle;
+      rv = bundle->GetStringFromName("pop3DeleteFolderDialogTitle",
+                                     deleteFolderDialogTitle);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsAutoString deleteFolderButtonLabel;
+      rv = bundle->GetStringFromName("pop3DeleteFolderButtonLabel",
+                                     deleteFolderButtonLabel);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsAutoString confirmationStr;
+      rv = bundle->FormatStringFromName("pop3MoveFolderToTrash", formatStrings,
+                                        confirmationStr);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIPrompt> dialog(do_GetInterface(docShell));
+      if (dialog) {
+        int32_t buttonPressed = 0;
+        // Default the dialog to "cancel".
+        const uint32_t buttonFlags =
+            (nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_0) +
+            (nsIPrompt::BUTTON_TITLE_CANCEL * nsIPrompt::BUTTON_POS_1);
+        bool dummyValue = false;
+        rv = dialog->ConfirmEx(deleteFolderDialogTitle.get(),
+                               confirmationStr.get(), buttonFlags,
+                               deleteFolderButtonLabel.get(), nullptr, nullptr,
+                               nullptr, &dummyValue, &buttonPressed);
+        NS_ENSURE_SUCCESS(rv, rv);
+        *aResult = !buttonPressed;  // "ok" is in position 0
+      }
+    } else
+      *aResult = true;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::Rename(const nsAString& aNewName,
+                                           nsIMsgWindow* msgWindow) {
+  // Renaming to the same name is easy
+  if (mName.Equals(aNewName)) return NS_OK;
+
+  nsCOMPtr<nsIMsgFolder> parentFolder;
+  nsresult rv = GetParent(getter_AddRefs(parentFolder));
+  if (!parentFolder) return NS_ERROR_NULL_POINTER;
+
+  rv = CheckIfFolderExists(aNewName, parentFolder, msgWindow);
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  nsCOMPtr<nsIMsgFolder> newFolder;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = msgStore->RenameFolder(this, aNewName, getter_AddRefs(newFolder));
+  if (NS_FAILED(rv)) {
+    if (msgWindow)
+      (void)ThrowAlertMsg(
+          (rv == NS_MSG_FOLDER_EXISTS) ? "folderExists" : "folderRenameFailed",
+          msgWindow);
+    return rv;
+  }
+
+  int32_t count = mSubFolders.Count();
+  if (newFolder) {
+    // Because we just renamed the db, w/o setting the pretty name in it,
+    // we need to force the pretty name to be correct.
+    // SetPrettyName won't write the name to the db if it doesn't think the
+    // name has changed. This hack forces the pretty name to get set in the db.
+    // We could set the new pretty name on the db before renaming the .msf file,
+    // but if the rename failed, it would be out of sync.
+    newFolder->SetPrettyName(EmptyString());
+    newFolder->SetPrettyName(aNewName);
+    bool changed = false;
+    MatchOrChangeFilterDestination(newFolder, true /*case-insensitive*/,
+                                   &changed);
+    if (changed) AlertFilterChanged(msgWindow);
+
+    if (count > 0) newFolder->RenameSubFolders(msgWindow, this);
+
+    // Discover the subfolders inside this folder (this is recursive)
+    nsTArray<RefPtr<nsIMsgFolder>> dummy;
+    newFolder->GetSubFolders(dummy);
+
+    // the newFolder should have the same flags
+    newFolder->SetFlags(mFlags);
+    if (parentFolder) {
+      SetParent(nullptr);
+      parentFolder->PropagateDelete(this, false);
+      parentFolder->NotifyFolderAdded(newFolder);
+    }
+    // Forget our path, since this folder object renamed itself.
+    SetFilePath(nullptr);
+    newFolder->NotifyFolderEvent(kRenameCompleted);
+
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+    if (notifier) notifier->NotifyFolderRenamed(this, newFolder);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::RenameSubFolders(nsIMsgWindow* msgWindow,
+                                                     nsIMsgFolder* oldFolder) {
+  nsresult rv = NS_OK;
+  mInitialized = true;
+
+  uint32_t flags;
+  oldFolder->GetFlags(&flags);
+  SetFlags(flags);
+
+  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+  rv = oldFolder->GetSubFolders(subFolders);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (nsIMsgFolder* msgFolder : subFolders) {
+    nsString folderName;
+    rv = msgFolder->GetName(folderName);
+    nsCOMPtr<nsIMsgFolder> newFolder;
+    AddSubfolder(folderName, getter_AddRefs(newFolder));
+    if (newFolder) {
+      newFolder->SetPrettyName(folderName);
+      bool changed = false;
+      msgFolder->MatchOrChangeFilterDestination(
+          newFolder, true /*case-insensitive*/, &changed);
+      if (changed) msgFolder->AlertFilterChanged(msgWindow);
+      newFolder->RenameSubFolders(msgWindow, msgFolder);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::GetPrettyName(nsAString& prettyName) {
+  return nsMsgDBFolder::GetPrettyName(prettyName);
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::SetPrettyName(const nsAString& aName) {
+  nsresult rv = nsMsgDBFolder::SetPrettyName(aName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCString folderName;
+  rv = GetStringProperty("folderName", folderName);
+  NS_ConvertUTF16toUTF8 utf8FolderName(mName);
+  return NS_FAILED(rv) || !folderName.Equals(utf8FolderName)
+             ? SetStringProperty("folderName", utf8FolderName)
+             : rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::GetName(nsAString& aName) {
+  ReadDBFolderInfo(false);
+  return nsMsgDBFolder::GetName(aName);
+}
+
+nsresult nsMsgLocalMailFolder::OpenDatabase() {
+  nsresult rv;
+  nsCOMPtr<nsIMsgDBService> msgDBService =
+      do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> file;
+  rv = GetFilePath(getter_AddRefs(file));
+
+  rv = msgDBService->OpenFolderDB(this, true, getter_AddRefs(mDatabase));
+  if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING) {
+    // check if we're a real folder by looking at the parent folder.
+    nsCOMPtr<nsIMsgFolder> parent;
+    GetParent(getter_AddRefs(parent));
+    if (parent) {
+      // This little dance creates an empty .msf file and then checks
+      // if the db is valid - this works if the folder is empty, which
+      // we don't have a direct way of checking.
+      nsCOMPtr<nsIMsgDatabase> db;
+      rv = msgDBService->CreateNewDB(this, getter_AddRefs(db));
+      if (db) {
+        UpdateSummaryTotals(true);
+        db->Close(true);
+        mDatabase = nullptr;
+        db = nullptr;
+        rv = msgDBService->OpenFolderDB(this, false, getter_AddRefs(mDatabase));
+        if (NS_FAILED(rv)) mDatabase = nullptr;
+      }
+    }
+  } else if (NS_FAILED(rv))
+    mDatabase = nullptr;
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::GetDBFolderInfoAndDB(nsIDBFolderInfo** folderInfo,
+                                           nsIMsgDatabase** db) {
+  if (!db || !folderInfo || !mPath || mIsServer)
+    return NS_ERROR_NULL_POINTER;  // ducarroz: should we use
+                                   // NS_ERROR_INVALID_ARG?
+
+  nsresult rv;
+  if (mDatabase)
+    rv = NS_OK;
+  else {
+    rv = OpenDatabase();
+
+    if (mAddListener && mDatabase) mDatabase->AddListener(this);
+  }
+
+  NS_IF_ADDREF(*db = mDatabase);
+  if (NS_SUCCEEDED(rv) && *db) rv = (*db)->GetDBFolderInfo(folderInfo);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::ReadFromFolderCacheElem(
+    nsIMsgFolderCacheElement* element) {
+  NS_ENSURE_ARG_POINTER(element);
+  nsresult rv = nsMsgDBFolder::ReadFromFolderCacheElem(element);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCString utf8Name;
+  rv = element->GetCachedString("folderName", utf8Name);
+  NS_ENSURE_SUCCESS(rv, rv);
+  CopyUTF8toUTF16(utf8Name, mName);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::WriteToFolderCacheElem(
+    nsIMsgFolderCacheElement* element) {
+  NS_ENSURE_ARG_POINTER(element);
+  nsMsgDBFolder::WriteToFolderCacheElem(element);
+  return element->SetCachedString("folderName", NS_ConvertUTF16toUTF8(mName));
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::GetDeletable(bool* deletable) {
+  NS_ENSURE_ARG_POINTER(deletable);
+
+  bool isServer;
+  GetIsServer(&isServer);
+  *deletable = !(isServer || (mFlags & nsMsgFolderFlags::SpecialUse));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::RefreshSizeOnDisk() {
+  int64_t oldFolderSize = mFolderSize;
+  // we set this to unknown to force it to get recalculated from disk
+  mFolderSize = kSizeUnknown;
+  if (NS_SUCCEEDED(GetSizeOnDisk(&mFolderSize)))
+    NotifyIntPropertyChanged(kFolderSize, oldFolderSize, mFolderSize);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::GetSizeOnDisk(int64_t* aSize) {
+  NS_ENSURE_ARG_POINTER(aSize);
+
+  bool isServer = false;
+  nsresult rv = GetIsServer(&isServer);
+  // If this is the rootFolder, return 0 as a safe value.
+  if (NS_FAILED(rv) || isServer) mFolderSize = 0;
+
+  if (mFolderSize == kSizeUnknown) {
+    nsCOMPtr<nsIFile> file;
+    rv = GetFilePath(getter_AddRefs(file));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // Use a temporary variable so that we keep mFolderSize on kSizeUnknown
+    // if GetFileSize() fails.
+    int64_t folderSize;
+    rv = file->GetFileSize(&folderSize);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    mFolderSize = folderSize;
+  }
+  *aSize = mFolderSize;
+  return NS_OK;
+}
+
+nsresult nsMsgLocalMailFolder::GetTrashFolder(nsIMsgFolder** result) {
+  NS_ENSURE_ARG_POINTER(result);
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  rv = GetRootFolder(getter_AddRefs(rootFolder));
+  if (NS_SUCCEEDED(rv)) {
+    rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Trash, result);
+    if (!*result) rv = NS_ERROR_FAILURE;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::DeleteMessages(
+    nsTArray<RefPtr<nsIMsgDBHdr>> const& msgHeaders, nsIMsgWindow* msgWindow,
+    bool deleteStorage, bool isMove, nsIMsgCopyServiceListener* listener,
+    bool allowUndo) {
+  nsresult rv;
+
+  // shift delete case - (delete to trash is handled in EndMove)
+  // this is also the case when applying retention settings.
+  if (deleteStorage && !isMove) {
+    nsTArray<RefPtr<nsIMsgDBHdr>> hdrsToDelete;
+    for (auto msgHdr : msgHeaders) {
+      uint32_t attachmentDetached = 0;
+      msgHdr->GetUint32Property("attachmentDetached", &attachmentDetached);
+      if (!attachmentDetached) {
+        hdrsToDelete.AppendElement(msgHdr);
+      }
+    }
+    MarkMsgsOnPop3Server(hdrsToDelete, POP3_DELETE);
+  }
+
+  bool isTrashFolder = mFlags & nsMsgFolderFlags::Trash;
+
+  // notify on delete from trash and shift-delete
+  if (!isMove && (deleteStorage || isTrashFolder)) {
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+    if (notifier) {
+      if (listener) {
+        listener->OnStartCopy();
+        listener->OnStopCopy(NS_OK);
+      }
+      notifier->NotifyMsgsDeleted(msgHeaders);
+    }
+  }
+
+  if (!deleteStorage && !isTrashFolder) {
+    // We're moving the messages to trash folder. Start by kicking off a copy.
+    nsCOMPtr<nsIMsgFolder> trashFolder;
+    rv = GetTrashFolder(getter_AddRefs(trashFolder));
+    if (NS_SUCCEEDED(rv)) {
+      nsCOMPtr<nsIMsgCopyService> copyService =
+          do_GetService("@mozilla.org/messenger/messagecopyservice;1", &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      // When the copy completes, DeleteMessages() will be called again to
+      // perform the actual delete.
+      return copyService->CopyMessages(this, msgHeaders, trashFolder, true,
+                                       listener, msgWindow, allowUndo);
+    }
+  } else {
+    // Performing an _actual_ delete. There are two ways we got here:
+    // 1) We're deleting messages without moving to trash.
+    // 2) We're in the second phase of a Move (to trash or elsewhere). The
+    //    copy succeeded, and now we need to delete the source messages.
+    nsCOMPtr<nsIMsgDatabase> msgDB;
+    rv = GetDatabaseWOReparse(getter_AddRefs(msgDB));
+    if (NS_SUCCEEDED(rv)) {
+      if (deleteStorage && isMove && GetDeleteFromServerOnMove())
+        MarkMsgsOnPop3Server(msgHeaders, POP3_DELETE);
+
+      nsCOMPtr<nsISupports> msgSupport;
+      rv = EnableNotifications(allMessageCountNotifications, false);
+      if (NS_SUCCEEDED(rv)) {
+        // First, delete the actual messages in the store.
+        nsCOMPtr<nsIMsgPluggableStore> msgStore;
+        rv = GetMsgStore(getter_AddRefs(msgStore));
+        if (NS_SUCCEEDED(rv)) {
+          // Second, remove the message entries from the DB.
+          rv = msgStore->DeleteMessages(msgHeaders);
+          for (auto hdr : msgHeaders) {
+            rv = msgDB->DeleteHeader(hdr, nullptr, false, true);
+          }
+        }
+      } else if (rv == NS_MSG_FOLDER_BUSY) {
+        ThrowAlertMsg("deletingMsgsFailed", msgWindow);
+      }
+
+      // Let everyone know the operation has finished.
+      NotifyFolderEvent(NS_SUCCEEDED(rv) ? kDeleteOrMoveMsgCompleted
+                                         : kDeleteOrMoveMsgFailed);
+      // NOTE: This reenabling also forces immediate recount + notification.
+      EnableNotifications(allMessageCountNotifications, true);
+      if (msgWindow) {
+        AutoCompact(msgWindow);
+      }
+    }
+  }
+
+  if (msgWindow && !isMove && (deleteStorage || isTrashFolder)) {
+    // Clear undo and redo stack.
+    nsCOMPtr<nsITransactionManager> txnMgr;
+    msgWindow->GetTransactionManager(getter_AddRefs(txnMgr));
+    if (txnMgr) {
+      txnMgr->Clear();
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::AddMessageDispositionState(
+    nsIMsgDBHdr* aMessage, nsMsgDispositionState aDispositionFlag) {
+  nsMsgMessageFlagType msgFlag = 0;
+  switch (aDispositionFlag) {
+    case nsIMsgFolder::nsMsgDispositionState_Replied:
+      msgFlag = nsMsgMessageFlags::Replied;
+      break;
+    case nsIMsgFolder::nsMsgDispositionState_Forwarded:
+      msgFlag = nsMsgMessageFlags::Forwarded;
+      break;
+    case nsIMsgFolder::nsMsgDispositionState_Redirected:
+      msgFlag = nsMsgMessageFlags::Redirected;
+      break;
+    default:
+      return NS_ERROR_UNEXPECTED;
+  }
+
+  nsresult rv =
+      nsMsgDBFolder::AddMessageDispositionState(aMessage, aDispositionFlag);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return msgStore->ChangeFlags({aMessage}, msgFlag, true);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::MarkMessagesRead(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages, bool aMarkRead) {
+  nsresult rv = nsMsgDBFolder::MarkMessagesRead(aMessages, aMarkRead);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return msgStore->ChangeFlags(aMessages, nsMsgMessageFlags::Read, aMarkRead);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::MarkMessagesFlagged(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages, bool aMarkFlagged) {
+  nsresult rv = nsMsgDBFolder::MarkMessagesFlagged(aMessages, aMarkFlagged);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return msgStore->ChangeFlags(aMessages, nsMsgMessageFlags::Marked,
+                               aMarkFlagged);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::MarkAllMessagesRead(nsIMsgWindow* aMsgWindow) {
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTArray<nsMsgKey> thoseMarked;
+  EnableNotifications(allMessageCountNotifications, false);
+  rv = mDatabase->MarkAllRead(thoseMarked);
+  EnableNotifications(allMessageCountNotifications, true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (thoseMarked.IsEmpty()) {
+    return NS_OK;
+  }
+
+  nsTArray<RefPtr<nsIMsgDBHdr>> messages;
+  rv = MsgGetHeadersFromKeys(mDatabase, thoseMarked, messages);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = msgStore->ChangeFlags(messages, nsMsgMessageFlags::Read, true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+
+  // Setup a undo-state
+  if (aMsgWindow)
+    rv = AddMarkAllReadUndoAction(aMsgWindow, thoseMarked.Elements(),
+                                  thoseMarked.Length());
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::MarkThreadRead(nsIMsgThread* thread) {
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTArray<nsMsgKey> thoseMarked;
+  rv = mDatabase->MarkThreadRead(thread, nullptr, thoseMarked);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (thoseMarked.IsEmpty()) {
+    return NS_OK;
+  }
+
+  nsTArray<RefPtr<nsIMsgDBHdr>> messages;
+  rv = MsgGetHeadersFromKeys(mDatabase, thoseMarked, messages);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = msgStore->ChangeFlags(messages, nsMsgMessageFlags::Read, true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+
+  return rv;
+}
+
+nsresult nsMsgLocalMailFolder::InitCopyState(
+    nsISupports* aSupport, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
+    bool isMove, nsIMsgCopyServiceListener* listener, nsIMsgWindow* msgWindow,
+    bool isFolder, bool allowUndo) {
+  nsCOMPtr<nsIFile> path;
+
+  NS_ASSERTION(!mCopyState, "already copying a msg into this folder");
+  if (mCopyState) return NS_ERROR_FAILURE;  // already has a  copy in progress
+
+  // get mDatabase set, so we can use it to add new hdrs to this db.
+  // calling GetDatabase will set mDatabase - we use the comptr
+  // here to avoid doubling the refcnt on mDatabase. We don't care if this
+  // fails - we just want to give it a chance. It will definitely fail in
+  // nsLocalMailFolder::EndCopy because we will have written data to the folder
+  // and changed its size.
+  nsCOMPtr<nsIMsgDatabase> msgDB;
+  GetDatabaseWOReparse(getter_AddRefs(msgDB));
+  bool isLocked;
+
+  GetLocked(&isLocked);
+  if (isLocked) return NS_MSG_FOLDER_BUSY;
+
+  AcquireSemaphore(static_cast<nsIMsgLocalMailFolder*>(this));
+
+  mCopyState = new nsLocalMailCopyState();
+  NS_ENSURE_TRUE(mCopyState, NS_ERROR_OUT_OF_MEMORY);
+
+  mCopyState->m_dataBuffer = (char*)PR_CALLOC(COPY_BUFFER_SIZE + 1);
+  NS_ENSURE_TRUE(mCopyState->m_dataBuffer, NS_ERROR_OUT_OF_MEMORY);
+
+  mCopyState->m_dataBufferSize = COPY_BUFFER_SIZE;
+  mCopyState->m_destDB = msgDB;
+
+  mCopyState->m_srcSupport = aSupport;
+  mCopyState->m_messages = messages.Clone();
+  mCopyState->m_curCopyIndex = 0;
+  mCopyState->m_isMove = isMove;
+  mCopyState->m_isFolder = isFolder;
+  mCopyState->m_allowUndo = allowUndo;
+  mCopyState->m_msgWindow = msgWindow;
+  mCopyState->m_totalMsgCount = messages.Length();
+  if (listener) mCopyState->m_listener = listener;
+  mCopyState->m_copyingMultipleMessages = false;
+  mCopyState->m_wholeMsgInStream = false;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::OnAnnouncerGoingAway(
+    nsIDBChangeAnnouncer* instigator) {
+  if (mCopyState) mCopyState->m_destDB = nullptr;
+  return nsMsgDBFolder::OnAnnouncerGoingAway(instigator);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::OnCopyCompleted(nsISupports* srcSupport,
+                                      bool moveCopySucceeded) {
+  if (mCopyState && mCopyState->m_notifyFolderLoaded)
+    NotifyFolderEvent(kFolderLoaded);
+
+  (void)RefreshSizeOnDisk();
+  // we are the destination folder for a move/copy
+  bool haveSemaphore;
+  nsresult rv =
+      TestSemaphore(static_cast<nsIMsgLocalMailFolder*>(this), &haveSemaphore);
+  if (NS_SUCCEEDED(rv) && haveSemaphore)
+    ReleaseSemaphore(static_cast<nsIMsgLocalMailFolder*>(this));
+
+  if (mCopyState && !mCopyState->m_newMsgKeywords.IsEmpty() &&
+      mCopyState->m_newHdr) {
+    AddKeywordsToMessages({&*mCopyState->m_newHdr},
+                          mCopyState->m_newMsgKeywords);
+  }
+  if (moveCopySucceeded && mDatabase) {
+    mDatabase->SetSummaryValid(true);
+    (void)CloseDBIfFolderNotOpen(false);
+  }
+
+  delete mCopyState;
+  mCopyState = nullptr;
+  nsCOMPtr<nsIMsgCopyService> copyService =
+      do_GetService("@mozilla.org/messenger/messagecopyservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return copyService->NotifyCompletion(
+      srcSupport, this, moveCopySucceeded ? NS_OK : NS_ERROR_FAILURE);
+}
+
+bool nsMsgLocalMailFolder::CheckIfSpaceForCopy(nsIMsgWindow* msgWindow,
+                                               nsIMsgFolder* srcFolder,
+                                               nsISupports* srcSupports,
+                                               bool isMove,
+                                               int64_t totalMsgSize) {
+  bool spaceNotAvailable = true;
+  nsresult rv =
+      WarnIfLocalFileTooBig(msgWindow, totalMsgSize, &spaceNotAvailable);
+  if (NS_FAILED(rv) || spaceNotAvailable) {
+    if (isMove && srcFolder)
+      srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgFailed);
+    OnCopyCompleted(srcSupports, false);
+    return false;
+  }
+  return true;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::CopyMessages(nsIMsgFolder* srcFolder,
+                                   nsTArray<RefPtr<nsIMsgDBHdr>> const& srcHdrs,
+                                   bool isMove, nsIMsgWindow* msgWindow,
+                                   nsIMsgCopyServiceListener* listener,
+                                   bool isFolder, bool allowUndo) {
+  nsCOMPtr<nsISupports> srcSupport = do_QueryInterface(srcFolder);
+  bool isServer;
+  nsresult rv = GetIsServer(&isServer);
+  if (NS_SUCCEEDED(rv) && isServer) {
+    NS_ERROR("Destination is the root folder. Cannot move/copy here");
+    if (isMove) srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgFailed);
+    return OnCopyCompleted(srcSupport, false);
+  }
+
+  UpdateTimestamps(allowUndo);
+  nsCString protocolType;
+  rv = srcFolder->GetURI(protocolType);
+  protocolType.SetLength(protocolType.FindChar(':'));
+
+  // If we're offline and the source folder is imap or news, to do the
+  // copy the message bodies MUST reside in offline storage.
+  bool needOfflineBodies =
+      (WeAreOffline() && (protocolType.LowerCaseEqualsLiteral("imap") ||
+                          protocolType.LowerCaseEqualsLiteral("news")));
+  int64_t totalMsgSize = 0;
+  bool allMsgsHaveOfflineStore = true;
+  for (auto message : srcHdrs) {
+    nsMsgKey key;
+    uint32_t msgSize;
+    message->GetMessageSize(&msgSize);
+
+    /* 200 is a per-message overhead to account for any extra data added
+       to the message.
+    */
+    totalMsgSize += msgSize + 200;
+
+    // Check if each source folder message has offline storage regardless
+    // of whether we're online or offline.
+    message->GetMessageKey(&key);
+    bool hasMsgOffline = false;
+    srcFolder->HasMsgOffline(key, &hasMsgOffline);
+    allMsgsHaveOfflineStore = allMsgsHaveOfflineStore && hasMsgOffline;
+
+    // If we're offline and not all messages are in offline storage, the copy
+    // or move can't occur and a notification for the user to download the
+    // messages is posted.
+    if (needOfflineBodies && !hasMsgOffline) {
+      if (isMove) srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgFailed);
+      ThrowAlertMsg("cantMoveMsgWOBodyOffline", msgWindow);
+      return OnCopyCompleted(srcSupport, false);
+    }
+  }
+
+  if (!CheckIfSpaceForCopy(msgWindow, srcFolder, srcSupport, isMove,
+                           totalMsgSize))
+    return NS_OK;
+
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool storeDidCopy = false;
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsITransaction> undoTxn;
+  nsTArray<RefPtr<nsIMsgDBHdr>> dstHdrs;
+  rv = msgStore->CopyMessages(isMove, srcHdrs, this, dstHdrs,
+                              getter_AddRefs(undoTxn), &storeDidCopy);
+  if (storeDidCopy) {
+    NS_ASSERTION(undoTxn, "if store does copy, it needs to add undo action");
+    if (msgWindow && undoTxn) {
+      nsCOMPtr<nsITransactionManager> txnMgr;
+      msgWindow->GetTransactionManager(getter_AddRefs(txnMgr));
+      if (txnMgr) txnMgr->DoTransaction(undoTxn);
+    }
+    if (isMove) {
+      srcFolder->NotifyFolderEvent(NS_SUCCEEDED(rv) ? kDeleteOrMoveMsgCompleted
+                                                    : kDeleteOrMoveMsgFailed);
+    }
+
+    if (NS_SUCCEEDED(rv)) {
+      // If the store did the copy, like maildir, we need to mark messages on
+      // the server. Otherwise that's done in EndMove().
+      nsCOMPtr<nsIMsgLocalMailFolder> localDstFolder;
+      QueryInterface(NS_GET_IID(nsIMsgLocalMailFolder),
+                     getter_AddRefs(localDstFolder));
+      if (localDstFolder) {
+        // If we are the trash and a local msg is being moved to us, mark the
+        // source for delete from server, if so configured.
+        if (mFlags & nsMsgFolderFlags::Trash) {
+          // If we're deleting on all moves, we'll mark this message for
+          // deletion when we call DeleteMessages on the source folder. So don't
+          // mark it for deletion here, in that case.
+          if (!GetDeleteFromServerOnMove()) {
+            localDstFolder->MarkMsgsOnPop3Server(dstHdrs, POP3_DELETE);
+          }
+        }
+      }
+    }
+
+    OnCopyCompleted(srcSupport, NS_SUCCEEDED(rv));
+    return rv;
+  }
+  // If the store doesn't do the copy, we'll stream the source messages into
+  // the target folder, using getMsgInputStream and getNewMsgOutputStream.
+
+  // don't update the counts in the dest folder until it is all over
+  EnableNotifications(allMessageCountNotifications, false);
+
+  // sort the message array by key
+  nsTArray<nsMsgKey> keyArray(srcHdrs.Length());
+  nsTArray<RefPtr<nsIMsgDBHdr>> sortedMsgs(srcHdrs.Length());
+  for (nsIMsgDBHdr* aMessage : srcHdrs) {
+    nsMsgKey key;
+    aMessage->GetMessageKey(&key);
+    keyArray.AppendElement(key);
+  }
+  keyArray.Sort();
+  rv = MessagesInKeyOrder(keyArray, srcFolder, sortedMsgs);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = InitCopyState(srcSupport, sortedMsgs, isMove, listener, msgWindow,
+                     isFolder, allowUndo);
+
+  if (NS_FAILED(rv)) {
+    ThrowAlertMsg("operationFailedFolderBusy", msgWindow);
+    (void)OnCopyCompleted(srcSupport, false);
+    return rv;
+  }
+
+  if (!protocolType.LowerCaseEqualsLiteral("mailbox")) {
+    // Copying from a non-mbox source, so we will be synthesising
+    // a "From " line and "X-Mozilla-*" headers before copying the message
+    // proper.
+    mCopyState->m_dummyEnvelopeNeeded = true;
+    nsParseMailMessageState* parseMsgState = new nsParseMailMessageState();
+    if (parseMsgState) {
+      nsCOMPtr<nsIMsgDatabase> msgDb;
+      mCopyState->m_parseMsgState = parseMsgState;
+      GetDatabaseWOReparse(getter_AddRefs(msgDb));
+      if (msgDb) parseMsgState->SetMailDB(msgDb);
+    }
+  }
+
+  // undo stuff
+  if (allowUndo)  // no undo for folder move/copy or or move/copy from search
+                  // window
+  {
+    RefPtr<nsLocalMoveCopyMsgTxn> msgTxn = new nsLocalMoveCopyMsgTxn;
+    if (msgTxn && NS_SUCCEEDED(msgTxn->Init(srcFolder, this, isMove))) {
+      msgTxn->SetMsgWindow(msgWindow);
+      if (isMove) {
+        if (mFlags & nsMsgFolderFlags::Trash)
+          msgTxn->SetTransactionType(nsIMessenger::eDeleteMsg);
+        else
+          msgTxn->SetTransactionType(nsIMessenger::eMoveMsg);
+      } else
+        msgTxn->SetTransactionType(nsIMessenger::eCopyMsg);
+      msgTxn.swap(mCopyState->m_undoMsgTxn);
+    }
+  }
+
+  if (srcHdrs.Length() > 1 &&
+      ((protocolType.LowerCaseEqualsLiteral("imap") &&
+        !allMsgsHaveOfflineStore) ||
+       protocolType.LowerCaseEqualsLiteral("mailbox"))) {
+    // For an imap source folder with more than one message to be copied that
+    // are not all in offline storage, this fetches all the messages from the
+    // imap server to do the copy. When source folder is "mailbox", this is not
+    // a concern since source messages are in local storage.
+    mCopyState->m_copyingMultipleMessages = true;
+    rv = CopyMessagesTo(keyArray, msgWindow, isMove);
+    if (NS_FAILED(rv)) {
+      NS_ERROR("copy message failed");
+      (void)OnCopyCompleted(srcSupport, false);
+    }
+  } else {
+    // This obtains the source messages from local/offline storage to do the
+    // copy. Note: CopyMessageTo() actually handles one or more messages.
+    nsIMsgDBHdr* msgSupport = mCopyState->m_messages[0];
+    if (msgSupport) {
+      rv = CopyMessageTo(msgSupport, msgWindow, isMove);
+      if (NS_FAILED(rv)) {
+        NS_ASSERTION(false, "copy message failed");
+        (void)OnCopyCompleted(srcSupport, false);
+      }
+    }
+  }
+  // if this failed immediately, need to turn back on notifications and inform
+  // FE.
+  if (NS_FAILED(rv)) {
+    if (isMove) srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgFailed);
+    EnableNotifications(allMessageCountNotifications, true);
+  }
+  return rv;
+}
+
+// for srcFolder that are on different server than the dstFolder.
+// "this" is the parent of the new dest folder.
+nsresult nsMsgLocalMailFolder::CopyFolderAcrossServer(
+    nsIMsgFolder* srcFolder, nsIMsgWindow* msgWindow,
+    nsIMsgCopyServiceListener* listener, bool moveMsgs) {
+  mInitialized = true;
+
+  nsString folderName;
+  srcFolder->GetName(folderName);
+
+  nsCOMPtr<nsIMsgFolder> newMsgFolder;
+  nsresult rv = CreateSubfolderInternal(folderName, msgWindow,
+                                        getter_AddRefs(newMsgFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgEnumerator> messages;
+  rv = srcFolder->GetMessages(getter_AddRefs(messages));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTArray<RefPtr<nsIMsgDBHdr>> msgArray;
+  bool hasMoreElements = false;
+
+  if (messages) rv = messages->HasMoreElements(&hasMoreElements);
+
+  while (NS_SUCCEEDED(rv) && hasMoreElements) {
+    nsCOMPtr<nsIMsgDBHdr> msg;
+    rv = messages->GetNext(getter_AddRefs(msg));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    msgArray.AppendElement(msg);
+    rv = messages->HasMoreElements(&hasMoreElements);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (msgArray.Length() > 0)  // if only srcFolder has messages..
+    // Allow move of copied messages but keep source folder in place.
+    newMsgFolder->CopyMessages(srcFolder, msgArray, moveMsgs, msgWindow,
+                               listener, true /* is folder*/,
+                               false /* allowUndo */);
+  else {
+    nsCOMPtr<nsIMsgLocalMailFolder> localFolder =
+        do_QueryInterface(newMsgFolder);
+    if (localFolder) {
+      // normally these would get called from ::EndCopy when the last message
+      // was finished copying. But since there are no messages, we have to call
+      // them explicitly.
+      nsCOMPtr<nsISupports> srcSupports = do_QueryInterface(srcFolder);
+      localFolder->CopyAllSubFolders(srcFolder, msgWindow, listener, moveMsgs);
+      return localFolder->OnCopyCompleted(srcSupports, true);
+    }
+  }
+  return NS_OK;  // otherwise the front-end will say Exception::CopyFolder
+}
+
+nsresult  // copy the sub folders
+nsMsgLocalMailFolder::CopyAllSubFolders(nsIMsgFolder* srcFolder,
+                                        nsIMsgWindow* msgWindow,
+                                        nsIMsgCopyServiceListener* listener,
+                                        bool isMove) {
+  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+  nsresult rv = srcFolder->GetSubFolders(subFolders);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (nsIMsgFolder* folder : subFolders) {
+    CopyFolderAcrossServer(folder, msgWindow, listener, isMove);
+  }
+  return NS_OK;
+}
+
+// "this" is the destination (parent) folder that srcFolder is copied to.
+NS_IMETHODIMP
+nsMsgLocalMailFolder::CopyFolder(nsIMsgFolder* srcFolder, bool isMoveFolder,
+                                 nsIMsgWindow* msgWindow,
+                                 nsIMsgCopyServiceListener* listener) {
+  NS_ENSURE_ARG_POINTER(srcFolder);
+  nsresult rv;
+  bool sameServer;
+  rv = IsOnSameServer(this, srcFolder, &sameServer);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (sameServer && isMoveFolder) {
+    // Do a pure folder move within the same Local Folder account/server. where
+    // "pure" means the folder AND messages are copied to the Local Folders
+    // destination and then both are removed from source account.
+    rv = CopyFolderLocal(srcFolder, isMoveFolder, msgWindow, listener);
+  } else {
+    // !sameServer OR it's a copy. Unit tests expect a successful folder
+    // copy within Local Folders account/server even though the UI forbids copy
+    // and only allows moves inside the same account. CopyFolderAcrossServer(),
+    // called below, handles the folder copy within Local Folders (needed by
+    // unit tests) and it handles the folder move or copy from another account
+    // or server into Local Folders. The move from another account is "impure"
+    // since just the messages are moved but the source folder remains in place.
+    rv = CopyFolderAcrossServer(srcFolder, msgWindow, listener, isMoveFolder);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::CopyFolderLocal(nsIMsgFolder* srcFolder,
+                                      bool isMoveFolder,
+                                      nsIMsgWindow* msgWindow,
+                                      nsIMsgCopyServiceListener* aListener) {
+  mInitialized = true;
+  bool isChildOfTrash;
+  nsresult rv = IsChildOfTrash(&isChildOfTrash);
+  if (NS_SUCCEEDED(rv) && isChildOfTrash) {
+    // do it just for the parent folder (isMoveFolder is true for parent only)
+    // if we are deleting/moving a folder tree don't confirm for rss folders.
+    if (isMoveFolder) {
+      // if there's a msgWindow, confirm the deletion
+      if (msgWindow) {
+        bool okToDelete = false;
+        ConfirmFolderDeletion(msgWindow, srcFolder, &okToDelete);
+        if (!okToDelete) return NS_MSG_ERROR_COPY_FOLDER_ABORTED;
+      }
+      // if we are moving a favorite folder to trash, we should clear the
+      // favorites flag so it gets removed from the view.
+      srcFolder->ClearFlag(nsMsgFolderFlags::Favorite);
+    }
+
+    bool match = false;
+    srcFolder->MatchOrChangeFilterDestination(nullptr, false, &match);
+    if (match && msgWindow) {
+      bool confirmed = false;
+      srcFolder->ConfirmFolderDeletionForFilter(msgWindow, &confirmed);
+      if (!confirmed) return NS_MSG_ERROR_COPY_FOLDER_ABORTED;
+    }
+  }
+
+  nsAutoString newFolderName;
+  nsAutoString folderName;
+  rv = srcFolder->GetName(folderName);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (!isMoveFolder) {
+    rv = CheckIfFolderExists(folderName, this, msgWindow);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  } else {
+    // If folder name already exists in destination, generate a new unique name.
+    bool containsChild = true;
+    uint32_t i;
+    for (i = 1; containsChild; i++) {
+      newFolderName.Assign(folderName);
+      if (i > 1) {
+        // This could be localizable but Toolkit is fine without it, see
+        // mozilla/toolkit/content/contentAreaUtils.js::uniqueFile()
+        newFolderName.Append('(');
+        newFolderName.AppendInt(i);
+        newFolderName.Append(')');
+      }
+      rv = ContainsChildNamed(newFolderName, &containsChild);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+    }
+
+    // 'i' is one more than the number of iterations done
+    // and the number tacked onto the name of the folder.
+    if (i > 2 && !isChildOfTrash) {
+      // Folder name already exists, ask if rename is OK.
+      // If moving to Trash, don't ask and do it.
+      if (!ConfirmAutoFolderRename(msgWindow, folderName, newFolderName))
+        return NS_MSG_ERROR_COPY_FOLDER_ABORTED;
+    }
+  }
+
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return msgStore->CopyFolder(srcFolder, this, isMoveFolder, msgWindow,
+                              aListener, newFolderName);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::CopyFileMessage(nsIFile* aFile, nsIMsgDBHdr* msgToReplace,
+                                      bool isDraftOrTemplate,
+                                      uint32_t newMsgFlags,
+                                      const nsACString& aNewMsgKeywords,
+                                      nsIMsgWindow* msgWindow,
+                                      nsIMsgCopyServiceListener* listener) {
+  NS_ENSURE_ARG_POINTER(aFile);
+  nsresult rv = NS_ERROR_NULL_POINTER;
+  nsParseMailMessageState* parseMsgState = nullptr;
+  int64_t fileSize = 0;
+
+  nsCOMPtr<nsISupports> fileSupport(aFile);
+
+  aFile->GetFileSize(&fileSize);
+  if (!CheckIfSpaceForCopy(msgWindow, nullptr, fileSupport, false, fileSize))
+    return NS_OK;
+
+  nsTArray<RefPtr<nsIMsgDBHdr>> messages;
+  if (msgToReplace) messages.AppendElement(msgToReplace);
+
+  rv = InitCopyState(fileSupport, messages, msgToReplace ? true : false,
+                     listener, msgWindow, false, false);
+  if (NS_SUCCEEDED(rv)) {
+    if (mCopyState) {
+      mCopyState->m_newMsgKeywords = aNewMsgKeywords;
+      mCopyState->m_flags = newMsgFlags;
+    }
+
+    parseMsgState = new nsParseMailMessageState();
+    NS_ENSURE_TRUE(parseMsgState, NS_ERROR_OUT_OF_MEMORY);
+    nsCOMPtr<nsIMsgDatabase> msgDb;
+    mCopyState->m_parseMsgState = parseMsgState;
+    GetDatabaseWOReparse(getter_AddRefs(msgDb));
+    if (msgDb) parseMsgState->SetMailDB(msgDb);
+
+    nsCOMPtr<nsIInputStream> inputStream;
+    rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), aFile);
+
+    // All or none for adding a message file to the store
+    if (NS_SUCCEEDED(rv) && fileSize > PR_INT32_MAX)
+      rv = NS_ERROR_ILLEGAL_VALUE;  // may need error code for max msg size
+
+    if (NS_SUCCEEDED(rv) && inputStream) {
+      char buffer[5];
+      uint32_t readCount;
+      rv = inputStream->Read(buffer, 5, &readCount);
+      if (NS_SUCCEEDED(rv)) {
+        if (strncmp(buffer, "From ", 5))
+          mCopyState->m_dummyEnvelopeNeeded = true;
+        nsCOMPtr<nsISeekableStream> seekableStream =
+            do_QueryInterface(inputStream, &rv);
+        if (NS_SUCCEEDED(rv))
+          seekableStream->Seek(nsISeekableStream::NS_SEEK_SET, 0);
+      }
+    }
+
+    mCopyState->m_wholeMsgInStream = true;
+    if (NS_SUCCEEDED(rv)) rv = BeginCopy();
+
+    if (NS_SUCCEEDED(rv)) rv = CopyData(inputStream, (int32_t)fileSize);
+
+    if (NS_SUCCEEDED(rv)) rv = EndCopy(true);
+
+    // mDatabase should have been initialized above - if we got msgDb
+    // If we were going to delete, here is where we would do it. But because
+    // existing code already supports doing those deletes, we are just going
+    // to end the copy.
+    if (NS_SUCCEEDED(rv) && msgToReplace && mDatabase)
+      rv = OnCopyCompleted(fileSupport, true);
+
+    if (inputStream) inputStream->Close();
+  }
+
+  if (NS_FAILED(rv)) (void)OnCopyCompleted(fileSupport, false);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::GetNewMessages(nsIMsgWindow* aWindow,
+                                                   nsIUrlListener* aListener) {
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, NS_MSG_INVALID_OR_MISSING_SERVER);
+
+  nsCOMPtr<nsILocalMailIncomingServer> localMailServer =
+      do_QueryInterface(server, &rv);
+  NS_ENSURE_SUCCESS(rv, NS_MSG_INVALID_OR_MISSING_SERVER);
+
+  // XXX todo, move all this into nsILocalMailIncomingServer's GetNewMail
+  // so that we don't have to have RSS foo here.
+  nsCOMPtr<nsIRssIncomingServer> rssServer = do_QueryInterface(server, &rv);
+  mozilla::Unused << rssServer;
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsIURI> resultURI;
+    return localMailServer->GetNewMail(aWindow, aListener, this,
+                                       getter_AddRefs(resultURI));
+  }
+
+  nsCOMPtr<nsIMsgFolder> inbox;
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  rv = server->GetRootMsgFolder(getter_AddRefs(rootFolder));
+  if (NS_SUCCEEDED(rv) && rootFolder) {
+    rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox,
+                                   getter_AddRefs(inbox));
+  }
+  nsCOMPtr<nsIMsgLocalMailFolder> localInbox = do_QueryInterface(inbox, &rv);
+  if (NS_SUCCEEDED(rv)) {
+    bool valid = false;
+    nsCOMPtr<nsIMsgDatabase> db;
+    // this will kick off a reparse if the db is out of date.
+    rv = localInbox->GetDatabaseWithReparse(nullptr, aWindow,
+                                            getter_AddRefs(db));
+    if (NS_SUCCEEDED(rv)) {
+      nsCOMPtr<nsIURI> resultURI;
+      db->GetSummaryValid(&valid);
+      rv = valid ? localMailServer->GetNewMail(aWindow, aListener, inbox,
+                                               getter_AddRefs(resultURI))
+                 : localInbox->SetCheckForNewMessagesAfterParsing(true);
+    }
+  }
+  return rv;
+}
+
+nsresult nsMsgLocalMailFolder::WriteStartOfNewMessage() {
+  // If moving, delete the message in source folder that was just copied.
+  // It will have index one less than the current index.
+  // But only do this if source folder is imap.
+  // Could be optimized (DeleteMessages() operate on non-array)?
+  nsresult rv;
+  uint32_t idx = mCopyState->m_curCopyIndex;
+  if (mCopyState->m_isMove && idx) {
+    nsCOMPtr<nsIMsgFolder> srcFolder =
+        do_QueryInterface(mCopyState->m_srcSupport, &rv);
+    if (NS_SUCCEEDED(rv) && srcFolder) {
+      // Delete source messages as we go only if they come from
+      // an imap folder.
+      nsCString protocolType;
+      if (NS_SUCCEEDED(srcFolder->GetURI(protocolType))) {
+        if (StringHead(protocolType, 5).LowerCaseEqualsLiteral("imap:")) {
+          // Create "array" of one message header to delete
+          idx--;
+          if (idx < mCopyState->m_messages.Length()) {
+            // Above check avoids a possible MOZ_CRASH after error recovery.
+            RefPtr<nsIMsgDBHdr> msg = mCopyState->m_messages[idx];
+            srcFolder->DeleteMessages({msg}, mCopyState->m_msgWindow, true,
+                                      true, nullptr, mCopyState->m_allowUndo);
+          }
+        }
+      }
+    }
+  }
+
+  // CopyFileMessage() and CopyMessages() from servers other than pop3
+  if (mCopyState->m_parseMsgState) {
+    // Make sure the parser knows where the "From " separator is.
+    // A hack for Bug 1734847.
+    // If we were using nsMsgMailboxParser, that would handle it automatically.
+    // But we're using the base class (nsParseMailMessageState) which doesn't.
+    mCopyState->m_parseMsgState->m_envelope_pos =
+        mCopyState->m_parseMsgState->m_position;
+
+    if (mCopyState->m_parseMsgState->m_newMsgHdr) {
+      mCopyState->m_parseMsgState->m_newMsgHdr->GetMessageKey(
+          &mCopyState->m_curDstKey);
+    }
+    mCopyState->m_parseMsgState->SetState(
+        nsIMsgParseMailMsgState::ParseHeadersState);
+  }
+  if (mCopyState->m_dummyEnvelopeNeeded) {
+    nsCString result;
+    nsAutoCString nowStr;
+    MsgGenerateNowStr(nowStr);
+    result.AppendLiteral("From - ");
+    result.Append(nowStr);
+    result.Append(MSG_LINEBREAK);
+
+    uint32_t bytesWritten;
+    mCopyState->m_fileStream->Write(result.get(), result.Length(),
+                                    &bytesWritten);
+    if (mCopyState->m_parseMsgState) {
+      mCopyState->m_parseMsgState->ParseAFolderLine(result.get(),
+                                                    result.Length());
+      // Make sure the parser knows where the header block begins.
+      // Another hack for Bug 1734847.
+      mCopyState->m_parseMsgState->m_headerstartpos =
+          mCopyState->m_parseMsgState->m_position;
+    }
+
+    // *** jt - hard code status line for now; come back later
+    char statusStrBuf[50];
+    if (mCopyState->m_curCopyIndex < mCopyState->m_messages.Length()) {
+      uint32_t dbFlags = 0;
+      mCopyState->m_messages[mCopyState->m_curCopyIndex]->GetFlags(&dbFlags);
+
+      // write out x-mozilla-status, but make sure we don't write out
+      // nsMsgMessageFlags::Offline
+      PR_snprintf(
+          statusStrBuf, sizeof(statusStrBuf),
+          X_MOZILLA_STATUS_FORMAT MSG_LINEBREAK,
+          dbFlags &
+              ~(nsMsgMessageFlags::RuntimeOnly | nsMsgMessageFlags::Offline) &
+              0x0000FFFF);
+    } else
+      strcpy(statusStrBuf, "X-Mozilla-Status: 0001" MSG_LINEBREAK);
+    mCopyState->m_fileStream->Write(statusStrBuf, strlen(statusStrBuf),
+                                    &bytesWritten);
+    if (mCopyState->m_parseMsgState)
+      mCopyState->m_parseMsgState->ParseAFolderLine(statusStrBuf,
+                                                    strlen(statusStrBuf));
+    result = "X-Mozilla-Status2: 00000000" MSG_LINEBREAK;
+    mCopyState->m_fileStream->Write(result.get(), result.Length(),
+                                    &bytesWritten);
+    if (mCopyState->m_parseMsgState)
+      mCopyState->m_parseMsgState->ParseAFolderLine(result.get(),
+                                                    result.Length());
+    result = X_MOZILLA_KEYWORDS;
+    mCopyState->m_fileStream->Write(result.get(), result.Length(),
+                                    &bytesWritten);
+    if (mCopyState->m_parseMsgState)
+      mCopyState->m_parseMsgState->ParseAFolderLine(result.get(),
+                                                    result.Length());
+    mCopyState->m_fromLineSeen = true;
+  } else
+    mCopyState->m_fromLineSeen = false;
+
+  mCopyState->m_curCopyIndex++;
+  return NS_OK;
+}
+
+nsresult nsMsgLocalMailFolder::InitCopyMsgHdrAndFileStream() {
+  nsresult rv = GetMsgStore(getter_AddRefs(mCopyState->m_msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = mCopyState->m_msgStore->GetNewMsgOutputStream(
+      this, getter_AddRefs(mCopyState->m_newHdr),
+      getter_AddRefs(mCopyState->m_fileStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (mCopyState->m_parseMsgState)
+    mCopyState->m_parseMsgState->SetNewMsgHdr(mCopyState->m_newHdr);
+  return rv;
+}
+
+// nsICopyMessageListener
+NS_IMETHODIMP nsMsgLocalMailFolder::BeginCopy() {
+  if (!mCopyState) return NS_ERROR_NULL_POINTER;
+
+  if (!mCopyState->m_copyingMultipleMessages) {
+    nsresult rv = InitCopyMsgHdrAndFileStream();
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  // The output stream may or may not be set already, depending upon all kinds
+  // of inscrutable conditions. This needs cleaning up (see Bug 1731177).
+  if (!mCopyState->m_fileStream) {
+    return NS_OK;
+  }
+
+  int32_t messageIndex = (mCopyState->m_copyingMultipleMessages)
+                             ? mCopyState->m_curCopyIndex - 1
+                             : mCopyState->m_curCopyIndex;
+  NS_ASSERTION(!mCopyState->m_copyingMultipleMessages || messageIndex >= 0,
+               "messageIndex invalid");
+  // by the time we get here, m_curCopyIndex is 1 relative because
+  // WriteStartOfNewMessage increments it
+  if (messageIndex < (int32_t)mCopyState->m_messages.Length()) {
+    mCopyState->m_message = mCopyState->m_messages[messageIndex];
+  } else {
+    mCopyState->m_message = nullptr;
+  }
+  // The flags of the source message can get changed when it is deleted, so
+  // save them here.
+  if (mCopyState->m_message)
+    mCopyState->m_message->GetFlags(&(mCopyState->m_flags));
+  DisplayMoveCopyStatusMsg();
+  if (mCopyState->m_listener)
+    mCopyState->m_listener->OnProgress(mCopyState->m_curCopyIndex,
+                                       mCopyState->m_totalMsgCount);
+  // if we're copying more than one message, StartMessage will handle this.
+  return !mCopyState->m_copyingMultipleMessages ? WriteStartOfNewMessage()
+                                                : NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::CopyData(nsIInputStream* aIStream,
+                                             int32_t aLength) {
+  // check to make sure we have control of the write.
+  bool haveSemaphore;
+  nsresult rv = NS_OK;
+
+  rv = TestSemaphore(static_cast<nsIMsgLocalMailFolder*>(this), &haveSemaphore);
+  if (NS_FAILED(rv)) return rv;
+  if (!haveSemaphore) return NS_MSG_FOLDER_BUSY;
+
+  if (!mCopyState) return NS_ERROR_OUT_OF_MEMORY;
+
+  uint32_t readCount;
+  // allocate one extra byte for '\0' at the end and another extra byte at the
+  // front to insert a '>' if we have a "From" line
+  // allocate 2 more for crlf that may be needed for those without crlf at end
+  // of file
+  if (aLength + mCopyState->m_leftOver + 4 > mCopyState->m_dataBufferSize) {
+    char* newBuffer = (char*)PR_REALLOC(mCopyState->m_dataBuffer,
+                                        aLength + mCopyState->m_leftOver + 4);
+    if (!newBuffer) return NS_ERROR_OUT_OF_MEMORY;
+
+    mCopyState->m_dataBuffer = newBuffer;
+    mCopyState->m_dataBufferSize = aLength + mCopyState->m_leftOver + 3;
+  }
+
+  rv = aIStream->Read(mCopyState->m_dataBuffer + mCopyState->m_leftOver + 1,
+                      aLength, &readCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mCopyState->m_leftOver += readCount;
+  mCopyState->m_dataBuffer[mCopyState->m_leftOver + 1] = '\0';
+  char* start = mCopyState->m_dataBuffer + 1;
+  char* endBuffer = mCopyState->m_dataBuffer + mCopyState->m_leftOver + 1;
+
+  uint32_t lineLength;
+  uint32_t bytesWritten;
+
+  while (1) {
+    char* end = PL_strnpbrk(start, "\r\n", endBuffer - start);
+    if (!end) {
+      mCopyState->m_leftOver -= (start - mCopyState->m_dataBuffer - 1);
+      // In CopyFileMessage, a complete message is being copied in a single
+      // call to CopyData, and if it does not have a LINEBREAK at the EOF,
+      // then end will be null after reading the last line, and we need
+      // to append the LINEBREAK to the buffer to enable transfer of the last
+      // line.
+      if (mCopyState->m_wholeMsgInStream) {
+        end = start + mCopyState->m_leftOver;
+        memcpy(end, MSG_LINEBREAK "\0", MSG_LINEBREAK_LEN + 1);
+      } else {
+        memmove(mCopyState->m_dataBuffer + 1, start, mCopyState->m_leftOver);
+        break;
+      }
+    }
+
+    // need to set the linebreak_len each time
+    uint32_t linebreak_len = 1;  // assume CR or LF
+    if (*end == '\r' && *(end + 1) == '\n') linebreak_len = 2;  // CRLF
+
+    if (!mCopyState->m_fromLineSeen) {
+      mCopyState->m_fromLineSeen = true;
+      NS_ASSERTION(strncmp(start, "From ", 5) == 0,
+                   "Fatal ... bad message format\n");
+    } else if (strncmp(start, "From ", 5) == 0) {
+      // if we're at the beginning of the buffer, we've reserved a byte to
+      // insert a '>'.  If we're in the middle, we're overwriting the previous
+      // line ending, but we've already written it to m_fileStream, so it's OK.
+      *--start = '>';
+    }
+
+    if (!mCopyState->m_fileStream) {
+      ThrowAlertMsg("copyMsgWriteFailed", mCopyState->m_msgWindow);
+      mCopyState->m_writeFailed = true;
+      return NS_ERROR_UNEXPECTED;
+    }
+
+    lineLength = end - start + linebreak_len;
+    rv = mCopyState->m_fileStream->Write(start, lineLength, &bytesWritten);
+    if (bytesWritten != lineLength || NS_FAILED(rv)) {
+      ThrowAlertMsg("copyMsgWriteFailed", mCopyState->m_msgWindow);
+      mCopyState->m_writeFailed = true;
+      return NS_MSG_ERROR_WRITING_MAIL_FOLDER;
+    }
+
+    if (mCopyState->m_parseMsgState)
+      mCopyState->m_parseMsgState->ParseAFolderLine(start, lineLength);
+
+    start = end + linebreak_len;
+    if (start >= endBuffer) {
+      mCopyState->m_leftOver = 0;
+      break;
+    }
+  }
+  return rv;
+}
+
+void nsMsgLocalMailFolder::CopyPropertiesToMsgHdr(nsIMsgDBHdr* destHdr,
+                                                  nsIMsgDBHdr* srcHdr,
+                                                  bool aIsMove) {
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch(
+      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCString dontPreserve;
+
+  // These preferences exist so that extensions can control which properties
+  // are preserved in the database when a message is moved or copied. All
+  // properties are preserved except those listed in these preferences
+  if (aIsMove)
+    prefBranch->GetCharPref("mailnews.database.summary.dontPreserveOnMove",
+                            dontPreserve);
+  else
+    prefBranch->GetCharPref("mailnews.database.summary.dontPreserveOnCopy",
+                            dontPreserve);
+
+  CopyHdrPropertiesWithSkipList(destHdr, srcHdr, dontPreserve);
+}
+
+void nsMsgLocalMailFolder::CopyHdrPropertiesWithSkipList(
+    nsIMsgDBHdr* destHdr, nsIMsgDBHdr* srcHdr, const nsCString& skipList) {
+  nsTArray<nsCString> properties;
+  nsresult rv = srcHdr->GetProperties(properties);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  // We'll add spaces at beginning and end so we can search for space-name-space
+  nsCString dontPreserveEx(" "_ns);
+  dontPreserveEx.Append(skipList);
+  dontPreserveEx.Append(' ');
+
+  nsCString sourceString;
+  for (auto property : properties) {
+    nsAutoCString propertyEx(" "_ns);
+    propertyEx.Append(property);
+    propertyEx.Append(' ');
+    if (dontPreserveEx.Find(propertyEx) != -1)  // -1 is not found
+      continue;
+
+    srcHdr->GetStringProperty(property.get(), sourceString);
+    destHdr->SetStringProperty(property.get(), sourceString);
+  }
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
+nsMsgLocalMailFolder::EndCopy(bool aCopySucceeded) {
+  if (!mCopyState) return NS_OK;
+
+  // we are the destination folder for a move/copy
+  nsresult rv = aCopySucceeded ? NS_OK : NS_ERROR_FAILURE;
+
+  if (!aCopySucceeded || mCopyState->m_writeFailed) {
+    if (mCopyState->m_fileStream) {
+      if (mCopyState->m_curDstKey != nsMsgKey_None)
+        mCopyState->m_msgStore->DiscardNewMessage(mCopyState->m_fileStream,
+                                                  mCopyState->m_newHdr);
+      mCopyState->m_fileStream->Close();
+    }
+
+    if (!mCopyState->m_isMove) {
+      // passing true because the messages that have been successfully
+      // copied have their corresponding hdrs in place. The message that has
+      // failed has been truncated so the msf file and berkeley mailbox
+      // are in sync.
+      (void)OnCopyCompleted(mCopyState->m_srcSupport, true);
+      // enable the dest folder
+      EnableNotifications(allMessageCountNotifications, true);
+    }
+    return NS_OK;
+  }
+
+  bool multipleCopiesFinished =
+      (mCopyState->m_curCopyIndex >= mCopyState->m_totalMsgCount);
+
+  RefPtr<nsLocalMoveCopyMsgTxn> localUndoTxn = mCopyState->m_undoMsgTxn;
+
+  NS_ASSERTION(mCopyState->m_leftOver == 0,
+               "whoops, something wrong with previous copy");
+  mCopyState->m_leftOver = 0;  // reset to 0.
+  // need to reset this in case we're move/copying multiple msgs.
+  mCopyState->m_fromLineSeen = false;
+
+  // flush the copied message. We need a close at the end to get the
+  // file size and time updated correctly.
+  //
+  // These filestream closes are handled inconsistently in the code. In some
+  // cases, this is done in EndMessage, while in others it is done here in
+  // EndCopy. When we do the close in EndMessage, we'll set
+  // mCopyState->m_fileStream to null since it is no longer needed, and detect
+  // here the null stream so we know that we don't have to close it here.
+  //
+  // Similarly, m_parseMsgState->GetNewMsgHdr() returns a null hdr if the hdr
+  // has already been processed by EndMessage so it is not doubly added here.
+
+  if (mCopyState->m_fileStream) {
+    rv = FinishNewLocalMessage(mCopyState->m_fileStream, mCopyState->m_newHdr,
+                               mCopyState->m_msgStore,
+                               mCopyState->m_parseMsgState);
+    if (NS_SUCCEEDED(rv) && mCopyState->m_newHdr)
+      mCopyState->m_newHdr->GetMessageKey(&mCopyState->m_curDstKey);
+    if (multipleCopiesFinished)
+      mCopyState->m_fileStream->Close();
+    else
+      mCopyState->m_fileStream->Flush();
+  }
+  // Copy the header to the new database
+  if (mCopyState->m_message) {
+    //  CopyMessages() goes here, and CopyFileMessages() with metadata to save;
+    nsCOMPtr<nsIMsgDBHdr> newHdr;
+    if (!mCopyState->m_parseMsgState) {
+      if (mCopyState->m_destDB) {
+        if (mCopyState->m_newHdr) {
+          newHdr = mCopyState->m_newHdr;
+          CopyHdrPropertiesWithSkipList(newHdr, mCopyState->m_message,
+                                        "storeToken msgOffset"_ns);
+          // We need to copy more than just what UpdateNewMsgHdr does. In fact,
+          // I think we want to copy almost every property other than
+          // storeToken and msgOffset.
+          mCopyState->m_destDB->AddNewHdrToDB(newHdr, true);
+        } else {
+          rv = mCopyState->m_destDB->CopyHdrFromExistingHdr(
+              mCopyState->m_curDstKey, mCopyState->m_message, true,
+              getter_AddRefs(newHdr));
+        }
+        uint32_t newHdrFlags;
+        if (newHdr) {
+          // turn off offline flag - it's not valid for local mail folders.
+          newHdr->AndFlags(~nsMsgMessageFlags::Offline, &newHdrFlags);
+          mCopyState->m_destMessages.AppendElement(newHdr);
+        }
+      }
+      // we can do undo with the dest folder db, see bug #198909
+      // else
+      //   mCopyState->m_undoMsgTxn = nullptr;  // null out the transaction
+      //                                        // because we can't undo w/o
+      //                                        // the msg db
+    }
+
+    // if we plan on allowing undo, (if we have a mCopyState->m_parseMsgState or
+    // not) we need to save the source and dest keys on the undo txn. see bug
+    // #179856 for details
+    bool isImap;
+    if (NS_SUCCEEDED(rv) && localUndoTxn) {
+      localUndoTxn->GetSrcIsImap(&isImap);
+      if (!isImap || !mCopyState->m_copyingMultipleMessages) {
+        nsMsgKey aKey;
+        mCopyState->m_message->GetMessageKey(&aKey);
+        localUndoTxn->AddSrcKey(aKey);
+        localUndoTxn->AddDstKey(mCopyState->m_curDstKey);
+      }
+    }
+  }
+  nsCOMPtr<nsIMsgDBHdr> newHdr;
+  // CopyFileMessage() and CopyMessages() from servers other than mailbox
+  if (mCopyState->m_parseMsgState) {
+    nsCOMPtr<nsIMsgDatabase> msgDb;
+    mCopyState->m_parseMsgState->FinishHeader();
+    GetDatabaseWOReparse(getter_AddRefs(msgDb));
+    if (msgDb) {
+      nsresult result =
+          mCopyState->m_parseMsgState->GetNewMsgHdr(getter_AddRefs(newHdr));
+      // we need to copy newHdr because mCopyState will get cleared
+      // in OnCopyCompleted, but we need OnCopyCompleted to know about
+      // the newHdr, via mCopyState. And we send a notification about newHdr
+      // after OnCopyCompleted.
+      mCopyState->m_newHdr = newHdr;
+      if (NS_SUCCEEDED(result) && newHdr) {
+        // Copy message metadata.
+        uint32_t newFlags;
+        newHdr->GetFlags(&newFlags);
+        if (mCopyState->m_message) {
+          // Propagate the new flag on an imap to local folder filter action
+          // Flags may get changed when deleting the original source message in
+          // IMAP. We have a copy of the original flags, but parseMsgState has
+          // already tried to decide what those flags should be. Who to believe?
+          // Let's deal here with the flags that might get changed, Read and
+          // New, and trust upstream code for everything else. However,
+          // we need to carry over HasRe since the subject is copied over
+          // from the original.
+          uint32_t carryOver = nsMsgMessageFlags::New |
+                               nsMsgMessageFlags::Read |
+                               nsMsgMessageFlags::HasRe;
+          newHdr->SetFlags((newFlags & ~carryOver) |
+                           ((mCopyState->m_flags) & carryOver));
+
+          // Copy other message properties.
+          CopyPropertiesToMsgHdr(newHdr, mCopyState->m_message,
+                                 mCopyState->m_isMove);
+        } else {
+          // Carry over some of the enforced flags, but do not clear any of the
+          // already set flags (for example nsMsgMessageFlags::Queued or
+          // nsMsgMessageFlags::MDNReportSent).
+          uint32_t carryOver = nsMsgMessageFlags::New |
+                               nsMsgMessageFlags::Read |
+                               nsMsgMessageFlags::Marked;
+          newHdr->SetFlags((newFlags & ~carryOver) |
+                           ((mCopyState->m_flags) & carryOver));
+        }
+        msgDb->AddNewHdrToDB(newHdr, true);
+        if (localUndoTxn) {
+          // ** jt - recording the message size for possible undo use; the
+          // message size is different for pop3 and imap4 messages
+          uint32_t msgSize;
+          newHdr->GetMessageSize(&msgSize);
+          localUndoTxn->AddDstMsgSize(msgSize);
+        }
+
+        mCopyState->m_destMessages.AppendElement(newHdr);
+      }
+      // msgDb->SetSummaryValid(true);
+      // msgDb->Commit(nsMsgDBCommitType::kLargeCommit);
+    } else
+      mCopyState->m_undoMsgTxn = nullptr;  // null out the transaction because
+                                           // we can't undo w/o the msg db
+
+    mCopyState->m_parseMsgState->Clear();
+    if (mCopyState->m_listener)  // CopyFileMessage() only
+      mCopyState->m_listener->SetMessageKey(mCopyState->m_curDstKey);
+  }
+
+  if (!multipleCopiesFinished && !mCopyState->m_copyingMultipleMessages) {
+    // CopyMessages() goes here; CopyFileMessage() never gets in here because
+    // curCopyIndex will always be less than the mCopyState->m_totalMsgCount
+    nsIMsgDBHdr* aSupport = mCopyState->m_messages[mCopyState->m_curCopyIndex];
+    rv = CopyMessageTo(aSupport, mCopyState->m_msgWindow, mCopyState->m_isMove);
+  } else {
+    // If we have some headers, then there is a source, so notify
+    // itemMoveCopyCompleted. If we don't have any headers already, (eg save as
+    // draft, send) then notify itemAdded. This notification is done after the
+    // messages are deleted, so that saving a new draft of a message works
+    // correctly -- first an itemDeleted is sent for the old draft, then an
+    // itemAdded for the new draft.
+    uint32_t numHdrs = mCopyState->m_messages.Length();
+
+    if (multipleCopiesFinished && numHdrs && !mCopyState->m_isFolder) {
+      // we need to send this notification before we delete the source messages,
+      // because deleting the source messages clears out the src msg db hdr.
+      nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+          do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+      if (notifier) {
+        notifier->NotifyMsgsMoveCopyCompleted(mCopyState->m_isMove,
+                                              mCopyState->m_messages, this,
+                                              mCopyState->m_destMessages);
+      }
+    }
+
+    // Now allow folder or nested folders move of their msgs from Local Folders.
+    // The original source folder(s) remain, just the msgs are moved (after
+    // copy they are deleted).
+    if (multipleCopiesFinished) {
+      nsCOMPtr<nsIMsgFolder> srcFolder;
+      srcFolder = do_QueryInterface(mCopyState->m_srcSupport);
+      if (mCopyState->m_isFolder) {
+        // Copy or move all subfolders then notify completion
+        CopyAllSubFolders(srcFolder, nullptr, nullptr, mCopyState->m_isMove);
+      }
+
+      // If this is done on move of selected messages between "mailbox" folders,
+      // the source messages are never deleted. So do this only on msg copy.
+      if (!mCopyState->m_isMove) {
+        if (mCopyState->m_msgWindow && mCopyState->m_undoMsgTxn) {
+          nsCOMPtr<nsITransactionManager> txnMgr;
+          mCopyState->m_msgWindow->GetTransactionManager(
+              getter_AddRefs(txnMgr));
+          if (txnMgr) {
+            RefPtr<nsLocalMoveCopyMsgTxn> txn = mCopyState->m_undoMsgTxn;
+            txnMgr->DoTransaction(txn);
+          }
+        }
+
+        // enable the dest folder
+        EnableNotifications(allMessageCountNotifications, true);
+        if (srcFolder && !mCopyState->m_isFolder) {
+          // I'm not too sure of the proper location of this event. It seems to
+          // need to be after the EnableNotifications, or the folder counts can
+          // be incorrect during the kDeleteOrMoveMsgCompleted call.
+          srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgCompleted);
+        }
+        (void)OnCopyCompleted(mCopyState->m_srcSupport, true);
+      }
+    }
+    // Send the itemAdded notification in case we didn't send the
+    // itemMoveCopyCompleted notification earlier. Posting news messages
+    // involves this, yet doesn't have the newHdr initialized, so don't send any
+    // notifications in that case.
+    if (!numHdrs && newHdr) {
+      nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+          do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+      if (notifier) {
+        notifier->NotifyMsgAdded(newHdr);
+        // We do not appear to trigger classification in this case, so let's
+        // paper over the abyss by just sending the classification notification.
+        notifier->NotifyMsgsClassified({&*newHdr}, false, false);
+        // (We do not add the NotReportedClassified processing flag since we
+        // just reported it!)
+      }
+    }
+  }
+  return rv;
+}
+
+static bool gGotGlobalPrefs;
+static bool gDeleteFromServerOnMove;
+
+bool nsMsgLocalMailFolder::GetDeleteFromServerOnMove() {
+  if (!gGotGlobalPrefs) {
+    nsCOMPtr<nsIPrefBranch> pPrefBranch(
+        do_GetService(NS_PREFSERVICE_CONTRACTID));
+    if (pPrefBranch) {
+      pPrefBranch->GetBoolPref("mail.pop3.deleteFromServerOnMove",
+                               &gDeleteFromServerOnMove);
+      gGotGlobalPrefs = true;
+    }
+  }
+  return gDeleteFromServerOnMove;
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
+nsMsgLocalMailFolder::EndMove(bool moveSucceeded) {
+  nsresult rv;
+  if (!mCopyState) return NS_OK;
+
+  if (!moveSucceeded || mCopyState->m_writeFailed) {
+    // Notify that a completion finished.
+    nsCOMPtr<nsIMsgFolder> srcFolder =
+        do_QueryInterface(mCopyState->m_srcSupport, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgFailed);
+
+    /* passing true because the messages that have been successfully copied have
+       their corresponding hdrs in place. The message that has failed has been
+       truncated so the msf file and berkeley mailbox are in sync*/
+
+    (void)OnCopyCompleted(mCopyState->m_srcSupport, true);
+    // enable the dest folder
+    EnableNotifications(allMessageCountNotifications, true);
+    return NS_OK;
+  }
+
+  if (mCopyState && mCopyState->m_curCopyIndex >= mCopyState->m_totalMsgCount) {
+    // Notify that a completion finished.
+    nsCOMPtr<nsIMsgFolder> srcFolder =
+        do_QueryInterface(mCopyState->m_srcSupport, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIMsgLocalMailFolder> localSrcFolder =
+        do_QueryInterface(srcFolder);
+    if (localSrcFolder) {
+      // if we are the trash and a local msg is being moved to us, mark the
+      // source for delete from server, if so configured.
+      if (mFlags & nsMsgFolderFlags::Trash) {
+        // if we're deleting on all moves, we'll mark this message for deletion
+        // when we call DeleteMessages on the source folder. So don't mark it
+        // for deletion here, in that case.
+        if (!GetDeleteFromServerOnMove()) {
+          localSrcFolder->MarkMsgsOnPop3Server(mCopyState->m_messages,
+                                               POP3_DELETE);
+        }
+      }
+    }
+    // lets delete these all at once - much faster that way
+    rv = srcFolder->DeleteMessages(mCopyState->m_messages,
+                                   mCopyState->m_msgWindow, true, true, nullptr,
+                                   mCopyState->m_allowUndo);
+    AutoCompact(mCopyState->m_msgWindow);
+
+    // enable the dest folder
+    EnableNotifications(allMessageCountNotifications, true);
+    // I'm not too sure of the proper location of this event. It seems to need
+    // to be after the EnableNotifications, or the folder counts can be
+    // incorrect during the kDeleteOrMoveMsgCompleted call.
+    srcFolder->NotifyFolderEvent(NS_SUCCEEDED(rv) ? kDeleteOrMoveMsgCompleted
+                                                  : kDeleteOrMoveMsgFailed);
+
+    if (NS_SUCCEEDED(rv) && mCopyState->m_msgWindow &&
+        mCopyState->m_undoMsgTxn) {
+      nsCOMPtr<nsITransactionManager> txnMgr;
+      mCopyState->m_msgWindow->GetTransactionManager(getter_AddRefs(txnMgr));
+      if (txnMgr) {
+        RefPtr<nsLocalMoveCopyMsgTxn> txn = mCopyState->m_undoMsgTxn;
+        txnMgr->DoTransaction(txn);
+      }
+    }
+    (void)OnCopyCompleted(
+        mCopyState->m_srcSupport,
+        NS_SUCCEEDED(rv)
+            ? true
+            : false);  // clear the copy state so that the next message from a
+                       // different folder can be move
+  }
+
+  return NS_OK;
+}
+
+// this is the beginning of the next message copied
+NS_IMETHODIMP nsMsgLocalMailFolder::StartMessage() {
+  // We get crashes that we don't understand (bug 284876), so stupidly prevent
+  // that.
+  NS_ENSURE_ARG_POINTER(mCopyState);
+  nsresult rv = InitCopyMsgHdrAndFileStream();
+  NS_ENSURE_SUCCESS(rv, rv);
+  return WriteStartOfNewMessage();
+}
+
+// just finished the current message.
+NS_IMETHODIMP nsMsgLocalMailFolder::EndMessage(nsMsgKey key) {
+  NS_ENSURE_ARG_POINTER(mCopyState);
+
+  RefPtr<nsLocalMoveCopyMsgTxn> localUndoTxn = mCopyState->m_undoMsgTxn;
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+  nsresult rv;
+
+  if (localUndoTxn) {
+    localUndoTxn->GetMsgWindow(getter_AddRefs(msgWindow));
+    localUndoTxn->AddSrcKey(key);
+    localUndoTxn->AddDstKey(mCopyState->m_curDstKey);
+  }
+
+  // I think this is always true for online to offline copy
+  mCopyState->m_dummyEnvelopeNeeded = true;
+  if (mCopyState->m_fileStream) {
+    rv = FinishNewLocalMessage(mCopyState->m_fileStream, mCopyState->m_newHdr,
+                               mCopyState->m_msgStore,
+                               mCopyState->m_parseMsgState);
+    mCopyState->m_fileStream->Close();
+    mCopyState->m_fileStream = nullptr;  // all done with the file stream
+  }
+
+  // CopyFileMessage() and CopyMessages() from servers other than mailbox
+  if (mCopyState->m_parseMsgState) {
+    nsCOMPtr<nsIMsgDatabase> msgDb;
+    nsCOMPtr<nsIMsgDBHdr> newHdr;
+
+    mCopyState->m_parseMsgState->FinishHeader();
+
+    rv = mCopyState->m_parseMsgState->GetNewMsgHdr(getter_AddRefs(newHdr));
+    if (NS_SUCCEEDED(rv) && newHdr) {
+      nsCOMPtr<nsIMsgFolder> srcFolder =
+          do_QueryInterface(mCopyState->m_srcSupport, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr<nsIMsgDatabase> srcDB;
+      srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
+      if (srcDB) {
+        nsCOMPtr<nsIMsgDBHdr> srcMsgHdr;
+        srcDB->GetMsgHdrForKey(key, getter_AddRefs(srcMsgHdr));
+        if (srcMsgHdr)
+          CopyPropertiesToMsgHdr(newHdr, srcMsgHdr, mCopyState->m_isMove);
+      }
+      rv = GetDatabaseWOReparse(getter_AddRefs(msgDb));
+      if (NS_SUCCEEDED(rv) && msgDb) {
+        msgDb->AddNewHdrToDB(newHdr, true);
+        if (localUndoTxn) {
+          // ** jt - recording the message size for possible undo use; the
+          // message size is different for pop3 and imap4 messages
+          uint32_t msgSize;
+          newHdr->GetMessageSize(&msgSize);
+          localUndoTxn->AddDstMsgSize(msgSize);
+        }
+      } else
+        mCopyState->m_undoMsgTxn = nullptr;  // null out the transaction because
+                                             // we can't undo w/o the msg db
+    }
+    mCopyState->m_parseMsgState->Clear();
+
+    if (mCopyState->m_listener)  // CopyFileMessage() only
+      mCopyState->m_listener->SetMessageKey(mCopyState->m_curDstKey);
+  }
+
+  if (mCopyState->m_fileStream) mCopyState->m_fileStream->Flush();
+  return NS_OK;
+}
+
+nsresult nsMsgLocalMailFolder::CopyMessagesTo(nsTArray<nsMsgKey>& keyArray,
+                                              nsIMsgWindow* aMsgWindow,
+                                              bool isMove) {
+  if (!mCopyState) return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv;
+
+  nsCOMPtr<nsICopyMessageStreamListener> copyStreamListener = do_CreateInstance(
+      "@mozilla.org/messenger/copymessagestreamlistener;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> srcFolder(
+      do_QueryInterface(mCopyState->m_srcSupport, &rv));
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_NO_INTERFACE);
+
+  rv = copyStreamListener->Init(this);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!mCopyState->m_messageService) {
+    nsCString uri;
+    srcFolder->GetURI(uri);
+    rv = GetMessageServiceFromURI(uri,
+                                  getter_AddRefs(mCopyState->m_messageService));
+  }
+
+  if (NS_SUCCEEDED(rv) && mCopyState->m_messageService) {
+    nsCOMPtr<nsIStreamListener> streamListener(
+        do_QueryInterface(copyStreamListener, &rv));
+    NS_ENSURE_SUCCESS(rv, NS_ERROR_NO_INTERFACE);
+
+    mCopyState->m_curCopyIndex = 0;
+    // we need to kick off the first message - subsequent messages
+    // are kicked off by nsMailboxProtocol when it finishes a message
+    // before starting the next message. Only do this if the source folder
+    // is a local folder, however. IMAP will handle calling StartMessage for
+    // each message that gets downloaded, and news doesn't go through here
+    // because news only downloads one message at a time, and this routine
+    // is for multiple message copy.
+    nsCOMPtr<nsIMsgLocalMailFolder> srcLocalFolder =
+        do_QueryInterface(srcFolder);
+    if (srcLocalFolder) {
+      StartMessage();
+    }
+    nsCOMPtr<nsIURI> dummyNull;
+    rv = mCopyState->m_messageService->CopyMessages(
+        keyArray, srcFolder, streamListener, isMove, nullptr, aMsgWindow,
+        getter_AddRefs(dummyNull));
+  }
+  return rv;
+}
+
+nsresult nsMsgLocalMailFolder::CopyMessageTo(nsISupports* message,
+                                             nsIMsgWindow* aMsgWindow,
+                                             bool isMove) {
+  if (!mCopyState) return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgDBHdr> msgHdr(do_QueryInterface(message, &rv));
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_NO_INTERFACE);
+
+  mCopyState->m_message = msgHdr;
+
+  nsCOMPtr<nsIMsgFolder> srcFolder(
+      do_QueryInterface(mCopyState->m_srcSupport, &rv));
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_NO_INTERFACE);
+  nsCString uri;
+  srcFolder->GetUriForMsg(msgHdr, uri);
+
+  nsCOMPtr<nsICopyMessageStreamListener> copyStreamListener = do_CreateInstance(
+      "@mozilla.org/messenger/copymessagestreamlistener;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = copyStreamListener->Init(this);
+  if (NS_FAILED(rv)) return rv;
+
+  if (!mCopyState->m_messageService)
+    rv = GetMessageServiceFromURI(uri,
+                                  getter_AddRefs(mCopyState->m_messageService));
+
+  if (NS_SUCCEEDED(rv) && mCopyState->m_messageService) {
+    nsCOMPtr<nsIStreamListener> streamListener(
+        do_QueryInterface(copyStreamListener, &rv));
+    NS_ENSURE_SUCCESS(rv, NS_ERROR_NO_INTERFACE);
+    rv = mCopyState->m_messageService->CopyMessage(uri, streamListener, isMove,
+                                                   nullptr, aMsgWindow);
+  }
+  return rv;
+}
+
+// A message is being deleted from a POP3 mail file, so check and see if we have
+// the message being deleted in the server. If so, then we need to remove the
+// message from the server as well. We have saved the UIDL of the message in the
+// popstate.dat file and we must match this uidl, so read the message headers
+// and see if we have it, then mark the message for deletion from the server.
+// The next time we look at mail the message will be deleted from the server.
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::MarkMsgsOnPop3Server(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages, int32_t aMark) {
+  nsLocalFolderScanState folderScanState;
+  nsCOMPtr<nsIPop3IncomingServer> curFolderPop3MailServer;
+  nsCOMArray<nsIPop3IncomingServer>
+      pop3Servers;  // servers with msgs deleted...
+
+  nsCOMPtr<nsIMsgIncomingServer> incomingServer;
+  nsresult rv = GetServer(getter_AddRefs(incomingServer));
+  NS_ENSURE_SUCCESS(rv, NS_MSG_INVALID_OR_MISSING_SERVER);
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // I wonder if we should run through the pop3 accounts and see if any of them
+  // have leave on server set. If not, we could short-circuit some of this.
+
+  curFolderPop3MailServer = do_QueryInterface(incomingServer, &rv);
+  rv = GetFolderScanState(&folderScanState);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Filter delete requests are always honored, others are subject
+  // to the deleteMailLeftOnServer preference.
+  int32_t mark;
+  mark = (aMark == POP3_FORCE_DEL) ? POP3_DELETE : aMark;
+
+  for (auto msgDBHdr : aMessages) {
+    uint32_t flags = 0;
+    if (msgDBHdr) {
+      msgDBHdr->GetFlags(&flags);
+      nsCOMPtr<nsIPop3IncomingServer> msgPop3Server = curFolderPop3MailServer;
+      bool leaveOnServer = false;
+      bool deleteMailLeftOnServer = false;
+      // set up defaults, in case there's no x-mozilla-account header
+      if (curFolderPop3MailServer) {
+        curFolderPop3MailServer->GetDeleteMailLeftOnServer(
+            &deleteMailLeftOnServer);
+        curFolderPop3MailServer->GetLeaveMessagesOnServer(&leaveOnServer);
+      }
+
+      rv = GetUidlFromFolder(&folderScanState, msgDBHdr);
+      if (!NS_SUCCEEDED(rv)) continue;
+
+      if (folderScanState.m_uidl) {
+        nsCOMPtr<nsIMsgAccount> account;
+        rv = accountManager->GetAccount(folderScanState.m_accountKey,
+                                        getter_AddRefs(account));
+        if (NS_SUCCEEDED(rv) && account) {
+          account->GetIncomingServer(getter_AddRefs(incomingServer));
+          nsCOMPtr<nsIPop3IncomingServer> curMsgPop3MailServer =
+              do_QueryInterface(incomingServer);
+          if (curMsgPop3MailServer) {
+            msgPop3Server = curMsgPop3MailServer;
+            msgPop3Server->GetDeleteMailLeftOnServer(&deleteMailLeftOnServer);
+            msgPop3Server->GetLeaveMessagesOnServer(&leaveOnServer);
+          }
+        }
+      }
+      // ignore this header if not partial and leaveOnServer not set...
+      // or if we can't find the pop3 server.
+      if (!msgPop3Server ||
+          (!(flags & nsMsgMessageFlags::Partial) && !leaveOnServer))
+        continue;
+      // if marking deleted, ignore header if we're not deleting from
+      // server when deleting locally.
+      if (aMark == POP3_DELETE && leaveOnServer && !deleteMailLeftOnServer)
+        continue;
+      if (folderScanState.m_uidl) {
+        msgPop3Server->AddUidlToMark(folderScanState.m_uidl, mark);
+        // remember this pop server in list of servers with msgs deleted
+        if (pop3Servers.IndexOfObject(msgPop3Server) == -1)
+          pop3Servers.AppendObject(msgPop3Server);
+      }
+    }
+  }
+  if (folderScanState.m_inputStream) folderScanState.m_inputStream->Close();
+  // need to do this for all pop3 mail servers that had messages deleted.
+  uint32_t serverCount = pop3Servers.Count();
+  for (uint32_t index = 0; index < serverCount; index++)
+    pop3Servers[index]->MarkMessages();
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::DeleteDownloadMsg(nsIMsgDBHdr* aMsgHdr) {
+  uint32_t numMsgs;
+  char* newMsgId;
+
+  // This method is only invoked through DownloadMessagesForOffline()
+  if (mDownloadState != DOWNLOAD_STATE_NONE) {
+    // We only remember the first key, no matter how many
+    // messages were originally selected.
+    if (mDownloadState == DOWNLOAD_STATE_INITED) {
+      aMsgHdr->GetMessageKey(&mDownloadSelectKey);
+      mDownloadState = DOWNLOAD_STATE_GOTMSG;
+    }
+
+    aMsgHdr->GetMessageId(&newMsgId);
+
+    // Walk through all the selected headers, looking for a matching
+    // Message-ID.
+    numMsgs = mDownloadMessages.Length();
+    for (uint32_t i = 0; i < numMsgs; i++) {
+      nsresult rv;
+      nsCOMPtr<nsIMsgDBHdr> msgDBHdr = mDownloadMessages[i];
+      char* oldMsgId = nullptr;
+      msgDBHdr->GetMessageId(&oldMsgId);
+
+      // Delete the first match and remove it from the array
+      if (!PL_strcmp(newMsgId, oldMsgId)) {
+        rv = GetDatabase();
+        if (!mDatabase) return rv;
+
+        UpdateNewMsgHdr(msgDBHdr, aMsgHdr);
+
+        mDatabase->DeleteHeader(msgDBHdr, nullptr, false, true);
+        mDownloadMessages.RemoveElementAt(i);
+        break;
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::DownloadMessagesForOffline(
+    nsTArray<RefPtr<nsIMsgDBHdr>> const& aMessages, nsIMsgWindow* aWindow) {
+  if (mDownloadState != DOWNLOAD_STATE_NONE)
+    return NS_ERROR_FAILURE;  // already has a download in progress
+
+  // We're starting a download...
+  mDownloadState = DOWNLOAD_STATE_INITED;
+
+  MarkMsgsOnPop3Server(aMessages, POP3_FETCH_BODY);
+
+  // Pull out all the PARTIAL messages into a new array
+  nsresult rv;
+  for (nsIMsgDBHdr* hdr : aMessages) {
+    uint32_t flags = 0;
+    hdr->GetFlags(&flags);
+    if (flags & nsMsgMessageFlags::Partial) {
+      mDownloadMessages.AppendElement(hdr);
+    }
+  }
+  mDownloadWindow = aWindow;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, NS_MSG_INVALID_OR_MISSING_SERVER);
+
+  nsCOMPtr<nsILocalMailIncomingServer> localMailServer =
+      do_QueryInterface(server, &rv);
+  NS_ENSURE_SUCCESS(rv, NS_MSG_INVALID_OR_MISSING_SERVER);
+  nsCOMPtr<nsIURI> resultURI;
+  return localMailServer->GetNewMail(aWindow, this, this,
+                                     getter_AddRefs(resultURI));
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::HasMsgOffline(nsMsgKey msgKey,
+                                                  bool* result) {
+  NS_ENSURE_ARG(result);
+  *result = false;
+  GetDatabase();
+  if (!mDatabase) return NS_ERROR_FAILURE;
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgDBHdr> hdr;
+  rv = mDatabase->GetMsgHdrForKey(msgKey, getter_AddRefs(hdr));
+  if (NS_FAILED(rv)) return rv;
+
+  if (hdr) {
+    uint32_t flags = 0;
+    hdr->GetFlags(&flags);
+    // Would be nice to check nsMsgMessageFlags::Offline... but local
+    // folders don't set it.
+    // Don't want partial messages.
+    if (!(flags & nsMsgMessageFlags::Partial)) {
+      *result = true;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::GetLocalMsgStream(nsIMsgDBHdr* hdr,
+                                                      nsIInputStream** stream) {
+  uint64_t offset = 0;
+  hdr->GetMessageOffset(&offset);
+  // It's a local folder - .messageSize holds the size.
+  uint32_t size = 0;
+  hdr->GetMessageSize(&size);
+  nsCOMPtr<nsIInputStream> fileStream;
+  nsresult rv = GetMsgInputStream(hdr, getter_AddRefs(fileStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<mozilla::SlicedInputStream> slicedStream =
+      new mozilla::SlicedInputStream(fileStream.forget(), offset,
+                                     uint64_t(size));
+  slicedStream.forget(stream);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::NotifyDelete() {
+  NotifyFolderEvent(kDeleteOrMoveMsgCompleted);
+  return NS_OK;
+}
+
+// TODO:  once we move certain code into the IncomingServer (search for TODO)
+// this method will go away.
+// sometimes this gets called when we don't have the server yet, so
+// that's why we're not calling GetServer()
+NS_IMETHODIMP
+nsMsgLocalMailFolder::GetIncomingServerType(nsACString& aServerType) {
+  nsresult rv;
+  if (mType.IsEmpty()) {
+    nsCOMPtr<nsIURL> url;
+    rv = NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID)
+             .SetSpec(mURI)
+             .Finalize(url);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIMsgAccountManager> accountManager =
+        do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    // try "none" first
+    rv = NS_MutateURI(url).SetScheme("none"_ns).Finalize(url);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = accountManager->FindServerByURI(url, getter_AddRefs(server));
+    if (NS_SUCCEEDED(rv) && server)
+      mType.AssignLiteral("none");
+    else {
+      // next try "pop3"
+      rv = NS_MutateURI(url).SetScheme("pop3"_ns).Finalize(url);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = accountManager->FindServerByURI(url, getter_AddRefs(server));
+      if (NS_SUCCEEDED(rv) && server)
+        mType.AssignLiteral("pop3");
+      else {
+        // next try "rss"
+        rv = NS_MutateURI(url).SetScheme("rss"_ns).Finalize(url);
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv = accountManager->FindServerByURI(url, getter_AddRefs(server));
+        if (NS_SUCCEEDED(rv) && server)
+          mType.AssignLiteral("rss");
+        else {
+        }
+      }
+    }
+  }
+  aServerType = mType;
+  return NS_OK;
+}
+
+nsresult nsMsgLocalMailFolder::CreateBaseMessageURI(const nsACString& aURI) {
+  return nsCreateLocalBaseMessageURI(aURI, mBaseMessageURI);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::OnStartRunningUrl(nsIURI* aUrl) {
+  nsresult rv;
+  nsCOMPtr<nsIPop3URL> popurl = do_QueryInterface(aUrl, &rv);
+  if (NS_SUCCEEDED(rv)) {
+    nsAutoCString aSpec;
+    rv = aUrl->GetSpec(aSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (strstr(aSpec.get(), "uidl=")) {
+      nsCOMPtr<nsIPop3Sink> popsink;
+      rv = popurl->GetPop3Sink(getter_AddRefs(popsink));
+      if (NS_SUCCEEDED(rv)) {
+        popsink->SetBaseMessageUri(mBaseMessageURI);
+        nsCString messageuri;
+        popurl->GetMessageUri(messageuri);
+        popsink->SetOrigMessageUri(messageuri);
+      }
+    }
+  }
+  return nsMsgDBFolder::OnStartRunningUrl(aUrl);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::OnStopRunningUrl(nsIURI* aUrl, nsresult aExitCode) {
+  // If we just finished a DownloadMessages call, reset...
+  if (mDownloadState != DOWNLOAD_STATE_NONE) {
+    mDownloadState = DOWNLOAD_STATE_NONE;
+    mDownloadMessages.Clear();
+    mDownloadWindow = nullptr;
+    return nsMsgDBFolder::OnStopRunningUrl(aUrl, aExitCode);
+  }
+
+  nsresult rv;
+  if (NS_SUCCEEDED(aExitCode)) {
+    nsCOMPtr<nsIMsgMailSession> mailSession =
+        do_GetService("@mozilla.org/messenger/services/session;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIMsgWindow> msgWindow;
+    rv = mailSession->GetTopmostMsgWindow(getter_AddRefs(msgWindow));
+    nsAutoCString aSpec;
+    if (aUrl) {
+      rv = aUrl->GetSpec(aSpec);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    if (mFlags & nsMsgFolderFlags::Inbox) {
+      if (mDatabase && mCheckForNewMessagesAfterParsing) {
+        bool valid =
+            false;  // GetSummaryValid may return without setting valid.
+        mDatabase->GetSummaryValid(&valid);
+        if (valid && msgWindow) rv = GetNewMessages(msgWindow, nullptr);
+        mCheckForNewMessagesAfterParsing = false;
+      }
+    }
+  }
+
+  if (m_parsingFolder) {
+    // Clear this before calling OnStopRunningUrl, in case the url listener
+    // tries to get the database.
+    m_parsingFolder = false;
+
+    // TODO: Updating the size should be pushed down into the msg store backend
+    // so that the size is recalculated as part of parsing the folder data
+    // (important for maildir), once GetSizeOnDisk is pushed into the msgStores
+    // (bug 1032360).
+    (void)RefreshSizeOnDisk();
+
+    // Update the summary totals so the front end will
+    // show the right thing.
+    UpdateSummaryTotals(true);
+
+    if (mReparseListener) {
+      nsCOMPtr<nsIUrlListener> saveReparseListener = mReparseListener;
+      mReparseListener = nullptr;
+      saveReparseListener->OnStopRunningUrl(aUrl, aExitCode);
+    }
+  }
+  if (mFlags & nsMsgFolderFlags::Inbox) {
+    // if we are the inbox and running pop url
+    nsCOMPtr<nsIPop3URL> popurl = do_QueryInterface(aUrl, &rv);
+    mozilla::Unused << popurl;
+    if (NS_SUCCEEDED(rv)) {
+      nsCOMPtr<nsIMsgIncomingServer> server;
+      GetServer(getter_AddRefs(server));
+      // this is the deferred to account, in the global inbox case
+      if (server) server->SetPerformingBiff(false);  // biff is over
+    }
+  }
+  return nsMsgDBFolder::OnStopRunningUrl(aUrl, aExitCode);
+}
+
+nsresult nsMsgLocalMailFolder::DisplayMoveCopyStatusMsg() {
+  nsresult rv = NS_OK;
+  if (mCopyState) {
+    if (!mCopyState->m_statusFeedback) {
+      // get msgWindow from undo txn
+      nsCOMPtr<nsIMsgWindow> msgWindow;
+      if (mCopyState->m_undoMsgTxn)
+        mCopyState->m_undoMsgTxn->GetMsgWindow(getter_AddRefs(msgWindow));
+      if (!msgWindow) return NS_OK;  // not a fatal error.
+
+      msgWindow->GetStatusFeedback(
+          getter_AddRefs(mCopyState->m_statusFeedback));
+    }
+
+    if (!mCopyState->m_stringBundle) {
+      nsCOMPtr<nsIStringBundleService> bundleService =
+          mozilla::components::StringBundle::Service();
+      NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+      rv = bundleService->CreateBundle(
+          "chrome://messenger/locale/localMsgs.properties",
+          getter_AddRefs(mCopyState->m_stringBundle));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    if (mCopyState->m_statusFeedback && mCopyState->m_stringBundle) {
+      nsString folderName;
+      GetName(folderName);
+      nsAutoString numMsgSoFarString;
+      numMsgSoFarString.AppendInt((mCopyState->m_copyingMultipleMessages)
+                                      ? mCopyState->m_curCopyIndex
+                                      : 1);
+
+      nsAutoString totalMessagesString;
+      totalMessagesString.AppendInt(mCopyState->m_totalMsgCount);
+      nsString finalString;
+      AutoTArray<nsString, 3> stringArray = {numMsgSoFarString,
+                                             totalMessagesString, folderName};
+      rv = mCopyState->m_stringBundle->FormatStringFromName(
+          (mCopyState->m_isMove) ? "movingMessagesStatus"
+                                 : "copyingMessagesStatus",
+          stringArray, finalString);
+      int64_t nowMS = PR_IntervalToMilliseconds(PR_IntervalNow());
+
+      // only update status/progress every half second
+      if (nowMS - mCopyState->m_lastProgressTime < 500 &&
+          mCopyState->m_curCopyIndex < mCopyState->m_totalMsgCount)
+        return NS_OK;
+
+      mCopyState->m_lastProgressTime = nowMS;
+      mCopyState->m_statusFeedback->ShowStatusString(finalString);
+      mCopyState->m_statusFeedback->ShowProgress(
+          mCopyState->m_curCopyIndex * 100 / mCopyState->m_totalMsgCount);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::SetFlagsOnDefaultMailboxes(uint32_t flags) {
+  if (flags & nsMsgFolderFlags::Inbox)
+    setSubfolderFlag(u"Inbox"_ns, nsMsgFolderFlags::Inbox);
+
+  if (flags & nsMsgFolderFlags::SentMail)
+    setSubfolderFlag(u"Sent"_ns, nsMsgFolderFlags::SentMail);
+
+  if (flags & nsMsgFolderFlags::Drafts)
+    setSubfolderFlag(u"Drafts"_ns, nsMsgFolderFlags::Drafts);
+
+  if (flags & nsMsgFolderFlags::Templates)
+    setSubfolderFlag(u"Templates"_ns, nsMsgFolderFlags::Templates);
+
+  if (flags & nsMsgFolderFlags::Trash)
+    setSubfolderFlag(u"Trash"_ns, nsMsgFolderFlags::Trash);
+
+  if (flags & nsMsgFolderFlags::Queue)
+    setSubfolderFlag(u"Unsent Messages"_ns, nsMsgFolderFlags::Queue);
+
+  if (flags & nsMsgFolderFlags::Junk)
+    setSubfolderFlag(u"Junk"_ns, nsMsgFolderFlags::Junk);
+
+  if (flags & nsMsgFolderFlags::Archive)
+    setSubfolderFlag(u"Archives"_ns, nsMsgFolderFlags::Archive);
+
+  return NS_OK;
+}
+
+nsresult nsMsgLocalMailFolder::setSubfolderFlag(const nsAString& aFolderName,
+                                                uint32_t flags) {
+  // FindSubFolder() expects the folder name to be escaped
+  // see bug #192043
+  nsAutoCString escapedFolderName;
+  nsresult rv = NS_MsgEscapeEncodeURLPath(aFolderName, escapedFolderName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  rv = FindSubFolder(escapedFolderName, getter_AddRefs(msgFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // we only want to do this if the folder *really* exists,
+  // so check if it has a parent. Otherwise, we'll create the
+  // .msf file when we don't want to.
+  nsCOMPtr<nsIMsgFolder> parent;
+  msgFolder->GetParent(getter_AddRefs(parent));
+  if (!parent) return NS_ERROR_FAILURE;
+
+  rv = msgFolder->SetFlag(flags);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return msgFolder->SetPrettyName(aFolderName);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::GetCheckForNewMessagesAfterParsing(
+    bool* aCheckForNewMessagesAfterParsing) {
+  NS_ENSURE_ARG_POINTER(aCheckForNewMessagesAfterParsing);
+  *aCheckForNewMessagesAfterParsing = mCheckForNewMessagesAfterParsing;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::SetCheckForNewMessagesAfterParsing(
+    bool aCheckForNewMessagesAfterParsing) {
+  mCheckForNewMessagesAfterParsing = aCheckForNewMessagesAfterParsing;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::NotifyCompactCompleted() {
+  mExpungedBytes = 0;
+  m_newMsgs.Clear();  // if compacted, m_newMsgs probably aren't valid.
+  // if compacted, processing flags probably also aren't valid.
+  ClearProcessingFlags();
+  (void)RefreshSizeOnDisk();
+  (void)CloseDBIfFolderNotOpen(false);
+  NotifyFolderEvent(kCompactCompleted);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::Shutdown(bool shutdownChildren) {
+  mInitialized = false;
+  return nsMsgDBFolder::Shutdown(shutdownChildren);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::OnMessageClassified(const nsACString& aMsgURI,
+                                          nsMsgJunkStatus aClassification,
+                                          uint32_t aJunkPercent)
+
+{
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISpamSettings> spamSettings;
+  rv = server->GetSpamSettings(getter_AddRefs(spamSettings));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString spamFolderURI;
+  rv = spamSettings->GetSpamFolderURI(spamFolderURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!aMsgURI.IsEmpty())  // not end of batch
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    rv = GetMsgDBHdrFromURI(aMsgURI, getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsMsgKey msgKey;
+    rv = msgHdr->GetMessageKey(&msgKey);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // check if this message needs junk classification
+    uint32_t processingFlags;
+    GetProcessingFlags(msgKey, &processingFlags);
+
+    if (processingFlags & nsMsgProcessingFlags::ClassifyJunk) {
+      nsMsgDBFolder::OnMessageClassified(aMsgURI, aClassification,
+                                         aJunkPercent);
+
+      if (aClassification == nsIJunkMailPlugin::JUNK) {
+        bool willMoveMessage = false;
+
+        // don't do the move when we are opening up
+        // the junk mail folder or the trash folder
+        // or when manually classifying messages in those folders
+        if (!(mFlags & nsMsgFolderFlags::Junk ||
+              mFlags & nsMsgFolderFlags::Trash)) {
+          bool moveOnSpam = false;
+          rv = spamSettings->GetMoveOnSpam(&moveOnSpam);
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (moveOnSpam) {
+            nsCOMPtr<nsIMsgFolder> folder;
+            rv = FindFolder(spamFolderURI, getter_AddRefs(folder));
+            NS_ENSURE_SUCCESS(rv, rv);
+            if (folder) {
+              rv = folder->SetFlag(nsMsgFolderFlags::Junk);
+              NS_ENSURE_SUCCESS(rv, rv);
+              mSpamKeysToMove.AppendElement(msgKey);
+              willMoveMessage = true;
+            } else {
+              // XXX TODO
+              // JUNK MAIL RELATED
+              // the listener should do
+              // rv = folder->SetFlag(nsMsgFolderFlags::Junk);
+              // NS_ENSURE_SUCCESS(rv,rv);
+              // mSpamKeysToMove.AppendElement(msgKey);
+              // willMoveMessage = true;
+              rv =
+                  GetOrCreateJunkFolder(spamFolderURI, nullptr /* aListener */);
+              NS_ASSERTION(NS_SUCCEEDED(rv), "GetOrCreateJunkFolder failed");
+            }
+          }
+        }
+        rv = spamSettings->LogJunkHit(msgHdr, willMoveMessage);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+  }
+
+  else  // end of batch
+  {
+    // Parent will apply post bayes filters.
+    nsMsgDBFolder::OnMessageClassified(EmptyCString(),
+                                       nsIJunkMailPlugin::UNCLASSIFIED, 0);
+    nsTArray<RefPtr<nsIMsgDBHdr>> messages;
+    if (!mSpamKeysToMove.IsEmpty()) {
+      nsCOMPtr<nsIMsgFolder> folder;
+      if (!spamFolderURI.IsEmpty()) {
+        rv = FindFolder(spamFolderURI, getter_AddRefs(folder));
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      for (uint32_t keyIndex = 0; keyIndex < mSpamKeysToMove.Length();
+           keyIndex++) {
+        // If an upstream filter moved this message, don't move it here.
+        nsMsgKey msgKey = mSpamKeysToMove.ElementAt(keyIndex);
+        nsMsgProcessingFlagType processingFlags;
+        GetProcessingFlags(msgKey, &processingFlags);
+        if (folder && !(processingFlags & nsMsgProcessingFlags::FilterToMove)) {
+          nsCOMPtr<nsIMsgDBHdr> mailHdr;
+          rv = GetMessageHeader(msgKey, getter_AddRefs(mailHdr));
+          if (NS_SUCCEEDED(rv) && mailHdr) messages.AppendElement(mailHdr);
+        } else {
+          // We don't need the processing flag any more.
+          AndProcessingFlags(msgKey, ~nsMsgProcessingFlags::FilterToMove);
+        }
+      }
+
+      if (folder) {
+        nsCOMPtr<nsIMsgCopyService> copySvc =
+            do_GetService("@mozilla.org/messenger/messagecopyservice;1", &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        rv = copySvc->CopyMessages(
+            this, messages, folder, true,
+            /*nsIMsgCopyServiceListener* listener*/ nullptr, nullptr,
+            false /*allowUndo*/);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "CopyMessages failed");
+        if (NS_FAILED(rv)) {
+          nsAutoCString logMsg(
+              "failed to copy junk messages to junk folder rv = ");
+          logMsg.AppendInt(static_cast<uint32_t>(rv), 16);
+          spamSettings->LogJunkString(logMsg.get());
+        }
+      }
+    }
+    int32_t numNewMessages;
+    GetNumNewMessages(false, &numNewMessages);
+    SetNumNewMessages(numNewMessages - messages.Length());
+    mSpamKeysToMove.Clear();
+    // check if this is the inbox first...
+    if (mFlags & nsMsgFolderFlags::Inbox) PerformBiffNotifications();
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::GetFolderScanState(nsLocalFolderScanState* aState) {
+  NS_ENSURE_ARG_POINTER(aState);
+
+  nsresult rv = GetMsgStore(getter_AddRefs(aState->m_msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  aState->m_uidl = nullptr;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::GetUidlFromFolder(nsLocalFolderScanState* aState,
+                                        nsIMsgDBHdr* aMsgDBHdr) {
+  bool more = false;
+  uint32_t size = 0, len = 0;
+  const char* accountKey = nullptr;
+  nsresult rv =
+      GetMsgInputStream(aMsgDBHdr, getter_AddRefs(aState->m_inputStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mozilla::UniquePtr<nsLineBuffer<char>> lineBuffer(new nsLineBuffer<char>);
+
+  aState->m_uidl = nullptr;
+
+  aMsgDBHdr->GetMessageSize(&len);
+  while (len > 0) {
+    rv = NS_ReadLine(aState->m_inputStream.get(), lineBuffer.get(),
+                     aState->m_header, &more);
+    if (NS_SUCCEEDED(rv)) {
+      size = aState->m_header.Length();
+      if (!size) break;
+      // this isn't quite right - need to account for line endings
+      len -= size;
+      // account key header will always be before X_UIDL header
+      if (!accountKey) {
+        accountKey =
+            strstr(aState->m_header.get(), HEADER_X_MOZILLA_ACCOUNT_KEY);
+        if (accountKey) {
+          accountKey += strlen(HEADER_X_MOZILLA_ACCOUNT_KEY) + 2;
+          aState->m_accountKey = accountKey;
+        }
+      } else {
+        aState->m_uidl = strstr(aState->m_header.get(), X_UIDL);
+        if (aState->m_uidl) {
+          aState->m_uidl += X_UIDL_LEN + 2;  // skip UIDL: header
+          break;
+        }
+      }
+    }
+  }
+  aState->m_inputStream->Close();
+  aState->m_inputStream = nullptr;
+  return rv;
+}
+
+/**
+ * Adds a message to the end of the folder, parsing it as it goes, and
+ * applying filters, if applicable.
+ */
+NS_IMETHODIMP
+nsMsgLocalMailFolder::AddMessage(const char* aMessage, nsIMsgDBHdr** aHdr) {
+  NS_ENSURE_ARG_POINTER(aHdr);
+  AutoTArray<nsCString, 1> aMessages = {nsDependentCString(aMessage)};
+  nsTArray<RefPtr<nsIMsgDBHdr>> hdrs;
+  nsresult rv = AddMessageBatch(aMessages, hdrs);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ADDREF(*aHdr = hdrs[0]);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::AddMessageBatch(
+    const nsTArray<nsCString>& aMessages,
+    nsTArray<RefPtr<nsIMsgDBHdr>>& aHdrArray) {
+  aHdrArray.ClearAndRetainStorage();
+  aHdrArray.SetCapacity(aMessages.Length());
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  nsCOMPtr<nsIOutputStream> outFileStream;
+  nsCOMPtr<nsIMsgDBHdr> newHdr;
+
+  rv = server->GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  rv = GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool isLocked;
+
+  GetLocked(&isLocked);
+  if (isLocked) return NS_MSG_FOLDER_BUSY;
+
+  AcquireSemaphore(static_cast<nsIMsgLocalMailFolder*>(this));
+
+  if (NS_SUCCEEDED(rv)) {
+    NS_ENSURE_SUCCESS(rv, rv);
+    for (uint32_t i = 0; i < aMessages.Length(); i++) {
+      RefPtr<nsParseNewMailState> newMailParser = new nsParseNewMailState;
+      NS_ENSURE_TRUE(newMailParser, NS_ERROR_OUT_OF_MEMORY);
+      if (!mGettingNewMessages) newMailParser->DisableFilters();
+      rv = msgStore->GetNewMsgOutputStream(this, getter_AddRefs(newHdr),
+                                           getter_AddRefs(outFileStream));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Get a msgWindow. Proceed without one, but filter actions to imap
+      // folders will silently fail if not signed in and no window for a prompt.
+      nsCOMPtr<nsIMsgWindow> msgWindow;
+      nsCOMPtr<nsIMsgMailSession> mailSession =
+          do_GetService("@mozilla.org/messenger/services/session;1", &rv);
+      if (NS_SUCCEEDED(rv))
+        mailSession->GetTopmostMsgWindow(getter_AddRefs(msgWindow));
+
+      rv = newMailParser->Init(rootFolder, this, msgWindow, newHdr,
+                               outFileStream);
+
+      uint32_t bytesWritten;
+      uint32_t messageLen = aMessages[i].Length();
+      outFileStream->Write(aMessages[i].get(), messageLen, &bytesWritten);
+      rv = newMailParser->BufferInput(aMessages[i].get(), messageLen);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = newMailParser->Flush();
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      FinishNewLocalMessage(outFileStream, newHdr, msgStore, newMailParser);
+      outFileStream->Close();
+      outFileStream = nullptr;
+      newMailParser->OnStopRequest(nullptr, NS_OK);
+      newMailParser->EndMsgDownload();
+      aHdrArray.AppendElement(newHdr);
+    }
+  }
+  ReleaseSemaphore(static_cast<nsIMsgLocalMailFolder*>(this));
+  return rv;
+}
+
+nsresult nsMsgLocalMailFolder::FinishNewLocalMessage(
+    nsIOutputStream* aOutputStream, nsIMsgDBHdr* aNewHdr,
+    nsIMsgPluggableStore* aMsgStore, nsParseMailMessageState* aParseMsgState) {
+  uint32_t bytesWritten;
+  aOutputStream->Write(MSG_LINEBREAK, MSG_LINEBREAK_LEN, &bytesWritten);
+  if (aParseMsgState)
+    aParseMsgState->ParseAFolderLine(MSG_LINEBREAK, MSG_LINEBREAK_LEN);
+  return aMsgStore->FinishNewMessage(aOutputStream, aNewHdr);
+}
+
+NS_IMETHODIMP
+nsMsgLocalMailFolder::WarnIfLocalFileTooBig(nsIMsgWindow* aWindow,
+                                            int64_t aSpaceRequested,
+                                            bool* aTooBig) {
+  NS_ENSURE_ARG_POINTER(aTooBig);
+
+  *aTooBig = true;
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  nsresult rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool spaceAvailable = false;
+  // check if we have a reasonable amount of space left
+  rv = msgStore->HasSpaceAvailable(this, aSpaceRequested, &spaceAvailable);
+  if (NS_SUCCEEDED(rv) && spaceAvailable) {
+    *aTooBig = false;
+  } else if (rv == NS_ERROR_FILE_TOO_BIG) {
+    ThrowAlertMsg("mailboxTooLarge", aWindow);
+  } else {
+    ThrowAlertMsg("outOfDiskSpace", aWindow);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::FetchMsgPreviewText(
+    nsTArray<nsMsgKey> const& aKeysToFetch, nsIUrlListener* aUrlListener,
+    bool* aAsyncResults) {
+  NS_ENSURE_ARG_POINTER(aAsyncResults);
+
+  *aAsyncResults = false;
+  nsCOMPtr<nsIInputStream> inputStream;
+
+  for (uint32_t i = 0; i < aKeysToFetch.Length(); i++) {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    nsCString prevBody;
+    nsresult rv = GetMessageHeader(aKeysToFetch[i], getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // ignore messages that already have a preview body.
+    msgHdr->GetStringProperty("preview", prevBody);
+    if (!prevBody.IsEmpty()) continue;
+
+    rv = GetMsgInputStream(msgHdr, getter_AddRefs(inputStream));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = GetMsgPreviewTextFromStream(msgHdr, inputStream);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::AddKeywordsToMessages(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
+    const nsACString& aKeywords) {
+  nsresult rv = nsMsgDBFolder::AddKeywordsToMessages(aMessages, aKeywords);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return msgStore->ChangeKeywords(aMessages, aKeywords, true /* add */);
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::RemoveKeywordsFromMessages(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
+    const nsACString& aKeywords) {
+  nsresult rv = nsMsgDBFolder::RemoveKeywordsFromMessages(aMessages, aKeywords);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  rv = GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return msgStore->ChangeKeywords(aMessages, aKeywords, false /* remove */);
+}
+
+NS_IMETHODIMP nsMsgLocalMailFolder::UpdateNewMsgHdr(nsIMsgDBHdr* aOldHdr,
+                                                    nsIMsgDBHdr* aNewHdr) {
+  NS_ENSURE_ARG_POINTER(aOldHdr);
+  NS_ENSURE_ARG_POINTER(aNewHdr);
+  // Preserve any properties set on the message.
+  CopyPropertiesToMsgHdr(aNewHdr, aOldHdr, true);
+
+  // Preserve keywords manually, since they are set as don't preserve.
+  nsCString keywordString;
+  aOldHdr->GetStringProperty("keywords", keywordString);
+  aNewHdr->SetStringProperty("keywords", keywordString);
+
+  // If the junk score was set by the plugin, remove junkscore to force a new
+  // junk analysis, this time using the body.
+  nsCString junkScoreOrigin;
+  aOldHdr->GetStringProperty("junkscoreorigin", junkScoreOrigin);
+  if (junkScoreOrigin.EqualsLiteral("plugin"))
+    aNewHdr->SetStringProperty("junkscore", ""_ns);
+
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsLocalMailFolder.h b/comm/mailnews/local/src/nsLocalMailFolder.h
new file mode 100644
index 0000000000..247a7d459c
--- /dev/null
+++ b/comm/mailnews/local/src/nsLocalMailFolder.h
@@ -0,0 +1,285 @@
+/* -*- 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/. */
+
+/**
+   Interface for representing Local Mail folders.
+*/
+
+#ifndef nsMsgLocalMailFolder_h__
+#define nsMsgLocalMailFolder_h__
+
+#include "mozilla/Attributes.h"
+#include "nsMsgDBFolder.h" /* include the interface we are going to support */
+#include "nsICopyMessageListener.h"
+#include "nsMsgTxn.h"
+#include "nsIMsgMessageService.h"
+#include "nsIMsgPluggableStore.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgWindow.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsIMsgCopyServiceListener.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsISeekableStream.h"
+#include "nsIStringBundle.h"
+#include "nsLocalUndoTxn.h"
+
+#define COPY_BUFFER_SIZE 16384
+
+class nsParseMailMessageState;
+
+struct nsLocalMailCopyState {
+  nsLocalMailCopyState();
+  virtual ~nsLocalMailCopyState();
+
+  nsCOMPtr<nsIOutputStream> m_fileStream;
+  nsCOMPtr<nsIMsgPluggableStore> m_msgStore;
+  nsCOMPtr<nsISupports> m_srcSupport;
+  /// Source nsIMsgDBHdr instances.
+  nsTArray<RefPtr<nsIMsgDBHdr>> m_messages;
+  /// Destination nsIMsgDBHdr instances.
+  nsTArray<RefPtr<nsIMsgDBHdr>> m_destMessages;
+  RefPtr<nsLocalMoveCopyMsgTxn> m_undoMsgTxn;
+  nsCOMPtr<nsIMsgDBHdr> m_message;  // current copy message
+  nsMsgMessageFlagType m_flags;     // current copy message flags
+  RefPtr<nsParseMailMessageState> m_parseMsgState;
+  nsCOMPtr<nsIMsgCopyServiceListener> m_listener;
+  nsCOMPtr<nsIMsgWindow> m_msgWindow;
+  nsCOMPtr<nsIMsgDatabase> m_destDB;
+
+  // for displaying status;
+  nsCOMPtr<nsIMsgStatusFeedback> m_statusFeedback;
+  nsCOMPtr<nsIStringBundle> m_stringBundle;
+  int64_t m_lastProgressTime;
+
+  nsMsgKey m_curDstKey;
+  uint32_t m_curCopyIndex;
+  nsCOMPtr<nsIMsgMessageService> m_messageService;
+  /// The number of messages in m_messages.
+  uint32_t m_totalMsgCount;
+  char* m_dataBuffer;
+  uint32_t m_dataBufferSize;
+  uint32_t m_leftOver;
+  bool m_isMove;
+  bool m_isFolder;  // isFolder move/copy
+  bool m_dummyEnvelopeNeeded;
+  bool m_copyingMultipleMessages;
+  bool m_fromLineSeen;
+  bool m_allowUndo;
+  bool m_writeFailed;
+  bool m_notifyFolderLoaded;
+  bool m_wholeMsgInStream;
+  nsCString m_newMsgKeywords;
+  nsCOMPtr<nsIMsgDBHdr> m_newHdr;
+};
+
+struct nsLocalFolderScanState {
+  nsLocalFolderScanState();
+  ~nsLocalFolderScanState();
+
+  nsCOMPtr<nsIInputStream> m_inputStream;
+  nsCOMPtr<nsIMsgPluggableStore> m_msgStore;
+  nsCString m_header;
+  nsCString m_accountKey;
+  const char* m_uidl;  // memory is owned by m_header
+};
+
+class nsMsgLocalMailFolder : public nsMsgDBFolder,
+                             public nsIMsgLocalMailFolder,
+                             public nsICopyMessageListener {
+ public:
+  nsMsgLocalMailFolder(void);
+  NS_DECL_NSICOPYMESSAGELISTENER
+  NS_DECL_NSIMSGLOCALMAILFOLDER
+  NS_DECL_NSIJUNKMAILCLASSIFICATIONLISTENER
+  NS_DECL_ISUPPORTS_INHERITED
+
+  // nsIUrlListener methods
+  NS_IMETHOD OnStartRunningUrl(nsIURI* aUrl) override;
+  NS_IMETHOD OnStopRunningUrl(nsIURI* aUrl, nsresult aExitCode) override;
+
+  // nsIMsgFolder methods:
+  NS_IMETHOD GetSubFolders(nsTArray<RefPtr<nsIMsgFolder>>& folders) override;
+  NS_IMETHOD GetMsgDatabase(nsIMsgDatabase** aMsgDatabase) override;
+
+  NS_IMETHOD OnAnnouncerGoingAway(nsIDBChangeAnnouncer* instigator) override;
+  NS_IMETHOD UpdateFolder(nsIMsgWindow* aWindow) override;
+
+  NS_IMETHOD CreateSubfolder(const nsAString& folderName,
+                             nsIMsgWindow* msgWindow) override;
+
+  NS_IMETHOD Compact(nsIUrlListener* aListener,
+                     nsIMsgWindow* aMsgWindow) override;
+  NS_IMETHOD CompactAll(nsIUrlListener* aListener,
+                        nsIMsgWindow* aMsgWindow) override;
+  NS_IMETHOD EmptyTrash(nsIUrlListener* aListener) override;
+  NS_IMETHOD DeleteSelf(nsIMsgWindow* msgWindow) override;
+  NS_IMETHOD CreateStorageIfMissing(nsIUrlListener* urlListener) override;
+  NS_IMETHOD Rename(const nsAString& aNewName,
+                    nsIMsgWindow* msgWindow) override;
+  NS_IMETHOD RenameSubFolders(nsIMsgWindow* msgWindow,
+                              nsIMsgFolder* oldFolder) override;
+
+  NS_IMETHOD GetPrettyName(nsAString& prettyName)
+      override;  // Override of the base, for top-level mail folder
+  NS_IMETHOD SetPrettyName(const nsAString& aName) override;
+
+  NS_IMETHOD GetFolderURL(nsACString& url) override;
+
+  NS_IMETHOD GetManyHeadersToDownload(bool* retval) override;
+
+  NS_IMETHOD GetDeletable(bool* deletable) override;
+  NS_IMETHOD GetSizeOnDisk(int64_t* size) override;
+
+  NS_IMETHOD GetDBFolderInfoAndDB(nsIDBFolderInfo** folderInfo,
+                                  nsIMsgDatabase** db) override;
+
+  NS_IMETHOD DeleteMessages(nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
+                            nsIMsgWindow* msgWindow, bool deleteStorage,
+                            bool isMove, nsIMsgCopyServiceListener* listener,
+                            bool allowUndo) override;
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD CopyMessages(
+      nsIMsgFolder* srcFolder, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
+      bool isMove, nsIMsgWindow* msgWindow, nsIMsgCopyServiceListener* listener,
+      bool isFolder, bool allowUndo) override;
+  NS_IMETHOD CopyFolder(nsIMsgFolder* srcFolder, bool isMoveFolder,
+                        nsIMsgWindow* msgWindow,
+                        nsIMsgCopyServiceListener* listener) override;
+  NS_IMETHOD CopyFileMessage(nsIFile* aFile, nsIMsgDBHdr* msgToReplace,
+                             bool isDraftOrTemplate, uint32_t newMsgFlags,
+                             const nsACString& aNewMsgKeywords,
+                             nsIMsgWindow* msgWindow,
+                             nsIMsgCopyServiceListener* listener) override;
+
+  NS_IMETHOD AddMessageDispositionState(
+      nsIMsgDBHdr* aMessage, nsMsgDispositionState aDispositionFlag) override;
+  NS_IMETHOD MarkMessagesRead(const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
+                              bool aMarkRead) override;
+  NS_IMETHOD MarkMessagesFlagged(const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
+                                 bool aMarkFlagged) override;
+  NS_IMETHOD MarkAllMessagesRead(nsIMsgWindow* aMsgWindow) override;
+  NS_IMETHOD MarkThreadRead(nsIMsgThread* thread) override;
+  NS_IMETHOD GetNewMessages(nsIMsgWindow* aWindow,
+                            nsIUrlListener* aListener) override;
+  NS_IMETHOD NotifyCompactCompleted() override;
+  NS_IMETHOD Shutdown(bool shutdownChildren) override;
+
+  NS_IMETHOD WriteToFolderCacheElem(nsIMsgFolderCacheElement* element) override;
+  NS_IMETHOD ReadFromFolderCacheElem(
+      nsIMsgFolderCacheElement* element) override;
+
+  NS_IMETHOD GetName(nsAString& aName) override;
+
+  // Used when headers_only is TRUE
+  NS_IMETHOD DownloadMessagesForOffline(
+      nsTArray<RefPtr<nsIMsgDBHdr>> const& aMessages,
+      nsIMsgWindow* aWindow) override;
+  NS_IMETHOD HasMsgOffline(nsMsgKey msgKey, bool* result) override;
+  NS_IMETHOD GetLocalMsgStream(nsIMsgDBHdr* hdr,
+                               nsIInputStream** stream) override;
+  NS_IMETHOD FetchMsgPreviewText(nsTArray<nsMsgKey> const& aKeysToFetch,
+                                 nsIUrlListener* aUrlListener,
+                                 bool* aAsyncResults) override;
+  NS_IMETHOD AddKeywordsToMessages(
+      const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
+      const nsACString& aKeywords) override;
+  NS_IMETHOD RemoveKeywordsFromMessages(
+      const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
+      const nsACString& aKeywords) override;
+  NS_IMETHOD GetIncomingServerType(nsACString& serverType) override;
+
+ protected:
+  virtual ~nsMsgLocalMailFolder();
+  nsresult CreateChildFromURI(const nsACString& uri,
+                              nsIMsgFolder** folder) override;
+  nsresult CopyFolderAcrossServer(nsIMsgFolder* srcFolder,
+                                  nsIMsgWindow* msgWindow,
+                                  nsIMsgCopyServiceListener* listener,
+                                  bool moveMsgs);
+
+  nsresult CreateSubFolders(nsIFile* path);
+  nsresult GetTrashFolder(nsIMsgFolder** trashFolder);
+  nsresult WriteStartOfNewMessage();
+
+  // CreateSubfolder, but without the nsIMsgFolderListener notification
+  nsresult CreateSubfolderInternal(const nsAString& folderName,
+                                   nsIMsgWindow* msgWindow,
+                                   nsIMsgFolder** aNewFolder);
+
+  nsresult IsChildOfTrash(bool* result);
+  nsresult RecursiveSetDeleteIsMoveTrash(bool bVal);
+  nsresult ConfirmFolderDeletion(nsIMsgWindow* aMsgWindow,
+                                 nsIMsgFolder* aFolder, bool* aResult);
+
+  nsresult GetDatabase() override;
+  // this will set mDatabase, if successful. It will also create a .msf file
+  // for an empty local mail folder. It will leave invalid DBs in place, and
+  // return an error.
+  nsresult OpenDatabase();
+
+  // copy message helper
+  nsresult DisplayMoveCopyStatusMsg();
+
+  nsresult CopyMessageTo(nsISupports* message, nsIMsgWindow* msgWindow,
+                         bool isMove);
+
+  /**
+   * Checks if there's room in the target folder to copy message(s) into.
+   * If not, handles alerting the user, and sending the copy notifications.
+   */
+  bool CheckIfSpaceForCopy(nsIMsgWindow* msgWindow, nsIMsgFolder* srcFolder,
+                           nsISupports* srcSupports, bool isMove,
+                           int64_t totalMsgSize);
+
+  // copy multiple messages at a time from this folder
+  nsresult CopyMessagesTo(nsTArray<nsMsgKey>& keyArray,
+                          nsIMsgWindow* aMsgWindow, bool isMove);
+  nsresult InitCopyState(nsISupports* aSupport,
+                         nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
+                         bool isMove, nsIMsgCopyServiceListener* listener,
+                         nsIMsgWindow* msgWindow, bool isMoveFolder,
+                         bool allowUndo);
+  nsresult InitCopyMsgHdrAndFileStream();
+  // preserve message metadata when moving or copying messages
+  void CopyPropertiesToMsgHdr(nsIMsgDBHdr* destHdr, nsIMsgDBHdr* srcHdr,
+                              bool isMove);
+  virtual nsresult CreateBaseMessageURI(const nsACString& aURI) override;
+  nsresult ChangeKeywordForMessages(
+      nsTArray<RefPtr<nsIMsgDBHdr>> const& aMessages,
+      const nsACString& aKeyword, bool add);
+  bool GetDeleteFromServerOnMove();
+  void CopyHdrPropertiesWithSkipList(nsIMsgDBHdr* destHdr, nsIMsgDBHdr* srcHdr,
+                                     const nsCString& skipList);
+  nsresult FinishNewLocalMessage(nsIOutputStream* outputStream,
+                                 nsIMsgDBHdr* newHdr,
+                                 nsIMsgPluggableStore* msgStore,
+                                 nsParseMailMessageState* parseMsgState);
+
+ protected:
+  nsLocalMailCopyState* mCopyState;  // We only allow one of these at a time
+  nsCString mType;
+  bool mHaveReadNameFromDB;
+  bool mInitialized;
+  bool mCheckForNewMessagesAfterParsing;
+  bool m_parsingFolder;
+  nsCOMPtr<nsIUrlListener> mReparseListener;
+  nsTArray<nsMsgKey> mSpamKeysToMove;
+  nsresult setSubfolderFlag(const nsAString& aFolderName, uint32_t flags);
+
+  // state variables for DownloadMessagesForOffline
+
+  nsCOMArray<nsIMsgDBHdr> mDownloadMessages;
+  nsCOMPtr<nsIMsgWindow> mDownloadWindow;
+  nsMsgKey mDownloadSelectKey;
+  uint32_t mDownloadState;
+#define DOWNLOAD_STATE_NONE 0
+#define DOWNLOAD_STATE_INITED 1
+#define DOWNLOAD_STATE_GOTMSG 2
+#define DOWNLOAD_STATE_DIDSEL 3
+};
+
+#endif  // nsMsgLocalMailFolder_h__
diff --git a/comm/mailnews/local/src/nsLocalUndoTxn.cpp b/comm/mailnews/local/src/nsLocalUndoTxn.cpp
new file mode 100644
index 0000000000..73bda9dcec
--- /dev/null
+++ b/comm/mailnews/local/src/nsLocalUndoTxn.cpp
@@ -0,0 +1,495 @@
+/* -*- 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 "nsIMsgHdr.h"
+#include "nsLocalUndoTxn.h"
+#include "nsImapCore.h"
+#include "nsIImapService.h"
+#include "nsIUrlListener.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgMailSession.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsThreadUtils.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgHdr.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "nsMsgDBFolder.h"
+
+NS_IMPL_ISUPPORTS_INHERITED(nsLocalMoveCopyMsgTxn, nsMsgTxn, nsIFolderListener)
+
+nsLocalMoveCopyMsgTxn::nsLocalMoveCopyMsgTxn()
+    : m_srcIsImap4(false), m_canUndelete(false) {}
+
+nsLocalMoveCopyMsgTxn::~nsLocalMoveCopyMsgTxn() {}
+
+nsresult nsLocalMoveCopyMsgTxn::Init(nsIMsgFolder* srcFolder,
+                                     nsIMsgFolder* dstFolder, bool isMove) {
+  nsresult rv;
+  rv = SetSrcFolder(srcFolder);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetDstFolder(dstFolder);
+  NS_ENSURE_SUCCESS(rv, rv);
+  m_isMove = isMove;
+
+  mUndoFolderListener = nullptr;
+
+  nsCString protocolType;
+  rv = srcFolder->GetURI(protocolType);
+  protocolType.SetLength(protocolType.FindChar(':'));
+  if (protocolType.LowerCaseEqualsLiteral("imap")) m_srcIsImap4 = true;
+  return nsMsgTxn::Init();
+}
+nsresult nsLocalMoveCopyMsgTxn::GetSrcIsImap(bool* isImap) {
+  *isImap = m_srcIsImap4;
+  return NS_OK;
+}
+nsresult nsLocalMoveCopyMsgTxn::SetSrcFolder(nsIMsgFolder* srcFolder) {
+  nsresult rv = NS_ERROR_NULL_POINTER;
+  if (srcFolder) m_srcFolder = do_GetWeakReference(srcFolder, &rv);
+  return rv;
+}
+
+nsresult nsLocalMoveCopyMsgTxn::SetDstFolder(nsIMsgFolder* dstFolder) {
+  nsresult rv = NS_ERROR_NULL_POINTER;
+  if (dstFolder) m_dstFolder = do_GetWeakReference(dstFolder, &rv);
+  return rv;
+}
+
+nsresult nsLocalMoveCopyMsgTxn::AddSrcKey(nsMsgKey aKey) {
+  m_srcKeyArray.AppendElement(aKey);
+  return NS_OK;
+}
+
+nsresult nsLocalMoveCopyMsgTxn::AddDstKey(nsMsgKey aKey) {
+  m_dstKeyArray.AppendElement(aKey);
+  return NS_OK;
+}
+
+nsresult nsLocalMoveCopyMsgTxn::AddDstMsgSize(uint32_t msgSize) {
+  m_dstSizeArray.AppendElement(msgSize);
+  return NS_OK;
+}
+
+nsresult nsLocalMoveCopyMsgTxn::UndoImapDeleteFlag(nsIMsgFolder* folder,
+                                                   nsTArray<nsMsgKey>& keyArray,
+                                                   bool deleteFlag) {
+  nsresult rv = NS_ERROR_FAILURE;
+  if (m_srcIsImap4) {
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIUrlListener> urlListener;
+    nsCString msgIds;
+    uint32_t i, count = keyArray.Length();
+    urlListener = do_QueryInterface(folder, &rv);
+    for (i = 0; i < count; i++) {
+      if (!msgIds.IsEmpty()) msgIds.Append(',');
+      msgIds.AppendInt((int32_t)keyArray[i]);
+    }
+    // This is to make sure that we are in the selected state
+    // when executing the imap url; we don't want to load the
+    // folder so use lite select to do the trick
+    rv = imapService->LiteSelectFolder(folder, urlListener, nullptr, nullptr);
+    if (!deleteFlag)
+      rv = imapService->AddMessageFlags(folder, urlListener, msgIds,
+                                        kImapMsgDeletedFlag, true);
+    else
+      rv = imapService->SubtractMessageFlags(folder, urlListener, msgIds,
+                                             kImapMsgDeletedFlag, true);
+    if (NS_SUCCEEDED(rv) && m_msgWindow) folder->UpdateFolder(m_msgWindow);
+    rv = NS_OK;  // always return NS_OK to indicate that the src is imap
+  } else
+    rv = NS_ERROR_FAILURE;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsLocalMoveCopyMsgTxn::UndoTransaction() {
+  nsresult rv;
+  nsCOMPtr<nsIMsgDatabase> dstDB;
+
+  nsCOMPtr<nsIMsgFolder> dstFolder = do_QueryReferent(m_dstFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgLocalMailFolder> dstlocalMailFolder =
+      do_QueryReferent(m_dstFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  dstlocalMailFolder->GetDatabaseWOReparse(getter_AddRefs(dstDB));
+
+  if (!dstDB) {
+    // This will listen for the db reparse finishing, and the corresponding
+    // FolderLoadedNotification. When it gets that, it will then call
+    // UndoTransactionInternal.
+    mUndoFolderListener = new nsLocalUndoFolderListener(this, dstFolder);
+    if (!mUndoFolderListener) return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(mUndoFolderListener);
+
+    nsCOMPtr<nsIMsgMailSession> mailSession =
+        do_GetService("@mozilla.org/messenger/services/session;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = mailSession->AddFolderListener(mUndoFolderListener,
+                                        nsIFolderListener::event);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = dstFolder->GetMsgDatabase(getter_AddRefs(dstDB));
+    NS_ENSURE_SUCCESS(rv, rv);
+  } else
+    rv = UndoTransactionInternal();
+  return rv;
+}
+
+nsresult nsLocalMoveCopyMsgTxn::UndoTransactionInternal() {
+  nsresult rv = NS_ERROR_FAILURE;
+
+  if (mUndoFolderListener) {
+    nsCOMPtr<nsIMsgMailSession> mailSession =
+        do_GetService("@mozilla.org/messenger/services/session;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = mailSession->RemoveFolderListener(mUndoFolderListener);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    NS_RELEASE(mUndoFolderListener);
+    mUndoFolderListener = nullptr;
+  }
+
+  nsCOMPtr<nsIMsgDatabase> srcDB;
+  nsCOMPtr<nsIMsgDatabase> dstDB;
+  nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryReferent(m_srcFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> dstFolder = do_QueryReferent(m_dstFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
+  if (NS_FAILED(rv)) return rv;
+
+  rv = dstFolder->GetMsgDatabase(getter_AddRefs(dstDB));
+  if (NS_FAILED(rv)) return rv;
+
+  uint32_t count = m_srcKeyArray.Length();
+  uint32_t i;
+
+  // protect against a bogus undo txn without any source keys
+  // see bug #179856 for details
+  NS_ASSERTION(count, "no source keys");
+  if (!count) return NS_ERROR_UNEXPECTED;
+
+  if (m_isMove) {
+    if (m_srcIsImap4) {
+      bool deleteFlag =
+          true;  // message has been deleted -we are trying to undo it
+      CheckForToggleDelete(srcFolder, m_srcKeyArray[0],
+                           &deleteFlag);  // there could have been a toggle.
+      rv = UndoImapDeleteFlag(srcFolder, m_srcKeyArray, deleteFlag);
+    } else if (m_canUndelete) {
+      nsTArray<RefPtr<nsIMsgDBHdr>> srcMessages(count);
+      nsTArray<RefPtr<nsIMsgDBHdr>> destMessages(count);
+
+      for (i = 0; i < count; i++) {
+        nsCOMPtr<nsIMsgDBHdr> oldHdr;
+        rv = dstDB->GetMsgHdrForKey(m_dstKeyArray[i], getter_AddRefs(oldHdr));
+        NS_ASSERTION(oldHdr, "fatal ... cannot get old msg header");
+        if (NS_SUCCEEDED(rv) && oldHdr) {
+          nsCOMPtr<nsIMsgDBHdr> newHdr;
+          rv = srcDB->CopyHdrFromExistingHdr(m_srcKeyArray[i], oldHdr, true,
+                                             getter_AddRefs(newHdr));
+          NS_ASSERTION(newHdr, "fatal ... cannot create new msg header");
+          if (NS_SUCCEEDED(rv) && newHdr) {
+            srcDB->UndoDelete(newHdr);
+            srcMessages.AppendElement(newHdr);
+            // (we want to keep these two lists in sync)
+            destMessages.AppendElement(oldHdr);
+          }
+        }
+      }
+
+      nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+          do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+      if (notifier) {
+        // Remember that we're actually moving things back from the destination
+        //  to the source!
+        notifier->NotifyMsgsMoveCopyCompleted(true, destMessages, srcFolder,
+                                              srcMessages);
+      }
+
+      nsCOMPtr<nsIMsgLocalMailFolder> localFolder =
+          do_QueryInterface(srcFolder);
+      if (localFolder) {
+        localFolder->MarkMsgsOnPop3Server(srcMessages,
+                                          POP3_NONE /*deleteMsgs*/);
+      }
+    } else  // undoing a move means moving the messages back.
+    {
+      nsTArray<RefPtr<nsIMsgDBHdr>> dstMessages(m_dstKeyArray.Length());
+      m_numHdrsCopied = 0;
+      m_srcKeyArray.Clear();
+      for (i = 0; i < count; i++) {
+        // GetMsgHdrForKey is not a test for whether the key exists, so check.
+        bool hasKey = false;
+        dstDB->ContainsKey(m_dstKeyArray[i], &hasKey);
+        nsCOMPtr<nsIMsgDBHdr> dstHdr;
+        if (hasKey)
+          dstDB->GetMsgHdrForKey(m_dstKeyArray[i], getter_AddRefs(dstHdr));
+        if (dstHdr) {
+          nsCString messageId;
+          dstHdr->GetMessageId(getter_Copies(messageId));
+          dstMessages.AppendElement(dstHdr);
+          m_copiedMsgIds.AppendElement(messageId);
+        } else {
+          NS_WARNING("Cannot get old msg header");
+        }
+      }
+      if (m_copiedMsgIds.Length()) {
+        srcFolder->AddFolderListener(this);
+        m_undoing = true;
+        return srcFolder->CopyMessages(dstFolder, dstMessages, true, nullptr,
+                                       nullptr, false, false);
+      } else {
+        // Nothing to do, probably because original messages were deleted.
+        NS_WARNING("Undo did not find any messages to move");
+      }
+    }
+    srcDB->SetSummaryValid(true);
+  }
+
+  dstDB->DeleteMessages(m_dstKeyArray, nullptr);
+  dstDB->SetSummaryValid(true);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsLocalMoveCopyMsgTxn::RedoTransaction() {
+  nsresult rv;
+  nsCOMPtr<nsIMsgDatabase> srcDB;
+  nsCOMPtr<nsIMsgDatabase> dstDB;
+
+  nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryReferent(m_srcFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> dstFolder = do_QueryReferent(m_dstFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
+  if (NS_FAILED(rv)) return rv;
+  rv = dstFolder->GetMsgDatabase(getter_AddRefs(dstDB));
+  if (NS_FAILED(rv)) return rv;
+
+  uint32_t count = m_srcKeyArray.Length();
+  uint32_t i;
+  nsCOMPtr<nsIMsgDBHdr> oldHdr;
+  nsCOMPtr<nsIMsgDBHdr> newHdr;
+
+  nsTArray<RefPtr<nsIMsgDBHdr>> srcMessages(m_srcKeyArray.Length());
+  for (i = 0; i < count; i++) {
+    rv = srcDB->GetMsgHdrForKey(m_srcKeyArray[i], getter_AddRefs(oldHdr));
+    NS_ASSERTION(oldHdr, "fatal ... cannot get old msg header");
+
+    if (NS_SUCCEEDED(rv) && oldHdr) {
+      srcMessages.AppendElement(oldHdr);
+
+      if (m_canUndelete) {
+        rv = dstDB->CopyHdrFromExistingHdr(m_dstKeyArray[i], oldHdr, true,
+                                           getter_AddRefs(newHdr));
+        NS_ASSERTION(newHdr, "fatal ... cannot get new msg header");
+        if (NS_SUCCEEDED(rv) && newHdr) {
+          if (i < m_dstSizeArray.Length())
+            rv = newHdr->SetMessageSize(m_dstSizeArray[i]);
+          dstDB->UndoDelete(newHdr);
+        }
+      }
+    }
+  }
+  dstDB->SetSummaryValid(true);
+
+  if (m_isMove) {
+    if (m_srcIsImap4) {
+      // protect against a bogus undo txn without any source keys
+      // see bug #179856 for details
+      NS_ASSERTION(!m_srcKeyArray.IsEmpty(), "no source keys");
+      if (m_srcKeyArray.IsEmpty()) return NS_ERROR_UNEXPECTED;
+
+      bool deleteFlag = false;  // message is un-deleted- we are trying to redo
+      CheckForToggleDelete(srcFolder, m_srcKeyArray[0],
+                           &deleteFlag);  // there could have been a toggle
+      rv = UndoImapDeleteFlag(srcFolder, m_srcKeyArray, deleteFlag);
+    } else if (m_canUndelete) {
+      nsCOMPtr<nsIMsgLocalMailFolder> localFolder =
+          do_QueryInterface(srcFolder);
+      if (localFolder) {
+        localFolder->MarkMsgsOnPop3Server(srcMessages,
+                                          POP3_DELETE /*deleteMsgs*/);
+      }
+
+      rv = srcDB->DeleteMessages(m_srcKeyArray, nullptr);
+      srcDB->SetSummaryValid(true);
+    } else {
+      nsCOMPtr<nsIMsgDBHdr> srcHdr;
+      m_numHdrsCopied = 0;
+      m_dstKeyArray.Clear();
+      for (i = 0; i < count; i++) {
+        srcDB->GetMsgHdrForKey(m_srcKeyArray[i], getter_AddRefs(srcHdr));
+        NS_ASSERTION(srcHdr, "fatal ... cannot get old msg header");
+        if (srcHdr) {
+          nsCString messageId;
+          srcHdr->GetMessageId(getter_Copies(messageId));
+          m_copiedMsgIds.AppendElement(messageId);
+        }
+      }
+      dstFolder->AddFolderListener(this);
+      m_undoing = false;
+      return dstFolder->CopyMessages(srcFolder, srcMessages, true, nullptr,
+                                     nullptr, false, false);
+    }
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnFolderAdded(nsIMsgFolder* parent,
+                                                   nsIMsgFolder* child) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnMessageAdded(nsIMsgFolder* parent,
+                                                    nsIMsgDBHdr* msgHdr) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder =
+      do_QueryReferent(m_undoing ? m_srcFolder : m_dstFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCString messageId;
+  msgHdr->GetMessageId(getter_Copies(messageId));
+  if (m_copiedMsgIds.Contains(messageId)) {
+    nsMsgKey msgKey;
+    msgHdr->GetMessageKey(&msgKey);
+    if (m_undoing)
+      m_srcKeyArray.AppendElement(msgKey);
+    else
+      m_dstKeyArray.AppendElement(msgKey);
+    if (++m_numHdrsCopied == m_copiedMsgIds.Length()) {
+      folder->RemoveFolderListener(this);
+      m_copiedMsgIds.Clear();
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnFolderRemoved(nsIMsgFolder* parent,
+                                                     nsIMsgFolder* child) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnMessageRemoved(nsIMsgFolder* parent,
+                                                      nsIMsgDBHdr* msg) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnFolderPropertyChanged(
+    nsIMsgFolder* item, const nsACString& property, const nsACString& oldValue,
+    const nsACString& newValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnFolderIntPropertyChanged(
+    nsIMsgFolder* item, const nsACString& property, int64_t oldValue,
+    int64_t newValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnFolderBoolPropertyChanged(
+    nsIMsgFolder* item, const nsACString& property, bool oldValue,
+    bool newValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnFolderUnicharPropertyChanged(
+    nsIMsgFolder* item, const nsACString& property, const nsAString& oldValue,
+    const nsAString& newValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnFolderPropertyFlagChanged(
+    nsIMsgDBHdr* item, const nsACString& property, uint32_t oldFlag,
+    uint32_t newFlag) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalMoveCopyMsgTxn::OnFolderEvent(nsIMsgFolder* aItem,
+                                                   const nsACString& aEvent) {
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsLocalUndoFolderListener, nsIFolderListener)
+
+nsLocalUndoFolderListener::nsLocalUndoFolderListener(
+    nsLocalMoveCopyMsgTxn* aTxn, nsIMsgFolder* aFolder) {
+  mTxn = aTxn;
+  mFolder = aFolder;
+}
+
+nsLocalUndoFolderListener::~nsLocalUndoFolderListener() {}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnFolderAdded(nsIMsgFolder* parent,
+                                                       nsIMsgFolder* child) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnMessageAdded(nsIMsgFolder* parent,
+                                                        nsIMsgDBHdr* msg) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnFolderRemoved(nsIMsgFolder* parent,
+                                                         nsIMsgFolder* child) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnMessageRemoved(nsIMsgFolder* parent,
+                                                          nsIMsgDBHdr* msg) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnFolderPropertyChanged(
+    nsIMsgFolder* item, const nsACString& property, const nsACString& oldValue,
+    const nsACString& newValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnFolderIntPropertyChanged(
+    nsIMsgFolder* item, const nsACString& property, int64_t oldValue,
+    int64_t newValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnFolderBoolPropertyChanged(
+    nsIMsgFolder* item, const nsACString& property, bool oldValue,
+    bool newValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnFolderUnicharPropertyChanged(
+    nsIMsgFolder* item, const nsACString& property, const nsAString& oldValue,
+    const nsAString& newValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnFolderPropertyFlagChanged(
+    nsIMsgDBHdr* item, const nsACString& property, uint32_t oldFlag,
+    uint32_t newFlag) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsLocalUndoFolderListener::OnFolderEvent(
+    nsIMsgFolder* aItem, const nsACString& aEvent) {
+  if (mTxn && mFolder && aItem == mFolder) {
+    if (aEvent.Equals(kFolderLoaded)) return mTxn->UndoTransactionInternal();
+  }
+
+  return NS_ERROR_FAILURE;
+}
diff --git a/comm/mailnews/local/src/nsLocalUndoTxn.h b/comm/mailnews/local/src/nsLocalUndoTxn.h
new file mode 100644
index 0000000000..f9f8244193
--- /dev/null
+++ b/comm/mailnews/local/src/nsLocalUndoTxn.h
@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsLocalUndoTxn_h__
+#define nsLocalUndoTxn_h__
+
+#include "mozilla/Attributes.h"
+#include "msgCore.h"
+#include "nsIMsgFolder.h"
+#include "nsMailboxService.h"
+#include "nsMsgTxn.h"
+#include "MailNewsTypes.h"
+#include "nsTArray.h"
+#include "nsCOMPtr.h"
+#include "nsIFolderListener.h"
+#include "nsIWeakReferenceUtils.h"
+
+class nsLocalUndoFolderListener;
+
+class nsLocalMoveCopyMsgTxn : public nsIFolderListener, public nsMsgTxn {
+ public:
+  nsLocalMoveCopyMsgTxn();
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIFOLDERLISTENER
+
+  // overloading nsITransaction methods
+  NS_IMETHOD UndoTransaction(void) override;
+  NS_IMETHOD RedoTransaction(void) override;
+
+  // helper
+  nsresult AddSrcKey(nsMsgKey aKey);
+  nsresult AddDstKey(nsMsgKey aKey);
+  nsresult AddDstMsgSize(uint32_t msgSize);
+  nsresult SetSrcFolder(nsIMsgFolder* srcFolder);
+  nsresult GetSrcIsImap(bool* isImap);
+  nsresult SetDstFolder(nsIMsgFolder* dstFolder);
+  nsresult Init(nsIMsgFolder* srcFolder, nsIMsgFolder* dstFolder, bool isMove);
+  nsresult UndoImapDeleteFlag(nsIMsgFolder* aFolder,
+                              nsTArray<nsMsgKey>& aKeyArray, bool deleteFlag);
+  nsresult UndoTransactionInternal();
+  // If the store using this undo transaction can "undelete" a message,
+  // it will call this function on the transaction; This makes undo/redo
+  // easy because message keys don't change after undo/redo. Otherwise,
+  // we need to adjust the src or dst keys after every undo/redo action
+  // to note the new keys.
+  void SetCanUndelete(bool canUndelete) { m_canUndelete = canUndelete; }
+
+ private:
+  virtual ~nsLocalMoveCopyMsgTxn();
+  nsWeakPtr m_srcFolder;
+  nsTArray<nsMsgKey> m_srcKeyArray;  // used when src is local or imap
+  nsWeakPtr m_dstFolder;
+  nsTArray<nsMsgKey> m_dstKeyArray;
+  bool m_isMove;
+  bool m_srcIsImap4;
+  bool m_canUndelete;
+  nsTArray<uint32_t> m_dstSizeArray;
+  bool m_undoing;  // if false, re-doing
+  uint32_t m_numHdrsCopied;
+  nsTArray<nsCString> m_copiedMsgIds;
+  nsLocalUndoFolderListener* mUndoFolderListener;
+};
+
+class nsLocalUndoFolderListener : public nsIFolderListener {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIFOLDERLISTENER
+
+  nsLocalUndoFolderListener(nsLocalMoveCopyMsgTxn* aTxn, nsIMsgFolder* aFolder);
+
+ private:
+  virtual ~nsLocalUndoFolderListener();
+  nsLocalMoveCopyMsgTxn* mTxn;
+  nsIMsgFolder* mFolder;
+};
+
+#endif
diff --git a/comm/mailnews/local/src/nsLocalUtils.cpp b/comm/mailnews/local/src/nsLocalUtils.cpp
new file mode 100644
index 0000000000..2dc96635c0
--- /dev/null
+++ b/comm/mailnews/local/src/nsLocalUtils.cpp
@@ -0,0 +1,208 @@
+/* -*- 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 "nsLocalUtils.h"
+#include "prsystem.h"
+#include "nsCOMPtr.h"
+#include "prmem.h"
+// stuff for temporary root folder hack
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsNativeCharsetUtils.h"
+
+#include "nsMsgUtils.h"
+#include "nsNetCID.h"
+#include "nsIURIMutator.h"
+
+// it would be really cool to:
+// - cache the last hostname->path match
+// - if no such server exists, behave like an old-style mailbox URL
+// (i.e. return the mail.directory preference or something)
+static nsresult nsGetMailboxServer(const char* uriStr,
+                                   nsIMsgIncomingServer** aResult) {
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIURL> url;
+  rv = NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID)
+           .SetSpec(nsDependentCString(uriStr))
+           .Finalize(url);
+  if (NS_FAILED(rv)) return rv;
+
+  // retrieve the AccountManager
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  if (NS_FAILED(rv)) return rv;
+
+  // find all local mail "no servers" matching the given hostname
+  nsCOMPtr<nsIMsgIncomingServer> none_server;
+  rv = NS_MutateURI(url).SetScheme("none"_ns).Finalize(url);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // No unescaping of username or hostname done here.
+  // The unescaping is done inside of FindServerByURI
+  rv = accountManager->FindServerByURI(url, getter_AddRefs(none_server));
+  if (NS_SUCCEEDED(rv)) {
+    none_server.forget(aResult);
+    return rv;
+  }
+
+  // if that fails, look for the rss hosts matching the given hostname
+  nsCOMPtr<nsIMsgIncomingServer> rss_server;
+  rv = NS_MutateURI(url).SetScheme("rss"_ns).Finalize(url);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = accountManager->FindServerByURI(url, getter_AddRefs(rss_server));
+  if (NS_SUCCEEDED(rv)) {
+    rss_server.forget(aResult);
+    return rv;
+  }
+
+  // if that fails, look for the pop hosts matching the given hostname
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  if (NS_FAILED(rv)) {
+    rv = NS_MutateURI(url).SetScheme("pop3"_ns).Finalize(url);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = accountManager->FindServerByURI(url, getter_AddRefs(server));
+
+    // if we can't find a pop server, maybe it's a local message
+    // in an imap hierarchy. look for an imap server.
+    if (NS_FAILED(rv)) {
+      rv = NS_MutateURI(url).SetScheme("imap"_ns).Finalize(url);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = accountManager->FindServerByURI(url, getter_AddRefs(server));
+    }
+  }
+  if (NS_SUCCEEDED(rv)) {
+    server.forget(aResult);
+    return rv;
+  }
+
+  // If you fail after looking at all "pop3", "none" servers, you fail.
+  return rv;
+}
+
+static nsresult nsLocalURI2Server(const char* uriStr,
+                                  nsIMsgIncomingServer** aResult) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = nsGetMailboxServer(uriStr, getter_AddRefs(server));
+  server.forget(aResult);
+  return rv;
+}
+
+// given rootURI and rootURI##folder, return on-disk path of folder
+nsresult nsLocalURI2Path(const char* rootURI, const char* uriStr,
+                         nsCString& pathResult) {
+  nsresult rv;
+
+  // verify that rootURI starts with "mailbox:/" or "mailbox-message:/"
+  if ((PL_strcmp(rootURI, kMailboxRootURI) != 0) &&
+      (PL_strcmp(rootURI, kMailboxMessageRootURI) != 0)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // verify that uristr starts with rooturi
+  nsAutoCString uri(uriStr);
+  if (uri.Find(rootURI) != 0) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = nsLocalURI2Server(uriStr, getter_AddRefs(server));
+
+  if (NS_FAILED(rv)) return rv;
+
+  // now ask the server what it's root is
+  // and begin pathResult with the mailbox root
+  nsCOMPtr<nsIFile> localPath;
+  rv = server->GetLocalPath(getter_AddRefs(localPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#ifdef XP_WIN
+  nsString path = localPath->NativePath();
+  nsCString localNativePath;
+  NS_CopyUnicodeToNative(path, localNativePath);
+#else
+  nsCString localNativePath = localPath->NativePath();
+#endif
+  nsEscapeNativePath(localNativePath);
+  pathResult = localNativePath.get();
+  const char* curPos = uriStr + PL_strlen(rootURI);
+  if (curPos) {
+    // advance past hostname
+    while ((*curPos) == '/') curPos++;
+    while (*curPos && (*curPos) != '/') curPos++;
+
+    nsAutoCString newPath("");
+
+    // Unescape folder name
+    nsCString unescapedStr;
+    MsgUnescapeString(nsDependentCString(curPos), 0, unescapedStr);
+    NS_MsgCreatePathStringFromFolderURI(unescapedStr.get(), newPath, "none"_ns);
+
+    pathResult.Append('/');
+    pathResult.Append(newPath);
+  }
+
+  return NS_OK;
+}
+
+/* parses LocalMessageURI
+ * mailbox-message://folder1/folder2#123?header=none or
+ * mailbox-message://folder1/folder2#1234&part=1.2
+ *
+ * puts folder URI in folderURI (mailbox://folder1/folder2)
+ * message key number in key
+ */
+nsresult nsParseLocalMessageURI(const nsACString& uri, nsCString& folderURI,
+                                nsMsgKey* key) {
+  if (!key) return NS_ERROR_NULL_POINTER;
+
+  const nsPromiseFlatCString& uriStr = PromiseFlatCString(uri);
+  int32_t keySeparator = uriStr.FindChar('#');
+  if (keySeparator != -1) {
+    int32_t keyEndSeparator = MsgFindCharInSet(uriStr, "?&", keySeparator);
+    folderURI = StringHead(uriStr, keySeparator);
+    folderURI.Cut(7, 8);  // cut out the -message part of mailbox-message:
+
+    nsAutoCString keyStr;
+    if (keyEndSeparator != -1)
+      keyStr = Substring(uriStr, keySeparator + 1,
+                         keyEndSeparator - (keySeparator + 1));
+    else
+      keyStr = StringTail(uriStr, uriStr.Length() - (keySeparator + 1));
+
+    *key = msgKeyFromInt(ParseUint64Str(keyStr.get()));
+    return NS_OK;
+  }
+  return NS_ERROR_FAILURE;
+}
+
+nsresult nsBuildLocalMessageURI(const nsACString& baseURI, nsMsgKey key,
+                                nsACString& uri) {
+  // need to convert mailbox://hostname/.. to mailbox-message://hostname/..
+  uri.Append(baseURI);
+  uri.Append('#');
+  uri.AppendInt(key);
+  return NS_OK;
+}
+
+nsresult nsCreateLocalBaseMessageURI(const nsACString& baseURI,
+                                     nsCString& baseMessageURI) {
+  nsAutoCString tailURI(baseURI);
+
+  // chop off mailbox:/
+  if (tailURI.Find(kMailboxRootURI) == 0)
+    tailURI.Cut(0, PL_strlen(kMailboxRootURI));
+
+  baseMessageURI = kMailboxMessageRootURI;
+  baseMessageURI += tailURI;
+
+  return NS_OK;
+}
+
+void nsEscapeNativePath(nsCString& nativePath) {
+#if defined(XP_WIN)
+  nativePath.Insert('/', 0);
+  nativePath.ReplaceChar('\\', '/');
+#endif
+}
diff --git a/comm/mailnews/local/src/nsLocalUtils.h b/comm/mailnews/local/src/nsLocalUtils.h
new file mode 100644
index 0000000000..0208be8495
--- /dev/null
+++ b/comm/mailnews/local/src/nsLocalUtils.h
@@ -0,0 +1,29 @@
+/* -*- 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 NS_LOCALUTILS_H
+#define NS_LOCALUTILS_H
+
+#include "nsString.h"
+#include "MailNewsTypes2.h"
+
+static const char kMailboxRootURI[] = "mailbox:/";
+static const char kMailboxMessageRootURI[] = "mailbox-message:/";
+
+nsresult nsLocalURI2Path(const char* rootURI, const char* uriStr,
+                         nsCString& pathResult);
+
+nsresult nsParseLocalMessageURI(const nsACString& uri, nsCString& folderURI,
+                                nsMsgKey* key);
+
+nsresult nsBuildLocalMessageURI(const nsACString& baseURI, nsMsgKey key,
+                                nsACString& uri);
+
+nsresult nsCreateLocalBaseMessageURI(const nsACString& baseURI,
+                                     nsCString& baseMessageURI);
+
+void nsEscapeNativePath(nsCString& nativePath);
+
+#endif  // NS_LOCALUTILS_H
diff --git a/comm/mailnews/local/src/nsMailboxProtocol.cpp b/comm/mailnews/local/src/nsMailboxProtocol.cpp
new file mode 100644
index 0000000000..389de0a93e
--- /dev/null
+++ b/comm/mailnews/local/src/nsMailboxProtocol.cpp
@@ -0,0 +1,657 @@
+/* -*- 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 "nsMailboxProtocol.h"
+#include "nscore.h"
+#include "nsIInputStreamPump.h"
+#include "nsIMsgHdr.h"
+#include "nsMsgLineBuffer.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMsgFolder.h"
+#include "nsICopyMessageStreamListener.h"
+#include "prtime.h"
+#include "mozilla/Logging.h"
+#include "mozilla/SlicedInputStream.h"
+#include "prerror.h"
+#include "prprf.h"
+#include "nspr.h"
+#include "nsIStreamTransportService.h"
+#include "nsIStreamConverterService.h"
+#include "nsNetUtil.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgWindow.h"
+#include "nsISeekableStream.h"
+#include "nsStreamUtils.h"
+
+using namespace mozilla;
+
+static LazyLogModule MAILBOX("Mailbox");
+
+/* 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)
+
+nsMailboxProtocol::nsMailboxProtocol(nsIURI* aURI)
+    : nsMsgProtocol(aURI),
+      m_mailboxAction(nsIMailboxUrl::ActionParseMailbox),
+      m_nextState(MAILBOX_UNINITIALIZED),
+      m_initialState(MAILBOX_UNINITIALIZED),
+      mCurrentProgress(0) {}
+
+nsMailboxProtocol::~nsMailboxProtocol() {}
+
+nsresult nsMailboxProtocol::OpenMultipleMsgTransport(uint64_t offset,
+                                                     int64_t size) {
+  nsresult rv;
+
+  nsCOMPtr<nsIStreamTransportService> serv =
+      do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIInputStream> clonedStream;
+  nsCOMPtr<nsIInputStream> replacementStream;
+  rv = NS_CloneInputStream(m_multipleMsgMoveCopyStream,
+                           getter_AddRefs(clonedStream),
+                           getter_AddRefs(replacementStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (replacementStream) {
+    // If m_multipleMsgMoveCopyStream is not clonable, NS_CloneInputStream
+    // will clone it using a pipe. In order to keep the copy alive and working,
+    // we have to replace the original stream with the replacement.
+    m_multipleMsgMoveCopyStream = replacementStream.forget();
+  }
+  // XXX 64-bit
+  // This can be called with size == -1 which means "read as much as we can".
+  // We pass this on as UINT64_MAX, which is in fact uint64_t(-1).
+  RefPtr<SlicedInputStream> slicedStream = new SlicedInputStream(
+      clonedStream.forget(), offset, size == -1 ? UINT64_MAX : uint64_t(size));
+  // Always close the sliced stream when done, we still have the original.
+  rv = serv->CreateInputTransport(slicedStream, true,
+                                  getter_AddRefs(m_transport));
+
+  return rv;
+}
+
+nsresult nsMailboxProtocol::Initialize(nsIURI* aURL) {
+  NS_ASSERTION(aURL, "invalid URL passed into MAILBOX Protocol");
+  nsresult rv = NS_OK;
+  if (aURL) {
+    m_runningUrl = do_QueryInterface(aURL, &rv);
+    if (NS_SUCCEEDED(rv) && m_runningUrl) {
+      nsCOMPtr<nsIMsgWindow> window;
+      rv = m_runningUrl->GetMailboxAction(&m_mailboxAction);
+      // clear stopped flag on msg window, because we care.
+      nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl);
+      if (mailnewsUrl) {
+        mailnewsUrl->GetMsgWindow(getter_AddRefs(window));
+        if (window) window->SetStopped(false);
+      }
+
+      if (m_mailboxAction == nsIMailboxUrl::ActionParseMailbox) {
+        // Set the length of the file equal to the max progress
+        nsCOMPtr<nsIFile> file;
+        GetFileFromURL(aURL, getter_AddRefs(file));
+        if (file) {
+          int64_t fileSize = 0;
+          file->GetFileSize(&fileSize);
+          mailnewsUrl->SetMaxProgress(fileSize);
+        }
+
+        rv =
+            OpenFileSocket(aURL, 0, -1 /* read in all the bytes in the file */);
+      } else {
+        if (RunningMultipleMsgUrl()) {
+          // if we're running multiple msg url, we clear the event sink because
+          // the multiple msg urls will handle setting the progress.
+          mProgressEventSink = nullptr;
+        }
+
+        nsCOMPtr<nsIMsgMessageUrl> msgUrl =
+            do_QueryInterface(m_runningUrl, &rv);
+        if (NS_SUCCEEDED(rv)) {
+          nsCOMPtr<nsIMsgFolder> folder;
+          nsCOMPtr<nsIMsgDBHdr> msgHdr;
+          rv = msgUrl->GetMessageHeader(getter_AddRefs(msgHdr));
+          if (NS_SUCCEEDED(rv) && msgHdr) {
+            uint32_t msgSize = 0;
+            msgHdr->GetMessageSize(&msgSize);
+            m_runningUrl->SetMessageSize(msgSize);
+
+            SetContentLength(msgSize);
+            mailnewsUrl->SetMaxProgress(msgSize);
+
+            rv = msgHdr->GetFolder(getter_AddRefs(folder));
+            if (NS_SUCCEEDED(rv) && folder) {
+              nsCOMPtr<nsIInputStream> stream;
+              int64_t offset = 0;
+              rv = folder->GetMsgInputStream(msgHdr, getter_AddRefs(stream));
+              NS_ENSURE_SUCCESS(rv, rv);
+              nsCOMPtr<nsISeekableStream> seekableStream(
+                  do_QueryInterface(stream, &rv));
+              NS_ENSURE_SUCCESS(rv, rv);
+              seekableStream->Tell(&offset);
+              // create input stream transport
+              nsCOMPtr<nsIStreamTransportService> sts =
+                  do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
+              if (NS_FAILED(rv)) return rv;
+              m_readCount = msgSize;
+
+              RefPtr<SlicedInputStream> slicedStream = new SlicedInputStream(
+                  stream.forget(), offset, uint64_t(msgSize));
+              // Always close the sliced stream when done, we still have the
+              // original.
+              rv = sts->CreateInputTransport(slicedStream, true,
+                                             getter_AddRefs(m_transport));
+
+              m_socketIsOpen = false;
+            }
+          }
+          if (!folder) {  // must be a .eml file
+            rv = OpenFileSocket(aURL, 0, -1);
+          }
+        }
+        NS_ASSERTION(NS_SUCCEEDED(rv), "oops....i messed something up");
+      }
+    }
+  }
+
+  m_lineStreamBuffer = new nsMsgLineStreamBuffer(OUTPUT_BUFFER_SIZE, true);
+
+  m_nextState = MAILBOX_READ_FOLDER;
+  m_initialState = MAILBOX_READ_FOLDER;
+  mCurrentProgress = 0;
+
+  // do we really need both?
+  m_tempMessageFile = m_tempMsgFile;
+  return rv;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// we support the nsIStreamListener interface
+////////////////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP nsMailboxProtocol::OnStartRequest(nsIRequest* request) {
+  // extract the appropriate event sinks from the url and initialize them in our
+  // protocol data the URL should be queried for a nsINewsURL. If it doesn't
+  // support a news URL interface then we have an error.
+  if (m_nextState == MAILBOX_READ_FOLDER && m_mailboxParser) {
+    // we need to inform our mailbox parser that it's time to start...
+    // NOTE: `request` here will be an nsInputStreamPump, but our callbacks
+    // are expecting to be able to QI to a `nsIChannel` to get the URI.
+    // So we pass `this`. See Bug 1528662.
+    m_mailboxParser->OnStartRequest(this);
+  }
+  return nsMsgProtocol::OnStartRequest(request);
+}
+
+bool nsMailboxProtocol::RunningMultipleMsgUrl() {
+  if (m_mailboxAction == nsIMailboxUrl::ActionCopyMessage ||
+      m_mailboxAction == nsIMailboxUrl::ActionMoveMessage) {
+    uint32_t numMoveCopyMsgs;
+    nsresult rv = m_runningUrl->GetNumMoveCopyMsgs(&numMoveCopyMsgs);
+    if (NS_SUCCEEDED(rv) && numMoveCopyMsgs > 1) return true;
+  }
+  return false;
+}
+
+// stop binding is a "notification" informing us that the stream associated with
+// aURL is going away.
+NS_IMETHODIMP nsMailboxProtocol::OnStopRequest(nsIRequest* request,
+                                               nsresult aStatus) {
+  nsresult rv;
+  if (m_nextState == MAILBOX_READ_FOLDER && m_mailboxParser) {
+    // we need to inform our mailbox parser that there is no more incoming
+    // data... NOTE: `request` here will be an nsInputStreamPump, but our
+    // callbacks are expecting to be able to QI to a `nsIChannel` to get the
+    // URI. So we pass `this`. See Bug 1528662.
+    m_mailboxParser->OnStopRequest(this, aStatus);
+  } else if (m_nextState == MAILBOX_READ_MESSAGE) {
+    DoneReadingMessage();
+  }
+  // I'm not getting cancel status - maybe the load group still has the status.
+  bool stopped = false;
+  if (m_runningUrl) {
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl);
+    if (mailnewsUrl) {
+      nsCOMPtr<nsIMsgWindow> window;
+      mailnewsUrl->GetMsgWindow(getter_AddRefs(window));
+      if (window) window->GetStopped(&stopped);
+    }
+
+    if (!stopped && NS_SUCCEEDED(aStatus) &&
+        (m_mailboxAction == nsIMailboxUrl::ActionCopyMessage ||
+         m_mailboxAction == nsIMailboxUrl::ActionMoveMessage)) {
+      uint32_t numMoveCopyMsgs;
+      uint32_t curMoveCopyMsgIndex;
+      rv = m_runningUrl->GetNumMoveCopyMsgs(&numMoveCopyMsgs);
+      if (NS_SUCCEEDED(rv) && numMoveCopyMsgs > 0) {
+        m_runningUrl->GetCurMoveCopyMsgIndex(&curMoveCopyMsgIndex);
+        if (++curMoveCopyMsgIndex < numMoveCopyMsgs) {
+          if (!mSuppressListenerNotifications && m_channelListener) {
+            nsCOMPtr<nsICopyMessageStreamListener> listener =
+                do_QueryInterface(m_channelListener, &rv);
+            if (listener) {
+              listener->EndCopy(mailnewsUrl, aStatus);
+              listener->StartMessage();  // start next message.
+            }
+          }
+          m_runningUrl->SetCurMoveCopyMsgIndex(curMoveCopyMsgIndex);
+          nsCOMPtr<nsIMsgDBHdr> nextMsg;
+          rv = m_runningUrl->GetMoveCopyMsgHdrForIndex(curMoveCopyMsgIndex,
+                                                       getter_AddRefs(nextMsg));
+          if (NS_SUCCEEDED(rv) && nextMsg) {
+            uint32_t msgSize = 0;
+            nsCOMPtr<nsIMsgFolder> msgFolder;
+            nextMsg->GetFolder(getter_AddRefs(msgFolder));
+            NS_ASSERTION(
+                msgFolder,
+                "couldn't get folder for next msg in multiple msg local copy");
+            if (msgFolder) {
+              nsCString uri;
+              msgFolder->GetUriForMsg(nextMsg, uri);
+              nsCOMPtr<nsIMsgMessageUrl> msgUrl =
+                  do_QueryInterface(m_runningUrl);
+              if (msgUrl) {
+                msgUrl->SetOriginalSpec(uri);
+                msgUrl->SetUri(uri);
+
+                uint64_t msgOffset;
+                nextMsg->GetMessageOffset(&msgOffset);
+                nextMsg->GetMessageSize(&msgSize);
+                // now we have to seek to the right position in the file and
+                // basically re-initialize the transport with the correct
+                // message size. then, we have to make sure the url keeps
+                // running somehow.
+                //
+                // put us in a state where we are always notified of incoming
+                // data
+                //
+                m_transport = nullptr;  // open new stream transport
+                m_outputStream = nullptr;
+
+                if (m_multipleMsgMoveCopyStream) {
+                  rv = OpenMultipleMsgTransport(msgOffset, msgSize);
+                } else {
+                  nsCOMPtr<nsIInputStream> stream;
+                  rv = msgFolder->GetMsgInputStream(nextMsg,
+                                                    getter_AddRefs(stream));
+                  if (NS_SUCCEEDED(rv)) {
+                    // create input stream transport
+                    nsCOMPtr<nsIStreamTransportService> sts = do_GetService(
+                        NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
+
+                    if (NS_SUCCEEDED(rv)) {
+                      m_readCount = msgSize;
+                      RefPtr<SlicedInputStream> slicedStream =
+                          new SlicedInputStream(stream.forget(), msgOffset,
+                                                uint64_t(msgSize));
+                      rv = sts->CreateInputTransport(
+                          slicedStream, true, getter_AddRefs(m_transport));
+                    }
+                  }
+                }
+
+                if (NS_SUCCEEDED(rv)) {
+                  nsCOMPtr<nsIInputStream> stream;
+                  rv = m_transport->OpenInputStream(0, 0, 0,
+                                                    getter_AddRefs(stream));
+
+                  if (NS_SUCCEEDED(rv)) {
+                    nsCOMPtr<nsIInputStreamPump> pump;
+                    rv = NS_NewInputStreamPump(getter_AddRefs(pump),
+                                               stream.forget());
+                    if (NS_SUCCEEDED(rv)) {
+                      rv = pump->AsyncRead(this);
+                      if (NS_SUCCEEDED(rv)) m_request = pump;
+                    }
+                  }
+                }
+
+                NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncRead failed");
+                if (m_loadGroup)
+                  m_loadGroup->RemoveRequest(static_cast<nsIRequest*>(this),
+                                             nullptr, aStatus);
+                m_socketIsOpen = true;  // mark the channel as open
+                return aStatus;
+              }
+            }
+          }
+        } else {
+        }
+      }
+    }
+  }
+  // and we want to mark ourselves for deletion or some how inform our protocol
+  // manager that we are available for another url if there is one.
+
+  // mscott --> maybe we should set our state to done because we don't run
+  // multiple urls in a mailbox protocol connection....
+  m_nextState = MAILBOX_DONE;
+
+  // the following is for smoke test purposes. QA is looking at this "Mailbox
+  // Done" string which is printed out to the console and determining if the
+  // mail app loaded up correctly...obviously this solution is not very good so
+  // we should look at something better, but don't remove this line before
+  // talking to me (mscott) and mailnews QA....
+
+  MOZ_LOG(MAILBOX, LogLevel::Info, ("Mailbox Done"));
+
+  // when on stop binding is called, we as the protocol are done...let's close
+  // down the connection releasing all of our interfaces. It's important to
+  // remember that this on stop binding call is coming from netlib so they are
+  // never going to ping us again with on data available. This means we'll never
+  // be going through the Process loop...
+
+  if (m_multipleMsgMoveCopyStream) {
+    m_multipleMsgMoveCopyStream->Close();
+    m_multipleMsgMoveCopyStream = nullptr;
+  }
+  nsMsgProtocol::OnStopRequest(request, aStatus);
+  return CloseSocket();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// End of nsIStreamListenerSupport
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+nsresult nsMailboxProtocol::DoneReadingMessage() {
+  nsresult rv = NS_OK;
+  // and close the article file if it was open....
+
+  if (m_mailboxAction == nsIMailboxUrl::ActionSaveMessageToDisk &&
+      m_msgFileOutputStream)
+    rv = m_msgFileOutputStream->Close();
+
+  return rv;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Begin protocol state machine functions...
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+nsresult nsMailboxProtocol::LoadUrl(nsIURI* aURL, nsISupports* aConsumer) {
+  nsresult rv = NS_OK;
+  // if we were already initialized with a consumer, use it...
+  nsCOMPtr<nsIStreamListener> consumer = do_QueryInterface(aConsumer);
+  if (consumer) m_channelListener = consumer;
+
+  if (aURL) {
+    m_runningUrl = do_QueryInterface(aURL);
+    if (m_runningUrl) {
+      // find out from the url what action we are supposed to perform...
+      rv = m_runningUrl->GetMailboxAction(&m_mailboxAction);
+
+      bool convertData = false;
+
+      // need to check if we're fetching an rfc822 part in order to
+      // quote a message.
+      if (m_mailboxAction == nsIMailboxUrl::ActionFetchMessage) {
+        nsCOMPtr<nsIMsgMailNewsUrl> msgUrl =
+            do_QueryInterface(m_runningUrl, &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        nsAutoCString queryStr;
+        rv = msgUrl->GetQuery(queryStr);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        // check if this is a filter plugin requesting the message.
+        // in that case, set up a text converter
+        convertData = (queryStr.Find("header=filter") != -1 ||
+                       queryStr.Find("header=attach") != -1);
+      } else if (m_mailboxAction == nsIMailboxUrl::ActionFetchPart) {
+        // when fetching a part, we need to insert a converter into the listener
+        // chain order to force just the part out of the message. Our channel
+        // listener is the consumer we'll pass in to AsyncConvertData.
+        convertData = true;
+        consumer = m_channelListener;
+      }
+      if (convertData) {
+        nsCOMPtr<nsIStreamConverterService> streamConverter =
+            do_GetService("@mozilla.org/streamConverters;1", &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        nsCOMPtr<nsIStreamListener> conversionListener;
+        nsCOMPtr<nsIChannel> channel;
+        QueryInterface(NS_GET_IID(nsIChannel), getter_AddRefs(channel));
+
+        rv = streamConverter->AsyncConvertData(
+            "message/rfc822", "*/*", consumer, channel,
+            getter_AddRefs(m_channelListener));
+      }
+
+      if (NS_SUCCEEDED(rv)) {
+        switch (m_mailboxAction) {
+          case nsIMailboxUrl::ActionParseMailbox:
+            // extract the mailbox parser..
+            rv =
+                m_runningUrl->GetMailboxParser(getter_AddRefs(m_mailboxParser));
+            m_nextState = MAILBOX_READ_FOLDER;
+            break;
+          case nsIMailboxUrl::ActionSaveMessageToDisk:
+            // ohhh, display message already writes a msg to disk (as part of a
+            // hack) so we can piggy back off of that!! We just need to change
+            // m_tempMessageFile to be the name of our save message to disk
+            // file. Since save message to disk urls are run without a docshell
+            // to display the msg into, we won't be trying to display the
+            // message after we write it to disk...
+            {
+              nsCOMPtr<nsIMsgMessageUrl> messageUrl =
+                  do_QueryInterface(m_runningUrl, &rv);
+              if (NS_SUCCEEDED(rv)) {
+                messageUrl->GetMessageFile(getter_AddRefs(m_tempMessageFile));
+                rv = MsgNewBufferedFileOutputStream(
+                    getter_AddRefs(m_msgFileOutputStream), m_tempMessageFile,
+                    -1, 00600);
+                NS_ENSURE_SUCCESS(rv, rv);
+
+                bool addDummyEnvelope = false;
+                messageUrl->GetAddDummyEnvelope(&addDummyEnvelope);
+                if (addDummyEnvelope)
+                  SetFlag(MAILBOX_MSG_PARSE_FIRST_LINE);
+                else
+                  ClearFlag(MAILBOX_MSG_PARSE_FIRST_LINE);
+              }
+            }
+            m_nextState = MAILBOX_READ_MESSAGE;
+            break;
+          case nsIMailboxUrl::ActionCopyMessage:
+          case nsIMailboxUrl::ActionMoveMessage:
+          case nsIMailboxUrl::ActionFetchMessage:
+            ClearFlag(MAILBOX_MSG_PARSE_FIRST_LINE);
+            m_nextState = MAILBOX_READ_MESSAGE;
+            break;
+          case nsIMailboxUrl::ActionFetchPart:
+            m_nextState = MAILBOX_READ_MESSAGE;
+            break;
+          default:
+            break;
+        }
+      }
+
+      rv = nsMsgProtocol::LoadUrl(aURL, m_channelListener);
+
+    }  // if we received an MAILBOX url...
+  }    // if we received a url!
+
+  return rv;
+}
+
+int32_t nsMailboxProtocol::ReadFolderResponse(nsIInputStream* inputStream,
+                                              uint64_t sourceOffset,
+                                              uint32_t length) {
+  // okay we are doing a folder read in 8K chunks of a mail folder....
+  // this is almost too easy....we can just forward the data in this stream on
+  // to our folder parser object!!!
+
+  nsresult rv = NS_OK;
+  mCurrentProgress += length;
+
+  if (m_mailboxParser) {
+    rv = m_mailboxParser->OnDataAvailable(
+        nullptr, inputStream, sourceOffset,
+        length);  // let the parser deal with it...
+  }
+  if (NS_FAILED(rv)) {
+    m_nextState = MAILBOX_ERROR_DONE;  // drop out of the loop....
+    return -1;
+  }
+
+  // now wait for the next 8K chunk to come in.....
+  SetFlag(MAILBOX_PAUSE_FOR_READ);
+
+  // leave our state alone so when the next chunk of the mailbox comes in we
+  // jump to this state and repeat....how does this process end? Well when the
+  // file is done being read in, core net lib will issue an ::OnStopRequest to
+  // us...we'll use that as our sign to drop out of this state and to close the
+  // protocol instance...
+
+  return 0;
+}
+
+int32_t nsMailboxProtocol::ReadMessageResponse(nsIInputStream* inputStream,
+                                               uint64_t sourceOffset,
+                                               uint32_t length) {
+  char* line = nullptr;
+  uint32_t status = 0;
+  nsresult rv = NS_OK;
+  mCurrentProgress += length;
+
+  // if we are doing a move or a copy, forward the data onto the copy handler...
+  // if we want to display the message then parse the incoming data...
+
+  if (m_channelListener) {
+    // just forward the data we read in to the listener...
+    rv = m_channelListener->OnDataAvailable(this, inputStream, sourceOffset,
+                                            length);
+  } else {
+    bool pauseForMoreData = false;
+    bool canonicalLineEnding = false;
+    nsCOMPtr<nsIMsgMessageUrl> msgurl = do_QueryInterface(m_runningUrl);
+
+    if (msgurl) msgurl->GetCanonicalLineEnding(&canonicalLineEnding);
+
+    while ((line = m_lineStreamBuffer->ReadNextLine(inputStream, status,
+                                                    pauseForMoreData)) &&
+           !pauseForMoreData) {
+      /* When we're sending this line to a converter (ie,
+      it's a message/rfc822) use the local line termination
+      convention, not CRLF.  This makes text articles get
+      saved with the local line terminators.  Since SMTP
+      and NNTP mandate the use of CRLF, it is expected that
+      the local system will convert that to the local line
+      terminator as it is read.
+      */
+      // mscott - the firstline hack is aimed at making sure we don't write
+      // out the dummy header when we are trying to display the message.
+      // The dummy header is the From line with the date tag on it.
+      if (m_msgFileOutputStream && TestFlag(MAILBOX_MSG_PARSE_FIRST_LINE)) {
+        uint32_t count = 0;
+        rv = m_msgFileOutputStream->Write(line, PL_strlen(line), &count);
+        if (NS_FAILED(rv)) break;
+
+        if (canonicalLineEnding)
+          rv = m_msgFileOutputStream->Write(CRLF, 2, &count);
+        else
+          rv = m_msgFileOutputStream->Write(MSG_LINEBREAK, MSG_LINEBREAK_LEN,
+                                            &count);
+
+        if (NS_FAILED(rv)) break;
+      } else
+        SetFlag(MAILBOX_MSG_PARSE_FIRST_LINE);
+      PR_Free(line);
+    }
+    PR_Free(line);
+  }
+
+  SetFlag(MAILBOX_PAUSE_FOR_READ);  // wait for more data to become available...
+  if (mProgressEventSink && m_runningUrl) {
+    int64_t maxProgress;
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(m_runningUrl));
+    mailnewsUrl->GetMaxProgress(&maxProgress);
+    mProgressEventSink->OnProgress(this, mCurrentProgress, maxProgress);
+  }
+
+  if (NS_FAILED(rv)) return -1;
+
+  return 0;
+}
+
+/*
+ * returns negative if the transfer is finished or error'd out
+ *
+ * returns zero or more if the transfer needs to be continued.
+ */
+nsresult nsMailboxProtocol::ProcessProtocolState(nsIURI* url,
+                                                 nsIInputStream* inputStream,
+                                                 uint64_t offset,
+                                                 uint32_t length) {
+  nsresult rv = NS_OK;
+  int32_t status = 0;
+  ClearFlag(MAILBOX_PAUSE_FOR_READ); /* already paused; reset */
+
+  while (!TestFlag(MAILBOX_PAUSE_FOR_READ)) {
+    switch (m_nextState) {
+      case MAILBOX_READ_MESSAGE:
+        if (inputStream == nullptr)
+          SetFlag(MAILBOX_PAUSE_FOR_READ);
+        else
+          status = ReadMessageResponse(inputStream, offset, length);
+        break;
+      case MAILBOX_READ_FOLDER:
+        if (inputStream == nullptr)
+          SetFlag(MAILBOX_PAUSE_FOR_READ);  // wait for file socket to read in
+                                            // the next chunk...
+        else
+          status = ReadFolderResponse(inputStream, offset, length);
+        break;
+      case MAILBOX_DONE:
+      case MAILBOX_ERROR_DONE: {
+        nsCOMPtr<nsIMsgMailNewsUrl> anotherUrl =
+            do_QueryInterface(m_runningUrl);
+        rv = m_nextState == MAILBOX_DONE ? NS_OK : NS_ERROR_FAILURE;
+        anotherUrl->SetUrlState(false, rv);
+        m_nextState = MAILBOX_FREE;
+      } break;
+
+      case MAILBOX_FREE:
+        // MAILBOX is a one time use connection so kill it if we get here...
+        CloseSocket();
+        return rv; /* final end */
+
+      default: /* should never happen !!! */
+        m_nextState = MAILBOX_ERROR_DONE;
+        break;
+    }
+
+    /* check for errors during load and call error
+     * state if found
+     */
+    if (status < 0 && m_nextState != MAILBOX_FREE) {
+      m_nextState = MAILBOX_ERROR_DONE;
+      /* don't exit! loop around again and do the free case */
+      ClearFlag(MAILBOX_PAUSE_FOR_READ);
+    }
+  } /* while(!MAILBOX_PAUSE_FOR_READ) */
+
+  return rv;
+}
+
+nsresult nsMailboxProtocol::CloseSocket() {
+  // how do you force a release when closing the connection??
+  nsMsgProtocol::CloseSocket();
+  m_runningUrl = nullptr;
+  m_mailboxParser = nullptr;
+  return NS_OK;
+}
+
+// vim: ts=2 sw=2
diff --git a/comm/mailnews/local/src/nsMailboxProtocol.h b/comm/mailnews/local/src/nsMailboxProtocol.h
new file mode 100644
index 0000000000..287729cb44
--- /dev/null
+++ b/comm/mailnews/local/src/nsMailboxProtocol.h
@@ -0,0 +1,113 @@
+/* -*- 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 nsMailboxProtocol_h___
+#define nsMailboxProtocol_h___
+
+#include "mozilla/Attributes.h"
+#include "nsMsgProtocol.h"
+#include "nsCOMPtr.h"
+#include "nsIFile.h"
+#include "nsIOutputStream.h"
+#include "nsIMailboxUrl.h"
+// 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 MAILBOX_PAUSE_FOR_READ \
+  0x00000001 /* should we pause for the next read */
+#define MAILBOX_MSG_PARSE_FIRST_LINE \
+  0x00000002 /* have we read in the first line of the msg */
+
+/* states of the machine
+ */
+typedef enum _MailboxStatesEnum {
+  MAILBOX_UNINITIALIZED,
+  MAILBOX_READ_FOLDER,
+  MAILBOX_READ_MESSAGE,
+  MAILBOX_DONE,
+  MAILBOX_ERROR_DONE,
+  MAILBOX_FREE,
+} MailboxStatesEnum;
+
+class nsMsgLineStreamBuffer;
+
+class nsMailboxProtocol : public nsMsgProtocol {
+ public:
+  // Creating a protocol instance requires the URL which needs to be run AND it
+  // requires a transport layer.
+  explicit nsMailboxProtocol(nsIURI* aURL);
+  virtual ~nsMailboxProtocol();
+
+  // initialization function given a new url and transport layer
+  nsresult Initialize(nsIURI* aURL);
+
+  // the consumer of the url might be something like an nsIDocShell....
+  virtual nsresult LoadUrl(nsIURI* aURL, nsISupports* aConsumer) override;
+
+  ////////////////////////////////////////////////////////////////////////////////////////
+  // we support the nsIStreamListener interface
+  ////////////////////////////////////////////////////////////////////////////////////////
+
+  NS_IMETHOD OnStartRequest(nsIRequest* request) override;
+  NS_IMETHOD OnStopRequest(nsIRequest* request, nsresult aStatus) override;
+
+ private:
+  nsCOMPtr<nsIMailboxUrl>
+      m_runningUrl;  // the nsIMailboxURL that is currently running
+  nsMailboxAction m_mailboxAction;  // current mailbox action associated with
+                                    // this connection...
+  // Event sink handles
+  nsCOMPtr<nsIStreamListener> m_mailboxParser;
+
+  // Local state for the current operation
+  RefPtr<nsMsgLineStreamBuffer>
+      m_lineStreamBuffer;  // used to efficiently extract lines from the
+                           // incoming data stream
+
+  // 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.
+  MailboxStatesEnum m_nextState;
+  MailboxStatesEnum m_initialState;
+
+  int64_t mCurrentProgress;
+
+  // can we just use the base class m_tempMsgFile?
+  nsCOMPtr<nsIFile> m_tempMessageFile;
+  nsCOMPtr<nsIOutputStream> m_msgFileOutputStream;
+
+  // this is used to hold the source mailbox file open when move/copying
+  // multiple messages.
+  nsCOMPtr<nsIInputStream> m_multipleMsgMoveCopyStream;
+
+  virtual nsresult ProcessProtocolState(nsIURI* url,
+                                        nsIInputStream* inputStream,
+                                        uint64_t sourceOffset,
+                                        uint32_t length) override;
+  virtual nsresult CloseSocket() override;
+
+  nsresult OpenMultipleMsgTransport(uint64_t offset, int64_t size);
+  bool RunningMultipleMsgUrl();
+
+  ////////////////////////////////////////////////////////////////////////////////////////
+  // 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.
+  ////////////////////////////////////////////////////////////////////////////////////////
+
+  // When parsing a mailbox folder in chunks, this protocol state reads in the
+  // current chunk and forwards it to the mailbox parser.
+  int32_t ReadFolderResponse(nsIInputStream* inputStream, uint64_t sourceOffset,
+                             uint32_t length);
+  int32_t ReadMessageResponse(nsIInputStream* inputStream,
+                              uint64_t sourceOffset, uint32_t length);
+  nsresult DoneReadingMessage();
+
+  ////////////////////////////////////////////////////////////////////////////////////////
+  // End of Protocol Methods
+  ////////////////////////////////////////////////////////////////////////////////////////
+};
+
+#endif  // nsMailboxProtocol_h___
diff --git a/comm/mailnews/local/src/nsMailboxServer.cpp b/comm/mailnews/local/src/nsMailboxServer.cpp
new file mode 100644
index 0000000000..e0ddc26388
--- /dev/null
+++ b/comm/mailnews/local/src/nsMailboxServer.cpp
@@ -0,0 +1,28 @@
+/**
+ * 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 "nsMailboxServer.h"
+#include "nsLocalMailFolder.h"
+
+NS_IMETHODIMP
+nsMailboxServer::GetLocalStoreType(nsACString& type) {
+  type.AssignLiteral("mailbox");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailboxServer::GetLocalDatabaseType(nsACString& type) {
+  type.AssignLiteral("mailbox");
+  return NS_OK;
+}
+
+nsresult nsMailboxServer::CreateRootFolderFromUri(const nsACString& serverUri,
+                                                  nsIMsgFolder** rootFolder) {
+  nsMsgLocalMailFolder* newRootFolder = new nsMsgLocalMailFolder;
+  if (!newRootFolder) return NS_ERROR_OUT_OF_MEMORY;
+  NS_ADDREF(*rootFolder = newRootFolder);
+  newRootFolder->Init(serverUri);
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsMailboxServer.h b/comm/mailnews/local/src/nsMailboxServer.h
new file mode 100644
index 0000000000..07bf628aae
--- /dev/null
+++ b/comm/mailnews/local/src/nsMailboxServer.h
@@ -0,0 +1,22 @@
+/**
+ * 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 nsMailboxServer_h__
+#define nsMailboxServer_h__
+
+#include "mozilla/Attributes.h"
+#include "nsMsgIncomingServer.h"
+
+class nsMailboxServer : public nsMsgIncomingServer {
+ public:
+  NS_IMETHOD GetLocalStoreType(nsACString& type) override;
+  NS_IMETHOD GetLocalDatabaseType(nsACString& type) override;
+
+ protected:
+  virtual nsresult CreateRootFolderFromUri(const nsACString& serverUri,
+                                           nsIMsgFolder** rootFolder) override;
+};
+
+#endif
diff --git a/comm/mailnews/local/src/nsMailboxService.cpp b/comm/mailnews/local/src/nsMailboxService.cpp
new file mode 100644
index 0000000000..8a6a9766a8
--- /dev/null
+++ b/comm/mailnews/local/src/nsMailboxService.cpp
@@ -0,0 +1,559 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"  // precompiled header...
+#include "nsCOMPtr.h"
+
+#include "nsMailboxService.h"
+#include "nsMailboxUrl.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsMailboxProtocol.h"
+#include "nsIMsgDatabase.h"
+#include "MailNewsTypes.h"
+#include "nsTArray.h"
+#include "nsLocalUtils.h"
+#include "nsIDocShell.h"
+#include "nsMsgUtils.h"
+#include "nsPop3URL.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsNetUtil.h"
+#include "nsIWebNavigation.h"
+#include "prprf.h"
+#include "nsIMsgHdr.h"
+#include "nsIFileURL.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/LoadInfo.h"
+#include "nsDocShellLoadState.h"
+#include "nsContentUtils.h"
+#include "nsMsgFileHdr.h"
+
+nsMailboxService::nsMailboxService() {}
+
+nsMailboxService::~nsMailboxService() {}
+
+NS_IMPL_ISUPPORTS(nsMailboxService, nsIMailboxService, nsIMsgMessageService,
+                  nsIProtocolHandler, nsIMsgMessageFetchPartService)
+
+nsresult nsMailboxService::ParseMailbox(nsIMsgWindow* aMsgWindow,
+                                        nsIFile* aMailboxPath,
+                                        nsIStreamListener* aMailboxParser,
+                                        nsIUrlListener* aUrlListener,
+                                        nsIURI** aURL) {
+  NS_ENSURE_ARG_POINTER(aMailboxPath);
+
+  nsresult rv;
+  nsCOMPtr<nsIMailboxUrl> mailboxurl =
+      do_CreateInstance("@mozilla.org/messenger/mailboxurl;1", &rv);
+  if (NS_SUCCEEDED(rv) && mailboxurl) {
+    nsCOMPtr<nsIMsgMailNewsUrl> url = do_QueryInterface(mailboxurl);
+    // okay now generate the url string
+#ifdef XP_WIN
+    nsString path = aMailboxPath->NativePath();
+    nsCString mailboxPath;
+    NS_CopyUnicodeToNative(path, mailboxPath);
+#else
+    nsCString mailboxPath = aMailboxPath->NativePath();
+#endif
+    nsAutoCString buf;
+    MsgEscapeURL(mailboxPath,
+                 nsINetUtil::ESCAPE_URL_MINIMAL | nsINetUtil::ESCAPE_URL_FORCED,
+                 buf);
+    nsEscapeNativePath(buf);
+    url->SetUpdatingFolder(true);
+    url->SetMsgWindow(aMsgWindow);
+    nsAutoCString uriSpec("mailbox://");
+    uriSpec.Append(buf);
+    rv = url->SetSpecInternal(uriSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    mailboxurl->SetMailboxParser(aMailboxParser);
+    if (aUrlListener) url->RegisterListener(aUrlListener);
+
+    rv = RunMailboxUrl(url, nullptr);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (aURL) {
+      url.forget(aURL);
+    }
+  }
+
+  return rv;
+}
+
+nsresult nsMailboxService::CopyMessage(const nsACString& aSrcMailboxURI,
+                                       nsIStreamListener* aMailboxCopyHandler,
+                                       bool moveMessage,
+                                       nsIUrlListener* aUrlListener,
+                                       nsIMsgWindow* aMsgWindow) {
+  nsMailboxAction mailboxAction = nsIMailboxUrl::ActionMoveMessage;
+  nsCOMPtr<nsIURI> aURL;  // unused...
+  if (!moveMessage) mailboxAction = nsIMailboxUrl::ActionCopyMessage;
+  return FetchMessage(aSrcMailboxURI, aMailboxCopyHandler, aMsgWindow,
+                      aUrlListener, nullptr, mailboxAction, false,
+                      getter_AddRefs(aURL));
+}
+
+nsresult nsMailboxService::CopyMessages(
+    const nsTArray<nsMsgKey>& aMsgKeys, nsIMsgFolder* srcFolder,
+    nsIStreamListener* aMailboxCopyHandler, bool moveMessage,
+    nsIUrlListener* aUrlListener, nsIMsgWindow* aMsgWindow, nsIURI** aURL) {
+  nsresult rv = NS_OK;
+  NS_ENSURE_ARG(srcFolder);
+  NS_ENSURE_TRUE(!aMsgKeys.IsEmpty(), NS_ERROR_INVALID_ARG);
+  nsCOMPtr<nsIMailboxUrl> mailboxurl;
+
+  nsMailboxAction actionToUse = nsIMailboxUrl::ActionMoveMessage;
+  if (!moveMessage) actionToUse = nsIMailboxUrl::ActionCopyMessage;
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  nsCOMPtr<nsIMsgDatabase> db;
+  srcFolder->GetMsgDatabase(getter_AddRefs(db));
+  if (db) {
+    db->GetMsgHdrForKey(aMsgKeys[0], getter_AddRefs(msgHdr));
+    if (msgHdr) {
+      nsCString uri;
+      srcFolder->GetUriForMsg(msgHdr, uri);
+      rv = PrepareMessageUrl(uri, aUrlListener, actionToUse,
+                             getter_AddRefs(mailboxurl), aMsgWindow);
+
+      if (NS_SUCCEEDED(rv)) {
+        nsCOMPtr<nsIURI> url = do_QueryInterface(mailboxurl);
+        nsCOMPtr<nsIMsgMailNewsUrl> msgUrl(do_QueryInterface(url));
+        nsCOMPtr<nsIMailboxUrl> mailboxUrl(do_QueryInterface(url));
+        msgUrl->SetMsgWindow(aMsgWindow);
+
+        mailboxUrl->SetMoveCopyMsgKeys(aMsgKeys);
+        rv = RunMailboxUrl(url, aMailboxCopyHandler);
+      }
+    }
+  }
+  if (aURL && mailboxurl) CallQueryInterface(mailboxurl, aURL);
+
+  return rv;
+}
+
+nsresult nsMailboxService::FetchMessage(
+    const nsACString& aMessageURI, nsISupports* aDisplayConsumer,
+    nsIMsgWindow* aMsgWindow, nsIUrlListener* aUrlListener,
+    const char* aFileName, /* only used by open attachment... */
+    nsMailboxAction mailboxAction, bool aAutodetectCharset, nsIURI** aURL) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMailboxUrl> mailboxurl;
+  nsMailboxAction actionToUse = mailboxAction;
+  nsCOMPtr<nsIURI> url;
+  nsCOMPtr<nsIMsgMailNewsUrl> msgUrl;
+  nsAutoCString uriString(aMessageURI);
+
+  if (StringBeginsWith(aMessageURI, "file:"_ns)) {
+    int64_t fileSize;
+    nsCOMPtr<nsIURI> fileUri;
+    rv = NS_NewURI(getter_AddRefs(fileUri), aMessageURI);
+    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);
+    file->GetFileSize(&fileSize);
+    uriString.Replace(0, 5, "mailbox:"_ns);
+    uriString.AppendLiteral("&number=0");
+    rv = NS_NewURI(getter_AddRefs(url), uriString);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    msgUrl = do_QueryInterface(url);
+    if (msgUrl) {
+      msgUrl->SetMsgWindow(aMsgWindow);
+      nsCOMPtr<nsIMailboxUrl> mailboxUrl = do_QueryInterface(msgUrl, &rv);
+      mailboxUrl->SetMessageSize((uint32_t)fileSize);
+    }
+  } else {
+    // this happens with forward inline of message/rfc822 attachment
+    // opened in a stand-alone msg window.
+    int32_t typeIndex = uriString.Find("&type=application/x-message-display");
+    if (typeIndex != -1) {
+      uriString.Cut(typeIndex,
+                    sizeof("&type=application/x-message-display") - 1);
+      rv = NS_NewURI(getter_AddRefs(url), uriString.get());
+      mailboxurl = do_QueryInterface(url);
+    } else
+      rv = PrepareMessageUrl(aMessageURI, aUrlListener, actionToUse,
+                             getter_AddRefs(mailboxurl), aMsgWindow);
+
+    if (NS_SUCCEEDED(rv)) {
+      url = do_QueryInterface(mailboxurl);
+      msgUrl = do_QueryInterface(url);
+      msgUrl->SetMsgWindow(aMsgWindow);
+      if (aFileName) msgUrl->SetFileNameInternal(nsDependentCString(aFileName));
+    }
+  }
+
+  nsCOMPtr<nsIMsgI18NUrl> i18nurl(do_QueryInterface(msgUrl));
+  if (i18nurl) i18nurl->SetAutodetectCharset(aAutodetectCharset);
+
+  // instead of running the mailbox url like we used to, let's try to run the
+  // url in the docshell...
+  nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aDisplayConsumer, &rv));
+  // if we were given a docShell, run the url in the docshell..otherwise just
+  // run it normally.
+  if (NS_SUCCEEDED(rv) && docShell && url) {
+    // DIRTY LITTLE HACK --> if we are opening an attachment we want the
+    // docshell to treat this load as if it were a user click event. Then the
+    // dispatching stuff will be much happier.
+    RefPtr<nsDocShellLoadState> loadState = new nsDocShellLoadState(url);
+    loadState->SetLoadFlags(mailboxAction == nsIMailboxUrl::ActionFetchPart
+                                ? nsIWebNavigation::LOAD_FLAGS_IS_LINK
+                                : nsIWebNavigation::LOAD_FLAGS_NONE);
+    if (mailboxAction == nsIMailboxUrl::ActionFetchPart)
+      loadState->SetLoadType(LOAD_LINK);
+    loadState->SetFirstParty(false);
+    loadState->SetTriggeringPrincipal(nsContentUtils::GetSystemPrincipal());
+    rv = docShell->LoadURI(loadState, false);
+  } else
+    rv = RunMailboxUrl(url, aDisplayConsumer);
+
+  if (aURL && mailboxurl) CallQueryInterface(mailboxurl, aURL);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMailboxService::FetchMimePart(
+    nsIURI* aURI, const nsACString& aMessageURI, nsISupports* aDisplayConsumer,
+    nsIMsgWindow* aMsgWindow, nsIUrlListener* aUrlListener, nsIURI** aURL) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailNewsUrl> msgUrl(do_QueryInterface(aURI, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  msgUrl->SetMsgWindow(aMsgWindow);
+
+  // set up the url listener
+  if (aUrlListener) msgUrl->RegisterListener(aUrlListener);
+
+  return RunMailboxUrl(msgUrl, aDisplayConsumer);
+}
+
+NS_IMETHODIMP nsMailboxService::LoadMessage(const nsACString& aMessageURI,
+                                            nsISupports* aDisplayConsumer,
+                                            nsIMsgWindow* aMsgWindow,
+                                            nsIUrlListener* aUrlListener,
+                                            bool aOverideCharset) {
+  nsCOMPtr<nsIURI> aURL;  // unused...
+  return FetchMessage(aMessageURI, aDisplayConsumer, aMsgWindow, aUrlListener,
+                      nullptr, nsIMailboxUrl::ActionFetchMessage,
+                      aOverideCharset, getter_AddRefs(aURL));
+}
+
+NS_IMETHODIMP
+nsMailboxService::StreamMessage(const nsACString& aMessageURI,
+                                nsISupports* aConsumer,
+                                nsIMsgWindow* aMsgWindow,
+                                nsIUrlListener* aUrlListener,
+                                bool /* aConvertData */,
+                                const nsACString& aAdditionalHeader,
+                                bool aLocalOnly, nsIURI** aURL) {
+  // The mailbox protocol object will look for "header=filter" or
+  // "header=attach" to decide if it wants to convert the data instead of
+  // using aConvertData. It turns out to be way too hard to pass aConvertData
+  // all the way over to the mailbox protocol object.
+  nsAutoCString aURIString(aMessageURI);
+  if (!aAdditionalHeader.IsEmpty()) {
+    aURIString.FindChar('?') == -1 ? aURIString += "?" : aURIString += "&";
+    aURIString += "header=";
+    aURIString += aAdditionalHeader;
+  }
+
+  return FetchMessage(aURIString, aConsumer, aMsgWindow, aUrlListener, nullptr,
+                      nsIMailboxUrl::ActionFetchMessage, false, aURL);
+}
+
+NS_IMETHODIMP nsMailboxService::StreamHeaders(const nsACString& aMessageURI,
+                                              nsIStreamListener* aConsumer,
+                                              nsIUrlListener* aUrlListener,
+                                              bool aLocalOnly, nsIURI** aURL) {
+  NS_ENSURE_ARG_POINTER(aConsumer);
+  nsAutoCString folderURI;
+  nsMsgKey msgKey;
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv =
+      DecomposeMailboxURI(aMessageURI, getter_AddRefs(folder), &msgKey);
+  if (msgKey == nsMsgKey_None) return NS_MSG_MESSAGE_NOT_FOUND;
+
+  nsCOMPtr<nsIMsgDatabase> db;
+  rv = folder->GetMsgDatabase(getter_AddRefs(db));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  rv = db->GetMsgHdrForKey(msgKey, getter_AddRefs(msgHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIInputStream> inputStream;
+  rv = folder->GetLocalMsgStream(msgHdr, getter_AddRefs(inputStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return MsgStreamMsgHeaders(inputStream, aConsumer);
+}
+
+NS_IMETHODIMP nsMailboxService::IsMsgInMemCache(nsIURI* aUrl,
+                                                nsIMsgFolder* aFolder,
+                                                bool* aResult) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMailboxService::SaveMessageToDisk(const nsACString& aMessageURI,
+                                    nsIFile* aFile, bool aAddDummyEnvelope,
+                                    nsIUrlListener* aUrlListener, nsIURI** aURL,
+                                    bool canonicalLineEnding,
+                                    nsIMsgWindow* aMsgWindow) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMailboxUrl> mailboxurl;
+
+  rv = PrepareMessageUrl(aMessageURI, aUrlListener,
+                         nsIMailboxUrl::ActionSaveMessageToDisk,
+                         getter_AddRefs(mailboxurl), aMsgWindow);
+
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(mailboxurl);
+    if (msgUrl) {
+      msgUrl->SetMessageFile(aFile);
+      msgUrl->SetAddDummyEnvelope(aAddDummyEnvelope);
+      msgUrl->SetCanonicalLineEnding(canonicalLineEnding);
+    }
+
+    nsCOMPtr<nsIURI> url = do_QueryInterface(mailboxurl);
+    rv = RunMailboxUrl(url);
+  }
+
+  if (aURL && mailboxurl) CallQueryInterface(mailboxurl, aURL);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMailboxService::GetUrlForUri(const nsACString& aMessageURI,
+                                             nsIMsgWindow* aMsgWindow,
+                                             nsIURI** aURL) {
+  NS_ENSURE_ARG_POINTER(aURL);
+  if (StringBeginsWith(aMessageURI, "file:"_ns) ||
+      PL_strstr(PromiseFlatCString(aMessageURI).get(),
+                "type=application/x-message-display") ||
+      StringBeginsWith(aMessageURI, "mailbox:"_ns))
+    return NS_NewURI(aURL, aMessageURI);
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMailboxUrl> mailboxurl;
+  rv =
+      PrepareMessageUrl(aMessageURI, nullptr, nsIMailboxUrl::ActionFetchMessage,
+                        getter_AddRefs(mailboxurl), aMsgWindow);
+  if (NS_SUCCEEDED(rv) && mailboxurl) rv = CallQueryInterface(mailboxurl, aURL);
+  return rv;
+}
+
+// Takes a mailbox url, this method creates a protocol instance and loads the
+// url into the protocol instance.
+nsresult nsMailboxService::RunMailboxUrl(nsIURI* aMailboxUrl,
+                                         nsISupports* aDisplayConsumer) {
+  // create a protocol instance to run the url..
+  RefPtr<nsMailboxProtocol> protocol = new nsMailboxProtocol(aMailboxUrl);
+  // It implements nsIChannel, and all channels require loadInfo.
+  protocol->SetLoadInfo(new mozilla::net::LoadInfo(
+      nsContentUtils::GetSystemPrincipal(), nullptr, nullptr,
+      nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+      nsIContentPolicy::TYPE_OTHER));
+  nsresult rv = protocol->Initialize(aMailboxUrl);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return protocol->LoadUrl(aMailboxUrl, aDisplayConsumer);
+}
+
+// This function takes a message uri, converts it into a file path & msgKey
+// pair. It then turns that into a mailbox url object. It also registers a url
+// listener if appropriate. AND it can take in a mailbox action and set that
+// field on the returned url as well.
+nsresult nsMailboxService::PrepareMessageUrl(
+    const nsACString& aSrcMsgMailboxURI, nsIUrlListener* aUrlListener,
+    nsMailboxAction aMailboxAction, nsIMailboxUrl** aMailboxUrl,
+    nsIMsgWindow* msgWindow) {
+  nsresult rv =
+      CallCreateInstance("@mozilla.org/messenger/mailboxurl;1", aMailboxUrl);
+  if (NS_SUCCEEDED(rv) && aMailboxUrl && *aMailboxUrl) {
+    // okay now generate the url string
+    char* urlSpec;
+    nsAutoCString folderURI;
+    nsMsgKey msgKey;
+    nsCString folderPath;
+    const nsPromiseFlatCString& flat = PromiseFlatCString(aSrcMsgMailboxURI);
+    const char* part = PL_strstr(flat.get(), "part=");
+    const char* header = PL_strstr(flat.get(), "header=");
+    rv = nsParseLocalMessageURI(aSrcMsgMailboxURI, folderURI, &msgKey);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = nsLocalURI2Path(kMailboxRootURI, folderURI.get(), folderPath);
+
+    if (NS_SUCCEEDED(rv)) {
+      // set up the url spec and initialize the url with it.
+      nsAutoCString buf;
+      MsgEscapeURL(
+          folderPath,
+          nsINetUtil::ESCAPE_URL_DIRECTORY | nsINetUtil::ESCAPE_URL_FORCED,
+          buf);
+      if (part)
+        urlSpec =
+            PR_smprintf("mailbox://%s?number=%lu&%s", buf.get(), msgKey, part);
+      else if (header)
+        urlSpec = PR_smprintf("mailbox://%s?number=%lu&%s", buf.get(), msgKey,
+                              header);
+      else
+        urlSpec = PR_smprintf("mailbox://%s?number=%lu", buf.get(), msgKey);
+
+      nsCOMPtr<nsIMsgMailNewsUrl> url = do_QueryInterface(*aMailboxUrl);
+      rv = url->SetSpecInternal(nsDependentCString(urlSpec));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      PR_smprintf_free(urlSpec);
+
+      (*aMailboxUrl)->SetMailboxAction(aMailboxAction);
+
+      // set up the url listener
+      if (aUrlListener) rv = url->RegisterListener(aUrlListener);
+
+      url->SetMsgWindow(msgWindow);
+      nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(url);
+      if (msgUrl) {
+        msgUrl->SetOriginalSpec(aSrcMsgMailboxURI);
+        msgUrl->SetUri(aSrcMsgMailboxURI);
+      }
+
+    }  // if we got a url
+  }    // if we got a url
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMailboxService::GetScheme(nsACString& aScheme) {
+  aScheme = "mailbox";
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxService::AllowPort(int32_t port, const char* scheme,
+                                          bool* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  // don't override anything.
+  *_retval = false;
+  return NS_OK;
+}
+
+nsresult nsMailboxService::NewURI(const nsACString& aSpec,
+                                  const char* aOriginCharset, nsIURI* aBaseURI,
+                                  nsIURI** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = 0;
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailNewsUrl> aMsgUri =
+      do_CreateInstance("@mozilla.org/messenger/mailboxurl;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // SetSpecInternal must not fail, or else the URL won't have a base URL and
+  // we'll crash later.
+  if (aBaseURI) {
+    nsAutoCString newSpec;
+    rv = aBaseURI->Resolve(aSpec, newSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = aMsgUri->SetSpecInternal(newSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+  } else {
+    rv = aMsgUri->SetSpecInternal(aSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  aMsgUri.forget(_retval);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMailboxService::NewChannel(nsIURI* aURI, nsILoadInfo* aLoadInfo,
+                                           nsIChannel** _retval) {
+  NS_ENSURE_ARG_POINTER(aURI);
+  NS_ENSURE_ARG_POINTER(_retval);
+  MOZ_ASSERT(aLoadInfo);
+  nsresult rv = NS_OK;
+  nsAutoCString spec;
+  rv = aURI->GetSpec(spec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (spec.Find("?uidl=") >= 0 || spec.Find("&uidl=") >= 0) {
+    nsCOMPtr<nsIProtocolHandler> handler =
+        do_GetService("@mozilla.org/network/protocol;1?name=pop", &rv);
+    if (NS_SUCCEEDED(rv)) {
+      nsCOMPtr<nsIURI> pop3Uri;
+
+      rv = nsPop3URL::NewURI(spec, aURI, getter_AddRefs(pop3Uri));
+      NS_ENSURE_SUCCESS(rv, rv);
+      return handler->NewChannel(pop3Uri, aLoadInfo, _retval);
+    }
+  }
+
+  RefPtr<nsMailboxProtocol> protocol = new nsMailboxProtocol(aURI);
+  if (!protocol) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  rv = protocol->Initialize(aURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = protocol->SetLoadInfo(aLoadInfo);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Add the attachment disposition. This forces docShell to open the
+  // attachment instead of displaying it. Content types we have special
+  // handlers for are white-listed. This white list also exists in
+  // nsImapService::NewChannel and nsNntpService::NewChannel, so if you're
+  // changing this, update those too.
+  if (spec.Find("part=") >= 0 && spec.Find("type=message/rfc822") < 0 &&
+      spec.Find("type=application/x-message-display") < 0 &&
+      spec.Find("type=application/pdf") < 0) {
+    rv = protocol->SetContentDisposition(nsIChannel::DISPOSITION_ATTACHMENT);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  protocol.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxService::Search(nsIMsgSearchSession* aSearchSession,
+                                       nsIMsgWindow* aMsgWindow,
+                                       nsIMsgFolder* aMsgFolder,
+                                       const nsACString& aMessageUri) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsresult nsMailboxService::DecomposeMailboxURI(const nsACString& aMessageURI,
+                                               nsIMsgFolder** aFolder,
+                                               nsMsgKey* aMsgKey) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aMsgKey);
+
+  nsresult rv = NS_OK;
+  nsAutoCString folderURI;
+  rv = nsParseLocalMessageURI(aMessageURI, folderURI, aMsgKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return GetOrCreateFolder(folderURI, aFolder);
+}
+
+NS_IMETHODIMP
+nsMailboxService::MessageURIToMsgHdr(const nsACString& uri,
+                                     nsIMsgDBHdr** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  if (StringBeginsWith(uri, "file:"_ns)) {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr = new nsMsgFileHdr(uri);
+    msgHdr.forget(_retval);
+    return NS_OK;
+  }
+
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsMsgKey msgKey;
+
+  rv = DecomposeMailboxURI(uri, getter_AddRefs(folder), &msgKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = folder->GetMessageHeader(msgKey, _retval);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsMailboxService.h b/comm/mailnews/local/src/nsMailboxService.h
new file mode 100644
index 0000000000..1ab9be1b67
--- /dev/null
+++ b/comm/mailnews/local/src/nsMailboxService.h
@@ -0,0 +1,59 @@
+/* -*- 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 nsMailboxService_h___
+#define nsMailboxService_h___
+
+#include "nscore.h"
+#include "nsISupports.h"
+
+#include "nsIMailboxService.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgMessageService.h"
+#include "nsIMsgWindow.h"
+#include "nsIMailboxUrl.h"
+#include "nsIURI.h"
+#include "nsIUrlListener.h"
+#include "nsIProtocolHandler.h"
+
+class nsMailboxService : public nsIMailboxService,
+                         public nsIMsgMessageService,
+                         public nsIMsgMessageFetchPartService,
+                         public nsIProtocolHandler {
+ public:
+  nsMailboxService();
+  static nsresult NewURI(const nsACString& aSpec, const char* aOriginCharset,
+                         nsIURI* aBaseURI, nsIURI** _retval);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMAILBOXSERVICE
+  NS_DECL_NSIMSGMESSAGESERVICE
+  NS_DECL_NSIMSGMESSAGEFETCHPARTSERVICE
+  NS_DECL_NSIPROTOCOLHANDLER
+
+ protected:
+  virtual ~nsMailboxService();
+
+  // helper functions used by the service
+  nsresult PrepareMessageUrl(const nsACString& aSrcMsgMailboxURI,
+                             nsIUrlListener* aUrlListener,
+                             nsMailboxAction aMailboxAction,
+                             nsIMailboxUrl** aMailboxUrl,
+                             nsIMsgWindow* msgWindow);
+
+  nsresult RunMailboxUrl(nsIURI* aMailboxUrl,
+                         nsISupports* aDisplayConsumer = nullptr);
+
+  nsresult FetchMessage(
+      const nsACString& aMessageURI, nsISupports* aDisplayConsumer,
+      nsIMsgWindow* aMsgWindow, nsIUrlListener* aUrlListener,
+      const char* aFileName, /* only used by open attachment */
+      nsMailboxAction mailboxAction, bool aAutodetectCharset, nsIURI** aURL);
+
+  nsresult DecomposeMailboxURI(const nsACString& aMessageURI,
+                               nsIMsgFolder** aFolder, nsMsgKey* aMsgKey);
+};
+
+#endif /* nsMailboxService_h___ */
diff --git a/comm/mailnews/local/src/nsMailboxUrl.cpp b/comm/mailnews/local/src/nsMailboxUrl.cpp
new file mode 100644
index 0000000000..841b6d8922
--- /dev/null
+++ b/comm/mailnews/local/src/nsMailboxUrl.cpp
@@ -0,0 +1,474 @@
+/* -*- 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 "nsIURI.h"
+#include "nsIMailboxUrl.h"
+#include "nsMailboxUrl.h"
+
+#include "nsString.h"
+#include "nsLocalUtils.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgHdr.h"
+
+#include "nsIMsgFolder.h"
+#include "prprf.h"
+#include "prmem.h"
+#include "nsIMsgMailSession.h"
+#include "nsNetUtil.h"
+#include "nsIFileURL.h"
+#include "nsIStandardURL.h"
+
+// this is totally lame and MUST be removed by M6
+// the real fix is to attach the URI to the URL as it runs through netlib
+// then grab it and use it on the other side
+#include "nsCOMPtr.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Components.h"
+
+// helper function for parsing the search field of a url
+char* extractAttributeValue(const char* searchString,
+                            const char* attributeName);
+
+nsMailboxUrl::nsMailboxUrl() {
+  m_mailboxAction = nsIMailboxUrl::ActionParseMailbox;
+  m_filePath = nullptr;
+  m_messageID = nullptr;
+  m_messageKey = nsMsgKey_None;
+  m_messageSize = 0;
+  m_messageFile = nullptr;
+  m_addDummyEnvelope = false;
+  m_canonicalLineEnding = false;
+  m_curMsgIndex = 0;
+  mAutodetectCharset = false;
+}
+
+nsMailboxUrl::~nsMailboxUrl() { PR_Free(m_messageID); }
+
+NS_IMPL_ADDREF_INHERITED(nsMailboxUrl, nsMsgMailNewsUrl)
+NS_IMPL_RELEASE_INHERITED(nsMailboxUrl, nsMsgMailNewsUrl)
+
+NS_INTERFACE_MAP_BEGIN(nsMailboxUrl)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMailboxUrl)
+  NS_INTERFACE_MAP_ENTRY(nsIMailboxUrl)
+  NS_INTERFACE_MAP_ENTRY(nsIMsgMessageUrl)
+  NS_INTERFACE_MAP_ENTRY(nsIMsgI18NUrl)
+NS_INTERFACE_MAP_END_INHERITING(nsMsgMailNewsUrl)
+
+////////////////////////////////////////////////////////////////////////////////////
+// Begin nsIMailboxUrl specific support
+////////////////////////////////////////////////////////////////////////////////////
+nsresult nsMailboxUrl::SetMailboxParser(nsIStreamListener* aMailboxParser) {
+  if (aMailboxParser) m_mailboxParser = aMailboxParser;
+  return NS_OK;
+}
+
+nsresult nsMailboxUrl::GetMailboxParser(nsIStreamListener** aConsumer) {
+  NS_ENSURE_ARG_POINTER(aConsumer);
+
+  NS_IF_ADDREF(*aConsumer = m_mailboxParser);
+  return NS_OK;
+}
+
+nsresult nsMailboxUrl::SetMailboxCopyHandler(
+    nsIStreamListener* aMailboxCopyHandler) {
+  if (aMailboxCopyHandler) m_mailboxCopyHandler = aMailboxCopyHandler;
+  return NS_OK;
+}
+
+nsresult nsMailboxUrl::GetMailboxCopyHandler(
+    nsIStreamListener** aMailboxCopyHandler) {
+  NS_ENSURE_ARG_POINTER(aMailboxCopyHandler);
+
+  if (aMailboxCopyHandler) {
+    NS_IF_ADDREF(*aMailboxCopyHandler = m_mailboxCopyHandler);
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMailboxUrl::GetMessageKey(nsMsgKey* aMessageKey) {
+  *aMessageKey = m_messageKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxUrl::GetMessageSize(uint32_t* aMessageSize) {
+  if (aMessageSize) {
+    *aMessageSize = m_messageSize;
+    return NS_OK;
+  } else
+    return NS_ERROR_NULL_POINTER;
+}
+
+nsresult nsMailboxUrl::SetMessageSize(uint32_t aMessageSize) {
+  m_messageSize = aMessageSize;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxUrl::GetNormalizedSpec(nsACString& aPrincipalSpec) {
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsURL;
+  QueryInterface(NS_GET_IID(nsIMsgMailNewsUrl), getter_AddRefs(mailnewsURL));
+
+  nsAutoCString spec;
+  mailnewsURL->GetSpecIgnoringRef(spec);
+
+  // mailbox: URLs contain a lot of query parts. We want need a normalized form:
+  // mailbox:///path/to/folder?number=nn.
+  // We also need to translate the second form
+  // mailbox://user@domain@server/folder?number=nn.
+
+  char* messageKey = extractAttributeValue(spec.get(), "number=");
+
+  // Strip any query part beginning with ? or /;
+  MsgRemoveQueryPart(spec);
+
+  // Check for format lacking absolute path.
+  if (spec.Find("///") == kNotFound) {
+    nsCString folderPath;
+    nsresult rv = nsLocalURI2Path(kMailboxRootURI, spec.get(), folderPath);
+    if (NS_SUCCEEDED(rv)) {
+      nsAutoCString buf;
+      MsgEscapeURL(
+          folderPath,
+          nsINetUtil::ESCAPE_URL_DIRECTORY | nsINetUtil::ESCAPE_URL_FORCED,
+          buf);
+      spec = "mailbox://"_ns + buf;
+    }
+  }
+
+  if (messageKey) {
+    spec += "?number="_ns;
+    spec.Append(messageKey);
+    PR_Free(messageKey);
+  }
+
+  aPrincipalSpec.Assign(spec);
+  return NS_OK;
+}
+
+nsresult nsMailboxUrl::CreateURL(const nsACString& aSpec, nsIURL** aURL) {
+  nsresult rv;
+  nsCOMPtr<nsIURL> url;
+  // Check whether the URL is of the form
+  // mailbox://user@domain@server/folder?number=nn and contains a hostname.
+  // Check for format lacking absolute path.
+  if (PromiseFlatCString(aSpec).Find("///") == kNotFound) {
+    rv = NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID)
+             .SetSpec(aSpec)
+             .Finalize(url);
+    NS_ENSURE_SUCCESS(rv, rv);
+  } else {
+    // The URL is more like a file URL without a hostname.
+    rv = NS_MutateURI(NS_STANDARDURLMUTATOR_CONTRACTID)
+             .Apply(&nsIStandardURLMutator::Init,
+                    nsIStandardURL::URLTYPE_NO_AUTHORITY, -1,
+                    PromiseFlatCString(aSpec), nullptr, nullptr, nullptr)
+             .Finalize(url);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  url.forget(aURL);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxUrl::SetUri(const nsACString& aURI) {
+  mURI = aURI;
+  return NS_OK;
+}
+
+nsresult nsMailboxUrl::Clone(nsIURI** _retval) {
+  nsresult rv = nsMsgMailNewsUrl::Clone(_retval);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // also clone the mURI member, because GetUri below won't work if
+  // mURI isn't set due to nsIFile fun.
+  nsCOMPtr<nsIMsgMessageUrl> clonedUrl = do_QueryInterface(*_retval);
+  if (clonedUrl) clonedUrl->SetUri(mURI);
+  return rv;
+}
+
+NS_IMETHODIMP nsMailboxUrl::GetUri(nsACString& aURI) {
+  // if we have been given a uri to associate with this url, then use it
+  // otherwise try to reconstruct a URI on the fly....
+
+  if (!mURI.IsEmpty())
+    aURI = mURI;
+  else {
+    if (m_filePath) {
+      nsAutoCString baseUri;
+      nsresult rv;
+      nsCOMPtr<nsIMsgAccountManager> accountManager =
+          do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // we blow off errors here so that we can open attachments
+      // in .eml files.
+      (void)accountManager->FolderUriForPath(m_filePath, baseUri);
+      if (baseUri.IsEmpty()) {
+        rv = m_baseURL->GetSpec(baseUri);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      nsCString baseMessageURI;
+      nsCreateLocalBaseMessageURI(baseUri, baseMessageURI);
+      nsBuildLocalMessageURI(baseMessageURI, m_messageKey, aURI);
+    } else
+      aURI = "";
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMailboxUrl::GetMsgHdrForKey(nsMsgKey msgKey, nsIMsgDBHdr** aMsgHdr) {
+  nsresult rv = NS_OK;
+  if (aMsgHdr && m_filePath) {
+    nsCOMPtr<nsIMsgDatabase> mailDBFactory;
+    nsCOMPtr<nsIMsgDatabase> mailDB;
+    nsCOMPtr<nsIMsgDBService> msgDBService =
+        do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+
+    if (msgDBService) {
+      rv = msgDBService->OpenMailDBFromFile(m_filePath, nullptr, false, false,
+                                            getter_AddRefs(mailDB));
+    }
+    if (NS_SUCCEEDED(rv) && mailDB) {
+      // Did we get a db back?
+      rv = mailDB->GetMsgHdrForKey(msgKey, aMsgHdr);
+    } else {
+      rv = NS_OK;
+    }
+  } else {
+    rv = NS_ERROR_NULL_POINTER;
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMailboxUrl::GetMessageHeader(nsIMsgDBHdr** aMsgHdr) {
+  return GetMsgHdrForKey(m_messageKey, aMsgHdr);
+}
+
+NS_IMPL_GETSET(nsMailboxUrl, AddDummyEnvelope, bool, m_addDummyEnvelope)
+NS_IMPL_GETSET(nsMailboxUrl, CanonicalLineEnding, bool, m_canonicalLineEnding)
+
+NS_IMETHODIMP
+nsMailboxUrl::GetOriginalSpec(nsACString& aSpec) {
+  if (m_originalSpec.IsEmpty()) return NS_ERROR_NULL_POINTER;
+  aSpec = m_originalSpec;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailboxUrl::SetOriginalSpec(const nsACString& aSpec) {
+  m_originalSpec = aSpec;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxUrl::SetMessageFile(nsIFile* aFile) {
+  m_messageFile = aFile;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxUrl::GetMessageFile(nsIFile** aFile) {
+  // why don't we return an error for null aFile?
+  if (aFile) NS_IF_ADDREF(*aFile = m_messageFile);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxUrl::IsUrlType(uint32_t type, bool* isType) {
+  NS_ENSURE_ARG(isType);
+
+  switch (type) {
+    case nsIMsgMailNewsUrl::eCopy:
+      *isType = (m_mailboxAction == nsIMailboxUrl::ActionCopyMessage);
+      break;
+    case nsIMsgMailNewsUrl::eMove:
+      *isType = (m_mailboxAction == nsIMailboxUrl::ActionMoveMessage);
+      break;
+    case nsIMsgMailNewsUrl::eDisplay:
+      *isType = (m_mailboxAction == nsIMailboxUrl::ActionFetchMessage ||
+                 m_mailboxAction == nsIMailboxUrl::ActionFetchPart);
+      break;
+    default:
+      *isType = false;
+  };
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// End nsIMailboxUrl specific support
+////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+// possible search part phrases include: MessageID=id&number=MessageKey
+
+nsresult nsMailboxUrl::ParseSearchPart() {
+  nsAutoCString searchPart;
+  nsresult rv = GetQuery(searchPart);
+  // add code to this function to decompose everything past the '?'.....
+  if (NS_SUCCEEDED(rv) && !searchPart.IsEmpty()) {
+    // the action for this mailbox must be a display message...
+    char* msgPart = extractAttributeValue(searchPart.get(), "part=");
+    if (msgPart)  // if we have a part in the url then we must be fetching just
+                  // the part.
+      m_mailboxAction = nsIMailboxUrl::ActionFetchPart;
+    else
+      m_mailboxAction = nsIMailboxUrl::ActionFetchMessage;
+
+    char* messageKey = extractAttributeValue(searchPart.get(), "number=");
+    m_messageID = extractAttributeValue(searchPart.get(), "messageid=");
+    if (messageKey)
+      m_messageKey =
+          (nsMsgKey)ParseUint64Str(messageKey);  // convert to a uint32_t...
+
+    PR_Free(msgPart);
+    PR_Free(messageKey);
+  } else
+    m_mailboxAction = nsIMailboxUrl::ActionParseMailbox;
+
+  return rv;
+}
+
+// warning: don't assume when parsing the url that the protocol part is
+// "news"...
+nsresult nsMailboxUrl::ParseUrl() {
+  GetFilePath(m_file);
+
+  ParseSearchPart();
+  // ### fix me.
+  // this hack is to avoid asserting on every local message loaded because the
+  // security manager is creating an empty "mailbox://" uri for every message.
+  if (m_file.Length() < 2)
+    m_filePath = nullptr;
+  else {
+    nsCString fileUri("file://");
+    fileUri.Append(m_file);
+    nsresult rv;
+    nsCOMPtr<nsIIOService> ioService = mozilla::components::IO::Service();
+    NS_ENSURE_TRUE(ioService, NS_ERROR_UNEXPECTED);
+    nsCOMPtr<nsIURI> uri;
+    rv = ioService->NewURI(fileUri, 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));
+    NS_ENSURE_TRUE(fileURLFile, NS_ERROR_NULL_POINTER);
+    m_filePath = fileURLFile;
+  }
+
+  GetPathQueryRef(m_file);
+  return NS_OK;
+}
+
+nsresult nsMailboxUrl::SetSpecInternal(const nsACString& aSpec) {
+  nsresult rv = nsMsgMailNewsUrl::SetSpecInternal(aSpec);
+  if (NS_SUCCEEDED(rv)) {
+    // Do not try to parse URLs of the form
+    // mailbox://user@domain@server/folder?number=nn since this will fail.
+    // Check for format lacking absolute path.
+    if (PromiseFlatCString(aSpec).Find("///") != kNotFound) {
+      rv = ParseUrl();
+    } else {
+      // We still need to parse the search part to populate
+      // m_messageKey etc.
+      ParseSearchPart();
+    }
+  }
+  return rv;
+}
+
+nsresult nsMailboxUrl::SetQuery(const nsACString& aQuery) {
+  nsresult rv = nsMsgMailNewsUrl::SetQuery(aQuery);
+  if (NS_SUCCEEDED(rv)) rv = ParseUrl();
+  return rv;
+}
+
+// takes a string like ?messageID=fooo&number=MsgKey and returns a new string
+// containing just the attribute value. i.e you could pass in this string with
+// an attribute name of messageID and I'll return fooo. Use PR_Free to delete
+// this string...
+
+// Assumption: attribute pairs in the string are separated by '&'.
+char* extractAttributeValue(const char* searchString,
+                            const char* attributeName) {
+  char* attributeValue = nullptr;
+
+  if (searchString && attributeName) {
+    // search the string for attributeName
+    uint32_t attributeNameSize = PL_strlen(attributeName);
+    char* startOfAttribute = PL_strcasestr(searchString, attributeName);
+    if (startOfAttribute) {
+      startOfAttribute += attributeNameSize;  // skip over the attributeName
+      if (startOfAttribute)  // is there something after the attribute name
+      {
+        char* endOfAttribute = PL_strchr(startOfAttribute, '&');
+        nsDependentCString attributeValueStr;
+        if (startOfAttribute &&
+            endOfAttribute)  // is there text after attribute value
+          attributeValueStr.Assign(startOfAttribute,
+                                   endOfAttribute - startOfAttribute);
+        else  // there is nothing left so eat up rest of line.
+          attributeValueStr.Assign(startOfAttribute);
+
+        // now unescape the string...
+        nsCString unescapedValue;
+        MsgUnescapeString(attributeValueStr, 0, unescapedValue);
+        attributeValue = PL_strdup(unescapedValue.get());
+      }  // if we have a attribute value
+
+    }  // if we have a attribute name
+  }    // if we got non-null search string and attribute name values
+
+  return attributeValue;
+}
+
+// nsIMsgI18NUrl support
+
+nsresult nsMailboxUrl::GetFolder(nsIMsgFolder** msgFolder) {
+  // if we have a RDF URI, then try to get the folder for that URI and then ask
+  // the folder for it's charset....
+  nsCString uri;
+  GetUri(uri);
+  NS_ENSURE_TRUE(!uri.IsEmpty(), NS_ERROR_FAILURE);
+  nsCOMPtr<nsIMsgDBHdr> msg;
+  GetMsgDBHdrFromURI(uri, getter_AddRefs(msg));
+  if (!msg) return NS_ERROR_FAILURE;
+  return msg->GetFolder(msgFolder);
+}
+
+NS_IMETHODIMP nsMailboxUrl::GetAutodetectCharset(bool* aAutodetectCharset) {
+  *aAutodetectCharset = mAutodetectCharset;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxUrl::SetAutodetectCharset(bool aAutodetectCharset) {
+  mAutodetectCharset = aAutodetectCharset;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxUrl::SetMoveCopyMsgKeys(
+    const nsTArray<nsMsgKey>& keysToFlag) {
+  m_keys = keysToFlag.Clone();
+  if (!m_keys.IsEmpty() && m_messageKey == nsMsgKey_None)
+    m_messageKey = m_keys[0];
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMailboxUrl::GetMoveCopyMsgHdrForIndex(uint32_t msgIndex,
+                                                      nsIMsgDBHdr** msgHdr) {
+  NS_ENSURE_ARG(msgHdr);
+  if (msgIndex < m_keys.Length()) {
+    nsMsgKey nextKey = m_keys[msgIndex];
+    return GetMsgHdrForKey(nextKey, msgHdr);
+  }
+  return NS_MSG_MESSAGE_NOT_FOUND;
+}
+
+NS_IMETHODIMP nsMailboxUrl::GetNumMoveCopyMsgs(uint32_t* numMsgs) {
+  NS_ENSURE_ARG(numMsgs);
+  *numMsgs = m_keys.Length();
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsMailboxUrl.h b/comm/mailnews/local/src/nsMailboxUrl.h
new file mode 100644
index 0000000000..29b932e38c
--- /dev/null
+++ b/comm/mailnews/local/src/nsMailboxUrl.h
@@ -0,0 +1,106 @@
+/* -*- 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 nsMailboxUrl_h__
+#define nsMailboxUrl_h__
+
+#include "mozilla/Attributes.h"
+#include "nsIMailboxUrl.h"
+#include "nsMsgMailNewsUrl.h"
+#include "nsIStreamListener.h"
+#include "nsIFile.h"
+#include "nsCOMPtr.h"
+#include "MailNewsTypes.h"
+#include "nsTArray.h"
+
+class nsMailboxUrl : public nsIMailboxUrl,
+                     public nsMsgMailNewsUrl,
+                     public nsIMsgMessageUrl,
+                     public nsIMsgI18NUrl {
+ public:
+  // nsIMsgMailNewsUrl override
+  nsresult SetSpecInternal(const nsACString& aSpec) override;
+  nsresult SetQuery(const nsACString& aQuery) override;
+  nsresult CreateURL(const nsACString& aSpec, nsIURL** aURL) override;
+
+  // from nsIMailboxUrl:
+  NS_IMETHOD SetMailboxParser(nsIStreamListener* aConsumer) override;
+  NS_IMETHOD GetMailboxParser(nsIStreamListener** aConsumer) override;
+  NS_IMETHOD SetMailboxCopyHandler(nsIStreamListener* aConsumer) override;
+  NS_IMETHOD GetMailboxCopyHandler(nsIStreamListener** aConsumer) override;
+
+  NS_IMETHOD GetMessageKey(nsMsgKey* aMessageKey) override;
+  NS_IMETHOD GetMessageSize(uint32_t* aMessageSize) override;
+  NS_IMETHOD SetMessageSize(uint32_t aMessageSize) override;
+  NS_IMETHOD GetMailboxAction(nsMailboxAction* result) override {
+    NS_ENSURE_ARG_POINTER(result);
+    *result = m_mailboxAction;
+    return NS_OK;
+  }
+  NS_IMETHOD SetMailboxAction(nsMailboxAction aAction) override {
+    m_mailboxAction = aAction;
+    return NS_OK;
+  }
+  NS_IMETHOD IsUrlType(uint32_t type, bool* isType) override;
+  NS_IMETHOD SetMoveCopyMsgKeys(const nsTArray<nsMsgKey>& keysToFlag) override;
+  NS_IMETHOD GetMoveCopyMsgHdrForIndex(uint32_t msgIndex,
+                                       nsIMsgDBHdr** msgHdr) override;
+  NS_IMETHOD GetNumMoveCopyMsgs(uint32_t* numMsgs) override;
+  NS_IMETHOD GetCurMoveCopyMsgIndex(uint32_t* result) override {
+    NS_ENSURE_ARG_POINTER(result);
+    *result = m_curMsgIndex;
+    return NS_OK;
+  }
+  NS_IMETHOD SetCurMoveCopyMsgIndex(uint32_t aIndex) override {
+    m_curMsgIndex = aIndex;
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetFolder(nsIMsgFolder** msgFolder) override;
+
+  // nsMsgMailNewsUrl override
+  nsresult Clone(nsIURI** _retval) override;
+
+  // nsMailboxUrl
+  nsMailboxUrl();
+  NS_DECL_NSIMSGMESSAGEURL
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIMSGI18NURL
+
+ protected:
+  virtual ~nsMailboxUrl();
+  // protocol specific code to parse a url...
+  virtual nsresult ParseUrl();
+  nsresult GetMsgHdrForKey(nsMsgKey msgKey, nsIMsgDBHdr** aMsgHdr);
+
+  // mailboxurl specific state
+  nsCOMPtr<nsIStreamListener> m_mailboxParser;
+  nsCOMPtr<nsIStreamListener> m_mailboxCopyHandler;
+
+  nsMailboxAction m_mailboxAction;  // the action this url represents...parse
+                                    // mailbox, display messages, etc.
+  nsCOMPtr<nsIFile> m_filePath;
+  char* m_messageID;
+  uint32_t m_messageSize;
+  nsMsgKey m_messageKey;
+  nsCString m_file;
+
+  // used by save message to disk
+  nsCOMPtr<nsIFile> m_messageFile;
+  bool m_addDummyEnvelope;
+  bool m_canonicalLineEnding;
+  nsresult ParseSearchPart();
+
+  // for multiple msg move/copy
+  nsTArray<nsMsgKey> m_keys;
+  int32_t m_curMsgIndex;
+
+  // truncated message support
+  nsCString m_originalSpec;
+  nsCString mURI;           // the RDF URI associated with this url.
+  bool mAutodetectCharset;  // used by nsIMsgI18NUrl...
+};
+
+#endif  // nsMailboxUrl_h__
diff --git a/comm/mailnews/local/src/nsMsgBrkMBoxStore.cpp b/comm/mailnews/local/src/nsMsgBrkMBoxStore.cpp
new file mode 100644
index 0000000000..1f48b7d278
--- /dev/null
+++ b/comm/mailnews/local/src/nsMsgBrkMBoxStore.cpp
@@ -0,0 +1,1033 @@
+/* -*- 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/. */
+
+/**
+   Class for handling Berkeley Mailbox stores.
+*/
+
+#include "prlog.h"
+#include "msgCore.h"
+#include "nsMsgBrkMBoxStore.h"
+#include "nsIMsgFolder.h"
+#include "nsMsgFolderFlags.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIInputStream.h"
+#include "nsCOMArray.h"
+#include "nsIFile.h"
+#include "nsIDirectoryEnumerator.h"
+#include "nsIMsgHdr.h"
+#include "nsNetUtil.h"
+#include "nsIMsgDatabase.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsMsgUtils.h"
+#include "nsIDBFolderInfo.h"
+#include "nsMsgLocalFolderHdrs.h"
+#include "nsMailHeaders.h"
+#include "nsParseMailbox.h"
+#include "nsIMailboxService.h"
+#include "nsIMsgFolderCompactor.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsPrintfCString.h"
+#include "nsQuarantinedOutputStream.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/SlicedInputStream.h"
+#include "prprf.h"
+#include <cstdlib>  // for std::abs(int/long)
+#include <cmath>    // for std::abs(float/double)
+
+nsMsgBrkMBoxStore::nsMsgBrkMBoxStore() {}
+
+nsMsgBrkMBoxStore::~nsMsgBrkMBoxStore() {}
+
+NS_IMPL_ISUPPORTS(nsMsgBrkMBoxStore, nsIMsgPluggableStore)
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::DiscoverSubFolders(nsIMsgFolder* aParentFolder,
+                                                    bool aDeep) {
+  NS_ENSURE_ARG_POINTER(aParentFolder);
+
+  nsCOMPtr<nsIFile> path;
+  nsresult rv = aParentFolder->GetFilePath(getter_AddRefs(path));
+  if (NS_FAILED(rv)) return rv;
+
+  bool exists;
+  path->Exists(&exists);
+  if (!exists) {
+    rv = path->Create(nsIFile::DIRECTORY_TYPE, 0755);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return AddSubFolders(aParentFolder, path, aDeep);
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::CreateFolder(nsIMsgFolder* aParent,
+                                              const nsAString& aFolderName,
+                                              nsIMsgFolder** aResult) {
+  NS_ENSURE_ARG_POINTER(aParent);
+  NS_ENSURE_ARG_POINTER(aResult);
+  if (aFolderName.IsEmpty()) return NS_MSG_ERROR_INVALID_FOLDER_NAME;
+
+  nsCOMPtr<nsIFile> path;
+  nsCOMPtr<nsIMsgFolder> child;
+  nsresult rv = aParent->GetFilePath(getter_AddRefs(path));
+  if (NS_FAILED(rv)) return rv;
+  // Get a directory based on our current path.
+  rv = CreateDirectoryForFolder(path);
+  if (NS_FAILED(rv)) return rv;
+
+  // Now we have a valid directory or we have returned.
+  // Make sure the new folder name is valid
+  nsAutoString safeFolderName(aFolderName);
+  NS_MsgHashIfNecessary(safeFolderName);
+
+  path->Append(safeFolderName);
+  bool exists;
+  path->Exists(&exists);
+  if (exists)  // check this because localized names are different from disk
+               // names
+    return NS_MSG_FOLDER_EXISTS;
+
+  rv = path->Create(nsIFile::NORMAL_FILE_TYPE, 0600);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // GetFlags and SetFlags in AddSubfolder will fail because we have no db at
+  // this point but mFlags is set.
+  rv = aParent->AddSubfolder(safeFolderName, getter_AddRefs(child));
+  if (!child || NS_FAILED(rv)) {
+    path->Remove(false);
+    return rv;
+  }
+  // Create an empty database for this mail folder, set its name from the user
+  nsCOMPtr<nsIMsgDBService> msgDBService =
+      do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+  if (msgDBService) {
+    nsCOMPtr<nsIMsgDatabase> unusedDB;
+    rv = msgDBService->OpenFolderDB(child, true, getter_AddRefs(unusedDB));
+    if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING)
+      rv = msgDBService->CreateNewDB(child, getter_AddRefs(unusedDB));
+
+    if ((NS_SUCCEEDED(rv) || rv == NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE) &&
+        unusedDB) {
+      // need to set the folder name
+      nsCOMPtr<nsIDBFolderInfo> folderInfo;
+      rv = unusedDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+      if (NS_SUCCEEDED(rv)) folderInfo->SetMailboxName(safeFolderName);
+
+      unusedDB->SetSummaryValid(true);
+      unusedDB->Close(true);
+      aParent->UpdateSummaryTotals(true);
+    } else {
+      path->Remove(false);
+      rv = NS_MSG_CANT_CREATE_FOLDER;
+    }
+  }
+  child.forget(aResult);
+  return rv;
+}
+
+// Get the current attributes of the mbox file, corrected for caching
+void nsMsgBrkMBoxStore::GetMailboxModProperties(nsIMsgFolder* aFolder,
+                                                int64_t* aSize,
+                                                uint32_t* aDate) {
+  // We'll simply return 0 on errors.
+  *aDate = 0;
+  *aSize = 0;
+  nsCOMPtr<nsIFile> pathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  rv = pathFile->GetFileSize(aSize);
+  if (NS_FAILED(rv)) return;  // expected result for virtual folders
+
+  PRTime lastModTime;
+  rv = pathFile->GetLastModifiedTime(&lastModTime);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  *aDate = (uint32_t)(lastModTime / PR_MSEC_PER_SEC);
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::HasSpaceAvailable(nsIMsgFolder* aFolder,
+                                                   int64_t aSpaceRequested,
+                                                   bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  NS_ENSURE_ARG_POINTER(aFolder);
+
+  nsCOMPtr<nsIFile> pathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool allow4GBfolders =
+      mozilla::Preferences::GetBool("mailnews.allowMboxOver4GB", true);
+
+  if (!allow4GBfolders) {
+    // Allow the mbox to only reach 0xFFC00000 = 4 GiB - 4 MiB.
+    int64_t fileSize;
+    rv = pathFile->GetFileSize(&fileSize);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    *aResult = ((fileSize + aSpaceRequested) < 0xFFC00000LL);
+    if (!*aResult) return NS_ERROR_FILE_TOO_BIG;
+  }
+
+  *aResult = DiskSpaceAvailableInStore(pathFile, aSpaceRequested);
+  if (!*aResult) return NS_ERROR_FILE_NO_DEVICE_SPACE;
+
+  return NS_OK;
+}
+
+static bool gGotGlobalPrefs = false;
+static int32_t gTimeStampLeeway = 60;
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::IsSummaryFileValid(nsIMsgFolder* aFolder,
+                                                    nsIMsgDatabase* aDB,
+                                                    bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aDB);
+  NS_ENSURE_ARG_POINTER(aResult);
+  // We only check local folders for db validity.
+  nsCOMPtr<nsIMsgLocalMailFolder> localFolder(do_QueryInterface(aFolder));
+  if (!localFolder) {
+    *aResult = true;
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIFile> pathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIDBFolderInfo> folderInfo;
+  rv = aDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+  NS_ENSURE_SUCCESS(rv, rv);
+  int64_t folderSize;
+  uint32_t folderDate;
+  int32_t numUnreadMessages;
+
+  *aResult = false;
+
+  folderInfo->GetNumUnreadMessages(&numUnreadMessages);
+  folderInfo->GetFolderSize(&folderSize);
+  folderInfo->GetFolderDate(&folderDate);
+
+  int64_t fileSize = 0;
+  uint32_t actualFolderTimeStamp = 0;
+  GetMailboxModProperties(aFolder, &fileSize, &actualFolderTimeStamp);
+
+  if (folderSize == fileSize && numUnreadMessages >= 0) {
+    if (!folderSize) {
+      *aResult = true;
+      return NS_OK;
+    }
+    if (!gGotGlobalPrefs) {
+      nsCOMPtr<nsIPrefBranch> pPrefBranch(
+          do_GetService(NS_PREFSERVICE_CONTRACTID));
+      if (pPrefBranch) {
+        rv = pPrefBranch->GetIntPref("mail.db_timestamp_leeway",
+                                     &gTimeStampLeeway);
+        gGotGlobalPrefs = true;
+      }
+    }
+    // if those values are ok, check time stamp
+    if (gTimeStampLeeway == 0)
+      *aResult = folderDate == actualFolderTimeStamp;
+    else
+      *aResult = std::abs((int32_t)(actualFolderTimeStamp - folderDate)) <=
+                 gTimeStampLeeway;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::SetSummaryFileValid(nsIMsgFolder* aFolder,
+                                                     nsIMsgDatabase* aDB,
+                                                     bool aValid) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aDB);
+  // We only need to do this for local folders.
+  nsCOMPtr<nsIMsgLocalMailFolder> localFolder(do_QueryInterface(aFolder));
+  if (!localFolder) return NS_OK;
+
+  nsCOMPtr<nsIFile> pathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIDBFolderInfo> folderInfo;
+  rv = aDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool exists;
+  pathFile->Exists(&exists);
+  if (!exists) return NS_MSG_ERROR_FOLDER_MISSING;
+
+  if (aValid) {
+    uint32_t actualFolderTimeStamp;
+    int64_t fileSize;
+    GetMailboxModProperties(aFolder, &fileSize, &actualFolderTimeStamp);
+    folderInfo->SetFolderSize(fileSize);
+    folderInfo->SetFolderDate(actualFolderTimeStamp);
+  } else {
+    folderInfo->SetVersion(0);  // that ought to do the trick.
+  }
+  aDB->Commit(nsMsgDBCommitType::kLargeCommit);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::DeleteFolder(nsIMsgFolder* aFolder) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  bool exists;
+
+  // Delete mbox file.
+  nsCOMPtr<nsIFile> pathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  exists = false;
+  pathFile->Exists(&exists);
+  if (exists) {
+    rv = pathFile->Remove(false);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Delete any subfolders (.sbd-suffixed directories).
+  AddDirectorySeparator(pathFile);
+  exists = false;
+  pathFile->Exists(&exists);
+  if (exists) {
+    rv = pathFile->Remove(true);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::RenameFolder(nsIMsgFolder* aFolder,
+                                              const nsAString& aNewName,
+                                              nsIMsgFolder** aNewFolder) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aNewFolder);
+
+  uint32_t numChildren;
+  aFolder->GetNumSubFolders(&numChildren);
+  nsString existingName;
+  aFolder->GetName(existingName);
+
+  nsCOMPtr<nsIFile> oldPathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(oldPathFile));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIMsgFolder> parentFolder;
+  rv = aFolder->GetParent(getter_AddRefs(parentFolder));
+  if (!parentFolder) return NS_ERROR_NULL_POINTER;
+
+  nsCOMPtr<nsIFile> oldSummaryFile;
+  rv = aFolder->GetSummaryFile(getter_AddRefs(oldSummaryFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> dirFile;
+  oldPathFile->Clone(getter_AddRefs(dirFile));
+
+  if (numChildren > 0) {
+    rv = CreateDirectoryForFolder(dirFile);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsAutoString safeName(aNewName);
+  NS_MsgHashIfNecessary(safeName);
+
+  nsAutoCString oldLeafName;
+  oldPathFile->GetNativeLeafName(oldLeafName);
+
+  nsCOMPtr<nsIFile> parentPathFile;
+  parentFolder->GetFilePath(getter_AddRefs(parentPathFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool isDirectory = false;
+  parentPathFile->IsDirectory(&isDirectory);
+  if (!isDirectory) {
+    nsAutoString leafName;
+    parentPathFile->GetLeafName(leafName);
+    leafName.AppendLiteral(FOLDER_SUFFIX);
+    rv = parentPathFile->SetLeafName(leafName);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  aFolder->ForceDBClosed();
+  // save off dir name before appending .msf
+  rv = oldPathFile->MoveTo(nullptr, safeName);
+  if (NS_FAILED(rv)) return rv;
+
+  nsString dbName(safeName);
+  dbName.AppendLiteral(SUMMARY_SUFFIX);
+  oldSummaryFile->MoveTo(nullptr, dbName);
+
+  if (numChildren > 0) {
+    // rename "*.sbd" directory
+    nsAutoString newNameDirStr(safeName);
+    newNameDirStr.AppendLiteral(FOLDER_SUFFIX);
+    dirFile->MoveTo(nullptr, newNameDirStr);
+  }
+
+  return parentFolder->AddSubfolder(safeName, aNewFolder);
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::CopyFolder(
+    nsIMsgFolder* aSrcFolder, nsIMsgFolder* aDstFolder, bool aIsMoveFolder,
+    nsIMsgWindow* aMsgWindow, nsIMsgCopyServiceListener* aListener,
+    const nsAString& aNewName) {
+  NS_ENSURE_ARG_POINTER(aSrcFolder);
+  NS_ENSURE_ARG_POINTER(aDstFolder);
+
+  nsAutoString folderName;
+  if (aNewName.IsEmpty())
+    aSrcFolder->GetName(folderName);
+  else
+    folderName.Assign(aNewName);
+
+  nsAutoString safeFolderName(folderName);
+  NS_MsgHashIfNecessary(safeFolderName);
+  nsCOMPtr<nsIMsgLocalMailFolder> localSrcFolder(do_QueryInterface(aSrcFolder));
+  nsCOMPtr<nsIMsgDatabase> srcDB;
+  if (localSrcFolder)
+    localSrcFolder->GetDatabaseWOReparse(getter_AddRefs(srcDB));
+  bool summaryValid = !!srcDB;
+  srcDB = nullptr;
+  aSrcFolder->ForceDBClosed();
+
+  nsCOMPtr<nsIFile> oldPath;
+  nsresult rv = aSrcFolder->GetFilePath(getter_AddRefs(oldPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> summaryFile;
+  GetSummaryFileLocation(oldPath, getter_AddRefs(summaryFile));
+
+  nsCOMPtr<nsIFile> newPath;
+  rv = aDstFolder->GetFilePath(getter_AddRefs(newPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool newPathIsDirectory = false;
+  newPath->IsDirectory(&newPathIsDirectory);
+  if (!newPathIsDirectory) {
+    AddDirectorySeparator(newPath);
+    rv = newPath->Create(nsIFile::DIRECTORY_TYPE, 0700);
+    if (rv == NS_ERROR_FILE_ALREADY_EXISTS) rv = NS_OK;
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCOMPtr<nsIFile> origPath;
+  oldPath->Clone(getter_AddRefs(origPath));
+
+  // copying necessary for aborting.... if failure return
+  rv = oldPath->CopyTo(newPath, safeFolderName);
+  NS_ENSURE_SUCCESS(rv, rv);  // Will fail if a file by that name exists
+
+  // Copy to dir can fail if filespec does not exist. If copy fails, we test
+  // if the filespec exist or not, if it does not that's ok, we continue
+  // without copying it. If it fails and filespec exist and is not zero sized
+  // there is real problem
+  // Copy the file to the new dir
+  nsAutoString dbName(safeFolderName);
+  dbName.AppendLiteral(SUMMARY_SUFFIX);
+  rv = summaryFile->CopyTo(newPath, dbName);
+  if (NS_FAILED(rv))  // Test if the copy is successful
+  {
+    // Test if the filespec has data
+    bool exists;
+    int64_t fileSize;
+    summaryFile->Exists(&exists);
+    summaryFile->GetFileSize(&fileSize);
+    if (exists && fileSize > 0)
+      NS_ENSURE_SUCCESS(rv, rv);  // Yes, it should have worked !
+    // else case is filespec is zero sized, no need to copy it,
+    // not an error
+  }
+
+  nsCOMPtr<nsIMsgFolder> newMsgFolder;
+  rv = aDstFolder->AddSubfolder(safeFolderName, getter_AddRefs(newMsgFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // linux and mac are not good about maintaining the file stamp when copying
+  // folders around. So if the source folder db is good, set the dest db as
+  // good too.
+  nsCOMPtr<nsIMsgDatabase> destDB;
+  if (summaryValid) {
+    nsAutoString folderLeafName;
+    origPath->GetLeafName(folderLeafName);
+    newPath->Append(folderLeafName);
+    nsCOMPtr<nsIMsgDBService> msgDBService =
+        do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = msgDBService->OpenMailDBFromFile(newPath, newMsgFolder, false, true,
+                                          getter_AddRefs(destDB));
+    if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE && destDB)
+      destDB->SetSummaryValid(true);
+  }
+  newMsgFolder->SetPrettyName(folderName);
+  uint32_t flags;
+  aSrcFolder->GetFlags(&flags);
+  newMsgFolder->SetFlags(flags);
+  bool changed = false;
+  rv = aSrcFolder->MatchOrChangeFilterDestination(newMsgFolder, true, &changed);
+  if (changed) aSrcFolder->AlertFilterChanged(aMsgWindow);
+
+  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+  rv = aSrcFolder->GetSubFolders(subFolders);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Copy subfolders to the new location
+  nsresult copyStatus = NS_OK;
+  nsCOMPtr<nsIMsgLocalMailFolder> localNewFolder(
+      do_QueryInterface(newMsgFolder, &rv));
+  if (NS_SUCCEEDED(rv)) {
+    for (nsIMsgFolder* folder : subFolders) {
+      copyStatus =
+          localNewFolder->CopyFolderLocal(folder, false, aMsgWindow, aListener);
+      // Test if the call succeeded, if not we have to stop recursive call
+      if (NS_FAILED(copyStatus)) {
+        // Copy failed we have to notify caller to handle the error and stop
+        // moving the folders. In case this happens to the topmost level of
+        // recursive call, then we just need to break from the while loop and
+        // go to error handling code.
+        if (!aIsMoveFolder) return copyStatus;
+        break;
+      }
+    }
+  }
+
+  if (aIsMoveFolder && NS_SUCCEEDED(copyStatus)) {
+    if (localNewFolder) {
+      nsCOMPtr<nsISupports> srcSupport(do_QueryInterface(aSrcFolder));
+      localNewFolder->OnCopyCompleted(srcSupport, true);
+    }
+
+    // Notify the "folder" that was dragged and dropped has been created. No
+    // need to do this for its subfolders. isMoveFolder will be true for folder.
+    aDstFolder->NotifyFolderAdded(newMsgFolder);
+
+    nsCOMPtr<nsIMsgFolder> msgParent;
+    aSrcFolder->GetParent(getter_AddRefs(msgParent));
+    aSrcFolder->SetParent(nullptr);
+    if (msgParent) {
+      // The files have already been moved, so delete storage false
+      msgParent->PropagateDelete(aSrcFolder, false);
+      oldPath->Remove(false);  // berkeley mailbox
+      aSrcFolder->DeleteStorage();
+
+      nsCOMPtr<nsIFile> parentPath;
+      rv = msgParent->GetFilePath(getter_AddRefs(parentPath));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      AddDirectorySeparator(parentPath);
+      nsCOMPtr<nsIDirectoryEnumerator> children;
+      parentPath->GetDirectoryEntries(getter_AddRefs(children));
+      bool more;
+      // checks if the directory is empty or not
+      if (children && NS_SUCCEEDED(children->HasMoreElements(&more)) && !more)
+        parentPath->Remove(true);
+    }
+  } else {
+    // This is the case where the copy of a subfolder failed.
+    // We have to delete the newDirectory tree to make a "rollback".
+    // Someone should add a popup to warn the user that the move was not
+    // possible.
+    if (aIsMoveFolder && NS_FAILED(copyStatus)) {
+      nsCOMPtr<nsIMsgFolder> msgParent;
+      newMsgFolder->ForceDBClosed();
+      newMsgFolder->GetParent(getter_AddRefs(msgParent));
+      newMsgFolder->SetParent(nullptr);
+      if (msgParent) {
+        msgParent->PropagateDelete(newMsgFolder, false);
+        newMsgFolder->DeleteStorage();
+        AddDirectorySeparator(newPath);
+        newPath->Remove(true);  // berkeley mailbox
+      }
+      return NS_ERROR_FAILURE;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgBrkMBoxStore::GetNewMsgOutputStream(nsIMsgFolder* aFolder,
+                                         nsIMsgDBHdr** aNewMsgHdr,
+                                         nsIOutputStream** aResult) {
+  bool quarantining = false;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (prefBranch) {
+    prefBranch->GetBoolPref("mailnews.downloadToTempFile", &quarantining);
+  }
+
+  if (!quarantining) {
+    // Caller will write directly to mbox.
+    return InternalGetNewMsgOutputStream(aFolder, aNewMsgHdr, aResult);
+  }
+
+  // Quarantining is on, so we want to write the new message to a temp file
+  // and let the virus checker have at it before we append it to the mbox.
+  // We'll wrap the mboxStream with an nsQuarantinedOutputStream and return
+  // that.
+  nsCOMPtr<nsIOutputStream> mboxStream;
+  nsresult rv = InternalGetNewMsgOutputStream(aFolder, aNewMsgHdr,
+                                              getter_AddRefs(mboxStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<nsQuarantinedOutputStream> qStream =
+      new nsQuarantinedOutputStream(mboxStream);
+  qStream.forget(aResult);
+  return NS_OK;
+}
+
+nsresult nsMsgBrkMBoxStore::InternalGetNewMsgOutputStream(
+    nsIMsgFolder* aFolder, nsIMsgDBHdr** aNewMsgHdr,
+    nsIOutputStream** aResult) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aNewMsgHdr);
+  NS_ENSURE_ARG_POINTER(aResult);
+
+#ifdef _DEBUG
+  NS_ASSERTION(m_streamOutstandingFolder != aFolder, "didn't finish prev msg");
+  m_streamOutstandingFolder = aFolder;
+#endif
+
+  nsresult rv;
+  nsCOMPtr<nsIFile> mboxFile;
+  rv = aFolder->GetFilePath(getter_AddRefs(mboxFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgDatabase> db;
+  aFolder->GetMsgDatabase(getter_AddRefs(db));
+  if (!db && !*aNewMsgHdr) NS_WARNING("no db, and no message header");
+  bool exists = false;
+  mboxFile->Exists(&exists);
+  if (!exists) {
+    rv = mboxFile->Create(nsIFile::NORMAL_FILE_TYPE, 0600);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCString URI;
+  aFolder->GetURI(URI);
+  nsCOMPtr<nsISeekableStream> seekable;
+  if (m_outputStreams.Get(URI, aResult)) {
+    seekable = do_QueryInterface(*aResult, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = seekable->Seek(nsISeekableStream::NS_SEEK_END, 0);
+    if (NS_FAILED(rv)) {
+      m_outputStreams.Remove(URI);
+      NS_RELEASE(*aResult);
+    }
+  }
+  if (!*aResult) {
+    rv = MsgGetFileStream(mboxFile, aResult);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "failed opening offline store for output");
+    if (NS_FAILED(rv))
+      printf("failed opening offline store for %s\n", URI.get());
+    NS_ENSURE_SUCCESS(rv, rv);
+    seekable = do_QueryInterface(*aResult, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = seekable->Seek(nsISeekableStream::NS_SEEK_END, 0);
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_outputStreams.InsertOrUpdate(URI, *aResult);
+  }
+  int64_t filePos;
+  seekable->Tell(&filePos);
+
+  if (db && !*aNewMsgHdr) {
+    db->CreateNewHdr(nsMsgKey_None, aNewMsgHdr);
+  }
+
+  if (*aNewMsgHdr) {
+    nsCString storeToken = nsPrintfCString("%" PRId64, filePos);
+    (*aNewMsgHdr)->SetStringProperty("storeToken", storeToken);
+    (*aNewMsgHdr)->SetMessageOffset(filePos);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgBrkMBoxStore::DiscardNewMessage(nsIOutputStream* aOutputStream,
+                                     nsIMsgDBHdr* aNewHdr) {
+  NS_ENSURE_ARG_POINTER(aOutputStream);
+  NS_ENSURE_ARG_POINTER(aNewHdr);
+#ifdef _DEBUG
+  m_streamOutstandingFolder = nullptr;
+#endif
+  nsCOMPtr<nsISafeOutputStream> safe = do_QueryInterface(aOutputStream);
+  if (safe) {
+    // nsISafeOutputStream only writes upon finish(), so no cleanup required.
+    return aOutputStream->Close();
+  }
+  // Truncate the mbox back to where we started writing.
+  uint64_t hdrOffset;
+  aNewHdr->GetMessageOffset(&hdrOffset);
+  aOutputStream->Close();
+  nsCOMPtr<nsIFile> mboxFile;
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = aNewHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = folder->GetFilePath(getter_AddRefs(mboxFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return mboxFile->SetFileSize(hdrOffset);
+}
+
+NS_IMETHODIMP
+nsMsgBrkMBoxStore::FinishNewMessage(nsIOutputStream* aOutputStream,
+                                    nsIMsgDBHdr* aNewHdr) {
+  NS_ENSURE_ARG_POINTER(aOutputStream);
+#ifdef _DEBUG
+  m_streamOutstandingFolder = nullptr;
+#endif
+  // Quarantining is implemented using a nsISafeOutputStream.
+  // It requires an explicit commit, or the data will be discarded.
+  nsCOMPtr<nsISafeOutputStream> safe = do_QueryInterface(aOutputStream);
+  if (safe) {
+    return safe->Finish();
+  }
+  aOutputStream->Close();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgBrkMBoxStore::MoveNewlyDownloadedMessage(nsIMsgDBHdr* aNewHdr,
+                                              nsIMsgFolder* aDestFolder,
+                                              bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aNewHdr);
+  NS_ENSURE_ARG_POINTER(aDestFolder);
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgBrkMBoxStore::GetMsgInputStream(nsIMsgFolder* aMsgFolder,
+                                     const nsACString& aMsgToken,
+                                     nsIInputStream** aResult) {
+  MOZ_ASSERT(aMsgFolder);
+  MOZ_ASSERT(aResult);
+  MOZ_ASSERT(!aMsgToken.IsEmpty());
+
+  uint64_t offset = ParseUint64Str(PromiseFlatCString(aMsgToken).get());
+  nsCOMPtr<nsIFile> mboxFile;
+  nsresult rv = aMsgFolder->GetFilePath(getter_AddRefs(mboxFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIInputStream> msgStream;
+  rv = NS_NewLocalFileInputStream(getter_AddRefs(msgStream), mboxFile);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsISeekableStream> seekable(do_QueryInterface(msgStream));
+  rv = seekable->Seek(PR_SEEK_SET, offset);
+  NS_ENSURE_SUCCESS(rv, rv);
+  msgStream.forget(aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::DeleteMessages(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aHdrArray) {
+  return ChangeFlags(aHdrArray, nsMsgMessageFlags::Expunged, true);
+}
+
+NS_IMETHODIMP
+nsMsgBrkMBoxStore::CopyMessages(bool isMove,
+                                const nsTArray<RefPtr<nsIMsgDBHdr>>& aHdrArray,
+                                nsIMsgFolder* aDstFolder,
+                                nsTArray<RefPtr<nsIMsgDBHdr>>& aDstHdrs,
+                                nsITransaction** aUndoAction, bool* aCopyDone) {
+  NS_ENSURE_ARG_POINTER(aDstFolder);
+  NS_ENSURE_ARG_POINTER(aCopyDone);
+  aDstHdrs.Clear();
+  *aUndoAction = nullptr;
+  // We return false to indicate there's no shortcut. The calling code will
+  // just have to perform the copy the hard way.
+  *aCopyDone = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgBrkMBoxStore::GetSupportsCompaction(bool* aSupportsCompaction) {
+  NS_ENSURE_ARG_POINTER(aSupportsCompaction);
+  *aSupportsCompaction = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::CompactFolder(nsIMsgFolder* aFolder,
+                                               nsIUrlListener* aListener,
+                                               nsIMsgWindow* aMsgWindow) {
+  // Eventually, folder compaction should be managed by nsMsgBrkMBoxStore, but
+  // for now it's separate (see nsMsgFolderCompactor) and invoked via the
+  // folder methods Compact() and CompactAll().
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::RebuildIndex(nsIMsgFolder* aFolder,
+                                              nsIMsgDatabase* aMsgDB,
+                                              nsIMsgWindow* aMsgWindow,
+                                              nsIUrlListener* aListener) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  nsCOMPtr<nsIFile> pathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
+  if (NS_FAILED(rv)) return rv;
+
+  bool isLocked;
+  aFolder->GetLocked(&isLocked);
+  if (isLocked) {
+    NS_ASSERTION(false, "Could not get folder lock");
+    return NS_MSG_FOLDER_BUSY;
+  }
+
+  nsCOMPtr<nsIMailboxService> mailboxService =
+      do_GetService("@mozilla.org/messenger/mailboxservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<nsMsgMailboxParser> parser = new nsMsgMailboxParser(aFolder);
+  NS_ENSURE_TRUE(parser, NS_ERROR_OUT_OF_MEMORY);
+  rv = parser->Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mailboxService->ParseMailbox(aMsgWindow, pathFile, parser, aListener,
+                                    nullptr);
+  if (NS_SUCCEEDED(rv)) ResetForceReparse(aMsgDB);
+  return rv;
+}
+
+nsresult nsMsgBrkMBoxStore::GetOutputStream(
+    nsIMsgDBHdr* aHdr, nsCOMPtr<nsIOutputStream>& outputStream,
+    nsCOMPtr<nsISeekableStream>& seekableStream, int64_t& restorePos) {
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = aHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCString URI;
+  folder->GetURI(URI);
+  restorePos = -1;
+  if (m_outputStreams.Get(URI, getter_AddRefs(outputStream))) {
+    seekableStream = do_QueryInterface(outputStream);
+    rv = seekableStream->Tell(&restorePos);
+    if (NS_FAILED(rv)) {
+      outputStream = nullptr;
+      m_outputStreams.Remove(URI);
+    }
+  }
+  if (!outputStream) {
+    nsCOMPtr<nsIFile> mboxFile;
+    rv = folder->GetFilePath(getter_AddRefs(mboxFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = MsgGetFileStream(mboxFile, getter_AddRefs(outputStream));
+    seekableStream = do_QueryInterface(outputStream);
+    if (NS_SUCCEEDED(rv)) m_outputStreams.InsertOrUpdate(URI, outputStream);
+  }
+  return rv;
+}
+
+void nsMsgBrkMBoxStore::SetDBValid(nsIMsgDBHdr* aHdr) {
+  nsCOMPtr<nsIMsgFolder> folder;
+  aHdr->GetFolder(getter_AddRefs(folder));
+  if (folder) {
+    nsCOMPtr<nsIMsgDatabase> db;
+    folder->GetMsgDatabase(getter_AddRefs(db));
+    if (db) SetSummaryFileValid(folder, db, true);
+  }
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::ChangeFlags(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aHdrArray, uint32_t aFlags,
+    bool aSet) {
+  if (aHdrArray.IsEmpty()) return NS_ERROR_INVALID_ARG;
+
+  nsCOMPtr<nsIOutputStream> outputStream;
+  nsCOMPtr<nsISeekableStream> seekableStream;
+  int64_t restoreStreamPos;
+  nsresult rv = GetOutputStream(aHdrArray[0], outputStream, seekableStream,
+                                restoreStreamPos);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  for (auto msgHdr : aHdrArray) {
+    // Work out the flags we want to write.
+    uint32_t flags = 0;
+    (void)msgHdr->GetFlags(&flags);
+    flags &= ~(nsMsgMessageFlags::RuntimeOnly | nsMsgMessageFlags::Offline);
+    if (aSet) {
+      flags |= aFlags;
+    } else {
+      flags &= ~aFlags;
+    }
+
+    // Rewrite flags into X-Mozilla-Status headers.
+    nsCOMPtr<nsISeekableStream> seekable(do_QueryInterface(outputStream, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    uint64_t msgOffset;
+    rv = msgHdr->GetMessageOffset(&msgOffset);
+    NS_ENSURE_SUCCESS(rv, rv);
+    seekable->Seek(nsISeekableStream::NS_SEEK_SET, msgOffset);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = RewriteMsgFlags(seekable, flags);
+    if (NS_FAILED(rv)) {
+      break;
+    }
+  }
+  if (restoreStreamPos != -1)
+    seekableStream->Seek(nsISeekableStream::NS_SEEK_SET, restoreStreamPos);
+  else if (outputStream)
+    outputStream->Close();
+  SetDBValid(aHdrArray[0]);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::ChangeKeywords(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aHdrArray, const nsACString& aKeywords,
+    bool aAdd) {
+  if (aHdrArray.IsEmpty()) return NS_ERROR_INVALID_ARG;
+
+  nsTArray<nsCString> keywordsToAdd;
+  nsTArray<nsCString> keywordsToRemove;
+  if (aAdd) {
+    ParseString(aKeywords, ' ', keywordsToAdd);
+  } else {
+    ParseString(aKeywords, ' ', keywordsToRemove);
+  }
+
+  // Get the (possibly-cached) seekable & writable stream for this mbox.
+  nsCOMPtr<nsIOutputStream> output;
+  nsCOMPtr<nsISeekableStream> seekable;
+  int64_t restoreStreamPos;
+  nsresult rv =
+      GetOutputStream(aHdrArray[0], output, seekable, restoreStreamPos);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (auto msgHdr : aHdrArray) {
+    uint64_t msgStart;
+    msgHdr->GetMessageOffset(&msgStart);
+    seekable->Seek(nsISeekableStream::NS_SEEK_SET, msgStart);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    bool notEnoughRoom;
+    rv = ChangeKeywordsHelper(seekable, keywordsToAdd, keywordsToRemove,
+                              notEnoughRoom);
+
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (notEnoughRoom) {
+      // The growKeywords property indicates that the X-Mozilla-Keys header
+      // doesn't have enough space, and should be rebuilt during the next
+      // folder compaction.
+      msgHdr->SetUint32Property("growKeywords", 1);
+    }
+  }
+
+  if (restoreStreamPos != -1) {
+    seekable->Seek(nsISeekableStream::NS_SEEK_SET, restoreStreamPos);
+  } else if (output) {
+    output->Close();
+  }
+  SetDBValid(aHdrArray[0]);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBrkMBoxStore::GetStoreType(nsACString& aType) {
+  aType.AssignLiteral("mbox");
+  return NS_OK;
+}
+
+// Iterates over the files in the "path" directory, and adds subfolders to
+// parent for each mailbox file found.
+nsresult nsMsgBrkMBoxStore::AddSubFolders(nsIMsgFolder* parent,
+                                          nsCOMPtr<nsIFile>& path, bool deep) {
+  nsresult rv;
+  nsCOMPtr<nsIFile> tmp;  // at top level so we can safely assign to path
+  bool isDirectory;
+  path->IsDirectory(&isDirectory);
+  if (!isDirectory) {
+    rv = path->Clone(getter_AddRefs(tmp));
+    path = tmp;
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoString leafName;
+    path->GetLeafName(leafName);
+    leafName.AppendLiteral(FOLDER_SUFFIX);
+    path->SetLeafName(leafName);
+    path->IsDirectory(&isDirectory);
+  }
+  if (!isDirectory) return NS_OK;
+  // first find out all the current subfolders and files, before using them
+  // while creating new subfolders; we don't want to modify and iterate the same
+  // directory at once.
+  nsCOMArray<nsIFile> currentDirEntries;
+  nsCOMPtr<nsIDirectoryEnumerator> directoryEnumerator;
+  rv = path->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool hasMore;
+  while (NS_SUCCEEDED(directoryEnumerator->HasMoreElements(&hasMore)) &&
+         hasMore) {
+    nsCOMPtr<nsIFile> currentFile;
+    rv = directoryEnumerator->GetNextFile(getter_AddRefs(currentFile));
+    if (NS_SUCCEEDED(rv) && currentFile) {
+      currentDirEntries.AppendObject(currentFile);
+    }
+  }
+
+  // add the folders
+  int32_t count = currentDirEntries.Count();
+  for (int32_t i = 0; i < count; ++i) {
+    nsCOMPtr<nsIFile> currentFile(currentDirEntries[i]);
+
+    nsAutoString leafName;
+    currentFile->GetLeafName(leafName);
+    // here we should handle the case where the current file is a .sbd directory
+    // w/o a matching folder file, or a directory w/o the name .sbd
+    if (nsShouldIgnoreFile(leafName, currentFile)) continue;
+
+    nsCOMPtr<nsIMsgFolder> child;
+    rv = parent->AddSubfolder(leafName, getter_AddRefs(child));
+    if (NS_FAILED(rv) && rv != NS_MSG_FOLDER_EXISTS) {
+      return rv;
+    }
+    if (child) {
+      nsString folderName;
+      child->GetName(folderName);  // try to get it from cache/db
+      if (folderName.IsEmpty()) child->SetPrettyName(leafName);
+      if (deep) {
+        nsCOMPtr<nsIFile> path;
+        rv = child->GetFilePath(getter_AddRefs(path));
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv = AddSubFolders(child, path, true);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+  }
+  return rv == NS_MSG_FOLDER_EXISTS ? NS_OK : rv;
+}
+
+/* Finds the directory associated with this folder.  That is if the path is
+   c:\Inbox, it will return c:\Inbox.sbd if it succeeds.  If that path doesn't
+   currently exist then it will create it. Path is strictly an out parameter.
+  */
+nsresult nsMsgBrkMBoxStore::CreateDirectoryForFolder(nsIFile* path) {
+  nsresult rv = NS_OK;
+
+  bool pathIsDirectory = false;
+  path->IsDirectory(&pathIsDirectory);
+  if (!pathIsDirectory) {
+    // If the current path isn't a directory, add directory separator
+    // and test it out.
+    nsAutoString leafName;
+    path->GetLeafName(leafName);
+    leafName.AppendLiteral(FOLDER_SUFFIX);
+    rv = path->SetLeafName(leafName);
+    if (NS_FAILED(rv)) return rv;
+
+    // If that doesn't exist, then we have to create this directory
+    pathIsDirectory = false;
+    path->IsDirectory(&pathIsDirectory);
+    if (!pathIsDirectory) {
+      bool pathExists;
+      path->Exists(&pathExists);
+      // If for some reason there's a file with the directory separator
+      // then we are going to fail.
+      rv = pathExists ? NS_MSG_COULD_NOT_CREATE_DIRECTORY
+                      : path->Create(nsIFile::DIRECTORY_TYPE, 0700);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgBrkMBoxStore::SliceStream(nsIInputStream* inStream, uint64_t start,
+                               uint32_t length, nsIInputStream** result) {
+  nsCOMPtr<nsIInputStream> in(inStream);
+  RefPtr<mozilla::SlicedInputStream> slicedStream =
+      new mozilla::SlicedInputStream(in.forget(), start, uint64_t(length));
+  slicedStream.forget(result);
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsMsgBrkMBoxStore.h b/comm/mailnews/local/src/nsMsgBrkMBoxStore.h
new file mode 100644
index 0000000000..a943cafb60
--- /dev/null
+++ b/comm/mailnews/local/src/nsMsgBrkMBoxStore.h
@@ -0,0 +1,57 @@
+/* -*- 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/. */
+
+/**
+   Class for handling Berkeley Mailbox stores.
+*/
+
+#ifndef nsMsgBrkMboxStore_h__
+#define nsMsgBrkMboxStore_h__
+
+#include "nsMsgLocalStoreUtils.h"
+#include "nsIMsgPluggableStore.h"
+#include "nsIFile.h"
+#include "nsInterfaceHashtable.h"
+#include "nsISeekableStream.h"
+#include "nsIOutputStream.h"
+
+class nsMsgBrkMBoxStore final : public nsMsgLocalStoreUtils,
+                                nsIMsgPluggableStore {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGPLUGGABLESTORE
+
+  nsMsgBrkMBoxStore();
+
+ private:
+  ~nsMsgBrkMBoxStore();
+
+ protected:
+  nsresult InternalGetNewMsgOutputStream(nsIMsgFolder* aFolder,
+                                         nsIMsgDBHdr** aNewMsgHdr,
+                                         nsIOutputStream** aResult);
+  nsresult AddSubFolders(nsIMsgFolder* parent, nsCOMPtr<nsIFile>& path,
+                         bool deep);
+  nsresult CreateDirectoryForFolder(nsIFile* path);
+  nsresult GetOutputStream(nsIMsgDBHdr* aHdr,
+                           nsCOMPtr<nsIOutputStream>& outputStream,
+                           nsCOMPtr<nsISeekableStream>& seekableStream,
+                           int64_t& restorePos);
+  void GetMailboxModProperties(nsIMsgFolder* aFolder, int64_t* aSize,
+                               uint32_t* aDate);
+  void SetDBValid(nsIMsgDBHdr* aHdr);
+
+  // We don't want to keep re-opening an output stream when downloading
+  // multiple pop3 messages, or adjusting x-mozilla-status headers, so
+  // we cache output streams based on folder uri's. If the caller has closed
+  // the stream, we'll get a new one.
+  nsInterfaceHashtable<nsCStringHashKey, nsIOutputStream> m_outputStreams;
+
+#ifdef _DEBUG
+  nsCOMPtr<nsIMsgFolder> m_streamOutstandingFolder;
+#endif
+};
+
+#endif
diff --git a/comm/mailnews/local/src/nsMsgFileHdr.cpp b/comm/mailnews/local/src/nsMsgFileHdr.cpp
new file mode 100644
index 0000000000..57cac43886
--- /dev/null
+++ b/comm/mailnews/local/src/nsMsgFileHdr.cpp
@@ -0,0 +1,389 @@
+/* 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 "nsMsgFileHdr.h"
+#include "nsMsgMessageFlags.h"
+#include "nsNetUtil.h"
+#include "nsIFileURL.h"
+#include "HeaderReader.h"
+#include "nsIFileStreams.h"
+#include "nsIMimeConverter.h"
+
+static inline uint32_t PRTimeToSeconds(PRTime aTimeUsec) {
+  return uint32_t(aTimeUsec / PR_USEC_PER_SEC);
+}
+
+NS_IMPL_ISUPPORTS(nsMsgFileHdr, nsIMsgDBHdr)
+
+nsMsgFileHdr::nsMsgFileHdr(const nsACString& aUri) {
+  mUri = nsCString(aUri);
+  mDate = 0;
+  mFlags = 0;
+}
+
+nsMsgFileHdr::~nsMsgFileHdr() {}
+
+nsresult nsMsgFileHdr::ReadFile() {
+  if (mFile) {
+    return NS_OK;
+  }
+
+  nsresult rv;
+
+  nsCOMPtr<nsIURI> uri;
+  NS_NewURI(getter_AddRefs(uri), mUri);
+  nsCOMPtr<nsIFileURL> fileUrl = do_QueryInterface(uri);
+  rv = fileUrl->GetFile(getter_AddRefs(mFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFileInputStream> fileStream =
+      do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID);
+  rv = fileStream->Init(mFile, PR_RDONLY, 0664, 0);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t count;
+  char buffer[8192];
+  rv = fileStream->Read(&buffer[0], 8192, &count);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  auto cb = [&](HeaderReader::Hdr const& hdr) {
+    auto name = hdr.Name(buffer);
+    if (name.EqualsLiteral("Subject") && mSubject.IsEmpty()) {
+      mSubject = hdr.Value(buffer);
+    }
+    if (name.EqualsLiteral("From") && mAuthor.IsEmpty()) {
+      mAuthor = hdr.Value(buffer);
+    }
+    if (name.EqualsLiteral("To") && mRecipients.IsEmpty()) {
+      mRecipients = hdr.Value(buffer);
+    }
+    if (name.EqualsLiteral("Cc") && mCcList.IsEmpty()) {
+      mCcList = hdr.Value(buffer);
+    }
+    if (name.EqualsLiteral("Bcc") && mBccList.IsEmpty()) {
+      mBccList = hdr.Value(buffer);
+    }
+    if (name.EqualsLiteral("Date") && mDate == 0) {
+      PR_ParseTimeString(hdr.Value(buffer).get(), false, &mDate);
+    }
+    if (name.EqualsLiteral("Message-ID") && mMessageID.IsEmpty()) {
+      mMessageID = hdr.Value(buffer);
+      mMessageID.Trim("<>");
+    }
+    return true;
+  };
+  HeaderReader rdr;
+  rdr.Parse(buffer, cb);
+
+  nsCOMPtr<nsIMimeConverter> mimeConverter =
+      do_GetService("@mozilla.org/messenger/mimeconverter;1");
+  mimeConverter->DecodeMimeHeader(mSubject.get(), "UTF-8", false, true,
+                                  mDecodedSubject);
+  mimeConverter->DecodeMimeHeader(mAuthor.get(), "UTF-8", false, true,
+                                  mDecodedAuthor);
+  mimeConverter->DecodeMimeHeader(mRecipients.get(), "UTF-8", false, true,
+                                  mDecodedRecipients);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetStringProperty(const char* propertyName,
+                                              const nsACString& propertyValue) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetStringProperty(const char* propertyName,
+                                              nsACString& _retval) {
+  if (!strcmp(propertyName, "dummyMsgUrl")) {
+    _retval = mUri;
+    return NS_OK;
+  }
+  _retval.Truncate();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetUint32Property(const char* propertyName,
+                                              uint32_t* _retval) {
+  if (!strcmp(propertyName, "dummyMsgLastModifiedTime")) {
+    nsresult rv = ReadFile();
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    PRTime modifiedTime;
+    mFile->GetLastModifiedTime(&modifiedTime);
+    *_retval = PRTimeToSeconds(modifiedTime);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetUint32Property(const char* propertyName,
+                                              uint32_t propertyVal) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetIsRead(bool* aIsRead) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::GetIsFlagged(bool* aIsFlagged) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::GetIsKilled(bool* aIsKilled) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::MarkRead(bool read) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::MarkFlagged(bool flagged) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::MarkHasAttachments(bool hasAttachments) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetPriority(nsMsgPriorityValue* aPriority) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetPriority(nsMsgPriorityValue aPriority) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetFlags(uint32_t* aFlags) {
+  *aFlags = mFlags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetFlags(uint32_t aFlags) {
+  mFlags = aFlags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::OrFlags(uint32_t flags, uint32_t* _retval) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::AndFlags(uint32_t flags, uint32_t* _retval) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetThreadId(nsMsgKey* aThreadId) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::SetThreadId(nsMsgKey aThreadId) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::GetMessageKey(nsMsgKey* aMessageKey) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetMessageKey(nsMsgKey aMessageKey) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetThreadParent(nsMsgKey* aThreadParent) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetThreadParent(nsMsgKey aThreadParent) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetMessageSize(uint32_t* aMessageSize) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int64_t fileSize;
+  mFile->GetFileSize(&fileSize);
+
+  *aMessageSize = uint32_t(fileSize);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetMessageSize(uint32_t aMessageSize) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetLineCount(uint32_t* aLineCount) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::SetLineCount(uint32_t aLineCount) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::GetMessageOffset(uint64_t* aMessageOffset) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetMessageOffset(uint64_t aMessageOffset) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetOfflineMessageSize(
+    uint32_t* aOfflineMessageSize) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetOfflineMessageSize(
+    uint32_t aOfflineMessageSize) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetDate(PRTime* aDate) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aDate = mDate;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetDate(PRTime aDate) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::GetDateInSeconds(uint32_t* aDateInSeconds) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetMessageId(char** aMessageId) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aMessageId = strdup(mMessageID.get());
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetMessageId(const char* aMessageId) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetCcList(char** aCcList) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aCcList = strdup(mCcList.get());
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetCcList(const char* aCcList) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::GetBccList(char** aBccList) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aBccList = strdup(mBccList.get());
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetBccList(const char* aBccList) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::GetAuthor(char** aAuthor) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aAuthor = strdup(mAuthor.get());
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetAuthor(const char* aAuthor) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::GetSubject(nsACString& aSubject) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aSubject = mSubject;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetSubject(const nsACString& aSubject) {
+  mSubject = aSubject;
+  bool strippedRE = NS_MsgStripRE(mSubject, mSubject);
+  nsCOMPtr<nsIMimeConverter> mimeConverter =
+      do_GetService("@mozilla.org/messenger/mimeconverter;1");
+  mimeConverter->DecodeMimeHeader(mSubject.get(), "UTF-8", false, true,
+                                  mDecodedSubject);
+  if (strippedRE) {
+    mFlags |= nsMsgMessageFlags::HasRe;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetRecipients(char** aRecipients) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aRecipients = strdup(mRecipients.get());
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetRecipients(const char* aRecipients) {
+  // FIXME: should do assignment (maybe not used but if used, a trap!)
+  // Same for all the other unimplemented setters here.
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::SetReferences(const nsACString& references) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetNumReferences(uint16_t* aNumReferences) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetStringReference(int32_t refNum,
+                                               nsACString& _retval) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetMime2DecodedAuthor(
+    nsAString& aMime2DecodedAuthor) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aMime2DecodedAuthor.Truncate();
+  aMime2DecodedAuthor.Assign(mDecodedAuthor);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetMime2DecodedSubject(
+    nsAString& aMime2DecodedSubject) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aMime2DecodedSubject.Truncate();
+  aMime2DecodedSubject.Assign(mDecodedSubject);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetMime2DecodedRecipients(
+    nsAString& aMime2DecodedRecipients) {
+  nsresult rv = ReadFile();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aMime2DecodedRecipients.Truncate();
+  aMime2DecodedRecipients.Assign(mDecodedRecipients);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetAuthorCollationKey(nsTArray<uint8_t>& _retval) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetSubjectCollationKey(nsTArray<uint8_t>& _retval) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetRecipientsCollationKey(
+    nsTArray<uint8_t>& _retval) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetCharset(char** aCharset) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::SetCharset(const char* aCharset) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetEffectiveCharset(nsACString& aEffectiveCharset) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetAccountKey(char** aAccountKey) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::SetAccountKey(const char* aAccountKey) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgFileHdr::GetFolder(nsIMsgFolder** aFolder) { return NS_OK; }
+
+NS_IMETHODIMP nsMsgFileHdr::GetProperties(nsTArray<nsCString>& headers) {
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsMsgFileHdr.h b/comm/mailnews/local/src/nsMsgFileHdr.h
new file mode 100644
index 0000000000..d63b099e04
--- /dev/null
+++ b/comm/mailnews/local/src/nsMsgFileHdr.h
@@ -0,0 +1,41 @@
+/* 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 _nsMsgFileHdr_H
+#define _nsMsgFileHdr_H
+
+#include "nsIMsgHdr.h"
+#include "nsString.h"
+#include "nsTArray.h"
+
+/* This mail-related class is a stub. You can help mailnews by expanding it. */
+
+class nsMsgFileHdr : public nsIMsgDBHdr {
+ public:
+  explicit nsMsgFileHdr(const nsACString& aUri);
+
+  NS_DECL_NSIMSGDBHDR
+  NS_DECL_ISUPPORTS
+
+ private:
+  virtual ~nsMsgFileHdr();
+
+  nsresult ReadFile();
+
+  nsCString mUri;
+  nsCOMPtr<nsIFile> mFile;
+  nsCString mAuthor;
+  nsString mDecodedAuthor;
+  nsCString mSubject;
+  nsString mDecodedSubject;
+  nsCString mRecipients;
+  nsString mDecodedRecipients;
+  nsCString mCcList;
+  nsCString mBccList;
+  PRTime mDate;
+  nsCString mMessageID;
+  uint32_t mFlags;
+};
+
+#endif
diff --git a/comm/mailnews/local/src/nsMsgLocalStoreUtils.cpp b/comm/mailnews/local/src/nsMsgLocalStoreUtils.cpp
new file mode 100644
index 0000000000..eef6694a67
--- /dev/null
+++ b/comm/mailnews/local/src/nsMsgLocalStoreUtils.cpp
@@ -0,0 +1,380 @@
+/* -*- 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 "nsMsgLocalStoreUtils.h"
+#include "nsIFile.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIMsgDatabase.h"
+#include "HeaderReader.h"
+#include "nsPrintfCString.h"
+#include "nsReadableUtils.h"
+#include "mozilla/Buffer.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "prprf.h"
+
+#define EXTRA_SAFETY_SPACE 0x400000  // (4MiB)
+
+nsMsgLocalStoreUtils::nsMsgLocalStoreUtils() {}
+
+nsresult nsMsgLocalStoreUtils::AddDirectorySeparator(nsIFile* path) {
+  nsAutoString leafName;
+  path->GetLeafName(leafName);
+  leafName.AppendLiteral(FOLDER_SUFFIX);
+  return path->SetLeafName(leafName);
+}
+
+bool nsMsgLocalStoreUtils::nsShouldIgnoreFile(nsAString& name, nsIFile* path) {
+  if (name.IsEmpty()) return true;
+
+  char16_t firstChar = name.First();
+  if (firstChar == '.' || firstChar == '#' ||
+      name.CharAt(name.Length() - 1) == '~')
+    return true;
+
+  if (name.LowerCaseEqualsLiteral("msgfilterrules.dat") ||
+      name.LowerCaseEqualsLiteral("rules.dat") ||
+      name.LowerCaseEqualsLiteral("filterlog.html") ||
+      name.LowerCaseEqualsLiteral("junklog.html") ||
+      name.LowerCaseEqualsLiteral("rulesbackup.dat"))
+    return true;
+
+  // don't add summary files to the list of folders;
+  // don't add popstate files to the list either, or rules (sort.dat).
+  if (StringEndsWith(name, u".snm"_ns) ||
+      name.LowerCaseEqualsLiteral("popstate.dat") ||
+      name.LowerCaseEqualsLiteral("sort.dat") ||
+      name.LowerCaseEqualsLiteral("mailfilt.log") ||
+      name.LowerCaseEqualsLiteral("filters.js") ||
+      StringEndsWith(name, u".toc"_ns))
+    return true;
+
+  // ignore RSS data source files (see FeedUtils.jsm)
+  if (name.LowerCaseEqualsLiteral("feeds.json") ||
+      name.LowerCaseEqualsLiteral("feeds.json.tmp") ||
+      name.LowerCaseEqualsLiteral("feeds.json.backup") ||
+      name.LowerCaseEqualsLiteral("feeds.json.corrupt") ||
+      name.LowerCaseEqualsLiteral("feeditems.json") ||
+      name.LowerCaseEqualsLiteral("feeditems.json.tmp") ||
+      name.LowerCaseEqualsLiteral("feeditems.json.backup") ||
+      name.LowerCaseEqualsLiteral("feeditems.json.corrupt") ||
+      name.LowerCaseEqualsLiteral("feeds.rdf") ||
+      name.LowerCaseEqualsLiteral("feeditems.rdf") ||
+      StringBeginsWith(name, u"feeditems_error"_ns))
+    return true;
+
+  // Ignore hidden and other special system files.
+  bool specialFile = false;
+  path->IsHidden(&specialFile);
+  if (specialFile) return true;
+  specialFile = false;
+  path->IsSpecial(&specialFile);
+  if (specialFile) return true;
+
+  // The .mozmsgs dir is for spotlight support
+  return (StringEndsWith(name, u".mozmsgs"_ns) ||
+          StringEndsWith(name, NS_LITERAL_STRING_FROM_CSTRING(FOLDER_SUFFIX)) ||
+          StringEndsWith(name, NS_LITERAL_STRING_FROM_CSTRING(SUMMARY_SUFFIX)));
+}
+
+// Attempts to fill a buffer. Returns a span holding the data read.
+// Might be less than buffer size, if EOF was encountered.
+// Upon error, an empty span is returned.
+static mozilla::Span<char> readBuf(nsIInputStream* readable,
+                                   mozilla::Buffer<char>& buf) {
+  uint32_t total = 0;
+  while (total < buf.Length()) {
+    uint32_t n;
+    nsresult rv =
+        readable->Read(buf.Elements() + total, buf.Length() - total, &n);
+    if (NS_FAILED(rv)) {
+      total = 0;
+      break;
+    }
+    if (n == 0) {
+      break;  // EOF
+    }
+    total += n;
+  }
+  return mozilla::Span<char>(buf.Elements(), total);
+}
+
+// Write data to outputstream, until complete or error.
+static nsresult writeBuf(nsIOutputStream* writeable, const char* data,
+                         size_t dataSize) {
+  uint32_t written = 0;
+  while (written < dataSize) {
+    uint32_t n;
+    nsresult rv = writeable->Write(data + written, dataSize - written, &n);
+    NS_ENSURE_SUCCESS(rv, rv);
+    written += n;
+  }
+  return NS_OK;
+}
+
+/**
+ * Attempt to update X-Mozilla-Status and X-Mozilla-Status2 headers with
+ * new message flags by rewriting them in place.
+ */
+nsresult nsMsgLocalStoreUtils::RewriteMsgFlags(nsISeekableStream* seekable,
+                                               uint32_t msgFlags) {
+  nsresult rv;
+
+  // Remember where we started.
+  int64_t msgStart;
+  rv = seekable->Tell(&msgStart);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // We edit the file in-place, so need to be able to read and write too.
+  nsCOMPtr<nsIInputStream> readable(do_QueryInterface(seekable, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIOutputStream> writable = do_QueryInterface(seekable, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Read in the first chunk of the header and search for the X-Mozilla-Status
+  // headers. We know that those headers always appear at the beginning, so
+  // don't need to look too far in.
+  mozilla::Buffer<char> buf(512);
+  mozilla::Span<const char> data = readBuf(readable, buf);
+
+  // If there's a "From " line, consume it.
+  mozilla::Span<const char> fromLine;
+  if (data.Length() >= 5 &&
+      nsDependentCSubstring(data.First(5)).EqualsLiteral("From ")) {
+    fromLine = FirstLine(data);
+    data = data.From(fromLine.Length());
+  }
+
+  HeaderReader::Hdr statusHdr;
+  HeaderReader::Hdr status2Hdr;
+  auto findHeadersFn = [&](auto const& hdr) {
+    if (hdr.Name(data).EqualsLiteral(X_MOZILLA_STATUS)) {
+      statusHdr = hdr;
+    } else if (hdr.Name(data).EqualsLiteral(X_MOZILLA_STATUS2)) {
+      status2Hdr = hdr;
+    } else {
+      return true;  // Keep looking.
+    }
+    // Keep looking until we find both.
+    return statusHdr.IsEmpty() || status2Hdr.IsEmpty();
+  };
+  HeaderReader rdr;
+  rdr.Parse(data, findHeadersFn);
+
+  // Update X-Mozilla-Status (holds the lower 16bits worth of flags).
+  if (!statusHdr.IsEmpty()) {
+    uint32_t oldFlags = statusHdr.Value(data).ToInteger(&rv, 16);
+    if (NS_SUCCEEDED(rv)) {
+      // Preserve the Queued flag from existing X-Mozilla-Status header.
+      // (Note: not sure why we do this, but keeping it in for now. - BenC)
+      msgFlags |= oldFlags & nsMsgMessageFlags::Queued;
+
+      if ((msgFlags & 0xFFFF) != oldFlags) {
+        auto out = nsPrintfCString("%4.4x", msgFlags & 0xFFFF);
+        if (out.Length() <= statusHdr.rawValLen) {
+          rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET,
+                              msgStart + fromLine.Length() + statusHdr.pos +
+                                  statusHdr.rawValOffset);
+          NS_ENSURE_SUCCESS(rv, rv);
+          // Should be an exact fit already, but just in case...
+          while (out.Length() < statusHdr.rawValLen) {
+            out.Append(' ');
+          }
+          rv = writeBuf(writable, out.BeginReading(), out.Length());
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+      }
+    }
+  }
+
+  // Update X-Mozilla-Status2 (holds the upper 16bit flags only(!)).
+  if (!status2Hdr.IsEmpty()) {
+    uint32_t oldFlags = status2Hdr.Value(data).ToInteger(&rv, 16);
+    if (NS_SUCCEEDED(rv)) {
+      if ((msgFlags & 0xFFFF0000) != oldFlags) {
+        auto out = nsPrintfCString("%8.8x", msgFlags & 0xFFFF0000);
+        if (out.Length() <= status2Hdr.rawValLen) {
+          rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET,
+                              msgStart + fromLine.Length() + status2Hdr.pos +
+                                  status2Hdr.rawValOffset);
+          NS_ENSURE_SUCCESS(rv, rv);
+          while (out.Length() < status2Hdr.rawValLen) {
+            out.Append(' ');
+          }
+          rv = writeBuf(writable, out.BeginReading(), out.Length());
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+/**
+ * Returns true if there is enough space on disk.
+ *
+ * @param aFile  Any file in the message store that is on a logical
+ *               disk volume so that it can be queried for disk space.
+ * @param aSpaceRequested  The size of free space there must be on the disk
+ *                         to return true.
+ */
+bool nsMsgLocalStoreUtils::DiskSpaceAvailableInStore(nsIFile* aFile,
+                                                     uint64_t aSpaceRequested) {
+  int64_t diskFree;
+  nsresult rv = aFile->GetDiskSpaceAvailable(&diskFree);
+  if (NS_SUCCEEDED(rv)) {
+#ifdef DEBUG
+    printf("GetDiskSpaceAvailable returned: %lld bytes\n", (long long)diskFree);
+#endif
+    // When checking for disk space available, take into consideration
+    // possible database changes, therefore ask for a little more
+    // (EXTRA_SAFETY_SPACE) than what the requested size is. Also, due to disk
+    // sector sizes, allocation blocks, etc. The space "available" may be
+    // greater than the actual space usable.
+    return ((aSpaceRequested + EXTRA_SAFETY_SPACE) < (uint64_t)diskFree);
+  } else if (rv == NS_ERROR_NOT_IMPLEMENTED) {
+    // The call to GetDiskSpaceAvailable is not implemented!
+    // This will happen on certain platforms where GetDiskSpaceAvailable
+    // is not implemented. Since people on those platforms still need
+    // to download mail, we will simply bypass the disk-space check.
+    //
+    // We'll leave a debug message to warn people.
+#ifdef DEBUG
+    printf(
+        "Call to GetDiskSpaceAvailable FAILED because it is not "
+        "implemented!\n");
+#endif
+    return true;
+  } else {
+    printf("Call to GetDiskSpaceAvailable FAILED!\n");
+    return false;
+  }
+}
+
+/**
+ * Resets forceReparse in the database.
+ *
+ * @param aMsgDb The database to reset.
+ */
+void nsMsgLocalStoreUtils::ResetForceReparse(nsIMsgDatabase* aMsgDB) {
+  if (aMsgDB) {
+    nsCOMPtr<nsIDBFolderInfo> folderInfo;
+    aMsgDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+    if (folderInfo) folderInfo->SetBooleanProperty("forceReparse", false);
+  }
+}
+
+/**
+ * Update the value of an X-Mozilla-Keys header in place.
+ *
+ * @param seekable The stream containing the message, positioned at the
+ *                 beginning of the message (must also be readable and
+ *                 writable).
+ * @param keywordsToAdd The list of keywords to add.
+ * @param keywordsToRemove The list of keywords to remove.
+ * @param notEnoughRoom Upon return, this will be set if the header is missing
+ * or too small to contain the new keywords.
+ *
+ */
+nsresult nsMsgLocalStoreUtils::ChangeKeywordsHelper(
+    nsISeekableStream* seekable, nsTArray<nsCString> const& keywordsToAdd,
+    nsTArray<nsCString> const& keywordsToRemove, bool& notEnoughRoom) {
+  notEnoughRoom = false;
+  nsresult rv;
+
+  // Remember where we started.
+  int64_t msgStart;
+  rv = seekable->Tell(&msgStart);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // We edit the file in-place, so need to be able to read and write too.
+  nsCOMPtr<nsIInputStream> readable(do_QueryInterface(seekable, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIOutputStream> writable = do_QueryInterface(seekable, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Read in the first chunk of the header and search for X-Mozilla-Keys.
+  // We know that it always appears near the beginning, so don't need to look
+  // too far in.
+  mozilla::Buffer<char> buf(512);
+  mozilla::Span<const char> data = readBuf(readable, buf);
+
+  // If there's a "From " line, consume it.
+  mozilla::Span<const char> fromLine;
+  if (data.Length() >= 5 &&
+      nsDependentCSubstring(data.First(5)).EqualsLiteral("From ")) {
+    fromLine = FirstLine(data);
+    data = data.From(fromLine.Length());
+  }
+
+  HeaderReader::Hdr kwHdr;
+  auto findHeaderFn = [&](auto const& hdr) {
+    if (hdr.Name(data).EqualsLiteral(HEADER_X_MOZILLA_KEYWORDS)) {
+      kwHdr = hdr;
+      return false;
+    }
+    return true;  // Keep looking.
+  };
+  HeaderReader rdr;
+  rdr.Parse(data, findHeaderFn);
+
+  if (kwHdr.IsEmpty()) {
+    NS_WARNING("X-Mozilla-Keys header not found.");
+    notEnoughRoom = true;
+    return NS_OK;
+  }
+
+  // Get existing keywords.
+  nsTArray<nsCString> keywords;
+  nsAutoCString old(kwHdr.Value(data));
+  old.CompressWhitespace();
+  for (nsACString const& kw : old.Split(' ')) {
+    keywords.AppendElement(kw);
+  }
+
+  bool altered = false;
+  // Add missing keywords.
+  for (auto const& add : keywordsToAdd) {
+    if (!keywords.Contains(add)) {
+      keywords.AppendElement(add);
+      altered = true;
+    }
+  }
+
+  // Remove any keywords we want gone.
+  for (auto const& remove : keywordsToRemove) {
+    auto idx = keywords.IndexOf(remove);
+    if (idx != keywords.NoIndex) {
+      keywords.RemoveElementAt(idx);
+      altered = true;
+    }
+  }
+
+  if (!altered) {
+    return NS_OK;
+  }
+
+  // Write updated keywords over existing value.
+  auto out = StringJoin(" "_ns, keywords);
+  if (out.Length() > kwHdr.rawValLen) {
+    NS_WARNING("X-Mozilla-Keys too small for new value.");
+    notEnoughRoom = true;
+    return NS_OK;
+  }
+  while (out.Length() < kwHdr.rawValLen) {
+    out.Append(' ');
+  }
+
+  rv = seekable->Seek(
+      nsISeekableStream::NS_SEEK_SET,
+      msgStart + fromLine.Length() + kwHdr.pos + kwHdr.rawValOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = writeBuf(writable, out.BeginReading(), out.Length());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsMsgLocalStoreUtils.h b/comm/mailnews/local/src/nsMsgLocalStoreUtils.h
new file mode 100644
index 0000000000..968ee8d436
--- /dev/null
+++ b/comm/mailnews/local/src/nsMsgLocalStoreUtils.h
@@ -0,0 +1,39 @@
+/* -*- 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 nsMsgLocalStoreUtils_h__
+#define nsMsgLocalStoreUtils_h__
+
+#include "msgCore.h"
+#include "nsString.h"
+#include "nsISeekableStream.h"
+#include "nsIMsgHdr.h"
+#include "nsMsgLocalFolderHdrs.h"
+#include "nsMailHeaders.h"
+#include "nsMsgUtils.h"
+#include "nsMsgMessageFlags.h"
+#include "nsArray.h"
+
+/**
+ * Utility Class for handling local mail stores. Berkeley Mailbox
+ * and MailDir stores inherit from this class to share some code.
+ */
+
+class nsMsgLocalStoreUtils {
+ public:
+  nsMsgLocalStoreUtils();
+
+  static nsresult AddDirectorySeparator(nsIFile* path);
+  static bool nsShouldIgnoreFile(nsAString& name, nsIFile* path);
+  static nsresult ChangeKeywordsHelper(
+      nsISeekableStream* seekable, nsTArray<nsCString> const& keywordsToAdd,
+      nsTArray<nsCString> const& keywordsToRemove, bool& notEnoughSpace);
+
+  static void ResetForceReparse(nsIMsgDatabase* aMsgDB);
+
+  nsresult RewriteMsgFlags(nsISeekableStream* seekable, uint32_t flags);
+  bool DiskSpaceAvailableInStore(nsIFile* aFile, uint64_t aSpaceRequested);
+};
+
+#endif
diff --git a/comm/mailnews/local/src/nsMsgMaildirStore.cpp b/comm/mailnews/local/src/nsMsgMaildirStore.cpp
new file mode 100644
index 0000000000..2f597cd464
--- /dev/null
+++ b/comm/mailnews/local/src/nsMsgMaildirStore.cpp
@@ -0,0 +1,1380 @@
+/* -*- 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/. */
+
+/**
+   Class for handling Maildir stores.
+*/
+
+#include "prprf.h"
+#include "msgCore.h"
+#include "nsMsgMaildirStore.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIDirectoryEnumerator.h"
+#include "nsIInputStream.h"
+#include "nsMsgFolderFlags.h"
+#include "nsCOMArray.h"
+#include "nsIFile.h"
+#include "nsNetUtil.h"
+#include "nsIMsgDatabase.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsMsgUtils.h"
+#include "nsIDBFolderInfo.h"
+#include "nsMailHeaders.h"
+#include "nsParseMailbox.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsITimer.h"
+#include "nsIMailboxUrl.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMsgFilterPlugin.h"
+#include "nsLocalUndoTxn.h"
+#include "nsIMessenger.h"
+#include "mozilla/Logging.h"
+#include "mozilla/SlicedInputStream.h"
+#include "mozilla/UniquePtr.h"
+
+static mozilla::LazyLogModule MailDirLog("MailDirStore");
+
+// Helper function to produce a safe filename from a Message-ID value.
+// We'll percent-encode anything not in this set: [-+.%=@_0-9a-zA-Z]
+// This is an overly-picky set, but should:
+//  - leave most sane Message-IDs unchanged
+//  - be safe on windows (the pickiest case)
+//  - avoid chars that can trip up shell scripts (spaces, semicolons etc)
+// If input contains malicious binary (or multibyte chars) it'll be
+// safely encoded as individual bytes.
+static void percentEncode(nsACString const& in, nsACString& out) {
+  const char* end = in.EndReading();
+  const char* cur;
+  // We know the output will be at least as long as the input.
+  out.SetLength(0);
+  out.SetCapacity(in.Length());
+  for (cur = in.BeginReading(); cur < end; ++cur) {
+    const char c = *cur;
+    bool whitelisted = (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') ||
+                       (c >= 'a' && c <= 'z') || c == '-' || c == '+' ||
+                       c == '.' || c == '%' || c == '=' || c == '@' || c == '_';
+    if (whitelisted) {
+      out.Append(c);
+    } else {
+      out.AppendPrintf("%%%02x", (unsigned char)c);
+    }
+  }
+}
+
+nsMsgMaildirStore::nsMsgMaildirStore() {}
+
+nsMsgMaildirStore::~nsMsgMaildirStore() {}
+
+NS_IMPL_ISUPPORTS(nsMsgMaildirStore, nsIMsgPluggableStore)
+
+// Iterates over the folders in the "path" directory, and adds subfolders to
+// parent for each Maildir folder found.
+nsresult nsMsgMaildirStore::AddSubFolders(nsIMsgFolder* parent, nsIFile* path,
+                                          bool deep) {
+  nsCOMArray<nsIFile> currentDirEntries;
+
+  nsCOMPtr<nsIDirectoryEnumerator> directoryEnumerator;
+  nsresult rv = path->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool hasMore;
+  while (NS_SUCCEEDED(directoryEnumerator->HasMoreElements(&hasMore)) &&
+         hasMore) {
+    nsCOMPtr<nsIFile> currentFile;
+    rv = directoryEnumerator->GetNextFile(getter_AddRefs(currentFile));
+    if (NS_SUCCEEDED(rv) && currentFile) {
+      nsAutoString leafName;
+      currentFile->GetLeafName(leafName);
+      bool isDirectory = false;
+      currentFile->IsDirectory(&isDirectory);
+      // Make sure this really is a mail folder dir (i.e., a directory that
+      // contains cur and tmp sub-dirs, and not a .sbd or .mozmsgs dir).
+      if (isDirectory && !nsShouldIgnoreFile(leafName, currentFile))
+        currentDirEntries.AppendObject(currentFile);
+    }
+  }
+
+  // add the folders
+  int32_t count = currentDirEntries.Count();
+  for (int32_t i = 0; i < count; ++i) {
+    nsCOMPtr<nsIFile> currentFile(currentDirEntries[i]);
+
+    nsAutoString leafName;
+    currentFile->GetLeafName(leafName);
+
+    nsCOMPtr<nsIMsgFolder> child;
+    rv = parent->AddSubfolder(leafName, getter_AddRefs(child));
+    if (child) {
+      nsString folderName;
+      child->GetName(folderName);  // try to get it from cache/db
+      if (folderName.IsEmpty()) child->SetPrettyName(leafName);
+      if (deep) {
+        nsCOMPtr<nsIFile> path;
+        rv = child->GetFilePath(getter_AddRefs(path));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        // Construct the .sbd directory path for the possible children of the
+        // folder.
+        GetDirectoryForFolder(path);
+        bool directory = false;
+        // Check that <folder>.sbd really is a directory.
+        path->IsDirectory(&directory);
+        if (directory) AddSubFolders(child, path, true);
+      }
+    }
+  }
+  return rv == NS_MSG_FOLDER_EXISTS ? NS_OK : rv;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::DiscoverSubFolders(nsIMsgFolder* aParentFolder,
+                                                    bool aDeep) {
+  NS_ENSURE_ARG_POINTER(aParentFolder);
+
+  nsCOMPtr<nsIFile> path;
+  nsresult rv = aParentFolder->GetFilePath(getter_AddRefs(path));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool isServer, directory = false;
+  aParentFolder->GetIsServer(&isServer);
+  if (!isServer) GetDirectoryForFolder(path);
+
+  path->IsDirectory(&directory);
+  if (directory) rv = AddSubFolders(aParentFolder, path, aDeep);
+
+  return (rv == NS_MSG_FOLDER_EXISTS) ? NS_OK : rv;
+}
+
+/**
+ * Create if missing a Maildir-style folder with "tmp" and "cur" subfolders
+ * but no "new" subfolder, because it doesn't make sense in the mail client
+ * context. ("new" directory is for messages on the server that haven't been
+ *  seen by a mail client).
+ * aFolderName is already "safe" - it has been through NS_MsgHashIfNecessary.
+ */
+nsresult nsMsgMaildirStore::CreateMaildir(nsIFile* path) {
+  nsresult rv = path->Create(nsIFile::DIRECTORY_TYPE, 0700);
+  if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS) {
+    NS_WARNING("Could not create root directory for message folder");
+    return rv;
+  }
+
+  // Create tmp, cur leaves
+  nsCOMPtr<nsIFile> leaf(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  leaf->InitWithFile(path);
+
+  leaf->AppendNative("tmp"_ns);
+  rv = leaf->Create(nsIFile::DIRECTORY_TYPE, 0700);
+  if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS) {
+    NS_WARNING("Could not create tmp directory for message folder");
+    return rv;
+  }
+
+  leaf->SetNativeLeafName("cur"_ns);
+  rv = leaf->Create(nsIFile::DIRECTORY_TYPE, 0700);
+  if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS) {
+    NS_WARNING("Could not create cur directory for message folder");
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::CreateFolder(nsIMsgFolder* aParent,
+                                              const nsAString& aFolderName,
+                                              nsIMsgFolder** aResult) {
+  NS_ENSURE_ARG_POINTER(aParent);
+  NS_ENSURE_ARG_POINTER(aResult);
+  if (aFolderName.IsEmpty()) return NS_MSG_ERROR_INVALID_FOLDER_NAME;
+
+  nsCOMPtr<nsIFile> path;
+  nsresult rv = aParent->GetFilePath(getter_AddRefs(path));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get a directory based on our current path
+  bool isServer;
+  aParent->GetIsServer(&isServer);
+  rv = CreateDirectoryForFolder(path, isServer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Make sure the new folder name is valid
+  nsAutoString safeFolderName(aFolderName);
+  NS_MsgHashIfNecessary(safeFolderName);
+
+  path->Append(safeFolderName);
+  bool exists;
+  path->Exists(&exists);
+  if (exists)  // check this because localized names are different from disk
+               // names
+    return NS_MSG_FOLDER_EXISTS;
+
+  rv = CreateMaildir(path);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> child;
+  // GetFlags and SetFlags in AddSubfolder will fail because we have no db at
+  // this point but mFlags is set.
+  rv = aParent->AddSubfolder(safeFolderName, getter_AddRefs(child));
+  if (!child || NS_FAILED(rv)) {
+    path->Remove(true);  // recursive
+    return rv;
+  }
+
+  // Create an empty database for this mail folder, set its name from the user
+  nsCOMPtr<nsIMsgDBService> msgDBService =
+      do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+  if (msgDBService) {
+    nsCOMPtr<nsIMsgDatabase> unusedDB;
+    rv = msgDBService->OpenFolderDB(child, true, getter_AddRefs(unusedDB));
+    if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING)
+      rv = msgDBService->CreateNewDB(child, getter_AddRefs(unusedDB));
+
+    if ((NS_SUCCEEDED(rv) || rv == NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE) &&
+        unusedDB) {
+      // need to set the folder name
+      nsCOMPtr<nsIDBFolderInfo> folderInfo;
+      rv = unusedDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+      if (NS_SUCCEEDED(rv)) folderInfo->SetMailboxName(safeFolderName);
+
+      unusedDB->SetSummaryValid(true);
+      unusedDB->Close(true);
+      aParent->UpdateSummaryTotals(true);
+    } else {
+      MOZ_LOG(MailDirLog, mozilla::LogLevel::Info,
+              ("CreateFolder - failed creating db for new folder"));
+      path->Remove(true);  // recursive
+      rv = NS_MSG_CANT_CREATE_FOLDER;
+    }
+  }
+  child.forget(aResult);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::HasSpaceAvailable(nsIMsgFolder* aFolder,
+                                                   int64_t aSpaceRequested,
+                                                   bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  NS_ENSURE_ARG_POINTER(aFolder);
+
+  nsCOMPtr<nsIFile> pathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aResult = DiskSpaceAvailableInStore(pathFile, aSpaceRequested);
+  if (!*aResult) return NS_ERROR_FILE_NO_DEVICE_SPACE;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::IsSummaryFileValid(nsIMsgFolder* aFolder,
+                                                    nsIMsgDatabase* aDB,
+                                                    bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aDB);
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = true;
+  nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+  aDB->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+  nsresult rv =
+      dbFolderInfo->GetBooleanProperty("maildirValid", false, aResult);
+  if (!*aResult) {
+    nsCOMPtr<nsIFile> newFile;
+    rv = aFolder->GetFilePath(getter_AddRefs(newFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+    newFile->Append(u"cur"_ns);
+
+    // If the "cur" sub-dir doesn't exist, and there are no messages
+    // in the db, then the folder is probably new and the db is valid.
+    bool exists;
+    newFile->Exists(&exists);
+    if (!exists) {
+      int32_t numMessages;
+      dbFolderInfo->GetNumMessages(&numMessages);
+      if (!numMessages) *aResult = true;
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::SetSummaryFileValid(nsIMsgFolder* aFolder,
+                                                     nsIMsgDatabase* aDB,
+                                                     bool aValid) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aDB);
+  nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+  aDB->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+  NS_ENSURE_STATE(dbFolderInfo);
+  return dbFolderInfo->SetBooleanProperty("maildirValid", aValid);
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::DeleteFolder(nsIMsgFolder* aFolder) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  bool exists;
+
+  // Delete the Maildir itself.
+  nsCOMPtr<nsIFile> pathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  exists = false;
+  pathFile->Exists(&exists);
+  if (exists) {
+    rv = pathFile->Remove(true);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Delete any subfolders (.sbd-suffixed directories).
+  AddDirectorySeparator(pathFile);
+  exists = false;
+  pathFile->Exists(&exists);
+  if (exists) {
+    rv = pathFile->Remove(true);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::RenameFolder(nsIMsgFolder* aFolder,
+                                              const nsAString& aNewName,
+                                              nsIMsgFolder** aNewFolder) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aNewFolder);
+
+  // old path
+  nsCOMPtr<nsIFile> oldPathFile;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(oldPathFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // old sbd directory
+  nsCOMPtr<nsIFile> sbdPathFile;
+  uint32_t numChildren;
+  aFolder->GetNumSubFolders(&numChildren);
+  if (numChildren > 0) {
+    sbdPathFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = sbdPathFile->InitWithFile(oldPathFile);
+    NS_ENSURE_SUCCESS(rv, rv);
+    GetDirectoryForFolder(sbdPathFile);
+  }
+
+  // old summary
+  nsCOMPtr<nsIFile> oldSummaryFile;
+  rv = aFolder->GetSummaryFile(getter_AddRefs(oldSummaryFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Validate new name
+  nsAutoString safeName(aNewName);
+  NS_MsgHashIfNecessary(safeName);
+
+  aFolder->ForceDBClosed();
+
+  // rename folder
+  rv = oldPathFile->MoveTo(nullptr, safeName);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (numChildren > 0) {
+    // rename "*.sbd" directory
+    nsAutoString sbdName = safeName;
+    sbdName.AppendLiteral(FOLDER_SUFFIX);
+    sbdPathFile->MoveTo(nullptr, sbdName);
+  }
+
+  // rename summary
+  nsAutoString summaryName(safeName);
+  summaryName.AppendLiteral(SUMMARY_SUFFIX);
+  oldSummaryFile->MoveTo(nullptr, summaryName);
+
+  nsCOMPtr<nsIMsgFolder> parentFolder;
+  rv = aFolder->GetParent(getter_AddRefs(parentFolder));
+  if (!parentFolder) return NS_ERROR_NULL_POINTER;
+
+  return parentFolder->AddSubfolder(safeName, aNewFolder);
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::CopyFolder(
+    nsIMsgFolder* aSrcFolder, nsIMsgFolder* aDstFolder, bool aIsMoveFolder,
+    nsIMsgWindow* aMsgWindow, nsIMsgCopyServiceListener* aListener,
+    const nsAString& aNewName) {
+  NS_ENSURE_ARG_POINTER(aSrcFolder);
+  NS_ENSURE_ARG_POINTER(aDstFolder);
+
+  nsAutoString folderName;
+  if (aNewName.IsEmpty())
+    aSrcFolder->GetName(folderName);
+  else
+    folderName.Assign(aNewName);
+
+  nsAutoString safeFolderName(folderName);
+  NS_MsgHashIfNecessary(safeFolderName);
+  aSrcFolder->ForceDBClosed();
+
+  nsCOMPtr<nsIFile> oldPath;
+  nsresult rv = aSrcFolder->GetFilePath(getter_AddRefs(oldPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> summaryFile;
+  GetSummaryFileLocation(oldPath, getter_AddRefs(summaryFile));
+
+  nsCOMPtr<nsIFile> newPath;
+  rv = aDstFolder->GetFilePath(getter_AddRefs(newPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // create target directory based on our current path
+  bool isServer;
+  aDstFolder->GetIsServer(&isServer);
+  rv = CreateDirectoryForFolder(newPath, isServer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> origPath;
+  oldPath->Clone(getter_AddRefs(origPath));
+
+  rv = oldPath->CopyTo(newPath, safeFolderName);
+  NS_ENSURE_SUCCESS(rv, rv);  // will fail if a file by that name exists
+
+  // Copy to dir can fail if file does not exist. If copy fails, we test
+  // if the file exists or not, if it does not that's ok, we continue
+  // without copying it. If it fails and file exist and is not zero sized
+  // there is real problem.
+  nsAutoString dbName(safeFolderName);
+  dbName.AppendLiteral(SUMMARY_SUFFIX);
+  rv = summaryFile->CopyTo(newPath, dbName);
+  if (!NS_SUCCEEDED(rv)) {
+    // Test if the file is not empty
+    bool exists;
+    int64_t fileSize;
+    summaryFile->Exists(&exists);
+    summaryFile->GetFileSize(&fileSize);
+    if (exists && fileSize > 0)
+      NS_ENSURE_SUCCESS(rv, rv);  // Yes, it should have worked!
+    // else case is file is zero sized, no need to copy it,
+    // not an error
+    // else case is file does not exist - not an error
+  }
+
+  nsCOMPtr<nsIMsgFolder> newMsgFolder;
+  rv = aDstFolder->AddSubfolder(safeFolderName, getter_AddRefs(newMsgFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  newMsgFolder->SetPrettyName(folderName);
+  uint32_t flags;
+  aSrcFolder->GetFlags(&flags);
+  newMsgFolder->SetFlags(flags);
+  bool changed = false;
+  rv = aSrcFolder->MatchOrChangeFilterDestination(newMsgFolder, true, &changed);
+  if (changed) aSrcFolder->AlertFilterChanged(aMsgWindow);
+
+  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+  rv = aSrcFolder->GetSubFolders(subFolders);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Copy subfolders to the new location
+  nsresult copyStatus = NS_OK;
+  nsCOMPtr<nsIMsgLocalMailFolder> localNewFolder(
+      do_QueryInterface(newMsgFolder, &rv));
+  if (NS_SUCCEEDED(rv)) {
+    for (nsIMsgFolder* folder : subFolders) {
+      copyStatus =
+          localNewFolder->CopyFolderLocal(folder, false, aMsgWindow, aListener);
+      // Test if the call succeeded, if not we have to stop recursive call
+      if (NS_FAILED(copyStatus)) {
+        // Copy failed we have to notify caller to handle the error and stop
+        // moving the folders. In case this happens to the topmost level of
+        // recursive call, then we just need to break from the while loop and
+        // go to error handling code.
+        if (!aIsMoveFolder) return copyStatus;
+        break;
+      }
+    }
+  }
+
+  if (aIsMoveFolder && NS_SUCCEEDED(copyStatus)) {
+    if (localNewFolder) {
+      nsCOMPtr<nsISupports> srcSupport(do_QueryInterface(aSrcFolder));
+      localNewFolder->OnCopyCompleted(srcSupport, true);
+    }
+
+    // Notify that the folder that was dragged and dropped has been created.
+    // No need to do this for its subfolders - isMoveFolder will be true for
+    // folder.
+    aDstFolder->NotifyFolderAdded(newMsgFolder);
+
+    nsCOMPtr<nsIMsgFolder> msgParent;
+    aSrcFolder->GetParent(getter_AddRefs(msgParent));
+    aSrcFolder->SetParent(nullptr);
+    if (msgParent) {
+      // The files have already been moved, so delete storage false
+      msgParent->PropagateDelete(aSrcFolder, false);
+      oldPath->Remove(true);
+      aSrcFolder->DeleteStorage();
+
+      nsCOMPtr<nsIFile> parentPath;
+      rv = msgParent->GetFilePath(getter_AddRefs(parentPath));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      AddDirectorySeparator(parentPath);
+      nsCOMPtr<nsIDirectoryEnumerator> children;
+      parentPath->GetDirectoryEntries(getter_AddRefs(children));
+      bool more;
+      // checks if the directory is empty or not
+      if (children && NS_SUCCEEDED(children->HasMoreElements(&more)) && !more)
+        parentPath->Remove(true);
+    }
+  } else {
+    // This is the case where the copy of a subfolder failed.
+    // We have to delete the newDirectory tree to make a "rollback".
+    // Someone should add a popup to warn the user that the move was not
+    // possible.
+    if (aIsMoveFolder && NS_FAILED(copyStatus)) {
+      nsCOMPtr<nsIMsgFolder> msgParent;
+      newMsgFolder->ForceDBClosed();
+      newMsgFolder->GetParent(getter_AddRefs(msgParent));
+      newMsgFolder->SetParent(nullptr);
+      if (msgParent) {
+        msgParent->PropagateDelete(newMsgFolder, false);
+        newMsgFolder->DeleteStorage();
+        AddDirectorySeparator(newPath);
+        newPath->Remove(true);  // berkeley mailbox
+      }
+      return NS_ERROR_FAILURE;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMaildirStore::GetNewMsgOutputStream(nsIMsgFolder* aFolder,
+                                         nsIMsgDBHdr** aNewMsgHdr,
+                                         nsIOutputStream** aResult) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aNewMsgHdr);
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  nsCOMPtr<nsIMsgDatabase> db;
+  nsresult rv = aFolder->GetMsgDatabase(getter_AddRefs(db));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!*aNewMsgHdr) {
+    rv = db->CreateNewHdr(nsMsgKey_None, aNewMsgHdr);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  // With maildir, messages have whole file to themselves.
+  (*aNewMsgHdr)->SetMessageOffset(0);
+
+  // We're going to save the new message into the maildir 'tmp' folder.
+  // When the message is completed, it can be moved to 'cur'.
+  nsCOMPtr<nsIFile> newFile;
+  rv = aFolder->GetFilePath(getter_AddRefs(newFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  newFile->Append(u"tmp"_ns);
+
+  // let's check if the folder exists
+  // XXX TODO: kill this and make sure maildir creation includes cur/tmp
+  bool exists;
+  newFile->Exists(&exists);
+  if (!exists) {
+    MOZ_LOG(MailDirLog, mozilla::LogLevel::Info,
+            ("GetNewMsgOutputStream - tmp subfolder does not exist!!"));
+    rv = newFile->Create(nsIFile::DIRECTORY_TYPE, 0755);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Generate the 'tmp' file name based on timestamp.
+  // (We'll use the Message-ID as the basis for the final filename,
+  // but we don't have headers at this point).
+  nsAutoCString newName;
+  newName.AppendInt(static_cast<int64_t>(PR_Now()));
+  newFile->AppendNative(newName);
+
+  // CreateUnique, in case we get more than one message per millisecond :-)
+  rv = newFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
+  NS_ENSURE_SUCCESS(rv, rv);
+  newFile->GetNativeLeafName(newName);
+  // save the file name in the message header - otherwise no way to retrieve it
+  (*aNewMsgHdr)->SetStringProperty("storeToken", newName);
+  return MsgNewBufferedFileOutputStream(aResult, newFile,
+                                        PR_WRONLY | PR_CREATE_FILE, 00600);
+}
+
+NS_IMETHODIMP
+nsMsgMaildirStore::DiscardNewMessage(nsIOutputStream* aOutputStream,
+                                     nsIMsgDBHdr* aNewHdr) {
+  NS_ENSURE_ARG_POINTER(aOutputStream);
+  NS_ENSURE_ARG_POINTER(aNewHdr);
+
+  aOutputStream->Close();
+  // file path is stored in message header property "storeToken"
+  nsAutoCString fileName;
+  aNewHdr->GetStringProperty("storeToken", fileName);
+  if (fileName.IsEmpty()) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIFile> path;
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = aNewHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = folder->GetFilePath(getter_AddRefs(path));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // path to the message download folder
+  path->Append(u"tmp"_ns);
+  path->AppendNative(fileName);
+
+  return path->Remove(false);
+}
+
+NS_IMETHODIMP
+nsMsgMaildirStore::FinishNewMessage(nsIOutputStream* aOutputStream,
+                                    nsIMsgDBHdr* aNewHdr) {
+  NS_ENSURE_ARG_POINTER(aOutputStream);
+  NS_ENSURE_ARG_POINTER(aNewHdr);
+
+  aOutputStream->Close();
+
+  nsCOMPtr<nsIFile> folderPath;
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = aNewHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = folder->GetFilePath(getter_AddRefs(folderPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // tmp filename is stored in "storeToken".
+  // By now we'll have the Message-ID, which we'll base the final filename on.
+  nsAutoCString tmpName;
+  aNewHdr->GetStringProperty("storeToken", tmpName);
+  if (tmpName.IsEmpty()) {
+    NS_ERROR("FinishNewMessage - no storeToken in msg hdr!!");
+    return NS_ERROR_FAILURE;
+  }
+
+  // path to the new destination
+  nsCOMPtr<nsIFile> curPath;
+  folderPath->Clone(getter_AddRefs(curPath));
+  curPath->Append(u"cur"_ns);
+
+  // let's check if the folder exists
+  // XXX TODO: kill this and make sure maildir creation includes cur/tmp
+  bool exists;
+  curPath->Exists(&exists);
+  if (!exists) {
+    rv = curPath->Create(nsIFile::DIRECTORY_TYPE, 0755);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // path to the downloaded message
+  nsCOMPtr<nsIFile> fromPath;
+  folderPath->Clone(getter_AddRefs(fromPath));
+  fromPath->Append(u"tmp"_ns);
+  fromPath->AppendNative(tmpName);
+
+  // Check that the message is still in tmp.
+  // XXX TODO: revisit this. I think it's needed because the
+  // pairing rules for:
+  // GetNewMsgOutputStream(), FinishNewMessage(),
+  // MoveNewlyDownloadedMessage() and DiscardNewMessage()
+  // are not well defined.
+  // If they are sorted out, this code can be removed.
+  fromPath->Exists(&exists);
+  if (!exists) {
+    // Perhaps the message has already moved. See bug 1028372 to fix this.
+    nsCOMPtr<nsIFile> existingPath;
+    curPath->Clone(getter_AddRefs(existingPath));
+    existingPath->AppendNative(tmpName);
+    existingPath->Exists(&exists);
+    if (exists)  // then there is nothing to do
+      return NS_OK;
+
+    NS_ERROR("FinishNewMessage - oops! file does not exist!");
+    return NS_ERROR_FILE_NOT_FOUND;
+  }
+
+  nsCString msgID;
+  aNewHdr->GetMessageId(getter_Copies(msgID));
+
+  nsCString baseName;
+  // For missing or suspiciously-short Message-IDs, use a timestamp
+  // instead.
+  // This also avoids some special filenames we can't use in windows (CON,
+  // AUX, NUL, LPT1 etc...). With an extension (eg "LPT4.txt") they're all
+  // below 9 chars.
+  if (msgID.Length() < 9) {
+    baseName.AppendInt(static_cast<int64_t>(PR_Now()));
+  } else {
+    percentEncode(msgID, baseName);
+    // No length limit on Message-Id header, but lets clip our filenames
+    // well below any MAX_PATH limits.
+    if (baseName.Length() > (128 - 4)) {
+      baseName.SetLength(128 - 4);  // (4 for ".eml")
+    }
+  }
+
+  nsCOMPtr<nsIFile> toPath;
+  curPath->Clone(getter_AddRefs(toPath));
+  nsCString toName(baseName);
+  toName.Append(".eml");
+  toPath->AppendNative(toName);
+
+  // Using CreateUnique in case we have duplicate Message-Ids
+  rv = toPath->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
+  if (NS_FAILED(rv)) {
+    // NS_ERROR_FILE_TOO_BIG means CreateUnique() bailed out at 10000 attempts.
+    if (rv != NS_ERROR_FILE_TOO_BIG) {
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // As a last resort, fall back to using timestamp as filename.
+    toName.SetLength(0);
+    toName.AppendInt(static_cast<int64_t>(PR_Now()));
+    toName.Append(".eml");
+    toPath->SetNativeLeafName(toName);
+    rv = toPath->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Move into place (using whatever name CreateUnique() settled upon).
+  toPath->GetNativeLeafName(toName);
+  rv = fromPath->MoveToNative(curPath, toName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Update the db to reflect the final filename.
+  aNewHdr->SetStringProperty("storeToken", toName);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMaildirStore::MoveNewlyDownloadedMessage(nsIMsgDBHdr* aHdr,
+                                              nsIMsgFolder* aDestFolder,
+                                              bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aHdr);
+  NS_ENSURE_ARG_POINTER(aDestFolder);
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  nsCOMPtr<nsIFile> folderPath;
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = aHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = folder->GetFilePath(getter_AddRefs(folderPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // file path is stored in message header property
+  nsAutoCString fileName;
+  aHdr->GetStringProperty("storeToken", fileName);
+  if (fileName.IsEmpty()) {
+    NS_ERROR("FinishNewMessage - no storeToken in msg hdr!!");
+    return NS_ERROR_FAILURE;
+  }
+
+  // path to the downloaded message
+  nsCOMPtr<nsIFile> fromPath;
+  folderPath->Clone(getter_AddRefs(fromPath));
+  fromPath->Append(u"cur"_ns);
+  fromPath->AppendNative(fileName);
+
+  // let's check if the tmp file exists
+  bool exists;
+  fromPath->Exists(&exists);
+  if (!exists) {
+    NS_ERROR("FinishNewMessage - oops! file does not exist!");
+    return NS_ERROR_FAILURE;
+  }
+
+  // move to the "cur" subfolder
+  nsCOMPtr<nsIFile> toPath;
+  aDestFolder->GetFilePath(getter_AddRefs(folderPath));
+  folderPath->Clone(getter_AddRefs(toPath));
+  toPath->Append(u"cur"_ns);
+
+  // let's check if the folder exists
+  // XXX TODO: kill this and make sure maildir creation includes cur/tmp
+  toPath->Exists(&exists);
+  if (!exists) {
+    rv = toPath->Create(nsIFile::DIRECTORY_TYPE, 0755);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCOMPtr<nsIMsgDatabase> destMailDB;
+  rv = aDestFolder->GetMsgDatabase(getter_AddRefs(destMailDB));
+  NS_WARNING_ASSERTION(destMailDB && NS_SUCCEEDED(rv),
+                       "failed to open mail db moving message");
+
+  nsCOMPtr<nsIMsgDBHdr> newHdr;
+  if (destMailDB)
+    rv = destMailDB->CopyHdrFromExistingHdr(nsMsgKey_None, aHdr, true,
+                                            getter_AddRefs(newHdr));
+  if (NS_SUCCEEDED(rv) && !newHdr) rv = NS_ERROR_UNEXPECTED;
+
+  if (NS_FAILED(rv)) {
+    aDestFolder->ThrowAlertMsg("filterFolderHdrAddFailed", nullptr);
+    return rv;
+  }
+
+  nsCOMPtr<nsIFile> existingPath;
+  toPath->Clone(getter_AddRefs(existingPath));
+  existingPath->AppendNative(fileName);
+  existingPath->Exists(&exists);
+
+  if (exists) {
+    rv = existingPath->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
+    NS_ENSURE_SUCCESS(rv, rv);
+    existingPath->GetNativeLeafName(fileName);
+    newHdr->SetStringProperty("storeToken", fileName);
+  }
+
+  rv = fromPath->MoveToNative(toPath, fileName);
+  *aResult = NS_SUCCEEDED(rv);
+  if (NS_FAILED(rv))
+    aDestFolder->ThrowAlertMsg("filterFolderWriteFailed", nullptr);
+
+  if (NS_FAILED(rv)) {
+    if (destMailDB) destMailDB->Close(true);
+
+    return NS_MSG_ERROR_WRITING_MAIL_FOLDER;
+  }
+
+  bool movedMsgIsNew = false;
+  // if we have made it this far then the message has successfully been
+  // written to the new folder now add the header to the destMailDB.
+
+  uint32_t newFlags;
+  newHdr->GetFlags(&newFlags);
+  nsMsgKey msgKey;
+  newHdr->GetMessageKey(&msgKey);
+  if (!(newFlags & nsMsgMessageFlags::Read)) {
+    nsCString junkScoreStr;
+    (void)newHdr->GetStringProperty("junkscore", junkScoreStr);
+    if (atoi(junkScoreStr.get()) != nsIJunkMailPlugin::IS_SPAM_SCORE) {
+      newHdr->OrFlags(nsMsgMessageFlags::New, &newFlags);
+      destMailDB->AddToNewList(msgKey);
+      movedMsgIsNew = true;
+    }
+  }
+
+  nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+      do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+  if (notifier) notifier->NotifyMsgAdded(newHdr);
+
+  if (movedMsgIsNew) {
+    aDestFolder->SetHasNewMessages(true);
+
+    // Notify the message was moved.
+    if (notifier) {
+      notifier->NotifyMsgUnincorporatedMoved(folder, newHdr);
+    }
+  }
+
+  nsCOMPtr<nsIMsgDatabase> sourceDB;
+  rv = folder->GetMsgDatabase(getter_AddRefs(sourceDB));
+
+  if (NS_SUCCEEDED(rv) && sourceDB) sourceDB->RemoveHeaderMdbRow(aHdr);
+
+  destMailDB->SetSummaryValid(true);
+  aDestFolder->UpdateSummaryTotals(true);
+  destMailDB->Commit(nsMsgDBCommitType::kLargeCommit);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgMaildirStore::GetMsgInputStream(nsIMsgFolder* aMsgFolder,
+                                     const nsACString& aMsgToken,
+                                     nsIInputStream** aResult) {
+  NS_ENSURE_ARG_POINTER(aMsgFolder);
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  // construct path to file
+  nsCOMPtr<nsIFile> path;
+  nsresult rv = aMsgFolder->GetFilePath(getter_AddRefs(path));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aMsgToken.IsEmpty()) {
+    MOZ_LOG(MailDirLog, mozilla::LogLevel::Info,
+            ("GetMsgInputStream - empty storeToken!!"));
+    return NS_ERROR_FAILURE;
+  }
+
+  path->Append(u"cur"_ns);
+
+  // let's check if the folder exists
+  // XXX TODO: kill this and make sure maildir creation includes cur/tmp
+  bool exists;
+  path->Exists(&exists);
+  if (!exists) {
+    MOZ_LOG(MailDirLog, mozilla::LogLevel::Info,
+            ("GetMsgInputStream - oops! cur subfolder does not exist!"));
+    rv = path->Create(nsIFile::DIRECTORY_TYPE, 0755);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  path->AppendNative(aMsgToken);
+  return NS_NewLocalFileInputStream(aResult, path);
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::DeleteMessages(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aHdrArray) {
+  nsCOMPtr<nsIMsgFolder> folder;
+
+  for (auto msgHdr : aHdrArray) {
+    msgHdr->GetFolder(getter_AddRefs(folder));
+    nsCOMPtr<nsIFile> path;
+    nsresult rv = folder->GetFilePath(getter_AddRefs(path));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoCString fileName;
+    msgHdr->GetStringProperty("storeToken", fileName);
+
+    if (fileName.IsEmpty()) {
+      MOZ_LOG(MailDirLog, mozilla::LogLevel::Info,
+              ("DeleteMessages - empty storeToken!!"));
+      // Perhaps an offline store has not downloaded this particular message.
+      continue;
+    }
+
+    path->Append(u"cur"_ns);
+    path->AppendNative(fileName);
+
+    // Let's check if the message exists.
+    bool exists;
+    path->Exists(&exists);
+    if (!exists) {
+      MOZ_LOG(MailDirLog, mozilla::LogLevel::Info,
+              ("DeleteMessages - file does not exist !!"));
+      // Perhaps an offline store has not downloaded this particular message.
+      continue;
+    }
+    path->Remove(false);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMaildirStore::CopyMessages(bool aIsMove,
+                                const nsTArray<RefPtr<nsIMsgDBHdr>>& aHdrArray,
+                                nsIMsgFolder* aDstFolder,
+                                nsTArray<RefPtr<nsIMsgDBHdr>>& aDstHdrs,
+                                nsITransaction** aUndoAction, bool* aCopyDone) {
+  NS_ENSURE_ARG_POINTER(aDstFolder);
+  NS_ENSURE_ARG_POINTER(aCopyDone);
+  NS_ENSURE_ARG_POINTER(aUndoAction);
+
+  *aCopyDone = false;
+  if (aHdrArray.IsEmpty()) {
+    return NS_ERROR_INVALID_ARG;
+  }
+  nsCOMPtr<nsIMsgFolder> srcFolder;
+  nsresult rv;
+  nsIMsgDBHdr* msgHdr = aHdrArray[0];
+  rv = msgHdr->GetFolder(getter_AddRefs(srcFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Both source and destination folders must use maildir type store.
+  nsCOMPtr<nsIMsgPluggableStore> srcStore;
+  nsAutoCString srcType;
+  srcFolder->GetMsgStore(getter_AddRefs(srcStore));
+  if (srcStore) srcStore->GetStoreType(srcType);
+  nsCOMPtr<nsIMsgPluggableStore> dstStore;
+  nsAutoCString dstType;
+  aDstFolder->GetMsgStore(getter_AddRefs(dstStore));
+  if (dstStore) dstStore->GetStoreType(dstType);
+  if (!srcType.EqualsLiteral("maildir") || !dstType.EqualsLiteral("maildir"))
+    return NS_OK;
+
+  // Both source and destination must be local folders. In theory we could
+  //   do efficient copies of the offline store of IMAP, but this is not
+  //   supported yet. For that, we need to deal with both correct handling
+  //   of deletes from the src server, and msgKey = UIDL in the dst folder.
+  nsCOMPtr<nsIMsgLocalMailFolder> destLocalFolder(
+      do_QueryInterface(aDstFolder));
+  if (!destLocalFolder) return NS_OK;
+  nsCOMPtr<nsIMsgLocalMailFolder> srcLocalFolder(do_QueryInterface(srcFolder));
+  if (!srcLocalFolder) return NS_OK;
+
+  // We should be able to use a file move for an efficient copy.
+
+  nsCOMPtr<nsIFile> destFolderPath;
+  nsCOMPtr<nsIMsgDatabase> destDB;
+  aDstFolder->GetMsgDatabase(getter_AddRefs(destDB));
+  rv = aDstFolder->GetFilePath(getter_AddRefs(destFolderPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+  destFolderPath->Append(u"cur"_ns);
+
+  nsCOMPtr<nsIFile> srcFolderPath;
+  rv = srcFolder->GetFilePath(getter_AddRefs(srcFolderPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+  srcFolderPath->Append(u"cur"_ns);
+
+  nsCOMPtr<nsIMsgDatabase> srcDB;
+  srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
+  RefPtr<nsLocalMoveCopyMsgTxn> msgTxn = new nsLocalMoveCopyMsgTxn;
+  NS_ENSURE_TRUE(msgTxn, NS_ERROR_OUT_OF_MEMORY);
+  if (NS_SUCCEEDED(msgTxn->Init(srcFolder, aDstFolder, aIsMove))) {
+    if (aIsMove)
+      msgTxn->SetTransactionType(nsIMessenger::eMoveMsg);
+    else
+      msgTxn->SetTransactionType(nsIMessenger::eCopyMsg);
+  }
+
+  aDstHdrs.Clear();
+  aDstHdrs.SetCapacity(aHdrArray.Length());
+
+  for (auto srcHdr : aHdrArray) {
+    nsMsgKey srcKey;
+    srcHdr->GetMessageKey(&srcKey);
+    msgTxn->AddSrcKey(srcKey);
+    nsAutoCString fileName;
+    srcHdr->GetStringProperty("storeToken", fileName);
+    if (fileName.IsEmpty()) {
+      MOZ_LOG(MailDirLog, mozilla::LogLevel::Info,
+              ("GetMsgInputStream - empty storeToken!!"));
+      return NS_ERROR_FAILURE;
+    }
+
+    nsCOMPtr<nsIFile> srcFile;
+    rv = srcFolderPath->Clone(getter_AddRefs(srcFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+    srcFile->AppendNative(fileName);
+
+    nsCOMPtr<nsIFile> destFile;
+    destFolderPath->Clone(getter_AddRefs(destFile));
+    destFile->AppendNative(fileName);
+    bool exists;
+    destFile->Exists(&exists);
+    if (exists) {
+      rv = destFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
+      NS_ENSURE_SUCCESS(rv, rv);
+      destFile->GetNativeLeafName(fileName);
+    }
+    if (aIsMove)
+      rv = srcFile->MoveToNative(destFolderPath, fileName);
+    else
+      rv = srcFile->CopyToNative(destFolderPath, fileName);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgDBHdr> destHdr;
+    if (destDB) {
+      rv = destDB->CopyHdrFromExistingHdr(nsMsgKey_None, srcHdr, true,
+                                          getter_AddRefs(destHdr));
+      NS_ENSURE_SUCCESS(rv, rv);
+      destHdr->SetStringProperty("storeToken", fileName);
+      aDstHdrs.AppendElement(destHdr);
+      nsMsgKey dstKey;
+      destHdr->GetMessageKey(&dstKey);
+      msgTxn->AddDstKey(dstKey);
+    }
+  }
+  nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+      do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+  if (notifier) {
+    notifier->NotifyMsgsMoveCopyCompleted(aIsMove, aHdrArray, aDstFolder,
+                                          aDstHdrs);
+  }
+
+  // For now, we only support local dest folders, and for those we are done and
+  // can delete the messages. Perhaps this should be moved into the folder
+  // when we try to support other folder types.
+  if (aIsMove) {
+    for (auto msgDBHdr : aHdrArray) {
+      srcDB->DeleteHeader(msgDBHdr, nullptr, false, true);
+    }
+  }
+
+  *aCopyDone = true;
+  msgTxn.forget(aUndoAction);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMaildirStore::GetSupportsCompaction(bool* aSupportsCompaction) {
+  NS_ENSURE_ARG_POINTER(aSupportsCompaction);
+  *aSupportsCompaction = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::CompactFolder(nsIMsgFolder* aFolder,
+                                               nsIUrlListener* aListener,
+                                               nsIMsgWindow* aMsgWindow) {
+  return NS_OK;
+}
+
+class MaildirStoreParser {
+ public:
+  MaildirStoreParser(nsIMsgFolder* aFolder, nsIMsgDatabase* aMsgDB,
+                     nsIDirectoryEnumerator* aDirectoryEnumerator,
+                     nsIUrlListener* aUrlListener);
+  virtual ~MaildirStoreParser();
+
+  nsresult ParseNextMessage(nsIFile* aFile);
+  static void TimerCallback(nsITimer* aTimer, void* aClosure);
+  nsresult StartTimer();
+
+  nsCOMPtr<nsIDirectoryEnumerator> m_directoryEnumerator;
+  nsCOMPtr<nsIMsgFolder> m_folder;
+  nsCOMPtr<nsIMsgDatabase> m_db;
+  nsCOMPtr<nsITimer> m_timer;
+  nsCOMPtr<nsIUrlListener> m_listener;
+};
+
+MaildirStoreParser::MaildirStoreParser(nsIMsgFolder* aFolder,
+                                       nsIMsgDatabase* aMsgDB,
+                                       nsIDirectoryEnumerator* aDirEnum,
+                                       nsIUrlListener* aUrlListener) {
+  m_folder = aFolder;
+  m_db = aMsgDB;
+  m_directoryEnumerator = aDirEnum;
+  m_listener = aUrlListener;
+}
+
+MaildirStoreParser::~MaildirStoreParser() {}
+
+nsresult MaildirStoreParser::ParseNextMessage(nsIFile* aFile) {
+  nsresult rv;
+  NS_ENSURE_TRUE(m_db, NS_ERROR_NULL_POINTER);
+  nsCOMPtr<nsIInputStream> inputStream;
+  nsCOMPtr<nsIMsgParseMailMsgState> msgParser =
+      do_CreateInstance("@mozilla.org/messenger/messagestateparser;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  msgParser->SetMailDB(m_db);
+  nsCOMPtr<nsIMsgDBHdr> newMsgHdr;
+  rv = m_db->CreateNewHdr(nsMsgKey_None, getter_AddRefs(newMsgHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  newMsgHdr->SetMessageOffset(0);
+
+  rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), aFile);
+  if (NS_SUCCEEDED(rv) && inputStream) {
+    RefPtr<nsMsgLineStreamBuffer> inputStreamBuffer =
+        new nsMsgLineStreamBuffer(FILE_IO_BUFFER_SIZE, true, false);
+    int64_t fileSize;
+    aFile->GetFileSize(&fileSize);
+    msgParser->SetNewMsgHdr(newMsgHdr);
+    msgParser->SetState(nsIMsgParseMailMsgState::ParseHeadersState);
+    bool needMoreData = false;
+    char* newLine = nullptr;
+    uint32_t numBytesInLine = 0;
+    // we only have to read the headers, because we know the message size
+    // from the file size. So we can do this in one time slice.
+    do {
+      newLine = inputStreamBuffer->ReadNextLine(inputStream, numBytesInLine,
+                                                needMoreData);
+      if (newLine) {
+        msgParser->ParseAFolderLine(newLine, numBytesInLine);
+        free(newLine);
+      }
+    } while (newLine && numBytesInLine > 0);
+
+    msgParser->FinishHeader();
+    // A single message needs to be less than 4GB
+    newMsgHdr->SetMessageSize((uint32_t)fileSize);
+    m_db->AddNewHdrToDB(newMsgHdr, true);
+    nsAutoCString storeToken;
+    aFile->GetNativeLeafName(storeToken);
+    newMsgHdr->SetStringProperty("storeToken", storeToken);
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+  return rv;
+}
+
+void MaildirStoreParser::TimerCallback(nsITimer* aTimer, void* aClosure) {
+  MaildirStoreParser* parser = (MaildirStoreParser*)aClosure;
+  bool hasMore;
+  parser->m_directoryEnumerator->HasMoreElements(&hasMore);
+  if (!hasMore) {
+    nsCOMPtr<nsIMsgPluggableStore> store;
+    parser->m_folder->GetMsgStore(getter_AddRefs(store));
+    parser->m_timer->Cancel();
+    if (parser->m_db) parser->m_db->SetSummaryValid(true);
+    // store->SetSummaryFileValid(parser->m_folder, parser->m_db, true);
+    if (parser->m_listener) {
+      nsresult rv;
+      nsCOMPtr<nsIMailboxUrl> mailboxurl =
+          do_CreateInstance("@mozilla.org/messenger/mailboxurl;1", &rv);
+      if (NS_SUCCEEDED(rv) && mailboxurl) {
+        nsCOMPtr<nsIMsgMailNewsUrl> url = do_QueryInterface(mailboxurl);
+        url->SetUpdatingFolder(true);
+        nsAutoCString uriSpec("mailbox://");
+        // ### TODO - what if SetSpec fails?
+        (void)url->SetSpecInternal(uriSpec);
+        parser->m_listener->OnStopRunningUrl(url, NS_OK);
+      }
+    }
+    // Parsing complete and timer cancelled, so we release the parser object.
+    delete parser;
+    return;
+  }
+  nsCOMPtr<nsIFile> currentFile;
+  nsresult rv =
+      parser->m_directoryEnumerator->GetNextFile(getter_AddRefs(currentFile));
+  if (NS_SUCCEEDED(rv)) rv = parser->ParseNextMessage(currentFile);
+  if (NS_FAILED(rv) && parser->m_listener)
+    parser->m_listener->OnStopRunningUrl(nullptr, NS_ERROR_FAILURE);
+}
+
+nsresult MaildirStoreParser::StartTimer() {
+  nsresult rv;
+  m_timer = do_CreateInstance("@mozilla.org/timer;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  m_timer->InitWithNamedFuncCallback(TimerCallback, (void*)this, 0,
+                                     nsITimer::TYPE_REPEATING_SLACK,
+                                     "MaildirStoreParser::TimerCallback");
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::RebuildIndex(nsIMsgFolder* aFolder,
+                                              nsIMsgDatabase* aMsgDB,
+                                              nsIMsgWindow* aMsgWindow,
+                                              nsIUrlListener* aListener) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  // This code needs to iterate over the maildir files, and parse each
+  // file and add a msg hdr to the db for the file.
+  nsCOMPtr<nsIFile> path;
+  nsresult rv = aFolder->GetFilePath(getter_AddRefs(path));
+  NS_ENSURE_SUCCESS(rv, rv);
+  path->Append(u"cur"_ns);
+
+  nsCOMPtr<nsIDirectoryEnumerator> directoryEnumerator;
+  rv = path->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  MaildirStoreParser* fileParser =
+      new MaildirStoreParser(aFolder, aMsgDB, directoryEnumerator, aListener);
+  NS_ENSURE_TRUE(fileParser, NS_ERROR_OUT_OF_MEMORY);
+  fileParser->StartTimer();
+  ResetForceReparse(aMsgDB);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::ChangeFlags(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aHdrArray, uint32_t aFlags,
+    bool aSet) {
+  for (auto msgHdr : aHdrArray) {
+    // get output stream for header
+    nsCOMPtr<nsIOutputStream> outputStream;
+    nsresult rv = GetOutputStream(msgHdr, outputStream);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Work out the flags we want to write.
+    uint32_t flags = 0;
+    (void)msgHdr->GetFlags(&flags);
+    flags &= ~(nsMsgMessageFlags::RuntimeOnly | nsMsgMessageFlags::Offline);
+    if (aSet) {
+      flags |= aFlags;
+    } else {
+      flags &= ~aFlags;
+    }
+
+    // Rewrite X-Mozilla-Status headers.
+    nsCOMPtr<nsISeekableStream> seekable(do_QueryInterface(outputStream, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = RewriteMsgFlags(seekable, flags);
+    if (NS_FAILED(rv)) NS_WARNING("updateFolderFlag failed");
+  }
+  return NS_OK;
+}
+
+// get output stream from header
+nsresult nsMsgMaildirStore::GetOutputStream(
+    nsIMsgDBHdr* aHdr, nsCOMPtr<nsIOutputStream>& aOutputStream) {
+  // file name is stored in message header property "storeToken"
+  nsAutoCString fileName;
+  aHdr->GetStringProperty("storeToken", fileName);
+  if (fileName.IsEmpty()) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = aHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> folderPath;
+  rv = folder->GetFilePath(getter_AddRefs(folderPath));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> maildirFile;
+  folderPath->Clone(getter_AddRefs(maildirFile));
+  maildirFile->Append(u"cur"_ns);
+  maildirFile->AppendNative(fileName);
+
+  return MsgGetFileStream(maildirFile, getter_AddRefs(aOutputStream));
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::ChangeKeywords(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aHdrArray, const nsACString& aKeywords,
+    bool aAdd) {
+  if (aHdrArray.IsEmpty()) return NS_ERROR_INVALID_ARG;
+
+  nsTArray<nsCString> keywordsToAdd;
+  nsTArray<nsCString> keywordsToRemove;
+  if (aAdd) {
+    ParseString(aKeywords, ' ', keywordsToAdd);
+  } else {
+    ParseString(aKeywords, ' ', keywordsToRemove);
+  }
+
+  for (auto msgHdr : aHdrArray) {
+    // Open the message file.
+    nsCOMPtr<nsIOutputStream> output;
+    nsresult rv = GetOutputStream(msgHdr, output);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsISeekableStream> seekable(do_QueryInterface(output, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    bool notEnoughRoom;
+    rv = ChangeKeywordsHelper(seekable, keywordsToAdd, keywordsToRemove,
+                              notEnoughRoom);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (notEnoughRoom) {
+      // The growKeywords property indicates that the X-Mozilla-Keys header
+      // doesn't have enough space, and should be rebuilt during the next
+      // folder compaction.
+      // TODO: For maildir there is no compaction, so this'll have no effect!
+      msgHdr->SetUint32Property("growKeywords", 1);
+    }
+    output->Close();
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMaildirStore::GetStoreType(nsACString& aType) {
+  aType.AssignLiteral("maildir");
+  return NS_OK;
+}
+
+/**
+ * Finds the directory associated with this folder. That is if the path is
+ * c:\Inbox, it will return c:\Inbox.sbd if it succeeds. Path is strictly
+ * an out parameter.
+ */
+nsresult nsMsgMaildirStore::GetDirectoryForFolder(nsIFile* path) {
+  // add directory separator to the path
+  nsAutoString leafName;
+  path->GetLeafName(leafName);
+  leafName.AppendLiteral(FOLDER_SUFFIX);
+  return path->SetLeafName(leafName);
+}
+
+nsresult nsMsgMaildirStore::CreateDirectoryForFolder(nsIFile* path,
+                                                     bool aIsServer) {
+  nsresult rv = NS_OK;
+  if (!aIsServer) {
+    rv = GetDirectoryForFolder(path);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  bool pathIsDirectory = false;
+  path->IsDirectory(&pathIsDirectory);
+  if (!pathIsDirectory) {
+    bool pathExists;
+    path->Exists(&pathExists);
+    // If for some reason there's a file with the directory separator
+    // then we are going to fail.
+    rv = pathExists ? NS_MSG_COULD_NOT_CREATE_DIRECTORY
+                    : path->Create(nsIFile::DIRECTORY_TYPE, 0700);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgMaildirStore::SliceStream(nsIInputStream* inStream, uint64_t start,
+                               uint32_t length, nsIInputStream** result) {
+  nsCOMPtr<nsIInputStream> in(inStream);
+  RefPtr<mozilla::SlicedInputStream> slicedStream =
+      new mozilla::SlicedInputStream(in.forget(), start, uint64_t(length));
+  slicedStream.forget(result);
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsMsgMaildirStore.h b/comm/mailnews/local/src/nsMsgMaildirStore.h
new file mode 100644
index 0000000000..0ab95be6c0
--- /dev/null
+++ b/comm/mailnews/local/src/nsMsgMaildirStore.h
@@ -0,0 +1,39 @@
+/* -*- 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/. */
+
+/**
+   Class for handling Maildir stores.
+*/
+
+#ifndef nsMsgMaildirStore_h__
+#define nsMsgMaildirStore_h__
+
+#include "nsMsgLocalStoreUtils.h"
+#include "nsIOutputStream.h"
+#include "nsIMsgPluggableStore.h"
+#include "nsIFile.h"
+#include "nsMsgMessageFlags.h"
+
+class nsMsgMaildirStore final : public nsMsgLocalStoreUtils,
+                                nsIMsgPluggableStore {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGPLUGGABLESTORE
+
+  nsMsgMaildirStore();
+
+ private:
+  ~nsMsgMaildirStore();
+
+ protected:
+  nsresult GetDirectoryForFolder(nsIFile* path);
+  nsresult CreateDirectoryForFolder(nsIFile* path, bool aIsServer);
+
+  nsresult CreateMaildir(nsIFile* path);
+  nsresult AddSubFolders(nsIMsgFolder* parent, nsIFile* path, bool deep);
+  nsresult GetOutputStream(nsIMsgDBHdr* aHdr,
+                           nsCOMPtr<nsIOutputStream>& aOutputStream);
+};
+#endif
diff --git a/comm/mailnews/local/src/nsNoIncomingServer.cpp b/comm/mailnews/local/src/nsNoIncomingServer.cpp
new file mode 100644
index 0000000000..b3a351eda6
--- /dev/null
+++ b/comm/mailnews/local/src/nsNoIncomingServer.cpp
@@ -0,0 +1,189 @@
+/* -*- 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"  // pre-compiled headers
+
+#include "prmem.h"
+#include "plstr.h"
+#include "prprf.h"
+#include "nsNoIncomingServer.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgMailSession.h"
+#include "nsIPop3IncomingServer.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMsgUtils.h"
+
+NS_IMPL_ISUPPORTS_INHERITED(nsNoIncomingServer, nsMsgIncomingServer,
+                            nsINoIncomingServer, nsILocalMailIncomingServer)
+
+nsNoIncomingServer::nsNoIncomingServer() {}
+
+nsNoIncomingServer::~nsNoIncomingServer() {}
+
+NS_IMETHODIMP
+nsNoIncomingServer::GetLocalStoreType(nsACString& type) {
+  type.AssignLiteral("mailbox");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoIncomingServer::GetLocalDatabaseType(nsACString& type) {
+  type.AssignLiteral("mailbox");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoIncomingServer::GetAccountManagerChrome(nsAString& aResult) {
+  aResult.AssignLiteral("am-serverwithnoidentities.xhtml");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoIncomingServer::SetFlagsOnDefaultMailboxes() {
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgLocalMailFolder> localFolder =
+      do_QueryInterface(rootFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // None server may have an inbox if it's deferred to,
+  // or if it's the smart mailboxes account.
+  localFolder->SetFlagsOnDefaultMailboxes(nsMsgFolderFlags::SpecialUse);
+
+  return NS_OK;
+}
+
+// TODO: make this work with maildir message store, bug 890742.
+NS_IMETHODIMP nsNoIncomingServer::CopyDefaultMessages(
+    const char* folderNameOnDisk) {
+  NS_ENSURE_ARG(folderNameOnDisk);
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailSession> mailSession =
+      do_GetService("@mozilla.org/messenger/services/session;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get defaults directory for messenger files. MailSession service appends
+  // 'messenger' to the the app defaults folder and returns it. Locale will be
+  // added to the path, if there is one.
+  nsCOMPtr<nsIFile> defaultMessagesFile;
+  rv = mailSession->GetDataFilesDir("messenger",
+                                    getter_AddRefs(defaultMessagesFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // check if bin/defaults/messenger/<folderNameOnDisk>
+  // (or bin/defaults/messenger/<locale>/<folderNameOnDisk> if we had a locale
+  // provide) exists. it doesn't have to exist.  if it doesn't, return
+  rv = defaultMessagesFile->AppendNative(nsDependentCString(folderNameOnDisk));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool exists;
+  rv = defaultMessagesFile->Exists(&exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!exists) return NS_OK;
+
+  nsCOMPtr<nsIFile> parentDir;
+  rv = GetLocalPath(getter_AddRefs(parentDir));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // check if parentDir/<folderNameOnDisk> exists
+  {
+    nsCOMPtr<nsIFile> testDir;
+    rv = parentDir->Clone(getter_AddRefs(testDir));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = testDir->AppendNative(nsDependentCString(folderNameOnDisk));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = testDir->Exists(&exists);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // if it exists add to the end, else copy
+  if (exists) {
+#ifdef DEBUG
+    printf("append default %s (unimplemented)\n", folderNameOnDisk);
+#endif
+    // todo for bug #1181 (the bug ID seems wrong...)
+    // open folderFile, seek to end
+    // read defaultMessagesFile, write to folderFile
+  } else {
+#ifdef DEBUG
+    printf("copy default %s\n", folderNameOnDisk);
+#endif
+    rv = defaultMessagesFile->CopyTo(parentDir, EmptyString());
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsNoIncomingServer::CreateDefaultMailboxes() {
+  nsresult rv;
+  bool isHidden = false;
+  GetHidden(&isHidden);
+  if (isHidden) return NS_OK;
+
+  // notice, no Inbox, unless we're deferred to...
+  bool isDeferredTo;
+  if (NS_SUCCEEDED(GetIsDeferredTo(&isDeferredTo)) && isDeferredTo) {
+    rv = CreateLocalFolder(u"Inbox"_ns);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  rv = CreateLocalFolder(u"Trash"_ns);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // copy the default templates into the Templates folder
+  rv = CopyDefaultMessages("Templates");
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return CreateLocalFolder(u"Unsent Messages"_ns);
+}
+
+NS_IMETHODIMP
+nsNoIncomingServer::GetNewMail(nsIMsgWindow* aMsgWindow,
+                               nsIUrlListener* aUrlListener,
+                               nsIMsgFolder* aInbox, nsIURI** aResult) {
+  if (aResult) {
+    *aResult = nullptr;
+  }
+  nsTArray<RefPtr<nsIPop3IncomingServer>> deferredServers;
+  nsresult rv = GetDeferredServers(this, deferredServers);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!deferredServers.IsEmpty()) {
+    rv = deferredServers[0]->DownloadMailFromServers(
+        deferredServers, aMsgWindow, aInbox, aUrlListener);
+  }
+  // listener might be counting on us to send a notification.
+  else if (aUrlListener)
+    aUrlListener->OnStopRunningUrl(nullptr, NS_OK);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsNoIncomingServer::GetCanSearchMessages(bool* canSearchMessages) {
+  NS_ENSURE_ARG_POINTER(canSearchMessages);
+  *canSearchMessages = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoIncomingServer::GetServerRequiresPasswordForBiff(
+    bool* aServerRequiresPasswordForBiff) {
+  NS_ENSURE_ARG_POINTER(aServerRequiresPasswordForBiff);
+  *aServerRequiresPasswordForBiff =
+      false;  // for local folders, we don't require a password
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoIncomingServer::GetSortOrder(int32_t* aSortOrder) {
+  NS_ENSURE_ARG_POINTER(aSortOrder);
+  *aSortOrder = 200000000;
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsNoIncomingServer.h b/comm/mailnews/local/src/nsNoIncomingServer.h
new file mode 100644
index 0000000000..79d09baa3a
--- /dev/null
+++ b/comm/mailnews/local/src/nsNoIncomingServer.h
@@ -0,0 +1,41 @@
+/* -*- 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 __nsNoIncomingServer_h
+#define __nsNoIncomingServer_h
+
+#include "mozilla/Attributes.h"
+#include "msgCore.h"
+#include "nsINoIncomingServer.h"
+#include "nsILocalMailIncomingServer.h"
+#include "nsMsgIncomingServer.h"
+#include "nsMailboxServer.h"
+
+/* get some implementation from nsMsgIncomingServer */
+class nsNoIncomingServer : public nsMailboxServer,
+                           public nsINoIncomingServer,
+                           public nsILocalMailIncomingServer
+
+{
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSINOINCOMINGSERVER
+  NS_DECL_NSILOCALMAILINCOMINGSERVER
+
+  nsNoIncomingServer();
+
+  NS_IMETHOD GetLocalStoreType(nsACString& type) override;
+  NS_IMETHOD GetLocalDatabaseType(nsACString& type) override;
+  NS_IMETHOD GetCanSearchMessages(bool* canSearchMessages) override;
+  NS_IMETHOD GetServerRequiresPasswordForBiff(
+      bool* aServerRequiresPasswordForBiff) override;
+  NS_IMETHOD GetAccountManagerChrome(nsAString& aResult) override;
+  NS_IMETHOD GetSortOrder(int32_t* aSortOrder) override;
+
+ private:
+  virtual ~nsNoIncomingServer();
+};
+
+#endif
diff --git a/comm/mailnews/local/src/nsNoneService.cpp b/comm/mailnews/local/src/nsNoneService.cpp
new file mode 100644
index 0000000000..74b03dc93e
--- /dev/null
+++ b/comm/mailnews/local/src/nsNoneService.cpp
@@ -0,0 +1,147 @@
+/* -*- 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 "nsNoneService.h"
+#include "nsINoIncomingServer.h"
+#include "nsINoneService.h"
+#include "nsIMsgProtocolInfo.h"
+
+#include "nsIFile.h"
+#include "nsCOMPtr.h"
+#include "nsMsgUtils.h"
+
+#include "nsMailDirServiceDefs.h"
+
+#define PREF_MAIL_ROOT_NONE_REL "mail.root.none-rel"
+// old - for backward compatibility only
+#define PREF_MAIL_ROOT_NONE "mail.root.none"
+
+nsNoneService::nsNoneService() {}
+
+nsNoneService::~nsNoneService() {}
+
+NS_IMPL_ISUPPORTS(nsNoneService, nsINoneService, nsIMsgProtocolInfo)
+
+NS_IMETHODIMP
+nsNoneService::SetDefaultLocalPath(nsIFile* aPath) {
+  NS_ENSURE_ARG(aPath);
+  return NS_SetPersistentFile(PREF_MAIL_ROOT_NONE_REL, PREF_MAIL_ROOT_NONE,
+                              aPath);
+}
+
+NS_IMETHODIMP
+nsNoneService::GetDefaultLocalPath(nsIFile** aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = nullptr;
+
+  bool havePref;
+  nsCOMPtr<nsIFile> localFile;
+  nsresult rv = NS_GetPersistentFile(PREF_MAIL_ROOT_NONE_REL,
+                                     PREF_MAIL_ROOT_NONE, NS_APP_MAIL_50_DIR,
+                                     havePref, getter_AddRefs(localFile));
+  if (NS_FAILED(rv)) return rv;
+
+  bool exists;
+  rv = localFile->Exists(&exists);
+  if (NS_SUCCEEDED(rv) && !exists)
+    rv = localFile->Create(nsIFile::DIRECTORY_TYPE, 0775);
+  if (NS_FAILED(rv)) return rv;
+
+  if (!havePref || !exists) {
+    rv = NS_SetPersistentFile(PREF_MAIL_ROOT_NONE_REL, PREF_MAIL_ROOT_NONE,
+                              localFile);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to set root dir pref.");
+  }
+
+  localFile.forget(aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetServerIID(nsIID** aServerIID) {
+  *aServerIID = new nsIID(NS_GET_IID(nsINoIncomingServer));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetRequiresUsername(bool* aRequiresUsername) {
+  NS_ENSURE_ARG_POINTER(aRequiresUsername);
+  *aRequiresUsername = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetPreflightPrettyNameWithEmailAddress(
+    bool* aPreflightPrettyNameWithEmailAddress) {
+  NS_ENSURE_ARG_POINTER(aPreflightPrettyNameWithEmailAddress);
+  *aPreflightPrettyNameWithEmailAddress = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetCanLoginAtStartUp(bool* aCanLoginAtStartUp) {
+  NS_ENSURE_ARG_POINTER(aCanLoginAtStartUp);
+  *aCanLoginAtStartUp = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetCanDelete(bool* aCanDelete) {
+  NS_ENSURE_ARG_POINTER(aCanDelete);
+  *aCanDelete = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetCanDuplicate(bool* aCanDuplicate) {
+  NS_ENSURE_ARG_POINTER(aCanDuplicate);
+  *aCanDuplicate = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetCanGetMessages(bool* aCanGetMessages) {
+  NS_ENSURE_ARG_POINTER(aCanGetMessages);
+  *aCanGetMessages = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetCanGetIncomingMessages(bool* aCanGetIncomingMessages) {
+  NS_ENSURE_ARG_POINTER(aCanGetIncomingMessages);
+  *aCanGetIncomingMessages = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetDefaultDoBiff(bool* aDoBiff) {
+  NS_ENSURE_ARG_POINTER(aDoBiff);
+  // by default, don't do biff for "none" servers
+  *aDoBiff = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetDefaultServerPort(bool isSecure, int32_t* aDefaultPort) {
+  NS_ENSURE_ARG_POINTER(aDefaultPort);
+  *aDefaultPort = -1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetShowComposeMsgLink(bool* showComposeMsgLink) {
+  NS_ENSURE_ARG_POINTER(showComposeMsgLink);
+  *showComposeMsgLink = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNoneService::GetFoldersCreatedAsync(bool* aAsyncCreation) {
+  NS_ENSURE_ARG_POINTER(aAsyncCreation);
+  *aAsyncCreation = false;
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsNoneService.h b/comm/mailnews/local/src/nsNoneService.h
new file mode 100644
index 0000000000..f87b25b846
--- /dev/null
+++ b/comm/mailnews/local/src/nsNoneService.h
@@ -0,0 +1,26 @@
+/* -*- 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 nsNoneService_h___
+#define nsNoneService_h___
+
+#include "nscore.h"
+
+#include "nsIMsgProtocolInfo.h"
+#include "nsINoneService.h"
+
+class nsNoneService : public nsIMsgProtocolInfo, public nsINoneService {
+ public:
+  nsNoneService();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGPROTOCOLINFO
+  NS_DECL_NSINONESERVICE
+
+ private:
+  virtual ~nsNoneService();
+};
+
+#endif /* nsNoneService_h___ */
diff --git a/comm/mailnews/local/src/nsParseMailbox.cpp b/comm/mailnews/local/src/nsParseMailbox.cpp
new file mode 100644
index 0000000000..7dc3c4d5b7
--- /dev/null
+++ b/comm/mailnews/local/src/nsParseMailbox.cpp
@@ -0,0 +1,2354 @@
+/* -*- 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 "nsIChannel.h"
+#include "nsParseMailbox.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgDatabase.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIInputStream.h"
+#include "nsIFile.h"
+#include "nsMsgLocalFolderHdrs.h"
+#include "nsIMailboxUrl.h"
+#include "nsNetUtil.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMsgFilter.h"
+#include "nsIMsgFilterPlugin.h"
+#include "nsIMsgFilterHitNotify.h"
+#include "nsIIOService.h"
+#include "nsNetCID.h"
+#include "nsMsgI18N.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsMsgUtils.h"
+#include "prprf.h"
+#include "prmem.h"
+#include "nsMsgSearchCore.h"
+#include "nsMailHeaders.h"
+#include "nsIMsgMailSession.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsIMsgComposeService.h"
+#include "nsIMsgCopyService.h"
+#include "nsICryptoHash.h"
+#include "nsIStringBundle.h"
+#include "nsPrintfCString.h"
+#include "nsIMsgFilterCustomAction.h"
+#include <ctype.h>
+#include "nsIMsgPluggableStore.h"
+#include "mozilla/Components.h"
+#include "nsQueryObject.h"
+#include "nsIOutputStream.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Logging.h"
+
+using namespace mozilla;
+
+extern LazyLogModule FILTERLOGMODULE;
+
+/* the following macros actually implement addref, release and query interface
+ * for our component. */
+NS_IMPL_ISUPPORTS_INHERITED(nsMsgMailboxParser, nsParseMailMessageState,
+                            nsIStreamListener, nsIRequestObserver)
+
+// Whenever data arrives from the connection, core netlib notifices the protocol
+// by calling OnDataAvailable. We then read and process the incoming data from
+// the input stream.
+NS_IMETHODIMP nsMsgMailboxParser::OnDataAvailable(nsIRequest* request,
+                                                  nsIInputStream* aIStream,
+                                                  uint64_t sourceOffset,
+                                                  uint32_t aLength) {
+  return ProcessMailboxInputStream(aIStream, aLength);
+}
+
+NS_IMETHODIMP nsMsgMailboxParser::OnStartRequest(nsIRequest* request) {
+  // extract the appropriate event sinks from the url and initialize them in our
+  // protocol data the URL should be queried for a nsIMailboxURL. If it doesn't
+  // support a mailbox URL interface then we have an error.
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIIOService> ioServ = mozilla::components::IO::Service();
+  NS_ENSURE_TRUE(ioServ, NS_ERROR_UNEXPECTED);
+
+  // We know the request is an nsIChannel we can get a URI from, but this is
+  // probably bad form. See Bug 1528662.
+  nsCOMPtr<nsIChannel> channel = do_QueryInterface(request, &rv);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "error QI nsIRequest to nsIChannel failed");
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIURI> uri;
+  rv = channel->GetURI(getter_AddRefs(uri));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMailboxUrl> runningUrl = do_QueryInterface(uri, &rv);
+
+  nsCOMPtr<nsIMsgMailNewsUrl> url = do_QueryInterface(uri);
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(m_folder);
+
+  if (NS_SUCCEEDED(rv) && runningUrl && folder) {
+    url->GetStatusFeedback(getter_AddRefs(m_statusFeedback));
+
+    // okay, now fill in our event sinks...Note that each getter ref counts
+    // before it returns the interface to us...we'll release when we are done
+
+    folder->GetName(m_folderName);
+
+    nsCOMPtr<nsIFile> path;
+    folder->GetFilePath(getter_AddRefs(path));
+
+    if (path) {
+      int64_t fileSize;
+      path->GetFileSize(&fileSize);
+      // the size of the mailbox file is our total base line for measuring
+      // progress
+      m_graph_progress_total = fileSize;
+      UpdateStatusText("buildingSummary");
+      nsCOMPtr<nsIMsgDBService> msgDBService =
+          do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+      if (msgDBService) {
+        // Use OpenFolderDB to always open the db so that db's m_folder
+        // is set correctly.
+        rv = msgDBService->OpenFolderDB(folder, true, getter_AddRefs(m_mailDB));
+        if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING)
+          rv = msgDBService->CreateNewDB(folder, getter_AddRefs(m_mailDB));
+
+        if (m_mailDB) m_mailDB->AddListener(this);
+      }
+      NS_ASSERTION(m_mailDB, "failed to open mail db parsing folder");
+
+      // try to get a backup message database
+      nsresult rvignore =
+          folder->GetBackupMsgDatabase(getter_AddRefs(m_backupMailDB));
+
+      // We'll accept failures and move on, as we're dealing with some
+      // sort of unknown problem to begin with.
+      if (NS_FAILED(rvignore)) {
+        if (m_backupMailDB) m_backupMailDB->RemoveListener(this);
+        m_backupMailDB = nullptr;
+      } else if (m_backupMailDB) {
+        m_backupMailDB->AddListener(this);
+      }
+    }
+  }
+
+  // need to get the mailbox name out of the url and call SetMailboxName with
+  // it. then, we need to open the mail db for this parser.
+  return rv;
+}
+
+// stop binding is a "notification" informing us that the stream associated with
+// aURL is going away.
+NS_IMETHODIMP nsMsgMailboxParser::OnStopRequest(nsIRequest* request,
+                                                nsresult aStatus) {
+  DoneParsingFolder(aStatus);
+  // what can we do? we can close the stream?
+
+  if (m_mailDB) m_mailDB->RemoveListener(this);
+  // and we want to mark ourselves for deletion or some how inform our protocol
+  // manager that we are available for another url if there is one....
+
+  ReleaseFolderLock();
+  // be sure to clear any status text and progress info..
+  m_graph_progress_received = 0;
+  UpdateProgressPercent();
+  UpdateStatusText("localStatusDocumentDone");
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsParseMailMessageState::OnHdrPropertyChanged(
+    nsIMsgDBHdr* aHdrToChange, const nsACString& property, bool aPreChange,
+    uint32_t* aStatus, nsIDBChangeListener* aInstigator) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsParseMailMessageState::OnHdrFlagsChanged(nsIMsgDBHdr* aHdrChanged,
+                                           uint32_t aOldFlags,
+                                           uint32_t aNewFlags,
+                                           nsIDBChangeListener* aInstigator) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsParseMailMessageState::OnHdrDeleted(nsIMsgDBHdr* aHdrChanged,
+                                      nsMsgKey aParentKey, int32_t aFlags,
+                                      nsIDBChangeListener* aInstigator) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsParseMailMessageState::OnHdrAdded(nsIMsgDBHdr* aHdrAdded, nsMsgKey aParentKey,
+                                    int32_t aFlags,
+                                    nsIDBChangeListener* aInstigator) {
+  return NS_OK;
+}
+
+/* void OnParentChanged (in nsMsgKey aKeyChanged, in nsMsgKey oldParent, in
+ * nsMsgKey newParent, in nsIDBChangeListener aInstigator); */
+NS_IMETHODIMP
+nsParseMailMessageState::OnParentChanged(nsMsgKey aKeyChanged,
+                                         nsMsgKey oldParent, nsMsgKey newParent,
+                                         nsIDBChangeListener* aInstigator) {
+  return NS_OK;
+}
+
+/* void OnAnnouncerGoingAway (in nsIDBChangeAnnouncer instigator); */
+NS_IMETHODIMP
+nsParseMailMessageState::OnAnnouncerGoingAway(
+    nsIDBChangeAnnouncer* instigator) {
+  if (m_backupMailDB && m_backupMailDB == instigator) {
+    m_backupMailDB->RemoveListener(this);
+    m_backupMailDB = nullptr;
+  } else if (m_mailDB) {
+    m_mailDB->RemoveListener(this);
+    m_mailDB = nullptr;
+    m_newMsgHdr = nullptr;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::OnEvent(nsIMsgDatabase* aDB,
+                                               const char* aEvent) {
+  return NS_OK;
+}
+
+/* void OnReadChanged (in nsIDBChangeListener instigator); */
+NS_IMETHODIMP
+nsParseMailMessageState::OnReadChanged(nsIDBChangeListener* instigator) {
+  return NS_OK;
+}
+
+/* void OnJunkScoreChanged (in nsIDBChangeListener instigator); */
+NS_IMETHODIMP
+nsParseMailMessageState::OnJunkScoreChanged(nsIDBChangeListener* instigator) {
+  return NS_OK;
+}
+
+nsMsgMailboxParser::nsMsgMailboxParser() : nsMsgLineBuffer() { Init(); }
+
+nsMsgMailboxParser::nsMsgMailboxParser(nsIMsgFolder* aFolder)
+    : nsMsgLineBuffer() {
+  m_folder = do_GetWeakReference(aFolder);
+}
+
+nsMsgMailboxParser::~nsMsgMailboxParser() { ReleaseFolderLock(); }
+
+nsresult nsMsgMailboxParser::Init() {
+  m_graph_progress_total = 0;
+  m_graph_progress_received = 0;
+  return AcquireFolderLock();
+}
+
+void nsMsgMailboxParser::UpdateStatusText(const char* stringName) {
+  if (m_statusFeedback) {
+    nsresult rv;
+    nsCOMPtr<nsIStringBundleService> bundleService =
+        mozilla::components::StringBundle::Service();
+    if (!bundleService) return;
+    nsCOMPtr<nsIStringBundle> bundle;
+    rv = bundleService->CreateBundle(
+        "chrome://messenger/locale/localMsgs.properties",
+        getter_AddRefs(bundle));
+    if (NS_FAILED(rv)) return;
+    nsString finalString;
+    AutoTArray<nsString, 1> stringArray = {m_folderName};
+    rv = bundle->FormatStringFromName(stringName, stringArray, finalString);
+    m_statusFeedback->ShowStatusString(finalString);
+  }
+}
+
+void nsMsgMailboxParser::UpdateProgressPercent() {
+  if (m_statusFeedback && m_graph_progress_total != 0) {
+    // prevent overflow by dividing both by 100
+    int64_t progressTotal = m_graph_progress_total / 100;
+    int64_t progressReceived = m_graph_progress_received / 100;
+    if (progressTotal > 0)
+      m_statusFeedback->ShowProgress((100 * (progressReceived)) /
+                                     progressTotal);
+  }
+}
+
+nsresult nsMsgMailboxParser::ProcessMailboxInputStream(nsIInputStream* aIStream,
+                                                       uint32_t aLength) {
+  nsresult ret = NS_OK;
+
+  uint32_t bytesRead = 0;
+
+  if (NS_SUCCEEDED(m_inputStream.GrowBuffer(aLength))) {
+    // OK, this sucks, but we're going to have to copy into our
+    // own byte buffer, and then pass that to the line buffering code,
+    // which means a couple buffer copies.
+    ret = aIStream->Read(m_inputStream.GetBuffer(), aLength, &bytesRead);
+    if (NS_SUCCEEDED(ret))
+      ret = BufferInput(m_inputStream.GetBuffer(), bytesRead);
+  }
+  if (m_graph_progress_total > 0) {
+    if (NS_SUCCEEDED(ret)) m_graph_progress_received += bytesRead;
+  }
+  return (ret);
+}
+
+void nsMsgMailboxParser::DoneParsingFolder(nsresult status) {
+  // End of file. Flush out any data remaining in the buffer.
+  Flush();
+  PublishMsgHeader(nullptr);
+
+  // only mark the db valid if we've succeeded.
+  if (NS_SUCCEEDED(status) &&
+      m_mailDB)  // finished parsing, so flush db folder info
+    UpdateDBFolderInfo();
+  else if (m_mailDB)
+    m_mailDB->SetSummaryValid(false);
+
+  // remove the backup database
+  if (m_backupMailDB) {
+    nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(m_folder);
+    if (folder) folder->RemoveBackupMsgDatabase();
+    m_backupMailDB = nullptr;
+  }
+}
+
+void nsMsgMailboxParser::UpdateDBFolderInfo() { UpdateDBFolderInfo(m_mailDB); }
+
+// update folder info in db so we know not to reparse.
+void nsMsgMailboxParser::UpdateDBFolderInfo(nsIMsgDatabase* mailDB) {
+  mailDB->SetSummaryValid(true);
+}
+
+// Tell the world about the message header (add to db, and view, if any)
+int32_t nsMsgMailboxParser::PublishMsgHeader(nsIMsgWindow* msgWindow) {
+  FinishHeader();
+  if (m_newMsgHdr) {
+    nsCString storeToken = nsPrintfCString("%" PRIu64, m_envelope_pos);
+    m_newMsgHdr->SetStringProperty("storeToken", storeToken);
+    m_newMsgHdr->SetMessageOffset(m_envelope_pos);
+
+    uint32_t flags;
+    (void)m_newMsgHdr->GetFlags(&flags);
+    if (flags & nsMsgMessageFlags::Expunged) {
+      nsCOMPtr<nsIDBFolderInfo> folderInfo;
+      m_mailDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+      uint32_t size;
+      (void)m_newMsgHdr->GetMessageSize(&size);
+      folderInfo->ChangeExpungedBytes(size);
+      m_newMsgHdr = nullptr;
+    } else if (m_mailDB) {
+      // add hdr but don't notify - shouldn't be requiring notifications
+      // during summary file rebuilding
+      m_mailDB->AddNewHdrToDB(m_newMsgHdr, false);
+      m_newMsgHdr = nullptr;
+    } else
+      NS_ASSERTION(
+          false,
+          "no database while parsing local folder");  // should have a DB, no?
+  } else if (m_mailDB) {
+    nsCOMPtr<nsIDBFolderInfo> folderInfo;
+    m_mailDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+    if (folderInfo)
+      folderInfo->ChangeExpungedBytes(m_position - m_envelope_pos);
+  }
+  return 0;
+}
+
+void nsMsgMailboxParser::AbortNewHeader() {
+  if (m_newMsgHdr && m_mailDB) m_newMsgHdr = nullptr;
+}
+
+void nsMsgMailboxParser::OnNewMessage(nsIMsgWindow* msgWindow) {
+  PublishMsgHeader(msgWindow);
+  Clear();
+}
+
+nsresult nsMsgMailboxParser::HandleLine(const char* line, uint32_t lineLength) {
+  /* If this is the very first line of a non-empty folder, make sure it's an
+   * envelope */
+  if (m_graph_progress_received == 0) {
+    /* This is the first block from the file.  Check to see if this
+       looks like a mail file. */
+    const char* s = line;
+    const char* end = s + lineLength;
+    while (s < end && IS_SPACE(*s)) s++;
+    if ((end - s) < 20 || !IsEnvelopeLine(s, end - s)) {
+      //      char buf[500];
+      //      PR_snprintf (buf, sizeof(buf),
+      //             XP_GetString(MK_MSG_NON_MAIL_FILE_READ_QUESTION),
+      //             folder_name);
+      //      else if (!FE_Confirm (m_context, buf))
+      //        return NS_MSG_NOT_A_MAIL_FOLDER; /* #### NOT_A_MAIL_FILE */
+    }
+  }
+  //  m_graph_progress_received += lineLength;
+
+  // mailbox parser needs to do special stuff when it finds an envelope
+  // after parsing a message body. So do that.
+  if (line[0] == 'F' && IsEnvelopeLine(line, lineLength)) {
+    // **** This used to be
+    // PR_ASSERT (m_parseMsgState->m_state == nsMailboxParseBodyState);
+    // **** I am not sure this is a right thing to do. This happens when
+    // going online, downloading a message while playing back append
+    // draft/template offline operation. We are mixing
+    // nsMailboxParseBodyState &&
+    // nsMailboxParseHeadersState. David I need your help here too. **** jt
+
+    NS_ASSERTION(m_state == nsIMsgParseMailMsgState::ParseBodyState ||
+                     m_state == nsIMsgParseMailMsgState::ParseHeadersState,
+                 "invalid parse state"); /* else folder corrupted */
+    OnNewMessage(nullptr);
+    nsresult rv = StartNewEnvelope(line, lineLength);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " error starting envelope parsing mailbox");
+    // at the start of each new message, update the progress bar
+    UpdateProgressPercent();
+    return rv;
+  }
+
+  // otherwise, the message parser can handle it completely.
+  if (m_mailDB != nullptr)  // if no DB, do we need to parse at all?
+    return ParseFolderLine(line, lineLength);
+
+  return NS_ERROR_NULL_POINTER;  // need to error out if we don't have a db.
+}
+
+void nsMsgMailboxParser::ReleaseFolderLock() {
+  nsresult result;
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(m_folder);
+  if (!folder) return;
+  bool haveSemaphore;
+  nsCOMPtr<nsISupports> supports =
+      do_QueryInterface(static_cast<nsIMsgParseMailMsgState*>(this));
+  result = folder->TestSemaphore(supports, &haveSemaphore);
+  if (NS_SUCCEEDED(result) && haveSemaphore)
+    (void)folder->ReleaseSemaphore(supports);
+}
+
+nsresult nsMsgMailboxParser::AcquireFolderLock() {
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(m_folder);
+  if (!folder) return NS_ERROR_NULL_POINTER;
+  nsCOMPtr<nsISupports> supports = do_QueryObject(this);
+  return folder->AcquireSemaphore(supports);
+}
+
+NS_IMPL_ISUPPORTS(nsParseMailMessageState, nsIMsgParseMailMsgState,
+                  nsIDBChangeListener)
+
+nsParseMailMessageState::nsParseMailMessageState() {
+  m_position = 0;
+  m_new_key = nsMsgKey_None;
+  m_state = nsIMsgParseMailMsgState::ParseBodyState;
+
+  // setup handling of custom db headers, headers that are added to .msf files
+  // as properties of the nsMsgHdr objects, controlled by the
+  // pref mailnews.customDBHeaders, a space-delimited list of headers.
+  // E.g., if mailnews.customDBHeaders is "X-Spam-Score", and we're parsing
+  // a mail message with the X-Spam-Score header, we'll set the
+  // "x-spam-score" property of nsMsgHdr to the value of the header.
+  m_customDBHeaderValues = nullptr;
+  nsCString customDBHeaders;  // not shown in search UI
+  nsCOMPtr<nsIPrefBranch> pPrefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (!pPrefBranch) {
+    return;
+  }
+  pPrefBranch->GetCharPref("mailnews.customDBHeaders", customDBHeaders);
+  ToLowerCase(customDBHeaders);
+  if (customDBHeaders.Find("content-base") == -1)
+    customDBHeaders.InsertLiteral("content-base ", 0);
+  ParseString(customDBHeaders, ' ', m_customDBHeaders);
+
+  // now add customHeaders
+  nsCString customHeadersString;  // shown in search UI
+  nsTArray<nsCString> customHeadersArray;
+  pPrefBranch->GetCharPref("mailnews.customHeaders", customHeadersString);
+  ToLowerCase(customHeadersString);
+  customHeadersString.StripWhitespace();
+  ParseString(customHeadersString, ':', customHeadersArray);
+  for (uint32_t i = 0; i < customHeadersArray.Length(); i++) {
+    if (!m_customDBHeaders.Contains(customHeadersArray[i]))
+      m_customDBHeaders.AppendElement(customHeadersArray[i]);
+  }
+
+  if (m_customDBHeaders.Length()) {
+    m_customDBHeaderValues =
+        new struct message_header[m_customDBHeaders.Length()];
+  }
+  Clear();
+}
+
+nsParseMailMessageState::~nsParseMailMessageState() {
+  ClearAggregateHeader(m_toList);
+  ClearAggregateHeader(m_ccList);
+  delete[] m_customDBHeaderValues;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::Clear() {
+  m_message_id.length = 0;
+  m_references.length = 0;
+  m_date.length = 0;
+  m_delivery_date.length = 0;
+  m_from.length = 0;
+  m_sender.length = 0;
+  m_newsgroups.length = 0;
+  m_subject.length = 0;
+  m_status.length = 0;
+  m_mozstatus.length = 0;
+  m_mozstatus2.length = 0;
+  m_envelope_from.length = 0;
+  m_envelope_date.length = 0;
+  m_priority.length = 0;
+  m_keywords.length = 0;
+  m_mdn_dnt.length = 0;
+  m_return_path.length = 0;
+  m_account_key.length = 0;
+  m_in_reply_to.length = 0;
+  m_replyTo.length = 0;
+  m_content_type.length = 0;
+  m_mdn_original_recipient.length = 0;
+  m_bccList.length = 0;
+  m_body_lines = 0;
+  m_lastLineBlank = 0;
+  m_newMsgHdr = nullptr;
+  m_envelope_pos = 0;
+  m_new_key = nsMsgKey_None;
+  ClearAggregateHeader(m_toList);
+  ClearAggregateHeader(m_ccList);
+  m_headers.ResetWritePos();
+  m_envelope.ResetWritePos();
+  m_receivedTime = 0;
+  m_receivedValue.Truncate();
+  for (uint32_t i = 0; i < m_customDBHeaders.Length(); i++) {
+    m_customDBHeaderValues[i].length = 0;
+  }
+  m_headerstartpos = 0;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::SetState(nsMailboxParseState aState) {
+  m_state = aState;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::GetState(nsMailboxParseState* aState) {
+  if (!aState) return NS_ERROR_NULL_POINTER;
+
+  *aState = m_state;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::GetNewMsgHdr(nsIMsgDBHdr** aMsgHeader) {
+  NS_ENSURE_ARG_POINTER(aMsgHeader);
+  NS_IF_ADDREF(*aMsgHeader = m_newMsgHdr);
+  return m_newMsgHdr ? NS_OK : NS_ERROR_NULL_POINTER;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::SetNewMsgHdr(nsIMsgDBHdr* aMsgHeader) {
+  m_newMsgHdr = aMsgHeader;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::ParseAFolderLine(const char* line,
+                                                        uint32_t lineLength) {
+  ParseFolderLine(line, lineLength);
+  return NS_OK;
+}
+
+nsresult nsParseMailMessageState::ParseFolderLine(const char* line,
+                                                  uint32_t lineLength) {
+  nsresult rv;
+
+  if (m_state == nsIMsgParseMailMsgState::ParseHeadersState) {
+    if (EMPTY_MESSAGE_LINE(line)) {
+      /* End of headers.  Now parse them. */
+      rv = ParseHeaders();
+      NS_ASSERTION(NS_SUCCEEDED(rv), "error parsing headers parsing mailbox");
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = FinalizeHeaders();
+      NS_ASSERTION(NS_SUCCEEDED(rv),
+                   "error finalizing headers parsing mailbox");
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      m_state = nsIMsgParseMailMsgState::ParseBodyState;
+    } else {
+      /* Otherwise, this line belongs to a header.  So append it to the
+         header data, and stay in MBOX `MIME_PARSE_HEADERS' state.
+      */
+      m_headers.AppendBuffer(line, lineLength);
+    }
+  } else if (m_state == nsIMsgParseMailMsgState::ParseBodyState) {
+    m_body_lines++;
+    // See comment in msgCore.h for why we use `IS_MSG_LINEBREAK` rather than
+    // just comparing `line` to `MSG_LINEBREAK`.
+    m_lastLineBlank = IS_MSG_LINEBREAK(line);
+  }
+
+  m_position += lineLength;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::SetMailDB(nsIMsgDatabase* mailDB) {
+  m_mailDB = mailDB;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::SetBackupMailDB(
+    nsIMsgDatabase* aBackupMailDB) {
+  m_backupMailDB = aBackupMailDB;
+  if (m_backupMailDB) m_backupMailDB->AddListener(this);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::SetNewKey(nsMsgKey aKey) {
+  m_new_key = aKey;
+  return NS_OK;
+}
+
+/* #define STRICT_ENVELOPE */
+
+bool nsParseMailMessageState::IsEnvelopeLine(const char* buf,
+                                             int32_t buf_size) {
+#ifdef STRICT_ENVELOPE
+  /* The required format is
+     From jwz  Fri Jul  1 09:13:09 1994
+   But we should also allow at least:
+     From jwz  Fri, Jul 01 09:13:09 1994
+     From jwz  Fri Jul  1 09:13:09 1994 PST
+     From jwz  Fri Jul  1 09:13:09 1994 (+0700)
+
+   We can't easily call XP_ParseTimeString() because the string is not
+   null terminated (ok, we could copy it after a quick check...) but
+   XP_ParseTimeString() may be too lenient for our purposes.
+
+   DANGER!!  The released version of 2.0b1 was (on some systems,
+   some Unix, some NT, possibly others) writing out envelope lines
+   like "From - 10/13/95 11:22:33" which STRICT_ENVELOPE will reject!
+   */
+  const char *date, *end;
+
+  if (buf_size < 29) return false;
+  if (*buf != 'F') return false;
+  if (strncmp(buf, "From ", 5)) return false;
+
+  end = buf + buf_size;
+  date = buf + 5;
+
+  /* Skip horizontal whitespace between "From " and user name. */
+  while ((*date == ' ' || *date == '\t') && date < end) date++;
+
+  /* If at the end, it doesn't match. */
+  if (IS_SPACE(*date) || date == end) return false;
+
+  /* Skip over user name. */
+  while (!IS_SPACE(*date) && date < end) date++;
+
+  /* Skip horizontal whitespace between user name and date. */
+  while ((*date == ' ' || *date == '\t') && date < end) date++;
+
+    /* Don't want this to be localized. */
+#  define TMP_ISALPHA(x) \
+    (((x) >= 'A' && (x) <= 'Z') || ((x) >= 'a' && (x) <= 'z'))
+
+  /* take off day-of-the-week. */
+  if (date >= end - 3) return false;
+  if (!TMP_ISALPHA(date[0]) || !TMP_ISALPHA(date[1]) || !TMP_ISALPHA(date[2]))
+    return false;
+  date += 3;
+  /* Skip horizontal whitespace (and commas) between dotw and month. */
+  if (*date != ' ' && *date != '\t' && *date != ',') return false;
+  while ((*date == ' ' || *date == '\t' || *date == ',') && date < end) date++;
+
+  /* take off month. */
+  if (date >= end - 3) return false;
+  if (!TMP_ISALPHA(date[0]) || !TMP_ISALPHA(date[1]) || !TMP_ISALPHA(date[2]))
+    return false;
+  date += 3;
+  /* Skip horizontal whitespace between month and dotm. */
+  if (date == end || (*date != ' ' && *date != '\t')) return false;
+  while ((*date == ' ' || *date == '\t') && date < end) date++;
+
+  /* Skip over digits and whitespace. */
+  while (((*date >= '0' && *date <= '9') || *date == ' ' || *date == '\t') &&
+         date < end)
+    date++;
+  /* Next character should be a colon. */
+  if (date >= end || *date != ':') return false;
+
+    /* Ok, that ought to be enough... */
+
+#  undef TMP_ISALPHA
+
+#else /* !STRICT_ENVELOPE */
+
+  if (buf_size < 5) return false;
+  if (*buf != 'F') return false;
+  if (strncmp(buf, "From ", 5)) return false;
+
+#endif /* !STRICT_ENVELOPE */
+
+  return true;
+}
+
+// We've found the start of the next message, so finish this one off.
+NS_IMETHODIMP nsParseMailMessageState::FinishHeader() {
+  if (m_newMsgHdr) {
+    if (m_lastLineBlank) m_body_lines--;
+    m_newMsgHdr->SetMessageSize(m_position - m_envelope_pos - m_lastLineBlank);
+    m_newMsgHdr->SetLineCount(m_body_lines);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsParseMailMessageState::GetAllHeaders(char** pHeaders,
+                                                     int32_t* pHeadersSize) {
+  if (!pHeaders || !pHeadersSize) return NS_ERROR_NULL_POINTER;
+  *pHeaders = m_headers.GetBuffer();
+  *pHeadersSize = m_headers.GetBufferPos();
+  return NS_OK;
+}
+
+// generate headers as a string, with CRLF between the headers
+NS_IMETHODIMP nsParseMailMessageState::GetHeaders(char** pHeaders) {
+  NS_ENSURE_ARG_POINTER(pHeaders);
+  nsCString crlfHeaders;
+  char* curHeader = m_headers.GetBuffer();
+  for (uint32_t headerPos = 0; headerPos < m_headers.GetBufferPos();) {
+    crlfHeaders.Append(curHeader);
+    crlfHeaders.Append(CRLF);
+    int32_t headerLen = strlen(curHeader);
+    curHeader += headerLen + 1;
+    headerPos += headerLen + 1;
+  }
+  *pHeaders = ToNewCString(crlfHeaders);
+  return NS_OK;
+}
+
+struct message_header* nsParseMailMessageState::GetNextHeaderInAggregate(
+    nsTArray<struct message_header*>& list) {
+  // When parsing a message with multiple To or CC header lines, we're storing
+  // each line in a list, where the list represents the "aggregate" total of all
+  // the header. Here we get a new line for the list
+
+  struct message_header* header =
+      (struct message_header*)PR_Calloc(1, sizeof(struct message_header));
+  list.AppendElement(header);
+  return header;
+}
+
+void nsParseMailMessageState::GetAggregateHeader(
+    nsTArray<struct message_header*>& list, struct message_header* outHeader) {
+  // When parsing a message with multiple To or CC header lines, we're storing
+  // each line in a list, where the list represents the "aggregate" total of all
+  // the header. Here we combine all the lines together, as though they were
+  // really all found on the same line
+
+  struct message_header* header = nullptr;
+  int length = 0;
+  size_t i;
+
+  // Count up the bytes required to allocate the aggregated header
+  for (i = 0; i < list.Length(); i++) {
+    header = list.ElementAt(i);
+    length += (header->length + 1);  //+ for ","
+  }
+
+  if (length > 0) {
+    char* value = (char*)PR_CALLOC(length + 1);  //+1 for null term
+    if (value) {
+      // Catenate all the To lines together, separated by commas
+      value[0] = '\0';
+      size_t size = list.Length();
+      for (i = 0; i < size; i++) {
+        header = list.ElementAt(i);
+        PL_strncat(value, header->value, header->length);
+        if (i + 1 < size) PL_strcat(value, ",");
+      }
+      outHeader->length = length;
+      outHeader->value = value;
+    }
+  } else {
+    outHeader->length = 0;
+    outHeader->value = nullptr;
+  }
+}
+
+void nsParseMailMessageState::ClearAggregateHeader(
+    nsTArray<struct message_header*>& list) {
+  // Reset the aggregate headers. Free only the message_header struct since
+  // we don't own the value pointer
+
+  for (size_t i = 0; i < list.Length(); i++) PR_Free(list.ElementAt(i));
+  list.Clear();
+}
+
+// We've found a new envelope to parse.
+nsresult nsParseMailMessageState::StartNewEnvelope(const char* line,
+                                                   uint32_t lineLength) {
+  m_envelope_pos = m_position;
+  m_state = nsIMsgParseMailMsgState::ParseHeadersState;
+  m_position += lineLength;
+  m_headerstartpos = m_position;
+  return ParseEnvelope(line, lineLength);
+}
+
+/* largely lifted from mimehtml.c, which does similar parsing, sigh...
+ */
+nsresult nsParseMailMessageState::ParseHeaders() {
+  char* buf = m_headers.GetBuffer();
+  uint32_t buf_length = m_headers.GetBufferPos();
+  if (buf_length == 0) {
+    // No header of an expected type is present. Consider this a successful
+    // parse so email still shows on summary and can be accessed and deleted.
+    return NS_OK;
+  }
+  char* buf_end = buf + buf_length;
+  if (!(buf_length > 1 &&
+        (buf[buf_length - 1] == '\r' || buf[buf_length - 1] == '\n'))) {
+    NS_WARNING("Header text should always end in a newline");
+    return NS_ERROR_UNEXPECTED;
+  }
+  while (buf < buf_end) {
+    char* colon = PL_strnchr(buf, ':', buf_end - buf);
+    char* value = 0;
+    struct message_header* header = 0;
+    struct message_header receivedBy;
+
+    if (!colon) break;
+
+    nsDependentCSubstring headerStr(buf, colon);
+    ToLowerCase(headerStr);
+
+    // Obtain firstChar in headerStr. But if headerStr is empty, just set it to
+    // the colon. This is needed because First() asserts on an empty string.
+    char firstChar = !headerStr.IsEmpty() ? headerStr.First() : *colon;
+
+    // See RFC 5322 section 3.6 for min-max number for given header.
+    // If multiple headers exist we need to make sure to use the first one.
+
+    switch (firstChar) {
+      case 'b':
+        if (headerStr.EqualsLiteral("bcc") && !m_bccList.length)
+          header = &m_bccList;
+        break;
+      case 'c':
+        if (headerStr.EqualsLiteral("cc"))  // XXX: RFC 5322 says it's 0 or 1.
+          header = GetNextHeaderInAggregate(m_ccList);
+        else if (headerStr.EqualsLiteral("content-type"))
+          header = &m_content_type;
+        break;
+      case 'd':
+        if (headerStr.EqualsLiteral("date") && !m_date.length)
+          header = &m_date;
+        else if (headerStr.EqualsLiteral("disposition-notification-to"))
+          header = &m_mdn_dnt;
+        else if (headerStr.EqualsLiteral("delivery-date"))
+          header = &m_delivery_date;
+        break;
+      case 'f':
+        if (headerStr.EqualsLiteral("from") && !m_from.length) {
+          header = &m_from;
+        }
+        break;
+      case 'i':
+        if (headerStr.EqualsLiteral("in-reply-to") && !m_in_reply_to.length)
+          header = &m_in_reply_to;
+        break;
+      case 'm':
+        if (headerStr.EqualsLiteral("message-id") && !m_message_id.length)
+          header = &m_message_id;
+        break;
+      case 'n':
+        if (headerStr.EqualsLiteral("newsgroups")) header = &m_newsgroups;
+        break;
+      case 'o':
+        if (headerStr.EqualsLiteral("original-recipient"))
+          header = &m_mdn_original_recipient;
+        break;
+      case 'p':
+        // we could very well care what the priority header was when we
+        // remember its value. If so, need to remember it here. Also,
+        // different priority headers can appear in the same message,
+        // but we only remember the last one that we see. Applies also to
+        // x-priority checked below.
+        if (headerStr.EqualsLiteral("priority")) header = &m_priority;
+        break;
+      case 'r':
+        if (headerStr.EqualsLiteral("references") && !m_references.length)
+          header = &m_references;
+        else if (headerStr.EqualsLiteral("return-path"))
+          header = &m_return_path;
+        // treat conventional Return-Receipt-To as MDN
+        // Disposition-Notification-To
+        else if (headerStr.EqualsLiteral("return-receipt-to"))
+          header = &m_mdn_dnt;
+        else if (headerStr.EqualsLiteral("reply-to") && !m_replyTo.length)
+          header = &m_replyTo;
+        else if (headerStr.EqualsLiteral("received")) {
+          header = &receivedBy;
+          header->length = 0;
+        }
+        break;
+      case 's':
+        if (headerStr.EqualsLiteral("subject") && !m_subject.length)
+          header = &m_subject;
+        else if (headerStr.EqualsLiteral("sender") && !m_sender.length)
+          header = &m_sender;
+        else if (headerStr.EqualsLiteral("status"))
+          header = &m_status;
+        break;
+      case 't':
+        if (headerStr.EqualsLiteral("to"))  // XXX: RFC 5322 says it's 0 or 1.
+          header = GetNextHeaderInAggregate(m_toList);
+        break;
+      case 'x':
+        if (headerStr.EqualsIgnoreCase(X_MOZILLA_STATUS2) &&
+            !m_mozstatus2.length)
+          header = &m_mozstatus2;
+        else if (headerStr.EqualsIgnoreCase(X_MOZILLA_STATUS) &&
+                 !m_mozstatus.length)
+          header = &m_mozstatus;
+        else if (headerStr.EqualsIgnoreCase(HEADER_X_MOZILLA_ACCOUNT_KEY) &&
+                 !m_account_key.length)
+          header = &m_account_key;
+        else if (headerStr.EqualsLiteral("x-priority"))  // See case 'p' above.
+          header = &m_priority;
+        else if (headerStr.EqualsIgnoreCase(HEADER_X_MOZILLA_KEYWORDS) &&
+                 !m_keywords.length)
+          header = &m_keywords;
+        break;
+    }
+
+    if (!header && m_customDBHeaders.Length()) {
+      size_t customHeaderIndex = m_customDBHeaders.IndexOf(headerStr);
+      if (customHeaderIndex != m_customDBHeaders.NoIndex)
+        header = &m_customDBHeaderValues[customHeaderIndex];
+    }
+
+    buf = colon + 1;
+    // We will be shuffling downwards, so this is our insertion point.
+    char* bufWrite = buf;
+
+  SEARCH_NEWLINE:
+    // move past any non terminating characters, rewriting them if folding white
+    // space exists
+    while (buf < buf_end && *buf != '\r' && *buf != '\n') {
+      if (buf != bufWrite) *bufWrite = *buf;
+      buf++;
+      bufWrite++;
+    }
+
+    // Look for folding, so CRLF, CR or LF followed by space or tab.
+    if ((buf + 2 < buf_end && (buf[0] == '\r' && buf[1] == '\n') &&
+         (buf[2] == ' ' || buf[2] == '\t')) ||
+        (buf + 1 < buf_end && (buf[0] == '\r' || buf[0] == '\n') &&
+         (buf[1] == ' ' || buf[1] == '\t'))) {
+      // Remove trailing spaces at the "write position" and add a single
+      // folding space.
+      while (*(bufWrite - 1) == ' ' || *(bufWrite - 1) == '\t') bufWrite--;
+      *(bufWrite++) = ' ';
+
+      // Skip CRLF, CR+space or LF+space ...
+      buf += 2;
+
+      // ... and skip leading spaces in that line.
+      while (buf < buf_end && (*buf == ' ' || *buf == '\t')) buf++;
+
+      // If we get here, the message headers ended in an empty line, like:
+      // To: blah blah blah<CR><LF>  <CR><LF>[end of buffer]. The code below
+      // requires buf to land on a newline to properly null-terminate the
+      // string, so back up a tad so that it is pointing to one.
+      if (buf == buf_end) {
+        --buf;
+        MOZ_ASSERT(*buf == '\n' || *buf == '\r',
+                   "Header text should always end in a newline.");
+      }
+      goto SEARCH_NEWLINE;
+    }
+
+    if (header) {
+      value = colon + 1;
+      // eliminate trailing blanks after the colon
+      while (value < bufWrite && (*value == ' ' || *value == '\t')) value++;
+
+      header->value = value;
+      header->length = bufWrite - value;
+      if (header->length < 0) header->length = 0;
+    }
+    if (*buf == '\r' || *buf == '\n') {
+      char* last = bufWrite;
+      char* saveBuf = buf;
+      if (*buf == '\r' && buf + 1 < buf_end && buf[1] == '\n') buf++;
+      buf++;
+      // null terminate the left-over slop so we don't confuse msg filters.
+      *saveBuf = 0;
+      *last = 0; /* short-circuit const, and null-terminate header. */
+    }
+
+    if (header) {
+      /* More const short-circuitry... */
+      /* strip trailing whitespace */
+      while (header->length > 0 && IS_SPACE(header->value[header->length - 1]))
+        ((char*)header->value)[--header->length] = 0;
+      if (header == &receivedBy) {
+        if (m_receivedTime == 0) {
+          // parse Received: header for date.
+          // We trust the first header as that is closest to recipient,
+          // and less likely to be spoofed.
+          nsAutoCString receivedHdr(header->value, header->length);
+          int32_t lastSemicolon = receivedHdr.RFindChar(';');
+          if (lastSemicolon != -1) {
+            nsAutoCString receivedDate;
+            receivedDate = Substring(receivedHdr, lastSemicolon + 1);
+            receivedDate.Trim(" \t\b\r\n");
+            PRTime resultTime;
+            if (PR_ParseTimeString(receivedDate.get(), false, &resultTime) ==
+                PR_SUCCESS)
+              m_receivedTime = resultTime;
+            else
+              NS_WARNING("PR_ParseTimeString failed in ParseHeaders().");
+          }
+        }
+        // Someone might want the received header saved.
+        if (m_customDBHeaders.Length()) {
+          if (m_customDBHeaders.Contains("received"_ns)) {
+            if (!m_receivedValue.IsEmpty()) m_receivedValue.Append(' ');
+            m_receivedValue.Append(header->value, header->length);
+          }
+        }
+      }
+
+      MOZ_ASSERT(header->value[header->length] == 0,
+                 "Non-null-terminated strings cause very, very bad problems");
+    }
+  }
+  return NS_OK;
+}
+
+// Try and glean a sender and/or timestamp from the "From " line, to use
+// as last-ditch fallbacks if the message is missing "From"/"Sender" or
+// "Date" headers.
+nsresult nsParseMailMessageState::ParseEnvelope(const char* line,
+                                                uint32_t line_size) {
+  const char* end;
+  char* s;
+
+  m_envelope.AppendBuffer(line, line_size);
+  end = m_envelope.GetBuffer() + line_size;
+  s = m_envelope.GetBuffer() + 5;
+
+  while (s < end && IS_SPACE(*s)) s++;
+  m_envelope_from.value = s;
+  while (s < end && !IS_SPACE(*s)) s++;
+  m_envelope_from.length = s - m_envelope_from.value;
+
+  while (s < end && IS_SPACE(*s)) s++;
+  m_envelope_date.value = s;
+  m_envelope_date.length = (uint16_t)(line_size - (s - m_envelope.GetBuffer()));
+
+  while (m_envelope_date.length > 0 &&
+         IS_SPACE(m_envelope_date.value[m_envelope_date.length - 1]))
+    m_envelope_date.length--;
+
+  /* #### short-circuit const */
+  ((char*)m_envelope_from.value)[m_envelope_from.length] = 0;
+  ((char*)m_envelope_date.value)[m_envelope_date.length] = 0;
+
+  return NS_OK;
+}
+
+nsresult nsParseMailMessageState::InternSubject(struct message_header* header) {
+  if (!header || header->length == 0) {
+    m_newMsgHdr->SetSubject(""_ns);
+    return NS_OK;
+  }
+
+  nsDependentCString key(header->value);
+
+  uint32_t flags;
+  (void)m_newMsgHdr->GetFlags(&flags);
+  /* strip "Re: " */
+  /**
+        We trust the X-Mozilla-Status line to be the smartest in almost
+        all things.  One exception, however, is the HAS_RE flag.  Since
+         we just parsed the subject header anyway, we expect that parsing
+         to be smartest.  (After all, what if someone just went in and
+        edited the subject line by hand?)
+     */
+  nsCString modifiedSubject;
+  bool strippedRE = NS_MsgStripRE(key, modifiedSubject);
+  if (strippedRE)
+    flags |= nsMsgMessageFlags::HasRe;
+  else
+    flags &= ~nsMsgMessageFlags::HasRe;
+  m_newMsgHdr->SetFlags(flags);  // this *does not* update the mozilla-status
+                                 // header in the local folder
+
+  m_newMsgHdr->SetSubject(strippedRE ? modifiedSubject : key);
+
+  return NS_OK;
+}
+
+// we've reached the end of the envelope, and need to turn all our accumulated
+// message_headers into a single nsIMsgDBHdr to store in a database.
+nsresult nsParseMailMessageState::FinalizeHeaders() {
+  nsresult rv;
+  struct message_header* sender;
+  struct message_header* recipient;
+  struct message_header* subject;
+  struct message_header* id;
+  struct message_header* inReplyTo;
+  struct message_header* replyTo;
+  struct message_header* references;
+  struct message_header* date;
+  struct message_header* deliveryDate;
+  struct message_header* statush;
+  struct message_header* mozstatus;
+  struct message_header* mozstatus2;
+  struct message_header* priority;
+  struct message_header* keywords;
+  struct message_header* account_key;
+  struct message_header* ccList;
+  struct message_header* bccList;
+  struct message_header* mdn_dnt;
+  struct message_header md5_header;
+  struct message_header* content_type;
+  char md5_data[50];
+
+  uint32_t flags = 0;
+  nsMsgPriorityValue priorityFlags = nsMsgPriority::notSet;
+
+  if (!m_mailDB)  // if we don't have a valid db, skip the header.
+    return NS_OK;
+
+  struct message_header to;
+  GetAggregateHeader(m_toList, &to);
+  struct message_header cc;
+  GetAggregateHeader(m_ccList, &cc);
+  // we don't aggregate bcc, as we only generate it locally,
+  // and we don't use multiple lines
+
+  // clang-format off
+  sender       = (m_from.length          ? &m_from          :
+                  m_sender.length        ? &m_sender        :
+                  m_envelope_from.length ? &m_envelope_from : 0);
+  recipient    = (to.length              ? &to              :
+                  cc.length              ? &cc              :
+                  m_newsgroups.length    ? &m_newsgroups    : 0);
+  ccList       = (cc.length              ? &cc              : 0);
+  bccList      = (m_bccList.length       ? &m_bccList       : 0);
+  subject      = (m_subject.length       ? &m_subject       : 0);
+  id           = (m_message_id.length    ? &m_message_id    : 0);
+  references   = (m_references.length    ? &m_references    : 0);
+  statush      = (m_status.length        ? &m_status        : 0);
+  mozstatus    = (m_mozstatus.length     ? &m_mozstatus     : 0);
+  mozstatus2   = (m_mozstatus2.length    ? &m_mozstatus2    : 0);
+  date         = (m_date.length          ? &m_date          :
+                  m_envelope_date.length ? &m_envelope_date : 0);
+  deliveryDate = (m_delivery_date.length ? &m_delivery_date : 0);
+  priority     = (m_priority.length      ? &m_priority      : 0);
+  keywords     = (m_keywords.length      ? &m_keywords      : 0);
+  mdn_dnt      = (m_mdn_dnt.length       ? &m_mdn_dnt       : 0);
+  inReplyTo    = (m_in_reply_to.length   ? &m_in_reply_to   : 0);
+  replyTo      = (m_replyTo.length       ? &m_replyTo       : 0);
+  content_type = (m_content_type.length  ? &m_content_type  : 0);
+  account_key  = (m_account_key.length   ? &m_account_key   : 0);
+  // clang-format on
+
+  if (mozstatus) {
+    if (mozstatus->length == 4) {
+      NS_ASSERTION(MsgIsHex(mozstatus->value, 4),
+                   "Expected 4 hex digits for flags.");
+      flags = MsgUnhex(mozstatus->value, 4);
+      // strip off and remember priority bits.
+      flags &= ~nsMsgMessageFlags::RuntimeOnly;
+      priorityFlags =
+          (nsMsgPriorityValue)((flags & nsMsgMessageFlags::Priorities) >> 13);
+      flags &= ~nsMsgMessageFlags::Priorities;
+    }
+  }
+
+  if (mozstatus2) {
+    uint32_t flags2 = 0;
+    sscanf(mozstatus2->value, " %x ", &flags2);
+    flags |= flags2;
+  }
+
+  if (!(flags & nsMsgMessageFlags::Expunged))  // message was deleted, don't
+                                               // bother creating a hdr.
+  {
+    // We'll need the message id first to recover data from the backup database
+    nsAutoCString rawMsgId;
+    /* Take off <> around message ID. */
+    if (id) {
+      if (id->length > 0 && id->value[0] == '<') {
+        id->length--;
+        id->value++;
+      }
+
+      NS_WARNING_ASSERTION(id->length > 0,
+                           "id->length failure in FinalizeHeaders().");
+
+      if (id->length > 0 && id->value[id->length - 1] == '>')
+        /* generate a new null-terminated string without the final > */
+        rawMsgId.Assign(id->value, id->length - 1);
+      else
+        rawMsgId.Assign(id->value);
+    }
+
+    /*
+     * Try to copy the data from the backup database, referencing the MessageID
+     * If that fails, just create a new header
+     */
+    nsCOMPtr<nsIMsgDBHdr> oldHeader;
+    nsresult ret = NS_OK;
+
+    if (m_backupMailDB && !rawMsgId.IsEmpty())
+      ret = m_backupMailDB->GetMsgHdrForMessageID(rawMsgId.get(),
+                                                  getter_AddRefs(oldHeader));
+
+    // m_new_key is set in nsImapMailFolder::ParseAdoptedHeaderLine to be
+    // the UID of the message, so that the key can get created as UID. That of
+    // course is extremely confusing, and we really need to clean that up. We
+    // really should not conflate the meaning of envelope position, key, and
+    // UID.
+    if (NS_SUCCEEDED(ret) && oldHeader)
+      ret = m_mailDB->CopyHdrFromExistingHdr(m_new_key, oldHeader, false,
+                                             getter_AddRefs(m_newMsgHdr));
+    else if (!m_newMsgHdr) {
+      // Should assert that this is not a local message
+      ret = m_mailDB->CreateNewHdr(m_new_key, getter_AddRefs(m_newMsgHdr));
+    }
+
+    if (NS_SUCCEEDED(ret) && m_newMsgHdr) {
+      uint32_t origFlags;
+      (void)m_newMsgHdr->GetFlags(&origFlags);
+      if (origFlags & nsMsgMessageFlags::HasRe)
+        flags |= nsMsgMessageFlags::HasRe;
+      else
+        flags &= ~nsMsgMessageFlags::HasRe;
+
+      flags &=
+          ~nsMsgMessageFlags::Offline;  // don't keep nsMsgMessageFlags::Offline
+                                        // for local msgs
+      if (mdn_dnt && !(origFlags & nsMsgMessageFlags::Read) &&
+          !(origFlags & nsMsgMessageFlags::MDNReportSent) &&
+          !(flags & nsMsgMessageFlags::MDNReportSent))
+        flags |= nsMsgMessageFlags::MDNReportNeeded;
+
+      m_newMsgHdr->SetFlags(flags);
+      if (priorityFlags != nsMsgPriority::notSet)
+        m_newMsgHdr->SetPriority(priorityFlags);
+
+      // if we have a reply to header, and it's different from the from: header,
+      // set the "replyTo" attribute on the msg hdr.
+      if (replyTo && (!sender || replyTo->length != sender->length ||
+                      strncmp(replyTo->value, sender->value, sender->length)))
+        m_newMsgHdr->SetStringProperty("replyTo",
+                                       nsDependentCString(replyTo->value));
+      if (sender) m_newMsgHdr->SetAuthor(sender->value);
+      if (recipient == &m_newsgroups) {
+        /* In the case where the recipient is a newsgroup, truncate the string
+           at the first comma.  This is used only for presenting the thread
+           list, and newsgroup lines tend to be long and non-shared, and tend to
+           bloat the string table.  So, by only showing the first newsgroup, we
+           can reduce memory and file usage at the expense of only showing the
+           one group in the summary list, and only being able to sort on the
+           first group rather than the whole list.  It's worth it. */
+        char* ch;
+        ch = PL_strchr(recipient->value, ',');
+        if (ch) {
+          /* generate a new string that terminates before the , */
+          nsAutoCString firstGroup;
+          firstGroup.Assign(recipient->value, ch - recipient->value);
+          m_newMsgHdr->SetRecipients(firstGroup.get());
+        }
+        m_newMsgHdr->SetRecipients(recipient->value);
+      } else if (recipient) {
+        m_newMsgHdr->SetRecipients(recipient->value);
+      }
+      if (ccList) {
+        m_newMsgHdr->SetCcList(ccList->value);
+      }
+
+      if (bccList) {
+        m_newMsgHdr->SetBccList(bccList->value);
+      }
+
+      rv = InternSubject(subject);
+      if (NS_SUCCEEDED(rv)) {
+        if (!id) {
+          // what to do about this? we used to do a hash of all the headers...
+          nsAutoCString hash;
+          const char* md5_b64 = "dummy.message.id";
+          nsresult rv;
+          nsCOMPtr<nsICryptoHash> hasher =
+              do_CreateInstance("@mozilla.org/security/hash;1", &rv);
+          if (NS_SUCCEEDED(rv)) {
+            if (NS_SUCCEEDED(hasher->Init(nsICryptoHash::MD5)) &&
+                NS_SUCCEEDED(
+                    hasher->Update((const uint8_t*)m_headers.GetBuffer(),
+                                   m_headers.GetBufferPos())) &&
+                NS_SUCCEEDED(hasher->Finish(true, hash)))
+              md5_b64 = hash.get();
+          }
+          PR_snprintf(md5_data, sizeof(md5_data), "<md5:%s>", md5_b64);
+          md5_header.value = md5_data;
+          md5_header.length = strlen(md5_data);
+          id = &md5_header;
+        }
+
+        if (!rawMsgId.IsEmpty())
+          m_newMsgHdr->SetMessageId(rawMsgId.get());
+        else
+          m_newMsgHdr->SetMessageId(id->value);
+        m_mailDB->UpdatePendingAttributes(m_newMsgHdr);
+
+        if (!mozstatus && statush) {
+          /* Parse a little bit of the Berkeley Mail status header. */
+          for (const char* s = statush->value; *s; s++) {
+            uint32_t msgFlags = 0;
+            (void)m_newMsgHdr->GetFlags(&msgFlags);
+            switch (*s) {
+              case 'R':
+              case 'r':
+                m_newMsgHdr->SetFlags(msgFlags | nsMsgMessageFlags::Read);
+                break;
+              case 'D':
+              case 'd':
+                /* msg->flags |= nsMsgMessageFlags::Expunged;  ### Is this
+                 * reasonable? */
+                break;
+              case 'N':
+              case 'n':
+              case 'U':
+              case 'u':
+                m_newMsgHdr->SetFlags(msgFlags & ~nsMsgMessageFlags::Read);
+                break;
+              default:  // Should check for corrupt file.
+                NS_ERROR("Corrupt file. Should not happen.");
+                break;
+            }
+          }
+        }
+
+        if (account_key != nullptr)
+          m_newMsgHdr->SetAccountKey(account_key->value);
+        // use in-reply-to header as references, if there's no references header
+        if (references != nullptr) {
+          m_newMsgHdr->SetReferences(nsDependentCString(references->value));
+        } else if (inReplyTo != nullptr)
+          m_newMsgHdr->SetReferences(nsDependentCString(inReplyTo->value));
+
+        // 'Received' should be as reliable an indicator of the receipt
+        // date+time as possible, whilst always giving something *from
+        // the message*.  It won't use PR_Now() under any circumstance.
+        // Therefore, the fall-thru order for 'Received' is:
+        // Received: -> Delivery-date: -> date
+        // 'Date' uses:
+        // date -> 'Received' -> PR_Now()
+        //
+        // date is:
+        // Date: -> m_envelope_date
+
+        uint32_t rcvTimeSecs = 0;
+        PRTime datePRTime = 0;
+        if (date) {
+          // Date:
+          if (PR_ParseTimeString(date->value, false, &datePRTime) ==
+              PR_SUCCESS) {
+            // Convert to seconds as default value for 'Received'.
+            PRTime2Seconds(datePRTime, &rcvTimeSecs);
+          } else {
+            NS_WARNING(
+                "PR_ParseTimeString of date failed in FinalizeHeader().");
+          }
+        }
+        if (m_receivedTime) {
+          // Upgrade 'Received' to Received: ?
+          PRTime2Seconds(m_receivedTime, &rcvTimeSecs);
+          if (datePRTime == 0) datePRTime = m_receivedTime;
+        } else if (deliveryDate) {
+          // Upgrade 'Received' to Delivery-date: ?
+          PRTime resultTime;
+          if (PR_ParseTimeString(deliveryDate->value, false, &resultTime) ==
+              PR_SUCCESS) {
+            PRTime2Seconds(resultTime, &rcvTimeSecs);
+            if (datePRTime == 0) datePRTime = resultTime;
+          } else {
+            // TODO/FIXME: We need to figure out what to do in this case!
+            NS_WARNING(
+                "PR_ParseTimeString of delivery date failed in "
+                "FinalizeHeader().");
+          }
+        }
+        m_newMsgHdr->SetUint32Property("dateReceived", rcvTimeSecs);
+
+        if (datePRTime == 0) {
+          // If there was some problem parsing the Date header *AND* we
+          // couldn't get a valid envelope date *AND* we couldn't get a valid
+          // Received: header date, use now as the time.
+          // This doesn't affect local (POP3) messages, because we use the
+          // envelope date if there's no Date: header, but it will affect IMAP
+          // msgs w/o a Date: header or Received: headers.
+          datePRTime = PR_Now();
+        }
+        m_newMsgHdr->SetDate(datePRTime);
+
+        if (priority) {
+          nsMsgPriorityValue priorityVal = nsMsgPriority::Default;
+
+          // We can ignore |NS_MsgGetPriorityFromString()| return value,
+          // since we set a default value for |priorityVal|.
+          NS_MsgGetPriorityFromString(priority->value, priorityVal);
+          m_newMsgHdr->SetPriority(priorityVal);
+        } else if (priorityFlags == nsMsgPriority::notSet)
+          m_newMsgHdr->SetPriority(nsMsgPriority::none);
+        if (keywords) {
+          // When there are many keywords, some may not have been written
+          // to the message file, so add extra keywords from the backup
+          nsAutoCString oldKeywords;
+          m_newMsgHdr->GetStringProperty("keywords", oldKeywords);
+          nsTArray<nsCString> newKeywordArray, oldKeywordArray;
+          ParseString(
+              Substring(keywords->value, keywords->value + keywords->length),
+              ' ', newKeywordArray);
+          ParseString(oldKeywords, ' ', oldKeywordArray);
+          for (uint32_t i = 0; i < oldKeywordArray.Length(); i++)
+            if (!newKeywordArray.Contains(oldKeywordArray[i]))
+              newKeywordArray.AppendElement(oldKeywordArray[i]);
+          nsAutoCString newKeywords;
+          for (uint32_t i = 0; i < newKeywordArray.Length(); i++) {
+            if (i) newKeywords.Append(' ');
+            newKeywords.Append(newKeywordArray[i]);
+          }
+          m_newMsgHdr->SetStringProperty("keywords", newKeywords);
+        }
+        for (uint32_t i = 0; i < m_customDBHeaders.Length(); i++) {
+          if (m_customDBHeaderValues[i].length)
+            m_newMsgHdr->SetStringProperty(
+                m_customDBHeaders[i].get(),
+                nsDependentCString(m_customDBHeaderValues[i].value));
+          // The received header is accumulated separately
+          if (m_customDBHeaders[i].EqualsLiteral("received") &&
+              !m_receivedValue.IsEmpty())
+            m_newMsgHdr->SetStringProperty("received", m_receivedValue);
+        }
+        if (content_type) {
+          char* substring = PL_strstr(content_type->value, "charset");
+          if (substring) {
+            char* charset = PL_strchr(substring, '=');
+            if (charset) {
+              charset++;
+              /* strip leading whitespace and double-quote */
+              while (*charset && (IS_SPACE(*charset) || '\"' == *charset))
+                charset++;
+              /* strip trailing whitespace and double-quote */
+              char* end = charset;
+              while (*end && !IS_SPACE(*end) && '\"' != *end && ';' != *end)
+                end++;
+              if (*charset) {
+                if (*end != '\0') {
+                  // if we're not at the very end of the line, we need
+                  // to generate a new string without the trailing crud
+                  nsAutoCString rawCharSet;
+                  rawCharSet.Assign(charset, end - charset);
+                  m_newMsgHdr->SetCharset(rawCharSet.get());
+                } else {
+                  m_newMsgHdr->SetCharset(charset);
+                }
+              }
+            }
+          }
+          substring = PL_strcasestr(content_type->value, "multipart/mixed");
+          if (substring) {
+            uint32_t newFlags;
+            m_newMsgHdr->OrFlags(nsMsgMessageFlags::Attachment, &newFlags);
+          }
+        }
+      }
+    } else {
+      NS_ASSERTION(false, "error creating message header");
+      rv = NS_ERROR_OUT_OF_MEMORY;
+    }
+  } else
+    rv = NS_OK;
+
+  // ### why is this stuff const?
+  char* tmp = (char*)to.value;
+  PR_Free(tmp);
+  tmp = (char*)cc.value;
+  PR_Free(tmp);
+
+  return rv;
+}
+
+nsParseNewMailState::nsParseNewMailState() : m_disableFilters(false) {
+  m_numNotNewMessages = 0;
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsParseNewMailState, nsMsgMailboxParser,
+                            nsIMsgFilterHitNotify)
+
+nsresult nsParseNewMailState::Init(nsIMsgFolder* serverFolder,
+                                   nsIMsgFolder* downloadFolder,
+                                   nsIMsgWindow* aMsgWindow, nsIMsgDBHdr* aHdr,
+                                   nsIOutputStream* aOutputStream) {
+  NS_ENSURE_ARG_POINTER(serverFolder);
+  nsresult rv;
+  Clear();
+  m_rootFolder = serverFolder;
+  m_msgWindow = aMsgWindow;
+  m_downloadFolder = downloadFolder;
+
+  m_newMsgHdr = aHdr;
+  m_outputStream = aOutputStream;
+  // the new mail parser isn't going to get the stream input, it seems, so we
+  // can't use the OnStartRequest mechanism the mailbox parser uses. So, let's
+  // open the db right now.
+  nsCOMPtr<nsIMsgDBService> msgDBService =
+      do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+  if (msgDBService && !m_mailDB)
+    rv = msgDBService->OpenFolderDB(downloadFolder, false,
+                                    getter_AddRefs(m_mailDB));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = serverFolder->GetServer(getter_AddRefs(server));
+  if (NS_SUCCEEDED(rv)) {
+    nsString serverName;
+    server->GetPrettyName(serverName);
+    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+            ("(Local) Detected new local messages on account '%s'",
+             NS_ConvertUTF16toUTF8(serverName).get()));
+    rv = server->GetFilterList(aMsgWindow, getter_AddRefs(m_filterList));
+
+    if (m_filterList) rv = server->ConfigureTemporaryFilters(m_filterList);
+    // check if this server defers to another server, in which case
+    // we'll use that server's filters as well.
+    nsCOMPtr<nsIMsgFolder> deferredToRootFolder;
+    server->GetRootMsgFolder(getter_AddRefs(deferredToRootFolder));
+    if (serverFolder != deferredToRootFolder) {
+      nsCOMPtr<nsIMsgIncomingServer> deferredToServer;
+      deferredToRootFolder->GetServer(getter_AddRefs(deferredToServer));
+      if (deferredToServer)
+        deferredToServer->GetFilterList(
+            aMsgWindow, getter_AddRefs(m_deferredToServerFilterList));
+    }
+  }
+  m_disableFilters = false;
+  return NS_OK;
+}
+
+nsParseNewMailState::~nsParseNewMailState() {
+  if (m_mailDB) m_mailDB->Close(true);
+  if (m_backupMailDB) m_backupMailDB->ForceClosed();
+#ifdef DOING_JSFILTERS
+  JSFilter_cleanup();
+#endif
+}
+
+// not an IMETHOD so we don't need to do error checking or return an error.
+// We only have one caller.
+void nsParseNewMailState::GetMsgWindow(nsIMsgWindow** aMsgWindow) {
+  NS_IF_ADDREF(*aMsgWindow = m_msgWindow);
+}
+
+// This gets called for every message because libnet calls IncorporateBegin,
+// IncorporateWrite (once or more), and IncorporateComplete for every message.
+void nsParseNewMailState::DoneParsingFolder(nsresult status) {
+  PublishMsgHeader(nullptr);
+  if (m_mailDB)  // finished parsing, so flush db folder info
+    UpdateDBFolderInfo();
+}
+
+void nsParseNewMailState::OnNewMessage(nsIMsgWindow* msgWindow) {}
+
+int32_t nsParseNewMailState::PublishMsgHeader(nsIMsgWindow* msgWindow) {
+  bool moved = false;
+  FinishHeader();
+
+  if (m_newMsgHdr) {
+    uint32_t newFlags, oldFlags;
+    m_newMsgHdr->GetFlags(&oldFlags);
+    if (!(oldFlags &
+          nsMsgMessageFlags::Read))  // don't mark read messages as new.
+      m_newMsgHdr->OrFlags(nsMsgMessageFlags::New, &newFlags);
+
+    if (!m_disableFilters) {
+      nsCOMPtr<nsIMsgIncomingServer> server;
+      nsresult rv = m_rootFolder->GetServer(getter_AddRefs(server));
+      NS_ENSURE_SUCCESS(rv, 0);
+      int32_t duplicateAction;
+      server->GetIncomingDuplicateAction(&duplicateAction);
+      if (duplicateAction != nsIMsgIncomingServer::keepDups) {
+        bool isDup;
+        server->IsNewHdrDuplicate(m_newMsgHdr, &isDup);
+        if (isDup) {
+          // we want to do something similar to applying filter hits.
+          // if a dup is marked read, it shouldn't trigger biff.
+          // Same for deleting it or moving it to trash.
+          switch (duplicateAction) {
+            case nsIMsgIncomingServer::deleteDups: {
+              nsCOMPtr<nsIMsgPluggableStore> msgStore;
+              nsresult rv =
+                  m_downloadFolder->GetMsgStore(getter_AddRefs(msgStore));
+              if (NS_SUCCEEDED(rv)) {
+                rv = msgStore->DiscardNewMessage(m_outputStream, m_newMsgHdr);
+                if (NS_FAILED(rv))
+                  m_rootFolder->ThrowAlertMsg("dupDeleteFolderTruncateFailed",
+                                              msgWindow);
+              }
+              m_mailDB->RemoveHeaderMdbRow(m_newMsgHdr);
+            } break;
+
+            case nsIMsgIncomingServer::moveDupsToTrash: {
+              nsCOMPtr<nsIMsgFolder> trash;
+              GetTrashFolder(getter_AddRefs(trash));
+              if (trash) {
+                uint32_t newFlags;
+                bool msgMoved;
+                m_newMsgHdr->AndFlags(~nsMsgMessageFlags::New, &newFlags);
+                nsCOMPtr<nsIMsgPluggableStore> msgStore;
+                rv = m_downloadFolder->GetMsgStore(getter_AddRefs(msgStore));
+                if (NS_SUCCEEDED(rv))
+                  rv = msgStore->MoveNewlyDownloadedMessage(m_newMsgHdr, trash,
+                                                            &msgMoved);
+                if (NS_SUCCEEDED(rv) && !msgMoved) {
+                  rv = MoveIncorporatedMessage(m_newMsgHdr, m_mailDB, trash,
+                                               nullptr, msgWindow);
+                  if (NS_SUCCEEDED(rv))
+                    rv = m_mailDB->RemoveHeaderMdbRow(m_newMsgHdr);
+                }
+                if (NS_FAILED(rv))
+                  NS_WARNING("moveDupsToTrash failed for some reason.");
+              }
+            } break;
+            case nsIMsgIncomingServer::markDupsRead:
+              MarkFilteredMessageRead(m_newMsgHdr);
+              break;
+          }
+          int32_t numNewMessages;
+          m_downloadFolder->GetNumNewMessages(false, &numNewMessages);
+          m_downloadFolder->SetNumNewMessages(numNewMessages - 1);
+
+          m_newMsgHdr = nullptr;
+          return 0;
+        }
+      }
+
+      ApplyFilters(&moved, msgWindow);
+    }
+    if (!moved) {
+      if (m_mailDB) {
+        m_mailDB->AddNewHdrToDB(m_newMsgHdr, true);
+        nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+            do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+        if (notifier) notifier->NotifyMsgAdded(m_newMsgHdr);
+        // mark the header as not yet reported classified
+        nsMsgKey msgKey;
+        m_newMsgHdr->GetMessageKey(&msgKey);
+        m_downloadFolder->OrProcessingFlags(
+            msgKey, nsMsgProcessingFlags::NotReportedClassified);
+      }
+    }  // if it was moved by imap filter, m_parseMsgState->m_newMsgHdr ==
+       // nullptr
+    m_newMsgHdr = nullptr;
+  }
+  return 0;
+}
+
+nsresult nsParseNewMailState::GetTrashFolder(nsIMsgFolder** pTrashFolder) {
+  nsresult rv = NS_ERROR_UNEXPECTED;
+  if (!pTrashFolder) return NS_ERROR_NULL_POINTER;
+
+  if (m_downloadFolder) {
+    nsCOMPtr<nsIMsgIncomingServer> incomingServer;
+    m_downloadFolder->GetServer(getter_AddRefs(incomingServer));
+    nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+    incomingServer->GetRootMsgFolder(getter_AddRefs(rootMsgFolder));
+    if (rootMsgFolder) {
+      rv = rootMsgFolder->GetFolderWithFlags(nsMsgFolderFlags::Trash,
+                                             pTrashFolder);
+      if (!*pTrashFolder) rv = NS_ERROR_FAILURE;
+    }
+  }
+  return rv;
+}
+
+void nsParseNewMailState::ApplyFilters(bool* pMoved, nsIMsgWindow* msgWindow) {
+  m_msgMovedByFilter = m_msgCopiedByFilter = false;
+
+  if (!m_disableFilters) {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr = m_newMsgHdr;
+    nsCOMPtr<nsIMsgFolder> downloadFolder = m_downloadFolder;
+    if (m_rootFolder) {
+      if (!downloadFolder)
+        m_rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox,
+                                         getter_AddRefs(downloadFolder));
+      if (downloadFolder) downloadFolder->GetURI(m_inboxUri);
+      char* headers = m_headers.GetBuffer();
+      uint32_t headersSize = m_headers.GetBufferPos();
+      nsAutoCString tok;
+      msgHdr->GetStringProperty("storeToken", tok);
+      if (m_filterList) {
+        MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+                ("(Local) Running filters on 1 message (%s)", tok.get()));
+        MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+                ("(Local) Using filters from the original account"));
+        (void)m_filterList->ApplyFiltersToHdr(
+            nsMsgFilterType::InboxRule, msgHdr, downloadFolder, m_mailDB,
+            nsDependentCSubstring(headers, headersSize), this, msgWindow);
+      }
+      if (!m_msgMovedByFilter && m_deferredToServerFilterList) {
+        MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+                ("(Local) Running filters on 1 message (%s)", tok.get()));
+        MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+                ("(Local) Using filters from the deferred to account"));
+        (void)m_deferredToServerFilterList->ApplyFiltersToHdr(
+            nsMsgFilterType::InboxRule, msgHdr, downloadFolder, m_mailDB,
+            nsDependentCSubstring(headers, headersSize), this, msgWindow);
+      }
+    }
+  }
+  if (pMoved) *pMoved = m_msgMovedByFilter;
+}
+
+NS_IMETHODIMP nsParseNewMailState::ApplyFilterHit(nsIMsgFilter* filter,
+                                                  nsIMsgWindow* msgWindow,
+                                                  bool* applyMore) {
+  NS_ENSURE_ARG_POINTER(filter);
+  NS_ENSURE_ARG_POINTER(applyMore);
+
+  uint32_t newFlags;
+  nsresult rv = NS_OK;
+
+  *applyMore = true;
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr = m_newMsgHdr;
+
+  nsTArray<RefPtr<nsIMsgRuleAction>> filterActionList;
+  rv = filter->GetSortedActionList(filterActionList);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t numActions = filterActionList.Length();
+
+  nsCString msgId;
+  msgHdr->GetMessageId(getter_Copies(msgId));
+  nsMsgKey msgKey;
+  msgHdr->GetMessageKey(&msgKey);
+  MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+          ("(Local) Applying %" PRIu32
+           " filter actions on message with key %" PRIu32,
+           numActions, msgKeyToInt(msgKey)));
+  MOZ_LOG(FILTERLOGMODULE, LogLevel::Debug,
+          ("(Local) Message ID: %s", msgId.get()));
+
+  bool loggingEnabled = false;
+  if (m_filterList && numActions)
+    m_filterList->GetLoggingEnabled(&loggingEnabled);
+
+  bool msgIsNew = true;
+  nsresult finalResult = NS_OK;  // result of all actions
+  for (uint32_t actionIndex = 0; actionIndex < numActions && *applyMore;
+       actionIndex++) {
+    nsCOMPtr<nsIMsgRuleAction> filterAction(filterActionList[actionIndex]);
+    if (!filterAction) {
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Warning,
+              ("(Local) Filter action at index %" PRIu32 " invalid, skipping",
+               actionIndex));
+      continue;
+    }
+
+    nsMsgRuleActionType actionType;
+    if (NS_SUCCEEDED(filterAction->GetType(&actionType))) {
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+              ("(Local) Running filter action at index %" PRIu32
+               ", action type = %i",
+               actionIndex, actionType));
+      if (loggingEnabled) (void)filter->LogRuleHit(filterAction, msgHdr);
+
+      nsCString actionTargetFolderUri;
+      if (actionType == nsMsgFilterAction::MoveToFolder ||
+          actionType == nsMsgFilterAction::CopyToFolder) {
+        rv = filterAction->GetTargetFolderUri(actionTargetFolderUri);
+        if (NS_FAILED(rv) || actionTargetFolderUri.IsEmpty()) {
+          // clang-format off
+          MOZ_LOG(FILTERLOGMODULE, LogLevel::Warning,
+                  ("(Local) Target URI for Copy/Move action is empty, skipping"));
+          // clang-format on
+          NS_ASSERTION(false, "actionTargetFolderUri is empty");
+          continue;
+        }
+      }
+
+      rv = NS_OK;  // result of the current action
+      switch (actionType) {
+        case nsMsgFilterAction::Delete: {
+          nsCOMPtr<nsIMsgFolder> trash;
+          // set value to trash folder
+          rv = GetTrashFolder(getter_AddRefs(trash));
+          if (NS_SUCCEEDED(rv) && trash) {
+            rv = trash->GetURI(actionTargetFolderUri);
+            if (NS_FAILED(rv)) break;
+          }
+
+          rv = msgHdr->OrFlags(nsMsgMessageFlags::Read,
+                               &newFlags);  // mark read in trash.
+          msgIsNew = false;
+        }
+          // FALLTHROUGH
+          [[fallthrough]];
+        case nsMsgFilterAction::MoveToFolder: {
+          // if moving to a different file, do it.
+          if (!actionTargetFolderUri.IsEmpty() &&
+              !m_inboxUri.Equals(actionTargetFolderUri,
+                                 nsCaseInsensitiveCStringComparator)) {
+            nsCOMPtr<nsIMsgFolder> destIFolder;
+            // XXX TODO: why do we create the folder here, while we do not in
+            // the Copy action?
+            rv = GetOrCreateFolder(actionTargetFolderUri,
+                                   getter_AddRefs(destIFolder));
+            if (NS_FAILED(rv)) {
+              MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
+                      ("(Local) Target Folder for Move action does not exist"));
+              break;
+            }
+            bool msgMoved = false;
+            // If we're moving to an imap folder, or this message has already
+            // has a pending copy action, use the imap coalescer so that
+            // we won't truncate the inbox before the copy fires.
+            if (m_msgCopiedByFilter ||
+                StringBeginsWith(actionTargetFolderUri, "imap:"_ns)) {
+              if (!m_moveCoalescer)
+                m_moveCoalescer =
+                    new nsImapMoveCoalescer(m_downloadFolder, m_msgWindow);
+              NS_ENSURE_TRUE(m_moveCoalescer, NS_ERROR_OUT_OF_MEMORY);
+              rv = m_moveCoalescer->AddMove(destIFolder, msgKey);
+              msgIsNew = false;
+              if (NS_FAILED(rv)) break;
+            } else {
+              nsCOMPtr<nsIMsgPluggableStore> msgStore;
+              rv = m_downloadFolder->GetMsgStore(getter_AddRefs(msgStore));
+              if (NS_SUCCEEDED(rv))
+                rv = msgStore->MoveNewlyDownloadedMessage(msgHdr, destIFolder,
+                                                          &msgMoved);
+              if (NS_SUCCEEDED(rv) && !msgMoved)
+                rv = MoveIncorporatedMessage(msgHdr, m_mailDB, destIFolder,
+                                             filter, msgWindow);
+              m_msgMovedByFilter = NS_SUCCEEDED(rv);
+              if (!m_msgMovedByFilter /* == NS_FAILED(err) */) {
+                // XXX: Invoke MSG_LOG_TO_CONSOLE once bug 1135265 lands.
+                if (loggingEnabled) {
+                  (void)filter->LogRuleHitFail(filterAction, msgHdr, rv,
+                                               "filterFailureMoveFailed"_ns);
+                }
+              }
+            }
+          } else {
+            MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+                    ("(Local) Target folder is the same as source folder, "
+                     "skipping"));
+            rv = NS_OK;
+          }
+          *applyMore = false;
+        } break;
+        case nsMsgFilterAction::CopyToFolder: {
+          nsCString uri;
+          rv = m_rootFolder->GetURI(uri);
+
+          if (!actionTargetFolderUri.IsEmpty() &&
+              !actionTargetFolderUri.Equals(uri)) {
+            nsCOMPtr<nsIMsgFolder> dstFolder;
+            nsCOMPtr<nsIMsgCopyService> copyService;
+            rv = GetExistingFolder(actionTargetFolderUri,
+                                   getter_AddRefs(dstFolder));
+            if (NS_FAILED(rv)) {
+              // Let's show a more specific warning.
+              MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
+                      ("(Local) Target Folder for Copy action does not exist"));
+              NS_WARNING("Target Folder does not exist.");
+              break;
+            }
+
+            copyService = do_GetService(
+                "@mozilla.org/messenger/messagecopyservice;1", &rv);
+            if (NS_SUCCEEDED(rv))
+              rv = copyService->CopyMessages(m_downloadFolder, {&*msgHdr},
+                                             dstFolder, false, nullptr,
+                                             msgWindow, false);
+
+            if (NS_FAILED(rv)) {
+              // XXX: Invoke MSG_LOG_TO_CONSOLE once bug 1135265 lands.
+              if (loggingEnabled) {
+                (void)filter->LogRuleHitFail(filterAction, msgHdr, rv,
+                                             "filterFailureCopyFailed"_ns);
+              }
+            } else
+              m_msgCopiedByFilter = true;
+          } else {
+            MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+                    ("(Local) Target folder is the same as source folder, "
+                     "skipping"));
+            break;
+          }
+        } break;
+        case nsMsgFilterAction::MarkRead:
+          msgIsNew = false;
+          MarkFilteredMessageRead(msgHdr);
+          rv = NS_OK;
+          break;
+        case nsMsgFilterAction::MarkUnread:
+          msgIsNew = true;
+          MarkFilteredMessageUnread(msgHdr);
+          rv = NS_OK;
+          break;
+        case nsMsgFilterAction::KillThread:
+          rv = msgHdr->SetUint32Property("ProtoThreadFlags",
+                                         nsMsgMessageFlags::Ignored);
+          break;
+        case nsMsgFilterAction::KillSubthread:
+          rv = msgHdr->OrFlags(nsMsgMessageFlags::Ignored, &newFlags);
+          break;
+        case nsMsgFilterAction::WatchThread:
+          rv = msgHdr->OrFlags(nsMsgMessageFlags::Watched, &newFlags);
+          break;
+        case nsMsgFilterAction::MarkFlagged: {
+          rv = m_downloadFolder->MarkMessagesFlagged({&*msgHdr}, true);
+        } break;
+        case nsMsgFilterAction::ChangePriority: {
+          nsMsgPriorityValue filterPriority;
+          filterAction->GetPriority(&filterPriority);
+          rv = msgHdr->SetPriority(filterPriority);
+        } break;
+        case nsMsgFilterAction::AddTag: {
+          nsCString keyword;
+          filterAction->GetStrValue(keyword);
+          rv = m_downloadFolder->AddKeywordsToMessages({&*msgHdr}, keyword);
+          break;
+        }
+        case nsMsgFilterAction::JunkScore: {
+          nsAutoCString junkScoreStr;
+          int32_t junkScore;
+          filterAction->GetJunkScore(&junkScore);
+          junkScoreStr.AppendInt(junkScore);
+          if (junkScore == nsIJunkMailPlugin::IS_SPAM_SCORE) msgIsNew = false;
+          rv = msgHdr->SetStringProperty("junkscore", junkScoreStr);
+          msgHdr->SetStringProperty("junkscoreorigin", "filter"_ns);
+        } break;
+        case nsMsgFilterAction::Forward: {
+          nsCString forwardTo;
+          filterAction->GetStrValue(forwardTo);
+          m_forwardTo.AppendElement(forwardTo);
+          m_msgToForwardOrReply = msgHdr;
+          rv = NS_OK;
+        } break;
+        case nsMsgFilterAction::Reply: {
+          nsCString replyTemplateUri;
+          filterAction->GetStrValue(replyTemplateUri);
+          m_replyTemplateUri.AppendElement(replyTemplateUri);
+          m_msgToForwardOrReply = msgHdr;
+          m_ruleAction = filterAction;
+          m_filter = filter;
+          rv = NS_OK;
+        } break;
+        case nsMsgFilterAction::DeleteFromPop3Server: {
+          nsCOMPtr<nsIMsgFolder> downloadFolder;
+          msgHdr->GetFolder(getter_AddRefs(downloadFolder));
+          nsCOMPtr<nsIMsgLocalMailFolder> localFolder =
+              do_QueryInterface(downloadFolder, &rv);
+          if (NS_FAILED(rv) || !localFolder) {
+            MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
+                    ("(Local) Couldn't find local mail folder"));
+            break;
+          }
+          // This action ignores the deleteMailLeftOnServer preference
+          rv = localFolder->MarkMsgsOnPop3Server({&*msgHdr}, POP3_FORCE_DEL);
+
+          // If this is just a header, throw it away. It's useless now
+          // that the server copy is being deleted.
+          uint32_t flags = 0;
+          msgHdr->GetFlags(&flags);
+          if (flags & nsMsgMessageFlags::Partial) {
+            m_msgMovedByFilter = true;
+            msgIsNew = false;
+          }
+        } break;
+        case nsMsgFilterAction::FetchBodyFromPop3Server: {
+          nsCOMPtr<nsIMsgFolder> downloadFolder;
+          msgHdr->GetFolder(getter_AddRefs(downloadFolder));
+          nsCOMPtr<nsIMsgLocalMailFolder> localFolder =
+              do_QueryInterface(downloadFolder, &rv);
+          if (NS_FAILED(rv) || !localFolder) {
+            MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
+                    ("(Local) Couldn't find local mail folder"));
+            break;
+          }
+          uint32_t flags = 0;
+          msgHdr->GetFlags(&flags);
+          if (flags & nsMsgMessageFlags::Partial) {
+            rv = localFolder->MarkMsgsOnPop3Server({&*msgHdr}, POP3_FETCH_BODY);
+            // Don't add this header to the DB, we're going to replace it
+            // with the full message.
+            m_msgMovedByFilter = true;
+            msgIsNew = false;
+            // Don't do anything else in this filter, wait until we
+            // have the full message.
+            *applyMore = false;
+          }
+        } break;
+
+        case nsMsgFilterAction::StopExecution: {
+          // don't apply any more filters
+          *applyMore = false;
+          rv = NS_OK;
+        } break;
+
+        case nsMsgFilterAction::Custom: {
+          nsCOMPtr<nsIMsgFilterCustomAction> customAction;
+          rv = filterAction->GetCustomAction(getter_AddRefs(customAction));
+          if (NS_FAILED(rv)) break;
+
+          nsAutoCString value;
+          rv = filterAction->GetStrValue(value);
+          if (NS_FAILED(rv)) break;
+
+          rv = customAction->ApplyAction({&*msgHdr}, value, nullptr,
+                                         nsMsgFilterType::InboxRule, msgWindow);
+        } break;
+
+        default:
+          // XXX should not be reached. Check in debug build.
+          NS_ERROR("unexpected filter action");
+          rv = NS_ERROR_UNEXPECTED;
+          break;
+      }
+    }
+    if (NS_FAILED(rv)) {
+      finalResult = rv;
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
+              ("(Local) Action execution failed with error: %" PRIx32,
+               static_cast<uint32_t>(rv)));
+      if (loggingEnabled) {
+        (void)filter->LogRuleHitFail(filterAction, msgHdr, rv,
+                                     "filterFailureAction"_ns);
+      }
+    } else {
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+              ("(Local) Action execution succeeded"));
+    }
+  }
+  if (!msgIsNew) {
+    int32_t numNewMessages;
+    m_downloadFolder->GetNumNewMessages(false, &numNewMessages);
+    if (numNewMessages > 0)
+      m_downloadFolder->SetNumNewMessages(numNewMessages - 1);
+    m_numNotNewMessages++;
+    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+            ("(Local) Message will not be marked new"));
+  }
+  MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+          ("(Local) Finished executing actions"));
+  return finalResult;
+}
+
+// this gets run in a second pass, after apply filters to a header.
+nsresult nsParseNewMailState::ApplyForwardAndReplyFilter(
+    nsIMsgWindow* msgWindow) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+
+  uint32_t i;
+  uint32_t count = m_forwardTo.Length();
+  nsMsgKey msgKey;
+  if (count > 0 && m_msgToForwardOrReply) {
+    m_msgToForwardOrReply->GetMessageKey(&msgKey);
+    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+            ("(Local) Forwarding message with key %" PRIu32 " to %" PRIu32
+             " addresses",
+             msgKeyToInt(msgKey), count));
+  }
+
+  for (i = 0; i < count; i++) {
+    if (!m_forwardTo[i].IsEmpty()) {
+      nsAutoString forwardStr;
+      CopyASCIItoUTF16(m_forwardTo[i], forwardStr);
+      rv = m_rootFolder->GetServer(getter_AddRefs(server));
+      NS_ENSURE_SUCCESS(rv, rv);
+      {
+        nsCOMPtr<nsIMsgComposeService> compService =
+            do_GetService("@mozilla.org/messengercompose;1", &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv = compService->ForwardMessage(
+            forwardStr, m_msgToForwardOrReply, msgWindow, server,
+            nsIMsgComposeService::kForwardAsDefault);
+        if (NS_FAILED(rv))
+          MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
+                  ("(Local) Forwarding failed"));
+      }
+    }
+  }
+  m_forwardTo.Clear();
+
+  count = m_replyTemplateUri.Length();
+  if (count > 0 && m_msgToForwardOrReply) {
+    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+            ("(Local) Replying message with key %" PRIu32 " to %" PRIu32
+             " addresses",
+             msgKeyToInt(msgKey), count));
+  }
+
+  for (i = 0; i < count; i++) {
+    if (!m_replyTemplateUri[i].IsEmpty()) {
+      // copy this and truncate the original, so we don't accidentally re-use it
+      // on the next hdr.
+      rv = m_rootFolder->GetServer(getter_AddRefs(server));
+      if (server) {
+        nsCOMPtr<nsIMsgComposeService> compService =
+            do_GetService("@mozilla.org/messengercompose;1");
+        if (compService) {
+          rv = compService->ReplyWithTemplate(
+              m_msgToForwardOrReply, m_replyTemplateUri[i], msgWindow, server);
+          if (NS_FAILED(rv)) {
+            NS_WARNING("ReplyWithTemplate failed");
+            MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
+                    ("(Local) Replying failed"));
+            if (rv == NS_ERROR_ABORT) {
+              (void)m_filter->LogRuleHitFail(
+                  m_ruleAction, m_msgToForwardOrReply, rv,
+                  "filterFailureSendingReplyAborted"_ns);
+            } else {
+              (void)m_filter->LogRuleHitFail(
+                  m_ruleAction, m_msgToForwardOrReply, rv,
+                  "filterFailureSendingReplyError"_ns);
+            }
+          }
+        }
+      }
+    }
+  }
+  m_replyTemplateUri.Clear();
+  m_msgToForwardOrReply = nullptr;
+  return rv;
+}
+
+void nsParseNewMailState::MarkFilteredMessageRead(nsIMsgDBHdr* msgHdr) {
+  m_downloadFolder->MarkMessagesRead({msgHdr}, true);
+}
+
+void nsParseNewMailState::MarkFilteredMessageUnread(nsIMsgDBHdr* msgHdr) {
+  uint32_t newFlags;
+  if (m_mailDB) {
+    nsMsgKey msgKey;
+    msgHdr->GetMessageKey(&msgKey);
+    m_mailDB->AddToNewList(msgKey);
+  } else {
+    msgHdr->OrFlags(nsMsgMessageFlags::New, &newFlags);
+  }
+  m_downloadFolder->MarkMessagesRead({msgHdr}, false);
+}
+
+nsresult nsParseNewMailState::EndMsgDownload() {
+  if (m_moveCoalescer) m_moveCoalescer->PlaybackMoves();
+
+  // need to do this for all folders that had messages filtered into them
+  uint32_t serverCount = m_filterTargetFolders.Count();
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailSession> session =
+      do_GetService("@mozilla.org/messenger/services/session;1", &rv);
+  if (NS_SUCCEEDED(rv) && session)  // don't use NS_ENSURE_SUCCESS here - we
+                                    // need to release semaphore below
+  {
+    for (uint32_t index = 0; index < serverCount; index++) {
+      bool folderOpen;
+      session->IsFolderOpenInWindow(m_filterTargetFolders[index], &folderOpen);
+      if (!folderOpen) {
+        uint32_t folderFlags;
+        m_filterTargetFolders[index]->GetFlags(&folderFlags);
+        if (!(folderFlags &
+              (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Inbox))) {
+          bool filtersRun;
+          m_filterTargetFolders[index]->CallFilterPlugins(nullptr, &filtersRun);
+          if (!filtersRun)
+            m_filterTargetFolders[index]->SetMsgDatabase(nullptr);
+        }
+      }
+    }
+  }
+  m_filterTargetFolders.Clear();
+  return rv;
+}
+
+nsresult nsParseNewMailState::AppendMsgFromStream(nsIInputStream* fileStream,
+                                                  nsIMsgDBHdr* aHdr,
+                                                  nsIMsgFolder* destFolder) {
+  nsCOMPtr<nsIMsgPluggableStore> store;
+  nsCOMPtr<nsIOutputStream> destOutputStream;
+  nsresult rv = destFolder->GetMsgStore(getter_AddRefs(store));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = store->GetNewMsgOutputStream(destFolder, &aHdr,
+                                    getter_AddRefs(destOutputStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint64_t bytesCopied;
+  rv = SyncCopyStream(fileStream, destOutputStream, bytesCopied);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = store->FinishNewMessage(destOutputStream, aHdr);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return NS_OK;
+}
+
+/*
+ * Moves message pointed to by mailHdr into folder destIFolder.
+ * After successful move mailHdr is no longer usable by the caller.
+ */
+nsresult nsParseNewMailState::MoveIncorporatedMessage(nsIMsgDBHdr* mailHdr,
+                                                      nsIMsgDatabase* sourceDB,
+                                                      nsIMsgFolder* destIFolder,
+                                                      nsIMsgFilter* filter,
+                                                      nsIMsgWindow* msgWindow) {
+  NS_ENSURE_ARG_POINTER(destIFolder);
+  nsresult rv = NS_OK;
+
+  // check if the destination is a real folder (by checking for null parent)
+  // and if it can file messages (e.g., servers or news folders can't file
+  // messages). Or read only imap folders...
+  bool canFileMessages = true;
+  nsCOMPtr<nsIMsgFolder> parentFolder;
+  destIFolder->GetParent(getter_AddRefs(parentFolder));
+  if (parentFolder) destIFolder->GetCanFileMessages(&canFileMessages);
+  if (!parentFolder || !canFileMessages) {
+    if (filter) {
+      filter->SetEnabled(false);
+      // we need to explicitly save the filter file.
+      if (m_filterList) m_filterList->SaveToDefaultFile();
+      destIFolder->ThrowAlertMsg("filterDisabled", msgWindow);
+    }
+    return NS_MSG_NOT_A_MAIL_FOLDER;
+  }
+
+  uint32_t messageLength;
+  mailHdr->GetMessageSize(&messageLength);
+
+  nsCOMPtr<nsIMsgLocalMailFolder> localFolder = do_QueryInterface(destIFolder);
+  if (localFolder) {
+    bool destFolderTooBig = true;
+    rv = localFolder->WarnIfLocalFileTooBig(msgWindow, messageLength,
+                                            &destFolderTooBig);
+    if (NS_FAILED(rv) || destFolderTooBig)
+      return NS_MSG_ERROR_WRITING_MAIL_FOLDER;
+  }
+
+  nsCOMPtr<nsISupports> myISupports =
+      do_QueryInterface(static_cast<nsIMsgParseMailMsgState*>(this));
+
+  // Make sure no one else is writing into this folder
+  if (NS_FAILED(rv = destIFolder->AcquireSemaphore(myISupports))) {
+    destIFolder->ThrowAlertMsg("filterFolderDeniedLocked", msgWindow);
+    return rv;
+  }
+  nsCOMPtr<nsIInputStream> inputStream;
+  rv =
+      m_downloadFolder->GetLocalMsgStream(mailHdr, getter_AddRefs(inputStream));
+  if (NS_FAILED(rv)) {
+    NS_ERROR("couldn't get source msg input stream in move filter");
+    destIFolder->ReleaseSemaphore(myISupports);
+    return NS_MSG_FOLDER_UNREADABLE;  // ### dmb
+  }
+
+  nsCOMPtr<nsIMsgDatabase> destMailDB;
+
+  if (!localFolder) return NS_MSG_POP_FILTER_TARGET_ERROR;
+
+  // don't force upgrade in place - open the db here before we start writing to
+  // the destination file because XP_Stat can return file size including bytes
+  // written...
+  rv = localFolder->GetDatabaseWOReparse(getter_AddRefs(destMailDB));
+  NS_WARNING_ASSERTION(destMailDB && NS_SUCCEEDED(rv),
+                       "failed to open mail db parsing folder");
+  nsCOMPtr<nsIMsgDBHdr> newHdr;
+
+  if (destMailDB)
+    rv = destMailDB->CopyHdrFromExistingHdr(m_new_key, mailHdr, true,
+                                            getter_AddRefs(newHdr));
+  if (NS_SUCCEEDED(rv) && !newHdr) rv = NS_ERROR_UNEXPECTED;
+
+  if (NS_FAILED(rv)) {
+    destIFolder->ThrowAlertMsg("filterFolderHdrAddFailed", msgWindow);
+  } else {
+    rv = AppendMsgFromStream(inputStream, newHdr, destIFolder);
+    if (NS_FAILED(rv))
+      destIFolder->ThrowAlertMsg("filterFolderWriteFailed", msgWindow);
+  }
+
+  if (NS_FAILED(rv)) {
+    if (destMailDB) destMailDB->Close(true);
+
+    destIFolder->ReleaseSemaphore(myISupports);
+
+    return NS_MSG_ERROR_WRITING_MAIL_FOLDER;
+  }
+
+  bool movedMsgIsNew = false;
+  // if we have made it this far then the message has successfully been written
+  // to the new folder now add the header to the destMailDB.
+
+  uint32_t newFlags;
+  newHdr->GetFlags(&newFlags);
+  nsMsgKey msgKey;
+  newHdr->GetMessageKey(&msgKey);
+  if (!(newFlags & nsMsgMessageFlags::Read)) {
+    nsCString junkScoreStr;
+    (void)newHdr->GetStringProperty("junkscore", junkScoreStr);
+    if (atoi(junkScoreStr.get()) == nsIJunkMailPlugin::IS_HAM_SCORE) {
+      newHdr->OrFlags(nsMsgMessageFlags::New, &newFlags);
+      destMailDB->AddToNewList(msgKey);
+      movedMsgIsNew = true;
+    }
+  }
+  nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+      do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+  if (notifier) notifier->NotifyMsgAdded(newHdr);
+  // mark the header as not yet reported classified
+  destIFolder->OrProcessingFlags(msgKey,
+                                 nsMsgProcessingFlags::NotReportedClassified);
+  m_msgToForwardOrReply = newHdr;
+
+  if (movedMsgIsNew) destIFolder->SetHasNewMessages(true);
+  if (!m_filterTargetFolders.Contains(destIFolder))
+    m_filterTargetFolders.AppendObject(destIFolder);
+
+  destIFolder->ReleaseSemaphore(myISupports);
+
+  (void)localFolder->RefreshSizeOnDisk();
+
+  // Notify the message was moved.
+  if (notifier) {
+    nsCOMPtr<nsIMsgFolder> folder;
+    nsresult rv = mailHdr->GetFolder(getter_AddRefs(folder));
+    if (NS_SUCCEEDED(rv)) {
+      notifier->NotifyMsgUnincorporatedMoved(folder, newHdr);
+    } else {
+      NS_WARNING("Can't get folder for message that was moved.");
+    }
+  }
+
+  nsCOMPtr<nsIMsgPluggableStore> store;
+  rv = m_downloadFolder->GetMsgStore(getter_AddRefs(store));
+  if (store) store->DiscardNewMessage(m_outputStream, mailHdr);
+  if (sourceDB) sourceDB->RemoveHeaderMdbRow(mailHdr);
+
+  // update the folder size so we won't reparse.
+  UpdateDBFolderInfo(destMailDB);
+  destIFolder->UpdateSummaryTotals(true);
+
+  destMailDB->Commit(nsMsgDBCommitType::kLargeCommit);
+  return rv;
+}
diff --git a/comm/mailnews/local/src/nsParseMailbox.h b/comm/mailnews/local/src/nsParseMailbox.h
new file mode 100644
index 0000000000..1e272cd8c0
--- /dev/null
+++ b/comm/mailnews/local/src/nsParseMailbox.h
@@ -0,0 +1,256 @@
+/* -*- 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 nsParseMailbox_H
+#define nsParseMailbox_H
+
+#include "mozilla/Attributes.h"
+#include "nsIURI.h"
+#include "nsIMsgParseMailMsgState.h"
+#include "nsIStreamListener.h"
+#include "nsMsgLineBuffer.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsCOMPtr.h"
+#include "nsCOMArray.h"
+#include "nsIDBChangeListener.h"
+#include "nsIWeakReferenceUtils.h"
+#include "nsIMsgWindow.h"
+#include "nsImapMoveCoalescer.h"
+#include "nsString.h"
+#include "nsIMsgFilterList.h"
+#include "nsIMsgFilter.h"
+#include "nsIMsgFilterHitNotify.h"
+#include "nsTArray.h"
+
+class nsOutputFileStream;
+class nsIMsgFolder;
+
+/* Used for the various things that parse RFC822 headers...
+ */
+typedef struct message_header {
+  const char* value; /* The contents of a header (after ": ") */
+  int32_t length;    /* The length of the data (it is not NULL-terminated.) */
+} message_header;
+
+// This object maintains the parse state for a single mail message.
+class nsParseMailMessageState : public nsIMsgParseMailMsgState,
+                                public nsIDBChangeListener {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGPARSEMAILMSGSTATE
+  NS_DECL_NSIDBCHANGELISTENER
+
+  nsParseMailMessageState();
+
+  nsresult ParseFolderLine(const char* line, uint32_t lineLength);
+  nsresult StartNewEnvelope(const char* line, uint32_t lineLength);
+  nsresult ParseHeaders();
+  nsresult FinalizeHeaders();
+  nsresult ParseEnvelope(const char* line, uint32_t line_size);
+  nsresult InternSubject(struct message_header* header);
+
+  // Returns true if line looks like an mbox "From " line.
+  static bool IsEnvelopeLine(const char* buf, int32_t buf_size);
+
+  // Helpers for dealing with multi-value headers.
+  struct message_header* GetNextHeaderInAggregate(
+      nsTArray<struct message_header*>& list);
+  void GetAggregateHeader(nsTArray<struct message_header*>& list,
+                          struct message_header*);
+  void ClearAggregateHeader(nsTArray<struct message_header*>& list);
+
+  nsCOMPtr<nsIMsgDBHdr> m_newMsgHdr; /* current message header we're building */
+  nsCOMPtr<nsIMsgDatabase> m_mailDB;
+  nsCOMPtr<nsIMsgDatabase> m_backupMailDB;
+
+  nsMailboxParseState m_state;
+  int64_t m_position;
+  // The start of the "From " line (the line before the start of the message).
+  uint64_t m_envelope_pos;
+  // The start of the message headers (immediately follows "From " line).
+  uint64_t m_headerstartpos;
+  nsMsgKey m_new_key;  // DB key for the new header.
+
+  // The "From " line, if any.
+  ::nsByteArray m_envelope;
+
+  // These two point into the m_envelope buffer.
+  struct message_header m_envelope_from;
+  struct message_header m_envelope_date;
+
+  // The raw header data.
+  ::nsByteArray m_headers;
+
+  // These all point into the m_headers buffer.
+  struct message_header m_message_id;
+  struct message_header m_references;
+  struct message_header m_date;
+  struct message_header m_delivery_date;
+  struct message_header m_from;
+  struct message_header m_sender;
+  struct message_header m_newsgroups;
+  struct message_header m_subject;
+  struct message_header m_status;
+  struct message_header m_mozstatus;
+  struct message_header m_mozstatus2;
+  struct message_header m_in_reply_to;
+  struct message_header m_replyTo;
+  struct message_header m_content_type;
+  struct message_header m_bccList;
+
+  // Support for having multiple To or Cc header lines in a message
+  nsTArray<struct message_header*> m_toList;
+  nsTArray<struct message_header*> m_ccList;
+
+  struct message_header m_priority;
+  struct message_header m_account_key;
+  struct message_header m_keywords;
+
+  // Mdn support
+  struct message_header m_mdn_original_recipient;
+  struct message_header m_return_path;
+  struct message_header m_mdn_dnt; /* MDN Disposition-Notification-To: header */
+
+  PRTime m_receivedTime;
+  uint16_t m_body_lines;
+  uint16_t m_lastLineBlank;
+
+  // this enables extensions to add the values of particular headers to
+  // the .msf file as properties of nsIMsgHdr. It is initialized from a
+  // pref, mailnews.customDBHeaders
+  nsTArray<nsCString> m_customDBHeaders;
+  struct message_header* m_customDBHeaderValues;
+  nsCString m_receivedValue;  // accumulated received header
+ protected:
+  virtual ~nsParseMailMessageState();
+};
+
+// This class is part of the mailbox parsing state machine
+class nsMsgMailboxParser : public nsIStreamListener,
+                           public nsParseMailMessageState,
+                           public nsMsgLineBuffer {
+ public:
+  explicit nsMsgMailboxParser(nsIMsgFolder*);
+  nsMsgMailboxParser();
+  nsresult Init();
+
+  NS_DECL_ISUPPORTS_INHERITED
+
+  ////////////////////////////////////////////////////////////////////////////////////////
+  // we support the nsIStreamListener interface
+  ////////////////////////////////////////////////////////////////////////////////////////
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSISTREAMLISTENER
+
+  void SetDB(nsIMsgDatabase* mailDB) { m_mailDB = mailDB; }
+
+  // message socket libnet callbacks, which come through folder pane
+  nsresult ProcessMailboxInputStream(nsIInputStream* aIStream,
+                                     uint32_t aLength);
+
+  virtual void DoneParsingFolder(nsresult status);
+  virtual void AbortNewHeader();
+
+  // for nsMsgLineBuffer
+  virtual nsresult HandleLine(const char* line, uint32_t line_length) override;
+
+  void UpdateDBFolderInfo();
+  void UpdateDBFolderInfo(nsIMsgDatabase* mailDB);
+  void UpdateStatusText(const char* stringName);
+
+  // Update the progress bar based on what we know.
+  virtual void UpdateProgressPercent();
+  virtual void OnNewMessage(nsIMsgWindow* msgWindow);
+
+ protected:
+  virtual ~nsMsgMailboxParser();
+  nsCOMPtr<nsIMsgStatusFeedback> m_statusFeedback;
+
+  virtual int32_t PublishMsgHeader(nsIMsgWindow* msgWindow);
+
+  // data
+  nsString m_folderName;
+  nsCString m_inboxUri;
+  ::nsByteArray m_inputStream;
+  uint64_t m_graph_progress_total;
+  uint64_t m_graph_progress_received;
+
+ private:
+  nsWeakPtr m_folder;
+  void ReleaseFolderLock();
+  nsresult AcquireFolderLock();
+};
+
+class nsParseNewMailState : public nsMsgMailboxParser,
+                            public nsIMsgFilterHitNotify {
+ public:
+  nsParseNewMailState();
+  NS_DECL_ISUPPORTS_INHERITED
+
+  nsresult Init(nsIMsgFolder* rootFolder, nsIMsgFolder* downloadFolder,
+                nsIMsgWindow* aMsgWindow, nsIMsgDBHdr* aHdr,
+                nsIOutputStream* aOutputStream);
+
+  virtual void DoneParsingFolder(nsresult status) override;
+
+  void DisableFilters() { m_disableFilters = true; }
+
+  NS_DECL_NSIMSGFILTERHITNOTIFY
+
+  nsOutputFileStream* GetLogFile();
+  virtual int32_t PublishMsgHeader(nsIMsgWindow* msgWindow) override;
+  void GetMsgWindow(nsIMsgWindow** aMsgWindow);
+  nsresult EndMsgDownload();
+
+  nsresult AppendMsgFromStream(nsIInputStream* fileStream, nsIMsgDBHdr* aHdr,
+                               nsIMsgFolder* destFolder);
+
+  void ApplyFilters(bool* pMoved, nsIMsgWindow* msgWindow);
+  nsresult ApplyForwardAndReplyFilter(nsIMsgWindow* msgWindow);
+  virtual void OnNewMessage(nsIMsgWindow* msgWindow) override;
+
+  // this keeps track of how many messages we downloaded that
+  // aren't new - e.g., marked read, or moved to an other server.
+  int32_t m_numNotNewMessages;
+
+ protected:
+  virtual ~nsParseNewMailState();
+  virtual nsresult GetTrashFolder(nsIMsgFolder** pTrashFolder);
+  virtual nsresult MoveIncorporatedMessage(nsIMsgDBHdr* mailHdr,
+                                           nsIMsgDatabase* sourceDB,
+                                           nsIMsgFolder* destIFolder,
+                                           nsIMsgFilter* filter,
+                                           nsIMsgWindow* msgWindow);
+  virtual void MarkFilteredMessageRead(nsIMsgDBHdr* msgHdr);
+  virtual void MarkFilteredMessageUnread(nsIMsgDBHdr* msgHdr);
+
+  nsCOMPtr<nsIMsgFilterList> m_filterList;
+  nsCOMPtr<nsIMsgFilterList> m_deferredToServerFilterList;
+  nsCOMPtr<nsIMsgFolder> m_rootFolder;
+  nsCOMPtr<nsIMsgWindow> m_msgWindow;
+  nsCOMPtr<nsIMsgFolder> m_downloadFolder;
+  nsCOMPtr<nsIOutputStream> m_outputStream;
+  nsCOMArray<nsIMsgFolder> m_filterTargetFolders;
+
+  RefPtr<nsImapMoveCoalescer> m_moveCoalescer;
+
+  bool m_msgMovedByFilter;
+  bool m_msgCopiedByFilter;
+  bool m_disableFilters;
+
+  // we have to apply the reply/forward filters in a second pass, after
+  // msg quarantining and moving to other local folders, so we remember the
+  // info we'll need to apply them with these vars.
+  // these need to be arrays in case we have multiple reply/forward filters.
+  nsTArray<nsCString> m_forwardTo;
+  nsTArray<nsCString> m_replyTemplateUri;
+  nsCOMPtr<nsIMsgDBHdr> m_msgToForwardOrReply;
+  nsCOMPtr<nsIMsgFilter> m_filter;
+  nsCOMPtr<nsIMsgRuleAction> m_ruleAction;
+};
+
+#endif
diff --git a/comm/mailnews/local/src/nsPop3Sink.cpp b/comm/mailnews/local/src/nsPop3Sink.cpp
new file mode 100644
index 0000000000..2d4b7472c9
--- /dev/null
+++ b/comm/mailnews/local/src/nsPop3Sink.cpp
@@ -0,0 +1,740 @@
+/* -*- 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 "nsPop3Sink.h"
+#include "prprf.h"
+#include "prlog.h"
+#include "nscore.h"
+#include <stdio.h>
+#include <time.h>
+#include "nsParseMailbox.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsLocalUtils.h"
+#include "nsMsgLocalFolderHdrs.h"
+#include "nsIMsgFolder.h"  // TO include biffState enum. Change to bool later...
+#include "nsMsgMessageFlags.h"
+#include "nsMailHeaders.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIPop3Protocol.h"
+#include "nsLocalMailFolder.h"
+#include "nsIInputStream.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsIPromptService.h"
+#include "nsIDocShell.h"
+#include "mozIDOMWindow.h"
+#include "nsEmbedCID.h"
+#include "nsMsgUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIObserverService.h"
+#include "nsIPop3Service.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Services.h"
+
+/* for logging to Error Console */
+#include "nsIScriptError.h"
+
+mozilla::LazyLogModule POP3LOGMODULE("POP3");
+#define POP3LOG(str) "sink: [this=%p] " str, this
+
+NS_IMPL_ISUPPORTS(nsPop3Sink, nsIPop3Sink)
+
+nsPop3Sink::nsPop3Sink() {
+  m_biffState = 0;
+  m_numNewMessages = 0;
+  m_numNewMessagesInFolder = 0;
+  m_numMsgsDownloaded = 0;
+  m_senderAuthed = false;
+  m_outFileStream = nullptr;
+  m_uidlDownload = false;
+  m_buildMessageUri = false;
+}
+
+nsPop3Sink::~nsPop3Sink() {
+  MOZ_LOG(POP3LOGMODULE, mozilla::LogLevel::Debug,
+          (POP3LOG("Calling ReleaseFolderLock from ~nsPop3Sink")));
+  ReleaseFolderLock();
+}
+
+partialRecord::partialRecord() : m_msgDBHdr(nullptr) {}
+
+partialRecord::~partialRecord() {}
+
+// Walk through all the messages in this folder and look for any
+// PARTIAL messages. For each of those, dig through the mailbox and
+// find the Account that the message belongs to. If that Account
+// matches the current Account, then look for the Uidl and save
+// this message for later processing.
+nsresult nsPop3Sink::FindPartialMessages() {
+  nsCOMPtr<nsIMsgEnumerator> messages;
+  bool hasMore = false;
+  bool isOpen = false;
+  nsLocalFolderScanState folderScanState;
+  nsCOMPtr<nsIMsgDatabase> db;
+  nsCOMPtr<nsIMsgLocalMailFolder> localFolder = do_QueryInterface(m_folder);
+  m_folder->GetMsgDatabase(getter_AddRefs(db));
+  if (!localFolder || !db)
+    return NS_ERROR_FAILURE;  // we need it to grub through the folder
+
+  nsresult rv = db->EnumerateMessages(getter_AddRefs(messages));
+  if (messages) messages->HasMoreElements(&hasMore);
+  while (hasMore && NS_SUCCEEDED(rv)) {
+    uint32_t flags = 0;
+    nsCOMPtr<nsIMsgDBHdr> msgDBHdr;
+    rv = messages->GetNext(getter_AddRefs(msgDBHdr));
+    if (!NS_SUCCEEDED(rv)) break;
+    msgDBHdr->GetFlags(&flags);
+    if (flags & nsMsgMessageFlags::Partial) {
+      // Open the various streams we need to seek and read from the mailbox
+      if (!isOpen) {
+        rv = localFolder->GetFolderScanState(&folderScanState);
+        if (NS_SUCCEEDED(rv))
+          isOpen = true;
+        else
+          break;
+      }
+      rv = localFolder->GetUidlFromFolder(&folderScanState, msgDBHdr);
+      if (!NS_SUCCEEDED(rv)) break;
+
+      // If we got the uidl, see if this partial message belongs to this
+      // account. Add it to the array if so...
+      if (folderScanState.m_uidl &&
+          m_accountKey.Equals(folderScanState.m_accountKey,
+                              nsCaseInsensitiveCStringComparator)) {
+        partialRecord* partialMsg = new partialRecord();
+        if (partialMsg) {
+          partialMsg->m_uidl = folderScanState.m_uidl;
+          partialMsg->m_msgDBHdr = msgDBHdr;
+          m_partialMsgsArray.AppendElement(partialMsg);
+        }
+      }
+    }
+    messages->HasMoreElements(&hasMore);
+  }
+  if (isOpen && folderScanState.m_inputStream)
+    folderScanState.m_inputStream->Close();
+  return rv;
+}
+
+// For all the partial messages saved by FindPartialMessages,
+// ask the protocol handler if they still exist on the server.
+// Any messages that don't exist any more are deleted from the
+// msgDB.
+void nsPop3Sink::CheckPartialMessages(nsIPop3Protocol* protocol) {
+  uint32_t count = m_partialMsgsArray.Length();
+  bool deleted = false;
+
+  for (uint32_t i = 0; i < count; i++) {
+    partialRecord* partialMsg;
+    bool found = true;
+    partialMsg = m_partialMsgsArray.ElementAt(i);
+    protocol->CheckMessage(partialMsg->m_uidl.get(), &found);
+    if (!found && partialMsg->m_msgDBHdr) {
+      if (m_newMailParser)
+        m_newMailParser->m_mailDB->DeleteHeader(partialMsg->m_msgDBHdr, nullptr,
+                                                false, true);
+      deleted = true;
+    }
+    delete partialMsg;
+  }
+  m_partialMsgsArray.Clear();
+  if (deleted) {
+    nsCOMPtr<nsIMsgLocalMailFolder> localFolder = do_QueryInterface(m_folder);
+    if (localFolder) localFolder->NotifyDelete();
+  }
+}
+
+nsresult nsPop3Sink::BeginMailDelivery(bool uidlDownload,
+                                       nsIMsgWindow* aMsgWindow, bool* aBool) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgIncomingServer> server = do_QueryInterface(m_popServer);
+  if (!server) return NS_ERROR_UNEXPECTED;
+
+  m_window = aMsgWindow;
+
+  nsCOMPtr<nsIMsgAccountManager> acctMgr =
+      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+  nsCOMPtr<nsIMsgAccount> account;
+  NS_ENSURE_SUCCESS(rv, rv);
+  acctMgr->FindAccountForServer(server, getter_AddRefs(account));
+  if (account) account->GetKey(m_accountKey);
+
+  bool isLocked;
+  nsCOMPtr<nsISupports> supports =
+      do_QueryInterface(static_cast<nsIPop3Sink*>(this));
+
+  NS_ENSURE_STATE(m_folder);
+  m_folder->GetLocked(&isLocked);
+  if (!isLocked) {
+    MOZ_LOG(POP3LOGMODULE, mozilla::LogLevel::Debug,
+            (POP3LOG("BeginMailDelivery acquiring semaphore")));
+    m_folder->AcquireSemaphore(supports);
+  } else {
+    MOZ_LOG(POP3LOGMODULE, mozilla::LogLevel::Debug,
+            (POP3LOG("BeginMailDelivery folder locked")));
+    return NS_MSG_FOLDER_BUSY;
+  }
+  m_uidlDownload = uidlDownload;
+  if (!uidlDownload) FindPartialMessages();
+
+  m_folder->GetNumNewMessages(false, &m_numNewMessagesInFolder);
+
+#ifdef DEBUG
+  printf("Begin mail message delivery.\n");
+#endif
+  nsCOMPtr<nsIPop3Service> pop3Service(
+      do_GetService("@mozilla.org/messenger/popservice;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  pop3Service->NotifyDownloadStarted(m_folder);
+  if (aBool) *aBool = true;
+  return NS_OK;
+}
+
+nsresult nsPop3Sink::EndMailDelivery(nsIPop3Protocol* protocol) {
+  CheckPartialMessages(protocol);
+
+  if (m_newMailParser) {
+    if (m_outFileStream) m_outFileStream->Flush();  // try this.
+    m_newMailParser->OnStopRequest(nullptr, NS_OK);
+    m_newMailParser->EndMsgDownload();
+  }
+  if (m_outFileStream) {
+    m_outFileStream->Close();
+    m_outFileStream = nullptr;
+  }
+
+  // tell the parser to mark the db valid *after* closing the mailbox.
+  if (m_newMailParser) m_newMailParser->UpdateDBFolderInfo();
+
+  MOZ_LOG(POP3LOGMODULE, mozilla::LogLevel::Debug,
+          (POP3LOG("Calling ReleaseFolderLock from EndMailDelivery")));
+  nsresult rv = ReleaseFolderLock();
+  NS_ASSERTION(NS_SUCCEEDED(rv), "folder lock not released successfully");
+
+  bool filtersRun;
+  m_folder->CallFilterPlugins(nullptr,
+                              &filtersRun);  // ??? do we need msgWindow?
+  int32_t numNewMessagesInFolder;
+  // if filters have marked msgs read or deleted, the num new messages count
+  // will go negative by the number of messages marked read or deleted,
+  // so if we add that number to the number of msgs downloaded, that will give
+  // us the number of actual new messages.
+  m_folder->GetNumNewMessages(false, &numNewMessagesInFolder);
+  m_numNewMessages -= (m_numNewMessagesInFolder - numNewMessagesInFolder);
+  m_folder->SetNumNewMessages(
+      m_numNewMessages);  // we'll adjust this for spam later
+  if (!filtersRun && m_numNewMessages > 0) {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    m_folder->GetServer(getter_AddRefs(server));
+    if (server) {
+      server->SetPerformingBiff(true);
+      m_folder->SetBiffState(m_biffState);
+      server->SetPerformingBiff(false);
+    }
+  }
+  // note that size on disk has possibly changed.
+  nsCOMPtr<nsIMsgLocalMailFolder> localFolder = do_QueryInterface(m_folder);
+  if (localFolder) (void)localFolder->RefreshSizeOnDisk();
+  nsCOMPtr<nsIMsgIncomingServer> server = do_QueryInterface(m_popServer);
+  if (server) {
+    nsCOMPtr<nsIMsgFilterList> filterList;
+    rv = server->GetFilterList(nullptr, getter_AddRefs(filterList));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (filterList) (void)filterList->FlushLogIfNecessary();
+  }
+
+  // fix for bug #161999
+  // we should update the summary totals for the folder (inbox)
+  // in case it's not the open folder
+  m_folder->UpdateSummaryTotals(true);
+
+  // check if the folder open in this window is not the current folder, and if
+  // it has new message, in which case we need to try to run the filter plugin.
+  if (m_newMailParser) {
+    nsCOMPtr<nsIMsgWindow> msgWindow;
+    m_newMailParser->GetMsgWindow(getter_AddRefs(msgWindow));
+    // this breaks down if it's biff downloading new mail because
+    // there's no msgWindow...
+    if (msgWindow) {
+      nsCOMPtr<nsIMsgFolder> openFolder;
+      (void)msgWindow->GetOpenFolder(getter_AddRefs(openFolder));
+      if (openFolder && openFolder != m_folder) {
+        // only call filter plugins if folder is a local folder, because only
+        // local folders get messages filtered into them synchronously by pop3.
+        nsCOMPtr<nsIMsgLocalMailFolder> localFolder =
+            do_QueryInterface(openFolder);
+        if (localFolder) {
+          bool hasNew, isLocked;
+          (void)openFolder->GetHasNewMessages(&hasNew);
+          if (hasNew) {
+            // if the open folder is locked, we shouldn't run the spam filters
+            // on it because someone is using the folder. see 218433.
+            // Ideally, the filter plugin code would try to grab the folder lock
+            // and hold onto it until done, but that's more difficult and I
+            // think this will actually fix the problem.
+            openFolder->GetLocked(&isLocked);
+            if (!isLocked) openFolder->CallFilterPlugins(nullptr, &filtersRun);
+          }
+        }
+      }
+    }
+  }
+#ifdef DEBUG
+  printf("End mail message delivery.\n");
+#endif
+  nsCOMPtr<nsIPop3Service> pop3Service(
+      do_GetService("@mozilla.org/messenger/popservice;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  pop3Service->NotifyDownloadCompleted(m_folder, m_numNewMessages);
+  return NS_OK;
+}
+
+nsresult nsPop3Sink::ReleaseFolderLock() {
+  nsresult result = NS_OK;
+  if (!m_folder) return result;
+  bool haveSemaphore;
+  nsCOMPtr<nsISupports> supports =
+      do_QueryInterface(static_cast<nsIPop3Sink*>(this));
+  result = m_folder->TestSemaphore(supports, &haveSemaphore);
+  MOZ_LOG(POP3LOGMODULE, mozilla::LogLevel::Debug,
+          (POP3LOG("ReleaseFolderLock haveSemaphore = %s"),
+           haveSemaphore ? "TRUE" : "FALSE"));
+
+  if (NS_SUCCEEDED(result) && haveSemaphore)
+    result = m_folder->ReleaseSemaphore(supports);
+  return result;
+}
+
+nsresult nsPop3Sink::AbortMailDelivery(nsIPop3Protocol* protocol) {
+  CheckPartialMessages(protocol);
+
+  // ### PS TODO - discard any new message?
+
+  if (m_outFileStream) {
+    m_outFileStream->Close();
+    m_outFileStream = nullptr;
+  }
+
+  /* tell the parser to mark the db valid *after* closing the mailbox.
+  we have truncated the inbox, so berkeley mailbox and msf file are in sync*/
+  if (m_newMailParser) m_newMailParser->UpdateDBFolderInfo();
+  MOZ_LOG(POP3LOGMODULE, mozilla::LogLevel::Debug,
+          (POP3LOG("Calling ReleaseFolderLock from AbortMailDelivery")));
+
+  nsresult rv = ReleaseFolderLock();
+  NS_ASSERTION(NS_SUCCEEDED(rv), "folder lock not released successfully");
+
+#ifdef DEBUG
+  printf("Abort mail message delivery.\n");
+#endif
+  nsCOMPtr<nsIPop3Service> pop3Service(
+      do_GetService("@mozilla.org/messenger/popservice;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  pop3Service->NotifyDownloadCompleted(m_folder, 0);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::IncorporateBegin(const char* uidlString, uint32_t flags) {
+#ifdef DEBUG
+  printf("Incorporate message begin:\n");
+  if (uidlString) printf("uidl string: %s\n", uidlString);
+#endif
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgDBHdr> newHdr;
+
+  nsCOMPtr<nsIMsgIncomingServer> server = do_QueryInterface(m_popServer);
+  if (!server) return NS_ERROR_UNEXPECTED;
+
+  rv = server->GetMsgStore(getter_AddRefs(m_msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = m_msgStore->GetNewMsgOutputStream(m_folder, getter_AddRefs(newHdr),
+                                         getter_AddRefs(m_outFileStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // create a new mail parser
+  if (!m_newMailParser) m_newMailParser = new nsParseNewMailState;
+  NS_ENSURE_TRUE(m_newMailParser, NS_ERROR_OUT_OF_MEMORY);
+  if (m_uidlDownload) m_newMailParser->DisableFilters();
+
+  nsCOMPtr<nsIMsgFolder> serverFolder;
+  rv = GetServerFolder(getter_AddRefs(serverFolder));
+  if (NS_FAILED(rv)) return rv;
+
+  rv = m_newMailParser->Init(serverFolder, m_folder, m_window, newHdr,
+                             m_outFileStream);
+  // If we failed to initialize the parser, then just don't use it!!!
+  // We can still continue without one.
+
+  if (NS_FAILED(rv)) {
+    m_newMailParser = nullptr;
+    rv = NS_OK;
+  }
+
+  nsCString outputString(GetDummyEnvelope());
+  rv = WriteLineToMailbox(outputString);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Write out account-key before UIDL so the code that looks for
+  // UIDL will find the account first and know it can stop looking
+  // once it finds the UIDL line.
+  if (!m_accountKey.IsEmpty()) {
+    outputString.AssignLiteral(HEADER_X_MOZILLA_ACCOUNT_KEY ": ");
+    outputString.Append(m_accountKey);
+    outputString.AppendLiteral(MSG_LINEBREAK);
+    rv = WriteLineToMailbox(outputString);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  if (uidlString) {
+    outputString.AssignLiteral("X-UIDL: ");
+    outputString.Append(uidlString);
+    outputString.AppendLiteral(MSG_LINEBREAK);
+    rv = WriteLineToMailbox(outputString);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // WriteLineToMailbox("X-Mozilla-Status: 8000" MSG_LINEBREAK);
+  char* statusLine = PR_smprintf(X_MOZILLA_STATUS_FORMAT MSG_LINEBREAK, flags);
+  outputString.Assign(statusLine);
+  rv = WriteLineToMailbox(outputString);
+  PR_smprintf_free(statusLine);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = WriteLineToMailbox("X-Mozilla-Status2: 00000000"_ns MSG_LINEBREAK);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // leave space for 60 bytes worth of keys/tags
+  rv = WriteLineToMailbox(nsLiteralCString(X_MOZILLA_KEYWORDS));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::SetPopServer(nsIPop3IncomingServer* server) {
+  m_popServer = server;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::GetPopServer(nsIPop3IncomingServer** aServer) {
+  NS_ENSURE_ARG_POINTER(aServer);
+  NS_IF_ADDREF(*aServer = m_popServer);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsPop3Sink::GetFolder(nsIMsgFolder** aFolder) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_IF_ADDREF(*aFolder = m_folder);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsPop3Sink::SetFolder(nsIMsgFolder* aFolder) {
+  m_folder = aFolder;
+  return NS_OK;
+}
+
+nsresult nsPop3Sink::GetServerFolder(nsIMsgFolder** aFolder) {
+  NS_ENSURE_ARG_POINTER(aFolder);
+
+  if (m_popServer) {
+    // not sure what this is used for - might be wrong if we have a deferred
+    // account.
+    nsCOMPtr<nsIMsgIncomingServer> incomingServer =
+        do_QueryInterface(m_popServer);
+    if (incomingServer) return incomingServer->GetRootFolder(aFolder);
+  }
+  *aFolder = nullptr;
+  return NS_ERROR_NULL_POINTER;
+}
+
+NS_IMETHODIMP nsPop3Sink::SetMsgsToDownload(uint32_t aNumMessages) {
+  m_numNewMessages = aNumMessages;
+  return NS_OK;
+}
+
+char* nsPop3Sink::GetDummyEnvelope(void) {
+  static char result[75];
+  char* ct;
+  time_t now = time((time_t*)0);
+#if defined(XP_WIN)
+  if (now < 0 || now > 0x7FFFFFFF) now = 0x7FFFFFFF;
+#endif
+  ct = ctime(&now);
+  PR_ASSERT(ct[24] == '\r' || ct[24] == '\n');
+  ct[24] = 0;
+  /* This value must be in ctime() format, with English abbreviations.
+   strftime("... %c ...") is no good, because it is localized. */
+  PL_strcpy(result, "From - ");
+  PL_strcpy(result + 7, ct);
+  PL_strcpy(result + 7 + 24, MSG_LINEBREAK);
+  return result;
+}
+
+nsresult nsPop3Sink::IncorporateWrite(const char* block, int32_t length) {
+  m_outputBuffer.Truncate();
+  if (!strncmp(block, "From ", 5)) m_outputBuffer.Assign('>');
+
+  m_outputBuffer.Append(block);
+
+  return WriteLineToMailbox(m_outputBuffer);
+}
+
+nsresult nsPop3Sink::WriteLineToMailbox(const nsACString& buffer) {
+  if (!buffer.IsEmpty()) {
+    uint32_t bufferLen = buffer.Length();
+    if (m_newMailParser)
+      m_newMailParser->HandleLine(buffer.BeginReading(), bufferLen);
+    // The following (!m_outFileStream etc) was added to make sure that we don't
+    // write somewhere where for some reason or another we can't write to and
+    // lose the messages See bug 62480
+    NS_ENSURE_TRUE(m_outFileStream, NS_ERROR_OUT_OF_MEMORY);
+
+    // To remove seeking to the end for each line to be written, remove the
+    // following line. See bug 1116055 for details.
+#define SEEK_TO_END
+#ifdef SEEK_TO_END
+    // seek to the end in case someone else has sought elsewhere in our stream.
+    nsCOMPtr<nsISeekableStream> seekableOutStream =
+        do_QueryInterface(m_outFileStream);
+
+    if (seekableOutStream) {
+      int64_t before_seek_pos;
+      nsresult rv2 = seekableOutStream->Tell(&before_seek_pos);
+      MOZ_ASSERT(NS_SUCCEEDED(rv2),
+                 "seekableOutStream->Tell(&before_seek_pos) failed");
+
+      // XXX Handle error such as network error for remote file system.
+      seekableOutStream->Seek(nsISeekableStream::NS_SEEK_END, 0);
+
+      int64_t after_seek_pos;
+      nsresult rv3 = seekableOutStream->Tell(&after_seek_pos);
+      MOZ_ASSERT(NS_SUCCEEDED(rv3),
+                 "seekableOutStream->Tell(&after_seek_pos) failed");
+
+      if (NS_SUCCEEDED(rv2) && NS_SUCCEEDED(rv3)) {
+        if (before_seek_pos != after_seek_pos) {
+          nsString folderName;
+          if (m_folder) m_folder->GetPrettyName(folderName);
+          // This merits a console message, it's poor man's telemetry.
+          MsgLogToConsole4(
+              u"Unexpected file position change detected"_ns +
+                  (folderName.IsEmpty() ? EmptyString() : u" in folder "_ns) +
+                  (folderName.IsEmpty() ? EmptyString() : folderName) +
+                  u". "
+                  "If you can reliably reproduce this, please report the "
+                  "steps you used to dev-apps-thunderbird@lists.mozilla.org "
+                  "or to bug 1308335 at bugzilla.mozilla.org. "
+                  "Resolving this problem will allow speeding up message "
+                  "downloads."_ns,
+              NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__,
+              nsIScriptError::errorFlag);
+#  ifdef DEBUG
+          // Debugging, see bug 1116055.
+          if (!folderName.IsEmpty()) {
+            fprintf(stderr,
+                    "(seekdebug) WriteLineToMailbox() detected an unexpected "
+                    "file position change in folder %s.\n",
+                    NS_ConvertUTF16toUTF8(folderName).get());
+          } else {
+            fprintf(stderr,
+                    "(seekdebug) WriteLineToMailbox() detected an unexpected "
+                    "file position change.\n");
+          }
+          fprintf(stderr,
+                  "(seekdebug) before_seek_pos=0x%016llx, "
+                  "after_seek_pos=0x%016llx\n",
+                  (long long unsigned int)before_seek_pos,
+                  (long long unsigned int)after_seek_pos);
+#  endif
+        }
+      }
+    }
+#endif
+
+    uint32_t bytesWritten;
+    nsresult rv =
+        m_outFileStream->Write(buffer.BeginReading(), bufferLen, &bytesWritten);
+    NS_ENSURE_SUCCESS(rv, rv);
+    NS_ENSURE_TRUE(bytesWritten == bufferLen, NS_ERROR_FAILURE);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::IncorporateComplete(nsIMsgWindow* aMsgWindow, int32_t aSize) {
+  if (m_buildMessageUri && !m_baseMessageUri.IsEmpty() && m_newMailParser &&
+      m_newMailParser->m_newMsgHdr) {
+    nsMsgKey msgKey;
+    m_newMailParser->m_newMsgHdr->GetMessageKey(&msgKey);
+    m_messageUri.Truncate();
+    nsBuildLocalMessageURI(m_baseMessageUri, msgKey, m_messageUri);
+  }
+
+  nsresult rv = WriteLineToMailbox(nsLiteralCString(MSG_LINEBREAK));
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool leaveOnServer = false;
+  m_popServer->GetLeaveMessagesOnServer(&leaveOnServer);
+  // We need to flush the output stream, in case mail filters move
+  // the new message, which relies on all the data being flushed.
+  rv =
+      m_outFileStream->Flush();  // Make sure the message is written to the disk
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ASSERTION(m_newMailParser, "could not get m_newMailParser");
+  if (m_newMailParser) {
+    // PublishMsgHdr clears m_newMsgHdr, so we need a comptr to
+    // hold onto it.
+    nsCOMPtr<nsIMsgDBHdr> hdr = m_newMailParser->m_newMsgHdr;
+    NS_ASSERTION(hdr, "m_newMailParser->m_newMsgHdr wasn't set");
+    if (!hdr) return NS_ERROR_FAILURE;
+
+    nsCOMPtr<nsIMsgLocalMailFolder> localFolder = do_QueryInterface(m_folder);
+
+    // If a header already exists for this message (for example, when
+    // getting a complete message when a partial exists), then update the new
+    // header from the old.
+    nsCOMPtr<nsIMsgDBHdr> oldMsgHdr;
+    if (!m_origMessageUri.IsEmpty() && localFolder) {
+      rv = GetMsgDBHdrFromURI(m_origMessageUri, getter_AddRefs(oldMsgHdr));
+      if (NS_SUCCEEDED(rv) && oldMsgHdr) {
+        localFolder->UpdateNewMsgHdr(oldMsgHdr, hdr);
+      }
+    }
+    m_msgStore->FinishNewMessage(m_outFileStream, hdr);
+    m_newMailParser->PublishMsgHeader(aMsgWindow);
+    m_newMailParser->ApplyForwardAndReplyFilter(aMsgWindow);
+    if (aSize) hdr->SetUint32Property("onlineSize", aSize);
+
+    if (oldMsgHdr) {
+      // We had the partial message, but got the full now.
+      nsCOMPtr<nsIMsgFolder> oldMsgFolder;
+      rv = oldMsgHdr->GetFolder(getter_AddRefs(oldMsgFolder));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCString oldURI;
+      rv = oldMsgFolder->GetUriForMsg(oldMsgHdr, oldURI);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIMsgFolder> newMsgFolder;
+      rv = hdr->GetFolder(getter_AddRefs(newMsgFolder));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCString newURI;
+      rv = newMsgFolder->GetUriForMsg(hdr, newURI);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Delete old header before notifying.
+      nsCOMPtr<nsIMsgDatabase> db;
+      rv = m_folder->GetMsgDatabase(getter_AddRefs(db));
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = db->DeleteHeader(oldMsgHdr, nullptr, false, true);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIObserverService> obsServ =
+          mozilla::services::GetObserverService();
+      nsCOMPtr<nsISupportsString> origUri =
+          do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
+      if (NS_SUCCEEDED(rv)) {
+        origUri->SetData(NS_ConvertUTF8toUTF16(oldURI));
+        obsServ->NotifyObservers(origUri, "message-content-updated",
+                                 NS_ConvertUTF8toUTF16(newURI).get());
+      }
+    }
+  }
+
+#ifdef DEBUG
+  printf("Incorporate message complete.\n");
+#endif
+  nsCOMPtr<nsIPop3Service> pop3Service(
+      do_GetService("@mozilla.org/messenger/popservice;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  pop3Service->NotifyDownloadProgress(m_folder, ++m_numMsgsDownloaded,
+                                      m_numNewMessages);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::IncorporateAbort(bool uidlDownload) {
+  NS_ENSURE_STATE(m_outFileStream);
+  nsresult rv = m_outFileStream->Close();
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (m_msgStore && m_newMailParser && m_newMailParser->m_newMsgHdr) {
+    m_msgStore->DiscardNewMessage(m_outFileStream,
+                                  m_newMailParser->m_newMsgHdr);
+  }
+#ifdef DEBUG
+  printf("Incorporate message abort.\n");
+#endif
+  return rv;
+}
+
+nsresult nsPop3Sink::SetBiffStateAndUpdateFE(uint32_t aBiffState,
+                                             int32_t numNewMessages,
+                                             bool notify) {
+  m_biffState = aBiffState;
+  if (m_newMailParser) numNewMessages -= m_newMailParser->m_numNotNewMessages;
+
+  if (notify && m_folder && numNewMessages > 0 &&
+      numNewMessages != m_numNewMessages &&
+      aBiffState == nsIMsgFolder::nsMsgBiffState_NewMail) {
+    m_folder->SetNumNewMessages(numNewMessages);
+    m_folder->SetBiffState(aBiffState);
+  }
+  m_numNewMessages = numNewMessages;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::GetBuildMessageUri(bool* bVal) {
+  NS_ENSURE_ARG_POINTER(bVal);
+  *bVal = m_buildMessageUri;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::SetBuildMessageUri(bool bVal) {
+  m_buildMessageUri = bVal;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::GetMessageUri(nsACString& messageUri) {
+  NS_ENSURE_TRUE(!m_messageUri.IsEmpty(), NS_ERROR_FAILURE);
+  messageUri = m_messageUri;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::SetMessageUri(const nsACString& messageUri) {
+  m_messageUri = messageUri;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::GetBaseMessageUri(nsACString& baseMessageUri) {
+  NS_ENSURE_TRUE(!m_baseMessageUri.IsEmpty(), NS_ERROR_FAILURE);
+  baseMessageUri = m_baseMessageUri;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::SetBaseMessageUri(const nsACString& baseMessageUri) {
+  m_baseMessageUri = baseMessageUri;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::GetOrigMessageUri(nsACString& aOrigMessageUri) {
+  aOrigMessageUri.Assign(m_origMessageUri);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3Sink::SetOrigMessageUri(const nsACString& aOrigMessageUri) {
+  m_origMessageUri.Assign(aOrigMessageUri);
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsPop3Sink.h b/comm/mailnews/local/src/nsPop3Sink.h
new file mode 100644
index 0000000000..9ea4e6b2ce
--- /dev/null
+++ b/comm/mailnews/local/src/nsPop3Sink.h
@@ -0,0 +1,70 @@
+/* -*- 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 nsPop3Sink_h__
+#define nsPop3Sink_h__
+
+#include "nscore.h"
+#include "nsIPop3Sink.h"
+#include "nsIOutputStream.h"
+#include "prmem.h"
+#include "prio.h"
+#include "plstr.h"
+#include "prenv.h"
+#include "nsIMsgFolder.h"
+#include "nsTArray.h"
+#include "nsString.h"
+
+class nsParseNewMailState;
+class nsIMsgFolder;
+
+struct partialRecord {
+  partialRecord();
+  ~partialRecord();
+
+  nsCOMPtr<nsIMsgDBHdr> m_msgDBHdr;
+  nsCString m_uidl;
+};
+
+class nsPop3Sink : public nsIPop3Sink {
+ public:
+  nsPop3Sink();
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIPOP3SINK
+  nsresult GetServerFolder(nsIMsgFolder** aFolder);
+  nsresult FindPartialMessages();
+  void CheckPartialMessages(nsIPop3Protocol* protocol);
+
+  static char* GetDummyEnvelope(void);
+
+ protected:
+  virtual ~nsPop3Sink();
+  nsresult WriteLineToMailbox(const nsACString& buffer);
+  nsresult ReleaseFolderLock();
+
+  uint32_t m_biffState;
+  int32_t m_numNewMessages;
+  int32_t m_numNewMessagesInFolder;
+  int32_t m_numMsgsDownloaded;
+  bool m_senderAuthed;
+  nsCString m_outputBuffer;
+  nsCOMPtr<nsIPop3IncomingServer> m_popServer;
+  // Currently the folder we want to update about biff info
+  nsCOMPtr<nsIMsgFolder> m_folder;
+  RefPtr<nsParseNewMailState> m_newMailParser;
+  nsCOMPtr<nsIOutputStream>
+      m_outFileStream;  // the file we write to, which may be temporary
+  nsCOMPtr<nsIMsgPluggableStore> m_msgStore;
+  bool m_uidlDownload;
+  bool m_buildMessageUri;
+  nsCOMPtr<nsIMsgWindow> m_window;
+  nsCString m_messageUri;
+  nsCString m_baseMessageUri;
+  nsCString m_origMessageUri;
+  nsCString m_accountKey;
+  nsTArray<partialRecord*> m_partialMsgsArray;
+};
+
+#endif
diff --git a/comm/mailnews/local/src/nsPop3URL.cpp b/comm/mailnews/local/src/nsPop3URL.cpp
new file mode 100644
index 0000000000..138a4d9930
--- /dev/null
+++ b/comm/mailnews/local/src/nsPop3URL.cpp
@@ -0,0 +1,202 @@
+/* -*- 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 "nsPop3URL.h"
+#include "nsString.h"
+#include "prmem.h"
+#include "plstr.h"
+#include "prprf.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgAccountManager.h"
+#include "nsLocalMailFolder.h"
+#include "nsPop3Sink.h"
+
+#define NS_POP3URL_CID                             \
+  {                                                \
+    0xea1b0a11, 0xe6f4, 0x11d2, {                  \
+      0x80, 0x70, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e \
+    }                                              \
+  }
+static NS_DEFINE_CID(kPop3UrlCID, NS_POP3URL_CID);
+
+nsPop3URL::nsPop3URL() : nsMsgMailNewsUrl() {}
+
+nsPop3URL::~nsPop3URL() {}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsPop3URL, nsMsgMailNewsUrl, nsIPop3URL)
+
+////////////////////////////////////////////////////////////////////////////////////
+// Begin nsIPop3URL specific support
+////////////////////////////////////////////////////////////////////////////////////
+
+nsresult nsPop3URL::SetPop3Sink(nsIPop3Sink* aPop3Sink) {
+  if (aPop3Sink) m_pop3Sink = aPop3Sink;
+  return NS_OK;
+}
+
+nsresult nsPop3URL::GetPop3Sink(nsIPop3Sink** aPop3Sink) {
+  if (aPop3Sink) {
+    *aPop3Sink = m_pop3Sink;
+    NS_IF_ADDREF(*aPop3Sink);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3URL::GetMessageUri(nsACString& aMessageUri) {
+  if (m_messageUri.IsEmpty()) return NS_ERROR_NULL_POINTER;
+  aMessageUri = m_messageUri;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPop3URL::SetMessageUri(const nsACString& aMessageUri) {
+  m_messageUri = aMessageUri;
+  return NS_OK;
+}
+
+nsresult nsPop3URL::BuildPop3Url(const char* urlSpec, nsIMsgFolder* inbox,
+                                 nsIPop3IncomingServer* server,
+                                 nsIUrlListener* aUrlListener, nsIURI** aUrl,
+                                 nsIMsgWindow* aMsgWindow) {
+  nsresult rv;
+
+  nsPop3Sink* pop3Sink = new nsPop3Sink();
+
+  pop3Sink->SetPopServer(server);
+  pop3Sink->SetFolder(inbox);
+
+  // now create a pop3 url and a protocol instance to run the url....
+  nsCOMPtr<nsIPop3URL> pop3Url = do_CreateInstance(kPop3UrlCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  pop3Url->SetPop3Sink(pop3Sink);
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl;
+  rv = pop3Url->QueryInterface(NS_GET_IID(nsIMsgMailNewsUrl),
+                               getter_AddRefs(mailnewsurl));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mailnewsurl->SetSpecInternal(nsDependentCString(urlSpec));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aUrlListener) mailnewsurl->RegisterListener(aUrlListener);
+  if (aMsgWindow) mailnewsurl->SetMsgWindow(aMsgWindow);
+
+  mailnewsurl.forget(aUrl);
+
+  return rv;
+}
+
+nsresult nsPop3URL::NewURI(const nsACString& aSpec, nsIURI* aBaseURI,
+                           nsIURI** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  nsAutoCString folderUri(aSpec);
+  int32_t offset = folderUri.FindChar('?');
+  if (offset != kNotFound) folderUri.SetLength(offset);
+
+  // Hold onto the string until it goes out of scope.
+  const nsPromiseFlatCString& flat = PromiseFlatCString(aSpec);
+  const char* uidl = PL_strstr(flat.get(), "uidl=");
+  NS_ENSURE_TRUE(uidl, NS_ERROR_FAILURE);
+
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  rv = GetOrCreateFolder(folderUri, getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+
+  nsLocalFolderScanState folderScanState;
+  nsCOMPtr<nsIMsgLocalMailFolder> localFolder = do_QueryInterface(folder);
+  nsCOMPtr<nsIMailboxUrl> mailboxUrl = do_QueryInterface(aBaseURI);
+
+  if (mailboxUrl && localFolder) {
+    rv = localFolder->GetFolderScanState(&folderScanState);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    nsMsgKey msgKey;
+    mailboxUrl->GetMessageKey(&msgKey);
+    folder->GetMessageHeader(msgKey, getter_AddRefs(msgHdr));
+    // we do this to get the account key
+    if (msgHdr) localFolder->GetUidlFromFolder(&folderScanState, msgHdr);
+    if (!folderScanState.m_accountKey.IsEmpty()) {
+      nsCOMPtr<nsIMsgAccountManager> accountManager =
+          do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+      if (accountManager) {
+        nsCOMPtr<nsIMsgAccount> account;
+        accountManager->GetAccount(folderScanState.m_accountKey,
+                                   getter_AddRefs(account));
+        if (account) account->GetIncomingServer(getter_AddRefs(server));
+      }
+    }
+  }
+
+  if (!server) rv = folder->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPop3IncomingServer> popServer = do_QueryInterface(server, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString hostname;
+  nsCString username;
+  server->GetHostName(hostname);
+  server->GetUsername(username);
+
+  int32_t port;
+  server->GetPort(&port);
+  if (port == -1) port = nsIPop3URL::DEFAULT_POP3_PORT;
+
+  // We need to escape the username before calling SetUsername() because it may
+  // contain characters like / % or @. GetUsername() will unescape the username.
+  nsCString escapedUsername;
+  MsgEscapeString(username, nsINetUtil::ESCAPE_XALPHAS, escapedUsername);
+
+  nsAutoCString popSpec("pop://");
+  popSpec += escapedUsername;
+  popSpec += "@";
+  popSpec += hostname;
+  popSpec += ":";
+  popSpec.AppendInt(port);
+  popSpec += "?";
+  popSpec += uidl;
+  nsCOMPtr<nsIUrlListener> urlListener = do_QueryInterface(folder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIURI> newUri;
+  rv = BuildPop3Url(popSpec.get(), folder, popServer, urlListener,
+                    getter_AddRefs(newUri), nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl = do_QueryInterface(newUri, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mailnewsurl->SetUsernameInternal(escapedUsername);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPop3URL> popurl = do_QueryInterface(newUri, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString messageUri(aSpec);
+  if (!strncmp(messageUri.get(), "mailbox:", 8))
+    messageUri.Replace(0, 8, "mailbox-message:");
+  offset = messageUri.Find("?number=");
+  if (offset != kNotFound) messageUri.Replace(offset, 8, "#");
+  offset = messageUri.FindChar('&');
+  if (offset != kNotFound) messageUri.SetLength(offset);
+  popurl->SetMessageUri(messageUri);
+  nsCOMPtr<nsIPop3Sink> pop3Sink;
+  rv = popurl->GetPop3Sink(getter_AddRefs(pop3Sink));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  pop3Sink->SetBuildMessageUri(true);
+
+  newUri.forget(_retval);
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsPop3URL.h b/comm/mailnews/local/src/nsPop3URL.h
new file mode 100644
index 0000000000..44e2ce6dc9
--- /dev/null
+++ b/comm/mailnews/local/src/nsPop3URL.h
@@ -0,0 +1,36 @@
+/* -*- 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 nsPop3URL_h__
+#define nsPop3URL_h__
+
+#include "nsIPop3URL.h"
+#include "nsMsgMailNewsUrl.h"
+#include "nsCOMPtr.h"
+
+class nsPop3URL : public nsIPop3URL, public nsMsgMailNewsUrl {
+ public:
+  NS_DECL_NSIPOP3URL
+  nsPop3URL();
+  static nsresult NewURI(const nsACString& aSpec, nsIURI* aBaseURI,
+                         nsIURI** _retval);
+  NS_DECL_ISUPPORTS_INHERITED
+
+ protected:
+  virtual ~nsPop3URL();
+
+  nsCString m_messageUri;
+
+  /* Pop3 specific event sinks */
+  nsCOMPtr<nsIPop3Sink> m_pop3Sink;
+
+  // convenience function to make constructing of the pop3 url easier...
+  static nsresult BuildPop3Url(const char* urlSpec, nsIMsgFolder* inbox,
+                               nsIPop3IncomingServer*,
+                               nsIUrlListener* aUrlListener, nsIURI** aUrl,
+                               nsIMsgWindow* aMsgWindow);
+};
+
+#endif  // nsPop3URL_h__
diff --git a/comm/mailnews/local/src/nsRssIncomingServer.cpp b/comm/mailnews/local/src/nsRssIncomingServer.cpp
new file mode 100644
index 0000000000..005e202c14
--- /dev/null
+++ b/comm/mailnews/local/src/nsRssIncomingServer.cpp
@@ -0,0 +1,248 @@
+/* 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 "nsRssIncomingServer.h"
+#include "nsMsgFolderFlags.h"
+#include "nsINewsBlogFeedDownloader.h"
+#include "nsIFile.h"
+#include "nsIMsgFolderNotificationService.h"
+
+#include "nsIMsgLocalMailFolder.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsMsgUtils.h"
+
+nsrefcnt nsRssIncomingServer::gInstanceCount = 0;
+
+NS_IMPL_ISUPPORTS_INHERITED(nsRssIncomingServer, nsMsgIncomingServer,
+                            nsIRssIncomingServer, nsIMsgFolderListener,
+                            nsILocalMailIncomingServer)
+
+nsRssIncomingServer::nsRssIncomingServer() {
+  m_canHaveFilters = true;
+
+  if (gInstanceCount == 0) {
+    nsresult rv;
+    nsCOMPtr<nsIMsgFolderNotificationService> notifyService =
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1", &rv);
+    if (NS_SUCCEEDED(rv))
+      notifyService->AddListener(
+          this, nsIMsgFolderNotificationService::folderAdded |
+                    nsIMsgFolderNotificationService::folderDeleted |
+                    nsIMsgFolderNotificationService::folderMoveCopyCompleted |
+                    nsIMsgFolderNotificationService::folderRenamed);
+  }
+
+  gInstanceCount++;
+}
+
+nsRssIncomingServer::~nsRssIncomingServer() {
+  gInstanceCount--;
+
+  if (gInstanceCount == 0) {
+    nsresult rv;
+    nsCOMPtr<nsIMsgFolderNotificationService> notifyService =
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1", &rv);
+    if (NS_SUCCEEDED(rv)) notifyService->RemoveListener(this);
+  }
+}
+
+nsresult nsRssIncomingServer::FillInDataSourcePath(
+    const nsAString& aDataSourceName, nsIFile** aLocation) {
+  nsresult rv;
+  // Get the local path for this server.
+  nsCOMPtr<nsIFile> localFile;
+  rv = GetLocalPath(getter_AddRefs(localFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Append the name of the subscriptions data source.
+  rv = localFile->Append(aDataSourceName);
+  localFile.forget(aLocation);
+  return rv;
+}
+
+// nsIRSSIncomingServer methods
+NS_IMETHODIMP nsRssIncomingServer::GetSubscriptionsPath(nsIFile** aLocation) {
+  return FillInDataSourcePath(u"feeds.json"_ns, aLocation);
+}
+
+NS_IMETHODIMP nsRssIncomingServer::GetFeedItemsPath(nsIFile** aLocation) {
+  return FillInDataSourcePath(u"feeditems.json"_ns, aLocation);
+}
+
+NS_IMETHODIMP nsRssIncomingServer::CreateDefaultMailboxes() {
+  // For Feeds, all we have is Trash.
+  return CreateLocalFolder(u"Trash"_ns);
+}
+
+NS_IMETHODIMP nsRssIncomingServer::SetFlagsOnDefaultMailboxes() {
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgLocalMailFolder> localFolder =
+      do_QueryInterface(rootFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  localFolder->SetFlagsOnDefaultMailboxes(nsMsgFolderFlags::Trash);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::PerformBiff(nsIMsgWindow* aMsgWindow) {
+  // Get the account root (server) folder and pass it on.
+  nsCOMPtr<nsIMsgFolder> rootRSSFolder;
+  GetRootMsgFolder(getter_AddRefs(rootRSSFolder));
+  nsCOMPtr<nsIUrlListener> urlListener = do_QueryInterface(rootRSSFolder);
+  nsresult rv;
+  bool isBiff = true;
+  nsCOMPtr<nsINewsBlogFeedDownloader> rssDownloader =
+      do_GetService("@mozilla.org/newsblog-feed-downloader;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rssDownloader->DownloadFeed(rootRSSFolder, urlListener, isBiff, aMsgWindow);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::GetNewMail(nsIMsgWindow* aMsgWindow,
+                                              nsIUrlListener* aUrlListener,
+                                              nsIMsgFolder* aFolder,
+                                              nsIURI** _retval) {
+  // Pass the selected folder on to the downloader.
+  if (_retval) {
+    *_retval = nullptr;
+  }
+  NS_ENSURE_ARG_POINTER(aFolder);
+  nsresult rv;
+  bool isBiff = false;
+  nsCOMPtr<nsINewsBlogFeedDownloader> rssDownloader =
+      do_GetService("@mozilla.org/newsblog-feed-downloader;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rssDownloader->DownloadFeed(aFolder, aUrlListener, isBiff, aMsgWindow);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::GetAccountManagerChrome(nsAString& aResult) {
+  aResult.AssignLiteral("am-newsblog.xhtml");
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::GetOfflineSupportLevel(
+    int32_t* aSupportLevel) {
+  NS_ENSURE_ARG_POINTER(aSupportLevel);
+  *aSupportLevel = OFFLINE_SUPPORT_LEVEL_NONE;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::GetSupportsDiskSpace(
+    bool* aSupportsDiskSpace) {
+  NS_ENSURE_ARG_POINTER(aSupportsDiskSpace);
+  *aSupportsDiskSpace = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::GetServerRequiresPasswordForBiff(
+    bool* aServerRequiresPasswordForBiff) {
+  NS_ENSURE_ARG_POINTER(aServerRequiresPasswordForBiff);
+  // For Feed folders, we don't require a password.
+  *aServerRequiresPasswordForBiff = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::GetCanSearchMessages(
+    bool* canSearchMessages) {
+  NS_ENSURE_ARG_POINTER(canSearchMessages);
+  *canSearchMessages = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::MsgAdded(nsIMsgDBHdr* aMsg) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::MsgsClassified(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMsgs, bool aJunkProcessed,
+    bool aTraitProcessed) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::MsgsJunkStatusChanged(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& messages) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::MsgsDeleted(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMsgs) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::MsgsMoveCopyCompleted(
+    bool aMove, const nsTArray<RefPtr<nsIMsgDBHdr>>& aSrcMsgs,
+    nsIMsgFolder* aDestFolder, const nsTArray<RefPtr<nsIMsgDBHdr>>& aDestMsgs) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::MsgKeyChanged(nsMsgKey aOldKey,
+                                                 nsIMsgDBHdr* aNewHdr) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::FolderAdded(nsIMsgFolder* aFolder) {
+  // Nothing to do. Not necessary for new folder adds, as a new folder never
+  // has a subscription.
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::FolderDeleted(nsIMsgFolder* aFolder) {
+  // Not necessary for folder deletes, which are move to Trash and handled by
+  // movecopy. Virtual folder or trash folder deletes send a folderdeleted,
+  // but these should have no subscriptions already.
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::FolderMoveCopyCompleted(
+    bool aMove, nsIMsgFolder* aSrcFolder, nsIMsgFolder* aDestFolder) {
+  return FolderChanged(aDestFolder, aSrcFolder, (aMove ? "move" : "copy"));
+}
+
+NS_IMETHODIMP nsRssIncomingServer::FolderRenamed(nsIMsgFolder* aOrigFolder,
+                                                 nsIMsgFolder* aNewFolder) {
+  return FolderChanged(aNewFolder, aOrigFolder, "rename");
+}
+
+nsresult nsRssIncomingServer::FolderChanged(nsIMsgFolder* aFolder,
+                                            nsIMsgFolder* aOrigFolder,
+                                            const char* aAction) {
+  if (!aFolder) return NS_OK;
+
+  nsresult rv;
+  nsCOMPtr<nsINewsBlogFeedDownloader> rssDownloader =
+      do_GetService("@mozilla.org/newsblog-feed-downloader;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rssDownloader->UpdateSubscriptionsDS(aFolder, aOrigFolder, aAction);
+  return rv;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::MsgUnincorporatedMoved(
+    nsIMsgFolder* srcFolder, nsIMsgDBHdr* msg) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::FolderCompactStart(nsIMsgFolder* folder) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::FolderCompactFinish(nsIMsgFolder* folder) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssIncomingServer::FolderReindexTriggered(
+    nsIMsgFolder* folder) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsRssIncomingServer::GetSortOrder(int32_t* aSortOrder) {
+  NS_ENSURE_ARG_POINTER(aSortOrder);
+  *aSortOrder = 400000000;
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsRssIncomingServer.h b/comm/mailnews/local/src/nsRssIncomingServer.h
new file mode 100644
index 0000000000..337f1ce95d
--- /dev/null
+++ b/comm/mailnews/local/src/nsRssIncomingServer.h
@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsRssIncomingServer_h
+#define __nsRssIncomingServer_h
+
+#include "mozilla/Attributes.h"
+#include "nsIRssIncomingServer.h"
+#include "nsILocalMailIncomingServer.h"
+#include "nsMsgIncomingServer.h"
+#include "nsIMsgFolderListener.h"
+#include "nsMailboxServer.h"
+
+class nsRssIncomingServer : public nsMailboxServer,
+                            public nsIRssIncomingServer,
+                            public nsILocalMailIncomingServer,
+                            public nsIMsgFolderListener
+
+{
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIRSSINCOMINGSERVER
+  NS_DECL_NSILOCALMAILINCOMINGSERVER
+  NS_DECL_NSIMSGFOLDERLISTENER
+
+  NS_IMETHOD GetOfflineSupportLevel(int32_t* aSupportLevel) override;
+  NS_IMETHOD GetSupportsDiskSpace(bool* aSupportsDiskSpace) override;
+  NS_IMETHOD GetAccountManagerChrome(nsAString& aResult) override;
+  NS_IMETHOD PerformBiff(nsIMsgWindow* aMsgWindow) override;
+  NS_IMETHOD GetServerRequiresPasswordForBiff(
+      bool* aServerRequiresPasswordForBiff) override;
+  NS_IMETHOD GetCanSearchMessages(bool* canSearchMessages) override;
+  NS_IMETHOD GetSortOrder(int32_t* aSortOrder) override;
+
+  nsRssIncomingServer();
+
+ protected:
+  virtual ~nsRssIncomingServer();
+  nsresult FolderChanged(nsIMsgFolder* aFolder, nsIMsgFolder* aOrigFolder,
+                         const char* aAction);
+  nsresult FillInDataSourcePath(const nsAString& aDataSourceName,
+                                nsIFile** aLocation);
+  static nsrefcnt gInstanceCount;
+};
+
+#endif /* __nsRssIncomingServer_h */
diff --git a/comm/mailnews/local/src/nsRssService.cpp b/comm/mailnews/local/src/nsRssService.cpp
new file mode 100644
index 0000000000..77cf04365d
--- /dev/null
+++ b/comm/mailnews/local/src/nsRssService.cpp
@@ -0,0 +1,113 @@
+/* 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 "nsRssService.h"
+#include "nsCOMPtr.h"
+#include "nsIFile.h"
+#include "nsMailDirServiceDefs.h"
+#include "nsIProperties.h"
+#include "nsServiceManagerUtils.h"
+
+nsRssService::nsRssService() {}
+
+nsRssService::~nsRssService() {}
+
+NS_IMPL_ISUPPORTS(nsRssService, nsIRssService, nsIMsgProtocolInfo)
+
+NS_IMETHODIMP nsRssService::GetDefaultLocalPath(nsIFile** aDefaultLocalPath) {
+  NS_ENSURE_ARG_POINTER(aDefaultLocalPath);
+  *aDefaultLocalPath = nullptr;
+
+  nsCOMPtr<nsIFile> localFile;
+  nsCOMPtr<nsIProperties> dirService(
+      do_GetService("@mozilla.org/file/directory_service;1"));
+  if (!dirService) return NS_ERROR_FAILURE;
+  dirService->Get(NS_APP_MAIL_50_DIR, NS_GET_IID(nsIFile),
+                  getter_AddRefs(localFile));
+  if (!localFile) return NS_ERROR_FAILURE;
+
+  bool exists;
+  nsresult rv = localFile->Exists(&exists);
+  if (NS_SUCCEEDED(rv) && !exists)
+    rv = localFile->Create(nsIFile::DIRECTORY_TYPE, 0775);
+  if (NS_FAILED(rv)) return rv;
+
+  localFile.forget(aDefaultLocalPath);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::SetDefaultLocalPath(nsIFile* aDefaultLocalPath) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssService::GetServerIID(nsIID** aServerIID) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssService::GetRequiresUsername(bool* aRequiresUsername) {
+  NS_ENSURE_ARG_POINTER(aRequiresUsername);
+  *aRequiresUsername = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::GetPreflightPrettyNameWithEmailAddress(
+    bool* aPreflightPrettyNameWithEmailAddress) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsRssService::GetCanDelete(bool* aCanDelete) {
+  NS_ENSURE_ARG_POINTER(aCanDelete);
+  *aCanDelete = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::GetCanLoginAtStartUp(bool* aCanLoginAtStartUp) {
+  NS_ENSURE_ARG_POINTER(aCanLoginAtStartUp);
+  *aCanLoginAtStartUp = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::GetCanDuplicate(bool* aCanDuplicate) {
+  NS_ENSURE_ARG_POINTER(aCanDuplicate);
+  *aCanDuplicate = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::GetDefaultServerPort(bool isSecure,
+                                                 int32_t* _retval) {
+  *_retval = -1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::GetCanGetMessages(bool* aCanGetMessages) {
+  NS_ENSURE_ARG_POINTER(aCanGetMessages);
+  *aCanGetMessages = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::GetCanGetIncomingMessages(
+    bool* aCanGetIncomingMessages) {
+  NS_ENSURE_ARG_POINTER(aCanGetIncomingMessages);
+  *aCanGetIncomingMessages = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::GetDefaultDoBiff(bool* aDefaultDoBiff) {
+  NS_ENSURE_ARG_POINTER(aDefaultDoBiff);
+  // by default, do biff for RSS feeds
+  *aDefaultDoBiff = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::GetShowComposeMsgLink(bool* aShowComposeMsgLink) {
+  NS_ENSURE_ARG_POINTER(aShowComposeMsgLink);
+  *aShowComposeMsgLink = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsRssService::GetFoldersCreatedAsync(bool* aAsyncCreation) {
+  NS_ENSURE_ARG_POINTER(aAsyncCreation);
+  *aAsyncCreation = false;
+  return NS_OK;
+}
diff --git a/comm/mailnews/local/src/nsRssService.h b/comm/mailnews/local/src/nsRssService.h
new file mode 100644
index 0000000000..490351d61e
--- /dev/null
+++ b/comm/mailnews/local/src/nsRssService.h
@@ -0,0 +1,23 @@
+/* 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 nsRssService_h___
+#define nsRssService_h___
+
+#include "nsIRssService.h"
+#include "nsIMsgProtocolInfo.h"
+
+class nsRssService : public nsIMsgProtocolInfo, public nsIRssService {
+ public:
+  nsRssService();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIRSSSERVICE
+  NS_DECL_NSIMSGPROTOCOLINFO
+
+ private:
+  virtual ~nsRssService();
+};
+
+#endif /* nsRssService_h___ */