Issue #1258 - Part 1: Import mailnews, ldap, and mork from comm-esr52.9.1

101 files changed, 45455 insertions, 0 deletions

diff --git a/mailnews/base/src/MailNewsDLF.cpp b/mailnews/base/src/MailNewsDLF.cpp
new file mode 100644
index 000000000..839d86006
--- /dev/null
+++ b/mailnews/base/src/MailNewsDLF.cpp
@@ -0,0 +1,101 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsCOMPtr.h"
+#include "MailNewsDLF.h"
+#include "nsIChannel.h"
+#include "plstr.h"
+#include "nsStringGlue.h"
+#include "nsICategoryManager.h"
+#include "nsIServiceManager.h"
+#include "nsIStreamConverterService.h"
+#include "nsIStreamListener.h"
+#include "nsNetCID.h"
+#include "nsMsgUtils.h"
+
+namespace mozilla {
+namespace mailnews {
+NS_IMPL_ISUPPORTS(MailNewsDLF, nsIDocumentLoaderFactory)
+
+MailNewsDLF::MailNewsDLF()
+{
+}
+
+MailNewsDLF::~MailNewsDLF()
+{
+}
+
+NS_IMETHODIMP
+MailNewsDLF::CreateInstance(const char* aCommand,
+                            nsIChannel* aChannel,
+                            nsILoadGroup* aLoadGroup,
+                            const nsACString& aContentType,
+                            nsIDocShell* aContainer,
+                            nsISupports* aExtraInfo,
+                            nsIStreamListener** aDocListener,
+                            nsIContentViewer** aDocViewer)
+{
+  nsresult rv;
+
+  bool viewSource = (PL_strstr(PromiseFlatCString(aContentType).get(),
+                               "view-source") != 0);
+
+  aChannel->SetContentType(NS_LITERAL_CSTRING(TEXT_HTML));
+
+  // Get the HTML category
+  nsCOMPtr<nsICategoryManager> catMan(
+    do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString contractID;
+  rv = catMan->GetCategoryEntry("Gecko-Content-Viewers", TEXT_HTML,
+                                getter_Copies(contractID));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDocumentLoaderFactory> factory(do_GetService(contractID.get(),
+                                             &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIStreamListener> listener;
+
+  if (viewSource) {
+    rv = factory->CreateInstance("view-source", aChannel, aLoadGroup,
+                                 NS_LITERAL_CSTRING(TEXT_HTML "; x-view-type=view-source"),
+                                 aContainer, aExtraInfo, getter_AddRefs(listener),
+                                 aDocViewer);
+  } else {
+    rv = factory->CreateInstance("view", aChannel, aLoadGroup, NS_LITERAL_CSTRING(TEXT_HTML),
+                                 aContainer, aExtraInfo, getter_AddRefs(listener),
+                                 aDocViewer);
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIStreamConverterService> scs(
+    do_GetService(NS_STREAMCONVERTERSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return scs->AsyncConvertData(MESSAGE_RFC822, TEXT_HTML, listener, aChannel,
+                               aDocListener);
+}
+
+NS_IMETHODIMP
+MailNewsDLF::CreateInstanceForDocument(nsISupports* aContainer,
+                                       nsIDocument* aDocument,
+                                       const char* aCommand,
+                                       nsIContentViewer** aDocViewer)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MailNewsDLF::CreateBlankDocument(nsILoadGroup* aLoadGroup,
+                                 nsIPrincipal* aPrincipal,
+                                 nsIDocument** aDocument)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+}
+}
diff --git a/mailnews/base/src/MailNewsDLF.h b/mailnews/base/src/MailNewsDLF.h
new file mode 100644
index 000000000..b0bd77b30
--- /dev/null
+++ b/mailnews/base/src/MailNewsDLF.h
@@ -0,0 +1,38 @@
+/* -*- 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 MailNewsDLF_h__
+#define MailNewsDLF_h__
+
+#include "nsIDocumentLoaderFactory.h"
+#include "nsMimeTypes.h"
+#include "nsMsgBaseCID.h"
+
+namespace mozilla {
+namespace mailnews {
+
+/*
+ * This factory is a thin wrapper around the text/html loader factory. All it
+ * does is convert message/rfc822 to text/html and delegate the rest of the
+ * work to the text/html factory.
+ */
+class MailNewsDLF : public nsIDocumentLoaderFactory
+{
+public:
+  MailNewsDLF();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIDOCUMENTLOADERFACTORY
+
+private:
+  virtual ~MailNewsDLF();
+};
+}
+}
+
+#define MAILNEWSDLF_CATEGORIES \
+  { "Gecko-Content-Viewers", MESSAGE_RFC822, NS_MAILNEWSDLF_CONTRACTID }, \
+
+#endif
diff --git a/mailnews/base/src/MailnewsLoadContextInfo.cpp b/mailnews/base/src/MailnewsLoadContextInfo.cpp
new file mode 100644
index 000000000..89aa56672
--- /dev/null
+++ b/mailnews/base/src/MailnewsLoadContextInfo.cpp
@@ -0,0 +1,55 @@
+/* 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/. */
+
+// This was copied from netwerk/base/LoadContextInfo.cpp
+
+#include "MailnewsLoadContextInfo.h"
+
+#include "mozilla/dom/ToJSValue.h"
+#include "nsIChannel.h"
+#include "nsILoadContext.h"
+#include "nsIWebNavigation.h"
+#include "nsNetUtil.h"
+
+// MailnewsLoadContextInfo
+
+NS_IMPL_ISUPPORTS(MailnewsLoadContextInfo, nsILoadContextInfo)
+
+MailnewsLoadContextInfo::MailnewsLoadContextInfo(bool aIsPrivate, bool aIsAnonymous, mozilla::NeckoOriginAttributes aOriginAttributes)
+  : mIsPrivate(aIsPrivate)
+  , mIsAnonymous(aIsAnonymous)
+  , mOriginAttributes(aOriginAttributes)
+{
+  mOriginAttributes.SyncAttributesWithPrivateBrowsing(mIsPrivate);
+}
+
+MailnewsLoadContextInfo::~MailnewsLoadContextInfo()
+{
+}
+
+NS_IMETHODIMP MailnewsLoadContextInfo::GetIsPrivate(bool *aIsPrivate)
+{
+  *aIsPrivate = mIsPrivate;
+  return NS_OK;
+}
+
+NS_IMETHODIMP MailnewsLoadContextInfo::GetIsAnonymous(bool *aIsAnonymous)
+{
+  *aIsAnonymous = mIsAnonymous;
+  return NS_OK;
+}
+
+mozilla::NeckoOriginAttributes const* MailnewsLoadContextInfo::OriginAttributesPtr()
+{
+  return &mOriginAttributes;
+}
+
+NS_IMETHODIMP MailnewsLoadContextInfo::GetOriginAttributes(JSContext *aCx,
+                                                   JS::MutableHandle<JS::Value> aVal)
+{
+  if (NS_WARN_IF(!ToJSValue(aCx, mOriginAttributes, aVal))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
diff --git a/mailnews/base/src/MailnewsLoadContextInfo.h b/mailnews/base/src/MailnewsLoadContextInfo.h
new file mode 100644
index 000000000..6a127bf4a
--- /dev/null
+++ b/mailnews/base/src/MailnewsLoadContextInfo.h
@@ -0,0 +1,32 @@
+/* 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/. */
+
+// This was copied from netwerk/base/LoadContextInfo.h
+
+#ifndef MailnewsLoadContextInfo_h__
+#define MailnewsLoadContextInfo_h__
+
+#include "nsILoadContextInfo.h"
+
+class nsIChannel;
+class nsILoadContext;
+
+class MailnewsLoadContextInfo : public nsILoadContextInfo
+{
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSILOADCONTEXTINFO
+
+  MailnewsLoadContextInfo(bool aIsPrivate, bool aIsAnonymous, mozilla::NeckoOriginAttributes aOriginAttributes);
+
+private:
+  virtual ~MailnewsLoadContextInfo();
+
+protected:
+  bool mIsPrivate : 1;
+  bool mIsAnonymous : 1;
+  mozilla::NeckoOriginAttributes mOriginAttributes;
+};
+
+#endif
diff --git a/mailnews/base/src/folderLookupService.js b/mailnews/base/src/folderLookupService.js
new file mode 100644
index 000000000..9c64b5ef0
--- /dev/null
+++ b/mailnews/base/src/folderLookupService.js
@@ -0,0 +1,99 @@
+/* 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/. */
+
+/**
+ * This module implements the folder lookup service. Presently, this uses RDF as
+ * the backing store, but the intent is that this will eventually become the
+ * authoritative map.
+ */
+
+"use strict";
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+function isValidFolder(folder) {
+  // RDF is liable to return folders that don't exist, and we may be working
+  // with a deleted folder but we're still holding on to the reference. For
+  // valid folders, one of two scenarios is true: either the folder has a parent
+  // (the deletion code clears the parent to indicate its nonvalidity), or the
+  // folder is a root folder of some server. Getting the root folder may throw
+  // an exception if we attempted to create a server that doesn't exist, so we
+  // need to guard for that error.
+  try {
+    return folder.parent != null || folder.rootFolder == folder;
+  } catch (e) {
+    return false;
+  }
+}
+
+// This insures that the service is only created once
+var gCreated = false;
+
+function folderLookupService() {
+  if (gCreated)
+    throw Cr.NS_ERROR_ALREADY_INITIALIZED;
+  this._map = new Map();
+  gCreated = true;
+}
+folderLookupService.prototype = {
+  // XPCOM registration stuff
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIFolderLookupService]),
+  classID: Components.ID("{a30be08c-afc8-4fed-9af7-79778a23db23}"),
+
+  // nsIFolderLookupService impl
+  getFolderForURL: function (aUrl) {
+    let folder = null;
+    // First, see if the folder is in our cache.
+    if (this._map.has(aUrl)) {
+      let valid = false;
+      try {
+        folder = this._map.get(aUrl).QueryReferent(Ci.nsIMsgFolder);
+        valid = isValidFolder(folder);
+      } catch (e) {
+        // The object was deleted, so it's not valid
+      }
+
+      if (valid)
+        return folder;
+
+      // Don't keep around invalid folders.
+      this._map.delete(aUrl);
+      folder = null;
+    }
+
+    // If we get here, then the folder was not in our map. It could be that the
+    // folder was created by somebody else, so try to find that folder.
+    // For now, we use the RDF service, since it results in minimal changes. But
+    // RDF has a tendency to create objects without checking to see if they
+    // really exist---use the parent property to see if the folder is a real
+    // folder.
+    if (folder == null) {
+      let rdf = Cc["@mozilla.org/rdf/rdf-service;1"]
+                  .getService(Ci.nsIRDFService);
+      try {
+        folder = rdf.GetResource(aUrl)
+                    .QueryInterface(Ci.nsIMsgFolder);
+      } catch (e) {
+        // If the QI fails, then we somehow picked up an RDF resource that isn't
+        // a folder. Return null in this case.
+        return null;
+      }
+    }
+    if (!isValidFolder(folder))
+      return null;
+
+    // Add the new folder to our map. Store a weak reference instead, so that
+    // the folder can be closed when necessary.
+    let weakRef = folder.QueryInterface(Ci.nsISupportsWeakReference)
+                        .GetWeakReference();
+    this._map.set(aUrl, weakRef);
+    return folder;
+  },
+};
+
+var NSGetFactory = XPCOMUtils.generateNSGetFactory([folderLookupService]);
diff --git a/mailnews/base/src/moz.build b/mailnews/base/src/moz.build
new file mode 100644
index 000000000..b84839e9e
--- /dev/null
+++ b/mailnews/base/src/moz.build
@@ -0,0 +1,82 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXPORTS += [
+    'nsMailDirServiceDefs.h',
+    'nsMsgRDFDataSource.h',
+    'nsMsgRDFUtils.h',
+]
+
+SOURCES += [
+    'MailNewsDLF.cpp',
+    'MailnewsLoadContextInfo.cpp',
+    'nsCidProtocolHandler.cpp',
+    'nsCopyMessageStreamListener.cpp',
+    'nsMailDirProvider.cpp',
+    'nsMessenger.cpp',
+    'nsMessengerBootstrap.cpp',
+    'nsMessengerContentHandler.cpp',
+    'nsMsgAccount.cpp',
+    'nsMsgAccountManager.cpp',
+    'nsMsgAccountManagerDS.cpp',
+    'nsMsgBiffManager.cpp',
+    'nsMsgContentPolicy.cpp',
+    'nsMsgCopyService.cpp',
+    'nsMsgDBView.cpp',
+    'nsMsgFolderCache.cpp',
+    'nsMsgFolderCacheElement.cpp',
+    'nsMsgFolderCompactor.cpp',
+    'nsMsgFolderDataSource.cpp',
+    'nsMsgFolderNotificationService.cpp',
+    'nsMsgGroupThread.cpp',
+    'nsMsgGroupView.cpp',
+    'nsMsgMailSession.cpp',
+    'nsMsgOfflineManager.cpp',
+    'nsMsgProgress.cpp',
+    'nsMsgPurgeService.cpp',
+    'nsMsgQuickSearchDBView.cpp',
+    'nsMsgRDFDataSource.cpp',
+    'nsMsgRDFUtils.cpp',
+    'nsMsgSearchDBView.cpp',
+    'nsMsgServiceProvider.cpp',
+    'nsMsgSpecialViews.cpp',
+    'nsMsgStatusFeedback.cpp',
+    'nsMsgTagService.cpp',
+    'nsMsgThreadedDBView.cpp',
+    'nsMsgWindow.cpp',
+    'nsMsgXFViewThread.cpp',
+    'nsMsgXFVirtualFolderDBView.cpp',
+    'nsSpamSettings.cpp',
+    'nsStatusBarBiffManager.cpp',
+    'nsSubscribableServer.cpp',
+    'nsSubscribeDataSource.cpp',
+]
+
+if CONFIG['NS_PRINTING']:
+    SOURCES += ['nsMsgPrintEngine.cpp']
+
+if CONFIG['OS_ARCH'] == 'WINNT':
+    SOURCES += ['nsMessengerWinIntegration.cpp']
+
+if CONFIG['MOZ_WIDGET_TOOLKIT'] in ('gtk2', 'gtk3', 'qt'):
+    SOURCES += ['nsMessengerUnixIntegration.cpp']
+elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    SOURCES += ['nsMessengerOSXIntegration.mm']
+
+EXTRA_COMPONENTS += [
+    'folderLookupService.js',
+    'msgAsyncPrompter.js',
+    'msgBase.manifest',
+    'msgOAuth2Module.js',
+    'newMailNotificationService.js',
+    'nsMailNewsCommandLineHandler.js',
+]
+
+EXTRA_JS_MODULES += [
+    'virtualFolderWrapper.js',
+]
+
+FINAL_LIBRARY = 'mail'
+
diff --git a/mailnews/base/src/msgAsyncPrompter.js b/mailnews/base/src/msgAsyncPrompter.js
new file mode 100644
index 000000000..58b5288e9
--- /dev/null
+++ b/mailnews/base/src/msgAsyncPrompter.js
@@ -0,0 +1,126 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+Components.utils.import("resource://gre/modules/Task.jsm");
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource:///modules/gloda/log4moz.js");
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+
+function runnablePrompter(asyncPrompter, hashKey) {
+  this._asyncPrompter = asyncPrompter;
+  this._hashKey = hashKey;
+}
+
+runnablePrompter.prototype = {
+  _asyncPrompter: null,
+  _hashKey: null,
+
+  run: Task.async(function *() {
+    yield Services.logins.initializationPromise;
+    this._asyncPrompter._log.debug("Running prompt for " + this._hashKey);
+    let prompter = this._asyncPrompter._pendingPrompts[this._hashKey];
+    let ok = false;
+    try {
+      ok = prompter.first.onPromptStart();
+    }
+    catch (ex) {
+      Components.utils.reportError("runnablePrompter:run: " + ex + "\n");
+    }
+
+    delete this._asyncPrompter._pendingPrompts[this._hashKey];
+
+    for (var consumer of prompter.consumers) {
+      try {
+        if (ok)
+          consumer.onPromptAuthAvailable();
+        else
+          consumer.onPromptCanceled();
+      }
+      catch (ex) {
+        // Log the error for extension devs and others to pick up.
+        Components.utils.reportError("runnablePrompter:run: consumer.onPrompt* reported an exception: " + ex + "\n");
+      }
+    }
+    this._asyncPrompter._asyncPromptInProgress--;
+
+    this._asyncPrompter._log.debug("Finished running prompter for " + this._hashKey);
+    this._asyncPrompter._doAsyncAuthPrompt();
+  })
+};
+
+function msgAsyncPrompter() {
+  this._pendingPrompts = {};
+  // By default, only log warnings to the error console and errors to dump().
+  // You can use the preferences:
+  //   msgAsyncPrompter.logging.console
+  //   msgAsyncPrompter.logging.dump
+  // To change this up.  Values should be one of:
+  //   Fatal/Error/Warn/Info/Config/Debug/Trace/All
+  this._log = Log4Moz.getConfiguredLogger("msgAsyncPrompter",
+                                          Log4Moz.Level.Warn,
+                                          Log4Moz.Level.Warn);
+}
+
+msgAsyncPrompter.prototype = {
+  classID: Components.ID("{49b04761-23dd-45d7-903d-619418a4d319}"),
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIMsgAsyncPrompter]),
+
+  _pendingPrompts: null,
+  _asyncPromptInProgress: 0,
+  _log: null,
+
+  queueAsyncAuthPrompt: function(aKey, aJumpQueue, aCaller) {
+    if (aKey in this._pendingPrompts) {
+      this._log.debug("Prompt bound to an existing one in the queue, key: " + aKey);
+      this._pendingPrompts[aKey].consumers.push(aCaller);
+      return;
+    }
+
+    this._log.debug("Adding new prompt to the queue, key: " + aKey);
+    let asyncPrompt = {
+      first: aCaller,
+      consumers: []
+    };
+
+    this._pendingPrompts[aKey] = asyncPrompt;
+    if (aJumpQueue) {
+      this._asyncPromptInProgress++;
+
+      this._log.debug("Forcing runnablePrompter for " + aKey);
+
+      let runnable = new runnablePrompter(this, aKey);
+      Services.tm.mainThread.dispatch(runnable, Ci.nsIThread.DISPATCH_NORMAL);
+    }
+    else
+      this._doAsyncAuthPrompt();
+  },
+
+  _doAsyncAuthPrompt: function() {
+    if (this._asyncPromptInProgress > 0) {
+      this._log.debug("_doAsyncAuthPrompt bypassed - prompt already in progress");
+      return;
+    }
+
+    // Find the first prompt key we have in the queue.
+    let hashKey = null;
+    for (hashKey in this._pendingPrompts)
+      break;
+
+    if (!hashKey)
+      return;
+
+    this._asyncPromptInProgress++;
+
+    this._log.debug("Dispatching runnablePrompter for " + hashKey);
+
+    let runnable = new runnablePrompter(this, hashKey);
+    Services.tm.mainThread.dispatch(runnable, Ci.nsIThread.DISPATCH_NORMAL);
+  }
+};
+
+var components = [msgAsyncPrompter];
+var NSGetFactory = XPCOMUtils.generateNSGetFactory(components);
diff --git a/mailnews/base/src/msgBase.manifest b/mailnews/base/src/msgBase.manifest
new file mode 100644
index 000000000..e7af18bdf
--- /dev/null
+++ b/mailnews/base/src/msgBase.manifest
@@ -0,0 +1,12 @@
+component {49b04761-23dd-45d7-903d-619418a4d319} msgAsyncPrompter.js
+contract @mozilla.org/messenger/msgAsyncPrompter;1 {49b04761-23dd-45d7-903d-619418a4d319}
+component {2f86d554-f9d9-4e76-8eb7-243f047333ee} nsMailNewsCommandLineHandler.js
+contract @mozilla.org/commandlinehandler/general-startup;1?type=mail {2f86d554-f9d9-4e76-8eb7-243f047333ee}
+category command-line-handler m-mail @mozilla.org/commandlinehandler/general-startup;1?type=mail
+component {740880E6-E299-4165-B82F-DF1DCAB3AE22} newMailNotificationService.js
+contract @mozilla.org/newMailNotificationService;1 {740880E6-E299-4165-B82F-DF1DCAB3AE22}
+category profile-after-change NewMailNotificationService @mozilla.org/newMailNotificationService;1 
+component {a30be08c-afc8-4fed-9af7-79778a23db23} folderLookupService.js
+contract @mozilla.org/mail/folder-lookup;1 {a30be08c-afc8-4fed-9af7-79778a23db23}
+component {b63d8e4c-bf60-439b-be0e-7c9f67291042} msgOAuth2Module.js
+contract @mozilla.org/mail/oauth2-module;1 {b63d8e4c-bf60-439b-be0e-7c9f67291042}
diff --git a/mailnews/base/src/msgOAuth2Module.js b/mailnews/base/src/msgOAuth2Module.js
new file mode 100644
index 000000000..407ab0519
--- /dev/null
+++ b/mailnews/base/src/msgOAuth2Module.js
@@ -0,0 +1,150 @@
+/* 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/. */
+
+"use strict";
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/OAuth2.jsm");
+Components.utils.import("resource://gre/modules/OAuth2Providers.jsm");
+Components.utils.import("resource://gre/modules/Preferences.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+function OAuth2Module() {
+  this._refreshToken = '';
+}
+OAuth2Module.prototype = {
+  // XPCOM registration stuff
+  QueryInterface: XPCOMUtils.generateQI([Ci.msgIOAuth2Module]),
+  classID: Components.ID("{b63d8e4c-bf60-439b-be0e-7c9f67291042}"),
+
+  _loadOAuthClientDetails(aIssuer) {
+    let details = OAuth2Providers.getIssuerDetails(aIssuer);
+    if (details)
+      [this._appKey, this._appSecret, this._authURI, this._tokenURI] = details;
+    else
+      throw Cr.NS_ERROR_INVALID_ARGUMENT;
+  },
+  initFromSmtp(aServer) {
+    return this._initPrefs("mail.smtpserver." + aServer.key + ".",
+      aServer.username, aServer.hostname);
+  },
+  initFromMail(aServer) {
+    return this._initPrefs("mail.server." + aServer.key + ".",
+      aServer.username, aServer.realHostName);
+  },
+  _initPrefs(root, aUsername, aHostname) {
+    // Load all of the parameters from preferences.
+    let issuer = Preferences.get(root + "oauth2.issuer", "");
+    let scope = Preferences.get(root + "oauth2.scope", "");
+
+    // These properties are absolutely essential to OAuth2 support. If we don't
+    // have them, we don't support OAuth2.
+    if (!issuer || !scope) {
+      // Since we currently only support gmail, init values if server matches.
+      let details = OAuth2Providers.getHostnameDetails(aHostname);
+      if (details)
+      {
+        [issuer, scope] = details;
+        Preferences.set(root + "oauth2.issuer", issuer);
+        Preferences.set(root + "oauth2.scope", scope);
+      }
+      else
+        return false;
+    }
+
+    // Find the app key we need for the OAuth2 string. Eventually, this should
+    // be using dynamic client registration, but there are no current
+    // implementations that we can test this with.
+    this._loadOAuthClientDetails(issuer);
+
+    // Username is needed to generate the XOAUTH2 string.
+    this._username = aUsername;
+    // LoginURL is needed to save the refresh token in the password manager.
+    this._loginUrl = "oauth://" + issuer;
+    // We use the scope to indicate the realm.
+    this._scope = scope;
+
+    // Define the OAuth property and store it.
+    this._oauth = new OAuth2(this._authURI, scope, this._appKey,
+      this._appSecret);
+    this._oauth.authURI = this._authURI;
+    this._oauth.tokenURI = this._tokenURI;
+
+    // Try hinting the username...
+    this._oauth.extraAuthParams = [
+      ["login_hint", aUsername]
+    ];
+
+    // Set the window title to something more useful than "Unnamed"
+    this._oauth.requestWindowTitle =
+      Services.strings.createBundle("chrome://messenger/locale/messenger.properties")
+                      .formatStringFromName("oauth2WindowTitle",
+                                            [aUsername, aHostname], 2);
+
+    // This stores the refresh token in the login manager.
+    Object.defineProperty(this._oauth, "refreshToken", {
+      get: () => this.refreshToken,
+      set: (token) => this.refreshToken = token
+    });
+
+    return true;
+  },
+
+  get refreshToken() {
+    let loginMgr = Cc["@mozilla.org/login-manager;1"]
+                     .getService(Ci.nsILoginManager);
+    let logins = loginMgr.findLogins({}, this._loginUrl, null, this._scope);
+    for (let login of logins) {
+      if (login.username == this._username)
+        return login.password;
+    }
+    return '';
+  },
+  set refreshToken(token) {
+    let loginMgr = Cc["@mozilla.org/login-manager;1"]
+                     .getService(Ci.nsILoginManager);
+
+    // Check if we already have a login with this username, and modify the
+    // password on that, if we do.
+    let logins = loginMgr.findLogins({}, this._loginUrl, null, this._scope);
+    for (let login of logins) {
+      if (login.username == this._username) {
+        if (token) {
+          let propBag = Cc["@mozilla.org/hash-property-bag;1"].
+                        createInstance(Ci.nsIWritablePropertyBag);
+          propBag.setProperty("password", token);
+          loginMgr.modifyLogin(login, propBag);
+        }
+        else
+          loginMgr.removeLogin(login);
+        return token;
+      }
+    }
+
+    // Otherwise, we need a new login, so create one and fill it in.
+    let login = Cc["@mozilla.org/login-manager/loginInfo;1"]
+                  .createInstance(Ci.nsILoginInfo);
+    login.init(this._loginUrl, null, this._scope, this._username, token,
+      '', '');
+    loginMgr.addLogin(login);
+    return token;
+  },
+
+  connect(aWithUI, aListener) {
+    this._oauth.connect(() => aListener.onSuccess(this._oauth.accessToken),
+                        x => aListener.onFailure(x),
+                        aWithUI, false);
+  },
+
+  buildXOAuth2String() {
+    return btoa("user=" + this._username + "\x01auth=Bearer " +
+      this._oauth.accessToken + "\x01\x01");
+  },
+};
+
+var NSGetFactory = XPCOMUtils.generateNSGetFactory([OAuth2Module]);
diff --git a/mailnews/base/src/newMailNotificationService.js b/mailnews/base/src/newMailNotificationService.js
new file mode 100644
index 000000000..4fe72f554
--- /dev/null
+++ b/mailnews/base/src/newMailNotificationService.js
@@ -0,0 +1,377 @@
+/* -*- Mode: Java; 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/. */
+
+/* platform-independent code to count new and unread messages and pass the information to
+ * platform-specific notification modules
+ *
+ * Logging for this module uses the TB version of log4moz. Default logging is at the Warn
+ * level. Other possibly interesting messages are at Error, Info and Debug. To configure, set the
+ * preferences "mail.notification.logging.console" (for the error console) or
+ * "mail.notification.logging.dump" (for stderr) to the string indicating the level you want.
+ */
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cu = Components.utils;
+
+Cu.import("resource:///modules/gloda/log4moz.js");
+Cu.import("resource:///modules/iteratorUtils.jsm");
+Cu.import("resource:///modules/mailServices.js");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+var NMNS = Ci.mozINewMailNotificationService;
+
+var countInboxesPref = "mail.notification.count.inbox_only";
+// Old name for pref
+var countNewMessagesPref = "mail.biff.use_new_count_in_mac_dock";
+// When we go cross-platform we should migrate to
+// const countNewMessagesPref = "mail.notification.count.new";
+
+// Helper function to retrieve a boolean preference with a default
+function getBoolPref(pref, defaultValue) {
+  try {
+    return Services.prefs.getBoolPref(pref);
+  }
+  catch(e) {
+    return defaultValue;
+  }
+}
+
+
+// constructor
+function NewMailNotificationService() {
+  this._mUnreadCount = 0;
+  this._mNewCount = 0;
+  this._listeners = [];
+  this.wrappedJSObject = this;
+
+  this._log = Log4Moz.getConfiguredLogger("mail.notification",
+                                          Log4Moz.Level.Warn,
+                                          Log4Moz.Level.Warn,
+                                          Log4Moz.Level.Warn);
+
+  // Listen for mail-startup-done to do the rest of our setup after folders are initialized
+  Services.obs.addObserver(this, "mail-startup-done", false);
+}
+
+NewMailNotificationService.prototype = {
+  classDescription: "Maintain counts of new and unread messages",
+  classID:              Components.ID("{740880E6-E299-4165-B82F-DF1DCAB3AE22}"),
+  contractID:           "@mozilla.org/newMailNotificationService;1",
+  QueryInterface:       XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsIFolderListener, Ci.mozINewMailNotificationService]),
+  _xpcom_factory: XPCOMUtils.generateSingletonFactory(NewMailNotificationService),
+  
+  _mUnreadCount: 0,
+  _mNewCount: 0,
+  _listeners: null,
+  _log: null,
+
+  get countNew() {
+    return getBoolPref(countNewMessagesPref, false);
+  },
+
+  observe: function NMNS_Observe(aSubject, aTopic, aData) {
+    // Set up to catch updates to unread count
+    this._log.info("NMNS_Observe: " + aTopic);
+
+    try {
+      if (aTopic == "mail-startup-done") {
+        try {
+          Services.obs.removeObserver(this, "mail-startup-done");
+        }
+        catch (e) {
+          this._log.error("NMNS_Observe: unable to deregister mail-startup-done listener: " + e);
+        }
+        Services.obs.addObserver(this, "profile-before-change", false);
+        MailServices.mailSession.AddFolderListener(this, Ci.nsIFolderListener.intPropertyChanged |
+                                                         Ci.nsIFolderListener.added |
+                                                         Ci.nsIFolderListener.removed |
+                                                         Ci.nsIFolderListener.propertyFlagChanged);
+        this._initUnreadCount();
+      }
+      else if (aTopic == "profile-before-change") {
+        try {
+          MailServices.mailSession.RemoveFolderListener(this);
+          Services.obs.removeObserver(this, "profile-before-change");
+        }
+        catch (e) {
+          this._log.error("NMNS_Observe: unable to deregister listeners at shutdown: " + e);
+        }
+      }
+    } catch (error) {
+      this._log.error("NMNS_Observe failed: " + error);
+    }
+  },
+
+  _initUnreadCount: function NMNS_initUnreadCount() {
+    let total = 0;
+    let allServers = MailServices.accounts.allServers;
+    for (let i = 0; i < allServers.length; i++) {
+      let currentServer = allServers.queryElementAt(i, Ci.nsIMsgIncomingServer);
+      this._log.debug("NMNS_initUnread: server " + currentServer.prettyName + " type " + currentServer.type);
+      // Don't bother counting RSS or NNTP servers
+      let type = currentServer.type;
+      if (type == "rss" || type == "nntp")
+        continue;
+
+      let rootFolder = currentServer.rootFolder;
+      if (rootFolder) {
+        total += this._countUnread(rootFolder);
+      }
+    }
+    this._mUnreadCount = total;
+    if (!this.countNew) {
+      this._log.info("NMNS_initUnread notifying listeners: " + total + " total unread messages");
+      this._notifyListeners(NMNS.count, "onCountChanged", total);
+    }
+  },
+
+  // Count all the unread messages below the given folder
+  _countUnread: function NMNS_countUnread(folder) {
+    this._log.trace("NMNS_countUnread: parent folder " + folder.URI);
+    let unreadCount = 0;
+
+    if (this.confirmShouldCount(folder)) {
+      let count = folder.getNumUnread(false);
+      this._log.debug("NMNS_countUnread: folder " + folder.URI + ", " + count + " unread");
+      if (count > 0)
+        unreadCount += count;
+    }
+
+    let allFolders = folder.descendants;
+    for (let folder in fixIterator(allFolders, Ci.nsIMsgFolder)) {
+      if (this.confirmShouldCount(folder)) {
+        let count = folder.getNumUnread(false);
+        this._log.debug("NMNS_countUnread: folder " + folder.URI + ", " + count + " unread");
+        if (count > 0)
+          unreadCount += count;
+      }
+    }
+    return unreadCount;
+  },
+
+  // Filter out special folders and then ask for observers to see if
+  // we should monitor unread messages in this folder
+  confirmShouldCount: function NMNS_confirmShouldCount(aFolder) {
+    let shouldCount = Cc['@mozilla.org/supports-PRBool;1'].createInstance(Ci.nsISupportsPRBool);
+    shouldCount.data = true;
+    this._log.trace("NMNS_confirmShouldCount: folder " + aFolder.URI + " flags " + aFolder.flags);
+    let srv = null;
+
+    // If it's not a mail folder we don't count it by default
+    if (!(aFolder.flags & Ci.nsMsgFolderFlags.Mail))
+      shouldCount.data = false;
+
+    // For whatever reason, RSS folders have the 'Mail' flag
+    else if ((srv = aFolder.server) && (srv.type == "rss"))
+      shouldCount.data = false;
+
+    // If it's a special folder *other than the inbox* we don't count it by default
+    else if ((aFolder.flags & Ci.nsMsgFolderFlags.SpecialUse)
+        && !(aFolder.flags & Ci.nsMsgFolderFlags.Inbox))
+      shouldCount.data = false;
+
+    else if (aFolder.flags & Ci.nsMsgFolderFlags.Virtual)
+      shouldCount.data = false;
+
+    // if we're only counting inboxes and it's not an inbox...
+    else
+      try {
+      // If we can't get this pref, just leave it as the default
+      let onlyCountInboxes = Services.prefs.getBoolPref(countInboxesPref);
+      if (onlyCountInboxes && !(aFolder.flags & Ci.nsMsgFolderFlags.Inbox))
+        shouldCount.data = false;
+      } catch (error) {}
+
+    this._log.trace("NMNS_confirmShouldCount: before observers " + shouldCount.data);
+    Services.obs.notifyObservers(shouldCount, "before-count-unread-for-folder", aFolder.URI);
+    this._log.trace("NMNS_confirmShouldCount: after observers " + shouldCount.data);
+
+    return shouldCount.data;
+  },
+
+  OnItemIntPropertyChanged: function NMNS_OnItemIntPropertyChanged(folder, property, oldValue, newValue) {
+    try {
+      if (property == "FolderSize")
+        return;
+      this._log.trace("NMNS_OnItemIntPropertyChanged: folder " + folder.URI + " " + property + " " + oldValue + " " + newValue);
+      if (property == "BiffState") {
+        this._biffStateChanged(folder, oldValue, newValue);
+      }
+      else if (property == "TotalUnreadMessages") {
+        this._updateUnreadCount(folder, oldValue, newValue);
+      }
+      else if (property == "NewMailReceived") {
+        this._newMailReceived(folder, oldValue, newValue);
+      }
+    } catch (error) {
+      this._log.error("NMNS_OnItemIntPropertyChanged: exception " + error);
+    }
+  },
+
+  _biffStateChanged: function NMNS_biffStateChanged(folder, oldValue, newValue) {
+    if (newValue == Ci.nsIMsgFolder.nsMsgBiffState_NewMail) {
+      if (folder.server && !folder.server.performingBiff) {
+        this._log.debug("NMNS_biffStateChanged: folder " + folder.URI + " notified, but server not performing biff");
+        return;
+      }
+
+      // Biff notifications come in for the top level of the server, we need to look for
+      // the folder that actually contains the new mail
+
+      let allFolders = folder.descendants;
+      let numFolders = allFolders.length;
+
+      this._log.trace("NMNS_biffStateChanged: folder " + folder.URI + " New mail, " + numFolders + " subfolders");
+      let newCount = 0;
+
+      if (this.confirmShouldCount(folder)) {
+        let folderNew = folder.getNumNewMessages(false);
+        this._log.debug("NMNS_biffStateChanged: folder " + folder.URI + " new messages: " + folderNew);
+        if (folderNew > 0)
+          newCount += folderNew;
+      }
+
+      for (let folder in fixIterator(allFolders, Ci.nsIMsgFolder)) {
+        if (this.confirmShouldCount(folder)) {
+          let folderNew = folder.getNumNewMessages(false);
+          this._log.debug("NMNS_biffStateChanged: folder " + folder.URI + " new messages: " + folderNew);
+          if (folderNew > 0)
+            newCount += folderNew;
+        }
+      }
+      if (newCount > 0) {
+        this._mNewCount += newCount;
+        this._log.debug("NMNS_biffStateChanged: " + folder.URI + " New mail count " + this._mNewCount);
+        if (this.countNew)
+          this._notifyListeners(NMNS.count, "onCountChanged", this._mNewCount);
+      }
+    }
+    else if (newValue == Ci.nsIMsgFolder.nsMsgBiffState_NoMail) {
+      // Dodgy - when any folder tells us it has no mail, clear all unread mail
+      this._mNewCount = 0;
+      this._log.debug("NMNS_biffStateChanged: " + folder.URI + " New mail count 0");
+      if (this.countNew)
+        this._notifyListeners(NMNS.count, "onCountChanged", this._mNewCount);
+    }
+  },
+
+  _newMailReceived: function NMNS_newMailReceived(folder, oldValue, newValue) {
+    if (!this.confirmShouldCount(folder))
+      return;
+
+    if (!oldValue || (oldValue < 0))
+      oldValue = 0;
+    let oldTotal = this._mNewCount;
+    this._mNewCount += (newValue - oldValue);
+    this._log.debug("NMNS_newMailReceived: " + folder.URI +
+                    " Old folder " + oldValue + " New folder " + newValue +
+                    " Old total " + oldTotal + " New total " + this._mNewCount);
+    if (this.countNew)
+      this._notifyListeners(NMNS.count, "onCountChanged", this._mNewCount);
+  },
+
+  _updateUnreadCount: function NMNS_updateUnreadCount(folder, oldValue, newValue) {
+    if (!this.confirmShouldCount(folder))
+      return;
+
+    // treat "count unknown" as zero
+    if (oldValue < 0)
+      oldValue = 0;
+    if (newValue < 0)
+      newValue = 0;
+
+    this._mUnreadCount += (newValue - oldValue);
+    if (!this.countNew) {
+      this._log.info("NMNS_updateUnreadCount notifying listeners: unread count " + this._mUnreadCount);
+      this._notifyListeners(NMNS.count, "onCountChanged", this._mUnreadCount);
+    }
+  },
+
+  OnItemAdded: function NMNS_OnItemAdded(parentItem, item) {
+    if (item instanceof Ci.nsIMsgDBHdr) {
+      if (this.confirmShouldCount(item.folder)) {
+        this._log.trace("NMNS_OnItemAdded: item " + item.folder.getUriForMsg(item) + " added to " + item.folder.folderURL);
+      }
+    }
+  },
+
+  OnItemPropertyFlagChanged: function NMNS_OnItemPropertyFlagChanged(item,
+                                                                    property,
+                                                                    oldFlag,
+                                                                    newFlag) {
+    if (item instanceof Ci.nsIMsgDBHdr) {
+      if ((oldFlag & Ci.nsMsgMessageFlags.New)
+          && !(newFlag & Ci.nsMsgMessageFlags.New)) {
+        this._log.trace("NMNS_OnItemPropertyFlagChanged: item " + item.folder.getUriForMsg(item) + " marked read");
+      }
+      else if (newFlag & Ci.nsMsgMessageFlags.New) {
+        this._log.trace("NMNS_OnItemPropertyFlagChanged: item " + item.folder.getUriForMsg(item) + " marked unread");
+      }
+    }
+  },
+
+  OnItemRemoved: function NMNS_OnItemRemoved(parentItem, item) {
+    if (item instanceof Ci.nsIMsgDBHdr && !item.isRead) {
+      this._log.trace("NMNS_OnItemRemoved: unread item " + item.folder.getUriForMsg(item) + " removed from " + item.folder.folderURL);
+    }
+  },
+  
+
+  // Implement mozINewMailNotificationService
+
+  get messageCount() {
+    if (this.countNew)
+      return this._mNewCount;
+    return this._mUnreadCount;
+  },
+
+  addListener: function NMNS_addListener(aListener, flags) {
+    this._log.trace("NMNS_addListener: listener " + aListener.toSource + " flags " + flags);
+    for (let i = 0; i < this._listeners.length; i++) {
+      let l = this._listeners[i];
+      if (l.obj === aListener) {
+        l.flags = flags;
+        return;
+      }
+    }
+    // If we get here, the listener wasn't already in the list
+    this._listeners.push({obj: aListener, flags: flags});
+  },
+
+  removeListener: function NMNS_removeListener(aListener) {
+    this._log.trace("NMNS_removeListener: listener " + aListener.toSource);
+    for (let i = 0; i < this._listeners.length; i++) {
+      let l = this._listeners[i];
+      if (l.obj === aListener) {
+        this._listeners.splice(i, 1);
+        return;
+      }
+    }
+  },
+
+  _listenersForFlag: function NMNS_listenersForFlag(flag) {
+    this._log.trace("NMNS_listenersForFlag " + flag + " length " + this._listeners.length + " " + this._listeners.toSource());
+    let list = [];
+    for (let i = 0; i < this._listeners.length; i++) {
+      let l = this._listeners[i];
+      if (l.flags & flag) {
+        list.push(l.obj);
+      }
+    }
+    return list;
+  },
+
+  _notifyListeners: function NMNS_notifyListeners(flag, func, value) {
+    let list = this._listenersForFlag(flag);
+    for (let i = 0; i < list.length; i++) {
+      this._log.debug("NMNS_notifyListeners " + flag + " " + func + " " + value);
+      list[i][func].call(list[i], value);
+    }
+  }
+};
+
+var NSGetFactory = XPCOMUtils.generateNSGetFactory([NewMailNotificationService]);
diff --git a/mailnews/base/src/nsCidProtocolHandler.cpp b/mailnews/base/src/nsCidProtocolHandler.cpp
new file mode 100644
index 000000000..8f3f520be
--- /dev/null
+++ b/mailnews/base/src/nsCidProtocolHandler.cpp
@@ -0,0 +1,73 @@
+/* -*- 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 "nsCidProtocolHandler.h"
+#include "nsStringGlue.h"
+#include "nsIURI.h"
+#include "nsNetCID.h"
+#include "nsComponentManagerUtils.h"
+
+nsCidProtocolHandler::nsCidProtocolHandler()
+{
+}
+
+nsCidProtocolHandler::~nsCidProtocolHandler()
+{
+}
+
+NS_IMPL_ISUPPORTS(nsCidProtocolHandler, nsIProtocolHandler)
+
+NS_IMETHODIMP nsCidProtocolHandler::GetScheme(nsACString & aScheme)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsCidProtocolHandler::GetDefaultPort(int32_t *aDefaultPort)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsCidProtocolHandler::GetProtocolFlags(uint32_t *aProtocolFlags)
+{
+  // XXXbz so why does this protocol handler exist, exactly?
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsCidProtocolHandler::NewURI(const nsACString & aSpec, const char *aOriginCharset, nsIURI *aBaseURI, nsIURI **_retval)
+{
+  nsresult rv;
+  nsCOMPtr <nsIURI> url = do_CreateInstance(NS_SIMPLEURI_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // the right fix is to use the baseSpec (or aBaseUri)
+  // and specify the cid, and then fix mime
+  // to handle that, like it does with "...&part=1.2"
+  // for now, do about blank to prevent spam
+  // from popping up annoying alerts about not implementing the cid
+  // protocol
+  rv = url->SetSpec(nsDependentCString("about:blank"));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  NS_IF_ADDREF(*_retval = url);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsCidProtocolHandler::NewChannel(nsIURI *aURI, nsIChannel **_retval)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsCidProtocolHandler::NewChannel2(nsIURI *aURI,
+                                                nsILoadInfo* aLoadInfo,
+                                                nsIChannel **_retval)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsCidProtocolHandler::AllowPort(int32_t port, const char *scheme, bool *_retval)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
diff --git a/mailnews/base/src/nsCidProtocolHandler.h b/mailnews/base/src/nsCidProtocolHandler.h
new file mode 100644
index 000000000..035763d48
--- /dev/null
+++ b/mailnews/base/src/nsCidProtocolHandler.h
@@ -0,0 +1,24 @@
+/* -*- 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 nsCidProtocolHandler_h__
+#define nsCidProtocolHandler_h__
+
+#include "nsCOMPtr.h"
+#include "nsIProtocolHandler.h"
+
+class nsCidProtocolHandler : public nsIProtocolHandler
+{
+public:
+  nsCidProtocolHandler();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPROTOCOLHANDLER
+
+private:
+  virtual ~nsCidProtocolHandler();
+};
+
+#endif /* nsCidProtocolHandler_h__ */
diff --git a/mailnews/base/src/nsCopyMessageStreamListener.cpp b/mailnews/base/src/nsCopyMessageStreamListener.cpp
new file mode 100644
index 000000000..ed41aa51b
--- /dev/null
+++ b/mailnews/base/src/nsCopyMessageStreamListener.cpp
@@ -0,0 +1,145 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsCopyMessageStreamListener.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMailboxUrl.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsIMsgMessageService.h"
+#include "nsMsgUtils.h"
+#include "netCore.h"
+
+NS_IMPL_ISUPPORTS(nsCopyMessageStreamListener, nsIStreamListener,
+  nsIRequestObserver, nsICopyMessageStreamListener)
+
+static nsresult GetMessage(nsIURI *aURL, nsIMsgDBHdr **message)
+{
+  NS_ENSURE_ARG_POINTER(message);
+
+	nsCOMPtr<nsIMsgMessageUrl> uriURL;
+	nsresult rv;
+
+	//Need to get message we are about to copy
+	uriURL = do_QueryInterface(aURL, &rv);
+	if(NS_FAILED(rv))
+		return rv;
+
+  // get the uri.  first try and use the original message spec
+  // if that fails, use the spec of nsIURI that we're called with
+  nsCString uri;
+  rv = uriURL->GetOriginalSpec(getter_Copies(uri));
+  if (NS_FAILED(rv) || uri.IsEmpty()) {
+    rv = uriURL->GetUri(getter_Copies(uri));
+    NS_ENSURE_SUCCESS(rv,rv);
+  }
+
+  nsCOMPtr <nsIMsgMessageService> msgMessageService;
+  rv = GetMessageServiceFromURI(uri, getter_AddRefs(msgMessageService));
+  NS_ENSURE_SUCCESS(rv,rv);
+  if (!msgMessageService) 
+    return NS_ERROR_FAILURE;
+
+  rv = msgMessageService->MessageURIToMsgHdr(uri.get(), message);
+  return rv; 
+}
+
+nsCopyMessageStreamListener::nsCopyMessageStreamListener()
+{
+}
+
+nsCopyMessageStreamListener::~nsCopyMessageStreamListener()
+{
+	//All member variables are nsCOMPtr's.
+}
+
+NS_IMETHODIMP nsCopyMessageStreamListener::Init(nsIMsgFolder *srcFolder, nsICopyMessageListener *destination, nsISupports *listenerData)
+{
+	mSrcFolder = srcFolder;
+	mDestination = destination;
+	mListenerData = listenerData;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCopyMessageStreamListener::StartMessage()
+{
+	if (mDestination)
+		mDestination->StartMessage();
+
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCopyMessageStreamListener::EndMessage(nsMsgKey key)
+{
+	if (mDestination)
+		mDestination->EndMessage(key);
+
+	return NS_OK;
+}
+
+
+NS_IMETHODIMP nsCopyMessageStreamListener::OnDataAvailable(nsIRequest * /* request */, nsISupports *ctxt, nsIInputStream *aIStream, uint64_t sourceOffset, uint32_t aLength)
+{
+	nsresult rv;
+	rv = mDestination->CopyData(aIStream, aLength);
+	return rv;
+}
+
+NS_IMETHODIMP nsCopyMessageStreamListener::OnStartRequest(nsIRequest * request, nsISupports *ctxt)
+{
+	nsCOMPtr<nsIMsgDBHdr> message;
+	nsresult rv = NS_OK;
+	nsCOMPtr<nsIURI> uri = do_QueryInterface(ctxt, &rv);
+
+  NS_ASSERTION(NS_SUCCEEDED(rv), "ahah...someone didn't pass in the expected context!!!");
+	
+	if (NS_SUCCEEDED(rv))
+		rv = GetMessage(uri, getter_AddRefs(message));
+	if(NS_SUCCEEDED(rv))
+		rv = mDestination->BeginCopy(message);
+
+  NS_ENSURE_SUCCESS(rv, rv);
+	return rv;
+}
+
+NS_IMETHODIMP nsCopyMessageStreamListener::EndCopy(nsISupports *url, nsresult aStatus)
+{
+  nsresult rv;
+  nsCOMPtr<nsIURI> uri = do_QueryInterface(url, &rv);
+
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool copySucceeded = (aStatus == NS_BINDING_SUCCEEDED);
+  rv = mDestination->EndCopy(copySucceeded);
+  //If this is a move and we finished the copy, delete the old message.
+  bool moveMessage = false;
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailURL(do_QueryInterface(uri));
+  if (mailURL)
+    rv = mailURL->IsUrlType(nsIMsgMailNewsUrl::eMove, &moveMessage);
+
+  if (NS_FAILED(rv))
+    moveMessage = false;
+
+  // OK, this is wrong if we're moving to an imap folder, for example. This really says that
+  // we were able to pull the message from the source, NOT that we were able to
+  // put it in the destination!
+  if (moveMessage)
+  {
+    // don't do this if we're moving to an imap folder - that's handled elsewhere.
+    nsCOMPtr<nsIMsgImapMailFolder> destImap = do_QueryInterface(mDestination);
+      // if the destination is a local folder, it will handle the delete from the source in EndMove
+    if (!destImap)
+      rv = mDestination->EndMove(copySucceeded);
+  }
+  // Even if the above actions failed we probably still want to return NS_OK.
+  // There should probably be some error dialog if either the copy or delete failed.
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsCopyMessageStreamListener::OnStopRequest(nsIRequest* request, nsISupports *ctxt, nsresult aStatus)
+{
+  return EndCopy(ctxt, aStatus);
+}
+
diff --git a/mailnews/base/src/nsCopyMessageStreamListener.h b/mailnews/base/src/nsCopyMessageStreamListener.h
new file mode 100644
index 000000000..b857401ed
--- /dev/null
+++ b/mailnews/base/src/nsCopyMessageStreamListener.h
@@ -0,0 +1,37 @@
+/* -*- 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 NSCOPYMESSAGESTREAMLISTENER_H
+#define NSCOPYMESSAGESTREAMLISTENER_H
+
+#include "nsICopyMsgStreamListener.h"
+#include "nsIStreamListener.h"
+#include "nsIMsgFolder.h"
+#include "nsICopyMessageListener.h"
+#include "nsCOMPtr.h"
+#include "nsIURI.h"
+
+class nsCopyMessageStreamListener : public nsIStreamListener, public nsICopyMessageStreamListener {
+
+public:
+	nsCopyMessageStreamListener();
+
+	NS_DECL_THREADSAFE_ISUPPORTS
+    NS_DECL_NSICOPYMESSAGESTREAMLISTENER
+    NS_DECL_NSIREQUESTOBSERVER
+    NS_DECL_NSISTREAMLISTENER
+
+protected:
+	virtual ~nsCopyMessageStreamListener();
+
+	nsCOMPtr<nsICopyMessageListener> mDestination;
+	nsCOMPtr<nsISupports> mListenerData;
+	nsCOMPtr<nsIMsgFolder> mSrcFolder;
+
+};
+
+
+
+#endif
diff --git a/mailnews/base/src/nsMailDirProvider.cpp b/mailnews/base/src/nsMailDirProvider.cpp
new file mode 100644
index 000000000..6df8d89e1
--- /dev/null
+++ b/mailnews/base/src/nsMailDirProvider.cpp
@@ -0,0 +1,206 @@
+/* -*- 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 "nsMailDirProvider.h"
+#include "nsMailDirServiceDefs.h"
+#include "nsXULAppAPI.h"
+#include "nsMsgBaseCID.h"
+#include "nsArrayEnumerator.h"
+#include "nsCOMArray.h"
+#include "nsEnumeratorUtils.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsIChromeRegistry.h"
+#include "nsICategoryManager.h"
+#include "nsServiceManagerUtils.h"
+#include "nsDirectoryServiceUtils.h"
+#include "mozilla/Services.h"
+
+#define MAIL_DIR_50_NAME             "Mail"
+#define IMAP_MAIL_DIR_50_NAME        "ImapMail"
+#define NEWS_DIR_50_NAME             "News"
+#define MSG_FOLDER_CACHE_DIR_50_NAME "panacea.dat"
+
+nsresult
+nsMailDirProvider::EnsureDirectory(nsIFile *aDirectory)
+{
+  bool exists;
+  nsresult rv = aDirectory->Exists(&exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!exists)
+    rv = aDirectory->Create(nsIFile::DIRECTORY_TYPE, 0700);
+
+  return rv;
+}
+
+NS_IMPL_ISUPPORTS(nsMailDirProvider,
+                   nsIDirectoryServiceProvider,
+                   nsIDirectoryServiceProvider2)
+
+NS_IMETHODIMP
+nsMailDirProvider::GetFile(const char *aKey, bool *aPersist,
+                           nsIFile **aResult)
+{
+  // NOTE: This function can be reentrant through the NS_GetSpecialDirectory
+  // call, so be careful not to cause infinite recursion.
+  // i.e. the check for supported files must come first.
+  const char* leafName = nullptr;
+  bool isDirectory = true;
+
+  if (!strcmp(aKey, NS_APP_MAIL_50_DIR))
+    leafName = MAIL_DIR_50_NAME;
+  else if (!strcmp(aKey, NS_APP_IMAP_MAIL_50_DIR))
+    leafName = IMAP_MAIL_DIR_50_NAME;
+  else if (!strcmp(aKey, NS_APP_NEWS_50_DIR))
+    leafName = NEWS_DIR_50_NAME;
+  else if (!strcmp(aKey, NS_APP_MESSENGER_FOLDER_CACHE_50_FILE)) {
+    isDirectory = false;
+    leafName = MSG_FOLDER_CACHE_DIR_50_NAME;
+  }
+  else
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIFile> parentDir;
+  nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
+                                       getter_AddRefs(parentDir));
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCOMPtr<nsIFile> file;
+  rv = parentDir->Clone(getter_AddRefs(file));
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsDependentCString leafStr(leafName);
+  rv = file->AppendNative(leafStr);
+  if (NS_FAILED(rv))
+    return rv;
+
+  bool exists;
+  if (isDirectory && NS_SUCCEEDED(file->Exists(&exists)) && !exists)
+    rv = EnsureDirectory(file);
+
+  *aPersist = true;
+  file.swap(*aResult);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMailDirProvider::GetFiles(const char *aKey,
+                            nsISimpleEnumerator **aResult)
+{
+  if (strcmp(aKey, ISP_DIRECTORY_LIST) != 0)
+    return NS_ERROR_FAILURE;
+
+  // The list of isp directories includes the isp directory
+  // in the current process dir (i.e. <path to thunderbird.exe>\isp and 
+  // <path to thunderbird.exe>\isp\locale 
+  // and isp and isp\locale for each active extension
+
+  nsCOMPtr<nsIProperties> dirSvc =
+    do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
+  if (!dirSvc)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIFile> currentProcessDir;
+  nsresult rv = dirSvc->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
+                   NS_GET_IID(nsIFile), getter_AddRefs(currentProcessDir));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISimpleEnumerator> directoryEnumerator;
+  rv = NS_NewSingletonEnumerator(getter_AddRefs(directoryEnumerator), currentProcessDir);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISimpleEnumerator> combinedEnumerator;
+  nsCOMPtr<nsISimpleEnumerator> extensionsEnum;
+
+  // xpcshell-tests don't have XRE_EXTENSIONS_DIR_LIST, so accept a null return here.
+  dirSvc->Get(XRE_EXTENSIONS_DIR_LIST,
+              NS_GET_IID(nsISimpleEnumerator),
+              getter_AddRefs(extensionsEnum));
+
+  rv = NS_NewUnionEnumerator(getter_AddRefs(combinedEnumerator), directoryEnumerator, extensionsEnum);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_IF_ADDREF(*aResult = new AppendingEnumerator(combinedEnumerator));
+  return NS_SUCCESS_AGGREGATE_RESULT;
+}
+
+NS_IMPL_ISUPPORTS(nsMailDirProvider::AppendingEnumerator,
+                   nsISimpleEnumerator)
+
+NS_IMETHODIMP
+nsMailDirProvider::AppendingEnumerator::HasMoreElements(bool *aResult)
+{
+  *aResult = mNext || mNextWithLocale ? true : false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMailDirProvider::AppendingEnumerator::GetNext(nsISupports* *aResult)
+{
+  // Set the return value to the next directory we want to enumerate over
+  if (aResult)
+    NS_ADDREF(*aResult = mNext);
+
+  if (mNextWithLocale)
+  {
+    mNext = mNextWithLocale;
+    mNextWithLocale = nullptr;
+    return NS_OK;
+  }
+
+  mNext = nullptr;
+
+  // Ignore all errors
+
+  bool more;
+  while (NS_SUCCEEDED(mBase->HasMoreElements(&more)) && more) {
+    nsCOMPtr<nsISupports> nextbasesupp;
+    mBase->GetNext(getter_AddRefs(nextbasesupp));
+
+    nsCOMPtr<nsIFile> nextbase(do_QueryInterface(nextbasesupp));
+    if (!nextbase)
+      continue;
+
+    nextbase->Clone(getter_AddRefs(mNext));
+    if (!mNext)
+      continue;
+
+    mNext->AppendNative(NS_LITERAL_CSTRING("isp"));
+    bool exists;
+    nsresult rv = mNext->Exists(&exists);
+    if (NS_SUCCEEDED(rv) && exists)
+    {
+      if (!mLocale.IsEmpty())
+      {
+        mNext->Clone(getter_AddRefs(mNextWithLocale));
+        mNextWithLocale->AppendNative(mLocale);
+        rv = mNextWithLocale->Exists(&exists);
+        if (NS_FAILED(rv) || !exists)
+          mNextWithLocale = nullptr; // clear out mNextWithLocale, so we don't try to iterate over it
+      } 
+      break;
+    }
+
+    mNext = nullptr;
+  }
+
+  return NS_OK;
+}
+
+nsMailDirProvider::AppendingEnumerator::AppendingEnumerator
+    (nsISimpleEnumerator* aBase) :
+  mBase(aBase)
+{
+  nsCOMPtr<nsIXULChromeRegistry> packageRegistry =
+    mozilla::services::GetXULChromeRegistryService();
+  if (packageRegistry)
+    packageRegistry->GetSelectedLocale(NS_LITERAL_CSTRING("global"), false, mLocale);
+  // Initialize mNext to begin
+  GetNext(nullptr);
+}
diff --git a/mailnews/base/src/nsMailDirProvider.h b/mailnews/base/src/nsMailDirProvider.h
new file mode 100644
index 000000000..d12876d89
--- /dev/null
+++ b/mailnews/base/src/nsMailDirProvider.h
@@ -0,0 +1,43 @@
+/* -*- 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 nsMailDirProvider_h__
+#define nsMailDirProvider_h__
+
+#include "nsIDirectoryService.h"
+#include "nsISimpleEnumerator.h"
+#include "nsStringGlue.h"
+#include "nsCOMPtr.h"
+
+class nsMailDirProvider final : public nsIDirectoryServiceProvider2
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIDIRECTORYSERVICEPROVIDER
+  NS_DECL_NSIDIRECTORYSERVICEPROVIDER2
+
+private:
+  ~nsMailDirProvider() {}
+
+  nsresult EnsureDirectory(nsIFile *aDirectory);
+
+  class AppendingEnumerator final : public nsISimpleEnumerator
+  {
+  public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSISIMPLEENUMERATOR
+
+    AppendingEnumerator(nsISimpleEnumerator* aBase);
+
+  private:
+    ~AppendingEnumerator() {}
+    nsCOMPtr<nsISimpleEnumerator> mBase;
+    nsCOMPtr<nsIFile>             mNext;
+    nsCOMPtr<nsIFile>             mNextWithLocale;
+    nsCString                     mLocale;
+  };
+};
+
+#endif // nsMailDirProvider_h__
diff --git a/mailnews/base/src/nsMailDirServiceDefs.h b/mailnews/base/src/nsMailDirServiceDefs.h
new file mode 100644
index 000000000..fe12ed0d6
--- /dev/null
+++ b/mailnews/base/src/nsMailDirServiceDefs.h
@@ -0,0 +1,31 @@
+/* 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 nsMailDirectoryServiceDefs_h___
+#define nsMailDirectoryServiceDefs_h___
+
+//=============================================================================
+//
+// Defines property names for directories available from the mail-specific
+// nsMailDirProvider.
+//
+// System and XPCOM properties are defined in nsDirectoryServiceDefs.h.
+// General application properties are defined in nsAppDirectoryServiceDefs.h.
+//
+//=============================================================================
+
+// ----------------------------------------------------------------------------
+// Files and directories that exist on a per-profile basis.
+// ----------------------------------------------------------------------------
+
+#define NS_APP_MAIL_50_DIR                      "MailD"
+#define NS_APP_IMAP_MAIL_50_DIR                 "IMapMD"
+#define NS_APP_NEWS_50_DIR                      "NewsD"
+
+#define NS_APP_MESSENGER_FOLDER_CACHE_50_FILE   "MFCaF"
+
+#define ISP_DIRECTORY_LIST                 "ISPDL"
+      
+#endif
diff --git a/mailnews/base/src/nsMailNewsCommandLineHandler.js b/mailnews/base/src/nsMailNewsCommandLineHandler.js
new file mode 100644
index 000000000..3a85ec336
--- /dev/null
+++ b/mailnews/base/src/nsMailNewsCommandLineHandler.js
@@ -0,0 +1,170 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/AppConstants.jsm");
+
+var MAPI_STARTUP_ARG = "MapiStartup";
+var MESSAGE_ID_PARAM = "?messageid=";
+
+var CMDLINEHANDLER_CID = Components.ID("{2f86d554-f9d9-4e76-8eb7-243f047333ee}");
+var CMDLINEHANDLER_CONTRACTID = "@mozilla.org/commandlinehandler/general-startup;1?type=mail";
+
+var nsMailNewsCommandLineHandler =
+{
+  get _messenger() {
+    delete this._messenger;
+    return this._messenger = Cc["@mozilla.org/messenger;1"]
+                               .createInstance(Ci.nsIMessenger);
+  },
+
+  /* nsICommandLineHandler */
+
+  /**
+   * Handles the following command line arguments:
+   * - -mail: opens the mail folder view
+   * - -MapiStartup: indicates that this startup is due to MAPI.
+   *   Don't do anything for now.
+   */
+  handle: function nsMailNewsCommandLineHandler_handle(aCommandLine) {
+    // Do this here because xpcshell isn't too happy with this at startup
+    Components.utils.import("resource:///modules/MailUtils.js");
+    // -mail <URL>
+    let mailURL = null;
+    try {
+      mailURL = aCommandLine.handleFlagWithParam("mail", false);
+    }
+    catch (e) {
+      // We're going to cover -mail without a parameter later
+    }
+
+    if (mailURL && mailURL.length > 0) {
+      let msgHdr = null;
+      if (/^(mailbox|imap|news)-message:\/\//.test(mailURL)) {
+        // This might be a standard message URI, or one with a messageID
+        // parameter. Handle both cases.
+        let messageIDIndex = mailURL.toLowerCase().indexOf(MESSAGE_ID_PARAM);
+        if (messageIDIndex != -1) {
+          // messageID parameter
+          // Convert the message URI into a folder URI
+          let folderURI = mailURL.slice(0, messageIDIndex)
+                                 .replace("-message", "");
+          // Get the message ID
+          let messageID = mailURL.slice(messageIDIndex + MESSAGE_ID_PARAM.length);
+          // Make sure the folder tree is initialized
+          MailUtils.discoverFolders();
+
+          let folder = MailUtils.getFolderForURI(folderURI, true);
+          // The folder might not exist, so guard against that
+          if (folder && messageID.length > 0)
+            msgHdr = folder.msgDatabase.getMsgHdrForMessageID(messageID);
+        }
+        else {
+          // message URI
+          msgHdr = this._messenger.msgHdrFromURI(mailURL);
+        }
+      }
+      else {
+        // Necko URL, so convert it into a message header
+        let neckoURL = null;
+        try {
+          neckoURL = Services.io.newURI(mailURL, null, null);
+        }
+        catch (e) {
+          // We failed to convert the URI. Oh well.
+        }
+
+        if (neckoURL instanceof Ci.nsIMsgMessageUrl)
+          msgHdr = neckoURL.messageHeader;
+      }
+
+      if (msgHdr) {
+        aCommandLine.preventDefault = true;
+        MailUtils.displayMessage(msgHdr);
+      }
+      else if (AppConstants.MOZ_APP_NAME == "seamonkey" &&
+               /\.(eml|msg)$/i.test(mailURL)) {
+        try {
+          let file = aCommandLine.resolveFile(mailURL);

+          // No point in trying to open a file if it doesn't exist or is empty

+          if (file.exists() && file.fileSize > 0) {

+            // Get the URL for this file

+            let fileURL = Services.io.newFileURI(file)

+                                  .QueryInterface(Ci.nsIFileURL);

+            fileURL.query = "?type=application/x-message-display";

+            // Open this file in a new message window.

+            Services.ww.openWindow(null,

+                                   "chrome://messenger/content/messageWindow.xul",

+                                   "_blank", "all,chrome,dialog=no,status,toolbar",

+                                   fileURL);

+            aCommandLine.preventDefault = true;
+          }
+        }
+        catch (e) {
+        }
+      }
+      else {
+        dump("Unrecognized URL: " + mailURL + "\n");
+        Services.console.logStringMessage("Unrecognized URL: " + mailURL);
+      }
+    }
+
+    // -mail (no parameter)
+    let mailFlag = aCommandLine.handleFlag("mail", false);
+    if (mailFlag) {
+      // Focus the 3pane window if one is present, else open one
+      let mail3PaneWindow = Services.wm.getMostRecentWindow("mail:3pane");
+      if (mail3PaneWindow) {
+        mail3PaneWindow.focus();
+      }
+      else {
+        Services.ww.openWindow(null, "chrome://messenger/content/", "_blank",
+            "chrome,extrachrome,menubar,resizable,scrollbars,status,toolbar,dialog=no",
+            null);
+      }
+      aCommandLine.preventDefault = true;
+    }
+
+    // -MapiStartup
+    aCommandLine.handleFlag(MAPI_STARTUP_ARG, false);
+  },
+
+  helpInfo: "  -mail              Open the mail folder view.\n" +
+            "  -mail <URL>        Open the message specified by this URL.\n",
+
+  classInfo: XPCOMUtils.generateCI({classID: CMDLINEHANDLER_CID,
+                                    contractID: CMDLINEHANDLER_CONTRACTID,
+                                    interfaces: [Ci.nsICommandLineHandler],
+                                    flags: Ci.nsIClassInfo.SINGLETON}),
+
+  /* nsIFactory */
+  createInstance: function(outer, iid) {
+    if (outer != null)
+      throw Cr.NS_ERROR_NO_AGGREGATION;
+
+    return this.QueryInterface(iid);
+  },
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsICommandLineHandler,
+                                         Ci.nsIFactory])
+};
+
+function mailNewsCommandLineHandlerModule() {}
+mailNewsCommandLineHandlerModule.prototype =
+{
+  // XPCOM registration
+  classID: CMDLINEHANDLER_CID,
+
+  QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsIModule]),
+
+  _xpcom_factory: nsMailNewsCommandLineHandler
+};
+
+var components = [mailNewsCommandLineHandlerModule];
+var NSGetFactory = XPCOMUtils.generateNSGetFactory(components);
diff --git a/mailnews/base/src/nsMessenger.cpp b/mailnews/base/src/nsMessenger.cpp
new file mode 100644
index 000000000..82fb5b68a
--- /dev/null
+++ b/mailnews/base/src/nsMessenger.cpp
@@ -0,0 +1,3072 @@
+/* -*- 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 "prsystem.h"
+
+#include "nsMessenger.h"
+
+// xpcom
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIStringStream.h"
+#include "nsIFile.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsQuickSort.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsIMutableArray.h"
+#include "mozilla/Services.h"
+
+// necko
+#include "nsMimeTypes.h"
+#include "nsIURL.h"
+#include "nsIPrompt.h"
+#include "nsIStreamListener.h"
+#include "nsIStreamConverterService.h"
+#include "nsNetUtil.h"
+#include "nsIFileURL.h"
+#include "nsIMIMEInfo.h"
+
+// rdf
+#include "nsIRDFResource.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+
+// gecko
+#include "nsLayoutCID.h"
+#include "nsIContentViewer.h"
+
+// embedding
+#ifdef NS_PRINTING
+#include "nsIWebBrowserPrint.h"
+#include "nsMsgPrintEngine.h"
+#endif
+
+/* for access to docshell */
+#include "nsPIDOMWindow.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellLoadInfo.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIWebNavigation.h"
+
+// mail
+#include "nsIMsgMailNewsUrl.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgMailSession.h"
+#include "nsIMailboxUrl.h"
+#include "nsIMsgFolder.h"
+#include "nsMsgFolderFlags.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMsgIncomingServer.h"
+
+#include "nsIMsgMessageService.h"
+#include "nsMsgRDFUtils.h"
+
+#include "nsIMsgHdr.h"
+#include "nsIMimeMiscStatus.h"
+// compose
+#include "nsMsgCompCID.h"
+#include "nsMsgI18N.h"
+#include "nsNativeCharsetUtils.h"
+
+// draft/folders/sendlater/etc
+#include "nsIMsgCopyService.h"
+#include "nsIMsgCopyServiceListener.h"
+#include "nsIUrlListener.h"
+
+// undo
+#include "nsITransaction.h"
+#include "nsMsgTxn.h"
+
+// charset conversions
+#include "nsMsgMimeCID.h"
+#include "nsIMimeConverter.h"
+
+// Save As
+#include "nsIFilePicker.h"
+#include "nsIStringBundle.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsCExternalHandlerService.h"
+#include "nsIExternalProtocolService.h"
+#include "nsIMIMEService.h"
+#include "nsITransfer.h"
+
+#include "nsILinkHandler.h"
+
+static NS_DEFINE_CID(kRDFServiceCID,  NS_RDFSERVICE_CID);
+
+#define MESSENGER_SAVE_DIR_PREF_NAME "messenger.save.dir"
+#define MIMETYPE_DELETED    "text/x-moz-deleted"
+#define ATTACHMENT_PERMISSION 00664
+
+//
+// Convert an nsString buffer to plain text...
+//
+#include "nsMsgUtils.h"
+#include "nsCharsetSource.h"
+#include "nsIChannel.h"
+#include "nsIOutputStream.h"
+#include "nsIPrincipal.h"
+
+static void ConvertAndSanitizeFileName(const char * displayName, nsString& aResult)
+{
+  nsCString unescapedName;
+
+  /* we need to convert the UTF-8 fileName to platform specific character set.
+     The display name is in UTF-8 because it has been escaped from JS
+  */
+  MsgUnescapeString(nsDependentCString(displayName), 0, unescapedName);
+  CopyUTF8toUTF16(unescapedName, aResult);
+
+  // replace platform specific path separator and illegale characters to avoid any confusion
+  MsgReplaceChar(aResult, FILE_PATH_SEPARATOR FILE_ILLEGAL_CHARACTERS, '-');
+}
+
+// ***************************************************
+// jefft - this is a rather obscured class serves for Save Message As File,
+// Save Message As Template, and Save Attachment to a file
+//
+class nsSaveAllAttachmentsState;
+
+class nsSaveMsgListener : public nsIUrlListener,
+                          public nsIMsgCopyServiceListener,
+                          public nsIStreamListener,
+                          public nsICancelable
+{
+public:
+  nsSaveMsgListener(nsIFile *file, nsMessenger *aMessenger, nsIUrlListener *aListener);
+
+  NS_DECL_ISUPPORTS
+
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSIMSGCOPYSERVICELISTENER
+  NS_DECL_NSISTREAMLISTENER
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSICANCELABLE
+
+  nsCOMPtr<nsIFile> m_file;
+  nsCOMPtr<nsIOutputStream> m_outputStream;
+  char m_dataBuffer[FILE_IO_BUFFER_SIZE];
+  nsCOMPtr<nsIChannel> m_channel;
+  nsCString m_templateUri;
+  nsMessenger *m_messenger; // not ref counted
+  nsSaveAllAttachmentsState *m_saveAllAttachmentsState;
+
+  // rhp: For character set handling
+  bool          m_doCharsetConversion;
+  nsString      m_charset;
+  enum {
+    eUnknown,
+    ePlainText,
+    eHTML
+  }             m_outputFormat;
+  nsCString     m_msgBuffer;
+
+  nsCString     m_contentType;    // used only when saving attachment
+
+  nsCOMPtr<nsITransfer> mTransfer;
+  nsCOMPtr<nsIUrlListener> mListener;
+  nsCOMPtr<nsIURI> mListenerUri;
+  int64_t mProgress;
+  int64_t mMaxProgress;
+  bool    mCanceled;
+  bool    mInitialized;
+  bool    mUrlHasStopped;
+  bool    mRequestHasStopped;
+  nsresult InitializeDownload(nsIRequest * aRequest);
+
+private:
+  virtual ~nsSaveMsgListener();
+};
+
+class nsSaveAllAttachmentsState
+{
+public:
+  nsSaveAllAttachmentsState(uint32_t count,
+                            const char **contentTypeArray,
+                            const char **urlArray,
+                            const char **displayNameArray,
+                            const char **messageUriArray,
+                            const char *directoryName,
+                            bool detachingAttachments);
+  virtual ~nsSaveAllAttachmentsState();
+
+  uint32_t m_count;
+  uint32_t m_curIndex;
+  char* m_directoryName;
+  char** m_contentTypeArray;
+  char** m_urlArray;
+  char** m_displayNameArray;
+  char** m_messageUriArray;
+  bool m_detachingAttachments;
+
+  // if detaching, do without warning? Will create unique files instead of
+  //  prompting if duplicate files exist.
+  bool m_withoutWarning;
+  nsTArray<nsCString> m_savedFiles; // if detaching first, remember where we saved to.
+};
+
+//
+// nsMessenger
+//
+nsMessenger::nsMessenger()
+{
+  mCurHistoryPos = -2; // first message selected goes at position 0.
+  //  InitializeFolderRoot();
+}
+
+nsMessenger::~nsMessenger()
+{
+}
+
+
+NS_IMPL_ISUPPORTS(nsMessenger, nsIMessenger, nsISupportsWeakReference, nsIFolderListener)
+
+NS_IMETHODIMP nsMessenger::SetWindow(mozIDOMWindowProxy *aWin, nsIMsgWindow *aMsgWindow)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgMailSession> mailSession =
+    do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aWin)
+  {
+    mMsgWindow = aMsgWindow;
+    mWindow = aWin;
+
+    rv = mailSession->AddFolderListener(this, nsIFolderListener::removed);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    NS_ENSURE_TRUE(aWin, NS_ERROR_FAILURE);
+    nsCOMPtr<nsPIDOMWindowOuter> win = nsPIDOMWindowOuter::From(aWin);
+
+    nsIDocShell *docShell = win->GetDocShell();
+    nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(docShell));
+    NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE);
+
+    nsCOMPtr<nsIDocShellTreeItem> rootDocShellAsItem;
+    docShellAsItem->GetSameTypeRootTreeItem(getter_AddRefs(rootDocShellAsItem));
+
+    nsCOMPtr<nsIDocShellTreeItem> childAsItem;
+    rv = rootDocShellAsItem->FindChildWithName(NS_LITERAL_STRING("messagepane"), true, false,
+                                               nullptr, nullptr, getter_AddRefs(childAsItem));
+
+    mDocShell = do_QueryInterface(childAsItem);
+    if (NS_SUCCEEDED(rv) && mDocShell) {
+      mCurrentDisplayCharset = ""; // Important! Clear out mCurrentDisplayCharset so we reset a default charset on mDocshell the next time we try to load something into it.
+
+      if (aMsgWindow)
+        aMsgWindow->GetTransactionManager(getter_AddRefs(mTxnMgr));
+    }
+
+    // we don't always have a message pane, like in the addressbook
+    // so if we don't have a docshell, use the one for the xul window.
+    // we do this so OpenURL() will work.
+    if (!mDocShell)
+      mDocShell = docShell;
+  } // if aWin
+  else
+  {
+    // Remove the folder listener if we added it, i.e. if mWindow is non-null
+    if (mWindow)
+    {
+      rv = mailSession->RemoveFolderListener(this);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    mWindow = nullptr;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMessenger::SetDisplayCharset(const nsACString& aCharset)
+{
+  // libmime always converts to UTF-8 (both HTML and XML)
+  if (mDocShell)
+  {
+    nsCOMPtr<nsIContentViewer> cv;
+    mDocShell->GetContentViewer(getter_AddRefs(cv));
+    if (cv)
+    {
+      cv->SetHintCharacterSet(aCharset);
+      cv->SetHintCharacterSetSource(kCharsetFromChannel);
+
+      mCurrentDisplayCharset = aCharset;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsMessenger::PromptIfFileExists(nsIFile *file)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+  bool exists;
+  file->Exists(&exists);
+  if (exists)
+  {
+    nsCOMPtr<nsIPrompt> dialog(do_GetInterface(mDocShell));
+    if (!dialog) return rv;
+    nsAutoString path;
+    bool dialogResult = false;
+    nsString errorMessage;
+
+    file->GetPath(path);
+    const char16_t *pathFormatStrings[] = { path.get() };
+
+    if (!mStringBundle)
+    {
+      rv = InitStringBundle();
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    rv = mStringBundle->FormatStringFromName(u"fileExists",
+                                             pathFormatStrings, 1,
+                                             getter_Copies(errorMessage));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = dialog->Confirm(nullptr, errorMessage.get(), &dialogResult);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (dialogResult)
+    {
+      return NS_OK; // user says okay to replace
+    }
+    else
+    {
+      // if we don't re-init the path for redisplay the picker will
+      // show the full path, not just the file name
+      nsCOMPtr<nsIFile> currentFile = do_CreateInstance("@mozilla.org/file/local;1");
+      if (!currentFile) return NS_ERROR_FAILURE;
+
+      rv = currentFile->InitWithPath(path);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsAutoString leafName;
+      currentFile->GetLeafName(leafName);
+      if (!leafName.IsEmpty())
+        path.Assign(leafName); // path should be a copy of leafName
+
+      nsCOMPtr<nsIFilePicker> filePicker =
+        do_CreateInstance("@mozilla.org/filepicker;1", &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsString saveAttachmentStr;
+      GetString(NS_LITERAL_STRING("SaveAttachment"), saveAttachmentStr);
+      filePicker->Init(mWindow,
+                       saveAttachmentStr,
+                       nsIFilePicker::modeSave);
+      filePicker->SetDefaultString(path);
+      filePicker->AppendFilters(nsIFilePicker::filterAll);
+
+      nsCOMPtr <nsIFile> lastSaveDir;
+      rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
+      if (NS_SUCCEEDED(rv) && lastSaveDir) {
+        filePicker->SetDisplayDirectory(lastSaveDir);
+      }
+
+      int16_t dialogReturn;
+      rv = filePicker->Show(&dialogReturn);
+      if (NS_FAILED(rv) || dialogReturn == nsIFilePicker::returnCancel) {
+        // XXX todo
+        // don't overload the return value like this
+        // change this function to have an out boolean
+        // that we check to see if the user cancelled
+        return NS_ERROR_FAILURE;
+      }
+
+      nsCOMPtr<nsIFile> localFile;
+
+      rv = filePicker->GetFile(getter_AddRefs(localFile));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = SetLastSaveDirectory(localFile);
+      NS_ENSURE_SUCCESS(rv,rv);
+
+      // reset the file to point to the new path
+      return file->InitWithFile(localFile);
+    }
+  }
+  else
+  {
+    return NS_OK;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessenger::AddMsgUrlToNavigateHistory(const nsACString& aURL)
+{
+  // mNavigatingToUri is set to a url if we're already doing a back/forward,
+  // in which case we don't want to add the url to the history list.
+  // Or if the entry at the cur history pos is the same as what we're loading, don't
+  // add it to the list.
+  if (!mNavigatingToUri.Equals(aURL) && (mCurHistoryPos < 0 || !mLoadedMsgHistory[mCurHistoryPos].Equals(aURL)))
+  {
+    mNavigatingToUri = aURL;
+    nsCString curLoadedFolderUri;
+    nsCOMPtr <nsIMsgFolder> curLoadedFolder;
+
+    mMsgWindow->GetOpenFolder(getter_AddRefs(curLoadedFolder));
+    // for virtual folders, we want to select the right folder,
+    // which isn't the same as the folder specified in the msg uri.
+    // So add the uri for the currently loaded folder to the history list.
+    if (curLoadedFolder)
+      curLoadedFolder->GetURI(curLoadedFolderUri);
+
+    mLoadedMsgHistory.InsertElementAt(mCurHistoryPos++ + 2, mNavigatingToUri);
+    mLoadedMsgHistory.InsertElementAt(mCurHistoryPos++ + 2, curLoadedFolderUri);
+    // we may want to prune this history if it gets large, but I think it's
+    // more interesting to prune the back and forward menu.
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessenger::OpenURL(const nsACString& aURL)
+{
+  // This is to setup the display DocShell as UTF-8 capable...
+  SetDisplayCharset(NS_LITERAL_CSTRING("UTF-8"));
+
+  nsCOMPtr <nsIMsgMessageService> messageService;
+  nsresult rv = GetMessageServiceFromURI(aURL, getter_AddRefs(messageService));
+
+  if (NS_SUCCEEDED(rv) && messageService)
+  {
+    nsCOMPtr<nsIURI> dummyNull;
+    messageService->DisplayMessage(PromiseFlatCString(aURL).get(), mDocShell,
+        mMsgWindow, nullptr, nullptr, getter_AddRefs(dummyNull));
+    AddMsgUrlToNavigateHistory(aURL);
+    mLastDisplayURI = aURL; // remember the last uri we displayed....
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
+  if(!webNav)
+    return NS_ERROR_FAILURE;
+  rv = webNav->LoadURI(NS_ConvertASCIItoUTF16(aURL).get(),   // URI string
+                       nsIWebNavigation::LOAD_FLAGS_IS_LINK, // Load flags
+                       nullptr,                               // Referring URI
+                       nullptr,                               // Post stream
+                       nullptr);                              // Extra headers
+  return rv;
+}
+
+NS_IMETHODIMP nsMessenger::LaunchExternalURL(const nsACString& aURL)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIURI> uri;
+  rv = NS_NewURI(getter_AddRefs(uri), PromiseFlatCString(aURL).get());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIExternalProtocolService> extProtService = do_GetService(NS_EXTERNALPROTOCOLSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return extProtService->LoadUrl(uri);
+}
+
+NS_IMETHODIMP
+nsMessenger::LoadURL(mozIDOMWindowProxy *aWin, const nsACString& aURL)
+{
+  nsresult rv;
+
+  SetDisplayCharset(NS_LITERAL_CSTRING("UTF-8"));
+
+  NS_ConvertASCIItoUTF16 uriString(aURL);
+  // Cleanup the empty spaces that might be on each end.
+  uriString.Trim(" ");
+  // Eliminate embedded newlines, which single-line text fields now allow:
+  uriString.StripChars("\r\n");
+  NS_ENSURE_TRUE(!uriString.IsEmpty(), NS_ERROR_FAILURE);
+
+  bool loadingFromFile = false;
+  bool getDummyMsgHdr = false;
+  int64_t fileSize;
+
+  if (StringBeginsWith(uriString, NS_LITERAL_STRING("file:")))
+  {
+    nsCOMPtr<nsIURI> fileUri;
+    rv = NS_NewURI(getter_AddRefs(fileUri), uriString);
+    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, NS_LITERAL_STRING("mailbox:"));
+    uriString.Append(NS_LITERAL_STRING("&number=0"));
+    loadingFromFile = true;
+    getDummyMsgHdr = true;
+  }
+  else if (StringBeginsWith(uriString, NS_LITERAL_STRING("mailbox:")) &&
+           (CaseInsensitiveFindInReadable(NS_LITERAL_STRING(".eml?"), uriString)))
+  {
+    // if we have a mailbox:// url that points to an .eml file, we have to read
+    // the file size as well
+    uriString.Replace(0, 8, NS_LITERAL_STRING("file:"));
+    nsCOMPtr<nsIURI> fileUri;
+    rv = NS_NewURI(getter_AddRefs(fileUri), uriString);
+    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, NS_LITERAL_STRING("mailbox:"));
+    loadingFromFile = true;
+    getDummyMsgHdr = true;
+  }
+  else if (uriString.Find("type=application/x-message-display") >= 0)
+    getDummyMsgHdr = true;
+
+  nsCOMPtr<nsIURI> uri;
+  rv = NS_NewURI(getter_AddRefs(uri), uriString);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ENSURE_TRUE(mDocShell, NS_ERROR_FAILURE);
+  nsCOMPtr<nsIMsgMailNewsUrl> msgurl = do_QueryInterface(uri);
+  if (msgurl)
+  {
+    msgurl->SetMsgWindow(mMsgWindow);
+    if (loadingFromFile || getDummyMsgHdr)
+    {
+      if (loadingFromFile)
+      {
+        nsCOMPtr <nsIMailboxUrl> mailboxUrl = do_QueryInterface(msgurl, &rv);
+        mailboxUrl->SetMessageSize((uint32_t) fileSize);
+      }
+      if (getDummyMsgHdr)
+      {
+        nsCOMPtr <nsIMsgHeaderSink> headerSink;
+         // need to tell the header sink to capture some headers to create a fake db header
+         // so we can do reply to a .eml file or a rfc822 msg attachment.
+        mMsgWindow->GetMsgHeaderSink(getter_AddRefs(headerSink));
+        if (headerSink)
+        {
+          nsCOMPtr <nsIMsgDBHdr> dummyHeader;
+          headerSink->GetDummyMsgHeader(getter_AddRefs(dummyHeader));
+          if (dummyHeader && loadingFromFile)
+            dummyHeader->SetMessageSize((uint32_t) fileSize);
+        }
+      }
+    }
+  }
+
+  nsCOMPtr<nsIDocShellLoadInfo> loadInfo;
+  rv = mDocShell->CreateLoadInfo(getter_AddRefs(loadInfo));
+  NS_ENSURE_SUCCESS(rv, rv);
+  loadInfo->SetLoadType(nsIDocShellLoadInfo::loadNormal);
+  AddMsgUrlToNavigateHistory(aURL);
+  mNavigatingToUri.Truncate();
+  mLastDisplayURI = aURL; // Remember the last uri we displayed.
+  return mDocShell->LoadURI(uri, loadInfo, 0, true);
+}
+
+NS_IMETHODIMP nsMessenger::SaveAttachmentToFile(nsIFile *aFile,
+                                                const nsACString &aURL,
+                                                const nsACString &aMessageUri,
+                                                const nsACString &aContentType,
+                                                nsIUrlListener *aListener)
+{
+  return SaveAttachment(aFile, aURL, aMessageUri, aContentType, nullptr, aListener);
+}
+
+NS_IMETHODIMP
+nsMessenger::DetachAttachmentsWOPrompts(nsIFile* aDestFolder,
+                                        uint32_t aCount,
+                                        const char **aContentTypeArray,
+                                        const char **aUrlArray,
+                                        const char **aDisplayNameArray,
+                                        const char **aMessageUriArray,
+                                        nsIUrlListener *aListener)
+{
+  NS_ENSURE_ARG_POINTER(aDestFolder);
+  NS_ENSURE_ARG_POINTER(aContentTypeArray);
+  NS_ENSURE_ARG_POINTER(aUrlArray);
+  NS_ENSURE_ARG_POINTER(aMessageUriArray);
+  NS_ENSURE_ARG_POINTER(aDisplayNameArray);
+  if (!aCount)
+    return NS_OK;
+  nsSaveAllAttachmentsState *saveState;
+  nsCOMPtr<nsIFile> attachmentDestination;
+  nsresult rv = aDestFolder->Clone(getter_AddRefs(attachmentDestination));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString path;
+  rv = attachmentDestination->GetNativePath(path);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoString unescapedFileName;
+  ConvertAndSanitizeFileName(aDisplayNameArray[0], unescapedFileName);
+  rv = attachmentDestination->Append(unescapedFileName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = attachmentDestination->CreateUnique(nsIFile::NORMAL_FILE_TYPE, ATTACHMENT_PERMISSION);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  saveState = new nsSaveAllAttachmentsState(aCount,
+                                            aContentTypeArray,
+                                            aUrlArray,
+                                            aDisplayNameArray,
+                                            aMessageUriArray,
+                                            path.get(),
+                                            true);
+
+  // This method is used in filters, where we don't want to warn
+  saveState->m_withoutWarning = true;
+  rv = SaveAttachment(attachmentDestination,
+                      nsDependentCString(aUrlArray[0]),
+                      nsDependentCString(aMessageUriArray[0]),
+                      nsDependentCString(aContentTypeArray[0]),
+                      (void *)saveState,
+                      aListener);
+  return rv;
+}
+
+nsresult nsMessenger::SaveAttachment(nsIFile *aFile,
+                                     const nsACString &aURL,
+                                     const nsACString &aMessageUri,
+                                     const nsACString &aContentType,
+                                     void *closure,
+                                     nsIUrlListener *aListener)
+{
+  nsCOMPtr<nsIMsgMessageService> messageService;
+  nsSaveAllAttachmentsState *saveState= (nsSaveAllAttachmentsState*) closure;
+  nsCOMPtr<nsIMsgMessageFetchPartService> fetchService;
+  nsAutoCString urlString;
+  nsCOMPtr<nsIURI> URL;
+  nsAutoCString fullMessageUri(aMessageUri);
+
+  // This instance will be held onto by the listeners, and will be released once 
+  // the transfer has been completed.
+  RefPtr<nsSaveMsgListener> saveListener(new nsSaveMsgListener(aFile, this, aListener));
+  if (!saveListener)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  saveListener->m_contentType = aContentType;
+  if (saveState)
+  {
+    saveListener->m_saveAllAttachmentsState = saveState;
+    if (saveState->m_detachingAttachments)
+    {
+      nsCOMPtr<nsIURI> outputURI;
+      nsresult rv = NS_NewFileURI(getter_AddRefs(outputURI), aFile);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsAutoCString fileUriSpec;
+      rv = outputURI->GetSpec(fileUriSpec);
+      NS_ENSURE_SUCCESS(rv, rv);
+      saveState->m_savedFiles.AppendElement(fileUriSpec);
+    }
+  }
+
+  urlString = aURL;
+  // strip out ?type=application/x-message-display because it confuses libmime
+
+  int32_t typeIndex = urlString.Find("?type=application/x-message-display");
+  if (typeIndex != kNotFound)
+  {
+    urlString.Cut(typeIndex, sizeof("?type=application/x-message-display") - 1);
+    // we also need to replace the next '&' with '?'
+    int32_t firstPartIndex = urlString.FindChar('&');
+    if (firstPartIndex != kNotFound)
+      urlString.SetCharAt('?', firstPartIndex);
+  }
+
+  MsgReplaceSubstring(urlString, "/;section", "?section");
+  nsresult rv = CreateStartupUrl(urlString.get(), getter_AddRefs(URL));
+
+  if (NS_SUCCEEDED(rv))
+  {
+    rv = GetMessageServiceFromURI(aMessageUri, getter_AddRefs(messageService));
+    if (NS_SUCCEEDED(rv))
+    {
+      fetchService = do_QueryInterface(messageService);
+      // if the message service has a fetch part service then we know we can fetch mime parts...
+      if (fetchService)
+      {
+        int32_t partPos = urlString.FindChar('?');
+        if (partPos == kNotFound)
+          return NS_ERROR_FAILURE;
+        fullMessageUri.Append(Substring(urlString, partPos));
+      }
+
+      nsCOMPtr<nsIStreamListener> convertedListener;
+      saveListener->QueryInterface(NS_GET_IID(nsIStreamListener),
+                                 getter_AddRefs(convertedListener));
+
+#ifndef XP_MACOSX
+      // if the content type is bin hex we are going to do a hokey hack and make sure we decode the bin hex
+      // when saving an attachment to disk..
+      if (MsgLowerCaseEqualsLiteral(aContentType, APPLICATION_BINHEX))
+      {
+        nsCOMPtr<nsIStreamListener> listener (do_QueryInterface(convertedListener));
+        nsCOMPtr<nsIStreamConverterService> streamConverterService = do_GetService("@mozilla.org/streamConverters;1", &rv);
+        nsCOMPtr<nsISupports> channelSupport = do_QueryInterface(saveListener->m_channel);
+
+        rv = streamConverterService->AsyncConvertData(APPLICATION_BINHEX,
+                                                      "*/*",
+                                                      listener,
+                                                      channelSupport,
+                                                      getter_AddRefs(convertedListener));
+      }
+#endif
+      nsCOMPtr<nsIURI> dummyNull;
+      if (fetchService)
+        rv = fetchService->FetchMimePart(URL, fullMessageUri.get(),
+                                         convertedListener, mMsgWindow,
+                                         saveListener, getter_AddRefs(dummyNull));
+      else
+        rv = messageService->DisplayMessage(fullMessageUri.get(),
+                                            convertedListener, mMsgWindow,
+                                            nullptr, nullptr,
+                                            getter_AddRefs(dummyNull));
+    } // if we got a message service
+  } // if we created a url
+
+  if (NS_FAILED(rv))
+    Alert("saveAttachmentFailed");
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessenger::OpenAttachment(const nsACString& aContentType, const nsACString& aURL,
+                            const nsACString& aDisplayName, const nsACString& aMessageUri, bool aIsExternalAttachment)
+{
+  nsresult rv = NS_OK;
+
+  // open external attachments inside our message pane which in turn should trigger the
+  // helper app dialog...
+  if (aIsExternalAttachment)
+    rv = OpenURL(aURL);
+  else
+  {
+    nsCOMPtr <nsIMsgMessageService> messageService;
+    rv = GetMessageServiceFromURI(aMessageUri, getter_AddRefs(messageService));
+    if (messageService)
+      rv = messageService->OpenAttachment(PromiseFlatCString(aContentType).get(), PromiseFlatCString(aDisplayName).get(),
+                                          PromiseFlatCString(aURL).get(), PromiseFlatCString(aMessageUri).get(),
+                                          mDocShell, mMsgWindow, nullptr);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessenger::SaveAttachmentToFolder(const nsACString& contentType, const nsACString& url, const nsACString& displayName,
+                                    const nsACString& messageUri, nsIFile * aDestFolder, nsIFile ** aOutFile)
+{
+  NS_ENSURE_ARG_POINTER(aDestFolder);
+  nsresult rv;
+
+  nsCOMPtr<nsIFile> attachmentDestination;
+  rv = aDestFolder->Clone(getter_AddRefs(attachmentDestination));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsString unescapedFileName;
+  ConvertAndSanitizeFileName(PromiseFlatCString(displayName).get(), unescapedFileName);
+  rv = attachmentDestination->Append(unescapedFileName);
+  NS_ENSURE_SUCCESS(rv, rv);
+#ifdef XP_MACOSX
+  rv = attachmentDestination->CreateUnique(nsIFile::NORMAL_FILE_TYPE, ATTACHMENT_PERMISSION);
+  NS_ENSURE_SUCCESS(rv, rv);
+#endif
+
+  rv = SaveAttachment(attachmentDestination, url, messageUri, contentType, nullptr, nullptr);
+  attachmentDestination.swap(*aOutFile);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessenger::SaveAttachment(const nsACString& aContentType, const nsACString& aURL,
+                            const nsACString& aDisplayName, const nsACString& aMessageUri, bool aIsExternalAttachment)
+{
+  // open external attachments inside our message pane which in turn should trigger the
+  // helper app dialog...
+  if (aIsExternalAttachment)
+    return OpenURL(aURL);
+  return SaveOneAttachment(PromiseFlatCString(aContentType).get(),
+                           PromiseFlatCString(aURL).get(),
+                           PromiseFlatCString(aDisplayName).get(),
+                           PromiseFlatCString(aMessageUri).get(),
+                           false);
+}
+
+nsresult
+nsMessenger::SaveOneAttachment(const char * aContentType, const char * aURL,
+                               const char * aDisplayName, const char * aMessageUri,
+                               bool detaching)
+{
+  nsresult rv = NS_ERROR_OUT_OF_MEMORY;
+  nsCOMPtr<nsIFilePicker> filePicker =
+      do_CreateInstance("@mozilla.org/filepicker;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int16_t dialogResult;
+  nsCOMPtr<nsIFile> localFile;
+  nsCOMPtr<nsIFile> lastSaveDir;
+  nsCString filePath;
+  nsString saveAttachmentStr;
+  nsString defaultDisplayString;
+  ConvertAndSanitizeFileName(aDisplayName, defaultDisplayString);
+
+  GetString(NS_LITERAL_STRING("SaveAttachment"), saveAttachmentStr);
+  filePicker->Init(mWindow, saveAttachmentStr,
+                   nsIFilePicker::modeSave);
+  filePicker->SetDefaultString(defaultDisplayString);
+
+  // Check if the attachment file name has an extension (which must not
+  // contain spaces) and set it as the default extension for the attachment.
+  int32_t extensionIndex = defaultDisplayString.RFindChar('.');
+  if (extensionIndex > 0 &&
+      defaultDisplayString.FindChar(' ', extensionIndex) == kNotFound)
+  {
+    nsString extension;
+    extension = Substring(defaultDisplayString, extensionIndex + 1);
+    filePicker->SetDefaultExtension(extension);
+    if (!mStringBundle)
+    {
+      rv = InitStringBundle();
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    nsString filterName;
+    const char16_t *extensionParam[] = { extension.get() };
+    rv = mStringBundle->FormatStringFromName(
+      u"saveAsType", extensionParam, 1, getter_Copies(filterName));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    extension.Insert(NS_LITERAL_STRING("*."), 0);
+    filePicker->AppendFilter(filterName, extension);
+  }
+
+  filePicker->AppendFilters(nsIFilePicker::filterAll);
+
+  rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
+  if (NS_SUCCEEDED(rv) && lastSaveDir)
+    filePicker->SetDisplayDirectory(lastSaveDir);
+
+  rv = filePicker->Show(&dialogResult);
+  if (NS_FAILED(rv) || dialogResult == nsIFilePicker::returnCancel)
+    return rv;
+
+  rv = filePicker->GetFile(getter_AddRefs(localFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  SetLastSaveDirectory(localFile);
+
+  nsCString dirName;
+  rv = localFile->GetNativePath(dirName);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsSaveAllAttachmentsState *saveState = 
+    new nsSaveAllAttachmentsState(1,
+                                  &aContentType,
+                                  &aURL,
+                                  &aDisplayName,
+                                  &aMessageUri,
+                                  dirName.get(),
+                                  detaching);
+
+  return SaveAttachment(localFile, nsDependentCString(aURL), nsDependentCString(aMessageUri),
+                        nsDependentCString(aContentType), (void *)saveState, nullptr);
+}
+
+
+NS_IMETHODIMP
+nsMessenger::SaveAllAttachments(uint32_t count,
+                                const char **contentTypeArray,
+                                const char **urlArray,
+                                const char **displayNameArray,
+                                const char **messageUriArray)
+{
+  if (!count)
+    return NS_ERROR_INVALID_ARG;
+  return SaveAllAttachments(count, contentTypeArray, urlArray, displayNameArray, messageUriArray, false);
+}
+
+nsresult
+nsMessenger::SaveAllAttachments(uint32_t count,
+                                const char **contentTypeArray,
+                                const char **urlArray,
+                                const char **displayNameArray,
+                                const char **messageUriArray,
+                                bool detaching)
+{
+  nsresult rv = NS_ERROR_OUT_OF_MEMORY;
+  nsCOMPtr<nsIFilePicker> filePicker =
+    do_CreateInstance("@mozilla.org/filepicker;1", &rv);
+  nsCOMPtr<nsIFile> localFile;
+  nsCOMPtr<nsIFile> lastSaveDir;
+  int16_t dialogResult;
+  nsString saveAttachmentStr;
+
+  NS_ENSURE_SUCCESS(rv, rv);
+  GetString(NS_LITERAL_STRING("SaveAllAttachments"), saveAttachmentStr);
+  filePicker->Init(mWindow,
+                   saveAttachmentStr,
+                   nsIFilePicker::modeGetFolder);
+
+  rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
+  if (NS_SUCCEEDED(rv) && lastSaveDir)
+    filePicker->SetDisplayDirectory(lastSaveDir);
+
+  rv = filePicker->Show(&dialogResult);
+  if (NS_FAILED(rv) || dialogResult == nsIFilePicker::returnCancel)
+    return rv;
+
+  rv = filePicker->GetFile(getter_AddRefs(localFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = SetLastSaveDirectory(localFile);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString dirName;
+  nsSaveAllAttachmentsState *saveState = nullptr;
+  rv = localFile->GetNativePath(dirName);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  saveState = new nsSaveAllAttachmentsState(count,
+                                            contentTypeArray,
+                                            urlArray,
+                                            displayNameArray,
+                                            messageUriArray,
+                                            dirName.get(),
+                                            detaching);
+  nsString unescapedName;
+  ConvertAndSanitizeFileName(displayNameArray[0], unescapedName);
+  rv = localFile->Append(unescapedName);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = PromptIfFileExists(localFile);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = SaveAttachment(localFile, nsDependentCString(urlArray[0]), nsDependentCString(messageUriArray[0]),
+                      nsDependentCString(contentTypeArray[0]), (void *)saveState, nullptr);
+  return rv;
+}
+
+enum MESSENGER_SAVEAS_FILE_TYPE
+{
+ EML_FILE_TYPE =  0,
+ HTML_FILE_TYPE = 1,
+ TEXT_FILE_TYPE = 2,
+ ANY_FILE_TYPE = 3
+};
+#define HTML_FILE_EXTENSION ".htm"
+#define HTML_FILE_EXTENSION2 ".html"
+#define TEXT_FILE_EXTENSION ".txt"
+
+/**
+ * Adjust the file name, removing characters from the middle of the name if
+ * the name would otherwise be too long - too long for what file systems
+ * usually support.
+ */
+nsresult nsMessenger::AdjustFileIfNameTooLong(nsIFile* aFile)
+{
+  NS_ENSURE_ARG_POINTER(aFile);
+  nsAutoString path;
+  nsresult rv = aFile->GetPath(path);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Most common file systems have a max filename length of 255. On windows, the
+  // total path length is (at least for all practical purposees) limited to 255.
+  // Let's just don't allow paths longer than that elsewhere either for
+  // simplicity.
+  uint32_t MAX = 255;
+  if (path.Length() > MAX) {
+    nsAutoString leafName;
+    rv = aFile->GetLeafName(leafName);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    uint32_t pathLengthUpToLeaf = path.Length() - leafName.Length();
+    if (pathLengthUpToLeaf >= MAX - 8) { // want at least 8 chars for name
+      return NS_ERROR_FILE_NAME_TOO_LONG;
+    }
+    uint32_t x = MAX - pathLengthUpToLeaf; // x = max leaf size
+    nsAutoString truncatedLeaf;
+    truncatedLeaf.Append(Substring(leafName, 0, x/2));
+    truncatedLeaf.AppendLiteral("...");
+    truncatedLeaf.Append(Substring(leafName, leafName.Length() - x/2 + 3,
+                                   leafName.Length()));
+    rv = aFile->SetLeafName(truncatedLeaf);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessenger::SaveAs(const nsACString& aURI, bool aAsFile,
+                    nsIMsgIdentity *aIdentity, const nsAString& aMsgFilename,
+                    bool aBypassFilePicker)
+{
+  nsCOMPtr<nsIMsgMessageService> messageService;
+  nsCOMPtr<nsIUrlListener> urlListener;
+  nsSaveMsgListener *saveListener = nullptr;
+  nsCOMPtr<nsIURI> url;
+  nsCOMPtr<nsIStreamListener> convertedListener;
+  int32_t saveAsFileType = EML_FILE_TYPE;
+
+  nsresult rv = GetMessageServiceFromURI(aURI, getter_AddRefs(messageService));
+  if (NS_FAILED(rv))
+    goto done;
+
+  if (aAsFile)
+  {
+    nsCOMPtr<nsIFile> saveAsFile;
+    // show the file picker if BypassFilePicker is not specified (null) or false
+    if (!aBypassFilePicker) {
+      rv = GetSaveAsFile(aMsgFilename, &saveAsFileType, getter_AddRefs(saveAsFile));
+      // A null saveAsFile means that the user canceled the save as
+      if (NS_FAILED(rv) || !saveAsFile)
+        goto done;
+    }
+    else {
+      saveAsFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+      rv = saveAsFile->InitWithPath(aMsgFilename);
+      if (NS_FAILED(rv))
+        goto done;      
+      if (StringEndsWith(aMsgFilename, NS_LITERAL_STRING(TEXT_FILE_EXTENSION),
+                         nsCaseInsensitiveStringComparator()))
+        saveAsFileType = TEXT_FILE_TYPE;
+      else if ((StringEndsWith(aMsgFilename,
+                               NS_LITERAL_STRING(HTML_FILE_EXTENSION),
+                               nsCaseInsensitiveStringComparator())) ||
+               (StringEndsWith(aMsgFilename,
+                               NS_LITERAL_STRING(HTML_FILE_EXTENSION2),
+                               nsCaseInsensitiveStringComparator())))
+        saveAsFileType = HTML_FILE_TYPE;
+      else
+        saveAsFileType = EML_FILE_TYPE;
+    }
+
+    rv = AdjustFileIfNameTooLong(saveAsFile);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = PromptIfFileExists(saveAsFile);
+    if (NS_FAILED(rv)) {
+      goto done;
+    }
+
+    // After saveListener goes out of scope, the listener will be owned by
+    // whoever the listener is registered with, usually a URL.
+    RefPtr<nsSaveMsgListener> saveListener = new nsSaveMsgListener(saveAsFile, this, nullptr);
+    if (!saveListener) {
+      rv = NS_ERROR_OUT_OF_MEMORY;
+      goto done;
+    }
+    rv = saveListener->QueryInterface(NS_GET_IID(nsIUrlListener), getter_AddRefs(urlListener));
+    if (NS_FAILED(rv))
+      goto done;
+
+    if (saveAsFileType == EML_FILE_TYPE)
+    {
+      nsCOMPtr<nsIURI> dummyNull;
+      rv = messageService->SaveMessageToDisk(PromiseFlatCString(aURI).get(), saveAsFile, false,
+        urlListener, getter_AddRefs(dummyNull),
+        true, mMsgWindow);
+    }
+    else
+    {
+      nsAutoCString urlString(aURI);
+
+      // we can't go RFC822 to TXT until bug #1775 is fixed
+      // so until then, do the HTML to TXT conversion in
+      // nsSaveMsgListener::OnStopRequest(), see ConvertBufToPlainText()
+      //
+      // Setup the URL for a "Save As..." Operation...
+      // For now, if this is a save as TEXT operation, then do
+      // a "printing" operation
+      if (saveAsFileType == TEXT_FILE_TYPE)
+      {
+        saveListener->m_outputFormat = nsSaveMsgListener::ePlainText;
+        saveListener->m_doCharsetConversion = true;
+        urlString.AppendLiteral("?header=print");
+      }
+      else
+      {
+        saveListener->m_outputFormat = nsSaveMsgListener::eHTML;
+        saveListener->m_doCharsetConversion = false;
+        urlString.AppendLiteral("?header=saveas");
+      }
+
+      rv = CreateStartupUrl(urlString.get(), getter_AddRefs(url));
+      NS_ASSERTION(NS_SUCCEEDED(rv), "CreateStartupUrl failed");
+      if (NS_FAILED(rv))
+        goto done;
+
+      nsCOMPtr<nsIPrincipal> nullPrincipal =
+        do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
+      NS_ASSERTION(NS_SUCCEEDED(rv), "CreateInstance of nullprincipal failed");
+      if (NS_FAILED(rv))
+        goto done;
+
+      saveListener->m_channel = nullptr;
+      rv = NS_NewInputStreamChannel(getter_AddRefs(saveListener->m_channel),
+                                    url,
+                                    nullptr,
+                                    nullPrincipal,
+                                    nsILoadInfo::SEC_NORMAL,
+                                    nsIContentPolicy::TYPE_OTHER);
+      NS_ASSERTION(NS_SUCCEEDED(rv), "NS_NewChannel failed");
+      if (NS_FAILED(rv))
+        goto done;
+
+      nsCOMPtr<nsIStreamConverterService> streamConverterService = do_GetService("@mozilla.org/streamConverters;1");
+      nsCOMPtr<nsISupports> channelSupport = do_QueryInterface(saveListener->m_channel);
+
+      // we can't go RFC822 to TXT until bug #1775 is fixed
+      // so until then, do the HTML to TXT conversion in
+      // nsSaveMsgListener::OnStopRequest(), see ConvertBufToPlainText()
+      rv = streamConverterService->AsyncConvertData(MESSAGE_RFC822,
+        TEXT_HTML,
+        saveListener,
+        channelSupport,
+        getter_AddRefs(convertedListener));
+      NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncConvertData failed");
+      if (NS_FAILED(rv))
+        goto done;
+
+      nsCOMPtr<nsIURI> dummyNull;
+      rv = messageService->DisplayMessage(urlString.get(), convertedListener, mMsgWindow,
+        nullptr, nullptr, getter_AddRefs(dummyNull));
+    }
+  }
+  else
+  {
+    // ** save as Template
+    nsCOMPtr <nsIFile> tmpFile;
+    nsresult rv = GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR,
+                                                  "nsmail.tmp",
+                                                  getter_AddRefs(tmpFile));
+
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // For temp file, we should use restrictive 00600 instead of ATTACHMENT_PERMISSION 
+    rv = tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
+    if (NS_FAILED(rv)) goto done;
+
+    // The saveListener is owned by whoever we ultimately register the
+    // listener with, generally a URL.
+    saveListener = new nsSaveMsgListener(tmpFile, this, nullptr);
+    if (!saveListener) {
+      rv = NS_ERROR_OUT_OF_MEMORY;
+      goto done;
+    }
+
+    if (aIdentity)
+      rv = aIdentity->GetStationeryFolder(saveListener->m_templateUri);
+    if (NS_FAILED(rv))
+      goto done;
+
+    bool needDummyHeader = StringBeginsWith(saveListener->m_templateUri, NS_LITERAL_CSTRING("mailbox://"));
+    bool canonicalLineEnding = StringBeginsWith(saveListener->m_templateUri, NS_LITERAL_CSTRING("imap://"));
+
+    rv = saveListener->QueryInterface(
+      NS_GET_IID(nsIUrlListener),
+      getter_AddRefs(urlListener));
+    if (NS_FAILED(rv))
+      goto done;
+
+    nsCOMPtr<nsIURI> dummyNull;
+    rv = messageService->SaveMessageToDisk(PromiseFlatCString(aURI).get(), tmpFile,
+      needDummyHeader,
+      urlListener, getter_AddRefs(dummyNull),
+      canonicalLineEnding, mMsgWindow);
+  }
+
+done:
+  if (NS_FAILED(rv))
+  {
+    NS_IF_RELEASE(saveListener);
+    Alert("saveMessageFailed");
+  }
+  return rv;
+}
+
+nsresult
+nsMessenger::GetSaveAsFile(const nsAString& aMsgFilename, int32_t *aSaveAsFileType,
+                           nsIFile **aSaveAsFile)
+{
+  nsresult rv;
+  nsCOMPtr<nsIFilePicker> filePicker = do_CreateInstance("@mozilla.org/filepicker;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsString saveMailAsStr;
+  GetString(NS_LITERAL_STRING("SaveMailAs"), saveMailAsStr);
+  filePicker->Init(mWindow, saveMailAsStr, nsIFilePicker::modeSave);
+
+  // if we have a non-null filename use it, otherwise use default save message one
+  if (aMsgFilename.IsEmpty())
+  {
+    nsString saveMsgStr;
+    GetString(NS_LITERAL_STRING("defaultSaveMessageAsFileName"), saveMsgStr);
+    filePicker->SetDefaultString(saveMsgStr);
+  }
+  else
+  {
+    filePicker->SetDefaultString(aMsgFilename);
+  }
+
+  // because we will be using GetFilterIndex()
+  // we must call AppendFilters() one at a time,
+  // in MESSENGER_SAVEAS_FILE_TYPE order
+  nsString emlFilesStr;
+  GetString(NS_LITERAL_STRING("EMLFiles"), emlFilesStr);
+  filePicker->AppendFilter(emlFilesStr,
+                           NS_LITERAL_STRING("*.eml"));
+  filePicker->AppendFilters(nsIFilePicker::filterHTML);
+  filePicker->AppendFilters(nsIFilePicker::filterText);
+  filePicker->AppendFilters(nsIFilePicker::filterAll);
+
+  // Save as the "All Files" file type by default. We want to save as .eml by
+  // default, but the filepickers on some platforms don't switch extensions
+  // based on the file type selected (bug 508597).
+  filePicker->SetFilterIndex(ANY_FILE_TYPE);
+  // Yes, this is fine even if we ultimately save as HTML or text. On Windows,
+  // this actually is a boolean telling the file picker to automatically add
+  // the correct extension depending on the filter. On Mac or Linux this is a
+  // no-op.
+  filePicker->SetDefaultExtension(NS_LITERAL_STRING("eml"));
+
+  int16_t dialogResult;
+
+  nsCOMPtr <nsIFile> lastSaveDir;
+  rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
+  if (NS_SUCCEEDED(rv) && lastSaveDir)
+    filePicker->SetDisplayDirectory(lastSaveDir);
+
+  nsCOMPtr<nsIFile> localFile;
+  rv = filePicker->Show(&dialogResult);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (dialogResult == nsIFilePicker::returnCancel)
+  {
+    // We'll indicate this by setting the outparam to null.
+    *aSaveAsFile = nullptr;
+    return NS_OK;
+  }
+
+  rv = filePicker->GetFile(getter_AddRefs(localFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = SetLastSaveDirectory(localFile);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t selectedSaveAsFileType;
+  rv = filePicker->GetFilterIndex(&selectedSaveAsFileType);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If All Files was selected, look at the extension
+  if (selectedSaveAsFileType == ANY_FILE_TYPE)
+  {
+    nsAutoString fileName;
+    rv = localFile->GetLeafName(fileName);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (StringEndsWith(fileName, NS_LITERAL_STRING(HTML_FILE_EXTENSION),
+                       nsCaseInsensitiveStringComparator()) ||
+        StringEndsWith(fileName, NS_LITERAL_STRING(HTML_FILE_EXTENSION2),
+                       nsCaseInsensitiveStringComparator()))
+      *aSaveAsFileType = HTML_FILE_TYPE;
+    else if (StringEndsWith(fileName, NS_LITERAL_STRING(TEXT_FILE_EXTENSION),
+                            nsCaseInsensitiveStringComparator()))
+      *aSaveAsFileType = TEXT_FILE_TYPE;
+    else
+      // The default is .eml
+      *aSaveAsFileType = EML_FILE_TYPE;
+  }
+  else
+  {
+    *aSaveAsFileType = selectedSaveAsFileType;
+  }
+
+  if (dialogResult == nsIFilePicker::returnReplace)
+  {
+    // be extra safe and only delete when the file is really a file
+    bool isFile;
+    rv = localFile->IsFile(&isFile);
+    if (NS_SUCCEEDED(rv) && isFile)
+    {
+      rv = localFile->Remove(false /* recursive delete */);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    else
+    {
+      // We failed, or this isn't a file. We can't do anything about it.
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  *aSaveAsFile = nullptr;
+  localFile.swap(*aSaveAsFile);
+  return NS_OK;
+}
+
+/**
+ * Show a Save All dialog allowing the user to pick which folder to save
+ * messages to.
+ * @param [out] aSaveDir directory to save to. Will be null on cancel.
+ */
+nsresult
+nsMessenger::GetSaveToDir(nsIFile **aSaveDir)
+{
+  nsresult rv;
+  nsCOMPtr<nsIFilePicker> filePicker =
+    do_CreateInstance("@mozilla.org/filepicker;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsString chooseFolderStr;
+  GetString(NS_LITERAL_STRING("ChooseFolder"), chooseFolderStr);
+  filePicker->Init(mWindow, chooseFolderStr, nsIFilePicker::modeGetFolder);
+
+  nsCOMPtr<nsIFile> lastSaveDir;
+  rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
+  if (NS_SUCCEEDED(rv) && lastSaveDir)
+    filePicker->SetDisplayDirectory(lastSaveDir);
+
+  int16_t dialogResult;
+  rv = filePicker->Show(&dialogResult);
+  if (NS_FAILED(rv) || dialogResult == nsIFilePicker::returnCancel)
+  {
+    // We'll indicate this by setting the outparam to null.
+    *aSaveDir = nullptr;
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIFile> dir;
+  rv = filePicker->GetFile(getter_AddRefs(dir));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = SetLastSaveDirectory(dir);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aSaveDir = nullptr;
+  dir.swap(*aSaveDir);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessenger::SaveMessages(uint32_t aCount,
+                          const char16_t **aFilenameArray,
+                          const char **aMessageUriArray)
+{
+  NS_ENSURE_ARG_MIN(aCount, 1);
+  NS_ENSURE_ARG_POINTER(aFilenameArray);
+  NS_ENSURE_ARG_POINTER(aMessageUriArray);
+
+  nsresult rv;
+
+  nsCOMPtr<nsIFile> saveDir;
+  rv = GetSaveToDir(getter_AddRefs(saveDir));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!saveDir) // A null saveDir means that the user canceled the save.
+    return NS_OK;
+
+  for (uint32_t i = 0; i < aCount; i++) {
+    if (!aFilenameArray[i]) // just to be sure
+      return NS_ERROR_FAILURE;
+
+    nsCOMPtr<nsIFile> saveToFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = saveToFile->InitWithFile(saveDir);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = saveToFile->Append(nsDependentString(aFilenameArray[i]));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = AdjustFileIfNameTooLong(saveToFile);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = PromptIfFileExists(saveToFile);
+    if (NS_FAILED(rv))
+      continue;
+
+    nsCOMPtr<nsIMsgMessageService> messageService;
+    nsCOMPtr<nsIUrlListener> urlListener;
+
+    rv = GetMessageServiceFromURI(nsDependentCString(aMessageUriArray[i]),
+                                  getter_AddRefs(messageService));
+    if (NS_FAILED(rv)) {
+      Alert("saveMessageFailed");
+      return rv;
+    }
+
+    nsSaveMsgListener *saveListener = new nsSaveMsgListener(saveToFile, this, nullptr);
+    if (!saveListener) {
+      NS_IF_RELEASE(saveListener);
+      Alert("saveMessageFailed");
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    NS_ADDREF(saveListener);
+
+    rv = saveListener->QueryInterface(NS_GET_IID(nsIUrlListener),
+                                      getter_AddRefs(urlListener));
+    if (NS_FAILED(rv)) {
+      NS_IF_RELEASE(saveListener);
+      Alert("saveMessageFailed");
+      return rv;
+    }
+
+    // Ok, now save the message.
+    nsCOMPtr<nsIURI> dummyNull;
+    rv = messageService->SaveMessageToDisk(aMessageUriArray[i],
+                                           saveToFile, false,
+                                           urlListener, getter_AddRefs(dummyNull),
+                                           true, mMsgWindow);
+    if (NS_FAILED(rv)) {
+      NS_IF_RELEASE(saveListener);
+      Alert("saveMessageFailed");
+      return rv;
+    }
+  }
+  return rv;
+}
+
+nsresult
+nsMessenger::Alert(const char *stringName)
+{
+  nsresult rv = NS_OK;
+
+  if (mDocShell)
+  {
+    nsCOMPtr<nsIPrompt> dialog(do_GetInterface(mDocShell));
+
+    if (dialog)
+    {
+      nsString alertStr;
+      GetString(NS_ConvertASCIItoUTF16(stringName), alertStr);
+      rv = dialog->Alert(nullptr, alertStr.get());
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessenger::MessageServiceFromURI(const nsACString& aUri, nsIMsgMessageService **aMsgService)
+{
+  NS_ENSURE_ARG_POINTER(aMsgService);
+  return GetMessageServiceFromURI(aUri, aMsgService);
+}
+
+NS_IMETHODIMP
+nsMessenger::MsgHdrFromURI(const nsACString& aUri, nsIMsgDBHdr **aMsgHdr)
+{
+  NS_ENSURE_ARG_POINTER(aMsgHdr);
+  nsCOMPtr <nsIMsgMessageService> msgService;
+  nsresult rv;
+
+
+  if (mMsgWindow &&
+      (StringBeginsWith(aUri, NS_LITERAL_CSTRING("file:")) ||
+       PromiseFlatCString(aUri).Find("type=application/x-message-display") >= 0))
+  {
+    nsCOMPtr <nsIMsgHeaderSink> headerSink;
+    mMsgWindow->GetMsgHeaderSink(getter_AddRefs(headerSink));
+    if (headerSink)
+    {
+      rv = headerSink->GetDummyMsgHeader(aMsgHdr);
+      // Is there a way to check if they're asking for the hdr currently
+      // displayed in a stand-alone msg window from a .eml file?
+      // (pretty likely if this is a file: uri)
+      return rv;
+    }
+  }
+
+  rv = GetMessageServiceFromURI(aUri, getter_AddRefs(msgService));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return msgService->MessageURIToMsgHdr(PromiseFlatCString(aUri).get(), aMsgHdr);
+}
+
+NS_IMETHODIMP nsMessenger::GetUndoTransactionType(uint32_t *txnType)
+{
+  NS_ENSURE_TRUE(txnType && mTxnMgr, NS_ERROR_NULL_POINTER);
+
+  nsresult rv;
+  *txnType = nsMessenger::eUnknown;
+  nsCOMPtr<nsITransaction> txn;
+  rv = mTxnMgr->PeekUndoStack(getter_AddRefs(txn));
+  if (NS_SUCCEEDED(rv) && txn)
+  {
+    nsCOMPtr <nsIPropertyBag2> propertyBag = do_QueryInterface(txn, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return propertyBag->GetPropertyAsUint32(NS_LITERAL_STRING("type"), txnType);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMessenger::CanUndo(bool *bValue)
+{
+  NS_ENSURE_TRUE(bValue && mTxnMgr, NS_ERROR_NULL_POINTER);
+
+  nsresult rv;
+  *bValue = false;
+  int32_t count = 0;
+  rv = mTxnMgr->GetNumberOfUndoItems(&count);
+  if (NS_SUCCEEDED(rv) && count > 0)
+    *bValue = true;
+  return rv;
+}
+
+NS_IMETHODIMP nsMessenger::GetRedoTransactionType(uint32_t *txnType)
+{
+  NS_ENSURE_TRUE(txnType && mTxnMgr, NS_ERROR_NULL_POINTER);
+
+  nsresult rv;
+  *txnType = nsMessenger::eUnknown;
+  nsCOMPtr<nsITransaction> txn;
+  rv = mTxnMgr->PeekRedoStack(getter_AddRefs(txn));
+  if (NS_SUCCEEDED(rv) && txn)
+  {
+    nsCOMPtr <nsIPropertyBag2> propertyBag = do_QueryInterface(txn, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return propertyBag->GetPropertyAsUint32(NS_LITERAL_STRING("type"), txnType);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMessenger::CanRedo(bool *bValue)
+{
+  NS_ENSURE_TRUE(bValue && mTxnMgr, NS_ERROR_NULL_POINTER);
+
+  nsresult rv;
+  *bValue = false;
+  int32_t count = 0;
+  rv = mTxnMgr->GetNumberOfRedoItems(&count);
+  if (NS_SUCCEEDED(rv) && count > 0)
+    *bValue = true;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessenger::Undo(nsIMsgWindow *msgWindow)
+{
+  nsresult rv = NS_OK;
+  if (mTxnMgr)
+  {
+    int32_t numTxn = 0;
+    rv = mTxnMgr->GetNumberOfUndoItems(&numTxn);
+    if (NS_SUCCEEDED(rv) && numTxn > 0)
+    {
+        nsCOMPtr<nsITransaction> txn;
+        rv = mTxnMgr->PeekUndoStack(getter_AddRefs(txn));
+        if (NS_SUCCEEDED(rv) && txn)
+        {
+            static_cast<nsMsgTxn*>(static_cast<nsITransaction*>(txn.get()))->SetMsgWindow(msgWindow);
+        }
+        mTxnMgr->UndoTransaction();
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessenger::Redo(nsIMsgWindow *msgWindow)
+{
+  nsresult rv = NS_OK;
+  if (mTxnMgr)
+  {
+    int32_t numTxn = 0;
+    rv = mTxnMgr->GetNumberOfRedoItems(&numTxn);
+    if (NS_SUCCEEDED(rv) && numTxn > 0)
+    {
+        nsCOMPtr<nsITransaction> txn;
+        rv = mTxnMgr->PeekRedoStack(getter_AddRefs(txn));
+        if (NS_SUCCEEDED(rv) && txn)
+        {
+            static_cast<nsMsgTxn*>(static_cast<nsITransaction*>(txn.get()))->SetMsgWindow(msgWindow);
+        }
+        mTxnMgr->RedoTransaction();
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessenger::GetTransactionManager(nsITransactionManager* *aTxnMgr)
+{
+  NS_ENSURE_TRUE(mTxnMgr && aTxnMgr, NS_ERROR_NULL_POINTER);
+
+  *aTxnMgr = mTxnMgr;
+  NS_ADDREF(*aTxnMgr);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMessenger::SetDocumentCharset(const nsACString& aCharacterSet)
+{
+  // We want to redisplay the currently selected message (if any) but forcing the
+  // redisplay to use characterSet
+  if (!mLastDisplayURI.IsEmpty())
+  {
+    SetDisplayCharset(NS_LITERAL_CSTRING("UTF-8"));
+
+    nsCOMPtr <nsIMsgMessageService> messageService;
+    nsresult rv = GetMessageServiceFromURI(mLastDisplayURI, getter_AddRefs(messageService));
+
+    if (NS_SUCCEEDED(rv) && messageService)
+    {
+      nsCOMPtr<nsIURI> dummyNull;
+      messageService->DisplayMessage(mLastDisplayURI.get(), mDocShell, mMsgWindow, nullptr,
+                                     PromiseFlatCString(aCharacterSet).get(), getter_AddRefs(dummyNull));
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessenger::GetLastDisplayedMessageUri(nsACString& aLastDisplayedMessageUri)
+{
+  aLastDisplayedMessageUri = mLastDisplayURI;
+  return NS_OK;
+}
+
+nsSaveMsgListener::nsSaveMsgListener(nsIFile* aFile, nsMessenger *aMessenger, nsIUrlListener *aListener)
+{
+  m_file = do_QueryInterface(aFile);
+  m_messenger = aMessenger;
+  mListener = aListener;
+  mUrlHasStopped = false;
+  mRequestHasStopped = false;
+  
+    // rhp: for charset handling
+  m_doCharsetConversion = false;
+  m_saveAllAttachmentsState = nullptr;
+  mProgress = 0;
+  mMaxProgress = -1;
+  mCanceled = false;
+  m_outputFormat = eUnknown;
+  mInitialized = false;
+}
+
+nsSaveMsgListener::~nsSaveMsgListener()
+{
+}
+
+//
+// nsISupports
+//
+NS_IMPL_ISUPPORTS(nsSaveMsgListener,
+                   nsIUrlListener,
+                   nsIMsgCopyServiceListener,
+                   nsIStreamListener,
+                   nsIRequestObserver,
+                   nsICancelable)
+
+NS_IMETHODIMP
+nsSaveMsgListener::Cancel(nsresult status)
+{
+  mCanceled = true;
+  return NS_OK;
+}
+
+//
+// nsIUrlListener
+//
+NS_IMETHODIMP
+nsSaveMsgListener::OnStartRunningUrl(nsIURI* url)
+{
+  if (mListener)
+    mListener->OnStartRunningUrl(url);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSaveMsgListener::OnStopRunningUrl(nsIURI *url, nsresult exitCode)
+{
+  nsresult rv = exitCode;
+  mUrlHasStopped = true;
+
+  // ** save as template goes here
+  if (!m_templateUri.IsEmpty()) 
+  {
+    nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+    if (NS_FAILED(rv)) goto done;
+    nsCOMPtr<nsIRDFResource> res;
+    rv = rdf->GetResource(m_templateUri, getter_AddRefs(res));
+    if (NS_FAILED(rv)) goto done;
+    nsCOMPtr<nsIMsgFolder> templateFolder;
+    templateFolder = do_QueryInterface(res, &rv);
+    if (NS_FAILED(rv)) goto done;
+    nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID);
+    if (copyService)
+    {
+      nsCOMPtr<nsIFile> clone;
+      m_file->Clone(getter_AddRefs(clone));
+      rv = copyService->CopyFileMessage(clone, templateFolder, nullptr,
+                                        true, nsMsgMessageFlags::Read,
+                                        EmptyCString(), this, nullptr);
+      // Clear this so we don't end up in a loop if OnStopRunningUrl gets
+      // called again.
+      m_templateUri.Truncate();
+    }
+  }
+  else if (m_outputStream && mRequestHasStopped)
+  {
+    m_outputStream->Close();
+    m_outputStream = nullptr;
+  }
+
+done:
+  if (NS_FAILED(rv))
+  {
+    if (m_file)
+      m_file->Remove(false);
+    if (m_messenger)
+        m_messenger->Alert("saveMessageFailed");
+  }
+  
+  if (mRequestHasStopped && mListener)
+    mListener->OnStopRunningUrl(url, exitCode);
+  else
+    mListenerUri = url;
+  
+  return rv;
+}
+
+NS_IMETHODIMP
+nsSaveMsgListener::OnStartCopy(void)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSaveMsgListener::OnProgress(uint32_t aProgress, uint32_t aProgressMax)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSaveMsgListener::SetMessageKey(nsMsgKey aKey)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsSaveMsgListener::GetMessageId(nsACString& aMessageId)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsSaveMsgListener::OnStopCopy(nsresult aStatus)
+{
+  if (m_file)
+    m_file->Remove(false);
+  return aStatus;
+}
+
+// initializes the progress window if we are going to show one
+// and for OSX, sets creator flags on the output file
+nsresult nsSaveMsgListener::InitializeDownload(nsIRequest * aRequest)
+{
+  nsresult rv = NS_OK;
+  
+  mInitialized = true;
+  nsCOMPtr<nsIChannel> channel (do_QueryInterface(aRequest));
+  
+  if (!channel)
+    return rv;
+  
+  // Get the max progress from the URL if we haven't already got it.
+  if (mMaxProgress == -1)
+  {
+    nsCOMPtr<nsIURI> uri;
+    channel->GetURI(getter_AddRefs(uri));
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(uri));
+    if (mailnewsUrl)
+      mailnewsUrl->GetMaxProgress(&mMaxProgress);
+  }
+  
+  if (!m_contentType.IsEmpty())
+  {
+    nsCOMPtr<nsIMIMEService> mimeService (do_GetService(NS_MIMESERVICE_CONTRACTID));
+    nsCOMPtr<nsIMIMEInfo> mimeinfo;
+    
+    mimeService->GetFromTypeAndExtension(m_contentType, EmptyCString(), getter_AddRefs(mimeinfo));
+    
+    // create a download progress window
+
+    // Set saveToDisk explicitly to avoid launching the saved file.
+    // See http://hg.mozilla.org/mozilla-central/file/814a6f071472/toolkit/components/jsdownloads/src/DownloadLegacy.js#l164
+    mimeinfo->SetPreferredAction(nsIHandlerInfo::saveToDisk);
+
+    // When we don't allow warnings, also don't show progress, as this
+    //  is an environment (typically filters) where we don't want
+    //  interruption.
+    bool allowProgress = true;
+    if (m_saveAllAttachmentsState)
+      allowProgress = !m_saveAllAttachmentsState->m_withoutWarning;
+    if (allowProgress)
+    {
+      nsCOMPtr<nsITransfer> tr = do_CreateInstance(NS_TRANSFER_CONTRACTID, &rv);
+      if (tr && m_file)
+      {
+        PRTime timeDownloadStarted = PR_Now();
+        
+        nsCOMPtr<nsIURI> outputURI;
+        NS_NewFileURI(getter_AddRefs(outputURI), m_file);
+        
+        nsCOMPtr<nsIURI> url;
+        channel->GetURI(getter_AddRefs(url));
+        rv = tr->Init(url, outputURI, EmptyString(), mimeinfo,
+                      timeDownloadStarted, nullptr, this, false);
+        
+          // now store the web progresslistener
+        mTransfer = tr;
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsSaveMsgListener::OnStartRequest(nsIRequest* request, nsISupports* aSupport)
+{
+  if (m_file)
+    MsgNewBufferedFileOutputStream(getter_AddRefs(m_outputStream), m_file, -1, ATTACHMENT_PERMISSION);
+  if (!m_outputStream)
+  {
+    mCanceled = true;
+    if (m_messenger)
+      m_messenger->Alert("saveAttachmentFailed");
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSaveMsgListener::OnStopRequest(nsIRequest* request, nsISupports* aSupport,
+                                 nsresult status)
+{
+  nsresult rv = NS_OK;
+  mRequestHasStopped = true;
+  
+  // rhp: If we are doing the charset conversion magic, this is different
+  // processing, otherwise, its just business as usual.
+  // If we need text/plain, then we need to convert the HTML and then convert
+  // to the systems charset.
+  if (m_doCharsetConversion && m_outputStream)
+  {
+    // For HTML, code is emitted immediately in OnDataAvailable.
+    MOZ_ASSERT(m_outputFormat == ePlainText,
+      "For HTML, m_doCharsetConversion shouldn't be set");
+    NS_ConvertUTF8toUTF16 utf16Buffer(m_msgBuffer);
+    ConvertBufToPlainText(utf16Buffer, false, false, false, false);
+
+    nsCString outCString;
+    rv = nsMsgI18NConvertFromUnicode(nsMsgI18NFileSystemCharset(),
+      utf16Buffer, outCString, false, true);
+    if (rv == NS_ERROR_UENC_NOMAPPING) {
+      // If we can't encode with the preferred charset, use UTF-8.
+      CopyUTF16toUTF8(utf16Buffer, outCString);
+      rv = NS_OK;
+    }
+    if (NS_SUCCEEDED(rv))
+    {
+      uint32_t writeCount;
+      rv = m_outputStream->Write(outCString.get(), outCString.Length(), &writeCount);
+      if (outCString.Length() != writeCount)
+        rv = NS_ERROR_FAILURE;
+    }
+  }
+ 
+  if (m_outputStream)
+  {
+    m_outputStream->Close();
+    m_outputStream = nullptr;
+  }
+  
+  if (m_saveAllAttachmentsState)
+  {
+    m_saveAllAttachmentsState->m_curIndex++;
+    if (!mCanceled && m_saveAllAttachmentsState->m_curIndex < m_saveAllAttachmentsState->m_count)
+    {
+      nsSaveAllAttachmentsState *state = m_saveAllAttachmentsState;
+      uint32_t i = state->m_curIndex;
+      nsString unescapedName;
+      nsCOMPtr<nsIFile> localFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+      if (NS_FAILED(rv)) goto done;
+      rv = localFile->InitWithNativePath(nsDependentCString(state->m_directoryName));
+      
+      if (NS_FAILED(rv)) goto done;
+      
+      ConvertAndSanitizeFileName(state->m_displayNameArray[i], unescapedName);
+      rv = localFile->Append(unescapedName);
+      if (NS_FAILED(rv))
+        goto done;
+
+      // When we are running with no warnings (typically filters and other automatic
+      //  uses), then don't prompt for duplicates, but create a unique file
+      //  instead.
+      if (!m_saveAllAttachmentsState->m_withoutWarning)
+      {
+        rv = m_messenger->PromptIfFileExists(localFile);
+        if (NS_FAILED(rv)) goto done;
+      }
+      else
+      {
+        rv = localFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, ATTACHMENT_PERMISSION);
+        if (NS_FAILED(rv)) goto done;
+      }
+      rv = m_messenger->SaveAttachment(localFile,
+                                       nsDependentCString(state->m_urlArray[i]),
+                                       nsDependentCString(state->m_messageUriArray[i]),
+                                       nsDependentCString(state->m_contentTypeArray[i]),
+                                       (void *)state, nullptr);
+      done:
+        if (NS_FAILED(rv))
+        {
+          delete state;
+          m_saveAllAttachmentsState = nullptr;
+        }
+    }
+    else
+    {
+          // check if we're saving attachments prior to detaching them.
+      if (m_saveAllAttachmentsState->m_detachingAttachments && !mCanceled)
+      {
+        nsSaveAllAttachmentsState *state = m_saveAllAttachmentsState;
+        m_messenger->DetachAttachments(state->m_count,
+                                       (const char **) state->m_contentTypeArray,
+                                       (const char **) state->m_urlArray,
+                                       (const char **) state->m_displayNameArray,
+                                       (const char **) state->m_messageUriArray,
+                                       &state->m_savedFiles,
+                                       state->m_withoutWarning);
+      }
+
+      delete m_saveAllAttachmentsState;
+      m_saveAllAttachmentsState = nullptr;
+    }
+  }
+
+  if(mTransfer)
+  {
+    mTransfer->OnProgressChange64(nullptr, nullptr, mMaxProgress, mMaxProgress, mMaxProgress, mMaxProgress);
+    mTransfer->OnStateChange(nullptr, nullptr, nsIWebProgressListener::STATE_STOP |
+      nsIWebProgressListener::STATE_IS_NETWORK, NS_OK);
+    mTransfer = nullptr; // break any circular dependencies between the progress dialog and use
+  }
+
+  if (mUrlHasStopped && mListener)
+    mListener->OnStopRunningUrl(mListenerUri, rv);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSaveMsgListener::OnDataAvailable(nsIRequest* request,
+                                  nsISupports* aSupport,
+                                  nsIInputStream* inStream,
+                                  uint64_t srcOffset,
+                                  uint32_t count)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+  // first, check to see if we've been canceled....
+  if (mCanceled) // then go cancel our underlying channel too
+    return request->Cancel(NS_BINDING_ABORTED);
+  
+  if (!mInitialized)
+    InitializeDownload(request);
+
+  if (m_outputStream)
+  {
+    mProgress += count;
+    uint64_t available;
+    uint32_t readCount, maxReadCount = sizeof(m_dataBuffer);
+    uint32_t writeCount;
+    rv = inStream->Available(&available);
+    while (NS_SUCCEEDED(rv) && available)
+    {
+      if (maxReadCount > available)
+        maxReadCount = (uint32_t)available;
+      rv = inStream->Read(m_dataBuffer, maxReadCount, &readCount);
+
+      // rhp:
+      // Ok, now we do one of two things. If we are sending out HTML, then
+      // just write it to the HTML stream as it comes along...but if this is
+      // a save as TEXT operation, we need to buffer this up for conversion
+      // when we are done. When the stream converter for HTML-TEXT gets in place,
+      // this magic can go away.
+      //
+      if (NS_SUCCEEDED(rv))
+      {
+        if ( (m_doCharsetConversion) && (m_outputFormat == ePlainText) )
+          m_msgBuffer.Append(Substring(m_dataBuffer, m_dataBuffer + readCount));
+        else
+          rv = m_outputStream->Write(m_dataBuffer, readCount, &writeCount);
+
+        available -= readCount;
+      }
+    }
+
+    if (NS_SUCCEEDED(rv) && mTransfer) // Send progress notification.
+      mTransfer->OnProgressChange64(nullptr, request, mProgress, mMaxProgress, mProgress, mMaxProgress);
+  }
+  return rv;
+}
+
+#define MESSENGER_STRING_URL       "chrome://messenger/locale/messenger.properties"
+
+nsresult
+nsMessenger::InitStringBundle()
+{
+  if (mStringBundle)
+    return NS_OK;
+
+  const char propertyURL[] = MESSENGER_STRING_URL;
+  nsCOMPtr<nsIStringBundleService> sBundleService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED);
+  return sBundleService->CreateBundle(propertyURL,
+                                      getter_AddRefs(mStringBundle));
+}
+
+void
+nsMessenger::GetString(const nsString& aStringName, nsString& aValue)
+{
+  nsresult rv;
+  aValue.Truncate();
+
+  if (!mStringBundle)
+    rv = InitStringBundle();
+
+  if (mStringBundle)
+    rv = mStringBundle->GetStringFromName(aStringName.get(), getter_Copies(aValue));
+  else
+    rv = NS_ERROR_FAILURE;
+
+  if (NS_FAILED(rv) || aValue.IsEmpty())
+    aValue = aStringName;
+  return;
+}
+
+nsSaveAllAttachmentsState::nsSaveAllAttachmentsState(uint32_t count,
+                                                     const char **contentTypeArray,
+                                                     const char **urlArray,
+                                                     const char **nameArray,
+                                                     const char **uriArray,
+                                                     const char *dirName,
+                                                     bool detachingAttachments)
+    : m_withoutWarning(false)
+{
+    uint32_t i;
+    NS_ASSERTION(count && urlArray && nameArray && uriArray && dirName,
+                 "fatal - invalid parameters\n");
+
+    m_count = count;
+    m_curIndex = 0;
+    m_contentTypeArray = new char*[count];
+    m_urlArray = new char*[count];
+    m_displayNameArray = new char*[count];
+    m_messageUriArray = new char*[count];
+    for (i = 0; i < count; i++)
+    {
+        m_contentTypeArray[i] = strdup(contentTypeArray[i]);
+        m_urlArray[i] = strdup(urlArray[i]);
+        m_displayNameArray[i] = strdup(nameArray[i]);
+        m_messageUriArray[i] = strdup(uriArray[i]);
+    }
+    m_directoryName = strdup(dirName);
+    m_detachingAttachments = detachingAttachments;
+}
+
+nsSaveAllAttachmentsState::~nsSaveAllAttachmentsState()
+{
+    uint32_t i;
+    for (i = 0; i < m_count; i++)
+    {
+      NS_Free(m_contentTypeArray[i]);
+      NS_Free(m_urlArray[i]);
+      NS_Free(m_displayNameArray[i]);
+      NS_Free(m_messageUriArray[i]);
+    }
+    delete[] m_contentTypeArray;
+    delete[] m_urlArray;
+    delete[] m_displayNameArray;
+    delete[] m_messageUriArray;
+    NS_Free(m_directoryName);
+}
+
+nsresult
+nsMessenger::GetLastSaveDirectory(nsIFile **aLastSaveDir)
+{
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // this can fail, and it will, on the first time we call it, as there is no default for this pref.
+  nsCOMPtr <nsIFile> localFile;
+  rv = prefBranch->GetComplexValue(MESSENGER_SAVE_DIR_PREF_NAME, NS_GET_IID(nsIFile), getter_AddRefs(localFile));
+  if (NS_SUCCEEDED(rv)) {
+    NS_IF_ADDREF(*aLastSaveDir = localFile);
+  }
+  return rv;
+}
+
+nsresult
+nsMessenger::SetLastSaveDirectory(nsIFile *aLocalFile)
+{
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr <nsIFile> file = do_QueryInterface(aLocalFile, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // if the file is a directory, just use it for the last dir chosen
+  // otherwise, use the parent of the file as the last dir chosen.
+  // IsDirectory() will return error on saving a file, as the
+  // file doesn't exist yet.
+  bool isDirectory;
+  rv = file->IsDirectory(&isDirectory);
+  if (NS_SUCCEEDED(rv) && isDirectory) {
+    rv = prefBranch->SetComplexValue(MESSENGER_SAVE_DIR_PREF_NAME, NS_GET_IID(nsIFile), aLocalFile);
+    NS_ENSURE_SUCCESS(rv,rv);
+  }
+  else {
+    nsCOMPtr <nsIFile> parent;
+    rv = file->GetParent(getter_AddRefs(parent));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = prefBranch->SetComplexValue(MESSENGER_SAVE_DIR_PREF_NAME, NS_GET_IID(nsIFile), parent);
+    NS_ENSURE_SUCCESS(rv,rv);
+  }
+  return NS_OK;
+}
+
+/* void getUrisAtNavigatePos (in long aPos, out ACString aFolderUri, out ACString aMsgUri); */
+// aPos is relative to the current history cursor - 1 is forward, -1 is back.
+NS_IMETHODIMP nsMessenger::GetMsgUriAtNavigatePos(int32_t aPos, nsACString& aMsgUri)
+{
+  int32_t desiredArrayIndex = (mCurHistoryPos + (aPos << 1));
+  if (desiredArrayIndex >= 0 && desiredArrayIndex < (int32_t)mLoadedMsgHistory.Length())
+  {
+    mNavigatingToUri = mLoadedMsgHistory[desiredArrayIndex];
+    aMsgUri = mNavigatingToUri;
+    return NS_OK;
+  }
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessenger::SetNavigatePos(int32_t aPos)
+{
+  if ((aPos << 1) < (int32_t)mLoadedMsgHistory.Length())
+  {
+    mCurHistoryPos = aPos << 1;
+    return NS_OK;
+  }
+  else
+    return NS_ERROR_INVALID_ARG;
+}
+
+NS_IMETHODIMP nsMessenger::GetNavigatePos(int32_t *aPos)
+{
+  NS_ENSURE_ARG_POINTER(aPos);
+  *aPos = mCurHistoryPos >> 1;
+  return NS_OK;
+}
+
+// aPos is relative to the current history cursor - 1 is forward, -1 is back.
+NS_IMETHODIMP nsMessenger::GetFolderUriAtNavigatePos(int32_t aPos, nsACString& aFolderUri)
+{
+  int32_t desiredArrayIndex = (mCurHistoryPos + (aPos << 1));
+  if (desiredArrayIndex >= 0 && desiredArrayIndex < (int32_t)mLoadedMsgHistory.Length())
+  {
+    mNavigatingToUri = mLoadedMsgHistory[desiredArrayIndex + 1];
+    aFolderUri = mNavigatingToUri;
+    return NS_OK;
+  }
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMessenger::GetNavigateHistory(uint32_t *aCurPos, uint32_t *aCount, char *** aHistoryUris)
+{
+  NS_ENSURE_ARG_POINTER(aCount);
+  NS_ENSURE_ARG_POINTER(aCurPos);
+
+  *aCurPos = mCurHistoryPos >> 1;
+  *aCount = mLoadedMsgHistory.Length();
+  // for just enabling commands, we don't need the history uris.
+  if (!aHistoryUris)
+    return NS_OK;
+
+  char **outArray, **next;
+  next = outArray = (char **)moz_xmalloc(*aCount * sizeof(char *));
+  if (!outArray) return NS_ERROR_OUT_OF_MEMORY;
+  for (uint32_t i = 0; i < *aCount; i++)
+  {
+    *next = ToNewCString(mLoadedMsgHistory[i]);
+    if (!*next)
+      return NS_ERROR_OUT_OF_MEMORY;
+    next++;
+  }
+  *aHistoryUris = outArray;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessenger::FormatFileSize(uint64_t aSize, bool aUseKB, nsAString& aFormattedSize)
+{
+  return ::FormatFileSize(aSize, aUseKB, aFormattedSize);
+}
+
+
+/* void OnItemAdded (in nsIMsgFolder parentItem, in nsISupports item); */
+NS_IMETHODIMP nsMessenger::OnItemAdded(nsIMsgFolder *parentItem, nsISupports *item)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void OnItemRemoved (in nsIMsgFolder parentItem, in nsISupports item); */
+NS_IMETHODIMP nsMessenger::OnItemRemoved(nsIMsgFolder *parentItem, nsISupports *item)
+{
+  // check if this item is a message header that's in our history list. If so,
+  // remove it from the history list.
+  nsCOMPtr <nsIMsgDBHdr> msgHdr = do_QueryInterface(item);
+  if (msgHdr)
+  {
+    nsCOMPtr <nsIMsgFolder> folder;
+    msgHdr->GetFolder(getter_AddRefs(folder));
+    if (folder)
+    {
+      nsCString msgUri;
+      nsMsgKey msgKey;
+      msgHdr->GetMessageKey(&msgKey);
+      folder->GenerateMessageURI(msgKey, msgUri);
+      // need to remove the correspnding folder entry, and
+      // adjust the current history pos.
+      size_t uriPos = mLoadedMsgHistory.IndexOf(msgUri);
+      if (uriPos != mLoadedMsgHistory.NoIndex)
+      {
+        mLoadedMsgHistory.RemoveElementAt(uriPos);
+        mLoadedMsgHistory.RemoveElementAt(uriPos); // and the folder uri entry
+        if (mCurHistoryPos >= (int32_t)uriPos)
+          mCurHistoryPos -= 2;
+      }
+    }
+  }
+  return NS_OK;
+}
+
+/* void OnItemPropertyChanged (in nsIMsgFolder item, in nsIAtom property, in string oldValue, in string newValue); */
+NS_IMETHODIMP nsMessenger::OnItemPropertyChanged(nsIMsgFolder *item, nsIAtom *property, const char *oldValue, const char *newValue)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void OnItemIntPropertyChanged (in nsIMsgFolder item, in nsIAtom property, in long long oldValue, in long long newValue); */
+NS_IMETHODIMP nsMessenger::OnItemIntPropertyChanged(nsIMsgFolder *item, nsIAtom *property, int64_t oldValue, int64_t newValue)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void OnItemBoolPropertyChanged (in nsIMsgFolder item, in nsIAtom property, in boolean oldValue, in boolean newValue); */
+NS_IMETHODIMP nsMessenger::OnItemBoolPropertyChanged(nsIMsgFolder *item, nsIAtom *property, bool oldValue, bool newValue)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void OnItemUnicharPropertyChanged (in nsIMsgFolder item, in nsIAtom property, in wstring oldValue, in wstring newValue); */
+NS_IMETHODIMP nsMessenger::OnItemUnicharPropertyChanged(nsIMsgFolder *item, nsIAtom *property, const char16_t *oldValue, const char16_t *newValue)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void OnItemPropertyFlagChanged (in nsIMsgDBHdr item, in nsIAtom property, in unsigned long oldFlag, in unsigned long newFlag); */
+NS_IMETHODIMP nsMessenger::OnItemPropertyFlagChanged(nsIMsgDBHdr *item, nsIAtom *property, uint32_t oldFlag, uint32_t newFlag)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void OnItemEvent (in nsIMsgFolder item, in nsIAtom event); */
+NS_IMETHODIMP nsMessenger::OnItemEvent(nsIMsgFolder *item, nsIAtom *event)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Detach/Delete Attachments
+///////////////////////////////////////////////////////////////////////////////
+
+static const char * GetAttachmentPartId(const char * aAttachmentUrl)
+{
+  static const char partIdPrefix[] = "part=";
+  const char * partId = PL_strstr(aAttachmentUrl, partIdPrefix);
+  return partId ? (partId + sizeof(partIdPrefix) - 1) : nullptr;
+}
+
+static int CompareAttachmentPartId(const char * aAttachUrlLeft, const char * aAttachUrlRight)
+{
+  // part ids are numbers separated by periods, like "1.2.3.4".
+  // we sort by doing a numerical comparison on each item in turn. e.g. "1.4" < "1.25"
+  // shorter entries come before longer entries. e.g. "1.4" < "1.4.1.2"
+  // return values:
+  //  -2  left is a parent of right
+  //  -1  left is less than right
+  //   0  left == right
+  //   1  right is greater than left
+  //   2  right is a parent of left
+
+  const char * partIdLeft  = GetAttachmentPartId(aAttachUrlLeft);
+  const char * partIdRight = GetAttachmentPartId(aAttachUrlRight);
+
+  // for detached attachments the URL does not contain any "part=xx"
+  if(!partIdLeft)
+    partIdLeft = "0";
+
+  if(!partIdRight)
+    partIdRight = "0";
+
+  long idLeft, idRight;
+  do
+  {
+    MOZ_ASSERT(partIdLeft && IS_DIGIT(*partIdLeft), "Invalid character in part id string");
+    MOZ_ASSERT(partIdRight && IS_DIGIT(*partIdRight), "Invalid character in part id string");
+
+    // if the part numbers are different then the numerically smaller one is first
+    char *fixConstLoss;
+    idLeft  = strtol(partIdLeft, &fixConstLoss, 10);
+    partIdLeft = fixConstLoss;
+    idRight = strtol(partIdRight, &fixConstLoss, 10);
+    partIdRight = fixConstLoss;
+    if (idLeft != idRight)
+      return idLeft < idRight ? -1 : 1;
+
+    // if one part id is complete but the other isn't, then the shortest one
+    // is first (parents before children)
+    if (*partIdLeft != *partIdRight)
+      return *partIdRight ? -2 : 2;
+
+    // if both part ids are complete (*partIdLeft == *partIdRight now) then
+    // they are equal
+    if (!*partIdLeft)
+      return 0;
+
+    MOZ_ASSERT(*partIdLeft == '.', "Invalid character in part id string");
+    MOZ_ASSERT(*partIdRight == '.', "Invalid character in part id string");
+
+    ++partIdLeft;
+    ++partIdRight;
+  }
+  while (true);
+  return 0;
+}
+
+// ------------------------------------
+
+// struct on purpose -> show that we don't ever want a vtable
+struct msgAttachment
+{
+  msgAttachment()
+    : mContentType(nullptr),
+      mUrl(nullptr),
+      mDisplayName(nullptr),
+      mMessageUri(nullptr)
+  {
+  }
+
+  ~msgAttachment()
+  {
+    Clear();
+  }
+
+  void Clear()
+  {
+    NS_Free(mContentType);
+    NS_Free(mUrl);
+    NS_Free(mDisplayName);
+    NS_Free(mMessageUri);
+  }
+
+  bool Init(const char * aContentType, const char * aUrl,
+              const char * aDisplayName, const char * aMessageUri)
+  {
+    Clear();
+    mContentType = strdup(aContentType);
+    mUrl = strdup(aUrl);
+    mDisplayName = strdup(aDisplayName);
+    mMessageUri = strdup(aMessageUri);
+    return (mContentType && mUrl && mDisplayName && mMessageUri);
+  }
+
+  // take the pointers from aSource
+  void Adopt(msgAttachment & aSource)
+  {
+    Clear();
+
+    mContentType = aSource.mContentType;
+    mUrl = aSource.mUrl;
+    mDisplayName = aSource.mDisplayName;
+    mMessageUri = aSource.mMessageUri;
+
+    aSource.mContentType = nullptr;
+    aSource.mUrl = nullptr;
+    aSource.mDisplayName = nullptr;
+    aSource.mMessageUri = nullptr;
+  }
+
+  char* mContentType;
+  char* mUrl;
+  char* mDisplayName;
+  char* mMessageUri;
+
+private:
+  // disable by not implementing
+  msgAttachment(const msgAttachment & rhs);
+  msgAttachment & operator=(const msgAttachment & rhs);
+};
+
+// ------------------------------------
+
+class nsAttachmentState
+{
+public:
+  nsAttachmentState();
+  ~nsAttachmentState();
+  nsresult Init(uint32_t aCount,
+                const char **aContentTypeArray,
+                const char **aUrlArray,
+                const char **aDisplayNameArray,
+                const char **aMessageUriArray);
+  nsresult PrepareForAttachmentDelete();
+
+private:
+  static int SortAttachmentsByPartId(const void * aLeft, const void * aRight, void *);
+
+public:
+  uint32_t        mCount;
+  uint32_t        mCurIndex;
+  msgAttachment*  mAttachmentArray;
+};
+
+nsAttachmentState::nsAttachmentState()
+  : mCount(0),
+    mCurIndex(0),
+    mAttachmentArray(nullptr)
+{
+}
+
+nsAttachmentState::~nsAttachmentState()
+{
+  delete[] mAttachmentArray;
+}
+
+nsresult
+nsAttachmentState::Init(uint32_t aCount, const char ** aContentTypeArray,
+                        const char ** aUrlArray, const char ** aDisplayNameArray,
+                        const char ** aMessageUriArray)
+{
+  MOZ_ASSERT(aCount > 0, "count is invalid");
+
+  mCount = aCount;
+  mCurIndex = 0;
+  delete[] mAttachmentArray;
+
+  mAttachmentArray = new msgAttachment[aCount];
+  if (!mAttachmentArray)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  for(uint32_t u = 0; u < aCount; ++u)
+  {
+    if (!mAttachmentArray[u].Init(aContentTypeArray[u], aUrlArray[u],
+      aDisplayNameArray[u], aMessageUriArray[u]))
+      return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsAttachmentState::PrepareForAttachmentDelete()
+{
+  // this must be called before any processing
+  if (mCurIndex != 0)
+    return NS_ERROR_FAILURE;
+
+  // this prepares the attachment list for use in deletion. In order to prepare, we
+  // sort the attachments in numerical ascending order on their part id, remove all
+  // duplicates and remove any subparts which will be removed automatically by the
+  // removal of the parent.
+  //
+  // e.g. the attachment list processing (showing only part ids)
+  // before: 1.11, 1.3, 1.2, 1.2.1.3, 1.4.1.2
+  // sorted: 1.2, 1.2.1.3, 1.3, 1.4.1.2, 1.11
+  // after:  1.2, 1.3, 1.4.1.2, 1.11
+
+  // sort
+  NS_QuickSort(mAttachmentArray, mCount, sizeof(msgAttachment), SortAttachmentsByPartId, nullptr);
+
+  // remove duplicates and sub-items
+  int nCompare;
+  for(uint32_t u = 1; u < mCount;)
+  {
+    nCompare = ::CompareAttachmentPartId(mAttachmentArray[u-1].mUrl, mAttachmentArray[u].mUrl);
+    if (nCompare == 0 || nCompare == -2) // [u-1] is the same as or a parent of [u]
+    {
+      // shuffle the array down (and thus keeping the sorted order)
+      // this will get rid of the current unnecessary element
+      for (uint32_t i = u + 1; i < mCount; ++i)
+      {
+        mAttachmentArray[i-1].Adopt(mAttachmentArray[i]);
+      }
+      --mCount;
+    }
+    else
+    {
+      ++u;
+    }
+  }
+
+  return NS_OK;
+}
+
+int
+nsAttachmentState::SortAttachmentsByPartId(const void * aLeft, const void * aRight, void *)
+{
+  msgAttachment & attachLeft  = *((msgAttachment*) aLeft);
+  msgAttachment & attachRight = *((msgAttachment*) aRight);
+  return ::CompareAttachmentPartId(attachLeft.mUrl, attachRight.mUrl);
+}
+
+// ------------------------------------
+
+class nsDelAttachListener : public nsIStreamListener,
+                            public nsIUrlListener,
+                            public nsIMsgCopyServiceListener
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSISTREAMLISTENER
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSIMSGCOPYSERVICELISTENER
+
+public:
+  nsDelAttachListener();
+  nsresult StartProcessing(nsMessenger * aMessenger, nsIMsgWindow * aMsgWindow,
+    nsAttachmentState * aAttach, bool aSaveFirst);
+  nsresult DeleteOriginalMessage();
+  void SelectNewMessage();
+
+public:
+  nsAttachmentState * mAttach;                      // list of attachments to process
+  bool mSaveFirst;                                // detach (true) or delete (false)
+  nsCOMPtr<nsIFile> mMsgFile;                       // temporary file (processed mail)
+  nsCOMPtr<nsIOutputStream> mMsgFileStream;         // temporary file (processed mail)
+  nsCOMPtr<nsIMsgMessageService> mMessageService;   // original message service
+  nsCOMPtr<nsIMsgDBHdr> mOriginalMessage;           // original message header
+  nsCOMPtr<nsIMsgFolder> mMessageFolder;            // original message folder
+  nsCOMPtr<nsIMessenger> mMessenger;                // our messenger instance
+  nsCOMPtr<nsIMsgWindow> mMsgWindow;                // our UI window
+  nsMsgKey mNewMessageKey;                          // new message key
+  uint32_t mOrigMsgFlags;
+
+
+   enum {
+      eStarting,
+      eCopyingNewMsg,
+      eUpdatingFolder, // for IMAP
+      eDeletingOldMessage,
+      eSelectingNewMessage
+    } m_state;
+   // temp
+  bool mWrittenExtra;
+  bool mDetaching;
+  nsTArray<nsCString> mDetachedFileUris;
+
+private:
+  virtual ~nsDelAttachListener();
+};
+
+//
+// nsISupports
+//
+NS_IMPL_ISUPPORTS(nsDelAttachListener,
+                   nsIStreamListener,
+                   nsIRequestObserver,
+                   nsIUrlListener,
+                   nsIMsgCopyServiceListener)
+
+//
+// nsIRequestObserver
+//
+NS_IMETHODIMP
+nsDelAttachListener::OnStartRequest(nsIRequest * aRequest, nsISupports * aContext)
+{
+  // called when we start processing the StreamMessage request.
+  // This is called after OnStartRunningUrl().
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDelAttachListener::OnStopRequest(nsIRequest * aRequest, nsISupports * aContext, nsresult aStatusCode)
+{
+  // called when we have completed processing the StreamMessage request.
+  // This is called after OnStopRequest(). This means that we have now
+  // received all data of the message and we have completed processing.
+  // We now start to copy the processed message from the temporary file
+  // back into the message store, replacing the original message.
+
+  mMessageFolder->CopyDataDone();
+  if (NS_FAILED(aStatusCode))
+    return aStatusCode;
+
+  // called when we complete processing of the StreamMessage request.
+  // This is called before OnStopRunningUrl().
+  nsresult rv;
+
+  // copy the file back into the folder. Note: setting msgToReplace only copies
+  // metadata, so we do the delete ourselves
+  nsCOMPtr<nsIMsgCopyServiceListener> listenerCopyService;
+  rv = this->QueryInterface( NS_GET_IID(nsIMsgCopyServiceListener), getter_AddRefs(listenerCopyService) );
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  mMsgFileStream->Close();
+  mMsgFileStream = nullptr;
+  mNewMessageKey = nsMsgKey_None;
+  nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID);
+  m_state = eCopyingNewMsg;
+  // clone file because nsIFile on Windows caches the wrong file size.
+  nsCOMPtr <nsIFile> clone;
+  mMsgFile->Clone(getter_AddRefs(clone));
+  if (copyService)
+  {
+    nsCString originalKeys;
+    mOriginalMessage->GetStringProperty("keywords", getter_Copies(originalKeys));
+    rv = copyService->CopyFileMessage(clone, mMessageFolder, mOriginalMessage, false,
+                                      mOrigMsgFlags, originalKeys, listenerCopyService, mMsgWindow);
+  }
+  return rv;
+}
+
+//
+// nsIStreamListener
+//
+
+NS_IMETHODIMP
+nsDelAttachListener::OnDataAvailable(nsIRequest * aRequest, nsISupports * aSupport,
+                                     nsIInputStream * aInStream, uint64_t aSrcOffset,
+                                     uint32_t aCount)
+{
+  if (!mMsgFileStream)
+    return NS_ERROR_NULL_POINTER;
+  return mMessageFolder->CopyDataToOutputStreamForAppend(aInStream, aCount, mMsgFileStream);
+}
+
+//
+// nsIUrlListener
+//
+
+NS_IMETHODIMP
+nsDelAttachListener::OnStartRunningUrl(nsIURI * aUrl)
+{
+  // called when we start processing the StreamMessage request. This is
+  // called before OnStartRequest().
+  return NS_OK;
+}
+
+nsresult nsDelAttachListener::DeleteOriginalMessage()
+{
+  nsresult rv;
+  nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = messageArray->AppendElement(mOriginalMessage, false);
+  NS_ENSURE_SUCCESS(rv,rv);
+  nsCOMPtr<nsIMsgCopyServiceListener> listenerCopyService;
+
+  QueryInterface( NS_GET_IID(nsIMsgCopyServiceListener), getter_AddRefs(listenerCopyService) );
+
+  mOriginalMessage = nullptr;
+  m_state = eDeletingOldMessage;
+  return mMessageFolder->DeleteMessages(
+    messageArray,         // messages
+    mMsgWindow,           // msgWindow
+    true,              // deleteStorage
+    false,              // isMove
+    listenerCopyService,  // listener
+    false);            // allowUndo
+}
+
+void nsDelAttachListener::SelectNewMessage()
+{
+  nsCString displayUri;
+  // all attachments refer to the same message
+  const char * messageUri = mAttach->mAttachmentArray[0].mMessageUri;
+  mMessenger->GetLastDisplayedMessageUri(displayUri);
+  if (displayUri.Equals(messageUri))
+  {
+    mMessageFolder->GenerateMessageURI(mNewMessageKey, displayUri);
+    if (!displayUri.IsEmpty() && mMsgWindow)
+    {
+      nsCOMPtr<nsIMsgWindowCommands> windowCommands;
+      mMsgWindow->GetWindowCommands(getter_AddRefs(windowCommands));
+      if (windowCommands)
+        windowCommands->SelectMessage(displayUri);
+    }
+  }
+  mNewMessageKey = nsMsgKey_None;
+}
+
+NS_IMETHODIMP
+nsDelAttachListener::OnStopRunningUrl(nsIURI * aUrl, nsresult aExitCode)
+{
+  nsresult rv = NS_OK;
+  const char * messageUri = mAttach->mAttachmentArray[0].mMessageUri;
+  if (mOriginalMessage && !strncmp(messageUri, "imap-message:", 13))
+  {
+    if (m_state == eUpdatingFolder)
+      rv = DeleteOriginalMessage();
+  }
+  // check if we've deleted the original message, and we know the new msg id.
+  else if (m_state == eDeletingOldMessage && mMsgWindow)
+    SelectNewMessage();
+
+  return rv;
+}
+
+//
+// nsIMsgCopyServiceListener
+//
+
+NS_IMETHODIMP
+nsDelAttachListener::OnStartCopy(void)
+{
+  // never called?
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDelAttachListener::OnProgress(uint32_t aProgress, uint32_t aProgressMax)
+{
+  // never called?
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDelAttachListener::SetMessageKey(nsMsgKey aKey)
+{
+  // called during the copy of the modified message back into the message
+  // store to notify us of the message key of the newly created message.
+  mNewMessageKey = aKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDelAttachListener::GetMessageId(nsACString& aMessageId)
+{
+  // never called?
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsDelAttachListener::OnStopCopy(nsresult aStatus)
+{
+  // only if the currently selected message is the one that we are about to delete then we
+  // change the selection to the new message that we just added. Failures in this code are not fatal.
+  // Note that can only do this if we have the new message key, which we don't always get from IMAP.
+  // delete the original message
+  if (NS_FAILED(aStatus))
+    return aStatus;
+
+  // check if we've deleted the original message, and we know the new msg id.
+  if (m_state == eDeletingOldMessage && mMsgWindow)
+    SelectNewMessage();
+  // do this for non-imap messages - for imap, we'll do the delete in
+  // OnStopRunningUrl. For local messages, we won't get an OnStopRunningUrl
+  // notification. And for imap, it's too late to delete the message here,
+  // because we'll be updating the folder naturally as a result of
+  // running an append url. If we delete the header here, that folder
+  // update will think we need to download the header...If we do it
+  // in OnStopRunningUrl, we'll issue the delete before we do the
+  // update....all nasty stuff.
+  const char * messageUri = mAttach->mAttachmentArray[0].mMessageUri;
+  if (mOriginalMessage && strncmp(messageUri, "imap-message:", 13))
+    return DeleteOriginalMessage();
+  else
+    m_state = eUpdatingFolder;
+  return NS_OK;
+}
+
+//
+// local methods
+//
+
+nsDelAttachListener::nsDelAttachListener()
+{
+  mAttach = nullptr;
+  mSaveFirst = false;
+  mWrittenExtra = false;
+  mNewMessageKey = nsMsgKey_None;
+  m_state = eStarting;
+}
+
+nsDelAttachListener::~nsDelAttachListener()
+{
+  if (mAttach)
+  {
+    delete mAttach;
+  }
+  if (mMsgFileStream)
+  {
+    mMsgFileStream->Close();
+    mMsgFileStream = nullptr;
+  }
+  if (mMsgFile)
+  {
+    mMsgFile->Remove(false);
+  }
+}
+
+nsresult
+nsDelAttachListener::StartProcessing(nsMessenger * aMessenger, nsIMsgWindow * aMsgWindow,
+                                     nsAttachmentState * aAttach, bool detaching)
+{
+  aMessenger->QueryInterface(NS_GET_IID(nsIMessenger), getter_AddRefs(mMessenger));
+  mMsgWindow = aMsgWindow;
+  mAttach    = aAttach;
+  mDetaching = detaching;
+
+  nsresult rv;
+
+  // all attachments refer to the same message
+  const char * messageUri = mAttach->mAttachmentArray[0].mMessageUri;
+
+  // get the message service, original message and folder for this message
+  rv = GetMessageServiceFromURI(nsDependentCString(messageUri), getter_AddRefs(mMessageService));
+  NS_ENSURE_SUCCESS(rv,rv);
+  rv = mMessageService->MessageURIToMsgHdr(messageUri, getter_AddRefs(mOriginalMessage));
+  NS_ENSURE_SUCCESS(rv,rv);
+  rv = mOriginalMessage->GetFolder(getter_AddRefs(mMessageFolder));
+  NS_ENSURE_SUCCESS(rv,rv);
+  mOriginalMessage->GetFlags(&mOrigMsgFlags);
+
+  // ensure that we can store and delete messages in this folder, if we
+  // can't then we can't do attachment deleting
+  bool canDelete = false;
+  mMessageFolder->GetCanDeleteMessages(&canDelete);
+  bool canFile = false;
+  mMessageFolder->GetCanFileMessages(&canFile);
+  if (!canDelete || !canFile)
+    return NS_ERROR_FAILURE;
+
+  // create an output stream on a temporary file. This stream will save the modified
+  // message data to a file which we will later use to replace the existing message.
+  // The file is removed in the destructor.
+  rv = GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR, "nsmail.tmp",
+                                       getter_AddRefs(mMsgFile));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // For temp file, we should use restrictive 00600 instead of ATTACHMENT_PERMISSION 
+  rv = mMsgFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mMsgFileStream), mMsgFile, -1, ATTACHMENT_PERMISSION);
+
+  // create the additional header for data conversion. This will tell the stream converter
+  // which MIME emitter we want to use, and it will tell the MIME emitter which attachments
+  // should be deleted.
+  const char * partId;
+  const char * nextField;
+  nsAutoCString sHeader("attach&del=");
+  nsAutoCString detachToHeader("&detachTo=");
+  for (uint32_t u = 0; u < mAttach->mCount; ++u)
+  {
+    if (u > 0)
+    {
+      sHeader.Append(",");
+      if (detaching)
+        detachToHeader.Append(",");
+    }
+    partId = GetAttachmentPartId(mAttach->mAttachmentArray[u].mUrl);
+    nextField = PL_strchr(partId, '&');
+    sHeader.Append(partId, nextField ? nextField - partId : -1);
+    if (detaching)
+      detachToHeader.Append(mDetachedFileUris[u]);
+  }
+
+  if (detaching)
+    sHeader.Append(detachToHeader);
+  // stream this message to our listener converting it via the attachment mime
+  // converter. The listener will just write the converted message straight to disk.
+  nsCOMPtr<nsISupports> listenerSupports;
+  rv = this->QueryInterface(NS_GET_IID(nsISupports), getter_AddRefs(listenerSupports));
+  NS_ENSURE_SUCCESS(rv,rv);
+  nsCOMPtr<nsIUrlListener> listenerUrlListener = do_QueryInterface(listenerSupports, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIURI> dummyNull;
+  rv = mMessageService->StreamMessage(messageUri, listenerSupports, mMsgWindow,
+                                      listenerUrlListener, true, sHeader,
+                                      false, getter_AddRefs(dummyNull));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  return NS_OK;
+}
+
+// ------------------------------------
+
+NS_IMETHODIMP
+nsMessenger::DetachAttachment(const char * aContentType, const char * aUrl,
+                              const char * aDisplayName, const char * aMessageUri,
+                              bool aSaveFirst, bool withoutWarning = false)
+{
+  NS_ENSURE_ARG_POINTER(aContentType);
+  NS_ENSURE_ARG_POINTER(aUrl);
+  NS_ENSURE_ARG_POINTER(aDisplayName);
+  NS_ENSURE_ARG_POINTER(aMessageUri);
+
+  if (aSaveFirst)
+    return SaveOneAttachment(aContentType, aUrl, aDisplayName, aMessageUri, true);
+  return DetachAttachments(1, &aContentType, &aUrl, &aDisplayName, &aMessageUri, nullptr, withoutWarning);
+}
+
+NS_IMETHODIMP
+nsMessenger::DetachAllAttachments(uint32_t aCount,
+                                  const char ** aContentTypeArray,
+                                  const char ** aUrlArray,
+                                  const char ** aDisplayNameArray,
+                                  const char ** aMessageUriArray,
+                                  bool aSaveFirst,
+                                  bool withoutWarning = false)
+{
+  NS_ENSURE_ARG_MIN(aCount, 1);
+  NS_ENSURE_ARG_POINTER(aContentTypeArray);
+  NS_ENSURE_ARG_POINTER(aUrlArray);
+  NS_ENSURE_ARG_POINTER(aDisplayNameArray);
+  NS_ENSURE_ARG_POINTER(aMessageUriArray);
+
+  if (aSaveFirst)
+    return SaveAllAttachments(aCount, aContentTypeArray, aUrlArray, aDisplayNameArray, aMessageUriArray, true);
+  else
+    return DetachAttachments(aCount, aContentTypeArray, aUrlArray, aDisplayNameArray, aMessageUriArray, nullptr, withoutWarning);
+}
+
+nsresult
+nsMessenger::DetachAttachments(uint32_t aCount,
+                               const char ** aContentTypeArray,
+                               const char ** aUrlArray,
+                               const char ** aDisplayNameArray,
+                               const char ** aMessageUriArray,
+                               nsTArray<nsCString> *saveFileUris,
+                               bool withoutWarning)
+{
+  // if withoutWarning no dialog for user
+  if (!withoutWarning && NS_FAILED(PromptIfDeleteAttachments(saveFileUris != nullptr, aCount, aDisplayNameArray)))
+      return NS_OK;
+  
+  nsresult rv = NS_OK;
+
+  // ensure that our arguments are valid
+//  char * partId;
+  for (uint32_t u = 0; u < aCount; ++u)
+  {
+    // ensure all of the message URI are the same, we cannot process
+    // attachments from different messages
+    if (u > 0 && 0 != strcmp(aMessageUriArray[0], aMessageUriArray[u]))
+    {
+      rv = NS_ERROR_INVALID_ARG;
+      break;
+    }
+
+    // ensure that we don't have deleted messages in this list
+    if (0 == strcmp(aContentTypeArray[u], MIMETYPE_DELETED))
+    {
+      rv = NS_ERROR_INVALID_ARG;
+      break;
+    }
+
+    // for the moment we prevent any attachments other than root level
+    // attachments being deleted (i.e. you can't delete attachments from a
+    // email forwarded as an attachment). We do this by ensuring that the
+    // part id only has a single period in it (e.g. "1.2").
+    //TODO: support non-root level attachment delete
+//    partId = ::GetAttachmentPartId(aUrlArray[u]);
+//    if (!partId || PL_strchr(partId, '.') != PL_strrchr(partId, '.'))
+//    {
+//      rv = NS_ERROR_INVALID_ARG;
+//      break;
+//    }
+  }
+  if (NS_FAILED(rv))
+  {
+    Alert("deleteAttachmentFailure");
+    return rv;
+  }
+
+  //TODO: ensure that nothing else is processing this message uri at the same time
+
+  //TODO: if any of the selected attachments are messages that contain other
+  // attachments we need to warn the user that all sub-attachments of those
+  // messages will also be deleted. Best to display a list of them.
+
+  // get the listener for running the url
+  nsDelAttachListener * listener = new nsDelAttachListener;
+  if (!listener)
+    return NS_ERROR_OUT_OF_MEMORY;
+  nsCOMPtr<nsISupports> listenerSupports; // auto-delete of the listener with error
+  listener->QueryInterface(NS_GET_IID(nsISupports), getter_AddRefs(listenerSupports));
+
+  if (saveFileUris)
+    listener->mDetachedFileUris = *saveFileUris;
+  // create the attachments for use by the listener
+  nsAttachmentState * attach = new nsAttachmentState;
+  if (!attach)
+    return NS_ERROR_OUT_OF_MEMORY;
+  rv = attach->Init(aCount, aContentTypeArray, aUrlArray, aDisplayNameArray, aMessageUriArray);
+  if (NS_SUCCEEDED(rv))
+    rv = attach->PrepareForAttachmentDelete();
+  if (NS_FAILED(rv))
+  {
+    delete attach;
+    return rv;
+  }
+
+  // initialize our listener with the attachments and details. The listener takes ownership
+  // of 'attach' immediately irrespective of the return value (error or not).
+  return listener->StartProcessing(this, mMsgWindow, attach, saveFileUris != nullptr);
+}
+
+nsresult
+nsMessenger::PromptIfDeleteAttachments(bool aSaveFirst,
+                                       uint32_t aCount,
+                                       const char ** aDisplayNameArray)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIPrompt> dialog(do_GetInterface(mDocShell));
+  if (!dialog) return rv;
+
+  if (!mStringBundle)
+  {
+    rv = InitStringBundle();
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // create the list of attachments we are removing
+  nsString displayString;
+  nsString attachmentList;
+  for (uint32_t u = 0; u < aCount; ++u)
+  {
+    ConvertAndSanitizeFileName(aDisplayNameArray[u], displayString);
+    attachmentList.Append(displayString);
+    attachmentList.Append(char16_t('\n'));
+  }
+  const char16_t *formatStrings[] = { attachmentList.get() };
+
+  // format the message and display
+  nsString promptMessage;
+  const char16_t * propertyName = aSaveFirst ?
+    u"detachAttachments" : u"deleteAttachments";
+  rv = mStringBundle->FormatStringFromName(propertyName, formatStrings, 1,getter_Copies(promptMessage));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool dialogResult = false;
+  rv = dialog->Confirm(nullptr, promptMessage.get(), &dialogResult);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return dialogResult ? NS_OK : NS_ERROR_FAILURE;
+}
+
diff --git a/mailnews/base/src/nsMessenger.h b/mailnews/base/src/nsMessenger.h
new file mode 100644
index 000000000..9ba22e26e
--- /dev/null
+++ b/mailnews/base/src/nsMessenger.h
@@ -0,0 +1,102 @@
+/* -*- 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 __nsMsgAppCore_h
+#define __nsMsgAppCore_h
+
+#include "nscore.h"
+#include "nsIMessenger.h"
+#include "nsCOMPtr.h"
+#include "nsITransactionManager.h"
+#include "nsIFile.h"
+#include "nsIDocShell.h"
+#include "nsIStringBundle.h"
+#include "nsIFile.h"
+#include "nsWeakReference.h"
+#include "mozIDOMWindow.h"
+#include "nsTArray.h"
+#include "nsIFolderListener.h"
+
+class nsMessenger : public nsIMessenger, public nsSupportsWeakReference, public nsIFolderListener
+{
+
+public:
+  nsMessenger();
+
+  NS_DECL_ISUPPORTS  
+  NS_DECL_NSIMESSENGER
+  NS_DECL_NSIFOLDERLISTENER
+
+  nsresult Alert(const char * stringName);
+
+  nsresult SaveAttachment(nsIFile *file, const nsACString& unescapedUrl,
+                          const nsACString& messageUri, const nsACString& contentType, 
+                          void *closure, nsIUrlListener *aListener);
+  nsresult PromptIfFileExists(nsIFile *file);
+  nsresult DetachAttachments(uint32_t aCount,
+                             const char ** aContentTypeArray,
+                             const char ** aUrlArray,
+                             const char ** aDisplayNameArray,
+                             const char ** aMessageUriArray,
+                             nsTArray<nsCString> *saveFileUris,
+                             bool withoutWarning = false);
+  nsresult SaveAllAttachments(uint32_t count,
+                              const char **contentTypeArray,
+                              const char **urlArray,
+                              const char **displayNameArray,
+                              const char **messageUriArray,
+                              bool detaching);
+  nsresult SaveOneAttachment(const char* aContentType,
+                             const char* aURL,
+                             const char* aDisplayName,
+                             const char* aMessageUri,
+                             bool detaching);
+
+protected:
+  virtual ~nsMessenger();
+
+  void GetString(const nsString& aStringName, nsString& stringValue);
+  nsresult InitStringBundle();
+  nsresult PromptIfDeleteAttachments(bool saveFirst, uint32_t count, const char **displayNameArray);
+
+private:
+  nsresult GetLastSaveDirectory(nsIFile **aLastSaveAsDir);
+  // if aLocalFile is a dir, we use it.  otherwise, we use the parent of aLocalFile.
+  nsresult SetLastSaveDirectory(nsIFile *aLocalFile);
+
+  nsresult AdjustFileIfNameTooLong(nsIFile* aFile);
+
+  nsresult GetSaveAsFile(const nsAString& aMsgFilename, int32_t *aSaveAsFileType,
+                         nsIFile **aSaveAsFile);
+
+  nsresult GetSaveToDir(nsIFile **aSaveToDir);
+
+  nsString mId;
+  nsCOMPtr<nsITransactionManager> mTxnMgr;
+
+  /* rhp - need this to drive message display */
+  nsCOMPtr<mozIDOMWindowProxy> mWindow;
+  nsCOMPtr<nsIMsgWindow>       mMsgWindow;
+  nsCOMPtr<nsIDocShell>        mDocShell;
+
+  // String bundles...
+  nsCOMPtr<nsIStringBundle>   mStringBundle;
+
+  nsCString mCurrentDisplayCharset;
+
+  nsCOMPtr<nsISupports>  mSearchContext;
+  nsCString   mLastDisplayURI; // this used when the user attempts to force a charset reload of a message...we need to get the last displayed
+                               // uri so we can re-display it..
+  nsCString mNavigatingToUri;
+  nsTArray<nsCString> mLoadedMsgHistory;
+  int32_t mCurHistoryPos;
+};
+
+#define NS_MESSENGER_CID \
+{ /* f436a174-e2c0-4955-9afe-e3feb68aee56 */      \
+  0xf436a174, 0xe2c0, 0x4955,                     \
+    {0x9a, 0xfe, 0xe3, 0xfe, 0xb6, 0x8a, 0xee, 0x56}}
+
+#endif
diff --git a/mailnews/base/src/nsMessengerBootstrap.cpp b/mailnews/base/src/nsMessengerBootstrap.cpp
new file mode 100644
index 000000000..a78ba3b7c
--- /dev/null
+++ b/mailnews/base/src/nsMessengerBootstrap.cpp
@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMessengerBootstrap.h"
+#include "nsCOMPtr.h"
+
+#include "nsIMutableArray.h"
+#include "nsIMsgFolder.h"
+#include "nsIWindowWatcher.h"
+#include "nsMsgUtils.h"
+#include "nsISupportsPrimitives.h"
+#include "mozIDOMWindow.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+
+NS_IMPL_ISUPPORTS(nsMessengerBootstrap, nsIMessengerWindowService)
+
+nsMessengerBootstrap::nsMessengerBootstrap()
+{
+}
+
+nsMessengerBootstrap::~nsMessengerBootstrap()
+{
+}
+
+NS_IMETHODIMP nsMessengerBootstrap::OpenMessengerWindowWithUri(const char *windowType, const char * aFolderURI, nsMsgKey aMessageKey)
+{
+  bool standAloneMsgWindow = false;
+  nsAutoCString chromeUrl("chrome://messenger/content/");
+  if (windowType && !strcmp(windowType, "mail:messageWindow"))
+  {
+    chromeUrl.Append("messageWindow.xul");
+    standAloneMsgWindow = true;
+  }
+  nsresult rv;
+  nsCOMPtr<nsIMutableArray> argsArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // create scriptable versions of our strings that we can store in our nsIMutableArray....
+  if (aFolderURI)
+  {
+    if (standAloneMsgWindow)
+    {
+      nsCOMPtr <nsIMsgFolder> folder;
+      rv = GetExistingFolder(nsDependentCString(aFolderURI), getter_AddRefs(folder));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsAutoCString msgUri;
+      folder->GetBaseMessageURI(msgUri);
+
+      nsCOMPtr<nsISupportsCString> scriptableMsgURI (do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID));
+      NS_ENSURE_TRUE(scriptableMsgURI, NS_ERROR_FAILURE);
+      msgUri.Append('#');
+      msgUri.AppendInt(aMessageKey, 10);
+      scriptableMsgURI->SetData(msgUri);
+      argsArray->AppendElement(scriptableMsgURI, false);
+    }
+    nsCOMPtr<nsISupportsCString> scriptableFolderURI (do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID));
+    NS_ENSURE_TRUE(scriptableFolderURI, NS_ERROR_FAILURE);
+
+    scriptableFolderURI->SetData(nsDependentCString(aFolderURI));
+    argsArray->AppendElement(scriptableFolderURI, false);
+
+    if (!standAloneMsgWindow)
+    {
+      nsCOMPtr<nsISupportsPRUint32> scriptableMessageKey (do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID));
+      NS_ENSURE_TRUE(scriptableMessageKey, NS_ERROR_FAILURE);
+      scriptableMessageKey->SetData(aMessageKey);
+      argsArray->AppendElement(scriptableMessageKey, false);
+    }
+  }
+  
+  nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // we need to use the "mailnews.reuse_thread_window2" pref
+  // to determine if we should open a new window, or use an existing one.
+  nsCOMPtr<mozIDOMWindowProxy> newWindow;
+  return wwatch->OpenWindow(0, chromeUrl.get(), "_blank",
+                            "chrome,all,dialog=no", argsArray,
+                             getter_AddRefs(newWindow));
+}
diff --git a/mailnews/base/src/nsMessengerBootstrap.h b/mailnews/base/src/nsMessengerBootstrap.h
new file mode 100644
index 000000000..94016a0ea
--- /dev/null
+++ b/mailnews/base/src/nsMessengerBootstrap.h
@@ -0,0 +1,31 @@
+/* -*- 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 __nsMessenger_h
+#define __nsMessenger_h
+
+#include "nscore.h"
+#include "nsIMessengerWindowService.h"
+
+#define NS_MESSENGERBOOTSTRAP_CID                 \
+{ /* 4a85a5d0-cddd-11d2-b7f6-00805f05ffa5 */      \
+  0x4a85a5d0, 0xcddd, 0x11d2,                     \
+  {0xb7, 0xf6, 0x00, 0x80, 0x5f, 0x05, 0xff, 0xa5}}
+
+class nsMessengerBootstrap :
+    public nsIMessengerWindowService
+{
+public:
+  nsMessengerBootstrap();
+
+  NS_DECL_THREADSAFE_ISUPPORTS  
+  NS_DECL_NSIMESSENGERWINDOWSERVICE
+
+private:
+  virtual ~nsMessengerBootstrap();
+};
+
+#endif
diff --git a/mailnews/base/src/nsMessengerContentHandler.cpp b/mailnews/base/src/nsMessengerContentHandler.cpp
new file mode 100644
index 000000000..5c6460965
--- /dev/null
+++ b/mailnews/base/src/nsMessengerContentHandler.cpp
@@ -0,0 +1,81 @@
+/* -*- 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 "nsMessengerContentHandler.h"
+#include "nsIChannel.h"
+#include "nsPIDOMWindow.h"
+#include "nsIServiceManager.h"
+#include "nsIWindowWatcher.h"
+#include "nsIDocShell.h"
+#include "nsIWebNavigation.h"
+#include "nsIURL.h"
+#include "nsStringGlue.h"
+#include "nsMsgBaseCID.h"
+#include "plstr.h"
+#include "nsIURL.h"
+#include "nsServiceManagerUtils.h"
+
+nsMessengerContentHandler::nsMessengerContentHandler()
+{
+}
+
+/* the following macro actually implement addref, release and query interface for our component. */
+NS_IMPL_ISUPPORTS(nsMessengerContentHandler, nsIContentHandler)
+
+nsMessengerContentHandler::~nsMessengerContentHandler()
+{
+}
+
+NS_IMETHODIMP nsMessengerContentHandler::HandleContent(const char * aContentType,
+                                                nsIInterfaceRequestor* aWindowContext, nsIRequest *request)
+{
+  nsresult rv = NS_OK;
+  if (!request)
+    return NS_ERROR_NULL_POINTER;
+
+  // First of all, get the content type and make sure it is a content type we know how to handle!
+  if (PL_strcasecmp(aContentType, "application/x-message-display") == 0) {
+    nsCOMPtr<nsIURI> aUri;
+    nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
+    if (!aChannel) return NS_ERROR_FAILURE;
+
+    rv = aChannel->GetURI(getter_AddRefs(aUri));
+    if (aUri)
+    {
+      rv = request->Cancel(NS_ERROR_ABORT);
+      if (NS_SUCCEEDED(rv))
+      {
+        nsCOMPtr<nsIURL> aUrl = do_QueryInterface(aUri);
+        if (aUrl)
+        {
+          nsAutoCString queryPart;
+          aUrl->GetQuery(queryPart);
+          queryPart.Replace(queryPart.Find("type=message/rfc822"),
+                            sizeof("type=message/rfc822") - 1,
+                            "type=application/x-message-display");
+          aUrl->SetQuery(queryPart);
+          rv = OpenWindow(aUri);
+        }
+      }
+    }
+  }
+
+  return rv;
+}
+
+// Utility function to open a message display window and and load the message in it.
+nsresult nsMessengerContentHandler::OpenWindow(nsIURI* aURI)
+{
+  NS_ENSURE_ARG_POINTER(aURI);
+  
+  nsCOMPtr<nsIWindowWatcher> wwatch = do_GetService("@mozilla.org/embedcomp/window-watcher;1");
+  if (!wwatch)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<mozIDOMWindowProxy> newWindow;
+  return wwatch->OpenWindow(0, "chrome://messenger/content/messageWindow.xul",
+                 "_blank", "all,chrome,dialog=no,status,toolbar", aURI,
+                 getter_AddRefs(newWindow));
+}
diff --git a/mailnews/base/src/nsMessengerContentHandler.h b/mailnews/base/src/nsMessengerContentHandler.h
new file mode 100644
index 000000000..dad69493b
--- /dev/null
+++ b/mailnews/base/src/nsMessengerContentHandler.h
@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIContentHandler.h"
+#include "nsIURI.h"
+
+class nsMessengerContentHandler : public nsIContentHandler
+{
+public:
+  nsMessengerContentHandler();
+  
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONTENTHANDLER
+    
+private:
+  virtual ~nsMessengerContentHandler();
+  nsresult OpenWindow(nsIURI* aURI);
+};
diff --git a/mailnews/base/src/nsMessengerOSXIntegration.h b/mailnews/base/src/nsMessengerOSXIntegration.h
new file mode 100644
index 000000000..91f42f2a2
--- /dev/null
+++ b/mailnews/base/src/nsMessengerOSXIntegration.h
@@ -0,0 +1,63 @@
+/* -*- 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 __nsMessengerOSXIntegration_h
+#define __nsMessengerOSXIntegration_h
+
+#include "nsIMessengerOSIntegration.h"
+#include "nsIFolderListener.h"
+#include "nsIAtom.h"
+#include "nsITimer.h"
+#include "nsCOMPtr.h"
+#include "nsStringGlue.h"
+#include "nsIObserver.h"
+#include "nsIAlertsService.h"
+#include "mozINewMailListener.h"
+
+#define NS_MESSENGEROSXINTEGRATION_CID \
+  {0xaa83266, 0x4225, 0x4c4b, \
+  {0x93, 0xf8, 0x94, 0xb1, 0x82, 0x58, 0x6f, 0x93}}
+
+class nsIStringBundle;
+
+class nsMessengerOSXIntegration : public nsIMessengerOSIntegration,
+                                  public nsIFolderListener,
+                                  public nsIObserver,
+                                  public mozINewMailListener
+{
+public:
+  nsMessengerOSXIntegration();
+  virtual nsresult Init();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMESSENGEROSINTEGRATION
+  NS_DECL_NSIFOLDERLISTENER
+  NS_DECL_NSIOBSERVER
+  NS_DECL_MOZINEWMAILLISTENER
+
+private:
+  virtual ~nsMessengerOSXIntegration();
+
+  nsCOMPtr<nsIAtom> mBiffStateAtom;
+  nsCOMPtr<nsIAtom> mNewMailReceivedAtom;
+  nsresult ShowAlertMessage(const nsAString& aAlertTitle, const nsAString& aAlertText, const nsACString& aFolderURI);
+  nsresult OnAlertFinished();
+  nsresult OnAlertClicked(const char16_t * aAlertCookie);
+#ifdef MOZ_SUITE
+  nsresult OnAlertClickedSimple();
+#endif
+  nsresult GetStringBundle(nsIStringBundle **aBundle);
+  void FillToolTipInfo(nsIMsgFolder *aFolder, int32_t aNewCount);
+  nsresult GetFirstFolderWithNewMail(nsIMsgFolder* aFolder, nsCString& aFolderURI);
+  nsresult BadgeDockIcon();
+  nsresult RestoreDockIcon();
+  nsresult BounceDockIcon();
+  nsresult GetNewMailAuthors(nsIMsgFolder* aFolder, nsString& aAuthors, int32_t aNewCount, int32_t* aNotDisplayed);
+
+  int32_t mUnreadTotal;
+  int32_t mUnreadChat;
+};
+
+#endif // __nsMessengerOSXIntegration_h
diff --git a/mailnews/base/src/nsMessengerOSXIntegration.mm b/mailnews/base/src/nsMessengerOSXIntegration.mm
new file mode 100644
index 000000000..286c76044
--- /dev/null
+++ b/mailnews/base/src/nsMessengerOSXIntegration.mm
@@ -0,0 +1,730 @@
+/* -*- 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 "nscore.h"
+#include "nsMsgUtils.h"
+#include "nsArrayUtils.h"
+#include "nsMessengerOSXIntegration.h"
+#include "nsIMsgMailSession.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIMsgIdentity.h"
+#include "nsIMsgAccount.h"
+#include "nsIMsgFolder.h"
+#include "nsCOMPtr.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgFolderFlags.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsIDirectoryService.h"
+#include "MailNewsTypes.h"
+#include "nsIWindowMediator.h"
+#include "nsIDOMChromeWindow.h"
+#include "mozIDOMWindow.h"
+#include "nsPIDOMWindow.h"
+#include "nsIDocShell.h"
+#include "nsIBaseWindow.h"
+#include "nsIWidget.h"
+#include "nsIObserverService.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIMessengerWindowService.h"
+#include "prprf.h"
+#include "nsIAlertsService.h"
+#include "nsIStringBundle.h"
+#include "nsToolkitCompsCID.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgHdr.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIWindowWatcher.h"
+#include "nsMsgLocalCID.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMsgWindow.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMessenger.h"
+#include "nsObjCExceptions.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "mozINewMailNotificationService.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+
+#include <Carbon/Carbon.h>
+#import <Cocoa/Cocoa.h>
+
+#define kChatEnabledPref "mail.chat.enabled"
+#define kBiffAnimateDockIconPref "mail.biff.animate_dock_icon"
+#define kMaxDisplayCount 10
+#define kNewChatMessageTopic "new-directed-incoming-message"
+#define kUnreadImCountChangedTopic "unread-im-count-changed"
+
+using namespace mozilla::mailnews;
+
+// HACK: Limitations in Focus/SetFocus on Mac (see bug 465446)
+nsresult FocusAppNative()
+{
+  ProcessSerialNumber psn;
+
+  if (::GetCurrentProcess(&psn) != 0)
+   return NS_ERROR_FAILURE;
+
+  if (::SetFrontProcess(&psn) != 0)
+   return NS_ERROR_FAILURE;
+
+  return NS_OK;
+}
+
+static void openMailWindow(const nsCString& aUri)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailSession> mailSession ( do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv));
+  if (NS_FAILED(rv))
+    return;
+
+  nsCOMPtr<nsIMsgWindow> topMostMsgWindow;
+  rv = mailSession->GetTopmostMsgWindow(getter_AddRefs(topMostMsgWindow));
+  if (topMostMsgWindow)
+  {
+    if (!aUri.IsEmpty())
+    {
+      nsCOMPtr<nsIMsgMailNewsUrl> msgUri(do_CreateInstance(NS_MAILBOXURL_CONTRACTID, &rv));
+      if (NS_FAILED(rv))
+        return;
+
+      rv = msgUri->SetSpec(aUri);
+      if (NS_FAILED(rv))
+        return;
+
+      bool isMessageUri = false;
+      msgUri->GetIsMessageUri(&isMessageUri);
+      if (isMessageUri)
+      {
+        nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
+        if (NS_FAILED(rv))
+          return;
+
+        // SeaMonkey only supports message uris, whereas Thunderbird only
+        // supports message headers. This should be simplified/removed when
+        // bug 507593 is implemented.
+#ifdef MOZ_SUITE
+        nsCOMPtr<mozIDOMWindowProxy> newWindow;
+        wwatch->OpenWindow(0, "chrome://messenger/content/messageWindow.xul",
+                           "_blank", "all,chrome,dialog=no,status,toolbar", msgUri,
+                           getter_AddRefs(newWindow));
+#else
+        nsCOMPtr<nsIMessenger> messenger(do_CreateInstance(NS_MESSENGER_CONTRACTID, &rv));
+        if (NS_FAILED(rv))
+          return;
+
+        nsCOMPtr<nsIMsgDBHdr> msgHdr; 
+        messenger->MsgHdrFromURI(aUri, getter_AddRefs(msgHdr));
+        if (msgHdr)
+        {
+          nsCOMPtr<mozIDOMWindowProxy> newWindow;
+          wwatch->OpenWindow(0, "chrome://messenger/content/messageWindow.xul",
+                             "_blank", "all,chrome,dialog=no,status,toolbar", msgHdr,
+                             getter_AddRefs(newWindow));
+        }
+#endif
+      }
+      else
+      {
+        nsCOMPtr<nsIMsgWindowCommands> windowCommands;
+        topMostMsgWindow->GetWindowCommands(getter_AddRefs(windowCommands));
+        if (windowCommands)
+          windowCommands->SelectFolder(aUri);
+      }
+    }
+
+    FocusAppNative();
+    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    topMostMsgWindow->GetDomWindow(getter_AddRefs(domWindow));
+    if (domWindow) {
+      nsCOMPtr<nsPIDOMWindowOuter> privateWindow = nsPIDOMWindowOuter::From(domWindow);
+      privateWindow->Focus();
+    }
+  }
+  else
+  {
+    // the user doesn't have a mail window open already so open one for them...
+    nsCOMPtr<nsIMessengerWindowService> messengerWindowService =
+      do_GetService(NS_MESSENGERWINDOWSERVICE_CONTRACTID);
+    // if we want to preselect the first account with new mail,
+    // here is where we would try to generate a uri to pass in
+    // (and add code to the messenger window service to make that work)
+    if (messengerWindowService)
+      messengerWindowService->OpenMessengerWindowWithUri(
+                                "mail:3pane", aUri.get(), nsMsgKey_None);
+  }
+}
+
+nsMessengerOSXIntegration::nsMessengerOSXIntegration()
+{
+  mBiffStateAtom = MsgGetAtom("BiffState");
+  mNewMailReceivedAtom = MsgGetAtom("NewMailReceived");
+  mUnreadTotal = 0;
+  mUnreadChat = 0;
+}
+
+nsMessengerOSXIntegration::~nsMessengerOSXIntegration()
+{
+  RestoreDockIcon();
+}
+
+NS_IMPL_ADDREF(nsMessengerOSXIntegration)
+NS_IMPL_RELEASE(nsMessengerOSXIntegration)
+
+NS_INTERFACE_MAP_BEGIN(nsMessengerOSXIntegration)
+   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMessengerOSIntegration)
+   NS_INTERFACE_MAP_ENTRY(nsIMessengerOSIntegration)
+   NS_INTERFACE_MAP_ENTRY(nsIFolderListener)
+   NS_INTERFACE_MAP_ENTRY(nsIObserver)
+   NS_INTERFACE_MAP_ENTRY(mozINewMailListener)
+NS_INTERFACE_MAP_END
+
+
+nsresult
+nsMessengerOSXIntegration::Init()
+{
+  nsresult rv;
+  nsCOMPtr<nsIObserverService> observerService = do_GetService("@mozilla.org/observer-service;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return observerService->AddObserver(this, "mail-startup-done", false);
+}
+
+NS_IMETHODIMP
+nsMessengerOSXIntegration::OnItemPropertyChanged(nsIMsgFolder *, nsIAtom *, char const *, char const *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerOSXIntegration::OnItemUnicharPropertyChanged(nsIMsgFolder *, nsIAtom *, const char16_t *, const char16_t *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerOSXIntegration::OnItemRemoved(nsIMsgFolder *, nsISupports *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerOSXIntegration::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
+{
+  if (!strcmp(aTopic, "alertfinished"))
+    return OnAlertFinished();
+
+  if (!strcmp(aTopic, "alertclickcallback"))
+    return OnAlertClicked(aData);
+
+#ifdef MOZ_SUITE
+  // SeaMonkey does most of the GUI work in JS code when clicking on a mail
+  // notification, so it needs an extra function here 
+  if (!strcmp(aTopic, "alertclicksimplecallback"))
+    return OnAlertClickedSimple();
+#endif
+
+  if (!strcmp(aTopic, "mail-startup-done")) {
+    nsresult rv;
+    nsCOMPtr<nsIObserverService> observerService = do_GetService("@mozilla.org/observer-service;1", &rv);
+    if (NS_SUCCEEDED(rv)) {
+      observerService->RemoveObserver(this, "mail-startup-done");
+
+      bool chatEnabled = false;
+      nsCOMPtr<nsIPrefBranch> pref(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+      if (NS_SUCCEEDED(rv))
+        rv = pref->GetBoolPref(kChatEnabledPref, &chatEnabled);
+      if (NS_SUCCEEDED(rv) && chatEnabled) {
+        observerService->AddObserver(this, kNewChatMessageTopic, false);
+        observerService->AddObserver(this, kUnreadImCountChangedTopic, false);
+      }
+    }
+
+    // Register with the new mail service for changes to the unread message count
+    nsCOMPtr<mozINewMailNotificationService> newmail
+      = do_GetService(MOZ_NEWMAILNOTIFICATIONSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv); // This should really be an assert with a helpful message
+    rv = newmail->AddListener(this, mozINewMailNotificationService::count);
+    NS_ENSURE_SUCCESS(rv, rv); // This should really be an assert with a helpful message
+
+    // Get the initial unread count. Ignore return value; if code above didn't fail, this won't
+    rv = newmail->GetMessageCount(&mUnreadTotal);
+    BadgeDockIcon();
+
+    // register with the mail sesson for folder events
+    // we care about new count, biff status
+    nsCOMPtr<nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return mailSession->AddFolderListener(this, nsIFolderListener::boolPropertyChanged | nsIFolderListener::intPropertyChanged);
+  }
+
+  if (!strcmp(aTopic, kNewChatMessageTopic)) {
+    // We don't have to bother about checking if the window is already focused
+    // before attempting to bounce the dock icon, as BounceDockIcon is
+    // implemented by a getAttention call which won't do anything if the window
+    // requesting attention is already focused.
+    return BounceDockIcon();
+  }
+
+  if (!strcmp(aTopic, kUnreadImCountChangedTopic)) {
+    nsresult rv;
+    nsCOMPtr<nsISupportsPRInt32> unreadCount = do_QueryInterface(aSubject, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = unreadCount->GetData(&mUnreadChat);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return BadgeDockIcon();
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsMessengerOSXIntegration::GetStringBundle(nsIStringBundle **aBundle)
+{
+  NS_ENSURE_ARG_POINTER(aBundle);
+  nsresult rv;
+  nsCOMPtr<nsIStringBundleService> bundleService = do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
+  nsCOMPtr<nsIStringBundle> bundle;
+  if (bundleService && NS_SUCCEEDED(rv))
+    bundleService->CreateBundle("chrome://messenger/locale/messenger.properties", getter_AddRefs(bundle));
+  bundle.swap(*aBundle);
+  return rv;
+}
+
+void
+nsMessengerOSXIntegration::FillToolTipInfo(nsIMsgFolder *aFolder, int32_t aNewCount)
+{
+  if (aFolder)
+  {
+    nsString authors;
+    int32_t numNotDisplayed;
+    nsresult rv = GetNewMailAuthors(aFolder, authors, aNewCount, &numNotDisplayed);
+
+    // If all senders are vetoed, the authors string will be empty.
+    if (NS_FAILED(rv) || authors.IsEmpty())
+      return;
+
+    // If this isn't the root folder, get it so we can report for it.
+    // GetRootFolder always returns the server's root, so calling on the root itself is fine.
+    nsCOMPtr<nsIMsgFolder> rootFolder;
+    aFolder->GetRootFolder(getter_AddRefs(rootFolder));
+    if (!rootFolder)
+      return;
+
+    nsString accountName;
+    rootFolder->GetPrettiestName(accountName);
+
+    nsCOMPtr<nsIStringBundle> bundle;
+    GetStringBundle(getter_AddRefs(bundle));
+    if (bundle)
+    {
+      nsAutoString numNewMsgsText;
+      numNewMsgsText.AppendInt(aNewCount);
+      nsString finalText;
+      nsCString uri;
+      aFolder->GetURI(uri);
+
+      if (numNotDisplayed > 0)
+      {
+        nsAutoString numNotDisplayedText;
+        numNotDisplayedText.AppendInt(numNotDisplayed);
+        const char16_t *formatStrings[3] = { numNewMsgsText.get(), authors.get(), numNotDisplayedText.get() };
+        bundle->FormatStringFromName(u"macBiffNotification_messages_extra",
+                                     formatStrings,
+                                     3,
+                                     getter_Copies(finalText));
+      }
+      else
+      {
+        const char16_t *formatStrings[2] = { numNewMsgsText.get(), authors.get() };
+
+        if (aNewCount == 1)
+        {
+          bundle->FormatStringFromName(u"macBiffNotification_message",
+                                       formatStrings,
+                                       2,
+                                       getter_Copies(finalText));
+          // Since there is only 1 message, use the most recent mail's URI instead of the folder's
+          nsCOMPtr<nsIMsgDatabase> db;
+          rv = aFolder->GetMsgDatabase(getter_AddRefs(db));
+          if (NS_SUCCEEDED(rv) && db)
+          {
+            uint32_t numNewKeys;
+            uint32_t *newMessageKeys;
+            rv = db->GetNewList(&numNewKeys, &newMessageKeys);
+            if (NS_SUCCEEDED(rv))
+            {
+              nsCOMPtr<nsIMsgDBHdr> hdr;
+              rv = db->GetMsgHdrForKey(newMessageKeys[numNewKeys - 1],
+                                       getter_AddRefs(hdr));
+              if (NS_SUCCEEDED(rv) && hdr)
+                aFolder->GetUriForMsg(hdr, uri);
+            }
+            NS_Free(newMessageKeys);
+          }
+        }
+        else
+          bundle->FormatStringFromName(u"macBiffNotification_messages",
+                                       formatStrings,
+                                       2,
+                                       getter_Copies(finalText));
+      }
+      ShowAlertMessage(accountName, finalText, uri);
+    } // if we got a bundle
+  } // if we got a folder
+}
+
+nsresult
+nsMessengerOSXIntegration::ShowAlertMessage(const nsAString& aAlertTitle,
+                                            const nsAString& aAlertText,
+                                            const nsACString& aFolderURI)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIAlertsService> alertsService (do_GetService(NS_ALERTSERVICE_CONTRACTID, &rv));
+  // If we have an nsIAlertsService implementation, use it:
+  if (NS_SUCCEEDED(rv))
+  {
+    alertsService->ShowAlertNotification(EmptyString(),
+                                         aAlertTitle, aAlertText, true,
+                                         NS_ConvertASCIItoUTF16(aFolderURI),
+                                         this, EmptyString(),
+                                         NS_LITERAL_STRING("auto"),
+                                         EmptyString(), EmptyString(),
+                                         nullptr,
+                                         false,
+                                         false);
+  }
+
+  BounceDockIcon();
+
+  if (NS_FAILED(rv))
+    OnAlertFinished();
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMessengerOSXIntegration::OnItemIntPropertyChanged(nsIMsgFolder *aFolder,
+                                                    nsIAtom *aProperty,
+                                                    int64_t aOldValue,
+                                                    int64_t aNewValue)
+{
+  // if we got new mail show an alert
+  if (aNewValue == nsIMsgFolder::nsMsgBiffState_NewMail)
+  {
+    bool performingBiff = false;
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    aFolder->GetServer(getter_AddRefs(server));
+    if (server)
+      server->GetPerformingBiff(&performingBiff);
+    if (!performingBiff)
+      return NS_OK; // kick out right now...
+
+    // Biff happens for the root folder, but we want info for the child with new mail
+    nsCString folderUri;
+    GetFirstFolderWithNewMail(aFolder, folderUri);
+    nsCOMPtr<nsIMsgFolder> childFolder;
+    nsresult rv = aFolder->GetChildWithURI(folderUri, true, true,
+                                           getter_AddRefs(childFolder));
+    if (NS_FAILED(rv) || !childFolder)
+      return NS_ERROR_FAILURE;
+
+    int32_t numNewMessages = 0;
+    childFolder->GetNumNewMessages(true, &numNewMessages);
+    FillToolTipInfo(childFolder, numNewMessages);
+  }
+  else if (mNewMailReceivedAtom == aProperty)
+  {
+    FillToolTipInfo(aFolder, aNewValue);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMessengerOSXIntegration::OnAlertClicked(const char16_t* aAlertCookie)
+{
+  openMailWindow(NS_ConvertUTF16toUTF8(aAlertCookie));
+  return NS_OK;
+}
+
+#ifdef MOZ_SUITE
+nsresult
+nsMessengerOSXIntegration::OnAlertClickedSimple()
+{
+  // SeaMonkey only function; only focus the app here, rest of the work will
+  // be done in suite/mailnews/mailWidgets.xml
+  FocusAppNative();
+  return NS_OK;
+}
+#endif
+
+nsresult
+nsMessengerOSXIntegration::OnAlertFinished()
+{
+  return NS_OK;
+}
+
+nsresult
+nsMessengerOSXIntegration::BounceDockIcon()
+{
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool bounceDockIcon = false;
+  rv = prefBranch->GetBoolPref(kBiffAnimateDockIconPref, &bounceDockIcon);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!bounceDockIcon)
+    return NS_OK;
+
+  nsCOMPtr<nsIWindowMediator> mediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID));
+  if (mediator)
+  {
+    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    mediator->GetMostRecentWindow(u"mail:3pane", getter_AddRefs(domWindow));
+    if (domWindow)
+    {
+      nsCOMPtr<nsIDOMChromeWindow> chromeWindow(do_QueryInterface(domWindow));
+      chromeWindow->GetAttention();
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMessengerOSXIntegration::RestoreDockIcon()
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
+
+  id tile = [[NSApplication sharedApplication] dockTile];
+  [tile setBadgeLabel: nil];
+
+  return NS_OK;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
+}
+
+nsresult
+nsMessengerOSXIntegration::BadgeDockIcon()
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
+
+  int32_t unreadCount = mUnreadTotal + mUnreadChat;
+  // If count is less than one, we should restore the original dock icon.
+  if (unreadCount < 1)
+  {
+    RestoreDockIcon();
+    return NS_OK;
+  }
+
+  // Draw the number, first giving extensions a chance to modify.
+  // Extensions might wish to transform "1000" into "100+" or some
+  // other short string. Getting back the empty string will cause
+  // nothing to be drawn and us to return early.
+  nsresult rv;
+  nsCOMPtr<nsIObserverService> os
+    (do_GetService("@mozilla.org/observer-service;1", &rv));
+  if (NS_FAILED(rv))
+  {
+    RestoreDockIcon();
+    return rv;
+  }
+
+  nsCOMPtr<nsISupportsString> str
+    (do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv));
+  if (NS_FAILED(rv))
+  {
+    RestoreDockIcon();
+    return rv;
+  }
+
+  nsAutoString total;
+  total.AppendInt(unreadCount);
+  str->SetData(total);
+  os->NotifyObservers(str, "before-unread-count-display",
+                      total.get());
+  nsAutoString badgeString;
+  str->GetData(badgeString);
+  if (badgeString.IsEmpty())
+  {
+    RestoreDockIcon();
+    return NS_OK;
+  }
+
+  id tile = [[NSApplication sharedApplication] dockTile];
+  [tile setBadgeLabel:[NSString stringWithFormat:@"%S", (const unichar*)badgeString.get()]];
+  return NS_OK;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
+}
+
+NS_IMETHODIMP
+nsMessengerOSXIntegration::OnItemPropertyFlagChanged(nsIMsgDBHdr *item, nsIAtom *property, uint32_t oldFlag, uint32_t newFlag)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerOSXIntegration::OnItemAdded(nsIMsgFolder *, nsISupports *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerOSXIntegration::OnItemBoolPropertyChanged(nsIMsgFolder *aItem,
+                                                         nsIAtom *aProperty,
+                                                         bool aOldValue,
+                                                         bool aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerOSXIntegration::OnItemEvent(nsIMsgFolder *, nsIAtom *)
+{
+  return NS_OK;
+}
+
+nsresult
+nsMessengerOSXIntegration::GetNewMailAuthors(nsIMsgFolder* aFolder,
+                                             nsString& aAuthors,
+                                             int32_t aNewCount,
+                                             int32_t* aNotDisplayed)
+{
+  // Get a list of names or email addresses for the folder's authors
+  // with new mail. Note that we only process the most recent "new"
+  // mail (aNewCount), working from most recently added. Duplicates
+  // are removed, and names are displayed to a set limit
+  // (kMaxDisplayCount) with the remaining count being returned in
+  // aNotDisplayed. Extension developers can listen for
+  // "newmail-notification-requested" and then make a decision about
+  // including a given author or not. As a result, it is possible that
+  // the resulting length of aAuthors will be 0.
+  nsCOMPtr<nsIMsgDatabase> db;
+  nsresult rv = aFolder->GetMsgDatabase(getter_AddRefs(db));
+  uint32_t numNewKeys = 0;
+  if (NS_SUCCEEDED(rv) && db)
+  {
+    nsCOMPtr<nsIObserverService> os =
+      do_GetService("@mozilla.org/observer-service;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Get proper l10n list separator -- ", " in English
+    nsCOMPtr<nsIStringBundle> bundle;
+    GetStringBundle(getter_AddRefs(bundle));
+    if (!bundle)
+      return NS_ERROR_FAILURE;
+
+    uint32_t *newMessageKeys;
+    rv = db->GetNewList(&numNewKeys, &newMessageKeys);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsString listSeparator;
+      bundle->GetStringFromName(u"macBiffNotification_separator", getter_Copies(listSeparator));
+
+      int32_t displayed = 0;
+      for (int32_t i = numNewKeys - 1; i >= 0; i--, aNewCount--)
+      {
+        if (0 == aNewCount || displayed == kMaxDisplayCount)
+          break;
+
+        nsCOMPtr<nsIMsgDBHdr> hdr;
+        rv = db->GetMsgHdrForKey(newMessageKeys[i],
+                                 getter_AddRefs(hdr));
+        if (NS_SUCCEEDED(rv) && hdr)
+        {
+          nsString author;
+          rv = hdr->GetMime2DecodedAuthor(author);
+          if (NS_FAILED(rv))
+            continue;
+
+          nsString name;
+          ExtractName(DecodedHeader(author), name);
+
+          // Give extensions a chance to suppress notifications for this author
+          nsCOMPtr<nsISupportsPRBool> notify =
+            do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID);
+
+          notify->SetData(true);
+          os->NotifyObservers(notify, "newmail-notification-requested",
+                              author.get());
+
+          bool includeSender;
+          notify->GetData(&includeSender);
+
+          // Don't add unwanted or duplicate names
+          if (includeSender && aAuthors.Find(name, true) == -1)
+          {
+            if (displayed > 0)
+              aAuthors.Append(listSeparator);
+            aAuthors.Append(name);
+            displayed++;
+          }
+        }
+      }
+    }
+    NS_Free(newMessageKeys);
+  }
+  *aNotDisplayed = aNewCount;
+  return rv;
+}
+
+nsresult
+nsMessengerOSXIntegration::GetFirstFolderWithNewMail(nsIMsgFolder* aFolder, nsCString& aFolderURI)
+{
+  // Find the subfolder in aFolder with new mail and return the folderURI
+  if (aFolder)
+  {
+    nsCOMPtr<nsIMsgFolder> msgFolder;
+    // enumerate over the folders under this root folder till we find one with new mail....
+    nsCOMPtr<nsIArray> allFolders;
+    nsresult rv = aFolder->GetDescendants(getter_AddRefs(allFolders));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsISimpleEnumerator> enumerator;
+    rv = allFolders->Enumerate(getter_AddRefs(enumerator));
+    if (NS_SUCCEEDED(rv) && enumerator)
+    {
+      nsCOMPtr<nsISupports> supports;
+      int32_t numNewMessages = 0;
+      bool hasMore = false;
+      while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore)
+      {
+        rv = enumerator->GetNext(getter_AddRefs(supports));
+        if (NS_SUCCEEDED(rv) && supports)
+        {
+          msgFolder = do_QueryInterface(supports, &rv);
+          if (msgFolder)
+          {
+            numNewMessages = 0;
+            msgFolder->GetNumNewMessages(false, &numNewMessages);
+            if (numNewMessages)
+              break; // kick out of the while loop
+          }
+        } // if we have a folder
+      }  // if we have more potential folders to enumerate
+    }  // if enumerator
+
+    if (msgFolder)
+      msgFolder->GetURI(aFolderURI);
+  }
+
+  return NS_OK;
+}
+
+/*
+ * Method implementations for mozINewMailListener
+ */
+NS_IMETHODIMP
+nsMessengerOSXIntegration::OnCountChanged(uint32_t count)
+{
+  mUnreadTotal = count;
+  BadgeDockIcon();
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMessengerUnixIntegration.cpp b/mailnews/base/src/nsMessengerUnixIntegration.cpp
new file mode 100644
index 000000000..0e4dd1405
--- /dev/null
+++ b/mailnews/base/src/nsMessengerUnixIntegration.cpp
@@ -0,0 +1,762 @@
+/* -*- 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 "nsMessengerUnixIntegration.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgMailSession.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIMsgIdentity.h"
+#include "nsIMsgAccount.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgWindow.h"
+#include "nsCOMPtr.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgFolderFlags.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsIDirectoryService.h"
+#include "nsIWindowWatcher.h"
+#include "nsIWindowMediator.h"
+#include "mozIDOMWindow.h"
+#include "nsPIDOMWindow.h"
+#include "nsIDocShell.h"
+#include "nsIBaseWindow.h"
+#include "MailNewsTypes.h"
+#include "nsIMessengerWindowService.h"
+#include "prprf.h"
+#include "nsIWeakReference.h"
+#include "nsIStringBundle.h"
+#include "nsIAlertsService.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgHdr.h"
+#include "nsAutoPtr.h"
+#include "prmem.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIWeakReferenceUtils.h"
+
+#include "nsNativeCharsetUtils.h"
+#include "nsToolkitCompsCID.h"
+#include "nsMsgUtils.h"
+#include "msgCore.h"
+#include "nsCOMArray.h"
+#include "nsIMutableArray.h"
+#include "nsArrayUtils.h"
+#include "nsMemory.h"
+#include "mozilla/Services.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+
+#define ALERT_CHROME_URL "chrome://messenger/content/newmailalert.xul"
+#define NEW_MAIL_ALERT_ICON "chrome://messenger/skin/icons/new-mail-alert.png"
+#define SHOW_ALERT_PREF "mail.biff.show_alert"
+#define SHOW_ALERT_PREVIEW_LENGTH "mail.biff.alert.preview_length"
+#define SHOW_ALERT_PREVIEW_LENGTH_DEFAULT 40
+#define SHOW_ALERT_PREVIEW "mail.biff.alert.show_preview"
+#define SHOW_ALERT_SENDER  "mail.biff.alert.show_sender"
+#define SHOW_ALERT_SUBJECT "mail.biff.alert.show_subject"
+#define SHOW_ALERT_SYSTEM  "mail.biff.use_system_alert"
+
+using namespace mozilla::mailnews;
+
+static void openMailWindow(const nsACString& aFolderUri)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailSession> mailSession ( do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv));
+  if (NS_FAILED(rv))
+    return;
+
+  nsCOMPtr<nsIMsgWindow> topMostMsgWindow;
+  rv = mailSession->GetTopmostMsgWindow(getter_AddRefs(topMostMsgWindow));
+  if (topMostMsgWindow)
+  {
+    if (!aFolderUri.IsEmpty())
+    {
+      nsCOMPtr<nsIMsgWindowCommands> windowCommands;
+      topMostMsgWindow->GetWindowCommands(getter_AddRefs(windowCommands));
+      if (windowCommands)
+        windowCommands->SelectFolder(aFolderUri);
+    }
+
+    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    topMostMsgWindow->GetDomWindow(getter_AddRefs(domWindow));
+    if (domWindow) {
+      nsCOMPtr<nsPIDOMWindowOuter> privateWindow = nsPIDOMWindowOuter::From(domWindow);
+      privateWindow->Focus();
+    }
+  }
+  else
+  {
+    // the user doesn't have a mail window open already so open one for them...
+    nsCOMPtr<nsIMessengerWindowService> messengerWindowService =
+      do_GetService(NS_MESSENGERWINDOWSERVICE_CONTRACTID);
+    // if we want to preselect the first account with new mail,
+    // here is where we would try to generate a uri to pass in
+    // (and add code to the messenger window service to make that work)
+    if (messengerWindowService)
+      messengerWindowService->OpenMessengerWindowWithUri(
+                                "mail:3pane", nsCString(aFolderUri).get(), nsMsgKey_None);
+  }
+}
+
+nsMessengerUnixIntegration::nsMessengerUnixIntegration()
+{
+  mBiffStateAtom = MsgGetAtom("BiffState");
+  mNewMailReceivedAtom = MsgGetAtom("NewMailReceived");
+  mAlertInProgress = false;
+  mFoldersWithNewMail = do_CreateInstance(NS_ARRAY_CONTRACTID);
+}
+
+NS_IMPL_ISUPPORTS(nsMessengerUnixIntegration, nsIFolderListener, nsIObserver,
+                   nsIMessengerOSIntegration, nsIUrlListener)
+
+nsresult
+nsMessengerUnixIntegration::Init()
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mailSession->AddFolderListener(this, nsIFolderListener::intPropertyChanged);
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnItemPropertyChanged(nsIMsgFolder *, nsIAtom *, char const *, char const *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnItemUnicharPropertyChanged(nsIMsgFolder *, nsIAtom *, const char16_t *, const char16_t *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnItemRemoved(nsIMsgFolder *, nsISupports *)
+{
+  return NS_OK;
+}
+
+nsresult nsMessengerUnixIntegration::GetStringBundle(nsIStringBundle **aBundle)
+{
+  NS_ENSURE_ARG_POINTER(aBundle);
+  nsCOMPtr<nsIStringBundleService> bundleService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+  nsCOMPtr<nsIStringBundle> bundle;
+  bundleService->CreateBundle("chrome://messenger/locale/messenger.properties",
+                              getter_AddRefs(bundle));
+  bundle.swap(*aBundle);
+  return NS_OK;
+}
+
+bool
+nsMessengerUnixIntegration::BuildNotificationTitle(nsIMsgFolder *aFolder, nsIStringBundle *aBundle, nsString &aTitle)
+{
+  nsString accountName;
+  aFolder->GetPrettiestName(accountName);
+
+  int32_t numNewMessages = 0;
+  aFolder->GetNumNewMessages(true, &numNewMessages);
+
+  if (!numNewMessages)
+    return false;
+
+  nsAutoString numNewMsgsText;
+  numNewMsgsText.AppendInt(numNewMessages);
+
+  const char16_t *formatStrings[] =
+  {
+    accountName.get(), numNewMsgsText.get()
+  };
+
+  aBundle->FormatStringFromName(numNewMessages == 1 ?
+                                  u"newMailNotification_message" :
+                                  u"newMailNotification_messages",
+                                formatStrings, 2, getter_Copies(aTitle));
+  return true;
+}
+
+/* This comparator lets us sort an nsCOMArray of nsIMsgDBHdr's by
+ * their dateInSeconds attributes in ascending order.
+ */
+static int
+nsMsgDbHdrTimestampComparator(nsIMsgDBHdr *aElement1,
+                              nsIMsgDBHdr *aElement2,
+                              void *aData)
+{
+  uint32_t aElement1Timestamp;
+  nsresult rv = aElement1->GetDateInSeconds(&aElement1Timestamp);
+  if (NS_FAILED(rv))
+    return 0;
+
+  uint32_t aElement2Timestamp;
+  rv = aElement2->GetDateInSeconds(&aElement2Timestamp);
+  if (NS_FAILED(rv))
+    return 0;
+
+  return aElement1Timestamp - aElement2Timestamp;
+}
+
+
+bool
+nsMessengerUnixIntegration::BuildNotificationBody(nsIMsgDBHdr *aHdr,
+                                                  nsIStringBundle *aBundle,
+                                                  nsString &aBody)
+{
+  nsAutoString alertBody;
+
+  bool showPreview = true;
+  bool showSubject = true;
+  bool showSender = true;
+  int32_t previewLength = SHOW_ALERT_PREVIEW_LENGTH_DEFAULT;
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (!prefBranch)
+    return false;
+
+  prefBranch->GetBoolPref(SHOW_ALERT_PREVIEW, &showPreview);
+  prefBranch->GetBoolPref(SHOW_ALERT_SENDER, &showSender);
+  prefBranch->GetBoolPref(SHOW_ALERT_SUBJECT, &showSubject);
+  prefBranch->GetIntPref(SHOW_ALERT_PREVIEW_LENGTH, &previewLength);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  aHdr->GetFolder(getter_AddRefs(folder));
+
+  if (!folder)
+    return false;
+
+  nsCString msgURI;
+  folder->GetUriForMsg(aHdr, msgURI);
+
+  bool localOnly;
+
+  size_t msgURIIndex = mFetchingURIs.IndexOf(msgURI);
+  if (msgURIIndex == mFetchingURIs.NoIndex)
+  {
+    localOnly = false;
+    mFetchingURIs.AppendElement(msgURI);
+  }
+  else
+    localOnly = true;
+
+  nsMsgKey messageKey;
+  if (NS_FAILED(aHdr->GetMessageKey(&messageKey)))
+    return false;
+
+  bool asyncResult = false;
+  nsresult rv = folder->FetchMsgPreviewText(&messageKey, 1,
+                                            localOnly, this,
+                                            &asyncResult);
+  // If we're still waiting on getting the message previews,
+  // bail early.  We'll come back later when the async operation
+  // finishes.
+  if (NS_FAILED(rv) || asyncResult)
+    return false;
+
+  // If we got here, that means that we've retrieved the message preview,
+  // so we can stop tracking it with our mFetchingURIs array.
+  if (msgURIIndex != mFetchingURIs.NoIndex)
+    mFetchingURIs.RemoveElementAt(msgURIIndex);
+
+  nsCString utf8previewString;
+  if (showPreview &&
+      NS_FAILED(aHdr->GetStringProperty("preview", getter_Copies(utf8previewString))))
+    return false;
+
+  // need listener that mailbox is remote such as IMAP
+  // to generate preview message
+  nsString previewString;
+  CopyUTF8toUTF16(utf8previewString, previewString);
+
+  nsString subject;
+  if (showSubject && NS_FAILED(aHdr->GetMime2DecodedSubject(subject)))
+    return false;
+
+  nsString author;
+  if (showSender)
+  {
+    nsString fullHeader;
+    if (NS_FAILED(aHdr->GetMime2DecodedAuthor(fullHeader)))
+      return false;
+
+    ExtractName(DecodedHeader(fullHeader), author);
+  }
+
+  if (showSubject && showSender)
+  {
+    nsString msgTitle;
+    const char16_t *formatStrings[] =
+    {
+      subject.get(), author.get()
+    };
+    aBundle->FormatStringFromName(u"newMailNotification_messagetitle",
+        formatStrings, 2, getter_Copies(msgTitle));
+    alertBody.Append(msgTitle);
+  }
+  else if (showSubject)
+    alertBody.Append(subject);
+  else if (showSender)
+    alertBody.Append(author);
+
+  if (showPreview && (showSubject || showSender))
+  {
+    alertBody.AppendLiteral("\n");
+  }
+
+  if (showPreview)
+    alertBody.Append(StringHead(previewString, previewLength));
+
+  if (alertBody.IsEmpty())
+    return false;
+
+  aBody.Assign(alertBody);
+  return true;
+}
+
+nsresult nsMessengerUnixIntegration::ShowAlertMessage(const nsAString& aAlertTitle, const nsAString& aAlertText, const nsACString& aFolderURI)
+{
+  nsresult rv;
+  // if we are already in the process of showing an alert, don't try to show another....
+  if (mAlertInProgress)
+    return NS_OK;
+
+  mAlertInProgress = true;
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // determine if we should use libnotify or the built-in alert system
+  bool useSystemAlert = true;
+  prefBranch->GetBoolPref(SHOW_ALERT_SYSTEM, &useSystemAlert);
+
+  if (useSystemAlert) {
+    nsCOMPtr<nsIAlertsService> alertsService(do_GetService(NS_SYSTEMALERTSERVICE_CONTRACTID, &rv));
+    if (NS_SUCCEEDED(rv)) {
+      rv = alertsService->ShowAlertNotification(NS_LITERAL_STRING(NEW_MAIL_ALERT_ICON),
+                                                aAlertTitle,
+                                                aAlertText,
+                                                false,
+                                                NS_ConvertASCIItoUTF16(aFolderURI),
+                                                this,
+                                                EmptyString(),
+                                                NS_LITERAL_STRING("auto"),
+                                                EmptyString(),
+                                                EmptyString(),
+                                                nullptr,
+                                                false,
+                                                false);
+      if (NS_SUCCEEDED(rv))
+        return rv;
+    }
+  }
+  AlertFinished();
+  rv = ShowNewAlertNotification(false);
+
+  if (NS_FAILED(rv)) // go straight to showing the system tray icon.
+    AlertFinished();
+
+  return rv;
+}
+
+// Opening Thunderbird's new mail alert notification window for not supporting libnotify
+// aUserInitiated --> true if we are opening the alert notification in response to a user action
+//                    like clicking on the biff icon
+nsresult nsMessengerUnixIntegration::ShowNewAlertNotification(bool aUserInitiated)
+{
+
+  nsresult rv;
+
+  // if we are already in the process of showing an alert, don't try to show another....
+  if (mAlertInProgress)
+    return NS_OK;
+
+  nsCOMPtr<nsIMutableArray> argsArray = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  if (!argsArray)
+    return NS_ERROR_FAILURE;
+
+  // pass in the array of folders with unread messages
+  nsCOMPtr<nsISupportsInterfacePointer> ifptr = do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  ifptr->SetData(mFoldersWithNewMail);
+  ifptr->SetDataIID(&NS_GET_IID(nsIArray));
+  argsArray->AppendElement(ifptr, false);
+
+  // pass in the observer
+  ifptr = do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr <nsISupports> supports = do_QueryInterface(static_cast<nsIMessengerOSIntegration*>(this));
+  ifptr->SetData(supports);
+  ifptr->SetDataIID(&NS_GET_IID(nsIObserver));
+  argsArray->AppendElement(ifptr, false);
+
+  // pass in the animation flag
+  nsCOMPtr<nsISupportsPRBool> scriptableUserInitiated (do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  scriptableUserInitiated->SetData(aUserInitiated);
+  argsArray->AppendElement(scriptableUserInitiated, false);
+
+  nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
+  nsCOMPtr<mozIDOMWindowProxy> newWindow;
+
+  mAlertInProgress = true;
+  rv = wwatch->OpenWindow(0, ALERT_CHROME_URL, "_blank",
+                          "chrome,dialog=yes,titlebar=no,popup=yes", argsArray,
+                          getter_AddRefs(newWindow));
+
+  if (NS_FAILED(rv))
+    AlertFinished();
+
+  return rv;
+}
+
+nsresult nsMessengerUnixIntegration::AlertFinished()
+{
+  mAlertInProgress = false;
+  return NS_OK;
+}
+
+nsresult nsMessengerUnixIntegration::AlertClicked()
+{
+  nsCString folderURI;
+  GetFirstFolderWithNewMail(folderURI);
+  openMailWindow(folderURI);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
+{
+  if (strcmp(aTopic, "alertfinished") == 0)
+    return AlertFinished();
+  if (strcmp(aTopic, "alertclickcallback") == 0)
+    return AlertClicked();
+
+  return NS_OK;
+}
+
+void nsMessengerUnixIntegration::FillToolTipInfo()
+{
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv,);
+
+  bool showAlert = true;
+  prefBranch->GetBoolPref(SHOW_ALERT_PREF, &showAlert);
+  if (!showAlert)
+    return;
+
+  nsCString folderUri;
+  GetFirstFolderWithNewMail(folderUri);
+
+  uint32_t count = 0;
+  NS_ENSURE_SUCCESS_VOID(mFoldersWithNewMail->GetLength(&count));
+
+  nsCOMPtr<nsIWeakReference> weakReference;
+  nsCOMPtr<nsIMsgFolder> folder = nullptr;
+  nsCOMPtr<nsIMsgFolder> folderWithNewMail = nullptr;
+
+  uint32_t i;
+  for (i = 0; i < count && !folderWithNewMail; i++)
+  {
+    weakReference = do_QueryElementAt(mFoldersWithNewMail, i);
+    folder = do_QueryReferent(weakReference);
+    folder->GetChildWithURI(folderUri, true, true,
+                            getter_AddRefs(folderWithNewMail));
+  }
+
+  if (folder && folderWithNewMail)
+  {
+    nsCOMPtr<nsIStringBundle> bundle;
+    GetStringBundle(getter_AddRefs(bundle));
+
+    if (!bundle)
+      return;
+
+    // Create the notification title
+    nsString alertTitle;
+    if (!BuildNotificationTitle(folder, bundle, alertTitle))
+      return;
+
+    // Let's get the new mail for this folder
+    nsCOMPtr<nsIMsgDatabase> db;
+    if (NS_FAILED(folderWithNewMail->GetMsgDatabase(getter_AddRefs(db))))
+      return;
+
+    uint32_t numNewKeys = 0;
+    uint32_t *newMessageKeys;
+    db->GetNewList(&numNewKeys, &newMessageKeys);
+
+    // If we had new messages, we *should* have new keys, but we'll
+    // check just in case.
+    if (numNewKeys <= 0) {
+      NS_Free(newMessageKeys);
+      return;
+    }
+
+    // Find the rootFolder that folder belongs to, and find out
+    // what MRUTime it maps to.  Assign this to lastMRUTime.
+    uint32_t lastMRUTime = 0;
+    if (NS_FAILED(GetMRUTimestampForFolder(folder, &lastMRUTime)))
+      lastMRUTime = 0;
+
+    // Next, add the new message headers to an nsCOMArray.  We
+    // only add message headers that are newer than lastMRUTime.
+    nsCOMArray<nsIMsgDBHdr> newMsgHdrs;
+    for (unsigned int i = 0; i < numNewKeys; ++i) {
+      nsCOMPtr<nsIMsgDBHdr> hdr;
+      if (NS_FAILED(db->GetMsgHdrForKey(newMessageKeys[i], getter_AddRefs(hdr))))
+        continue;
+
+      uint32_t dateInSeconds = 0;
+      hdr->GetDateInSeconds(&dateInSeconds);
+
+      if (dateInSeconds > lastMRUTime)
+        newMsgHdrs.AppendObject(hdr);
+
+    }
+
+    // At this point, we don't need newMessageKeys any more,
+    // so let's free it.
+    NS_Free(newMessageKeys);
+
+    // If we didn't happen to add any message headers, bail out
+    if (!newMsgHdrs.Count())
+      return;
+
+    // Sort the message headers by dateInSeconds, in ascending
+    // order
+    newMsgHdrs.Sort(nsMsgDbHdrTimestampComparator, nullptr);
+
+    nsString alertBody;
+
+    // Build the body text of the notification.
+    if (!BuildNotificationBody(newMsgHdrs[0], bundle, alertBody))
+      return;
+
+    // Show the notification
+    ShowAlertMessage(alertTitle, alertBody, EmptyCString());
+
+    // Find the last, and therefore newest message header
+    // in our nsCOMArray
+    nsCOMPtr<nsIMsgDBHdr> lastMsgHdr = newMsgHdrs[newMsgHdrs.Count() - 1];
+
+    uint32_t dateInSeconds = 0;
+    if (NS_FAILED(lastMsgHdr->GetDateInSeconds(&dateInSeconds)))
+      return;
+
+    // Write the newest message timestamp to the appropriate
+    // mapping in our hashtable of MRUTime's.
+    PutMRUTimestampForFolder(folder, dateInSeconds);
+  } // if we got a folder
+}
+
+// Get the first top level folder which we know has new mail, then enumerate over
+// all the subfolders looking for the first real folder with new mail.
+// Return the folderURI for that folder.
+nsresult nsMessengerUnixIntegration::GetFirstFolderWithNewMail(nsACString& aFolderURI)
+{
+  NS_ENSURE_TRUE(mFoldersWithNewMail, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsCOMPtr<nsIWeakReference> weakReference;
+
+  uint32_t count = 0;
+  nsresult rv = mFoldersWithNewMail->GetLength(&count);
+  if (NS_FAILED(rv) || !count)  // kick out if we don't have any folders with new mail
+    return NS_OK;
+
+  uint32_t i;
+  for(i = 0; i < count; i++)
+  {
+    weakReference = do_QueryElementAt(mFoldersWithNewMail, i);
+    folder = do_QueryReferent(weakReference);
+
+    // We only want to find folders which haven't been notified
+    // yet.  This is specific to Thunderbird.  In Seamonkey, we
+    // just return 0, and we don't care about timestamps anymore.
+    uint32_t lastMRUTime = 0;
+    rv = GetMRUTimestampForFolder(folder, &lastMRUTime);
+    if (NS_FAILED(rv))
+      lastMRUTime = 0;
+
+    if (!folder)
+      continue;
+    // enumerate over the folders under this root folder till we find one with new mail....
+    nsCOMPtr<nsIMsgFolder> msgFolder;
+    nsCOMPtr<nsIArray> allFolders;
+    rv = folder->GetDescendants(getter_AddRefs(allFolders));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    uint32_t subfolderCount = 0;
+    allFolders->GetLength(&subfolderCount);
+    uint32_t j;
+    for (j = 0; j < subfolderCount; j++)
+    {
+      nsCOMPtr<nsIMsgFolder> msgFolder = do_QueryElementAt(allFolders, j);
+
+      if (!msgFolder)
+        continue;
+
+      uint32_t flags;
+      rv = msgFolder->GetFlags(&flags);
+
+      if (NS_FAILED(rv))
+        continue;
+
+      // Unless we're dealing with an Inbox, we don't care
+      // about Drafts, Queue, SentMail, Template, or Junk folders
+      if (!(flags & nsMsgFolderFlags::Inbox) &&
+           (flags & (nsMsgFolderFlags::SpecialUse & ~nsMsgFolderFlags::Inbox)))
+        continue;
+
+      nsCString folderURI;
+      msgFolder->GetURI(folderURI);
+      bool hasNew = false;
+      rv = msgFolder->GetHasNewMessages(&hasNew);
+
+      if (NS_FAILED(rv))
+        continue;
+
+      // Grab the MRUTime property from the folder
+      nsCString dateStr;
+      msgFolder->GetStringProperty(MRU_TIME_PROPERTY, dateStr);
+      uint32_t MRUTime = (uint32_t) dateStr.ToInteger(&rv, 10);
+      if (NS_FAILED(rv))
+        MRUTime = 0;
+
+      if (hasNew && MRUTime > lastMRUTime)
+      {
+        rv = msgFolder->GetURI(aFolderURI);
+        NS_ENSURE_SUCCESS(rv, rv);
+        return NS_OK;
+      }
+    }  // if we have more potential folders to enumerate
+  }
+
+  // If we got here, then something when pretty wrong.
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnItemPropertyFlagChanged(nsIMsgDBHdr *item, nsIAtom *property, uint32_t oldFlag, uint32_t newFlag)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnItemAdded(nsIMsgFolder *, nsISupports *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnItemBoolPropertyChanged(nsIMsgFolder *aItem,
+                                                         nsIAtom *aProperty,
+                                                         bool aOldValue,
+                                                         bool aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnItemEvent(nsIMsgFolder *, nsIAtom *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnItemIntPropertyChanged(nsIMsgFolder *aItem, nsIAtom *aProperty, int64_t aOldValue, int64_t aNewValue)
+{
+  nsCString atomName;
+  // if we got new mail show an icon in the system tray
+  if (mBiffStateAtom == aProperty && mFoldersWithNewMail)
+  {
+    nsCOMPtr<nsIWeakReference> weakFolder = do_GetWeakReference(aItem);
+    uint32_t indexInNewArray;
+    nsresult rv = mFoldersWithNewMail->IndexOf(0, weakFolder, &indexInNewArray);
+    bool folderFound = NS_SUCCEEDED(rv);
+
+    if (aNewValue == nsIMsgFolder::nsMsgBiffState_NewMail)
+    {
+      // only show a system tray icon iff we are performing biff
+      // (as opposed to the user getting new mail)
+      bool performingBiff = false;
+      nsCOMPtr<nsIMsgIncomingServer> server;
+      aItem->GetServer(getter_AddRefs(server));
+      if (server)
+        server->GetPerformingBiff(&performingBiff);
+      if (!performingBiff)
+        return NS_OK; // kick out right now...
+
+      if (!folderFound)
+        mFoldersWithNewMail->AppendElement(weakFolder, false);
+      // now regenerate the tooltip
+      FillToolTipInfo();
+    }
+    else if (aNewValue == nsIMsgFolder::nsMsgBiffState_NoMail)
+    {
+      if (folderFound) {
+        mFoldersWithNewMail->RemoveElementAt(indexInNewArray);
+      }
+    }
+  } // if the biff property changed
+  else if (mNewMailReceivedAtom == aProperty)
+  {
+    FillToolTipInfo();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnStartRunningUrl(nsIURI *aUrl)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerUnixIntegration::OnStopRunningUrl(nsIURI *aUrl, nsresult aExitCode)
+{
+  if (NS_SUCCEEDED(aExitCode))
+    // preview fetch is done.
+    FillToolTipInfo();
+  return NS_OK;
+}
+
+nsresult
+nsMessengerUnixIntegration::GetMRUTimestampForFolder(nsIMsgFolder *aFolder,
+                                                     uint32_t *aLastMRUTime)
+{
+  nsCOMPtr<nsIMsgFolder> rootFolder = nullptr;
+  nsresult rv = aFolder->GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString rootFolderURI;
+  rootFolder->GetURI(rootFolderURI);
+  if (!mLastMRUTimes.Get(rootFolderURI, aLastMRUTime))
+    aLastMRUTime = 0;
+
+  return NS_OK;
+}
+
+nsresult
+nsMessengerUnixIntegration::PutMRUTimestampForFolder(nsIMsgFolder *aFolder,
+                                                     uint32_t aLastMRUTime)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> rootFolder = nullptr;
+  rv = aFolder->GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString rootFolderURI;
+  rootFolder->GetURI(rootFolderURI);
+  mLastMRUTimes.Put(rootFolderURI, aLastMRUTime);
+
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMessengerUnixIntegration.h b/mailnews/base/src/nsMessengerUnixIntegration.h
new file mode 100644
index 000000000..ba9f0f3f5
--- /dev/null
+++ b/mailnews/base/src/nsMessengerUnixIntegration.h
@@ -0,0 +1,63 @@
+/* -*- 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 __nsMessengerUnixIntegration_h
+#define __nsMessengerUnixIntegration_h
+
+#include "nsIMessengerOSIntegration.h"
+#include "nsIFolderListener.h"
+#include "nsIUrlListener.h"
+#include "nsIMutableArray.h"
+#include "nsIStringBundle.h"
+#include "nsIObserver.h"
+#include "nsIAtom.h"
+#include "nsDataHashtable.h"
+#include "nsTArray.h"
+
+#define NS_MESSENGERUNIXINTEGRATION_CID \
+  {0xf62f3d3a, 0x1dd1, 0x11b2, \
+    {0xa5, 0x16, 0xef, 0xad, 0xb1, 0x31, 0x61, 0x5c}}
+
+class nsIStringBundle;
+
+class nsMessengerUnixIntegration : public nsIFolderListener,
+                                   public nsIObserver,
+                                   public nsIUrlListener,
+                                   public nsIMessengerOSIntegration
+{
+public:
+  nsMessengerUnixIntegration();
+  virtual nsresult Init();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMESSENGEROSINTEGRATION
+  NS_DECL_NSIFOLDERLISTENER
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSIURLLISTENER
+
+private:
+  virtual ~nsMessengerUnixIntegration() {}
+  nsresult ShowAlertMessage(const nsAString& aAlertTitle, const nsAString& aAlertText, const nsACString& aFolderURI);
+  nsresult GetFirstFolderWithNewMail(nsACString& aFolderURI);
+  nsresult GetStringBundle(nsIStringBundle **aBundle);
+  nsresult AlertFinished();
+  nsresult AlertClicked();
+  void FillToolTipInfo();
+  nsresult GetMRUTimestampForFolder(nsIMsgFolder *aFolder, uint32_t *aLastMRUTime);
+
+  bool BuildNotificationBody(nsIMsgDBHdr *aHdr, nsIStringBundle *Bundle, nsString &aBody);
+  bool BuildNotificationTitle(nsIMsgFolder *aFolder, nsIStringBundle *aBundle, nsString &aTitle);
+  nsresult ShowNewAlertNotification(bool aUserInitiated);
+  nsresult PutMRUTimestampForFolder(nsIMsgFolder *aFolder, uint32_t aLastMRUTime);
+
+  nsCOMPtr<nsIMutableArray> mFoldersWithNewMail;  // keep track of all the root folders with pending new mail
+  nsCOMPtr<nsIAtom> mBiffStateAtom;
+  nsCOMPtr<nsIAtom> mNewMailReceivedAtom;
+  bool mAlertInProgress;
+  nsDataHashtable<nsCStringHashKey, uint32_t> mLastMRUTimes; // We keep track of the last time we did a new mail notification for each account
+  nsTArray<nsCString> mFetchingURIs;
+};
+
+#endif // __nsMessengerUnixIntegration_h
diff --git a/mailnews/base/src/nsMessengerWinIntegration.cpp b/mailnews/base/src/nsMessengerWinIntegration.cpp
new file mode 100644
index 000000000..a014b9737
--- /dev/null
+++ b/mailnews/base/src/nsMessengerWinIntegration.cpp
@@ -0,0 +1,1191 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <windows.h>
+#include <shellapi.h>
+
+#include "nsMessengerWinIntegration.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgMailSession.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIMsgIdentity.h"
+#include "nsIMsgAccount.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgWindow.h"
+#include "nsCOMPtr.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgFolderFlags.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsIDirectoryService.h"
+#include "nsIWindowWatcher.h"
+#include "nsIWindowMediator.h"
+#include "mozIDOMWindow.h"
+#include "nsPIDOMWindow.h"
+#include "nsIDocShell.h"
+#include "nsIBaseWindow.h"
+#include "nsIWidget.h"
+#include "nsWidgetsCID.h"
+#include "MailNewsTypes.h"
+#include "nsIMessengerWindowService.h"
+#include "prprf.h"
+#include "nsIWeakReference.h"
+#include "nsIStringBundle.h"
+#include "nsIAlertsService.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIProperties.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIWeakReferenceUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsMsgUtils.h"
+#ifdef MOZILLA_INTERNAL_API
+#include "mozilla/LookAndFeel.h"
+#endif
+#include "mozilla/Services.h"
+#include "nsIMutableArray.h"
+#include "nsArrayUtils.h"
+
+#include "nsToolkitCompsCID.h"
+#include <stdlib.h>
+#define PROFILE_COMMANDLINE_ARG " -profile "
+
+#define NOTIFICATIONCLASSNAME "MailBiffNotificationMessageWindow"
+#define UNREADMAILNODEKEY "Software\\Microsoft\\Windows\\CurrentVersion\\UnreadMail\\"
+#define SHELL32_DLL L"shell32.dll"
+#define DOUBLE_QUOTE "\""
+#define MAIL_COMMANDLINE_ARG " -mail"
+#define IDI_MAILBIFF 32576
+#define UNREAD_UPDATE_INTERVAL	(20 * 1000)	// 20 seconds
+#define ALERT_CHROME_URL "chrome://messenger/content/newmailalert.xul"
+#define NEW_MAIL_ALERT_ICON "chrome://messenger/skin/icons/new-mail-alert.png"
+#define SHOW_ALERT_PREF     "mail.biff.show_alert"
+#define SHOW_TRAY_ICON_PREF "mail.biff.show_tray_icon"
+#define SHOW_BALLOON_PREF   "mail.biff.show_balloon"
+#define SHOW_NEW_ALERT_PREF "mail.biff.show_new_alert"
+#define ALERT_ORIGIN_PREF   "ui.alertNotificationOrigin"
+
+// since we are including windows.h in this file, undefine get user name....
+#ifdef GetUserName
+#undef GetUserName
+#endif
+
+#ifndef NIIF_USER
+#define NIIF_USER       0x00000004
+#endif
+
+#ifndef NIIF_NOSOUND
+#define NIIF_NOSOUND    0x00000010
+#endif
+
+#ifndef NIN_BALOONUSERCLICK
+#define NIN_BALLOONUSERCLICK (WM_USER + 5)
+#endif
+
+#ifndef MOZILLA_INTERNAL_API
+// from LookAndFeel.h
+#define NS_ALERT_HORIZONTAL 1
+#define NS_ALERT_LEFT       2
+#define NS_ALERT_TOP        4
+#endif
+
+using namespace mozilla;
+
+// begin shameless copying from nsNativeAppSupportWin
+HWND hwndForDOMWindow( mozIDOMWindowProxy *window )
+{
+  if ( !window ) {
+    return 0;
+  }
+  nsCOMPtr<nsPIDOMWindowOuter> pidomwindow = nsPIDOMWindowOuter::From(window);
+
+  nsCOMPtr<nsIBaseWindow> ppBaseWindow =
+    do_QueryInterface( pidomwindow->GetDocShell() );
+  if (!ppBaseWindow)
+    return 0;
+
+  nsCOMPtr<nsIWidget> ppWidget;
+  ppBaseWindow->GetMainWidget( getter_AddRefs( ppWidget ) );
+
+  return (HWND)( ppWidget->GetNativeData( NS_NATIVE_WIDGET ) );
+}
+
+static void activateWindow( mozIDOMWindowProxy *win )
+{
+  // Try to get native window handle.
+  HWND hwnd = hwndForDOMWindow( win );
+  if ( hwnd )
+  {
+    // Restore the window if it is minimized.
+    if ( ::IsIconic( hwnd ) )
+      ::ShowWindow( hwnd, SW_RESTORE );
+    // Use the OS call, if possible.
+    ::SetForegroundWindow( hwnd );
+  } else {
+    // Use internal method.
+    nsCOMPtr<nsPIDOMWindowOuter> privateWindow = nsPIDOMWindowOuter::From(win);
+    privateWindow->Focus();
+  }
+}
+// end shameless copying from nsNativeAppWinSupport.cpp
+
+static void openMailWindow(const nsACString& aFolderUri)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailSession> mailSession ( do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv));
+  if (NS_FAILED(rv))
+    return;
+
+  nsCOMPtr<nsIMsgWindow> topMostMsgWindow;
+  rv = mailSession->GetTopmostMsgWindow(getter_AddRefs(topMostMsgWindow));
+  if (topMostMsgWindow)
+  {
+    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    topMostMsgWindow->GetDomWindow(getter_AddRefs(domWindow));
+    if (domWindow)
+    {
+      if (!aFolderUri.IsEmpty())
+      {
+        nsCOMPtr<nsIMsgWindowCommands> windowCommands;
+        topMostMsgWindow->GetWindowCommands(getter_AddRefs(windowCommands));
+        if (windowCommands)
+          windowCommands->SelectFolder(aFolderUri);
+      }
+      activateWindow(domWindow);
+      return;
+    }
+  }
+
+  {
+    // the user doesn't have a mail window open already so open one for them...
+    nsCOMPtr<nsIMessengerWindowService> messengerWindowService =
+      do_GetService(NS_MESSENGERWINDOWSERVICE_CONTRACTID);
+    // if we want to preselect the first account with new mail,
+    // here is where we would try to generate a uri to pass in
+    // (and add code to the messenger window service to make that work)
+    if (messengerWindowService)
+      messengerWindowService->OpenMessengerWindowWithUri(
+                                "mail:3pane", nsCString(aFolderUri).get(), nsMsgKey_None);
+  }
+}
+
+static void CALLBACK delayedSingleClick(HWND msgWindow, UINT msg, INT_PTR idEvent, DWORD dwTime)
+{
+  ::KillTimer(msgWindow, idEvent);
+
+  // single clicks on the biff icon should re-open the alert notification
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMessengerOSIntegration> integrationService =
+    do_GetService(NS_MESSENGEROSINTEGRATION_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv))
+  {
+    // we know we are dealing with the windows integration object
+    nsMessengerWinIntegration * winIntegrationService = static_cast<nsMessengerWinIntegration*>
+                                                                   (static_cast<nsIMessengerOSIntegration*>(integrationService.get()));
+    winIntegrationService->ShowNewAlertNotification(true, EmptyString(), EmptyString());
+  }
+}
+
+// Window proc.
+static LRESULT CALLBACK MessageWindowProc( HWND msgWindow, UINT msg, WPARAM wp, LPARAM lp )
+{
+  if (msg == WM_USER)
+  {
+    if (lp == WM_LBUTTONDOWN)
+    {
+      // the only way to tell a single left click
+      // from a double left click is to fire a timer which gets cleared if we end up getting
+      // a WM_LBUTTONDBLK event.
+      ::SetTimer(msgWindow, 1, GetDoubleClickTime(), (TIMERPROC) delayedSingleClick);
+    }
+    else if (lp == WM_LBUTTONDBLCLK || lp == NIN_BALLOONUSERCLICK)
+    {
+      ::KillTimer(msgWindow, 1);
+      openMailWindow(EmptyCString());
+    }
+  }
+
+  return TRUE;
+}
+
+static HWND msgWindow;
+
+// Create: Register class and create window.
+static nsresult Create()
+{
+  if (msgWindow)
+    return NS_OK;
+
+  WNDCLASS classStruct = { 0,                          // style
+                           &MessageWindowProc,         // lpfnWndProc
+                           0,                          // cbClsExtra
+                           0,                          // cbWndExtra
+                           0,                          // hInstance
+                           0,                          // hIcon
+                           0,                          // hCursor
+                           0,                          // hbrBackground
+                           0,                          // lpszMenuName
+                           NOTIFICATIONCLASSNAME };    // lpszClassName
+
+  // Register the window class.
+  NS_ENSURE_TRUE( ::RegisterClass( &classStruct ), NS_ERROR_FAILURE );
+  // Create the window.
+  NS_ENSURE_TRUE( msgWindow = ::CreateWindow( NOTIFICATIONCLASSNAME,
+                                              0,          // title
+                                              WS_CAPTION, // style
+                                              0,0,0,0,    // x, y, cx, cy
+                                              0,          // parent
+                                              0,          // menu
+                                              0,          // instance
+                                              0 ),        // create struct
+                  NS_ERROR_FAILURE );
+  return NS_OK;
+}
+
+
+nsMessengerWinIntegration::nsMessengerWinIntegration()
+{
+  mDefaultServerAtom = MsgGetAtom("DefaultServer");
+  mTotalUnreadMessagesAtom = MsgGetAtom("TotalUnreadMessages");
+
+  mUnreadTimerActive = false;
+
+  mBiffStateAtom = MsgGetAtom("BiffState");
+  mBiffIconVisible = false;
+  mSuppressBiffIcon = false;
+  mAlertInProgress = false;
+  mBiffIconInitialized = false;
+  mFoldersWithNewMail = do_CreateInstance(NS_ARRAY_CONTRACTID);
+}
+
+nsMessengerWinIntegration::~nsMessengerWinIntegration()
+{
+  if (mUnreadCountUpdateTimer) {
+    mUnreadCountUpdateTimer->Cancel();
+    mUnreadCountUpdateTimer = nullptr;
+  }
+
+  // one last attempt, update the registry
+  nsresult rv = UpdateRegistryWithCurrent();
+  NS_ASSERTION(NS_SUCCEEDED(rv), "failed to update registry on shutdown");
+  DestroyBiffIcon();
+}
+
+NS_IMPL_ADDREF(nsMessengerWinIntegration)
+NS_IMPL_RELEASE(nsMessengerWinIntegration)
+
+NS_INTERFACE_MAP_BEGIN(nsMessengerWinIntegration)
+   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMessengerOSIntegration)
+   NS_INTERFACE_MAP_ENTRY(nsIMessengerOSIntegration)
+   NS_INTERFACE_MAP_ENTRY(nsIFolderListener)
+   NS_INTERFACE_MAP_ENTRY(nsIObserver)
+NS_INTERFACE_MAP_END
+
+
+nsresult
+nsMessengerWinIntegration::ResetCurrent()
+{
+  mInboxURI.Truncate();
+  mEmail.Truncate();
+
+  mCurrentUnreadCount = -1;
+  mLastUnreadCountWrittenToRegistry = -1;
+
+  mDefaultAccountMightHaveAnInbox = true;
+  return NS_OK;
+}
+
+NOTIFYICONDATAW sBiffIconData = { NOTIFYICONDATAW_V2_SIZE,
+                                  0,
+                                  2,
+                                  NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_INFO,
+                                  WM_USER,
+                                  0,
+                                  L"",
+                                  0,
+                                  0,
+                                  L"",
+                                  30000,
+                                  L"",
+                                  NIIF_USER | NIIF_NOSOUND };
+// allow for the null terminator
+static const uint32_t kMaxTooltipSize = sizeof(sBiffIconData.szTip) /
+                                        sizeof(sBiffIconData.szTip[0]) - 1;
+static const uint32_t kMaxBalloonSize = sizeof(sBiffIconData.szInfo) /
+                                        sizeof(sBiffIconData.szInfo[0]) - 1;
+static const uint32_t kMaxBalloonTitle = sizeof(sBiffIconData.szInfoTitle) /
+                                         sizeof(sBiffIconData.szInfoTitle[0]) - 1;
+
+void nsMessengerWinIntegration::InitializeBiffStatusIcon()
+{
+  // initialize our biff status bar icon
+  Create();
+
+  sBiffIconData.hWnd = (HWND) msgWindow;
+  sBiffIconData.hIcon = ::LoadIcon( ::GetModuleHandle( NULL ), MAKEINTRESOURCE(IDI_MAILBIFF) );
+
+  mBiffIconInitialized = true;
+}
+
+nsresult
+nsMessengerWinIntegration::Init()
+{
+  nsresult rv;
+
+  // Get shell32.dll handle
+  HMODULE hModule = ::GetModuleHandleW(SHELL32_DLL);
+
+  if (hModule) {
+    // SHQueryUserNotificationState is available from Vista
+    mSHQueryUserNotificationState = (fnSHQueryUserNotificationState)GetProcAddress(hModule, "SHQueryUserNotificationState");
+  }
+
+  nsCOMPtr <nsIMsgAccountManager> accountManager =
+    do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // because we care if the default server changes
+  rv = accountManager->AddRootFolderListener(this);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // because we care if the unread total count changes
+  rv = mailSession->AddFolderListener(this, nsIFolderListener::boolPropertyChanged | nsIFolderListener::intPropertyChanged);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // get current profile path for the commandliner
+  nsCOMPtr<nsIProperties> directoryService =
+    do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIFile> profilePath;
+  rv = directoryService->Get(NS_APP_USER_PROFILE_50_DIR,
+                             NS_GET_IID(nsIFile),
+                             getter_AddRefs(profilePath));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = profilePath->GetPath(mProfilePath);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // get application path
+  WCHAR appPath[_MAX_PATH] = {0};
+  ::GetModuleFileNameW(nullptr, appPath, sizeof(appPath));
+  mAppName.Assign((char16_t *)appPath);
+
+  rv = ResetCurrent();
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerWinIntegration::OnItemPropertyChanged(nsIMsgFolder *, nsIAtom *, char const *, char const *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerWinIntegration::OnItemUnicharPropertyChanged(nsIMsgFolder *, nsIAtom *, const char16_t *, const char16_t *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerWinIntegration::OnItemRemoved(nsIMsgFolder *, nsISupports *)
+{
+  return NS_OK;
+}
+
+nsresult nsMessengerWinIntegration::GetStringBundle(nsIStringBundle **aBundle)
+{
+  NS_ENSURE_ARG_POINTER(aBundle);
+  nsCOMPtr<nsIStringBundleService> bundleService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+  nsCOMPtr<nsIStringBundle> bundle;
+  bundleService->CreateBundle("chrome://messenger/locale/messenger.properties",
+                              getter_AddRefs(bundle));
+  NS_IF_ADDREF(*aBundle = bundle);
+  return NS_OK;
+}
+
+#ifndef MOZ_THUNDERBIRD
+nsresult nsMessengerWinIntegration::ShowAlertMessage(const nsString& aAlertTitle,
+                                                     const nsString& aAlertText,
+                                                     const nsACString& aFolderURI)
+{
+  nsresult rv;
+
+  // if we are already in the process of showing an alert, don't try to show another....
+  if (mAlertInProgress)
+    return NS_OK;
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool showBalloon = false;
+  prefBranch->GetBoolPref(SHOW_BALLOON_PREF, &showBalloon);
+  sBiffIconData.szInfo[0] = '\0';
+  if (showBalloon) {
+    ::wcsncpy( sBiffIconData.szInfoTitle, aAlertTitle.get(), kMaxBalloonTitle);
+    ::wcsncpy( sBiffIconData.szInfo, aAlertText.get(), kMaxBalloonSize);
+  }
+
+  bool showAlert = true;
+  prefBranch->GetBoolPref(SHOW_ALERT_PREF, &showAlert);
+
+  if (showAlert)
+  {
+    nsCOMPtr<nsIAlertsService> alertsService (do_GetService(NS_ALERTSERVICE_CONTRACTID, &rv));
+    if (NS_SUCCEEDED(rv))
+    {
+      rv = alertsService->ShowAlertNotification(NS_LITERAL_STRING(NEW_MAIL_ALERT_ICON), aAlertTitle,
+                                                aAlertText, true,
+                                                NS_ConvertASCIItoUTF16(aFolderURI), this,
+                                                EmptyString(),
+                                                NS_LITERAL_STRING("auto"),
+                                                EmptyString(), EmptyString(),
+                                                nullptr,
+                                                false,
+                                                false);
+      mAlertInProgress = true;
+    }
+  }
+
+  if (!showAlert || NS_FAILED(rv)) // go straight to showing the system tray icon.
+    AlertFinished();
+
+  return rv;
+}
+#endif
+// Opening Thunderbird's new mail alert notification window
+// aUserInitiated --> true if we are opening the alert notification in response to a user action
+//                    like clicking on the biff icon
+nsresult nsMessengerWinIntegration::ShowNewAlertNotification(bool aUserInitiated, const nsString& aAlertTitle, const nsString& aAlertText)
+{
+  nsresult rv;
+
+  // if we are already in the process of showing an alert, don't try to show another....
+  if (mAlertInProgress)
+    return NS_OK;
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool showBalloon = false;
+  prefBranch->GetBoolPref(SHOW_BALLOON_PREF, &showBalloon);
+  sBiffIconData.szInfo[0] = '\0';
+  if (showBalloon) {
+    ::wcsncpy( sBiffIconData.szInfoTitle, aAlertTitle.get(), kMaxBalloonTitle);
+    ::wcsncpy( sBiffIconData.szInfo, aAlertText.get(), kMaxBalloonSize);
+  }
+
+  bool showAlert = true;
+
+  if (prefBranch)
+    prefBranch->GetBoolPref(SHOW_ALERT_PREF, &showAlert);
+
+  // check if we are allowed to show a notification
+  if (showAlert && mSHQueryUserNotificationState) {
+    MOZ_QUERY_USER_NOTIFICATION_STATE qstate;
+    if (SUCCEEDED(mSHQueryUserNotificationState(&qstate))) {
+      if (qstate != QUNS_ACCEPTS_NOTIFICATIONS) {
+        showAlert = false;
+      }
+    }
+  }
+
+  if (showAlert)
+  {
+    nsCOMPtr<nsIMutableArray> argsArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // pass in the array of folders with unread messages
+    nsCOMPtr<nsISupportsInterfacePointer> ifptr = do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    ifptr->SetData(mFoldersWithNewMail);
+    ifptr->SetDataIID(&NS_GET_IID(nsIArray));
+    rv = argsArray->AppendElement(ifptr, false);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // pass in the observer
+    ifptr = do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr <nsISupports> supports = do_QueryInterface(static_cast<nsIMessengerOSIntegration*>(this));
+    ifptr->SetData(supports);
+    ifptr->SetDataIID(&NS_GET_IID(nsIObserver));
+    rv = argsArray->AppendElement(ifptr, false);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // pass in the animation flag
+    nsCOMPtr<nsISupportsPRBool> scriptableUserInitiated (do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    scriptableUserInitiated->SetData(aUserInitiated);
+    rv = argsArray->AppendElement(scriptableUserInitiated, false);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // pass in the alert origin
+    nsCOMPtr<nsISupportsPRUint8> scriptableOrigin (do_CreateInstance(NS_SUPPORTS_PRUINT8_CONTRACTID));
+    NS_ENSURE_TRUE(scriptableOrigin, NS_ERROR_FAILURE);
+    scriptableOrigin->SetData(0);
+    int32_t origin = 0;
+#ifdef MOZILLA_INTERNAL_API
+    origin = LookAndFeel::GetInt(LookAndFeel::eIntID_AlertNotificationOrigin);
+#else
+    // Get task bar window handle
+    HWND shellWindow = FindWindowW(L"Shell_TrayWnd", NULL);
+
+    rv = prefBranch->GetIntPref(ALERT_ORIGIN_PREF, &origin);
+    if (NS_FAILED(rv) && (shellWindow != NULL))
+    {
+      // Determine position
+      APPBARDATA appBarData;
+      appBarData.hWnd = shellWindow;
+      appBarData.cbSize = sizeof(appBarData);
+      if (SHAppBarMessage(ABM_GETTASKBARPOS, &appBarData))
+      {
+        // Set alert origin as a bit field - see LookAndFeel.h
+        // 0 represents bottom right, sliding vertically.
+        switch(appBarData.uEdge)
+        {
+          case ABE_LEFT:
+            origin = NS_ALERT_HORIZONTAL | NS_ALERT_LEFT;
+            break;
+          case ABE_RIGHT:
+            origin = NS_ALERT_HORIZONTAL;
+            break;
+          case ABE_TOP:
+            origin = NS_ALERT_TOP;
+            // fall through for the right-to-left handling.
+          case ABE_BOTTOM:
+            // If the task bar is right-to-left,
+            // move the origin to the left
+            if (::GetWindowLong(shellWindow, GWL_EXSTYLE) &
+                  WS_EX_LAYOUTRTL)
+              origin |= NS_ALERT_LEFT;
+            break;
+        }
+      }
+    }
+#endif
+    scriptableOrigin->SetData(origin);
+
+    rv = argsArray->AppendElement(scriptableOrigin, false);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
+    nsCOMPtr<mozIDOMWindowProxy> newWindow;
+    rv = wwatch->OpenWindow(0, ALERT_CHROME_URL, "_blank",
+                "chrome,dialog=yes,titlebar=no,popup=yes", argsArray,
+                 getter_AddRefs(newWindow));
+
+    mAlertInProgress = true;
+  }
+
+  // if the user has turned off the mail alert, or  openWindow generated an error,
+  // then go straight to the system tray.
+  if (!showAlert || NS_FAILED(rv))
+    AlertFinished();
+
+  return rv;
+}
+
+nsresult nsMessengerWinIntegration::AlertFinished()
+{
+  // okay, we are done showing the alert
+  // now put an icon in the system tray, if allowed
+  bool showTrayIcon = !mSuppressBiffIcon || sBiffIconData.szInfo[0];
+  if (showTrayIcon)
+  {
+    nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+    if (prefBranch)
+      prefBranch->GetBoolPref(SHOW_TRAY_ICON_PREF, &showTrayIcon);
+  }
+  if (showTrayIcon)
+  {
+    GenericShellNotify(NIM_ADD);
+    mBiffIconVisible = true;
+  }
+  mSuppressBiffIcon = false;
+  mAlertInProgress = false;
+  return NS_OK;
+}
+
+nsresult nsMessengerWinIntegration::AlertClicked()
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  nsCOMPtr<nsIMsgWindow> topMostMsgWindow;
+  rv = mailSession->GetTopmostMsgWindow(getter_AddRefs(topMostMsgWindow));
+  if (topMostMsgWindow)
+  {
+    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    topMostMsgWindow->GetDomWindow(getter_AddRefs(domWindow));
+    if (domWindow)
+    {
+      activateWindow(domWindow);
+      return NS_OK;
+    }
+  }
+  // make sure we don't insert the icon in the system tray since the user clicked on the alert.
+  mSuppressBiffIcon = true;
+  nsCString folderURI;
+  GetFirstFolderWithNewMail(folderURI);
+  openMailWindow(folderURI);
+  return NS_OK;
+}
+
+#ifdef MOZ_SUITE
+nsresult nsMessengerWinIntegration::AlertClickedSimple()
+{
+  mSuppressBiffIcon = true;
+  return NS_OK;
+}
+#endif MOZ_SUITE
+
+NS_IMETHODIMP
+nsMessengerWinIntegration::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
+{
+  if (strcmp(aTopic, "alertfinished") == 0)
+      return AlertFinished();
+
+  if (strcmp(aTopic, "alertclickcallback") == 0)
+      return AlertClicked();
+
+#ifdef MOZ_SUITE
+  // SeaMonkey does most of the GUI work in JS code when clicking on a mail
+  // notification, so it needs an extra function here
+  if (strcmp(aTopic, "alertclicksimplecallback") == 0)
+      return AlertClickedSimple();
+#endif
+
+  return NS_OK;
+}
+
+static void EscapeAmpersands(nsString& aToolTip)
+{
+  // First, check to see whether we have any ampersands.
+  int32_t pos = aToolTip.FindChar('&');
+  if (pos == kNotFound)
+    return;
+
+  // Next, see if we only have bare ampersands.
+  pos = MsgFind(aToolTip, "&&", false, pos);
+
+  // Windows tooltip code removes one ampersand from each run,
+  // then collapses pairs of amperands. This means that in the easy case,
+  // we need to replace each ampersand with three.
+  MsgReplaceSubstring(aToolTip, NS_LITERAL_STRING("&"), NS_LITERAL_STRING("&&&"));
+  if (pos == kNotFound)
+    return;
+
+  // We inserted too many ampersands. Remove some.
+  for (;;) {
+    pos = MsgFind(aToolTip, "&&&&&&", false, pos);
+    if (pos == kNotFound)
+      return;
+
+    aToolTip.Cut(pos, 1);
+    pos += 2;
+  }
+}
+
+void nsMessengerWinIntegration::FillToolTipInfo()
+{
+  // iterate over all the folders in mFoldersWithNewMail
+  nsString accountName;
+  nsCString hostName;
+  nsString toolTipLine;
+  nsAutoString toolTipText;
+  nsAutoString animatedAlertText;
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsCOMPtr<nsIWeakReference> weakReference;
+  int32_t numNewMessages = 0;
+
+  uint32_t count = 0;
+  NS_ENSURE_SUCCESS_VOID(mFoldersWithNewMail->GetLength(&count));
+
+  for (uint32_t index = 0; index < count; index++)
+  {
+    weakReference = do_QueryElementAt(mFoldersWithNewMail, index);
+    folder = do_QueryReferent(weakReference);
+    if (folder)
+    {
+      folder->GetPrettiestName(accountName);
+
+      numNewMessages = 0;
+      folder->GetNumNewMessages(true, &numNewMessages);
+      nsCOMPtr<nsIStringBundle> bundle;
+      GetStringBundle(getter_AddRefs(bundle));
+      if (bundle)
+      {
+        nsAutoString numNewMsgsText;
+        numNewMsgsText.AppendInt(numNewMessages);
+
+        const char16_t *formatStrings[] =
+        {
+          numNewMsgsText.get(),
+        };
+
+        nsString finalText;
+        if (numNewMessages == 1)
+          bundle->FormatStringFromName(u"biffNotification_message", formatStrings, 1, getter_Copies(finalText));
+        else
+          bundle->FormatStringFromName(u"biffNotification_messages", formatStrings, 1, getter_Copies(finalText));
+
+        // the alert message is special...we actually only want to show the first account with
+        // new mail in the alert.
+        if (animatedAlertText.IsEmpty()) // if we haven't filled in the animated alert text yet
+          animatedAlertText = finalText;
+
+        toolTipLine.Append(accountName);
+        toolTipLine.Append(' ');
+        toolTipLine.Append(finalText);
+        EscapeAmpersands(toolTipLine);
+
+        // only add this new string if it will fit without truncation....
+        if (toolTipLine.Length() + toolTipText.Length() <= kMaxTooltipSize)
+          toolTipText.Append(toolTipLine);
+
+        // clear out the tooltip line for the next folder
+        toolTipLine.Assign('\n');
+      } // if we got a bundle
+    } // if we got a folder
+  } // for each folder
+
+  ::wcsncpy( sBiffIconData.szTip, toolTipText.get(), kMaxTooltipSize);
+
+  if (!mBiffIconVisible)
+  {
+#ifndef MOZ_THUNDERBIRD
+  nsresult rv;
+  bool showNewAlert = false;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  prefBranch->GetBoolPref(SHOW_NEW_ALERT_PREF, &showNewAlert);
+  if (!showNewAlert)
+    ShowAlertMessage(accountName, animatedAlertText, EmptyCString());
+  else
+#endif
+    ShowNewAlertNotification(false, accountName, animatedAlertText);
+  }
+  else
+   GenericShellNotify( NIM_MODIFY);
+}
+
+// Get the first top level folder which we know has new mail, then enumerate over
+// all the subfolders looking for the first real folder with new mail.
+// Return the folderURI for that folder.
+nsresult nsMessengerWinIntegration::GetFirstFolderWithNewMail(nsACString& aFolderURI)
+{
+  NS_ENSURE_TRUE(mFoldersWithNewMail, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsCOMPtr<nsIWeakReference> weakReference;
+  int32_t numNewMessages = 0;
+
+  uint32_t count = 0;
+  nsresult rv = mFoldersWithNewMail->GetLength(&count);
+  if (NS_FAILED(rv) || !count)  // kick out if we don't have any folders with new mail
+    return NS_OK;
+
+  weakReference = do_QueryElementAt(mFoldersWithNewMail, 0);
+  folder = do_QueryReferent(weakReference);
+
+  if (folder)
+  {
+    nsCOMPtr<nsIMsgFolder> msgFolder;
+    // enumerate over the folders under this root folder till we find one with new mail....
+    nsCOMPtr<nsIArray> allFolders;
+    rv = folder->GetDescendants(getter_AddRefs(allFolders));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsISimpleEnumerator> enumerator;
+    rv = allFolders->Enumerate(getter_AddRefs(enumerator));
+    if (NS_SUCCEEDED(rv) && enumerator)
+    {
+      nsCOMPtr<nsISupports> supports;
+      bool hasMore = false;
+      while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore)
+      {
+        rv = enumerator->GetNext(getter_AddRefs(supports));
+        if (NS_SUCCEEDED(rv) && supports)
+        {
+          msgFolder = do_QueryInterface(supports, &rv);
+          if (msgFolder)
+          {
+            numNewMessages = 0;
+            msgFolder->GetNumNewMessages(false, &numNewMessages);
+            if (numNewMessages)
+              break; // kick out of the while loop
+          }
+        } // if we have a folder
+      }  // if we have more potential folders to enumerate
+    }  // if enumerator
+
+    if (msgFolder)
+      msgFolder->GetURI(aFolderURI);
+  }
+
+  return NS_OK;
+}
+
+void nsMessengerWinIntegration::DestroyBiffIcon()
+{
+  GenericShellNotify(NIM_DELETE);
+  // Don't call DestroyIcon().  see http://bugzilla.mozilla.org/show_bug.cgi?id=134745
+}
+
+void nsMessengerWinIntegration::GenericShellNotify(DWORD aMessage)
+{
+  ::Shell_NotifyIconW( aMessage, &sBiffIconData );
+}
+
+NS_IMETHODIMP
+nsMessengerWinIntegration::OnItemPropertyFlagChanged(nsIMsgDBHdr *item, nsIAtom *property, uint32_t oldFlag, uint32_t newFlag)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerWinIntegration::OnItemAdded(nsIMsgFolder *, nsISupports *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerWinIntegration::OnItemBoolPropertyChanged(nsIMsgFolder *aItem,
+                                                         nsIAtom *aProperty,
+                                                         bool aOldValue,
+                                                         bool aNewValue)
+{
+  if (aProperty == mDefaultServerAtom) {
+    nsresult rv;
+
+    // this property changes multiple times
+    // on account deletion or when the user changes their
+    // default account.  ResetCurrent() will set
+    // mInboxURI to null, so we use that
+    // to prevent us from attempting to remove
+    // something from the registry that has already been removed
+    if (!mInboxURI.IsEmpty() && !mEmail.IsEmpty()) {
+      rv = RemoveCurrentFromRegistry();
+      NS_ENSURE_SUCCESS(rv,rv);
+    }
+
+    // reset so we'll go get the new default server next time
+    rv = ResetCurrent();
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = UpdateUnreadCount();
+    NS_ENSURE_SUCCESS(rv,rv);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerWinIntegration::OnItemEvent(nsIMsgFolder *, nsIAtom *)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMessengerWinIntegration::OnItemIntPropertyChanged(nsIMsgFolder *aItem, nsIAtom *aProperty, int64_t aOldValue, int64_t aNewValue)
+{
+  // if we got new mail show a icon in the system tray
+  if (mBiffStateAtom == aProperty && mFoldersWithNewMail)
+  {
+    nsCOMPtr<nsIWeakReference> weakFolder = do_GetWeakReference(aItem);
+    uint32_t indexInNewArray;
+    nsresult rv = mFoldersWithNewMail->IndexOf(0, weakFolder, &indexInNewArray);
+    bool folderFound = NS_SUCCEEDED(rv);
+
+    if (!mBiffIconInitialized)
+      InitializeBiffStatusIcon();
+
+    if (aNewValue == nsIMsgFolder::nsMsgBiffState_NewMail)
+    {
+      // if the icon is not already visible, only show a system tray icon iff
+      // we are performing biff (as opposed to the user getting new mail)
+      if (!mBiffIconVisible)
+      {
+        bool performingBiff = false;
+        nsCOMPtr<nsIMsgIncomingServer> server;
+        aItem->GetServer(getter_AddRefs(server));
+        if (server)
+          server->GetPerformingBiff(&performingBiff);
+        if (!performingBiff)
+          return NS_OK; // kick out right now...
+      }
+      if (!folderFound)
+        mFoldersWithNewMail->InsertElementAt(weakFolder, 0, false);
+      // now regenerate the tooltip
+      FillToolTipInfo();
+    }
+    else if (aNewValue == nsIMsgFolder::nsMsgBiffState_NoMail)
+    {
+      // we are always going to remove the icon whenever we get our first no mail
+      // notification.
+
+      // avoid a race condition where we are told to remove the icon before we've actually
+      // added it to the system tray. This happens when the user reads a new message before
+      // the animated alert has gone away.
+      if (mAlertInProgress)
+        mSuppressBiffIcon = true;
+
+      if (folderFound)
+        mFoldersWithNewMail->RemoveElementAt(indexInNewArray);
+      if (mBiffIconVisible)
+      {
+        mBiffIconVisible = false;
+        GenericShellNotify(NIM_DELETE);
+      }
+    }
+  } // if the biff property changed
+
+  if (aProperty == mTotalUnreadMessagesAtom) {
+    nsCString itemURI;
+    nsresult rv;
+    rv = aItem->GetURI(itemURI);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    if (mInboxURI.Equals(itemURI))
+      mCurrentUnreadCount = aNewValue;
+
+    // If the timer isn't running yet, then we immediately update the
+    // registry and then start a one-shot timer. If the Unread counter
+    // has toggled zero / nonzero, we also update immediately.
+    // Otherwise, if the timer is running, defer the update. This means
+    // that all counter updates that occur within the timer interval are
+    // batched into a single registry update, to avoid hitting the
+    // registry too frequently. We also do a final update on shutdown,
+    // regardless of the timer.
+    if (!mUnreadTimerActive ||
+         (!mCurrentUnreadCount && mLastUnreadCountWrittenToRegistry) ||
+         (mCurrentUnreadCount && mLastUnreadCountWrittenToRegistry < 1)) {
+      rv = UpdateUnreadCount();
+      NS_ENSURE_SUCCESS(rv,rv);
+      // If timer wasn't running, start it.
+      if (!mUnreadTimerActive)
+        rv = SetupUnreadCountUpdateTimer();
+    }
+  }
+  return NS_OK;
+}
+
+void
+nsMessengerWinIntegration::OnUnreadCountUpdateTimer(nsITimer *timer, void *osIntegration)
+{
+  nsMessengerWinIntegration *winIntegration = (nsMessengerWinIntegration*)osIntegration;
+
+  winIntegration->mUnreadTimerActive = false;
+  nsresult rv = winIntegration->UpdateUnreadCount();
+  NS_ASSERTION(NS_SUCCEEDED(rv), "updating unread count failed");
+}
+
+nsresult
+nsMessengerWinIntegration::RemoveCurrentFromRegistry()
+{
+  // If Windows XP, open the registry and get rid of old account registry entries
+  // If there is a email prefix, get it and use it to build the registry key.
+  // Otherwise, just the email address will be the registry key.
+  nsAutoString currentUnreadMailCountKey;
+  if (!mEmailPrefix.IsEmpty()) {
+    currentUnreadMailCountKey.Assign(mEmailPrefix);
+    currentUnreadMailCountKey.Append(NS_ConvertASCIItoUTF16(mEmail));
+  }
+  else
+    CopyASCIItoUTF16(mEmail, currentUnreadMailCountKey);
+
+  WCHAR registryUnreadMailCountKey[_MAX_PATH] = {0};
+  // Enumerate through registry entries to delete the key matching
+  // currentUnreadMailCountKey
+  int index = 0;
+  while (SUCCEEDED(SHEnumerateUnreadMailAccountsW(HKEY_CURRENT_USER,
+                                                  index,
+                                                  registryUnreadMailCountKey,
+                                                  sizeof(registryUnreadMailCountKey))))
+  {
+    if (wcscmp(registryUnreadMailCountKey, currentUnreadMailCountKey.get())==0) {
+      nsAutoString deleteKey;
+      deleteKey.Assign(NS_LITERAL_STRING(UNREADMAILNODEKEY).get());
+      deleteKey.Append(currentUnreadMailCountKey.get());
+
+      if (!deleteKey.IsEmpty()) {
+        // delete this key and berak out of the loop
+        RegDeleteKey(HKEY_CURRENT_USER,
+                     NS_ConvertUTF16toUTF8(deleteKey).get());
+        break;
+      }
+      else {
+        index++;
+      }
+    }
+    else {
+      index++;
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMessengerWinIntegration::UpdateRegistryWithCurrent()
+{
+  if (mInboxURI.IsEmpty() || mEmail.IsEmpty())
+    return NS_OK;
+
+  // only update the registry if the count has changed
+  // and if the unread count is valid
+  if ((mCurrentUnreadCount < 0) || (mCurrentUnreadCount == mLastUnreadCountWrittenToRegistry))
+    return NS_OK;
+
+  // commandliner has to be built in the form of statement
+  // which can be open the mailer app to the default user account
+  // For given profile 'foo', commandliner will be built as
+  // ""<absolute path to application>" -p foo -mail" where absolute
+  // path to application is extracted from mAppName
+  nsAutoString commandLinerForAppLaunch;
+  commandLinerForAppLaunch.Assign(NS_LITERAL_STRING(DOUBLE_QUOTE));
+  commandLinerForAppLaunch.Append(mAppName);
+  commandLinerForAppLaunch.Append(NS_LITERAL_STRING(DOUBLE_QUOTE));
+  commandLinerForAppLaunch.Append(NS_LITERAL_STRING(PROFILE_COMMANDLINE_ARG));
+  commandLinerForAppLaunch.Append(NS_LITERAL_STRING(DOUBLE_QUOTE));
+  commandLinerForAppLaunch.Append(mProfilePath);
+  commandLinerForAppLaunch.Append(NS_LITERAL_STRING(DOUBLE_QUOTE));
+  commandLinerForAppLaunch.Append(NS_LITERAL_STRING(MAIL_COMMANDLINE_ARG));
+
+  if (!commandLinerForAppLaunch.IsEmpty())
+  {
+    nsAutoString pBuffer;
+
+    if (!mEmailPrefix.IsEmpty()) {
+      pBuffer.Assign(mEmailPrefix);
+      pBuffer.Append(NS_ConvertASCIItoUTF16(mEmail));
+    }
+    else
+      CopyASCIItoUTF16(mEmail, pBuffer);
+
+    // Write the info into the registry
+    HRESULT hr = SHSetUnreadMailCountW(pBuffer.get(),
+                                       mCurrentUnreadCount,
+                                       commandLinerForAppLaunch.get());
+  }
+
+  // do this last
+  mLastUnreadCountWrittenToRegistry = mCurrentUnreadCount;
+
+  return NS_OK;
+}
+
+nsresult
+nsMessengerWinIntegration::SetupInbox()
+{
+  nsresult rv;
+
+  // get default account
+  nsCOMPtr <nsIMsgAccountManager> accountManager =
+    do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr <nsIMsgAccount> account;
+  rv = accountManager->GetDefaultAccount(getter_AddRefs(account));
+  if (NS_FAILED(rv)) {
+    // this can happen if we launch mail on a new profile
+    // we don't have a default account yet
+    mDefaultAccountMightHaveAnInbox = false;
+    return NS_OK;
+  }
+
+  // get incoming server
+  nsCOMPtr <nsIMsgIncomingServer> server;
+  rv = account->GetIncomingServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv,rv);
+  if (!server)
+    return NS_ERROR_FAILURE;
+
+  nsCString type;
+  rv = server->GetType(type);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // we only care about imap and pop3
+  if (type.EqualsLiteral("imap") || type.EqualsLiteral("pop3")) {
+    // imap and pop3 account should have an Inbox
+    mDefaultAccountMightHaveAnInbox = true;
+
+    mEmailPrefix.Truncate();
+
+    // Get user's email address
+    nsCOMPtr<nsIMsgIdentity> identity;
+    rv = account->GetDefaultIdentity(getter_AddRefs(identity));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    if (!identity)
+      return NS_ERROR_FAILURE;
+
+    rv = identity->GetEmail(mEmail);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+    rv = server->GetRootMsgFolder(getter_AddRefs(rootMsgFolder));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    if (!rootMsgFolder)
+      return NS_ERROR_FAILURE;
+
+    nsCOMPtr <nsIMsgFolder> inboxFolder;
+    rootMsgFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox,
+                                      getter_AddRefs(inboxFolder));
+    NS_ENSURE_TRUE(inboxFolder, NS_ERROR_FAILURE);
+
+    rv = inboxFolder->GetURI(mInboxURI);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = inboxFolder->GetNumUnread(false, &mCurrentUnreadCount);
+    NS_ENSURE_SUCCESS(rv,rv);
+  }
+  else {
+    // the default account is valid, but it's not something
+    // that we expect to have an inbox.  (local folders, news accounts)
+    // set this flag to avoid calling SetupInbox() every time
+    // the timer goes off.
+    mDefaultAccountMightHaveAnInbox = false;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsMessengerWinIntegration::UpdateUnreadCount()
+{
+  nsresult rv;
+
+  if (mDefaultAccountMightHaveAnInbox && mInboxURI.IsEmpty()) {
+    rv = SetupInbox();
+    NS_ENSURE_SUCCESS(rv,rv);
+  }
+
+  return UpdateRegistryWithCurrent();
+}
+
+nsresult
+nsMessengerWinIntegration::SetupUnreadCountUpdateTimer()
+{
+  mUnreadTimerActive = true;
+  if (mUnreadCountUpdateTimer)
+    mUnreadCountUpdateTimer->Cancel();
+  else
+    mUnreadCountUpdateTimer = do_CreateInstance("@mozilla.org/timer;1");
+
+  mUnreadCountUpdateTimer->InitWithFuncCallback(OnUnreadCountUpdateTimer,
+    (void *)this, UNREAD_UPDATE_INTERVAL, nsITimer::TYPE_ONE_SHOT);
+
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMessengerWinIntegration.h b/mailnews/base/src/nsMessengerWinIntegration.h
new file mode 100644
index 000000000..6c49a71c2
--- /dev/null
+++ b/mailnews/base/src/nsMessengerWinIntegration.h
@@ -0,0 +1,122 @@
+/* -*- 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 __nsMessengerWinIntegration_h
+#define __nsMessengerWinIntegration_h
+
+#include <windows.h>
+
+// shellapi.h is needed to build with WIN32_LEAN_AND_MEAN
+#include <shellapi.h>
+
+#include "nsIMessengerOSIntegration.h"
+#include "nsIFolderListener.h"
+#include "nsIAtom.h"
+#include "nsITimer.h"
+#include "nsCOMPtr.h"
+#include "nsStringGlue.h"
+#include "nsIMutableArray.h"
+#include "nsIObserver.h"
+
+typedef enum tagMOZ_QUERY_USER_NOTIFICATION_STATE {
+    QUNS_NOT_PRESENT = 1,
+    QUNS_BUSY = 2,
+    QUNS_RUNNING_D3D_FULL_SCREEN = 3,
+    QUNS_PRESENTATION_MODE = 4,
+    QUNS_ACCEPTS_NOTIFICATIONS = 5,
+    QUNS_QUIET_TIME = 6
+} MOZ_QUERY_USER_NOTIFICATION_STATE;
+
+// this function is exported by shell32.dll on Windows Vista or later
+extern "C"
+{
+// Vista or later
+typedef HRESULT (__stdcall *fnSHQueryUserNotificationState)(MOZ_QUERY_USER_NOTIFICATION_STATE *pquns);
+}
+
+#define NS_MESSENGERWININTEGRATION_CID \
+  {0xf62f3d3a, 0x1dd1, 0x11b2, \
+    {0xa5, 0x16, 0xef, 0xad, 0xb1, 0x31, 0x61, 0x5c}}
+
+class nsIStringBundle; 
+
+class nsMessengerWinIntegration : public nsIMessengerOSIntegration,
+                                  public nsIFolderListener,
+                                  public nsIObserver
+{
+public:
+  nsMessengerWinIntegration();
+  virtual nsresult Init();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMESSENGEROSINTEGRATION
+  NS_DECL_NSIFOLDERLISTENER
+  NS_DECL_NSIOBSERVER
+
+  nsresult ShowNewAlertNotification(bool aUserInitiated, const nsString& aAlertTitle, const nsString& aAlertText);
+#ifndef MOZ_THUNDERBIRD
+  nsresult ShowAlertMessage(const nsString& aAlertTitle, const nsString& aAlertText, const nsACString& aFolderURI);
+#endif
+
+private:
+  virtual ~nsMessengerWinIntegration();
+  nsresult AlertFinished();
+  nsresult AlertClicked();
+#ifdef MOZ_SUITE
+  nsresult AlertClickedSimple();
+#endif
+
+  void InitializeBiffStatusIcon(); 
+  void FillToolTipInfo();
+  void GenericShellNotify(DWORD aMessage);
+  void DestroyBiffIcon();
+
+  nsresult GetFirstFolderWithNewMail(nsACString& aFolderURI);
+
+  nsresult GetStringBundle(nsIStringBundle **aBundle);
+  nsCOMPtr<nsIMutableArray> mFoldersWithNewMail;  // keep track of all the root folders with pending new mail
+  nsCOMPtr<nsIAtom> mBiffStateAtom;
+  uint32_t mCurrentBiffState;
+
+  bool mBiffIconVisible;
+  bool mBiffIconInitialized;
+  bool mSuppressBiffIcon;
+  bool mAlertInProgress;
+  
+  // "might" because we don't know until we check 
+  // what type of server is associated with the default account
+  bool            mDefaultAccountMightHaveAnInbox;
+
+  // True if the timer is running
+  bool mUnreadTimerActive;
+
+  nsresult ResetCurrent();
+  nsresult RemoveCurrentFromRegistry();
+  nsresult UpdateRegistryWithCurrent();
+  nsresult SetupInbox();
+
+  nsresult SetupUnreadCountUpdateTimer();
+  static void OnUnreadCountUpdateTimer(nsITimer *timer, void *osIntegration);
+  nsresult UpdateUnreadCount();
+
+  nsCOMPtr <nsIAtom> mDefaultServerAtom;
+  nsCOMPtr <nsIAtom> mTotalUnreadMessagesAtom;
+  nsCOMPtr <nsITimer> mUnreadCountUpdateTimer;
+
+  fnSHQueryUserNotificationState mSHQueryUserNotificationState;
+
+  nsCString mInboxURI;
+  nsCString mEmail;
+
+  nsString  mAppName;
+  nsString  mEmailPrefix;
+
+  nsString mProfilePath;
+
+  int32_t   mCurrentUnreadCount;
+  int32_t   mLastUnreadCountWrittenToRegistry;
+};
+
+#endif // __nsMessengerWinIntegration_h
diff --git a/mailnews/base/src/nsMsgAccount.cpp b/mailnews/base/src/nsMsgAccount.cpp
new file mode 100644
index 000000000..9022176bf
--- /dev/null
+++ b/mailnews/base/src/nsMsgAccount.cpp
@@ -0,0 +1,435 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+#include "prprf.h"
+#include "plstr.h"
+#include "prmem.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsCRTGlue.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgFolderNotificationService.h"
+
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgAccount.h"
+#include "nsIMsgAccount.h"
+#include "nsIMsgAccountManager.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMemory.h"
+#include "nsComponentManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "nsArrayUtils.h"
+
+NS_IMPL_ISUPPORTS(nsMsgAccount, nsIMsgAccount)
+
+nsMsgAccount::nsMsgAccount()
+  : mTriedToGetServer(false)
+{
+}
+
+nsMsgAccount::~nsMsgAccount()
+{
+}
+
+nsresult
+nsMsgAccount::getPrefService()
+{
+  if (m_prefs)
+    return NS_OK;
+
+  nsresult rv;
+  NS_ENSURE_FALSE(m_accountKey.IsEmpty(), NS_ERROR_NOT_INITIALIZED);
+  nsCOMPtr<nsIPrefService> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString accountRoot("mail.account.");
+  accountRoot.Append(m_accountKey);
+  accountRoot.Append('.');
+  return prefs->GetBranch(accountRoot.get(), getter_AddRefs(m_prefs));
+}
+
+NS_IMETHODIMP
+nsMsgAccount::GetIncomingServer(nsIMsgIncomingServer **aIncomingServer)
+{
+  NS_ENSURE_ARG_POINTER(aIncomingServer);
+
+  // create the incoming server lazily
+  if (!mTriedToGetServer && !m_incomingServer) {
+    mTriedToGetServer = true;
+    // ignore the error (and return null), but it's still bad so warn
+    mozilla::DebugOnly<nsresult> rv = createIncomingServer();
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "couldn't lazily create the server\n");
+  }
+
+  NS_IF_ADDREF(*aIncomingServer = m_incomingServer);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccount::CreateServer()
+{
+  if (m_incomingServer)
+    return NS_ERROR_ALREADY_INITIALIZED;
+  return createIncomingServer();
+}
+
+nsresult
+nsMsgAccount::createIncomingServer()
+{
+  // from here, load mail.account.myaccount.server
+  // Load the incoming server
+  //
+  // ex) mail.account.myaccount.server = "myserver"
+
+  nsresult rv = getPrefService();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // get the "server" pref
+  nsCString serverKey;
+  rv = m_prefs->GetCharPref("server", getter_Copies(serverKey));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // get the server from the account manager
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+           do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = accountManager->GetIncomingServer(serverKey, getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // store the server in this structure
+  m_incomingServer = server;
+  accountManager->NotifyServerLoaded(server);
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgAccount::SetIncomingServer(nsIMsgIncomingServer *aIncomingServer)
+{
+  NS_ENSURE_ARG_POINTER(aIncomingServer);
+
+  nsCString key;
+  nsresult rv = aIncomingServer->GetKey(key);
+
+  if (NS_SUCCEEDED(rv)) {
+    rv = getPrefService();
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_prefs->SetCharPref("server", key.get());
+  }
+
+  m_incomingServer = aIncomingServer;
+
+  bool serverValid;
+  (void) aIncomingServer->GetValid(&serverValid);
+  // only notify server loaded if server is valid so
+  // account manager only gets told about finished accounts.
+  if (serverValid)
+  {
+    // this is the point at which we can notify listeners about the
+    // creation of the root folder, which implies creation of the new server.
+    nsCOMPtr<nsIMsgFolder> rootFolder;
+    rv = aIncomingServer->GetRootFolder(getter_AddRefs(rootFolder));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIFolderListener> mailSession =
+             do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    mailSession->OnItemAdded(nullptr, rootFolder);
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    notifier->NotifyFolderAdded(rootFolder);
+
+    nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+    if (NS_SUCCEEDED(rv))
+      accountManager->NotifyServerLoaded(aIncomingServer);
+
+    // Force built-in folders to be created and discovered. Then, notify listeners
+    // about them.
+    nsCOMPtr<nsISimpleEnumerator> enumerator;
+    rv = rootFolder->GetSubFolders(getter_AddRefs(enumerator));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    bool hasMore;
+    while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore)
+    {
+      nsCOMPtr<nsISupports> item;
+      enumerator->GetNext(getter_AddRefs(item));
+
+      nsCOMPtr<nsIMsgFolder> msgFolder(do_QueryInterface(item));
+      if (!msgFolder)
+        continue;
+      mailSession->OnItemAdded(rootFolder, msgFolder);
+      notifier->NotifyFolderAdded(msgFolder);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccount::GetIdentities(nsIArray **_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+  NS_ENSURE_TRUE(m_identities, NS_ERROR_FAILURE);
+
+  NS_IF_ADDREF(*_retval = m_identities);
+  return NS_OK;
+}
+
+/*
+ * set up the m_identities array
+ * do not call this more than once or we'll leak.
+ */
+nsresult
+nsMsgAccount::createIdentities()
+{
+  NS_ENSURE_FALSE(m_identities, NS_ERROR_FAILURE);
+
+  nsresult rv;
+  m_identities = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString identityKey;
+  rv = getPrefService();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  m_prefs->GetCharPref("identities", getter_Copies(identityKey));
+  if (identityKey.IsEmpty())    // not an error if no identities, but
+    return NS_OK;               // strtok will be unhappy
+  // get the server from the account manager
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+           do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  char* newStr = identityKey.BeginWriting();
+  char* token = NS_strtok(",", &newStr);
+
+  // temporaries used inside the loop
+  nsCOMPtr<nsIMsgIdentity> identity;
+  nsAutoCString key;
+
+  // iterate through id1,id2, etc
+  while (token) {
+    key = token;
+    key.StripWhitespace();
+
+    // create the account
+    rv = accountManager->GetIdentity(key, getter_AddRefs(identity));
+    if (NS_SUCCEEDED(rv)) {
+      // ignore error from addIdentityInternal() - if it fails, it fails.
+      rv = addIdentityInternal(identity);
+      NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create identity");
+    }
+
+    // advance to next key, if any
+    token = NS_strtok(",", &newStr);
+  }
+
+  return rv;
+}
+
+
+/* attribute nsIMsgIdentity defaultIdentity; */
+NS_IMETHODIMP
+nsMsgAccount::GetDefaultIdentity(nsIMsgIdentity **aDefaultIdentity)
+{
+  NS_ENSURE_ARG_POINTER(aDefaultIdentity);
+  NS_ENSURE_TRUE(m_identities, NS_ERROR_NOT_INITIALIZED);
+
+  *aDefaultIdentity = nullptr;
+  uint32_t count;
+  nsresult rv = m_identities->GetLength(&count);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (count == 0)
+    return NS_OK;
+
+  nsCOMPtr<nsIMsgIdentity> identity = do_QueryElementAt(m_identities, 0, &rv);
+  identity.swap(*aDefaultIdentity);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgAccount::SetDefaultIdentity(nsIMsgIdentity *aDefaultIdentity)
+{
+  NS_ENSURE_TRUE(m_identities, NS_ERROR_FAILURE);
+
+  uint32_t position = 0;
+  nsresult rv = m_identities->IndexOf(0, aDefaultIdentity, &position);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = m_identities->RemoveElementAt(position);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // The passed in identity is in the list, so we have at least one element.
+  rv = m_identities->InsertElementAt(aDefaultIdentity, 0, false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return saveIdentitiesPref();
+}
+
+// add the identity to m_identities, but don't fiddle with the
+// prefs. The assumption here is that the pref for this identity is
+// already set.
+nsresult
+nsMsgAccount::addIdentityInternal(nsIMsgIdentity *identity)
+{
+  NS_ENSURE_TRUE(m_identities, NS_ERROR_FAILURE);
+
+  return m_identities->AppendElement(identity, false);
+}
+
+/* void addIdentity (in nsIMsgIdentity identity); */
+NS_IMETHODIMP
+nsMsgAccount::AddIdentity(nsIMsgIdentity *identity)
+{
+  NS_ENSURE_ARG_POINTER(identity);
+
+  // hack hack - need to add this to the list of identities.
+  // for now just treat this as a Setxxx accessor
+  // when this is actually implemented, don't refcount the default identity
+  nsCString key;
+  nsresult rv = identity->GetKey(key);
+
+  if (NS_SUCCEEDED(rv)) {
+    nsCString identityList;
+    m_prefs->GetCharPref("identities", getter_Copies(identityList));
+
+    nsAutoCString newIdentityList(identityList);
+
+    nsAutoCString testKey;      // temporary to strip whitespace
+    bool foundIdentity = false; // if the input identity is found
+
+    if (!identityList.IsEmpty()) {
+      char *newStr = identityList.BeginWriting();
+      char *token = NS_strtok(",", &newStr);
+
+      // look for the identity key that we're adding
+      while (token) {
+        testKey = token;
+        testKey.StripWhitespace();
+
+        if (testKey.Equals(key))
+          foundIdentity = true;
+
+        token = NS_strtok(",", &newStr);
+      }
+    }
+
+    // if it didn't already exist, append it
+    if (!foundIdentity) {
+      if (newIdentityList.IsEmpty())
+        newIdentityList = key;
+      else {
+        newIdentityList.Append(',');
+        newIdentityList.Append(key);
+      }
+    }
+
+    m_prefs->SetCharPref("identities", newIdentityList.get());
+  }
+
+  // now add it to the in-memory list
+  return addIdentityInternal(identity);
+}
+
+/* void removeIdentity (in nsIMsgIdentity identity); */
+NS_IMETHODIMP
+nsMsgAccount::RemoveIdentity(nsIMsgIdentity *aIdentity)
+{
+  NS_ENSURE_ARG_POINTER(aIdentity);
+  NS_ENSURE_TRUE(m_identities, NS_ERROR_FAILURE);
+
+  uint32_t count = 0;
+  m_identities->GetLength(&count);
+  // At least one identity must stay after the delete.
+  NS_ENSURE_TRUE(count > 1, NS_ERROR_FAILURE);
+
+  uint32_t pos = 0;
+  nsresult rv = m_identities->IndexOf(0, aIdentity, &pos);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // remove our identity
+  m_identities->RemoveElementAt(pos);
+
+  // clear out the actual pref values associated with the identity
+  aIdentity->ClearAllValues();
+
+  return saveIdentitiesPref();
+}
+
+nsresult
+nsMsgAccount::saveIdentitiesPref()
+{
+  nsAutoCString newIdentityList;
+
+  // Iterate over the existing identities and build the pref value,
+  // a string of identity keys: id1, id2, idX...
+  uint32_t count;
+  nsresult rv = m_identities->GetLength(&count);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString key;
+  for (uint32_t index = 0; index < count; index++)
+  {
+    nsCOMPtr<nsIMsgIdentity> identity = do_QueryElementAt(m_identities, index, &rv);
+    if (identity)
+    {
+      identity->GetKey(key);
+
+      if (!index) {
+        newIdentityList = key;
+      }
+      else
+      {
+        newIdentityList.Append(',');
+        newIdentityList.Append(key);
+      }
+    }
+  }
+
+  // Save the pref.
+  m_prefs->SetCharPref("identities", newIdentityList.get());
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccount::GetKey(nsACString& accountKey)
+{
+  accountKey = m_accountKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccount::SetKey(const nsACString& accountKey)
+{
+  m_accountKey = accountKey;
+  m_prefs = nullptr;
+  m_identities = nullptr;
+  return createIdentities();
+}
+
+NS_IMETHODIMP
+nsMsgAccount::ToString(nsAString& aResult)
+{
+  nsAutoString val;
+  aResult.AssignLiteral("[nsIMsgAccount: ");
+  aResult.Append(NS_ConvertASCIItoUTF16(m_accountKey));
+  aResult.AppendLiteral("]");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccount::ClearAllValues()
+{
+  nsresult rv = getPrefService();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return m_prefs->DeleteBranch("");
+}
diff --git a/mailnews/base/src/nsMsgAccount.h b/mailnews/base/src/nsMsgAccount.h
new file mode 100644
index 000000000..5a12dab1a
--- /dev/null
+++ b/mailnews/base/src/nsMsgAccount.h
@@ -0,0 +1,38 @@
+/* -*- 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 "nscore.h"
+#include "nsIMsgAccount.h"
+#include "nsIPrefBranch.h"
+#include "nsStringGlue.h"
+#include "nsIMutableArray.h"
+
+class nsMsgAccount : public nsIMsgAccount
+{
+
+public:
+  nsMsgAccount();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGACCOUNT
+
+private:
+  virtual ~nsMsgAccount();
+  nsCString m_accountKey;
+  nsCOMPtr<nsIPrefBranch> m_prefs;
+  nsCOMPtr<nsIMsgIncomingServer> m_incomingServer;
+
+  nsCOMPtr<nsIMutableArray> m_identities;
+
+  nsresult getPrefService();
+  nsresult createIncomingServer();
+  nsresult createIdentities();
+  nsresult saveIdentitiesPref();
+  nsresult addIdentityInternal(nsIMsgIdentity* identity);
+
+  // Have we tried to get the server yet?
+  bool mTriedToGetServer;
+};
+
diff --git a/mailnews/base/src/nsMsgAccountManager.cpp b/mailnews/base/src/nsMsgAccountManager.cpp
new file mode 100644
index 000000000..5dd3893b6
--- /dev/null
+++ b/mailnews/base/src/nsMsgAccountManager.cpp
@@ -0,0 +1,3708 @@
+/* -*- 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/. */
+
+/*
+ * The account manager service - manages all accounts, servers, and identities
+ */
+
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+// Disable deprecation warnings generated by nsISupportsArray and associated
+// classes.
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(_MSC_VER)
+#pragma warning (disable : 4996)
+#endif
+#include "nsISupportsArray.h"
+#include "nsIArray.h"
+#include "nsArrayUtils.h"
+#include "nsMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgCompCID.h"
+#include "nsMsgDBCID.h"
+#include "prmem.h"
+#include "prcmon.h"
+#include "prthread.h"
+#include "plstr.h"
+#include "nsStringGlue.h"
+#include "nsUnicharUtils.h"
+#include "nscore.h"
+#include "prprf.h"
+#include "nsIMsgFolderCache.h"
+#include "nsMsgUtils.h"
+#include "nsIFile.h"
+#include "nsIURL.h"
+#include "nsNetCID.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsISmtpService.h"
+#include "nsIMsgBiffManager.h"
+#include "nsIMsgPurgeService.h"
+#include "nsIObserverService.h"
+#include "nsINoIncomingServer.h"
+#include "nsIMsgMailSession.h"
+#include "nsIDirectoryService.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsMailDirServiceDefs.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsIImapIncomingServer.h"
+#include "nsIImapUrl.h"
+#include "nsIMessengerOSIntegration.h"
+#include "nsICategoryManager.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIMsgFilterService.h"
+#include "nsIMsgFilter.h"
+#include "nsIMsgSearchSession.h"
+#include "nsIMsgSearchTerm.h"
+#include "nsIMutableArray.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIMsgHdr.h"
+#include "nsILineInputStream.h"
+#include "nsThreadUtils.h"
+#include "nsNetUtil.h"
+#include "nsIStringBundle.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMsgFilterList.h"
+#include "nsDirectoryServiceUtils.h"
+#include "mozilla/Services.h"
+#include <algorithm>
+#include "nsIFileStreams.h"
+#include "nsIOutputStream.h"
+#include "nsISafeOutputStream.h"
+
+#define PREF_MAIL_ACCOUNTMANAGER_ACCOUNTS "mail.accountmanager.accounts"
+#define PREF_MAIL_ACCOUNTMANAGER_DEFAULTACCOUNT "mail.accountmanager.defaultaccount"
+#define PREF_MAIL_ACCOUNTMANAGER_LOCALFOLDERSSERVER "mail.accountmanager.localfoldersserver"
+#define PREF_MAIL_SERVER_PREFIX "mail.server."
+#define ACCOUNT_PREFIX "account"
+#define SERVER_PREFIX "server"
+#define ID_PREFIX "id"
+#define ABOUT_TO_GO_OFFLINE_TOPIC "network:offline-about-to-go-offline"
+#define ACCOUNT_DELIMITER ','
+#define APPEND_ACCOUNTS_VERSION_PREF_NAME "append_preconfig_accounts.version"
+#define MAILNEWS_ROOT_PREF "mailnews."
+#define PREF_MAIL_ACCOUNTMANAGER_APPEND_ACCOUNTS "mail.accountmanager.appendaccounts"
+
+static NS_DEFINE_CID(kMsgAccountCID, NS_MSGACCOUNT_CID);
+static NS_DEFINE_CID(kMsgFolderCacheCID, NS_MSGFOLDERCACHE_CID);
+
+#define SEARCH_FOLDER_FLAG "searchFolderFlag"
+#define SEARCH_FOLDER_FLAG_LEN (sizeof(SEARCH_FOLDER_FLAG) - 1)
+
+const char *kSearchFolderUriProp = "searchFolderUri";
+
+bool nsMsgAccountManager::m_haveShutdown = false;
+bool nsMsgAccountManager::m_shutdownInProgress = false;
+
+NS_IMPL_ISUPPORTS(nsMsgAccountManager,
+                              nsIMsgAccountManager,
+                              nsIObserver,
+                              nsISupportsWeakReference,
+                              nsIUrlListener,
+                              nsIFolderListener)
+
+nsMsgAccountManager::nsMsgAccountManager() :
+  m_accountsLoaded(false),
+  m_emptyTrashInProgress(false),
+  m_cleanupInboxInProgress(false),
+  m_userAuthenticated(false),
+  m_loadingVirtualFolders(false),
+  m_virtualFoldersLoaded(false)
+{
+}
+
+nsMsgAccountManager::~nsMsgAccountManager()
+{
+  if(!m_haveShutdown)
+  {
+    Shutdown();
+    //Don't remove from Observer service in Shutdown because Shutdown also gets called
+    //from xpcom shutdown observer.  And we don't want to remove from the service in that case.
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+    if (observerService)
+    {
+      observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+      observerService->RemoveObserver(this, "quit-application-granted");
+      observerService->RemoveObserver(this, ABOUT_TO_GO_OFFLINE_TOPIC);
+      observerService->RemoveObserver(this, "sleep_notification");
+    }
+  }
+}
+
+nsresult nsMsgAccountManager::Init()
+{
+  nsresult rv;
+
+  m_prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIObserverService> observerService =
+           mozilla::services::GetObserverService();
+  if (observerService)
+  {
+    observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
+    observerService->AddObserver(this, "quit-application-granted" , true);
+    observerService->AddObserver(this, ABOUT_TO_GO_OFFLINE_TOPIC, true);
+    observerService->AddObserver(this, "profile-before-change", true);
+    observerService->AddObserver(this, "sleep_notification", true);
+  }
+
+  // Make sure PSM gets initialized before any accounts use certificates.
+  net_EnsurePSMInit();
+
+  return NS_OK;
+}
+
+nsresult nsMsgAccountManager::Shutdown()
+{
+  if (m_haveShutdown)     // do not shutdown twice
+    return NS_OK;
+
+  nsresult rv;
+
+  SaveVirtualFolders();
+
+  nsCOMPtr<nsIMsgDBService> msgDBService = do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+  if (msgDBService)
+  {
+    nsTObserverArray<RefPtr<VirtualFolderChangeListener> >::ForwardIterator iter(m_virtualFolderListeners);
+    RefPtr<VirtualFolderChangeListener> listener;
+
+    while (iter.HasMore())
+    {
+      listener = iter.GetNext();
+      msgDBService->UnregisterPendingListener(listener);
+    }
+  }
+  if(m_msgFolderCache)
+    WriteToFolderCache(m_msgFolderCache);
+  (void)ShutdownServers();
+  (void)UnloadAccounts();
+
+  //shutdown removes nsIIncomingServer listener from biff manager, so do it after accounts have been unloaded
+  nsCOMPtr<nsIMsgBiffManager> biffService = do_GetService(NS_MSGBIFFMANAGER_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv) && biffService)
+    biffService->Shutdown();
+
+  //shutdown removes nsIIncomingServer listener from purge service, so do it after accounts have been unloaded
+  nsCOMPtr<nsIMsgPurgeService> purgeService = do_GetService(NS_MSGPURGESERVICE_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv) && purgeService)
+    purgeService->Shutdown();
+
+  m_msgFolderCache = nullptr;
+  m_haveShutdown = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetShutdownInProgress(bool *_retval)
+{
+    NS_ENSURE_ARG_POINTER(_retval);
+    *_retval = m_shutdownInProgress;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetUserNeedsToAuthenticate(bool *aRetval)
+{
+  NS_ENSURE_ARG_POINTER(aRetval);
+  if (!m_userAuthenticated)
+    return m_prefs->GetBoolPref("mail.password_protect_local_cache", aRetval);
+  *aRetval = !m_userAuthenticated;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::SetUserNeedsToAuthenticate(bool aUserNeedsToAuthenticate)
+{
+  m_userAuthenticated = !aUserNeedsToAuthenticate;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *someData)
+{
+  if(!strcmp(aTopic,NS_XPCOM_SHUTDOWN_OBSERVER_ID))
+  {
+    Shutdown();
+    return NS_OK;
+  }
+  if (!strcmp(aTopic, "quit-application-granted"))
+  {
+    // CleanupOnExit will set m_shutdownInProgress to true.
+    CleanupOnExit();
+    return NS_OK;
+  }
+  if (!strcmp(aTopic, ABOUT_TO_GO_OFFLINE_TOPIC))
+  {
+    nsAutoString dataString(NS_LITERAL_STRING("offline"));
+    if (someData)
+    {
+      nsAutoString someDataString(someData);
+      if (dataString.Equals(someDataString))
+        CloseCachedConnections();
+    }
+    return NS_OK;
+  }
+  if (!strcmp(aTopic, "sleep_notification"))
+    return CloseCachedConnections();
+
+  if (!strcmp(aTopic, "profile-before-change"))
+  {
+    Shutdown();
+    return NS_OK;
+  }
+
+ return NS_OK;
+}
+
+void
+nsMsgAccountManager::getUniqueAccountKey(nsCString& aResult)
+{
+  int32_t lastKey = 0;
+  nsresult rv;
+  nsCOMPtr<nsIPrefService> prefservice(do_GetService(NS_PREFSERVICE_CONTRACTID,
+                                       &rv));
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsIPrefBranch> prefBranch;
+    prefservice->GetBranch("", getter_AddRefs(prefBranch));
+
+    rv = prefBranch->GetIntPref("mail.account.lastKey", &lastKey);
+    if (NS_FAILED(rv) || lastKey == 0) {
+      // If lastKey pref does not contain a valid value, loop over existing
+      // pref names mail.account.* .
+      nsCOMPtr<nsIPrefBranch> prefBranchAccount;
+      rv = prefservice->GetBranch("mail.account.", getter_AddRefs(prefBranchAccount));
+      if (NS_SUCCEEDED(rv)) {
+        uint32_t prefCount;
+        char **prefList;
+        rv = prefBranchAccount->GetChildList("", &prefCount, &prefList);
+        if (NS_SUCCEEDED(rv)) {
+          // Pref names are of the format accountX.
+          // Find the maximum value of 'X' used so far.
+          for (uint32_t i = 0; i < prefCount; i++) {
+            nsCString prefName;
+            prefName.Assign(prefList[i]);
+            if (StringBeginsWith(prefName, NS_LITERAL_CSTRING(ACCOUNT_PREFIX))) {
+              int32_t dotPos = prefName.FindChar('.');
+              if (dotPos != kNotFound) {
+                nsCString keyString(Substring(prefName, strlen(ACCOUNT_PREFIX),
+                                              dotPos - strlen(ACCOUNT_PREFIX)));
+                int32_t thisKey = keyString.ToInteger(&rv);
+                if (NS_SUCCEEDED(rv))
+                  lastKey = std::max(lastKey, thisKey);
+              }
+            }
+          }
+          NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList);
+        }
+      }
+    }
+
+    // Use next available key and store the value in the pref.
+    aResult.Assign(ACCOUNT_PREFIX);
+    aResult.AppendInt(++lastKey);
+    rv = prefBranch->SetIntPref("mail.account.lastKey", lastKey);
+  } else {
+    // If pref service is not working, try to find a free accountX key
+    // by checking which keys exist.
+    int32_t i = 1;
+    nsCOMPtr<nsIMsgAccount> account;
+
+    do {
+      aResult = ACCOUNT_PREFIX;
+      aResult.AppendInt(i++);
+      GetAccount(aResult, getter_AddRefs(account));
+    } while (account);
+  }
+}
+
+void
+nsMsgAccountManager::GetUniqueServerKey(nsACString& aResult)
+{
+  nsAutoCString prefResult;
+  bool usePrefsScan = true;
+  nsresult rv;
+  nsCOMPtr<nsIPrefService> prefService(do_GetService(NS_PREFSERVICE_CONTRACTID,
+                                       &rv));
+  if (NS_FAILED(rv))
+    usePrefsScan = false;
+
+  // Loop over existing pref names mail.server.server(lastKey).type
+  nsCOMPtr<nsIPrefBranch> prefBranchServer;
+  if (prefService)
+  {
+    rv = prefService->GetBranch(PREF_MAIL_SERVER_PREFIX, getter_AddRefs(prefBranchServer));
+    if (NS_FAILED(rv))
+      usePrefsScan = false;
+  }
+
+  if (usePrefsScan)
+  {
+    nsAutoCString type;
+    nsAutoCString typeKey;
+    for (uint32_t lastKey = 1; ; lastKey++)
+    {
+      aResult.AssignLiteral(SERVER_PREFIX);
+      aResult.AppendInt(lastKey);
+      typeKey.Assign(aResult);
+      typeKey.AppendLiteral(".type");
+      prefBranchServer->GetCharPref(typeKey.get(), getter_Copies(type));
+      if (type.IsEmpty()) // a server slot with no type is considered empty
+        return;
+    }
+  }
+  else
+  {
+    // If pref service fails, try to find a free serverX key
+    // by checking which keys exist.
+    nsAutoCString internalResult;
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    uint32_t i = 1;
+    do {
+      aResult.AssignLiteral(SERVER_PREFIX);
+      aResult.AppendInt(i++);
+      m_incomingServers.Get(aResult, getter_AddRefs(server));
+    } while (server);
+    return;
+  }
+}
+
+nsresult
+nsMsgAccountManager::CreateIdentity(nsIMsgIdentity **_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+  nsresult rv;
+  nsAutoCString key;
+  nsCOMPtr<nsIMsgIdentity> identity;
+  int32_t i = 1;
+  do {
+    key.AssignLiteral(ID_PREFIX);
+    key.AppendInt(i++);
+    m_identities.Get(key, getter_AddRefs(identity));
+  } while (identity);
+
+  rv = createKeyedIdentity(key, _retval);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetIdentity(const nsACString& key, nsIMsgIdentity **_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+  nsresult rv = NS_OK;
+  *_retval = nullptr;
+
+  if (!key.IsEmpty())
+  {
+    nsCOMPtr<nsIMsgIdentity> identity;
+    m_identities.Get(key, getter_AddRefs(identity));
+    if (identity)
+      identity.swap(*_retval);
+    else // identity doesn't exist. create it.
+      rv = createKeyedIdentity(key, _retval);
+  }
+
+  return rv;
+}
+
+/*
+ * the shared identity-creation code
+ * create an identity and add it to the accountmanager's list.
+ */
+nsresult
+nsMsgAccountManager::createKeyedIdentity(const nsACString& key,
+                                         nsIMsgIdentity ** aIdentity)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgIdentity> identity =
+      do_CreateInstance(NS_MSGIDENTITY_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  identity->SetKey(key);
+  m_identities.Put(key, identity);
+  identity.swap(*aIdentity);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::CreateIncomingServer(const nsACString&  username,
+                                          const nsACString& hostname,
+                                          const nsACString& type,
+                                          nsIMsgIncomingServer **_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  nsresult rv = LoadAccounts();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString key;
+  GetUniqueServerKey(key);
+  rv = createKeyedServer(key, username, hostname, type, _retval);
+  if (*_retval)
+  {
+    nsCString defaultStore;
+    m_prefs->GetCharPref("mail.serverDefaultStoreContractID", getter_Copies(defaultStore));
+    (*_retval)->SetCharValue("storeContractID", defaultStore);
+
+    // From when we first create the account until we have created some folders,
+    // we can change the store type.
+    (*_retval)->SetBoolValue("canChangeStoreType", true);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetIncomingServer(const nsACString& key,
+                                       nsIMsgIncomingServer **_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+  nsresult rv;
+
+  if (m_incomingServers.Get(key, _retval))
+    return NS_OK;
+
+  // server doesn't exist, so create it
+  // this is really horrible because we are doing our own prefname munging
+  // instead of leaving it up to the incoming server.
+  // this should be fixed somehow so that we can create the incoming server
+  // and then read from the incoming server's attributes
+
+  // in order to create the right kind of server, we have to look
+  // at the pref for this server to get the username, hostname, and type
+  nsAutoCString serverPrefPrefix(PREF_MAIL_SERVER_PREFIX);
+  serverPrefPrefix.Append(key);
+
+  nsCString serverType;
+  nsAutoCString serverPref (serverPrefPrefix);
+  serverPref.AppendLiteral(".type");
+  rv = m_prefs->GetCharPref(serverPref.get(), getter_Copies(serverType));
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_NOT_INITIALIZED);
+
+  //
+  // .userName
+  serverPref = serverPrefPrefix;
+  serverPref.AppendLiteral(".userName");
+  nsCString username;
+  rv = m_prefs->GetCharPref(serverPref.get(), getter_Copies(username));
+
+  // .hostname
+  serverPref = serverPrefPrefix;
+  serverPref.AppendLiteral(".hostname");
+  nsCString hostname;
+  rv = m_prefs->GetCharPref(serverPref.get(), getter_Copies(hostname));
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_NOT_INITIALIZED);
+
+  return createKeyedServer(key, username, hostname, serverType, _retval);
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::RemoveIncomingServer(nsIMsgIncomingServer *aServer,
+                                          bool aRemoveFiles)
+{
+  NS_ENSURE_ARG_POINTER(aServer);
+
+  nsCString serverKey;
+  nsresult rv = aServer->GetKey(serverKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  LogoutOfServer(aServer); // close cached connections and forget session password
+
+  // invalidate the FindServer() cache if we are removing the cached server
+  if (m_lastFindServerResult == aServer)
+    SetLastServerFound(nullptr, EmptyCString(), EmptyCString(), 0, EmptyCString());
+
+  m_incomingServers.Remove(serverKey);
+
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  nsCOMPtr<nsIArray> allDescendants;
+
+  rv = aServer->GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = rootFolder->GetDescendants(getter_AddRefs(allDescendants));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t cnt = 0;
+  rv = allDescendants->GetLength(&cnt);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolderNotificationService> notifier =
+           do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID);
+  nsCOMPtr<nsIFolderListener> mailSession =
+           do_GetService(NS_MSGMAILSESSION_CONTRACTID);
+
+  for (uint32_t i = 0; i < cnt; i++)
+  {
+    nsCOMPtr<nsIMsgFolder> folder = do_QueryElementAt(allDescendants, i);
+    if (folder)
+    {
+      folder->ForceDBClosed();
+      if (notifier)
+        notifier->NotifyFolderDeleted(folder);
+      if (mailSession)
+      {
+        nsCOMPtr<nsIMsgFolder> parentFolder;
+        folder->GetParent(getter_AddRefs(parentFolder));
+        mailSession->OnItemRemoved(parentFolder, folder);
+      }
+    }
+  }
+  if (notifier)
+    notifier->NotifyFolderDeleted(rootFolder);
+  if (mailSession)
+    mailSession->OnItemRemoved(nullptr, rootFolder);
+
+  removeListenersFromFolder(rootFolder);
+  NotifyServerUnloaded(aServer);
+  if (aRemoveFiles)
+  {
+    rv = aServer->RemoveFiles();
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // now clear out the server once and for all.
+  // watch out! could be scary
+  aServer->ClearAllValues();
+  rootFolder->Shutdown(true);
+  return rv;
+}
+
+/*
+ * create a server when you know the key and the type
+ */
+nsresult
+nsMsgAccountManager::createKeyedServer(const nsACString& key,
+                                       const nsACString& username,
+                                       const nsACString& hostname,
+                                       const nsACString& type,
+                                       nsIMsgIncomingServer ** aServer)
+{
+  nsresult rv;
+  *aServer = nullptr;
+
+  //construct the contractid
+  nsAutoCString serverContractID(NS_MSGINCOMINGSERVER_CONTRACTID_PREFIX);
+  serverContractID += type;
+
+  // finally, create the server
+  // (This will fail if type is from an extension that has been removed)
+  nsCOMPtr<nsIMsgIncomingServer> server =
+           do_CreateInstance(serverContractID.get(), &rv);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_NOT_AVAILABLE);
+
+  int32_t port;
+  nsCOMPtr <nsIMsgIncomingServer> existingServer;
+  server->SetKey(key);
+  server->SetType(type);
+  server->SetUsername(username);
+  server->SetHostName(hostname);
+  server->GetPort(&port);
+  FindRealServer(username, hostname, type, port, getter_AddRefs(existingServer));
+  // don't allow duplicate servers.
+  if (existingServer)
+    return NS_ERROR_FAILURE;
+
+  m_incomingServers.Put(key, server);
+
+  // now add all listeners that are supposed to be
+  // waiting on root folders
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  rv = server->GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTObserverArray<nsCOMPtr<nsIFolderListener> >::ForwardIterator iter(mFolderListeners);
+  while (iter.HasMore())
+  {
+    rootFolder->AddFolderListener(iter.GetNext());
+  }
+
+  server.swap(*aServer);
+  return NS_OK;
+}
+
+void
+nsMsgAccountManager::removeListenersFromFolder(nsIMsgFolder *aFolder)
+{
+  nsTObserverArray<nsCOMPtr<nsIFolderListener> >::ForwardIterator iter(mFolderListeners);
+  while (iter.HasMore())
+  {
+    aFolder->RemoveFolderListener(iter.GetNext());
+  }
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::RemoveAccount(nsIMsgAccount *aAccount,
+                                   bool aRemoveFiles = false)
+{
+  NS_ENSURE_ARG_POINTER(aAccount);
+  nsresult rv = LoadAccounts();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool accountRemoved = m_accounts.RemoveElement(aAccount);
+
+  rv  = OutputAccountsPref();
+  // If we couldn't write out the pref, restore the account.
+  if (NS_FAILED(rv) && accountRemoved)
+  {
+    m_accounts.AppendElement(aAccount);
+    return rv;
+  }
+
+  // if it's the default, clear the default account
+  if (m_defaultAccount.get() == aAccount)
+    SetDefaultAccount(nullptr);
+
+  // XXX - need to figure out if this is the last time this server is
+  // being used, and only send notification then.
+  // (and only remove from hashtable then too!)
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = aAccount->GetIncomingServer(getter_AddRefs(server));
+  if (NS_SUCCEEDED(rv) && server)
+    RemoveIncomingServer(server, aRemoveFiles);
+
+  nsCOMPtr<nsIArray> identityArray;
+  rv = aAccount->GetIdentities(getter_AddRefs(identityArray));
+  if (NS_SUCCEEDED(rv)) {
+    uint32_t count = 0;
+    identityArray->GetLength(&count);
+    uint32_t i;
+    for (i = 0; i < count; i++)
+    {
+      nsCOMPtr<nsIMsgIdentity> identity( do_QueryElementAt(identityArray, i, &rv));
+      bool identityStillUsed = false;
+      // for each identity, see if any existing account still uses it,
+      // and if not, clear it.
+      // Note that we are also searching here accounts with missing servers from
+      //  unloaded extension types.
+      if (NS_SUCCEEDED(rv))
+      {
+        uint32_t index;
+        for (index = 0; index < m_accounts.Length() && !identityStillUsed; index++)
+        {
+          nsCOMPtr<nsIArray> existingIdentitiesArray;
+
+          rv = m_accounts[index]->GetIdentities(getter_AddRefs(existingIdentitiesArray));
+          uint32_t pos;
+          if (NS_SUCCEEDED(existingIdentitiesArray->IndexOf(0, identity, &pos)))
+          {
+            identityStillUsed = true;
+            break;
+          }
+        }
+      }
+      // clear out all identity information if no other account uses it.
+      if (!identityStillUsed)
+        identity->ClearAllValues();
+    }
+  }
+
+  // It is not a critical problem if this fails as the account was already
+  // removed from the list of accounts so should not ever be referenced.
+  // Just print it out for debugging.
+  rv = aAccount->ClearAllValues();
+  NS_ASSERTION(NS_SUCCEEDED(rv), "removing of account prefs failed");
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManager::OutputAccountsPref()
+{
+  nsCString accountKey;
+  mAccountKeyList.Truncate();
+
+  for (uint32_t index = 0; index < m_accounts.Length(); index++)
+  {
+    m_accounts[index]->GetKey(accountKey);
+    if (index)
+      mAccountKeyList.Append(ACCOUNT_DELIMITER);
+    mAccountKeyList.Append(accountKey);
+  }
+  return m_prefs->SetCharPref(PREF_MAIL_ACCOUNTMANAGER_ACCOUNTS,
+                                mAccountKeyList.get());
+}
+
+/* get the default account. If no default account, pick the first account */
+NS_IMETHODIMP
+nsMsgAccountManager::GetDefaultAccount(nsIMsgAccount **aDefaultAccount)
+{
+  NS_ENSURE_ARG_POINTER(aDefaultAccount);
+
+  nsresult rv = LoadAccounts();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!m_defaultAccount) {
+    uint32_t count = m_accounts.Length();
+    if (!count) {
+      *aDefaultAccount = nullptr;
+      return NS_ERROR_FAILURE;
+    }
+
+    nsCString defaultKey;
+    rv = m_prefs->GetCharPref(PREF_MAIL_ACCOUNTMANAGER_DEFAULTACCOUNT, getter_Copies(defaultKey));
+
+    if (NS_SUCCEEDED(rv))
+      rv = GetAccount(defaultKey, getter_AddRefs(m_defaultAccount));
+
+    if (NS_FAILED(rv) || !m_defaultAccount) {
+      nsCOMPtr<nsIMsgAccount> firstAccount;
+      uint32_t index;
+      bool foundValidDefaultAccount = false;
+      for (index = 0; index < count; index++) {
+        nsCOMPtr<nsIMsgAccount> account(m_accounts[index]);
+
+        // get incoming server
+        nsCOMPtr <nsIMsgIncomingServer> server;
+        // server could be null if created by an unloaded extension
+        (void) account->GetIncomingServer(getter_AddRefs(server));
+
+        bool canBeDefaultServer = false;
+        if (server)
+        {
+          server->GetCanBeDefaultServer(&canBeDefaultServer);
+          if (!firstAccount)
+            firstAccount = account;
+        }
+
+        // if this can serve as default server, set it as default and
+        // break out of the loop.
+        if (canBeDefaultServer) {
+          SetDefaultAccount(account);
+          foundValidDefaultAccount = true;
+          break;
+        }
+      }
+
+      if (!foundValidDefaultAccount) {
+        // Get the first account and use it.
+        // We need to fix this scenario, e.g. in bug 342632.
+        NS_WARNING("No valid default account found.");
+        if (firstAccount) {
+          NS_WARNING("Just using the first one (FIXME).");
+          SetDefaultAccount(firstAccount);
+        }
+      }
+    }
+  }
+
+  if (!m_defaultAccount) {
+    // Absolutely no usable account found. Error out.
+    NS_ERROR("Default account is null, when not expected!");
+    *aDefaultAccount = nullptr;
+    return NS_ERROR_FAILURE;
+  }
+  NS_ADDREF(*aDefaultAccount = m_defaultAccount);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::SetDefaultAccount(nsIMsgAccount *aDefaultAccount)
+{
+  if (m_defaultAccount != aDefaultAccount)
+  {
+    nsCOMPtr<nsIMsgAccount> oldAccount = m_defaultAccount;
+    m_defaultAccount = aDefaultAccount;
+    (void) setDefaultAccountPref(aDefaultAccount);
+    (void) notifyDefaultServerChange(oldAccount, aDefaultAccount);
+  }
+  return NS_OK;
+}
+
+// fire notifications
+nsresult
+nsMsgAccountManager::notifyDefaultServerChange(nsIMsgAccount *aOldAccount,
+                                               nsIMsgAccount *aNewAccount)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+
+  // first tell old server it's no longer the default
+  if (aOldAccount) {
+    rv = aOldAccount->GetIncomingServer(getter_AddRefs(server));
+    if (NS_SUCCEEDED(rv) && server) {
+      rv = server->GetRootFolder(getter_AddRefs(rootFolder));
+      if (NS_SUCCEEDED(rv) && rootFolder)
+        rootFolder->NotifyBoolPropertyChanged(kDefaultServerAtom,
+                                              true, false);
+    }
+  }
+
+    // now tell new server it is.
+  if (aNewAccount) {
+    rv = aNewAccount->GetIncomingServer(getter_AddRefs(server));
+    if (NS_SUCCEEDED(rv) && server) {
+      rv = server->GetRootFolder(getter_AddRefs(rootFolder));
+      if (NS_SUCCEEDED(rv) && rootFolder)
+        rootFolder->NotifyBoolPropertyChanged(kDefaultServerAtom,
+                                              false, true);
+    }
+  }
+
+  if (aOldAccount && aNewAccount)  //only notify if the user goes and changes default account
+  {
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+
+    if (observerService)
+      observerService->NotifyObservers(nullptr,"mailDefaultAccountChanged",nullptr);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManager::setDefaultAccountPref(nsIMsgAccount* aDefaultAccount)
+{
+  nsresult rv;
+
+  if (aDefaultAccount) {
+    nsCString key;
+    rv = aDefaultAccount->GetKey(key);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = m_prefs->SetCharPref(PREF_MAIL_ACCOUNTMANAGER_DEFAULTACCOUNT, key.get());
+    NS_ENSURE_SUCCESS(rv,rv);
+  }
+  else
+    m_prefs->ClearUserPref(PREF_MAIL_ACCOUNTMANAGER_DEFAULTACCOUNT);
+
+  return NS_OK;
+}
+
+void nsMsgAccountManager::LogoutOfServer(nsIMsgIncomingServer *aServer)
+{
+  if (!aServer)
+    return;
+  mozilla::DebugOnly<nsresult> rv = aServer->Shutdown();
+  NS_ASSERTION(NS_SUCCEEDED(rv), "Shutdown of server failed");
+  rv = aServer->ForgetSessionPassword();
+  NS_ASSERTION(NS_SUCCEEDED(rv), "failed to remove the password associated with server");
+}
+
+NS_IMETHODIMP nsMsgAccountManager::GetFolderCache(nsIMsgFolderCache* *aFolderCache)
+{
+  NS_ENSURE_ARG_POINTER(aFolderCache);
+  nsresult rv = NS_OK;
+
+  if (!m_msgFolderCache)
+  {
+    m_msgFolderCache = do_CreateInstance(kMsgFolderCacheCID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIFile> cacheFile;
+    rv = NS_GetSpecialDirectory(NS_APP_MESSENGER_FOLDER_CACHE_50_FILE,
+                                getter_AddRefs(cacheFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_msgFolderCache->Init(cacheFile);
+  }
+
+  NS_IF_ADDREF(*aFolderCache = m_msgFolderCache);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetAccounts(nsIArray **_retval)
+{
+  nsresult rv = LoadAccounts();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMutableArray> accounts(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (uint32_t index = 0; index < m_accounts.Length(); index++)
+  {
+    nsCOMPtr<nsIMsgAccount> existingAccount(m_accounts[index]);
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    existingAccount->GetIncomingServer(getter_AddRefs(server));
+    if (!server)
+      continue;
+    if (server)
+    {
+      bool hidden = false;
+      server->GetHidden(&hidden);
+      if (hidden)
+        continue;
+    }
+    accounts->AppendElement(existingAccount, false);
+  }
+  NS_IF_ADDREF(*_retval = accounts);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetAllIdentities(nsIArray **_retval)
+{
+  nsresult rv = LoadAccounts();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMutableArray> result(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIArray> identities;
+
+  for (uint32_t i = 0; i < m_accounts.Length(); ++i) {
+    rv = m_accounts[i]->GetIdentities(getter_AddRefs(identities));
+    if (NS_FAILED(rv))
+      continue;
+
+    uint32_t idCount;
+    rv = identities->GetLength(&idCount);
+    if (NS_FAILED(rv))
+      continue;
+
+    for (uint32_t j = 0; j < idCount; ++j) {
+      nsCOMPtr<nsIMsgIdentity> identity(do_QueryElementAt(identities, j, &rv));
+      if (NS_FAILED(rv))
+        continue;
+
+      nsAutoCString key;
+      rv = identity->GetKey(key);
+      if (NS_FAILED(rv))
+        continue;
+
+      uint32_t resultCount;
+      rv = result->GetLength(&resultCount);
+      if (NS_FAILED(rv))
+        continue;
+
+      bool found = false;
+      for (uint32_t k = 0; k < resultCount && !found; ++k) {
+        nsCOMPtr<nsIMsgIdentity> thisIdentity(do_QueryElementAt(result, k, &rv));
+        if (NS_FAILED(rv))
+          continue;
+
+        nsAutoCString thisKey;
+        rv = thisIdentity->GetKey(thisKey);
+        if (NS_FAILED(rv))
+          continue;
+
+        if (key == thisKey)
+          found = true;
+      }
+
+      if (!found)
+        result->AppendElement(identity, false);
+    }
+  }
+  result.forget(_retval);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetAllServers(nsIArray **_retval)
+{
+  nsresult rv = LoadAccounts();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMutableArray> servers(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();
+    if (!server)
+      continue;
+
+    bool hidden = false;
+    server->GetHidden(&hidden);
+    if (hidden)
+      continue;
+
+    nsCString type;
+    if (NS_FAILED(server->GetType(type))) {
+      NS_WARNING("server->GetType() failed");
+      continue;
+    }
+
+    if (!type.EqualsLiteral("im")) {
+      servers->AppendElement(server, false);
+    }
+  }
+
+  servers.forget(_retval);
+  return rv;
+}
+
+nsresult
+nsMsgAccountManager::LoadAccounts()
+{
+  nsresult rv;
+
+  // for now safeguard multiple calls to this function
+  if (m_accountsLoaded)
+    return NS_OK;
+
+  nsCOMPtr<nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+
+  if (NS_SUCCEEDED(rv))
+    mailSession->AddFolderListener(this, nsIFolderListener::added |
+                                         nsIFolderListener::removed |
+                                         nsIFolderListener::intPropertyChanged);
+  // If we have code trying to do things after we've unloaded accounts,
+  // ignore it.
+  if (m_shutdownInProgress || m_haveShutdown)
+    return NS_ERROR_FAILURE;
+
+  kDefaultServerAtom = MsgGetAtom("DefaultServer");
+  mFolderFlagAtom = MsgGetAtom("FolderFlag");
+
+  //Ensure biff service has started
+  nsCOMPtr<nsIMsgBiffManager> biffService =
+           do_GetService(NS_MSGBIFFMANAGER_CONTRACTID, &rv);
+
+  if (NS_SUCCEEDED(rv))
+    biffService->Init();
+
+  //Ensure purge service has started
+  nsCOMPtr<nsIMsgPurgeService> purgeService =
+           do_GetService(NS_MSGPURGESERVICE_CONTRACTID, &rv);
+
+  if (NS_SUCCEEDED(rv))
+    purgeService->Init();
+
+  nsCOMPtr<nsIPrefService> prefservice(do_GetService(NS_PREFSERVICE_CONTRACTID,
+                                       &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Ensure messenger OS integration service has started
+  // note, you can't expect the integrationService to be there
+  // we don't have OS integration on all platforms.
+  nsCOMPtr<nsIMessengerOSIntegration> integrationService =
+           do_GetService(NS_MESSENGEROSINTEGRATION_CONTRACTID, &rv);
+
+  // mail.accountmanager.accounts is the main entry point for all accounts
+  nsCString accountList;
+  rv = m_prefs->GetCharPref(PREF_MAIL_ACCOUNTMANAGER_ACCOUNTS, getter_Copies(accountList));
+
+  /**
+   * Check to see if we need to add pre-configured accounts.
+   * Following prefs are important to note in understanding the procedure here.
+   *
+   * 1. pref("mailnews.append_preconfig_accounts.version", version number);
+   * This pref registers the current version in the user prefs file. A default value
+   * is stored in mailnews.js file. If a given vendor needs to add more preconfigured
+   * accounts, the default version number can be increased. Comparing version
+   * number from user's prefs file and the default one from mailnews.js, we
+   * can add new accounts and any other version level changes that need to be done.
+   *
+   * 2. pref("mail.accountmanager.appendaccounts", <comma separated account list>);
+   * This pref contains the list of pre-configured accounts that ISP/Vendor wants to
+   * to add to the existing accounts list.
+   */
+  nsCOMPtr<nsIPrefBranch> defaultsPrefBranch;
+  rv = prefservice->GetDefaultBranch(MAILNEWS_ROOT_PREF, getter_AddRefs(defaultsPrefBranch));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch;
+  rv = prefservice->GetBranch(MAILNEWS_ROOT_PREF, getter_AddRefs(prefBranch));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t appendAccountsCurrentVersion=0;
+  int32_t appendAccountsDefaultVersion=0;
+  rv = prefBranch->GetIntPref(APPEND_ACCOUNTS_VERSION_PREF_NAME, &appendAccountsCurrentVersion);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = defaultsPrefBranch->GetIntPref(APPEND_ACCOUNTS_VERSION_PREF_NAME, &appendAccountsDefaultVersion);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Update the account list if needed
+  if ((appendAccountsCurrentVersion <= appendAccountsDefaultVersion)) {
+
+    // Get a list of pre-configured accounts
+    nsCString appendAccountList;
+    rv = m_prefs->GetCharPref(PREF_MAIL_ACCOUNTMANAGER_APPEND_ACCOUNTS,
+                              getter_Copies(appendAccountList));
+    appendAccountList.StripWhitespace();
+
+    // If there are pre-configured accounts, we need to add them to the
+    // existing list.
+    if (!appendAccountList.IsEmpty())
+    {
+      if (!accountList.IsEmpty())
+      {
+        // Tokenize the data and add each account
+        // in the user's current mailnews account list
+        nsTArray<nsCString> accountsArray;
+        ParseString(accountList, ACCOUNT_DELIMITER, accountsArray);
+        uint32_t i = accountsArray.Length();
+
+        // Append each account in the pre-configured account list
+        ParseString(appendAccountList, ACCOUNT_DELIMITER, accountsArray);
+
+        // Now add each account that does not already appear in the list
+        for (; i < accountsArray.Length(); i++)
+        {
+          if (accountsArray.IndexOf(accountsArray[i]) == i)
+          {
+            accountList.Append(ACCOUNT_DELIMITER);
+            accountList.Append(accountsArray[i]);
+          }
+        }
+      }
+      else
+      {
+        accountList = appendAccountList;
+      }
+      // Increase the version number so that updates will happen as and when needed
+      rv = prefBranch->SetIntPref(APPEND_ACCOUNTS_VERSION_PREF_NAME, appendAccountsCurrentVersion + 1);
+    }
+  }
+
+  // It is ok to return null accounts like when we create new profile.
+  m_accountsLoaded = true;
+  m_haveShutdown = false;
+
+  if (accountList.IsEmpty())
+      return NS_OK;
+
+  /* parse accountList and run loadAccount on each string, comma-separated */
+  nsCOMPtr<nsIMsgAccount> account;
+  // Tokenize the data and add each account
+  // in the user's current mailnews account list
+  nsTArray<nsCString> accountsArray;
+  ParseString(accountList, ACCOUNT_DELIMITER, accountsArray);
+
+  // These are the duplicate accounts we found. We keep track of these
+  // because if any other server defers to one of these accounts, we need
+  // to defer to the correct account.
+  nsCOMArray<nsIMsgAccount> dupAccounts;
+
+  // Now add each account that does not already appear in the list
+  for (uint32_t i = 0; i < accountsArray.Length(); i++)
+  {
+    // if we've already seen this exact account, advance to the next account.
+    // After the loop, we'll notice that we don't have as many actual accounts
+    // as there were accounts in the pref, and rewrite the pref.
+    if (accountsArray.IndexOf(accountsArray[i]) != i)
+      continue;
+
+    // get the "server" pref to see if we already have an account with this
+    // server. If we do, we ignore this account.
+    nsAutoCString serverKeyPref("mail.account.");
+    serverKeyPref += accountsArray[i];
+
+    nsCOMPtr<nsIPrefBranch> accountPrefBranch;
+    rv = prefservice->GetBranch(serverKeyPref.get(),
+                                getter_AddRefs(accountPrefBranch));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    serverKeyPref += ".server";
+    nsCString serverKey;
+    rv = m_prefs->GetCharPref(serverKeyPref.get(), getter_Copies(serverKey));
+    if (NS_FAILED(rv))
+      continue;
+
+    nsCOMPtr<nsIMsgAccount> serverAccount;
+    findAccountByServerKey(serverKey, getter_AddRefs(serverAccount));
+    // If we have an existing account with the same server, ignore this account
+    if (serverAccount)
+      continue;
+
+    if (NS_FAILED(createKeyedAccount(accountsArray[i],
+                                     getter_AddRefs(account))) || !account)
+    {
+      NS_WARNING("unexpected entry in account list; prefs corrupt?");
+      continue;
+    }
+
+    // See nsIMsgAccount.idl for a description of the secondsToLeaveUnavailable
+    //  and timeFoundUnavailable preferences
+    nsAutoCString toLeavePref(PREF_MAIL_SERVER_PREFIX);
+    toLeavePref.Append(serverKey);
+    nsAutoCString unavailablePref(toLeavePref); // this is the server-specific prefix
+    unavailablePref.AppendLiteral(".timeFoundUnavailable");
+    toLeavePref.AppendLiteral(".secondsToLeaveUnavailable");
+    int32_t secondsToLeave = 0;
+    int32_t timeUnavailable = 0;
+
+    m_prefs->GetIntPref(toLeavePref.get(), &secondsToLeave);
+
+    // force load of accounts (need to find a better way to do this)
+    nsCOMPtr<nsIArray> identities;
+    account->GetIdentities(getter_AddRefs(identities));
+
+    rv = account->CreateServer();
+    bool deleteAccount = NS_FAILED(rv);
+
+    if (secondsToLeave)
+    { // we need to process timeUnavailable
+      if (NS_SUCCEEDED(rv)) // clear the time if server is available
+      {
+        m_prefs->ClearUserPref(unavailablePref.get());
+      }
+      // NS_ERROR_NOT_AVAILABLE signifies a server that could not be
+      // instantiated, presumably because of an invalid type.
+      else if (rv == NS_ERROR_NOT_AVAILABLE)
+      {
+        m_prefs->GetIntPref(unavailablePref.get(), &timeUnavailable);
+        if (!timeUnavailable)
+        { // we need to set it, this must be the first time unavailable
+          uint32_t nowSeconds;
+          PRTime2Seconds(PR_Now(), &nowSeconds);
+          m_prefs->SetIntPref(unavailablePref.get(), nowSeconds);
+          deleteAccount = false;
+        }
+      }
+    }
+
+    if (rv == NS_ERROR_NOT_AVAILABLE && timeUnavailable != 0)
+    { // Our server is still unavailable. Have we timed out yet?
+      uint32_t nowSeconds;
+      PRTime2Seconds(PR_Now(), &nowSeconds);
+      if ((int32_t)nowSeconds < timeUnavailable + secondsToLeave)
+        deleteAccount = false;
+    }
+
+    if (deleteAccount)
+    {
+      dupAccounts.AppendObject(account);
+      m_accounts.RemoveElement(account);
+    }
+  }
+
+  // Check if we removed one or more of the accounts in the pref string.
+  // If so, rewrite the pref string.
+  if (accountsArray.Length() != m_accounts.Length())
+    OutputAccountsPref();
+
+  int32_t cnt = dupAccounts.Count();
+  nsCOMPtr<nsIMsgAccount> dupAccount;
+
+  // Go through the accounts seeing if any existing server is deferred to
+  // an account we removed. If so, fix the deferral. Then clean up the prefs
+  // for the removed account.
+  for (int32_t i = 0; i < cnt; i++)
+  {
+    dupAccount = dupAccounts[i];
+    for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+      /*
+       * This loop gets run for every incoming server, and is passed a
+       * duplicate account. It checks that the server is not deferred to the
+       * duplicate account. If it is, then it looks up the information for the
+       * duplicate account's server (username, hostName, type), and finds an
+       * account with a server with the same username, hostname, and type, and
+       * if it finds one, defers to that account instead. Generally, this will
+       * be a Local Folders account, since 2.0 has a bug where duplicate Local
+       * Folders accounts are created.
+       */
+      nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();    // njn: rename
+      nsCString type;
+      server->GetType(type);
+      if (type.EqualsLiteral("pop3"))
+      {
+        nsCString deferredToAccount;
+        // Get the pref directly, because the GetDeferredToAccount accessor
+        // attempts to fix broken deferrals, but we know more about what the
+        // deferred to account was.
+        server->GetCharValue("deferred_to_account", deferredToAccount);
+        if (!deferredToAccount.IsEmpty())
+        {
+          nsCString dupAccountKey;
+          dupAccount->GetKey(dupAccountKey);
+          if (deferredToAccount.Equals(dupAccountKey))
+          {
+            nsresult rv;
+            nsCString accountPref("mail.account.");
+            nsCString dupAccountServerKey;
+            accountPref.Append(dupAccountKey);
+            accountPref.Append(".server");
+            nsCOMPtr<nsIPrefService> prefservice(
+              do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+            if (NS_FAILED(rv)) {
+              continue;
+            }
+            nsCOMPtr<nsIPrefBranch> prefBranch(
+              do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+            if (NS_FAILED(rv)) {
+              continue;
+            }
+            rv = prefBranch->GetCharPref(accountPref.get(),
+                                         getter_Copies(dupAccountServerKey));
+            if (NS_FAILED(rv)) {
+              continue;
+            }
+            nsCOMPtr<nsIPrefBranch> serverPrefBranch;
+            nsCString serverKeyPref(PREF_MAIL_SERVER_PREFIX);
+            serverKeyPref.Append(dupAccountServerKey);
+            serverKeyPref.Append(".");
+            rv = prefservice->GetBranch(serverKeyPref.get(),
+                                        getter_AddRefs(serverPrefBranch));
+            if (NS_FAILED(rv)) {
+              continue;
+            }
+            nsCString userName;
+            nsCString hostName;
+            nsCString type;
+            serverPrefBranch->GetCharPref("userName", getter_Copies(userName));
+            serverPrefBranch->GetCharPref("hostname", getter_Copies(hostName));
+            serverPrefBranch->GetCharPref("type", getter_Copies(type));
+            // Find a server with the same info.
+            nsCOMPtr<nsIMsgAccountManager> accountManager =
+                     do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+            if (NS_FAILED(rv)) {
+              continue;
+            }
+            nsCOMPtr<nsIMsgIncomingServer> server;
+            accountManager->FindServer(userName, hostName, type,
+                                       getter_AddRefs(server));
+            if (server)
+            {
+              nsCOMPtr<nsIMsgAccount> replacement;
+              accountManager->FindAccountForServer(server,
+                                                   getter_AddRefs(replacement));
+              if (replacement)
+              {
+                nsCString accountKey;
+                replacement->GetKey(accountKey);
+                if (!accountKey.IsEmpty())
+                  server->SetCharValue("deferred_to_account", accountKey);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    nsAutoCString accountKeyPref("mail.account.");
+    nsCString dupAccountKey;
+    dupAccount->GetKey(dupAccountKey);
+    if (dupAccountKey.IsEmpty())
+      continue;
+    accountKeyPref += dupAccountKey;
+
+    nsCOMPtr<nsIPrefBranch> accountPrefBranch;
+    rv = prefservice->GetBranch(accountKeyPref.get(),
+                                getter_AddRefs(accountPrefBranch));
+    if (accountPrefBranch)
+      accountPrefBranch->DeleteBranch("");
+  }
+
+  // Make sure we have an account that points at the local folders server
+  nsCString localFoldersServerKey;
+  rv = m_prefs->GetCharPref(PREF_MAIL_ACCOUNTMANAGER_LOCALFOLDERSSERVER,
+                            getter_Copies(localFoldersServerKey));
+
+  if (!localFoldersServerKey.IsEmpty())
+  {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    rv = GetIncomingServer(localFoldersServerKey, getter_AddRefs(server));
+    if (server)
+    {
+      nsCOMPtr<nsIMsgAccount> localFoldersAccount;
+      findAccountByServerKey(localFoldersServerKey, getter_AddRefs(localFoldersAccount));
+      // If we don't have an existing account pointing at the local folders
+      // server, we're going to add one.
+      if (!localFoldersAccount)
+      {
+        nsCOMPtr<nsIMsgAccount> account;
+        (void) CreateAccount(getter_AddRefs(account));
+        if (account)
+          account->SetIncomingServer(server);
+      }
+    }
+  }
+  return NS_OK;
+}
+
+// this routine goes through all the identities and makes sure
+// that the special folders for each identity have the
+// correct special folder flags set, e.g, the Sent folder has
+// the sent flag set.
+//
+// it also goes through all the spam settings for each account
+// and makes sure the folder flags are set there, too
+NS_IMETHODIMP
+nsMsgAccountManager::SetSpecialFolders()
+{
+  nsresult rv;
+  nsCOMPtr<nsIRDFService> rdf = do_GetService("@mozilla.org/rdf/rdf-service;1", &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIArray> identities;
+  GetAllIdentities(getter_AddRefs(identities));
+
+  uint32_t idCount = 0;
+  identities->GetLength(&idCount);
+
+  uint32_t id;
+  nsCString identityKey;
+
+  for (id = 0; id < idCount; id++)
+  {
+    nsCOMPtr<nsIMsgIdentity> thisIdentity(do_QueryElementAt(identities, id, &rv));
+    if (NS_FAILED(rv))
+      continue;
+
+    if (NS_SUCCEEDED(rv) && thisIdentity)
+    {
+      nsCString folderUri;
+      nsCOMPtr<nsIRDFResource> res;
+      nsCOMPtr<nsIMsgFolder> folder;
+      thisIdentity->GetFccFolder(folderUri);
+      if (!folderUri.IsEmpty() && NS_SUCCEEDED(rdf->GetResource(folderUri, getter_AddRefs(res))))
+      {
+        folder = do_QueryInterface(res, &rv);
+        nsCOMPtr <nsIMsgFolder> parent;
+        if (folder && NS_SUCCEEDED(rv))
+        {
+          rv = folder->GetParent(getter_AddRefs(parent));
+          if (NS_SUCCEEDED(rv) && parent)
+            rv = folder->SetFlag(nsMsgFolderFlags::SentMail);
+        }
+      }
+      thisIdentity->GetDraftFolder(folderUri);
+      if (!folderUri.IsEmpty() && NS_SUCCEEDED(rdf->GetResource(folderUri, getter_AddRefs(res))))
+      {
+        folder = do_QueryInterface(res, &rv);
+        nsCOMPtr <nsIMsgFolder> parent;
+        if (folder && NS_SUCCEEDED(rv))
+        {
+          rv = folder->GetParent(getter_AddRefs(parent));
+          if (NS_SUCCEEDED(rv) && parent)
+            rv = folder->SetFlag(nsMsgFolderFlags::Drafts);
+        }
+      }
+      thisIdentity->GetArchiveFolder(folderUri);
+      if (!folderUri.IsEmpty() && NS_SUCCEEDED(rdf->GetResource(folderUri, getter_AddRefs(res))))
+      {
+        folder = do_QueryInterface(res, &rv);
+        nsCOMPtr <nsIMsgFolder> parent;
+        if (folder && NS_SUCCEEDED(rv))
+        {
+          rv = folder->GetParent(getter_AddRefs(parent));
+          if (NS_SUCCEEDED(rv) && parent)
+          {
+            bool archiveEnabled;
+            thisIdentity->GetArchiveEnabled(&archiveEnabled);
+            if (archiveEnabled)
+              rv = folder->SetFlag(nsMsgFolderFlags::Archive);
+            else
+              rv = folder->ClearFlag(nsMsgFolderFlags::Archive);
+          }
+        }
+      }
+      thisIdentity->GetStationeryFolder(folderUri);
+      if (!folderUri.IsEmpty() && NS_SUCCEEDED(rdf->GetResource(folderUri, getter_AddRefs(res))))
+      {
+        folder = do_QueryInterface(res, &rv);
+        if (folder && NS_SUCCEEDED(rv))
+        {
+          nsCOMPtr <nsIMsgFolder> parent;
+          rv = folder->GetParent(getter_AddRefs(parent));
+          if (NS_SUCCEEDED(rv) && parent) // only set flag if folder is real
+            rv = folder->SetFlag(nsMsgFolderFlags::Templates);
+        }
+      }
+    }
+  }
+
+  // XXX todo
+  // get all servers
+  // get all spam settings for each server
+  // set the JUNK folder flag on the spam folders, right?
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::UnloadAccounts()
+{
+  // release the default account
+  kDefaultServerAtom = nullptr;
+  mFolderFlagAtom = nullptr;
+
+  m_defaultAccount=nullptr;
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();
+    if (!server)
+      continue;
+    nsresult rv;
+    NotifyServerUnloaded(server);
+
+    nsCOMPtr<nsIMsgFolder> rootFolder;
+    rv = server->GetRootFolder(getter_AddRefs(rootFolder));
+    if (NS_SUCCEEDED(rv)) {
+      removeListenersFromFolder(rootFolder);
+
+      rootFolder->Shutdown(true);
+    }
+  }
+
+  m_accounts.Clear();          // will release all elements
+  m_identities.Clear();
+  m_incomingServers.Clear();
+  mAccountKeyList.Truncate();
+  SetLastServerFound(nullptr, EmptyCString(), EmptyCString(), 0, EmptyCString());
+
+  if (m_accountsLoaded)
+  {
+    nsCOMPtr<nsIMsgMailSession> mailSession =
+      do_GetService(NS_MSGMAILSESSION_CONTRACTID);
+    if (mailSession)
+      mailSession->RemoveFolderListener(this);
+    m_accountsLoaded = false;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::ShutdownServers()
+{
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();
+    if (server)
+      server->Shutdown();
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::CloseCachedConnections()
+{
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();
+    if (server)
+      server->CloseCachedConnections();
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::CleanupOnExit()
+{
+  // This can get called multiple times, and potentially re-entrantly.
+  // So add some protection against that.
+  if (m_shutdownInProgress)
+    return NS_OK;
+
+  m_shutdownInProgress = true;
+
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();
+
+    bool emptyTrashOnExit = false;
+    bool cleanupInboxOnExit = false;
+    nsresult rv;
+
+    if (WeAreOffline())
+      break;
+
+    if (!server)
+      continue;
+
+    server->GetEmptyTrashOnExit(&emptyTrashOnExit);
+    nsCOMPtr <nsIImapIncomingServer> imapserver = do_QueryInterface(server);
+    if (imapserver)
+    {
+      imapserver->GetCleanupInboxOnExit(&cleanupInboxOnExit);
+      imapserver->SetShuttingDown(true);
+    }
+    if (emptyTrashOnExit || cleanupInboxOnExit)
+    {
+      nsCOMPtr<nsIMsgFolder> root;
+      server->GetRootFolder(getter_AddRefs(root));
+      nsCString type;
+      server->GetType(type);
+      if (root)
+      {
+        nsCOMPtr<nsIMsgFolder> folder;
+        folder = do_QueryInterface(root);
+        if (folder)
+        {
+          nsCString passwd;
+          bool serverRequiresPasswordForAuthentication = true;
+          bool isImap = type.EqualsLiteral("imap");
+          if (isImap)
+          {
+            server->GetServerRequiresPasswordForBiff(&serverRequiresPasswordForAuthentication);
+            server->GetPassword(passwd);
+          }
+          if (!isImap || (isImap && (!serverRequiresPasswordForAuthentication || !passwd.IsEmpty())))
+          {
+            nsCOMPtr<nsIUrlListener> urlListener;
+            nsCOMPtr<nsIMsgAccountManager> accountManager =
+                     do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+            if (NS_FAILED(rv))
+              continue;
+
+            if (isImap)
+              urlListener = do_QueryInterface(accountManager, &rv);
+
+            if (isImap && cleanupInboxOnExit)
+            {
+              nsCOMPtr<nsISimpleEnumerator> enumerator;
+              rv = folder->GetSubFolders(getter_AddRefs(enumerator));
+              if (NS_SUCCEEDED(rv))
+              {
+                bool hasMore;
+                while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) &&
+                       hasMore)
+                {
+                  nsCOMPtr<nsISupports> item;
+                  enumerator->GetNext(getter_AddRefs(item));
+
+                  nsCOMPtr<nsIMsgFolder> inboxFolder(do_QueryInterface(item));
+                  if (!inboxFolder)
+                    continue;
+
+                  uint32_t flags;
+                  inboxFolder->GetFlags(&flags);
+                  if (flags & nsMsgFolderFlags::Inbox)
+                  {
+                    rv = inboxFolder->Compact(urlListener, nullptr /* msgwindow */);
+                    if (NS_SUCCEEDED(rv))
+                      accountManager->SetFolderDoingCleanupInbox(inboxFolder);
+                    break;
+                  }
+                }
+              }
+            }
+
+            if (emptyTrashOnExit)
+            {
+              rv = folder->EmptyTrash(nullptr, urlListener);
+              if (isImap && NS_SUCCEEDED(rv))
+                accountManager->SetFolderDoingEmptyTrash(folder);
+            }
+
+            if (isImap && urlListener)
+            {
+              nsCOMPtr<nsIThread> thread(do_GetCurrentThread());
+
+              bool inProgress = false;
+              if (cleanupInboxOnExit)
+              {
+                int32_t loopCount = 0; // used to break out after 5 seconds
+                accountManager->GetCleanupInboxInProgress(&inProgress);
+                while (inProgress && loopCount++ < 5000)
+                {
+                  accountManager->GetCleanupInboxInProgress(&inProgress);
+                  PR_CEnterMonitor(folder);
+                  PR_CWait(folder, PR_MicrosecondsToInterval(1000UL));
+                  PR_CExitMonitor(folder);
+                  NS_ProcessPendingEvents(thread, PR_MicrosecondsToInterval(1000UL));
+                }
+              }
+              if (emptyTrashOnExit)
+              {
+                accountManager->GetEmptyTrashInProgress(&inProgress);
+                int32_t loopCount = 0;
+                while (inProgress && loopCount++ < 5000)
+                {
+                  accountManager->GetEmptyTrashInProgress(&inProgress);
+                  PR_CEnterMonitor(folder);
+                  PR_CWait(folder, PR_MicrosecondsToInterval(1000UL));
+                  PR_CExitMonitor(folder);
+                  NS_ProcessPendingEvents(thread, PR_MicrosecondsToInterval(1000UL));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Try to do this early on in the shutdown process before
+  // necko shuts itself down.
+  CloseCachedConnections();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::WriteToFolderCache(nsIMsgFolderCache *folderCache)
+{
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    iter.Data()->WriteToFolderCache(folderCache);
+  }
+  return folderCache ? folderCache->Close() : NS_ERROR_FAILURE;
+}
+
+nsresult
+nsMsgAccountManager::createKeyedAccount(const nsCString& key,
+                                        nsIMsgAccount ** aAccount)
+{
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgAccount> account = do_CreateInstance(kMsgAccountCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  account->SetKey(key);
+
+  m_accounts.AppendElement(account);
+
+  // add to string list
+  if (mAccountKeyList.IsEmpty())
+    mAccountKeyList = key;
+  else {
+    mAccountKeyList.Append(',');
+    mAccountKeyList.Append(key);
+  }
+
+  m_prefs->SetCharPref(PREF_MAIL_ACCOUNTMANAGER_ACCOUNTS, mAccountKeyList.get());
+  account.swap(*aAccount);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::CreateAccount(nsIMsgAccount **_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  nsAutoCString key;
+  getUniqueAccountKey(key);
+
+  return createKeyedAccount(key, _retval);
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetAccount(const nsACString& aKey, nsIMsgAccount **aAccount)
+{
+  NS_ENSURE_ARG_POINTER(aAccount);
+  *aAccount = nullptr;
+
+  for (uint32_t i = 0; i < m_accounts.Length(); ++i)
+  {
+    nsCOMPtr<nsIMsgAccount> account(m_accounts[i]);
+    nsCString key;
+    account->GetKey(key);
+    if (key.Equals(aKey))
+    {
+      account.swap(*aAccount);
+      break;
+    }
+  }
+
+  // If not found, create on demand.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::FindServerIndex(nsIMsgIncomingServer* server, int32_t* result)
+{
+  NS_ENSURE_ARG_POINTER(server);
+  NS_ENSURE_ARG_POINTER(result);
+
+  nsCString key;
+  nsresult rv = server->GetKey(key);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // do this by account because the account list is in order
+  uint32_t i;
+  for (i = 0; i < m_accounts.Length(); ++i)
+  {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    rv = m_accounts[i]->GetIncomingServer(getter_AddRefs(server));
+    if (!server || NS_FAILED(rv))
+      continue;
+
+    nsCString serverKey;
+    rv = server->GetKey(serverKey);
+    if (NS_FAILED(rv))
+      continue;
+
+    // stop when found,
+    // index will be set to the current index
+    if (serverKey.Equals(key))
+      break;
+  }
+
+  // Even if the search failed, we can return index.
+  // This means that all servers not in the array return an index higher
+  // than all "registered" servers.
+  *result = i;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::AddIncomingServerListener(nsIIncomingServerListener *serverListener)
+{
+  m_incomingServerListeners.AppendObject(serverListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::RemoveIncomingServerListener(nsIIncomingServerListener *serverListener)
+{
+  m_incomingServerListeners.RemoveObject(serverListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::NotifyServerLoaded(nsIMsgIncomingServer *server)
+{
+  int32_t count = m_incomingServerListeners.Count();
+  for(int32_t i = 0; i < count; i++)
+  {
+    nsIIncomingServerListener* listener = m_incomingServerListeners[i];
+    listener->OnServerLoaded(server);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::NotifyServerUnloaded(nsIMsgIncomingServer *server)
+{
+  NS_ENSURE_ARG_POINTER(server);
+
+  int32_t count = m_incomingServerListeners.Count();
+  server->SetFilterList(nullptr); // clear this to cut shutdown leaks. we are always passing valid non-null server here.
+
+  for(int32_t i = 0; i < count; i++)
+  {
+    nsIIncomingServerListener* listener = m_incomingServerListeners[i];
+    listener->OnServerUnloaded(server);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::NotifyServerChanged(nsIMsgIncomingServer *server)
+{
+  int32_t count = m_incomingServerListeners.Count();
+  for(int32_t i = 0; i < count; i++)
+  {
+    nsIIncomingServerListener* listener = m_incomingServerListeners[i];
+    listener->OnServerChanged(server);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::FindServerByURI(nsIURI *aURI, bool aRealFlag,
+                                nsIMsgIncomingServer** aResult)
+{
+  NS_ENSURE_ARG_POINTER(aURI);
+
+  nsresult rv = LoadAccounts();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get username and hostname and port so we can get the server
+  nsAutoCString username;
+  nsAutoCString escapedUsername;
+  rv = aURI->GetUserPass(escapedUsername);
+  if (NS_SUCCEEDED(rv) && !escapedUsername.IsEmpty())
+    MsgUnescapeString(escapedUsername, 0,  username);
+
+  nsAutoCString hostname;
+  nsAutoCString escapedHostname;
+  rv = aURI->GetHost(escapedHostname);
+  if (NS_SUCCEEDED(rv) && !escapedHostname.IsEmpty())
+    MsgUnescapeString(escapedHostname, 0, hostname);
+
+  nsAutoCString type;
+  rv = aURI->GetScheme(type);
+  if (NS_SUCCEEDED(rv) && !type.IsEmpty())
+  {
+    // now modify type if pop or news
+    if (type.EqualsLiteral("pop"))
+      type.AssignLiteral("pop3");
+    // we use "nntp" in the server list so translate it here.
+    else if (type.EqualsLiteral("news"))
+      type.AssignLiteral("nntp");
+    // we use "any" as the wildcard type.
+    else if (type.EqualsLiteral("any"))
+      type.Truncate();
+  }
+
+  int32_t port = 0;
+  // check the port of the scheme is not 'none' or blank
+  if (!(type.EqualsLiteral("none") || type.IsEmpty()))
+  {
+    rv = aURI->GetPort(&port);
+    // Set the port to zero if we got a -1 (use default)
+    if (NS_SUCCEEDED(rv) && (port == -1))
+      port = 0;
+  }
+
+  return findServerInternal(username, hostname, type, port, aRealFlag, aResult);
+}
+
+nsresult
+nsMsgAccountManager::findServerInternal(const nsACString& username,
+                                        const nsACString& hostname,
+                                        const nsACString& type,
+                                        int32_t port,
+                                        bool aRealFlag,
+                                        nsIMsgIncomingServer** aResult)
+{
+  // If 'aRealFlag' is set then we want to scan all existing accounts
+  // to make sure there's no duplicate including those whose host and/or
+  // user names have been changed.
+  if (!aRealFlag &&
+      (m_lastFindServerUserName.Equals(username)) &&
+      (m_lastFindServerHostName.Equals(hostname)) &&
+      (m_lastFindServerType.Equals(type)) &&
+      (m_lastFindServerPort == port) &&
+      m_lastFindServerResult)
+  {
+    NS_ADDREF(*aResult = m_lastFindServerResult);
+    return NS_OK;
+  }
+
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    // Find matching server by user+host+type+port.
+    nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();
+
+    if (!server)
+      continue;
+
+    nsresult rv;
+    nsCString thisHostname;
+    if (aRealFlag)
+      rv = server->GetRealHostName(thisHostname);
+    else
+      rv = server->GetHostName(thisHostname);
+    if (NS_FAILED(rv))
+      continue;
+
+    nsCString thisUsername;
+    if (aRealFlag)
+      rv = server->GetRealUsername(thisUsername);
+    else
+      rv = server->GetUsername(thisUsername);
+    if (NS_FAILED(rv))
+      continue;
+
+    nsCString thisType;
+    rv = server->GetType(thisType);
+    if (NS_FAILED(rv))
+      continue;
+
+    int32_t thisPort = -1; // use the default port identifier
+    // Don't try and get a port for the 'none' scheme
+    if (!thisType.EqualsLiteral("none"))
+    {
+      rv = server->GetPort(&thisPort);
+      if (NS_FAILED(rv)) {
+        continue;
+      }
+    }
+
+    // treat "" as a wild card, so if the caller passed in "" for the desired attribute
+    // treat it as a match
+    if ((type.IsEmpty() || thisType.Equals(type)) &&
+        (hostname.IsEmpty() || thisHostname.Equals(hostname, nsCaseInsensitiveCStringComparator())) &&
+        (!(port != 0) || (port == thisPort)) &&
+        (username.IsEmpty() || thisUsername.Equals(username)))
+    {
+      // stop on first find; cache for next time
+      if (!aRealFlag)
+        SetLastServerFound(server, hostname, username, port, type);
+
+      NS_ADDREF(*aResult = server);
+      return NS_OK;
+    }
+  }
+
+  return NS_ERROR_UNEXPECTED;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::FindServer(const nsACString& username,
+                                const nsACString& hostname,
+                                const nsACString& type,
+                                nsIMsgIncomingServer** aResult)
+{
+  return findServerInternal(username, hostname, type, 0, false, aResult);
+}
+
+// Interface called by UI js only (always return true).
+NS_IMETHODIMP
+nsMsgAccountManager::FindRealServer(const nsACString& username,
+                                    const nsACString& hostname,
+                                    const nsACString& type,
+                                    int32_t port,
+                                    nsIMsgIncomingServer** aResult)
+{
+  *aResult = nullptr;
+  findServerInternal(username, hostname, type, port, true, aResult);
+  return NS_OK;
+}
+
+void
+nsMsgAccountManager::findAccountByServerKey(const nsCString &aKey,
+                                            nsIMsgAccount **aResult)
+{
+  *aResult = nullptr;
+
+  for (uint32_t i = 0; i < m_accounts.Length(); ++i)
+  {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    nsresult rv = m_accounts[i]->GetIncomingServer(getter_AddRefs(server));
+    if (!server || NS_FAILED(rv))
+      continue;
+
+    nsCString key;
+    rv = server->GetKey(key);
+    if (NS_FAILED(rv))
+      continue;
+
+    // if the keys are equal, the servers are equal
+    if (key.Equals(aKey))
+    {
+      NS_ADDREF(*aResult = m_accounts[i]);
+      break; // stop on first found account
+    }
+  }
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::FindAccountForServer(nsIMsgIncomingServer *server,
+                                            nsIMsgAccount **aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  if (!server)
+  {
+    (*aResult) = nullptr;
+    return NS_OK;
+  }
+
+  nsresult rv;
+
+  nsCString key;
+  rv = server->GetKey(key);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  findAccountByServerKey(key, aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetFirstIdentityForServer(nsIMsgIncomingServer *aServer, nsIMsgIdentity **aIdentity)
+{
+  NS_ENSURE_ARG_POINTER(aServer);
+  NS_ENSURE_ARG_POINTER(aIdentity);
+
+  nsCOMPtr<nsIArray> identities;
+  nsresult rv = GetIdentitiesForServer(aServer, getter_AddRefs(identities));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // not all servers have identities
+  // for example, Local Folders
+  uint32_t numIdentities;
+  rv = identities->GetLength(&numIdentities);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (numIdentities > 0)
+  {
+    nsCOMPtr<nsIMsgIdentity> identity(do_QueryElementAt(identities, 0, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    identity.swap(*aIdentity);
+  }
+  else
+    *aIdentity = nullptr;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetIdentitiesForServer(nsIMsgIncomingServer *server,
+                                            nsIArray **_retval)
+{
+  NS_ENSURE_ARG_POINTER(server);
+  NS_ENSURE_ARG_POINTER(_retval);
+  nsresult rv = LoadAccounts();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMutableArray> identities(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString serverKey;
+  rv = server->GetKey(serverKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (uint32_t i = 0; i < m_accounts.Length(); ++i)
+  {
+    nsCOMPtr<nsIMsgAccount> account(m_accounts[i]);
+
+    nsCOMPtr<nsIMsgIncomingServer> thisServer;
+    rv = account->GetIncomingServer(getter_AddRefs(thisServer));
+    if (NS_FAILED(rv) || !thisServer)
+      continue;
+
+    nsAutoCString thisServerKey;
+    rv = thisServer->GetKey(thisServerKey);
+    if (serverKey.Equals(thisServerKey))
+    {
+      nsCOMPtr<nsIArray> theseIdentities;
+      rv = account->GetIdentities(getter_AddRefs(theseIdentities));
+      if (NS_SUCCEEDED(rv))
+      {
+        uint32_t theseLength;
+        rv = theseIdentities->GetLength(&theseLength);
+        if (NS_SUCCEEDED(rv))
+        {
+          for (uint32_t j = 0; j < theseLength; ++j)
+          {
+            nsCOMPtr<nsISupports> id(do_QueryElementAt(theseIdentities, j, &rv));
+            if (NS_SUCCEEDED(rv))
+              identities->AppendElement(id, false);
+          }
+        }
+      }
+    }
+  }
+
+  identities.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetServersForIdentity(nsIMsgIdentity *aIdentity,
+                                           nsIArray **_retval)
+{
+  NS_ENSURE_ARG_POINTER(aIdentity);
+
+  nsresult rv;
+  rv = LoadAccounts();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMutableArray> servers(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (uint32_t i = 0; i < m_accounts.Length(); ++i)
+  {
+    nsCOMPtr<nsIArray> identities;
+    if (NS_FAILED(m_accounts[i]->GetIdentities(getter_AddRefs(identities))))
+      continue;
+
+    uint32_t idCount = 0;
+    if (NS_FAILED(identities->GetLength(&idCount)))
+      continue;
+
+    uint32_t id;
+    nsCString identityKey;
+    rv = aIdentity->GetKey(identityKey);
+    for (id = 0; id < idCount; id++)
+    {
+      nsCOMPtr<nsIMsgIdentity> thisIdentity(do_QueryElementAt(identities, id, &rv));
+      if (NS_SUCCEEDED(rv))
+      {
+        nsCString thisIdentityKey;
+        rv = thisIdentity->GetKey(thisIdentityKey);
+
+        if (NS_SUCCEEDED(rv) && identityKey.Equals(thisIdentityKey))
+        {
+          nsCOMPtr<nsIMsgIncomingServer> thisServer;
+          rv = m_accounts[i]->GetIncomingServer(getter_AddRefs(thisServer));
+          if (thisServer && NS_SUCCEEDED(rv))
+          {
+            servers->AppendElement(thisServer, false);
+            break;
+          }
+        }
+      }
+    }
+  }
+  servers.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::AddRootFolderListener(nsIFolderListener *aListener)
+{
+  NS_ENSURE_TRUE(aListener, NS_OK);
+  mFolderListeners.AppendElement(aListener);
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    nsCOMPtr<nsIMsgFolder> rootFolder;
+    nsresult rv = iter.Data()->GetRootFolder(getter_AddRefs(rootFolder));
+    if (NS_FAILED(rv)) {
+      continue;
+    }
+    rv = rootFolder->AddFolderListener(aListener);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::RemoveRootFolderListener(nsIFolderListener *aListener)
+{
+  NS_ENSURE_TRUE(aListener, NS_OK);
+  mFolderListeners.RemoveElement(aListener);
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    nsCOMPtr<nsIMsgFolder> rootFolder;
+    nsresult rv = iter.Data()->GetRootFolder(getter_AddRefs(rootFolder));
+    if (NS_FAILED(rv)) {
+      continue;
+    }
+    rv = rootFolder->RemoveFolderListener(aListener);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::SetLocalFoldersServer(nsIMsgIncomingServer *aServer)
+{
+  NS_ENSURE_ARG_POINTER(aServer);
+  nsCString key;
+  nsresult rv = aServer->GetKey(key);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return m_prefs->SetCharPref(PREF_MAIL_ACCOUNTMANAGER_LOCALFOLDERSSERVER, key.get());
+}
+
+NS_IMETHODIMP nsMsgAccountManager::GetLocalFoldersServer(nsIMsgIncomingServer **aServer)
+{
+  NS_ENSURE_ARG_POINTER(aServer);
+
+  nsCString serverKey;
+
+  nsresult rv = m_prefs->GetCharPref(PREF_MAIL_ACCOUNTMANAGER_LOCALFOLDERSSERVER, getter_Copies(serverKey));
+
+  if (NS_SUCCEEDED(rv) && !serverKey.IsEmpty())
+  {
+    rv = GetIncomingServer(serverKey, aServer);
+    if (NS_SUCCEEDED(rv))
+      return rv;
+    // otherwise, we're going to fall through to looking for an existing local
+    // folders account, because now we fail creating one if one already exists.
+  }
+
+  // try ("nobody","Local Folders","none"), and work down to any "none" server.
+  rv = FindServer(NS_LITERAL_CSTRING("nobody"), NS_LITERAL_CSTRING("Local Folders"),
+                  NS_LITERAL_CSTRING("none"), aServer);
+  if (NS_FAILED(rv) || !*aServer)
+  {
+      rv = FindServer(NS_LITERAL_CSTRING("nobody"), EmptyCString(), NS_LITERAL_CSTRING("none"), aServer);
+      if (NS_FAILED(rv) || !*aServer)
+      {
+          rv = FindServer(EmptyCString(), NS_LITERAL_CSTRING("Local Folders"),
+                          NS_LITERAL_CSTRING("none"), aServer);
+          if (NS_FAILED(rv) || !*aServer)
+              rv = FindServer(EmptyCString(), EmptyCString(), NS_LITERAL_CSTRING("none"), aServer);
+      }
+  }
+
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!*aServer)
+    return NS_ERROR_FAILURE;
+
+  // we don't want the Smart Mailboxes server to be the local server.
+  bool hidden;
+  (*aServer)->GetHidden(&hidden);
+  if (hidden)
+    return NS_ERROR_FAILURE;
+
+  rv = SetLocalFoldersServer(*aServer);
+  return rv;
+}
+
+nsresult nsMsgAccountManager::GetLocalFoldersPrettyName(nsString &localFoldersName)
+{
+  // we don't want "nobody at Local Folders" to show up in the
+  // folder pane, so we set the pretty name to a localized "Local Folders"
+  nsCOMPtr<nsIStringBundle> bundle;
+  nsresult rv;
+  nsCOMPtr<nsIStringBundleService> sBundleService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED);
+
+  rv = sBundleService->CreateBundle("chrome://messenger/locale/messenger.properties",
+                                    getter_AddRefs(bundle));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return bundle->GetStringFromName(u"localFolders", getter_Copies(localFoldersName));
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::CreateLocalMailAccount()
+{
+  // create the server
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = CreateIncomingServer(NS_LITERAL_CSTRING("nobody"),
+                            NS_LITERAL_CSTRING("Local Folders"),
+                            NS_LITERAL_CSTRING("none"), getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsString localFoldersName;
+  rv = GetLocalFoldersPrettyName(localFoldersName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  server->SetPrettyName(localFoldersName);
+
+  nsCOMPtr<nsINoIncomingServer> noServer;
+  noServer = do_QueryInterface(server, &rv);
+  if (NS_FAILED(rv)) return rv;
+
+  // create the directory structure for old 4.x "Local Mail"
+  // under <profile dir>/Mail/Local Folders or
+  // <"mail.directory" pref>/Local Folders
+  nsCOMPtr <nsIFile> mailDir;
+  nsCOMPtr <nsIFile> localFile;
+  bool dirExists;
+
+  // we want <profile>/Mail
+  rv = NS_GetSpecialDirectory(NS_APP_MAIL_50_DIR, getter_AddRefs(mailDir));
+  if (NS_FAILED(rv)) return rv;
+  localFile = do_QueryInterface(mailDir);
+
+  rv = mailDir->Exists(&dirExists);
+  if (NS_SUCCEEDED(rv) && !dirExists)
+    rv = mailDir->Create(nsIFile::DIRECTORY_TYPE, 0775);
+  if (NS_FAILED(rv)) return rv;
+
+  // set the default local path for "none"
+  rv = server->SetDefaultLocalPath(localFile);
+  if (NS_FAILED(rv)) return rv;
+
+  // Create an account when valid server values are established.
+  // This will keep the status of accounts sane by avoiding the addition of incomplete accounts.
+  nsCOMPtr<nsIMsgAccount> account;
+  rv = CreateAccount(getter_AddRefs(account));
+  if (NS_FAILED(rv)) return rv;
+
+  // notice, no identity for local mail
+  // hook the server to the account
+  // after we set the server's local path
+  // (see bug #66018)
+  account->SetIncomingServer(server);
+
+  // remember this as the local folders server
+  return SetLocalFoldersServer(server);
+}
+
+  // nsIUrlListener methods
+
+NS_IMETHODIMP
+nsMsgAccountManager::OnStartRunningUrl(nsIURI * aUrl)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::OnStopRunningUrl(nsIURI * aUrl, nsresult aExitCode)
+{
+  if (aUrl)
+  {
+    nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(aUrl);
+    if (imapUrl)
+    {
+      nsImapAction imapAction = nsIImapUrl::nsImapTest;
+      imapUrl->GetImapAction(&imapAction);
+      switch(imapAction)
+      {
+        case nsIImapUrl::nsImapExpungeFolder:
+          if (m_folderDoingCleanupInbox)
+          {
+            PR_CEnterMonitor(m_folderDoingCleanupInbox);
+            PR_CNotifyAll(m_folderDoingCleanupInbox);
+            m_cleanupInboxInProgress = false;
+            PR_CExitMonitor(m_folderDoingCleanupInbox);
+            m_folderDoingCleanupInbox=nullptr;   //reset to nullptr
+          }
+          break;
+        case nsIImapUrl::nsImapDeleteAllMsgs:
+          if (m_folderDoingEmptyTrash)
+          {
+            PR_CEnterMonitor(m_folderDoingEmptyTrash);
+            PR_CNotifyAll(m_folderDoingEmptyTrash);
+            m_emptyTrashInProgress = false;
+            PR_CExitMonitor(m_folderDoingEmptyTrash);
+            m_folderDoingEmptyTrash = nullptr;  //reset to nullptr;
+          }
+          break;
+        default:
+          break;
+       }
+     }
+   }
+   return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::SetFolderDoingEmptyTrash(nsIMsgFolder *folder)
+{
+  m_folderDoingEmptyTrash = folder;
+  m_emptyTrashInProgress = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetEmptyTrashInProgress(bool *bVal)
+{
+  NS_ENSURE_ARG_POINTER(bVal);
+  *bVal = m_emptyTrashInProgress;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::SetFolderDoingCleanupInbox(nsIMsgFolder *folder)
+{
+  m_folderDoingCleanupInbox = folder;
+  m_cleanupInboxInProgress = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetCleanupInboxInProgress(bool *bVal)
+{
+  NS_ENSURE_ARG_POINTER(bVal);
+  *bVal = m_cleanupInboxInProgress;
+  return NS_OK;
+}
+
+void
+nsMsgAccountManager::SetLastServerFound(nsIMsgIncomingServer *server, const nsACString& hostname,
+                                        const nsACString& username, const int32_t port, const nsACString& type)
+{
+  m_lastFindServerResult = server;
+  m_lastFindServerHostName = hostname;
+  m_lastFindServerUserName = username;
+  m_lastFindServerPort = port;
+  m_lastFindServerType = type;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::SaveAccountInfo()
+{
+  nsresult rv;
+  nsCOMPtr<nsIPrefService> pref(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv,rv);
+  return pref->SavePrefFile(nullptr);
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetChromePackageName(const nsACString& aExtensionName, nsACString& aChromePackageName)
+{
+  nsresult rv;
+  nsCOMPtr<nsICategoryManager> catman = do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsISimpleEnumerator> e;
+  rv = catman->EnumerateCategory(MAILNEWS_ACCOUNTMANAGER_EXTENSIONS, getter_AddRefs(e));
+  if(NS_SUCCEEDED(rv) && e) {
+    while (true) {
+      nsCOMPtr<nsISupports> supports;
+      rv = e->GetNext(getter_AddRefs(supports));
+      nsCOMPtr<nsISupportsCString> catEntry = do_QueryInterface(supports);
+      if (NS_FAILED(rv) || !catEntry)
+        break;
+
+      nsAutoCString entryString;
+      rv = catEntry->GetData(entryString);
+      if (NS_FAILED(rv))
+         break;
+
+      nsCString contractidString;
+      rv = catman->GetCategoryEntry(MAILNEWS_ACCOUNTMANAGER_EXTENSIONS, entryString.get(),
+                                    getter_Copies(contractidString));
+      if (NS_FAILED(rv))
+        break;
+
+      nsCOMPtr <nsIMsgAccountManagerExtension> extension = do_GetService(contractidString.get(), &rv);
+      if (NS_FAILED(rv) || !extension)
+        break;
+
+      nsCString name;
+      rv = extension->GetName(name);
+      if (NS_FAILED(rv))
+        break;
+
+      if (name.Equals(aExtensionName))
+        return extension->GetChromePackageName(aChromePackageName);
+    }
+  }
+  return NS_ERROR_UNEXPECTED;
+}
+
+class VFChangeListenerEvent : public mozilla::Runnable
+{
+public:
+  VFChangeListenerEvent(VirtualFolderChangeListener *vfChangeListener,
+                        nsIMsgFolder *virtFolder, nsIMsgDatabase *virtDB)
+    : mVFChangeListener(vfChangeListener), mFolder(virtFolder), mDB(virtDB)
+  {}
+
+  NS_IMETHOD Run()
+  {
+    if (mVFChangeListener)
+      mVFChangeListener->ProcessUpdateEvent(mFolder, mDB);
+    return NS_OK;
+  }
+
+private:
+  RefPtr<VirtualFolderChangeListener> mVFChangeListener;
+  nsCOMPtr<nsIMsgFolder> mFolder;
+  nsCOMPtr<nsIMsgDatabase> mDB;
+};
+
+NS_IMPL_ISUPPORTS(VirtualFolderChangeListener, nsIDBChangeListener)
+
+VirtualFolderChangeListener::VirtualFolderChangeListener() :
+  m_searchOnMsgStatus(false), m_batchingEvents(false)
+{}
+
+nsresult VirtualFolderChangeListener::Init()
+{
+  nsCOMPtr <nsIMsgDatabase> msgDB;
+  nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+
+  nsresult rv = m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(msgDB));
+  if (NS_SUCCEEDED(rv) && msgDB)
+  {
+    nsCString searchTermString;
+    dbFolderInfo->GetCharProperty("searchStr", searchTermString);
+    nsCOMPtr<nsIMsgFilterService> filterService = do_GetService(NS_MSGFILTERSERVICE_CONTRACTID, &rv);
+    nsCOMPtr<nsIMsgFilterList> filterList;
+    rv = filterService->GetTempFilterList(m_virtualFolder, getter_AddRefs(filterList));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr <nsIMsgFilter> tempFilter;
+    filterList->CreateFilter(NS_LITERAL_STRING("temp"), getter_AddRefs(tempFilter));
+    NS_ENSURE_SUCCESS(rv, rv);
+    filterList->ParseCondition(tempFilter, searchTermString.get());
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_searchSession = do_CreateInstance(NS_MSGSEARCHSESSION_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsISupportsArray> searchTerms;
+    rv = tempFilter->GetSearchTerms(getter_AddRefs(searchTerms));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // we add the search scope right before we match the header,
+    // because we don't want the search scope caching the body input
+    // stream, because that holds onto the mailbox file, breaking
+    // compaction.
+
+    // add each item in termsArray to the search session
+    uint32_t numTerms;
+    searchTerms->Count(&numTerms);
+    for (uint32_t i = 0; i < numTerms; i++)
+    {
+      nsCOMPtr <nsIMsgSearchTerm> searchTerm (do_QueryElementAt(searchTerms, i));
+      nsMsgSearchAttribValue attrib;
+      searchTerm->GetAttrib(&attrib);
+      if (attrib == nsMsgSearchAttrib::MsgStatus)
+        m_searchOnMsgStatus = true;
+      m_searchSession->AppendTerm(searchTerm);
+    }
+  }
+  return rv;
+}
+
+  /**
+   * nsIDBChangeListener
+   */
+
+NS_IMETHODIMP
+VirtualFolderChangeListener::OnHdrPropertyChanged(nsIMsgDBHdr *aHdrChanged, bool aPreChange, uint32_t *aStatus,
+                                                 nsIDBChangeListener *aInstigator)
+{
+  const uint32_t kMatch = 0x1;
+  const uint32_t kRead = 0x2;
+  const uint32_t kNew = 0x4;
+  NS_ENSURE_ARG_POINTER(aHdrChanged);
+  NS_ENSURE_ARG_POINTER(aStatus);
+
+  uint32_t flags;
+  bool match;
+  nsCOMPtr<nsIMsgDatabase> msgDB;
+  nsresult rv = m_folderWatching->GetMsgDatabase(getter_AddRefs(msgDB));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // we don't want any early returns from this function, until we've
+  // called ClearScopes on the search session.
+  m_searchSession->AddScopeTerm(nsMsgSearchScope::offlineMail, m_folderWatching);
+  rv = m_searchSession->MatchHdr(aHdrChanged, msgDB, &match);
+  m_searchSession->ClearScopes();
+  NS_ENSURE_SUCCESS(rv, rv);
+  aHdrChanged->GetFlags(&flags);
+
+  if (aPreChange) // We're looking at the old header, save status
+  {
+    *aStatus = 0;
+    if (match)
+      *aStatus |= kMatch;
+    if (flags & nsMsgMessageFlags::Read)
+      *aStatus |= kRead;
+    if (flags & nsMsgMessageFlags::New)
+      *aStatus |= kNew;
+    return NS_OK;
+  }
+
+  // This is the post change section where changes are detected
+
+  bool wasMatch = *aStatus & kMatch;
+  if (!match && !wasMatch) // header not in virtual folder
+    return NS_OK;
+
+  int32_t totalDelta = 0, unreadDelta = 0, newDelta = 0;
+
+  if (match) {
+    totalDelta++;
+    if (!(flags & nsMsgMessageFlags::Read))
+      unreadDelta++;
+    if (flags & nsMsgMessageFlags::New)
+      newDelta++;
+  }
+
+  if (wasMatch) {
+    totalDelta--;
+    if (!(*aStatus & kRead)) unreadDelta--;
+    if (*aStatus & kNew) newDelta--;
+  }
+
+  if ( !(unreadDelta || totalDelta || newDelta) )
+    return NS_OK;
+
+  nsCOMPtr<nsIMsgDatabase> virtDatabase;
+  nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+  rv = m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo),
+                        getter_AddRefs(virtDatabase));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (unreadDelta)
+    dbFolderInfo->ChangeNumUnreadMessages(unreadDelta);
+
+  if (newDelta)
+  {
+    int32_t numNewMessages;
+    m_virtualFolder->GetNumNewMessages(false, &numNewMessages);
+    m_virtualFolder->SetNumNewMessages(numNewMessages + newDelta);
+    m_virtualFolder->SetHasNewMessages(numNewMessages + newDelta > 0);
+  }
+
+  if (totalDelta)
+  {
+    dbFolderInfo->ChangeNumMessages(totalDelta);
+    nsCString searchUri;
+    m_virtualFolder->GetURI(searchUri);
+    msgDB->UpdateHdrInCache(searchUri.get(), aHdrChanged, totalDelta == 1);
+  }
+
+    PostUpdateEvent(m_virtualFolder, virtDatabase);
+
+  return NS_OK;
+}
+
+void VirtualFolderChangeListener::DecrementNewMsgCount()
+{
+  int32_t numNewMessages;
+  m_virtualFolder->GetNumNewMessages(false, &numNewMessages);
+  if (numNewMessages > 0)
+    numNewMessages--;
+  m_virtualFolder->SetNumNewMessages(numNewMessages);
+  if (!numNewMessages)
+    m_virtualFolder->SetHasNewMessages(false);
+}
+
+NS_IMETHODIMP VirtualFolderChangeListener::OnHdrFlagsChanged(nsIMsgDBHdr *aHdrChanged, uint32_t aOldFlags, uint32_t aNewFlags, nsIDBChangeListener *aInstigator)
+{
+  nsCOMPtr <nsIMsgDatabase> msgDB;
+
+  nsresult rv = m_folderWatching->GetMsgDatabase(getter_AddRefs(msgDB));
+  bool oldMatch = false, newMatch = false;
+  // we don't want any early returns from this function, until we've
+  // called ClearScopes 0n the search session.
+  m_searchSession->AddScopeTerm(nsMsgSearchScope::offlineMail, m_folderWatching);
+  rv = m_searchSession->MatchHdr(aHdrChanged, msgDB, &newMatch);
+  if (NS_SUCCEEDED(rv) && m_searchOnMsgStatus)
+  {
+    // if status is a search criteria, check if the header matched before
+    // it changed, in order to determine if we need to bump the counts.
+    aHdrChanged->SetFlags(aOldFlags);
+    rv = m_searchSession->MatchHdr(aHdrChanged, msgDB, &oldMatch);
+    aHdrChanged->SetFlags(aNewFlags); // restore new flags even on match failure.
+  }
+  else
+    oldMatch = newMatch;
+  m_searchSession->ClearScopes();
+  NS_ENSURE_SUCCESS(rv, rv);
+  // we don't want to change the total counts if this virtual folder is open in a view,
+  // because we won't remove the header from view while it's open. On the other hand,
+  // it's hard to fix the count when the user clicks away to another folder, w/o re-running
+  // the search, or setting some sort of pending count change.
+  // Maybe this needs to be handled in the view code...the view could do the same calculation
+  // and also keep track of the counts changed. Then, when the view was closed, if it's a virtual
+  // folder, it could update the counts for the db.
+  if (oldMatch != newMatch || (oldMatch && (aOldFlags & nsMsgMessageFlags::Read) != (aNewFlags & nsMsgMessageFlags::Read)))
+  {
+    nsCOMPtr <nsIMsgDatabase> virtDatabase;
+    nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+
+    rv = m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(virtDatabase));
+    NS_ENSURE_SUCCESS(rv, rv);
+    int32_t totalDelta = 0,  unreadDelta = 0;
+    if (oldMatch != newMatch)
+    {
+ //     bool isOpen = false;
+//      nsCOMPtr <nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID);
+//      if (mailSession && aFolder)
+//        mailSession->IsFolderOpenInWindow(m_virtualFolder, &isOpen);
+      // we can't remove headers that no longer match - but we might add headers that newly match, someday.
+//      if (!isOpen)
+        totalDelta = (oldMatch) ? -1 : 1;
+    }
+    bool msgHdrIsRead;
+    aHdrChanged->GetIsRead(&msgHdrIsRead);
+    if (oldMatch == newMatch) // read flag changed state
+      unreadDelta = (msgHdrIsRead) ? -1 : 1;
+    else if (oldMatch) // else header should removed
+      unreadDelta = (aOldFlags & nsMsgMessageFlags::Read) ? 0 : -1;
+    else               // header should be added
+      unreadDelta = (aNewFlags & nsMsgMessageFlags::Read) ? 0 : 1;
+    if (unreadDelta)
+      dbFolderInfo->ChangeNumUnreadMessages(unreadDelta);
+    if (totalDelta)
+      dbFolderInfo->ChangeNumMessages(totalDelta);
+    if (unreadDelta == -1 && aOldFlags & nsMsgMessageFlags::New)
+      DecrementNewMsgCount();
+
+    if (totalDelta)
+    {
+      nsCString searchUri;
+      m_virtualFolder->GetURI(searchUri);
+      msgDB->UpdateHdrInCache(searchUri.get(), aHdrChanged, totalDelta == 1);
+    }
+
+    PostUpdateEvent(m_virtualFolder, virtDatabase);
+  }
+  else if (oldMatch && (aOldFlags & nsMsgMessageFlags::New) &&
+           !(aNewFlags & nsMsgMessageFlags::New))
+    DecrementNewMsgCount();
+
+  return rv;
+}
+
+NS_IMETHODIMP VirtualFolderChangeListener::OnHdrDeleted(nsIMsgDBHdr *aHdrDeleted, nsMsgKey aParentKey, int32_t aFlags, nsIDBChangeListener *aInstigator)
+{
+  nsCOMPtr <nsIMsgDatabase> msgDB;
+
+  nsresult rv = m_folderWatching->GetMsgDatabase(getter_AddRefs(msgDB));
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool match = false;
+  m_searchSession->AddScopeTerm(nsMsgSearchScope::offlineMail, m_folderWatching);
+  // Since the notifier went to the trouble of passing in the msg flags,
+  // we should use them when doing the match.
+  uint32_t msgFlags;
+  aHdrDeleted->GetFlags(&msgFlags);
+  aHdrDeleted->SetFlags(aFlags);
+  rv = m_searchSession->MatchHdr(aHdrDeleted, msgDB, &match);
+  aHdrDeleted->SetFlags(msgFlags);
+  m_searchSession->ClearScopes();
+  if (match)
+  {
+    nsCOMPtr <nsIMsgDatabase> virtDatabase;
+    nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+
+    rv = m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(virtDatabase));
+    NS_ENSURE_SUCCESS(rv, rv);
+    bool msgHdrIsRead;
+    aHdrDeleted->GetIsRead(&msgHdrIsRead);
+    if (!msgHdrIsRead)
+      dbFolderInfo->ChangeNumUnreadMessages(-1);
+    dbFolderInfo->ChangeNumMessages(-1);
+    if (aFlags & nsMsgMessageFlags::New)
+    {
+      int32_t numNewMessages;
+      m_virtualFolder->GetNumNewMessages(false, &numNewMessages);
+      m_virtualFolder->SetNumNewMessages(numNewMessages - 1);
+      if (numNewMessages == 1)
+        m_virtualFolder->SetHasNewMessages(false);
+    }
+
+    nsCString searchUri;
+    m_virtualFolder->GetURI(searchUri);
+    msgDB->UpdateHdrInCache(searchUri.get(), aHdrDeleted, false);
+
+    PostUpdateEvent(m_virtualFolder, virtDatabase);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP VirtualFolderChangeListener::OnHdrAdded(nsIMsgDBHdr *aNewHdr, nsMsgKey aParentKey, int32_t aFlags, nsIDBChangeListener *aInstigator)
+{
+  nsCOMPtr<nsIMsgDatabase> msgDB;
+
+  nsresult rv = m_folderWatching->GetMsgDatabase(getter_AddRefs(msgDB));
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool match = false;
+  if (!m_searchSession)
+    return NS_ERROR_NULL_POINTER;
+
+  m_searchSession->AddScopeTerm(nsMsgSearchScope::offlineMail, m_folderWatching);
+  rv = m_searchSession->MatchHdr(aNewHdr, msgDB, &match);
+  m_searchSession->ClearScopes();
+  if (match)
+  {
+    nsCOMPtr <nsIMsgDatabase> virtDatabase;
+    nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+
+    rv = m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(virtDatabase));
+    NS_ENSURE_SUCCESS(rv, rv);
+    bool msgHdrIsRead;
+    uint32_t msgFlags;
+    aNewHdr->GetIsRead(&msgHdrIsRead);
+    aNewHdr->GetFlags(&msgFlags);
+    if (!msgHdrIsRead)
+      dbFolderInfo->ChangeNumUnreadMessages(1);
+    if (msgFlags & nsMsgMessageFlags::New)
+    {
+      int32_t numNewMessages;
+      m_virtualFolder->GetNumNewMessages(false, &numNewMessages);
+      m_virtualFolder->SetHasNewMessages(true);
+      m_virtualFolder->SetNumNewMessages(numNewMessages + 1);
+    }
+    nsCString searchUri;
+    m_virtualFolder->GetURI(searchUri);
+    msgDB->UpdateHdrInCache(searchUri.get(), aNewHdr, true);
+    dbFolderInfo->ChangeNumMessages(1);
+    PostUpdateEvent(m_virtualFolder, virtDatabase);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP VirtualFolderChangeListener::OnParentChanged(nsMsgKey aKeyChanged, nsMsgKey oldParent, nsMsgKey newParent, nsIDBChangeListener *aInstigator)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP VirtualFolderChangeListener::OnAnnouncerGoingAway(nsIDBChangeAnnouncer *instigator)
+{
+  nsCOMPtr <nsIMsgDatabase> msgDB = do_QueryInterface(instigator);
+  if (msgDB)
+    msgDB->RemoveListener(this);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+VirtualFolderChangeListener::OnEvent(nsIMsgDatabase *aDB, const char *aEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP VirtualFolderChangeListener::OnReadChanged(nsIDBChangeListener *aInstigator)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP VirtualFolderChangeListener::OnJunkScoreChanged(nsIDBChangeListener *aInstigator)
+{
+  return NS_OK;
+}
+
+nsresult VirtualFolderChangeListener::PostUpdateEvent(nsIMsgFolder *virtualFolder,
+                                                  nsIMsgDatabase *virtDatabase)
+{
+  if (m_batchingEvents)
+    return NS_OK;
+  m_batchingEvents = true;
+  nsCOMPtr<nsIRunnable> event = new VFChangeListenerEvent(this, virtualFolder,
+                                                          virtDatabase);
+  return NS_DispatchToCurrentThread(event);
+}
+
+void VirtualFolderChangeListener::ProcessUpdateEvent(nsIMsgFolder *virtFolder,
+                                                     nsIMsgDatabase *virtDB)
+{
+  m_batchingEvents = false;
+  virtFolder->UpdateSummaryTotals(true); // force update from db.
+  virtDB->Commit(nsMsgDBCommitType::kLargeCommit);
+}
+
+nsresult nsMsgAccountManager::GetVirtualFoldersFile(nsCOMPtr<nsIFile>& file)
+{
+  nsCOMPtr<nsIFile> profileDir;
+  nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(profileDir));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = profileDir->AppendNative(nsDependentCString("virtualFolders.dat"));
+  if (NS_SUCCEEDED(rv))
+    file = do_QueryInterface(profileDir, &rv);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::LoadVirtualFolders()
+{
+  nsCOMPtr <nsIFile> file;
+  GetVirtualFoldersFile(file);
+  if (!file)
+    return NS_ERROR_FAILURE;
+
+  if (m_virtualFoldersLoaded)
+    return NS_OK;
+
+  m_loadingVirtualFolders = true;
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgDBService> msgDBService = do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+  if (msgDBService)
+  {
+     NS_ENSURE_SUCCESS(rv, rv);
+     nsCOMPtr<nsIFileInputStream> fileStream = do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv);
+     NS_ENSURE_SUCCESS(rv, rv);
+
+     rv = fileStream->Init(file,  PR_RDONLY, 0664, false);
+     nsCOMPtr <nsILineInputStream> lineInputStream(do_QueryInterface(fileStream));
+
+    bool isMore = true;
+    nsAutoCString buffer;
+    int32_t version = -1;
+    nsCOMPtr <nsIMsgFolder> virtualFolder;
+    nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+    nsCOMPtr<nsIRDFResource> resource;
+    nsCOMPtr<nsIRDFService> rdf(do_GetService("@mozilla.org/rdf/rdf-service;1", &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIArray> allFolders;
+
+    while (isMore &&
+           NS_SUCCEEDED(lineInputStream->ReadLine(buffer, &isMore)))
+    {
+      if (!buffer.IsEmpty())
+      {
+        if (version == -1)
+        {
+          buffer.Cut(0, 8);
+          nsresult irv;
+          version = buffer.ToInteger(&irv);
+          continue;
+        }
+        if (Substring(buffer, 0, 4).Equals("uri="))
+        {
+          buffer.Cut(0, 4);
+          dbFolderInfo = nullptr;
+
+          rv = rdf->GetResource(buffer, getter_AddRefs(resource));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          virtualFolder = do_QueryInterface(resource);
+          if (!virtualFolder)
+            NS_WARNING("Failed to QI virtual folder, is this leftover from an optional account type?");
+          else
+          {
+            nsCOMPtr <nsIMsgFolder> grandParent;
+            nsCOMPtr <nsIMsgFolder> oldParent;
+            nsCOMPtr <nsIMsgFolder> parentFolder;
+            bool isServer;
+            do
+            {
+              // need to add the folder as a sub-folder of its parent.
+              int32_t lastSlash = buffer.RFindChar('/');
+              if (lastSlash == kNotFound)
+                break;
+              nsDependentCSubstring parentUri(buffer, 0, lastSlash);
+              // hold a reference so it won't get deleted before it's parented.
+              oldParent = parentFolder;
+
+              rdf->GetResource(parentUri, getter_AddRefs(resource));
+              parentFolder = do_QueryInterface(resource);
+              if (parentFolder)
+              {
+                nsAutoString currentFolderNameStr;
+                nsAutoCString currentFolderNameCStr;
+                MsgUnescapeString(nsCString(Substring(buffer, lastSlash + 1, buffer.Length())), 0, currentFolderNameCStr);
+                CopyUTF8toUTF16(currentFolderNameCStr, currentFolderNameStr);
+                nsCOMPtr <nsIMsgFolder> childFolder;
+                nsCOMPtr <nsIMsgDatabase> db;
+                // force db to get created.
+                virtualFolder->SetParent(parentFolder);
+                rv = virtualFolder->GetMsgDatabase(getter_AddRefs(db));
+                if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING)
+                  msgDBService->CreateNewDB(virtualFolder, getter_AddRefs(db));
+                if (db)
+                  rv = db->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+                else
+                  break;
+
+                parentFolder->AddSubfolder(currentFolderNameStr, getter_AddRefs(childFolder));
+                virtualFolder->SetFlag(nsMsgFolderFlags::Virtual);
+                if (childFolder)
+                  parentFolder->NotifyItemAdded(childFolder);
+                // here we make sure if our parent is rooted - if not, we're
+                // going to loop and add our parent as a child of its grandparent
+                // and repeat until we get to the server, or a folder that
+                // has its parent set.
+                parentFolder->GetParent(getter_AddRefs(grandParent));
+                parentFolder->GetIsServer(&isServer);
+                buffer.SetLength(lastSlash);
+              }
+              else
+                break;
+            } while (!grandParent && !isServer);
+          }
+        }
+        else if (dbFolderInfo && Substring(buffer, 0, 6).Equals("scope="))
+        {
+          buffer.Cut(0, 6);
+          // if this is a cross folder virtual folder, we have a list of folders uris,
+          // and we have to add a pending listener for each of them.
+          if (!buffer.IsEmpty())
+          {
+            ParseAndVerifyVirtualFolderScope(buffer, rdf);
+            dbFolderInfo->SetCharProperty(kSearchFolderUriProp, buffer);
+            AddVFListenersForVF(virtualFolder, buffer, rdf, msgDBService);
+          }
+        }
+        else if (dbFolderInfo && Substring(buffer, 0, 6).Equals("terms="))
+        {
+          buffer.Cut(0, 6);
+          dbFolderInfo->SetCharProperty("searchStr", buffer);
+        }
+        else if (dbFolderInfo && Substring(buffer, 0, 13).Equals("searchOnline="))
+        {
+          buffer.Cut(0, 13);
+          dbFolderInfo->SetBooleanProperty("searchOnline", buffer.Equals("true"));
+        }
+        else if (dbFolderInfo &&
+                 Substring(buffer, 0, SEARCH_FOLDER_FLAG_LEN + 1)
+                   .Equals(SEARCH_FOLDER_FLAG"="))
+        {
+          buffer.Cut(0, SEARCH_FOLDER_FLAG_LEN + 1);
+          dbFolderInfo->SetCharProperty(SEARCH_FOLDER_FLAG, buffer);
+        }
+      }
+    }
+  }
+
+  m_loadingVirtualFolders = false;
+  m_virtualFoldersLoaded = true;
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::SaveVirtualFolders()
+{
+  if (!m_virtualFoldersLoaded)
+    return NS_OK;
+
+  nsCOMPtr<nsIFile> file;
+  GetVirtualFoldersFile(file);
+
+  // Open a buffered, safe output stream
+  nsCOMPtr<nsIOutputStream> outStream;
+  nsresult rv = MsgNewSafeBufferedFileOutputStream(getter_AddRefs(outStream),
+                                                   file,
+                                                   PR_CREATE_FILE | PR_WRONLY | PR_TRUNCATE,
+                                                   0664);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  WriteLineToOutputStream("version=", "1", outStream);
+  for (auto iter = m_incomingServers.Iter(); !iter.Done(); iter.Next()) {
+    nsCOMPtr<nsIMsgIncomingServer>& server = iter.Data();
+    if (server)
+    {
+      nsCOMPtr <nsIMsgFolder> rootFolder;
+      server->GetRootFolder(getter_AddRefs(rootFolder));
+      if (rootFolder)
+      {
+        nsCOMPtr <nsIArray> virtualFolders;
+        nsresult rv = rootFolder->GetFoldersWithFlags(nsMsgFolderFlags::Virtual,
+                                             getter_AddRefs(virtualFolders));
+        if (NS_FAILED(rv)) {
+          continue;
+        }
+        uint32_t vfCount;
+        virtualFolders->GetLength(&vfCount);
+        for (uint32_t folderIndex = 0; folderIndex < vfCount; folderIndex++)
+        {
+          nsCOMPtr <nsIRDFResource> folderRes (do_QueryElementAt(virtualFolders, folderIndex));
+          nsCOMPtr <nsIMsgFolder> msgFolder = do_QueryInterface(folderRes);
+          const char *uri;
+          nsCOMPtr <nsIMsgDatabase> db;
+          nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+          rv = msgFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(db)); // force db to get created.
+          if (dbFolderInfo)
+          {
+            nsCString srchFolderUri;
+            nsCString searchTerms;
+            nsCString regexScope;
+            nsCString vfFolderFlag;
+            bool searchOnline = false;
+            dbFolderInfo->GetBooleanProperty("searchOnline", false, &searchOnline);
+            dbFolderInfo->GetCharProperty(kSearchFolderUriProp, srchFolderUri);
+            dbFolderInfo->GetCharProperty("searchStr", searchTerms);
+            // logically searchFolderFlag is an int, but since we want to
+            // write out a string, get it as a string.
+            dbFolderInfo->GetCharProperty(SEARCH_FOLDER_FLAG, vfFolderFlag);
+            folderRes->GetValueConst(&uri);
+            if (!srchFolderUri.IsEmpty() && !searchTerms.IsEmpty())
+            {
+              WriteLineToOutputStream("uri=", uri, outStream);
+              if (!vfFolderFlag.IsEmpty())
+                WriteLineToOutputStream(SEARCH_FOLDER_FLAG"=", vfFolderFlag.get(), outStream);
+              WriteLineToOutputStream("scope=", srchFolderUri.get(), outStream);
+              WriteLineToOutputStream("terms=", searchTerms.get(), outStream);
+              WriteLineToOutputStream("searchOnline=", searchOnline ? "true" : "false", outStream);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  nsCOMPtr<nsISafeOutputStream> safeStream = do_QueryInterface(outStream, &rv);
+  NS_ASSERTION(safeStream, "expected a safe output stream!");
+  if (safeStream) {
+    rv = safeStream->Finish();
+    if (NS_FAILED(rv)) {
+      NS_WARNING("failed to save personal dictionary file! possible data loss");
+    }
+  }
+  return rv;
+}
+
+nsresult nsMsgAccountManager::WriteLineToOutputStream(const char *prefix, const char * line, nsIOutputStream *outputStream)
+{
+  uint32_t writeCount;
+  outputStream->Write(prefix, strlen(prefix), &writeCount);
+  outputStream->Write(line, strlen(line), &writeCount);
+  outputStream->Write("\n", 1, &writeCount);
+  return NS_OK;
+}
+
+/**
+ * Parse the '|' separated folder uri string into individual folders, verify
+ * that the folders are real. If we were to add things like wildcards, we
+ * could implement the expansion into real folders here.
+ *
+ * @param buffer On input, list of folder uri's, on output, verified list.
+ * @param rdf rdf service
+ */
+void nsMsgAccountManager::ParseAndVerifyVirtualFolderScope(nsCString &buffer,
+                                                           nsIRDFService *rdf)
+{
+  nsCString verifiedFolders;
+  nsTArray<nsCString> folderUris;
+  ParseString(buffer, '|', folderUris);
+  nsCOMPtr <nsIRDFResource> resource;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsCOMPtr<nsIMsgFolder> parent;
+
+  for (uint32_t i = 0; i < folderUris.Length(); i++)
+  {
+    rdf->GetResource(folderUris[i], getter_AddRefs(resource));
+    nsCOMPtr <nsIMsgFolder> realFolder = do_QueryInterface(resource);
+    if (!realFolder)
+      continue;
+    realFolder->GetParent(getter_AddRefs(parent));
+    if (!parent)
+      continue;
+    realFolder->GetServer(getter_AddRefs(server));
+    if (!server)
+      continue;
+    if (!verifiedFolders.IsEmpty())
+      verifiedFolders.Append('|');
+    verifiedFolders.Append(folderUris[i]);
+  }
+  buffer.Assign(verifiedFolders);
+}
+
+// This conveniently works to add a single folder as well.
+nsresult nsMsgAccountManager::AddVFListenersForVF(nsIMsgFolder *virtualFolder,
+                                                  const nsCString& srchFolderUris,
+                                                  nsIRDFService *rdf,
+                                                  nsIMsgDBService *msgDBService)
+{
+  nsTArray<nsCString> folderUris;
+  ParseString(srchFolderUris, '|', folderUris);
+  nsCOMPtr <nsIRDFResource> resource;
+
+  for (uint32_t i = 0; i < folderUris.Length(); i++)
+  {
+    rdf->GetResource(folderUris[i], getter_AddRefs(resource));
+    nsCOMPtr <nsIMsgFolder> realFolder = do_QueryInterface(resource);
+    if (!realFolder)
+      continue;
+    RefPtr<VirtualFolderChangeListener> dbListener = new VirtualFolderChangeListener();
+    NS_ENSURE_TRUE(dbListener, NS_ERROR_OUT_OF_MEMORY);
+    dbListener->m_virtualFolder = virtualFolder;
+    dbListener->m_folderWatching = realFolder;
+    if (NS_FAILED(dbListener->Init()))
+    {
+      dbListener = nullptr;
+      continue;
+    }
+    m_virtualFolderListeners.AppendElement(dbListener);
+    msgDBService->RegisterPendingListener(realFolder, dbListener);
+  }
+  return NS_OK;
+}
+
+// This is called if a folder that's part of the scope of a saved search
+// has gone away.
+nsresult nsMsgAccountManager::RemoveVFListenerForVF(nsIMsgFolder *virtualFolder,
+                                                    nsIMsgFolder *folder)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgDBService> msgDBService(do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTObserverArray<RefPtr<VirtualFolderChangeListener> >::ForwardIterator iter(m_virtualFolderListeners);
+  RefPtr<VirtualFolderChangeListener> listener;
+
+  while (iter.HasMore())
+  {
+    listener = iter.GetNext();
+    if (listener->m_folderWatching == folder &&
+        listener->m_virtualFolder == virtualFolder)
+    {
+      msgDBService->UnregisterPendingListener(listener);
+      m_virtualFolderListeners.RemoveElement(listener);
+      break;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::GetAllFolders(nsIArray **aAllFolders)
+{
+  NS_ENSURE_ARG_POINTER(aAllFolders);
+
+  nsCOMPtr<nsIArray> servers;
+  nsresult rv = GetAllServers(getter_AddRefs(servers));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t numServers = 0;
+  rv = servers->GetLength(&numServers);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMutableArray> allFolders(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t i;
+  for (i = 0; i < numServers; i++)
+  {
+    nsCOMPtr<nsIMsgIncomingServer> server = do_QueryElementAt(servers, i);
+    if (server)
+    {
+      nsCOMPtr<nsIMsgFolder> rootFolder;
+      server->GetRootFolder(getter_AddRefs(rootFolder));
+      if (rootFolder)
+        rootFolder->ListDescendants(allFolders);
+    }
+  }
+
+  allFolders.forget(aAllFolders);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::OnItemAdded(nsIMsgFolder *parentItem, nsISupports *item)
+{
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(item);
+  // just kick out with a success code if the item in question is not a folder
+  if (!folder)
+    return NS_OK;
+
+  uint32_t folderFlags;
+  folder->GetFlags(&folderFlags);
+  bool addToSmartFolders = false;
+  folder->IsSpecialFolder(nsMsgFolderFlags::Inbox |
+                          nsMsgFolderFlags::Templates |
+                          nsMsgFolderFlags::Trash |
+                          nsMsgFolderFlags::Drafts, false,
+                          &addToSmartFolders);
+  // For Sent/Archives/Trash, we treat sub-folders of those folders as
+  // "special", and want to add them the smart folders search scope.
+  // So we check if this is a sub-folder of one of those special folders
+  // and set the corresponding folderFlag if so.
+  if (!addToSmartFolders)
+  {
+    bool isSpecial = false;
+    folder->IsSpecialFolder(nsMsgFolderFlags::SentMail, true, &isSpecial);
+    if (isSpecial)
+    {
+      addToSmartFolders = true;
+      folderFlags |= nsMsgFolderFlags::SentMail;
+    }
+    folder->IsSpecialFolder(nsMsgFolderFlags::Archive, true, &isSpecial);
+    if (isSpecial)
+    {
+      addToSmartFolders = true;
+      folderFlags |= nsMsgFolderFlags::Archive;
+    }
+    folder->IsSpecialFolder(nsMsgFolderFlags::Trash, true, &isSpecial);
+    if (isSpecial)
+    {
+      addToSmartFolders = true;
+      folderFlags |= nsMsgFolderFlags::Trash;
+    }
+  }
+  nsresult rv = NS_OK;
+  // if this is a special folder, check if we have a saved search over
+  // folders with this flag, and if so, add this folder to the scope.
+  if (addToSmartFolders)
+  {
+    // quick way to enumerate the saved searches.
+    nsTObserverArray<RefPtr<VirtualFolderChangeListener> >::ForwardIterator iter(m_virtualFolderListeners);
+    RefPtr<VirtualFolderChangeListener> listener;
+
+    while (iter.HasMore())
+    {
+      listener = iter.GetNext();
+      nsCOMPtr <nsIMsgDatabase> db;
+      nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+      listener->m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo),
+                                                      getter_AddRefs(db));
+      if (dbFolderInfo)
+      {
+        uint32_t vfFolderFlag;
+        dbFolderInfo->GetUint32Property("searchFolderFlag", 0, & vfFolderFlag);
+        // found a saved search over folders w/ the same flag as the new folder.
+        if (vfFolderFlag & folderFlags)
+        {
+          nsCString searchURI;
+          dbFolderInfo->GetCharProperty(kSearchFolderUriProp, searchURI);
+
+          // "normalize" searchURI so we can search for |folderURI|.
+          if (!searchURI.IsEmpty())
+          {
+            searchURI.Insert('|', 0);
+            searchURI.Append('|');
+          }
+          nsCString folderURI;
+          folder->GetURI(folderURI);
+
+          int32_t index = searchURI.Find(folderURI);
+          if (index == kNotFound)
+          {
+            searchURI.Cut(0, 1);
+            searchURI.Append(folderURI);
+            dbFolderInfo->SetCharProperty(kSearchFolderUriProp, searchURI);
+            break;
+          }
+          // New sent or archive folder, need to add sub-folders to smart folder.
+          if (vfFolderFlag & (nsMsgFolderFlags::Archive | nsMsgFolderFlags::SentMail))
+          {
+            nsCOMPtr<nsIArray> allDescendants;
+            rv = folder->GetDescendants(getter_AddRefs(allDescendants));
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            uint32_t cnt = 0;
+            rv = allDescendants->GetLength(&cnt);
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            nsCOMPtr<nsIMsgFolder> parent;
+            for (uint32_t j = 0; j < cnt; j++)
+            {
+              nsCOMPtr<nsIMsgFolder> subFolder = do_QueryElementAt(allDescendants, j);
+              if (subFolder)
+              {
+                subFolder->GetParent(getter_AddRefs(parent));
+                OnItemAdded(parent, subFolder);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  // need to make sure this isn't happening during loading of virtualfolders.dat
+  if (folderFlags & nsMsgFolderFlags::Virtual && !m_loadingVirtualFolders)
+  {
+    // When a new virtual folder is added, need to create a db Listener for it.
+    nsCOMPtr<nsIMsgDBService> msgDBService = do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+    if (msgDBService)
+    {
+      nsCOMPtr <nsIMsgDatabase> virtDatabase;
+      nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+      rv = folder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(virtDatabase));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCString srchFolderUri;
+      dbFolderInfo->GetCharProperty(kSearchFolderUriProp, srchFolderUri);
+      nsCOMPtr<nsIRDFService> rdf(do_GetService("@mozilla.org/rdf/rdf-service;1", &rv));
+      AddVFListenersForVF(folder, srchFolderUri, rdf, msgDBService);
+    }
+    rv = SaveVirtualFolders();
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::OnItemRemoved(nsIMsgFolder *parentItem, nsISupports *item)
+{
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(item);
+  // just kick out with a success code if the item in question is not a folder
+  if (!folder)
+    return NS_OK;
+  nsresult rv = NS_OK;
+  uint32_t folderFlags;
+  folder->GetFlags(&folderFlags);
+  if (folderFlags & nsMsgFolderFlags::Virtual) // if we removed a VF, flush VF list to disk.
+  {
+    rv = SaveVirtualFolders();
+    // clear flags on deleted folder if it's a virtual folder, so that creating a new folder
+    // with the same name doesn't cause confusion.
+    folder->SetFlags(0);
+    return rv;
+  }
+  // need to update the saved searches to check for a few things:
+  // 1. Folder removed was in the scope of a saved search - if so, remove the
+  //    uri from the scope of the saved search.
+  // 2. If the scope is now empty, remove the saved search.
+
+  // build a "normalized" uri that we can do a find on.
+  nsCString removedFolderURI;
+  folder->GetURI(removedFolderURI);
+  removedFolderURI.Insert('|', 0);
+  removedFolderURI.Append('|');
+
+  // Enumerate the saved searches.
+  nsTObserverArray<RefPtr<VirtualFolderChangeListener> >::ForwardIterator iter(m_virtualFolderListeners);
+  RefPtr<VirtualFolderChangeListener> listener;
+
+  while (iter.HasMore())
+  {
+    listener = iter.GetNext();
+    nsCOMPtr<nsIMsgDatabase> db;
+    nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+    nsCOMPtr<nsIMsgFolder> savedSearch = listener->m_virtualFolder;
+    savedSearch->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo),
+                                      getter_AddRefs(db));
+    if (dbFolderInfo)
+    {
+      nsCString searchURI;
+      dbFolderInfo->GetCharProperty(kSearchFolderUriProp, searchURI);
+      // "normalize" searchURI so we can search for |folderURI|.
+      searchURI.Insert('|', 0);
+      searchURI.Append('|');
+      int32_t index = searchURI.Find(removedFolderURI);
+      if (index != kNotFound)
+      {
+        RemoveVFListenerForVF(savedSearch, folder);
+
+        // remove |folderURI
+        searchURI.Cut(index, removedFolderURI.Length() - 1);
+        // remove last '|' we added
+        searchURI.SetLength(searchURI.Length() - 1);
+
+        // if saved search is empty now, delete it.
+        if (searchURI.IsEmpty())
+        {
+          db = nullptr;
+          dbFolderInfo = nullptr;
+
+          nsCOMPtr<nsIMsgFolder> parent;
+          rv = savedSearch->GetParent(getter_AddRefs(parent));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          if (!parent)
+            continue;
+          parent->PropagateDelete(savedSearch, true, nullptr);
+        }
+        else
+        {
+        // remove leading '|' we added (or one after |folderURI, if first URI)
+          searchURI.Cut(0, 1);
+          dbFolderInfo->SetCharProperty(kSearchFolderUriProp, searchURI);
+        }
+      }
+    }
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::OnItemPropertyChanged(nsIMsgFolder *item, nsIAtom *property, const char *oldValue, const char *newValue)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::OnItemIntPropertyChanged(nsIMsgFolder *aFolder,
+                                              nsIAtom *aProperty,
+                                              int64_t oldValue,
+                                              int64_t newValue)
+{
+  if (aProperty == mFolderFlagAtom)
+  {
+    uint32_t smartFlagsChanged = (oldValue ^ newValue) &
+      (nsMsgFolderFlags::SpecialUse & ~nsMsgFolderFlags::Queue);
+    if (smartFlagsChanged)
+    {
+      if (smartFlagsChanged & newValue)
+      {
+        // if the smart folder flag was set, calling OnItemAdded will
+        // do the right thing.
+        nsCOMPtr<nsIMsgFolder> parent;
+        aFolder->GetParent(getter_AddRefs(parent));
+        return OnItemAdded(parent, aFolder);
+      }
+      RemoveFolderFromSmartFolder(aFolder, smartFlagsChanged);
+      // sent|archive flag removed, remove sub-folders from smart folder.
+      if (smartFlagsChanged & (nsMsgFolderFlags::Archive | nsMsgFolderFlags::SentMail))
+      {
+        nsCOMPtr<nsIArray> allDescendants;
+        nsresult rv = aFolder->GetDescendants(getter_AddRefs(allDescendants));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        uint32_t cnt = 0;
+        rv = allDescendants->GetLength(&cnt);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        nsCOMPtr<nsIMsgFolder> parent;
+        for (uint32_t j = 0; j < cnt; j++)
+        {
+          nsCOMPtr<nsIMsgFolder> subFolder = do_QueryElementAt(allDescendants, j);
+          if (subFolder)
+            RemoveFolderFromSmartFolder(subFolder, smartFlagsChanged);
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManager::RemoveFolderFromSmartFolder(nsIMsgFolder *aFolder,
+                                                 uint32_t flagsChanged)
+{
+  nsCString removedFolderURI;
+  aFolder->GetURI(removedFolderURI);
+  removedFolderURI.Insert('|', 0);
+  removedFolderURI.Append('|');
+  uint32_t flags;
+  aFolder->GetFlags(&flags);
+  NS_ASSERTION(!(flags & flagsChanged), "smart folder flag should not be set");
+  // Flag was removed. Look for smart folder based on that flag,
+  // and remove this folder from its scope.
+  nsTObserverArray<RefPtr<VirtualFolderChangeListener> >::ForwardIterator iter(m_virtualFolderListeners);
+  RefPtr<VirtualFolderChangeListener> listener;
+
+  while (iter.HasMore())
+  {
+    listener = iter.GetNext();
+    nsCOMPtr <nsIMsgDatabase> db;
+    nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+    listener->m_virtualFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo),
+                                                    getter_AddRefs(db));
+    if (dbFolderInfo)
+    {
+      uint32_t vfFolderFlag;
+      dbFolderInfo->GetUint32Property("searchFolderFlag", 0, & vfFolderFlag);
+      // found a smart folder over the removed flag
+      if (vfFolderFlag & flagsChanged)
+      {
+        nsCString searchURI;
+        dbFolderInfo->GetCharProperty(kSearchFolderUriProp, searchURI);
+        // "normalize" searchURI so we can search for |folderURI|.
+        searchURI.Insert('|', 0);
+        searchURI.Append('|');
+        int32_t index = searchURI.Find(removedFolderURI);
+        if (index != kNotFound)
+        {
+          RemoveVFListenerForVF(listener->m_virtualFolder, aFolder);
+
+          // remove |folderURI
+          searchURI.Cut(index, removedFolderURI.Length() - 1);
+          // remove last '|' we added
+          searchURI.SetLength(searchURI.Length() - 1);
+
+          // remove leading '|' we added (or one after |folderURI, if first URI)
+          searchURI.Cut(0, 1);
+          dbFolderInfo->SetCharProperty(kSearchFolderUriProp, searchURI);
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::OnItemBoolPropertyChanged(nsIMsgFolder *item, nsIAtom *property, bool oldValue, bool newValue)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::OnItemUnicharPropertyChanged(nsIMsgFolder *item, nsIAtom *property, const char16_t *oldValue, const char16_t *newValue)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP nsMsgAccountManager::OnItemPropertyFlagChanged(nsIMsgDBHdr *item, nsIAtom *property, uint32_t oldFlag, uint32_t newFlag)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgAccountManager::OnItemEvent(nsIMsgFolder *aFolder, nsIAtom *aEvent)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::FolderUriForPath(nsIFile *aLocalPath,
+                                               nsACString &aMailboxUri)
+{
+  NS_ENSURE_ARG_POINTER(aLocalPath);
+  bool equals;
+  if (m_lastPathLookedUp &&
+      NS_SUCCEEDED(aLocalPath->Equals(m_lastPathLookedUp, &equals)) && equals)
+  {
+    aMailboxUri = m_lastFolderURIForPath;
+    return NS_OK;
+  }
+  nsCOMPtr<nsIArray> folderArray;
+  nsresult rv = GetAllFolders(getter_AddRefs(folderArray));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t count;
+  rv = folderArray->GetLength(&count);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (uint32_t i = 0; i < count; i++)
+  {
+    nsCOMPtr<nsIMsgFolder> folder(do_QueryElementAt(folderArray, i, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIFile> folderPath;
+    rv = folder->GetFilePath(getter_AddRefs(folderPath));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Check if we're equal
+    rv = folderPath->Equals(aLocalPath, &equals);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (equals)
+    {
+      rv = folder->GetURI(aMailboxUri);
+      m_lastFolderURIForPath = aMailboxUri;
+      aLocalPath->Clone(getter_AddRefs(m_lastPathLookedUp));
+      return rv;
+    }
+  }
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManager::GetSortOrder(nsIMsgIncomingServer* aServer, int32_t* aSortOrder)
+{
+  NS_ENSURE_ARG_POINTER(aServer);
+  NS_ENSURE_ARG_POINTER(aSortOrder);
+
+  // If the passed in server is the default, return its sort order as 0 regardless
+  // of its server sort order.
+
+  nsCOMPtr<nsIMsgAccount> defaultAccount;
+  nsresult rv = GetDefaultAccount(getter_AddRefs(defaultAccount));
+  if (NS_SUCCEEDED(rv) && defaultAccount) {
+    nsCOMPtr<nsIMsgIncomingServer> defaultServer;
+    rv = m_defaultAccount->GetIncomingServer(getter_AddRefs(defaultServer));
+    if (NS_SUCCEEDED(rv) && defaultServer && (aServer == defaultServer)) {
+      *aSortOrder = 0;
+      return NS_OK;
+    }
+    // It is OK if there is no default account.
+  }
+
+  // This function returns the sort order by querying the server object for its
+  // sort order value and then incrementing it by the position of the server in
+  // the accounts list. This ensures that even when several accounts have the
+  // same sort order value, the returned value is not the same and keeps
+  // their relative order in the account list when and unstable sort is run
+  // on the returned sort order values.
+  int32_t sortOrder;
+  int32_t serverIndex;
+
+  rv = aServer->GetSortOrder(&sortOrder);
+  if (NS_SUCCEEDED(rv))
+    rv = FindServerIndex(aServer, &serverIndex);
+
+  if (NS_FAILED(rv)) {
+    *aSortOrder = 999999999;
+  } else {
+    *aSortOrder = sortOrder + serverIndex;
+  }
+
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMsgAccountManager.h b/mailnews/base/src/nsMsgAccountManager.h
new file mode 100644
index 000000000..d5a116e57
--- /dev/null
+++ b/mailnews/base/src/nsMsgAccountManager.h
@@ -0,0 +1,216 @@
+/* -*- 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/.
+ * This Original Code has been modified by IBM Corporation. Modifications made by IBM 
+ * described herein are Copyright (c) International Business Machines Corporation, 2000.
+ * Modifications to Mozilla code or documentation identified per MPL Section 3.3
+ *
+ * Date             Modified by     Description of modification
+ * 04/20/2000       IBM Corp.      OS/2 VisualAge build.
+ */
+
+#include "nscore.h"
+#include "nsIMsgAccountManager.h"
+#include "nsCOMPtr.h"
+#include "nsISmtpServer.h"
+#include "nsIPrefBranch.h"
+#include "nsIMsgFolderCache.h"
+#include "nsIMsgFolder.h"
+#include "nsIObserver.h"
+#include "nsWeakReference.h"
+#include "nsIUrlListener.h"
+#include "nsCOMArray.h"
+#include "nsIMsgSearchSession.h"
+#include "nsInterfaceHashtable.h"
+#include "nsIMsgDatabase.h"
+#include "nsIDBChangeListener.h"
+#include "nsAutoPtr.h"
+#include "nsTObserverArray.h"
+
+class nsIRDFService;
+
+class VirtualFolderChangeListener final : public nsIDBChangeListener
+{
+public:
+  VirtualFolderChangeListener();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIDBCHANGELISTENER
+
+  nsresult Init();
+  /**
+   * Posts an event to update the summary totals and commit the db.
+   * We post the event to avoid committing each time we're called
+   * in a synchronous loop.
+   */
+  nsresult PostUpdateEvent(nsIMsgFolder *folder, nsIMsgDatabase *db);
+  /// Handles event posted to event queue to batch notifications.
+  void ProcessUpdateEvent(nsIMsgFolder *folder, nsIMsgDatabase *db);
+
+  void DecrementNewMsgCount();
+
+  nsCOMPtr <nsIMsgFolder> m_virtualFolder; // folder we're listening to db changes on behalf of.
+  nsCOMPtr <nsIMsgFolder> m_folderWatching; // folder whose db we're listening to.
+  nsCOMPtr <nsIMsgSearchSession> m_searchSession;
+  bool m_searchOnMsgStatus;
+  bool m_batchingEvents;
+
+private:
+  ~VirtualFolderChangeListener() {}
+};
+
+
+class nsMsgAccountManager: public nsIMsgAccountManager,
+    public nsIObserver,
+    public nsSupportsWeakReference,
+    public nsIUrlListener,
+    public nsIFolderListener
+{
+public:
+
+  nsMsgAccountManager();
+  
+  NS_DECL_THREADSAFE_ISUPPORTS
+ 
+  /* nsIMsgAccountManager methods */
+  
+  NS_DECL_NSIMSGACCOUNTMANAGER
+  NS_DECL_NSIOBSERVER  
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSIFOLDERLISTENER
+
+  nsresult Init();
+  nsresult Shutdown();
+  void LogoutOfServer(nsIMsgIncomingServer *aServer);
+
+private:
+  virtual ~nsMsgAccountManager();
+
+  bool m_accountsLoaded;
+  nsCOMPtr <nsIMsgFolderCache> m_msgFolderCache;
+  nsCOMPtr<nsIAtom> kDefaultServerAtom;
+  nsCOMPtr<nsIAtom> mFolderFlagAtom;
+  nsTArray<nsCOMPtr<nsIMsgAccount> > m_accounts;
+  nsInterfaceHashtable<nsCStringHashKey, nsIMsgIdentity> m_identities;
+  nsInterfaceHashtable<nsCStringHashKey, nsIMsgIncomingServer> m_incomingServers;
+  nsCOMPtr<nsIMsgAccount> m_defaultAccount;
+  nsCOMArray<nsIIncomingServerListener> m_incomingServerListeners;
+  nsTObserverArray<RefPtr<VirtualFolderChangeListener> > m_virtualFolderListeners;
+  nsCOMPtr<nsIMsgFolder> m_folderDoingEmptyTrash;
+  nsCOMPtr<nsIMsgFolder> m_folderDoingCleanupInbox;
+  bool m_emptyTrashInProgress;
+  bool m_cleanupInboxInProgress;
+
+  nsCString mAccountKeyList;
+
+  // These are static because the account manager may go away during
+  // shutdown, and get recreated.
+  static bool m_haveShutdown;
+  static bool m_shutdownInProgress;
+
+  bool m_userAuthenticated;
+  bool m_loadingVirtualFolders;
+  bool m_virtualFoldersLoaded;
+
+  /* we call FindServer() a lot.  so cache the last server found */
+  nsCOMPtr <nsIMsgIncomingServer> m_lastFindServerResult;
+  nsCString m_lastFindServerHostName;
+  nsCString m_lastFindServerUserName;
+  int32_t m_lastFindServerPort;
+  nsCString m_lastFindServerType;
+
+  void SetLastServerFound(nsIMsgIncomingServer *server, const nsACString& hostname,
+                          const nsACString& username, const int32_t port, const nsACString& type);
+
+  // Cache the results of the last call to FolderUriFromDirInProfile
+  nsCOMPtr<nsIFile> m_lastPathLookedUp;
+  nsCString m_lastFolderURIForPath;
+
+  /* internal creation routines - updates m_identities and m_incomingServers */
+  nsresult createKeyedAccount(const nsCString& key,
+                              nsIMsgAccount **_retval);
+  nsresult createKeyedServer(const nsACString& key,
+                             const nsACString& username,
+                             const nsACString& password,
+                             const nsACString& type,
+                             nsIMsgIncomingServer **_retval);
+
+  nsresult createKeyedIdentity(const nsACString& key,
+                               nsIMsgIdentity **_retval);
+
+  nsresult GetLocalFoldersPrettyName(nsString &localFoldersName);
+
+  // sets the pref for the default server
+  nsresult setDefaultAccountPref(nsIMsgAccount *aDefaultAccount);
+
+  // Write out the accounts pref from the m_accounts list of accounts.
+  nsresult OutputAccountsPref();
+
+  // fires notifications to the appropriate root folders
+  nsresult notifyDefaultServerChange(nsIMsgAccount *aOldAccount,
+                                     nsIMsgAccount *aNewAccount);
+
+  //
+  // account enumerators
+  // ("element" is always an account)
+  //
+
+  // find the servers that correspond to the given identity
+  static bool findServersForIdentity (nsISupports *element, void *aData);
+
+  void findAccountByServerKey(const nsCString &aKey,
+                              nsIMsgAccount **aResult);
+
+  //
+  // server enumerators
+  // ("element" is always a server)
+  //
+
+  nsresult findServerInternal(const nsACString& username,
+                              const nsACString& hostname,
+                              const nsACString& type,
+                              int32_t port,
+                              bool aRealFlag,
+                              nsIMsgIncomingServer** aResult);
+
+  // handle virtual folders
+  static nsresult GetVirtualFoldersFile(nsCOMPtr<nsIFile>& file);
+  static nsresult WriteLineToOutputStream(const char *prefix, const char * line, nsIOutputStream *outputStream);
+  void     ParseAndVerifyVirtualFolderScope(nsCString &buffer,
+                                            nsIRDFService *rdf);
+  nsresult AddVFListenersForVF(nsIMsgFolder *virtualFolder,
+                               const nsCString& srchFolderUris,
+                               nsIRDFService *rdf,
+                               nsIMsgDBService *msgDBService);
+
+  nsresult RemoveVFListenerForVF(nsIMsgFolder *virtualFolder,
+                                 nsIMsgFolder *folder);
+
+  void getUniqueAccountKey(nsCString& aResult);
+
+  // Scan the preferences to find a unique server key
+  void GetUniqueServerKey(nsACString& aResult);
+
+  nsresult RemoveFolderFromSmartFolder(nsIMsgFolder *aFolder,
+                                       uint32_t flagsChanged);
+
+  nsresult SetSendLaterUriPref(nsIMsgIncomingServer *server);
+
+  nsCOMPtr<nsIPrefBranch> m_prefs;
+
+  //
+  // root folder listener stuff
+  //
+
+  // this array is for folder listeners that are supposed to be listening
+  // on the root folders.
+  // When a new server is created, all of the the folder listeners
+  //    should be added to the new server
+  // When a new listener is added, it should be added to all root folders.
+  // similar for when servers are deleted or listeners removed
+  nsTObserverArray<nsCOMPtr<nsIFolderListener> > mFolderListeners;
+
+  void removeListenersFromFolder(nsIMsgFolder *aFolder);
+};
diff --git a/mailnews/base/src/nsMsgAccountManagerDS.cpp b/mailnews/base/src/nsMsgAccountManagerDS.cpp
new file mode 100644
index 000000000..728aaabce
--- /dev/null
+++ b/mailnews/base/src/nsMsgAccountManagerDS.cpp
@@ -0,0 +1,1183 @@
+/* -*- 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/. */
+
+/*
+ * RDF datasource for the account manager
+ */
+
+#include "nsMsgAccountManagerDS.h"
+#include "rdf.h"
+#include "nsRDFCID.h"
+#include "nsIRDFDataSource.h"
+#include "nsEnumeratorUtils.h"
+#include "nsIServiceManager.h"
+#include "nsMsgRDFUtils.h"
+#include "nsIMsgFolder.h"
+#include "nsMsgBaseCID.h"
+
+#include "nsICategoryManager.h"
+#include "nsXPCOM.h"
+#include "nsISupportsPrimitives.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsArrayEnumerator.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Services.h"
+#include "nsArrayUtils.h"
+
+// turn this on to see useful output
+#undef DEBUG_amds
+
+#define NC_RDF_PAGETITLE_PREFIX               NC_NAMESPACE_URI "PageTitle"
+#define NC_RDF_PAGETITLE_MAIN                 NC_RDF_PAGETITLE_PREFIX "Main"
+#define NC_RDF_PAGETITLE_SERVER               NC_RDF_PAGETITLE_PREFIX "Server"
+#define NC_RDF_PAGETITLE_COPIES               NC_RDF_PAGETITLE_PREFIX "Copies"
+#define NC_RDF_PAGETITLE_SYNCHRONIZATION      NC_RDF_PAGETITLE_PREFIX "Synchronization"
+#define NC_RDF_PAGETITLE_DISKSPACE            NC_RDF_PAGETITLE_PREFIX "DiskSpace"
+#define NC_RDF_PAGETITLE_ADDRESSING           NC_RDF_PAGETITLE_PREFIX "Addressing"
+#define NC_RDF_PAGETITLE_SMTP                 NC_RDF_PAGETITLE_PREFIX "SMTP"
+#define NC_RDF_PAGETITLE_JUNK                 NC_RDF_PAGETITLE_PREFIX "Junk"
+#define NC_RDF_PAGETAG NC_NAMESPACE_URI "PageTag"
+
+
+#define NC_RDF_ACCOUNTROOT "msgaccounts:/"
+
+// the root resource (msgaccounts:/)
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_AccountRoot=nullptr;
+
+// attributes of accounts
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_Name=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_FolderTreeName=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_FolderTreeSimpleName=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_NameSort=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_FolderTreeNameSort=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_PageTag=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_IsDefaultServer=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_SupportsFilters=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_CanGetMessages=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_CanGetIncomingMessages=nullptr;
+
+// containment
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_Child=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_Settings=nullptr;
+
+
+// properties corresponding to interfaces
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_Account=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_Server=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_Identity=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_Junk=nullptr;
+
+// individual pages
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_PageTitleMain=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_PageTitleServer=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_PageTitleCopies=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_PageTitleSynchronization=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_PageTitleDiskSpace=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_PageTitleAddressing=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_PageTitleSMTP=nullptr;
+nsIRDFResource* nsMsgAccountManagerDataSource::kNC_PageTitleJunk=nullptr;
+
+// common literals
+nsIRDFLiteral* nsMsgAccountManagerDataSource::kTrueLiteral = nullptr;
+
+nsIAtom* nsMsgAccountManagerDataSource::kDefaultServerAtom = nullptr;
+
+nsrefcnt nsMsgAccountManagerDataSource::gAccountManagerResourceRefCnt = 0;
+
+// shared arc lists
+nsCOMPtr<nsIMutableArray> nsMsgAccountManagerDataSource::mAccountArcsOut;
+nsCOMPtr<nsIMutableArray> nsMsgAccountManagerDataSource::mAccountRootArcsOut;
+
+
+// RDF to match
+#define NC_RDF_ACCOUNT NC_NAMESPACE_URI "Account"
+#define NC_RDF_SERVER  NC_NAMESPACE_URI "Server"
+#define NC_RDF_IDENTITY NC_NAMESPACE_URI "Identity"
+#define NC_RDF_SETTINGS NC_NAMESPACE_URI "Settings"
+#define NC_RDF_JUNK NC_NAMESPACE_URI "Junk"
+#define NC_RDF_ISDEFAULTSERVER NC_NAMESPACE_URI "IsDefaultServer"
+#define NC_RDF_SUPPORTSFILTERS NC_NAMESPACE_URI "SupportsFilters"
+#define NC_RDF_CANGETMESSAGES NC_NAMESPACE_URI "CanGetMessages"
+#define NC_RDF_CANGETINCOMINGMESSAGES NC_NAMESPACE_URI "CanGetIncomingMessages"
+
+nsMsgAccountManagerDataSource::nsMsgAccountManagerDataSource()
+{
+#ifdef DEBUG_amds
+  printf("nsMsgAccountManagerDataSource() being created\n");
+#endif
+
+  // do per-class initialization here
+  if (gAccountManagerResourceRefCnt++ == 0) {
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_CHILD), &kNC_Child);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_NAME), &kNC_Name);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERTREENAME),
+                                 &kNC_FolderTreeName);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERTREESIMPLENAME),
+                                 &kNC_FolderTreeSimpleName);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_NAME_SORT), &kNC_NameSort);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERTREENAME_SORT),
+                                 &kNC_FolderTreeNameSort);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETAG), &kNC_PageTag);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_ISDEFAULTSERVER),
+                                 &kNC_IsDefaultServer);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_SUPPORTSFILTERS),
+                                 &kNC_SupportsFilters);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANGETMESSAGES),
+                                 &kNC_CanGetMessages);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANGETINCOMINGMESSAGES),
+                                 &kNC_CanGetIncomingMessages);
+
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_ACCOUNT), &kNC_Account);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_SERVER), &kNC_Server);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_IDENTITY), &kNC_Identity);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_JUNK), &kNC_Junk);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_MAIN),
+                                 &kNC_PageTitleMain);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_SERVER),
+                                 &kNC_PageTitleServer);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_COPIES),
+                                 &kNC_PageTitleCopies);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_SYNCHRONIZATION),
+                                 &kNC_PageTitleSynchronization);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_DISKSPACE),
+                                 &kNC_PageTitleDiskSpace);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_ADDRESSING),
+                                 &kNC_PageTitleAddressing);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_SMTP),
+                                 &kNC_PageTitleSMTP);
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_PAGETITLE_JUNK),
+                                 &kNC_PageTitleJunk);
+
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_ACCOUNTROOT),
+                                 &kNC_AccountRoot);
+
+    getRDFService()->GetLiteral(u"true",
+                                &kTrueLiteral);
+
+    // eventually these need to exist in some kind of array
+    // that's easily extensible
+    getRDFService()->GetResource(NS_LITERAL_CSTRING(NC_RDF_SETTINGS), &kNC_Settings);
+
+    kDefaultServerAtom = MsgNewAtom("DefaultServer").take();
+  }
+}
+
+nsMsgAccountManagerDataSource::~nsMsgAccountManagerDataSource()
+{
+  nsCOMPtr<nsIMsgAccountManager> am = do_QueryReferent(mAccountManager);
+  if (am)
+    am->RemoveIncomingServerListener(this);
+
+  if (--gAccountManagerResourceRefCnt == 0) {
+    NS_IF_RELEASE(kNC_Child);
+    NS_IF_RELEASE(kNC_Name);
+    NS_IF_RELEASE(kNC_FolderTreeName);
+    NS_IF_RELEASE(kNC_FolderTreeSimpleName);
+    NS_IF_RELEASE(kNC_NameSort);
+    NS_IF_RELEASE(kNC_FolderTreeNameSort);
+    NS_IF_RELEASE(kNC_PageTag);
+    NS_IF_RELEASE(kNC_IsDefaultServer);
+    NS_IF_RELEASE(kNC_SupportsFilters);
+    NS_IF_RELEASE(kNC_CanGetMessages);
+    NS_IF_RELEASE(kNC_CanGetIncomingMessages);
+    NS_IF_RELEASE(kNC_Account);
+    NS_IF_RELEASE(kNC_Server);
+    NS_IF_RELEASE(kNC_Identity);
+    NS_IF_RELEASE(kNC_Junk);
+    NS_IF_RELEASE(kNC_PageTitleMain);
+    NS_IF_RELEASE(kNC_PageTitleServer);
+    NS_IF_RELEASE(kNC_PageTitleCopies);
+    NS_IF_RELEASE(kNC_PageTitleSynchronization);
+    NS_IF_RELEASE(kNC_PageTitleDiskSpace);
+    NS_IF_RELEASE(kNC_PageTitleAddressing);
+    NS_IF_RELEASE(kNC_PageTitleSMTP);
+    NS_IF_RELEASE(kNC_PageTitleJunk);
+    NS_IF_RELEASE(kTrueLiteral);
+
+    NS_IF_RELEASE(kNC_AccountRoot);
+
+    // eventually these need to exist in some kind of array
+    // that's easily extensible
+    NS_IF_RELEASE(kNC_Settings);
+
+
+    NS_IF_RELEASE(kDefaultServerAtom);
+    mAccountArcsOut = nullptr;
+    mAccountRootArcsOut = nullptr;
+  }
+
+}
+
+NS_IMPL_ADDREF_INHERITED(nsMsgAccountManagerDataSource, nsMsgRDFDataSource)
+NS_IMPL_RELEASE_INHERITED(nsMsgAccountManagerDataSource, nsMsgRDFDataSource)
+NS_INTERFACE_MAP_BEGIN(nsMsgAccountManagerDataSource)
+  NS_INTERFACE_MAP_ENTRY(nsIIncomingServerListener)
+  NS_INTERFACE_MAP_ENTRY(nsIFolderListener)
+NS_INTERFACE_MAP_END_INHERITING(nsMsgRDFDataSource)
+
+nsresult
+nsMsgAccountManagerDataSource::Init()
+{
+  nsresult rv;
+
+  rv = nsMsgRDFDataSource::Init();
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIMsgAccountManager> am;
+
+  // get a weak ref to the account manager
+  if (!mAccountManager) 
+  {
+    am = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+    mAccountManager = do_GetWeakReference(am);
+  }
+  else
+    am = do_QueryReferent(mAccountManager);
+
+  if (am) 
+  {
+    am->AddIncomingServerListener(this);
+    am->AddRootFolderListener(this);
+  }
+
+
+  return NS_OK;
+}
+
+void nsMsgAccountManagerDataSource::Cleanup()
+{
+  nsCOMPtr<nsIMsgAccountManager> am = do_QueryReferent(mAccountManager);
+
+  if (am)
+  {
+    am->RemoveIncomingServerListener(this);
+    am->RemoveRootFolderListener(this);
+  }
+
+  nsMsgRDFDataSource::Cleanup();
+}
+
+/* nsIRDFNode GetTarget (in nsIRDFResource aSource, in nsIRDFResource property, in boolean aTruthValue); */
+NS_IMETHODIMP
+nsMsgAccountManagerDataSource::GetTarget(nsIRDFResource *source,
+                                         nsIRDFResource *property,
+                                         bool aTruthValue,
+                                         nsIRDFNode **target)
+{
+  nsresult rv;
+
+
+  rv = NS_RDF_NO_VALUE;
+
+  nsAutoString str;
+  if (property == kNC_Name || property == kNC_FolderTreeName ||
+      property == kNC_FolderTreeSimpleName) 
+  {
+    rv = getStringBundle();
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsString pageTitle;
+    if (source == kNC_PageTitleServer)
+      mStringBundle->GetStringFromName(u"prefPanel-server",
+                                       getter_Copies(pageTitle));
+
+    else if (source == kNC_PageTitleCopies)
+      mStringBundle->GetStringFromName(u"prefPanel-copies",
+                                       getter_Copies(pageTitle));
+    else if (source == kNC_PageTitleSynchronization)
+      mStringBundle->GetStringFromName(u"prefPanel-synchronization",
+                                       getter_Copies(pageTitle));
+    else if (source == kNC_PageTitleDiskSpace)
+      mStringBundle->GetStringFromName(u"prefPanel-diskspace",
+                                       getter_Copies(pageTitle));
+    else if (source == kNC_PageTitleAddressing)
+      mStringBundle->GetStringFromName(u"prefPanel-addressing",
+                                       getter_Copies(pageTitle));
+    else if (source == kNC_PageTitleSMTP)
+      mStringBundle->GetStringFromName(u"prefPanel-smtp",
+                                       getter_Copies(pageTitle));
+    else if (source == kNC_PageTitleJunk)
+      mStringBundle->GetStringFromName(u"prefPanel-junk",
+                                       getter_Copies(pageTitle));
+
+    else {
+      // if it's a server, use the pretty name
+      nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(source, &rv);
+      if (NS_SUCCEEDED(rv) && folder) {
+        bool isServer;
+        rv = folder->GetIsServer(&isServer);
+        if (NS_SUCCEEDED(rv) && isServer)
+          rv = folder->GetPrettyName(pageTitle);
+      }
+      else {
+        // allow for the accountmanager to be dynamically extended.
+
+        nsCOMPtr<nsIStringBundleService> strBundleService =
+          mozilla::services::GetStringBundleService();
+        NS_ENSURE_TRUE(strBundleService, NS_ERROR_UNEXPECTED);
+
+        const char *sourceValue;
+        rv = source->GetValueConst(&sourceValue);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        // make sure the pointer math we're about to do is safe.
+        NS_ENSURE_TRUE(sourceValue && (strlen(sourceValue) > strlen(NC_RDF_PAGETITLE_PREFIX)), NS_ERROR_UNEXPECTED);
+
+        nsCOMPtr<nsIMsgAccountManager> am = do_QueryReferent(mAccountManager, &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        // turn NC#PageTitlefoobar into foobar, so we can get the am-foobar.properties bundle
+        nsCString chromePackageName;
+        rv = am->GetChromePackageName(nsCString(sourceValue + strlen(NC_RDF_PAGETITLE_PREFIX)), chromePackageName);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        nsAutoCString bundleURL;
+        bundleURL = "chrome://";
+        bundleURL += chromePackageName;
+        bundleURL += "/locale/am-";
+        bundleURL += (sourceValue + strlen(NC_RDF_PAGETITLE_PREFIX));
+        bundleURL += ".properties";
+
+        nsCOMPtr <nsIStringBundle> bundle;
+        rv = strBundleService->CreateBundle(bundleURL.get(), getter_AddRefs(bundle));
+
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        nsAutoString panelTitleName;
+        panelTitleName.AssignLiteral("prefPanel-");
+        panelTitleName.Append(NS_ConvertASCIItoUTF16(sourceValue + strlen(NC_RDF_PAGETITLE_PREFIX)));
+        bundle->GetStringFromName(panelTitleName.get(), getter_Copies(pageTitle));
+      }
+    }
+    str = pageTitle.get();
+  }
+  else if (property == kNC_PageTag) {
+    // do NOT localize these strings. these are the urls of the XUL files
+    if (source == kNC_PageTitleServer)
+      str.AssignLiteral("am-server.xul");
+    else if (source == kNC_PageTitleCopies)
+      str.AssignLiteral("am-copies.xul");
+    else if ((source == kNC_PageTitleSynchronization) ||
+             (source == kNC_PageTitleDiskSpace))
+      str.AssignLiteral("am-offline.xul");
+    else if (source == kNC_PageTitleAddressing)
+      str.AssignLiteral("am-addressing.xul");
+    else if (source == kNC_PageTitleSMTP)
+      str.AssignLiteral("am-smtp.xul");
+    else if (source == kNC_PageTitleJunk)
+      str.AssignLiteral("am-junk.xul");
+    else {
+      nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(source, &rv);
+      if (NS_SUCCEEDED(rv) && folder) {
+        /* if this is a server, with no identities, then we show a special panel */
+        nsCOMPtr<nsIMsgIncomingServer> server;
+        rv = getServerForFolderNode(source, getter_AddRefs(server));
+        if (server)
+          server->GetAccountManagerChrome(str);
+        else 
+          str.AssignLiteral("am-main.xul");
+      }
+      else {
+        // allow for the accountmanager to be dynamically extended
+        const char *sourceValue;
+        rv = source->GetValueConst(&sourceValue);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        // make sure the pointer math we're about to do is safe.
+        NS_ENSURE_TRUE(sourceValue && (strlen(sourceValue) > strlen(NC_RDF_PAGETITLE_PREFIX)), NS_ERROR_UNEXPECTED);
+
+        // turn NC#PageTitlefoobar into foobar, so we can get the am-foobar.xul file
+        str.AssignLiteral("am-");
+        str.Append(NS_ConvertASCIItoUTF16(sourceValue + strlen(NC_RDF_PAGETITLE_PREFIX)));
+        str.AppendLiteral(".xul");
+      }
+    }
+  }
+
+  // handle sorting of servers
+  else if ((property == kNC_NameSort) ||
+           (property == kNC_FolderTreeNameSort)) {
+
+    // order for the folder pane
+    // and for the account manager tree is:
+    //
+    // - default mail account
+    // - <other mail accounts>
+    // - "Local Folders" account
+    // - news accounts
+    // - smtp settings (note, this is only in account manager tree)
+
+    // make sure we're handling a root folder that is a server
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    rv = getServerForFolderNode(source, getter_AddRefs(server));
+
+    if (NS_SUCCEEDED(rv) && server) {
+      int32_t accountNum;
+      nsCOMPtr<nsIMsgAccountManager> am = do_QueryReferent(mAccountManager);
+
+      if (isDefaultServer(server))
+        str.AssignLiteral("000000000");
+      else {
+        rv = am->GetSortOrder(server, &accountNum);
+        NS_ENSURE_SUCCESS(rv, rv);
+        str.AppendInt(accountNum);
+      }
+    }
+    else {
+      const char *sourceValue;
+      rv = source->GetValueConst(&sourceValue);
+      NS_ENSURE_SUCCESS(rv, NS_RDF_NO_VALUE);
+
+      // if this is a page (which we determine by the prefix of the URI)
+      // we want to generate a sort value
+      // so that we can sort the categories in the account manager tree
+      // (or the folder pane)
+      //
+      // otherwise, return NS_RDF_NO_VALUE
+      // so that the folder data source will take care of it.
+      if (sourceValue && (strncmp(sourceValue, NC_RDF_PAGETITLE_PREFIX, strlen(NC_RDF_PAGETITLE_PREFIX)) == 0)) {
+        if (source == kNC_PageTitleSMTP)
+          str.AssignLiteral("900000000");
+        else if (source == kNC_PageTitleServer)
+          str.AssignLiteral("1");
+        else if (source == kNC_PageTitleCopies)
+          str.AssignLiteral("2");
+        else if (source == kNC_PageTitleAddressing)
+          str.AssignLiteral("3");
+        else if (source == kNC_PageTitleSynchronization)
+          str.AssignLiteral("4");
+        else if (source == kNC_PageTitleDiskSpace)
+          str.AssignLiteral("4");
+        else if (source == kNC_PageTitleJunk)
+          str.AssignLiteral("5");
+        else {
+          // allow for the accountmanager to be dynamically extended
+          // all the other pages come after the standard ones
+          // server, copies, addressing, disk space (or offline & disk space)
+          CopyASCIItoUTF16(nsDependentCString(sourceValue), str);
+        }
+      }
+      else {
+        return NS_RDF_NO_VALUE;
+      }
+    }
+  }
+
+  // GetTargets() stuff - need to return a valid answer so that
+  // twisties will appear
+  else if (property == kNC_Settings) {
+    nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(source,&rv);
+    if (NS_FAILED(rv))
+      return NS_RDF_NO_VALUE;
+
+    bool isServer=false;
+    folder->GetIsServer(&isServer);
+    // no need to localize this!
+    if (isServer)
+      str.AssignLiteral("ServerSettings");
+  }
+
+  else if (property == kNC_IsDefaultServer) {
+    nsCOMPtr<nsIMsgIncomingServer> thisServer;
+    rv = getServerForFolderNode(source, getter_AddRefs(thisServer));
+    if (NS_FAILED(rv) || !thisServer) return NS_RDF_NO_VALUE;
+
+    if (isDefaultServer(thisServer))
+      str.AssignLiteral("true");
+  }
+
+  else if (property == kNC_SupportsFilters) {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    rv = getServerForFolderNode(source, getter_AddRefs(server));
+    if (NS_FAILED(rv) || !server) return NS_RDF_NO_VALUE;
+
+    if (supportsFilters(server))
+      str.AssignLiteral("true");
+  }
+  else if (property == kNC_CanGetMessages) {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    rv = getServerForFolderNode(source, getter_AddRefs(server));
+    if (NS_FAILED(rv) || !server) return NS_RDF_NO_VALUE;
+
+    if (canGetMessages(server))
+      str.AssignLiteral("true");
+  }
+  else if (property == kNC_CanGetIncomingMessages) {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    rv = getServerForFolderNode(source, getter_AddRefs(server));
+    if (NS_FAILED(rv) || !server) return NS_RDF_NO_VALUE;
+
+    if (canGetIncomingMessages(server))
+      str.AssignLiteral("true");
+  }
+
+  if (!str.IsEmpty())
+    rv = createNode(str.get(), target, getRDFService());
+
+  //if we have an empty string and we don't have an error value, then
+  //we don't have a value for RDF.
+  else if(NS_SUCCEEDED(rv))
+    rv = NS_RDF_NO_VALUE;
+
+  return rv;
+}
+
+
+
+/* nsISimpleEnumerator GetTargets (in nsIRDFResource aSource, in nsIRDFResource property, in boolean aTruthValue); */
+NS_IMETHODIMP
+nsMsgAccountManagerDataSource::GetTargets(nsIRDFResource *source,
+                                          nsIRDFResource *property,
+                                          bool aTruthValue,
+                                          nsISimpleEnumerator **_retval)
+{
+  nsresult rv = NS_RDF_NO_VALUE;
+
+  // create array and enumerator
+  // even if we're not handling this we need to return something empty?
+  nsCOMArray<nsIRDFResource> nodes;
+  if (NS_FAILED(rv)) return rv;
+  if (source == kNC_AccountRoot)
+    rv = createRootResources(property, &nodes);
+  else if (property == kNC_Settings)
+    rv = createSettingsResources(source, &nodes);
+
+  if (NS_FAILED(rv))
+    return NS_RDF_NO_VALUE;
+  return NS_NewArrayEnumerator(_retval, nodes);
+}
+
+// end of all arcs coming out of msgaccounts:/
+nsresult
+nsMsgAccountManagerDataSource::createRootResources(nsIRDFResource *property,
+                                                   nsCOMArray<nsIRDFResource> *aNodeArray)
+{
+  nsresult rv = NS_OK;
+  if (isContainment(property)) {
+
+    nsCOMPtr<nsIMsgAccountManager> am = do_QueryReferent(mAccountManager);
+    if (!am) return NS_ERROR_FAILURE;
+
+    nsCOMPtr<nsIArray> servers;
+    rv = am->GetAllServers(getter_AddRefs(servers));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    uint32_t length;
+    rv = servers->GetLength(&length);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    for (uint32_t i = 0; i < length; ++i)
+    {
+      nsCOMPtr<nsIMsgIncomingServer> server(do_QueryElementAt(servers, i, &rv));
+      if (NS_FAILED(rv))
+        continue;
+
+      nsCOMPtr<nsIMsgFolder> serverFolder;
+      rv = server->GetRootFolder(getter_AddRefs(serverFolder));
+      if (NS_FAILED(rv))
+        continue;
+
+      // add the resource to the array
+      nsCOMPtr<nsIRDFResource> serverResource = do_QueryInterface(serverFolder);
+      if (serverResource)
+        (void) aNodeArray->AppendObject(serverResource);
+    }
+
+#ifdef DEBUG_amds
+    uint32_t nodecount;
+    aNodeArray->GetLength(&nodecount);
+    printf("GetTargets(): added %d servers on %s\n", nodecount,
+           (const char*)property_arc);
+#endif
+    // For the "settings" arc, we also want to add SMTP setting.
+    if (property == kNC_Settings) {
+      aNodeArray->AppendObject(kNC_PageTitleSMTP);
+    }
+  }
+
+#ifdef DEBUG_amds
+  else {
+    printf("unknown arc %s on msgaccounts:/\n", (const char*)property_arc);
+  }
+#endif
+
+  return rv;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::appendGenericSettingsResources(nsIMsgIncomingServer *server, nsCOMArray<nsIRDFResource> *aNodeArray)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsICategoryManager> catman = do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsISimpleEnumerator> e;
+  rv = catman->EnumerateCategory(MAILNEWS_ACCOUNTMANAGER_EXTENSIONS, getter_AddRefs(e));
+  if(NS_SUCCEEDED(rv) && e) {
+    while (true) {
+      nsCOMPtr<nsISupports> supports;
+      rv = e->GetNext(getter_AddRefs(supports));
+      nsCOMPtr<nsISupportsCString> catEntry = do_QueryInterface(supports);
+      if (NS_FAILED(rv) || !catEntry)
+        break;
+
+      nsAutoCString entryString;
+      rv = catEntry->GetData(entryString);
+      if (NS_FAILED(rv))
+        break;
+
+      nsCString contractidString;
+      rv = catman->GetCategoryEntry(MAILNEWS_ACCOUNTMANAGER_EXTENSIONS, entryString.get(), getter_Copies(contractidString));
+      if (NS_FAILED(rv))
+        break;
+
+      nsCOMPtr <nsIMsgAccountManagerExtension> extension =
+        do_GetService(contractidString.get(), &rv);
+      if (NS_FAILED(rv) || !extension)
+        break;
+
+      bool showPanel;
+      rv = extension->ShowPanel(server, &showPanel);
+      if (NS_FAILED(rv))
+        break;
+
+      if (showPanel) {
+        nsCString name;
+        rv = extension->GetName(name);
+        if (NS_FAILED(rv))
+          break;
+
+        rv = appendGenericSetting(name.get(), aNodeArray);
+        if (NS_FAILED(rv))
+          break;
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::appendGenericSetting(const char *name,
+                                                    nsCOMArray<nsIRDFResource> *aNodeArray)
+{
+  NS_ENSURE_ARG_POINTER(name);
+  NS_ENSURE_ARG_POINTER(aNodeArray);
+
+  nsCOMPtr <nsIRDFResource> resource;
+
+  nsAutoCString resourceStr;
+  resourceStr = NC_RDF_PAGETITLE_PREFIX;
+  resourceStr += name;
+
+  nsresult rv = getRDFService()->GetResource(resourceStr, getter_AddRefs(resource));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // AppendElement will addref.
+  aNodeArray->AppendObject(resource);
+  return NS_OK;
+}
+
+// end of all #Settings arcs
+nsresult
+nsMsgAccountManagerDataSource::createSettingsResources(nsIRDFResource *aSource,
+                                                       nsCOMArray<nsIRDFResource> *aNodeArray)
+{
+  // If this isn't a server, just return.
+  if (aSource == kNC_PageTitleSMTP)
+    return NS_OK;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  getServerForFolderNode(aSource, getter_AddRefs(server));
+  if (server) {
+    bool hasIdentities;
+    nsresult rv = serverHasIdentities(server, &hasIdentities);
+
+    if (hasIdentities) {
+      aNodeArray->AppendObject(kNC_PageTitleServer);
+      aNodeArray->AppendObject(kNC_PageTitleCopies);
+      aNodeArray->AppendObject(kNC_PageTitleAddressing);
+    }
+
+    // Junk settings apply for all server types except for news and rss.
+    nsCString serverType;
+    server->GetType(serverType);
+    if (!MsgLowerCaseEqualsLiteral(serverType, "nntp") &&
+        !MsgLowerCaseEqualsLiteral(serverType, "rss"))
+      aNodeArray->AppendObject(kNC_PageTitleJunk);
+
+    // Check the offline capability before adding
+    // offline item
+    int32_t offlineSupportLevel = 0;
+    rv = server->GetOfflineSupportLevel(&offlineSupportLevel);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    bool supportsDiskSpace;
+    rv = server->GetSupportsDiskSpace(&supportsDiskSpace);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    // currently there is no offline without diskspace
+    if (offlineSupportLevel >= OFFLINE_SUPPORT_LEVEL_REGULAR) 
+      aNodeArray->AppendObject(kNC_PageTitleSynchronization);
+    else if (supportsDiskSpace)
+      aNodeArray->AppendObject(kNC_PageTitleDiskSpace);
+
+    if (hasIdentities) {
+      // extensions come after the default panels
+      rv = appendGenericSettingsResources(server, aNodeArray);
+      NS_ASSERTION(NS_SUCCEEDED(rv), "failed to add generic panels");
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::serverHasIdentities(nsIMsgIncomingServer* aServer,
+                                                   bool *aResult)
+{
+  nsresult rv;
+  *aResult = false;
+
+  nsCOMPtr<nsIMsgAccountManager> am = do_QueryReferent(mAccountManager, &rv);
+
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIArray> identities;
+  rv = am->GetIdentitiesForServer(aServer, getter_AddRefs(identities));
+
+  // no identities just means no arcs
+  if (NS_FAILED(rv)) return NS_OK;
+
+  uint32_t count;
+  rv = identities->GetLength(&count);
+  if (NS_FAILED(rv)) return NS_OK;
+
+  if (count >0)
+    *aResult = true;
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::getAccountArcs(nsIMutableArray **aResult)
+{
+  nsresult rv;
+  if (!mAccountArcsOut) {
+    mAccountArcsOut = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    mAccountArcsOut->AppendElement(kNC_Settings, false);
+    mAccountArcsOut->AppendElement(kNC_Name, false);
+    mAccountArcsOut->AppendElement(kNC_FolderTreeName, false);
+    mAccountArcsOut->AppendElement(kNC_FolderTreeSimpleName, false);
+    mAccountArcsOut->AppendElement(kNC_NameSort, false);
+    mAccountArcsOut->AppendElement(kNC_FolderTreeNameSort, false);
+    mAccountArcsOut->AppendElement(kNC_PageTag, false);
+  }
+
+  *aResult = mAccountArcsOut;
+  NS_IF_ADDREF(*aResult);
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::getAccountRootArcs(nsIMutableArray **aResult)
+{
+  nsresult rv;
+  if (!mAccountRootArcsOut) {
+    mAccountRootArcsOut = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    mAccountRootArcsOut->AppendElement(kNC_Server, false);
+    mAccountRootArcsOut->AppendElement(kNC_Child, false);
+
+    mAccountRootArcsOut->AppendElement(kNC_Settings, false);
+    mAccountRootArcsOut->AppendElement(kNC_Name, false);
+    mAccountRootArcsOut->AppendElement(kNC_FolderTreeName, false);
+    mAccountRootArcsOut->AppendElement(kNC_FolderTreeSimpleName, false);
+    mAccountRootArcsOut->AppendElement(kNC_NameSort, false);
+    mAccountRootArcsOut->AppendElement(kNC_FolderTreeNameSort, false);
+    mAccountRootArcsOut->AppendElement(kNC_PageTag, false);
+  }
+
+  *aResult = mAccountRootArcsOut;
+  NS_IF_ADDREF(*aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManagerDataSource::HasArcOut(nsIRDFResource *source, nsIRDFResource *aArc, bool *result)
+{
+  if (aArc == kNC_Settings) {
+    // based on createSettingsResources()
+    // we only have settings for local folders and servers with identities
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    nsresult rv = getServerForFolderNode(source, getter_AddRefs(server));
+    if (NS_SUCCEEDED(rv) && server) {
+      // Check the offline capability before adding arc
+      int32_t offlineSupportLevel = 0;
+      (void) server->GetOfflineSupportLevel(&offlineSupportLevel);
+      if (offlineSupportLevel >= OFFLINE_SUPPORT_LEVEL_REGULAR) {
+        *result = true;
+        return NS_OK;
+      }
+
+      bool supportsDiskSpace;
+      (void) server->GetSupportsDiskSpace(&supportsDiskSpace);
+      if (supportsDiskSpace) {
+        *result = true;
+        return NS_OK;
+      }
+      return serverHasIdentities(server, result);
+    }
+  }
+
+  *result = false;
+  return NS_OK;
+}
+
+/* nsISimpleEnumerator ArcLabelsOut (in nsIRDFResource aSource); */
+NS_IMETHODIMP
+nsMsgAccountManagerDataSource::ArcLabelsOut(nsIRDFResource *source,
+                                            nsISimpleEnumerator **_retval)
+{
+  nsresult rv;
+
+  // we have to return something, so always create the array/enumerators
+  nsCOMPtr<nsIMutableArray> arcs;
+  if (source == kNC_AccountRoot)
+    rv = getAccountRootArcs(getter_AddRefs(arcs));
+  else
+    rv = getAccountArcs(getter_AddRefs(arcs));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = NS_NewArrayEnumerator(_retval, arcs);
+  if (NS_FAILED(rv)) return rv;
+
+#ifdef DEBUG_amds_
+  printf("GetArcLabelsOut(%s): Adding child, settings, and name arclabels\n", value);
+#endif
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManagerDataSource::HasAssertion(nsIRDFResource *aSource,
+                                            nsIRDFResource *aProperty,
+                                            nsIRDFNode *aTarget,
+                                            bool aTruthValue,
+                                            bool *_retval)
+{
+  nsresult rv=NS_ERROR_FAILURE;
+
+  //
+  // msgaccounts:/ properties
+  //
+  if (aSource == kNC_AccountRoot) {
+    rv = HasAssertionAccountRoot(aProperty, aTarget, aTruthValue, _retval);
+  }
+  //
+  // server properties
+  //   try to convert the resource to a folder, and then only
+  //   answer if it's a server.. any failure falls through to the default case
+  //
+  // short-circuit on property, so objects like filters, etc, don't get queried
+  else if (aProperty == kNC_IsDefaultServer || aProperty == kNC_CanGetMessages ||
+           aProperty == kNC_CanGetIncomingMessages || aProperty == kNC_SupportsFilters) {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    rv = getServerForFolderNode(aSource, getter_AddRefs(server));
+    if (NS_SUCCEEDED(rv) && server)
+      rv = HasAssertionServer(server, aProperty, aTarget,
+                              aTruthValue, _retval);
+  }
+
+  // any failures above fallthrough to the parent class
+  if (NS_FAILED(rv))
+    return nsMsgRDFDataSource::HasAssertion(aSource, aProperty,
+                                            aTarget, aTruthValue, _retval);
+  return NS_OK;
+}
+
+
+
+nsresult
+nsMsgAccountManagerDataSource::HasAssertionServer(nsIMsgIncomingServer *aServer,
+                                                  nsIRDFResource *aProperty,
+                                                  nsIRDFNode *aTarget,
+                                                  bool aTruthValue,
+                                                  bool *_retval)
+{
+  if (aProperty == kNC_IsDefaultServer)
+    *_retval = (aTarget == kTrueLiteral) ? isDefaultServer(aServer) : !isDefaultServer(aServer);
+  else if (aProperty == kNC_SupportsFilters)
+    *_retval = (aTarget == kTrueLiteral) ? supportsFilters(aServer) : !supportsFilters(aServer);
+  else if (aProperty == kNC_CanGetMessages)
+   *_retval = (aTarget == kTrueLiteral) ? canGetMessages(aServer) : !canGetMessages(aServer);
+  else if (aProperty == kNC_CanGetIncomingMessages)
+    *_retval = (aTarget == kTrueLiteral) ? canGetIncomingMessages(aServer) : !canGetIncomingMessages(aServer);
+  else
+    *_retval = false;
+  return NS_OK;
+}
+
+bool
+nsMsgAccountManagerDataSource::isDefaultServer(nsIMsgIncomingServer *aServer)
+{
+  nsresult rv;
+  if (!aServer) return false;
+
+  nsCOMPtr<nsIMsgAccountManager> am = do_QueryReferent(mAccountManager, &rv);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  nsCOMPtr<nsIMsgAccount> defaultAccount;
+  rv = am->GetDefaultAccount(getter_AddRefs(defaultAccount));
+  NS_ENSURE_SUCCESS(rv, false);
+  if (!defaultAccount) return false;
+
+  // in some weird case that there is no default and they asked
+  // for the default
+  nsCOMPtr<nsIMsgIncomingServer> defaultServer;
+  rv = defaultAccount->GetIncomingServer(getter_AddRefs(defaultServer));
+  NS_ENSURE_SUCCESS(rv, false);
+  if (!defaultServer) return false;
+
+  bool isEqual;
+  rv = defaultServer->Equals(aServer, &isEqual);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  return isEqual;
+}
+
+
+bool
+nsMsgAccountManagerDataSource::supportsFilters(nsIMsgIncomingServer *aServer)
+{
+  bool supportsFilters;
+  nsresult rv = aServer->GetCanHaveFilters(&supportsFilters);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  return supportsFilters;
+}
+
+bool
+nsMsgAccountManagerDataSource::canGetMessages(nsIMsgIncomingServer *aServer)
+{
+  nsCOMPtr<nsIMsgProtocolInfo> protocolInfo;
+  nsresult rv = aServer->GetProtocolInfo(getter_AddRefs(protocolInfo));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  bool canGetMessages;
+  rv = protocolInfo->GetCanGetMessages(&canGetMessages);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  return canGetMessages;
+}
+
+bool
+nsMsgAccountManagerDataSource::canGetIncomingMessages(nsIMsgIncomingServer *aServer)
+{
+  nsCOMPtr<nsIMsgProtocolInfo> protocolInfo;
+  nsresult rv = aServer->GetProtocolInfo(getter_AddRefs(protocolInfo));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  bool canGetIncomingMessages;
+  rv = protocolInfo->GetCanGetIncomingMessages(&canGetIncomingMessages);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  return canGetIncomingMessages;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::HasAssertionAccountRoot(nsIRDFResource *aProperty,
+                                                       nsIRDFNode *aTarget,
+                                                       bool aTruthValue,
+                                                       bool *_retval)
+{
+  // set up default
+  *_retval = false;
+
+  // for child and settings arcs, just make sure it's a valid server:
+  if (isContainment(aProperty)) {
+
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    nsresult rv = getServerForFolderNode(aTarget, getter_AddRefs(server));
+    if (NS_FAILED(rv) || !server) return rv;
+
+    nsCString serverKey;
+    server->GetKey(serverKey);
+
+    nsCOMPtr<nsIMsgAccountManager> am = do_QueryReferent(mAccountManager, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIArray> serverArray;
+    rv = am->GetAllServers(getter_AddRefs(serverArray));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    uint32_t length;
+    rv = serverArray->GetLength(&length);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    for (uint32_t i = 0; i < length; ++i)
+    {
+      nsCOMPtr<nsIMsgIncomingServer> server(do_QueryElementAt(serverArray, i, &rv));
+      if (NS_FAILED(rv))
+        continue;
+
+      nsCString key;
+      server->GetKey(key);
+      if (key.Equals(serverKey))
+      {
+        *_retval = true;
+        break;
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+bool
+nsMsgAccountManagerDataSource::isContainment(nsIRDFResource *aProperty)
+{
+
+  if (aProperty == kNC_Child ||
+      aProperty == kNC_Settings)
+    return true;
+  return false;
+}
+
+// returns failure if the object is not a root server
+nsresult
+nsMsgAccountManagerDataSource::getServerForFolderNode(nsIRDFNode *aResource,
+                                                      nsIMsgIncomingServer **aResult)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(aResource, &rv);
+  if (NS_SUCCEEDED(rv)) 
+  {
+    bool isServer;
+    rv = folder->GetIsServer(&isServer);
+    if (NS_SUCCEEDED(rv) && isServer) 
+      return folder->GetServer(aResult);
+  }
+  return NS_ERROR_FAILURE;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::getStringBundle()
+{
+  if (mStringBundle) return NS_OK;
+
+  nsCOMPtr<nsIStringBundleService> strBundleService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(strBundleService, NS_ERROR_UNEXPECTED);
+
+  return strBundleService->CreateBundle("chrome://messenger/locale/prefs.properties",
+                                      getter_AddRefs(mStringBundle));
+}
+
+NS_IMETHODIMP
+nsMsgAccountManagerDataSource::OnServerLoaded(nsIMsgIncomingServer* aServer)
+{
+  nsCOMPtr<nsIMsgFolder> serverFolder;
+  nsresult rv = aServer->GetRootFolder(getter_AddRefs(serverFolder));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIRDFResource> serverResource = do_QueryInterface(serverFolder,&rv);
+  if (NS_FAILED(rv)) return rv;
+
+  NotifyObservers(kNC_AccountRoot, kNC_Child, serverResource, nullptr, true, false);
+  NotifyObservers(kNC_AccountRoot, kNC_Settings, serverResource, nullptr, true, false);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManagerDataSource::OnServerUnloaded(nsIMsgIncomingServer* aServer)
+{
+  nsCOMPtr<nsIMsgFolder> serverFolder;
+  nsresult rv = aServer->GetRootFolder(getter_AddRefs(serverFolder));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIRDFResource> serverResource = do_QueryInterface(serverFolder,&rv);
+  if (NS_FAILED(rv)) return rv;
+
+
+  NotifyObservers(kNC_AccountRoot, kNC_Child, serverResource, nullptr, false, false);
+  NotifyObservers(kNC_AccountRoot, kNC_Settings, serverResource, nullptr, false, false);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManagerDataSource::OnServerChanged(nsIMsgIncomingServer *server)
+{
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::OnItemPropertyChanged(nsIMsgFolder *, nsIAtom *, char const *, char const *)
+{
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::OnItemUnicharPropertyChanged(nsIMsgFolder *, nsIAtom *, const char16_t *, const char16_t *)
+{
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::OnItemRemoved(nsIMsgFolder *, nsISupports *)
+{
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::OnItemPropertyFlagChanged(nsIMsgDBHdr *, nsIAtom *, uint32_t, uint32_t)
+{
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::OnItemAdded(nsIMsgFolder *, nsISupports *)
+{
+  return NS_OK;
+}
+
+
+nsresult
+nsMsgAccountManagerDataSource::OnItemBoolPropertyChanged(nsIMsgFolder *aItem,
+                                                         nsIAtom *aProperty,
+                                                         bool aOldValue,
+                                                         bool aNewValue)
+{
+  if (aProperty == kDefaultServerAtom) {
+    nsCOMPtr<nsIRDFResource> resource(do_QueryInterface(aItem));
+    NotifyObservers(resource, kNC_IsDefaultServer, kTrueLiteral, nullptr, aNewValue, false);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::OnItemEvent(nsIMsgFolder *, nsIAtom *)
+{
+  return NS_OK;
+}
+
+nsresult
+nsMsgAccountManagerDataSource::OnItemIntPropertyChanged(nsIMsgFolder *, nsIAtom *, int64_t, int64_t)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgAccountManagerDataSource::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData)
+{
+  nsMsgRDFDataSource::Observe(aSubject, aTopic, aData);
+
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMsgAccountManagerDS.h b/mailnews/base/src/nsMsgAccountManagerDS.h
new file mode 100644
index 000000000..0a8d4cf42
--- /dev/null
+++ b/mailnews/base/src/nsMsgAccountManagerDS.h
@@ -0,0 +1,142 @@
+/* -*- 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 __nsMsgAccountManagerDS_h
+#define __nsMsgAccountManagerDS_h
+
+#include "mozilla/Attributes.h"
+#include "nscore.h"
+#include "nsError.h"
+#include "nsIID.h"
+#include "nsCOMPtr.h"
+#include "nsIStringBundle.h"
+
+#include "nsMsgRDFDataSource.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIIncomingServerListener.h"
+#include "nsIMsgProtocolInfo.h"
+#include "nsWeakPtr.h"
+#include "nsIMutableArray.h"
+#include "nsCOMArray.h"
+
+/* {3f989ca4-f77a-11d2-969d-006008948010} */
+#define NS_MSGACCOUNTMANAGERDATASOURCE_CID \
+  {0x3f989ca4, 0xf77a, 0x11d2, \
+    {0x96, 0x9d, 0x00, 0x60, 0x08, 0x94, 0x80, 0x10}}
+
+class nsMsgAccountManagerDataSource : public nsMsgRDFDataSource,
+                                      public nsIFolderListener,
+                                      public nsIIncomingServerListener
+{
+
+public:
+    
+  nsMsgAccountManagerDataSource();
+  virtual nsresult Init() override;
+
+  virtual void Cleanup() override;
+  // service manager shutdown method
+  
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIFOLDERLISTENER
+  NS_DECL_NSIINCOMINGSERVERLISTENER
+  NS_DECL_NSIOBSERVER
+  // RDF datasource methods
+  NS_IMETHOD GetTarget(nsIRDFResource *source,
+                       nsIRDFResource *property,
+                       bool aTruthValue,
+                       nsIRDFNode **_retval) override;
+  NS_IMETHOD GetTargets(nsIRDFResource *source,
+                        nsIRDFResource *property,
+                        bool aTruthValue,
+                        nsISimpleEnumerator **_retval) override;
+  NS_IMETHOD ArcLabelsOut(nsIRDFResource *source,
+                          nsISimpleEnumerator **_retval) override;
+
+  NS_IMETHOD HasAssertion(nsIRDFResource *aSource, nsIRDFResource *aProperty,
+                          nsIRDFNode *aTarget, bool aTruthValue,
+                          bool *_retval) override;
+  NS_IMETHOD HasArcOut(nsIRDFResource *source, nsIRDFResource *aArc,
+                       bool *result) override;
+    
+protected:
+  virtual ~nsMsgAccountManagerDataSource();
+
+  nsresult HasAssertionServer(nsIMsgIncomingServer *aServer,
+                              nsIRDFResource *aProperty,
+                              nsIRDFNode *aTarget,
+                              bool aTruthValue, bool *_retval);
+
+  nsresult HasAssertionAccountRoot(nsIRDFResource *aProperty,
+                                   nsIRDFNode *aTarget,
+                                   bool aTruthValue, bool *_retval);
+  
+  bool isDefaultServer(nsIMsgIncomingServer *aServer);
+  bool supportsFilters(nsIMsgIncomingServer *aServer);
+  bool canGetMessages(nsIMsgIncomingServer *aServer);
+  bool canGetIncomingMessages(nsIMsgIncomingServer *aServer);
+  
+  static bool isContainment(nsIRDFResource *aProperty);
+  nsresult getServerForFolderNode(nsIRDFNode *aResource,
+                                  nsIMsgIncomingServer **aResult);
+  
+  nsresult createRootResources(nsIRDFResource *aProperty,
+                               nsCOMArray<nsIRDFResource> *aNodeArray);
+  nsresult createSettingsResources(nsIRDFResource *aSource,
+                                   nsCOMArray<nsIRDFResource> *aNodeArray);
+  nsresult appendGenericSettingsResources(nsIMsgIncomingServer *server,\
+                                          nsCOMArray<nsIRDFResource> *aNodeArray);
+  nsresult appendGenericSetting(const char *name,
+                                nsCOMArray<nsIRDFResource> *aNodeArray);
+
+  static nsIRDFResource* kNC_Name;
+  static nsIRDFResource* kNC_FolderTreeName;
+  static nsIRDFResource* kNC_FolderTreeSimpleName;
+  static nsIRDFResource* kNC_NameSort;
+  static nsIRDFResource* kNC_FolderTreeNameSort;
+  static nsIRDFResource* kNC_PageTag;
+  static nsIRDFResource* kNC_IsDefaultServer;
+  static nsIRDFResource* kNC_SupportsFilters;
+  static nsIRDFResource* kNC_CanGetMessages;
+  static nsIRDFResource* kNC_CanGetIncomingMessages;
+  
+  static nsIRDFResource* kNC_Child;
+  static nsIRDFResource* kNC_AccountRoot;
+  
+  static nsIRDFResource* kNC_Account;
+  static nsIRDFResource* kNC_Server;
+  static nsIRDFResource* kNC_Identity;
+  static nsIRDFResource* kNC_Settings;
+  static nsIRDFResource* kNC_Junk;
+
+  static nsIRDFResource* kNC_PageTitleMain;
+  static nsIRDFResource* kNC_PageTitleServer;
+  static nsIRDFResource* kNC_PageTitleCopies;
+  static nsIRDFResource* kNC_PageTitleSynchronization;
+  static nsIRDFResource* kNC_PageTitleDiskSpace;
+  static nsIRDFResource* kNC_PageTitleAddressing;
+  static nsIRDFResource* kNC_PageTitleSMTP;
+  static nsIRDFResource* kNC_PageTitleJunk;
+
+  static nsIRDFLiteral* kTrueLiteral;
+
+  static nsIAtom* kDefaultServerAtom;
+
+  static nsrefcnt gAccountManagerResourceRefCnt;
+
+  static nsresult getAccountArcs(nsIMutableArray **aResult);
+  static nsresult getAccountRootArcs(nsIMutableArray **aResult);
+  
+private:
+  nsresult serverHasIdentities(nsIMsgIncomingServer *aServer, bool *aResult);
+  nsresult getStringBundle();
+
+  static nsCOMPtr<nsIMutableArray> mAccountArcsOut;
+  static nsCOMPtr<nsIMutableArray> mAccountRootArcsOut;
+  nsWeakPtr mAccountManager;
+  nsCOMPtr<nsIStringBundle> mStringBundle;
+};
+
+#endif /* __nsMsgAccountManagerDS_h */
diff --git a/mailnews/base/src/nsMsgBiffManager.cpp b/mailnews/base/src/nsMsgBiffManager.cpp
new file mode 100644
index 000000000..360600147
--- /dev/null
+++ b/mailnews/base/src/nsMsgBiffManager.cpp
@@ -0,0 +1,373 @@
+/* -*- 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 "nsMsgBiffManager.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsStatusBarBiffManager.h"
+#include "nsCOMArray.h"
+#include "mozilla/Logging.h"
+#include "nspr.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIObserverService.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Services.h"
+#include <algorithm>
+
+#define PREF_BIFF_JITTER "mail.biff.add_interval_jitter"
+
+static NS_DEFINE_CID(kStatusBarBiffManagerCID, NS_STATUSBARBIFFMANAGER_CID);
+
+static PRLogModuleInfo *MsgBiffLogModule = nullptr;
+
+NS_IMPL_ISUPPORTS(nsMsgBiffManager, nsIMsgBiffManager,
+                   nsIIncomingServerListener, nsIObserver,
+                   nsISupportsWeakReference)
+
+void OnBiffTimer(nsITimer *timer, void *aBiffManager)
+{
+  nsMsgBiffManager *biffManager = (nsMsgBiffManager*)aBiffManager;
+  biffManager->PerformBiff();
+}
+
+nsMsgBiffManager::nsMsgBiffManager()
+{
+  mHaveShutdown = false;
+  mInited = false;
+}
+
+nsMsgBiffManager::~nsMsgBiffManager()
+{
+  if (mBiffTimer)
+    mBiffTimer->Cancel();
+
+  if (!mHaveShutdown)
+    Shutdown();
+
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  if (observerService)
+  {
+    observerService->RemoveObserver(this, "wake_notification");
+    observerService->RemoveObserver(this, "sleep_notification");
+  }
+}
+
+NS_IMETHODIMP nsMsgBiffManager::Init()
+{
+  if (mInited)
+    return NS_OK;
+
+  mInited = true;
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager = 
+  do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv))
+    accountManager->AddIncomingServerListener(this);
+
+  // in turbo mode on profile change we don't need to do anything below this
+  if (mHaveShutdown)
+  {
+    mHaveShutdown = false;
+    return NS_OK;
+  }
+
+  // Ensure status bar biff service has started
+  nsCOMPtr<nsIFolderListener> statusBarBiffService = 
+    do_GetService(kStatusBarBiffManagerCID, &rv);
+
+  if (!MsgBiffLogModule)
+    MsgBiffLogModule = PR_NewLogModule("MsgBiff");
+
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  if (observerService)
+  {
+    observerService->AddObserver(this, "sleep_notification", true);
+    observerService->AddObserver(this, "wake_notification", true);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBiffManager::Shutdown()
+{
+  if (mBiffTimer) 
+  {
+    mBiffTimer->Cancel();
+    mBiffTimer = nullptr;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+    do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv))
+    accountManager->RemoveIncomingServerListener(this);
+
+  mHaveShutdown = true;
+  mInited = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBiffManager::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *someData)
+{
+  if (!strcmp(aTopic, "sleep_notification") && mBiffTimer)
+  {
+    mBiffTimer->Cancel();
+    mBiffTimer = nullptr;
+  }
+  else if (!strcmp(aTopic, "wake_notification"))
+  {
+    // wait 10 seconds after waking up to start biffing again.
+    mBiffTimer = do_CreateInstance("@mozilla.org/timer;1");
+    mBiffTimer->InitWithFuncCallback(OnBiffTimer, (void*)this, 10000,
+                                     nsITimer::TYPE_ONE_SHOT);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBiffManager::AddServerBiff(nsIMsgIncomingServer *server)
+{
+  NS_ENSURE_ARG_POINTER(server);
+
+  int32_t biffMinutes;
+
+  nsresult rv = server->GetBiffMinutes(&biffMinutes);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Don't add if biffMinutes isn't > 0
+  if (biffMinutes > 0)
+  {
+    int32_t serverIndex = FindServer(server);
+    // Only add it if it hasn't been added already.
+    if (serverIndex == -1)
+    {
+      nsBiffEntry biffEntry;
+      biffEntry.server = server;
+      rv = SetNextBiffTime(biffEntry, PR_Now());
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      AddBiffEntry(biffEntry);
+      SetupNextBiff();
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBiffManager::RemoveServerBiff(nsIMsgIncomingServer *server)
+{
+  int32_t pos = FindServer(server);
+  if (pos != -1)
+    mBiffArray.RemoveElementAt(pos);
+
+  // Should probably reset biff time if this was the server that gets biffed
+  // next.
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMsgBiffManager::ForceBiff(nsIMsgIncomingServer *server)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBiffManager::ForceBiffAll()
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgBiffManager::OnServerLoaded(nsIMsgIncomingServer *server)
+{
+  NS_ENSURE_ARG_POINTER(server);
+
+  bool doBiff = false;
+  nsresult rv = server->GetDoBiff(&doBiff);
+
+  if (NS_SUCCEEDED(rv) && doBiff)
+    rv = AddServerBiff(server);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgBiffManager::OnServerUnloaded(nsIMsgIncomingServer *server)
+{
+  return RemoveServerBiff(server);
+}
+
+NS_IMETHODIMP nsMsgBiffManager::OnServerChanged(nsIMsgIncomingServer *server)
+{
+  // nothing required.  If the hostname or username changed
+  // the next time biff fires, we'll ping the right server
+  return NS_OK;
+}
+
+int32_t nsMsgBiffManager::FindServer(nsIMsgIncomingServer *server)
+{
+  uint32_t count = mBiffArray.Length();
+  for (uint32_t i = 0; i < count; i++)
+  {
+    if (server == mBiffArray[i].server.get())
+      return i;
+  }
+  return -1;
+}
+
+nsresult nsMsgBiffManager::AddBiffEntry(nsBiffEntry &biffEntry)
+{
+  uint32_t i;
+  uint32_t count = mBiffArray.Length();
+  for (i = 0; i < count; i++)
+  {
+    if (biffEntry.nextBiffTime < mBiffArray[i].nextBiffTime)
+      break;
+  }
+  MOZ_LOG(MsgBiffLogModule, mozilla::LogLevel::Info, ("inserting biff entry at %d\n", i));
+  mBiffArray.InsertElementAt(i, biffEntry);
+  return NS_OK;
+}
+
+nsresult nsMsgBiffManager::SetNextBiffTime(nsBiffEntry &biffEntry, PRTime currentTime)
+{
+  nsIMsgIncomingServer *server = biffEntry.server;
+  NS_ENSURE_TRUE(server, NS_ERROR_FAILURE);
+
+  int32_t biffInterval;
+  nsresult rv = server->GetBiffMinutes(&biffInterval);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Add biffInterval, converted in microseconds, to current time.
+  // Force 64-bit multiplication.
+  PRTime chosenTimeInterval = biffInterval * 60000000LL;
+  biffEntry.nextBiffTime = currentTime + chosenTimeInterval;
+
+  // Check if we should jitter.
+  nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
+  if (prefs)
+  {
+    bool shouldUseBiffJitter = false;
+    prefs->GetBoolPref(PREF_BIFF_JITTER, &shouldUseBiffJitter);
+    if (shouldUseBiffJitter)
+    {
+      // Calculate a jitter of +/-5% on chosenTimeInterval
+      // - minimum 1 second (to avoid a modulo with 0)
+      // - maximum 30 seconds (to avoid problems when biffInterval is very large)
+      int64_t jitter = (int64_t)(0.05 * (int64_t)chosenTimeInterval);
+      jitter = std::max<int64_t>(1000000LL, std::min<int64_t>(jitter, 30000000LL));
+      jitter = ((rand() % 2) ? 1 : -1) * (rand() % jitter);
+
+      biffEntry.nextBiffTime += jitter;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMsgBiffManager::SetupNextBiff()
+{
+  if (mBiffArray.Length() > 0)
+  {
+    // Get the next biff entry
+    const nsBiffEntry &biffEntry = mBiffArray[0];
+    PRTime currentTime = PR_Now();
+    int64_t biffDelay;
+    int64_t ms(1000);
+
+    if (currentTime > biffEntry.nextBiffTime)
+    {
+      // Let's wait 30 seconds before firing biff again
+      biffDelay = 30 * PR_USEC_PER_SEC;
+    }
+    else
+      biffDelay = biffEntry.nextBiffTime - currentTime;
+
+    // Convert biffDelay into milliseconds
+    int64_t timeInMS = biffDelay / ms;
+    uint32_t timeInMSUint32 = (uint32_t)timeInMS;
+
+    // Can't currently reset a timer when it's in the process of
+    // calling Notify. So, just release the timer here and create a new one.
+    if (mBiffTimer)
+      mBiffTimer->Cancel();
+
+    MOZ_LOG(MsgBiffLogModule, mozilla::LogLevel::Info, ("setting %d timer\n", timeInMSUint32));
+    mBiffTimer = do_CreateInstance("@mozilla.org/timer;1");
+    mBiffTimer->InitWithFuncCallback(OnBiffTimer, (void*)this, timeInMSUint32, 
+                                     nsITimer::TYPE_ONE_SHOT);
+
+  }
+  return NS_OK;
+}
+
+//This is the function that does a biff on all of the servers whose time it is to biff.
+nsresult nsMsgBiffManager::PerformBiff()
+{
+  PRTime currentTime = PR_Now();
+  nsCOMArray<nsIMsgFolder> targetFolders;
+  MOZ_LOG(MsgBiffLogModule, mozilla::LogLevel::Info, ("performing biffs\n"));
+
+  uint32_t count = mBiffArray.Length();
+  for (uint32_t i = 0; i < count; i++)
+  {
+    // Take a copy of the entry rather than the a reference so that we can
+    // remove and add if necessary, but keep the references and memory alive.
+    nsBiffEntry current = mBiffArray[i];
+    if (current.nextBiffTime < currentTime)
+    {
+      bool serverBusy = false;
+      bool serverRequiresPassword = true;
+      bool passwordPromptRequired; 
+
+      current.server->GetPasswordPromptRequired(&passwordPromptRequired);
+      current.server->GetServerBusy(&serverBusy);
+      current.server->GetServerRequiresPasswordForBiff(&serverRequiresPassword);
+      // find the dest folder we're actually downloading to...
+      nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+      current.server->GetRootMsgFolder(getter_AddRefs(rootMsgFolder));
+      int32_t targetFolderIndex = targetFolders.IndexOfObject(rootMsgFolder);
+      if (targetFolderIndex == kNotFound)
+        targetFolders.AppendObject(rootMsgFolder);
+
+      // so if we need to be authenticated to biff, check that we are
+      // (since we don't want to prompt the user for password UI)
+      // and make sure the server isn't already in the middle of downloading
+      // new messages
+      if (!serverBusy &&
+          (!serverRequiresPassword || !passwordPromptRequired) &&
+          targetFolderIndex == kNotFound)
+      {
+        nsCString serverKey;
+        current.server->GetKey(serverKey);
+        nsresult rv = current.server->PerformBiff(nullptr);
+        MOZ_LOG(MsgBiffLogModule, mozilla::LogLevel::Info, ("biffing server %s rv = %x\n", serverKey.get(), rv));
+      }
+      else
+      {
+        MOZ_LOG(MsgBiffLogModule, mozilla::LogLevel::Info, ("not biffing server serverBusy = %d requirespassword = %d password prompt required = %d targetFolderIndex = %d\n",
+          serverBusy, serverRequiresPassword, passwordPromptRequired, targetFolderIndex));
+      }
+      // if we didn't do this server because the destination server was already being
+      // biffed into, leave this server in the biff array so it will fire next.
+      if (targetFolderIndex == kNotFound)
+      {
+        mBiffArray.RemoveElementAt(i);
+        i--; //Because we removed it we need to look at the one that just moved up.
+        SetNextBiffTime(current, currentTime);
+        AddBiffEntry(current);
+      }
+#ifdef DEBUG_David_Bienvenu
+      else
+        printf("dest account performing biff\n");
+#endif
+    }
+    else
+      //since we're in biff order, there's no reason to keep checking
+      break;
+  }
+  SetupNextBiff();
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMsgBiffManager.h b/mailnews/base/src/nsMsgBiffManager.h
new file mode 100644
index 000000000..909c2b493
--- /dev/null
+++ b/mailnews/base/src/nsMsgBiffManager.h
@@ -0,0 +1,55 @@
+/* -*- 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 NSMSGBIFFMANAGER_H
+#define NSMSGBIFFMANAGER_H
+
+#include "msgCore.h"
+#include "nsIMsgBiffManager.h"
+#include "nsITimer.h"
+#include "nsTArray.h"
+#include "nsCOMPtr.h"
+#include "nsIIncomingServerListener.h"
+#include "nsWeakReference.h"
+#include "nsIObserver.h"
+
+typedef struct {
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  PRTime nextBiffTime;
+} nsBiffEntry;
+
+
+class nsMsgBiffManager
+  : public nsIMsgBiffManager,
+    public nsIIncomingServerListener,
+    public nsIObserver,
+    public nsSupportsWeakReference
+{
+public:
+  nsMsgBiffManager(); 
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGBIFFMANAGER
+  NS_DECL_NSIINCOMINGSERVERLISTENER
+  NS_DECL_NSIOBSERVER
+
+  nsresult PerformBiff();
+
+protected:
+  virtual ~nsMsgBiffManager();
+
+  int32_t FindServer(nsIMsgIncomingServer *server);
+  nsresult SetNextBiffTime(nsBiffEntry &biffEntry, PRTime currentTime);
+  nsresult SetupNextBiff();
+  nsresult AddBiffEntry(nsBiffEntry &biffEntry);
+
+protected:
+  nsCOMPtr<nsITimer> mBiffTimer;
+  nsTArray<nsBiffEntry> mBiffArray;
+  bool mHaveShutdown;
+  bool mInited;
+};
+
+#endif // NSMSGBIFFMANAGER_H
diff --git a/mailnews/base/src/nsMsgContentPolicy.cpp b/mailnews/base/src/nsMsgContentPolicy.cpp
new file mode 100644
index 000000000..ebc02635f
--- /dev/null
+++ b/mailnews/base/src/nsMsgContentPolicy.cpp
@@ -0,0 +1,1076 @@
+/* -*- 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 "nsMsgContentPolicy.h"
+#include "nsIPermissionManager.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIAbManager.h"
+#include "nsIAbDirectory.h"
+#include "nsIAbCard.h"
+#include "nsIMsgWindow.h"
+#include "nsIMimeMiscStatus.h"
+#include "nsIMsgHdr.h"
+#include "nsIEncryptedSMIMEURIsSrvc.h"
+#include "nsNetUtil.h"
+#include "nsIMsgComposeService.h"
+#include "nsMsgCompCID.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIWebNavigation.h"
+#include "nsContentPolicyUtils.h"
+#include "nsIDOMHTMLImageElement.h"
+#include "nsIFrameLoader.h"
+#include "nsIWebProgress.h"
+#include "nsMsgUtils.h"
+#include "nsThreadUtils.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+#include "nsINntpUrl.h"
+#include "nsSandboxFlags.h"
+
+static const char kBlockRemoteImages[] = "mailnews.message_display.disable_remote_image";
+static const char kAllowPlugins[] = "mailnews.message_display.allow_plugins";
+static const char kTrustedDomains[] =  "mail.trusteddomains";
+
+using namespace mozilla::mailnews;
+
+// Per message headder flags to keep track of whether the user is allowing remote
+// content for a particular message.
+// if you change or add more values to these constants, be sure to modify
+// the corresponding definitions in mailWindowOverlay.js
+#define kNoRemoteContentPolicy 0
+#define kBlockRemoteContent 1
+#define kAllowRemoteContent 2
+
+NS_IMPL_ISUPPORTS(nsMsgContentPolicy,
+                  nsIContentPolicy,
+                  nsIWebProgressListener,
+                  nsIMsgContentPolicy,
+                  nsIObserver,
+                  nsISupportsWeakReference)
+
+nsMsgContentPolicy::nsMsgContentPolicy()
+{
+  mAllowPlugins = false;
+  mBlockRemoteImages = true;
+}
+
+nsMsgContentPolicy::~nsMsgContentPolicy()
+{
+  // hey, we are going away...clean up after ourself....unregister our observer
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefInternal = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv))
+  {
+    prefInternal->RemoveObserver(kBlockRemoteImages, this);
+    prefInternal->RemoveObserver(kAllowPlugins, this);
+  }
+}
+
+nsresult nsMsgContentPolicy::Init()
+{
+  nsresult rv;
+
+  // register ourself as an observer on the mail preference to block remote images
+  nsCOMPtr<nsIPrefBranch> prefInternal = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  prefInternal->AddObserver(kBlockRemoteImages, this, true);
+  prefInternal->AddObserver(kAllowPlugins, this, true);
+
+  prefInternal->GetBoolPref(kAllowPlugins, &mAllowPlugins);
+  prefInternal->GetCharPref(kTrustedDomains, getter_Copies(mTrustedMailDomains));
+  prefInternal->GetBoolPref(kBlockRemoteImages, &mBlockRemoteImages);
+
+  // Grab a handle on the PermissionManager service for managing allowed remote
+  // content senders.
+  mPermissionManager = do_GetService(NS_PERMISSIONMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+/**
+ * @returns true if the sender referenced by aMsgHdr is explicitly allowed to
+ *          load remote images according to the PermissionManager
+ */
+bool
+nsMsgContentPolicy::ShouldAcceptRemoteContentForSender(nsIMsgDBHdr *aMsgHdr)
+{
+  if (!aMsgHdr)
+    return false;
+
+  // extract the e-mail address from the msg hdr
+  nsCString author;
+  nsresult rv = aMsgHdr->GetAuthor(getter_Copies(author));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  nsCString emailAddress;
+  ExtractEmail(EncodedHeader(author), emailAddress);
+  if (emailAddress.IsEmpty())
+    return false;
+
+  nsCOMPtr<nsIIOService> ios = do_GetService("@mozilla.org/network/io-service;1", &rv);
+  NS_ENSURE_SUCCESS(rv, false);
+  nsCOMPtr<nsIURI> mailURI;
+  emailAddress.Insert("chrome://messenger/content/email=", 0);
+  rv = ios->NewURI(emailAddress, nullptr, nullptr, getter_AddRefs(mailURI));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  // check with permission manager
+  uint32_t permission = 0;
+  rv = mPermissionManager->TestPermission(mailURI, "image", &permission);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  // Only return true if the permission manager has an explicit allow
+  return (permission == nsIPermissionManager::ALLOW_ACTION);
+}
+
+/**
+ * Extract the host name from aContentLocation, and look it up in our list
+ * of trusted domains.
+ */
+bool nsMsgContentPolicy::IsTrustedDomain(nsIURI * aContentLocation)
+{
+  bool trustedDomain = false;
+  // get the host name of the server hosting the remote image
+  nsAutoCString host;
+  nsresult rv = aContentLocation->GetHost(host);
+
+  if (NS_SUCCEEDED(rv) && !mTrustedMailDomains.IsEmpty())
+    trustedDomain = MsgHostDomainIsTrusted(host, mTrustedMailDomains);
+
+  return trustedDomain;
+}
+
+NS_IMETHODIMP
+nsMsgContentPolicy::ShouldLoad(uint32_t          aContentType,
+                               nsIURI           *aContentLocation,
+                               nsIURI           *aRequestingLocation,
+                               nsISupports      *aRequestingContext,
+                               const nsACString &aMimeGuess,
+                               nsISupports      *aExtra,
+                               nsIPrincipal     *aRequestPrincipal,
+                               int16_t          *aDecision)
+{
+  nsresult rv = NS_OK;
+  // The default decision at the start of the function is to accept the load.
+  // Once we have checked the content type and the requesting location, then
+  // we switch it to reject.
+  //
+  // Be very careful about returning error codes - if this method returns an
+  // NS_ERROR_*, any decision made here will be ignored, and the document could
+  // be accepted when we don't want it to be.
+  //
+  // In most cases if an error occurs, its something we didn't expect so we
+  // should be rejecting the document anyway.
+  *aDecision = nsIContentPolicy::ACCEPT;
+
+  NS_ENSURE_ARG_POINTER(aContentLocation);
+
+#ifdef DEBUG_MsgContentPolicy
+  fprintf(stderr, "aContentType: %d\naContentLocation = %s\n",
+          aContentType,
+          aContentLocation->GetSpecOrDefault().get());
+#endif
+
+#ifndef MOZ_THUNDERBIRD
+  // Go find out if we are dealing with mailnews. Anything else
+  // isn't our concern and we accept content.
+  nsCOMPtr<nsIDocShell> rootDocShell;
+  rv = GetRootDocShellForContext(aRequestingContext,
+                                 getter_AddRefs(rootDocShell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t appType;
+  rv = rootDocShell->GetAppType(&appType);
+  // We only want to deal with mailnews
+  if (NS_FAILED(rv) || appType != nsIDocShell::APP_TYPE_MAIL)
+    return NS_OK;
+#endif
+
+  switch(aContentType) {
+    // Plugins (nsIContentPolicy::TYPE_OBJECT) are blocked on document load.
+  case nsIContentPolicy::TYPE_DOCUMENT:
+    // At this point, we have no intention of supporting a different JS
+    // setting on a subdocument, so we don't worry about TYPE_SUBDOCUMENT here.
+
+    // If the timing were right, we'd enable JavaScript on the docshell
+    // for non mailnews URIs here.  However, at this point, the
+    // old document may still be around, so we can't do any enabling just yet.
+    // Instead, we apply the policy in nsIWebProgressListener::OnLocationChange.
+    // For now, we explicitly disable JavaScript in order to be safe rather than
+    // sorry, because OnLocationChange isn't guaranteed to necessarily be called
+    // soon enough to disable it in time (though bz says it _should_ be called
+    // soon enough "in all sane cases").
+    rv = SetDisableItemsOnMailNewsUrlDocshells(aContentLocation,
+                                               aRequestingContext);
+    // if something went wrong during the tweaking, reject this content
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Failed to set disable items on docShells");
+      *aDecision = nsIContentPolicy::REJECT_TYPE;
+      return NS_OK;
+    }
+    break;
+
+  case nsIContentPolicy::TYPE_CSP_REPORT:
+    // We cannot block CSP reports.
+    *aDecision = nsIContentPolicy::ACCEPT;
+    return NS_OK;
+    break;
+
+  default:
+    break;
+  }
+
+  // NOTE: Not using NS_ENSURE_ARG_POINTER because this is a legitimate case
+  // that can happen.  Also keep in mind that the default policy used for a
+  // failure code is ACCEPT.
+  if (!aRequestingLocation)
+    return NS_ERROR_INVALID_POINTER;
+
+#ifdef DEBUG_MsgContentPolicy
+  fprintf(stderr, "aRequestingLocation = %s\n", aRequestingLocation->GetSpecOrDefault().get());
+#endif
+
+  // If the requesting location is safe, accept the content location request.
+  if (IsSafeRequestingLocation(aRequestingLocation))
+    return rv;
+
+  // Now default to reject so early returns via NS_ENSURE_SUCCESS
+  // cause content to be rejected.
+  *aDecision = nsIContentPolicy::REJECT_REQUEST;
+
+  // We want to establish the following:
+  // \--------\  requester    |               |              |
+  // content   \------------\ |               |              |
+  // requested               \| mail message  | news message | http(s)/data etc.
+  // -------------------------+---------------+--------------+------------------
+  // mail message content     | load if same  | don't load   | don't load
+  // mailbox, imap, JsAccount | message (1)   | (2)          | (3)
+  // -------------------------+---------------+--------------+------------------
+  // news message             | don't load (4)| load (5)     | load (6)
+  // -------------------------+---------------+--------------+------------------
+  // http(s)/data, etc.       | (default)     | (default)    | (default)
+  // -------------------------+---------------+--------------+------------------
+  nsCOMPtr<nsIMsgMessageUrl> contentURL(do_QueryInterface(aContentLocation));
+  if (contentURL) {
+    nsCOMPtr<nsINntpUrl> contentNntpURL(do_QueryInterface(aContentLocation));
+    if (!contentNntpURL) {
+      // Mail message (mailbox, imap or JsAccount) content requested, for example
+      // a message part, like an image:
+      // To load mail message content the requester must have the same
+      // "normalised" principal. This is basically a "same origin" test, it
+      // protects against cross-loading of mail message content from
+      // other mail or news messages.
+      nsCOMPtr<nsIMsgMessageUrl> requestURL(do_QueryInterface(aRequestingLocation));
+      // If the request URL is not also a message URL, then we don't accept.
+      if (requestURL) {
+        nsCString contentPrincipalSpec, requestPrincipalSpec;
+        nsresult rv1 = contentURL->GetPrincipalSpec(contentPrincipalSpec);
+        nsresult rv2 = requestURL->GetPrincipalSpec(requestPrincipalSpec);
+        if (NS_SUCCEEDED(rv1) && NS_SUCCEEDED(rv2) &&
+            contentPrincipalSpec.Equals(requestPrincipalSpec))
+          *aDecision = nsIContentPolicy::ACCEPT; // (1)
+      }
+      return NS_OK; // (2) and (3)
+    }
+
+    // News message content requested. Don't accept request coming
+    // from a mail message since it would access the news server.
+    nsCOMPtr<nsIMsgMessageUrl> requestURL(do_QueryInterface(aRequestingLocation));
+    if (requestURL) {
+      nsCOMPtr<nsINntpUrl> requestNntpURL(do_QueryInterface(aRequestingLocation));
+      if (!requestNntpURL)
+        return NS_OK; // (4)
+    }
+    *aDecision = nsIContentPolicy::ACCEPT; // (5) and (6)
+    return NS_OK;
+  }
+
+  // If exposed protocol not covered by the test above or protocol that has been
+  // specifically exposed by an add-on, or is a chrome url, then allow the load.
+  if (IsExposedProtocol(aContentLocation))
+  {
+    *aDecision = nsIContentPolicy::ACCEPT;
+    return NS_OK;
+  }
+
+  // never load unexposed protocols except for http, https and file.
+  // Protocols like ftp are always blocked.
+  if (ShouldBlockUnexposedProtocol(aContentLocation))
+    return NS_OK;
+
+
+  // Find out the URI that originally initiated the set of requests for this
+  // context.
+  nsCOMPtr<nsIURI> originatorLocation;
+  if (!aRequestingContext && aRequestPrincipal)
+  {
+    // Can get the URI directly from the principal.
+    rv = aRequestPrincipal->GetURI(getter_AddRefs(originatorLocation));
+  }
+  else
+  {
+    rv = GetOriginatingURIForContext(aRequestingContext,
+                                     getter_AddRefs(originatorLocation));
+  }
+  NS_ENSURE_SUCCESS(rv, NS_OK);
+
+#ifdef DEBUG_MsgContentPolicy
+  fprintf(stderr, "originatorLocation = %s\n", originatorLocation->GetSpecOrDefault().get());
+#endif
+
+  // Don't load remote content for encrypted messages.
+  nsCOMPtr<nsIEncryptedSMIMEURIsService> encryptedURIService =
+    do_GetService("@mozilla.org/messenger-smime/smime-encrypted-uris-service;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool isEncrypted;
+  rv = encryptedURIService->IsEncrypted(aRequestingLocation->GetSpecOrDefault(), &isEncrypted);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (isEncrypted)
+  {
+    *aDecision = nsIContentPolicy::REJECT_REQUEST;
+    NotifyContentWasBlocked(originatorLocation, aContentLocation, false);
+    return NS_OK;
+  }
+
+  // If we are allowing all remote content...
+  if (!mBlockRemoteImages)
+  {
+    *aDecision = nsIContentPolicy::ACCEPT;
+    return NS_OK;
+  }
+
+  // Extract the windowtype to handle compose windows separately from mail
+  if (aRequestingContext)
+  {
+    nsCOMPtr<nsIMsgCompose> msgCompose =
+      GetMsgComposeForContext(aRequestingContext);
+    // Work out if we're in a compose window or not.
+    if (msgCompose)
+    {
+      ComposeShouldLoad(msgCompose, aRequestingContext, aContentLocation,
+                        aDecision);
+      return NS_OK;
+    }
+  }
+
+  // Allow content when using a remote page.
+  bool isHttp;
+  bool isHttps;
+  rv = originatorLocation->SchemeIs("http", &isHttp);
+  nsresult rv2 = originatorLocation->SchemeIs("https", &isHttps);
+  if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(rv2) && (isHttp || isHttps))
+  {
+    *aDecision = nsIContentPolicy::ACCEPT;
+    return NS_OK;
+  }
+
+  uint32_t permission;
+  mPermissionManager->TestPermission(aContentLocation, "image", &permission);
+  switch (permission) {
+    case nsIPermissionManager::UNKNOWN_ACTION:
+    {
+      // No exception was found for this location.
+      break;
+    }
+    case nsIPermissionManager::ALLOW_ACTION:
+    {
+      *aDecision = nsIContentPolicy::ACCEPT;
+      return NS_OK;
+    }
+    case nsIPermissionManager::DENY_ACTION:
+    {
+      *aDecision = nsIContentPolicy::REJECT_REQUEST;
+      return NS_OK;
+    }
+  }
+
+  // The default decision is still to reject.
+  ShouldAcceptContentForPotentialMsg(originatorLocation, aContentLocation,
+                                     aDecision);
+  return NS_OK;
+}
+
+/**
+ * Determines if the requesting location is a safe one, i.e. its under the
+ * app/user's control - so file, about, chrome etc.
+ */
+bool
+nsMsgContentPolicy::IsSafeRequestingLocation(nsIURI *aRequestingLocation)
+{
+  if (!aRequestingLocation)
+    return false;
+
+  // If aRequestingLocation is one of chrome, resource, file or view-source,
+  // allow aContentLocation to load.
+  bool isChrome;
+  bool isRes;
+  bool isFile;
+  bool isViewSource;
+
+  nsresult rv = aRequestingLocation->SchemeIs("chrome", &isChrome);
+  NS_ENSURE_SUCCESS(rv, false);
+  rv = aRequestingLocation->SchemeIs("resource", &isRes);
+  NS_ENSURE_SUCCESS(rv, false);
+  rv = aRequestingLocation->SchemeIs("file", &isFile);
+  NS_ENSURE_SUCCESS(rv, false);
+  rv = aRequestingLocation->SchemeIs("view-source", &isViewSource);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  if (isChrome || isRes || isFile || isViewSource)
+    return true;
+
+  // Only allow about: to load anything if the requesting location is not the
+  // special about:blank one.
+  bool isAbout;
+  rv = aRequestingLocation->SchemeIs("about", &isAbout);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  if (!isAbout)
+    return false;
+
+  nsCString fullSpec;
+  rv = aRequestingLocation->GetSpec(fullSpec);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  return !fullSpec.EqualsLiteral("about:blank");
+}
+
+/**
+ * Determines if the content location is a scheme that we're willing to expose
+ * for unlimited loading of content.
+ */
+bool
+nsMsgContentPolicy::IsExposedProtocol(nsIURI *aContentLocation)
+{
+  nsAutoCString contentScheme;
+  nsresult rv = aContentLocation->GetScheme(contentScheme);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  // Check some exposed protocols. Not all protocols in the list of
+  // network.protocol-handler.expose.* prefs in all-thunderbird.js are
+  // admitted purely based on their scheme.
+  // news, snews, nntp, imap and mailbox are checked before the call
+  // to this function by matching content location and requesting location.
+  if (MsgLowerCaseEqualsLiteral(contentScheme, "mailto") ||
+      MsgLowerCaseEqualsLiteral(contentScheme, "addbook") ||
+      MsgLowerCaseEqualsLiteral(contentScheme, "about"))
+    return true;
+
+  // check if customized exposed scheme
+  if (mCustomExposedProtocols.Contains(contentScheme))
+    return true;
+
+  bool isData;
+  bool isChrome;
+  bool isRes;
+  rv = aContentLocation->SchemeIs("chrome", &isChrome);
+  NS_ENSURE_SUCCESS(rv, false);
+  rv = aContentLocation->SchemeIs("resource", &isRes);
+  NS_ENSURE_SUCCESS(rv, false);
+  rv = aContentLocation->SchemeIs("data", &isData);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  return isChrome || isRes || isData;
+}
+
+/**
+ * We block most unexposed protocols - apart from http(s) and file.
+ */
+bool
+nsMsgContentPolicy::ShouldBlockUnexposedProtocol(nsIURI *aContentLocation)
+{
+  bool isHttp;
+  bool isHttps;
+  bool isFile;
+  // Error condition - we must return true so that we block.
+  nsresult rv = aContentLocation->SchemeIs("http", &isHttp);
+  NS_ENSURE_SUCCESS(rv, true);
+  rv = aContentLocation->SchemeIs("https", &isHttps);
+  NS_ENSURE_SUCCESS(rv, true);
+  rv = aContentLocation->SchemeIs("file", &isFile);
+  NS_ENSURE_SUCCESS(rv, true);
+
+  return !isHttp && !isHttps && !isFile;
+}
+
+/**
+ * The default for this function will be to reject the content request.
+ * When determining if to allow the request for a given msg hdr, the function
+ * will go through the list of remote content blocking criteria:
+ *
+ * #1 Allow if there is a db header for a manual override.
+ * #2 Allow if the message is in an RSS folder.
+ * #3 Allow if the domain for the remote image in our white list.
+ * #4 Allow if the author has been specifically white listed.
+ */
+int16_t
+nsMsgContentPolicy::ShouldAcceptRemoteContentForMsgHdr(nsIMsgDBHdr *aMsgHdr,
+                                                       nsIURI *aRequestingLocation,
+                                                       nsIURI *aContentLocation)
+{
+  if (!aMsgHdr)
+    return static_cast<int16_t>(nsIContentPolicy::REJECT_REQUEST);
+
+  // Case #1, check the db hdr for the remote content policy on this particular
+  // message.
+  uint32_t remoteContentPolicy = kNoRemoteContentPolicy;
+  aMsgHdr->GetUint32Property("remoteContentPolicy", &remoteContentPolicy);
+
+  // Case #2, check if the message is in an RSS folder
+  bool isRSS = false;
+  IsRSSArticle(aRequestingLocation, &isRSS);
+
+  // Case #3, the domain for the remote image is in our white list
+  bool trustedDomain = IsTrustedDomain(aContentLocation);
+
+  // Case 4 means looking up items in the permissions database. So if
+  // either of the two previous items means we load the data, just do it.
+  if (isRSS || remoteContentPolicy == kAllowRemoteContent || trustedDomain)
+    return nsIContentPolicy::ACCEPT;
+
+  // Case #4, author is in our white list..
+  bool allowForSender = ShouldAcceptRemoteContentForSender(aMsgHdr);
+
+  int16_t result = allowForSender ?
+    static_cast<int16_t>(nsIContentPolicy::ACCEPT) :
+    static_cast<int16_t>(nsIContentPolicy::REJECT_REQUEST);
+
+  // kNoRemoteContentPolicy means we have never set a value on the message
+  if (result == nsIContentPolicy::REJECT_REQUEST && !remoteContentPolicy)
+    aMsgHdr->SetUint32Property("remoteContentPolicy", kBlockRemoteContent);
+
+  return result;
+}
+
+class RemoteContentNotifierEvent : public mozilla::Runnable
+{
+public:
+  RemoteContentNotifierEvent(nsIMsgWindow *aMsgWindow, nsIMsgDBHdr *aMsgHdr,
+                             nsIURI *aContentURI, bool aCanOverride = true)
+    : mMsgWindow(aMsgWindow), mMsgHdr(aMsgHdr), mContentURI(aContentURI),
+    mCanOverride(aCanOverride)
+  {}
+
+  NS_IMETHOD Run()
+  {
+    if (mMsgWindow)
+    {
+      nsCOMPtr<nsIMsgHeaderSink> msgHdrSink;
+      (void)mMsgWindow->GetMsgHeaderSink(getter_AddRefs(msgHdrSink));
+      if (msgHdrSink)
+        msgHdrSink->OnMsgHasRemoteContent(mMsgHdr, mContentURI, mCanOverride);
+    }
+    return NS_OK;
+  }
+
+private:
+  nsCOMPtr<nsIMsgWindow> mMsgWindow;
+  nsCOMPtr<nsIMsgDBHdr> mMsgHdr;
+  nsCOMPtr<nsIURI> mContentURI;
+  bool mCanOverride;
+};
+
+/**
+ * This function is used to show a blocked remote content notification.
+ */
+void
+nsMsgContentPolicy::NotifyContentWasBlocked(nsIURI *aOriginatorLocation,
+                                            nsIURI *aContentLocation,
+                                            bool aCanOverride)
+{
+  // Is it a mailnews url?
+  nsresult rv;
+  nsCOMPtr<nsIMsgMessageUrl> msgUrl(do_QueryInterface(aOriginatorLocation,
+                                                      &rv));
+  if (NS_FAILED(rv))
+  {
+    return;
+  }
+
+  nsCString resourceURI;
+  rv = msgUrl->GetUri(getter_Copies(resourceURI));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(aOriginatorLocation, &rv));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  rv = GetMsgDBHdrFromURI(resourceURI.get(), getter_AddRefs(msgHdr));
+  if (NS_FAILED(rv))
+  {
+    // Maybe we can get a dummy header.
+    nsCOMPtr<nsIMsgWindow> msgWindow;
+    rv = mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+    if (msgWindow)
+    {
+      nsCOMPtr<nsIMsgHeaderSink> msgHdrSink;
+      rv = msgWindow->GetMsgHeaderSink(getter_AddRefs(msgHdrSink));
+      if (msgHdrSink)
+        rv = msgHdrSink->GetDummyMsgHeader(getter_AddRefs(msgHdr));
+    }
+  }
+
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+  (void)mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+  if (msgWindow)
+  {
+    nsCOMPtr<nsIRunnable> event =
+      new RemoteContentNotifierEvent(msgWindow, msgHdr, aContentLocation, aCanOverride);
+    // Post this as an event because it can cause dom mutations, and we
+    // get called at a bad time to be causing dom mutations.
+    if (event)
+      NS_DispatchToCurrentThread(event);
+  }
+}
+
+/**
+ * This function is used to determine if we allow content for a remote message.
+ * If we reject loading remote content, then we'll inform the message window
+ * that this message has remote content (and hence we are not loading it).
+ *
+ * See ShouldAcceptRemoteContentForMsgHdr for the actual decisions that
+ * determine if we are going to allow remote content.
+ */
+void
+nsMsgContentPolicy::ShouldAcceptContentForPotentialMsg(nsIURI *aOriginatorLocation,
+                                                       nsIURI *aContentLocation,
+                                                       int16_t *aDecision)
+{
+  NS_PRECONDITION(*aDecision == nsIContentPolicy::REJECT_REQUEST,
+                  "AllowContentForPotentialMessage expects default decision to be reject!");
+
+  // Is it a mailnews url?
+  nsresult rv;
+  nsCOMPtr<nsIMsgMessageUrl> msgUrl(do_QueryInterface(aOriginatorLocation,
+                                                      &rv));
+  if (NS_FAILED(rv))
+  {
+    // It isn't a mailnews url - so we accept the load here, and let other
+    // content policies make the decision if we should be loading it or not.
+    *aDecision = nsIContentPolicy::ACCEPT;
+    return;
+  }
+
+  nsCString resourceURI;
+  rv = msgUrl->GetUri(getter_Copies(resourceURI));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(aOriginatorLocation, &rv));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  rv = GetMsgDBHdrFromURI(resourceURI.get(), getter_AddRefs(msgHdr));
+  if (NS_FAILED(rv))
+  {
+    // Maybe we can get a dummy header.
+    nsCOMPtr<nsIMsgWindow> msgWindow;
+    rv = mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+    if (msgWindow)
+    {
+      nsCOMPtr<nsIMsgHeaderSink> msgHdrSink;
+      rv = msgWindow->GetMsgHeaderSink(getter_AddRefs(msgHdrSink));
+      if (msgHdrSink)
+        rv = msgHdrSink->GetDummyMsgHeader(getter_AddRefs(msgHdr));
+    }
+  }
+
+  // Get a decision on whether or not to allow remote content for this message
+  // header.
+  *aDecision = ShouldAcceptRemoteContentForMsgHdr(msgHdr, aOriginatorLocation,
+                                                  aContentLocation);
+
+  // If we're not allowing the remote content, tell the nsIMsgWindow loading
+  // this url that this is the case, so that the UI knows to show the remote
+  // content header bar, so the user can override if they wish.
+  if (*aDecision == nsIContentPolicy::REJECT_REQUEST)
+  {
+    nsCOMPtr<nsIMsgWindow> msgWindow;
+    (void)mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+    if (msgWindow)
+    {
+      nsCOMPtr<nsIRunnable> event =
+        new RemoteContentNotifierEvent(msgWindow, msgHdr, aContentLocation);
+      // Post this as an event because it can cause dom mutations, and we
+      // get called at a bad time to be causing dom mutations.
+      if (event)
+        NS_DispatchToCurrentThread(event);
+    }
+  }
+}
+
+/**
+ * Content policy logic for compose windows
+ *
+ */
+void nsMsgContentPolicy::ComposeShouldLoad(nsIMsgCompose *aMsgCompose,
+                                           nsISupports *aRequestingContext,
+                                           nsIURI *aContentLocation,
+                                           int16_t *aDecision)
+{
+  NS_PRECONDITION(*aDecision == nsIContentPolicy::REJECT_REQUEST,
+                  "ComposeShouldLoad expects default decision to be reject!");
+
+  nsCString originalMsgURI;
+  nsresult rv = aMsgCompose->GetOriginalMsgURI(getter_Copies(originalMsgURI));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  MSG_ComposeType composeType;
+  rv = aMsgCompose->GetType(&composeType);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  // Only allow remote content for new mail compositions or mailto
+  // Block remote content for all other types (drafts, templates, forwards, replies, etc)
+  // unless there is an associated msgHdr which allows the load, or unless the image is being
+  // added by the user and not the quoted message content...
+  if (composeType == nsIMsgCompType::New ||
+      composeType == nsIMsgCompType::MailToUrl)
+    *aDecision = nsIContentPolicy::ACCEPT;
+  else if (!originalMsgURI.IsEmpty())
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    rv = GetMsgDBHdrFromURI(originalMsgURI.get(), getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS_VOID(rv);
+    *aDecision = ShouldAcceptRemoteContentForMsgHdr(msgHdr, nullptr,
+                                                    aContentLocation);
+
+    // Special case image elements. When replying to a message, we want to allow
+    // the user to add remote images to the message. But we don't want remote
+    // images that are a part of the quoted content to load. Hence we block them
+    // while the reply is created (insertingQuotedContent==true), but allow them
+    // later when the user inserts them.
+    if (*aDecision == nsIContentPolicy::REJECT_REQUEST)
+    {
+      bool insertingQuotedContent = true;
+      aMsgCompose->GetInsertingQuotedContent(&insertingQuotedContent);
+      nsCOMPtr<nsIDOMHTMLImageElement> imageElement(do_QueryInterface(aRequestingContext));
+      if (imageElement)
+      {
+        if (!insertingQuotedContent)
+        {
+          *aDecision = nsIContentPolicy::ACCEPT;
+          return;
+        }
+
+        // Test whitelist.
+        uint32_t permission;
+        mPermissionManager->TestPermission(aContentLocation, "image", &permission);
+        if (permission == nsIPermissionManager::ALLOW_ACTION)
+          *aDecision = nsIContentPolicy::ACCEPT;
+      }
+    }
+  }
+}
+
+already_AddRefed<nsIMsgCompose> nsMsgContentPolicy::GetMsgComposeForContext(nsISupports *aRequestingContext)
+{
+  nsresult rv;
+
+  nsIDocShell *shell = NS_CP_GetDocShellFromContext(aRequestingContext);
+  nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem(do_QueryInterface(shell, &rv));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  nsCOMPtr<nsIDocShellTreeItem> rootItem;
+  rv = docShellTreeItem->GetSameTypeRootTreeItem(getter_AddRefs(rootItem));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(rootItem, &rv));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  nsCOMPtr<nsIMsgComposeService> composeService(do_GetService(NS_MSGCOMPOSESERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  nsCOMPtr<nsIMsgCompose> msgCompose;
+  // Don't bother checking rv, as GetMsgComposeForDocShell returns NS_ERROR_FAILURE
+  // for not found.
+  composeService->GetMsgComposeForDocShell(docShell,
+                                           getter_AddRefs(msgCompose));
+  return msgCompose.forget();
+}
+
+nsresult nsMsgContentPolicy::SetDisableItemsOnMailNewsUrlDocshells(
+  nsIURI *aContentLocation, nsISupports *aRequestingContext)
+{
+  // XXX if this class changes so that this method can be called from
+  // ShouldProcess, and if it's possible for this to be null when called from
+  // ShouldLoad, but not in the corresponding ShouldProcess call,
+  // we need to re-think the assumptions underlying this code.
+
+  // If there's no docshell to get to, there's nowhere for the JavaScript to
+  // run, so we're already safe and don't need to disable anything.
+  if (!aRequestingContext) {
+    return NS_OK;
+  }
+
+  nsresult rv;
+  bool isAllowedContent = !ShouldBlockUnexposedProtocol(aContentLocation);
+  nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(aContentLocation, &rv);
+  if (NS_FAILED(rv) && !isAllowedContent) {
+    // If it's not a mailnews url or allowed content url (http[s]|file) then
+    // bail; otherwise set whether js and plugins are allowed.
+    return NS_OK;
+  }
+
+  // since NS_CP_GetDocShellFromContext returns the containing docshell rather
+  // than the contained one we need, we can't use that here, so...
+  nsCOMPtr<nsIFrameLoaderOwner> flOwner = do_QueryInterface(aRequestingContext,
+                                                            &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFrameLoader> frameLoader;
+  rv = flOwner->GetFrameLoaderXPCOM(getter_AddRefs(frameLoader));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(frameLoader, NS_ERROR_INVALID_POINTER);
+
+  nsCOMPtr<nsIDocShell> docShell;
+  rv = frameLoader->GetDocShell(getter_AddRefs(docShell));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDocShellTreeItem> docshellTreeItem(do_QueryInterface(docShell, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // what sort of docshell is this?
+  int32_t itemType;
+  rv = docshellTreeItem->GetItemType(&itemType);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // we're only worried about policy settings in content docshells
+  if (itemType != nsIDocShellTreeItem::typeContent) {
+    return NS_OK;
+  }
+
+  if (!isAllowedContent) {
+    // Disable JavaScript on message URLs.
+    rv = docShell->SetAllowJavascript(false);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = docShell->SetAllowContentRetargetingOnChildren(false);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = docShell->SetAllowPlugins(mAllowPlugins);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    uint32_t sandboxFlags;
+    rv = docShell->GetSandboxFlags(&sandboxFlags);
+    sandboxFlags |= SANDBOXED_FORMS;
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = docShell->SetSandboxFlags(sandboxFlags);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  else {
+    // JavaScript and plugins are allowed on non-message URLs.
+    rv = docShell->SetAllowJavascript(true);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = docShell->SetAllowContentRetargetingOnChildren(true);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = docShell->SetAllowPlugins(true);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+/**
+ * Gets the root docshell from a requesting context.
+ */
+nsresult
+nsMsgContentPolicy::GetRootDocShellForContext(nsISupports *aRequestingContext,
+                                              nsIDocShell **aDocShell)
+{
+  NS_ENSURE_ARG_POINTER(aRequestingContext);
+  nsresult rv;
+
+  nsIDocShell *shell = NS_CP_GetDocShellFromContext(aRequestingContext);
+  nsCOMPtr<nsIDocShellTreeItem> docshellTreeItem(do_QueryInterface(shell, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDocShellTreeItem> rootItem;
+  rv = docshellTreeItem->GetRootTreeItem(getter_AddRefs(rootItem));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return CallQueryInterface(rootItem, aDocShell);
+}
+
+/**
+ * Gets the originating URI that started off a set of requests, accounting
+ * for multiple iframes.
+ *
+ * Navigates up the docshell tree from aRequestingContext and finds the
+ * highest parent with the same type docshell as aRequestingContext, then
+ * returns the URI associated with that docshell.
+ */
+nsresult
+nsMsgContentPolicy::GetOriginatingURIForContext(nsISupports *aRequestingContext,
+                                                nsIURI **aURI)
+{
+  NS_ENSURE_ARG_POINTER(aRequestingContext);
+  nsresult rv;
+
+  nsIDocShell *shell = NS_CP_GetDocShellFromContext(aRequestingContext);
+  nsCOMPtr<nsIDocShellTreeItem> docshellTreeItem(do_QueryInterface(shell, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDocShellTreeItem> rootItem;
+  rv = docshellTreeItem->GetSameTypeRootTreeItem(getter_AddRefs(rootItem));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIWebNavigation> webNavigation(do_QueryInterface(rootItem, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return webNavigation->GetCurrentURI(aURI);
+}
+
+NS_IMETHODIMP
+nsMsgContentPolicy::ShouldProcess(uint32_t          aContentType,
+                                  nsIURI           *aContentLocation,
+                                  nsIURI           *aRequestingLocation,
+                                  nsISupports      *aRequestingContext,
+                                  const nsACString &aMimeGuess,
+                                  nsISupports      *aExtra,
+                                  nsIPrincipal     *aRequestPrincipal,
+                                  int16_t          *aDecision)
+{
+  // XXX Returning ACCEPT is presumably only a reasonable thing to do if we
+  // think that ShouldLoad is going to catch all possible cases (i.e. that
+  // everything we use to make decisions is going to be available at
+  // ShouldLoad time, and not only become available in time for ShouldProcess).
+  // Do we think that's actually the case?
+  *aDecision = nsIContentPolicy::ACCEPT;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgContentPolicy::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData)
+{
+  if (!strcmp(NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, aTopic))
+  {
+    NS_LossyConvertUTF16toASCII pref(aData);
+
+    nsresult rv;
+
+    nsCOMPtr<nsIPrefBranch> prefBranchInt = do_QueryInterface(aSubject, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (pref.Equals(kBlockRemoteImages))
+      prefBranchInt->GetBoolPref(kBlockRemoteImages, &mBlockRemoteImages);
+    if (pref.Equals(kAllowPlugins))
+      prefBranchInt->GetBoolPref(kAllowPlugins, &mAllowPlugins);
+  }
+
+  return NS_OK;
+}
+
+/**
+ * We implement the nsIWebProgressListener interface in order to enforce
+ * settings at onLocationChange time.
+ */
+NS_IMETHODIMP
+nsMsgContentPolicy::OnStateChange(nsIWebProgress *aWebProgress,
+                                  nsIRequest *aRequest, uint32_t aStateFlags,
+                                  nsresult aStatus)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgContentPolicy::OnProgressChange(nsIWebProgress *aWebProgress,
+                                     nsIRequest *aRequest,
+                                     int32_t aCurSelfProgress,
+                                     int32_t aMaxSelfProgress,
+                                     int32_t aCurTotalProgress,
+                                     int32_t aMaxTotalProgress)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgContentPolicy::OnLocationChange(nsIWebProgress *aWebProgress,
+                                     nsIRequest *aRequest, nsIURI *aLocation,
+                                     uint32_t aFlags)
+{
+  nsresult rv;
+
+  // If anything goes wrong and/or there's no docshell associated with this
+  // request, just give up.  The behavior ends up being "don't consider
+  // re-enabling JS on the docshell", which is the safe thing to do (and if
+  // the problem was that there's no docshell, that means that there was
+  // nowhere for any JavaScript to run, so we're already safe
+
+  nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(aWebProgress, &rv);
+  if (NS_FAILED(rv)) {
+    return NS_OK;
+  }
+
+#ifdef DEBUG
+  nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest, &rv);
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsIDocShell> docShell2;
+    NS_QueryNotificationCallbacks(channel, docShell2);
+    NS_ASSERTION(docShell == docShell2, "aWebProgress and channel callbacks"
+                                        " do not point to the same docshell");
+  }
+#endif
+
+  nsCOMPtr<nsIMsgMessageUrl> messageUrl = do_QueryInterface(aLocation, &rv);
+
+  if (NS_SUCCEEDED(rv)) {
+    // Disable javascript on message URLs.
+    rv = docShell->SetAllowJavascript(false);
+    NS_ASSERTION(NS_SUCCEEDED(rv),
+                 "Failed to set javascript disabled on docShell");
+    // Also disable plugins if the preference requires it.
+    rv = docShell->SetAllowPlugins(mAllowPlugins);
+    NS_ASSERTION(NS_SUCCEEDED(rv),
+                 "Failed to set plugins disabled on docShell");
+  }
+  else {
+    // Disable javascript and plugins are allowed on non-message URLs.
+    rv = docShell->SetAllowJavascript(true);
+    NS_ASSERTION(NS_SUCCEEDED(rv),
+                 "Failed to set javascript allowed on docShell");
+    rv = docShell->SetAllowPlugins(true);
+    NS_ASSERTION(NS_SUCCEEDED(rv),
+                 "Failed to set plugins allowed on docShell");
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgContentPolicy::OnStatusChange(nsIWebProgress *aWebProgress,
+                                   nsIRequest *aRequest, nsresult aStatus,
+                                   const char16_t *aMessage)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgContentPolicy::OnSecurityChange(nsIWebProgress *aWebProgress,
+                                     nsIRequest *aRequest, uint32_t aState)
+{
+  return NS_OK;
+}
+
+/**
+ * Implementation of nsIMsgContentPolicy
+ *
+ */
+NS_IMETHODIMP
+nsMsgContentPolicy::AddExposedProtocol(const nsACString &aScheme)
+{
+  if (mCustomExposedProtocols.Contains(nsCString(aScheme)))
+    return NS_OK;
+
+  mCustomExposedProtocols.AppendElement(aScheme);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgContentPolicy::RemoveExposedProtocol(const nsACString &aScheme)
+{
+  mCustomExposedProtocols.RemoveElement(nsCString(aScheme));
+
+  return NS_OK;
+}
+
diff --git a/mailnews/base/src/nsMsgContentPolicy.h b/mailnews/base/src/nsMsgContentPolicy.h
new file mode 100644
index 000000000..745708683
--- /dev/null
+++ b/mailnews/base/src/nsMsgContentPolicy.h
@@ -0,0 +1,93 @@
+/* -*- 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/. */
+
+/**********************************************************************************
+ * nsMsgContentPolicy enforces the specified content policy on images, js, plugins, etc.
+ * This is the class used to determine what elements in a message should be loaded.
+ *
+ * nsMsgCookiePolicy enforces our cookie policy for mail and RSS messages. 
+ ***********************************************************************************/
+
+#ifndef _nsMsgContentPolicy_H_
+#define _nsMsgContentPolicy_H_
+
+#include "nsIContentPolicy.h"
+#include "nsIObserver.h"
+#include "nsWeakReference.h"
+#include "nsStringGlue.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIWebProgressListener.h"
+#include "nsIMsgCompose.h"
+#include "nsIDocShell.h"
+#include "nsIPermissionManager.h"
+#include "nsIMsgContentPolicy.h"
+#include "nsTArray.h"
+
+/* DBFCFDF0-4489-4faa-8122-190FD1EFA16C */
+#define NS_MSGCONTENTPOLICY_CID \
+{ 0xdbfcfdf0, 0x4489, 0x4faa, { 0x81, 0x22, 0x19, 0xf, 0xd1, 0xef, 0xa1, 0x6c } }
+
+#define NS_MSGCONTENTPOLICY_CONTRACTID "@mozilla.org/messenger/content-policy;1"
+
+class nsIMsgDBHdr;
+class nsIDocShell;
+
+class nsMsgContentPolicy : public nsIContentPolicy,
+                           public nsIObserver,
+                           public nsIWebProgressListener,
+                           public nsIMsgContentPolicy,
+                           public nsSupportsWeakReference
+{
+public:
+  nsMsgContentPolicy();
+
+  nsresult Init();
+    
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONTENTPOLICY
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSIWEBPROGRESSLISTENER
+  NS_DECL_NSIMSGCONTENTPOLICY
+  
+protected:
+  virtual ~nsMsgContentPolicy();
+
+  bool     mBlockRemoteImages;
+  bool     mAllowPlugins;
+  nsCString mTrustedMailDomains;
+  nsCOMPtr<nsIPermissionManager> mPermissionManager;
+
+  bool IsTrustedDomain(nsIURI * aContentLocation);
+  bool IsSafeRequestingLocation(nsIURI *aRequestingLocation);
+  bool IsExposedProtocol(nsIURI *aContentLocation);
+  bool IsExposedChromeProtocol(nsIURI *aContentLocation);
+  bool ShouldBlockUnexposedProtocol(nsIURI *aContentLocation);
+
+  bool ShouldAcceptRemoteContentForSender(nsIMsgDBHdr *aMsgHdr);
+  int16_t ShouldAcceptRemoteContentForMsgHdr(nsIMsgDBHdr *aMsgHdr,
+                                             nsIURI *aRequestingLocation,
+                                             nsIURI *aContentLocation);
+  void NotifyContentWasBlocked(nsIURI *aOriginatorLocation,
+                               nsIURI *aContentLocation,
+                               bool aCanOverride);
+  void ShouldAcceptContentForPotentialMsg(nsIURI *aOriginatorLocation,
+                                          nsIURI *aContentLocation,
+                                          int16_t *aDecision);
+  void ComposeShouldLoad(nsIMsgCompose *aMsgCompose,
+                         nsISupports *aRequestingContext, 
+                         nsIURI *aContentLocation, int16_t *aDecision);
+  already_AddRefed<nsIMsgCompose> GetMsgComposeForContext(nsISupports *aRequestingContext);
+
+  nsresult GetRootDocShellForContext(nsISupports *aRequestingContext,
+                                     nsIDocShell **aDocShell);
+  nsresult GetOriginatingURIForContext(nsISupports *aRequestingContext,
+                                       nsIURI **aURI);
+  nsresult SetDisableItemsOnMailNewsUrlDocshells(nsIURI *aContentLocation,
+                                                 nsISupports *aRequestingContext);
+
+  nsTArray<nsCString> mCustomExposedProtocols;
+};
+
+#endif // _nsMsgContentPolicy_H_
diff --git a/mailnews/base/src/nsMsgCopyService.cpp b/mailnews/base/src/nsMsgCopyService.cpp
new file mode 100644
index 000000000..e7b79bd56
--- /dev/null
+++ b/mailnews/base/src/nsMsgCopyService.cpp
@@ -0,0 +1,708 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgCopyService.h"
+#include "nsCOMArray.h"
+#include "nspr.h"
+#include "nsIFile.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMutableArray.h"
+#include "nsArrayUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Logging.h"
+
+static PRLogModuleInfo *gCopyServiceLog;
+
+// ******************** nsCopySource ******************
+//
+
+nsCopySource::nsCopySource() : m_processed(false)
+{
+  MOZ_COUNT_CTOR(nsCopySource);
+  m_messageArray = do_CreateInstance(NS_ARRAY_CONTRACTID);
+}
+
+nsCopySource::nsCopySource(nsIMsgFolder* srcFolder) :
+    m_processed(false)
+{
+  MOZ_COUNT_CTOR(nsCopySource);
+  m_messageArray = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  m_msgFolder = srcFolder;
+}
+
+nsCopySource::~nsCopySource()
+{
+  MOZ_COUNT_DTOR(nsCopySource);
+}
+
+void nsCopySource::AddMessage(nsIMsgDBHdr* aMsg)
+{
+  m_messageArray->AppendElement(aMsg, false);
+}
+
+// ************ nsCopyRequest *****************
+//
+
+nsCopyRequest::nsCopyRequest() :
+    m_requestType(nsCopyMessagesType),
+    m_isMoveOrDraftOrTemplate(false),
+    m_processed(false),
+    m_newMsgFlags(0)
+{
+  MOZ_COUNT_CTOR(nsCopyRequest);
+}
+
+nsCopyRequest::~nsCopyRequest()
+{
+  MOZ_COUNT_DTOR(nsCopyRequest);
+
+  int32_t j = m_copySourceArray.Length();
+  while(j-- > 0)
+    delete m_copySourceArray.ElementAt(j);
+}
+
+nsresult
+nsCopyRequest::Init(nsCopyRequestType type, nsISupports* aSupport,
+                    nsIMsgFolder* dstFolder,
+                    bool bVal, uint32_t newMsgFlags, 
+                    const nsACString &newMsgKeywords,
+                    nsIMsgCopyServiceListener* listener,
+                    nsIMsgWindow* msgWindow, bool allowUndo)
+{
+  nsresult rv = NS_OK;
+  m_requestType = type;
+  m_srcSupport = aSupport;
+  m_dstFolder = dstFolder;
+  m_isMoveOrDraftOrTemplate = bVal;
+  m_allowUndo = allowUndo;
+  m_newMsgFlags = newMsgFlags;
+  m_newMsgKeywords = newMsgKeywords;
+
+  if (listener)
+      m_listener = listener;
+  if (msgWindow)
+  {
+    m_msgWindow = msgWindow;
+    if (m_allowUndo)
+      msgWindow->GetTransactionManager(getter_AddRefs(m_txnMgr));
+  }
+  if (type == nsCopyFoldersType)
+  {
+    // To support multiple copy folder operations to the same destination, we
+    // need to save the leaf name of the src file spec so that FindRequest() is
+    // able to find the right request when copy finishes.
+    nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryInterface(aSupport, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsString folderName;
+    rv = srcFolder->GetName(folderName);
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_dstFolderName = folderName;
+  }
+
+  return rv;
+}
+
+nsCopySource*
+nsCopyRequest::AddNewCopySource(nsIMsgFolder* srcFolder)
+{
+  nsCopySource* newSrc = new nsCopySource(srcFolder);
+  if (newSrc)
+  {
+      m_copySourceArray.AppendElement(newSrc);
+      if (srcFolder == m_dstFolder)
+        newSrc->m_processed = true;
+  }
+  return newSrc;
+}
+
+// ************* nsMsgCopyService ****************
+//
+
+
+nsMsgCopyService::nsMsgCopyService()
+{
+  gCopyServiceLog = PR_NewLogModule("MsgCopyService");
+}
+
+nsMsgCopyService::~nsMsgCopyService()
+{
+  int32_t i = m_copyRequests.Length();
+
+  while (i-- > 0)
+    ClearRequest(m_copyRequests.ElementAt(i), NS_ERROR_FAILURE);
+}
+
+void nsMsgCopyService::LogCopyCompletion(nsISupports *aSrc, nsIMsgFolder *aDest)
+{
+  nsCString srcFolderUri, destFolderUri;
+  nsCOMPtr<nsIMsgFolder> srcFolder(do_QueryInterface(aSrc));
+  if (srcFolder)
+    srcFolder->GetURI(srcFolderUri);
+  aDest->GetURI(destFolderUri);
+  MOZ_LOG(gCopyServiceLog, mozilla::LogLevel::Info,
+         ("NotifyCompletion - src %s dest %s\n",
+          srcFolderUri.get(), destFolderUri.get()));
+}
+
+void nsMsgCopyService::LogCopyRequest(const char *logMsg, nsCopyRequest* aRequest)
+{
+  nsCString srcFolderUri, destFolderUri;
+  nsCOMPtr<nsIMsgFolder> srcFolder(do_QueryInterface(aRequest->m_srcSupport));
+  if (srcFolder)
+    srcFolder->GetURI(srcFolderUri);
+  aRequest->m_dstFolder->GetURI(destFolderUri);
+  uint32_t numMsgs = 0;
+  if (aRequest->m_requestType == nsCopyMessagesType &&
+      aRequest->m_copySourceArray.Length() > 0 &&
+      aRequest->m_copySourceArray[0]->m_messageArray)
+    aRequest->m_copySourceArray[0]->m_messageArray->GetLength(&numMsgs);
+  MOZ_LOG(gCopyServiceLog, mozilla::LogLevel::Info,
+         ("request %lx %s - src %s dest %s numItems %d type=%d",
+         aRequest, logMsg, srcFolderUri.get(),
+         destFolderUri.get(), numMsgs, aRequest->m_requestType));
+}
+
+nsresult
+nsMsgCopyService::ClearRequest(nsCopyRequest* aRequest, nsresult rv)
+{
+  if (aRequest)
+  {
+    if (MOZ_LOG_TEST(gCopyServiceLog, mozilla::LogLevel::Info))
+      LogCopyRequest(NS_SUCCEEDED(rv) ? "Clearing OK request" 
+                                      : "Clearing failed request", aRequest);
+
+    // Send notifications to nsIMsgFolderListeners
+    if (NS_SUCCEEDED(rv) && aRequest->m_requestType == nsCopyFoldersType)
+    {
+      nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+      if (notifier)
+      {
+        bool hasListeners;
+        notifier->GetHasListeners(&hasListeners);
+        if (hasListeners)
+        {
+          // Iterate over the copy sources and append their message arrays to this mutable array
+          // or in the case of folders, the source folder.
+          int32_t cnt, i;
+          cnt = aRequest->m_copySourceArray.Length();
+          for (i = 0; i < cnt; i++)
+          {
+            nsCopySource *copySource = aRequest->m_copySourceArray.ElementAt(i);
+            notifier->NotifyFolderMoveCopyCompleted(aRequest->m_isMoveOrDraftOrTemplate, copySource->m_msgFolder, aRequest->m_dstFolder);
+          }
+        }
+      }
+    }
+
+    // undo stuff
+    if (aRequest->m_allowUndo &&
+        aRequest->m_copySourceArray.Length() > 1 &&
+        aRequest->m_txnMgr)
+        aRequest->m_txnMgr->EndBatch(false);
+
+    m_copyRequests.RemoveElement(aRequest);
+    if (aRequest->m_listener)
+        aRequest->m_listener->OnStopCopy(rv);
+    delete aRequest;
+  }
+
+  return rv;
+}
+
+nsresult
+nsMsgCopyService::QueueRequest(nsCopyRequest* aRequest, bool *aCopyImmediately)
+{
+  NS_ENSURE_ARG_POINTER(aRequest);
+  NS_ENSURE_ARG_POINTER(aCopyImmediately);
+  *aCopyImmediately = true;
+  nsCopyRequest* copyRequest;
+
+  uint32_t cnt = m_copyRequests.Length();
+  for (uint32_t i = 0; i < cnt; i++)
+  {
+    copyRequest = m_copyRequests.ElementAt(i);
+    if (aRequest->m_requestType == nsCopyFoldersType)
+    {
+      // For copy folder, see if both destination folder (root)
+      // (ie, Local Folder) and folder name (ie, abc) are the same.
+      if (copyRequest->m_dstFolderName == aRequest->m_dstFolderName &&
+          copyRequest->m_dstFolder.get() == aRequest->m_dstFolder.get())
+      {
+        *aCopyImmediately = false;
+        break;
+      }
+    }
+    else if (copyRequest->m_dstFolder.get() == aRequest->m_dstFolder.get())  //if dst are same and we already have a request, we cannot copy immediately
+    {
+      *aCopyImmediately = false;
+      break;
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgCopyService::DoCopy(nsCopyRequest* aRequest)
+{
+  NS_ENSURE_ARG(aRequest);
+  bool copyImmediately;
+  QueueRequest(aRequest, &copyImmediately);
+  m_copyRequests.AppendElement(aRequest);
+  if (MOZ_LOG_TEST(gCopyServiceLog, mozilla::LogLevel::Info))
+    LogCopyRequest(copyImmediately ? "DoCopy" : "QueueRequest", aRequest);
+
+  // if no active request for this dest folder then we can copy immediately
+  if (copyImmediately)
+    return DoNextCopy();
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgCopyService::DoNextCopy()
+{
+  nsresult rv = NS_OK;
+  nsCopyRequest* copyRequest = nullptr;
+  nsCopySource* copySource = nullptr;
+  uint32_t i, j, scnt;
+
+  uint32_t cnt = m_copyRequests.Length();
+  if (cnt > 0)
+  {
+    nsCOMArray<nsIMsgFolder> activeTargets;
+
+    // ** jt -- always FIFO
+    for (i = 0; i < cnt; i++)
+    {
+      copyRequest = m_copyRequests.ElementAt(i);
+      copySource = nullptr;
+      scnt = copyRequest->m_copySourceArray.Length();
+      if (!copyRequest->m_processed)
+      {
+        // if the target folder of this request already has an active
+        // copy request, skip this request for now.
+        if (activeTargets.ContainsObject(copyRequest->m_dstFolder))
+        {
+          copyRequest = nullptr;
+          continue;
+        }
+        if (scnt <= 0)
+            goto found; // must be CopyFileMessage
+        for (j = 0; j < scnt; j++)
+        {
+          copySource = copyRequest->m_copySourceArray.ElementAt(j);
+          if (!copySource->m_processed)
+            goto found;
+        }
+        if (j >= scnt) // all processed set the value
+          copyRequest->m_processed = true;
+      }
+      if (copyRequest->m_processed) // keep track of folders actively getting copied to.
+        activeTargets.AppendObject(copyRequest->m_dstFolder);
+    }
+    found:
+      if (copyRequest && !copyRequest->m_processed)
+      {
+          if (copyRequest->m_listener)
+              copyRequest->m_listener->OnStartCopy();
+          if (copyRequest->m_requestType == nsCopyMessagesType &&
+              copySource)
+          {
+              copySource->m_processed = true;
+              rv = copyRequest->m_dstFolder->CopyMessages
+                  (copySource->m_msgFolder, copySource->m_messageArray,
+                   copyRequest->m_isMoveOrDraftOrTemplate,
+                   copyRequest->m_msgWindow, copyRequest->m_listener, false, copyRequest->m_allowUndo);   //isFolder operation false
+
+          }
+          else if (copyRequest->m_requestType == nsCopyFoldersType)
+          {
+              NS_ENSURE_STATE(copySource);
+              copySource->m_processed = true;
+              rv = copyRequest->m_dstFolder->CopyFolder
+                  (copySource->m_msgFolder,
+                   copyRequest->m_isMoveOrDraftOrTemplate,
+                   copyRequest->m_msgWindow, copyRequest->m_listener);
+              // If it's a copy folder operation and the destination
+              // folder already exists, CopyFolder() returns an error w/o sending
+              // a completion notification, so clear it here.
+              if (NS_FAILED(rv))
+                ClearRequest(copyRequest, rv);
+
+          }
+          else if (copyRequest->m_requestType == nsCopyFileMessageType)
+          {
+            nsCOMPtr<nsIFile> aFile(do_QueryInterface(copyRequest->m_srcSupport, &rv));
+            if (NS_SUCCEEDED(rv))
+            {
+                // ** in case of saving draft/template; the very first
+                // time we may not have the original message to replace
+                // with; if we do we shall have an instance of copySource
+                nsCOMPtr<nsIMsgDBHdr> aMessage;
+                if (copySource)
+                {
+                    aMessage = do_QueryElementAt(copySource->m_messageArray,
+                                                 0, &rv);
+                    copySource->m_processed = true;
+                }
+                copyRequest->m_processed = true;
+                rv = copyRequest->m_dstFolder->CopyFileMessage
+                    (aFile, aMessage,
+                     copyRequest->m_isMoveOrDraftOrTemplate,
+                     copyRequest->m_newMsgFlags,
+                     copyRequest->m_newMsgKeywords,
+                     copyRequest->m_msgWindow,
+                     copyRequest->m_listener);
+            }
+          }
+      }
+    }
+    return rv;
+}
+
+/**
+ * Find a request in m_copyRequests which matches the passed in source 
+ * and destination folders.
+ *
+ * @param aSupport the iSupports of the source folder.
+ * @param dstFolder the destination folder of the copy request.
+ */
+nsCopyRequest*
+nsMsgCopyService::FindRequest(nsISupports* aSupport,
+                              nsIMsgFolder* dstFolder)
+{
+  nsCopyRequest* copyRequest = nullptr;
+  uint32_t cnt = m_copyRequests.Length();
+  for (uint32_t i = 0; i < cnt; i++)
+  {
+    copyRequest = m_copyRequests.ElementAt(i);
+    if (copyRequest->m_requestType == nsCopyFoldersType)
+    {
+        // If the src is different then check next request.
+        if (copyRequest->m_srcSupport.get() != aSupport)
+        {
+          copyRequest = nullptr;
+          continue;
+        }
+
+        // See if the parent of the copied folder is the same as the one when the request was made.
+        // Note if the destination folder is already a server folder then no need to get parent.
+        nsCOMPtr <nsIMsgFolder> parentMsgFolder;
+        nsresult rv = NS_OK;
+        bool isServer=false;
+        dstFolder->GetIsServer(&isServer);
+        if (!isServer)
+          rv = dstFolder->GetParent(getter_AddRefs(parentMsgFolder));
+        if ((NS_FAILED(rv)) || (!parentMsgFolder && !isServer) || (copyRequest->m_dstFolder.get() != parentMsgFolder))
+        {
+          copyRequest = nullptr;
+          continue;
+        }
+
+        // Now checks if the folder name is the same.
+        nsString folderName;
+        rv = dstFolder->GetName(folderName);
+        if (NS_FAILED(rv))
+        {
+          copyRequest = nullptr;
+          continue;
+        }
+
+        if (copyRequest->m_dstFolderName == folderName)
+          break;
+    }
+    else if (copyRequest->m_srcSupport.get() == aSupport &&
+        copyRequest->m_dstFolder.get() == dstFolder)
+        break;
+    else
+        copyRequest = nullptr;
+  }
+
+  return copyRequest;
+}
+
+NS_IMPL_ISUPPORTS(nsMsgCopyService, nsIMsgCopyService)
+
+NS_IMETHODIMP
+nsMsgCopyService::CopyMessages(nsIMsgFolder* srcFolder, /* UI src folder */
+                               nsIArray* messages,
+                               nsIMsgFolder* dstFolder,
+                               bool isMove,
+                               nsIMsgCopyServiceListener* listener,
+                               nsIMsgWindow* window,
+                               bool allowUndo)
+{
+  NS_ENSURE_ARG_POINTER(srcFolder);
+  NS_ENSURE_ARG_POINTER(messages);
+  NS_ENSURE_ARG_POINTER(dstFolder);
+
+  MOZ_LOG(gCopyServiceLog, mozilla::LogLevel::Debug, ("CopyMessages"));
+
+  if (srcFolder == dstFolder)
+  {
+    NS_ERROR("src and dest folders for msg copy can't be the same");
+    return NS_ERROR_FAILURE;
+  }
+  nsCopyRequest* copyRequest;
+  nsCopySource* copySource = nullptr;
+  nsCOMArray<nsIMsgDBHdr> msgArray;
+  uint32_t cnt;
+  nsCOMPtr<nsIMsgDBHdr> msg;
+  nsCOMPtr<nsIMsgFolder> curFolder;
+  nsCOMPtr<nsISupports> aSupport;
+  nsresult rv;
+
+  // XXX TODO
+  // JUNK MAIL RELATED
+  // make sure dest folder exists
+  // and has proper flags, before we start copying?
+
+  // bail early if nothing to do
+  messages->GetLength(&cnt);
+  if (!cnt)
+  {
+    if (listener)
+    {
+      listener->OnStartCopy();
+      listener->OnStopCopy(NS_OK);
+    }
+    return NS_OK;
+  }
+
+  copyRequest = new nsCopyRequest();
+  if (!copyRequest)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  aSupport = do_QueryInterface(srcFolder, &rv);
+
+  rv = copyRequest->Init(nsCopyMessagesType, aSupport, dstFolder, isMove,
+                        0 /* new msg flags, not used */, EmptyCString(), 
+                        listener, window, allowUndo);
+  if (NS_FAILED(rv))
+    goto done;
+
+  if (MOZ_LOG_TEST(gCopyServiceLog, mozilla::LogLevel::Info))
+    LogCopyRequest("CopyMessages request", copyRequest);
+
+  // duplicate the message array so we could sort the messages by it's
+  // folder easily
+  for (uint32_t i = 0; i < cnt; i++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> currMsg = do_QueryElementAt(messages, i);
+    msgArray.AppendObject(currMsg);
+  }
+
+  cnt = msgArray.Count();
+
+  while (cnt-- > 0)
+  {
+    msg = msgArray[cnt];
+    rv = msg->GetFolder(getter_AddRefs(curFolder));
+
+    if (NS_FAILED(rv))
+      goto done;
+    if (!copySource)
+    {
+      copySource = copyRequest->AddNewCopySource(curFolder);
+      if (!copySource)
+      {
+         rv = NS_ERROR_OUT_OF_MEMORY;
+         goto done;
+      }
+    }
+
+    if (curFolder == copySource->m_msgFolder)
+    {
+      copySource->AddMessage(msg);
+      msgArray.RemoveObjectAt(cnt);
+    }
+
+    if (cnt == 0)
+    {
+      cnt = msgArray.Count();
+      if (cnt > 0)
+        copySource = nullptr; // * force to create a new one and
+                             // * continue grouping the messages
+    }
+  }
+
+  // undo stuff
+  if (NS_SUCCEEDED(rv) && copyRequest->m_allowUndo && copyRequest->m_copySourceArray.Length() > 1 &&
+      copyRequest->m_txnMgr)
+    copyRequest->m_txnMgr->BeginBatch(nullptr);
+
+done:
+
+    if (NS_FAILED(rv))
+      delete copyRequest;
+    else
+      rv = DoCopy(copyRequest);
+
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMsgCopyService::CopyFolders(nsIArray* folders,
+                              nsIMsgFolder* dstFolder,
+                              bool isMove,
+                              nsIMsgCopyServiceListener* listener,
+                              nsIMsgWindow* window)
+{
+  NS_ENSURE_ARG_POINTER(folders);
+  NS_ENSURE_ARG_POINTER(dstFolder);
+  nsCopyRequest* copyRequest;
+  nsCopySource* copySource = nullptr;
+  nsresult rv;
+  uint32_t cnt;
+  nsCOMPtr<nsIMsgFolder> curFolder;
+  nsCOMPtr<nsISupports> support;
+
+  rv = folders->GetLength(&cnt);   //if cnt is zero it cannot to get this point, will be detected earlier
+  if (cnt > 1)
+    NS_ASSERTION((NS_SUCCEEDED(rv)),"More than one folders to copy");
+
+  support = do_QueryElementAt(folders, 0);
+
+  copyRequest = new nsCopyRequest();
+  if (!copyRequest) return NS_ERROR_OUT_OF_MEMORY;
+
+  rv = copyRequest->Init(nsCopyFoldersType, support, dstFolder,
+    isMove, 0 /* new msg flags, not used */ , EmptyCString(), listener, window, false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  curFolder = do_QueryInterface(support, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  copySource = copyRequest->AddNewCopySource(curFolder);
+  if (!copySource)
+    rv = NS_ERROR_OUT_OF_MEMORY;
+
+  if (NS_FAILED(rv))
+  {
+    delete copyRequest;
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  else
+    rv = DoCopy(copyRequest);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgCopyService::CopyFileMessage(nsIFile* file,
+                                  nsIMsgFolder* dstFolder,
+                                  nsIMsgDBHdr* msgToReplace,
+                                  bool isDraft,
+                                  uint32_t aMsgFlags,
+                                  const nsACString &aNewMsgKeywords,
+                                  nsIMsgCopyServiceListener* listener,
+                                  nsIMsgWindow* window)
+{
+  nsresult rv = NS_ERROR_NULL_POINTER;
+  nsCopyRequest* copyRequest;
+  nsCopySource* copySource = nullptr;
+  nsCOMPtr<nsISupports> fileSupport;
+  nsCOMPtr<nsITransactionManager> txnMgr;
+
+  NS_ENSURE_ARG_POINTER(file);
+  NS_ENSURE_ARG_POINTER(dstFolder);
+
+  if (window)
+    window->GetTransactionManager(getter_AddRefs(txnMgr));
+  copyRequest = new nsCopyRequest();
+  if (!copyRequest) return rv;
+  fileSupport = do_QueryInterface(file, &rv);
+  if (NS_FAILED(rv)) goto done;
+
+  rv = copyRequest->Init(nsCopyFileMessageType, fileSupport, dstFolder,
+                         isDraft, aMsgFlags, aNewMsgKeywords, listener, window, false);
+  if (NS_FAILED(rv)) goto done;
+
+  if (msgToReplace)
+  {
+    // The actual source of the message is a file not a folder, but
+    // we still need an nsCopySource to reference the old message header
+    // which will be used to recover message metadata.
+    copySource = copyRequest->AddNewCopySource(nullptr);
+    if (!copySource)
+    {
+        rv = NS_ERROR_OUT_OF_MEMORY;
+        goto done;
+    }
+    copySource->AddMessage(msgToReplace);
+  }
+
+done:
+    if (NS_FAILED(rv))
+    {
+      delete copyRequest;
+    }
+    else
+    {
+      rv = DoCopy(copyRequest);
+    }
+
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMsgCopyService::NotifyCompletion(nsISupports* aSupport,
+                                   nsIMsgFolder* dstFolder,
+                                   nsresult result)
+{
+  if (MOZ_LOG_TEST(gCopyServiceLog, mozilla::LogLevel::Info))
+    LogCopyCompletion(aSupport, dstFolder);
+  nsCopyRequest* copyRequest = nullptr;
+  uint32_t numOrigRequests = m_copyRequests.Length();
+  do
+  {
+    // loop for copy requests, because if we do a cross server folder copy,
+    // we'll have a copy request for the folder copy, which will in turn
+    // generate a copy request for the messages in the folder, which
+    // will have the same src support.
+    copyRequest = FindRequest(aSupport, dstFolder);
+
+    if (copyRequest)
+    {
+      // ClearRequest can cause a new request to get added to m_copyRequests
+      // with matching source and dest folders if the copy listener starts
+      // a new copy. We want to ignore any such request here, because it wasn't
+      // the one that was completed. So we keep track of how many original
+      // requests there were.
+      if (m_copyRequests.IndexOf(copyRequest) >= numOrigRequests)
+        break;
+      // check if this copy request is done by making sure all the
+      // sources have been processed.
+      int32_t sourceIndex, sourceCount;
+      sourceCount = copyRequest->m_copySourceArray.Length();
+      for (sourceIndex = 0; sourceIndex < sourceCount;)
+      {
+        if (!(copyRequest->m_copySourceArray.ElementAt(sourceIndex))->m_processed)
+            break;
+         sourceIndex++;
+      }
+      // if all sources processed, mark the request as processed
+      if (sourceIndex >= sourceCount)
+        copyRequest->m_processed = true;
+      // if this request is done, or failed, clear it.
+      if (copyRequest->m_processed || NS_FAILED(result))
+      {
+        ClearRequest(copyRequest, result);
+        numOrigRequests--;
+      }
+      else
+        break;
+    }
+    else
+      break;
+  }
+  while (copyRequest);
+
+  return DoNextCopy();
+}
+
diff --git a/mailnews/base/src/nsMsgCopyService.h b/mailnews/base/src/nsMsgCopyService.h
new file mode 100644
index 000000000..dfb9acc7a
--- /dev/null
+++ b/mailnews/base/src/nsMsgCopyService.h
@@ -0,0 +1,94 @@
+/* -*- 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 nsMsgCopyService_h__
+#define nsMsgCopyService_h__
+
+#include "nscore.h"
+#include "nsIMsgCopyService.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgWindow.h"
+#include "nsIMutableArray.h"
+#include "nsITransactionManager.h"
+#include "nsTArray.h"
+
+typedef enum _nsCopyRequestType
+{
+    nsCopyMessagesType = 0x0,
+    nsCopyFileMessageType = 0x1,
+    nsCopyFoldersType = 0x2
+} nsCopyRequestType;
+
+class nsCopyRequest;
+
+class nsCopySource
+{
+public:
+    nsCopySource();
+    nsCopySource(nsIMsgFolder* srcFolder);
+    ~nsCopySource();
+    void AddMessage(nsIMsgDBHdr* aMsg);
+
+    nsCOMPtr<nsIMsgFolder> m_msgFolder;
+    nsCOMPtr<nsIMutableArray> m_messageArray;
+    bool m_processed;
+};
+
+class nsCopyRequest 
+{
+public:
+    nsCopyRequest();
+    ~nsCopyRequest();
+
+    nsresult Init(nsCopyRequestType type, nsISupports* aSupport,
+                  nsIMsgFolder* dstFolder,
+                  bool bVal, uint32_t newMsgFlags, 
+                  const nsACString &newMsgKeywords,
+                  nsIMsgCopyServiceListener* listener,
+                  nsIMsgWindow *msgWindow, bool allowUndo);
+    nsCopySource* AddNewCopySource(nsIMsgFolder* srcFolder);
+
+    nsCOMPtr<nsISupports> m_srcSupport; // ui source folder or file spec
+    nsCOMPtr<nsIMsgFolder> m_dstFolder;
+    nsCOMPtr<nsIMsgWindow> m_msgWindow;
+    nsCOMPtr<nsIMsgCopyServiceListener> m_listener;
+    nsCOMPtr<nsITransactionManager> m_txnMgr;
+    nsCopyRequestType m_requestType;
+    bool m_isMoveOrDraftOrTemplate;
+    bool m_allowUndo;
+    bool m_processed;
+    uint32_t m_newMsgFlags;
+    nsCString m_newMsgKeywords;
+    nsString m_dstFolderName;      // used for copy folder.
+    nsTArray<nsCopySource*> m_copySourceArray; // array of nsCopySource
+};
+
+class nsMsgCopyService : public nsIMsgCopyService
+{
+public:
+  nsMsgCopyService();
+
+  NS_DECL_THREADSAFE_ISUPPORTS 
+
+  NS_DECL_NSIMSGCOPYSERVICE
+
+private:
+  virtual ~nsMsgCopyService();
+
+  nsresult ClearRequest(nsCopyRequest* aRequest, nsresult rv);
+  nsresult DoCopy(nsCopyRequest* aRequest);
+  nsresult DoNextCopy();
+  nsCopyRequest* FindRequest(nsISupports* aSupport, nsIMsgFolder* dstFolder);
+  nsresult QueueRequest(nsCopyRequest* aRequest, bool *aCopyImmediately);
+  void LogCopyCompletion(nsISupports *aSrc, nsIMsgFolder *aDest);
+  void LogCopyRequest(const char *logMsg, nsCopyRequest* aRequest);
+
+  nsTArray<nsCopyRequest*> m_copyRequests;
+};
+
+
+#endif 
diff --git a/mailnews/base/src/nsMsgDBView.cpp b/mailnews/base/src/nsMsgDBView.cpp
new file mode 100644
index 000000000..f7856dd4d
--- /dev/null
+++ b/mailnews/base/src/nsMsgDBView.cpp
@@ -0,0 +1,8066 @@
+/* -*- 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 "prmem.h"
+#include "nsArrayUtils.h"
+#include "nsIMsgCustomColumnHandler.h"
+#include "nsMsgDBView.h"
+#include "nsISupports.h"
+#include "nsIMsgFolder.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgFolder.h"
+#include "MailNewsTypes2.h"
+#include "nsMsgUtils.h"
+#include "nsQuickSort.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsImapCore.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIDOMElement.h"
+#include "nsDateTimeFormatCID.h"
+#include "nsMsgMimeCID.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefLocalizedString.h"
+#include "nsIMsgSearchSession.h"
+#include "nsIMsgCopyService.h"
+#include "nsMsgBaseCID.h"
+#include "nsISpamSettings.h"
+#include "nsIMsgAccountManager.h"
+#include "nsITreeColumns.h"
+#include "nsTextFormatter.h"
+#include "nsIMutableArray.h"
+#include "nsIMimeConverter.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIPrompt.h"
+#include "nsIWindowWatcher.h"
+#include "nsMsgDBCID.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsMemory.h"
+#include "nsAlgorithm.h"
+#include "nsIAbManager.h"
+#include "nsIAbDirectory.h"
+#include "nsIAbCard.h"
+#include "mozilla/Services.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+#include "nsTArray.h"
+#include <algorithm>
+
+using namespace mozilla::mailnews;
+nsrefcnt nsMsgDBView::gInstanceCount  = 0;
+
+nsIAtom * nsMsgDBView::kJunkMsgAtom = nullptr;
+nsIAtom * nsMsgDBView::kNotJunkMsgAtom = nullptr;
+
+char16_t * nsMsgDBView::kHighestPriorityString = nullptr;
+char16_t * nsMsgDBView::kHighPriorityString = nullptr;
+char16_t * nsMsgDBView::kLowestPriorityString = nullptr;
+char16_t * nsMsgDBView::kLowPriorityString = nullptr;
+char16_t * nsMsgDBView::kNormalPriorityString = nullptr;
+char16_t * nsMsgDBView::kReadString = nullptr;
+char16_t * nsMsgDBView::kRepliedString = nullptr;
+char16_t * nsMsgDBView::kForwardedString = nullptr;
+char16_t * nsMsgDBView::kNewString = nullptr;
+
+nsDateFormatSelector  nsMsgDBView::m_dateFormatDefault = kDateFormatShort;
+nsDateFormatSelector  nsMsgDBView::m_dateFormatThisWeek = kDateFormatShort;
+nsDateFormatSelector  nsMsgDBView::m_dateFormatToday = kDateFormatNone;
+
+static const uint32_t kMaxNumSortColumns = 2;
+
+static void GetCachedName(const nsCString& unparsedString,
+                          int32_t displayVersion, nsACString& cachedName);
+
+static void UpdateCachedName(nsIMsgDBHdr *aHdr, const char *header_field,
+                             const nsAString& newName);
+
+// this is passed into NS_QuickSort as custom data.
+class viewSortInfo
+{
+public:
+  nsMsgDBView *view;
+  nsIMsgDatabase *db;
+  bool isSecondarySort;
+  bool ascendingSort;
+};
+
+
+NS_IMPL_ADDREF(nsMsgDBView)
+NS_IMPL_RELEASE(nsMsgDBView)
+
+NS_INTERFACE_MAP_BEGIN(nsMsgDBView)
+   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIMsgDBView)
+   NS_INTERFACE_MAP_ENTRY(nsIMsgDBView)
+   NS_INTERFACE_MAP_ENTRY(nsIDBChangeListener)
+   NS_INTERFACE_MAP_ENTRY(nsITreeView)
+   NS_INTERFACE_MAP_ENTRY(nsIJunkMailClassificationListener)
+NS_INTERFACE_MAP_END
+
+nsMsgDBView::nsMsgDBView()
+{
+  /* member initializers and constructor code */
+  m_sortValid = false;
+  m_checkedCustomColumns = false;
+  m_sortOrder = nsMsgViewSortOrder::none;
+  m_viewFlags = nsMsgViewFlagsType::kNone;
+  m_secondarySort = nsMsgViewSortType::byId;
+  m_secondarySortOrder = nsMsgViewSortOrder::ascending;
+  m_cachedMsgKey = nsMsgKey_None;
+  m_currentlyDisplayedMsgKey = nsMsgKey_None;
+  m_currentlyDisplayedViewIndex = nsMsgViewIndex_None;
+  mNumSelectedRows = 0;
+  mSuppressMsgDisplay = false;
+  mSuppressCommandUpdating = false;
+  mSuppressChangeNotification = false;
+  mSummarizeFailed = false;
+  mSelectionSummarized = false;
+  mGoForwardEnabled = false;
+  mGoBackEnabled = false;
+
+  mIsNews = false;
+  mIsRss = false;
+  mIsXFVirtual = false;
+  mDeleteModel = nsMsgImapDeleteModels::MoveToTrash;
+  m_deletingRows = false;
+  mNumMessagesRemainingInBatch = 0;
+  mShowSizeInLines = false;
+  mSortThreadsByRoot = false;
+
+  /* mCommandsNeedDisablingBecauseOfSelection - A boolean that tell us if we needed to disable commands because of what's selected.
+    If we're offline w/o a downloaded msg selected, or a dummy message was selected.
+  */
+
+  mCommandsNeedDisablingBecauseOfSelection = false;
+  mRemovingRow = false;
+  m_saveRestoreSelectionDepth = 0;
+  mRecentlyDeletedArrayIndex = 0;
+  // initialize any static atoms or unicode strings
+  if (gInstanceCount == 0)
+  {
+    InitializeAtomsAndLiterals();
+    InitDisplayFormats();
+  }
+
+  InitLabelStrings();
+  gInstanceCount++;
+}
+
+void nsMsgDBView::InitializeAtomsAndLiterals()
+{
+  kJunkMsgAtom = MsgNewAtom("junk").take();
+  kNotJunkMsgAtom = MsgNewAtom("notjunk").take();
+
+  // priority strings
+  kHighestPriorityString = GetString(u"priorityHighest");
+  kHighPriorityString = GetString(u"priorityHigh");
+  kLowestPriorityString = GetString(u"priorityLowest");
+  kLowPriorityString = GetString(u"priorityLow");
+  kNormalPriorityString = GetString(u"priorityNormal");
+
+  kReadString = GetString(u"read");
+  kRepliedString = GetString(u"replied");
+  kForwardedString = GetString(u"forwarded");
+  kNewString = GetString(u"new");
+}
+
+nsMsgDBView::~nsMsgDBView()
+{
+  if (m_db)
+    m_db->RemoveListener(this);
+
+  gInstanceCount--;
+  if (gInstanceCount <= 0)
+  {
+    NS_IF_RELEASE(kJunkMsgAtom);
+    NS_IF_RELEASE(kNotJunkMsgAtom);
+
+    NS_Free(kHighestPriorityString);
+    NS_Free(kHighPriorityString);
+    NS_Free(kLowestPriorityString);
+    NS_Free(kLowPriorityString);
+    NS_Free(kNormalPriorityString);
+
+    NS_Free(kReadString);
+    NS_Free(kRepliedString);
+    NS_Free(kForwardedString);
+    NS_Free(kNewString);
+  }
+}
+
+nsresult nsMsgDBView::InitLabelStrings()
+{
+  nsresult rv = NS_OK;
+  nsCString prefString;
+
+  for(int32_t i = 0; i < PREF_LABELS_MAX; i++)
+  {
+    prefString.Assign(PREF_LABELS_DESCRIPTION);
+    prefString.AppendInt(i + 1);
+    rv = GetPrefLocalizedString(prefString.get(), mLabelPrefDescriptions[i]);
+  }
+  return rv;
+}
+
+// helper function used to fetch strings from the messenger string bundle
+char16_t * nsMsgDBView::GetString(const char16_t *aStringName)
+{
+  nsresult    res = NS_ERROR_UNEXPECTED;
+  char16_t   *ptrv = nullptr;
+
+  if (!mMessengerStringBundle)
+  {
+    static const char propertyURL[] = MESSENGER_STRING_URL;
+    nsCOMPtr<nsIStringBundleService> sBundleService =
+      mozilla::services::GetStringBundleService();
+    if (sBundleService)
+      res = sBundleService->CreateBundle(propertyURL, getter_AddRefs(mMessengerStringBundle));
+  }
+
+  if (mMessengerStringBundle)
+    res = mMessengerStringBundle->GetStringFromName(aStringName, &ptrv);
+
+  if ( NS_SUCCEEDED(res) && (ptrv) )
+    return ptrv;
+  else
+    return NS_strdup(aStringName);
+}
+
+// helper function used to fetch localized strings from the prefs
+nsresult nsMsgDBView::GetPrefLocalizedString(const char *aPrefName, nsString& aResult)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIPrefBranch> prefBranch;
+  nsCOMPtr<nsIPrefLocalizedString> pls;
+  nsString ucsval;
+
+  prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = prefBranch->GetComplexValue(aPrefName, NS_GET_IID(nsIPrefLocalizedString), getter_AddRefs(pls));
+  NS_ENSURE_SUCCESS(rv, rv);
+  pls->ToString(getter_Copies(ucsval));
+  aResult = ucsval.get();
+  return rv;
+}
+
+nsresult nsMsgDBView::AppendKeywordProperties(const nsACString& keywords, nsAString& properties, bool addSelectedTextProperty)
+{
+  // get the top most keyword's color and append that as a property.
+  nsresult rv;
+  if (!mTagService)
+  {
+    mTagService = do_GetService(NS_MSGTAGSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCString topKey;
+  rv = mTagService->GetTopKey(keywords, topKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (topKey.IsEmpty())
+    return NS_OK;
+
+  nsCString color;
+  rv = mTagService->GetColorForKey(topKey, color);
+  if (NS_SUCCEEDED(rv) && !color.IsEmpty())
+  {
+    if (addSelectedTextProperty)
+    {
+      if (color.EqualsLiteral(LABEL_COLOR_WHITE_STRING))
+        properties.AppendLiteral(" lc-black");
+      else
+        properties.AppendLiteral(" lc-white");
+    }
+    color.Replace(0, 1, NS_LITERAL_CSTRING(LABEL_COLOR_STRING));
+    properties.AppendASCII(color.get());
+  }
+  return rv;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// nsITreeView Implementation Methods (and helper methods)
+///////////////////////////////////////////////////////////////////////////
+
+static nsresult GetDisplayNameInAddressBook(const nsACString& emailAddress,
+                                            nsAString& displayName)
+{
+  nsresult rv;
+  nsCOMPtr<nsIAbManager> abManager(do_GetService("@mozilla.org/abmanager;1",
+                                   &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISimpleEnumerator> enumerator;
+  rv = abManager->GetDirectories(getter_AddRefs(enumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISupports> supports;
+  nsCOMPtr<nsIAbDirectory> directory;
+  nsCOMPtr<nsIAbCard> cardForAddress;
+  bool hasMore;
+
+  // Scan the addressbook to find out the card of the email address
+  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) &&
+         hasMore && !cardForAddress)
+  {
+    rv = enumerator->GetNext(getter_AddRefs(supports));
+    NS_ENSURE_SUCCESS(rv, rv);
+    directory = do_QueryInterface(supports);
+    if (directory)
+    {
+      rv = directory->CardForEmailAddress(emailAddress,
+                        getter_AddRefs(cardForAddress));
+
+      if (NS_SUCCEEDED(rv) && cardForAddress)
+        break; // the card is found,so stop looping
+    }
+  }
+
+  if (cardForAddress)
+  {
+    bool preferDisplayName = true;
+    cardForAddress->GetPropertyAsBool("PreferDisplayName",&preferDisplayName);
+
+    if (preferDisplayName)
+      rv = cardForAddress->GetDisplayName(displayName);
+  }
+
+  return rv;
+}
+
+/* The unparsedString has following format
+ * "version|displayname"
+ */
+static void GetCachedName(const nsCString& unparsedString,
+                          int32_t displayVersion, nsACString& cachedName)
+{
+  nsresult err;
+
+  //get verion #
+  int32_t cachedVersion = unparsedString.ToInteger(&err);
+  if (cachedVersion != displayVersion)
+    return;
+
+  //get cached name
+  int32_t pos = unparsedString.FindChar('|');
+  if (pos != kNotFound)
+    cachedName = Substring(unparsedString, pos + 1);
+}
+
+static void UpdateCachedName(nsIMsgDBHdr *aHdr, const char *header_field,
+                             const nsAString& newName)
+{
+  nsCString newCachedName;
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  int32_t  currentDisplayNameVersion = 0;
+
+  prefs->GetIntPref("mail.displayname.version", &currentDisplayNameVersion);
+
+  // save version number
+  newCachedName.AppendInt(currentDisplayNameVersion);
+  newCachedName.Append("|");
+
+  // save name
+  newCachedName.Append(NS_ConvertUTF16toUTF8(newName));
+
+  aHdr->SetStringProperty(header_field,newCachedName.get());
+}
+
+nsresult nsMsgDBView::FetchAuthor(nsIMsgDBHdr * aHdr, nsAString &aSenderString)
+{
+  nsCString unparsedAuthor;
+  bool showCondensedAddresses = false;
+  int32_t  currentDisplayNameVersion = 0;
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+
+  prefs->GetIntPref("mail.displayname.version", &currentDisplayNameVersion);
+  prefs->GetBoolPref("mail.showCondensedAddresses", &showCondensedAddresses);
+
+  aHdr->GetStringProperty("sender_name", getter_Copies(unparsedAuthor));
+
+  // if the author is already computed, use it
+  if (!unparsedAuthor.IsEmpty())
+  {
+    nsCString cachedDisplayName;
+
+    GetCachedName(unparsedAuthor, currentDisplayNameVersion, cachedDisplayName);
+    if (!cachedDisplayName.IsEmpty())
+    {
+      CopyUTF8toUTF16(cachedDisplayName, aSenderString);
+      return NS_OK;
+    }
+  }
+
+  nsCString author;
+  (void) aHdr->GetAuthor(getter_Copies(author));
+
+  nsCString headerCharset;
+  aHdr->GetEffectiveCharset(headerCharset);
+
+  nsCString emailAddress;
+  nsString name;
+  ExtractFirstAddress(EncodedHeader(author, headerCharset.get()), name,
+    emailAddress);
+
+  if (showCondensedAddresses)
+    GetDisplayNameInAddressBook(emailAddress, aSenderString);
+
+  if (aSenderString.IsEmpty())
+  {
+     // We can't use the display name in the card; use the name contained in
+     // the header or email address.
+    if (name.IsEmpty()) {
+      CopyUTF8toUTF16(emailAddress, aSenderString);
+    } else {
+      int32_t atPos;
+      if ((atPos = name.FindChar('@')) == kNotFound ||
+          name.FindChar('.', atPos) == kNotFound) {
+        aSenderString = name;
+      } else {
+        // Found @ followed by a dot, so this looks like a spoofing case.
+        aSenderString = name;
+        aSenderString.AppendLiteral(" <");
+        AppendUTF8toUTF16(emailAddress, aSenderString);
+        aSenderString.Append('>');
+      }
+    }
+  }
+
+  UpdateCachedName(aHdr, "sender_name", aSenderString);
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::FetchAccount(nsIMsgDBHdr * aHdr, nsAString& aAccount)
+{
+  nsCString accountKey;
+
+  nsresult rv = aHdr->GetAccountKey(getter_Copies(accountKey));
+
+  // Cache the account manager?
+  nsCOMPtr<nsIMsgAccountManager> accountManager(
+    do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgAccount> account;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  if (!accountKey.IsEmpty())
+    rv = accountManager->GetAccount(accountKey, getter_AddRefs(account));
+
+  if (account)
+  {
+    account->GetIncomingServer(getter_AddRefs(server));
+  }
+  else
+  {
+    nsCOMPtr<nsIMsgFolder> folder;
+    aHdr->GetFolder(getter_AddRefs(folder));
+    if (folder)
+     folder->GetServer(getter_AddRefs(server));
+  }
+  if (server)
+    server->GetPrettyName(aAccount);
+  else
+    CopyASCIItoUTF16(accountKey, aAccount);
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::FetchRecipients(nsIMsgDBHdr * aHdr, nsAString &aRecipientsString)
+{
+  nsCString recipients;
+  int32_t currentDisplayNameVersion = 0;
+  bool showCondensedAddresses = false;
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+
+  prefs->GetIntPref("mail.displayname.version", &currentDisplayNameVersion);
+  prefs->GetBoolPref("mail.showCondensedAddresses", &showCondensedAddresses);
+
+  aHdr->GetStringProperty("recipient_names", getter_Copies(recipients));
+
+  if (!recipients.IsEmpty())
+  {
+    nsCString cachedRecipients;
+
+    GetCachedName(recipients, currentDisplayNameVersion, cachedRecipients);
+
+    // recipients have already been cached,check if the addressbook
+    // was changed after cache.
+    if (!cachedRecipients.IsEmpty())
+    {
+      CopyUTF8toUTF16(cachedRecipients, aRecipientsString);
+      return NS_OK;
+    }
+  }
+
+  nsCString unparsedRecipients;
+  nsresult rv = aHdr->GetRecipients(getter_Copies(unparsedRecipients));
+
+  nsCString headerCharset;
+  aHdr->GetEffectiveCharset(headerCharset);
+
+  nsTArray<nsString> names;
+  nsTArray<nsCString> emails;
+  ExtractAllAddresses(EncodedHeader(unparsedRecipients, headerCharset.get()),
+    names, UTF16ArrayAdapter<>(emails));
+
+  uint32_t numAddresses = names.Length();
+
+  nsCOMPtr<nsISimpleEnumerator> enumerator;
+  nsCOMPtr<nsIAbManager>
+    abManager(do_GetService("@mozilla.org/abmanager;1", &rv));
+  NS_ENSURE_SUCCESS(rv, NS_OK);
+
+  // go through each email address in the recipients and
+  // compute its display name.
+  for (uint32_t i = 0; i < numAddresses; i++)
+  {
+    nsString recipient;
+    nsCString &curAddress = emails[i];
+    nsString &curName = names[i];
+
+    if (showCondensedAddresses)
+      GetDisplayNameInAddressBook(curAddress, recipient);
+
+    if (recipient.IsEmpty())
+    {
+      // we can't use the display name in the card,
+      // use the name contained in the header or email address.
+      if (curName.IsEmpty()) {
+        CopyUTF8toUTF16(curAddress, recipient);
+      } else {
+        int32_t atPos;
+        if ((atPos = curName.FindChar('@')) == kNotFound ||
+            curName.FindChar('.', atPos) == kNotFound) {
+          recipient = curName;
+        } else {
+          // Found @ followed by a dot, so this looks like a spoofing case.
+          recipient = curName;
+          recipient.AppendLiteral(" <");
+          AppendUTF8toUTF16(curAddress, recipient);
+          recipient.Append('>');
+        }
+      }
+    }
+
+    // add ', ' between each recipient
+    if (i != 0)
+      aRecipientsString.Append(NS_LITERAL_STRING(", "));
+
+    aRecipientsString.Append(recipient);
+  }
+
+  if (numAddresses == 0 && unparsedRecipients.FindChar(':') != kNotFound) {
+    // No addresses and a colon, so an empty group like "undisclosed-recipients: ;".
+    // Add group name so at least something displays.
+    nsString group;
+    CopyUTF8toUTF16(unparsedRecipients, group);
+    aRecipientsString.Assign(group);
+  }
+
+  UpdateCachedName(aHdr, "recipient_names", aRecipientsString);
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::FetchSubject(nsIMsgDBHdr * aMsgHdr, uint32_t aFlags, nsAString &aValue)
+{
+  if (aFlags & nsMsgMessageFlags::HasRe)
+  {
+    nsString subject;
+    aMsgHdr->GetMime2DecodedSubject(subject);
+    aValue.AssignLiteral("Re: ");
+    aValue.Append(subject);
+  }
+  else
+    aMsgHdr->GetMime2DecodedSubject(aValue);
+  return NS_OK;
+}
+
+// in case we want to play around with the date string, I've broken it out into
+// a separate routine.  Set rcvDate to true to get the Received: date instead
+// of the Date: date.
+nsresult nsMsgDBView::FetchDate(nsIMsgDBHdr * aHdr, nsAString &aDateString, bool rcvDate)
+{
+  PRTime dateOfMsg;
+  PRTime dateOfMsgLocal;
+  uint32_t rcvDateSecs;
+  nsresult rv;
+
+  if (!mDateFormatter)
+    mDateFormatter = do_CreateInstance(NS_DATETIMEFORMAT_CONTRACTID);
+
+  NS_ENSURE_TRUE(mDateFormatter, NS_ERROR_FAILURE);
+  // Silently return Date: instead if Received: is unavailable
+  if (rcvDate)
+  {
+    rv = aHdr->GetUint32Property("dateReceived", &rcvDateSecs);
+    if (rcvDateSecs != 0)
+      Seconds2PRTime(rcvDateSecs, &dateOfMsg);
+  }
+  if (!rcvDate || rcvDateSecs == 0)
+    rv = aHdr->GetDate(&dateOfMsg);
+
+  PRTime currentTime = PR_Now();
+  PRExplodedTime explodedCurrentTime;
+  PR_ExplodeTime(currentTime, PR_LocalTimeParameters, &explodedCurrentTime);
+  PRExplodedTime explodedMsgTime;
+  PR_ExplodeTime(dateOfMsg, PR_LocalTimeParameters, &explodedMsgTime);
+
+  // if the message is from today, don't show the date, only the time. (i.e. 3:15 pm)
+  // if the message is from the last week, show the day of the week.   (i.e. Mon 3:15 pm)
+  // in all other cases, show the full date (03/19/01 3:15 pm)
+
+  nsDateFormatSelector dateFormat = m_dateFormatDefault;
+  if (explodedCurrentTime.tm_year == explodedMsgTime.tm_year &&
+      explodedCurrentTime.tm_month == explodedMsgTime.tm_month &&
+      explodedCurrentTime.tm_mday == explodedMsgTime.tm_mday)
+  {
+    // same day...
+    dateFormat = m_dateFormatToday;
+  }
+  // the following chunk of code allows us to show a day instead of a number if the message was received
+  // within the last 7 days. i.e. Mon 5:10pm. (depending on the mail.ui.display.dateformat.thisweek pref)
+  // The concrete format used is dependent on a preference setting (see InitDisplayFormats).
+  else if (currentTime > dateOfMsg)
+  {
+    // Convert the times from GMT to local time
+    int64_t GMTLocalTimeShift = PR_USEC_PER_SEC *
+      int64_t(explodedCurrentTime.tm_params.tp_gmt_offset +
+       explodedCurrentTime.tm_params.tp_dst_offset);
+    currentTime += GMTLocalTimeShift;
+    dateOfMsgLocal = dateOfMsg + GMTLocalTimeShift;
+
+    // Find the most recent midnight
+    int64_t todaysMicroSeconds = currentTime % PR_USEC_PER_DAY;
+    int64_t mostRecentMidnight = currentTime - todaysMicroSeconds;
+
+    // most recent midnight minus 6 days
+    int64_t mostRecentWeek = mostRecentMidnight - (PR_USEC_PER_DAY * 6);
+
+    // was the message sent during the last week?
+    if (dateOfMsgLocal >= mostRecentWeek)
+    { // yes ....
+      dateFormat = m_dateFormatThisWeek;
+    }
+  }
+
+  if (NS_SUCCEEDED(rv))
+    rv = mDateFormatter->FormatPRTime(nullptr /* nsILocale* locale */,
+                                      dateFormat,
+                                      kTimeFormatNoSeconds,
+                                      dateOfMsg,
+                                      aDateString);
+
+  return rv;
+}
+
+nsresult nsMsgDBView::FetchStatus(uint32_t aFlags, nsAString &aStatusString)
+{
+  if (aFlags & nsMsgMessageFlags::Replied)
+    aStatusString = kRepliedString;
+  else if (aFlags & nsMsgMessageFlags::Forwarded)
+    aStatusString = kForwardedString;
+  else if (aFlags & nsMsgMessageFlags::New)
+    aStatusString = kNewString;
+  else if (aFlags & nsMsgMessageFlags::Read)
+    aStatusString = kReadString;
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::FetchSize(nsIMsgDBHdr * aHdr, nsAString &aSizeString)
+{
+  nsresult rv;
+  nsAutoString formattedSizeString;
+  uint32_t msgSize = 0;
+
+  // for news, show the line count, not the size if the user wants so
+  if (mShowSizeInLines)
+  {
+    aHdr->GetLineCount(&msgSize);
+    formattedSizeString.AppendInt(msgSize);
+  }
+  else
+  {
+    uint32_t flags = 0;
+
+    aHdr->GetFlags(&flags);
+    if (flags & nsMsgMessageFlags::Partial)
+      aHdr->GetUint32Property("onlineSize", &msgSize);
+
+    if (msgSize == 0)
+      aHdr->GetMessageSize(&msgSize);
+
+    rv = FormatFileSize(msgSize, true, formattedSizeString);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  aSizeString = formattedSizeString;
+  // the formattingString Length includes the null terminator byte!
+  if (!formattedSizeString.Last())
+    aSizeString.SetLength(formattedSizeString.Length() - 1);
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::FetchPriority(nsIMsgDBHdr *aHdr, nsAString & aPriorityString)
+{
+  nsMsgPriorityValue priority = nsMsgPriority::notSet;
+  aHdr->GetPriority(&priority);
+
+  switch (priority)
+  {
+  case nsMsgPriority::highest:
+    aPriorityString = kHighestPriorityString;
+    break;
+  case nsMsgPriority::high:
+    aPriorityString = kHighPriorityString;
+    break;
+  case nsMsgPriority::low:
+    aPriorityString = kLowPriorityString;
+    break;
+  case nsMsgPriority::lowest:
+    aPriorityString = kLowestPriorityString;
+    break;
+  case nsMsgPriority::normal:
+    aPriorityString = kNormalPriorityString;
+    break;
+  default:
+    break;
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::FetchKeywords(nsIMsgDBHdr *aHdr, nsACString &keywordString)
+{
+  NS_ENSURE_ARG_POINTER(aHdr);
+  nsresult rv = NS_OK;
+  if (!mTagService)
+  {
+    mTagService = do_GetService(NS_MSGTAGSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  nsMsgLabelValue label = 0;
+
+  rv = aHdr->GetLabel(&label);
+  nsCString keywords;
+  aHdr->GetStringProperty("keywords", getter_Copies(keywords));
+  if (label > 0)
+  {
+    nsAutoCString labelStr("$label");
+    labelStr.Append((char) (label + '0'));
+    if (keywords.Find(labelStr, CaseInsensitiveCompare) == -1)
+    {
+      if (!keywords.IsEmpty())
+        keywords.Append(' ');
+      keywords.Append(labelStr);
+    }
+  }
+  keywordString = keywords;
+  return NS_OK;
+}
+
+// If the row is a collapsed thread, we optionally roll-up the keywords in all
+// the messages in the thread, otherwise, return just the keywords for the row.
+nsresult nsMsgDBView::FetchRowKeywords(nsMsgViewIndex aRow, nsIMsgDBHdr *aHdr,
+                                       nsACString &keywordString)
+{
+  nsresult rv = FetchKeywords(aHdr,keywordString);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool cascadeKeywordsUp = true;
+  nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  prefs->GetBoolPref("mailnews.display_reply_tag_colors_for_collapsed_threads",
+                     &cascadeKeywordsUp);
+
+  if ((m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay) &&
+      cascadeKeywordsUp)
+  {
+    if ((m_flags[aRow] & MSG_VIEW_FLAG_ISTHREAD)
+        && (m_flags[aRow] & nsMsgMessageFlags::Elided))
+    {
+      nsCOMPtr<nsIMsgThread> thread;
+      rv = GetThreadContainingIndex(aRow, getter_AddRefs(thread));
+      if (NS_SUCCEEDED(rv) && thread)
+      {
+        uint32_t numChildren;
+        thread->GetNumChildren(&numChildren);
+        nsCOMPtr<nsIMsgDBHdr> msgHdr;
+        nsCString moreKeywords;
+        for (uint32_t index = 0; index < numChildren; index++)
+        {
+          thread->GetChildHdrAt(index, getter_AddRefs(msgHdr));
+          rv = FetchKeywords(msgHdr, moreKeywords);
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          if (!keywordString.IsEmpty() && !moreKeywords.IsEmpty())
+            keywordString.Append(' ');
+          keywordString.Append(moreKeywords);
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+nsresult nsMsgDBView::FetchTags(nsIMsgDBHdr *aHdr, nsAString &aTagString)
+{
+  NS_ENSURE_ARG_POINTER(aHdr);
+  nsresult rv = NS_OK;
+  if (!mTagService)
+  {
+    mTagService = do_GetService(NS_MSGTAGSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsString tags;
+  nsCString keywords;
+  aHdr->GetStringProperty("keywords", getter_Copies(keywords));
+
+  nsMsgLabelValue label = 0;
+  rv = aHdr->GetLabel(&label);
+  if (label > 0)
+  {
+    nsAutoCString labelStr("$label");
+    labelStr.Append((char) (label + '0'));
+    if (keywords.Find(labelStr, CaseInsensitiveCompare) == -1)
+      FetchLabel(aHdr, tags);
+  }
+
+  nsTArray<nsCString> keywordsArray;
+  ParseString(keywords, ' ', keywordsArray);
+  nsAutoString tag;
+
+  for (uint32_t i = 0; i < keywordsArray.Length(); i++)
+  {
+    rv = mTagService->GetTagForKey(keywordsArray[i], tag);
+    if (NS_SUCCEEDED(rv) && !tag.IsEmpty())
+    {
+      if (!tags.IsEmpty())
+        tags.Append((char16_t) ' ');
+      tags.Append(tag);
+    }
+  }
+
+  aTagString = tags;
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::FetchLabel(nsIMsgDBHdr *aHdr, nsAString &aLabelString)
+{
+  nsresult rv = NS_OK;
+  nsMsgLabelValue label = 0;
+
+  NS_ENSURE_ARG_POINTER(aHdr);
+
+  rv = aHdr->GetLabel(&label);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // we don't care if label is not between 1 and PREF_LABELS_MAX inclusive.
+  if ((label < 1) || (label > PREF_LABELS_MAX))
+  {
+    aLabelString.Truncate();
+    return NS_OK;
+  }
+
+  // We need to subtract 1 because mLabelPrefDescriptions is 0 based.
+  aLabelString = mLabelPrefDescriptions[label - 1];
+  return NS_OK;
+}
+
+bool nsMsgDBView::IsOutgoingMsg(nsIMsgDBHdr* aHdr)
+{
+  nsString author;
+  aHdr->GetMime2DecodedAuthor(author);
+
+  nsCString emailAddress;
+  nsString name;
+  ExtractFirstAddress(DecodedHeader(author), name, emailAddress);
+
+  return mEmails.Contains(emailAddress);
+}
+
+
+/*if you call SaveAndClearSelection make sure to call RestoreSelection otherwise
+m_saveRestoreSelectionDepth will be incorrect and will lead to selection msg problems*/
+
+nsresult nsMsgDBView::SaveAndClearSelection(nsMsgKey *aCurrentMsgKey, nsTArray<nsMsgKey> &aMsgKeyArray)
+{
+  // we don't do anything on nested Save / Restore calls.
+  m_saveRestoreSelectionDepth++;
+  if (m_saveRestoreSelectionDepth != 1)
+    return NS_OK;
+
+  if (!mTreeSelection || !mTree)
+    return NS_OK;
+
+  // first, freeze selection.
+  mTreeSelection->SetSelectEventsSuppressed(true);
+
+  // second, save the current index.
+  if (aCurrentMsgKey)
+  {
+    int32_t currentIndex;
+    if (NS_SUCCEEDED(mTreeSelection->GetCurrentIndex(&currentIndex)) &&
+        currentIndex >= 0 && uint32_t(currentIndex) < GetSize())
+      *aCurrentMsgKey = m_keys[currentIndex];
+    else
+      *aCurrentMsgKey = nsMsgKey_None;
+  }
+
+  // third, get an array of view indices for the selection.
+  nsMsgViewIndexArray selection;
+  GetSelectedIndices(selection);
+  int32_t numIndices = selection.Length();
+  aMsgKeyArray.SetLength(numIndices);
+
+  // now store the msg key for each selected item.
+  nsMsgKey msgKey;
+  for (int32_t index = 0; index < numIndices; index++)
+  {
+    msgKey = m_keys[selection[index]];
+    aMsgKeyArray[index] = msgKey;
+  }
+
+  // clear the selection, we'll manually restore it later.
+  if (mTreeSelection)
+    mTreeSelection->ClearSelection();
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::RestoreSelection(nsMsgKey aCurrentMsgKey, nsTArray<nsMsgKey> &aMsgKeyArray)
+{
+  // we don't do anything on nested Save / Restore calls.
+  m_saveRestoreSelectionDepth--;
+  if (m_saveRestoreSelectionDepth)
+    return NS_OK;
+
+  if (!mTreeSelection)  // don't assert.
+    return NS_OK;
+
+  // turn our message keys into corresponding view indices
+  int32_t arraySize = aMsgKeyArray.Length();
+  nsMsgViewIndex  currentViewPosition = nsMsgViewIndex_None;
+  nsMsgViewIndex  newViewPosition = nsMsgViewIndex_None;
+
+  // if we are threaded, we need to do a little more work
+  // we need to find (and expand) all the threads that contain messages
+  // that we had selected before.
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    for (int32_t index = 0; index < arraySize; index ++)
+    {
+      FindKey(aMsgKeyArray[index], true /* expand */);
+    }
+  }
+
+  for (int32_t index = 0; index < arraySize; index ++)
+  {
+    newViewPosition = FindKey(aMsgKeyArray[index], false);
+    // add the index back to the selection.
+    if (newViewPosition != nsMsgViewIndex_None)
+      mTreeSelection->ToggleSelect(newViewPosition);
+  }
+
+  // make sure the currentView was preserved....
+  if (aCurrentMsgKey != nsMsgKey_None)
+    currentViewPosition = FindKey(aCurrentMsgKey, true);
+
+  if (mTree)
+    mTreeSelection->SetCurrentIndex(currentViewPosition);
+
+  // make sure the current message is once again visible in the thread pane
+  // so we don't have to go search for it in the thread pane
+  if (mTree && currentViewPosition != nsMsgViewIndex_None)
+    mTree->EnsureRowIsVisible(currentViewPosition);
+
+  // unfreeze selection.
+  mTreeSelection->SetSelectEventsSuppressed(false);
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::GenerateURIForMsgKey(nsMsgKey aMsgKey, nsIMsgFolder *folder, nsACString & aURI)
+{
+  NS_ENSURE_ARG(folder);
+  return folder->GenerateMessageURI(aMsgKey, aURI);
+}
+
+nsresult nsMsgDBView::GetMessageEnumerator(nsISimpleEnumerator **enumerator)
+{
+  return m_db->EnumerateMessages(enumerator);
+}
+
+nsresult nsMsgDBView::CycleThreadedColumn(nsIDOMElement * aElement)
+{
+  nsAutoString currentView;
+
+  // toggle threaded/unthreaded mode
+  aElement->GetAttribute(NS_LITERAL_STRING("currentView"), currentView);
+  if (currentView.EqualsLiteral("threaded"))
+    aElement->SetAttribute(NS_LITERAL_STRING("currentView"), NS_LITERAL_STRING("unthreaded"));
+  else
+     aElement->SetAttribute(NS_LITERAL_STRING("currentView"), NS_LITERAL_STRING("threaded"));
+
+  // i think we need to create a new view and switch it in this circumstance since
+  // we are toggline between threaded and non threaded mode.
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::IsEditable(int32_t row, nsITreeColumn* col, bool* _retval)
+{
+  NS_ENSURE_ARG_POINTER(col);
+  NS_ENSURE_ARG_POINTER(_retval);
+  //attempt to retreive a custom column handler. If it exists call it and return
+  const char16_t* colID;
+  col->GetIdConst(&colID);
+
+  nsIMsgCustomColumnHandler* colHandler = GetColumnHandler(colID);
+
+  if (colHandler)
+  {
+    colHandler->IsEditable(row, col, _retval);
+    return NS_OK;
+  }
+
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::IsSelectable(int32_t row, nsITreeColumn* col, bool* _retval)
+{
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetCellValue(int32_t row, nsITreeColumn* col, const nsAString& value)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetCellText(int32_t row, nsITreeColumn* col, const nsAString& value)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetRowCount(int32_t *aRowCount)
+{
+  *aRowCount = GetSize();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSelection(nsITreeSelection * *aSelection)
+{
+  *aSelection = mTreeSelection;
+  NS_IF_ADDREF(*aSelection);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetSelection(nsITreeSelection * aSelection)
+{
+  mTreeSelection = aSelection;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::ReloadMessageWithAllParts()
+{
+  if (m_currentlyDisplayedMsgUri.IsEmpty() || mSuppressMsgDisplay)
+    return NS_OK;
+
+  nsAutoCString forceAllParts(m_currentlyDisplayedMsgUri);
+  forceAllParts += (forceAllParts.FindChar('?') == kNotFound) ? '?' : '&';
+  forceAllParts.AppendLiteral("fetchCompleteMessage=true");
+  nsCOMPtr<nsIMessenger> messenger (do_QueryReferent(mMessengerWeak));
+  NS_ENSURE_TRUE(messenger, NS_ERROR_FAILURE);
+
+  nsresult rv = messenger->OpenURL(forceAllParts);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  UpdateDisplayMessage(m_currentlyDisplayedViewIndex);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::ReloadMessage()
+{
+  if (m_currentlyDisplayedMsgUri.IsEmpty() || mSuppressMsgDisplay)
+    return NS_OK;
+  nsCOMPtr<nsIMessenger> messenger (do_QueryReferent(mMessengerWeak));
+  NS_ENSURE_TRUE(messenger, NS_ERROR_FAILURE);
+
+  nsresult rv = messenger->OpenURL(m_currentlyDisplayedMsgUri);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  UpdateDisplayMessage(m_currentlyDisplayedViewIndex);
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::UpdateDisplayMessage(nsMsgViewIndex viewPosition)
+{
+  nsresult rv;
+  if (mCommandUpdater)
+  {
+    // get the subject and the folder for the message and inform the front end that
+    // we changed the message we are currently displaying.
+    if (viewPosition != nsMsgViewIndex_None)
+    {
+      nsCOMPtr <nsIMsgDBHdr> msgHdr;
+      rv = GetMsgHdrForViewIndex(viewPosition, getter_AddRefs(msgHdr));
+      NS_ENSURE_SUCCESS(rv,rv);
+
+      nsString subject;
+      FetchSubject(msgHdr, m_flags[viewPosition], subject);
+
+      nsCString keywords;
+      rv = msgHdr->GetStringProperty("keywords", getter_Copies(keywords));
+      NS_ENSURE_SUCCESS(rv,rv);
+
+      nsCOMPtr<nsIMsgFolder> folder = m_viewFolder ? m_viewFolder : m_folder;
+
+      mCommandUpdater->DisplayMessageChanged(folder, subject, keywords);
+
+      if (folder)
+      {
+        rv = folder->SetLastMessageLoaded(m_keys[viewPosition]);
+        NS_ENSURE_SUCCESS(rv,rv);
+      }
+    } // if view position is valid
+  } // if we have an updater
+  return NS_OK;
+}
+
+// given a msg key, we will load the message for it.
+NS_IMETHODIMP nsMsgDBView::LoadMessageByMsgKey(nsMsgKey aMsgKey)
+{
+  return LoadMessageByViewIndex(FindKey(aMsgKey, false));
+}
+
+NS_IMETHODIMP nsMsgDBView::LoadMessageByViewIndex(nsMsgViewIndex aViewIndex)
+{
+  NS_ASSERTION(aViewIndex != nsMsgViewIndex_None,"trying to load nsMsgViewIndex_None");
+  if (aViewIndex == nsMsgViewIndex_None) return NS_ERROR_UNEXPECTED;
+
+  nsCString uri;
+  nsresult rv = GetURIForViewIndex(aViewIndex, uri);
+  if (!mSuppressMsgDisplay && !m_currentlyDisplayedMsgUri.Equals(uri))
+  {
+    NS_ENSURE_SUCCESS(rv,rv);
+    nsCOMPtr<nsIMessenger> messenger (do_QueryReferent(mMessengerWeak));
+    NS_ENSURE_TRUE(messenger, NS_ERROR_FAILURE);
+    messenger->OpenURL(uri);
+    m_currentlyDisplayedMsgKey = m_keys[aViewIndex];
+    m_currentlyDisplayedMsgUri = uri;
+    m_currentlyDisplayedViewIndex = aViewIndex;
+    UpdateDisplayMessage(m_currentlyDisplayedViewIndex);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::LoadMessageByUrl(const char *aUrl)
+{
+  NS_ASSERTION(aUrl, "trying to load a null url");
+  if (!mSuppressMsgDisplay)
+  {
+    nsresult rv;
+    nsCOMPtr<nsIMessenger> messenger (do_QueryReferent(mMessengerWeak, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    messenger->LoadURL(NULL, nsDependentCString(aUrl));
+    m_currentlyDisplayedMsgKey = nsMsgKey_None;
+    m_currentlyDisplayedMsgUri = aUrl;
+    m_currentlyDisplayedViewIndex = nsMsgViewIndex_None;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SelectionChanged()
+{
+  // if the currentSelection changed then we have a message to display - not if we are in the middle of deleting rows
+  if (m_deletingRows)
+    return NS_OK;
+
+  uint32_t numSelected = 0;
+
+  nsMsgViewIndexArray selection;
+  GetSelectedIndices(selection);
+  nsMsgViewIndex *indices = selection.Elements();
+  numSelected = selection.Length();
+
+  bool commandsNeedDisablingBecauseOfSelection = false;
+
+  if(indices)
+  {
+    if (WeAreOffline())
+      commandsNeedDisablingBecauseOfSelection = !OfflineMsgSelected(indices, numSelected);
+    if (!NonDummyMsgSelected(indices, numSelected))
+      commandsNeedDisablingBecauseOfSelection = true;
+  }
+  bool selectionSummarized = false;
+  mSummarizeFailed = false;
+  // let the front-end adjust the message pane appropriately with either
+  // the message body, or a summary of the selection
+  if (mCommandUpdater)
+  {
+    mCommandUpdater->SummarizeSelection(&selectionSummarized);
+    // check if the selection was not summarized, but we expected it to be,
+    // and if so, remember it so GetHeadersFromSelection won't include
+    // the messages in collapsed threads.
+    if (!selectionSummarized &&
+        (numSelected > 1 || (numSelected == 1 &&
+                              m_flags[indices[0]] & nsMsgMessageFlags::Elided &&
+                              OperateOnMsgsInCollapsedThreads())))
+      mSummarizeFailed = true;
+  }
+
+  bool summaryStateChanged = selectionSummarized != mSelectionSummarized;
+
+  mSelectionSummarized = selectionSummarized;
+  // if only one item is selected then we want to display a message
+  if (mTreeSelection && numSelected == 1 && !selectionSummarized)
+  {
+    int32_t startRange;
+    int32_t endRange;
+    nsresult rv = mTreeSelection->GetRangeAt(0, &startRange, &endRange);
+    NS_ENSURE_SUCCESS(rv, NS_OK); // tree doesn't care if we failed
+
+    if (startRange >= 0 && startRange == endRange &&
+        uint32_t(startRange) < GetSize())
+    {
+      if (!mRemovingRow)
+      {
+        if (!mSuppressMsgDisplay)
+          LoadMessageByViewIndex(startRange);
+        else
+          UpdateDisplayMessage(startRange);
+      }
+    }
+    else
+      numSelected = 0; // selection seems bogus, so set to 0.
+  }
+  else {
+    // if we have zero or multiple items selected, we shouldn't be displaying any message
+    m_currentlyDisplayedMsgKey = nsMsgKey_None;
+    m_currentlyDisplayedMsgUri.Truncate();
+    m_currentlyDisplayedViewIndex = nsMsgViewIndex_None;
+  }
+
+  // determine if we need to push command update notifications out to the UI or not.
+
+  // we need to push a command update notification iff, one of the following conditions are met
+  // (1) the selection went from 0 to 1
+  // (2) it went from 1 to 0
+  // (3) it went from 1 to many
+  // (4) it went from many to 1 or 0
+  // (5) a different msg was selected - perhaps it was offline or not...matters only when we are offline
+  // (6) we did a forward/back, or went from having no history to having history - not sure how to tell this.
+  // (7) whether the selection was summarized or not changed.
+
+  // I think we're going to need to keep track of whether forward/back were enabled/should be enabled,
+  // and when this changes, force a command update.
+
+  bool enableGoForward = false;
+  bool enableGoBack = false;
+
+  NavigateStatus(nsMsgNavigationType::forward, &enableGoForward);
+  NavigateStatus(nsMsgNavigationType::back, &enableGoBack);
+  if (!summaryStateChanged &&
+      (numSelected == mNumSelectedRows ||
+      (numSelected > 1 && mNumSelectedRows > 1)) && (commandsNeedDisablingBecauseOfSelection == mCommandsNeedDisablingBecauseOfSelection)
+      && enableGoForward == mGoForwardEnabled && enableGoBack == mGoBackEnabled)
+  {
+  }
+  // don't update commands if we're suppressing them, or if we're removing rows, unless it was the last row.
+  else if (!mSuppressCommandUpdating && mCommandUpdater && (!mRemovingRow || GetSize() == 0)) // o.t. push an updated
+  {
+    mCommandUpdater->UpdateCommandStatus();
+  }
+
+  mCommandsNeedDisablingBecauseOfSelection = commandsNeedDisablingBecauseOfSelection;
+  mGoForwardEnabled = enableGoForward;
+  mGoBackEnabled = enableGoBack;
+  mNumSelectedRows = numSelected;
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::GetSelectedIndices(nsMsgViewIndexArray& selection)
+{
+  if (mTreeSelection)
+  {
+    int32_t viewSize = GetSize();
+    int32_t count;
+    mTreeSelection->GetCount(&count);
+    selection.SetLength(count);
+    count = 0;
+    int32_t selectionCount;
+    mTreeSelection->GetRangeCount(&selectionCount);
+    for (int32_t i = 0; i < selectionCount; i++)
+    {
+      int32_t startRange = -1;
+      int32_t endRange = -1;
+      mTreeSelection->GetRangeAt(i, &startRange, &endRange);
+      if (startRange >= 0 && startRange < viewSize)
+      {
+        for (int32_t rangeIndex = startRange; rangeIndex <= endRange && rangeIndex < viewSize; rangeIndex++)
+          selection[count++] = rangeIndex;
+      }
+    }
+    NS_ASSERTION(selection.Length() == uint32_t(count), "selection count is wrong");
+    selection.SetLength(count);
+  }
+  else
+  {
+    // if there is no tree selection object then we must be in stand alone message mode.
+    // in that case the selected indices are really just the current message key.
+    nsMsgViewIndex viewIndex = FindViewIndex(m_currentlyDisplayedMsgKey);
+    if (viewIndex != nsMsgViewIndex_None)
+      selection.AppendElement(viewIndex);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetRowProperties(int32_t index, nsAString& properties)
+{
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  // this is where we tell the tree to apply styles to a particular row
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  nsresult rv = NS_OK;
+
+  rv = GetMsgHdrForViewIndex(index, getter_AddRefs(msgHdr));
+
+  if (NS_FAILED(rv) || !msgHdr) {
+    ClearHdrCache();
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  }
+
+  nsCString keywordProperty;
+  FetchRowKeywords(index, msgHdr, keywordProperty);
+  if (!keywordProperty.IsEmpty())
+    AppendKeywordProperties(keywordProperty, properties, false);
+
+  // give the custom column handlers a chance to style the row.
+  for (int i = 0; i < m_customColumnHandlers.Count(); i++)
+  {
+    nsString extra;
+    m_customColumnHandlers[i]->GetRowProperties(index, extra);
+    if (!extra.IsEmpty())
+    {
+      properties.Append(' ');
+      properties.Append(extra);
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetColumnProperties(nsITreeColumn* col, nsAString& properties)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetCellProperties(int32_t aRow, nsITreeColumn *col, nsAString& properties)
+{
+  if (!IsValidIndex(aRow))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  // this is where we tell the tree to apply styles to a particular row
+  // i.e. if the row is an unread message...
+
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  nsresult rv = NS_OK;
+
+  rv = GetMsgHdrForViewIndex(aRow, getter_AddRefs(msgHdr));
+
+  if (NS_FAILED(rv) || !msgHdr)
+  {
+    ClearHdrCache();
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  }
+
+  const char16_t* colID;
+  col->GetIdConst(&colID);
+  nsIMsgCustomColumnHandler* colHandler = GetColumnHandler(colID);
+  if (colHandler != nullptr)
+    colHandler->GetCellProperties(aRow, col, properties);
+  else if (colID[0] == 'c') // correspondent
+  {
+    if (IsOutgoingMsg(msgHdr))
+      properties.AssignLiteral("outgoing");
+    else
+      properties.AssignLiteral("incoming");
+  }
+
+  if (!properties.IsEmpty())
+    properties.Append(' ');
+
+  properties.Append(mMessageType);
+
+  uint32_t flags;
+  msgHdr->GetFlags(&flags);
+
+  if (!(flags & nsMsgMessageFlags::Read))
+    properties.AppendLiteral(" unread");
+  else
+    properties.AppendLiteral(" read");
+
+  if (flags & nsMsgMessageFlags::Replied)
+    properties.AppendLiteral(" replied");
+
+  if (flags & nsMsgMessageFlags::Forwarded)
+    properties.AppendLiteral(" forwarded");
+
+  if (flags & nsMsgMessageFlags::New)
+    properties.AppendLiteral(" new");
+
+  if (m_flags[aRow] & nsMsgMessageFlags::Marked)
+    properties.AppendLiteral(" flagged");
+
+  // For threaded display add the ignoreSubthread property to the
+  // subthread top row (this row). For non-threaded add it to all rows.
+  if (!(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay) &&
+      (flags & nsMsgMessageFlags::Ignored)) {
+    properties.AppendLiteral(" ignoreSubthread");
+  }
+  else {
+    bool ignored;
+    msgHdr->GetIsKilled(&ignored);
+    if (ignored)
+      properties.AppendLiteral(" ignoreSubthread");
+  }
+
+  nsCOMPtr <nsIMsgLocalMailFolder> localFolder = do_QueryInterface(m_folder);
+
+  if ((flags & nsMsgMessageFlags::Offline) || (localFolder && !(flags & nsMsgMessageFlags::Partial)))
+    properties.AppendLiteral(" offline");
+
+  if (flags & nsMsgMessageFlags::Attachment)
+    properties.AppendLiteral(" attach");
+
+  if ((mDeleteModel == nsMsgImapDeleteModels::IMAPDelete) && (flags & nsMsgMessageFlags::IMAPDeleted))
+    properties.AppendLiteral(" imapdeleted");
+
+  nsCString imageSize;
+  msgHdr->GetStringProperty("imageSize", getter_Copies(imageSize));
+  if (!imageSize.IsEmpty())
+    properties.AppendLiteral(" hasimage");
+
+  nsCString junkScoreStr;
+  msgHdr->GetStringProperty("junkscore", getter_Copies(junkScoreStr));
+  if (!junkScoreStr.IsEmpty()) {
+    if (junkScoreStr.ToInteger(&rv) == nsIJunkMailPlugin::IS_SPAM_SCORE)
+      properties.AppendLiteral(" junk");
+    else
+      properties.AppendLiteral(" notjunk");
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Converting junkScore to integer failed.");
+  }
+
+  nsCString keywords;
+  FetchRowKeywords(aRow, msgHdr, keywords);
+  if (!keywords.IsEmpty())
+    AppendKeywordProperties(keywords, properties, true);
+
+  // this is a double fetch of the keywords property since we also fetch
+  // it for the tags - do we want to do this?
+  // I'm not sure anyone uses the kw- property, though it could be nice
+  // for people wanting to extend the thread pane.
+  nsCString keywordProperty;
+  msgHdr->GetStringProperty("keywords", getter_Copies(keywordProperty));
+  if (!keywordProperty.IsEmpty())
+  {
+    NS_ConvertUTF8toUTF16 keywords(keywordProperty);
+    int32_t spaceIndex = 0;
+    do
+    {
+      spaceIndex = keywords.FindChar(' ');
+      int32_t endOfKeyword = (spaceIndex == -1) ? keywords.Length() : spaceIndex;
+      properties.AppendLiteral(" kw-");
+      properties.Append(StringHead(keywords, endOfKeyword));
+      if (spaceIndex > 0)
+        keywords.Cut(0, endOfKeyword + 1);
+    }
+    while (spaceIndex > 0);
+  }
+
+#ifdef SUPPORT_PRIORITY_COLORS
+  // add special styles for priority
+  nsMsgPriorityValue priority;
+  msgHdr->GetPriority(&priority);
+  switch (priority)
+  {
+  case nsMsgPriority::highest:
+    properties.append(" priority-highest");
+    break;
+  case nsMsgPriority::high:
+    properties.append(" priority-high");
+    break;
+  case nsMsgPriority::low:
+    properties.append(" priority-low");
+    break;
+  case nsMsgPriority::lowest:
+    properties.append(" priority-lowest");
+    break;
+  default:
+    break;
+  }
+#endif
+
+
+  nsCOMPtr <nsIMsgThread> thread;
+  rv = GetThreadContainingIndex(aRow, getter_AddRefs(thread));
+  if (NS_SUCCEEDED(rv) && thread)
+  {
+    uint32_t numUnreadChildren;
+    thread->GetNumUnreadChildren(&numUnreadChildren);
+    if (numUnreadChildren > 0)
+      properties.AppendLiteral(" hasUnread");
+
+    // For threaded display add the ignore/watch properties to the
+    // thread top row. For non-threaded add it to all rows.
+    if (!(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay) ||
+         ((m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay) &&
+        (m_flags[aRow] & MSG_VIEW_FLAG_ISTHREAD))) {
+      thread->GetFlags(&flags);
+      if (flags & nsMsgMessageFlags::Watched)
+        properties.AppendLiteral(" watch");
+      if (flags & nsMsgMessageFlags::Ignored)
+        properties.AppendLiteral(" ignore");
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::IsContainer(int32_t index, bool *_retval)
+{
+  if (!IsValidIndex(index))
+      return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    uint32_t flags = m_flags[index];
+    *_retval = !!(flags & MSG_VIEW_FLAG_HASCHILDREN);
+  }
+  else
+    *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::IsContainerOpen(int32_t index, bool *_retval)
+{
+  if (!IsValidIndex(index))
+      return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    uint32_t flags = m_flags[index];
+    *_retval = (flags & MSG_VIEW_FLAG_HASCHILDREN) && !(flags & nsMsgMessageFlags::Elided);
+  }
+  else
+    *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::IsContainerEmpty(int32_t index, bool *_retval)
+{
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    uint32_t flags = m_flags[index];
+    *_retval = !(flags & MSG_VIEW_FLAG_HASCHILDREN);
+  }
+  else
+    *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::IsSeparator(int32_t index, bool *_retval)
+{
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  *_retval = false;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetParentIndex(int32_t rowIndex, int32_t *_retval)
+{
+  *_retval = -1;
+
+  int32_t rowIndexLevel;
+  nsresult rv = GetLevel(rowIndex, &rowIndexLevel);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t i;
+  for(i = rowIndex; i >= 0; i--)
+  {
+    int32_t l;
+    GetLevel(i, &l);
+    if (l < rowIndexLevel)
+    {
+      *_retval = i;
+      break;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::HasNextSibling(int32_t rowIndex, int32_t afterIndex, bool *_retval)
+{
+  *_retval = false;
+
+  int32_t rowIndexLevel;
+  GetLevel(rowIndex, &rowIndexLevel);
+
+  int32_t i;
+  int32_t count;
+  GetRowCount(&count);
+  for(i = afterIndex + 1; i < count; i++)
+  {
+    int32_t l;
+    GetLevel(i, &l);
+    if (l < rowIndexLevel)
+      break;
+    if (l == rowIndexLevel)
+    {
+      *_retval = true;
+      break;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetLevel(int32_t index, int32_t *_retval)
+{
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+    *_retval = m_levels[index];
+  else
+    *_retval = 0;
+  return NS_OK;
+}
+
+// search view will override this since headers can span db's
+nsresult nsMsgDBView::GetMsgHdrForViewIndex(nsMsgViewIndex index, nsIMsgDBHdr **msgHdr)
+{
+  nsresult rv = NS_OK;
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  nsMsgKey key = m_keys[index];
+  if (key == nsMsgKey_None || !m_db)
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (key == m_cachedMsgKey)
+  {
+    *msgHdr = m_cachedHdr;
+    NS_IF_ADDREF(*msgHdr);
+  }
+  else
+  {
+    rv = m_db->GetMsgHdrForKey(key, msgHdr);
+    if (NS_SUCCEEDED(rv))
+    {
+      m_cachedHdr = *msgHdr;
+      m_cachedMsgKey = key;
+    }
+  }
+
+  return rv;
+}
+
+void nsMsgDBView::InsertMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr,
+                                 nsMsgKey msgKey, uint32_t flags, uint32_t level)
+{
+  if ((int32_t) index < 0 || index > m_keys.Length())
+  {
+    // Something's gone wrong in a caller, but we have no clue why
+    // Return without adding the header to the view
+    NS_ERROR("Index for message header insertion out of array range!");
+    return;
+  }
+  m_keys.InsertElementAt(index, msgKey);
+  m_flags.InsertElementAt(index, flags);
+  m_levels.InsertElementAt(index, level);
+}
+
+void nsMsgDBView::SetMsgHdrAt(nsIMsgDBHdr *hdr, nsMsgViewIndex index,
+                              nsMsgKey msgKey, uint32_t flags, uint32_t level)
+{
+  m_keys[index] = msgKey;
+  m_flags[index] = flags;
+  m_levels[index] = level;
+}
+
+nsresult nsMsgDBView::GetFolderForViewIndex(nsMsgViewIndex index, nsIMsgFolder **aFolder)
+{
+  NS_IF_ADDREF(*aFolder = m_folder);
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::GetDBForViewIndex(nsMsgViewIndex index, nsIMsgDatabase **db)
+{
+  NS_IF_ADDREF(*db = m_db);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetImageSrc(int32_t aRow, nsITreeColumn* aCol, nsAString& aValue)
+{
+  NS_ENSURE_ARG_POINTER(aCol);
+  //attempt to retreive a custom column handler. If it exists call it and return
+  const char16_t* colID;
+  aCol->GetIdConst(&colID);
+
+  nsIMsgCustomColumnHandler* colHandler = GetColumnHandler(colID);
+
+  if (colHandler)
+  {
+    colHandler->GetImageSrc(aRow, aCol, aValue);
+    return NS_OK;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::GetProgressMode(int32_t aRow, nsITreeColumn* aCol, int32_t* _retval)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetCellValue(int32_t aRow, nsITreeColumn* aCol, nsAString& aValue)
+{
+  if (!IsValidIndex(aRow))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  nsresult rv = GetMsgHdrForViewIndex(aRow, getter_AddRefs(msgHdr));
+
+  if (NS_FAILED(rv) || !msgHdr)
+  {
+    ClearHdrCache();
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  }
+
+  const char16_t* colID;
+  aCol->GetIdConst(&colID);
+
+  uint32_t flags;
+  msgHdr->GetFlags(&flags);
+
+  aValue.Truncate();
+  // provide a string "value" for cells that do not normally have text.
+  // use empty string for the normal states "Read", "Not Starred", "No Attachment" and "Not Junk"
+  switch (colID[0])
+  {
+    case 'a': // attachment column
+      if (flags & nsMsgMessageFlags::Attachment) {
+        nsString tmp_str;
+        tmp_str.Adopt(GetString(u"messageHasAttachment"));
+        aValue.Assign(tmp_str);
+      }
+      break;
+    case 'f': // flagged (starred) column
+      if (flags & nsMsgMessageFlags::Marked) {
+        nsString tmp_str;
+        tmp_str.Adopt(GetString(u"messageHasFlag"));
+        aValue.Assign(tmp_str);
+      }
+      break;
+    case 'j': // junk column
+      if (JunkControlsEnabled(aRow))
+      {
+        nsCString junkScoreStr;
+        msgHdr->GetStringProperty("junkscore", getter_Copies(junkScoreStr));
+        // Only need to assing a real value for junk, it's empty already
+        // as it should be for non-junk.
+        if (!junkScoreStr.IsEmpty() &&
+            (junkScoreStr.ToInteger(&rv) == nsIJunkMailPlugin::IS_SPAM_SCORE))
+          aValue.AssignLiteral("messageJunk");
+
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Converting junkScore to integer failed.");
+      }
+      break;
+    case 't':
+      if (colID[1] == 'h' && (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+      {       // thread column
+        bool isContainer, isContainerEmpty, isContainerOpen;
+        IsContainer(aRow, &isContainer);
+        if (isContainer)
+        {
+          IsContainerEmpty(aRow, &isContainerEmpty);
+          if (!isContainerEmpty)
+          {
+            nsString tmp_str;
+
+            IsContainerOpen(aRow, &isContainerOpen);
+            tmp_str.Adopt(GetString(isContainerOpen ?
+                            u"messageExpanded" :
+                            u"messageCollapsed"));
+            aValue.Assign(tmp_str);
+          }
+        }
+      }
+      break;
+    case 'u': // read/unread column
+      if (!(flags & nsMsgMessageFlags::Read)) {
+        nsString tmp_str;
+        tmp_str.Adopt(GetString(u"messageUnread"));
+        aValue.Assign(tmp_str);
+      }
+      break;
+    default:
+      aValue.Assign(colID);
+      break;
+  }
+  return rv;
+}
+
+void nsMsgDBView::RememberDeletedMsgHdr(nsIMsgDBHdr *msgHdr)
+{
+  nsCString messageId;
+  msgHdr->GetMessageId(getter_Copies(messageId));
+  if (mRecentlyDeletedArrayIndex >= mRecentlyDeletedMsgIds.Length())
+    mRecentlyDeletedMsgIds.AppendElement(messageId);
+  else
+    mRecentlyDeletedMsgIds[mRecentlyDeletedArrayIndex] = messageId;
+  // only remember last 20 deleted msgs.
+  mRecentlyDeletedArrayIndex = (mRecentlyDeletedArrayIndex + 1) % 20;
+}
+
+bool nsMsgDBView::WasHdrRecentlyDeleted(nsIMsgDBHdr *msgHdr)
+{
+  nsCString messageId;
+  msgHdr->GetMessageId(getter_Copies(messageId));
+  return mRecentlyDeletedMsgIds.Contains(messageId);
+}
+
+//add a custom column handler
+NS_IMETHODIMP nsMsgDBView::AddColumnHandler(const nsAString& column, nsIMsgCustomColumnHandler* handler)
+{
+  bool custColInSort = false;
+  size_t index = m_customColumnHandlerIDs.IndexOf(column);
+
+  nsAutoString strColID(column);
+
+  //does not exist
+  if (index == m_customColumnHandlerIDs.NoIndex)
+  {
+    m_customColumnHandlerIDs.AppendElement(strColID);
+    m_customColumnHandlers.AppendObject(handler);
+  }
+  else
+  {
+    //insert new handler into the appropriate place in the COMPtr array
+    //no need to replace the column ID (it's the same)
+    m_customColumnHandlers.ReplaceObjectAt(handler, index);
+
+  }
+  // Check if the column name matches any of the columns in
+  // m_sortColumns, and if so, set m_sortColumns[i].mColHandler
+  for (uint32_t i = 0; i < m_sortColumns.Length(); i++)
+  {
+    MsgViewSortColumnInfo &sortInfo = m_sortColumns[i];
+    if (sortInfo.mSortType == nsMsgViewSortType::byCustom &&
+        sortInfo.mCustomColumnName.Equals(column))
+    {
+      custColInSort = true;
+      sortInfo.mColHandler = handler;
+    }
+  }
+
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+    // Grouped view has its own ways.
+    return NS_OK;
+
+  // This cust col is in sort columns, and all are now registered, so sort.
+  if (custColInSort && !CustomColumnsInSortAndNotRegistered())
+    Sort(m_sortType, m_sortOrder);
+
+  return NS_OK;
+}
+
+//remove a custom column handler
+NS_IMETHODIMP nsMsgDBView::RemoveColumnHandler(const nsAString& aColID)
+{
+
+  // here we should check if the column name matches any of the columns in
+  // m_sortColumns, and if so, clear m_sortColumns[i].mColHandler
+  size_t index = m_customColumnHandlerIDs.IndexOf(aColID);
+
+  if (index != m_customColumnHandlerIDs.NoIndex)
+  {
+    m_customColumnHandlerIDs.RemoveElementAt(index);
+    m_customColumnHandlers.RemoveObjectAt(index);
+    // Check if the column name matches any of the columns in
+    // m_sortColumns, and if so, clear m_sortColumns[i].mColHandler
+    for (uint32_t i = 0; i < m_sortColumns.Length(); i++)
+    {
+      MsgViewSortColumnInfo &sortInfo = m_sortColumns[i];
+      if (sortInfo.mSortType == nsMsgViewSortType::byCustom &&
+            sortInfo.mCustomColumnName.Equals(aColID))
+        sortInfo.mColHandler = nullptr;
+    }
+
+    return NS_OK;
+  }
+
+  return NS_ERROR_FAILURE; //can't remove a column that isn't currently custom handled
+}
+
+//TODO: NS_ENSURE_SUCCESS
+nsIMsgCustomColumnHandler* nsMsgDBView::GetCurColumnHandler()
+{
+  return GetColumnHandler(m_curCustomColumn.get());
+}
+
+NS_IMETHODIMP nsMsgDBView::SetCurCustomColumn(const nsAString& aColID)
+{
+  m_curCustomColumn = aColID;
+
+  if (m_viewFolder)
+  {
+    nsCOMPtr <nsIMsgDatabase> db;
+    nsCOMPtr <nsIDBFolderInfo> folderInfo;
+    nsresult rv = m_viewFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(db));
+    NS_ENSURE_SUCCESS(rv,rv);
+    folderInfo->SetProperty("customSortCol", aColID);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetCurCustomColumn(nsAString &result)
+{
+  result = m_curCustomColumn;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSecondaryCustomColumn(nsAString &result)
+{
+  result = m_secondaryCustomColumn;
+  return NS_OK;
+}
+
+nsIMsgCustomColumnHandler* nsMsgDBView::GetColumnHandler(const char16_t *colID)
+{
+  size_t index = m_customColumnHandlerIDs.IndexOf(nsDependentString(colID));
+  return (index != m_customColumnHandlerIDs.NoIndex) ?
+    m_customColumnHandlers[index] : nullptr;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetColumnHandler(const nsAString& aColID, nsIMsgCustomColumnHandler** aHandler)
+{
+  NS_ENSURE_ARG_POINTER(aHandler);
+  nsAutoString column(aColID);
+  NS_IF_ADDREF(*aHandler = GetColumnHandler(column.get()));
+  return (*aHandler) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+// Check if any active sort columns are custom. If none are custom, return false
+// and go on as always. If any are custom, and all are not registered yet,
+// return true (so that the caller can postpone sort). When the custom column
+// observer is notified with MsgCreateDBView and registers the handler,
+// AddColumnHandler will sort once all required handlers are set.
+bool nsMsgDBView::CustomColumnsInSortAndNotRegistered()
+{
+  // The initial sort on view open has been started, subsequent user initiated
+  // sort callers can ignore verifying cust col registration.
+  m_checkedCustomColumns = true;
+
+  // DecodeColumnSort must have already created m_sortColumns, otherwise we
+  // can't know, but go on anyway.
+  if (!m_sortColumns.Length())
+    return false;
+
+  bool custColNotRegistered = false;
+  for (uint32_t i = 0; i < m_sortColumns.Length() && !custColNotRegistered; i++)
+  {
+    if (m_sortColumns[i].mSortType == nsMsgViewSortType::byCustom &&
+        m_sortColumns[i].mColHandler == nullptr)
+      custColNotRegistered = true;
+  }
+
+  return custColNotRegistered;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetCellText(int32_t aRow, nsITreeColumn* aCol, nsAString& aValue)
+{
+  const char16_t* colID;
+  aCol->GetIdConst(&colID);
+
+  if (!IsValidIndex(aRow))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  aValue.Truncate();
+
+  //attempt to retreive a custom column handler. If it exists call it and return
+  nsIMsgCustomColumnHandler* colHandler = GetColumnHandler(colID);
+
+  if (colHandler)
+  {
+    colHandler->GetCellText(aRow, aCol, aValue);
+    return NS_OK;
+  }
+
+  return CellTextForColumn(aRow, colID, aValue);
+}
+
+NS_IMETHODIMP nsMsgDBView::CellTextForColumn(int32_t aRow,
+                                             const char16_t *aColumnName,
+                                             nsAString &aValue)
+{
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  nsresult rv = GetMsgHdrForViewIndex(aRow, getter_AddRefs(msgHdr));
+
+  if (NS_FAILED(rv) || !msgHdr)
+  {
+    ClearHdrCache();
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  }
+
+  nsCOMPtr<nsIMsgThread> thread;
+
+  switch (aColumnName[0])
+  {
+  case 's':
+    if (aColumnName[1] == 'u') // subject
+      rv = FetchSubject(msgHdr, m_flags[aRow], aValue);
+    else if (aColumnName[1] == 'e') // sender
+      rv = FetchAuthor(msgHdr, aValue);
+    else if (aColumnName[1] == 'i') // size
+      rv = FetchSize(msgHdr, aValue);
+    else if (aColumnName[1] == 't') // status
+    {
+      uint32_t flags;
+      msgHdr->GetFlags(&flags);
+      rv = FetchStatus(flags, aValue);
+    }
+    break;
+  case 'r':
+    if (aColumnName[3] == 'i') // recipient
+      rv = FetchRecipients(msgHdr, aValue);
+    else if (aColumnName[3] == 'e') // received
+      rv = FetchDate(msgHdr, aValue, true);
+    break;
+  case 'd':  // date
+    rv = FetchDate(msgHdr, aValue);
+    break;
+  case 'c': // correspondent
+    if (IsOutgoingMsg(msgHdr))
+      rv = FetchRecipients(msgHdr, aValue);
+    else
+      rv = FetchAuthor(msgHdr, aValue);
+    break;
+  case 'p': // priority
+    rv = FetchPriority(msgHdr, aValue);
+    break;
+  case 'a': // account
+    if (aColumnName[1] == 'c') // account
+      rv = FetchAccount(msgHdr, aValue);
+    break;
+  case 't':
+    // total msgs in thread column
+    if (aColumnName[1] == 'o' && (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    {
+      if (m_flags[aRow] & MSG_VIEW_FLAG_ISTHREAD)
+      {
+        rv = GetThreadContainingIndex(aRow, getter_AddRefs(thread));
+        if (NS_SUCCEEDED(rv) && thread)
+        {
+          nsAutoString formattedCountString;
+          uint32_t numChildren;
+          thread->GetNumChildren(&numChildren);
+          formattedCountString.AppendInt(numChildren);
+          aValue.Assign(formattedCountString);
+        }
+      }
+    }
+    else if (aColumnName[1] == 'a') // tags
+    {
+      rv = FetchTags(msgHdr, aValue);
+    }
+    break;
+  case 'u':
+    // unread msgs in thread col
+    if (aColumnName[6] == 'C' && (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    {
+      if (m_flags[aRow] & MSG_VIEW_FLAG_ISTHREAD)
+      {
+        rv = GetThreadContainingIndex(aRow, getter_AddRefs(thread));
+        if (NS_SUCCEEDED(rv) && thread)
+        {
+          nsAutoString formattedCountString;
+          uint32_t numUnreadChildren;
+          thread->GetNumUnreadChildren(&numUnreadChildren);
+          if (numUnreadChildren > 0)
+          {
+            formattedCountString.AppendInt(numUnreadChildren);
+            aValue.Assign(formattedCountString);
+          }
+        }
+      }
+    }
+    break;
+  case 'j':
+    {
+      nsCString junkScoreStr;
+      msgHdr->GetStringProperty("junkscore", getter_Copies(junkScoreStr));
+      CopyASCIItoUTF16(junkScoreStr, aValue);
+    }
+    break;
+  case 'i': // id
+    {
+      nsAutoString keyString;
+      nsMsgKey key;
+      msgHdr->GetMessageKey(&key);
+      keyString.AppendInt((int64_t)key);
+      aValue.Assign(keyString);
+    }
+    break;
+  default:
+    break;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetTree(nsITreeBoxObject *tree)
+{
+  mTree = tree;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::ToggleOpenState(int32_t index)
+{
+  uint32_t numChanged;
+  nsresult rv = ToggleExpansion(index, &numChanged);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::CycleHeader(nsITreeColumn* aCol)
+{
+    // let HandleColumnClick() in threadPane.js handle it
+    // since it will set / clear the sort indicators.
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::CycleCell(int32_t row, nsITreeColumn* col)
+{
+  if (!IsValidIndex(row))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  const char16_t* colID;
+  col->GetIdConst(&colID);
+
+  //attempt to retreive a custom column handler. If it exists call it and return
+  nsIMsgCustomColumnHandler* colHandler = GetColumnHandler(colID);
+
+  if (colHandler)
+  {
+    colHandler->CycleCell(row, col);
+    return NS_OK;
+  }
+
+  // The cyclers below don't work for the grouped header dummy row, currently.
+  // A future implementation should consider both collapsed and expanded state.
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort &&
+      m_flags[row] & MSG_VIEW_FLAG_DUMMY)
+    return NS_OK;
+
+  switch (colID[0])
+  {
+  case 'u': // unreadButtonColHeader
+    if (colID[6] == 'B')
+      ApplyCommandToIndices(nsMsgViewCommandType::toggleMessageRead, (nsMsgViewIndex *) &row, 1);
+   break;
+  case 't': // tag cell, threaded cell or total cell
+    if (colID[1] == 'h')
+    {
+      ExpandAndSelectThreadByIndex(row, false);
+    }
+    else if (colID[1] == 'a')
+    {
+      // ### Do we want to keep this behaviour but switch it to tags?
+      // We could enumerate over the tags and go to the next one - it looks
+      // to me like this wasn't working before tags landed, so maybe not
+      // worth bothering with.
+    }
+    break;
+  case 'f': // flagged column
+    // toggle the flagged status of the element at row.
+    if (m_flags[row] & nsMsgMessageFlags::Marked)
+      ApplyCommandToIndices(nsMsgViewCommandType::unflagMessages, (nsMsgViewIndex *) &row, 1);
+    else
+      ApplyCommandToIndices(nsMsgViewCommandType::flagMessages, (nsMsgViewIndex *) &row, 1);
+    break;
+  case 'j': // junkStatus column
+    {
+      if (!JunkControlsEnabled(row))
+        return NS_OK;
+
+      nsCOMPtr <nsIMsgDBHdr> msgHdr;
+
+      nsresult rv = GetMsgHdrForViewIndex(row, getter_AddRefs(msgHdr));
+      if (NS_SUCCEEDED(rv) && msgHdr)
+      {
+        nsCString junkScoreStr;
+        rv = msgHdr->GetStringProperty("junkscore", getter_Copies(junkScoreStr));
+        if (junkScoreStr.IsEmpty() || (junkScoreStr.ToInteger(&rv) == nsIJunkMailPlugin::IS_HAM_SCORE))
+          ApplyCommandToIndices(nsMsgViewCommandType::junk, (nsMsgViewIndex *) &row, 1);
+        else
+          ApplyCommandToIndices(nsMsgViewCommandType::unjunk, (nsMsgViewIndex *) &row, 1);
+
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Converting junkScore to integer failed.");
+      }
+    }
+    break;
+  default:
+    break;
+
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::PerformAction(const char16_t *action)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::PerformActionOnRow(const char16_t *action, int32_t row)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::PerformActionOnCell(const char16_t *action, int32_t row, nsITreeColumn* col)
+{
+  return NS_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// end nsITreeView Implementation Methods
+///////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP nsMsgDBView::Open(nsIMsgFolder *folder, nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder, nsMsgViewFlagsTypeValue viewFlags, int32_t *pCount)
+{
+  m_viewFlags = viewFlags;
+  m_sortOrder = sortOrder;
+  m_sortType = sortType;
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+           do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool userNeedsToAuthenticate = false;
+  // if we're PasswordProtectLocalCache, then we need to find out if the server is authenticated.
+  (void) accountManager->GetUserNeedsToAuthenticate(&userNeedsToAuthenticate);
+  if (userNeedsToAuthenticate)
+    return NS_MSG_USER_NOT_AUTHENTICATED;
+
+  if (folder) // search view will have a null folder
+  {
+    nsCOMPtr <nsIDBFolderInfo> folderInfo;
+    rv = folder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(m_db));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIMsgDBService> msgDBService = do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    msgDBService->RegisterPendingListener(folder, this);
+    m_folder = folder;
+
+    if (!m_viewFolder)
+      // There is never a viewFolder already set except for the single folder
+      // saved search case, where the backing folder m_folder is different from
+      // the m_viewFolder with its own dbFolderInfo state.
+      m_viewFolder = folder;
+
+    SetMRUTimeForFolder(m_viewFolder);
+
+    RestoreSortInfo();
+
+    // determine if we are in a news folder or not.
+    // if yes, we'll show lines instead of size, and special icons in the thread pane
+    nsCOMPtr <nsIMsgIncomingServer> server;
+    rv = folder->GetServer(getter_AddRefs(server));
+    NS_ENSURE_SUCCESS(rv,rv);
+    nsCString type;
+    rv = server->GetType(type);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    // I'm not sure this is correct, because XF virtual folders with mixed news
+    // and mail can have this set.
+    mIsNews = MsgLowerCaseEqualsLiteral(type, "nntp");
+
+    // Default to a virtual folder if folder not set, since synthetic search
+    // views may not have a folder.
+    uint32_t folderFlags = nsMsgFolderFlags::Virtual;
+    if (folder)
+      folder->GetFlags(&folderFlags);
+    mIsXFVirtual = folderFlags & nsMsgFolderFlags::Virtual;
+
+    if (!mIsXFVirtual && MsgLowerCaseEqualsLiteral(type, "rss"))
+      mIsRss = true;
+
+    // special case nntp --> news since we'll break themes if we try to be consistent
+    if (mIsNews)
+      mMessageType.AssignLiteral("news");
+    else
+      CopyUTF8toUTF16(type, mMessageType);
+
+    GetImapDeleteModel(nullptr);
+
+    nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
+    if (prefs)
+    {
+      prefs->GetBoolPref("mailnews.sort_threads_by_root", &mSortThreadsByRoot);
+
+      if (mIsNews)
+        prefs->GetBoolPref("news.show_size_in_lines", &mShowSizeInLines);
+    }
+  }
+
+  nsCOMPtr<nsIArray> identities;
+  rv = accountManager->GetAllIdentities(getter_AddRefs(identities));
+  if (!identities)
+    return rv;
+
+  uint32_t count;
+  identities->GetLength(&count);
+  for (uint32_t i = 0; i < count; i++)
+  {
+    nsCOMPtr<nsIMsgIdentity> identity(do_QueryElementAt(identities, i));
+    if (!identity)
+      continue;
+
+    nsCString email;
+    identity->GetEmail(email);
+    if (!email.IsEmpty())
+      mEmails.PutEntry(email);
+
+    identity->GetReplyTo(email);
+    if (!email.IsEmpty())
+      mEmails.PutEntry(email);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::Close()
+{
+  int32_t oldSize = GetSize();
+  // this is important, because the tree will ask us for our
+  // row count, which get determine from the number of keys.
+  m_keys.Clear();
+  // be consistent
+  m_flags.Clear();
+  m_levels.Clear();
+
+  // clear these out since they no longer apply if we're switching a folder
+  if (mJunkHdrs)
+    mJunkHdrs->Clear();
+
+  // this needs to happen after we remove all the keys, since RowCountChanged() will call our GetRowCount()
+  if (mTree)
+    mTree->RowCountChanged(0, -oldSize);
+
+  ClearHdrCache();
+  if (m_db)
+  {
+    m_db->RemoveListener(this);
+    m_db = nullptr;
+  }
+  if (m_folder)
+  {
+    nsresult rv;
+    nsCOMPtr<nsIMsgDBService> msgDBService = do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    msgDBService->UnregisterPendingListener(this);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::OpenWithHdrs(nsISimpleEnumerator *aHeaders, nsMsgViewSortTypeValue aSortType,
+                                        nsMsgViewSortOrderValue aSortOrder, nsMsgViewFlagsTypeValue aViewFlags,
+                                        int32_t *aCount)
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgDBView::Init(nsIMessenger * aMessengerInstance, nsIMsgWindow * aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater)
+{
+  mMessengerWeak = do_GetWeakReference(aMessengerInstance);
+  mMsgWindowWeak = do_GetWeakReference(aMsgWindow);
+  mCommandUpdater = aCmdUpdater;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetSuppressCommandUpdating(bool aSuppressCommandUpdating)
+{
+  mSuppressCommandUpdating = aSuppressCommandUpdating;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSuppressCommandUpdating(bool * aSuppressCommandUpdating)
+{
+  *aSuppressCommandUpdating = mSuppressCommandUpdating;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetSuppressMsgDisplay(bool aSuppressDisplay)
+{
+  uint32_t numSelected = 0;
+  GetNumSelected(&numSelected);
+
+  bool forceDisplay = false;
+  if (mSuppressMsgDisplay && !aSuppressDisplay && numSelected == 1)
+    forceDisplay = true;
+
+  mSuppressMsgDisplay = aSuppressDisplay;
+  if (forceDisplay)
+  {
+    // get the view indexfor the currently selected message
+    nsMsgViewIndex viewIndex;
+    nsresult rv = GetViewIndexForFirstSelectedMsg(&viewIndex);
+    if (NS_SUCCEEDED(rv) && viewIndex != nsMsgViewIndex_None)
+       LoadMessageByViewIndex(viewIndex);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSuppressMsgDisplay(bool * aSuppressDisplay)
+{
+  *aSuppressDisplay = mSuppressMsgDisplay;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetUsingLines(bool * aUsingLines)
+{
+  *aUsingLines = mShowSizeInLines;
+  return NS_OK;
+}
+
+int CompareViewIndices (const void *v1, const void *v2, void *)
+{
+  nsMsgViewIndex i1 = *(nsMsgViewIndex*) v1;
+  nsMsgViewIndex i2 = *(nsMsgViewIndex*) v2;
+  return i1 - i2;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetIndicesForSelection(uint32_t *length, nsMsgViewIndex **indices)
+{
+  NS_ENSURE_ARG_POINTER(length);
+  *length = 0;
+  NS_ENSURE_ARG_POINTER(indices);
+  *indices = nullptr;
+
+  nsMsgViewIndexArray selection;
+  GetSelectedIndices(selection);
+  uint32_t numIndices = selection.Length();
+  if (!numIndices) return NS_OK;
+  *length = numIndices;
+
+  uint32_t datalen = numIndices * sizeof(nsMsgViewIndex);
+  *indices = (nsMsgViewIndex *)NS_Alloc(datalen);
+  if (!*indices) return NS_ERROR_OUT_OF_MEMORY;
+  memcpy(*indices, selection.Elements(), datalen);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSelectedMsgHdrs(uint32_t *aLength, nsIMsgDBHdr ***aResult)
+{
+  nsresult rv;
+
+  NS_ENSURE_ARG_POINTER(aLength);
+  *aLength = 0;
+
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = nullptr;
+
+  nsMsgViewIndexArray selection;
+  GetSelectedIndices(selection);
+  uint32_t numIndices = selection.Length();
+  if (!numIndices) return NS_OK;
+
+  nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = GetHeadersFromSelection(selection.Elements(), numIndices, messages);
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint32_t numMsgsSelected;
+  messages->GetLength(&numMsgsSelected);
+
+  nsIMsgDBHdr **headers = static_cast<nsIMsgDBHdr**>(NS_Alloc(
+    sizeof(nsIMsgDBHdr*) * numMsgsSelected));
+  for (uint32_t i = 0; i < numMsgsSelected; i++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr = do_QueryElementAt(messages, i, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    msgHdr.forget(&headers[i]); // Already AddRefed
+  }
+
+  *aLength = numMsgsSelected;
+  *aResult = headers;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetMsgHdrsForSelection(nsIMutableArray **aResult)
+{
+  nsMsgViewIndexArray selection;
+  GetSelectedIndices(selection);
+  uint32_t numIndices = selection.Length();
+
+  nsresult rv;
+  nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = GetHeadersFromSelection(selection.Elements(), numIndices, messages);
+  NS_ENSURE_SUCCESS(rv, rv);
+  messages.forget(aResult);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetURIsForSelection(uint32_t *length, char ***uris)
+{
+  nsresult rv = NS_OK;
+
+  NS_ENSURE_ARG_POINTER(length);
+  *length = 0;
+
+  NS_ENSURE_ARG_POINTER(uris);
+  *uris = nullptr;
+
+  nsMsgViewIndexArray selection;
+  GetSelectedIndices(selection);
+  uint32_t numIndices = selection.Length();
+  if (!numIndices) return NS_OK;
+
+  nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = GetHeadersFromSelection(selection.Elements(), numIndices, messages);
+  NS_ENSURE_SUCCESS(rv, rv);
+  messages->GetLength(length);
+  uint32_t numMsgsSelected = *length;
+
+  char **outArray, **next;
+  next = outArray = (char **)moz_xmalloc(numMsgsSelected * sizeof(char *));
+  if (!outArray) return NS_ERROR_OUT_OF_MEMORY;
+  for (uint32_t i = 0; i < numMsgsSelected; i++)
+  {
+    nsCString tmpUri;
+    nsCOMPtr<nsIMsgDBHdr> msgHdr = do_QueryElementAt(messages, i, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIMsgFolder> folder;
+    nsMsgKey msgKey;
+    msgHdr->GetMessageKey(&msgKey);
+    msgHdr->GetFolder(getter_AddRefs(folder));
+    rv = GenerateURIForMsgKey(msgKey, folder, tmpUri);
+    NS_ENSURE_SUCCESS(rv,rv);
+    *next = ToNewCString(tmpUri);
+    if (!*next)
+      return NS_ERROR_OUT_OF_MEMORY;
+
+    next++;
+  }
+
+  *uris = outArray;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetURIForViewIndex(nsMsgViewIndex index, nsACString &result)
+{
+  nsresult rv;
+  nsCOMPtr <nsIMsgFolder> folder = m_folder;
+  if (!folder)
+  {
+    rv = GetFolderForViewIndex(index, getter_AddRefs(folder));
+    NS_ENSURE_SUCCESS(rv,rv);
+  }
+  if (index == nsMsgViewIndex_None || index >= m_flags.Length() ||
+      m_flags[index] & MSG_VIEW_FLAG_DUMMY)
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  return GenerateURIForMsgKey(m_keys[index], folder, result);
+}
+
+NS_IMETHODIMP nsMsgDBView::DoCommandWithFolder(nsMsgViewCommandTypeValue command, nsIMsgFolder *destFolder)
+{
+  NS_ENSURE_ARG_POINTER(destFolder);
+
+  nsMsgViewIndexArray selection;
+
+  GetSelectedIndices(selection);
+
+  nsMsgViewIndex *indices = selection.Elements();
+  int32_t numIndices = selection.Length();
+
+  nsresult rv = NS_OK;
+  switch (command) {
+    case nsMsgViewCommandType::copyMessages:
+    case nsMsgViewCommandType::moveMessages:
+        NoteStartChange(nsMsgViewNotificationCode::none, 0, 0);
+        rv = ApplyCommandToIndicesWithFolder(command, indices, numIndices, destFolder);
+        NoteEndChange(nsMsgViewNotificationCode::none, 0, 0);
+        break;
+    default:
+        NS_ASSERTION(false, "invalid command type");
+        rv = NS_ERROR_UNEXPECTED;
+        break;
+  }
+  return rv;
+
+}
+
+NS_IMETHODIMP nsMsgDBView::DoCommand(nsMsgViewCommandTypeValue command)
+{
+  nsMsgViewIndexArray selection;
+
+  GetSelectedIndices(selection);
+
+  nsMsgViewIndex *indices = selection.Elements();
+  int32_t numIndices = selection.Length();
+  nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(mMsgWindowWeak));
+
+  nsresult rv = NS_OK;
+  switch (command)
+  {
+  case nsMsgViewCommandType::downloadSelectedForOffline:
+    return DownloadForOffline(msgWindow, indices, numIndices);
+  case nsMsgViewCommandType::downloadFlaggedForOffline:
+    return DownloadFlaggedForOffline(msgWindow);
+  case nsMsgViewCommandType::markMessagesRead:
+  case nsMsgViewCommandType::markMessagesUnread:
+  case nsMsgViewCommandType::toggleMessageRead:
+  case nsMsgViewCommandType::flagMessages:
+  case nsMsgViewCommandType::unflagMessages:
+  case nsMsgViewCommandType::deleteMsg:
+  case nsMsgViewCommandType::undeleteMsg:
+  case nsMsgViewCommandType::deleteNoTrash:
+  case nsMsgViewCommandType::markThreadRead:
+  case nsMsgViewCommandType::junk:
+  case nsMsgViewCommandType::unjunk:
+    NoteStartChange(nsMsgViewNotificationCode::none, 0, 0);
+    rv = ApplyCommandToIndices(command, indices, numIndices);
+    NoteEndChange(nsMsgViewNotificationCode::none, 0, 0);
+    break;
+  case nsMsgViewCommandType::selectAll:
+    if (mTreeSelection)
+    {
+      // if in threaded mode, we need to expand all before selecting
+      if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+          rv = ExpandAll();
+      mTreeSelection->SelectAll();
+      if (mTree)
+        mTree->Invalidate();
+    }
+    break;
+  case nsMsgViewCommandType::selectThread:
+    rv = ExpandAndSelectThread();
+    break;
+  case nsMsgViewCommandType::selectFlagged:
+    if (!mTreeSelection)
+      rv = NS_ERROR_UNEXPECTED;
+    else
+    {
+      mTreeSelection->SetSelectEventsSuppressed(true);
+      mTreeSelection->ClearSelection();
+      // XXX ExpandAll?
+      nsMsgViewIndex numIndices = GetSize();
+      for (nsMsgViewIndex curIndex = 0; curIndex < numIndices; curIndex++)
+      {
+        if (m_flags[curIndex] & nsMsgMessageFlags::Marked)
+          mTreeSelection->ToggleSelect(curIndex);
+      }
+      mTreeSelection->SetSelectEventsSuppressed(false);
+    }
+    break;
+  case nsMsgViewCommandType::markAllRead:
+    if (m_folder)
+    {
+      SetSuppressChangeNotifications(true);
+      rv = m_folder->MarkAllMessagesRead(msgWindow);
+      SetSuppressChangeNotifications(false);
+      if (mTree)
+        mTree->Invalidate();
+    }
+    break;
+  case nsMsgViewCommandType::toggleThreadWatched:
+    rv = ToggleWatched(indices,  numIndices);
+    break;
+  case nsMsgViewCommandType::expandAll:
+    rv = ExpandAll();
+    m_viewFlags |= nsMsgViewFlagsType::kExpandAll;
+    SetViewFlags(m_viewFlags);
+    if (mTree)
+      mTree->Invalidate();
+    break;
+  case nsMsgViewCommandType::collapseAll:
+    rv = CollapseAll();
+    m_viewFlags &= ~nsMsgViewFlagsType::kExpandAll;
+    SetViewFlags(m_viewFlags);
+    if(mTree)
+      mTree->Invalidate();
+    break;
+  default:
+    NS_ASSERTION(false, "invalid command type");
+    rv = NS_ERROR_UNEXPECTED;
+    break;
+  }
+  return rv;
+}
+
+bool nsMsgDBView::ServerSupportsFilterAfterTheFact()
+{
+  if (!m_folder)  // cross folder virtual folders might not have a folder set.
+    return false;
+
+  nsCOMPtr <nsIMsgIncomingServer> server;
+  nsresult rv = m_folder->GetServer(getter_AddRefs(server));
+  if (NS_FAILED(rv))
+    return false; // unexpected
+
+  // filter after the fact is implement using search
+  // so if you can't search, you can't filter after the fact
+  bool canSearch;
+  rv = server->GetCanSearchMessages(&canSearch);
+  if (NS_FAILED(rv))
+    return false; // unexpected
+
+  return canSearch;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetCommandStatus(nsMsgViewCommandTypeValue command, bool *selectable_p, nsMsgViewCommandCheckStateValue *selected_p)
+{
+  nsresult rv = NS_OK;
+
+  bool haveSelection;
+  int32_t rangeCount;
+  nsMsgViewIndexArray selection;
+  GetSelectedIndices(selection);
+  int32_t numIndices = selection.Length();
+  nsMsgViewIndex *indices = selection.Elements();
+  // if range count is non-zero, we have at least one item selected, so we have a selection
+  if (mTreeSelection && NS_SUCCEEDED(mTreeSelection->GetRangeCount(&rangeCount)) && rangeCount > 0)
+    haveSelection = NonDummyMsgSelected(indices, numIndices);
+  else
+  // If we don't have a tree selection we must be in stand alone mode.
+    haveSelection = IsValidIndex(m_currentlyDisplayedViewIndex);
+
+  switch (command)
+  {
+  case nsMsgViewCommandType::deleteMsg:
+  case nsMsgViewCommandType::deleteNoTrash:
+    {
+      bool canDelete;
+      if (m_folder && NS_SUCCEEDED(m_folder->GetCanDeleteMessages(&canDelete)) && !canDelete)
+        *selectable_p = false;
+      else
+        *selectable_p = haveSelection;
+    }
+    break;
+  case nsMsgViewCommandType::applyFilters:
+    // disable if no messages
+    // XXX todo, check that we have filters, and at least one is enabled
+    *selectable_p = GetSize();
+    if (*selectable_p)
+      *selectable_p = ServerSupportsFilterAfterTheFact();
+    break;
+  case nsMsgViewCommandType::runJunkControls:
+    // disable if no messages
+    // XXX todo, check that we have JMC enabled?
+    *selectable_p = GetSize() && JunkControlsEnabled(nsMsgViewIndex_None);
+    break;
+  case nsMsgViewCommandType::deleteJunk:
+    {
+      // disable if no messages, or if we can't delete (like news and certain imap folders)
+      bool canDelete;
+      *selectable_p = GetSize() && (m_folder && NS_SUCCEEDED(m_folder->GetCanDeleteMessages(&canDelete)) && canDelete);
+    }
+    break;
+  case nsMsgViewCommandType::markMessagesRead:
+  case nsMsgViewCommandType::markMessagesUnread:
+  case nsMsgViewCommandType::toggleMessageRead:
+  case nsMsgViewCommandType::flagMessages:
+  case nsMsgViewCommandType::unflagMessages:
+  case nsMsgViewCommandType::toggleThreadWatched:
+  case nsMsgViewCommandType::markThreadRead:
+  case nsMsgViewCommandType::downloadSelectedForOffline:
+    *selectable_p = haveSelection;
+    break;
+  case nsMsgViewCommandType::junk:
+  case nsMsgViewCommandType::unjunk:
+    *selectable_p = haveSelection && numIndices && JunkControlsEnabled(selection[0]);
+    break;
+  case nsMsgViewCommandType::cmdRequiringMsgBody:
+    *selectable_p = haveSelection && (!WeAreOffline() || OfflineMsgSelected(indices, numIndices));
+    break;
+  case nsMsgViewCommandType::downloadFlaggedForOffline:
+  case nsMsgViewCommandType::markAllRead:
+    *selectable_p = true;
+    break;
+  default:
+    NS_ASSERTION(false, "invalid command type");
+    rv = NS_ERROR_FAILURE;
+  }
+  return rv;
+}
+
+// This method needs to be overridden by the various view classes
+// that have different kinds of threads. For example, in a
+// threaded quick search db view, we'd only want to include children
+// of the thread that fit the view (IMO). And when we have threaded
+// cross folder views, we would include all the children of the
+// cross-folder thread.
+nsresult nsMsgDBView::ListCollapsedChildren(nsMsgViewIndex viewIndex,
+                                            nsIMutableArray *messageArray)
+{
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  nsCOMPtr<nsIMsgThread> thread;
+  GetMsgHdrForViewIndex(viewIndex, getter_AddRefs(msgHdr));
+  if (!msgHdr)
+  {
+    NS_ASSERTION(false, "couldn't find message to expand");
+    return NS_MSG_MESSAGE_NOT_FOUND;
+  }
+  nsresult rv = GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(thread));
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint32_t numChildren;
+  thread->GetNumChildren(&numChildren);
+  for (uint32_t i = 1; i < numChildren && NS_SUCCEEDED(rv); i++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    rv = thread->GetChildHdrAt(i, getter_AddRefs(msgHdr));
+    if (!msgHdr)
+      continue;
+    rv = messageArray->AppendElement(msgHdr, false);
+  }
+  return rv;
+}
+
+bool nsMsgDBView::OperateOnMsgsInCollapsedThreads()
+{
+  if (mTreeSelection)
+  {
+    nsCOMPtr<nsITreeBoxObject> selTree;
+    mTreeSelection->GetTree(getter_AddRefs(selTree));
+    // no tree means stand-alone message window
+    if (!selTree)
+      return false;
+  }
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIPrefBranch> prefBranch (do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  bool includeCollapsedMsgs = false;
+  prefBranch->GetBoolPref("mail.operate_on_msgs_in_collapsed_threads", &includeCollapsedMsgs);
+  return includeCollapsedMsgs;
+}
+
+nsresult nsMsgDBView::GetHeadersFromSelection(uint32_t *indices,
+                                              uint32_t numIndices,
+                                              nsIMutableArray *messageArray)
+{
+  nsresult rv = NS_OK;
+
+  // Don't include collapsed messages if the front end failed to summarize
+  // the selection.
+  bool includeCollapsedMsgs = OperateOnMsgsInCollapsedThreads() &&
+                                !mSummarizeFailed;
+
+  for (uint32_t index = 0;
+       index < (nsMsgViewIndex) numIndices && NS_SUCCEEDED(rv); index++)
+  {
+    nsMsgViewIndex viewIndex = indices[index];
+    if (viewIndex == nsMsgViewIndex_None)
+      continue;
+    uint32_t viewIndexFlags = m_flags[viewIndex];
+    if (viewIndexFlags & MSG_VIEW_FLAG_DUMMY)
+    {
+      // if collapsed dummy header selected, list its children
+      if (includeCollapsedMsgs && viewIndexFlags & nsMsgMessageFlags::Elided &&
+          m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+        rv = ListCollapsedChildren(viewIndex, messageArray);
+      continue;
+    }
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    rv = GetMsgHdrForViewIndex(viewIndex, getter_AddRefs(msgHdr));
+    if (NS_SUCCEEDED(rv) && msgHdr)
+    {
+      rv = messageArray->AppendElement(msgHdr, false);
+      if (NS_SUCCEEDED(rv) && includeCollapsedMsgs &&
+          viewIndexFlags & nsMsgMessageFlags::Elided &&
+          viewIndexFlags & MSG_VIEW_FLAG_HASCHILDREN &&
+          m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+      {
+        rv = ListCollapsedChildren(viewIndex, messageArray);
+      }
+    }
+  }
+  return rv;
+}
+
+nsresult
+nsMsgDBView::CopyMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool isMove, nsIMsgFolder *destFolder)
+{
+  if (m_deletingRows)
+  {
+    NS_ASSERTION(false, "Last move did not complete");
+    return NS_OK;
+  }
+
+  nsresult rv;
+  NS_ENSURE_ARG_POINTER(destFolder);
+  nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = GetHeadersFromSelection(indices, numIndices, messageArray);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  m_deletingRows = isMove && mDeleteModel != nsMsgImapDeleteModels::IMAPDelete;
+  if (m_deletingRows)
+    mIndicesToNoteChange.AppendElements(indices, numIndices);
+
+  nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return copyService->CopyMessages(m_folder /* source folder */, messageArray, destFolder, isMove, nullptr /* listener */, window, true /*allowUndo*/);
+}
+
+nsresult
+nsMsgDBView::ApplyCommandToIndicesWithFolder(nsMsgViewCommandTypeValue command, nsMsgViewIndex* indices,
+                    int32_t numIndices, nsIMsgFolder *destFolder)
+{
+  nsresult rv = NS_OK;
+  NS_ENSURE_ARG_POINTER(destFolder);
+
+  nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(mMsgWindowWeak));
+  switch (command) {
+    case nsMsgViewCommandType::copyMessages:
+        NS_ASSERTION(!(m_folder == destFolder), "The source folder and the destination folder are the same");
+        if (m_folder != destFolder)
+          rv = CopyMessages(msgWindow, indices, numIndices, false /* isMove */, destFolder);
+        break;
+    case nsMsgViewCommandType::moveMessages:
+        NS_ASSERTION(!(m_folder == destFolder), "The source folder and the destination folder are the same");
+        if (m_folder != destFolder)
+          rv = CopyMessages(msgWindow, indices, numIndices, true     /* isMove */, destFolder);
+        break;
+    default:
+        NS_ASSERTION(false, "unhandled command");
+        rv = NS_ERROR_UNEXPECTED;
+        break;
+    }
+    return rv;
+}
+
+nsresult
+nsMsgDBView::ApplyCommandToIndices(nsMsgViewCommandTypeValue command, nsMsgViewIndex* indices,
+          int32_t numIndices)
+{
+  NS_ASSERTION(numIndices >= 0, "nsMsgDBView::ApplyCommandToIndices(): "
+               "numIndices is negative!");
+
+  if (numIndices == 0)
+    return NS_OK; // return quietly, just in case
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = GetFolderForViewIndex(indices[0], getter_AddRefs(folder));
+  nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(mMsgWindowWeak));
+  if (command == nsMsgViewCommandType::deleteMsg)
+    return DeleteMessages(msgWindow, indices, numIndices, false);
+  if (command == nsMsgViewCommandType::deleteNoTrash)
+    return DeleteMessages(msgWindow, indices, numIndices, true);
+
+  nsTArray<nsMsgKey> imapUids;
+  nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(folder);
+  bool thisIsImapFolder = (imapFolder != nullptr);
+  nsCOMPtr<nsIJunkMailPlugin> junkPlugin;
+
+  // if this is a junk command, get the junk plugin.
+  if (command == nsMsgViewCommandType::junk ||
+      command == nsMsgViewCommandType::unjunk)
+  {
+    // get the folder from the first item; we assume that
+    // all messages in the view are from the same folder (no
+    // more junk status column in the 'search messages' dialog
+    // like in earlier versions...)
+
+     nsCOMPtr<nsIMsgIncomingServer> server;
+     rv = folder->GetServer(getter_AddRefs(server));
+     NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgFilterPlugin> filterPlugin;
+    rv = server->GetSpamFilterPlugin(getter_AddRefs(filterPlugin));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    junkPlugin = do_QueryInterface(filterPlugin, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!mJunkHdrs)
+    {
+      mJunkHdrs = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+      NS_ENSURE_SUCCESS(rv,rv);
+    }
+  }
+
+  folder->EnableNotifications(nsIMsgFolder::allMessageCountNotifications, false, true /*dbBatching*/);
+
+  // no sense going through the code that handles messages in collasped threads
+  // for mark thread read.
+  if (command == nsMsgViewCommandType::markThreadRead)
+  {
+    for (int32_t index = 0; index < numIndices; index++)
+      SetThreadOfMsgReadByIndex(indices[index], imapUids, true);
+  }
+  else
+  {
+    // Turn the selection into an array of msg hdrs. This may include messages
+    // in collapsed threads
+    uint32_t length;
+    nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = GetHeadersFromSelection(indices, numIndices, messages);
+    NS_ENSURE_SUCCESS(rv, rv);
+    messages->GetLength(&length);
+
+    if (thisIsImapFolder)
+      imapUids.SetLength(length);
+
+    for (uint32_t i = 0; i < length; i++)
+    {
+      nsMsgKey msgKey;
+      nsCOMPtr<nsIMsgDBHdr> msgHdr = do_QueryElementAt(messages, i);
+      msgHdr->GetMessageKey(&msgKey);
+      if (thisIsImapFolder)
+        imapUids[i] = msgKey;
+
+      switch (command)
+      {
+      case nsMsgViewCommandType::junk:
+        mNumMessagesRemainingInBatch++;
+        mJunkHdrs->AppendElement(msgHdr, false);
+        rv = SetMsgHdrJunkStatus(junkPlugin.get(), msgHdr,
+                                 nsIJunkMailPlugin::JUNK);
+        break;
+      case nsMsgViewCommandType::unjunk:
+        mNumMessagesRemainingInBatch++;
+        mJunkHdrs->AppendElement(msgHdr, false);
+        rv = SetMsgHdrJunkStatus(junkPlugin.get(), msgHdr,
+                                 nsIJunkMailPlugin::GOOD);
+        break;
+      case nsMsgViewCommandType::toggleMessageRead:
+      case nsMsgViewCommandType::undeleteMsg:
+      case nsMsgViewCommandType::markMessagesRead:
+      case nsMsgViewCommandType::markMessagesUnread:
+      case nsMsgViewCommandType::unflagMessages:
+      case nsMsgViewCommandType::flagMessages:
+        break; // this is completely handled in the code below.
+      default:
+        NS_ERROR("unhandled command");
+        break;
+      }
+    }
+
+    switch (command)
+    {
+      case nsMsgViewCommandType::toggleMessageRead:
+      {
+        nsCOMPtr<nsIMsgDBHdr> msgHdr = do_QueryElementAt(messages, 0);
+        if (!msgHdr)
+          break;
+        uint32_t msgFlags;
+        msgHdr->GetFlags(&msgFlags);
+        folder->MarkMessagesRead(messages,
+                                 !(msgFlags & nsMsgMessageFlags::Read));
+      }
+        break;
+      case nsMsgViewCommandType::markMessagesRead:
+      case nsMsgViewCommandType::markMessagesUnread:
+        folder->MarkMessagesRead(messages,
+                                 command == nsMsgViewCommandType::markMessagesRead);
+        break;
+      case nsMsgViewCommandType::unflagMessages:
+      case nsMsgViewCommandType::flagMessages:
+        folder->MarkMessagesFlagged(messages,
+                                    command == nsMsgViewCommandType::flagMessages);
+        break;
+      default:
+        break;
+
+    }
+    // Provide junk-related batch notifications
+    if ((command == nsMsgViewCommandType::junk) ||
+        (command == nsMsgViewCommandType::unjunk)) {
+      nsCOMPtr<nsIMsgFolderNotificationService>
+        notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+      if (notifier)
+        notifier->NotifyItemEvent(messages,
+                                  NS_LITERAL_CSTRING("JunkStatusChanged"),
+                                  (command == nsMsgViewCommandType::junk) ?
+                                    kJunkMsgAtom : kNotJunkMsgAtom);
+    }
+  }
+
+  folder->EnableNotifications(nsIMsgFolder::allMessageCountNotifications, true, true /*dbBatching*/);
+
+  if (thisIsImapFolder)
+  {
+    imapMessageFlagsType flags = kNoImapMsgFlag;
+    bool addFlags = false;
+    nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(mMsgWindowWeak));
+    switch (command)
+    {
+    case nsMsgViewCommandType::markThreadRead:
+      flags |= kImapMsgSeenFlag;
+      addFlags = true;
+      break;
+    case nsMsgViewCommandType::undeleteMsg:
+      flags = kImapMsgDeletedFlag;
+      addFlags = false;
+      break;
+    case nsMsgViewCommandType::junk:
+        return imapFolder->StoreCustomKeywords(msgWindow,
+                    NS_LITERAL_CSTRING("Junk"),
+                    NS_LITERAL_CSTRING("NonJunk"),
+                    imapUids.Elements(), imapUids.Length(),
+                    nullptr);
+    case nsMsgViewCommandType::unjunk:
+      {
+        nsCOMPtr<nsIMsgDBHdr> msgHdr;
+        GetHdrForFirstSelectedMessage(getter_AddRefs(msgHdr));
+        uint32_t msgFlags = 0;
+        if (msgHdr)
+          msgHdr->GetFlags(&msgFlags);
+        if (msgFlags & nsMsgMessageFlags::IMAPDeleted)
+          imapFolder->StoreImapFlags(kImapMsgDeletedFlag, false,
+                                     imapUids.Elements(),
+                                     imapUids.Length(), nullptr);
+        return imapFolder->StoreCustomKeywords(msgWindow,
+                    NS_LITERAL_CSTRING("NonJunk"),
+                    NS_LITERAL_CSTRING("Junk"),
+                    imapUids.Elements(), imapUids.Length(),
+                    nullptr);
+      }
+
+    default:
+      break;
+    }
+
+    if (flags != kNoImapMsgFlag)  // can't get here without thisIsImapThreadPane == TRUE
+      imapFolder->StoreImapFlags(flags, addFlags, imapUids.Elements(), imapUids.Length(), nullptr);
+
+  }
+
+  return rv;
+}
+
+// view modifications methods by index
+
+// This method just removes the specified line from the view. It does
+// NOT delete it from the database.
+nsresult nsMsgDBView::RemoveByIndex(nsMsgViewIndex index)
+{
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  m_keys.RemoveElementAt(index);
+  m_flags.RemoveElementAt(index);
+  m_levels.RemoveElementAt(index);
+
+  // the call to NoteChange() has to happen after we remove the key
+  // as NoteChange() will call RowCountChanged() which will call our GetRowCount()
+  if (!m_deletingRows)
+    NoteChange(index, -1, nsMsgViewNotificationCode::insertOrDelete); // an example where view is not the listener - D&D messages
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::DeleteMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool deleteStorage)
+{
+  if (m_deletingRows)
+  {
+    NS_WARNING("Last delete did not complete");
+    return NS_OK;
+  }
+  nsresult rv;
+  nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = GetHeadersFromSelection(indices, numIndices, messageArray);
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint32_t numMsgs;
+  messageArray->GetLength(&numMsgs);
+
+  const char *warnCollapsedPref = "mail.warn_on_collapsed_thread_operation";
+  const char *warnShiftDelPref = "mail.warn_on_shift_delete";
+  const char *warnNewsPref = "news.warn_on_delete";
+  const char *warnTrashDelPref = "mail.warn_on_delete_from_trash";
+  const char *activePref = nullptr;
+  nsString warningName;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool trashFolder = false;
+  rv = m_folder->GetFlag(nsMsgFolderFlags::Trash, &trashFolder);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (trashFolder)
+  {
+    bool pref = false;
+    prefBranch->GetBoolPref(warnTrashDelPref, &pref);
+    if (pref)
+    {
+      activePref = warnTrashDelPref;
+      warningName.AssignLiteral("confirmMsgDelete.deleteFromTrash.desc");
+    }
+  }
+
+  if (!activePref && (uint32_t(numIndices) != numMsgs))
+  {
+    bool pref = false;
+    prefBranch->GetBoolPref(warnCollapsedPref, &pref);
+    if (pref)
+    {
+      activePref = warnCollapsedPref;
+      warningName.AssignLiteral("confirmMsgDelete.collapsed.desc");
+    }
+  }
+
+  if (!activePref && deleteStorage && !trashFolder)
+  {
+    bool pref = false;
+    prefBranch->GetBoolPref(warnShiftDelPref, &pref);
+    if (pref)
+    {
+      activePref = warnShiftDelPref;
+      warningName.AssignLiteral("confirmMsgDelete.deleteNoTrash.desc");
+    }
+  }
+
+  if (!activePref && mIsNews)
+  {
+    bool pref = false;
+    prefBranch->GetBoolPref(warnNewsPref, &pref);
+    if (pref)
+    {
+      activePref = warnNewsPref;
+      warningName.AssignLiteral("confirmMsgDelete.deleteNoTrash.desc");
+    }
+  }
+
+  if (activePref)
+  {
+    nsCOMPtr<nsIPrompt> dialog;
+
+    nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = wwatch->GetNewPrompter(0, getter_AddRefs(dialog));
+    NS_ENSURE_SUCCESS(rv, rv);
+    bool dontAsk = false; // "Don't ask..." - unchecked by default.
+    int32_t buttonPressed = 0;
+
+    nsString dialogTitle;
+    nsString confirmString;
+    nsString checkboxText;
+    nsString buttonApplyNowText;
+    dialogTitle.Adopt(GetString(u"confirmMsgDelete.title"));
+    checkboxText.Adopt(GetString(u"confirmMsgDelete.dontAsk.label"));
+    buttonApplyNowText.Adopt(GetString(u"confirmMsgDelete.delete.label"));
+
+    confirmString.Adopt(GetString(warningName.get()));
+
+    const uint32_t buttonFlags =
+      (nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_0) +
+      (nsIPrompt::BUTTON_TITLE_CANCEL * nsIPrompt::BUTTON_POS_1);
+    rv = dialog->ConfirmEx(dialogTitle.get(), confirmString.get(), buttonFlags,
+                           buttonApplyNowText.get(), nullptr, nullptr,
+                           checkboxText.get(), &dontAsk, &buttonPressed);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (buttonPressed)
+      return NS_ERROR_FAILURE;
+    if (dontAsk)
+      prefBranch->SetBoolPref(activePref, false);
+  }
+
+  if (mDeleteModel != nsMsgImapDeleteModels::IMAPDelete)
+    m_deletingRows = true;
+
+  if (m_deletingRows)
+    mIndicesToNoteChange.AppendElements(indices, numIndices);
+
+  rv = m_folder->DeleteMessages(messageArray, window, deleteStorage, false, nullptr, true /*allow Undo*/ );
+  if (NS_FAILED(rv))
+    m_deletingRows = false;
+  return rv;
+}
+
+nsresult nsMsgDBView::DownloadForOffline(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID));
+  for (nsMsgViewIndex index = 0; index < (nsMsgViewIndex) numIndices; index++)
+  {
+    nsMsgKey key = m_keys[indices[index]];
+    nsCOMPtr <nsIMsgDBHdr> msgHdr;
+    rv = m_db->GetMsgHdrForKey(key, getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS(rv,rv);
+    if (msgHdr)
+    {
+      uint32_t flags;
+      msgHdr->GetFlags(&flags);
+      if (!(flags & nsMsgMessageFlags::Offline))
+        messageArray->AppendElement(msgHdr, false);
+    }
+  }
+  m_folder->DownloadMessagesForOffline(messageArray, window);
+  return rv;
+}
+
+nsresult nsMsgDBView::DownloadFlaggedForOffline(nsIMsgWindow *window)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID));
+  nsCOMPtr <nsISimpleEnumerator> enumerator;
+  rv = GetMessageEnumerator(getter_AddRefs(enumerator));
+  if (NS_SUCCEEDED(rv) && enumerator)
+  {
+    bool hasMore;
+
+    while (NS_SUCCEEDED(rv = enumerator->HasMoreElements(&hasMore)) && hasMore)
+    {
+      nsCOMPtr <nsISupports> supports;
+      rv = enumerator->GetNext(getter_AddRefs(supports));
+      NS_ASSERTION(NS_SUCCEEDED(rv), "nsMsgDBEnumerator broken");
+      nsCOMPtr <nsIMsgDBHdr> pHeader = do_QueryInterface(supports);
+      if (pHeader && NS_SUCCEEDED(rv))
+      {
+        uint32_t flags;
+        pHeader->GetFlags(&flags);
+        if ((flags & nsMsgMessageFlags::Marked) && !(flags & nsMsgMessageFlags::Offline))
+          messageArray->AppendElement(pHeader, false);
+      }
+    }
+  }
+  m_folder->DownloadMessagesForOffline(messageArray, window);
+  return rv;
+}
+
+// read/unread handling.
+nsresult nsMsgDBView::ToggleReadByIndex(nsMsgViewIndex index)
+{
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  return SetReadByIndex(index, !(m_flags[index] & nsMsgMessageFlags::Read));
+}
+
+nsresult nsMsgDBView::SetReadByIndex(nsMsgViewIndex index, bool read)
+{
+  nsresult rv;
+
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  if (read)
+  {
+    OrExtraFlag(index, nsMsgMessageFlags::Read);
+    // MarkRead() will clear this flag in the db
+    // and then call OnKeyChange(), but
+    // because we are the instigator of the change
+    // we'll ignore the change.
+    //
+    // so we need to clear it in m_flags
+    // to keep the db and m_flags in sync
+    AndExtraFlag(index, ~nsMsgMessageFlags::New);
+  }
+  else
+  {
+    AndExtraFlag(index, ~nsMsgMessageFlags::Read);
+  }
+
+  nsCOMPtr <nsIMsgDatabase> dbToUse;
+  rv = GetDBForViewIndex(index, getter_AddRefs(dbToUse));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = dbToUse->MarkRead(m_keys[index], read, this);
+  NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    nsMsgViewIndex threadIndex = GetThreadIndex(index);
+    if (threadIndex != index)
+      NoteChange(threadIndex, 1, nsMsgViewNotificationCode::changed);
+  }
+  return rv;
+}
+
+nsresult nsMsgDBView::SetThreadOfMsgReadByIndex(nsMsgViewIndex index, nsTArray<nsMsgKey> &keysMarkedRead, bool /*read*/)
+{
+  nsresult rv;
+
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  rv = MarkThreadOfMsgRead(m_keys[index], index, keysMarkedRead, true);
+  return rv;
+}
+
+nsresult nsMsgDBView::SetFlaggedByIndex(nsMsgViewIndex index, bool mark)
+{
+  nsresult rv;
+
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  nsCOMPtr <nsIMsgDatabase> dbToUse;
+  rv = GetDBForViewIndex(index, getter_AddRefs(dbToUse));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (mark)
+    OrExtraFlag(index, nsMsgMessageFlags::Marked);
+  else
+    AndExtraFlag(index, ~nsMsgMessageFlags::Marked);
+
+  rv = dbToUse->MarkMarked(m_keys[index], mark, this);
+  NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+  return rv;
+}
+
+nsresult nsMsgDBView::SetMsgHdrJunkStatus(nsIJunkMailPlugin *aJunkPlugin,
+                                          nsIMsgDBHdr *aMsgHdr,
+                                          nsMsgJunkStatus aNewClassification)
+{
+    // get the old junk score
+    //
+    nsCString junkScoreStr;
+    nsresult rv = aMsgHdr->GetStringProperty("junkscore", getter_Copies(junkScoreStr));
+
+    // and the old origin
+    //
+    nsCString oldOriginStr;
+    rv = aMsgHdr->GetStringProperty("junkscoreorigin",
+                                   getter_Copies(oldOriginStr));
+
+    // if this was not classified by the user, say so
+    //
+    nsMsgJunkStatus oldUserClassification;
+    if (oldOriginStr.get()[0] != 'u') {
+        oldUserClassification = nsIJunkMailPlugin::UNCLASSIFIED;
+    }
+    else {
+        // otherwise, pass the actual user classification
+        if (junkScoreStr.IsEmpty())
+          oldUserClassification = nsIJunkMailPlugin::UNCLASSIFIED;
+        else if (junkScoreStr.ToInteger(&rv) == nsIJunkMailPlugin::IS_SPAM_SCORE)
+          oldUserClassification = nsIJunkMailPlugin::JUNK;
+        else
+          oldUserClassification = nsIJunkMailPlugin::GOOD;
+
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Converting junkScore to integer failed.");
+    }
+
+    // get the URI for this message so we can pass it to the plugin
+    //
+    nsCString uri;
+    nsMsgKey msgKey;
+    nsCOMPtr<nsIMsgFolder> folder;
+    nsCOMPtr<nsIMsgDatabase> db;
+    aMsgHdr->GetMessageKey(&msgKey);
+    rv = aMsgHdr->GetFolder(getter_AddRefs(folder));
+    NS_ENSURE_SUCCESS(rv, rv);
+    GenerateURIForMsgKey(msgKey, folder, uri);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = folder->GetMsgDatabase(getter_AddRefs(db));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // tell the plugin about this change, so that it can (potentially)
+    // adjust its database appropriately
+    nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(mMsgWindowWeak));
+    rv = aJunkPlugin->SetMessageClassification(
+        uri.get(), oldUserClassification, aNewClassification, msgWindow, this);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // this routine is only reached if the user someone touched the UI
+    // and told us the junk status of this message.
+    // Set origin first so that listeners on the junkscore will
+    // know the correct origin.
+    rv = db->SetStringProperty(msgKey, "junkscoreorigin", "user");
+    NS_ASSERTION(NS_SUCCEEDED(rv), "SetStringPropertyByIndex failed");
+
+    // set the junk score on the message itself
+
+    nsAutoCString msgJunkScore;
+    msgJunkScore.AppendInt(aNewClassification == nsIJunkMailPlugin::JUNK ?
+          nsIJunkMailPlugin::IS_SPAM_SCORE:
+          nsIJunkMailPlugin::IS_HAM_SCORE);
+    db->SetStringProperty(msgKey, "junkscore", msgJunkScore.get());
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return rv;
+}
+
+nsresult
+nsMsgDBView::GetFolderFromMsgURI(const char *aMsgURI, nsIMsgFolder **aFolder)
+{
+  NS_IF_ADDREF(*aFolder = m_folder);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::OnMessageClassified(const char *aMsgURI,
+                                 nsMsgJunkStatus aClassification,
+                                 uint32_t aJunkPercent)
+
+{
+  // Note: we know all messages in a batch have the same
+  // classification, since unlike OnMessageClassified
+  // methods in other classes (such as nsLocalMailFolder
+  // and nsImapMailFolder), this class, nsMsgDBView, currently
+  // only triggers message classifications due to a command to
+  // mark some of the messages in the view as junk, or as not
+  // junk - so the classification is dictated to the filter,
+  // not suggested by it.
+  //
+  // for this reason the only thing we (may) have to do is
+  // perform the action on all of the junk messages
+  //
+
+  uint32_t numJunk;
+  mJunkHdrs->GetLength(&numJunk);
+  NS_ASSERTION((aClassification == nsIJunkMailPlugin::GOOD) ||
+                numJunk,
+                "the classification of a manually-marked junk message has"
+                "been classified as junk, yet there seem to be no such outstanding messages");
+
+  // is this the last message in the batch?
+
+  if (--mNumMessagesRemainingInBatch == 0 && numJunk > 0)
+  {
+    PerformActionsOnJunkMsgs(aClassification == nsIJunkMailPlugin::JUNK);
+    mJunkHdrs->Clear();
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgDBView::PerformActionsOnJunkMsgs(bool msgsAreJunk)
+{
+  uint32_t numJunkHdrs;
+  mJunkHdrs->GetLength(&numJunkHdrs);
+  if (!numJunkHdrs)
+  {
+    NS_ERROR("no indices of marked-as-junk messages to act on");
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIMsgFolder> srcFolder;
+  nsCOMPtr<nsIMsgDBHdr> firstHdr(do_QueryElementAt(mJunkHdrs, 0));
+  firstHdr->GetFolder(getter_AddRefs(srcFolder));
+
+  bool moveMessages, changeReadState;
+  nsCOMPtr<nsIMsgFolder> targetFolder;
+
+  nsresult rv = DetermineActionsForJunkChange(msgsAreJunk, srcFolder,
+                                              moveMessages, changeReadState,
+                                              getter_AddRefs(targetFolder));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // nothing to do, bail out
+  if (!(moveMessages || changeReadState))
+    return NS_OK;
+  if (changeReadState)
+  {
+    // notes on marking junk as read:
+    // 1. there are 2 occasions on which junk messages are marked as
+    //    read: after a manual marking (here and in the front end) and after
+    //    automatic classification by the bayesian filter (see code for local
+    //    mail folders and for imap mail folders). The server-specific
+    //    markAsReadOnSpam pref only applies to the latter, the former is
+    //    controlled by "mailnews.ui.junk.manualMarkAsJunkMarksRead".
+    // 2. even though move/delete on manual mark may be
+    //    turned off, we might still need to mark as read
+
+    NoteStartChange(nsMsgViewNotificationCode::none, 0, 0);
+    rv = srcFolder->MarkMessagesRead(mJunkHdrs, msgsAreJunk);
+    NoteEndChange(nsMsgViewNotificationCode::none, 0, 0);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "marking marked-as-junk messages as read failed");
+  }
+  if (moveMessages)
+  {
+    // check if one of the messages to be junked is actually selected
+    // if more than one message being junked, one must be selected.
+    // if no tree selection at all, must be in stand-alone message window.
+    bool junkedMsgSelected = numJunkHdrs > 1 || !mTreeSelection;
+    for (nsMsgViewIndex junkIndex = 0; !junkedMsgSelected && junkIndex < numJunkHdrs; junkIndex++)
+    {
+      nsCOMPtr<nsIMsgDBHdr> junkHdr(do_QueryElementAt(mJunkHdrs, junkIndex, &rv));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsMsgViewIndex hdrIndex = FindHdr(junkHdr);
+      if (hdrIndex != nsMsgViewIndex_None)
+        mTreeSelection->IsSelected(hdrIndex, &junkedMsgSelected);
+    }
+
+    // if a junked msg is selected, tell the FE to call SetNextMessageAfterDelete() because a delete is coming
+    if (junkedMsgSelected && mCommandUpdater)
+    {
+      rv = mCommandUpdater->UpdateNextMessageAfterDelete();
+      NS_ENSURE_SUCCESS(rv,rv);
+    }
+
+    nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(mMsgWindowWeak));
+    NoteStartChange(nsMsgViewNotificationCode::none, 0, 0);
+    if (targetFolder)
+    {
+      nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = copyService->CopyMessages(srcFolder , mJunkHdrs, targetFolder,
+                                     true, nullptr, msgWindow, true);
+    }
+    else if (msgsAreJunk)
+    {
+      if (mDeleteModel == nsMsgImapDeleteModels::IMAPDelete)
+      {
+        // Unfortunately the DeleteMessages in this case is interpreted by IMAP as
+        //  a delete toggle. So what we have to do is to assemble a new delete
+        //  array, keeping only those that are not deleted.
+        //
+        nsCOMPtr<nsIMutableArray> hdrsToDelete = do_CreateInstance("@mozilla.org/array;1", &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        uint32_t cnt;
+        rv = mJunkHdrs->GetLength(&cnt);
+        for (uint32_t i = 0; i < cnt; i++)
+        {
+          nsCOMPtr<nsIMsgDBHdr> msgHdr = do_QueryElementAt(mJunkHdrs, i);
+          if (msgHdr)
+          {
+            uint32_t flags;
+            msgHdr->GetFlags(&flags);
+            if (!(flags & nsMsgMessageFlags::IMAPDeleted))
+              hdrsToDelete->AppendElement(msgHdr, false);
+          }
+        }
+        hdrsToDelete->GetLength(&cnt);
+        if (cnt)
+          rv = srcFolder->DeleteMessages(hdrsToDelete, msgWindow, false, false,
+                                         nullptr, true);
+      }
+      else
+        rv = srcFolder->DeleteMessages(mJunkHdrs, msgWindow, false, false,
+                                       nullptr, true);
+
+    }
+    else if (mDeleteModel == nsMsgImapDeleteModels::IMAPDelete)
+    {
+      nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(srcFolder));
+      nsTArray<nsMsgKey> imapUids;
+      imapUids.SetLength(numJunkHdrs);
+      for (uint32_t i = 0; i < numJunkHdrs; i++)
+      {
+        nsCOMPtr<nsIMsgDBHdr> msgHdr = do_QueryElementAt(mJunkHdrs, i);
+        msgHdr->GetMessageKey(&imapUids[i]);
+      }
+
+      imapFolder->StoreImapFlags(kImapMsgDeletedFlag, false, imapUids.Elements(),
+                                 imapUids.Length(), nullptr);
+    }
+    NoteEndChange(nsMsgViewNotificationCode::none, 0, 0);
+
+    NS_ASSERTION(NS_SUCCEEDED(rv), "move or deletion of message marked-as-junk/non junk failed");
+  }
+  return rv;
+}
+
+nsresult
+nsMsgDBView::DetermineActionsForJunkChange(bool msgsAreJunk,
+                                           nsIMsgFolder *srcFolder,
+                                           bool &moveMessages,
+                                           bool &changeReadState,
+                                           nsIMsgFolder** targetFolder)
+{
+  // there are two possible actions which may be performed
+  // on messages marked as spam: marking as read and moving
+  // somewhere...When a message is marked as non junk,
+  // it may be moved to the inbox, and marked unread.
+
+  moveMessages = false;
+  changeReadState = false;
+
+  // ... the 'somewhere', junkTargetFolder, can be a folder,
+  // but if it remains null we'll delete the messages
+
+  *targetFolder = nullptr;
+
+  uint32_t folderFlags;
+  srcFolder->GetFlags(&folderFlags);
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = srcFolder->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // handle the easy case of marking a junk message as good first...
+  // set the move target folder to the inbox, if any.
+  if (!msgsAreJunk)
+  {
+    if (folderFlags & nsMsgFolderFlags::Junk)
+    {
+      prefBranch->GetBoolPref("mail.spam.markAsNotJunkMarksUnRead",
+                              &changeReadState);
+      nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+      rv = server->GetRootMsgFolder(getter_AddRefs(rootMsgFolder));
+      NS_ENSURE_SUCCESS(rv,rv);
+      rootMsgFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox, targetFolder);
+      moveMessages = targetFolder != nullptr;
+    }
+    return NS_OK;
+  }
+
+  nsCOMPtr <nsISpamSettings> spamSettings;
+  rv = server->GetSpamSettings(getter_AddRefs(spamSettings));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // When the user explicitly marks a message as junk, we can mark it as read,
+  // too. This is independent of the "markAsReadOnSpam" pref, which applies
+  // only to automatically-classified messages.
+  // Note that this behaviour should match the one in the front end for marking
+  // as junk via toolbar/context menu.
+  prefBranch->GetBoolPref("mailnews.ui.junk.manualMarkAsJunkMarksRead",
+                          &changeReadState);
+
+  // now let's determine whether we'll be taking the second action,
+  // the move / deletion (and also determine which of these two)
+
+  bool manualMark;
+  (void)spamSettings->GetManualMark(&manualMark);
+  if (!manualMark)
+    return NS_OK;
+
+  int32_t manualMarkMode;
+  (void)spamSettings->GetManualMarkMode(&manualMarkMode);
+  NS_ASSERTION(manualMarkMode == nsISpamSettings::MANUAL_MARK_MODE_MOVE
+            || manualMarkMode == nsISpamSettings::MANUAL_MARK_MODE_DELETE,
+            "bad manual mark mode");
+
+  if (manualMarkMode == nsISpamSettings::MANUAL_MARK_MODE_MOVE)
+  {
+    // if this is a junk folder
+    // (not only "the" junk folder for this account)
+    // don't do the move
+    if (folderFlags & nsMsgFolderFlags::Junk)
+      return NS_OK;
+
+    nsCString spamFolderURI;
+    rv = spamSettings->GetSpamFolderURI(getter_Copies(spamFolderURI));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NS_ASSERTION(!spamFolderURI.IsEmpty(), "spam folder URI is empty, can't move");
+    if (!spamFolderURI.IsEmpty())
+    {
+      rv = GetExistingFolder(spamFolderURI, targetFolder);
+      if (NS_SUCCEEDED(rv) && *targetFolder)
+      {
+        moveMessages = true;
+      }
+      else
+      {
+        // XXX ToDo: GetOrCreateFolder will only create a folder with localized
+        //           name "Junk" regardless of spamFolderURI. So if someone
+        //           sets the junk folder to an existing folder of a different
+        //           name, then deletes that folder, this will fail to create
+        //           the correct folder.
+        rv = GetOrCreateFolder(spamFolderURI, nullptr /* aListener */);
+        if (NS_SUCCEEDED(rv))
+          rv = GetExistingFolder(spamFolderURI, targetFolder);
+        NS_ASSERTION(NS_SUCCEEDED(rv) && *targetFolder, "GetOrCreateFolder failed");
+      }
+    }
+    return NS_OK;
+  }
+
+  // at this point manualMarkMode == nsISpamSettings::MANUAL_MARK_MODE_DELETE)
+
+  // if this is in the trash, let's not delete
+  if (folderFlags & nsMsgFolderFlags::Trash)
+    return NS_OK;
+
+  return srcFolder->GetCanDeleteMessages(&moveMessages);
+}
+
+// reversing threads involves reversing the threads but leaving the
+// expanded messages ordered relative to the thread, so we
+// make a copy of each array and copy them over.
+void nsMsgDBView::ReverseThreads()
+{
+    nsTArray<uint32_t> newFlagArray;
+    nsTArray<nsMsgKey> newKeyArray;
+    nsTArray<uint8_t> newLevelArray;
+
+    uint32_t viewSize = GetSize();
+    uint32_t startThread = viewSize;
+    uint32_t nextThread = viewSize;
+    uint32_t destIndex = 0;
+
+    newKeyArray.SetLength(m_keys.Length());
+    newFlagArray.SetLength(m_flags.Length());
+    newLevelArray.SetLength(m_levels.Length());
+
+    while (startThread)
+    {
+        startThread--;
+
+        if (m_flags[startThread] & MSG_VIEW_FLAG_ISTHREAD)
+        {
+            for (uint32_t sourceIndex = startThread; sourceIndex < nextThread; sourceIndex++)
+            {
+                newKeyArray[destIndex] = m_keys[sourceIndex];
+                newFlagArray[destIndex] = m_flags[sourceIndex];
+                newLevelArray[destIndex] = m_levels[sourceIndex];
+                destIndex++;
+            }
+            nextThread = startThread; // because we're copying in reverse order
+        }
+    }
+    m_keys.SwapElements(newKeyArray);
+    m_flags.SwapElements(newFlagArray);
+    m_levels.SwapElements(newLevelArray);
+}
+
+void nsMsgDBView::ReverseSort()
+{
+    uint32_t topIndex = GetSize();
+
+    nsCOMArray<nsIMsgFolder> *folders = GetFolders();
+
+    // go up half the array swapping values
+    for (uint32_t bottomIndex = 0; bottomIndex < --topIndex; bottomIndex++)
+    {
+        // swap flags
+        uint32_t tempFlags = m_flags[bottomIndex];
+        m_flags[bottomIndex] = m_flags[topIndex];
+        m_flags[topIndex] = tempFlags;
+
+        // swap keys
+        nsMsgKey tempKey = m_keys[bottomIndex];
+        m_keys[bottomIndex] = m_keys[topIndex];
+        m_keys[topIndex] = tempKey;
+
+        if (folders)
+        {
+            // swap folders --
+            // needed when search is done across multiple folders
+            nsIMsgFolder *bottomFolder = folders->ObjectAt(bottomIndex);
+            nsIMsgFolder *topFolder = folders->ObjectAt(topIndex);
+            folders->ReplaceObjectAt(topFolder, bottomIndex);
+            folders->ReplaceObjectAt(bottomFolder, topIndex);
+        }
+        // no need to swap elements in m_levels; since we only call
+        // ReverseSort in non-threaded mode, m_levels are all the same.
+    }
+}
+int
+nsMsgDBView::FnSortIdKey(const void *pItem1, const void *pItem2, void *privateData)
+{
+    int32_t retVal = 0;
+
+    IdKey** p1 = (IdKey**)pItem1;
+    IdKey** p2 = (IdKey**)pItem2;
+    viewSortInfo* sortInfo = (viewSortInfo *) privateData;
+
+    nsIMsgDatabase *db = sortInfo->db;
+
+    mozilla::DebugOnly<nsresult> rv = db->CompareCollationKeys((*p1)->dword, (*p1)->key,
+                                                               (*p2)->dword, (*p2)->key,
+                                                               &retVal);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "compare failed");
+
+    if (retVal)
+      return sortInfo->ascendingSort ? retVal : -retVal;
+    if (sortInfo->view->m_secondarySort == nsMsgViewSortType::byId)
+      return (sortInfo->view->m_secondarySortOrder == nsMsgViewSortOrder::ascending &&
+              (*p1)->id >= (*p2)->id) ? 1 : -1;
+    else
+      return sortInfo->view->SecondarySort((*p1)->id, (*p1)->folder, (*p2)->id, (*p2)->folder, sortInfo);
+    // here we'd use the secondary sort
+}
+
+int
+nsMsgDBView::FnSortIdKeyPtr(const void *pItem1, const void *pItem2, void *privateData)
+{
+  int32_t retVal = 0;
+
+  IdKeyPtr** p1 = (IdKeyPtr**)pItem1;
+  IdKeyPtr** p2 = (IdKeyPtr**)pItem2;
+  viewSortInfo* sortInfo = (viewSortInfo *) privateData;
+
+  nsIMsgDatabase *db = sortInfo->db;
+
+  mozilla::DebugOnly<nsresult> rv = db->CompareCollationKeys((*p1)->dword, (*p1)->key,
+                                                             (*p2)->dword, (*p2)->key,
+                                                             &retVal);
+  NS_ASSERTION(NS_SUCCEEDED(rv), "compare failed");
+
+  if (retVal)
+    return sortInfo->ascendingSort ? retVal : -retVal;
+
+  if (sortInfo->view->m_secondarySort == nsMsgViewSortType::byId)
+    return (sortInfo->view->m_secondarySortOrder == nsMsgViewSortOrder::ascending &&
+            (*p1)->id >= (*p2)->id) ? 1 : -1;
+  else
+    return sortInfo->view->SecondarySort((*p1)->id, (*p1)->folder, (*p2)->id, (*p2)->folder, sortInfo);
+}
+
+int
+nsMsgDBView::FnSortIdUint32(const void *pItem1, const void *pItem2, void *privateData)
+{
+  IdUint32** p1 = (IdUint32**)pItem1;
+  IdUint32** p2 = (IdUint32**)pItem2;
+  viewSortInfo* sortInfo = (viewSortInfo *) privateData;
+
+  if ((*p1)->dword > (*p2)->dword)
+    return (sortInfo->ascendingSort) ? 1 : -1;
+  else if ((*p1)->dword < (*p2)->dword)
+      return (sortInfo->ascendingSort) ? -1 : 1;
+  if (sortInfo->view->m_secondarySort == nsMsgViewSortType::byId)
+    return (sortInfo->view->m_secondarySortOrder == nsMsgViewSortOrder::ascending &&
+            (*p1)->id >= (*p2)->id) ? 1 : -1;
+  else
+    return sortInfo->view->SecondarySort((*p1)->id, (*p1)->folder, (*p2)->id, (*p2)->folder, sortInfo);
+}
+
+
+// XXX are these still correct?
+//To compensate for memory alignment required for
+//systems such as HP-UX these values must be 4 bytes
+//aligned.  Don't break this when modify the constants
+const int kMaxSubjectKey = 160;
+const int kMaxLocationKey = 160;  // also used for account
+const int kMaxAuthorKey = 160;
+const int kMaxRecipientKey = 80;
+
+//
+// There are cases when pFieldType is not set:
+// one case returns NS_ERROR_UNEXPECTED;
+// the other case now return NS_ERROR_NULL_POINTER (this is only when
+// colHandler below is null, but is very unlikely).
+// The latter case used to return NS_OK, which was incorrect.
+//
+nsresult nsMsgDBView::GetFieldTypeAndLenForSort(nsMsgViewSortTypeValue sortType,
+                                                uint16_t *pMaxLen,
+                                                eFieldType *pFieldType,
+                                                nsIMsgCustomColumnHandler* colHandler)
+{
+    NS_ENSURE_ARG_POINTER(pMaxLen);
+    NS_ENSURE_ARG_POINTER(pFieldType);
+
+    switch (sortType)
+    {
+        case nsMsgViewSortType::bySubject:
+            *pFieldType = kCollationKey;
+            *pMaxLen = kMaxSubjectKey;
+            break;
+        case nsMsgViewSortType::byAccount:
+        case nsMsgViewSortType::byTags:
+        case nsMsgViewSortType::byLocation:
+            *pFieldType = kCollationKey;
+            *pMaxLen = kMaxLocationKey;
+            break;
+        case nsMsgViewSortType::byRecipient:
+        case nsMsgViewSortType::byCorrespondent:
+            *pFieldType = kCollationKey;
+            *pMaxLen = kMaxRecipientKey;
+            break;
+        case nsMsgViewSortType::byAuthor:
+            *pFieldType = kCollationKey;
+            *pMaxLen = kMaxAuthorKey;
+            break;
+        case nsMsgViewSortType::byDate:
+        case nsMsgViewSortType::byReceived:
+        case nsMsgViewSortType::byPriority:
+        case nsMsgViewSortType::byThread:
+        case nsMsgViewSortType::byId:
+        case nsMsgViewSortType::bySize:
+        case nsMsgViewSortType::byFlagged:
+        case nsMsgViewSortType::byUnread:
+        case nsMsgViewSortType::byStatus:
+        case nsMsgViewSortType::byJunkStatus:
+        case nsMsgViewSortType::byAttachments:
+            *pFieldType = kU32;
+            *pMaxLen = 0;
+            break;
+        case nsMsgViewSortType::byCustom:
+        {
+          if (colHandler == nullptr)
+          {
+            NS_WARNING("colHandler is null. *pFieldType is not set.");
+            return NS_ERROR_NULL_POINTER;
+          }
+
+          bool isString;
+          colHandler->IsString(&isString);
+
+          if (isString)
+          {
+            *pFieldType = kCollationKey;
+            *pMaxLen = kMaxRecipientKey; //80 - do we need a seperate k?
+          }
+          else
+          {
+            *pFieldType = kU32;
+            *pMaxLen = 0;
+          }
+          break;
+        }
+        case nsMsgViewSortType::byNone: // bug 901948
+          return NS_ERROR_INVALID_ARG;
+        default:
+        {
+           nsAutoCString message("unexpected switch value: sortType=");
+           message.AppendInt(sortType);
+           NS_WARNING(message.get());
+           return NS_ERROR_UNEXPECTED;
+        }
+    }
+
+    return NS_OK;
+}
+
+#define MSG_STATUS_MASK (nsMsgMessageFlags::Replied | nsMsgMessageFlags::Forwarded)
+
+nsresult nsMsgDBView::GetStatusSortValue(nsIMsgDBHdr *msgHdr, uint32_t *result)
+{
+  NS_ENSURE_ARG_POINTER(msgHdr);
+  NS_ENSURE_ARG_POINTER(result);
+
+  uint32_t messageFlags;
+  nsresult rv = msgHdr->GetFlags(&messageFlags);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  if (messageFlags & nsMsgMessageFlags::New)
+  {
+    // happily, new by definition stands alone
+    *result = 0;
+    return NS_OK;
+  }
+
+  switch (messageFlags & MSG_STATUS_MASK)
+  {
+    case nsMsgMessageFlags::Replied:
+        *result = 2;
+        break;
+    case nsMsgMessageFlags::Forwarded | nsMsgMessageFlags::Replied:
+        *result = 1;
+        break;
+    case nsMsgMessageFlags::Forwarded:
+        *result = 3;
+        break;
+    default:
+        *result = (messageFlags & nsMsgMessageFlags::Read) ? 4 : 5;
+        break;
+    }
+
+    return NS_OK;
+}
+
+nsresult nsMsgDBView::GetLongField(nsIMsgDBHdr *msgHdr, nsMsgViewSortTypeValue sortType, uint32_t *result, nsIMsgCustomColumnHandler* colHandler)
+{
+  nsresult rv;
+  NS_ENSURE_ARG_POINTER(msgHdr);
+  NS_ENSURE_ARG_POINTER(result);
+
+  bool isRead;
+  uint32_t bits;
+
+  switch (sortType)
+  {
+    case nsMsgViewSortType::bySize:
+      rv = (mShowSizeInLines) ? msgHdr->GetLineCount(result) : msgHdr->GetMessageSize(result);
+      break;
+    case nsMsgViewSortType::byPriority:
+        nsMsgPriorityValue priority;
+        rv = msgHdr->GetPriority(&priority);
+
+        // treat "none" as "normal" when sorting.
+        if (priority == nsMsgPriority::none)
+            priority = nsMsgPriority::normal;
+
+        // we want highest priority to have lowest value
+        // so ascending sort will have highest priority first.
+        *result = nsMsgPriority::highest - priority;
+        break;
+    case nsMsgViewSortType::byStatus:
+        rv = GetStatusSortValue(msgHdr,result);
+        break;
+    case nsMsgViewSortType::byFlagged:
+        bits = 0;
+        rv = msgHdr->GetFlags(&bits);
+        *result = !(bits & nsMsgMessageFlags::Marked);  //make flagged come out on top.
+        break;
+    case nsMsgViewSortType::byUnread:
+        rv = msgHdr->GetIsRead(&isRead);
+        if (NS_SUCCEEDED(rv))
+            *result = !isRead;
+        break;
+    case nsMsgViewSortType::byJunkStatus:
+      {
+        nsCString junkScoreStr;
+        rv = msgHdr->GetStringProperty("junkscore", getter_Copies(junkScoreStr));
+        // unscored messages should come before messages that are scored
+        // junkScoreStr is "", and "0" - "100"
+        // normalize to 0 - 101
+        *result = junkScoreStr.IsEmpty() ? (0) : atoi(junkScoreStr.get()) + 1;
+      }
+      break;
+     case nsMsgViewSortType::byAttachments:
+        bits = 0;
+        rv = msgHdr->GetFlags(&bits);
+        *result = !(bits & nsMsgMessageFlags::Attachment);
+      break;
+    case nsMsgViewSortType::byDate:
+      // when sorting threads by date, we may want the date of the newest msg
+      // in the thread
+      if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay
+        && ! (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+        && ! mSortThreadsByRoot)
+      {
+        nsCOMPtr <nsIMsgThread> thread;
+        rv = GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(thread));
+        if (NS_SUCCEEDED(rv))
+        {
+          thread->GetNewestMsgDate(result);
+          break;
+        }
+      }
+      rv = msgHdr->GetDateInSeconds(result);
+      break;
+    case nsMsgViewSortType::byReceived:
+      // when sorting threads by received date, we may want the received date
+      // of the newest msg in the thread
+      if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay
+        && ! (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+        && ! mSortThreadsByRoot)
+      {
+        nsCOMPtr <nsIMsgThread> thread;
+        rv = GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(thread));
+        NS_ENSURE_SUCCESS(rv, rv);
+        thread->GetNewestMsgDate(result);
+      }
+      else
+      {
+        rv = msgHdr->GetUint32Property("dateReceived", result);  // Already in seconds...
+        if (*result == 0)  // Use Date instead, we have no Received property
+          rv = msgHdr->GetDateInSeconds(result);
+      }
+      break;
+    case nsMsgViewSortType::byCustom:
+      if (colHandler != nullptr)
+      {
+        colHandler->GetSortLongForRow(msgHdr, result);
+        rv = NS_OK;
+      }
+      else
+      {
+        NS_ASSERTION(false, "should not be here (Sort Type: byCustom (Long), but no custom handler)");
+        rv = NS_ERROR_UNEXPECTED;
+      }
+      break;
+    case nsMsgViewSortType::byNone: // Bug 901948
+      return NS_ERROR_INVALID_ARG;
+
+    case nsMsgViewSortType::byId:
+        // handled by caller, since caller knows the key
+    default:
+        NS_ERROR("should not be here");
+        rv = NS_ERROR_UNEXPECTED;
+        break;
+    }
+
+    NS_ENSURE_SUCCESS(rv,rv);
+    return NS_OK;
+}
+
+MsgViewSortColumnInfo::MsgViewSortColumnInfo(const MsgViewSortColumnInfo &other)
+{
+  mSortType = other.mSortType;
+  mSortOrder = other.mSortOrder;
+  mCustomColumnName = other.mCustomColumnName;
+  mColHandler = other.mColHandler;
+}
+
+bool MsgViewSortColumnInfo::operator== (const MsgViewSortColumnInfo& other) const
+{
+  return (mSortType == nsMsgViewSortType::byCustom) ?
+    mCustomColumnName.Equals(other.mCustomColumnName) : mSortType == other.mSortType;
+}
+
+nsresult nsMsgDBView::EncodeColumnSort(nsString &columnSortString)
+{
+  for (uint32_t i = 0; i < m_sortColumns.Length(); i++)
+  {
+    MsgViewSortColumnInfo &sortInfo = m_sortColumns[i];
+    columnSortString.Append((char) sortInfo.mSortType);
+    columnSortString.Append((char) sortInfo.mSortOrder + '0');
+    if (sortInfo.mSortType == nsMsgViewSortType::byCustom)
+    {
+      columnSortString.Append(sortInfo.mCustomColumnName);
+      columnSortString.Append((char16_t) '\r');
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::DecodeColumnSort(nsString &columnSortString)
+{
+  const char16_t *stringPtr = columnSortString.BeginReading();
+  while (*stringPtr)
+  {
+    MsgViewSortColumnInfo sortColumnInfo;
+    sortColumnInfo.mSortType = (nsMsgViewSortTypeValue) *stringPtr++;
+    sortColumnInfo.mSortOrder = (nsMsgViewSortOrderValue) (*stringPtr++) - '0';
+    if (sortColumnInfo.mSortType == nsMsgViewSortType::byCustom)
+    {
+      while (*stringPtr && *stringPtr != '\r')
+        sortColumnInfo.mCustomColumnName.Append(*stringPtr++);
+      sortColumnInfo.mColHandler = GetColumnHandler(sortColumnInfo.mCustomColumnName.get());
+      if (*stringPtr) // advance past '\r'
+        stringPtr++;
+    }
+    m_sortColumns.AppendElement(sortColumnInfo);
+  }
+  return NS_OK;
+}
+
+//  cf. Secondary Sort Key: when you select a column to sort, that
+//  becomes the new Primary sort key, and all previous sort keys
+//  become secondary. For example, if you first click on Date,
+//  the messages are sorted by Date; then click on From, and now the
+//  messages are sorted by From, and for each value of From the
+//  messages are in Date order.
+
+void nsMsgDBView::PushSort(const MsgViewSortColumnInfo &newSort)
+{
+  // DONE
+  //  Handle byNone (bug 901948) ala a mail/base/modules/dbViewerWrapper.js
+  //  where we don't push the secondary sort type if it's ::byNone;
+  //  (and secondary sort type is NOT the same as the first sort type
+  //  there.). This code should behave the same way.
+
+  // We don't expect to be passed sort type ::byNone,
+  // but if we are it's safe to ignore it.
+  if (newSort.mSortType == nsMsgViewSortType::byNone)
+    return;
+
+  // Date and ID are unique keys, so if we are sorting by them we don't
+  // need to keep any secondary sort keys
+  if (newSort.mSortType == nsMsgViewSortType::byDate ||
+      newSort.mSortType == nsMsgViewSortType::byId   )
+    m_sortColumns.Clear();
+  m_sortColumns.RemoveElement(newSort);
+  m_sortColumns.InsertElementAt(0, newSort);
+  if (m_sortColumns.Length() > kMaxNumSortColumns)
+    m_sortColumns.RemoveElementAt(kMaxNumSortColumns);
+}
+
+nsresult
+nsMsgDBView::GetCollationKey(nsIMsgDBHdr *msgHdr, nsMsgViewSortTypeValue sortType, uint8_t **result, uint32_t *len, nsIMsgCustomColumnHandler* colHandler)
+{
+  nsresult rv = NS_ERROR_UNEXPECTED;
+  NS_ENSURE_ARG_POINTER(msgHdr);
+  NS_ENSURE_ARG_POINTER(result);
+
+  switch (sortType)
+  {
+    case nsMsgViewSortType::bySubject:
+        rv = msgHdr->GetSubjectCollationKey(len, result);
+        break;
+    case nsMsgViewSortType::byLocation:
+        rv = GetLocationCollationKey(msgHdr, result, len);
+        break;
+    case nsMsgViewSortType::byRecipient:
+      {
+        nsString recipients;
+        rv = FetchRecipients(msgHdr, recipients);
+        if (NS_SUCCEEDED(rv))
+        {
+          nsCOMPtr <nsIMsgDatabase> dbToUse = m_db;
+          if (!dbToUse) // probably search view
+          {
+            rv = GetDBForHeader(msgHdr, getter_AddRefs(dbToUse));
+            NS_ENSURE_SUCCESS(rv,rv);
+          }
+          rv = dbToUse->CreateCollationKey(recipients, len, result);
+        }
+      }
+      break;
+    case nsMsgViewSortType::byAuthor:
+      {
+        rv = msgHdr->GetAuthorCollationKey(len, result);
+        nsString author;
+        rv = FetchAuthor(msgHdr, author);
+        if (NS_SUCCEEDED(rv))
+        {
+          nsCOMPtr <nsIMsgDatabase> dbToUse = m_db;
+          if (!dbToUse) // probably search view
+          {
+            rv = GetDBForHeader(msgHdr, getter_AddRefs(dbToUse));
+            NS_ENSURE_SUCCESS(rv,rv);
+          }
+          rv = dbToUse->CreateCollationKey(author, len, result);
+        }
+      }
+      break;
+    case nsMsgViewSortType::byAccount:
+    case nsMsgViewSortType::byTags:
+      {
+        nsString str;
+        nsCOMPtr <nsIMsgDatabase> dbToUse = m_db;
+
+        if (!dbToUse) // probably search view
+          GetDBForViewIndex(0, getter_AddRefs(dbToUse));
+
+        rv = (sortType == nsMsgViewSortType::byAccount)
+            ? FetchAccount(msgHdr, str)
+            : FetchTags(msgHdr, str);
+
+        if (NS_SUCCEEDED(rv) && dbToUse)
+          rv = dbToUse->CreateCollationKey(str, len, result);
+      }
+      break;
+    case nsMsgViewSortType::byCustom:
+      if (colHandler != nullptr)
+      {
+        nsAutoString strKey;
+        rv = colHandler->GetSortStringForRow(msgHdr, strKey);
+        NS_ASSERTION(NS_SUCCEEDED(rv),"failed to get sort string for custom row");
+        nsAutoString strTemp(strKey);
+
+        nsCOMPtr <nsIMsgDatabase> dbToUse = m_db;
+        if (!dbToUse) // probably search view
+        {
+          rv = GetDBForHeader(msgHdr, getter_AddRefs(dbToUse));
+          NS_ENSURE_SUCCESS(rv,rv);
+        }
+        rv = dbToUse->CreateCollationKey(strKey, len, result);
+      }
+      else
+      {
+        NS_ERROR("should not be here (Sort Type: byCustom (String), but no custom handler)");
+        rv = NS_ERROR_UNEXPECTED;
+      }
+      break;
+    case nsMsgViewSortType::byCorrespondent:
+      {
+        nsString value;
+        if (IsOutgoingMsg(msgHdr))
+          rv = FetchRecipients(msgHdr, value);
+        else
+          rv = FetchAuthor(msgHdr, value);
+        if (NS_SUCCEEDED(rv))
+        {
+          nsCOMPtr <nsIMsgDatabase> dbToUse = m_db;
+          if (!dbToUse) // probably search view
+          {
+            rv = GetDBForHeader(msgHdr, getter_AddRefs(dbToUse));
+            NS_ENSURE_SUCCESS(rv,rv);
+          }
+          rv = dbToUse->CreateCollationKey(value, len, result);
+        }
+      }
+      break;
+    default:
+        rv = NS_ERROR_UNEXPECTED;
+        break;
+    }
+
+    // bailing out with failure will stop the sort and leave us in
+    // a bad state.  try to continue on, instead
+    NS_ASSERTION(NS_SUCCEEDED(rv),"failed to get the collation key");
+    if (NS_FAILED(rv))
+    {
+        *result = nullptr;
+        *len = 0;
+    }
+    return NS_OK;
+}
+
+// As the location collation key is created getting folder from the msgHdr,
+// it is defined in this file and not from the db.
+nsresult
+nsMsgDBView::GetLocationCollationKey(nsIMsgDBHdr *msgHdr, uint8_t **result, uint32_t *len)
+{
+  nsCOMPtr <nsIMsgFolder> folder;
+
+  nsresult rv = msgHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv,rv);
+  nsCOMPtr <nsIMsgDatabase> dbToUse;
+  rv = folder->GetMsgDatabase(getter_AddRefs(dbToUse));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsString locationString;
+  rv = folder->GetPrettiestName(locationString);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  return dbToUse->CreateCollationKey(locationString, len, result);
+}
+
+nsresult nsMsgDBView::SaveSortInfo(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder)
+{
+  if (m_viewFolder)
+  {
+    nsCOMPtr <nsIDBFolderInfo> folderInfo;
+    nsCOMPtr <nsIMsgDatabase> db;
+    nsresult rv = m_viewFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(db));
+    if (NS_SUCCEEDED(rv) && folderInfo)
+    {
+      // save off sort type and order, view type and flags
+      folderInfo->SetSortType(sortType);
+      folderInfo->SetSortOrder(sortOrder);
+
+      nsString sortColumnsString;
+      rv = EncodeColumnSort(sortColumnsString);
+      NS_ENSURE_SUCCESS(rv, rv);
+      folderInfo->SetProperty("sortColumns", sortColumnsString);
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::RestoreSortInfo()
+{
+  if (!m_viewFolder)
+    return NS_OK;
+
+  nsCOMPtr <nsIDBFolderInfo> folderInfo;
+  nsCOMPtr <nsIMsgDatabase> db;
+  nsresult rv = m_viewFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(db));
+  if (NS_SUCCEEDED(rv) && folderInfo)
+  {
+    // Restore m_sortColumns from db.
+    nsString sortColumnsString;
+    folderInfo->GetProperty("sortColumns", sortColumnsString);
+    DecodeColumnSort(sortColumnsString);
+    if (m_sortColumns.Length() > 1)
+    {
+      m_secondarySort = m_sortColumns[1].mSortType;
+      m_secondarySortOrder = m_sortColumns[1].mSortOrder;
+      m_secondaryCustomColumn = m_sortColumns[1].mCustomColumnName;
+    }
+
+    // Restore curCustomColumn from db.
+    folderInfo->GetProperty("customSortCol", m_curCustomColumn);
+  }
+
+  return NS_OK;
+}
+
+// Called by msgDBView::Sort, at which point any persisted active custom
+// columns must be registered. If not, reset their m_sortColumns entries
+// to byDate; Sort will fill in values if necessary based on new user sort.
+void nsMsgDBView::EnsureCustomColumnsValid()
+{
+  if (!m_sortColumns.Length())
+    return;
+
+  for (uint32_t i = 0; i < m_sortColumns.Length(); i++)
+  {
+    if (m_sortColumns[i].mSortType == nsMsgViewSortType::byCustom &&
+        m_sortColumns[i].mColHandler == nullptr)
+    {
+      m_sortColumns[i].mSortType = nsMsgViewSortType::byDate;
+      m_sortColumns[i].mCustomColumnName.Truncate();
+      // There are only two...
+      if (i == 0 && m_sortType != nsMsgViewSortType::byCustom)
+        SetCurCustomColumn(EmptyString());
+      if (i == 1)
+        m_secondaryCustomColumn.Truncate();
+    }
+  }
+}
+
+int32_t  nsMsgDBView::SecondarySort(nsMsgKey key1, nsISupports *supports1,
+                                    nsMsgKey key2, nsISupports *supports2,
+                                    viewSortInfo *comparisonContext)
+{
+  // We need to make sure that in the case of the secondary sort field also
+  // matching, we don't recurse.
+  if (comparisonContext->isSecondarySort)
+    return key1 > key2;
+
+  nsCOMPtr<nsIMsgFolder> folder1, folder2;
+  nsCOMPtr <nsIMsgDBHdr> hdr1, hdr2;
+  folder1 = do_QueryInterface(supports1);
+  folder2 = do_QueryInterface(supports2);
+  nsresult rv = folder1->GetMessageHeader(key1, getter_AddRefs(hdr1));
+  NS_ENSURE_SUCCESS(rv, 0);
+  rv = folder2->GetMessageHeader(key2, getter_AddRefs(hdr2));
+  NS_ENSURE_SUCCESS(rv, 0);
+  IdKeyPtr EntryInfo1, EntryInfo2;
+  EntryInfo1.key = nullptr;
+  EntryInfo2.key = nullptr;
+
+  uint16_t  maxLen;
+  eFieldType fieldType;
+  nsMsgViewSortTypeValue sortType = comparisonContext->view->m_secondarySort;
+  nsMsgViewSortOrderValue sortOrder = comparisonContext->view->m_secondarySortOrder;
+
+  // Get the custom column handler for the *secondary* sort and pass it first
+  // to GetFieldTypeAndLenForSort to get the fieldType and then either
+  // GetCollationKey or GetLongField.
+  nsIMsgCustomColumnHandler* colHandler = nullptr;
+  if (sortType == nsMsgViewSortType::byCustom &&
+      comparisonContext->view->m_sortColumns.Length() > 1)
+    colHandler = comparisonContext->view->m_sortColumns[1].mColHandler;
+
+  // The following may leave fieldType undefined.
+  // In this case, we can return 0 right away since
+  // it is the value returned in the default case of
+  // switch (fieldType) statement below.
+  rv = GetFieldTypeAndLenForSort(sortType, &maxLen, &fieldType, colHandler);
+  NS_ENSURE_SUCCESS(rv, 0);
+
+  const void *pValue1 = &EntryInfo1, *pValue2 = &EntryInfo2;
+
+  int (* comparisonFun) (const void *pItem1, const void *pItem2, void *privateData) = nullptr;
+  int retStatus = 0;
+  hdr1->GetMessageKey(&EntryInfo1.id);
+  hdr2->GetMessageKey(&EntryInfo2.id);
+
+  switch (fieldType)
+  {
+    case kCollationKey:
+      rv = GetCollationKey(hdr1, sortType, &EntryInfo1.key, &EntryInfo1.dword, colHandler);
+      NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create collation key");
+      comparisonFun = FnSortIdKeyPtr;
+      break;
+    case kU32:
+      if (sortType == nsMsgViewSortType::byId)
+        EntryInfo1.dword = EntryInfo1.id;
+      else
+        GetLongField(hdr1, sortType, &EntryInfo1.dword, colHandler);
+      comparisonFun = FnSortIdUint32;
+      break;
+    default:
+      return 0;
+  }
+  bool saveAscendingSort = comparisonContext->ascendingSort;
+  comparisonContext->isSecondarySort = true;
+  comparisonContext->ascendingSort = (sortOrder == nsMsgViewSortOrder::ascending);
+  if (fieldType == kCollationKey)
+  {
+    PR_FREEIF(EntryInfo2.key);
+    rv = GetCollationKey(hdr2, sortType, &EntryInfo2.key, &EntryInfo2.dword, colHandler);
+    NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create collation key");
+  }
+  else if (fieldType == kU32)
+  {
+    if (sortType == nsMsgViewSortType::byId)
+      EntryInfo2.dword = EntryInfo2.id;
+    else
+      GetLongField(hdr2, sortType, &EntryInfo2.dword, colHandler);
+  }
+  retStatus = (*comparisonFun)(&pValue1, &pValue2, comparisonContext);
+
+  comparisonContext->isSecondarySort = false;
+  comparisonContext->ascendingSort = saveAscendingSort;
+
+  return retStatus;
+}
+
+
+NS_IMETHODIMP nsMsgDBView::Sort(nsMsgViewSortTypeValue sortType,
+                                nsMsgViewSortOrderValue sortOrder)
+{
+  EnsureCustomColumnsValid();
+
+  // If we're doing a stable sort, we can't just reverse the messages.
+  // Check also that the custom column we're sorting on hasn't changed.
+  // Otherwise, to be on the safe side, resort.
+  // Note: m_curCustomColumn is the desired (possibly new) custom column name,
+  // while m_sortColumns[0].mCustomColumnName is the name for the last completed
+  // sort, since these are persisted after each sort.
+  if (m_sortType == sortType && m_sortValid &&
+      (sortType != nsMsgViewSortType::byCustom ||
+       (sortType == nsMsgViewSortType::byCustom && m_sortColumns.Length() &&
+        m_sortColumns[0].mCustomColumnName.Equals(m_curCustomColumn))) &&
+      m_sortColumns.Length() < 2)
+  {
+    // same as it ever was.  do nothing
+    if (m_sortOrder == sortOrder)
+      return NS_OK;
+
+    // for secondary sort, remember the sort order on a per column basis.
+    if (m_sortColumns.Length())
+      m_sortColumns[0].mSortOrder = sortOrder;
+    SaveSortInfo(sortType, sortOrder);
+    if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+      ReverseThreads();
+    else
+      ReverseSort();
+
+    m_sortOrder = sortOrder;
+    // we just reversed the sort order...we still need to invalidate the view
+    return NS_OK;
+  }
+
+  if (sortType == nsMsgViewSortType::byThread)
+    return NS_OK;
+
+  // If a sortType has changed, or the sortType is byCustom and a column has
+  // changed, this is the new primary sortColumnInfo.
+  // Note: m_curCustomColumn is the desired (possibly new) custom column name,
+  // while m_sortColumns[0].mCustomColumnName is the name for the last completed
+  // sort, since these are persisted after each sort.
+  if (m_sortType != sortType ||
+      (sortType == nsMsgViewSortType::byCustom && m_sortColumns.Length() &&
+       !m_sortColumns[0].mCustomColumnName.Equals(m_curCustomColumn)))
+  {
+    // For secondary sort, remember the sort order of the original primary sort!
+    if (m_sortColumns.Length())
+      m_sortColumns[0].mSortOrder = m_sortOrder;
+
+    MsgViewSortColumnInfo sortColumnInfo;
+    sortColumnInfo.mSortType = sortType;
+    sortColumnInfo.mSortOrder = sortOrder;
+    if (sortType == nsMsgViewSortType::byCustom)
+    {
+      GetCurCustomColumn(sortColumnInfo.mCustomColumnName);
+      sortColumnInfo.mColHandler = GetCurColumnHandler();
+    }
+
+    PushSort(sortColumnInfo);
+  }
+  else
+  {
+    // For primary sort, remember the sort order on a per column basis.
+    if (m_sortColumns.Length())
+      m_sortColumns[0].mSortOrder = sortOrder;
+  }
+
+  if (m_sortColumns.Length() > 1)
+  {
+    m_secondarySort = m_sortColumns[1].mSortType;
+    m_secondarySortOrder = m_sortColumns[1].mSortOrder;
+    m_secondaryCustomColumn = m_sortColumns[1].mCustomColumnName;
+  }
+  SaveSortInfo(sortType, sortOrder);
+  // figure out how much memory we'll need, and the malloc it
+  uint16_t maxLen;
+  eFieldType fieldType;
+
+  // Get the custom column handler for the primary sort and pass it first
+  // to GetFieldTypeAndLenForSort to get the fieldType and then either
+  // GetCollationKey or GetLongField.
+  nsIMsgCustomColumnHandler* colHandler = GetCurColumnHandler();
+
+  // If we did not obtain proper fieldType, it needs to be checked
+  // because the subsequent code does not handle it very well.
+  nsresult rv = GetFieldTypeAndLenForSort(sortType, &maxLen, &fieldType, colHandler);
+
+  // Don't sort if the field type is not supported: Bug 901948
+  if (NS_FAILED(rv))
+    return NS_OK;
+
+  nsTArray<void*> ptrs;
+  uint32_t arraySize = GetSize();
+
+  if (!arraySize)
+    return NS_OK;
+
+  nsCOMArray<nsIMsgFolder> *folders = GetFolders();
+
+  IdKey** pPtrBase = (IdKey**)PR_Malloc(arraySize * sizeof(IdKey*));
+  NS_ASSERTION(pPtrBase, "out of memory, can't sort");
+  if (!pPtrBase) return NS_ERROR_OUT_OF_MEMORY;
+  ptrs.AppendElement((void *)pPtrBase); // remember this pointer so we can free it later
+
+  // build up the beast, so we can sort it.
+  uint32_t numSoFar = 0;
+  const uint32_t keyOffset = offsetof(IdKey, key);
+  // calc max possible size needed for all the rest
+  uint32_t maxSize = (keyOffset + maxLen) * (arraySize - numSoFar);
+
+  const uint32_t maxBlockSize = (uint32_t) 0xf000L;
+  uint32_t allocSize = std::min(maxBlockSize, maxSize);
+  char *pTemp = (char *) PR_Malloc(allocSize);
+  NS_ASSERTION(pTemp, "out of memory, can't sort");
+  if (!pTemp)
+  {
+    FreeAll(&ptrs);
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  ptrs.AppendElement(pTemp); // remember this pointer so we can free it later
+
+  char *pBase = pTemp;
+  bool more = true;
+
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  uint8_t *keyValue = nullptr;
+  uint32_t longValue;
+  while (more && numSoFar < arraySize)
+  {
+    nsMsgKey thisKey = m_keys[numSoFar];
+    if (sortType != nsMsgViewSortType::byId)
+    {
+      rv = GetMsgHdrForViewIndex(numSoFar, getter_AddRefs(msgHdr));
+      NS_ASSERTION(NS_SUCCEEDED(rv) && msgHdr, "header not found");
+      if (NS_FAILED(rv) || !msgHdr)
+      {
+        FreeAll(&ptrs);
+        return NS_ERROR_UNEXPECTED;
+      }
+    }
+    else
+    {
+      msgHdr = nullptr;
+    }
+
+    // Could be a problem here if the ones that appear here are different than
+    // the ones already in the array.
+    uint32_t actualFieldLen = 0;
+
+    if (fieldType == kCollationKey)
+    {
+      rv = GetCollationKey(msgHdr, sortType, &keyValue, &actualFieldLen, colHandler);
+      NS_ENSURE_SUCCESS(rv,rv);
+
+      longValue = actualFieldLen;
+    }
+    else
+    {
+      if (sortType == nsMsgViewSortType::byId)
+      {
+        longValue = thisKey;
+      }
+      else
+      {
+        rv = GetLongField(msgHdr, sortType, &longValue, colHandler);
+        NS_ENSURE_SUCCESS(rv,rv);
+      }
+    }
+
+    // check to see if this entry fits into the block we have allocated so far
+    // pTemp - pBase = the space we have used so far
+    // sizeof(EntryInfo) + fieldLen = space we need for this entry
+    // allocSize = size of the current block
+    if ((uint32_t)(pTemp - pBase) + (keyOffset + actualFieldLen) >= allocSize)
+    {
+      maxSize = (keyOffset + maxLen) * (arraySize - numSoFar);
+      allocSize = std::min(maxBlockSize, maxSize);
+      // make sure allocSize is big enough for the current value
+      allocSize = std::max(allocSize, keyOffset + actualFieldLen);
+      pTemp = (char *) PR_Malloc(allocSize);
+      NS_ASSERTION(pTemp, "out of memory, can't sort");
+      if (!pTemp)
+      {
+        FreeAll(&ptrs);
+        return NS_ERROR_OUT_OF_MEMORY;
+      }
+      pBase = pTemp;
+      ptrs.AppendElement(pTemp); // remember this pointer so we can free it later
+    }
+
+    // now store this entry away in the allocated memory
+    IdKey *info = (IdKey*)pTemp;
+    pPtrBase[numSoFar] = info;
+    info->id = thisKey;
+    info->bits = m_flags[numSoFar];
+    info->dword = longValue;
+    //info->pad = 0;
+    info->folder = folders ? folders->ObjectAt(numSoFar) : m_folder.get();
+
+    memcpy(info->key, keyValue, actualFieldLen);
+    //In order to align memory for systems that require it, such as HP-UX
+    //calculate the correct value to pad the actualFieldLen value
+    const uint32_t align = sizeof(IdKey) - sizeof(IdUint32) - 1;
+    actualFieldLen = (actualFieldLen + align) & ~align;
+
+    pTemp += keyOffset + actualFieldLen;
+    ++numSoFar;
+    PR_Free(keyValue);
+  }
+
+  viewSortInfo qsPrivateData;
+  qsPrivateData.view = this;
+  qsPrivateData.isSecondarySort = false;
+  qsPrivateData.ascendingSort = (sortOrder == nsMsgViewSortOrder::ascending);
+
+  nsCOMPtr <nsIMsgDatabase> dbToUse = m_db;
+
+  if (!dbToUse) // probably search view
+    GetDBForViewIndex(0, getter_AddRefs(dbToUse));
+  qsPrivateData.db = dbToUse;
+  if (dbToUse)
+  {
+    // do the sort
+    switch (fieldType)
+    {
+      case kCollationKey:
+        NS_QuickSort(pPtrBase, numSoFar, sizeof(IdKey*), FnSortIdKey, &qsPrivateData);
+        break;
+      case kU32:
+        NS_QuickSort(pPtrBase, numSoFar, sizeof(IdKey*), FnSortIdUint32, &qsPrivateData);
+        break;
+      default:
+        NS_ERROR("not supposed to get here");
+        break;
+    }
+  }
+
+  // now put the IDs into the array in proper order
+  for (uint32_t i = 0; i < numSoFar; i++)
+  {
+    m_keys[i] = pPtrBase[i]->id;
+    m_flags[i] = pPtrBase[i]->bits;
+
+    if (folders)
+      folders->ReplaceObjectAt(pPtrBase[i]->folder, i);
+  }
+
+  m_sortType = sortType;
+  m_sortOrder = sortOrder;
+
+  // free all the memory we allocated
+  FreeAll(&ptrs);
+
+  m_sortValid = true;
+  //m_db->SetSortInfo(sortType, sortOrder);
+
+  return NS_OK;
+}
+
+void nsMsgDBView::FreeAll(nsTArray<void*> *ptrs)
+{
+  int32_t i;
+  int32_t count = (int32_t) ptrs->Length();
+  if (count == 0)
+    return;
+
+  for (i=(count - 1);i>=0;i--)
+    PR_Free((void *) ptrs->ElementAt(i));
+  ptrs->Clear();
+}
+
+nsMsgViewIndex nsMsgDBView::GetIndexOfFirstDisplayedKeyInThread(
+    nsIMsgThread *threadHdr, bool allowDummy)
+{
+  nsMsgViewIndex  retIndex = nsMsgViewIndex_None;
+  uint32_t        childIndex = 0;
+  // We could speed up the unreadOnly view by starting our search with the first
+  // unread message in the thread. Sometimes, that will be wrong, however, so
+  // let's skip it until we're sure it's necessary.
+  //  (m_viewFlags & nsMsgViewFlagsType::kUnreadOnly)
+  //    ? threadHdr->GetFirstUnreadKey(m_db) : threadHdr->GetChildAt(0);
+  uint32_t numThreadChildren;
+  threadHdr->GetNumChildren(&numThreadChildren);
+  while (retIndex == nsMsgViewIndex_None && childIndex < numThreadChildren)
+  {
+    nsCOMPtr<nsIMsgDBHdr> childHdr;
+    threadHdr->GetChildHdrAt(childIndex++, getter_AddRefs(childHdr));
+    if (childHdr)
+      retIndex = FindHdr(childHdr, 0, allowDummy);
+  }
+  return retIndex;
+}
+
+nsresult nsMsgDBView::GetFirstMessageHdrToDisplayInThread(nsIMsgThread *threadHdr, nsIMsgDBHdr **result)
+{
+  nsresult rv;
+
+  if (m_viewFlags & nsMsgViewFlagsType::kUnreadOnly)
+    rv = threadHdr->GetFirstUnreadChild(result);
+  else
+    rv = threadHdr->GetChildHdrAt(0, result);
+  return rv;
+}
+
+// Find the view index of the thread containing the passed msgKey, if
+// the thread is in the view. MsgIndex is passed in as a shortcut if
+// it turns out the msgKey is the first message in the thread,
+// then we can avoid looking for the msgKey.
+nsMsgViewIndex nsMsgDBView::ThreadIndexOfMsg(nsMsgKey msgKey,
+                                            nsMsgViewIndex msgIndex /* = nsMsgViewIndex_None */,
+                                            int32_t *pThreadCount /* = NULL */,
+                                            uint32_t *pFlags /* = NULL */)
+{
+  if (! (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    return nsMsgViewIndex_None;
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  nsresult rv = m_db->GetMsgHdrForKey(msgKey, getter_AddRefs(msgHdr));
+  NS_ENSURE_SUCCESS(rv, nsMsgViewIndex_None);
+  return ThreadIndexOfMsgHdr(msgHdr, msgIndex, pThreadCount, pFlags);
+}
+
+nsMsgViewIndex nsMsgDBView::GetThreadIndex(nsMsgViewIndex msgIndex)
+{
+  if (!IsValidIndex(msgIndex))
+    return nsMsgViewIndex_None;
+
+  // scan up looking for level 0 message.
+  while (m_levels[msgIndex] && msgIndex)
+    --msgIndex;
+  return msgIndex;
+}
+
+nsMsgViewIndex
+nsMsgDBView::ThreadIndexOfMsgHdr(nsIMsgDBHdr *msgHdr,
+                                 nsMsgViewIndex msgIndex,
+                                 int32_t *pThreadCount,
+                                 uint32_t *pFlags)
+{
+  nsCOMPtr<nsIMsgThread> threadHdr;
+  nsresult rv = GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(threadHdr));
+  NS_ENSURE_SUCCESS(rv, nsMsgViewIndex_None);
+
+  nsMsgViewIndex retIndex = nsMsgViewIndex_None;
+
+  if (threadHdr != nullptr)
+  {
+    if (msgIndex == nsMsgViewIndex_None)
+      msgIndex = FindHdr(msgHdr, 0, true);
+
+    if (msgIndex == nsMsgViewIndex_None)  // hdr is not in view, need to find by thread
+    {
+      msgIndex = GetIndexOfFirstDisplayedKeyInThread(threadHdr, true);
+      //nsMsgKey    threadKey = (msgIndex == nsMsgViewIndex_None) ? nsMsgKey_None : GetAt(msgIndex);
+      if (pFlags)
+        threadHdr->GetFlags(pFlags);
+    }
+    nsMsgViewIndex startOfThread = msgIndex;
+    while ((int32_t) startOfThread >= 0 && m_levels[startOfThread] != 0)
+      startOfThread--;
+    retIndex = startOfThread;
+    if (pThreadCount)
+    {
+      int32_t numChildren = 0;
+      nsMsgViewIndex threadIndex = startOfThread;
+      do
+      {
+        threadIndex++;
+        numChildren++;
+      }
+      while (threadIndex < m_levels.Length() && m_levels[threadIndex] != 0);
+      *pThreadCount = numChildren;
+    }
+  }
+  return retIndex;
+}
+
+nsMsgKey nsMsgDBView::GetKeyOfFirstMsgInThread(nsMsgKey key)
+{
+  // Just report no key for any failure. This can occur when a
+  // message is deleted from a threaded view
+  nsCOMPtr <nsIMsgThread> pThread;
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  nsresult rv = m_db->GetMsgHdrForKey(key, getter_AddRefs(msgHdr));
+  if (NS_FAILED(rv))
+    return nsMsgKey_None;
+  rv = GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(pThread));
+  if (NS_FAILED(rv))
+    return nsMsgKey_None;
+  nsMsgKey  firstKeyInThread = nsMsgKey_None;
+
+  if (!pThread)
+    return firstKeyInThread;
+
+  // ### dmb UnreadOnly - this is wrong. But didn't seem to matter in 4.x
+  pThread->GetChildKeyAt(0, &firstKeyInThread);
+  return firstKeyInThread;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetKeyAt(nsMsgViewIndex index, nsMsgKey *result)
+{
+  NS_ENSURE_ARG(result);
+  *result = GetAt(index);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetFlagsAt(nsMsgViewIndex aIndex, uint32_t *aResult)
+{
+  NS_ENSURE_ARG(aResult);
+  if (!IsValidIndex(aIndex))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  *aResult = m_flags[aIndex];
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetMsgHdrAt(nsMsgViewIndex aIndex, nsIMsgDBHdr **aResult)
+{
+  NS_ENSURE_ARG(aResult);
+  if (!IsValidIndex(aIndex))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  return GetMsgHdrForViewIndex(aIndex, aResult);
+}
+
+nsMsgViewIndex nsMsgDBView::FindHdr(nsIMsgDBHdr *msgHdr, nsMsgViewIndex startIndex,
+                                    bool allowDummy)
+{
+  nsMsgKey msgKey;
+  msgHdr->GetMessageKey(&msgKey);
+  nsMsgViewIndex viewIndex = m_keys.IndexOf(msgKey, startIndex);
+  if (viewIndex == nsMsgViewIndex_None)
+    return viewIndex;
+  // if we're supposed to allow dummies, and the previous index is a dummy that
+  //  is not elided, then it must be the dummy corresponding to our node and
+  //  we should return that instead.
+  if (allowDummy && viewIndex
+      && (m_flags[viewIndex-1] & MSG_VIEW_FLAG_DUMMY)
+      && !(m_flags[viewIndex-1] & nsMsgMessageFlags::Elided))
+    viewIndex--;
+  // else if we're not allowing dummies, and we found a dummy, look again
+  // one past the dummy.
+  else if (!allowDummy && m_flags[viewIndex] & MSG_VIEW_FLAG_DUMMY)
+    return m_keys.IndexOf(msgKey, viewIndex + 1);
+  return viewIndex;
+}
+
+nsMsgViewIndex nsMsgDBView::FindKey(nsMsgKey key, bool expand)
+{
+  nsMsgViewIndex retIndex = nsMsgViewIndex_None;
+  retIndex = (nsMsgViewIndex) (m_keys.IndexOf(key));
+  // for dummy headers, try to expand if the caller says so. And if the thread is
+  // expanded, ignore the dummy header and return the real header index.
+  if (retIndex != nsMsgViewIndex_None && m_flags[retIndex] & MSG_VIEW_FLAG_DUMMY &&  !(m_flags[retIndex] & nsMsgMessageFlags::Elided))
+    return (nsMsgViewIndex) m_keys.IndexOf(key, retIndex + 1);
+  if (key != nsMsgKey_None && (retIndex == nsMsgViewIndex_None || m_flags[retIndex] & MSG_VIEW_FLAG_DUMMY)
+    && expand && m_db)
+  {
+    nsMsgKey threadKey = GetKeyOfFirstMsgInThread(key);
+    if (threadKey != nsMsgKey_None)
+    {
+      nsMsgViewIndex threadIndex = FindKey(threadKey, false);
+      if (threadIndex != nsMsgViewIndex_None)
+      {
+        uint32_t flags = m_flags[threadIndex];
+        if (((flags & nsMsgMessageFlags::Elided) &&
+             NS_SUCCEEDED(ExpandByIndex(threadIndex, nullptr)))
+            || (flags & MSG_VIEW_FLAG_DUMMY))
+          retIndex = (nsMsgViewIndex) m_keys.IndexOf(key, threadIndex + 1);
+      }
+    }
+  }
+  return retIndex;
+}
+
+nsresult nsMsgDBView::GetThreadCount(nsMsgViewIndex index, uint32_t *pThreadCount)
+{
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  nsresult rv = GetMsgHdrForViewIndex(index, getter_AddRefs(msgHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr <nsIMsgThread> pThread;
+  rv = GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(pThread));
+  if (NS_SUCCEEDED(rv) && pThread != nullptr)
+    rv = pThread->GetNumChildren(pThreadCount);
+  return rv;
+}
+
+// This counts the number of messages in an expanded thread, given the
+// index of the first message in the thread.
+int32_t nsMsgDBView::CountExpandedThread(nsMsgViewIndex index)
+{
+  int32_t numInThread = 0;
+  nsMsgViewIndex startOfThread = index;
+  while ((int32_t) startOfThread >= 0 && m_levels[startOfThread] != 0)
+    startOfThread--;
+  nsMsgViewIndex threadIndex = startOfThread;
+  do
+  {
+    threadIndex++;
+    numInThread++;
+  }
+  while (threadIndex < m_levels.Length() && m_levels[threadIndex] != 0);
+
+  return numInThread;
+}
+
+// returns the number of lines that would be added (> 0) or removed (< 0)
+// if we were to try to expand/collapse the passed index.
+nsresult nsMsgDBView::ExpansionDelta(nsMsgViewIndex index, int32_t *expansionDelta)
+{
+  uint32_t numChildren;
+  nsresult  rv;
+
+  *expansionDelta = 0;
+  if (index >= ((nsMsgViewIndex) m_keys.Length()))
+    return NS_MSG_MESSAGE_NOT_FOUND;
+  char  flags = m_flags[index];
+
+  if (!(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    return NS_OK;
+
+  // The client can pass in the key of any message
+  // in a thread and get the expansion delta for the thread.
+
+  if (flags & nsMsgMessageFlags::Elided)
+  {
+    rv = GetThreadCount(index, &numChildren);
+    NS_ENSURE_SUCCESS(rv, rv);
+    *expansionDelta = numChildren - 1;
+  }
+  else
+  {
+    numChildren = CountExpandedThread(index);
+    *expansionDelta = - (int32_t) (numChildren - 1);
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::ToggleExpansion(nsMsgViewIndex index, uint32_t *numChanged)
+{
+  nsresult rv;
+  NS_ENSURE_ARG(numChanged);
+  *numChanged = 0;
+  nsMsgViewIndex threadIndex = GetThreadIndex(index);
+  if (threadIndex == nsMsgViewIndex_None)
+  {
+    NS_ASSERTION(false, "couldn't find thread");
+    return NS_MSG_MESSAGE_NOT_FOUND;
+  }
+  int32_t  flags = m_flags[threadIndex];
+
+  // if not a thread, or doesn't have children, no expand/collapse
+  // If we add sub-thread expand collapse, this will need to be relaxed
+  if (!(flags & MSG_VIEW_FLAG_ISTHREAD) || !(flags & MSG_VIEW_FLAG_HASCHILDREN))
+    return NS_MSG_MESSAGE_NOT_FOUND;
+  if (flags & nsMsgMessageFlags::Elided)
+    rv = ExpandByIndex(threadIndex, numChanged);
+  else
+    rv = CollapseByIndex(threadIndex, numChanged);
+
+  // if we collaps/uncollapse a thread, this changes the selected URIs
+  SelectionChanged();
+  return rv;
+}
+
+nsresult nsMsgDBView::ExpandAndSelectThread()
+{
+    nsresult rv;
+
+    NS_ASSERTION(mTreeSelection, "no tree selection");
+    if (!mTreeSelection) return NS_ERROR_UNEXPECTED;
+
+    int32_t index;
+    rv = mTreeSelection->GetCurrentIndex(&index);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = ExpandAndSelectThreadByIndex(index, false);
+    NS_ENSURE_SUCCESS(rv,rv);
+    return NS_OK;
+}
+
+nsresult nsMsgDBView::ExpandAndSelectThreadByIndex(nsMsgViewIndex index, bool augment)
+{
+  nsresult rv;
+
+  nsMsgViewIndex threadIndex;
+  bool inThreadedMode = (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay);
+
+  if (inThreadedMode)
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    GetMsgHdrForViewIndex(index, getter_AddRefs(msgHdr));
+    threadIndex = ThreadIndexOfMsgHdr(msgHdr, index);
+    if (threadIndex == nsMsgViewIndex_None)
+    {
+      NS_ASSERTION(false, "couldn't find thread");
+      return NS_MSG_MESSAGE_NOT_FOUND;
+    }
+  }
+  else
+  {
+    threadIndex = index;
+  }
+
+  int32_t flags = m_flags[threadIndex];
+  int32_t count = 0;
+
+  if (inThreadedMode && (flags & MSG_VIEW_FLAG_ISTHREAD) && (flags & MSG_VIEW_FLAG_HASCHILDREN))
+  {
+    // if closed, expand this thread.
+    if (flags & nsMsgMessageFlags::Elided)
+    {
+      uint32_t numExpanded;
+      rv = ExpandByIndex(threadIndex, &numExpanded);
+      NS_ENSURE_SUCCESS(rv,rv);
+    }
+
+    // get the number of messages in the expanded thread
+    // so we know how many to select
+    count = CountExpandedThread(threadIndex);
+  }
+  else
+  {
+    count = 1;
+  }
+  NS_ASSERTION(count > 0, "bad count");
+
+  // update the selection
+
+  NS_ASSERTION(mTreeSelection, "no tree selection");
+  if (!mTreeSelection) return NS_ERROR_UNEXPECTED;
+
+  // the count should be 1 or greater. if there was only one message in the thread, we just select it.
+  // if more, we select all of them.
+  mTreeSelection->RangedSelect(threadIndex + count - 1, threadIndex, augment);
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::ExpandAll()
+{
+  if (mTree)
+    mTree->BeginUpdateBatch();
+  for (int32_t i = GetSize() - 1; i >= 0; i--)
+  {
+    uint32_t numExpanded;
+    uint32_t flags = m_flags[i];
+    if (flags & nsMsgMessageFlags::Elided)
+      ExpandByIndex(i, &numExpanded);
+  }
+  if (mTree)
+    mTree->EndUpdateBatch();
+  SelectionChanged();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetThreadContainingMsgHdr(nsIMsgDBHdr *msgHdr, nsIMsgThread **pThread)
+{
+  return m_db->GetThreadContainingMsgHdr(msgHdr, pThread);
+}
+
+nsresult nsMsgDBView::ExpandByIndex(nsMsgViewIndex index, uint32_t *pNumExpanded)
+{
+  if ((uint32_t) index >= m_keys.Length())
+    return NS_MSG_MESSAGE_NOT_FOUND;
+
+  uint32_t      flags = m_flags[index];
+  uint32_t      numExpanded = 0;
+
+  NS_ASSERTION(flags & nsMsgMessageFlags::Elided, "can't expand an already expanded thread");
+  flags &= ~nsMsgMessageFlags::Elided;
+
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  nsCOMPtr <nsIMsgThread> pThread;
+  nsresult rv = GetThreadContainingIndex(index, getter_AddRefs(pThread));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (m_viewFlags & nsMsgViewFlagsType::kUnreadOnly)
+  {
+    if (flags & nsMsgMessageFlags::Read)
+      m_levels.AppendElement(0);  // keep top level hdr in thread, even though read.
+    rv = ListUnreadIdsInThread(pThread,  index, &numExpanded);
+  }
+  else
+    rv = ListIdsInThread(pThread,  index, &numExpanded);
+
+  if (numExpanded > 0)
+  {
+    m_flags[index] = flags;
+    NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+  }
+  NoteStartChange(index + 1, numExpanded, nsMsgViewNotificationCode::insertOrDelete);
+  NoteEndChange(index + 1, numExpanded, nsMsgViewNotificationCode::insertOrDelete);
+  if (pNumExpanded != nullptr)
+    *pNumExpanded = numExpanded;
+  return rv;
+}
+
+nsresult nsMsgDBView::CollapseAll()
+{
+  for (uint32_t i = 0; i < GetSize(); i++)
+  {
+    uint32_t numExpanded;
+    uint32_t flags = m_flags[i];
+    if (!(flags & nsMsgMessageFlags::Elided) && (flags & MSG_VIEW_FLAG_HASCHILDREN))
+      CollapseByIndex(i, &numExpanded);
+  }
+  SelectionChanged();
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::CollapseByIndex(nsMsgViewIndex index, uint32_t *pNumCollapsed)
+{
+  nsresult  rv;
+  int32_t  flags = m_flags[index];
+  int32_t  rowDelta = 0;
+
+  if (flags & nsMsgMessageFlags::Elided || !(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay) || !(flags & MSG_VIEW_FLAG_HASCHILDREN))
+    return NS_OK;
+
+  if (index > m_keys.Length())
+    return NS_MSG_MESSAGE_NOT_FOUND;
+
+  rv = ExpansionDelta(index, &rowDelta);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  flags |= nsMsgMessageFlags::Elided;
+
+  m_flags[index] = flags;
+  NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+
+  int32_t numRemoved = -rowDelta; // don't count first header in thread
+  if (index + 1 + numRemoved > m_keys.Length())
+  {
+    NS_ERROR("trying to remove too many rows");
+    numRemoved -= (index + 1 + numRemoved) - m_keys.Length();
+    if (numRemoved <= 0)
+      return NS_MSG_MESSAGE_NOT_FOUND;
+  }
+  NoteStartChange(index + 1, rowDelta, nsMsgViewNotificationCode::insertOrDelete);
+  // start at first id after thread.
+  RemoveRows(index + 1, numRemoved);
+  if (pNumCollapsed != nullptr)
+    *pNumCollapsed = numRemoved;
+  NoteEndChange(index + 1, rowDelta, nsMsgViewNotificationCode::insertOrDelete);
+
+  return rv;
+}
+
+nsresult nsMsgDBView::OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey aParentKey, bool /*ensureListed*/)
+{
+    nsresult rv = NS_OK;
+    // views can override this behaviour, which is to append to view.
+    // This is the mail behaviour, but threaded views will want
+    // to insert in order...
+    if (newHdr)
+  rv = AddHdr(newHdr);
+    return rv;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetThreadContainingIndex(nsMsgViewIndex index, nsIMsgThread **resultThread)
+{
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  nsresult rv = GetMsgHdrForViewIndex(index, getter_AddRefs(msgHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return GetThreadContainingMsgHdr(msgHdr, resultThread);
+}
+
+nsMsgViewIndex
+nsMsgDBView::GetIndexForThread(nsIMsgDBHdr *msgHdr)
+{
+  // Take advantage of the fact that we're already sorted
+  // and find the insert index via a binary search, though expanded threads
+  // make that tricky.
+
+  nsMsgViewIndex highIndex = m_keys.Length();
+  nsMsgViewIndex lowIndex = 0;
+  IdKeyPtr EntryInfo1, EntryInfo2;
+  EntryInfo1.key = nullptr;
+  EntryInfo2.key = nullptr;
+
+  nsresult rv;
+  uint16_t  maxLen;
+  eFieldType fieldType;
+
+  // Get the custom column handler for the primary sort and pass it first
+  // to GetFieldTypeAndLenForSort to get the fieldType and then either
+  // GetCollationKey or GetLongField.
+  nsIMsgCustomColumnHandler* colHandler = GetCurColumnHandler();
+
+  // The following may leave fieldType undefined.
+  // In this case, we can return highIndex right away since
+  // it is the value returned in the default case of
+  // switch (fieldType) statement below.
+  rv = GetFieldTypeAndLenForSort(m_sortType, &maxLen, &fieldType, colHandler);
+  NS_ENSURE_SUCCESS(rv, highIndex);
+
+  const void *pValue1 = &EntryInfo1, *pValue2 = &EntryInfo2;
+
+  int retStatus = 0;
+  msgHdr->GetMessageKey(&EntryInfo1.id);
+  msgHdr->GetFolder(&EntryInfo1.folder);
+  EntryInfo1.folder->Release();
+
+  viewSortInfo comparisonContext;
+  comparisonContext.view = this;
+  comparisonContext.isSecondarySort = false;
+  comparisonContext.ascendingSort = (m_sortOrder == nsMsgViewSortOrder::ascending);
+  nsCOMPtr <nsIMsgDatabase> hdrDB;
+  EntryInfo1.folder->GetMsgDatabase(getter_AddRefs(hdrDB));
+  comparisonContext.db = hdrDB.get();
+  switch (fieldType)
+  {
+    case kCollationKey:
+      rv = GetCollationKey(msgHdr, m_sortType, &EntryInfo1.key, &EntryInfo1.dword, colHandler);
+      NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create collation key");
+      break;
+    case kU32:
+      if (m_sortType == nsMsgViewSortType::byId)
+        EntryInfo1.dword = EntryInfo1.id;
+      else
+        GetLongField(msgHdr, m_sortType, &EntryInfo1.dword, colHandler);
+      break;
+    default:
+      return highIndex;
+  }
+  while (highIndex > lowIndex)
+  {
+    nsMsgViewIndex tryIndex = (lowIndex + highIndex) / 2;
+    // need to adjust tryIndex if it's not a thread.
+    while (m_levels[tryIndex] && tryIndex)
+      tryIndex--;
+
+    if (tryIndex < lowIndex)
+    {
+      NS_ERROR("try index shouldn't be less than low index");
+      break;
+    }
+    EntryInfo2.id = m_keys[tryIndex];
+    GetFolderForViewIndex(tryIndex, &EntryInfo2.folder);
+    EntryInfo2.folder->Release();
+
+    nsCOMPtr <nsIMsgDBHdr> tryHdr;
+    nsCOMPtr <nsIMsgDatabase> db;
+    // ### this should get the db from the folder...
+    GetDBForViewIndex(tryIndex, getter_AddRefs(db));
+    if (db)
+      rv = db->GetMsgHdrForKey(EntryInfo2.id, getter_AddRefs(tryHdr));
+    if (!tryHdr)
+      break;
+    if (tryHdr == msgHdr)
+    {
+      NS_WARNING("didn't expect header to already be in view");
+      highIndex = tryIndex;
+      break;
+    }
+    if (fieldType == kCollationKey)
+    {
+      PR_FREEIF(EntryInfo2.key);
+      rv = GetCollationKey(tryHdr, m_sortType, &EntryInfo2.key, &EntryInfo2.dword, colHandler);
+      NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create collation key");
+      retStatus = FnSortIdKeyPtr(&pValue1, &pValue2, &comparisonContext);
+    }
+    else if (fieldType == kU32)
+    {
+      if (m_sortType == nsMsgViewSortType::byId)
+        EntryInfo2.dword = EntryInfo2.id;
+      else
+        GetLongField(tryHdr, m_sortType, &EntryInfo2.dword, colHandler);
+      retStatus = FnSortIdUint32(&pValue1, &pValue2, &comparisonContext);
+    }
+    if (retStatus == 0)
+    {
+      highIndex = tryIndex;
+      break;
+    }
+
+    if (retStatus < 0)
+    {
+      highIndex = tryIndex;
+      // we already made sure tryIndex was at a thread at the top of the loop.
+    }
+    else
+    {
+      lowIndex = tryIndex + 1;
+      while (lowIndex < GetSize() && m_levels[lowIndex])
+        lowIndex++;
+    }
+  }
+
+  PR_Free(EntryInfo1.key);
+  PR_Free(EntryInfo2.key);
+  return highIndex;
+}
+
+nsMsgViewIndex nsMsgDBView::GetInsertIndexHelper(nsIMsgDBHdr *msgHdr, nsTArray<nsMsgKey> &keys,
+                                                 nsCOMArray<nsIMsgFolder> *folders,
+                                                 nsMsgViewSortOrderValue sortOrder, nsMsgViewSortTypeValue sortType)
+{
+  nsMsgViewIndex highIndex = keys.Length();
+  nsMsgViewIndex lowIndex = 0;
+  IdKeyPtr EntryInfo1, EntryInfo2;
+  EntryInfo1.key = nullptr;
+  EntryInfo2.key = nullptr;
+
+  nsresult rv;
+  uint16_t  maxLen;
+  eFieldType fieldType;
+
+  // Get the custom column handler for the primary sort and pass it first
+  // to GetFieldTypeAndLenForSort to get the fieldType and then either
+  // GetCollationKey or GetLongField.
+  nsIMsgCustomColumnHandler* colHandler = GetCurColumnHandler();
+
+  // The following may leave fieldType undefined.
+  // In this case, we can return highIndex right away since
+  // it is the value returned in the default case of
+  // switch (fieldType) statement below.
+  rv = GetFieldTypeAndLenForSort(sortType, &maxLen, &fieldType, colHandler);
+  NS_ENSURE_SUCCESS(rv, highIndex);
+
+  const void *pValue1 = &EntryInfo1, *pValue2 = &EntryInfo2;
+
+  int (* comparisonFun) (const void *pItem1, const void *pItem2, void *privateData) = nullptr;
+  int retStatus = 0;
+  msgHdr->GetMessageKey(&EntryInfo1.id);
+  msgHdr->GetFolder(&EntryInfo1.folder);
+  EntryInfo1.folder->Release();
+
+  viewSortInfo comparisonContext;
+  comparisonContext.view = this;
+  comparisonContext.isSecondarySort = false;
+  comparisonContext.ascendingSort = (sortOrder == nsMsgViewSortOrder::ascending);
+  rv = EntryInfo1.folder->GetMsgDatabase(&comparisonContext.db);
+  NS_ENSURE_SUCCESS(rv, highIndex);
+  comparisonContext.db->Release();
+  switch (fieldType)
+  {
+    case kCollationKey:
+      rv = GetCollationKey(msgHdr, sortType, &EntryInfo1.key, &EntryInfo1.dword, colHandler);
+      NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create collation key");
+      comparisonFun = FnSortIdKeyPtr;
+      break;
+    case kU32:
+      if (sortType == nsMsgViewSortType::byId)
+        EntryInfo1.dword = EntryInfo1.id;
+      else
+        GetLongField(msgHdr, sortType, &EntryInfo1.dword, colHandler);
+      comparisonFun = FnSortIdUint32;
+      break;
+    default:
+      return highIndex;
+  }
+  while (highIndex > lowIndex)
+  {
+    nsMsgViewIndex tryIndex = (lowIndex + highIndex - 1) / 2;
+    EntryInfo2.id = keys[tryIndex];
+    EntryInfo2.folder = folders ? folders->ObjectAt(tryIndex) : m_folder.get();
+
+    nsCOMPtr <nsIMsgDBHdr> tryHdr;
+    EntryInfo2.folder->GetMessageHeader(EntryInfo2.id, getter_AddRefs(tryHdr));
+    if (!tryHdr)
+      break;
+    if (fieldType == kCollationKey)
+    {
+      PR_FREEIF(EntryInfo2.key);
+      rv = GetCollationKey(tryHdr, sortType, &EntryInfo2.key, &EntryInfo2.dword, colHandler);
+      NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create collation key");
+    }
+    else if (fieldType == kU32)
+    {
+      if (sortType == nsMsgViewSortType::byId) {
+        EntryInfo2.dword = EntryInfo2.id;
+      }
+      else {
+        GetLongField(tryHdr, sortType, &EntryInfo2.dword, colHandler);
+      }
+    }
+    retStatus = (*comparisonFun)(&pValue1, &pValue2, &comparisonContext);
+    if (retStatus == 0)
+    {
+      highIndex = tryIndex;
+      break;
+    }
+
+    if (retStatus < 0)
+    {
+      highIndex = tryIndex;
+    }
+    else
+    {
+      lowIndex = tryIndex + 1;
+    }
+  }
+
+  PR_Free(EntryInfo1.key);
+  PR_Free(EntryInfo2.key);
+  return highIndex;
+}
+
+nsMsgViewIndex nsMsgDBView::GetInsertIndex(nsIMsgDBHdr *msgHdr)
+{
+  if (!GetSize())
+    return 0;
+
+  if ((m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay) != 0
+        && !(m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+        && m_sortOrder != nsMsgViewSortType::byId)
+    return GetIndexForThread(msgHdr);
+
+  return GetInsertIndexHelper(msgHdr, m_keys, GetFolders(), m_sortOrder, m_sortType);
+}
+
+nsresult  nsMsgDBView::AddHdr(nsIMsgDBHdr *msgHdr, nsMsgViewIndex *resultIndex)
+{
+  uint32_t  flags = 0;
+#ifdef DEBUG_bienvenu
+  NS_ASSERTION(m_keys.Length() == m_flags.Length() && (int) m_keys.Length() == m_levels.Length(), "view arrays out of sync!");
+#endif
+
+  if (resultIndex)
+    *resultIndex = nsMsgViewIndex_None;
+
+  if (!GetShowingIgnored())
+  {
+    nsCOMPtr <nsIMsgThread> thread;
+    GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(thread));
+    if (thread)
+    {
+      thread->GetFlags(&flags);
+      if (flags & nsMsgMessageFlags::Ignored)
+        return NS_OK;
+    }
+
+    bool ignored;
+    msgHdr->GetIsKilled(&ignored);
+    if (ignored)
+       return NS_OK;
+  }
+
+  nsMsgKey msgKey, threadId;
+  nsMsgKey threadParent;
+  msgHdr->GetMessageKey(&msgKey);
+  msgHdr->GetThreadId(&threadId);
+  msgHdr->GetThreadParent(&threadParent);
+
+  msgHdr->GetFlags(&flags);
+  // ### this isn't quite right, is it? Should be checking that our thread parent key is none?
+  if (threadParent == nsMsgKey_None)
+    flags |= MSG_VIEW_FLAG_ISTHREAD;
+  nsMsgViewIndex insertIndex = GetInsertIndex(msgHdr);
+  if (insertIndex == nsMsgViewIndex_None)
+  {
+    // if unreadonly, level is 0 because we must be the only msg in the thread.
+    int32_t levelToAdd = 0;
+
+    if (m_sortOrder == nsMsgViewSortOrder::ascending)
+    {
+      InsertMsgHdrAt(GetSize(), msgHdr, msgKey, flags, levelToAdd);
+      if (resultIndex)
+        *resultIndex = GetSize() - 1;
+
+      // the call to NoteChange() has to happen after we add the key
+      // as NoteChange() will call RowCountChanged() which will call our GetRowCount()
+      NoteChange(GetSize() - 1, 1, nsMsgViewNotificationCode::insertOrDelete);
+    }
+    else
+    {
+      InsertMsgHdrAt(0, msgHdr, msgKey, flags, levelToAdd);
+      if (resultIndex)
+        *resultIndex = 0;
+
+      // the call to NoteChange() has to happen after we insert the key
+      // as NoteChange() will call RowCountChanged() which will call our GetRowCount()
+      NoteChange(0, 1, nsMsgViewNotificationCode::insertOrDelete);
+    }
+    m_sortValid = false;
+  }
+  else
+  {
+    InsertMsgHdrAt(insertIndex, msgHdr, msgKey, flags, 0);
+    if (resultIndex)
+      *resultIndex = insertIndex;
+    // the call to NoteChange() has to happen after we add the key
+    // as NoteChange() will call RowCountChanged() which will call our GetRowCount()
+    NoteChange(insertIndex, 1, nsMsgViewNotificationCode::insertOrDelete);
+  }
+  OnHeaderAddedOrDeleted();
+  return NS_OK;
+}
+
+bool nsMsgDBView::WantsThisThread(nsIMsgThread * /*threadHdr*/)
+{
+  return true; // default is to want all threads.
+}
+
+nsMsgViewIndex nsMsgDBView::FindParentInThread(nsMsgKey parentKey, nsMsgViewIndex startOfThreadViewIndex)
+{
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  while (parentKey != nsMsgKey_None)
+  {
+    nsMsgViewIndex parentIndex = m_keys.IndexOf(parentKey, startOfThreadViewIndex);
+    if (parentIndex != nsMsgViewIndex_None)
+      return parentIndex;
+
+    if (NS_FAILED(m_db->GetMsgHdrForKey(parentKey, getter_AddRefs(msgHdr))))
+      break;
+
+    msgHdr->GetThreadParent(&parentKey);
+  }
+
+  return startOfThreadViewIndex;
+}
+
+nsresult nsMsgDBView::ListIdsInThreadOrder(nsIMsgThread *threadHdr, nsMsgKey parentKey,
+                                           uint32_t level, nsMsgViewIndex *viewIndex,
+                                           uint32_t *pNumListed)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr <nsISimpleEnumerator> msgEnumerator;
+  threadHdr->EnumerateMessages(parentKey, getter_AddRefs(msgEnumerator));
+  uint32_t numChildren;
+  (void) threadHdr->GetNumChildren(&numChildren);
+  NS_ASSERTION(numChildren, "Empty thread in view/db");
+  if (!numChildren)
+    return NS_OK;  // bogus, but harmless.
+
+  numChildren--; // account for the existing thread root
+
+  // skip the first one.
+  bool hasMore;
+  nsCOMPtr <nsISupports> supports;
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  while (NS_SUCCEEDED(rv) && NS_SUCCEEDED(rv = msgEnumerator->HasMoreElements(&hasMore)) && hasMore)
+  {
+    rv = msgEnumerator->GetNext(getter_AddRefs(supports));
+    if (NS_SUCCEEDED(rv) && supports)
+    {
+      if (*pNumListed == numChildren)
+      {
+        NS_NOTREACHED("thread corrupt in db");
+        // if we've listed more messages than are in the thread, then the db
+        // is corrupt, and we should invalidate it.
+        // we'll use this rv to indicate there's something wrong with the db
+        // though for now it probably won't get paid attention to.
+        m_db->SetSummaryValid(false);
+        rv = NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE;
+        break;
+      }
+
+      msgHdr = do_QueryInterface(supports);
+      if (!(m_viewFlags & nsMsgViewFlagsType::kShowIgnored))
+      {
+        bool ignored;
+        msgHdr->GetIsKilled(&ignored);
+        // We are not going to process subthreads, horribly invalidating the
+        // numChildren characteristic
+        if (ignored)
+          continue;
+      }
+
+      nsMsgKey msgKey;
+      uint32_t msgFlags, newFlags;
+      msgHdr->GetMessageKey(&msgKey);
+      msgHdr->GetFlags(&msgFlags);
+      AdjustReadFlag(msgHdr, &msgFlags);
+      SetMsgHdrAt(msgHdr, *viewIndex, msgKey, msgFlags & ~MSG_VIEW_FLAGS, level);
+      // turn off thread or elided bit if they got turned on (maybe from new only view?)
+      msgHdr->AndFlags(~(MSG_VIEW_FLAG_ISTHREAD | nsMsgMessageFlags::Elided), &newFlags);
+      (*pNumListed)++;
+      (*viewIndex)++;
+      rv = ListIdsInThreadOrder(threadHdr, msgKey, level + 1, viewIndex, pNumListed);
+    }
+  }
+  return rv; // we don't want to return the rv from the enumerator when it reaches the end, do we?
+}
+
+bool nsMsgDBView::InsertEmptyRows(nsMsgViewIndex viewIndex, int32_t numRows)
+{
+  return m_keys.InsertElementsAt(viewIndex, numRows, 0) &&
+         m_flags.InsertElementsAt(viewIndex, numRows, 0) &&
+         m_levels.InsertElementsAt(viewIndex, numRows, 1);
+}
+
+void nsMsgDBView::RemoveRows(nsMsgViewIndex viewIndex, int32_t numRows)
+{
+  m_keys.RemoveElementsAt(viewIndex, numRows);
+  m_flags.RemoveElementsAt(viewIndex, numRows);
+  m_levels.RemoveElementsAt(viewIndex, numRows);
+}
+
+NS_IMETHODIMP nsMsgDBView::InsertTreeRows(nsMsgViewIndex aIndex,
+                                          uint32_t aNumRows,
+                                          nsMsgKey aKey,
+                                          nsMsgViewFlagsTypeValue aFlags,
+                                          uint32_t aLevel,
+                                          nsIMsgFolder *aFolder)
+{
+  if (GetSize() < aIndex)
+    return NS_ERROR_UNEXPECTED;
+
+  nsCOMArray<nsIMsgFolder> *folders = GetFolders();
+  if (folders)
+  {
+    // In a search/xfvf view only, a folder is required.
+    NS_ENSURE_ARG_POINTER(aFolder);
+    for (size_t i = 0; i < aNumRows; i++)
+      // Insert into m_folders.
+      if (!folders->InsertObjectAt(aFolder, aIndex + i))
+        return NS_ERROR_UNEXPECTED;
+  }
+
+  if (m_keys.InsertElementsAt(aIndex, aNumRows, aKey) &&
+      m_flags.InsertElementsAt(aIndex, aNumRows, aFlags) &&
+      m_levels.InsertElementsAt(aIndex, aNumRows, aLevel))
+    return NS_OK;
+
+  return NS_ERROR_UNEXPECTED;
+}
+
+NS_IMETHODIMP nsMsgDBView::RemoveTreeRows(nsMsgViewIndex aIndex,
+                                          uint32_t aNumRows)
+{
+  // Prevent a crash if attempting to remove rows which don't exist.
+  if (GetSize() < aIndex + aNumRows)
+    return NS_ERROR_UNEXPECTED;
+
+  nsMsgDBView::RemoveRows(aIndex, aNumRows);
+
+  nsCOMArray<nsIMsgFolder> *folders = GetFolders();
+  if (folders)
+    // In a search/xfvf view only, remove from m_folders.
+    if (!folders->RemoveObjectsAt(aIndex, aNumRows))
+      return NS_ERROR_UNEXPECTED;
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::ListIdsInThread(nsIMsgThread *threadHdr, nsMsgViewIndex startOfThreadViewIndex, uint32_t *pNumListed)
+{
+  NS_ENSURE_ARG(threadHdr);
+  // these children ids should be in thread order.
+  nsresult rv = NS_OK;
+  uint32_t i;
+  nsMsgViewIndex viewIndex = startOfThreadViewIndex + 1;
+  *pNumListed = 0;
+
+  uint32_t numChildren;
+  threadHdr->GetNumChildren(&numChildren);
+  NS_ASSERTION(numChildren, "Empty thread in view/db");
+  if (!numChildren)
+    return NS_OK;
+
+  numChildren--; // account for the existing thread root
+  if (!InsertEmptyRows(viewIndex, numChildren))
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  // ### need to rework this when we implemented threading in group views.
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay && ! (m_viewFlags & nsMsgViewFlagsType::kGroupBySort))
+  {
+    nsMsgKey parentKey = m_keys[startOfThreadViewIndex];
+    // If the thread is bigger than the hdr cache, expanding the thread
+    // can be slow. Increasing the hdr cache size will help a fair amount.
+    uint32_t hdrCacheSize;
+    m_db->GetMsgHdrCacheSize(&hdrCacheSize);
+    if (numChildren > hdrCacheSize)
+      m_db->SetMsgHdrCacheSize(numChildren);
+    // If this fails, *pNumListed will be 0, and we'll fall back to just
+    // enumerating the messages in the thread below.
+    rv = ListIdsInThreadOrder(threadHdr, parentKey, 1, &viewIndex, pNumListed);
+    if (numChildren > hdrCacheSize)
+      m_db->SetMsgHdrCacheSize(hdrCacheSize);
+  }
+  if (! *pNumListed)
+  {
+    uint32_t ignoredHeaders = 0;
+    // if we're not threaded, just list em out in db order
+    for (i = 1; i <= numChildren; i++)
+    {
+      nsCOMPtr <nsIMsgDBHdr> msgHdr;
+      threadHdr->GetChildHdrAt(i, getter_AddRefs(msgHdr));
+
+      if (msgHdr != nullptr)
+      {
+        if (!(m_viewFlags & nsMsgViewFlagsType::kShowIgnored))
+        {
+          bool killed;
+          msgHdr->GetIsKilled(&killed);
+          if (killed)
+          {
+            ignoredHeaders++;
+            continue;
+          }
+        }
+
+        nsMsgKey msgKey;
+        uint32_t msgFlags, newFlags;
+        msgHdr->GetMessageKey(&msgKey);
+        msgHdr->GetFlags(&msgFlags);
+        AdjustReadFlag(msgHdr, &msgFlags);
+        SetMsgHdrAt(msgHdr, viewIndex, msgKey, msgFlags & ~MSG_VIEW_FLAGS, 1);
+        // here, we're either flat, or we're grouped - in either case, level is 1
+        // turn off thread or elided bit if they got turned on (maybe from new only view?)
+        if (i > 0)
+          msgHdr->AndFlags(~(MSG_VIEW_FLAG_ISTHREAD | nsMsgMessageFlags::Elided), &newFlags);
+        (*pNumListed)++;
+        viewIndex++;
+      }
+    }
+    if (ignoredHeaders + *pNumListed < numChildren)
+    {
+      NS_NOTREACHED("thread corrupt in db");
+      // if we've listed fewer messages than are in the thread, then the db
+      // is corrupt, and we should invalidate it.
+      // we'll use this rv to indicate there's something wrong with the db
+      // though for now it probably won't get paid attention to.
+      m_db->SetSummaryValid(false);
+      rv = NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE;
+    }
+  }
+
+  // We may have added too many elements (i.e., subthreads were cut)
+  // ### fix for cross folder view case.
+  if (*pNumListed < numChildren)
+    RemoveRows(viewIndex, numChildren - *pNumListed);
+  return rv;
+}
+
+int32_t nsMsgDBView::FindLevelInThread(nsIMsgDBHdr *msgHdr, nsMsgViewIndex startOfThread, nsMsgViewIndex viewIndex)
+{
+  nsCOMPtr <nsIMsgDBHdr> curMsgHdr = msgHdr;
+  nsMsgKey msgKey;
+  msgHdr->GetMessageKey(&msgKey);
+
+  // look through the ancestors of the passed in msgHdr in turn, looking for them in the view, up to the start of
+  // the thread. If we find an ancestor, then our level is one greater than the level of the ancestor.
+  while (curMsgHdr)
+  {
+    nsMsgKey parentKey;
+    curMsgHdr->GetThreadParent(&parentKey);
+    if (parentKey == nsMsgKey_None)
+      break;
+
+    // scan up to find view index of ancestor, if any
+    for (nsMsgViewIndex indexToTry = viewIndex; indexToTry && indexToTry-- >= startOfThread;)
+    {
+      if (m_keys[indexToTry] == parentKey)
+        return m_levels[indexToTry] + 1;
+    }
+
+    // if msgHdr's key is its parentKey, we'll loop forever, so protect
+    // against that corruption.
+    if (msgKey == parentKey || NS_FAILED(m_db->GetMsgHdrForKey(parentKey, getter_AddRefs(curMsgHdr))))
+    {
+      NS_ERROR("msgKey == parentKey, or GetMsgHdrForKey failed, this used to be an infinte loop condition");
+      curMsgHdr = nullptr;
+    }
+    else
+    {
+      // need to update msgKey so the check for a msgHdr with matching
+      // key+parentKey will work after first time through loop
+      curMsgHdr->GetMessageKey(&msgKey);
+    }
+  }
+  return 1;
+}
+
+// ### Can this be combined with GetIndexForThread??
+nsMsgViewIndex
+nsMsgDBView::GetThreadRootIndex(nsIMsgDBHdr *msgHdr)
+{
+  if (!msgHdr)
+  {
+    NS_WARNING("null msgHdr parameter");
+    return nsMsgViewIndex_None;
+  }
+
+  // Take advantage of the fact that we're already sorted
+  // and find the thread root via a binary search.
+
+  nsMsgViewIndex highIndex = m_keys.Length();
+  nsMsgViewIndex lowIndex = 0;
+  IdKeyPtr EntryInfo1, EntryInfo2;
+  EntryInfo1.key = nullptr;
+  EntryInfo2.key = nullptr;
+
+  nsresult rv;
+  uint16_t maxLen;
+  eFieldType fieldType;
+
+  // Get the custom column handler for the primary sort and pass it first
+  // to GetFieldTypeAndLenForSort to get the fieldType and then either
+  // GetCollationKey or GetLongField.
+  nsIMsgCustomColumnHandler* colHandler = GetCurColumnHandler();
+
+  // The following may leave fieldType undefined.
+  // In this case, we can return highIndex right away since
+  // it is the value returned in the default case of
+  // switch (fieldType) statement below.
+  rv = GetFieldTypeAndLenForSort(m_sortType, &maxLen, &fieldType, colHandler);
+  NS_ENSURE_SUCCESS(rv, highIndex);
+
+  const void *pValue1 = &EntryInfo1, *pValue2 = &EntryInfo2;
+
+  int retStatus = 0;
+  msgHdr->GetMessageKey(&EntryInfo1.id);
+  msgHdr->GetFolder(&EntryInfo1.folder);
+  EntryInfo1.folder->Release();
+
+  viewSortInfo comparisonContext;
+  comparisonContext.view = this;
+  comparisonContext.isSecondarySort = false;
+  comparisonContext.ascendingSort = (m_sortOrder == nsMsgViewSortOrder::ascending);
+  nsCOMPtr<nsIMsgDatabase> hdrDB;
+  EntryInfo1.folder->GetMsgDatabase(getter_AddRefs(hdrDB));
+  comparisonContext.db = hdrDB.get();
+  switch (fieldType)
+  {
+    case kCollationKey:
+      rv = GetCollationKey(msgHdr, m_sortType, &EntryInfo1.key, &EntryInfo1.dword, colHandler);
+      NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create collation key");
+      break;
+    case kU32:
+      if (m_sortType == nsMsgViewSortType::byId)
+        EntryInfo1.dword = EntryInfo1.id;
+      else
+        GetLongField(msgHdr, m_sortType, &EntryInfo1.dword, colHandler);
+      break;
+    default:
+      return highIndex;
+  }
+  while (highIndex > lowIndex)
+  {
+    nsMsgViewIndex tryIndex = (lowIndex + highIndex) / 2;
+    // need to adjust tryIndex if it's not a thread.
+    while (m_levels[tryIndex] && tryIndex)
+      tryIndex--;
+
+    if (tryIndex < lowIndex)
+    {
+      NS_ERROR("try index shouldn't be less than low index");
+      break;
+    }
+    EntryInfo2.id = m_keys[tryIndex];
+    GetFolderForViewIndex(tryIndex, &EntryInfo2.folder);
+    EntryInfo2.folder->Release();
+
+    nsCOMPtr<nsIMsgDBHdr> tryHdr;
+    nsCOMPtr<nsIMsgDatabase> db;
+    // ### this should get the db from the folder...
+    GetDBForViewIndex(tryIndex, getter_AddRefs(db));
+    if (db)
+      rv = db->GetMsgHdrForKey(EntryInfo2.id, getter_AddRefs(tryHdr));
+    if (!tryHdr)
+      break;
+    if (tryHdr == msgHdr)
+    {
+      highIndex = tryIndex;
+      break;
+    }
+    if (fieldType == kCollationKey)
+    {
+      PR_FREEIF(EntryInfo2.key);
+      rv = GetCollationKey(tryHdr, m_sortType, &EntryInfo2.key, &EntryInfo2.dword, colHandler);
+      NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create collation key");
+      retStatus = FnSortIdKeyPtr(&pValue1, &pValue2, &comparisonContext);
+    }
+    else if (fieldType == kU32)
+    {
+      if (m_sortType == nsMsgViewSortType::byId)
+        EntryInfo2.dword = EntryInfo2.id;
+      else
+        GetLongField(tryHdr, m_sortType, &EntryInfo2.dword, colHandler);
+      retStatus = FnSortIdUint32(&pValue1, &pValue2, &comparisonContext);
+    }
+    if (retStatus == 0)
+    {
+      highIndex = tryIndex;
+      break;
+    }
+
+    if (retStatus < 0)
+    {
+      highIndex = tryIndex;
+      // we already made sure tryIndex was at a thread at the top of the loop.
+    }
+    else
+    {
+      lowIndex = tryIndex + 1;
+      while (lowIndex < GetSize() && m_levels[lowIndex])
+        lowIndex++;
+    }
+  }
+
+  nsCOMPtr<nsIMsgDBHdr> resultHdr;
+  GetMsgHdrForViewIndex(highIndex, getter_AddRefs(resultHdr));
+
+  if (resultHdr != msgHdr)
+  {
+    NS_WARNING("didn't find hdr");
+    highIndex = FindHdr(msgHdr);
+#ifdef DEBUG_David_Bienvenu
+    if (highIndex != nsMsgViewIndex_None)
+    {
+      NS_WARNING("but find hdr did");
+      printf("level of found hdr = %d\n", m_levels[highIndex]);
+      ValidateSort();
+    }
+#endif
+    return highIndex;
+  }
+  PR_Free(EntryInfo1.key);
+  PR_Free(EntryInfo2.key);
+  return msgHdr == resultHdr ? highIndex : nsMsgViewIndex_None;
+}
+
+#ifdef DEBUG_David_Bienvenu
+
+void nsMsgDBView::InitEntryInfoForIndex(nsMsgViewIndex i, IdKeyPtr &EntryInfo)
+{
+  EntryInfo.key = nullptr;
+
+  nsresult rv;
+  uint16_t maxLen;
+  eFieldType fieldType;
+
+  // Get the custom column handler for the primary sort and pass it first
+  // to GetFieldTypeAndLenForSort to get the fieldType and then either
+  // GetCollationKey or GetLongField.
+  nsIMsgCustomColumnHandler* colHandler = GetCurColumnHandler();
+
+  // The following may leave fieldType undefined.
+  rv = GetFieldTypeAndLenForSort(m_sortType, &maxLen, &fieldType, colHandler);
+  NS_ASSERTION(NS_SUCCEEDED(rv),"failed to obtain fieldType");
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  GetMsgHdrForViewIndex(i, getter_AddRefs(msgHdr));
+
+  msgHdr->GetMessageKey(&EntryInfo.id);
+  msgHdr->GetFolder(&EntryInfo.folder);
+  EntryInfo.folder->Release();
+
+  nsCOMPtr<nsIMsgDatabase> hdrDB;
+  EntryInfo.folder->GetMsgDatabase(getter_AddRefs(hdrDB));
+  switch (fieldType)
+  {
+    case kCollationKey:
+      PR_FREEIF(EntryInfo.key);
+      rv = GetCollationKey(msgHdr, m_sortType, &EntryInfo.key, &EntryInfo.dword, colHandler);
+      NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create collation key");
+      break;
+    case kU32:
+      if (m_sortType == nsMsgViewSortType::byId)
+        EntryInfo.dword = EntryInfo.id;
+      else
+        GetLongField(msgHdr, m_sortType, &EntryInfo.dword, colHandler);
+      break;
+    default:
+      NS_ERROR("invalid field type");
+  }
+}
+
+void nsMsgDBView::ValidateSort()
+{
+  IdKeyPtr EntryInfo1, EntryInfo2;
+  nsCOMPtr<nsIMsgDBHdr> hdr1, hdr2;
+
+  uint16_t  maxLen;
+  eFieldType fieldType;
+
+  // Get the custom column handler for the primary sort and pass it first
+  // to GetFieldTypeAndLenForSort to get the fieldType and then either
+  // GetCollationKey or GetLongField.
+  nsIMsgCustomColumnHandler* colHandler = GetCurColumnHandler();
+
+  // It is not entirely clear what we should do since,
+  // if fieldType is not available, there is no way to know
+  // how to compare the field to check for sorting.
+  // So we bomb out here. It is OK since this is debug code
+  // inside  #ifdef DEBUG_David_Bienvenu
+  rv = GetFieldTypeAndLenForSort(m_sortType, &maxLen, &fieldType, colHandler);
+  NS_ASSERTION(NS_SUCCEEDED(rv),"failed to obtain fieldType");
+
+  viewSortInfo comparisonContext;
+  comparisonContext.view = this;
+  comparisonContext.isSecondarySort = false;
+  comparisonContext.ascendingSort = (m_sortOrder == nsMsgViewSortOrder::ascending);
+  nsCOMPtr<nsIMsgDatabase> db;
+  GetDBForViewIndex(0, getter_AddRefs(db));
+  // this is only for comparing collation keys - it could be any db.
+  comparisonContext.db = db.get();
+
+  for (nsMsgViewIndex i = 0; i < m_keys.Length();)
+  {
+    // ignore non threads
+    if (m_levels[i])
+    {
+      i++;
+      continue;
+    }
+
+    // find next header.
+    nsMsgViewIndex j = i + 1;
+    while (j < m_keys.Length() && m_levels[j])
+      j++;
+    if (j == m_keys.Length())
+      break;
+
+    InitEntryInfoForIndex(i, EntryInfo1);
+    InitEntryInfoForIndex(j, EntryInfo2);
+    const void *pValue1 = &EntryInfo1, *pValue2 = &EntryInfo2;
+    int retStatus = 0;
+    if (fieldType == kCollationKey)
+      retStatus = FnSortIdKeyPtr(&pValue1, &pValue2, &comparisonContext);
+    else if (fieldType == kU32)
+      retStatus = FnSortIdUint32(&pValue1, &pValue2, &comparisonContext);
+
+    if (retStatus && (retStatus < 0) == (m_sortOrder == nsMsgViewSortOrder::ascending))
+    {
+      NS_ERROR("view not sorted correctly");
+      break;
+    }
+    // j is the new i.
+    i = j;
+  }
+}
+
+#endif
+
+nsresult nsMsgDBView::ListUnreadIdsInThread(nsIMsgThread *threadHdr, nsMsgViewIndex startOfThreadViewIndex, uint32_t *pNumListed)
+{
+  NS_ENSURE_ARG(threadHdr);
+  // these children ids should be in thread order.
+  nsMsgViewIndex viewIndex = startOfThreadViewIndex + 1;
+  *pNumListed = 0;
+  nsMsgKey topLevelMsgKey = m_keys[startOfThreadViewIndex];
+
+  uint32_t numChildren;
+  threadHdr->GetNumChildren(&numChildren);
+  uint32_t i;
+  for (i = 0; i < numChildren; i++)
+  {
+    nsCOMPtr <nsIMsgDBHdr> msgHdr;
+    threadHdr->GetChildHdrAt(i, getter_AddRefs(msgHdr));
+    if (msgHdr != nullptr)
+    {
+      if (!(m_viewFlags & nsMsgViewFlagsType::kShowIgnored))
+      {
+        bool killed;
+        msgHdr->GetIsKilled(&killed);
+        if (killed)
+          continue;
+      }
+
+      nsMsgKey msgKey;
+      uint32_t msgFlags;
+      msgHdr->GetMessageKey(&msgKey);
+      msgHdr->GetFlags(&msgFlags);
+      bool isRead = AdjustReadFlag(msgHdr, &msgFlags);
+      if (!isRead)
+      {
+        // just make sure flag is right in db.
+        m_db->MarkHdrRead(msgHdr, false, nullptr);
+        if (msgKey != topLevelMsgKey)
+        {
+          InsertMsgHdrAt(viewIndex, msgHdr, msgKey, msgFlags,
+                FindLevelInThread(msgHdr, startOfThreadViewIndex, viewIndex));
+          viewIndex++;
+          (*pNumListed)++;
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::OnHdrFlagsChanged(nsIMsgDBHdr *aHdrChanged, uint32_t aOldFlags,
+                                       uint32_t aNewFlags, nsIDBChangeListener *aInstigator)
+{
+  // if we're not the instigator, update flags if this key is in our view
+  if (aInstigator != this)
+  {
+    NS_ENSURE_ARG_POINTER(aHdrChanged);
+    nsMsgKey msgKey;
+    aHdrChanged->GetMessageKey(&msgKey);
+    nsMsgViewIndex index = FindHdr(aHdrChanged);
+    if (index != nsMsgViewIndex_None)
+    {
+      uint32_t viewOnlyFlags = m_flags[index] & (MSG_VIEW_FLAGS | nsMsgMessageFlags::Elided);
+
+      // ### what about saving the old view only flags, like IsThread and HasChildren?
+      // I think we'll want to save those away.
+      m_flags[index] = aNewFlags | viewOnlyFlags;
+      // tell the view the extra flag changed, so it can
+      // update the previous view, if any.
+      OnExtraFlagChanged(index, aNewFlags);
+      NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+    }
+
+    uint32_t deltaFlags = (aOldFlags ^ aNewFlags);
+    if (deltaFlags & (nsMsgMessageFlags::Read | nsMsgMessageFlags::New))
+    {
+      nsMsgViewIndex threadIndex =
+            ThreadIndexOfMsgHdr(aHdrChanged, index, nullptr, nullptr);
+      // may need to fix thread counts
+      if (threadIndex != nsMsgViewIndex_None && threadIndex != index)
+        NoteChange(threadIndex, 1, nsMsgViewNotificationCode::changed);
+    }
+ }
+  // don't need to propagate notifications, right?
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::OnHdrDeleted(nsIMsgDBHdr *aHdrChanged,
+                                        nsMsgKey aParentKey,
+                                        int32_t aFlags,
+                                        nsIDBChangeListener *aInstigator)
+{
+  nsMsgViewIndex deletedIndex = FindHdr(aHdrChanged);
+  if (IsValidIndex(deletedIndex))
+  {
+    // Check if this message is currently selected. If it is, tell the frontend
+    // to be prepared for a delete.
+    if (mTreeSelection && mCommandUpdater)
+    {
+      bool isMsgSelected = false;
+      mTreeSelection->IsSelected(deletedIndex, &isMsgSelected);
+      if (isMsgSelected)
+        mCommandUpdater->UpdateNextMessageAfterDelete();
+    }
+
+    RemoveByIndex(deletedIndex);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::OnHdrAdded(nsIMsgDBHdr *aHdrChanged, nsMsgKey aParentKey, int32_t aFlags,
+                          nsIDBChangeListener *aInstigator)
+{
+  return OnNewHeader(aHdrChanged, aParentKey, false);
+  // probably also want to pass that parent key in, since we went to the trouble
+  // of figuring out what it is.
+}
+
+NS_IMETHODIMP
+nsMsgDBView::OnHdrPropertyChanged(nsIMsgDBHdr *aHdrToChange, bool aPreChange, uint32_t *aStatus,
+                                 nsIDBChangeListener * aInstigator)
+{
+  if (aPreChange)
+    return NS_OK;
+
+  if (aHdrToChange)
+  {
+    nsMsgViewIndex index = FindHdr(aHdrToChange);
+    if (index != nsMsgViewIndex_None)
+      NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::OnParentChanged (nsMsgKey aKeyChanged, nsMsgKey oldParent, nsMsgKey newParent, nsIDBChangeListener *aInstigator)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::OnAnnouncerGoingAway(nsIDBChangeAnnouncer *instigator)
+{
+  if (m_db)
+  {
+    m_db->RemoveListener(this);
+    m_db = nullptr;
+  }
+
+  int32_t saveSize = GetSize();
+  ClearHdrCache();
+
+  // this is important, because the tree will ask us for our
+  // row count, which get determine from the number of keys.
+  m_keys.Clear();
+  // be consistent
+  m_flags.Clear();
+  m_levels.Clear();
+
+  // tell the tree all the rows have gone away
+  if (mTree)
+    mTree->RowCountChanged(0, -saveSize);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::OnEvent(nsIMsgDatabase *aDB, const char *aEvent)
+{
+  if (!strcmp(aEvent, "DBOpened"))
+    m_db = aDB;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMsgDBView::OnReadChanged(nsIDBChangeListener *aInstigator)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::OnJunkScoreChanged(nsIDBChangeListener *aInstigator)
+{
+  return NS_OK;
+}
+
+void nsMsgDBView::ClearHdrCache()
+{
+  m_cachedHdr = nullptr;
+  m_cachedMsgKey = nsMsgKey_None;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetSuppressChangeNotifications(bool aSuppressChangeNotifications)
+{
+  mSuppressChangeNotification = aSuppressChangeNotifications;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSuppressChangeNotifications(bool * aSuppressChangeNotifications)
+{
+  NS_ENSURE_ARG_POINTER(aSuppressChangeNotifications);
+  *aSuppressChangeNotifications = mSuppressChangeNotification;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::NoteChange(nsMsgViewIndex firstLineChanged,
+                                      int32_t numChanged,
+                                      nsMsgViewNotificationCodeValue changeType)
+{
+  if (mTree && !mSuppressChangeNotification)
+  {
+    switch (changeType)
+    {
+    case nsMsgViewNotificationCode::changed:
+      mTree->InvalidateRange(firstLineChanged, firstLineChanged + numChanged - 1);
+      break;
+    case nsMsgViewNotificationCode::insertOrDelete:
+      if (numChanged < 0)
+        mRemovingRow = true;
+      // the caller needs to have adjusted m_keys before getting here, since
+      // RowCountChanged() will call our GetRowCount()
+      mTree->RowCountChanged(firstLineChanged, numChanged);
+      mRemovingRow = false;
+      MOZ_FALLTHROUGH;
+    case nsMsgViewNotificationCode::all:
+      ClearHdrCache();
+      break;
+    }
+  }
+  return NS_OK;
+}
+
+void nsMsgDBView::NoteStartChange(nsMsgViewIndex firstlineChanged, int32_t numChanged,
+                                  nsMsgViewNotificationCodeValue changeType)
+{
+}
+void nsMsgDBView::NoteEndChange(nsMsgViewIndex firstlineChanged, int32_t numChanged,
+                                nsMsgViewNotificationCodeValue changeType)
+{
+  // send the notification now.
+  NoteChange(firstlineChanged, numChanged, changeType);
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSortOrder(nsMsgViewSortOrderValue *aSortOrder)
+{
+    NS_ENSURE_ARG_POINTER(aSortOrder);
+    *aSortOrder = m_sortOrder;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSortType(nsMsgViewSortTypeValue *aSortType)
+{
+    NS_ENSURE_ARG_POINTER(aSortType);
+    *aSortType = m_sortType;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetSortType(nsMsgViewSortTypeValue aSortType)
+{
+    m_sortType = aSortType;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMsgDBView::GetViewType(nsMsgViewTypeValue *aViewType)
+{
+    NS_ERROR("you should be overriding this");
+    return NS_ERROR_UNEXPECTED;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSecondarySortOrder(nsMsgViewSortOrderValue *aSortOrder)
+{
+    NS_ENSURE_ARG_POINTER(aSortOrder);
+    *aSortOrder = m_secondarySortOrder;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetSecondarySortOrder(nsMsgViewSortOrderValue aSortOrder)
+{
+    m_secondarySortOrder = aSortOrder;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetSecondarySortType(nsMsgViewSortTypeValue *aSortType)
+{
+    NS_ENSURE_ARG_POINTER(aSortType);
+    *aSortType = m_secondarySort;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetSecondarySortType(nsMsgViewSortTypeValue aSortType)
+{
+    m_secondarySort = aSortType;
+    return NS_OK;
+}
+
+nsresult nsMsgDBView::PersistFolderInfo(nsIDBFolderInfo **dbFolderInfo)
+{
+  nsresult rv = m_db->GetDBFolderInfo(dbFolderInfo);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // save off sort type and order, view type and flags
+  (*dbFolderInfo)->SetSortType(m_sortType);
+  (*dbFolderInfo)->SetSortOrder(m_sortOrder);
+  (*dbFolderInfo)->SetViewFlags(m_viewFlags);
+  nsMsgViewTypeValue viewType;
+  GetViewType(&viewType);
+  (*dbFolderInfo)->SetViewType(viewType);
+  return rv;
+}
+
+
+NS_IMETHODIMP nsMsgDBView::GetViewFlags(nsMsgViewFlagsTypeValue *aViewFlags)
+{
+    NS_ENSURE_ARG_POINTER(aViewFlags);
+    *aViewFlags = m_viewFlags;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetViewFlags(nsMsgViewFlagsTypeValue aViewFlags)
+{
+  // if we're turning off threaded display, we need to expand all so that all
+  // messages will be displayed.
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay && ! (aViewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+  {
+    ExpandAll();
+    m_sortValid = false; // invalidate the sort so sorting will do something
+  }
+  m_viewFlags = aViewFlags;
+
+  if (m_viewFolder)
+  {
+    nsCOMPtr <nsIMsgDatabase> db;
+    nsCOMPtr <nsIDBFolderInfo> folderInfo;
+    nsresult rv = m_viewFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(db));
+    NS_ENSURE_SUCCESS(rv,rv);
+    return folderInfo->SetViewFlags(aViewFlags);
+  }
+  else
+    return NS_OK;
+}
+
+nsresult nsMsgDBView::MarkThreadOfMsgRead(nsMsgKey msgId, nsMsgViewIndex msgIndex, nsTArray<nsMsgKey> &idsMarkedRead, bool bRead)
+{
+    nsCOMPtr <nsIMsgThread> threadHdr;
+    nsresult rv = GetThreadContainingIndex(msgIndex, getter_AddRefs(threadHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsMsgViewIndex threadIndex;
+
+    NS_ASSERTION(threadHdr, "threadHdr is null");
+    if (!threadHdr)
+        return NS_MSG_MESSAGE_NOT_FOUND;
+
+    nsCOMPtr<nsIMsgDBHdr> firstHdr;
+    rv = threadHdr->GetChildHdrAt(0, getter_AddRefs(firstHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsMsgKey firstHdrId;
+    firstHdr->GetMessageKey(&firstHdrId);
+    if (msgId != firstHdrId)
+        threadIndex = GetIndexOfFirstDisplayedKeyInThread(threadHdr);
+    else
+        threadIndex = msgIndex;
+    return MarkThreadRead(threadHdr, threadIndex, idsMarkedRead, bRead);
+}
+
+nsresult nsMsgDBView::MarkThreadRead(nsIMsgThread *threadHdr, nsMsgViewIndex threadIndex, nsTArray<nsMsgKey> &idsMarkedRead, bool bRead)
+{
+    uint32_t numChildren;
+    threadHdr->GetNumChildren(&numChildren);
+    idsMarkedRead.SetCapacity(numChildren);
+    for (int32_t childIndex = 0; childIndex < (int32_t) numChildren ; childIndex++)
+    {
+        nsCOMPtr <nsIMsgDBHdr> msgHdr;
+        threadHdr->GetChildHdrAt(childIndex, getter_AddRefs(msgHdr));
+        NS_ASSERTION(msgHdr, "msgHdr is null");
+        if (!msgHdr)
+            continue;
+
+        bool isRead;
+
+        nsMsgKey hdrMsgId;
+        msgHdr->GetMessageKey(&hdrMsgId);
+        nsCOMPtr<nsIMsgDatabase> db;
+        nsresult rv = GetDBForHeader(msgHdr, getter_AddRefs(db));
+        NS_ENSURE_SUCCESS(rv, rv);
+        db->IsRead(hdrMsgId, &isRead);
+
+        if (isRead != bRead)
+        {
+            // MarkHdrRead will change the unread count on the thread
+            db->MarkHdrRead(msgHdr, bRead, nullptr);
+            // insert at the front.  should we insert at the end?
+            idsMarkedRead.InsertElementAt(0, hdrMsgId);
+        }
+    }
+
+    return NS_OK;
+}
+
+bool nsMsgDBView::AdjustReadFlag(nsIMsgDBHdr *msgHdr, uint32_t *msgFlags)
+{
+  // if we're a cross-folder view, just bail on this.
+  if (GetFolders())
+    return *msgFlags & nsMsgMessageFlags::Read;
+  bool isRead = false;
+  nsMsgKey msgKey;
+  msgHdr->GetMessageKey(&msgKey);
+  m_db->IsRead(msgKey, &isRead);
+    // just make sure flag is right in db.
+#ifdef DEBUG_David_Bienvenu
+  NS_ASSERTION(isRead == ((*msgFlags & nsMsgMessageFlags::Read) != 0), "msgFlags out of sync");
+#endif
+  if (isRead)
+    *msgFlags |= nsMsgMessageFlags::Read;
+  else
+    *msgFlags &= ~nsMsgMessageFlags::Read;
+  m_db->MarkHdrRead(msgHdr, isRead, nullptr);
+  return isRead;
+}
+
+// Starting from startIndex, performs the passed in navigation, including
+// any marking read needed, and returns the resultId and resultIndex of the
+// destination of the navigation.  If no message is found in the view,
+// it returns a resultId of nsMsgKey_None and an resultIndex of nsMsgViewIndex_None.
+NS_IMETHODIMP nsMsgDBView::ViewNavigate(nsMsgNavigationTypeValue motion, nsMsgKey *pResultKey, nsMsgViewIndex *pResultIndex, nsMsgViewIndex *pThreadIndex, bool wrap)
+{
+    NS_ENSURE_ARG_POINTER(pResultKey);
+    NS_ENSURE_ARG_POINTER(pResultIndex);
+    NS_ENSURE_ARG_POINTER(pThreadIndex);
+
+    int32_t currentIndex;
+    nsMsgViewIndex startIndex;
+
+    if (!mTreeSelection) // we must be in stand alone message mode
+    {
+      currentIndex = FindViewIndex(m_currentlyDisplayedMsgKey);
+    }
+    else
+    {
+      nsresult rv = mTreeSelection->GetCurrentIndex(&currentIndex);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    startIndex = currentIndex;
+    return nsMsgDBView::NavigateFromPos(motion, startIndex, pResultKey, pResultIndex, pThreadIndex, wrap);
+}
+
+nsresult nsMsgDBView::NavigateFromPos(nsMsgNavigationTypeValue motion, nsMsgViewIndex startIndex, nsMsgKey *pResultKey, nsMsgViewIndex *pResultIndex, nsMsgViewIndex *pThreadIndex, bool wrap)
+{
+    nsresult rv = NS_OK;
+    nsMsgKey resultThreadKey;
+    nsMsgViewIndex curIndex;
+    nsMsgViewIndex lastIndex = (GetSize() > 0) ? (nsMsgViewIndex) GetSize() - 1 : nsMsgViewIndex_None;
+    nsMsgViewIndex threadIndex = nsMsgViewIndex_None;
+
+    // if there aren't any messages in the view, bail out.
+    if (GetSize() <= 0)
+    {
+      *pResultIndex = nsMsgViewIndex_None;
+      *pResultKey = nsMsgKey_None;
+      return NS_OK;
+    }
+
+    switch (motion)
+    {
+        case nsMsgNavigationType::firstMessage:
+            *pResultIndex = 0;
+            *pResultKey = m_keys[0];
+            break;
+        case nsMsgNavigationType::nextMessage:
+            // return same index and id on next on last message
+            *pResultIndex = std::min(startIndex + 1, lastIndex);
+            *pResultKey = m_keys[*pResultIndex];
+            break;
+        case nsMsgNavigationType::previousMessage:
+            *pResultIndex = (startIndex != nsMsgViewIndex_None && startIndex > 0) ? startIndex - 1 : 0;
+            *pResultKey = m_keys[*pResultIndex];
+            break;
+        case nsMsgNavigationType::lastMessage:
+            *pResultIndex = lastIndex;
+            *pResultKey = m_keys[*pResultIndex];
+            break;
+        case nsMsgNavigationType::firstFlagged:
+            rv = FindFirstFlagged(pResultIndex);
+            if (IsValidIndex(*pResultIndex))
+                *pResultKey = m_keys[*pResultIndex];
+            break;
+        case nsMsgNavigationType::nextFlagged:
+            rv = FindNextFlagged(startIndex + 1, pResultIndex);
+            if (IsValidIndex(*pResultIndex))
+                *pResultKey = m_keys[*pResultIndex];
+            break;
+        case nsMsgNavigationType::previousFlagged:
+            rv = FindPrevFlagged(startIndex, pResultIndex);
+            if (IsValidIndex(*pResultIndex))
+                *pResultKey = m_keys[*pResultIndex];
+            break;
+        case nsMsgNavigationType::firstNew:
+            rv = FindFirstNew(pResultIndex);
+            if (IsValidIndex(*pResultIndex))
+                *pResultKey = m_keys[*pResultIndex];
+            break;
+        case nsMsgNavigationType::firstUnreadMessage:
+            startIndex = nsMsgViewIndex_None;        // note fall thru - is this motion ever used?
+            MOZ_FALLTHROUGH;
+        case nsMsgNavigationType::nextUnreadMessage:
+            for (curIndex = (startIndex == nsMsgViewIndex_None) ? 0 : startIndex; curIndex <= lastIndex && lastIndex != nsMsgViewIndex_None; curIndex++) {
+                uint32_t flags = m_flags[curIndex];
+
+                // don't return start index since navigate should move
+                if (!(flags & (nsMsgMessageFlags::Read | MSG_VIEW_FLAG_DUMMY)) && (curIndex != startIndex))
+                {
+                    *pResultIndex = curIndex;
+                    *pResultKey = m_keys[*pResultIndex];
+                    break;
+                }
+                // check for collapsed thread with new children
+                if ((m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay) && flags & MSG_VIEW_FLAG_ISTHREAD && flags & nsMsgMessageFlags::Elided) {
+                    nsCOMPtr <nsIMsgThread> threadHdr;
+                    GetThreadContainingIndex(curIndex, getter_AddRefs(threadHdr));
+                    NS_ENSURE_SUCCESS(rv, rv);
+
+                    NS_ASSERTION(threadHdr, "threadHdr is null");
+                    if (!threadHdr)
+                        continue;
+                    uint32_t numUnreadChildren;
+                    threadHdr->GetNumUnreadChildren(&numUnreadChildren);
+                    if (numUnreadChildren > 0)
+                    {
+                        uint32_t numExpanded;
+                        ExpandByIndex(curIndex, &numExpanded);
+                        lastIndex += numExpanded;
+                        if (pThreadIndex)
+                            *pThreadIndex = curIndex;
+                    }
+                }
+            }
+            if (curIndex > lastIndex)
+            {
+                // wrap around by starting at index 0.
+                if (wrap)
+                {
+                    nsMsgKey startKey = GetAt(startIndex);
+
+                    rv = NavigateFromPos(nsMsgNavigationType::nextUnreadMessage, nsMsgViewIndex_None, pResultKey, pResultIndex, pThreadIndex, false);
+
+                    if (*pResultKey == startKey)
+                    {
+                        // wrapped around and found start message!
+                        *pResultIndex = nsMsgViewIndex_None;
+                        *pResultKey = nsMsgKey_None;
+                    }
+                }
+                else
+                {
+                    *pResultIndex = nsMsgViewIndex_None;
+                    *pResultKey = nsMsgKey_None;
+                }
+            }
+            break;
+        case nsMsgNavigationType::previousUnreadMessage:
+            if (startIndex == nsMsgViewIndex_None)
+              break;
+            rv = FindPrevUnread(m_keys[startIndex], pResultKey,
+                                &resultThreadKey);
+            if (NS_SUCCEEDED(rv))
+            {
+                *pResultIndex = FindViewIndex(*pResultKey);
+                if (*pResultKey != resultThreadKey && (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+                {
+                    threadIndex  = GetThreadIndex(*pResultIndex);
+                    if (*pResultIndex == nsMsgViewIndex_None)
+                    {
+                        nsCOMPtr <nsIMsgThread> threadHdr;
+                        nsCOMPtr <nsIMsgDBHdr> msgHdr;
+                        rv = m_db->GetMsgHdrForKey(*pResultKey, getter_AddRefs(msgHdr));
+                        NS_ENSURE_SUCCESS(rv, rv);
+                        rv = GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(threadHdr));
+                        NS_ENSURE_SUCCESS(rv, rv);
+
+                        NS_ASSERTION(threadHdr, "threadHdr is null");
+                        if (threadHdr)
+                            break;
+                        uint32_t numUnreadChildren;
+                        threadHdr->GetNumUnreadChildren(&numUnreadChildren);
+                        if (numUnreadChildren > 0)
+                        {
+                            uint32_t numExpanded;
+                            ExpandByIndex(threadIndex, &numExpanded);
+                        }
+                        *pResultIndex = FindViewIndex(*pResultKey);
+                    }
+                }
+                if (pThreadIndex)
+                    *pThreadIndex = threadIndex;
+            }
+            break;
+        case nsMsgNavigationType::lastUnreadMessage:
+            break;
+        case nsMsgNavigationType::nextUnreadThread:
+            if (startIndex != nsMsgViewIndex_None)
+              ApplyCommandToIndices(nsMsgViewCommandType::markThreadRead, &startIndex, 1);
+
+            return NavigateFromPos(nsMsgNavigationType::nextUnreadMessage, startIndex, pResultKey, pResultIndex, pThreadIndex, true);
+        case nsMsgNavigationType::toggleThreadKilled:
+            {
+                bool resultKilled;
+                nsMsgViewIndexArray selection;
+                GetSelectedIndices(selection);
+                ToggleIgnored(selection.Elements(), selection.Length(), &threadIndex, &resultKilled);
+                if (resultKilled)
+                {
+                    return NavigateFromPos(nsMsgNavigationType::nextUnreadThread, threadIndex, pResultKey, pResultIndex, pThreadIndex, true);
+                }
+                else
+                {
+                    *pResultIndex = nsMsgViewIndex_None;
+                    *pResultKey = nsMsgKey_None;
+                    return NS_OK;
+                }
+            }
+        case nsMsgNavigationType::toggleSubthreadKilled:
+            {
+                bool resultKilled;
+                nsMsgViewIndexArray selection;
+                GetSelectedIndices(selection);
+                ToggleMessageKilled(selection.Elements(), selection.Length(),
+                    &threadIndex, &resultKilled);
+                if (resultKilled)
+                {
+                    return NavigateFromPos(nsMsgNavigationType::nextUnreadMessage, threadIndex, pResultKey, pResultIndex, pThreadIndex, true);
+                }
+                else
+                {
+                    *pResultIndex = nsMsgViewIndex_None;
+                    *pResultKey = nsMsgKey_None;
+                    return NS_OK;
+                }
+            }
+          // check where navigate says this will take us. If we have the message in the view,
+          // return it. Otherwise, return an error.
+      case nsMsgNavigationType::back:
+      case nsMsgNavigationType::forward:
+        {
+          nsCString folderUri, msgUri;
+          nsCString viewFolderUri;
+          nsCOMPtr<nsIMsgFolder> curFolder = m_viewFolder ? m_viewFolder : m_folder;
+          if (curFolder)
+            curFolder->GetURI(viewFolderUri);
+          int32_t relPos = (motion == nsMsgNavigationType::forward)
+            ? 1 : (m_currentlyDisplayedMsgKey != nsMsgKey_None) ? -1 : 0;
+          int32_t curPos;
+          nsresult rv;
+          nsCOMPtr<nsIMessenger> messenger (do_QueryReferent(mMessengerWeak, &rv));
+          NS_ENSURE_SUCCESS(rv, rv);
+          rv = messenger->GetFolderUriAtNavigatePos(relPos, folderUri);
+          NS_ENSURE_SUCCESS(rv, rv);
+          // Empty viewFolderUri means we're in a search results view.
+          if (viewFolderUri.IsEmpty() || folderUri.Equals(viewFolderUri))
+          {
+            nsCOMPtr <nsIMsgDBHdr> msgHdr;
+            rv = messenger->GetMsgUriAtNavigatePos(relPos, msgUri);
+            NS_ENSURE_SUCCESS(rv, rv);
+            messenger->MsgHdrFromURI(msgUri, getter_AddRefs(msgHdr));
+            if (msgHdr)
+            {
+              messenger->GetNavigatePos(&curPos);
+              curPos += relPos;
+              *pResultIndex = FindHdr(msgHdr);
+              messenger->SetNavigatePos(curPos);
+              msgHdr->GetMessageKey(pResultKey);
+              return NS_OK;
+            }
+          }
+          *pResultIndex = nsMsgViewIndex_None;
+          *pResultKey = nsMsgKey_None;
+          break;
+
+        }
+        default:
+            NS_ERROR("unsupported motion");
+            break;
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::NavigateStatus(nsMsgNavigationTypeValue motion, bool *_retval)
+{
+    NS_ENSURE_ARG_POINTER(_retval);
+
+    bool enable = false;
+    nsresult rv = NS_ERROR_FAILURE;
+    nsMsgKey resultKey = nsMsgKey_None;
+    int32_t index = nsMsgKey_None;
+    nsMsgViewIndex resultIndex = nsMsgViewIndex_None;
+    if (mTreeSelection)
+      (void) mTreeSelection->GetCurrentIndex(&index);
+    else
+      index = FindViewIndex(m_currentlyDisplayedMsgKey);
+    nsCOMPtr<nsIMessenger> messenger (do_QueryReferent(mMessengerWeak));
+    // warning - we no longer validate index up front because fe passes in -1 for no
+    // selection, so if you use index, be sure to validate it before using it
+    // as an array index.
+    switch (motion)
+    {
+        case nsMsgNavigationType::firstMessage:
+        case nsMsgNavigationType::lastMessage:
+            if (GetSize() > 0)
+                enable = true;
+            break;
+        case nsMsgNavigationType::nextMessage:
+            if (IsValidIndex(index) && uint32_t(index) < GetSize() - 1)
+                enable = true;
+            break;
+        case nsMsgNavigationType::previousMessage:
+            if (IsValidIndex(index) && index != 0 && GetSize() > 1)
+                enable = true;
+            break;
+        case nsMsgNavigationType::firstFlagged:
+            rv = FindFirstFlagged(&resultIndex);
+            enable = (NS_SUCCEEDED(rv) && resultIndex != nsMsgViewIndex_None);
+            break;
+        case nsMsgNavigationType::nextFlagged:
+            rv = FindNextFlagged(index + 1, &resultIndex);
+            enable = (NS_SUCCEEDED(rv) && resultIndex != nsMsgViewIndex_None);
+            break;
+        case nsMsgNavigationType::previousFlagged:
+            if (IsValidIndex(index) && index != 0)
+                rv = FindPrevFlagged(index, &resultIndex);
+            enable = (NS_SUCCEEDED(rv) && resultIndex != nsMsgViewIndex_None);
+            break;
+        case nsMsgNavigationType::firstNew:
+            rv = FindFirstNew(&resultIndex);
+            enable = (NS_SUCCEEDED(rv) && resultIndex != nsMsgViewIndex_None);
+            break;
+        case nsMsgNavigationType::readMore:
+            enable = true;  // for now, always true.
+            break;
+        case nsMsgNavigationType::nextFolder:
+        case nsMsgNavigationType::nextUnreadThread:
+        case nsMsgNavigationType::nextUnreadMessage:
+        case nsMsgNavigationType::toggleThreadKilled:
+            enable = true;  // always enabled
+            break;
+        case nsMsgNavigationType::previousUnreadMessage:
+            if (IsValidIndex(index))
+            {
+                nsMsgKey threadId;
+                rv = FindPrevUnread(m_keys[index], &resultKey, &threadId);
+                enable = (resultKey != nsMsgKey_None);
+            }
+            break;
+        case nsMsgNavigationType::forward:
+        case nsMsgNavigationType::back:
+        {
+          uint32_t curPos;
+          uint32_t historyCount;
+
+          if (messenger)
+          {
+            messenger->GetNavigateHistory(&curPos, &historyCount, nullptr);
+            int32_t desiredPos = (int32_t) curPos;
+            if (motion == nsMsgNavigationType::forward)
+              desiredPos++;
+            else
+              desiredPos--; //? operator code didn't work for me
+            enable = (desiredPos >= 0 && desiredPos < (int32_t) historyCount / 2);
+          }
+        }
+          break;
+
+        default:
+            NS_ERROR("unexpected");
+            break;
+    }
+
+    *_retval = enable;
+    return NS_OK;
+}
+
+// Note that these routines do NOT expand collapsed threads! This mimics the old behaviour,
+// but it's also because we don't remember whether a thread contains a flagged message the
+// same way we remember if a thread contains new messages. It would be painful to dive down
+// into each collapsed thread to update navigate status.
+// We could cache this info, but it would still be expensive the first time this status needs
+// to get updated.
+nsresult nsMsgDBView::FindNextFlagged(nsMsgViewIndex startIndex, nsMsgViewIndex *pResultIndex)
+{
+    nsMsgViewIndex lastIndex = (nsMsgViewIndex) GetSize() - 1;
+    nsMsgViewIndex curIndex;
+
+    *pResultIndex = nsMsgViewIndex_None;
+
+    if (GetSize() > 0)
+    {
+        for (curIndex = startIndex; curIndex <= lastIndex; curIndex++)
+        {
+            uint32_t flags = m_flags[curIndex];
+            if (flags & nsMsgMessageFlags::Marked)
+            {
+                *pResultIndex = curIndex;
+                break;
+            }
+        }
+    }
+
+    return NS_OK;
+}
+
+nsresult nsMsgDBView::FindFirstNew(nsMsgViewIndex *pResultIndex)
+{
+  if (m_db)
+  {
+    nsMsgKey firstNewKey = nsMsgKey_None;
+    m_db->GetFirstNew(&firstNewKey);
+    *pResultIndex = (firstNewKey != nsMsgKey_None)
+        ? FindKey(firstNewKey, true) : nsMsgViewIndex_None;
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::FindPrevUnread(nsMsgKey startKey, nsMsgKey *pResultKey,
+                                     nsMsgKey *resultThreadId)
+{
+    nsMsgViewIndex startIndex = FindViewIndex(startKey);
+    nsMsgViewIndex curIndex = startIndex;
+    nsresult rv = NS_MSG_MESSAGE_NOT_FOUND;
+
+    if (startIndex == nsMsgViewIndex_None)
+        return NS_MSG_MESSAGE_NOT_FOUND;
+
+    *pResultKey = nsMsgKey_None;
+    if (resultThreadId)
+        *resultThreadId = nsMsgKey_None;
+
+    for (; (int) curIndex >= 0 && (*pResultKey == nsMsgKey_None); curIndex--)
+    {
+        uint32_t flags = m_flags[curIndex];
+
+        if (curIndex != startIndex && flags & MSG_VIEW_FLAG_ISTHREAD && flags & nsMsgMessageFlags::Elided)
+        {
+            NS_ERROR("fix this");
+            //nsMsgKey threadId = m_keys[curIndex];
+            //rv = m_db->GetUnreadKeyInThread(threadId, pResultKey, resultThreadId);
+            if (NS_SUCCEEDED(rv) && (*pResultKey != nsMsgKey_None))
+                break;
+        }
+        if (!(flags & (nsMsgMessageFlags::Read | MSG_VIEW_FLAG_DUMMY)) && (curIndex != startIndex))
+        {
+            *pResultKey = m_keys[curIndex];
+            rv = NS_OK;
+            break;
+        }
+    }
+    // found unread message but we don't know the thread
+    NS_ASSERTION(!(*pResultKey != nsMsgKey_None && resultThreadId && *resultThreadId == nsMsgKey_None),
+      "fix this");
+    return rv;
+}
+
+nsresult nsMsgDBView::FindFirstFlagged(nsMsgViewIndex *pResultIndex)
+{
+    return FindNextFlagged(0, pResultIndex);
+}
+
+nsresult nsMsgDBView::FindPrevFlagged(nsMsgViewIndex startIndex, nsMsgViewIndex *pResultIndex)
+{
+    nsMsgViewIndex curIndex;
+
+    *pResultIndex = nsMsgViewIndex_None;
+
+    if (GetSize() > 0 && IsValidIndex(startIndex))
+    {
+        curIndex = startIndex;
+        do
+        {
+            if (curIndex != 0)
+                curIndex--;
+
+            uint32_t flags = m_flags[curIndex];
+            if (flags & nsMsgMessageFlags::Marked)
+            {
+                *pResultIndex = curIndex;
+                break;
+            }
+        }
+        while (curIndex != 0);
+    }
+    return NS_OK;
+}
+
+bool nsMsgDBView::IsValidIndex(nsMsgViewIndex index)
+{
+    return index != nsMsgViewIndex_None &&
+           (index < (nsMsgViewIndex) m_keys.Length());
+}
+
+nsresult nsMsgDBView::OrExtraFlag(nsMsgViewIndex index, uint32_t orflag)
+{
+  uint32_t  flag;
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  flag = m_flags[index];
+  flag |= orflag;
+  m_flags[index] = flag;
+  OnExtraFlagChanged(index, flag);
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::AndExtraFlag(nsMsgViewIndex index, uint32_t andflag)
+{
+  uint32_t  flag;
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  flag = m_flags[index];
+  flag &= andflag;
+  m_flags[index] = flag;
+  OnExtraFlagChanged(index, flag);
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::SetExtraFlag(nsMsgViewIndex index, uint32_t extraflag)
+{
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  m_flags[index] = extraflag;
+  OnExtraFlagChanged(index, extraflag);
+  return NS_OK;
+}
+
+
+nsresult nsMsgDBView::ToggleIgnored(nsMsgViewIndex * indices, int32_t numIndices, nsMsgViewIndex *resultIndex, bool *resultToggleState)
+{
+  nsCOMPtr <nsIMsgThread> thread;
+
+  // Ignored state is toggled based on the first selected thread
+  nsMsgViewIndex threadIndex = GetThreadFromMsgIndex(indices[0], getter_AddRefs(thread));
+  uint32_t threadFlags;
+  thread->GetFlags(&threadFlags);
+  uint32_t ignored = threadFlags & nsMsgMessageFlags::Ignored;
+
+  // Process threads in reverse order
+  // Otherwise collapsing the threads will invalidate the indices
+  threadIndex = nsMsgViewIndex_None;
+  while (numIndices)
+  {
+    numIndices--;
+    if (indices[numIndices] < threadIndex)
+    {
+      threadIndex = GetThreadFromMsgIndex(indices[numIndices], getter_AddRefs(thread));
+      thread->GetFlags(&threadFlags);
+      if ((threadFlags & nsMsgMessageFlags::Ignored) == ignored)
+        SetThreadIgnored(thread, threadIndex, !ignored);
+    }
+  }
+
+  if (resultIndex)
+    *resultIndex = threadIndex;
+  if (resultToggleState)
+    *resultToggleState = !ignored;
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::ToggleMessageKilled(nsMsgViewIndex * indices, int32_t numIndices, nsMsgViewIndex *resultIndex, bool *resultToggleState)
+{
+  NS_ENSURE_ARG_POINTER(resultToggleState);
+
+  nsCOMPtr <nsIMsgDBHdr> header;
+  // Ignored state is toggled based on the first selected message
+  nsresult rv = GetMsgHdrForViewIndex(indices[0], getter_AddRefs(header));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t msgFlags;
+  header->GetFlags(&msgFlags);
+  uint32_t ignored = msgFlags & nsMsgMessageFlags::Ignored;
+
+  // Process messages in reverse order
+  // Otherwise the indices may be invalidated...
+  nsMsgViewIndex msgIndex = nsMsgViewIndex_None;
+  while (numIndices)
+  {
+    numIndices--;
+    if (indices[numIndices] < msgIndex)
+    {
+      msgIndex = indices[numIndices];
+      rv = GetMsgHdrForViewIndex(msgIndex, getter_AddRefs(header));
+      NS_ENSURE_SUCCESS(rv, rv);
+      header->GetFlags(&msgFlags);
+      if ((msgFlags & nsMsgMessageFlags::Ignored) == ignored)
+        SetSubthreadKilled(header, msgIndex, !ignored);
+    }
+  }
+
+  if (resultIndex)
+    *resultIndex = msgIndex;
+  if (resultToggleState)
+    *resultToggleState = !ignored;
+
+  return NS_OK;
+}
+
+nsMsgViewIndex  nsMsgDBView::GetThreadFromMsgIndex(nsMsgViewIndex index,
+                                                   nsIMsgThread **threadHdr)
+{
+  nsMsgKey        msgKey = GetAt(index);
+  nsMsgViewIndex  threadIndex;
+
+  if (threadHdr == nullptr)
+    return nsMsgViewIndex_None;
+
+  nsresult rv = GetThreadContainingIndex(index, threadHdr);
+  NS_ENSURE_SUCCESS(rv,nsMsgViewIndex_None);
+
+  if (*threadHdr == nullptr)
+    return nsMsgViewIndex_None;
+
+  nsMsgKey threadKey;
+  (*threadHdr)->GetThreadKey(&threadKey);
+  if (msgKey !=threadKey)
+    threadIndex = GetIndexOfFirstDisplayedKeyInThread(*threadHdr);
+  else
+    threadIndex = index;
+  return threadIndex;
+}
+
+nsresult nsMsgDBView::ToggleWatched( nsMsgViewIndex* indices,  int32_t numIndices)
+{
+  nsCOMPtr <nsIMsgThread> thread;
+
+  // Watched state is toggled based on the first selected thread
+  nsMsgViewIndex threadIndex = GetThreadFromMsgIndex(indices[0], getter_AddRefs(thread));
+  uint32_t threadFlags;
+  thread->GetFlags(&threadFlags);
+  uint32_t watched = threadFlags & nsMsgMessageFlags::Watched;
+
+  // Process threads in reverse order
+  // for consistency with ToggleIgnored
+  threadIndex = nsMsgViewIndex_None;
+  while (numIndices)
+  {
+    numIndices--;
+    if (indices[numIndices] < threadIndex)
+    {
+      threadIndex = GetThreadFromMsgIndex(indices[numIndices], getter_AddRefs(thread));
+      thread->GetFlags(&threadFlags);
+      if ((threadFlags & nsMsgMessageFlags::Watched) == watched)
+        SetThreadWatched(thread, threadIndex, !watched);
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::SetThreadIgnored(nsIMsgThread *thread, nsMsgViewIndex threadIndex, bool ignored)
+{
+  if (!IsValidIndex(threadIndex))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  NoteChange(threadIndex, 1, nsMsgViewNotificationCode::changed);
+  if (ignored)
+  {
+    nsTArray<nsMsgKey> idsMarkedRead;
+
+    MarkThreadRead(thread, threadIndex, idsMarkedRead, true);
+    CollapseByIndex(threadIndex, nullptr);
+  }
+
+  if (!m_db)
+    return NS_ERROR_FAILURE;
+  return m_db->MarkThreadIgnored(thread, m_keys[threadIndex], ignored, this);
+}
+
+nsresult nsMsgDBView::SetSubthreadKilled(nsIMsgDBHdr *header, nsMsgViewIndex msgIndex, bool ignored)
+{
+  if (!IsValidIndex(msgIndex))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  NoteChange(msgIndex, 1, nsMsgViewNotificationCode::changed);
+
+  if (!m_db)
+    return NS_ERROR_FAILURE;
+  nsresult rv = m_db->MarkHeaderKilled(header, ignored, this);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (ignored)
+  {
+    nsCOMPtr <nsIMsgThread> thread;
+    nsresult rv;
+    rv = GetThreadContainingMsgHdr(header, getter_AddRefs(thread));
+    if (NS_FAILED(rv))
+      return NS_OK; // So we didn't mark threads read
+
+    uint32_t children, current;
+    thread->GetNumChildren(&children);
+
+    nsMsgKey headKey;
+    header->GetMessageKey(&headKey);
+
+    for (current = 0; current < children; current++)
+    {
+       nsMsgKey newKey;
+       thread->GetChildKeyAt(current, &newKey);
+       if (newKey == headKey)
+         break;
+    }
+
+    // Process all messages, starting with this message.
+    for (; current < children; current++)
+    {
+       nsCOMPtr <nsIMsgDBHdr> nextHdr;
+       bool isKilled;
+
+       thread->GetChildHdrAt(current, getter_AddRefs(nextHdr));
+       nextHdr->GetIsKilled(&isKilled);
+
+       // Ideally, the messages should stop processing here.
+       // However, the children are ordered not by thread...
+       if (isKilled)
+         nextHdr->MarkRead(true);
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::SetThreadWatched(nsIMsgThread *thread, nsMsgViewIndex index, bool watched)
+{
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+  return m_db->MarkThreadWatched(thread, m_keys[index], watched, this);
+}
+
+NS_IMETHODIMP nsMsgDBView::GetMsgFolder(nsIMsgFolder **aMsgFolder)
+{
+  NS_ENSURE_ARG_POINTER(aMsgFolder);
+  NS_IF_ADDREF(*aMsgFolder = m_folder);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SetViewFolder(nsIMsgFolder *aMsgFolder)
+{
+  m_viewFolder = aMsgFolder;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetViewFolder(nsIMsgFolder **aMsgFolder)
+{
+  NS_ENSURE_ARG_POINTER(aMsgFolder);
+  NS_IF_ADDREF(*aMsgFolder = m_viewFolder);
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgDBView::GetNumSelected(uint32_t *aNumSelected)
+{
+  NS_ENSURE_ARG_POINTER(aNumSelected);
+
+  if (!mTreeSelection)
+  {
+    // No tree selection can mean we're in the stand alone mode.
+    *aNumSelected = (m_currentlyDisplayedMsgKey != nsMsgKey_None) ? 1 : 0;
+    return NS_OK;
+  }
+
+  bool includeCollapsedMsgs = OperateOnMsgsInCollapsedThreads();
+
+  // We call this a lot from the front end JS, so make it fast.
+  nsresult rv = mTreeSelection->GetCount((int32_t*)aNumSelected);
+  if (!*aNumSelected || !includeCollapsedMsgs ||
+       !(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    return rv;
+
+  int32_t numSelectedIncludingCollapsed = *aNumSelected;
+  nsMsgViewIndexArray selection;
+  GetSelectedIndices(selection);
+  int32_t numIndices = selection.Length();
+  // iterate over the selection, counting up the messages in collapsed
+  // threads.
+  for (int32_t i = 0; i < numIndices; i++)
+  {
+    if (m_flags[selection[i]] & nsMsgMessageFlags::Elided)
+    {
+      int32_t collapsedCount;
+      ExpansionDelta(selection[i], &collapsedCount);
+      numSelectedIncludingCollapsed += collapsedCount;
+    }
+  }
+  *aNumSelected = numSelectedIncludingCollapsed;
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetNumMsgsInView(int32_t *aNumMsgs)
+{
+  NS_ENSURE_ARG_POINTER(aNumMsgs);
+  return (m_folder) ? m_folder->GetTotalMessages(false, aNumMsgs) :
+                    NS_ERROR_FAILURE;
+}
+/**
+ * @note For the IMAP delete model, this applies to both deleting and
+ *       undeleting a message.
+ */
+NS_IMETHODIMP
+nsMsgDBView::GetMsgToSelectAfterDelete(nsMsgViewIndex *msgToSelectAfterDelete)
+{
+  NS_ENSURE_ARG_POINTER(msgToSelectAfterDelete);
+  *msgToSelectAfterDelete = nsMsgViewIndex_None;
+
+  bool isMultiSelect = false;
+  int32_t startFirstRange = nsMsgViewIndex_None;
+  int32_t endFirstRange = nsMsgViewIndex_None;
+  if (!mTreeSelection)
+  {
+    // If we don't have a tree selection then we must be in stand alone mode.
+    // return the index of the current message key as the first selected index.
+    *msgToSelectAfterDelete = FindViewIndex(m_currentlyDisplayedMsgKey);
+  }
+  else
+  {
+    int32_t selectionCount;
+    int32_t startRange;
+    int32_t endRange;
+    nsresult rv = mTreeSelection->GetRangeCount(&selectionCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+    for (int32_t i = 0; i < selectionCount; i++)
+    {
+      rv = mTreeSelection->GetRangeAt(i, &startRange, &endRange);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // save off the first range in case we need it later
+      if (i == 0) {
+        startFirstRange = startRange;
+        endFirstRange = endRange;
+      } else {
+        // If the tree selection is goofy (eg adjacent or overlapping ranges),
+        // complain about it, but don't try and cope.  Just live with the fact
+        // that one of the deleted messages is going to end up selected.
+        NS_WARNING_ASSERTION(endFirstRange != startRange,
+                             "goofy tree selection state: two ranges are adjacent!");
+      }
+      *msgToSelectAfterDelete = std::min(*msgToSelectAfterDelete,
+                                       (nsMsgViewIndex)startRange);
+    }
+
+    // Multiple selection either using Ctrl, Shift, or one of the affordances
+    // to select an entire thread.
+    isMultiSelect = (selectionCount > 1 || (endRange-startRange) > 0);
+  }
+
+  if (*msgToSelectAfterDelete == nsMsgViewIndex_None)
+    return NS_OK;
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  GetMsgFolder(getter_AddRefs(folder));
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(folder);
+  bool thisIsImapFolder = (imapFolder != nullptr);
+  // Need to update the imap-delete model, can change more than once in a session.
+  if (thisIsImapFolder)
+    GetImapDeleteModel(nullptr);
+
+  // If mail.delete_matches_sort_order is true,
+  // for views sorted in descending order (newest at the top), make msgToSelectAfterDelete
+  // advance in the same direction as the sort order.
+  bool deleteMatchesSort = false;
+  if (m_sortOrder == nsMsgViewSortOrder::descending && *msgToSelectAfterDelete)
+  {
+    nsresult rv;
+    nsCOMPtr<nsIPrefBranch> prefBranch (do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    prefBranch->GetBoolPref("mail.delete_matches_sort_order", &deleteMatchesSort);
+  }
+
+  if (mDeleteModel == nsMsgImapDeleteModels::IMAPDelete)
+  {
+    if (isMultiSelect)
+    {
+      if (deleteMatchesSort)
+        *msgToSelectAfterDelete = startFirstRange - 1;
+      else
+        *msgToSelectAfterDelete = endFirstRange + 1;
+    }
+    else
+    {
+      if (deleteMatchesSort)
+        *msgToSelectAfterDelete -= 1;
+      else
+        *msgToSelectAfterDelete += 1;
+    }
+  }
+  else if (deleteMatchesSort)
+  {
+    *msgToSelectAfterDelete -= 1;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::GetRemoveRowOnMoveOrDelete(bool *aRemoveRowOnMoveOrDelete)
+{
+  NS_ENSURE_ARG_POINTER(aRemoveRowOnMoveOrDelete);
+  nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(m_folder);
+  if (!imapFolder)
+  {
+    *aRemoveRowOnMoveOrDelete = true;
+    return NS_OK;
+  }
+
+  // need to update the imap-delete model, can change more than once in a session.
+  GetImapDeleteModel(nullptr);
+
+  // unlike the other imap delete models, "mark as deleted" does not remove rows on delete (or move)
+  *aRemoveRowOnMoveOrDelete = (mDeleteModel != nsMsgImapDeleteModels::IMAPDelete);
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgDBView::GetCurrentlyDisplayedMessage(nsMsgViewIndex *currentlyDisplayedMessage)
+{
+  NS_ENSURE_ARG_POINTER(currentlyDisplayedMessage);
+  *currentlyDisplayedMessage = FindViewIndex(m_currentlyDisplayedMsgKey);
+  return NS_OK;
+}
+
+// if nothing selected, return an NS_ERROR
+NS_IMETHODIMP
+nsMsgDBView::GetHdrForFirstSelectedMessage(nsIMsgDBHdr **hdr)
+{
+  NS_ENSURE_ARG_POINTER(hdr);
+
+  nsresult rv;
+  nsMsgKey key;
+  rv = GetKeyForFirstSelectedMessage(&key);
+  // don't assert, it is legal for nothing to be selected
+  if (NS_FAILED(rv)) return rv;
+
+  if (!m_db)
+    return NS_MSG_MESSAGE_NOT_FOUND;
+
+  rv = m_db->GetMsgHdrForKey(key, hdr);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return NS_OK;
+}
+
+// if nothing selected, return an NS_ERROR
+NS_IMETHODIMP
+nsMsgDBView::GetURIForFirstSelectedMessage(nsACString &uri)
+{
+  nsresult rv;
+  nsMsgViewIndex viewIndex;
+  rv = GetViewIndexForFirstSelectedMsg(&viewIndex);
+  // don't assert, it is legal for nothing to be selected
+  if (NS_FAILED(rv)) return rv;
+
+  return GetURIForViewIndex(viewIndex, uri);
+}
+
+NS_IMETHODIMP
+nsMsgDBView::OnDeleteCompleted(bool aSucceeded)
+{
+  if (m_deletingRows && aSucceeded)
+  {
+    uint32_t numIndices = mIndicesToNoteChange.Length();
+    if (numIndices && mTree)
+    {
+      if (numIndices > 1)
+        mIndicesToNoteChange.Sort();
+
+      // the call to NoteChange() has to happen after we are done removing the keys
+      // as NoteChange() will call RowCountChanged() which will call our GetRowCount()
+      if (numIndices > 1)
+        mTree->BeginUpdateBatch();
+      for (uint32_t i = 0; i < numIndices; i++)
+        NoteChange(mIndicesToNoteChange[i], -1, nsMsgViewNotificationCode::insertOrDelete);
+      if (numIndices > 1)
+        mTree->EndUpdateBatch();
+    }
+    mIndicesToNoteChange.Clear();
+  }
+
+ m_deletingRows = false;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetDb(nsIMsgDatabase **aDB)
+{
+  NS_ENSURE_ARG_POINTER(aDB);
+  NS_IF_ADDREF(*aDB = m_db);
+  return NS_OK;
+}
+
+bool nsMsgDBView::OfflineMsgSelected(nsMsgViewIndex * indices, int32_t numIndices)
+{
+  nsCOMPtr <nsIMsgLocalMailFolder> localFolder = do_QueryInterface(m_folder);
+  if (localFolder)
+    return true;
+
+  for (nsMsgViewIndex index = 0; index < (nsMsgViewIndex) numIndices; index++)
+  {
+    // For cross-folder saved searches, we need to check if any message
+    // is in a local folder.
+    if (!m_folder)
+    {
+      nsCOMPtr<nsIMsgFolder> folder;
+      GetFolderForViewIndex(indices[index], getter_AddRefs(folder));
+      nsCOMPtr <nsIMsgLocalMailFolder> localFolder = do_QueryInterface(folder);
+      if (localFolder)
+        return true;
+    }
+
+    uint32_t flags = m_flags[indices[index]];
+    if ((flags & nsMsgMessageFlags::Offline))
+      return true;
+  }
+  return false;
+}
+
+bool nsMsgDBView::NonDummyMsgSelected(nsMsgViewIndex * indices, int32_t numIndices)
+{
+  bool includeCollapsedMsgs = OperateOnMsgsInCollapsedThreads();
+
+  for (nsMsgViewIndex index = 0; index < (nsMsgViewIndex) numIndices; index++)
+  {
+    uint32_t flags = m_flags[indices[index]];
+    // We now treat having a collapsed dummy message selected as if
+    // the whole group was selected so we can apply commands to the group.
+    if (!(flags & MSG_VIEW_FLAG_DUMMY) ||
+        (flags & nsMsgMessageFlags::Elided && includeCollapsedMsgs))
+      return true;
+  }
+  return false;
+}
+
+NS_IMETHODIMP nsMsgDBView::GetViewIndexForFirstSelectedMsg(nsMsgViewIndex *aViewIndex)
+{
+  NS_ENSURE_ARG_POINTER(aViewIndex);
+  // If we don't have a tree selection we must be in stand alone mode...
+  if (!mTreeSelection)
+  {
+    *aViewIndex = m_currentlyDisplayedViewIndex;
+    return NS_OK;
+  }
+
+  int32_t startRange;
+  int32_t endRange;
+  nsresult rv = mTreeSelection->GetRangeAt(0, &startRange, &endRange);
+  // don't assert, it is legal for nothing to be selected
+  if (NS_FAILED(rv))
+    return rv;
+
+  // check that the first index is valid, it may not be if nothing is selected
+  if (startRange < 0 || uint32_t(startRange) >= GetSize())
+    return NS_ERROR_UNEXPECTED;
+
+  *aViewIndex = startRange;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::GetKeyForFirstSelectedMessage(nsMsgKey *key)
+{
+  NS_ENSURE_ARG_POINTER(key);
+  // If we don't have a tree selection we must be in stand alone mode...
+  if (!mTreeSelection)
+  {
+    *key = m_currentlyDisplayedMsgKey;
+    return NS_OK;
+  }
+
+  int32_t startRange;
+  int32_t endRange;
+  nsresult rv = mTreeSelection->GetRangeAt(0, &startRange, &endRange);
+  // don't assert, it is legal for nothing to be selected
+  if (NS_FAILED(rv))
+    return rv;
+
+  // check that the first index is valid, it may not be if nothing is selected
+  if (startRange < 0 || uint32_t(startRange) >= GetSize())
+    return NS_ERROR_UNEXPECTED;
+
+  if (m_flags[startRange] & MSG_VIEW_FLAG_DUMMY)
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  *key = m_keys[startRange];
+  return NS_OK;
+}
+
+nsCOMArray<nsIMsgFolder>* nsMsgDBView::GetFolders()
+{
+  return nullptr;
+}
+
+nsresult nsMsgDBView::AdjustRowCount(int32_t rowCountBeforeSort, int32_t rowCountAfterSort)
+{
+  int32_t rowChange = rowCountAfterSort - rowCountBeforeSort;
+
+  if (rowChange)
+  {
+    // this is not safe to use when you have a selection
+    // RowCountChanged() will call AdjustSelection()
+    uint32_t numSelected = 0;
+    GetNumSelected(&numSelected);
+    NS_ASSERTION(numSelected == 0, "it is not save to call AdjustRowCount() when you have a selection");
+
+    if (mTree)
+      mTree->RowCountChanged(0, rowChange);
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::GetImapDeleteModel(nsIMsgFolder *folder)
+{
+   nsresult rv = NS_OK;
+   nsCOMPtr <nsIMsgIncomingServer> server;
+   if (folder) //for the search view
+     folder->GetServer(getter_AddRefs(server));
+   else if (m_folder)
+     m_folder->GetServer(getter_AddRefs(server));
+   nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryInterface(server, &rv);
+   if (NS_SUCCEEDED(rv) && imapServer )
+     imapServer->GetDeleteModel(&mDeleteModel);
+   return rv;
+}
+
+
+//
+// CanDrop
+//
+// Can't drop on the thread pane.
+//
+NS_IMETHODIMP nsMsgDBView::CanDrop(int32_t index,
+                                   int32_t orient,
+                                   nsIDOMDataTransfer *dataTransfer,
+                                   bool *_retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = false;
+
+  return NS_OK;
+}
+
+
+//
+// Drop
+//
+// Can't drop on the thread pane.
+//
+NS_IMETHODIMP nsMsgDBView::Drop(int32_t row,
+                                int32_t orient,
+                                nsIDOMDataTransfer *dataTransfer)
+{
+  return NS_OK;
+}
+
+
+//
+// IsSorted
+//
+// ...
+//
+NS_IMETHODIMP nsMsgDBView::IsSorted(bool *_retval)
+{
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SelectFolderMsgByKey(nsIMsgFolder *aFolder, nsMsgKey aKey)
+{
+  NS_ENSURE_ARG_POINTER(aFolder);
+  if (aKey == nsMsgKey_None)
+    return NS_ERROR_FAILURE;
+
+  // this is OK for non search views.
+
+  nsMsgViewIndex viewIndex = FindKey(aKey, true /* expand */);
+
+  if (mTree)
+    mTreeSelection->SetCurrentIndex(viewIndex);
+
+  // make sure the current message is once again visible in the thread pane
+  // so we don't have to go search for it in the thread pane
+  if (mTree && viewIndex != nsMsgViewIndex_None)
+  {
+    mTreeSelection->Select(viewIndex);
+    mTree->EnsureRowIsVisible(viewIndex);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgDBView::SelectMsgByKey(nsMsgKey aKey)
+{
+  NS_ASSERTION(aKey != nsMsgKey_None, "bad key");
+  if (aKey == nsMsgKey_None)
+    return NS_OK;
+
+  // use SaveAndClearSelection()
+  // and RestoreSelection() so that we'll clear the current selection
+  // but pass in a different key array so that we'll
+  // select (and load) the desired message
+
+  AutoTArray<nsMsgKey, 1> preservedSelection;
+  nsresult rv = SaveAndClearSelection(nullptr, preservedSelection);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // now, restore our desired selection
+  AutoTArray<nsMsgKey, 1> keyArray;
+  keyArray.AppendElement(aKey);
+
+  // if the key was not found
+  // (this can happen with "remember last selected message")
+  // nothing will be selected
+  rv = RestoreSelection(aKey, keyArray);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater, nsIMsgDBView **_retval)
+{
+  nsMsgDBView* newMsgDBView = new nsMsgDBView();
+
+  if (!newMsgDBView)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv = CopyDBView(newMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  NS_IF_ADDREF(*_retval = newMsgDBView);
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::CopyDBView(nsMsgDBView *aNewMsgDBView, nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater)
+{
+  NS_ENSURE_ARG_POINTER(aNewMsgDBView);
+  if (aMsgWindow)
+  {
+    aNewMsgDBView->mMsgWindowWeak = do_GetWeakReference(aMsgWindow);
+    aMsgWindow->SetOpenFolder(m_viewFolder? m_viewFolder : m_folder);
+  }
+  aNewMsgDBView->mMessengerWeak = do_GetWeakReference(aMessengerInstance);
+  aNewMsgDBView->mCommandUpdater = aCmdUpdater;
+  aNewMsgDBView->m_folder = m_folder;
+  aNewMsgDBView->m_viewFlags = m_viewFlags;
+  aNewMsgDBView->m_sortOrder = m_sortOrder;
+  aNewMsgDBView->m_sortType = m_sortType;
+  aNewMsgDBView->m_curCustomColumn = m_curCustomColumn;
+  aNewMsgDBView->m_secondarySort = m_secondarySort;
+  aNewMsgDBView->m_secondarySortOrder = m_secondarySortOrder;
+  aNewMsgDBView->m_secondaryCustomColumn = m_secondaryCustomColumn;
+  aNewMsgDBView->m_db = m_db;
+  aNewMsgDBView->mDateFormatter = mDateFormatter;
+  if (m_db)
+    aNewMsgDBView->m_db->AddListener(aNewMsgDBView);
+  aNewMsgDBView->mIsNews = mIsNews;
+  aNewMsgDBView->mIsRss = mIsRss;
+  aNewMsgDBView->mIsXFVirtual = mIsXFVirtual;
+  aNewMsgDBView->mShowSizeInLines = mShowSizeInLines;
+  aNewMsgDBView->mDeleteModel = mDeleteModel;
+  aNewMsgDBView->m_flags = m_flags;
+  aNewMsgDBView->m_levels = m_levels;
+  aNewMsgDBView->m_keys = m_keys;
+
+  aNewMsgDBView->m_customColumnHandlerIDs = m_customColumnHandlerIDs;
+  aNewMsgDBView->m_customColumnHandlers.AppendObjects(m_customColumnHandlers);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::GetSearchSession(nsIMsgSearchSession* *aSession)
+{
+  NS_ASSERTION(false, "should be overriden by child class");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::SetSearchSession(nsIMsgSearchSession *aSession)
+{
+  NS_ASSERTION(false, "should be overriden by child class");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::GetSupportsThreading(bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::FindIndexFromKey(nsMsgKey aMsgKey, bool aExpand, nsMsgViewIndex *aIndex)
+{
+  NS_ENSURE_ARG_POINTER(aIndex);
+
+  *aIndex = FindKey(aMsgKey, aExpand);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgDBView::FindIndexOfMsgHdr(nsIMsgDBHdr *aMsgHdr, bool aExpand, nsMsgViewIndex *aIndex)
+{
+  NS_ENSURE_ARG(aMsgHdr);
+  NS_ENSURE_ARG_POINTER(aIndex);
+
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    nsMsgViewIndex threadIndex = ThreadIndexOfMsgHdr(aMsgHdr);
+    if (threadIndex != nsMsgViewIndex_None)
+    {
+      if (aExpand && (m_flags[threadIndex] & nsMsgMessageFlags::Elided))
+        ExpandByIndex(threadIndex, nullptr);
+      *aIndex = FindHdr(aMsgHdr, threadIndex);
+    }
+    else
+      *aIndex = nsMsgViewIndex_None;
+  }
+  else
+    *aIndex = FindHdr(aMsgHdr);
+
+  return NS_OK;
+}
+
+static void getDateFormatPref( nsIPrefBranch* _prefBranch, const char* _prefLocalName, nsDateFormatSelector& _format )
+{
+  // read
+  int32_t nFormatSetting( 0 );
+  nsresult result = _prefBranch->GetIntPref( _prefLocalName, &nFormatSetting );
+  if ( NS_SUCCEEDED( result ) )
+  {
+    // translate
+    nsDateFormatSelector res( nFormatSetting );
+    // transfer if valid
+    if ( ( res >= kDateFormatNone ) && ( res <= kDateFormatWeekday ) )
+      _format = res;
+  }
+}
+
+nsresult nsMsgDBView::InitDisplayFormats()
+{
+  m_dateFormatDefault   = kDateFormatShort;
+  m_dateFormatThisWeek  = kDateFormatShort;
+  m_dateFormatToday     = kDateFormatNone;
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  nsCOMPtr<nsIPrefBranch> dateFormatPrefs;
+  rv = prefs->GetBranch("mail.ui.display.dateformat.", getter_AddRefs(dateFormatPrefs));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  getDateFormatPref( dateFormatPrefs, "default", m_dateFormatDefault );
+  getDateFormatPref( dateFormatPrefs, "thisweek", m_dateFormatThisWeek );
+  getDateFormatPref( dateFormatPrefs, "today", m_dateFormatToday );
+  return rv;
+}
+
+void nsMsgDBView::SetMRUTimeForFolder(nsIMsgFolder *folder)
+{
+  uint32_t seconds;
+  PRTime2Seconds(PR_Now(), &seconds);
+  nsAutoCString nowStr;
+  nowStr.AppendInt(seconds);
+  folder->SetStringProperty(MRU_TIME_PROPERTY, nowStr);
+}
+
+
+NS_IMPL_ISUPPORTS(nsMsgDBView::nsMsgViewHdrEnumerator, nsISimpleEnumerator)
+
+nsMsgDBView::nsMsgViewHdrEnumerator::nsMsgViewHdrEnumerator(nsMsgDBView *view)
+{
+  // we need to clone the view because the caller may clear the
+  // current view immediately. It also makes it easier to expand all
+  // if we're working on a copy.
+  nsCOMPtr<nsIMsgDBView> clonedView;
+  view->CloneDBView(nullptr, nullptr, nullptr, getter_AddRefs(clonedView));
+  m_view = static_cast<nsMsgDBView*>(clonedView.get());
+  // make sure we enumerate over collapsed threads by expanding all.
+  m_view->ExpandAll();
+  m_curHdrIndex = 0;
+}
+
+nsMsgDBView::nsMsgViewHdrEnumerator::~nsMsgViewHdrEnumerator()
+{
+  if (m_view)
+    m_view->Close();
+}
+
+NS_IMETHODIMP nsMsgDBView::nsMsgViewHdrEnumerator::GetNext(nsISupports **aItem)
+{
+  NS_ENSURE_ARG_POINTER(aItem);
+
+  if (m_curHdrIndex >= m_view->GetSize())
+    return NS_ERROR_FAILURE;
+
+  // Ignore dummy header. We won't have empty groups, so
+  // we know the view index is good.
+  if (m_view->m_flags[m_curHdrIndex] & MSG_VIEW_FLAG_DUMMY)
+    ++m_curHdrIndex;
+
+  nsCOMPtr<nsIMsgDBHdr> nextHdr;
+
+  nsresult rv = m_view->GetMsgHdrForViewIndex(m_curHdrIndex++, getter_AddRefs(nextHdr));
+  NS_IF_ADDREF(*aItem = nextHdr);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgDBView::nsMsgViewHdrEnumerator::HasMoreElements(bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = m_curHdrIndex < m_view->GetSize();
+  return NS_OK;
+}
+
+nsresult nsMsgDBView::GetViewEnumerator(nsISimpleEnumerator **enumerator)
+{
+  NS_IF_ADDREF(*enumerator = new nsMsgViewHdrEnumerator(this));
+  return (*enumerator) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+nsresult nsMsgDBView::GetDBForHeader(nsIMsgDBHdr *msgHdr, nsIMsgDatabase **db)
+{
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = msgHdr->GetFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return folder->GetMsgDatabase(db);
+}
+
+/**
+ * Determine whether junk commands should be enabled on this view.
+ * Junk commands are always enabled for mail. For nntp and rss, they
+ * may be selectively enabled using an inherited folder property.
+ *
+ * @param  aViewIndex  view index of the message to check
+ * @return             true if junk controls should be enabled
+ */
+bool nsMsgDBView::JunkControlsEnabled(nsMsgViewIndex aViewIndex)
+{
+  // For normal mail, junk commands are always enabled.
+  if (!(mIsNews || mIsRss || mIsXFVirtual))
+    return true;
+
+  // we need to check per message or folder
+  nsCOMPtr <nsIMsgFolder> folder = m_folder;
+  if (!folder && IsValidIndex(aViewIndex))
+    GetFolderForViewIndex(aViewIndex, getter_AddRefs(folder));
+  if (folder)
+  {
+    // Check if this is a mail message in search folders.
+    if (mIsXFVirtual)
+    {
+      nsCOMPtr <nsIMsgIncomingServer> server;
+      folder->GetServer(getter_AddRefs(server));
+      nsAutoCString type;
+      if (server)
+        server->GetType(type);
+      if (!(MsgLowerCaseEqualsLiteral(type, "nntp") || MsgLowerCaseEqualsLiteral(type, "rss")))
+        return true;
+    }
+
+    // For rss and news, check the inherited folder property.
+    nsAutoCString junkEnableOverride;
+    folder->GetInheritedStringProperty("dobayes.mailnews@mozilla.org#junk",
+                                       junkEnableOverride);
+    if (junkEnableOverride.EqualsLiteral("true"))
+      return true;
+  }
+
+  return false;
+}
diff --git a/mailnews/base/src/nsMsgDBView.h b/mailnews/base/src/nsMsgDBView.h
new file mode 100644
index 000000000..6dcbbea3b
--- /dev/null
+++ b/mailnews/base/src/nsMsgDBView.h
@@ -0,0 +1,513 @@
+/* -*- 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 _nsMsgDBView_H_
+#define _nsMsgDBView_H_
+
+#include "nsIMsgDBView.h"
+#include "nsIMsgWindow.h"
+#include "nsIMessenger.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgHdr.h"
+#include "MailNewsTypes.h"
+#include "nsIDBChangeListener.h"
+#include "nsITreeView.h"
+#include "nsITreeBoxObject.h"
+#include "nsITreeSelection.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgThread.h"
+#include "nsIDateTimeFormat.h"
+#include "nsIDOMElement.h"
+#include "nsIAtom.h"
+#include "nsIImapIncomingServer.h"
+#include "nsIWeakReference.h"
+#include "nsIMsgFilterPlugin.h"
+#include "nsIStringBundle.h"
+#include "nsMsgTagService.h"
+#include "nsCOMArray.h"
+#include "nsTArray.h"
+#include "nsTHashtable.h"
+#include "nsHashKeys.h"
+#include "nsIMsgCustomColumnHandler.h"
+#include "nsAutoPtr.h"
+#include "nsIWeakReferenceUtils.h"
+#define MESSENGER_STRING_URL       "chrome://messenger/locale/messenger.properties"
+
+typedef AutoTArray<nsMsgViewIndex, 1> nsMsgViewIndexArray;
+static_assert(nsMsgViewIndex(nsMsgViewIndexArray::NoIndex) ==
+  nsMsgViewIndex_None, "These need to be the same value.");
+
+enum eFieldType {
+    kCollationKey,
+    kU32
+};
+
+// this is used in an nsTArray<> to keep track of a multi-column sort
+class MsgViewSortColumnInfo
+{
+public:
+  MsgViewSortColumnInfo(const MsgViewSortColumnInfo &other);
+  MsgViewSortColumnInfo() {}
+  bool operator == (const MsgViewSortColumnInfo &other) const;
+  nsMsgViewSortTypeValue mSortType;
+  nsMsgViewSortOrderValue mSortOrder;
+  // if mSortType == byCustom, info about the custom column sort
+  nsString mCustomColumnName;
+  nsCOMPtr <nsIMsgCustomColumnHandler> mColHandler;
+} ;
+
+// reserve the top 8 bits in the msg flags for the view-only flags.
+#define MSG_VIEW_FLAGS 0xEE000000
+#define MSG_VIEW_FLAG_HASCHILDREN 0x40000000
+#define MSG_VIEW_FLAG_DUMMY 0x20000000
+#define MSG_VIEW_FLAG_ISTHREAD 0x8000000
+#define MSG_VIEW_FLAG_OUTGOING 0x2000000
+#define MSG_VIEW_FLAG_INCOMING 0x1000000
+
+/* There currently only 5 labels defined */
+#define PREF_LABELS_MAX 5
+#define PREF_LABELS_DESCRIPTION  "mailnews.labels.description."
+#define PREF_LABELS_COLOR  "mailnews.labels.color."
+
+#define LABEL_COLOR_STRING " lc-"
+#define LABEL_COLOR_WHITE_STRING "#FFFFFF"
+
+struct IdUint32
+{
+  nsMsgKey    id;
+  uint32_t    bits;
+  uint32_t    dword;
+  nsIMsgFolder* folder;
+};
+
+struct IdKey : public IdUint32
+{
+  // actually a variable length array, whose actual size is determined
+  // when the struct is allocated.
+  uint8_t     key[1];
+};
+
+struct IdKeyPtr : public IdUint32
+{
+  uint8_t     *key;
+};
+
+// This is an abstract implementation class.
+// The actual view objects will be instances of sub-classes of this class
+class nsMsgDBView : public nsIMsgDBView, public nsIDBChangeListener,
+                    public nsITreeView,
+                    public nsIJunkMailClassificationListener
+{
+public:
+  nsMsgDBView();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGDBVIEW
+  NS_DECL_NSIDBCHANGELISTENER
+  NS_DECL_NSITREEVIEW
+  NS_DECL_NSIJUNKMAILCLASSIFICATIONLISTENER
+
+  nsMsgViewIndex GetInsertIndexHelper(nsIMsgDBHdr *msgHdr, nsTArray<nsMsgKey> &keys,
+                                      nsCOMArray<nsIMsgFolder> *folders,
+                                        nsMsgViewSortOrderValue sortOrder,
+                                        nsMsgViewSortTypeValue sortType);
+  int32_t  SecondarySort(nsMsgKey key1, nsISupports *folder1, nsMsgKey key2, nsISupports *folder2,
+                         class viewSortInfo *comparisonContext);
+
+protected:
+  virtual ~nsMsgDBView();
+
+  static nsrefcnt gInstanceCount;
+
+  static char16_t* kHighestPriorityString;
+  static char16_t* kHighPriorityString;
+  static char16_t* kLowestPriorityString;
+  static char16_t* kLowPriorityString;
+  static char16_t* kNormalPriorityString;
+
+  static nsIAtom* kJunkMsgAtom;
+  static nsIAtom* kNotJunkMsgAtom;
+
+  static char16_t* kReadString;
+  static char16_t* kRepliedString;
+  static char16_t* kForwardedString;
+  static char16_t* kNewString;
+
+  nsCOMPtr<nsITreeBoxObject> mTree;
+  nsCOMPtr<nsITreeSelection> mTreeSelection;
+  uint32_t mNumSelectedRows; // we cache this to determine when to push command status notifications.
+  bool           mSuppressMsgDisplay; // set when the message pane is collapsed
+  bool           mSuppressCommandUpdating;
+  bool           mRemovingRow; // set when we're telling the outline a row is being removed. used to suppress msg loading.
+                        // during delete/move operations.
+  bool          mCommandsNeedDisablingBecauseOfSelection;
+  bool          mSuppressChangeNotification;
+  bool          mGoForwardEnabled;
+  bool          mGoBackEnabled;
+  
+  virtual const char * GetViewName(void) {return "MsgDBView"; }
+  nsresult FetchAuthor(nsIMsgDBHdr * aHdr, nsAString &aAuthorString);
+  nsresult FetchRecipients(nsIMsgDBHdr * aHdr, nsAString &aRecipientsString);
+  nsresult FetchSubject(nsIMsgDBHdr * aMsgHdr, uint32_t aFlags, nsAString &aValue);
+  nsresult FetchDate(nsIMsgDBHdr * aHdr, nsAString & aDateString, bool rcvDate = false);
+  nsresult FetchStatus(uint32_t aFlags, nsAString &aStatusString);
+  nsresult FetchSize(nsIMsgDBHdr * aHdr, nsAString & aSizeString);
+  nsresult FetchPriority(nsIMsgDBHdr *aHdr, nsAString & aPriorityString);
+  nsresult FetchLabel(nsIMsgDBHdr *aHdr, nsAString & aLabelString);
+  nsresult FetchTags(nsIMsgDBHdr *aHdr, nsAString & aTagString);
+  nsresult FetchKeywords(nsIMsgDBHdr *aHdr, nsACString & keywordString);
+  nsresult FetchRowKeywords(nsMsgViewIndex aRow, nsIMsgDBHdr *aHdr,
+                            nsACString & keywordString);
+  nsresult FetchAccount(nsIMsgDBHdr * aHdr, nsAString& aAccount);
+  bool IsOutgoingMsg(nsIMsgDBHdr * aHdr);
+  nsresult CycleThreadedColumn(nsIDOMElement * aElement);
+
+  // The default enumerator is over the db, but things like
+  // quick search views will enumerate just the displayed messages.
+  virtual nsresult GetMessageEnumerator(nsISimpleEnumerator **enumerator);
+  // this is a message enumerator that enumerates based on the view contents
+  virtual nsresult GetViewEnumerator(nsISimpleEnumerator **enumerator);
+
+  // Save and Restore Selection are a pair of routines you should
+  // use when performing an operation which is going to change the view
+  // and you want to remember the selection. (i.e. for sorting). 
+  // Call SaveAndClearSelection and we'll give you an array of msg keys for
+  // the current selection. We also freeze and clear the selection. 
+  // When you are done changing the view, 
+  // call RestoreSelection passing in the same array
+  // and we'll restore the selection AND unfreeze selection in the UI.
+  nsresult SaveAndClearSelection(nsMsgKey *aCurrentMsgKey, nsTArray<nsMsgKey> &aMsgKeyArray);
+  nsresult RestoreSelection(nsMsgKey aCurrentmsgKey, nsTArray<nsMsgKey> &aMsgKeyArray);
+
+  // this is not safe to use when you have a selection
+  // RowCountChanged() will call AdjustSelection() 
+  // it should be called after SaveAndClearSelection() and before
+  // RestoreSelection()
+  nsresult AdjustRowCount(int32_t rowCountBeforeSort, int32_t rowCountAfterSort);
+
+  nsresult GetSelectedIndices(nsMsgViewIndexArray& selection);
+  nsresult GenerateURIForMsgKey(nsMsgKey aMsgKey, nsIMsgFolder *folder, nsACString &aURI);
+// routines used in building up view
+  virtual bool WantsThisThread(nsIMsgThread * thread);
+  virtual nsresult AddHdr(nsIMsgDBHdr *msgHdr, nsMsgViewIndex *resultIndex = nullptr);
+  bool GetShowingIgnored() {return (m_viewFlags & nsMsgViewFlagsType::kShowIgnored) != 0;}
+  bool OperateOnMsgsInCollapsedThreads();
+
+  virtual nsresult OnNewHeader(nsIMsgDBHdr *aNewHdr, nsMsgKey parentKey, bool ensureListed);
+  virtual nsMsgViewIndex GetInsertIndex(nsIMsgDBHdr *msgHdr);
+  nsMsgViewIndex GetIndexForThread(nsIMsgDBHdr *hdr);
+  nsMsgViewIndex GetThreadRootIndex(nsIMsgDBHdr *msgHdr);
+  virtual nsresult GetMsgHdrForViewIndex(nsMsgViewIndex index, nsIMsgDBHdr **msgHdr);
+  // given a view index, return the index of the top-level msg in the thread.
+  nsMsgViewIndex GetThreadIndex(nsMsgViewIndex msgIndex);
+
+  virtual void InsertMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr,
+                              nsMsgKey msgKey, uint32_t flags, uint32_t level);
+  virtual void SetMsgHdrAt(nsIMsgDBHdr *hdr, nsMsgViewIndex index, 
+                              nsMsgKey msgKey, uint32_t flags, uint32_t level);
+  virtual bool InsertEmptyRows(nsMsgViewIndex viewIndex, int32_t numRows);
+  virtual void RemoveRows(nsMsgViewIndex viewIndex, int32_t numRows);
+  nsresult ToggleExpansion(nsMsgViewIndex index, uint32_t *numChanged);
+  nsresult ExpandByIndex(nsMsgViewIndex index, uint32_t *pNumExpanded);
+  nsresult CollapseByIndex(nsMsgViewIndex index, uint32_t *pNumCollapsed);
+  nsresult ExpandAll();
+  nsresult CollapseAll();
+  nsresult ExpandAndSelectThread();
+
+  // helper routines for thread expanding and collapsing.
+  nsresult GetThreadCount(nsMsgViewIndex viewIndex, uint32_t *pThreadCount);
+  /**
+   * Retrieve the view index of the first displayed message in the given thread.
+   * @param threadHdr The thread you care about.
+   * @param allowDummy Should dummy headers be returned when the non-dummy
+   *     header is available?  If the root node of the thread is a dummy header
+   *     and you pass false, then we will return the first child of the thread
+   *     unless the thread is elided, in which case we will return the root.
+   *     If you pass true, we will always return the root.
+   * @return the view index of the first message in the thread, if any.
+   */
+  nsMsgViewIndex GetIndexOfFirstDisplayedKeyInThread(nsIMsgThread *threadHdr,
+      bool allowDummy=false);
+  virtual nsresult GetFirstMessageHdrToDisplayInThread(nsIMsgThread *threadHdr, nsIMsgDBHdr **result);
+  virtual nsMsgViewIndex ThreadIndexOfMsg(nsMsgKey msgKey,
+                            nsMsgViewIndex msgIndex = nsMsgViewIndex_None,
+                            int32_t *pThreadCount = nullptr,
+                            uint32_t *pFlags = nullptr);
+  nsMsgViewIndex ThreadIndexOfMsgHdr(nsIMsgDBHdr *msgHdr,
+                                 nsMsgViewIndex msgIndex = nsMsgViewIndex_None,
+                                 int32_t *pThreadCount = nullptr,
+                                 uint32_t *pFlags = nullptr);
+  nsMsgKey GetKeyOfFirstMsgInThread(nsMsgKey key);
+  int32_t CountExpandedThread(nsMsgViewIndex index);
+  virtual  nsresult ExpansionDelta(nsMsgViewIndex index, int32_t *expansionDelta);
+  void ReverseSort();
+  void ReverseThreads();
+  nsresult SaveSortInfo(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder);
+  nsresult RestoreSortInfo();
+  nsresult PersistFolderInfo(nsIDBFolderInfo **dbFolderInfo);
+  void     SetMRUTimeForFolder(nsIMsgFolder *folder);
+
+  nsMsgKey  GetAt(nsMsgViewIndex index)
+                  {return m_keys.SafeElementAt(index, nsMsgKey_None);}
+  nsMsgViewIndex FindViewIndex(nsMsgKey  key)
+     {return FindKey(key, false);}
+  /**
+   * Find the message header if it is visible in this view.  (Messages in
+   *     threads/groups that are elided will not be
+   * @param msgHdr Message header to look for.
+   * @param startIndex The index to start looking from.
+   * @param allowDummy Are dummy headers acceptable?  If yes, then for a group
+   *     with a dummy header, we return the root of the thread (the dummy
+   *     header), otherwise we return the actual "content" header for the
+   *     message.
+   * @return The view index of the header found, if any.
+   */
+  virtual nsMsgViewIndex FindHdr(nsIMsgDBHdr *msgHdr, nsMsgViewIndex startIndex = 0,
+                                 bool allowDummy=false);
+  virtual nsMsgViewIndex FindKey(nsMsgKey key, bool expand);
+  virtual nsresult GetDBForViewIndex(nsMsgViewIndex index, nsIMsgDatabase **db);
+  virtual nsCOMArray<nsIMsgFolder>* GetFolders();
+  virtual nsresult GetFolderFromMsgURI(const char *aMsgURI, nsIMsgFolder **aFolder);
+
+  virtual nsresult ListIdsInThread(nsIMsgThread *threadHdr, nsMsgViewIndex viewIndex, uint32_t *pNumListed);
+  nsresult ListUnreadIdsInThread(nsIMsgThread *threadHdr, nsMsgViewIndex startOfThreadViewIndex, uint32_t *pNumListed);
+  nsMsgViewIndex FindParentInThread(nsMsgKey parentKey, nsMsgViewIndex startOfThreadViewIndex);
+  virtual nsresult ListIdsInThreadOrder(nsIMsgThread *threadHdr,
+                                        nsMsgKey parentKey, uint32_t level,
+                                        nsMsgViewIndex *viewIndex,
+                                        uint32_t *pNumListed);
+  uint32_t GetSize(void) {return(m_keys.Length());}
+
+  // notification api's
+  void  NoteStartChange(nsMsgViewIndex firstlineChanged, int32_t numChanged,
+                        nsMsgViewNotificationCodeValue changeType);
+  void  NoteEndChange(nsMsgViewIndex firstlineChanged, int32_t numChanged,
+                        nsMsgViewNotificationCodeValue changeType);
+
+  // for commands
+  virtual nsresult ApplyCommandToIndices(nsMsgViewCommandTypeValue command, nsMsgViewIndex* indices,
+                                         int32_t numIndices);
+  virtual nsresult ApplyCommandToIndicesWithFolder(nsMsgViewCommandTypeValue command, nsMsgViewIndex* indices,
+                    int32_t numIndices, nsIMsgFolder *destFolder);
+  virtual nsresult CopyMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool isMove, nsIMsgFolder *destFolder);
+  virtual nsresult DeleteMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool deleteStorage);
+  nsresult GetHeadersFromSelection(uint32_t *indices, uint32_t numIndices, nsIMutableArray *messageArray);
+  virtual nsresult ListCollapsedChildren(nsMsgViewIndex viewIndex,
+                                         nsIMutableArray *messageArray);
+
+  nsresult SetMsgHdrJunkStatus(nsIJunkMailPlugin *aJunkPlugin,
+                               nsIMsgDBHdr *aMsgHdr,
+                               nsMsgJunkStatus aNewClassification);
+  nsresult ToggleReadByIndex(nsMsgViewIndex index);
+  nsresult SetReadByIndex(nsMsgViewIndex index, bool read);
+  nsresult SetThreadOfMsgReadByIndex(nsMsgViewIndex index, nsTArray<nsMsgKey> &keysMarkedRead, bool read);
+  nsresult SetFlaggedByIndex(nsMsgViewIndex index, bool mark);
+  nsresult SetLabelByIndex(nsMsgViewIndex index, nsMsgLabelValue label);
+  nsresult OrExtraFlag(nsMsgViewIndex index, uint32_t orflag);
+  nsresult AndExtraFlag(nsMsgViewIndex index, uint32_t andflag);
+  nsresult SetExtraFlag(nsMsgViewIndex index, uint32_t extraflag);
+  virtual nsresult RemoveByIndex(nsMsgViewIndex index);
+  virtual void OnExtraFlagChanged(nsMsgViewIndex /*index*/, uint32_t /*extraFlag*/) {}
+  virtual void OnHeaderAddedOrDeleted() {}	
+  nsresult ToggleWatched( nsMsgViewIndex* indices,	int32_t numIndices);
+  nsresult SetThreadWatched(nsIMsgThread *thread, nsMsgViewIndex index, bool watched);
+  nsresult SetThreadIgnored(nsIMsgThread *thread, nsMsgViewIndex threadIndex, bool ignored);
+  nsresult SetSubthreadKilled(nsIMsgDBHdr *header, nsMsgViewIndex msgIndex, bool ignored);
+  nsresult DownloadForOffline(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices);
+  nsresult DownloadFlaggedForOffline(nsIMsgWindow *window);
+  nsMsgViewIndex	GetThreadFromMsgIndex(nsMsgViewIndex index, nsIMsgThread **threadHdr);
+  /// Should junk commands be enabled for the current message in the view?
+  bool JunkControlsEnabled(nsMsgViewIndex aViewIndex);
+
+  // for sorting
+  nsresult GetFieldTypeAndLenForSort(nsMsgViewSortTypeValue sortType,
+                                        uint16_t *pMaxLen,
+                                        eFieldType *pFieldType,
+                                        nsIMsgCustomColumnHandler* colHandler = nullptr);
+  nsresult GetCollationKey(nsIMsgDBHdr *msgHdr,
+                             nsMsgViewSortTypeValue sortType,
+                             uint8_t **result,
+                             uint32_t *len,
+                             nsIMsgCustomColumnHandler* colHandler = nullptr);
+  nsresult GetLongField(nsIMsgDBHdr *msgHdr,
+                          nsMsgViewSortTypeValue sortType,
+                          uint32_t *result,
+                          nsIMsgCustomColumnHandler* colHandler = nullptr);
+
+  static int FnSortIdKey(const void *pItem1, const void *pItem2, void *privateData);
+  static int FnSortIdKeyPtr(const void *pItem1, const void *pItem2, void *privateData);
+  static int FnSortIdUint32(const void *pItem1, const void *pItem2, void *privateData);
+
+  nsresult GetStatusSortValue(nsIMsgDBHdr *msgHdr, uint32_t *result);
+  nsresult GetLocationCollationKey(nsIMsgDBHdr *msgHdr, uint8_t **result, uint32_t *len);
+  void PushSort(const MsgViewSortColumnInfo &newSort);
+  nsresult EncodeColumnSort(nsString &columnSortString);
+  nsresult DecodeColumnSort(nsString &columnSortString);
+  // for view navigation
+  nsresult NavigateFromPos(nsMsgNavigationTypeValue motion, nsMsgViewIndex startIndex, nsMsgKey *pResultKey, 
+              nsMsgViewIndex *pResultIndex, nsMsgViewIndex *pThreadIndex, bool wrap);
+  nsresult FindNextFlagged(nsMsgViewIndex startIndex, nsMsgViewIndex *pResultIndex);
+  nsresult FindFirstNew(nsMsgViewIndex *pResultIndex);
+  nsresult FindPrevUnread(nsMsgKey startKey, nsMsgKey *pResultKey, nsMsgKey *resultThreadId);
+  nsresult FindFirstFlagged(nsMsgViewIndex *pResultIndex);
+  nsresult FindPrevFlagged(nsMsgViewIndex startIndex, nsMsgViewIndex *pResultIndex);
+  nsresult MarkThreadOfMsgRead(nsMsgKey msgId, nsMsgViewIndex msgIndex, nsTArray<nsMsgKey> &idsMarkedRead, bool bRead);
+  nsresult MarkThreadRead(nsIMsgThread *threadHdr, nsMsgViewIndex threadIndex, nsTArray<nsMsgKey> &idsMarkedRead, bool bRead);
+  bool IsValidIndex(nsMsgViewIndex index);
+  nsresult ToggleIgnored(nsMsgViewIndex * indices, int32_t numIndices, nsMsgViewIndex *resultIndex, bool *resultToggleState);
+  nsresult ToggleMessageKilled(nsMsgViewIndex * indices, int32_t numIndices, nsMsgViewIndex *resultIndex, bool *resultToggleState);
+  bool OfflineMsgSelected(nsMsgViewIndex * indices, int32_t numIndices);
+  bool NonDummyMsgSelected(nsMsgViewIndex * indices, int32_t numIndices);
+  char16_t * GetString(const char16_t *aStringName);
+  nsresult GetPrefLocalizedString(const char *aPrefName, nsString& aResult);
+  nsresult GetLabelPrefStringAndAtom(const char *aPrefName, nsString& aColor, nsIAtom** aColorAtom);
+  nsresult AppendKeywordProperties(const nsACString& keywords, nsAString& properties, bool addSelectedTextProperty);
+  nsresult InitLabelStrings(void);
+  nsresult CopyDBView(nsMsgDBView *aNewMsgDBView, nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater);
+  void InitializeAtomsAndLiterals();
+  virtual int32_t FindLevelInThread(nsIMsgDBHdr *msgHdr, nsMsgViewIndex startOfThread, nsMsgViewIndex viewIndex);
+  nsresult GetImapDeleteModel(nsIMsgFolder *folder);
+  nsresult UpdateDisplayMessage(nsMsgViewIndex viewPosition);
+  nsresult GetDBForHeader(nsIMsgDBHdr *msgHdr, nsIMsgDatabase **db);
+
+  bool AdjustReadFlag(nsIMsgDBHdr *msgHdr, uint32_t *msgFlags);
+  void FreeAll(nsTArray<void*> *ptrs);
+  void ClearHdrCache();
+  nsTArray<nsMsgKey> m_keys;
+  nsTArray<uint32_t> m_flags;
+  nsTArray<uint8_t> m_levels;
+  nsMsgImapDeleteModel mDeleteModel;
+
+  // cache the most recently asked for header and corresponding msgKey.
+  nsCOMPtr <nsIMsgDBHdr>  m_cachedHdr;
+  nsMsgKey                m_cachedMsgKey;
+
+  // we need to store the message key for the message we are currenty displaying to ensure we
+  // don't try to redisplay the same message just because the selection changed (i.e. after a sort)
+  nsMsgKey                m_currentlyDisplayedMsgKey;
+  nsCString               m_currentlyDisplayedMsgUri;
+  nsMsgViewIndex          m_currentlyDisplayedViewIndex;
+  // if we're deleting messages, we want to hold off loading messages on selection changed until the delete is done
+  // and we want to batch notifications.
+  bool m_deletingRows;
+  // for certain special folders 
+  // and decendents of those folders
+  // (like the "Sent" folder, "Sent/Old Sent")
+  // the Sender column really shows recipients.
+
+  // Server types for this view's folder
+  bool mIsNews;             // we have special icons for news
+  bool mIsRss;              // rss affects enabling of junk commands
+  bool mIsXFVirtual;        // a virtual folder with multiple folders
+
+  bool mShowSizeInLines;    // for news we show lines instead of size when true
+  bool mSortThreadsByRoot;  // as opposed to by the newest message
+  bool m_sortValid;
+  bool m_checkedCustomColumns;
+  bool mSelectionSummarized;
+  // we asked the front end to summarize the selection and it did not.
+  bool mSummarizeFailed;
+  uint8_t      m_saveRestoreSelectionDepth;
+
+  nsCOMPtr <nsIMsgDatabase> m_db;
+  nsCOMPtr <nsIMsgFolder> m_folder;
+  nsCOMPtr <nsIMsgFolder> m_viewFolder; // for virtual folders, the VF db.
+  nsString mMessageType;
+  nsTArray <MsgViewSortColumnInfo> m_sortColumns;
+  nsMsgViewSortTypeValue  m_sortType;
+  nsMsgViewSortOrderValue m_sortOrder;
+  nsString m_curCustomColumn;
+  nsMsgViewSortTypeValue m_secondarySort;
+  nsMsgViewSortOrderValue m_secondarySortOrder;
+  nsString m_secondaryCustomColumn;
+  nsMsgViewFlagsTypeValue m_viewFlags;
+
+  // I18N date formatter service which we'll want to cache locally.
+  nsCOMPtr<nsIDateTimeFormat> mDateFormatter;
+  nsCOMPtr<nsIMsgTagService> mTagService;
+  nsWeakPtr mMessengerWeak;
+  nsWeakPtr mMsgWindowWeak;
+  nsCOMPtr<nsIMsgDBViewCommandUpdater> mCommandUpdater; // we push command update notifications to the UI from this.
+  nsCOMPtr<nsIStringBundle> mMessengerStringBundle;  
+
+  // used for the preference labels
+  nsString mLabelPrefDescriptions[PREF_LABELS_MAX];
+  nsString mLabelPrefColors[PREF_LABELS_MAX];
+  // used to cache the atoms created for each color to be displayed
+  static nsIAtom* mLabelPrefColorAtoms[PREF_LABELS_MAX];
+
+  // used to determine when to start and end
+  // junk plugin batches
+  uint32_t mNumMessagesRemainingInBatch;
+
+  // these are the headers of the messages in the current
+  // batch/series of batches of messages manually marked
+  // as junk
+  nsCOMPtr<nsIMutableArray> mJunkHdrs;
+  
+  nsTArray<uint32_t> mIndicesToNoteChange;
+
+  nsTHashtable<nsCStringHashKey> mEmails;
+
+  // the saved search views keep track of the XX most recently deleted msg ids, so that if the 
+  // delete is undone, we can add the msg back to the search results, even if it no longer
+  // matches the search criteria (e.g., a saved search over unread messages).
+  // We use mRecentlyDeletedArrayIndex to treat the array as a list of the XX
+  // most recently deleted msgs.
+  nsTArray<nsCString> mRecentlyDeletedMsgIds;
+  uint32_t mRecentlyDeletedArrayIndex;
+  void RememberDeletedMsgHdr(nsIMsgDBHdr *msgHdr);
+  bool WasHdrRecentlyDeleted(nsIMsgDBHdr *msgHdr);
+  
+  //these hold pointers (and IDs) for the nsIMsgCustomColumnHandler object that constitutes the custom column handler
+  nsCOMArray <nsIMsgCustomColumnHandler> m_customColumnHandlers;
+  nsTArray<nsString> m_customColumnHandlerIDs;
+  
+  nsIMsgCustomColumnHandler* GetColumnHandler(const char16_t*);
+  nsIMsgCustomColumnHandler* GetCurColumnHandler();
+  bool CustomColumnsInSortAndNotRegistered();
+  void EnsureCustomColumnsValid();
+
+#ifdef DEBUG_David_Bienvenu
+void InitEntryInfoForIndex(nsMsgViewIndex i, IdKeyPtr &EntryInfo);
+void ValidateSort();
+#endif
+
+protected:
+  static nsresult   InitDisplayFormats();
+
+private:
+  static nsDateFormatSelector  m_dateFormatDefault;
+  static nsDateFormatSelector  m_dateFormatThisWeek;
+  static nsDateFormatSelector  m_dateFormatToday;
+  bool ServerSupportsFilterAfterTheFact();
+
+  nsresult PerformActionsOnJunkMsgs(bool msgsAreJunk);
+  nsresult DetermineActionsForJunkChange(bool msgsAreJunk,
+                                         nsIMsgFolder *srcFolder,
+                                         bool &moveMessages,
+                                         bool &changeReadState,
+                                         nsIMsgFolder** targetFolder);
+
+  class nsMsgViewHdrEnumerator final : public nsISimpleEnumerator
+  {
+  public:
+    NS_DECL_ISUPPORTS
+
+    // nsISimpleEnumerator methods:
+    NS_DECL_NSISIMPLEENUMERATOR
+
+    // nsMsgThreadEnumerator methods:
+    nsMsgViewHdrEnumerator(nsMsgDBView *view);
+
+    RefPtr<nsMsgDBView> m_view;
+    nsMsgViewIndex m_curHdrIndex;
+
+  private:
+    ~nsMsgViewHdrEnumerator();
+  };
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgFolderCache.cpp b/mailnews/base/src/nsMsgFolderCache.cpp
new file mode 100644
index 000000000..9510a6e3d
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderCache.cpp
@@ -0,0 +1,376 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgFolderCacheElement.h"
+#include "nsMsgFolderCache.h"
+#include "nsMorkCID.h"
+#include "nsIMdbFactoryFactory.h"
+#include "nsMsgBaseCID.h"
+#include "nsServiceManagerUtils.h"
+
+const char *kFoldersScope = "ns:msg:db:row:scope:folders:all";	// scope for all folders table
+const char *kFoldersTableKind = "ns:msg:db:table:kind:folders";
+
+nsMsgFolderCache::nsMsgFolderCache()
+{
+  m_mdbEnv = nullptr;
+  m_mdbStore = nullptr;
+  m_mdbAllFoldersTable = nullptr;
+}
+
+// should this, could this be an nsCOMPtr ?
+static nsIMdbFactory *gMDBFactory = nullptr;
+
+nsMsgFolderCache::~nsMsgFolderCache()
+{
+  m_cacheElements.Clear(); // make sure the folder cache elements are released before we release our m_mdb objects...
+  if (m_mdbAllFoldersTable)
+    m_mdbAllFoldersTable->Release();
+  if (m_mdbStore)
+    m_mdbStore->Release();
+  NS_IF_RELEASE(gMDBFactory);
+  if (m_mdbEnv)
+    m_mdbEnv->Release();
+}
+
+
+NS_IMPL_ISUPPORTS(nsMsgFolderCache, nsIMsgFolderCache)
+
+void nsMsgFolderCache::GetMDBFactory(nsIMdbFactory ** aMdbFactory)
+{
+  if (!mMdbFactory)
+  {
+    nsresult rv;
+    nsCOMPtr <nsIMdbFactoryService> mdbFactoryService = do_GetService(NS_MORK_CONTRACTID, &rv);
+    if (NS_SUCCEEDED(rv) && mdbFactoryService)
+      rv = mdbFactoryService->GetMdbFactory(getter_AddRefs(mMdbFactory));
+  }
+  NS_IF_ADDREF(*aMdbFactory = mMdbFactory);
+}
+
+// initialize the various tokens and tables in our db's env
+nsresult nsMsgFolderCache::InitMDBInfo()
+{
+  nsresult err = NS_OK;
+  if (GetStore())
+  {
+    err = GetStore()->StringToToken(GetEnv(), kFoldersScope, &m_folderRowScopeToken);
+    if (NS_SUCCEEDED(err))
+    {
+      err = GetStore()->StringToToken(GetEnv(), kFoldersTableKind, &m_folderTableKindToken);
+      if (NS_SUCCEEDED(err))
+      {
+        // The table of all message hdrs will have table id 1.
+        m_allFoldersTableOID.mOid_Scope = m_folderRowScopeToken;
+        m_allFoldersTableOID.mOid_Id = 1;
+      }
+    }
+  }
+  return err;
+}
+
+// set up empty tables, dbFolderInfo, etc.
+nsresult nsMsgFolderCache::InitNewDB()
+{
+  nsresult err = InitMDBInfo();
+  if (NS_SUCCEEDED(err))
+  {
+    nsIMdbStore *store = GetStore();
+    // create the unique table for the dbFolderInfo.
+    // TODO: this error assignment is suspicious and never checked.
+    (void) store->NewTable(GetEnv(), m_folderRowScopeToken, m_folderTableKindToken,
+                           false, nullptr, &m_mdbAllFoldersTable);
+  }
+  return err;
+}
+
+nsresult nsMsgFolderCache::InitExistingDB()
+{
+  nsresult err = InitMDBInfo();
+  if (NS_FAILED(err))
+    return err;
+
+  err = GetStore()->GetTable(GetEnv(), &m_allFoldersTableOID, &m_mdbAllFoldersTable);
+  if (NS_SUCCEEDED(err) && m_mdbAllFoldersTable)
+  {
+    nsIMdbTableRowCursor* rowCursor = nullptr;
+    err = m_mdbAllFoldersTable->GetTableRowCursor(GetEnv(), -1, &rowCursor);
+    if (NS_SUCCEEDED(err) && rowCursor)
+    {
+      // iterate over the table rows and create nsMsgFolderCacheElements for each.
+      while (true)
+      {
+        nsresult rv;
+        nsIMdbRow* hdrRow;
+        mdb_pos rowPos;
+
+        rv = rowCursor->NextRow(GetEnv(), &hdrRow, &rowPos);
+        if (NS_FAILED(rv) || !hdrRow)
+          break;
+
+        rv = AddCacheElement(EmptyCString(), hdrRow, nullptr);
+        hdrRow->Release();
+        if (NS_FAILED(rv))
+          return rv;
+      }
+      rowCursor->Release();
+    }
+  }
+  else
+    err = NS_ERROR_FAILURE;
+
+  return err;
+}
+
+nsresult nsMsgFolderCache::OpenMDB(const nsACString& dbName, bool exists)
+{
+  nsresult ret=NS_OK;
+  nsCOMPtr<nsIMdbFactory> mdbFactory;
+  GetMDBFactory(getter_AddRefs(mdbFactory));
+  if (mdbFactory)
+  {
+    ret = mdbFactory->MakeEnv(nullptr, &m_mdbEnv);
+    if (NS_SUCCEEDED(ret))
+    {
+      nsIMdbThumb *thumb = nullptr;
+      nsIMdbHeap* dbHeap = nullptr;
+
+      if (m_mdbEnv)
+        m_mdbEnv->SetAutoClear(true);
+      if (exists)
+      {
+        mdbOpenPolicy inOpenPolicy;
+        mdb_bool canOpen;
+        mdbYarn outFormatVersion;
+
+        nsIMdbFile* oldFile = nullptr;
+        ret = mdbFactory->OpenOldFile(m_mdbEnv, dbHeap, nsCString(dbName).get(),
+                                      mdbBool_kFalse, // not readonly, we want modifiable
+                                      &oldFile);
+        if ( oldFile )
+        {
+          if (NS_SUCCEEDED(ret))
+          {
+            ret = mdbFactory->CanOpenFilePort(m_mdbEnv, oldFile, // file to investigate
+              &canOpen, &outFormatVersion);
+            if (NS_SUCCEEDED(ret) && canOpen)
+            {
+              inOpenPolicy.mOpenPolicy_ScopePlan.mScopeStringSet_Count = 0;
+              inOpenPolicy.mOpenPolicy_MinMemory = 0;
+              inOpenPolicy.mOpenPolicy_MaxLazy = 0;
+
+              ret = mdbFactory->OpenFileStore(m_mdbEnv, NULL, oldFile, &inOpenPolicy,
+                &thumb);
+            }
+            else
+              ret = NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE;
+          }
+          NS_RELEASE(oldFile); // always release our file ref, store has own
+        }
+      }
+      if (NS_SUCCEEDED(ret) && thumb)
+      {
+        mdb_count outTotal;    // total somethings to do in operation
+        mdb_count outCurrent;  // subportion of total completed so far
+        mdb_bool outDone = false;      // is operation finished?
+        mdb_bool outBroken;     // is operation irreparably dead and broken?
+        do
+        {
+          ret = thumb->DoMore(m_mdbEnv, &outTotal, &outCurrent, &outDone, &outBroken);
+          if (NS_FAILED(ret))
+          {
+            outDone = true;
+            break;
+          }
+        }
+        while (NS_SUCCEEDED(ret) && !outBroken && !outDone);
+        // m_mdbEnv->ClearErrors(); // ### temporary...
+        if (NS_SUCCEEDED(ret) && outDone)
+        {
+          ret = mdbFactory->ThumbToOpenStore(m_mdbEnv, thumb, &m_mdbStore);
+          if (NS_SUCCEEDED(ret) && m_mdbStore)
+            ret = InitExistingDB();
+        }
+#ifdef DEBUG_bienvenu1
+        DumpContents();
+#endif
+      }
+      else // ### need error code saying why open file store failed
+      {
+        nsIMdbFile* newFile = 0;
+        ret = mdbFactory->CreateNewFile(m_mdbEnv, dbHeap, nsCString(dbName).get(), &newFile);
+        if ( newFile )
+        {
+          if (NS_SUCCEEDED(ret))
+          {
+            mdbOpenPolicy inOpenPolicy;
+
+            inOpenPolicy.mOpenPolicy_ScopePlan.mScopeStringSet_Count = 0;
+            inOpenPolicy.mOpenPolicy_MinMemory = 0;
+            inOpenPolicy.mOpenPolicy_MaxLazy = 0;
+
+            ret = mdbFactory->CreateNewFileStore(m_mdbEnv, dbHeap,
+              newFile, &inOpenPolicy, &m_mdbStore);
+            if (NS_SUCCEEDED(ret))
+              ret = InitNewDB();
+          }
+          NS_RELEASE(newFile); // always release our file ref, store has own
+        }
+
+      }
+      NS_IF_RELEASE(thumb);
+    }
+  }
+  return ret;
+}
+
+NS_IMETHODIMP nsMsgFolderCache::Init(nsIFile *aFile)
+{
+  NS_ENSURE_ARG_POINTER(aFile);
+
+  bool exists;
+  aFile->Exists(&exists);
+
+  nsAutoCString dbPath;
+  aFile->GetNativePath(dbPath);
+  // ### evil cast until MDB supports file streams.
+  nsresult rv = OpenMDB(dbPath, exists);
+  // if this fails and panacea.dat exists, try blowing away the db and recreating it
+  if (NS_FAILED(rv) && exists)
+  {
+    if (m_mdbStore)
+      m_mdbStore->Release();
+    aFile->Remove(false);
+    rv = OpenMDB(dbPath, false);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgFolderCache::GetCacheElement(const nsACString& pathKey, bool createIfMissing,
+                                                nsIMsgFolderCacheElement **result)
+{
+  NS_ENSURE_ARG_POINTER(result);
+  NS_ENSURE_TRUE(!pathKey.IsEmpty(), NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIMsgFolderCacheElement> folderCacheEl;
+  m_cacheElements.Get(pathKey, getter_AddRefs(folderCacheEl));
+  folderCacheEl.swap(*result);
+
+  if (*result)
+    return NS_OK;
+  else if (createIfMissing)
+  {
+    nsIMdbRow* hdrRow;
+
+    if (GetStore())
+    {
+      nsresult err = GetStore()->NewRow(GetEnv(), m_folderRowScopeToken, // row scope for row ids
+        &hdrRow);
+      if (NS_SUCCEEDED(err) && hdrRow)
+      {
+        m_mdbAllFoldersTable->AddRow(GetEnv(), hdrRow);
+        nsresult ret = AddCacheElement(pathKey, hdrRow, result);
+        if (*result)
+          (*result)->SetStringProperty("key", pathKey);
+        hdrRow->Release();
+        return ret;
+      }
+    }
+  }
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMsgFolderCache::RemoveElement(const nsACString& key)
+{
+  nsCOMPtr<nsIMsgFolderCacheElement> folderCacheEl;
+  m_cacheElements.Get(key, getter_AddRefs(folderCacheEl));
+  if (!folderCacheEl)
+    return NS_ERROR_FAILURE;
+  nsMsgFolderCacheElement *element = static_cast<nsMsgFolderCacheElement *>(static_cast<nsISupports *>(folderCacheEl.get())); // why the double cast??
+  m_mdbAllFoldersTable->CutRow(GetEnv(), element->m_mdbRow);
+  m_cacheElements.Remove(key);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFolderCache::Clear()
+{
+  m_cacheElements.Clear();
+  if (m_mdbAllFoldersTable)
+    m_mdbAllFoldersTable->CutAllRows(GetEnv());
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFolderCache::Close()
+{
+  return Commit(true);
+}
+
+NS_IMETHODIMP nsMsgFolderCache::Commit(bool compress)
+{
+  nsresult ret = NS_OK;
+  nsIMdbThumb *commitThumb = nullptr;
+  if (m_mdbStore)
+  {
+    if (compress)
+      ret = m_mdbStore->CompressCommit(GetEnv(), &commitThumb);
+    else
+      ret = m_mdbStore->LargeCommit(GetEnv(), &commitThumb);
+  }
+
+  if (commitThumb)
+  {
+    mdb_count outTotal = 0;    // total somethings to do in operation
+    mdb_count outCurrent = 0;  // subportion of total completed so far
+    mdb_bool outDone = false;      // is operation finished?
+    mdb_bool outBroken = false;     // is operation irreparably dead and broken?
+    while (!outDone && !outBroken && NS_SUCCEEDED(ret))
+      ret = commitThumb->DoMore(GetEnv(), &outTotal, &outCurrent, &outDone, &outBroken);
+    NS_IF_RELEASE(commitThumb);
+  }
+  // ### do something with error, but clear it now because mork errors out on commits.
+  if (GetEnv())
+    GetEnv()->ClearErrors();
+  return ret;
+}
+
+nsresult nsMsgFolderCache::AddCacheElement(const nsACString& key, nsIMdbRow *row, nsIMsgFolderCacheElement **result)
+{
+  nsMsgFolderCacheElement *cacheElement = new nsMsgFolderCacheElement;
+  NS_ENSURE_TRUE(cacheElement, NS_ERROR_OUT_OF_MEMORY);
+  nsCOMPtr<nsIMsgFolderCacheElement> folderCacheEl(do_QueryInterface(cacheElement));
+
+  cacheElement->SetMDBRow(row);
+  cacheElement->SetOwningCache(this);
+  nsCString hashStrKey(key);
+  // if caller didn't pass in key, try to get it from row.
+  if (key.IsEmpty())
+    folderCacheEl->GetStringProperty("key", hashStrKey);
+  folderCacheEl->SetKey(hashStrKey);
+  m_cacheElements.Put(hashStrKey, folderCacheEl);
+  if (result)
+    folderCacheEl.swap(*result);
+  return NS_OK;
+}
+
+nsresult nsMsgFolderCache::RowCellColumnToCharPtr(nsIMdbRow *hdrRow, mdb_token columnToken, nsACString& resultStr)
+{
+  nsresult err = NS_OK;
+  nsIMdbCell *hdrCell;
+  if (hdrRow) // ### probably should be an error if hdrRow is NULL...
+  {
+    err = hdrRow->GetCell(GetEnv(), columnToken, &hdrCell);
+    if (NS_SUCCEEDED(err) && hdrCell)
+    {
+      struct mdbYarn yarn;
+      hdrCell->AliasYarn(GetEnv(), &yarn);
+      resultStr.Assign((const char *)yarn.mYarn_Buf, yarn.mYarn_Fill);
+      resultStr.SetLength(yarn.mYarn_Fill); // ensure the string is null terminated.
+      hdrCell->Release(); // always release ref
+    }
+  }
+  return err;
+}
diff --git a/mailnews/base/src/nsMsgFolderCache.h b/mailnews/base/src/nsMsgFolderCache.h
new file mode 100644
index 000000000..88536084b
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderCache.h
@@ -0,0 +1,50 @@
+/* -*- 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 nsMsgFolderCache_H
+#define nsMsgFolderCache_H
+
+#include "nsIMsgFolderCache.h"
+#include "nsIMsgFolderCacheElement.h"
+#include "nsInterfaceHashtable.h"
+#include "nsCOMPtr.h"
+#include "mdb.h"
+
+class nsMsgFolderCache : public nsIMsgFolderCache
+{
+
+public:
+  friend class nsMsgFolderCacheElement;
+
+  nsMsgFolderCache();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGFOLDERCACHE
+
+protected:
+  virtual ~nsMsgFolderCache();
+
+  void GetMDBFactory(nsIMdbFactory ** aMdbFactory);
+  nsresult AddCacheElement(const nsACString& key, nsIMdbRow *row, nsIMsgFolderCacheElement **result);
+  nsresult RowCellColumnToCharPtr(nsIMdbRow *hdrRow, mdb_token columnToken, nsACString& resultPtr);
+  nsresult InitMDBInfo();
+  nsresult InitNewDB();
+  nsresult InitExistingDB();
+  nsresult OpenMDB(const nsACString& dbName, bool create);
+  nsIMdbEnv *GetEnv() {return m_mdbEnv;}
+  nsIMdbStore *GetStore() {return m_mdbStore;}
+  nsInterfaceHashtable<nsCStringHashKey, nsIMsgFolderCacheElement> m_cacheElements;
+  // mdb stuff
+  nsIMdbEnv           *m_mdbEnv; // to be used in all the db calls.
+  nsIMdbStore         *m_mdbStore;
+  nsIMdbTable         *m_mdbAllFoldersTable;
+  mdb_token           m_folderRowScopeToken;
+  mdb_token           m_folderTableKindToken;
+  nsCOMPtr<nsIMdbFactory> mMdbFactory;
+
+  struct mdbOid       m_allFoldersTableOID;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgFolderCacheElement.cpp b/mailnews/base/src/nsMsgFolderCacheElement.cpp
new file mode 100644
index 000000000..e1197c7ed
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderCacheElement.cpp
@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"
+#include "nsMsgFolderCacheElement.h"
+#include "prmem.h"
+#include "nsMsgUtils.h"
+
+nsMsgFolderCacheElement::nsMsgFolderCacheElement()
+{
+  m_mdbRow = nullptr;
+  m_owningCache = nullptr;
+}
+
+nsMsgFolderCacheElement::~nsMsgFolderCacheElement()
+{
+  NS_IF_RELEASE(m_mdbRow);
+  // circular reference, don't do it.
+  // NS_IF_RELEASE(m_owningCache);
+}
+
+NS_IMPL_ISUPPORTS(nsMsgFolderCacheElement, nsIMsgFolderCacheElement)
+
+NS_IMETHODIMP nsMsgFolderCacheElement::GetKey(nsACString& aFolderKey)
+{
+  aFolderKey = m_folderKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFolderCacheElement::SetKey(const nsACString& aFolderKey)
+{
+  m_folderKey = aFolderKey;
+  return NS_OK;
+}
+
+void nsMsgFolderCacheElement::SetOwningCache(nsMsgFolderCache *owningCache)
+{
+  m_owningCache = owningCache;
+  // circular reference, don't do it.
+  //  if (owningCache)
+  //    NS_ADDREF(owningCache);
+}
+
+NS_IMETHODIMP nsMsgFolderCacheElement::GetStringProperty(const char *propertyName, nsACString& result)
+{
+  NS_ENSURE_ARG_POINTER(propertyName);
+  NS_ENSURE_TRUE(m_mdbRow && m_owningCache, NS_ERROR_FAILURE);
+
+  mdb_token property_token;
+  nsresult ret = m_owningCache->GetStore()->StringToToken(m_owningCache->GetEnv(),  propertyName, &property_token);
+  if (NS_SUCCEEDED(ret))
+    ret = m_owningCache->RowCellColumnToCharPtr(m_mdbRow, property_token, result);
+  return ret;
+}
+
+NS_IMETHODIMP nsMsgFolderCacheElement::GetInt32Property(const char *propertyName, int32_t *aResult)
+{
+  NS_ENSURE_ARG_POINTER(propertyName);
+  NS_ENSURE_ARG_POINTER(aResult);
+  NS_ENSURE_TRUE(m_mdbRow, NS_ERROR_FAILURE);
+
+  nsCString resultStr;
+  GetStringProperty(propertyName, resultStr);
+  if (resultStr.IsEmpty())
+    return NS_ERROR_FAILURE;
+
+  // This must be an inverse function to nsCString.AppentInt(),
+  // which uses snprintf("%x") internally, so that the wrapped negative numbers
+  // are decoded properly.
+  if (PR_sscanf(resultStr.get(), "%x", aResult) != 1)
+  {
+    NS_WARNING("Unexpected failure to decode hex string.");
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFolderCacheElement::GetInt64Property(const char *propertyName, int64_t *aResult)
+{
+  NS_ENSURE_ARG_POINTER(propertyName);
+  NS_ENSURE_ARG_POINTER(aResult);
+  NS_ENSURE_TRUE(m_mdbRow, NS_ERROR_FAILURE);
+
+  nsCString resultStr;
+  GetStringProperty(propertyName, resultStr);
+  if (resultStr.IsEmpty())
+    return NS_ERROR_FAILURE;
+
+  // This must be an inverse function to nsCString.AppentInt(),
+  // which uses snprintf("%x") internally, so that the wrapped negative numbers
+  // are decoded properly.
+  if (PR_sscanf(resultStr.get(), "%llx", aResult) != 1)
+  {
+    NS_WARNING("Unexpected failure to decode hex string.");
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFolderCacheElement::SetStringProperty(const char *propertyName, const nsACString& propertyValue)
+{
+  NS_ENSURE_ARG_POINTER(propertyName);
+  NS_ENSURE_TRUE(m_mdbRow, NS_ERROR_FAILURE);
+  nsresult rv = NS_OK;
+  mdb_token property_token;
+
+  if (m_owningCache)
+  {
+    rv = m_owningCache->GetStore()->StringToToken(m_owningCache->GetEnv(), propertyName, &property_token);
+    if (NS_SUCCEEDED(rv))
+    {
+      struct mdbYarn yarn;
+
+      yarn.mYarn_Grow = NULL;
+      if (m_mdbRow)
+      {
+        nsCString propertyVal (propertyValue);
+        yarn.mYarn_Buf = (void *) propertyVal.get();
+        yarn.mYarn_Size = strlen((const char *) yarn.mYarn_Buf) + 1;
+        yarn.mYarn_Fill = yarn.mYarn_Size - 1;
+        yarn.mYarn_Form = 0; // what to do with this? we're storing csid in the msg hdr...
+        rv = m_mdbRow->AddColumn(m_owningCache->GetEnv(), property_token, &yarn);
+        return rv;
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgFolderCacheElement::SetInt32Property(const char *propertyName, int32_t propertyValue)
+{
+  NS_ENSURE_ARG_POINTER(propertyName);
+  NS_ENSURE_TRUE(m_mdbRow, NS_ERROR_FAILURE);
+
+  // This also supports encoding negative numbers into hex
+  // by integer wrapping them (e.g. -1 -> "ffffffff").
+  nsAutoCString propertyStr;
+  propertyStr.AppendInt(propertyValue, 16);
+  return SetStringProperty(propertyName, propertyStr);
+}
+
+NS_IMETHODIMP nsMsgFolderCacheElement::SetInt64Property(const char *propertyName, int64_t propertyValue)
+{
+  NS_ENSURE_ARG_POINTER(propertyName);
+  NS_ENSURE_TRUE(m_mdbRow, NS_ERROR_FAILURE);
+
+  // This also supports encoding negative numbers into hex
+  // by integer wrapping them (e.g. -1 -> "ffffffffffffffff").
+  nsAutoCString propertyStr;
+  propertyStr.AppendInt(propertyValue, 16);
+  return SetStringProperty(propertyName, propertyStr);
+}
+
+void nsMsgFolderCacheElement::SetMDBRow(nsIMdbRow *row)
+{
+  if (m_mdbRow)
+    NS_RELEASE(m_mdbRow);
+  NS_IF_ADDREF(m_mdbRow = row);
+}
diff --git a/mailnews/base/src/nsMsgFolderCacheElement.h b/mailnews/base/src/nsMsgFolderCacheElement.h
new file mode 100644
index 000000000..4abf0f08f
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderCacheElement.h
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsMsgFolderCacheElement_H
+#define nsMsgFolderCacheElement_H
+
+#include "nsIMsgFolderCacheElement.h"
+#include "nsMsgFolderCache.h"
+#include "mdb.h"
+
+class nsMsgFolderCacheElement : public nsIMsgFolderCacheElement
+{
+public:
+  nsMsgFolderCacheElement();
+  friend class nsMsgFolderCache;
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGFOLDERCACHEELEMENT
+
+  void SetMDBRow(nsIMdbRow *row);
+  void SetOwningCache(nsMsgFolderCache *owningCache);
+protected:
+  virtual ~nsMsgFolderCacheElement();
+
+  nsIMdbRow *m_mdbRow;
+
+  nsMsgFolderCache *m_owningCache; // this will be ref-counted. Is this going to be a problem?
+  // I want to avoid circular references, but since this is
+  // scriptable, I think I have to ref-count it.
+  nsCString m_folderKey;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgFolderCompactor.cpp b/mailnews/base/src/nsMsgFolderCompactor.cpp
new file mode 100644
index 000000000..4b0dc3ad5
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderCompactor.cpp
@@ -0,0 +1,1348 @@
+/* -*- 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 "nsIMsgFolder.h"
+#include "nsAutoPtr.h"
+#include "nsIFile.h"
+#include "nsNetUtil.h"
+#include "nsIMsgHdr.h"
+#include "nsIStreamListener.h"
+#include "nsIMsgMessageService.h"
+#include "nsMsgDBCID.h"
+#include "nsMsgUtils.h"
+#include "nsISeekableStream.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIDocShell.h"
+#include "nsIPrompt.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsMailHeaders.h"
+#include "nsMsgI18N.h"
+#include "prprf.h"
+#include "nsMsgLocalFolderHdrs.h"
+#include "nsIMsgDatabase.h"
+#include "nsArrayUtils.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsIMsgPluggableStore.h"
+#include "nsMsgFolderCompactor.h"
+#include <algorithm>
+#include "nsIOutputStream.h"
+#include "nsIInputStream.h"
+#include "nsPrintfCString.h"
+
+
+//////////////////////////////////////////////////////////////////////////////
+// nsFolderCompactState
+//////////////////////////////////////////////////////////////////////////////
+
+NS_IMPL_ISUPPORTS(nsFolderCompactState, nsIMsgFolderCompactor, nsIRequestObserver, nsIStreamListener, nsICopyMessageStreamListener, nsIUrlListener)
+
+nsFolderCompactState::nsFolderCompactState()
+{
+  m_fileStream = nullptr;
+  m_size = 0;
+  m_curIndex = 0;
+  m_status = NS_OK;
+  m_compactAll = false;
+  m_compactOfflineAlso = false;
+  m_compactingOfflineFolders = false;
+  m_parsingFolder=false;
+  m_folderIndex = 0;
+  m_startOfMsg = true;
+  m_needStatusLine = false;
+  m_totalExpungedBytes = 0;
+  m_alreadyWarnedDiskSpace = false;
+}
+
+nsFolderCompactState::~nsFolderCompactState()
+{
+  CloseOutputStream();
+  if (NS_FAILED(m_status))
+  {
+    CleanupTempFilesAfterError();
+    // if for some reason we failed remove the temp folder and database
+  }
+}
+
+void nsFolderCompactState::CloseOutputStream()
+{
+  if (m_fileStream)
+  {
+    m_fileStream->Close();
+    m_fileStream = nullptr;
+  }
+
+}
+
+void nsFolderCompactState::CleanupTempFilesAfterError()
+{
+  CloseOutputStream();
+  if (m_db)
+    m_db->ForceClosed();
+  nsCOMPtr <nsIFile> summaryFile;
+  GetSummaryFileLocation(m_file, getter_AddRefs(summaryFile)); 
+  m_file->Remove(false);
+  summaryFile->Remove(false);
+}
+
+nsresult nsFolderCompactState::BuildMessageURI(const char *baseURI, nsMsgKey key, nsCString& uri)
+{
+  uri.Append(baseURI);
+  uri.Append('#');
+  uri.AppendInt(key);
+
+  return NS_OK;
+}
+
+
+nsresult
+nsFolderCompactState::InitDB(nsIMsgDatabase *db)
+{
+  nsCOMPtr<nsIMsgDatabase> mailDBFactory;
+  nsresult rv = db->ListAllKeys(m_keyArray);
+  NS_ENSURE_SUCCESS(rv, rv);
+  m_size = m_keyArray->m_keys.Length();
+
+  nsCOMPtr<nsIMsgDBService> msgDBService = do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = msgDBService->OpenMailDBFromFile(m_file, m_folder, true, false,
+                                     getter_AddRefs(m_db));
+
+  if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE ||
+      rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING)
+      // if it's out of date then reopen with upgrade.
+    return msgDBService->OpenMailDBFromFile(m_file,
+                                            m_folder, true, true,
+                               getter_AddRefs(m_db));
+  return rv;
+}
+
+NS_IMETHODIMP nsFolderCompactState::CompactFolders(nsIArray *aArrayOfFoldersToCompact,
+                                                   nsIArray *aOfflineFolderArray,
+                                                   nsIUrlListener *aUrlListener,
+                                                   nsIMsgWindow *aMsgWindow)
+{
+  m_window = aMsgWindow;
+  m_listener = aUrlListener;
+  if (aArrayOfFoldersToCompact)
+    m_folderArray = aArrayOfFoldersToCompact;
+  else if (aOfflineFolderArray)
+  {
+    m_folderArray = aOfflineFolderArray;
+    m_compactingOfflineFolders = true;
+    aOfflineFolderArray = nullptr;
+  }
+  if (!m_folderArray)
+    return NS_OK;
+ 
+  m_compactAll = true;
+  m_compactOfflineAlso = aOfflineFolderArray != nullptr;
+  if (m_compactOfflineAlso)
+    m_offlineFolderArray = aOfflineFolderArray;
+
+  m_folderIndex = 0;
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgFolder> firstFolder = do_QueryElementAt(m_folderArray,
+                                                         m_folderIndex, &rv);
+
+  if (NS_SUCCEEDED(rv) && firstFolder)
+    Compact(firstFolder, m_compactingOfflineFolders, aUrlListener, 
+            aMsgWindow);   //start with first folder from here.
+  
+  return rv;
+}
+
+NS_IMETHODIMP
+nsFolderCompactState::Compact(nsIMsgFolder *folder, bool aOfflineStore,
+                              nsIUrlListener *aListener, nsIMsgWindow *aMsgWindow)
+{
+  NS_ENSURE_ARG_POINTER(folder);
+  m_listener = aListener;
+  if (!m_compactingOfflineFolders && !aOfflineStore)
+  {
+    nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(folder);
+    if (imapFolder)
+      return imapFolder->Expunge(this, aMsgWindow);
+  }
+
+   m_window = aMsgWindow;
+   nsresult rv;
+   nsCOMPtr<nsIMsgDatabase> db;
+   nsCOMPtr<nsIFile> path;
+   nsCString baseMessageURI;
+
+   nsCOMPtr <nsIMsgLocalMailFolder> localFolder = do_QueryInterface(folder, &rv);
+   if (NS_SUCCEEDED(rv) && localFolder)
+   {
+     rv=localFolder->GetDatabaseWOReparse(getter_AddRefs(db));
+     if (NS_FAILED(rv) || !db)
+     {
+       if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING ||
+           rv == NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE)
+       {
+         m_folder = folder;  //will be used to compact
+         m_parsingFolder = true;
+         rv = localFolder->ParseFolder(m_window, this);
+       }
+       return rv;
+     }
+     else
+     {
+       bool valid;
+       rv = db->GetSummaryValid(&valid);
+       if (!valid) //we are probably parsing the folder because we selected it.
+       {
+         folder->NotifyCompactCompleted();
+         if (m_compactAll)
+           return CompactNextFolder();
+         else
+           return NS_OK;
+       }
+     }
+   }
+   else
+   {
+     rv = folder->GetMsgDatabase(getter_AddRefs(db));
+     NS_ENSURE_SUCCESS(rv, rv);
+   }
+
+  rv = folder->GetFilePath(getter_AddRefs(path));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  do {
+    bool exists = false;
+    rv = path->Exists(&exists);
+    if (!exists) {
+      // No need to compact if the local file does not exist.
+      // Can happen e.g. on IMAP when the folder is not marked for offline use.
+      break;
+    }
+
+    int64_t expunged = 0;
+    folder->GetExpungedBytes(&expunged);
+    if (expunged == 0) {
+      // No need to compact if nothing would be expunged.
+      break;
+    }
+
+    int64_t diskSize;
+    rv = folder->GetSizeOnDisk(&diskSize);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    int64_t diskFree;
+    rv = path->GetDiskSpaceAvailable(&diskFree);
+    if (NS_FAILED(rv)) {
+      // If GetDiskSpaceAvailable() failed, better bail out fast.
+      if (rv != NS_ERROR_NOT_IMPLEMENTED)
+        return rv;
+      // Some platforms do not have GetDiskSpaceAvailable implemented.
+      // In that case skip the preventive free space analysis and let it
+      // fail in compact later if space actually wasn't available.
+    } else {
+      // Let's try to not even start compact if there is really low free space.
+      // It may still fail later as we do not know how big exactly the folder DB will
+      // end up being.
+      // The DB already doesn't contain references to messages that are already deleted.
+      // So theoretically it shouldn't shrink with compact. But in practice,
+      // the automatic shrinking of the DB may still have not yet happened.
+      // So we cap the final size at 1KB per message.
+      db->Commit(nsMsgDBCommitType::kCompressCommit);
+
+      int64_t dbSize;
+      rv = db->GetDatabaseSize(&dbSize);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      int32_t totalMsgs;
+      rv = folder->GetTotalMessages(false, &totalMsgs);
+      NS_ENSURE_SUCCESS(rv, rv);
+      int64_t expectedDBSize = std::min<int64_t>(dbSize, ((int64_t)totalMsgs) * 1024);
+      if (diskFree < diskSize - expunged + expectedDBSize)
+      {
+        if (!m_alreadyWarnedDiskSpace)
+        {
+          folder->ThrowAlertMsg("compactFolderInsufficientSpace", m_window);
+          m_alreadyWarnedDiskSpace = true;
+        }
+        break;
+      }
+    }
+
+    rv = folder->GetBaseMessageURI(baseMessageURI);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = Init(folder, baseMessageURI.get(), db, path, m_window);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    bool isLocked = true;
+    m_folder->GetLocked(&isLocked);
+    if (isLocked)
+    {
+      CleanupTempFilesAfterError();
+      m_folder->ThrowAlertMsg("compactFolderDeniedLock", m_window);
+      break;
+    }
+
+    // If we got here start the real compacting.
+    nsCOMPtr<nsISupports> supports = do_QueryInterface(static_cast<nsIMsgFolderCompactor*>(this));
+    m_folder->AcquireSemaphore(supports);
+    m_totalExpungedBytes += expunged;
+    return StartCompacting();
+
+  } while(false); // block for easy skipping the compaction using 'break'
+
+  folder->NotifyCompactCompleted();
+  if (m_compactAll)
+    return CompactNextFolder();
+  else
+    return NS_OK;
+}
+
+nsresult nsFolderCompactState::ShowStatusMsg(const nsString& aMsg)
+{
+  nsCOMPtr <nsIMsgStatusFeedback> statusFeedback;
+  if (m_window)
+  {
+    m_window->GetStatusFeedback(getter_AddRefs(statusFeedback));
+    if (statusFeedback && !aMsg.IsEmpty())
+      return statusFeedback->SetStatusString(aMsg);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsFolderCompactState::Init(nsIMsgFolder *folder, const char *baseMsgUri, nsIMsgDatabase *db,
+                           nsIFile *path, nsIMsgWindow *aMsgWindow)
+{
+  nsresult rv;
+
+  m_folder = folder;
+  m_baseMessageUri = baseMsgUri;
+  m_file = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  m_file->InitWithFile(path);
+  // need to make sure the temp file goes in the same real directory
+  // as the original file, so resolve sym links.
+  m_file->SetFollowLinks(true);
+
+  m_file->SetNativeLeafName(NS_LITERAL_CSTRING("nstmp"));
+  rv = m_file->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);   //make sure we are not crunching existing nstmp file
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  m_window = aMsgWindow;
+  m_keyArray = new nsMsgKeyArray;
+  m_size = 0;
+  m_totalMsgSize = 0;
+  rv = InitDB(db);
+  if (NS_FAILED(rv))
+  {
+    CleanupTempFilesAfterError();
+    return rv;
+  }
+
+  m_curIndex = 0;
+
+  rv = MsgNewBufferedFileOutputStream(getter_AddRefs(m_fileStream), m_file, -1, 00600);
+  if (NS_FAILED(rv)) 
+    m_folder->ThrowAlertMsg("compactFolderWriteFailed", m_window);
+  else
+    rv = GetMessageServiceFromURI(nsDependentCString(baseMsgUri),
+                                getter_AddRefs(m_messageService));
+  if (NS_FAILED(rv))
+  {
+    m_status = rv;
+  }
+  return rv;
+}
+
+void nsFolderCompactState::ShowCompactingStatusMsg()
+{
+  nsString statusString;
+  nsresult rv = m_folder->GetStringWithFolderNameFromBundle("compactingFolder", statusString);
+  if (!statusString.IsEmpty() && NS_SUCCEEDED(rv))
+    ShowStatusMsg(statusString);
+}
+
+NS_IMETHODIMP nsFolderCompactState::OnStartRunningUrl(nsIURI *url)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsFolderCompactState::OnStopRunningUrl(nsIURI *url, nsresult status)
+{
+  if (m_parsingFolder)
+  {
+    m_parsingFolder = false;
+    if (NS_SUCCEEDED(status))
+      status = Compact(m_folder, m_compactingOfflineFolders, m_listener, m_window);
+    else if (m_compactAll)
+      CompactNextFolder();
+  }
+  else if (m_compactAll) // this should be the imap case only
+  {
+    nsCOMPtr <nsIMsgFolder> prevFolder = do_QueryElementAt(m_folderArray,
+                                                           m_folderIndex);
+    if (prevFolder)
+      prevFolder->SetMsgDatabase(nullptr);
+    CompactNextFolder();
+  }
+  else if (m_listener)
+  {
+    CompactCompleted(status);
+  }
+  return NS_OK;
+}
+
+nsresult nsFolderCompactState::StartCompacting()
+{
+  nsCOMPtr<nsIMsgPluggableStore> msgStore;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  
+  nsresult rv = m_folder->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = server->GetMsgStore(getter_AddRefs(msgStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  // Notify that compaction is beginning.  We do this even if there are no
+  // messages to be copied because the summary database still gets blown away
+  // which is still pretty interesting.  (And we like consistency.)
+  nsCOMPtr<nsIMsgFolderNotificationService>
+    notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+  if (notifier)
+    notifier->NotifyItemEvent(m_folder,
+                              NS_LITERAL_CSTRING("FolderCompactStart"),
+                              nullptr);
+
+  // TODO: test whether sorting the messages (m_keyArray) by messageOffset
+  // would improve performance on large files (less seeks).
+  // The m_keyArray is in the order as stored in DB and on IMAP or News
+  // the messages stored on the mbox file are not necessarily in the same order.
+  if (m_size > 0)
+  {
+    nsCOMPtr<nsIURI> notUsed;
+    ShowCompactingStatusMsg();
+    AddRef();
+    rv = m_messageService->CopyMessages(m_size, m_keyArray->m_keys.Elements(),
+                                        m_folder, this,
+                                        false, nullptr, m_window,
+                                        getter_AddRefs(notUsed));
+  }
+  else
+  { // no messages to copy with
+    FinishCompact();
+//    Release(); // we don't "own" ourselves yet.
+  }
+  return rv;
+}
+
+nsresult
+nsFolderCompactState::FinishCompact()
+{
+  NS_ENSURE_TRUE(m_folder, NS_ERROR_NOT_INITIALIZED);
+  NS_ENSURE_TRUE(m_file, NS_ERROR_NOT_INITIALIZED);
+
+  // All okay time to finish up the compact process
+  nsCOMPtr<nsIFile> path;
+  nsCOMPtr<nsIDBFolderInfo> folderInfo;
+
+  // get leaf name and database name of the folder
+  nsresult rv = m_folder->GetFilePath(getter_AddRefs(path));
+  nsCOMPtr <nsIFile> folderPath = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = folderPath->InitWithFile(path);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // need to make sure we put the .msf file in the same directory
+  // as the original mailbox, so resolve symlinks.
+  folderPath->SetFollowLinks(true);
+
+  nsCOMPtr <nsIFile> oldSummaryFile;
+  rv = GetSummaryFileLocation(folderPath, getter_AddRefs(oldSummaryFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsAutoCString dbName;
+  oldSummaryFile->GetNativeLeafName(dbName);
+  nsAutoCString folderName;
+  path->GetNativeLeafName(folderName);
+
+  // close down the temp file stream; preparing for deleting the old folder
+  // and its database; then rename the temp folder and database
+  if (m_fileStream)
+  {
+    m_fileStream->Flush();
+    m_fileStream->Close();
+    m_fileStream = nullptr;
+  }
+
+  // make sure the new database is valid.
+  // Close it so we can rename the .msf file.
+  if (m_db)
+  {
+    m_db->ForceClosed();
+    m_db = nullptr;
+  }
+
+  nsCOMPtr <nsIFile> newSummaryFile;
+  rv = GetSummaryFileLocation(m_file, getter_AddRefs(newSummaryFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr <nsIDBFolderInfo> transferInfo;
+  m_folder->GetDBTransferInfo(getter_AddRefs(transferInfo));
+
+  // close down database of the original folder
+  m_folder->ForceDBClosed();
+
+  nsCOMPtr<nsIFile> cloneFile;
+  int64_t fileSize = 0;
+  rv = m_file->Clone(getter_AddRefs(cloneFile));
+  if (NS_SUCCEEDED(rv))
+    rv = cloneFile->GetFileSize(&fileSize);
+  bool tempFileRightSize = ((uint64_t)fileSize == m_totalMsgSize);
+  NS_WARNING_ASSERTION(tempFileRightSize, "temp file not of expected size in compact");
+
+  bool folderRenameSucceeded = false;
+  bool msfRenameSucceeded = false;
+  if (NS_SUCCEEDED(rv) && tempFileRightSize)
+  {
+    // First we're going to try and move the old summary file out the way.
+    // We don't delete it yet, as we want to keep the files in sync.
+    nsCOMPtr<nsIFile> tempSummaryFile;
+    rv = oldSummaryFile->Clone(getter_AddRefs(tempSummaryFile));
+    if (NS_SUCCEEDED(rv))
+      rv = tempSummaryFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
+
+    nsAutoCString tempSummaryFileName;
+    if (NS_SUCCEEDED(rv))
+      rv = tempSummaryFile->GetNativeLeafName(tempSummaryFileName);
+
+    if (NS_SUCCEEDED(rv))
+      rv = oldSummaryFile->MoveToNative((nsIFile*) nullptr, tempSummaryFileName);
+
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "error moving compacted folder's db out of the way");
+    if (NS_SUCCEEDED(rv))
+    {
+      // Now we've successfully moved the summary file out the way, try moving
+      // the newly compacted message file over the old one.
+      rv = m_file->MoveToNative((nsIFile *) nullptr, folderName);
+      folderRenameSucceeded = NS_SUCCEEDED(rv);
+      NS_WARNING_ASSERTION(folderRenameSucceeded, "error renaming compacted folder");
+      if (folderRenameSucceeded)
+      {
+        // That worked, so land the new summary file in the right place.
+        nsCOMPtr<nsIFile> renamedCompactedSummaryFile;
+        newSummaryFile->Clone(getter_AddRefs(renamedCompactedSummaryFile));
+        if (renamedCompactedSummaryFile)
+        {
+          rv = renamedCompactedSummaryFile->MoveToNative((nsIFile *) nullptr, dbName);
+          msfRenameSucceeded = NS_SUCCEEDED(rv);
+        }
+        NS_WARNING_ASSERTION(msfRenameSucceeded, "error renaming compacted folder's db");
+      }
+
+      if (!msfRenameSucceeded)
+      {
+        // Do our best to put the summary file back to where it was
+        rv = tempSummaryFile->MoveToNative((nsIFile*) nullptr, dbName);
+        if (NS_SUCCEEDED(rv))
+          tempSummaryFile = nullptr; // flagging that a renamed db no longer exists
+        else
+          NS_WARNING("error restoring uncompacted folder's db");
+      }
+    }
+    // We don't want any temporarily renamed summary file to lie around
+    if (tempSummaryFile)
+      tempSummaryFile->Remove(false);
+  }
+
+  NS_WARNING_ASSERTION(msfRenameSucceeded, "compact failed");
+  nsresult rvReleaseFolderLock = ReleaseFolderLock();
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rvReleaseFolderLock),"folder lock not released successfully");
+  rv = NS_FAILED(rv) ? rv : rvReleaseFolderLock;
+
+  // Cleanup of nstmp-named compacted files if failure
+  if (!folderRenameSucceeded)
+  {
+    // remove the abandoned compacted version with the wrong name
+    m_file->Remove(false);
+  }
+  if (!msfRenameSucceeded)
+  {
+    // remove the abandoned compacted summary file
+    newSummaryFile->Remove(false);
+  }
+
+  if (msfRenameSucceeded)
+  {
+    // Transfer local db information from transferInfo
+    nsCOMPtr<nsIMsgDBService> msgDBService =
+      do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = msgDBService->OpenFolderDB(m_folder, true, getter_AddRefs(m_db));
+    NS_ENSURE_TRUE(m_db, NS_FAILED(rv) ? rv : NS_ERROR_FAILURE);
+    // These errors are expected.
+    rv = (rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING ||
+          rv == NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE) ? NS_OK : rv;
+    m_db->SetSummaryValid(true);
+    m_folder->SetDBTransferInfo(transferInfo);
+
+    // since we're transferring info from the old db, we need to reset the expunged bytes
+    nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+    m_db->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+    if(dbFolderInfo)
+      dbFolderInfo->SetExpungedBytes(0);
+  }
+  if (m_db)
+    m_db->Close(true);
+  m_db = nullptr;
+
+  // Notify that compaction of the folder is completed.
+  nsCOMPtr<nsIMsgFolderNotificationService>
+    notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+  if (notifier)
+    notifier->NotifyItemEvent(m_folder,
+                              NS_LITERAL_CSTRING("FolderCompactFinish"),
+                              nullptr);
+  m_folder->NotifyCompactCompleted();
+
+  if (m_compactAll)
+    rv = CompactNextFolder();
+  else
+    CompactCompleted(rv);
+      
+  return rv;
+}
+
+nsresult
+GetBaseStringBundle(nsIStringBundle **aBundle)
+{
+  NS_ENSURE_ARG_POINTER(aBundle);
+  nsCOMPtr<nsIStringBundleService> bundleService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+  nsCOMPtr<nsIStringBundle> bundle;
+  return bundleService->CreateBundle(
+    "chrome://messenger/locale/messenger.properties", aBundle);
+}
+
+void nsFolderCompactState::CompactCompleted(nsresult exitCode)
+{
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(exitCode),
+                       "nsFolderCompactState::CompactCompleted failed");
+  if (m_listener)
+    m_listener->OnStopRunningUrl(nullptr, exitCode);
+  ShowDoneStatus();
+}
+
+nsresult
+nsFolderCompactState::ReleaseFolderLock()
+{
+  nsresult result = NS_OK;
+  if (!m_folder) return result;
+  bool haveSemaphore;
+  nsCOMPtr <nsISupports> supports = do_QueryInterface(static_cast<nsIMsgFolderCompactor*>(this));
+  result = m_folder->TestSemaphore(supports, &haveSemaphore);
+  if(NS_SUCCEEDED(result) && haveSemaphore)
+    result = m_folder->ReleaseSemaphore(supports);
+  return result;
+}
+
+void nsFolderCompactState::ShowDoneStatus()
+{
+  if (m_folder)
+  {
+    nsString statusString;
+    nsCOMPtr <nsIStringBundle> bundle;
+    nsresult rv = GetBaseStringBundle(getter_AddRefs(bundle));
+    NS_ENSURE_SUCCESS_VOID(rv);
+    nsAutoString expungedAmount;
+    FormatFileSize(m_totalExpungedBytes, true, expungedAmount);
+    const char16_t* params[] = { expungedAmount.get() };
+    rv = bundle->FormatStringFromName(u"compactingDone",
+                                      params, 1, getter_Copies(statusString));
+
+    if (!statusString.IsEmpty() && NS_SUCCEEDED(rv))
+      ShowStatusMsg(statusString);
+  }
+}
+
+nsresult
+nsFolderCompactState::CompactNextFolder()
+{
+  m_folderIndex++;
+  uint32_t cnt = 0;
+  nsresult rv = m_folderArray->GetLength(&cnt);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // m_folderIndex might be > cnt if we compact offline stores,
+  // and get back here from OnStopRunningUrl.
+  if (m_folderIndex >= cnt)
+  {
+    if (!m_compactOfflineAlso || m_compactingOfflineFolders)
+    {
+      CompactCompleted(NS_OK);
+      return rv;
+    }
+    m_compactingOfflineFolders = true;
+    nsCOMPtr<nsIMsgFolder> folder = do_QueryElementAt(m_folderArray,
+                                                      m_folderIndex-1, &rv);
+    if (NS_SUCCEEDED(rv) && folder)
+      return folder->CompactAllOfflineStores(this, m_window, m_offlineFolderArray);
+    else
+      NS_WARNING("couldn't get folder to compact offline stores");
+
+  }
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryElementAt(m_folderArray,
+                                                    m_folderIndex, &rv);
+
+  if (NS_SUCCEEDED(rv) && folder)
+    rv = Compact(folder, m_compactingOfflineFolders, m_listener, m_window);
+  else
+    CompactCompleted(rv);
+  return rv;
+}
+
+nsresult
+nsFolderCompactState::GetMessage(nsIMsgDBHdr **message)
+{
+  return GetMsgDBHdrFromURI(m_messageUri.get(), message);
+}
+
+
+NS_IMETHODIMP
+nsFolderCompactState::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
+{
+  return StartMessage();
+}
+
+NS_IMETHODIMP
+nsFolderCompactState::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
+                                    nsresult status)
+{
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  if (NS_FAILED(status))
+  {
+    m_status = status; // set the m_status to status so the destructor can remove the
+                       // temp folder and database
+    CleanupTempFilesAfterError();
+    m_folder->NotifyCompactCompleted();
+    ReleaseFolderLock();
+    m_folder->ThrowAlertMsg("compactFolderWriteFailed", m_window);
+  }
+  else
+  {
+    EndCopy(nullptr, status);
+    if (m_curIndex >= m_size)
+    {
+      msgHdr = nullptr;
+      // no more to copy finish it up
+      FinishCompact();
+    }
+    else
+    {
+      // in case we're not getting an error, we still need to pretend we did get an error,
+      // because the compact did not successfully complete.
+      m_folder->NotifyCompactCompleted();
+      CleanupTempFilesAfterError();
+      ReleaseFolderLock();
+    }
+  }
+  Release(); // kill self
+  return status;
+}
+
+NS_IMETHODIMP
+nsFolderCompactState::OnDataAvailable(nsIRequest *request, nsISupports *ctxt,
+                                      nsIInputStream *inStr,
+                                      uint64_t sourceOffset, uint32_t count)
+{
+  if (!m_fileStream || !inStr) 
+    return NS_ERROR_FAILURE;
+
+  nsresult rv = NS_OK;
+  uint32_t msgFlags;
+  bool checkForKeyword = m_startOfMsg;
+  bool addKeywordHdr = false;
+  uint32_t needToGrowKeywords = 0;
+  uint32_t statusOffset;
+  nsCString msgHdrKeywords;
+
+  if (m_startOfMsg)
+  {
+    m_statusOffset = 0;
+    m_addedHeaderSize = 0;
+    m_messageUri.Truncate(); // clear the previous message uri
+    if (NS_SUCCEEDED(BuildMessageURI(m_baseMessageUri.get(), m_keyArray->m_keys[m_curIndex],
+                                m_messageUri)))
+    {
+      rv = GetMessage(getter_AddRefs(m_curSrcHdr));
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (m_curSrcHdr)
+      {
+        (void) m_curSrcHdr->GetFlags(&msgFlags);
+        (void) m_curSrcHdr->GetStatusOffset(&statusOffset);
+        
+        if (statusOffset == 0)
+          m_needStatusLine = true;
+        // x-mozilla-status lines should be at the start of the headers, and the code
+        // below assumes everything will fit in m_dataBuffer - if there's not
+        // room, skip the keyword stuff.
+        if (statusOffset > sizeof(m_dataBuffer) - 1024)
+        {
+          checkForKeyword = false;
+          NS_ASSERTION(false, "status offset past end of read buffer size");
+          
+        }
+      }
+    }
+    m_startOfMsg = false;
+  }
+  uint32_t maxReadCount, readCount, writeCount;
+  uint32_t bytesWritten;
+  
+  while (NS_SUCCEEDED(rv) && (int32_t) count > 0)
+  {
+    maxReadCount = count > sizeof(m_dataBuffer) - 1 ? sizeof(m_dataBuffer) - 1 : count;
+    writeCount = 0;
+    rv = inStr->Read(m_dataBuffer, maxReadCount, &readCount);
+    
+    // if status offset is past the number of bytes we read, it's probably bogus,
+    // and we shouldn't do any of the keyword stuff.
+    if (statusOffset + X_MOZILLA_STATUS_LEN > readCount)
+      checkForKeyword = false;
+    
+    if (NS_SUCCEEDED(rv))
+    {
+      if (checkForKeyword)
+      {
+        // make sure that status offset really points to x-mozilla-status line
+        if  (!strncmp(m_dataBuffer + statusOffset, X_MOZILLA_STATUS, X_MOZILLA_STATUS_LEN))
+        {
+          const char *keywordHdr = PL_strnrstr(m_dataBuffer, HEADER_X_MOZILLA_KEYWORDS, readCount);
+          if (keywordHdr)
+            m_curSrcHdr->GetUint32Property("growKeywords", &needToGrowKeywords);
+          else
+            addKeywordHdr = true;
+          m_curSrcHdr->GetStringProperty("keywords", getter_Copies(msgHdrKeywords));
+        }
+        checkForKeyword = false;
+      }
+      uint32_t blockOffset = 0;
+      if (m_needStatusLine)
+      {
+        m_needStatusLine = false;
+        // we need to parse out the "From " header, write it out, then 
+        // write out the x-mozilla-status headers, and set the 
+        // status offset of the dest hdr for later use 
+        // in OnEndCopy).
+        if (!strncmp(m_dataBuffer, "From ", 5))
+        {
+          blockOffset = 5;
+          // skip from line
+          MsgAdvanceToNextLine(m_dataBuffer, blockOffset, readCount);
+          char statusLine[50];
+          m_fileStream->Write(m_dataBuffer, blockOffset, &writeCount);
+          m_statusOffset = blockOffset;
+          PR_snprintf(statusLine, sizeof(statusLine), X_MOZILLA_STATUS_FORMAT MSG_LINEBREAK, msgFlags & 0xFFFF);
+          m_fileStream->Write(statusLine, strlen(statusLine), &m_addedHeaderSize);
+          PR_snprintf(statusLine, sizeof(statusLine), X_MOZILLA_STATUS2_FORMAT MSG_LINEBREAK, msgFlags & 0xFFFF0000);
+          m_fileStream->Write(statusLine, strlen(statusLine), &bytesWritten);
+          m_addedHeaderSize += bytesWritten;
+        }
+        else
+        {
+          NS_ASSERTION(false, "not an envelope");
+          // try to mark the db as invalid so it will be reparsed.
+          nsCOMPtr <nsIMsgDatabase> srcDB;
+          m_folder->GetMsgDatabase(getter_AddRefs(srcDB));
+          if (srcDB)
+          {
+            srcDB->SetSummaryValid(false);
+            srcDB->ForceClosed();
+          }
+        }
+      }
+#define EXTRA_KEYWORD_HDR "                                                                                 " MSG_LINEBREAK
+
+       // if status offset isn't in the first block, this code won't work. There's no good reason
+      // for the status offset not to be at the beginning of the message anyway.
+      if (addKeywordHdr)
+      {
+        // if blockOffset is set, we added x-mozilla-status headers so
+        // file pointer is already past them.
+        if (!blockOffset)
+        {
+          blockOffset = statusOffset;
+          // skip x-mozilla-status and status2 lines.
+          MsgAdvanceToNextLine(m_dataBuffer, blockOffset, readCount);
+          MsgAdvanceToNextLine(m_dataBuffer, blockOffset, readCount);
+          // need to rewrite the headers up to and including the x-mozilla-status2 header
+          m_fileStream->Write(m_dataBuffer, blockOffset, &writeCount);
+        }
+        // we should write out the existing keywords from the msg hdr, if any.
+        if (msgHdrKeywords.IsEmpty())
+        { // no keywords, so write blank header
+          m_fileStream->Write(X_MOZILLA_KEYWORDS, sizeof(X_MOZILLA_KEYWORDS) - 1, &bytesWritten);
+          m_addedHeaderSize += bytesWritten;
+        }
+        else
+        {
+          if (msgHdrKeywords.Length() < sizeof(X_MOZILLA_KEYWORDS) - sizeof(HEADER_X_MOZILLA_KEYWORDS) + 10 /* allow some slop */)
+          { // keywords fit in normal blank header, so replace blanks in keyword hdr with keywords
+            nsAutoCString keywordsHdr(X_MOZILLA_KEYWORDS);
+            keywordsHdr.Replace(sizeof(HEADER_X_MOZILLA_KEYWORDS) + 1, msgHdrKeywords.Length(), msgHdrKeywords);
+            m_fileStream->Write(keywordsHdr.get(), keywordsHdr.Length(), &bytesWritten);
+            m_addedHeaderSize += bytesWritten;
+          }
+          else
+          { // keywords don't fit, so write out keywords on one line and an extra blank line
+            nsCString newKeywordHeader(HEADER_X_MOZILLA_KEYWORDS ": ");
+            newKeywordHeader.Append(msgHdrKeywords);
+            newKeywordHeader.Append(MSG_LINEBREAK EXTRA_KEYWORD_HDR);
+            m_fileStream->Write(newKeywordHeader.get(), newKeywordHeader.Length(), &bytesWritten);
+            m_addedHeaderSize += bytesWritten;
+          }
+        }
+        addKeywordHdr = false;
+      }
+      else if (needToGrowKeywords)
+      {
+        blockOffset = statusOffset;
+        if (!strncmp(m_dataBuffer + blockOffset, X_MOZILLA_STATUS, X_MOZILLA_STATUS_LEN))
+          MsgAdvanceToNextLine(m_dataBuffer, blockOffset, readCount); // skip x-mozilla-status hdr
+        if (!strncmp(m_dataBuffer + blockOffset, X_MOZILLA_STATUS2, X_MOZILLA_STATUS2_LEN))
+          MsgAdvanceToNextLine(m_dataBuffer, blockOffset, readCount); // skip x-mozilla-status2 hdr
+        uint32_t preKeywordBlockOffset = blockOffset;
+        if (!strncmp(m_dataBuffer + blockOffset, HEADER_X_MOZILLA_KEYWORDS, sizeof(HEADER_X_MOZILLA_KEYWORDS) - 1))
+        {
+          do
+          {
+            // skip x-mozilla-keywords hdr and any existing continuation headers
+            MsgAdvanceToNextLine(m_dataBuffer, blockOffset, readCount);
+          }
+          while (m_dataBuffer[blockOffset] == ' ');
+        }
+        int32_t oldKeywordSize = blockOffset - preKeywordBlockOffset;
+
+        // rewrite the headers up to and including the x-mozilla-status2 header
+        m_fileStream->Write(m_dataBuffer, preKeywordBlockOffset, &writeCount);
+        // let's just rewrite all the keywords on several lines and add a blank line,
+        // instead of worrying about which are missing.
+        bool done = false;
+        nsAutoCString keywordHdr(HEADER_X_MOZILLA_KEYWORDS ": ");
+        int32_t nextBlankOffset = 0;
+        int32_t curHdrLineStart = 0;
+        int32_t newKeywordSize = 0;
+        while (!done)
+        {
+          nextBlankOffset = msgHdrKeywords.FindChar(' ', nextBlankOffset);
+          if (nextBlankOffset == kNotFound)
+          {
+            nextBlankOffset = msgHdrKeywords.Length();
+            done = true;
+          }
+          if (nextBlankOffset - curHdrLineStart > 90 || done)
+          {
+            keywordHdr.Append(nsDependentCSubstring(msgHdrKeywords, curHdrLineStart, msgHdrKeywords.Length() - curHdrLineStart));
+            keywordHdr.Append(MSG_LINEBREAK);
+            m_fileStream->Write(keywordHdr.get(), keywordHdr.Length(), &bytesWritten);
+            newKeywordSize += bytesWritten;
+            curHdrLineStart = nextBlankOffset;
+            keywordHdr.Assign(' ');
+          }
+          nextBlankOffset++;
+        }
+        m_fileStream->Write(EXTRA_KEYWORD_HDR, sizeof(EXTRA_KEYWORD_HDR) - 1, &bytesWritten);
+        newKeywordSize += bytesWritten;
+        m_addedHeaderSize += newKeywordSize - oldKeywordSize;
+        m_curSrcHdr->SetUint32Property("growKeywords", 0);
+        needToGrowKeywords = false;
+        writeCount += blockOffset - preKeywordBlockOffset; // fudge writeCount
+
+      }
+      if (readCount <= blockOffset)
+      {
+        NS_ASSERTION(false, "bad block offset");
+        // not sure what to do to handle this.
+      
+      }
+      m_fileStream->Write(m_dataBuffer + blockOffset, readCount - blockOffset, &bytesWritten);
+      writeCount += bytesWritten;
+      count -= readCount;
+      if (writeCount != readCount)
+        return NS_MSG_ERROR_WRITING_MAIL_FOLDER;
+    }
+  }
+  return rv;
+}
+
+nsOfflineStoreCompactState::nsOfflineStoreCompactState()
+{
+}
+
+nsOfflineStoreCompactState::~nsOfflineStoreCompactState()
+{
+}
+
+
+nsresult
+nsOfflineStoreCompactState::InitDB(nsIMsgDatabase *db)
+{
+  // Start with the list of messages we have offline as the possible
+  // message to keep when compacting the offline store.
+  db->ListAllOfflineMsgs(m_keyArray);
+  m_size = m_keyArray->m_keys.Length();
+  m_db = db;
+  return NS_OK;
+}
+
+/**
+ * This will copy one message to the offline store, but if it fails to
+ * copy the next message, it will keep trying messages until it finds one
+ * it can copy, or it runs out of messages.
+ */
+nsresult nsOfflineStoreCompactState::CopyNextMessage(bool &done)
+{
+  while (m_curIndex < m_size)
+  {
+    // Filter out msgs that have the "pendingRemoval" attribute set.
+    nsCOMPtr<nsIMsgDBHdr> hdr;
+    nsString pendingRemoval;
+    nsresult rv = m_db->GetMsgHdrForKey(m_keyArray->m_keys[m_curIndex], getter_AddRefs(hdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+    hdr->GetProperty("pendingRemoval", pendingRemoval);
+    if (!pendingRemoval.IsEmpty())
+    {
+      m_curIndex++;
+      // Turn off offline flag for message, since after the compact is completed;
+      // we won't have the message in the offline store.
+      uint32_t resultFlags;
+      hdr->AndFlags(~nsMsgMessageFlags::Offline, &resultFlags);
+      // We need to clear this in case the user changes the offline retention
+      // settings.
+      hdr->SetStringProperty("pendingRemoval", "");
+      continue;
+    }
+    m_messageUri.Truncate(); // clear the previous message uri
+    rv = BuildMessageURI(m_baseMessageUri.get(), m_keyArray->m_keys[m_curIndex],
+                                  m_messageUri);
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_startOfMsg = true;
+    nsCOMPtr<nsISupports> thisSupports;
+    QueryInterface(NS_GET_IID(nsISupports), getter_AddRefs(thisSupports));
+    nsCOMPtr<nsIURI> dummyNull;
+    rv = m_messageService->StreamMessage(m_messageUri.get(), thisSupports, m_window, nullptr,
+                                    false, EmptyCString(), true, getter_AddRefs(dummyNull));
+    // if copy fails, we clear the offline flag on the source message.
+    if (NS_FAILED(rv))
+    {
+      nsCOMPtr<nsIMsgDBHdr> hdr;
+      GetMessage(getter_AddRefs(hdr));
+      if (hdr)
+      {
+        uint32_t resultFlags;
+        hdr->AndFlags(~nsMsgMessageFlags::Offline, &resultFlags);
+      }
+      m_curIndex++;
+      continue;
+    }
+    else
+      break;
+  }
+  done = m_curIndex >= m_size;
+  // In theory, we might be able to stream the next message, so
+  // return NS_OK, not rv.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsOfflineStoreCompactState::OnStopRequest(nsIRequest *request, nsISupports *ctxt,
+                                          nsresult status)
+{
+  nsresult rv = status;
+  nsCOMPtr<nsIURI> uri;
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  nsCOMPtr <nsIMsgStatusFeedback> statusFeedback;
+  bool done = false;
+
+  // The NS_MSG_ERROR_MSG_NOT_OFFLINE error should allow us to continue, so we
+  // check for it specifically and don't terminate the compaction.
+  if (NS_FAILED(rv) && rv != NS_MSG_ERROR_MSG_NOT_OFFLINE)
+    goto done;
+  uri = do_QueryInterface(ctxt, &rv);
+  if (NS_FAILED(rv)) goto done;
+  rv = GetMessage(getter_AddRefs(msgHdr));
+  if (NS_FAILED(rv)) goto done;
+
+  // This is however an unexpected condition, so let's print a warning.
+  if (rv == NS_MSG_ERROR_MSG_NOT_OFFLINE) {
+    nsAutoCString spec;
+    uri->GetSpec(spec);
+    nsPrintfCString msg("Message expectedly not available offline: %s", spec.get());
+    NS_WARNING(msg.get());
+  }
+
+  if (msgHdr)
+  {
+    if (NS_SUCCEEDED(status))
+    {
+      msgHdr->SetMessageOffset(m_startOfNewMsg);
+      char storeToken[100];
+      PR_snprintf(storeToken, sizeof(storeToken), "%lld", m_startOfNewMsg);
+      msgHdr->SetStringProperty("storeToken", storeToken);
+      msgHdr->SetOfflineMessageSize(m_offlineMsgSize);
+    }
+    else
+    {
+      uint32_t resultFlags;
+      msgHdr->AndFlags(~nsMsgMessageFlags::Offline, &resultFlags);
+    }
+  }
+
+  if (m_window)
+  {
+    m_window->GetStatusFeedback(getter_AddRefs(statusFeedback));
+    if (statusFeedback)
+      statusFeedback->ShowProgress(100 * m_curIndex / m_size);
+  }
+  // advance to next message
+  m_curIndex++;
+  rv = CopyNextMessage(done);
+  if (done)
+  {
+    m_db->Commit(nsMsgDBCommitType::kCompressCommit);
+    msgHdr = nullptr;
+    // no more to copy finish it up
+    ReleaseFolderLock();
+    FinishCompact();
+    Release(); // kill self
+  }
+
+done:
+  if (NS_FAILED(rv)) {
+    m_status = rv; // set the status to rv so the destructor can remove the
+                   // temp folder and database
+    ReleaseFolderLock();
+    Release(); // kill self
+    return rv;
+  }
+  return rv;
+}
+ 
+
+nsresult
+nsOfflineStoreCompactState::FinishCompact()
+{
+  // All okay time to finish up the compact process
+  nsCOMPtr<nsIFile> path;
+  uint32_t flags;
+
+    // get leaf name and database name of the folder
+  m_folder->GetFlags(&flags);
+  nsresult rv = m_folder->GetFilePath(getter_AddRefs(path));
+
+  nsCString leafName;
+  path->GetNativeLeafName(leafName);
+
+  if (m_fileStream)
+  {
+    // close down the temp file stream; preparing for deleting the old folder
+    // and its database; then rename the temp folder and database
+    m_fileStream->Flush();
+    m_fileStream->Close();
+    m_fileStream = nullptr;
+  }
+
+    // make sure the new database is valid
+  nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+  m_db->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+  if (dbFolderInfo)
+    dbFolderInfo->SetExpungedBytes(0);
+  // this forces the m_folder to update mExpungedBytes from the db folder info.
+  int64_t expungedBytes;
+  m_folder->GetExpungedBytes(&expungedBytes);
+  m_folder->UpdateSummaryTotals(true);
+  m_db->SetSummaryValid(true);
+
+    // remove the old folder 
+  path->Remove(false);
+
+    // rename the copied folder to be the original folder 
+  m_file->MoveToNative((nsIFile *) nullptr, leafName);
+
+  ShowStatusMsg(EmptyString());
+  m_folder->NotifyCompactCompleted();
+  if (m_compactAll)
+    rv = CompactNextFolder();
+  return rv;
+}
+
+
+NS_IMETHODIMP
+nsFolderCompactState::Init(nsIMsgFolder *srcFolder, nsICopyMessageListener *destination, nsISupports *listenerData)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFolderCompactState::StartMessage()
+{
+  nsresult rv = NS_ERROR_FAILURE;
+  NS_ASSERTION(m_fileStream, "Fatal, null m_fileStream...\n");
+  if (m_fileStream)
+  {
+    nsCOMPtr <nsISeekableStream> seekableStream = do_QueryInterface(m_fileStream, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    // this will force an internal flush, but not a sync. Tell should really do an internal flush,
+    // but it doesn't, and I'm afraid to change that nsIFileStream.cpp code anymore.
+    seekableStream->Seek(nsISeekableStream::NS_SEEK_CUR, 0);
+    // record the new message key for the message
+    int64_t curStreamPos;
+    seekableStream->Tell(&curStreamPos);
+    m_startOfNewMsg = curStreamPos;
+    rv = NS_OK;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsFolderCompactState::EndMessage(nsMsgKey key)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFolderCompactState::EndCopy(nsISupports *url, nsresult aStatus)
+{
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  nsCOMPtr<nsIMsgDBHdr> newMsgHdr;
+
+  if (m_curIndex >= m_size)
+  {
+    NS_ASSERTION(false, "m_curIndex out of bounds");
+    return NS_OK;
+  }
+
+  /**
+   * Done with the current message; copying the existing message header
+   * to the new database.
+   */
+  if (m_curSrcHdr)
+  {
+    nsMsgKey key;
+    m_curSrcHdr->GetMessageKey(&key);
+    m_db->CopyHdrFromExistingHdr(key, m_curSrcHdr, true,
+                                 getter_AddRefs(newMsgHdr));
+  }
+  m_curSrcHdr = nullptr;
+  if (newMsgHdr)
+  {
+    if (m_statusOffset != 0)
+      newMsgHdr->SetStatusOffset(m_statusOffset);
+
+    char storeToken[100];
+    PR_snprintf(storeToken, sizeof(storeToken), "%lld", m_startOfNewMsg);
+    newMsgHdr->SetStringProperty("storeToken", storeToken);
+    newMsgHdr->SetMessageOffset(m_startOfNewMsg);
+
+    uint32_t msgSize;
+    (void) newMsgHdr->GetMessageSize(&msgSize);
+    if (m_addedHeaderSize)
+    {
+      msgSize += m_addedHeaderSize;
+      newMsgHdr->SetMessageSize(msgSize);
+    }
+    m_totalMsgSize += msgSize;
+  }
+
+//  m_db->Commit(nsMsgDBCommitType::kLargeCommit);  // no sense commiting until the end
+  // advance to next message
+  m_curIndex ++;
+  m_startOfMsg = true;
+  nsCOMPtr <nsIMsgStatusFeedback> statusFeedback;
+  if (m_window)
+  {
+    m_window->GetStatusFeedback(getter_AddRefs(statusFeedback));
+    if (statusFeedback)
+      statusFeedback->ShowProgress(100 * m_curIndex / m_size);
+  }
+  return NS_OK;
+}
+
+nsresult nsOfflineStoreCompactState::StartCompacting()
+{
+  nsresult rv = NS_OK;
+  if (m_size > 0 && m_curIndex == 0)
+  {
+    AddRef(); // we own ourselves, until we're done, anyway.
+    ShowCompactingStatusMsg();
+    bool done = false;
+    rv = CopyNextMessage(done);
+    if (!done)
+      return rv;
+  }
+  ReleaseFolderLock();
+  FinishCompact();
+  return rv;
+}
+
+NS_IMETHODIMP
+nsOfflineStoreCompactState::OnDataAvailable(nsIRequest *request, nsISupports *ctxt,
+                                            nsIInputStream *inStr,
+                                            uint64_t sourceOffset, uint32_t count)
+{
+  if (!m_fileStream || !inStr) 
+    return NS_ERROR_FAILURE;
+
+  nsresult rv = NS_OK;
+
+  if (m_startOfMsg)
+  {
+    m_statusOffset = 0;
+    m_offlineMsgSize = 0;
+    m_messageUri.Truncate(); // clear the previous message uri
+    if (NS_SUCCEEDED(BuildMessageURI(m_baseMessageUri.get(), m_keyArray->m_keys[m_curIndex],
+                                m_messageUri)))
+    {
+      rv = GetMessage(getter_AddRefs(m_curSrcHdr));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  uint32_t maxReadCount, readCount, writeCount;
+  uint32_t bytesWritten;
+
+  while (NS_SUCCEEDED(rv) && (int32_t) count > 0)
+  {
+    maxReadCount = count > sizeof(m_dataBuffer) - 1 ? sizeof(m_dataBuffer) - 1 : count;
+    writeCount = 0;
+    rv = inStr->Read(m_dataBuffer, maxReadCount, &readCount);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      if (m_startOfMsg)
+      {
+        m_startOfMsg = false;
+        // check if there's an envelope header; if not, write one.
+        if (strncmp(m_dataBuffer, "From ", 5))
+        {
+          m_fileStream->Write("From " CRLF, 7, &bytesWritten);
+          m_offlineMsgSize += bytesWritten;
+        }
+      }
+      m_fileStream->Write(m_dataBuffer, readCount, &bytesWritten);
+      m_offlineMsgSize += bytesWritten;
+      writeCount += bytesWritten;
+      count -= readCount;
+      if (writeCount != readCount)
+      {
+        m_folder->ThrowAlertMsg("compactFolderWriteFailed", m_window);
+        return NS_MSG_ERROR_WRITING_MAIL_FOLDER;
+      }
+    }
+  }
+  return rv;
+}
+
diff --git a/mailnews/base/src/nsMsgFolderCompactor.h b/mailnews/base/src/nsMsgFolderCompactor.h
new file mode 100644
index 000000000..50a69df81
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderCompactor.h
@@ -0,0 +1,115 @@
+/* -*- 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 _nsMsgFolderCompactor_h
+#define _nsMsgFolderCompactor_h
+
+#include "mozilla/Attributes.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgFolder.h"
+#include "nsIStreamListener.h"
+#include "nsIMsgFolderCompactor.h"
+#include "nsICopyMsgStreamListener.h"
+#include "nsMsgKeyArray.h"
+#include "nsIMsgWindow.h"
+#include "nsIStringBundle.h"
+#include "nsIMsgMessageService.h"
+
+#define COMPACTOR_READ_BUFF_SIZE 16384
+
+class nsFolderCompactState : public nsIMsgFolderCompactor,
+                             public nsIStreamListener,
+                             public nsICopyMessageStreamListener,
+                             public nsIUrlListener
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSISTREAMLISTENER
+  NS_DECL_NSICOPYMESSAGESTREAMLISTENER
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSIMSGFOLDERCOMPACTOR
+
+  nsFolderCompactState(void);
+protected:
+  virtual ~nsFolderCompactState(void);
+
+  virtual nsresult InitDB(nsIMsgDatabase *db);
+  virtual nsresult StartCompacting();
+  virtual nsresult FinishCompact();
+  void CloseOutputStream();
+  void  CleanupTempFilesAfterError();
+
+  nsresult Init(nsIMsgFolder *aFolder, const char* aBaseMsgUri, nsIMsgDatabase *aDb,
+                            nsIFile *aPath, nsIMsgWindow *aMsgWindow);
+  nsresult GetMessage(nsIMsgDBHdr **message);
+  nsresult BuildMessageURI(const char *baseURI, nsMsgKey key, nsCString& uri);
+  nsresult ShowStatusMsg(const nsString& aMsg);
+  nsresult ReleaseFolderLock();
+  void     ShowCompactingStatusMsg();
+  void     CompactCompleted(nsresult exitCode);
+  void     ShowDoneStatus();
+  nsresult CompactNextFolder();
+
+  nsCString m_baseMessageUri; // base message uri
+  nsCString m_messageUri; // current message uri being copy
+  nsCOMPtr<nsIMsgFolder> m_folder; // current folder being compact
+  nsCOMPtr<nsIMsgDatabase> m_db; // new database for the compact folder
+  nsCOMPtr <nsIFile> m_file; // new mailbox for the compact folder
+  nsCOMPtr <nsIOutputStream> m_fileStream; // output file stream for writing
+  // all message keys that need to be copied over
+  RefPtr<nsMsgKeyArray> m_keyArray;
+  uint32_t m_size;
+
+   // sum of the sizes of the messages, accumulated as we visit each msg.
+  uint64_t m_totalMsgSize;
+  // number of bytes that can be expunged while compacting.
+  uint64_t m_totalExpungedBytes;
+
+  uint32_t m_curIndex; // index of the current copied message key in key array
+  uint64_t m_startOfNewMsg; // offset in mailbox of new message
+  char m_dataBuffer[COMPACTOR_READ_BUFF_SIZE + 1]; // temp data buffer for copying message
+  nsresult m_status; // the status of the copying operation
+  nsCOMPtr <nsIMsgMessageService> m_messageService; // message service for copying 
+  nsCOMPtr<nsIArray> m_folderArray; // folders we are compacting, if compacting multiple.
+  nsCOMPtr <nsIMsgWindow> m_window;
+  nsCOMPtr <nsIMsgDBHdr> m_curSrcHdr;
+  uint32_t m_folderIndex; // tells which folder to compact in case of compact all
+  bool m_compactAll;  //flag for compact all
+  bool m_compactOfflineAlso; //whether to compact offline also
+  bool m_compactingOfflineFolders; // are we in the offline folder compact phase
+  bool m_parsingFolder; //flag for parsing local folders;
+  // these members are used to add missing status lines to compacted messages.
+  bool m_needStatusLine;
+  bool m_startOfMsg;
+  int32_t m_statusOffset;
+  uint32_t m_addedHeaderSize;
+  nsCOMPtr<nsIArray> m_offlineFolderArray;
+  nsCOMPtr<nsIUrlListener> m_listener;
+  bool m_alreadyWarnedDiskSpace;
+};
+
+class nsOfflineStoreCompactState : public nsFolderCompactState
+{
+public:
+
+  nsOfflineStoreCompactState(void);
+  virtual ~nsOfflineStoreCompactState(void);
+  NS_IMETHOD OnStopRequest(nsIRequest *request, nsISupports *ctxt,
+                                    nsresult status) override;
+  NS_IMETHODIMP OnDataAvailable(nsIRequest *request, nsISupports *ctxt,
+                                nsIInputStream *inStr,
+                                uint64_t sourceOffset, uint32_t count) override;
+
+protected:
+    nsresult         CopyNextMessage(bool &done);
+    virtual nsresult InitDB(nsIMsgDatabase *db) override;
+    virtual nsresult StartCompacting() override;
+    virtual nsresult FinishCompact() override;
+
+    uint32_t m_offlineMsgSize;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgFolderDataSource.cpp b/mailnews/base/src/nsMsgFolderDataSource.cpp
new file mode 100644
index 000000000..391596ab4
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderDataSource.cpp
@@ -0,0 +1,2475 @@
+/* -*- 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 "prlog.h"
+#include "prmem.h"
+#include "nsMsgFolderDataSource.h"
+#include "nsMsgFolderFlags.h"
+
+#include "nsMsgUtils.h"
+#include "nsMsgRDFUtils.h"
+
+#include "rdf.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "nsIRDFNode.h"
+#include "nsEnumeratorUtils.h"
+
+#include "nsStringGlue.h"
+#include "nsCOMPtr.h"
+
+#include "nsIMsgMailSession.h"
+#include "nsIMsgCopyService.h"
+#include "nsMsgBaseCID.h"
+#include "nsIInputStream.h"
+#include "nsIMsgHdr.h"
+#include "nsTraceRefcnt.h"
+#include "nsIMsgFolder.h" // TO include biffState enum. Change to bool later...
+#include "nsIMutableArray.h"
+#include "nsIPop3IncomingServer.h"
+#include "nsINntpIncomingServer.h"
+#include "nsTextFormatter.h"
+#include "nsIStringBundle.h"
+#include "nsIPrompt.h"
+#include "nsIMsgAccountManager.h"
+#include "nsArrayEnumerator.h"
+#include "nsArrayUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMemory.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Services.h"
+
+#define MESSENGER_STRING_URL       "chrome://messenger/locale/messenger.properties"
+
+nsIRDFResource* nsMsgFolderDataSource::kNC_Child = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_Folder= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_Name= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_Open = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_FolderTreeName= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_FolderTreeSimpleName= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_NameSort= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_FolderTreeNameSort= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_SpecialFolder= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_ServerType = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_IsDeferred = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CanCreateFoldersOnServer = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CanFileMessagesOnServer = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_IsServer = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_IsSecure = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CanSubscribe = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_SupportsOffline = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CanFileMessages = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CanCreateSubfolders = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CanRename = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CanCompact = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_TotalMessages= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_TotalUnreadMessages= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_FolderSize = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_Charset = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_BiffState = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_HasUnreadMessages = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_NewMessages = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_SubfoldersHaveUnreadMessages = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_NoSelect = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_VirtualFolder = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_InVFEditSearchScope = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_ImapShared = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_Synchronize = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_SyncDisabled = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CanSearchMessages = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_UnreadFolders = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_FavoriteFolders = nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_RecentFolders = nullptr;
+
+// commands
+nsIRDFResource* nsMsgFolderDataSource::kNC_Delete= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_ReallyDelete= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_NewFolder= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_GetNewMessages= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_Copy= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_Move= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CopyFolder= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_MoveFolder= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_MarkAllMessagesRead= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_Compact= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_CompactAll= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_Rename= nullptr;
+nsIRDFResource* nsMsgFolderDataSource::kNC_EmptyTrash= nullptr;
+
+nsrefcnt nsMsgFolderDataSource::gFolderResourceRefCnt = 0;
+
+nsIAtom * nsMsgFolderDataSource::kBiffStateAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kSortOrderAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kNewMessagesAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kTotalMessagesAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kTotalUnreadMessagesAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kFolderSizeAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kNameAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kSynchronizeAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kOpenAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kIsDeferredAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kIsSecureAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kCanFileMessagesAtom = nullptr;
+nsIAtom * nsMsgFolderDataSource::kInVFEditSearchScopeAtom = nullptr;
+
+static const uint32_t kDisplayBlankCount = 0xFFFFFFFE;
+static const uint32_t kDisplayQuestionCount = 0xFFFFFFFF;
+static const int64_t kDisplayBlankCount64 = -2;
+static const int64_t kDisplayQuestionCount64 = -1;
+
+nsMsgFolderDataSource::nsMsgFolderDataSource()
+{
+  // one-time initialization here
+  nsIRDFService* rdf = getRDFService();
+
+  if (gFolderResourceRefCnt++ == 0) {
+    nsCOMPtr<nsIStringBundle> sMessengerStringBundle;
+
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CHILD),   &kNC_Child);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDER),  &kNC_Folder);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_NAME),    &kNC_Name);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_OPEN),    &kNC_Open);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERTREENAME),    &kNC_FolderTreeName);
+    rdf->GetResource(NS_LITERAL_CSTRING("mailnewsunreadfolders:/"),    &kNC_UnreadFolders);
+    rdf->GetResource(NS_LITERAL_CSTRING("mailnewsfavefolders:/"),    &kNC_FavoriteFolders);
+    rdf->GetResource(NS_LITERAL_CSTRING("mailnewsrecentfolders:/"),    &kNC_RecentFolders);
+
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERTREESIMPLENAME),    &kNC_FolderTreeSimpleName);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_NAME_SORT),    &kNC_NameSort);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERTREENAME_SORT),    &kNC_FolderTreeNameSort);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_SPECIALFOLDER), &kNC_SpecialFolder);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_SERVERTYPE), &kNC_ServerType);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_ISDEFERRED),&kNC_IsDeferred);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANCREATEFOLDERSONSERVER), &kNC_CanCreateFoldersOnServer);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANFILEMESSAGESONSERVER), &kNC_CanFileMessagesOnServer);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_ISSERVER), &kNC_IsServer);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_ISSECURE), &kNC_IsSecure);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANSUBSCRIBE), &kNC_CanSubscribe);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_SUPPORTSOFFLINE), &kNC_SupportsOffline);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANFILEMESSAGES), &kNC_CanFileMessages);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANCREATESUBFOLDERS), &kNC_CanCreateSubfolders);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANRENAME), &kNC_CanRename);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANCOMPACT), &kNC_CanCompact);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_TOTALMESSAGES), &kNC_TotalMessages);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_TOTALUNREADMESSAGES), &kNC_TotalUnreadMessages);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_FOLDERSIZE), &kNC_FolderSize);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CHARSET), &kNC_Charset);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_BIFFSTATE), &kNC_BiffState);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_HASUNREADMESSAGES), &kNC_HasUnreadMessages);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_NEWMESSAGES), &kNC_NewMessages);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_SUBFOLDERSHAVEUNREADMESSAGES), &kNC_SubfoldersHaveUnreadMessages);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_NOSELECT), &kNC_NoSelect);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_VIRTUALFOLDER), &kNC_VirtualFolder);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_INVFEDITSEARCHSCOPE), &kNC_InVFEditSearchScope);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_IMAPSHARED), &kNC_ImapShared);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_SYNCHRONIZE), &kNC_Synchronize);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_SYNCDISABLED), &kNC_SyncDisabled);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_CANSEARCHMESSAGES), &kNC_CanSearchMessages);
+
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_DELETE), &kNC_Delete);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_REALLY_DELETE), &kNC_ReallyDelete);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_NEWFOLDER), &kNC_NewFolder);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_GETNEWMESSAGES), &kNC_GetNewMessages);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_COPY), &kNC_Copy);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_MOVE), &kNC_Move);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_COPYFOLDER), &kNC_CopyFolder);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_MOVEFOLDER), &kNC_MoveFolder);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_MARKALLMESSAGESREAD),
+                             &kNC_MarkAllMessagesRead);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_COMPACT), &kNC_Compact);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_COMPACTALL), &kNC_CompactAll);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_RENAME), &kNC_Rename);
+    rdf->GetResource(NS_LITERAL_CSTRING(NC_RDF_EMPTYTRASH), &kNC_EmptyTrash);
+
+    kTotalMessagesAtom           = MsgNewAtom("TotalMessages").take();
+    kTotalUnreadMessagesAtom     = MsgNewAtom("TotalUnreadMessages").take();
+    kFolderSizeAtom              = MsgNewAtom("FolderSize").take();
+    kBiffStateAtom               = MsgNewAtom("BiffState").take();
+    kSortOrderAtom               = MsgNewAtom("SortOrder").take();
+    kNewMessagesAtom             = MsgNewAtom("NewMessages").take();
+    kNameAtom                    = MsgNewAtom("Name").take();
+    kSynchronizeAtom             = MsgNewAtom("Synchronize").take();
+    kOpenAtom                    = MsgNewAtom("open").take();
+    kIsDeferredAtom              = MsgNewAtom("isDeferred").take();
+    kIsSecureAtom                = MsgNewAtom("isSecure").take();
+    kCanFileMessagesAtom         = MsgNewAtom("canFileMessages").take();
+    kInVFEditSearchScopeAtom     = MsgNewAtom("inVFEditSearchScope").take();
+  }
+
+  CreateLiterals(rdf);
+  CreateArcsOutEnumerator();
+}
+
+nsMsgFolderDataSource::~nsMsgFolderDataSource (void)
+{
+  if (--gFolderResourceRefCnt == 0)
+  {
+    nsrefcnt refcnt;
+    NS_RELEASE2(kNC_Child, refcnt);
+    NS_RELEASE2(kNC_Folder, refcnt);
+    NS_RELEASE2(kNC_Name, refcnt);
+    NS_RELEASE2(kNC_Open, refcnt);
+    NS_RELEASE2(kNC_FolderTreeName, refcnt);
+    NS_RELEASE2(kNC_FolderTreeSimpleName, refcnt);
+    NS_RELEASE2(kNC_NameSort, refcnt);
+    NS_RELEASE2(kNC_FolderTreeNameSort, refcnt);
+    NS_RELEASE2(kNC_SpecialFolder, refcnt);
+    NS_RELEASE2(kNC_ServerType, refcnt);
+    NS_RELEASE2(kNC_IsDeferred, refcnt);
+    NS_RELEASE2(kNC_CanCreateFoldersOnServer, refcnt);
+    NS_RELEASE2(kNC_CanFileMessagesOnServer, refcnt);
+    NS_RELEASE2(kNC_IsServer, refcnt);
+    NS_RELEASE2(kNC_IsSecure, refcnt);
+    NS_RELEASE2(kNC_CanSubscribe, refcnt);
+    NS_RELEASE2(kNC_SupportsOffline, refcnt);
+    NS_RELEASE2(kNC_CanFileMessages, refcnt);
+    NS_RELEASE2(kNC_CanCreateSubfolders, refcnt);
+    NS_RELEASE2(kNC_CanRename, refcnt);
+    NS_RELEASE2(kNC_CanCompact, refcnt);
+    NS_RELEASE2(kNC_TotalMessages, refcnt);
+    NS_RELEASE2(kNC_TotalUnreadMessages, refcnt);
+    NS_RELEASE2(kNC_FolderSize, refcnt);
+    NS_RELEASE2(kNC_Charset, refcnt);
+    NS_RELEASE2(kNC_BiffState, refcnt);
+    NS_RELEASE2(kNC_HasUnreadMessages, refcnt);
+    NS_RELEASE2(kNC_NewMessages, refcnt);
+    NS_RELEASE2(kNC_SubfoldersHaveUnreadMessages, refcnt);
+    NS_RELEASE2(kNC_NoSelect, refcnt);
+    NS_RELEASE2(kNC_VirtualFolder, refcnt);
+    NS_RELEASE2(kNC_InVFEditSearchScope, refcnt);
+    NS_RELEASE2(kNC_ImapShared, refcnt);
+    NS_RELEASE2(kNC_Synchronize, refcnt);
+    NS_RELEASE2(kNC_SyncDisabled, refcnt);
+    NS_RELEASE2(kNC_CanSearchMessages, refcnt);
+
+    NS_RELEASE2(kNC_Delete, refcnt);
+    NS_RELEASE2(kNC_ReallyDelete, refcnt);
+    NS_RELEASE2(kNC_NewFolder, refcnt);
+    NS_RELEASE2(kNC_GetNewMessages, refcnt);
+    NS_RELEASE2(kNC_Copy, refcnt);
+    NS_RELEASE2(kNC_Move, refcnt);
+    NS_RELEASE2(kNC_CopyFolder, refcnt);
+    NS_RELEASE2(kNC_MoveFolder, refcnt);
+    NS_RELEASE2(kNC_MarkAllMessagesRead, refcnt);
+    NS_RELEASE2(kNC_Compact, refcnt);
+    NS_RELEASE2(kNC_CompactAll, refcnt);
+    NS_RELEASE2(kNC_Rename, refcnt);
+    NS_RELEASE2(kNC_EmptyTrash, refcnt);
+    NS_RELEASE2(kNC_UnreadFolders, refcnt);
+    NS_RELEASE2(kNC_FavoriteFolders, refcnt);
+    NS_RELEASE2(kNC_RecentFolders, refcnt);
+
+    NS_RELEASE(kTotalMessagesAtom);
+    NS_RELEASE(kTotalUnreadMessagesAtom);
+    NS_RELEASE(kFolderSizeAtom);
+    NS_RELEASE(kBiffStateAtom);
+    NS_RELEASE(kSortOrderAtom);
+    NS_RELEASE(kNewMessagesAtom);
+    NS_RELEASE(kNameAtom);
+    NS_RELEASE(kSynchronizeAtom);
+    NS_RELEASE(kOpenAtom);
+    NS_RELEASE(kIsDeferredAtom);
+    NS_RELEASE(kIsSecureAtom);
+    NS_RELEASE(kCanFileMessagesAtom);
+    NS_RELEASE(kInVFEditSearchScopeAtom);
+  }
+}
+
+nsresult nsMsgFolderDataSource::CreateLiterals(nsIRDFService *rdf)
+{
+  createNode(u"true",
+    getter_AddRefs(kTrueLiteral), rdf);
+  createNode(u"false",
+    getter_AddRefs(kFalseLiteral), rdf);
+
+  return NS_OK;
+}
+
+nsresult nsMsgFolderDataSource::Init()
+{
+  nsresult rv;
+
+  rv = nsMsgRDFDataSource::Init();
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCOMPtr<nsIMsgMailSession> mailSession =
+    do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+
+  if(NS_SUCCEEDED(rv))
+    mailSession->AddFolderListener(this,
+      nsIFolderListener::added |
+      nsIFolderListener::removed |
+      nsIFolderListener::intPropertyChanged |
+      nsIFolderListener::boolPropertyChanged |
+      nsIFolderListener::unicharPropertyChanged);
+
+  return NS_OK;
+}
+
+void nsMsgFolderDataSource::Cleanup()
+{
+  nsresult rv;
+  if (!m_shuttingDown)
+  {
+    nsCOMPtr<nsIMsgMailSession> mailSession =
+      do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+
+    if(NS_SUCCEEDED(rv))
+      mailSession->RemoveFolderListener(this);
+  }
+
+  nsMsgRDFDataSource::Cleanup();
+}
+
+nsresult nsMsgFolderDataSource::CreateArcsOutEnumerator()
+{
+  nsresult rv;
+
+  rv = getFolderArcLabelsOut(kFolderArcsOutArray);
+  if(NS_FAILED(rv)) return rv;
+
+  return rv;
+}
+
+NS_IMPL_ADDREF_INHERITED(nsMsgFolderDataSource, nsMsgRDFDataSource)
+NS_IMPL_RELEASE_INHERITED(nsMsgFolderDataSource, nsMsgRDFDataSource)
+
+NS_IMPL_QUERY_INTERFACE_INHERITED(nsMsgFolderDataSource, nsMsgRDFDataSource, nsIFolderListener)
+
+ // nsIRDFDataSource methods
+NS_IMETHODIMP nsMsgFolderDataSource::GetURI(char* *uri)
+{
+  if ((*uri = strdup("rdf:mailnewsfolders")) == nullptr)
+    return NS_ERROR_OUT_OF_MEMORY;
+  else
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFolderDataSource::GetSource(nsIRDFResource* property,
+                                               nsIRDFNode* target,
+                                               bool tv,
+                                               nsIRDFResource** source /* out */)
+{
+  NS_ASSERTION(false, "not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgFolderDataSource::GetTarget(nsIRDFResource* source,
+                                               nsIRDFResource* property,
+                                               bool tv,
+                                               nsIRDFNode** target)
+{
+  nsresult rv = NS_RDF_NO_VALUE;
+
+  // we only have positive assertions in the mail data source.
+  if (! tv)
+    return NS_RDF_NO_VALUE;
+
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(source));
+  if (folder)
+    rv = createFolderNode(folder, property, target);
+  else
+    return NS_RDF_NO_VALUE;
+  return rv;
+}
+
+
+NS_IMETHODIMP nsMsgFolderDataSource::GetSources(nsIRDFResource* property,
+                                                nsIRDFNode* target,
+                                                bool tv,
+                                                nsISimpleEnumerator** sources)
+{
+  return NS_RDF_NO_VALUE;
+}
+
+NS_IMETHODIMP nsMsgFolderDataSource::GetTargets(nsIRDFResource* source,
+                                                nsIRDFResource* property,
+                                                bool tv,
+                                                nsISimpleEnumerator** targets)
+{
+  nsresult rv = NS_RDF_NO_VALUE;
+  if(!targets)
+    return NS_ERROR_NULL_POINTER;
+
+  *targets = nullptr;
+
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(source, &rv));
+  if (NS_SUCCEEDED(rv))
+  {
+    if (kNC_Child == property)
+    {
+      rv = folder->GetSubFolders(targets);
+    }
+    else if ((kNC_Name == property) ||
+      (kNC_Open == property) ||
+      (kNC_FolderTreeName == property) ||
+      (kNC_FolderTreeSimpleName == property) ||
+      (kNC_SpecialFolder == property) ||
+      (kNC_IsServer == property) ||
+      (kNC_IsSecure == property) ||
+      (kNC_CanSubscribe == property) ||
+      (kNC_SupportsOffline == property) ||
+      (kNC_CanFileMessages == property) ||
+      (kNC_CanCreateSubfolders == property) ||
+      (kNC_CanRename == property) ||
+      (kNC_CanCompact == property) ||
+      (kNC_ServerType == property) ||
+      (kNC_IsDeferred == property) ||
+      (kNC_CanCreateFoldersOnServer == property) ||
+      (kNC_CanFileMessagesOnServer == property) ||
+      (kNC_NoSelect == property) ||
+      (kNC_VirtualFolder == property) ||
+      (kNC_InVFEditSearchScope == property) ||
+      (kNC_ImapShared == property) ||
+      (kNC_Synchronize == property) ||
+      (kNC_SyncDisabled == property) ||
+      (kNC_CanSearchMessages == property))
+    {
+      return NS_NewSingletonEnumerator(targets, property);
+    }
+  }
+  if(!*targets)
+  {
+    //create empty cursor
+    rv = NS_NewEmptyEnumerator(targets);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgFolderDataSource::Assert(nsIRDFResource* source,
+                      nsIRDFResource* property,
+                      nsIRDFNode* target,
+                      bool tv)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(source, &rv));
+  //We don't handle tv = false at the moment.
+  if(NS_SUCCEEDED(rv) && tv)
+    return DoFolderAssert(folder, property, target);
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMsgFolderDataSource::Unassert(nsIRDFResource* source,
+                        nsIRDFResource* property,
+                        nsIRDFNode* target)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(source, &rv));
+  NS_ENSURE_SUCCESS(rv,rv);
+  return DoFolderUnassert(folder, property, target);
+}
+
+
+NS_IMETHODIMP nsMsgFolderDataSource::HasAssertion(nsIRDFResource* source,
+                            nsIRDFResource* property,
+                            nsIRDFNode* target,
+                            bool tv,
+                            bool* hasAssertion)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(source, &rv));
+  if(NS_SUCCEEDED(rv))
+    return DoFolderHasAssertion(folder, property, target, tv, hasAssertion);
+  else
+    *hasAssertion = false;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, bool *result)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(aSource, &rv));
+  if (NS_SUCCEEDED(rv))
+  {
+    *result = (aArc == kNC_Name ||
+      aArc == kNC_Open ||
+      aArc == kNC_FolderTreeName ||
+      aArc == kNC_FolderTreeSimpleName ||
+      aArc == kNC_SpecialFolder ||
+      aArc == kNC_ServerType ||
+      aArc == kNC_IsDeferred ||
+      aArc == kNC_CanCreateFoldersOnServer ||
+      aArc == kNC_CanFileMessagesOnServer ||
+      aArc == kNC_IsServer ||
+      aArc == kNC_IsSecure ||
+      aArc == kNC_CanSubscribe ||
+      aArc == kNC_SupportsOffline ||
+      aArc == kNC_CanFileMessages ||
+      aArc == kNC_CanCreateSubfolders ||
+      aArc == kNC_CanRename ||
+      aArc == kNC_CanCompact ||
+      aArc == kNC_TotalMessages ||
+      aArc == kNC_TotalUnreadMessages ||
+      aArc == kNC_FolderSize ||
+      aArc == kNC_Charset ||
+      aArc == kNC_BiffState ||
+      aArc == kNC_Child ||
+      aArc == kNC_NoSelect ||
+      aArc == kNC_VirtualFolder ||
+      aArc == kNC_InVFEditSearchScope ||
+      aArc == kNC_ImapShared ||
+      aArc == kNC_Synchronize ||
+      aArc == kNC_SyncDisabled ||
+      aArc == kNC_CanSearchMessages);
+  }
+  else
+  {
+    *result = false;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFolderDataSource::ArcLabelsIn(nsIRDFNode* node,
+                                                 nsISimpleEnumerator** labels)
+{
+  return nsMsgRDFDataSource::ArcLabelsIn(node, labels);
+}
+
+NS_IMETHODIMP nsMsgFolderDataSource::ArcLabelsOut(nsIRDFResource* source,
+                                                  nsISimpleEnumerator** labels)
+{
+  nsresult rv = NS_RDF_NO_VALUE;
+
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(source, &rv));
+  if (NS_SUCCEEDED(rv))
+  {
+    rv = NS_NewArrayEnumerator(labels, kFolderArcsOutArray);
+  }
+  else
+  {
+    rv = NS_NewEmptyEnumerator(labels);
+  }
+
+  return rv;
+}
+
+nsresult
+nsMsgFolderDataSource::getFolderArcLabelsOut(nsCOMArray<nsIRDFResource> &aArcs)
+{
+  aArcs.AppendObject(kNC_Name);
+  aArcs.AppendObject(kNC_Open);
+  aArcs.AppendObject(kNC_FolderTreeName);
+  aArcs.AppendObject(kNC_FolderTreeSimpleName);
+  aArcs.AppendObject(kNC_SpecialFolder);
+  aArcs.AppendObject(kNC_ServerType);
+  aArcs.AppendObject(kNC_IsDeferred);
+  aArcs.AppendObject(kNC_CanCreateFoldersOnServer);
+  aArcs.AppendObject(kNC_CanFileMessagesOnServer);
+  aArcs.AppendObject(kNC_IsServer);
+  aArcs.AppendObject(kNC_IsSecure);
+  aArcs.AppendObject(kNC_CanSubscribe);
+  aArcs.AppendObject(kNC_SupportsOffline);
+  aArcs.AppendObject(kNC_CanFileMessages);
+  aArcs.AppendObject(kNC_CanCreateSubfolders);
+  aArcs.AppendObject(kNC_CanRename);
+  aArcs.AppendObject(kNC_CanCompact);
+  aArcs.AppendObject(kNC_TotalMessages);
+  aArcs.AppendObject(kNC_TotalUnreadMessages);
+  aArcs.AppendObject(kNC_FolderSize);
+  aArcs.AppendObject(kNC_Charset);
+  aArcs.AppendObject(kNC_BiffState);
+  aArcs.AppendObject(kNC_Child);
+  aArcs.AppendObject(kNC_NoSelect);
+  aArcs.AppendObject(kNC_VirtualFolder);
+  aArcs.AppendObject(kNC_InVFEditSearchScope);
+  aArcs.AppendObject(kNC_ImapShared);
+  aArcs.AppendObject(kNC_Synchronize);
+  aArcs.AppendObject(kNC_SyncDisabled);
+  aArcs.AppendObject(kNC_CanSearchMessages);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::GetAllResources(nsISimpleEnumerator** aCursor)
+{
+  NS_NOTYETIMPLEMENTED("sorry!");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::GetAllCmds(nsIRDFResource* source,
+                                      nsISimpleEnumerator/*<nsIRDFResource>*/** commands)
+{
+  NS_NOTYETIMPLEMENTED("no one actually uses me");
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(source, &rv));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIMutableArray> cmds =
+    do_CreateInstance(NS_ARRAY_CONTRACTID);
+  NS_ENSURE_STATE(cmds);
+
+  cmds->AppendElement(kNC_Delete, false);
+  cmds->AppendElement(kNC_ReallyDelete, false);
+  cmds->AppendElement(kNC_NewFolder, false);
+  cmds->AppendElement(kNC_GetNewMessages, false);
+  cmds->AppendElement(kNC_Copy, false);
+  cmds->AppendElement(kNC_Move, false);
+  cmds->AppendElement(kNC_CopyFolder, false);
+  cmds->AppendElement(kNC_MoveFolder, false);
+  cmds->AppendElement(kNC_MarkAllMessagesRead, false);
+  cmds->AppendElement(kNC_Compact, false);
+  cmds->AppendElement(kNC_CompactAll, false);
+  cmds->AppendElement(kNC_Rename, false);
+  cmds->AppendElement(kNC_EmptyTrash, false);
+
+  return cmds->Enumerate(commands);
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::IsCommandEnabled(nsISupports/*nsISupportsArray<nsIRDFResource>*/* aSources,
+                                        nsIRDFResource*   aCommand,
+                                        nsISupports/*nsISupportsArray<nsIRDFResource>*/* aArguments,
+                                        bool* aResult)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folder;
+
+  nsCOMPtr<nsISupportsArray> sources = do_QueryInterface(aSources);
+  NS_ENSURE_STATE(sources);
+
+  uint32_t cnt;
+  rv = sources->Count(&cnt);
+  if (NS_FAILED(rv)) return rv;
+  for (uint32_t i = 0; i < cnt; i++)
+  {
+    folder = do_QueryElementAt(sources, i, &rv);
+    if (NS_SUCCEEDED(rv))
+    {
+      // we don't care about the arguments -- folder commands are always enabled
+      if (!((aCommand == kNC_Delete) ||
+            (aCommand == kNC_ReallyDelete) ||
+            (aCommand == kNC_NewFolder) ||
+            (aCommand == kNC_Copy) ||
+            (aCommand == kNC_Move) ||
+            (aCommand == kNC_CopyFolder) ||
+            (aCommand == kNC_MoveFolder) ||
+            (aCommand == kNC_GetNewMessages) ||
+            (aCommand == kNC_MarkAllMessagesRead) ||
+            (aCommand == kNC_Compact) ||
+            (aCommand == kNC_CompactAll) ||
+            (aCommand == kNC_Rename) ||
+            (aCommand == kNC_EmptyTrash)))
+      {
+        *aResult = false;
+        return NS_OK;
+      }
+    }
+  }
+  *aResult = true;
+  return NS_OK; // succeeded for all sources
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::DoCommand(nsISupports/*nsISupportsArray<nsIRDFResource>*/* aSources,
+                                 nsIRDFResource*   aCommand,
+                                 nsISupports/*nsISupportsArray<nsIRDFResource>*/* aArguments)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsISupports> supports;
+  nsCOMPtr<nsIMsgWindow> window;
+
+  nsCOMPtr<nsISupportsArray> sources = do_QueryInterface(aSources);
+  NS_ENSURE_STATE(sources);
+  nsCOMPtr<nsISupportsArray> arguments = do_QueryInterface(aArguments);
+
+  // callers can pass in the msgWindow as the last element of the arguments
+  // array. If they do, we'll use that as the msg window for progress, etc.
+  if (arguments)
+  {
+    uint32_t numArgs;
+    arguments->Count(&numArgs);
+    if (numArgs > 1)
+      window = do_QueryElementAt(arguments, numArgs - 1);
+  }
+  if (!window)
+    window = mWindow;
+
+  // XXX need to handle batching of command applied to all sources
+
+  uint32_t cnt = 0;
+  uint32_t i = 0;
+
+  rv = sources->Count(&cnt);
+  if (NS_FAILED(rv)) return rv;
+
+  for ( ; i < cnt; i++)
+  {
+    nsCOMPtr<nsIMsgFolder> folder = do_QueryElementAt(sources, i, &rv);
+    if (NS_SUCCEEDED(rv))
+    {
+      if (aCommand == kNC_Delete)
+      {
+        rv = DoDeleteFromFolder(folder, arguments, window, false);
+      }
+      if (aCommand == kNC_ReallyDelete)
+      {
+        rv = DoDeleteFromFolder(folder, arguments, window, true);
+      }
+      else if (aCommand == kNC_NewFolder)
+      {
+        rv = DoNewFolder(folder, arguments, window);
+      }
+      else if (aCommand == kNC_GetNewMessages)
+      {
+        nsCOMPtr<nsIMsgIncomingServer> server = do_QueryElementAt(arguments, i, &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv = server->GetNewMessages(folder, window, nullptr);
+      }
+      else if (aCommand == kNC_Copy)
+      {
+        rv = DoCopyToFolder(folder, arguments, window, false);
+      }
+      else if (aCommand == kNC_Move)
+      {
+        rv = DoCopyToFolder(folder, arguments, window, true);
+      }
+      else if (aCommand == kNC_CopyFolder)
+      {
+        rv = DoFolderCopyToFolder(folder, arguments, window, false);
+      }
+      else if (aCommand == kNC_MoveFolder)
+      {
+        rv = DoFolderCopyToFolder(folder, arguments, window, true);
+      }
+      else if (aCommand == kNC_MarkAllMessagesRead)
+      {
+        rv = folder->MarkAllMessagesRead(window);
+      }
+      else if (aCommand == kNC_Compact)
+      {
+        rv = folder->Compact(nullptr, window);
+      }
+      else if (aCommand == kNC_CompactAll)
+      {
+        // this will also compact offline stores for IMAP
+        rv = folder->CompactAll(nullptr, window, true);
+      }
+      else if (aCommand == kNC_EmptyTrash)
+      {
+          rv = folder->EmptyTrash(window, nullptr);
+      }
+      else if (aCommand == kNC_Rename)
+      {
+        nsCOMPtr<nsIRDFLiteral> literal = do_QueryElementAt(arguments, 0, &rv);
+        if(NS_SUCCEEDED(rv))
+        {
+          nsString name;
+          literal->GetValue(getter_Copies(name));
+          rv = folder->Rename(name, window);
+        }
+      }
+    }
+    else
+    {
+      rv = NS_ERROR_NOT_IMPLEMENTED;
+    }
+  }
+  //for the moment return NS_OK, because failure stops entire DoCommand process.
+  return rv;
+  //return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgFolderDataSource::OnItemAdded(nsIMsgFolder *parentItem, nsISupports *item)
+{
+  return OnItemAddedOrRemoved(parentItem, item, true);
+}
+
+NS_IMETHODIMP nsMsgFolderDataSource::OnItemRemoved(nsIMsgFolder *parentItem, nsISupports *item)
+{
+  return OnItemAddedOrRemoved(parentItem, item, false);
+}
+
+nsresult nsMsgFolderDataSource::OnItemAddedOrRemoved(nsIMsgFolder *parentItem, nsISupports *item, bool added)
+{
+  nsCOMPtr<nsIRDFNode> itemNode(do_QueryInterface(item));
+  if (itemNode)
+  {
+    nsCOMPtr<nsIRDFResource> parentResource(do_QueryInterface(parentItem));
+    if (parentResource) // RDF is not happy about a null parent resource.
+      NotifyObservers(parentResource, kNC_Child, itemNode, nullptr, added, false);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::OnItemPropertyChanged(nsIMsgFolder *resource,
+                                             nsIAtom *property,
+                                             const char *oldValue,
+                                             const char *newValue)
+
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::OnItemIntPropertyChanged(nsIMsgFolder *folder,
+                                                nsIAtom *property,
+                                                int64_t oldValue,
+                                                int64_t newValue)
+{
+  nsCOMPtr<nsIRDFResource> resource(do_QueryInterface(folder));
+  if (kTotalMessagesAtom == property)
+    OnTotalMessagePropertyChanged(resource, oldValue, newValue);
+  else if (kTotalUnreadMessagesAtom == property)
+    OnUnreadMessagePropertyChanged(resource, oldValue, newValue);
+  else if (kFolderSizeAtom == property)
+    OnFolderSizePropertyChanged(resource, oldValue, newValue);
+  else if (kSortOrderAtom == property)
+    OnFolderSortOrderPropertyChanged(resource, oldValue, newValue);
+  else if (kBiffStateAtom == property) {
+    // be careful about skipping if oldValue == newValue
+    // see the comment in nsMsgFolder::SetBiffState() about filters
+
+    nsCOMPtr<nsIRDFNode> biffNode;
+    nsresult rv = createBiffStateNodeFromFlag(newValue, getter_AddRefs(biffNode));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NotifyPropertyChanged(resource, kNC_BiffState, biffNode);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::OnItemUnicharPropertyChanged(nsIMsgFolder *folder,
+                                                    nsIAtom *property,
+                                                    const char16_t *oldValue,
+                                                    const char16_t *newValue)
+{
+  nsCOMPtr<nsIRDFResource> resource(do_QueryInterface(folder));
+  if (kNameAtom == property)
+  {
+    int32_t numUnread;
+    folder->GetNumUnread(false, &numUnread);
+    NotifyFolderTreeNameChanged(folder, resource, numUnread);
+    NotifyFolderTreeSimpleNameChanged(folder, resource);
+    NotifyFolderNameChanged(folder, resource);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::OnItemBoolPropertyChanged(nsIMsgFolder *folder,
+                                                 nsIAtom *property,
+                                                 bool oldValue,
+                                                 bool newValue)
+{
+  nsCOMPtr<nsIRDFResource> resource(do_QueryInterface(folder));
+  if (newValue != oldValue) {
+    nsIRDFNode* literalNode = newValue?kTrueLiteral:kFalseLiteral;
+    nsIRDFNode* oldLiteralNode = oldValue?kTrueLiteral:kFalseLiteral;
+    if (kNewMessagesAtom == property)
+      NotifyPropertyChanged(resource, kNC_NewMessages, literalNode);
+    else if (kSynchronizeAtom == property)
+      NotifyPropertyChanged(resource, kNC_Synchronize, literalNode);
+    else if (kOpenAtom == property)
+      NotifyPropertyChanged(resource, kNC_Open, literalNode);
+    else if (kIsDeferredAtom == property)
+      NotifyPropertyChanged(resource, kNC_IsDeferred, literalNode, oldLiteralNode);
+    else if (kIsSecureAtom == property)
+      NotifyPropertyChanged(resource, kNC_IsSecure, literalNode, oldLiteralNode);
+    else if (kCanFileMessagesAtom == property)
+      NotifyPropertyChanged(resource, kNC_CanFileMessages, literalNode, oldLiteralNode);
+    else if (kInVFEditSearchScopeAtom == property)
+      NotifyPropertyChanged(resource, kNC_InVFEditSearchScope, literalNode);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::OnItemPropertyFlagChanged(nsIMsgDBHdr *item,
+                                                 nsIAtom *property,
+                                                 uint32_t oldFlag,
+                                                 uint32_t newFlag)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgFolderDataSource::OnItemEvent(nsIMsgFolder *aFolder, nsIAtom *aEvent)
+{
+  return NS_OK;
+}
+
+
+nsresult nsMsgFolderDataSource::createFolderNode(nsIMsgFolder* folder,
+                                                 nsIRDFResource* property,
+                                                 nsIRDFNode** target)
+{
+  nsresult rv = NS_RDF_NO_VALUE;
+
+  if (kNC_NameSort == property)
+    rv = createFolderNameNode(folder, target, true);
+  else if(kNC_FolderTreeNameSort == property)
+    rv = createFolderNameNode(folder, target, true);
+  else if (kNC_Name == property)
+    rv = createFolderNameNode(folder, target, false);
+  else if(kNC_Open == property)
+    rv = createFolderOpenNode(folder, target);
+  else if (kNC_FolderTreeName == property)
+    rv = createFolderTreeNameNode(folder, target);
+  else if (kNC_FolderTreeSimpleName == property)
+    rv = createFolderTreeSimpleNameNode(folder, target);
+  else if (kNC_SpecialFolder == property)
+    rv = createFolderSpecialNode(folder,target);
+  else if (kNC_ServerType == property)
+    rv = createFolderServerTypeNode(folder, target);
+  else if (kNC_IsDeferred == property)
+    rv = createServerIsDeferredNode(folder, target);
+  else if (kNC_CanCreateFoldersOnServer == property)
+    rv = createFolderCanCreateFoldersOnServerNode(folder, target);
+  else if (kNC_CanFileMessagesOnServer == property)
+    rv = createFolderCanFileMessagesOnServerNode(folder, target);
+  else if (kNC_IsServer == property)
+    rv = createFolderIsServerNode(folder, target);
+  else if (kNC_IsSecure == property)
+    rv = createFolderIsSecureNode(folder, target);
+  else if (kNC_CanSubscribe == property)
+    rv = createFolderCanSubscribeNode(folder, target);
+  else if (kNC_SupportsOffline == property)
+    rv = createFolderSupportsOfflineNode(folder, target);
+  else if (kNC_CanFileMessages == property)
+    rv = createFolderCanFileMessagesNode(folder, target);
+  else if (kNC_CanCreateSubfolders == property)
+    rv = createFolderCanCreateSubfoldersNode(folder, target);
+  else if (kNC_CanRename == property)
+    rv = createFolderCanRenameNode(folder, target);
+  else if (kNC_CanCompact == property)
+    rv = createFolderCanCompactNode(folder, target);
+  else if (kNC_TotalMessages == property)
+    rv = createTotalMessagesNode(folder, target);
+  else if (kNC_TotalUnreadMessages == property)
+    rv = createUnreadMessagesNode(folder, target);
+  else if (kNC_FolderSize == property)
+    rv = createFolderSizeNode(folder, target);
+  else if (kNC_Charset == property)
+    rv = createCharsetNode(folder, target);
+  else if (kNC_BiffState == property)
+    rv = createBiffStateNodeFromFolder(folder, target);
+  else if (kNC_HasUnreadMessages == property)
+    rv = createHasUnreadMessagesNode(folder, false, target);
+  else if (kNC_NewMessages == property)
+    rv = createNewMessagesNode(folder, target);
+  else if (kNC_SubfoldersHaveUnreadMessages == property)
+    rv = createHasUnreadMessagesNode(folder, true, target);
+  else if (kNC_Child == property)
+    rv = createFolderChildNode(folder, target);
+  else if (kNC_NoSelect == property)
+    rv = createFolderNoSelectNode(folder, target);
+  else if (kNC_VirtualFolder == property)
+    rv = createFolderVirtualNode(folder, target);
+  else if (kNC_InVFEditSearchScope == property)
+    rv = createInVFEditSearchScopeNode(folder, target);
+  else if (kNC_ImapShared == property)
+    rv = createFolderImapSharedNode(folder, target);
+  else if (kNC_Synchronize == property)
+    rv = createFolderSynchronizeNode(folder, target);
+  else if (kNC_SyncDisabled == property)
+    rv = createFolderSyncDisabledNode(folder, target);
+  else if (kNC_CanSearchMessages == property)
+    rv = createCanSearchMessages(folder, target);
+  return NS_FAILED(rv) ? NS_RDF_NO_VALUE : rv;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderNameNode(nsIMsgFolder *folder,
+                                            nsIRDFNode **target, bool sort)
+{
+  nsresult rv;
+  if (sort)
+  {
+    uint8_t *sortKey=nullptr;
+    uint32_t sortKeyLength;
+    rv = folder->GetSortKey(&sortKeyLength, &sortKey);
+    NS_ENSURE_SUCCESS(rv, rv);
+    createBlobNode(sortKey, sortKeyLength, target, getRDFService());
+    PR_Free(sortKey);
+  }
+  else
+  {
+    nsString name;
+    rv = folder->GetName(name);
+    if (NS_FAILED(rv))
+      return rv;
+    createNode(name.get(), target, getRDFService());
+  }
+
+  return NS_OK;
+}
+
+nsresult nsMsgFolderDataSource::GetFolderDisplayName(nsIMsgFolder *folder, nsString& folderName)
+{
+  return folder->GetAbbreviatedName(folderName);
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderTreeNameNode(nsIMsgFolder *folder,
+                                                nsIRDFNode **target)
+{
+  nsString name;
+  nsresult rv = GetFolderDisplayName(folder, name);
+  if (NS_FAILED(rv)) return rv;
+  nsAutoString nameString(name);
+  int32_t unreadMessages;
+
+  rv = folder->GetNumUnread(false, &unreadMessages);
+  if(NS_SUCCEEDED(rv))
+    CreateUnreadMessagesNameString(unreadMessages, nameString);
+
+  createNode(nameString.get(), target, getRDFService());
+  return NS_OK;
+}
+
+nsresult nsMsgFolderDataSource::createFolderTreeSimpleNameNode(nsIMsgFolder * folder, nsIRDFNode **target)
+{
+  nsString name;
+  nsresult rv = GetFolderDisplayName(folder, name);
+  if (NS_FAILED(rv)) return rv;
+
+  createNode(name.get(), target, getRDFService());
+  return NS_OK;
+}
+
+nsresult nsMsgFolderDataSource::CreateUnreadMessagesNameString(int32_t unreadMessages, nsAutoString &nameString)
+{
+  //Only do this if unread messages are positive
+  if(unreadMessages > 0)
+  {
+    nameString.Append(NS_LITERAL_STRING(" ("));
+    nameString.AppendInt(unreadMessages);
+    nameString.Append(u')');
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderSpecialNode(nsIMsgFolder *folder,
+                                               nsIRDFNode **target)
+{
+  uint32_t flags;
+  nsresult rv = folder->GetFlags(&flags);
+  if(NS_FAILED(rv))
+    return rv;
+
+  nsAutoString specialFolderString;
+  if (flags & nsMsgFolderFlags::Inbox)
+    specialFolderString.AssignLiteral("Inbox");
+  else if (flags & nsMsgFolderFlags::Trash)
+    specialFolderString.AssignLiteral("Trash");
+  else if (flags & nsMsgFolderFlags::Queue)
+    specialFolderString.AssignLiteral("Outbox");
+  else if (flags & nsMsgFolderFlags::SentMail)
+    specialFolderString.AssignLiteral("Sent");
+  else if (flags & nsMsgFolderFlags::Drafts)
+    specialFolderString.AssignLiteral("Drafts");
+  else if (flags & nsMsgFolderFlags::Templates)
+    specialFolderString.AssignLiteral("Templates");
+  else if (flags & nsMsgFolderFlags::Junk)
+    specialFolderString.AssignLiteral("Junk");
+  else if (flags & nsMsgFolderFlags::Virtual)
+    specialFolderString.AssignLiteral("Virtual");
+  else if (flags & nsMsgFolderFlags::Archive)
+    specialFolderString.AssignLiteral("Archives");
+  else {
+    // XXX why do this at all? or just ""
+    specialFolderString.AssignLiteral("none");
+  }
+
+  createNode(specialFolderString.get(), target, getRDFService());
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderServerTypeNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = folder->GetServer(getter_AddRefs(server));
+  if (NS_FAILED(rv) || !server) return NS_ERROR_FAILURE;
+
+  nsCString serverType;
+  rv = server->GetType(serverType);
+  if (NS_FAILED(rv)) return rv;
+
+  createNode(NS_ConvertASCIItoUTF16(serverType).get(), target, getRDFService());
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createServerIsDeferredNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  bool isDeferred = false;
+  nsCOMPtr <nsIMsgIncomingServer> incomingServer;
+  folder->GetServer(getter_AddRefs(incomingServer));
+  if (incomingServer)
+  {
+    nsCOMPtr <nsIPop3IncomingServer> pop3Server = do_QueryInterface(incomingServer);
+    if (pop3Server)
+    {
+      nsCString deferredToServer;
+      pop3Server->GetDeferredToAccount(deferredToServer);
+      isDeferred = !deferredToServer.IsEmpty();
+    }
+  }
+  *target = (isDeferred) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderCanCreateFoldersOnServerNode(nsIMsgFolder* folder,
+                                                                 nsIRDFNode **target)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = folder->GetServer(getter_AddRefs(server));
+  if (NS_FAILED(rv) || !server) return NS_ERROR_FAILURE;
+
+  bool canCreateFoldersOnServer;
+  rv = server->GetCanCreateFoldersOnServer(&canCreateFoldersOnServer);
+  if (NS_FAILED(rv)) return rv;
+
+  if (canCreateFoldersOnServer)
+    *target = kTrueLiteral;
+  else
+    *target = kFalseLiteral;
+  NS_IF_ADDREF(*target);
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderCanFileMessagesOnServerNode(nsIMsgFolder* folder,
+                                                                 nsIRDFNode **target)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = folder->GetServer(getter_AddRefs(server));
+  if (NS_FAILED(rv) || !server) return NS_ERROR_FAILURE;
+
+  bool canFileMessagesOnServer;
+  rv = server->GetCanFileMessagesOnServer(&canFileMessagesOnServer);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = (canFileMessagesOnServer) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+
+  return NS_OK;
+}
+
+
+nsresult
+nsMsgFolderDataSource::createFolderIsServerNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  bool isServer;
+  rv = folder->GetIsServer(&isServer);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = nullptr;
+
+  if (isServer)
+    *target = kTrueLiteral;
+  else
+    *target = kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderNoSelectNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  bool noSelect;
+  rv = folder->GetNoSelect(&noSelect);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = (noSelect) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createInVFEditSearchScopeNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  bool inVFEditSearchScope = false;
+  folder->GetInVFEditSearchScope(&inVFEditSearchScope);
+
+  *target = inVFEditSearchScope ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderVirtualNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  uint32_t folderFlags;
+  folder->GetFlags(&folderFlags);
+
+  *target = (folderFlags & nsMsgFolderFlags::Virtual) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+
+nsresult
+nsMsgFolderDataSource::createFolderImapSharedNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  bool imapShared;
+  rv = folder->GetImapShared(&imapShared);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = (imapShared) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+
+nsresult
+nsMsgFolderDataSource::createFolderSynchronizeNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  bool sync;
+  rv = folder->GetFlag(nsMsgFolderFlags::Offline, &sync);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = nullptr;
+
+  *target = (sync) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderSyncDisabledNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+
+  nsresult rv;
+  bool isServer;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+
+  rv = folder->GetIsServer(&isServer);
+  if (NS_FAILED(rv)) return rv;
+
+  rv = folder->GetServer(getter_AddRefs(server));
+  if (NS_FAILED(rv) || !server) return NS_ERROR_FAILURE;
+
+  nsCString serverType;
+  rv = server->GetType(serverType);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = isServer || MsgLowerCaseEqualsLiteral(serverType, "none") || MsgLowerCaseEqualsLiteral(serverType, "pop3") ?
+            kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createCanSearchMessages(nsIMsgFolder* folder,
+                                                                 nsIRDFNode **target)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = folder->GetServer(getter_AddRefs(server));
+  if (NS_FAILED(rv) || !server) return NS_ERROR_FAILURE;
+
+  bool canSearchMessages;
+  rv = server->GetCanSearchMessages(&canSearchMessages);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = (canSearchMessages) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderOpenNode(nsIMsgFolder *folder, nsIRDFNode **target)
+{
+  NS_ENSURE_ARG_POINTER(target);
+
+  // call GetSubFolders() to ensure mFlags is set correctly
+  // from the folder cache on startup
+  nsCOMPtr<nsISimpleEnumerator> subFolders;
+  nsresult rv = folder->GetSubFolders(getter_AddRefs(subFolders));
+  if (NS_FAILED(rv))
+    return NS_RDF_NO_VALUE;
+
+  bool closed;
+  rv = folder->GetFlag(nsMsgFolderFlags::Elided, &closed);
+  if (NS_FAILED(rv))
+    return rv;
+
+  *target = (closed) ? kFalseLiteral : kTrueLiteral;
+
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderIsSecureNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  bool isSecure = false;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = folder->GetServer(getter_AddRefs(server));
+
+  if (NS_SUCCEEDED(rv) && server) {
+    rv = server->GetIsSecure(&isSecure);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  *target = (isSecure) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+
+nsresult
+nsMsgFolderDataSource::createFolderCanSubscribeNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  bool canSubscribe;
+  rv = folder->GetCanSubscribe(&canSubscribe);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = (canSubscribe) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderSupportsOfflineNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  bool supportsOffline;
+  rv = folder->GetSupportsOffline(&supportsOffline);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  *target = (supportsOffline) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderCanFileMessagesNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  bool canFileMessages;
+  rv = folder->GetCanFileMessages(&canFileMessages);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = (canFileMessages) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderCanCreateSubfoldersNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  nsresult rv;
+  bool canCreateSubfolders;
+  rv = folder->GetCanCreateSubfolders(&canCreateSubfolders);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = (canCreateSubfolders) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderCanRenameNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  bool canRename;
+  nsresult rv = folder->GetCanRename(&canRename);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = (canRename) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderCanCompactNode(nsIMsgFolder* folder,
+                                                  nsIRDFNode **target)
+{
+  bool canCompact;
+  nsresult rv = folder->GetCanCompact(&canCompact);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = (canCompact) ? kTrueLiteral : kFalseLiteral;
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+
+nsresult
+nsMsgFolderDataSource::createTotalMessagesNode(nsIMsgFolder *folder,
+                                               nsIRDFNode **target)
+{
+
+  bool isServer;
+  nsresult rv = folder->GetIsServer(&isServer);
+  if (NS_FAILED(rv)) return rv;
+
+  int32_t totalMessages;
+  if(isServer)
+    totalMessages = kDisplayBlankCount;
+  else
+  {
+    rv = folder->GetTotalMessages(false, &totalMessages);
+    if(NS_FAILED(rv)) return rv;
+  }
+  GetNumMessagesNode(totalMessages, target);
+
+  return rv;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderSizeNode(nsIMsgFolder *folder, nsIRDFNode **target)
+{
+  bool isServer;
+  nsresult rv = folder->GetIsServer(&isServer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int64_t folderSize;
+  if (isServer) {
+    folderSize = kDisplayBlankCount64;
+  }
+  else
+  {
+    // XXX todo, we are asserting here for news
+    // for offline news, we'd know the size on disk, right? Yes, bug 851275.
+    rv = folder->GetSizeOnDisk(&folderSize);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return GetFolderSizeNode(folderSize, target);
+}
+
+nsresult
+nsMsgFolderDataSource::createCharsetNode(nsIMsgFolder *folder, nsIRDFNode **target)
+{
+  nsCString charset;
+  nsresult rv = folder->GetCharset(charset);
+  if (NS_SUCCEEDED(rv))
+    createNode(NS_ConvertASCIItoUTF16(charset).get(), target, getRDFService());
+  else
+    createNode(EmptyString().get(), target, getRDFService());
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createBiffStateNodeFromFolder(nsIMsgFolder *folder, nsIRDFNode **target)
+{
+  uint32_t biffState;
+  nsresult rv = folder->GetBiffState(&biffState);
+  if(NS_FAILED(rv)) return rv;
+
+  rv = createBiffStateNodeFromFlag(biffState, target);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createBiffStateNodeFromFlag(uint32_t flag, nsIRDFNode **target)
+{
+  const char16_t *biffStateStr;
+
+  switch (flag) {
+    case nsIMsgFolder::nsMsgBiffState_NewMail:
+      biffStateStr = u"NewMail";
+      break;
+    case nsIMsgFolder::nsMsgBiffState_NoMail:
+      biffStateStr = u"NoMail";
+      break;
+    default:
+      biffStateStr = u"UnknownMail";
+      break;
+  }
+
+  createNode(biffStateStr, target, getRDFService());
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createUnreadMessagesNode(nsIMsgFolder *folder,
+                        nsIRDFNode **target)
+{
+  bool isServer;
+  nsresult rv = folder->GetIsServer(&isServer);
+  if (NS_FAILED(rv)) return rv;
+
+  int32_t totalUnreadMessages;
+  if(isServer)
+    totalUnreadMessages = kDisplayBlankCount;
+  else
+  {
+    rv = folder->GetNumUnread(false, &totalUnreadMessages);
+    if(NS_FAILED(rv)) return rv;
+  }
+  GetNumMessagesNode(totalUnreadMessages, target);
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createHasUnreadMessagesNode(nsIMsgFolder *folder, bool aIncludeSubfolders, nsIRDFNode **target)
+{
+  bool isServer;
+  nsresult rv = folder->GetIsServer(&isServer);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = kFalseLiteral;
+
+  int32_t totalUnreadMessages;
+  if(!isServer)
+  {
+    rv = folder->GetNumUnread(aIncludeSubfolders, &totalUnreadMessages);
+    if(NS_FAILED(rv)) return rv;
+    // if we're including sub-folders, we're trying to find out if child folders
+    // have unread. If so, we subtract the unread msgs in the current folder.
+    if (aIncludeSubfolders)
+    {
+      int32_t numUnreadInFolder;
+      rv = folder->GetNumUnread(false, &numUnreadInFolder);
+      NS_ENSURE_SUCCESS(rv, rv);
+      // don't subtract if numUnread is negative (which means we don't know the unread count)
+      if (numUnreadInFolder > 0)
+        totalUnreadMessages -= numUnreadInFolder;
+    }
+    *target = (totalUnreadMessages > 0) ? kTrueLiteral : kFalseLiteral;
+  }
+
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::OnUnreadMessagePropertyChanged(nsIRDFResource *folderResource, int32_t oldValue, int32_t newValue)
+{
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(folderResource);
+  if(folder)
+  {
+    //First send a regular unread message changed notification
+    nsCOMPtr<nsIRDFNode> newNode;
+
+    GetNumMessagesNode(newValue, getter_AddRefs(newNode));
+    NotifyPropertyChanged(folderResource, kNC_TotalUnreadMessages, newNode);
+
+    //Now see if hasUnreadMessages has changed
+    if(oldValue <=0 && newValue >0)
+    {
+      NotifyPropertyChanged(folderResource, kNC_HasUnreadMessages, kTrueLiteral);
+      NotifyAncestors(folder, kNC_SubfoldersHaveUnreadMessages, kTrueLiteral);
+    }
+    else if(oldValue > 0 && newValue <= 0)
+    {
+      NotifyPropertyChanged(folderResource, kNC_HasUnreadMessages, kFalseLiteral);
+      // this isn't quite right - parents could still have other children with
+      // unread messages. NotifyAncestors will have to figure that out...
+      NotifyAncestors(folder, kNC_SubfoldersHaveUnreadMessages, kFalseLiteral);
+    }
+
+    //We will have to change the folderTreeName if the unread column is hidden
+    NotifyFolderTreeNameChanged(folder, folderResource, newValue);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::NotifyFolderNameChanged(nsIMsgFolder* aFolder, nsIRDFResource *folderResource)
+{
+  nsString name;
+  nsresult rv = aFolder->GetName(name);
+
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsIRDFNode> newNameNode;
+    createNode(name.get(), getter_AddRefs(newNameNode), getRDFService());
+    NotifyPropertyChanged(folderResource, kNC_Name, newNameNode);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::NotifyFolderTreeSimpleNameChanged(nsIMsgFolder* aFolder, nsIRDFResource *folderResource)
+{
+  nsString abbreviatedName;
+  nsresult rv = GetFolderDisplayName(aFolder, abbreviatedName);
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsIRDFNode> newNameNode;
+    createNode(abbreviatedName.get(), getter_AddRefs(newNameNode), getRDFService());
+    NotifyPropertyChanged(folderResource, kNC_FolderTreeSimpleName, newNameNode);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::NotifyFolderTreeNameChanged(nsIMsgFolder* aFolder,
+                                                   nsIRDFResource* aFolderResource,
+                                                   int32_t aUnreadMessages)
+{
+  nsString name;
+  nsresult rv = GetFolderDisplayName(aFolder, name);
+  if (NS_SUCCEEDED(rv)) {
+    nsAutoString newNameString(name);
+    CreateUnreadMessagesNameString(aUnreadMessages, newNameString);
+    nsCOMPtr<nsIRDFNode> newNameNode;
+    createNode(newNameString.get(), getter_AddRefs(newNameNode), getRDFService());
+    NotifyPropertyChanged(aFolderResource, kNC_FolderTreeName, newNameNode);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::NotifyAncestors(nsIMsgFolder *aFolder, nsIRDFResource *aPropertyResource, nsIRDFNode *aNode)
+{
+  bool isServer = false;
+  nsresult rv = aFolder->GetIsServer(&isServer);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  if (isServer)
+    // done, stop
+    return NS_OK;
+
+  nsCOMPtr <nsIMsgFolder> parentMsgFolder;
+  rv = aFolder->GetParent(getter_AddRefs(parentMsgFolder));
+  NS_ENSURE_SUCCESS(rv,rv);
+  if (!parentMsgFolder)
+    return NS_OK;
+
+  rv = parentMsgFolder->GetIsServer(&isServer);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // don't need to notify servers either.
+  if (isServer)
+    // done, stop
+    return NS_OK;
+
+  nsCOMPtr<nsIRDFResource> parentFolderResource = do_QueryInterface(parentMsgFolder,&rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // if we're setting the subFoldersHaveUnreadMessages property to false, check
+  // if the folder really doesn't have subfolders with unread messages.
+  if (aPropertyResource == kNC_SubfoldersHaveUnreadMessages && aNode == kFalseLiteral)
+  {
+    nsCOMPtr <nsIRDFNode> unreadMsgsNode;
+    createHasUnreadMessagesNode(parentMsgFolder, true, getter_AddRefs(unreadMsgsNode));
+    aNode = unreadMsgsNode;
+  }
+  NotifyPropertyChanged(parentFolderResource, aPropertyResource, aNode);
+
+  return NotifyAncestors(parentMsgFolder, aPropertyResource, aNode);
+}
+
+// New Messages
+
+nsresult
+nsMsgFolderDataSource::createNewMessagesNode(nsIMsgFolder *folder, nsIRDFNode **target)
+{
+
+  nsresult rv;
+
+  bool isServer;
+  rv = folder->GetIsServer(&isServer);
+  if (NS_FAILED(rv)) return rv;
+
+  *target = kFalseLiteral;
+
+  //int32_t totalNewMessages;
+  bool isNewMessages;
+  if(!isServer)
+  {
+    rv = folder->GetHasNewMessages(&isNewMessages);
+    if(NS_FAILED(rv)) return rv;
+    *target = (isNewMessages) ? kTrueLiteral : kFalseLiteral;
+  }
+  NS_IF_ADDREF(*target);
+  return NS_OK;
+}
+
+/**
+nsresult
+nsMsgFolderDataSource::OnUnreadMessagePropertyChanged(nsIMsgFolder *folder, int32_t oldValue, int32_t newValue)
+{
+  nsCOMPtr<nsIRDFResource> folderResource = do_QueryInterface(folder);
+  if(folderResource)
+  {
+    //First send a regular unread message changed notification
+    nsCOMPtr<nsIRDFNode> newNode;
+
+    GetNumMessagesNode(newValue, getter_AddRefs(newNode));
+    NotifyPropertyChanged(folderResource, kNC_TotalUnreadMessages, newNode);
+
+    //Now see if hasUnreadMessages has changed
+    nsCOMPtr<nsIRDFNode> oldHasUnreadMessages;
+    nsCOMPtr<nsIRDFNode> newHasUnreadMessages;
+    if(oldValue <=0 && newValue >0)
+    {
+      oldHasUnreadMessages = kFalseLiteral;
+      newHasUnreadMessages = kTrueLiteral;
+      NotifyPropertyChanged(folderResource, kNC_HasUnreadMessages, newHasUnreadMessages);
+    }
+    else if(oldValue > 0 && newValue <= 0)
+    {
+      newHasUnreadMessages = kFalseLiteral;
+      NotifyPropertyChanged(folderResource, kNC_HasUnreadMessages, newHasUnreadMessages);
+    }
+  }
+  return NS_OK;
+}
+
+**/
+nsresult
+nsMsgFolderDataSource::OnFolderSortOrderPropertyChanged(nsIRDFResource *folderResource, int32_t oldValue, int32_t newValue)
+{
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(folderResource));
+  if (folder)
+  {
+    nsCOMPtr<nsIRDFNode> newNode;
+    createFolderNameNode(folder, getter_AddRefs(newNode), true);
+    NotifyPropertyChanged(folderResource, kNC_FolderTreeNameSort, newNode);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::OnFolderSizePropertyChanged(nsIRDFResource *folderResource, int64_t oldValue, int64_t newValue)
+{
+  nsCOMPtr<nsIRDFNode> newNode;
+  GetFolderSizeNode(newValue, getter_AddRefs(newNode));
+  NotifyPropertyChanged(folderResource, kNC_FolderSize, newNode);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::OnTotalMessagePropertyChanged(nsIRDFResource *folderResource, int32_t oldValue, int32_t newValue)
+{
+  nsCOMPtr<nsIRDFNode> newNode;
+  GetNumMessagesNode(newValue, getter_AddRefs(newNode));
+  NotifyPropertyChanged(folderResource, kNC_TotalMessages, newNode);
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::GetNumMessagesNode(int32_t aNumMessages, nsIRDFNode **node)
+{
+  uint32_t numMessages = aNumMessages;
+  if(numMessages == kDisplayQuestionCount)
+    createNode(u"???", node, getRDFService());
+  else if (numMessages == kDisplayBlankCount || numMessages == 0)
+    createNode(EmptyString().get(), node, getRDFService());
+  else
+    createIntNode(numMessages, node, getRDFService());
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::GetFolderSizeNode(int64_t aFolderSize, nsIRDFNode **aNode)
+{
+  nsresult rv;
+  if (aFolderSize == kDisplayBlankCount64 || aFolderSize == 0)
+    createNode(EmptyString().get(), aNode, getRDFService());
+  else if (aFolderSize == kDisplayQuestionCount64)
+    createNode(u"???", aNode, getRDFService());
+  else
+  {
+    nsAutoString sizeString;
+    rv = FormatFileSize(aFolderSize, true, sizeString);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    createNode(sizeString.get(), aNode, getRDFService());
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgFolderDataSource::createFolderChildNode(nsIMsgFolder *folder,
+                                             nsIRDFNode **target)
+{
+  nsCOMPtr<nsISimpleEnumerator> subFolders;
+  nsresult rv = folder->GetSubFolders(getter_AddRefs(subFolders));
+  if (NS_FAILED(rv))
+    return NS_RDF_NO_VALUE;
+
+  bool hasMore;
+  rv = subFolders->HasMoreElements(&hasMore);
+  if (NS_FAILED(rv) || !hasMore)
+    return NS_RDF_NO_VALUE;
+
+  nsCOMPtr<nsISupports> firstFolder;
+  rv = subFolders->GetNext(getter_AddRefs(firstFolder));
+  if (NS_FAILED(rv))
+    return NS_RDF_NO_VALUE;
+
+  return CallQueryInterface(firstFolder, target);
+}
+
+
+nsresult nsMsgFolderDataSource::DoCopyToFolder(nsIMsgFolder *dstFolder, nsISupportsArray *arguments,
+                         nsIMsgWindow *msgWindow, bool isMove)
+{
+  nsresult rv;
+  uint32_t itemCount;
+  rv = arguments->Count(&itemCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  //need source folder and at least one item to copy
+  if(itemCount < 2)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgFolder> srcFolder(do_QueryElementAt(arguments, 0));
+  if(!srcFolder)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID));
+
+  // Remove first element
+  for(uint32_t i = 1; i < itemCount; i++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> message(do_QueryElementAt(arguments, i));
+    if (message)
+    {
+      messageArray->AppendElement(message, false);
+    }
+  }
+
+  //Call copyservice with dstFolder, srcFolder, messages, isMove, and txnManager
+  nsCOMPtr<nsIMsgCopyService> copyService =
+    do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  return copyService->CopyMessages(srcFolder, messageArray, dstFolder, isMove,
+    nullptr, msgWindow, true/* allowUndo */);
+}
+
+nsresult nsMsgFolderDataSource::DoFolderCopyToFolder(nsIMsgFolder *dstFolder, nsISupportsArray *arguments,
+                                                     nsIMsgWindow *msgWindow, bool isMoveFolder)
+{
+  nsresult rv;
+  uint32_t itemCount;
+  rv = arguments->Count(&itemCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  //need at least one item to copy
+  if(itemCount < 1)
+    return NS_ERROR_FAILURE;
+
+  if (!isMoveFolder)   // copy folder not on the same server
+  {
+    // Create an nsIMutableArray from the nsISupportsArray
+    nsCOMPtr<nsIMutableArray> folderArray(do_CreateInstance(NS_ARRAY_CONTRACTID));
+    for (uint32_t i = 0; i < itemCount; i++)
+    {
+      nsCOMPtr<nsISupports> element(do_QueryElementAt(arguments, i, &rv));
+      if (NS_SUCCEEDED(rv))
+        folderArray->AppendElement(element, false);
+    }
+
+    //Call copyservice with dstFolder, srcFolder, folders and isMoveFolder
+    nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+    if(NS_SUCCEEDED(rv))
+    {
+      rv = copyService->CopyFolders(folderArray, dstFolder, isMoveFolder,
+        nullptr, msgWindow);
+
+    }
+  }
+  else    //within the same server therefore no need for copy service
+  {
+
+    nsCOMPtr<nsIMsgFolder> msgFolder;
+    for (uint32_t i=0;i< itemCount; i++)
+    {
+      msgFolder = do_QueryElementAt(arguments, i, &rv);
+      if (NS_SUCCEEDED(rv))
+      {
+        rv = dstFolder->CopyFolder(msgFolder, isMoveFolder , msgWindow, nullptr);
+        NS_ASSERTION((NS_SUCCEEDED(rv)),"Copy folder failed.");
+      }
+    }
+  }
+
+  return rv;
+  //return NS_OK;
+}
+
+nsresult nsMsgFolderDataSource::DoDeleteFromFolder(nsIMsgFolder *folder, nsISupportsArray *arguments,
+                                                   nsIMsgWindow *msgWindow, bool reallyDelete)
+{
+  nsresult rv = NS_OK;
+  uint32_t itemCount;
+  rv = arguments->Count(&itemCount);
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID));
+  nsCOMPtr<nsIMutableArray> folderArray(do_CreateInstance(NS_ARRAY_CONTRACTID));
+
+  //Split up deleted items into different type arrays to be passed to the folder
+  //for deletion.
+  for(uint32_t item = 0; item < itemCount; item++)
+  {
+    nsCOMPtr<nsISupports> supports(do_QueryElementAt(arguments, item));
+    nsCOMPtr<nsIMsgDBHdr> deletedMessage(do_QueryInterface(supports));
+    nsCOMPtr<nsIMsgFolder> deletedFolder(do_QueryInterface(supports));
+    if (deletedMessage)
+    {
+      messageArray->AppendElement(supports, false);
+    }
+    else if(deletedFolder)
+    {
+      folderArray->AppendElement(supports, false);
+    }
+  }
+  uint32_t cnt;
+  rv = messageArray->GetLength(&cnt);
+  if (NS_FAILED(rv)) return rv;
+  if (cnt > 0)
+    rv = folder->DeleteMessages(messageArray, msgWindow, reallyDelete, false, nullptr, true /*allowUndo*/);
+
+  rv = folderArray->GetLength(&cnt);
+  if (NS_FAILED(rv)) return rv;
+  if (cnt > 0)
+  {
+    nsCOMPtr<nsIMsgFolder> folderToDelete = do_QueryElementAt(folderArray, 0);
+    uint32_t folderFlags = 0;
+    if (folderToDelete)
+    {
+      folderToDelete->GetFlags(&folderFlags);
+      if (folderFlags & nsMsgFolderFlags::Virtual)
+      {
+        NS_ENSURE_ARG_POINTER(msgWindow);
+        nsCOMPtr<nsIStringBundleService> sBundleService =
+          mozilla::services::GetStringBundleService();
+        NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED);
+        nsCOMPtr<nsIStringBundle> sMessengerStringBundle;
+        nsString confirmMsg;
+        rv = sBundleService->CreateBundle(MESSENGER_STRING_URL, getter_AddRefs(sMessengerStringBundle));
+        NS_ENSURE_SUCCESS(rv, rv);
+        sMessengerStringBundle->GetStringFromName(u"confirmSavedSearchDeleteMessage", getter_Copies(confirmMsg));
+
+        nsCOMPtr<nsIPrompt> dialog;
+        rv = msgWindow->GetPromptDialog(getter_AddRefs(dialog));
+        if (NS_SUCCEEDED(rv))
+        {
+          bool dialogResult;
+          rv = dialog->Confirm(nullptr, confirmMsg.get(), &dialogResult);
+          if (!dialogResult)
+            return NS_OK;
+        }
+      }
+    }
+    rv = folder->DeleteSubFolders(folderArray, msgWindow);
+  }
+  return rv;
+}
+
+nsresult nsMsgFolderDataSource::DoNewFolder(nsIMsgFolder *folder, nsISupportsArray *arguments, nsIMsgWindow *window)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIRDFLiteral> literal = do_QueryElementAt(arguments, 0, &rv);
+  if(NS_SUCCEEDED(rv))
+  {
+    nsString name;
+    literal->GetValue(getter_Copies(name));
+    rv = folder->CreateSubfolder(name, window);
+  }
+  return rv;
+}
+
+nsresult nsMsgFolderDataSource::DoFolderAssert(nsIMsgFolder *folder, nsIRDFResource *property, nsIRDFNode *target)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+
+  if (kNC_Charset == property)
+  {
+    nsCOMPtr<nsIRDFLiteral> literal(do_QueryInterface(target));
+    if(literal)
+    {
+      const char16_t* value;
+      rv = literal->GetValueConst(&value);
+      if(NS_SUCCEEDED(rv))
+        rv = folder->SetCharset(NS_LossyConvertUTF16toASCII(value));
+    }
+    else
+      rv = NS_ERROR_FAILURE;
+  }
+  else if (kNC_Open == property && target == kTrueLiteral)
+      rv = folder->ClearFlag(nsMsgFolderFlags::Elided);
+
+  return rv;
+}
+
+nsresult nsMsgFolderDataSource::DoFolderUnassert(nsIMsgFolder *folder, nsIRDFResource *property, nsIRDFNode *target)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+
+  if((kNC_Open == property) && target == kTrueLiteral)
+      rv = folder->SetFlag(nsMsgFolderFlags::Elided);
+
+  return rv;
+}
+
+nsresult nsMsgFolderDataSource::DoFolderHasAssertion(nsIMsgFolder *folder,
+                                                     nsIRDFResource *property,
+                                                     nsIRDFNode *target,
+                                                     bool tv,
+                                                     bool *hasAssertion)
+{
+  nsresult rv = NS_OK;
+  if(!hasAssertion)
+    return NS_ERROR_NULL_POINTER;
+
+  //We're not keeping track of negative assertions on folders.
+  if(!tv)
+  {
+    *hasAssertion = false;
+    return NS_OK;
+  }
+
+  if (kNC_Child == property)
+  {
+    nsCOMPtr<nsIMsgFolder> childFolder(do_QueryInterface(target, &rv));
+    if(NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIMsgFolder> childsParent;
+      rv = childFolder->GetParent(getter_AddRefs(childsParent));
+      *hasAssertion = (NS_SUCCEEDED(rv) && childsParent && folder
+        && (childsParent.get() == folder));
+    }
+  }
+  else if ((kNC_Name == property) ||
+    (kNC_Open == property) ||
+    (kNC_FolderTreeName == property) ||
+    (kNC_FolderTreeSimpleName == property) ||
+    (kNC_SpecialFolder == property) ||
+    (kNC_ServerType == property) ||
+    (kNC_IsDeferred == property) ||
+    (kNC_CanCreateFoldersOnServer == property) ||
+    (kNC_CanFileMessagesOnServer == property) ||
+    (kNC_IsServer == property) ||
+    (kNC_IsSecure == property) ||
+    (kNC_CanSubscribe == property) ||
+    (kNC_SupportsOffline == property) ||
+    (kNC_CanFileMessages == property) ||
+    (kNC_CanCreateSubfolders == property) ||
+    (kNC_CanRename == property) ||
+    (kNC_CanCompact == property) ||
+    (kNC_TotalMessages == property) ||
+    (kNC_TotalUnreadMessages == property) ||
+    (kNC_FolderSize == property) ||
+    (kNC_Charset == property) ||
+    (kNC_BiffState == property) ||
+    (kNC_HasUnreadMessages == property) ||
+    (kNC_NoSelect == property)  ||
+    (kNC_Synchronize == property) ||
+    (kNC_SyncDisabled == property) ||
+    (kNC_VirtualFolder == property) ||
+    (kNC_CanSearchMessages == property))
+  {
+    nsCOMPtr<nsIRDFResource> folderResource(do_QueryInterface(folder, &rv));
+
+    if(NS_FAILED(rv))
+      return rv;
+
+    rv = GetTargetHasAssertion(this, folderResource, property, tv, target, hasAssertion);
+  }
+  else
+    *hasAssertion = false;
+  return rv;
+}
+
+nsMsgFlatFolderDataSource::nsMsgFlatFolderDataSource()
+{
+  m_builtFolders = false;
+}
+
+nsMsgFlatFolderDataSource::~nsMsgFlatFolderDataSource()
+{
+}
+
+nsresult nsMsgFlatFolderDataSource::Init()
+{
+  nsIRDFService* rdf = getRDFService();
+  NS_ENSURE_TRUE(rdf, NS_ERROR_FAILURE);
+  nsCOMPtr<nsIRDFResource> source;
+  nsAutoCString dsUri(m_dsName);
+  dsUri.Append(":/");
+  rdf->GetResource(dsUri, getter_AddRefs(m_rootResource));
+
+  return nsMsgFolderDataSource::Init();
+}
+
+void nsMsgFlatFolderDataSource::Cleanup()
+{
+  m_folders.Clear();
+  m_builtFolders = false;
+  nsMsgFolderDataSource::Cleanup();
+}
+
+NS_IMETHODIMP nsMsgFlatFolderDataSource::GetTarget(nsIRDFResource* source,
+                       nsIRDFResource* property,
+                       bool tv,
+                       nsIRDFNode** target)
+{
+  return (property == kNC_Child)
+    ? NS_RDF_NO_VALUE
+    : nsMsgFolderDataSource::GetTarget(source, property, tv, target);
+}
+
+
+NS_IMETHODIMP nsMsgFlatFolderDataSource::GetTargets(nsIRDFResource* source,
+                                                nsIRDFResource* property,
+                                                bool tv,
+                                                nsISimpleEnumerator** targets)
+{
+  if (kNC_Child != property)
+    return nsMsgFolderDataSource::GetTargets(source, property, tv, targets);
+
+  if(!targets)
+    return NS_ERROR_NULL_POINTER;
+
+  if (ResourceIsOurRoot(source))
+  {
+    EnsureFolders();
+    return NS_NewArrayEnumerator(targets, m_folders);
+  }
+  return NS_NewSingletonEnumerator(targets, property);
+}
+
+void nsMsgFlatFolderDataSource::EnsureFolders()
+{
+  if (m_builtFolders)
+    return;
+
+  m_builtFolders = true; // in case something goes wrong
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIArray> allFolders;
+  rv = accountManager->GetAllFolders(getter_AddRefs(allFolders));
+  if (NS_FAILED(rv) || !allFolders)
+    return;
+
+  uint32_t count;
+  rv = allFolders->GetLength(&count);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  for (uint32_t i = 0; i < count; i++)
+  {
+    nsCOMPtr<nsIMsgFolder> curFolder = do_QueryElementAt(allFolders, i);
+    if (WantsThisFolder(curFolder))
+      m_folders.AppendObject(curFolder);
+  }
+}
+
+
+NS_IMETHODIMP nsMsgFlatFolderDataSource::GetURI(char* *aUri)
+{
+  nsAutoCString uri("rdf:");
+  uri.Append(m_dsName);
+  return (*aUri = ToNewCString(uri))
+    ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsMsgFlatFolderDataSource::HasAssertion(nsIRDFResource* source,
+                            nsIRDFResource* property,
+                            nsIRDFNode* target,
+                            bool tv,
+                            bool* hasAssertion)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(source, &rv));
+  // we need to check if the folder belongs in this datasource.
+  if (NS_SUCCEEDED(rv) && property != kNC_Open && property != kNC_Child)
+  {
+    if (WantsThisFolder(folder) && (kNC_Child != property))
+      return DoFolderHasAssertion(folder, property, target, tv, hasAssertion);
+  }
+  else if (property == kNC_Child && ResourceIsOurRoot(source)) // check if source is us
+  {
+    folder = do_QueryInterface(target);
+    if (folder)
+    {
+      nsCOMPtr<nsIMsgFolder> parentMsgFolder;
+      folder->GetParent(getter_AddRefs(parentMsgFolder));
+      // a folder without a parent must be getting deleted as part of
+      // the rename operation and is thus a folder we are
+      // no longer interested in
+      if (parentMsgFolder && WantsThisFolder(folder))
+      {
+        *hasAssertion = true;
+        return NS_OK;
+      }
+    }
+  }
+  *hasAssertion = false;
+  return NS_OK;
+}
+
+nsresult nsMsgFlatFolderDataSource::OnItemAddedOrRemoved(nsIMsgFolder *parentItem, nsISupports *item, bool added)
+{
+  // When a folder is added or removed, parentItem is the parent folder and item is the folder being
+  // added or removed. In a flat data source, there is no arc in the graph between the parent folder
+  // and the folder being added or removed. Our flat data source root (i.e. mailnewsunreadfolders:/) has
+  // an arc with the child property to every folder in the data source.  We must change parentItem
+  // to be our data source root before calling nsMsgFolderDataSource::OnItemAddedOrRemoved. This ensures
+  // that datasource listeners such as the template builder properly handle add and remove
+  // notifications on the flat datasource.
+  nsCOMPtr<nsIRDFNode> itemNode(do_QueryInterface(item));
+  if (itemNode)
+    NotifyObservers(m_rootResource, kNC_Child, itemNode, nullptr, added, false);
+  return NS_OK;
+}
+
+bool nsMsgFlatFolderDataSource::ResourceIsOurRoot(nsIRDFResource *resource)
+{
+  return m_rootResource.get() == resource;
+}
+
+bool nsMsgFlatFolderDataSource::WantsThisFolder(nsIMsgFolder *folder)
+{
+  EnsureFolders();
+  return m_folders.Contains(folder);
+}
+
+nsresult nsMsgFlatFolderDataSource::GetFolderDisplayName(nsIMsgFolder *folder, nsString& folderName)
+{
+  folder->GetName(folderName);
+  uint32_t foldersCount = m_folders.Count();
+  nsString otherFolderName;
+  for (uint32_t index = 0; index < foldersCount; index++)
+  {
+    if (folder == m_folders[index]) // ignore ourselves.
+      continue;
+    m_folders[index]->GetName(otherFolderName);
+    if (otherFolderName.Equals(folderName))
+    {
+      nsCOMPtr <nsIMsgIncomingServer> server;
+      folder->GetServer(getter_AddRefs(server));
+      if (server)
+      {
+        nsString serverName;
+        server->GetPrettyName(serverName);
+        folderName.AppendLiteral(" - ");
+        folderName.Append(serverName);
+        return NS_OK;
+      }
+    }
+  }
+  // check if folder name is unique - if not, append account name
+  return folder->GetAbbreviatedName(folderName);
+}
+
+
+bool nsMsgUnreadFoldersDataSource::WantsThisFolder(nsIMsgFolder *folder)
+{
+  int32_t numUnread;
+  folder->GetNumUnread(false, &numUnread);
+  return numUnread > 0;
+}
+
+nsresult nsMsgUnreadFoldersDataSource::NotifyPropertyChanged(nsIRDFResource *resource,
+                    nsIRDFResource *property, nsIRDFNode *newNode,
+                    nsIRDFNode *oldNode)
+{
+  // check if it's the has unread property that's changed; if so, see if we need
+  // to add this folder to the view.
+  // Then, call base class.
+  if (kNC_HasUnreadMessages == property)
+  {
+    nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(resource));
+    if (folder)
+    {
+      int32_t numUnread;
+      folder->GetNumUnread(false, &numUnread);
+      if (numUnread > 0)
+      {
+        if (!m_folders.Contains(folder))
+          m_folders.AppendObject(folder);
+        NotifyObservers(kNC_UnreadFolders, kNC_Child, resource, nullptr, true, false);
+      }
+    }
+  }
+  return nsMsgFolderDataSource::NotifyPropertyChanged(resource, property,
+                                                newNode, oldNode);
+}
+
+bool nsMsgFavoriteFoldersDataSource::WantsThisFolder(nsIMsgFolder *folder)
+{
+  uint32_t folderFlags;
+  folder->GetFlags(&folderFlags);
+  return folderFlags & nsMsgFolderFlags::Favorite;
+}
+
+
+void nsMsgRecentFoldersDataSource::Cleanup()
+{
+  m_cutOffDate = 0;
+  nsMsgFlatFolderDataSource::Cleanup();
+}
+
+
+void nsMsgRecentFoldersDataSource::EnsureFolders()
+{
+  if (m_builtFolders)
+    return;
+
+  m_builtFolders = true; // in case something goes wrong
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCOMPtr<nsIArray> allFolders;
+  rv = accountManager->GetAllFolders(getter_AddRefs(allFolders));
+  if (NS_FAILED(rv) || !allFolders)
+    return;
+
+  uint32_t count;
+  rv = allFolders->GetLength(&count);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  for (uint32_t i = 0; i < count; i++)
+  {
+    nsCOMPtr<nsIMsgFolder> curFolder = do_QueryElementAt(allFolders, i);
+    nsCString dateStr;
+    curFolder->GetStringProperty(MRU_TIME_PROPERTY, dateStr);
+    uint32_t curFolderDate = (uint32_t) dateStr.ToInteger(&rv);
+    if (NS_FAILED(rv))
+      curFolderDate = 0;
+
+    if (curFolderDate > m_cutOffDate)
+    {
+      // if m_folders is "full", replace oldest folder with this folder,
+      // and adjust m_cutOffDate so that it's the mrutime
+      // of the "new" oldest folder.
+      uint32_t curFaveFoldersCount = m_folders.Count();
+      if (curFaveFoldersCount > m_maxNumFolders)
+      {
+        uint32_t indexOfOldestFolder = 0;
+        uint32_t oldestFaveDate = 0;
+        uint32_t newOldestFaveDate = 0;
+        for (uint32_t index = 0; index < curFaveFoldersCount; )
+        {
+          nsCString curFaveFolderDateStr;
+          m_folders[index]->GetStringProperty(MRU_TIME_PROPERTY, curFaveFolderDateStr);
+          uint32_t curFaveFolderDate = (uint32_t) curFaveFolderDateStr.ToInteger(&rv);
+          if (!oldestFaveDate || curFaveFolderDate < oldestFaveDate)
+          {
+            indexOfOldestFolder = index;
+            newOldestFaveDate = oldestFaveDate;
+            oldestFaveDate = curFaveFolderDate;
+          }
+          if (!newOldestFaveDate || (index != indexOfOldestFolder
+              && curFaveFolderDate < newOldestFaveDate)) {
+            newOldestFaveDate = curFaveFolderDate;
+          }
+          index++;
+        }
+        if (curFolderDate > oldestFaveDate && !m_folders.Contains(curFolder))
+          m_folders.ReplaceObjectAt(curFolder, indexOfOldestFolder);
+
+        NS_ASSERTION(newOldestFaveDate >= m_cutOffDate, "cutoff date should be getting bigger");
+        m_cutOffDate = newOldestFaveDate;
+      }
+      else if (!m_folders.Contains(curFolder))
+        m_folders.AppendObject(curFolder);
+    }
+#ifdef DEBUG_David_Bienvenu
+    else
+    {
+      for (uint32_t index = 0; index < m_folders.Count(); index++)
+      {
+        nsCString curFaveFolderDateStr;
+        m_folders[index]->GetStringProperty(MRU_TIME_PROPERTY, curFaveFolderDateStr);
+        uint32_t curFaveFolderDate = (uint32_t) curFaveFolderDateStr.ToInteger(&rv);
+        NS_ASSERTION(curFaveFolderDate > curFolderDate, "folder newer then faves but not added");
+      }
+    }
+#endif
+  }
+}
+
+NS_IMETHODIMP nsMsgRecentFoldersDataSource::OnItemAdded(nsIMsgFolder *parentItem, nsISupports *item)
+{
+  // if we've already built the recent folder array, we should add this item to the array
+  // since just added items are by definition new.
+  // I think this means newly discovered imap folders (ones w/o msf files) will
+  // get added, but maybe that's OK.
+  if (m_builtFolders)
+  {
+    nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(item));
+    if (folder && !m_folders.Contains(folder))
+    {
+      m_folders.AppendObject(folder);
+      nsCOMPtr<nsIRDFResource> resource = do_QueryInterface(item);
+      NotifyObservers(kNC_RecentFolders, kNC_Child, resource, nullptr, true, false);
+    }
+  }
+  return nsMsgFlatFolderDataSource::OnItemAdded(parentItem, item);
+}
+
+nsresult nsMsgRecentFoldersDataSource::NotifyPropertyChanged(nsIRDFResource *resource,
+                    nsIRDFResource *property, nsIRDFNode *newNode,
+                    nsIRDFNode *oldNode)
+{
+  // check if it's the has new property that's changed; if so, see if we need
+  // to add this folder to the view.
+  // Then, call base class.
+  if (kNC_NewMessages == property)
+  {
+    nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(resource));
+    if (folder)
+    {
+      bool hasNewMessages;
+      folder->GetHasNewMessages(&hasNewMessages);
+      if (hasNewMessages)
+      {
+        if (!m_folders.Contains(folder))
+        {
+          m_folders.AppendObject(folder);
+          NotifyObservers(kNC_RecentFolders, kNC_Child, resource, nullptr, true, false);
+        }
+      }
+    }
+  }
+  return nsMsgFolderDataSource::NotifyPropertyChanged(resource, property,
+                                                newNode, oldNode);
+}
diff --git a/mailnews/base/src/nsMsgFolderDataSource.h b/mailnews/base/src/nsMsgFolderDataSource.h
new file mode 100644
index 000000000..c683274ac
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderDataSource.h
@@ -0,0 +1,356 @@
+/* -*- 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 "mozilla/Attributes.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFService.h"
+
+#include "nsIFolderListener.h"
+#include "nsMsgRDFDataSource.h"
+
+#include "nsITransactionManager.h"
+#include "nsCOMArray.h"
+#include "nsIMutableArray.h"
+// Disable deprecation warnings generated by nsISupportsArray and associated
+// classes.
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(_MSC_VER)
+#pragma warning (disable : 4996)
+#endif
+#include "nsISupportsArray.h"
+/**
+ * The mail data source.
+ */
+class nsMsgFolderDataSource : public nsMsgRDFDataSource,
+                              public nsIFolderListener
+{
+public:
+  
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIFOLDERLISTENER
+
+  nsMsgFolderDataSource(void);
+  virtual nsresult Init() override;
+  virtual void Cleanup() override;
+
+  // nsIRDFDataSource methods
+  NS_IMETHOD GetURI(char* *uri) override;
+
+  NS_IMETHOD GetSource(nsIRDFResource* property,
+                       nsIRDFNode* target,
+                       bool tv,
+                       nsIRDFResource** source /* out */) override;
+
+  NS_IMETHOD GetTarget(nsIRDFResource* source,
+                       nsIRDFResource* property,
+                       bool tv,
+                       nsIRDFNode** target) override;
+
+  NS_IMETHOD GetSources(nsIRDFResource* property,
+                        nsIRDFNode* target,
+                        bool tv,
+                        nsISimpleEnumerator** sources) override;
+
+  NS_IMETHOD GetTargets(nsIRDFResource* source,
+                        nsIRDFResource* property,    
+                        bool tv,
+                        nsISimpleEnumerator** targets) override;
+
+  NS_IMETHOD Assert(nsIRDFResource* source,
+                    nsIRDFResource* property, 
+                    nsIRDFNode* target,
+                    bool tv) override;
+
+  NS_IMETHOD Unassert(nsIRDFResource* source,
+                      nsIRDFResource* property,
+                      nsIRDFNode* target) override;
+
+  NS_IMETHOD HasAssertion(nsIRDFResource* source,
+                          nsIRDFResource* property,
+                          nsIRDFNode* target,
+                          bool tv,
+                          bool* hasAssertion) override;
+
+  NS_IMETHOD HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc,
+                       bool *result) override;
+
+  NS_IMETHOD ArcLabelsIn(nsIRDFNode* node,
+                         nsISimpleEnumerator** labels) override;
+
+  NS_IMETHOD ArcLabelsOut(nsIRDFResource* source,
+                          nsISimpleEnumerator** labels) override; 
+
+  NS_IMETHOD GetAllResources(nsISimpleEnumerator** aResult) override;
+
+  NS_IMETHOD GetAllCmds(nsIRDFResource* source,
+                            nsISimpleEnumerator/*<nsIRDFResource>*/** commands
+                        ) override;
+
+  NS_IMETHOD IsCommandEnabled(nsISupports/*nsISupportsArray<nsIRDFResource>*/* aSources,
+                              nsIRDFResource*   aCommand,
+                              nsISupports/*nsISupportsArray<nsIRDFResource>*/* aArguments,
+                              bool* aResult) override;
+
+  NS_IMETHOD DoCommand(nsISupports/*nsISupportsArray<nsIRDFResource>*/* aSources,
+                       nsIRDFResource*   aCommand,
+                       nsISupports/*nsISupportsArray<nsIRDFResource>*/* aArguments) override;
+protected:
+  virtual ~nsMsgFolderDataSource();
+
+  nsresult GetSenderName(nsAutoString& sender, nsAutoString *senderUserName);
+
+  nsresult createFolderNode(nsIMsgFolder *folder, nsIRDFResource* property,
+                            nsIRDFNode **target);
+  nsresult createFolderNameNode(nsIMsgFolder *folder, nsIRDFNode **target, bool sort);
+  nsresult createFolderOpenNode(nsIMsgFolder *folder,nsIRDFNode **target);
+  nsresult createFolderTreeNameNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createFolderTreeSimpleNameNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createFolderSpecialNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createFolderServerTypeNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createServerIsDeferredNode(nsIMsgFolder* folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderCanCreateFoldersOnServerNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderCanFileMessagesOnServerNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderIsServerNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderIsSecureNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderCanSubscribeNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderSupportsOfflineNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderCanFileMessagesNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderCanCreateSubfoldersNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderCanRenameNode(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderCanCompactNode(nsIMsgFolder *folder,
+                                     nsIRDFNode **target);
+  nsresult createTotalMessagesNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createUnreadMessagesNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createFolderSizeNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createCharsetNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createBiffStateNodeFromFolder(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createBiffStateNodeFromFlag(uint32_t flag, nsIRDFNode **target);
+  nsresult createHasUnreadMessagesNode(nsIMsgFolder *folder, bool aIncludeSubfolders, nsIRDFNode **target);
+  nsresult createNewMessagesNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createFolderNoSelectNode(nsIMsgFolder *folder,
+                                    nsIRDFNode **target);
+  nsresult createFolderVirtualNode(nsIMsgFolder *folder,
+                                    nsIRDFNode **target);
+  nsresult createInVFEditSearchScopeNode(nsIMsgFolder* folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderImapSharedNode(nsIMsgFolder *folder,
+                                    nsIRDFNode **target);
+  nsresult createFolderSynchronizeNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createFolderSyncDisabledNode(nsIMsgFolder *folder, nsIRDFNode **target);
+  nsresult createCanSearchMessages(nsIMsgFolder *folder,
+                                      nsIRDFNode **target);
+  nsresult createFolderChildNode(nsIMsgFolder *folder, nsIRDFNode **target);
+
+  nsresult getFolderArcLabelsOut(nsCOMArray<nsIRDFResource> &aArcs);
+  
+  nsresult DoDeleteFromFolder(nsIMsgFolder *folder,
+                nsISupportsArray *arguments, nsIMsgWindow *msgWindow, bool reallyDelete);
+
+  nsresult DoCopyToFolder(nsIMsgFolder *dstFolder, nsISupportsArray *arguments,
+              nsIMsgWindow *msgWindow, bool isMove);
+
+  nsresult DoFolderCopyToFolder(nsIMsgFolder *dstFolder, nsISupportsArray *arguments,
+              nsIMsgWindow *msgWindow, bool isMoveFolder);
+
+  nsresult DoNewFolder(nsIMsgFolder *folder, nsISupportsArray *arguments, 
+                        nsIMsgWindow *window);
+
+  nsresult DoFolderAssert(nsIMsgFolder *folder, nsIRDFResource *property, nsIRDFNode *target);
+  nsresult DoFolderUnassert(nsIMsgFolder *folder, nsIRDFResource *property, nsIRDFNode *target);
+
+  nsresult DoFolderHasAssertion(nsIMsgFolder *folder, nsIRDFResource *property, nsIRDFNode *target,
+                                bool tv, bool *hasAssertion);
+
+  nsresult GetBiffStateString(uint32_t biffState, nsAutoCString & biffStateStr);
+
+  nsresult CreateUnreadMessagesNameString(int32_t unreadMessages, nsAutoString &nameString);
+  nsresult CreateArcsOutEnumerator();
+
+  virtual nsresult OnItemAddedOrRemoved(nsIMsgFolder *parentItem, nsISupports *item, bool added);
+
+  nsresult OnUnreadMessagePropertyChanged(nsIRDFResource *folderResource, int32_t oldValue, int32_t newValue);
+  nsresult OnTotalMessagePropertyChanged(nsIRDFResource *folderResource, int32_t oldValue, int32_t newValue);
+  nsresult OnFolderSizePropertyChanged(nsIRDFResource *folderResource, int64_t oldValue, int64_t newValue);
+  nsresult OnFolderSortOrderPropertyChanged(nsIRDFResource *folderResource, int32_t oldValue, int32_t newValue);
+  nsresult NotifyFolderTreeNameChanged(nsIMsgFolder *folder, nsIRDFResource *folderResource, int32_t aUnreadMessages);
+  nsresult NotifyFolderTreeSimpleNameChanged(nsIMsgFolder *folder, nsIRDFResource *folderResource);
+  nsresult NotifyFolderNameChanged(nsIMsgFolder *folder, nsIRDFResource *folderResource);
+  nsresult NotifyAncestors(nsIMsgFolder *aFolder, nsIRDFResource *aPropertyResource, nsIRDFNode *aNode);
+  nsresult GetNumMessagesNode(int32_t numMessages, nsIRDFNode **node);
+  nsresult GetFolderSizeNode(int64_t folderSize, nsIRDFNode **node);
+  nsresult CreateLiterals(nsIRDFService *rdf);
+
+  virtual nsresult GetFolderDisplayName(nsIMsgFolder *folder, nsString& folderName);
+
+  static nsIRDFResource* kNC_Child;
+  static nsIRDFResource* kNC_Folder;
+  static nsIRDFResource* kNC_Name;
+  static nsIRDFResource* kNC_Open;
+  static nsIRDFResource* kNC_FolderTreeName;
+  static nsIRDFResource* kNC_FolderTreeSimpleName;
+  static nsIRDFResource* kNC_NameSort;
+  static nsIRDFResource* kNC_FolderTreeNameSort;
+  static nsIRDFResource* kNC_Columns;
+  static nsIRDFResource* kNC_MSGFolderRoot;
+  static nsIRDFResource* kNC_SpecialFolder;
+  static nsIRDFResource* kNC_ServerType;
+  static nsIRDFResource* kNC_IsDeferred;
+  static nsIRDFResource* kNC_CanCreateFoldersOnServer;
+  static nsIRDFResource* kNC_CanFileMessagesOnServer;
+  static nsIRDFResource* kNC_IsServer;
+  static nsIRDFResource* kNC_IsSecure;
+  static nsIRDFResource* kNC_CanSubscribe;
+  static nsIRDFResource* kNC_SupportsOffline;
+  static nsIRDFResource* kNC_CanFileMessages;
+  static nsIRDFResource* kNC_CanCreateSubfolders;
+  static nsIRDFResource* kNC_CanRename;
+  static nsIRDFResource* kNC_CanCompact;
+  static nsIRDFResource* kNC_TotalMessages;
+  static nsIRDFResource* kNC_TotalUnreadMessages;
+  static nsIRDFResource* kNC_FolderSize;
+  static nsIRDFResource* kNC_Charset;
+  static nsIRDFResource* kNC_BiffState;
+  static nsIRDFResource* kNC_HasUnreadMessages;
+  static nsIRDFResource* kNC_NewMessages;
+  static nsIRDFResource* kNC_SubfoldersHaveUnreadMessages;
+  static nsIRDFResource* kNC_NoSelect;
+  static nsIRDFResource* kNC_ImapShared;
+  static nsIRDFResource* kNC_Synchronize;
+  static nsIRDFResource* kNC_SyncDisabled;
+  static nsIRDFResource* kNC_CanSearchMessages;
+  static nsIRDFResource* kNC_VirtualFolder;
+  static nsIRDFResource* kNC_InVFEditSearchScope;
+  static nsIRDFResource* kNC_UnreadFolders; // maybe should be in nsMsgFlatFolderDataSource?
+  static nsIRDFResource* kNC_FavoriteFolders; // maybe should be in nsMsgFlatFolderDataSource?
+  static nsIRDFResource* kNC_RecentFolders; // maybe should be in nsMsgFlatFolderDataSource?
+  // commands
+  static nsIRDFResource* kNC_Delete;
+  static nsIRDFResource* kNC_ReallyDelete;
+  static nsIRDFResource* kNC_NewFolder;
+  static nsIRDFResource* kNC_GetNewMessages;
+  static nsIRDFResource* kNC_Copy;
+  static nsIRDFResource* kNC_Move;
+  static nsIRDFResource* kNC_CopyFolder;
+  static nsIRDFResource* kNC_MoveFolder;
+  static nsIRDFResource* kNC_MarkAllMessagesRead;
+  static nsIRDFResource* kNC_Compact;
+  static nsIRDFResource* kNC_CompactAll;
+  static nsIRDFResource* kNC_Rename;
+  static nsIRDFResource* kNC_EmptyTrash;
+  static nsIRDFResource* kNC_DownloadFlagged;
+  //Cached literals
+  nsCOMPtr<nsIRDFNode> kTrueLiteral;
+  nsCOMPtr<nsIRDFNode> kFalseLiteral;
+
+  // property atoms
+  static nsIAtom* kTotalMessagesAtom;
+  static nsIAtom* kTotalUnreadMessagesAtom;
+  static nsIAtom* kFolderSizeAtom;
+  static nsIAtom* kBiffStateAtom;
+  static nsIAtom* kSortOrderAtom;
+  static nsIAtom* kNewMessagesAtom;
+  static nsIAtom* kNameAtom;
+  static nsIAtom* kSynchronizeAtom;
+  static nsIAtom* kOpenAtom;
+  static nsIAtom* kIsDeferredAtom;
+  static nsIAtom* kIsSecureAtom;
+  static nsrefcnt gFolderResourceRefCnt;
+  static nsIAtom* kCanFileMessagesAtom;
+  static nsIAtom* kInVFEditSearchScopeAtom;
+  
+  nsCOMArray<nsIRDFResource> kFolderArcsOutArray;
+
+};
+
+
+class nsMsgFlatFolderDataSource : public nsMsgFolderDataSource
+{
+public:
+  // constructor could take a filter to filter out folders.
+  nsMsgFlatFolderDataSource();
+  virtual ~nsMsgFlatFolderDataSource();
+  virtual nsresult Init() override;
+  virtual void Cleanup() override;
+
+  NS_IMETHOD GetURI(char* *uri) override;
+  NS_IMETHOD GetTargets(nsIRDFResource* source,
+                        nsIRDFResource* property,    
+                        bool tv,
+                        nsISimpleEnumerator** targets) override;
+  NS_IMETHOD GetTarget(nsIRDFResource* source,
+                       nsIRDFResource* property,
+                       bool tv,
+                       nsIRDFNode** target) override;
+
+  NS_IMETHOD HasAssertion(nsIRDFResource* source,
+                            nsIRDFResource* property,
+                            nsIRDFNode* target,
+                            bool tv,
+                            bool* hasAssertion) override;
+protected:
+  virtual nsresult GetFolderDisplayName(nsIMsgFolder *folder,
+                                        nsString& folderName) override;
+  virtual void EnsureFolders();
+  virtual bool WantsThisFolder(nsIMsgFolder *folder);
+          bool ResourceIsOurRoot(nsIRDFResource *resource);
+  virtual nsresult OnItemAddedOrRemoved(nsIMsgFolder *parentItem, nsISupports *item,
+                                        bool added) override;
+
+  nsCOMArray <nsIMsgFolder> m_folders;
+  nsCOMPtr<nsIRDFResource>  m_rootResource; // the resource for our root
+  nsCString m_dsName;
+  bool m_builtFolders;
+};
+
+
+class nsMsgUnreadFoldersDataSource : public nsMsgFlatFolderDataSource
+{
+public:
+  nsMsgUnreadFoldersDataSource() {m_dsName = "mailnewsunreadfolders";}
+  virtual ~nsMsgUnreadFoldersDataSource() {}
+  virtual nsresult NotifyPropertyChanged(nsIRDFResource *resource, 
+                    nsIRDFResource *propertyResource, nsIRDFNode *newNode, 
+                    nsIRDFNode *oldNode = nullptr) override;
+protected:
+  virtual bool WantsThisFolder(nsIMsgFolder *folder) override;
+};
+
+class nsMsgFavoriteFoldersDataSource : public nsMsgFlatFolderDataSource
+{
+public:
+  nsMsgFavoriteFoldersDataSource() {m_dsName = "mailnewsfavefolders";}
+  virtual ~nsMsgFavoriteFoldersDataSource() {}
+protected:
+  virtual bool WantsThisFolder(nsIMsgFolder *folder) override;
+};
+
+class nsMsgRecentFoldersDataSource : public nsMsgFlatFolderDataSource
+{
+public:
+  nsMsgRecentFoldersDataSource() {m_dsName = "mailnewsrecentfolders";
+                                  m_cutOffDate = 0; m_maxNumFolders = 15;}
+  virtual ~nsMsgRecentFoldersDataSource() {}
+  virtual nsresult NotifyPropertyChanged(nsIRDFResource *resource, 
+                    nsIRDFResource *property, nsIRDFNode *newNode, 
+                    nsIRDFNode *oldNode) override;
+  NS_IMETHOD OnItemAdded(nsIMsgFolder *parentItem, nsISupports *item) override;
+  virtual void Cleanup() override;
+protected:
+  virtual void EnsureFolders() override;
+  uint32_t m_cutOffDate;
+  uint32_t m_maxNumFolders;
+};
diff --git a/mailnews/base/src/nsMsgFolderNotificationService.cpp b/mailnews/base/src/nsMsgFolderNotificationService.cpp
new file mode 100644
index 000000000..ebf88275a
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderNotificationService.cpp
@@ -0,0 +1,172 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"
+#include "nsMsgFolderNotificationService.h"
+#include "nsIArray.h"
+#include "nsArrayUtils.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsIImapIncomingServer.h"
+
+//
+//  nsMsgFolderNotificationService
+//
+NS_IMPL_ISUPPORTS(nsMsgFolderNotificationService, nsIMsgFolderNotificationService)
+
+nsMsgFolderNotificationService::nsMsgFolderNotificationService()
+{
+}
+
+nsMsgFolderNotificationService::~nsMsgFolderNotificationService()
+{
+  /* destructor code */
+}
+
+NS_IMETHODIMP nsMsgFolderNotificationService::GetHasListeners(bool *aHasListeners)
+{
+  NS_ENSURE_ARG_POINTER(aHasListeners);
+  *aHasListeners = mListeners.Length() > 0;
+  return NS_OK;
+}
+
+
+/* void addListener (in nsIMsgFolderListener aListener, in msgFolderListenerFlag flags); */
+NS_IMETHODIMP nsMsgFolderNotificationService::AddListener(nsIMsgFolderListener *aListener,
+                                                          msgFolderListenerFlag aFlags)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+  MsgFolderListener listener(aListener, aFlags);
+  mListeners.AppendElementUnlessExists(listener);
+  return NS_OK;
+}
+
+/* void removeListener (in nsIMsgFolderListener aListener); */
+NS_IMETHODIMP nsMsgFolderNotificationService::RemoveListener(nsIMsgFolderListener *aListener)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+
+  mListeners.RemoveElement(aListener);
+  return NS_OK;
+}
+
+#define NOTIFY_MSGFOLDER_LISTENERS(propertyflag_, propertyfunc_, params_) \
+  PR_BEGIN_MACRO                                                          \
+  nsTObserverArray<MsgFolderListener>::ForwardIterator iter(mListeners);  \
+  while (iter.HasMore()) {                                                \
+    const MsgFolderListener &listener = iter.GetNext();                   \
+    if (listener.mFlags & propertyflag_)                                  \
+      listener.mListener->propertyfunc_ params_;                          \
+  }                                                                       \
+  PR_END_MACRO
+
+/* void notifyMsgAdded (in nsIMsgDBHdr aMsg); */
+NS_IMETHODIMP nsMsgFolderNotificationService::NotifyMsgAdded(nsIMsgDBHdr *aMsg)
+{
+  NOTIFY_MSGFOLDER_LISTENERS(msgAdded, MsgAdded, (aMsg));
+  return NS_OK;
+}
+
+/* void notifyMsgsClassified (in  */
+NS_IMETHODIMP nsMsgFolderNotificationService::NotifyMsgsClassified(
+  nsIArray *aMsgs, bool aJunkProcessed, bool aTraitProcessed)
+{
+  NOTIFY_MSGFOLDER_LISTENERS(msgsClassified, MsgsClassified,
+                             (aMsgs, aJunkProcessed, aTraitProcessed));
+  return NS_OK;
+}
+
+/* void notifyMsgsDeleted (in nsIArray aMsgs); */
+NS_IMETHODIMP nsMsgFolderNotificationService::NotifyMsgsDeleted(nsIArray *aMsgs)
+{
+  NOTIFY_MSGFOLDER_LISTENERS(msgsDeleted, MsgsDeleted, (aMsgs));
+  return NS_OK;
+}
+
+/* void notifyMsgsMoveCopyCompleted (in boolean aMove, in nsIArray aSrcMsgs,
+                                     in nsIMsgFolder aDestFolder); */
+NS_IMETHODIMP nsMsgFolderNotificationService::NotifyMsgsMoveCopyCompleted(
+  bool aMove, nsIArray *aSrcMsgs, nsIMsgFolder *aDestFolder,
+  nsIArray *aDestMsgs)
+{
+  uint32_t count = mListeners.Length();
+  
+  // IMAP delete model means that a "move" isn't really a move, it is a copy,
+  // followed by storing the IMAP deleted flag on the message.
+  bool isReallyMove = aMove;
+  if (count > 0 && aMove)
+  {
+    nsresult rv;
+    // Assume that all the source messages are from the same server.
+    nsCOMPtr<nsIMsgDBHdr> message(do_QueryElementAt(aSrcMsgs, 0, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgFolder> msgFolder;
+    rv = message->GetFolder(getter_AddRefs(msgFolder));
+    NS_ENSURE_SUCCESS(rv, rv);
+    
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(msgFolder));
+    if (imapFolder)
+    {
+      nsCOMPtr<nsIImapIncomingServer> imapServer;
+      imapFolder->GetImapIncomingServer(getter_AddRefs(imapServer));
+      if (imapServer)
+      {
+        nsMsgImapDeleteModel deleteModel;
+        imapServer->GetDeleteModel(&deleteModel);
+        if (deleteModel == nsMsgImapDeleteModels::IMAPDelete)
+          isReallyMove = false;
+      }
+    }
+  }
+
+  NOTIFY_MSGFOLDER_LISTENERS(msgsMoveCopyCompleted, MsgsMoveCopyCompleted,
+                             (isReallyMove, aSrcMsgs, aDestFolder, aDestMsgs));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgFolderNotificationService::NotifyMsgKeyChanged(nsMsgKey aOldKey,
+                                                    nsIMsgDBHdr *aNewHdr)
+{
+  NOTIFY_MSGFOLDER_LISTENERS(msgKeyChanged, MsgKeyChanged, (aOldKey, aNewHdr));
+  return NS_OK;
+}
+
+/* void notifyFolderAdded(in nsIMsgFolder aFolder); */
+NS_IMETHODIMP nsMsgFolderNotificationService::NotifyFolderAdded(nsIMsgFolder *aFolder)
+{
+  NOTIFY_MSGFOLDER_LISTENERS(folderAdded, FolderAdded, (aFolder));
+  return NS_OK;
+}
+
+/* void notifyFolderDeleted(in nsIMsgFolder aFolder); */
+NS_IMETHODIMP nsMsgFolderNotificationService::NotifyFolderDeleted(nsIMsgFolder *aFolder)
+{
+  NOTIFY_MSGFOLDER_LISTENERS(folderDeleted, FolderDeleted, (aFolder));
+  return NS_OK;
+}
+
+/* void notifyFolderMoveCopyCompleted(in boolean aMove, in nsIMsgFolder aSrcFolder, in nsIMsgFolder aDestFolder); */
+NS_IMETHODIMP nsMsgFolderNotificationService::NotifyFolderMoveCopyCompleted(bool aMove, nsIMsgFolder *aSrcFolder, nsIMsgFolder *aDestFolder)
+{
+  NOTIFY_MSGFOLDER_LISTENERS(folderMoveCopyCompleted, FolderMoveCopyCompleted,
+                             (aMove, aSrcFolder, aDestFolder));
+  return NS_OK;
+}
+
+/* void notifyFolderRenamed (in nsIMsgFolder aOrigFolder, in nsIMsgFolder aNewFolder); */
+NS_IMETHODIMP nsMsgFolderNotificationService::NotifyFolderRenamed(nsIMsgFolder *aOrigFolder, nsIMsgFolder *aNewFolder)
+{
+  NOTIFY_MSGFOLDER_LISTENERS(folderRenamed, FolderRenamed, (aOrigFolder, aNewFolder));
+  return NS_OK;
+}
+
+/* void notifyItemEvent (in nsISupports aItem, in string aEvent, in nsISupports aData); */
+NS_IMETHODIMP nsMsgFolderNotificationService::NotifyItemEvent(nsISupports *aItem, const nsACString &aEvent, nsISupports *aData)
+{
+  NOTIFY_MSGFOLDER_LISTENERS(itemEvent, ItemEvent, (aItem, aEvent, aData));
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMsgFolderNotificationService.h b/mailnews/base/src/nsMsgFolderNotificationService.h
new file mode 100644
index 000000000..61fdd842b
--- /dev/null
+++ b/mailnews/base/src/nsMsgFolderNotificationService.h
@@ -0,0 +1,46 @@
+/* -*- 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 nsMsgFolderNotificationService_h__
+#define nsMsgFolderNotificationService_h__
+
+#include "nsIMsgFolderNotificationService.h"
+#include "nsIMsgFolderListener.h"
+#include "nsTObserverArray.h"
+#include "nsCOMPtr.h"
+
+class nsMsgFolderNotificationService final : public nsIMsgFolderNotificationService
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGFOLDERNOTIFICATIONSERVICE
+
+  nsMsgFolderNotificationService();
+
+private:
+  ~nsMsgFolderNotificationService();
+  struct MsgFolderListener
+  {
+    nsCOMPtr<nsIMsgFolderListener> mListener;
+    msgFolderListenerFlag mFlags;
+
+    MsgFolderListener(nsIMsgFolderListener *aListener, msgFolderListenerFlag aFlags)
+      : mListener(aListener), mFlags(aFlags) {}
+    MsgFolderListener(const MsgFolderListener &aListener)
+      : mListener(aListener.mListener), mFlags(aListener.mFlags) {}
+    ~MsgFolderListener() {}
+
+    int operator==(nsIMsgFolderListener* aListener) const {
+      return mListener == aListener;
+    }
+    int operator==(const MsgFolderListener &aListener) const {
+      return mListener == aListener.mListener;
+    }
+  };
+
+  nsTObserverArray<MsgFolderListener> mListeners;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgGroupThread.cpp b/mailnews/base/src/nsMsgGroupThread.cpp
new file mode 100644
index 000000000..c68a6329d
--- /dev/null
+++ b/mailnews/base/src/nsMsgGroupThread.cpp
@@ -0,0 +1,856 @@
+/* -*- 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 "nsMsgGroupThread.h"
+#include "nsMsgDBView.h"
+#include "nsMsgMessageFlags.h"
+#include "nsMsgUtils.h"
+
+NS_IMPL_ISUPPORTS(nsMsgGroupThread, nsIMsgThread)
+
+nsMsgGroupThread::nsMsgGroupThread()
+{
+  Init();
+}
+nsMsgGroupThread::nsMsgGroupThread(nsIMsgDatabase *db)
+{
+  m_db = db;
+  Init();
+}
+
+void nsMsgGroupThread::Init()
+{
+  m_threadKey = nsMsgKey_None; 
+  m_threadRootKey = nsMsgKey_None;
+  m_numUnreadChildren = 0;	
+  m_flags = 0;
+  m_newestMsgDate = 0;
+  m_dummy = false;
+}
+
+nsMsgGroupThread::~nsMsgGroupThread()
+{
+}
+
+NS_IMETHODIMP nsMsgGroupThread::SetThreadKey(nsMsgKey threadKey)
+{
+  m_threadKey = threadKey;
+  // by definition, the initial thread key is also the thread root key.
+  m_threadRootKey = threadKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::GetThreadKey(nsMsgKey *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = m_threadKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::GetFlags(uint32_t *aFlags)
+{
+  NS_ENSURE_ARG_POINTER(aFlags);
+  *aFlags = m_flags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::SetFlags(uint32_t aFlags)
+{
+  m_flags = aFlags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::SetSubject(const nsACString& aSubject)
+{
+  NS_ASSERTION(false, "shouldn't call this");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::GetSubject(nsACString& result)
+{
+  NS_ASSERTION(false, "shouldn't call this");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::GetNumChildren(uint32_t *aNumChildren)
+{
+  NS_ENSURE_ARG_POINTER(aNumChildren);
+  *aNumChildren = m_keys.Length(); // - ((m_dummy) ? 1 : 0);
+  return NS_OK;
+}
+
+uint32_t nsMsgGroupThread::NumRealChildren()
+{
+  return m_keys.Length() - ((m_dummy) ? 1 : 0);
+}
+
+NS_IMETHODIMP nsMsgGroupThread::GetNumUnreadChildren (uint32_t *aNumUnreadChildren)
+{
+  NS_ENSURE_ARG_POINTER(aNumUnreadChildren);
+  *aNumUnreadChildren = m_numUnreadChildren;
+  return NS_OK;
+}
+
+void nsMsgGroupThread::InsertMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr)
+{
+  nsMsgKey msgKey;
+  hdr->GetMessageKey(&msgKey);
+  m_keys.InsertElementAt(index, msgKey);
+}
+
+void nsMsgGroupThread::SetMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr)
+{
+  nsMsgKey msgKey;
+  hdr->GetMessageKey(&msgKey);
+  m_keys[index] = msgKey;
+}
+
+nsMsgViewIndex nsMsgGroupThread::FindMsgHdr(nsIMsgDBHdr *hdr)
+{
+  nsMsgKey msgKey;
+  hdr->GetMessageKey(&msgKey);
+  return (nsMsgViewIndex)m_keys.IndexOf(msgKey);
+}
+
+NS_IMETHODIMP nsMsgGroupThread::AddChild(nsIMsgDBHdr *child, nsIMsgDBHdr *inReplyTo, bool threadInThread, 
+                                    nsIDBChangeAnnouncer *announcer)
+{
+  NS_ASSERTION(false, "shouldn't call this");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsMsgViewIndex nsMsgGroupThread::AddMsgHdrInDateOrder(nsIMsgDBHdr *child, nsMsgDBView *view)
+{
+  nsMsgKey newHdrKey;
+  child->GetMessageKey(&newHdrKey);
+  uint32_t insertIndex = 0;
+  // since we're sorted by date, we could do a binary search for the 
+  // insert point. Or, we could start at the end...
+  if (m_keys.Length() > 0)
+  {
+    nsMsgViewSortTypeValue  sortType;
+    nsMsgViewSortOrderValue sortOrder;
+    (void) view->GetSortType(&sortType);
+    (void) view->GetSortOrder(&sortOrder);
+    // historical behavior is ascending date order unless our primary sort is
+    //  on date
+    nsMsgViewSortOrderValue threadSortOrder = 
+      (sortType == nsMsgViewSortType::byDate
+        && sortOrder == nsMsgViewSortOrder::descending) ? 
+          nsMsgViewSortOrder::descending : nsMsgViewSortOrder::ascending;
+    // new behavior is tricky and uses the secondary sort order if the secondary
+    //  sort is on the date
+    nsMsgViewSortTypeValue  secondarySortType;
+    nsMsgViewSortOrderValue secondarySortOrder;
+    (void) view->GetSecondarySortType(&secondarySortType);
+    (void) view->GetSecondarySortOrder(&secondarySortOrder);
+    if (secondarySortType == nsMsgViewSortType::byDate)
+      threadSortOrder = secondarySortOrder;
+    // sort by date within group.
+    insertIndex = GetInsertIndexFromView(view, child, threadSortOrder);
+  }
+  m_keys.InsertElementAt(insertIndex, newHdrKey);
+  if (!insertIndex)
+    m_threadRootKey = newHdrKey;
+  return insertIndex;
+}
+
+nsMsgViewIndex 
+nsMsgGroupThread::GetInsertIndexFromView(nsMsgDBView *view, 
+                                          nsIMsgDBHdr *child, 
+                                          nsMsgViewSortOrderValue threadSortOrder)
+{
+   return view->GetInsertIndexHelper(child, m_keys, nullptr, threadSortOrder, nsMsgViewSortType::byDate);
+}
+
+nsMsgViewIndex nsMsgGroupThread::AddChildFromGroupView(nsIMsgDBHdr *child, nsMsgDBView *view)
+{
+  uint32_t newHdrFlags = 0;
+  uint32_t msgDate;
+  nsMsgKey newHdrKey = 0;
+  
+  child->GetFlags(&newHdrFlags);
+  child->GetMessageKey(&newHdrKey);
+  child->GetDateInSeconds(&msgDate);
+  if (msgDate > m_newestMsgDate)
+    SetNewestMsgDate(msgDate);
+
+  child->AndFlags(~(nsMsgMessageFlags::Watched), &newHdrFlags);
+  uint32_t numChildren;
+  
+  // get the num children before we add the new header.
+  GetNumChildren(&numChildren);
+  
+  // if this is an empty thread, set the root key to this header's key
+  if (numChildren == 0)
+    m_threadRootKey = newHdrKey;
+  
+  if (! (newHdrFlags & nsMsgMessageFlags::Read))
+    ChangeUnreadChildCount(1);
+
+  return AddMsgHdrInDateOrder(child, view);
+}
+
+nsresult nsMsgGroupThread::ReparentNonReferenceChildrenOf(nsIMsgDBHdr *topLevelHdr, nsMsgKey newParentKey,
+                                                            nsIDBChangeAnnouncer *announcer)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::GetChildKeyAt(uint32_t aIndex, nsMsgKey *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  if (aIndex >= m_keys.Length())
+    return NS_ERROR_INVALID_ARG;
+  *aResult = m_keys[aIndex];
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::GetChildHdrAt(uint32_t aIndex, nsIMsgDBHdr **aResult)
+{
+  if (aIndex >= m_keys.Length())
+    return NS_MSG_MESSAGE_NOT_FOUND;
+  return m_db->GetMsgHdrForKey(m_keys[aIndex], aResult);
+}
+
+
+NS_IMETHODIMP nsMsgGroupThread::GetChild(nsMsgKey msgKey, nsIMsgDBHdr **aResult)
+{
+  return GetChildHdrAt(m_keys.IndexOf(msgKey), aResult);
+}
+
+NS_IMETHODIMP nsMsgGroupThread::RemoveChildAt(uint32_t aIndex)
+{
+  NS_ENSURE_TRUE(aIndex < m_keys.Length(), NS_MSG_MESSAGE_NOT_FOUND);
+
+  m_keys.RemoveElementAt(aIndex);
+  return NS_OK;
+}
+
+nsresult nsMsgGroupThread::RemoveChild(nsMsgKey msgKey)
+{
+  m_keys.RemoveElement(msgKey);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::RemoveChildHdr(nsIMsgDBHdr *child, nsIDBChangeAnnouncer *announcer)
+{
+  NS_ENSURE_ARG_POINTER(child);
+
+  uint32_t flags;
+  nsMsgKey key;
+
+  child->GetFlags(&flags);
+  child->GetMessageKey(&key);
+
+  // if this was the newest msg, clear the newest msg date so we'll recalc.
+  uint32_t date;
+  child->GetDateInSeconds(&date);
+  if (date == m_newestMsgDate)
+    SetNewestMsgDate(0);
+
+  if (!(flags & nsMsgMessageFlags::Read))
+    ChangeUnreadChildCount(-1);
+  nsMsgViewIndex threadIndex = FindMsgHdr(child);
+  bool wasFirstChild = threadIndex == 0;
+  nsresult rv = RemoveChildAt(threadIndex);
+  // if we're deleting the root of a dummy thread, need to update the threadKey
+  // and the dummy header at position 0
+  if (m_dummy && wasFirstChild && m_keys.Length() > 1)
+  {
+    nsIMsgDBHdr *newRootChild;
+    rv = GetChildHdrAt(1, &newRootChild);
+    NS_ENSURE_SUCCESS(rv, rv);
+    SetMsgHdrAt(0, newRootChild);
+  }
+
+  return rv;
+}
+
+nsresult nsMsgGroupThread::ReparentChildrenOf(nsMsgKey oldParent, nsMsgKey newParent, nsIDBChangeAnnouncer *announcer)
+{
+  nsresult rv = NS_OK;
+  
+  uint32_t numChildren;
+  uint32_t childIndex = 0;
+  
+  GetNumChildren(&numChildren);
+  
+  nsCOMPtr <nsIMsgDBHdr> curHdr;
+  if (numChildren > 0)
+  {
+    for (childIndex = 0; childIndex < numChildren; childIndex++)
+    {
+      rv = GetChildHdrAt(childIndex, getter_AddRefs(curHdr));
+      if (NS_SUCCEEDED(rv) && curHdr)
+      {
+        nsMsgKey threadParent;
+        
+        curHdr->GetThreadParent(&threadParent);
+        if (threadParent == oldParent)
+        {
+          nsMsgKey curKey;
+          
+          curHdr->SetThreadParent(newParent);
+          curHdr->GetMessageKey(&curKey);
+          if (announcer)
+            announcer->NotifyParentChangedAll(curKey, oldParent, newParent, nullptr);
+          // if the old parent was the root of the thread, then only the first child gets 
+          // promoted to root, and other children become children of the new root.
+          if (newParent == nsMsgKey_None)
+          {
+            m_threadRootKey = curKey;
+            newParent = curKey;
+          }
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::MarkChildRead(bool bRead)
+{
+  ChangeUnreadChildCount(bRead ? -1 : 1);
+  return NS_OK;
+}
+
+// this could be moved into utils, because I think it's the same as the db impl.
+class nsMsgGroupThreadEnumerator : public nsISimpleEnumerator {
+public:
+  NS_DECL_ISUPPORTS
+    
+  // nsISimpleEnumerator methods:
+  NS_DECL_NSISIMPLEENUMERATOR
+    
+  // nsMsgGroupThreadEnumerator methods:
+  typedef nsresult (*nsMsgGroupThreadEnumeratorFilter)(nsIMsgDBHdr* hdr, void* closure);
+  
+  nsMsgGroupThreadEnumerator(nsMsgGroupThread *thread, nsMsgKey startKey,
+  nsMsgGroupThreadEnumeratorFilter filter, void* closure);
+  int32_t MsgKeyFirstChildIndex(nsMsgKey inMsgKey);
+  
+protected:
+  virtual ~nsMsgGroupThreadEnumerator();
+  
+  nsresult                Prefetch();
+  
+  nsCOMPtr <nsIMsgDBHdr>  mResultHdr;
+  nsMsgGroupThread*       mThread;
+  nsMsgKey                mThreadParentKey;
+  nsMsgKey                mFirstMsgKey;
+  int32_t                 mChildIndex;
+  bool                    mDone;
+  bool                    mNeedToPrefetch;
+  nsMsgGroupThreadEnumeratorFilter     mFilter;
+  void*                   mClosure;
+  bool                    mFoundChildren;
+};
+
+nsMsgGroupThreadEnumerator::nsMsgGroupThreadEnumerator(nsMsgGroupThread *thread, nsMsgKey startKey,
+                                             nsMsgGroupThreadEnumeratorFilter filter, void* closure)
+                                             : mDone(false),
+                                             mFilter(filter), mClosure(closure), mFoundChildren(false)
+{
+  mThreadParentKey = startKey;
+  mChildIndex = 0;
+  mThread = thread;
+  mNeedToPrefetch = true;
+  mFirstMsgKey = nsMsgKey_None;
+  
+  nsresult rv = mThread->GetRootHdr(nullptr, getter_AddRefs(mResultHdr));
+  
+  if (NS_SUCCEEDED(rv) && mResultHdr)
+    mResultHdr->GetMessageKey(&mFirstMsgKey);
+  
+  uint32_t numChildren;
+  mThread->GetNumChildren(&numChildren);
+  
+  if (mThreadParentKey != nsMsgKey_None)
+  {
+    nsMsgKey msgKey = nsMsgKey_None;
+    uint32_t childIndex = 0;
+    
+    
+    for (childIndex = 0; childIndex < numChildren; childIndex++)
+    {
+      rv = mThread->GetChildHdrAt(childIndex, getter_AddRefs(mResultHdr));
+      if (NS_SUCCEEDED(rv) && mResultHdr)
+      {
+        mResultHdr->GetMessageKey(&msgKey);
+        
+        if (msgKey == startKey)
+        {
+          mChildIndex = MsgKeyFirstChildIndex(msgKey);
+          mDone = (mChildIndex < 0);
+          break;
+        }
+        
+        if (mDone)
+          break;
+        
+      }
+      else
+        NS_ASSERTION(false, "couldn't get child from thread");
+    }
+  }
+  
+#ifdef DEBUG_bienvenu1
+  nsCOMPtr <nsIMsgDBHdr> child;
+  for (uint32_t childIndex = 0; childIndex < numChildren; childIndex++)
+  {
+    rv = mThread->GetChildHdrAt(childIndex, getter_AddRefs(child));
+    if (NS_SUCCEEDED(rv) && child)
+    {
+      nsMsgKey threadParent;
+      nsMsgKey msgKey;
+      // we're only doing one level of threading, so check if caller is
+      // asking for children of the first message in the thread or not.
+      // if not, we will tell him there are no children.
+      child->GetMessageKey(&msgKey);
+      child->GetThreadParent(&threadParent);
+      
+      printf("index = %ld key = %ld parent = %lx\n", childIndex, msgKey, threadParent);
+    }
+  }
+#endif
+  NS_ADDREF(thread);
+}
+
+nsMsgGroupThreadEnumerator::~nsMsgGroupThreadEnumerator()
+{
+    NS_RELEASE(mThread);
+}
+
+NS_IMPL_ISUPPORTS(nsMsgGroupThreadEnumerator, nsISimpleEnumerator)
+
+
+int32_t nsMsgGroupThreadEnumerator::MsgKeyFirstChildIndex(nsMsgKey inMsgKey)
+{
+  //	if (msgKey != mThreadParentKey)
+  //		mDone = true;
+  // look through rest of thread looking for a child of this message.
+  // If the inMsgKey is the first message in the thread, then all children
+  // without parents are considered to be children of inMsgKey.
+  // Otherwise, only true children qualify.
+  uint32_t numChildren;
+  nsCOMPtr <nsIMsgDBHdr> curHdr;
+  int32_t firstChildIndex = -1;
+  
+  mThread->GetNumChildren(&numChildren);
+  
+  // if this is the first message in the thread, just check if there's more than
+  // one message in the thread.
+  //	if (inMsgKey == mThread->m_threadRootKey)
+  //		return (numChildren > 1) ? 1 : -1;
+  
+  for (uint32_t curChildIndex = 0; curChildIndex < numChildren; curChildIndex++)
+  {
+    nsresult rv = mThread->GetChildHdrAt(curChildIndex, getter_AddRefs(curHdr));
+    if (NS_SUCCEEDED(rv) && curHdr)
+    {
+      nsMsgKey parentKey;
+      
+      curHdr->GetThreadParent(&parentKey);
+      if (parentKey == inMsgKey)
+      {
+        firstChildIndex = curChildIndex;
+        break;
+      }
+    }
+  }
+#ifdef DEBUG_bienvenu1
+  printf("first child index of %ld = %ld\n", inMsgKey, firstChildIndex);
+#endif
+  return firstChildIndex;
+}
+
+NS_IMETHODIMP nsMsgGroupThreadEnumerator::GetNext(nsISupports **aItem)
+{
+  if (!aItem)
+    return NS_ERROR_NULL_POINTER;
+  nsresult rv = NS_OK;
+  
+  if (mNeedToPrefetch)
+    rv = Prefetch();
+  
+  if (NS_SUCCEEDED(rv) && mResultHdr) 
+  {
+    *aItem = mResultHdr;
+    NS_ADDREF(*aItem);
+    mNeedToPrefetch = true;
+  }
+  return rv;
+}
+
+nsresult nsMsgGroupThreadEnumerator::Prefetch()
+{
+  nsresult rv=NS_OK;          // XXX or should this default to an error?
+  mResultHdr = nullptr;
+  if (mThreadParentKey == nsMsgKey_None)
+  {
+    rv = mThread->GetRootHdr(&mChildIndex, getter_AddRefs(mResultHdr));
+    NS_ASSERTION(NS_SUCCEEDED(rv) && mResultHdr, "better be able to get root hdr");
+    mChildIndex = 0; // since root can be anywhere, set mChildIndex to 0.
+  }
+  else if (!mDone)
+  {
+    uint32_t numChildren;
+    mThread->GetNumChildren(&numChildren);
+    
+    while ((uint32_t)mChildIndex < numChildren)
+    {
+      rv  = mThread->GetChildHdrAt(mChildIndex++, getter_AddRefs(mResultHdr));
+      if (NS_SUCCEEDED(rv) && mResultHdr)
+      {
+        nsMsgKey parentKey;
+        nsMsgKey curKey;
+        
+        if (mFilter && NS_FAILED(mFilter(mResultHdr, mClosure))) {
+          mResultHdr = nullptr;
+          continue;
+        }
+        
+        mResultHdr->GetThreadParent(&parentKey);
+        mResultHdr->GetMessageKey(&curKey);
+        // if the parent is the same as the msg we're enumerating over,
+        // or the parentKey isn't set, and we're iterating over the top
+        // level message in the thread, then leave mResultHdr set to cur msg.
+        if (parentKey == mThreadParentKey || 
+          (parentKey == nsMsgKey_None 
+          && mThreadParentKey == mFirstMsgKey && curKey != mThreadParentKey))
+          break;
+        mResultHdr = nullptr;
+      }
+      else
+        NS_ASSERTION(false, "better be able to get child");
+    }
+    if (!mResultHdr && mThreadParentKey == mFirstMsgKey && !mFoundChildren && numChildren > 1)
+    {
+//      mThread->ReparentMsgsWithInvalidParent(numChildren, mThreadParentKey);
+    }
+  }
+  if (!mResultHdr) 
+  {
+    mDone = true;
+    return NS_ERROR_FAILURE;
+  }
+  if (NS_FAILED(rv)) 
+  {
+    mDone = true;
+    return rv;
+  }
+  else
+    mNeedToPrefetch = false;
+  mFoundChildren = true;
+
+#ifdef DEBUG_bienvenu1
+	nsMsgKey debugMsgKey;
+	mResultHdr->GetMessageKey(&debugMsgKey);
+	printf("next for %ld = %ld\n", mThreadParentKey, debugMsgKey);
+#endif
+
+    return rv;
+}
+
+NS_IMETHODIMP nsMsgGroupThreadEnumerator::HasMoreElements(bool *aResult)
+{
+  if (!aResult)
+    return NS_ERROR_NULL_POINTER;
+  if (mNeedToPrefetch)
+    Prefetch();
+  *aResult = !mDone;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::EnumerateMessages(nsMsgKey parentKey, nsISimpleEnumerator* *result)
+{
+    nsMsgGroupThreadEnumerator* e = new nsMsgGroupThreadEnumerator(this, parentKey, nullptr, nullptr);
+    if (e == nullptr)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(e);
+    *result = e;
+
+    return NS_OK;
+}
+#if 0
+nsresult nsMsgGroupThread::ReparentMsgsWithInvalidParent(uint32_t numChildren, nsMsgKey threadParentKey)
+{
+  nsresult ret = NS_OK;
+  // run through looking for messages that don't have a correct parent, 
+  // i.e., a parent that's in the thread!
+  for (int32_t childIndex = 0; childIndex < (int32_t) numChildren; childIndex++)
+  {
+    nsCOMPtr <nsIMsgDBHdr> curChild;
+    ret  = GetChildHdrAt(childIndex, getter_AddRefs(curChild));
+    if (NS_SUCCEEDED(ret) && curChild)
+    {
+      nsMsgKey parentKey;
+      nsCOMPtr <nsIMsgDBHdr> parent;
+      
+      curChild->GetThreadParent(&parentKey);
+      
+      if (parentKey != nsMsgKey_None)
+      {
+        GetChild(parentKey, getter_AddRefs(parent));
+        if (!parent)
+          curChild->SetThreadParent(threadParentKey);
+      }
+    }
+  }
+  return ret;
+}
+#endif
+NS_IMETHODIMP nsMsgGroupThread::GetRootHdr(int32_t *resultIndex, nsIMsgDBHdr **result)
+{
+  if (!result)
+    return NS_ERROR_NULL_POINTER;
+  
+  *result = nullptr;
+  
+  if (m_threadRootKey != nsMsgKey_None)
+  {
+    nsresult ret = GetChildHdrForKey(m_threadRootKey, result, resultIndex);
+    if (NS_SUCCEEDED(ret) && *result)
+      return ret;
+    else
+    {
+      printf("need to reset thread root key\n");
+      uint32_t numChildren;
+      nsMsgKey threadParentKey = nsMsgKey_None;
+      GetNumChildren(&numChildren);
+      
+      for (uint32_t childIndex = 0; childIndex < numChildren; childIndex++)
+      {
+        nsCOMPtr <nsIMsgDBHdr> curChild;
+        ret  = GetChildHdrAt(childIndex, getter_AddRefs(curChild));
+        if (NS_SUCCEEDED(ret) && curChild)
+        {
+          nsMsgKey parentKey;
+          
+          curChild->GetThreadParent(&parentKey);
+          if (parentKey == nsMsgKey_None)
+          {
+            NS_ASSERTION(!(*result), "two top level msgs, not good");
+            curChild->GetMessageKey(&threadParentKey);
+            m_threadRootKey = threadParentKey;
+            if (resultIndex)
+              *resultIndex = childIndex;
+            *result = curChild;
+            NS_ADDREF(*result);
+//            ReparentMsgsWithInvalidParent(numChildren, threadParentKey);
+            //            return NS_OK;
+          }
+        }
+      }
+      if (*result)
+      {
+        return NS_OK;
+      }
+    }
+    // if we can't get the thread root key, we'll just get the first hdr.
+    // there's a bug where sometimes we weren't resetting the thread root key 
+    // when removing the thread root key.
+  }
+  if (resultIndex)
+    *resultIndex = 0;
+  return GetChildHdrAt(0, result);
+}
+
+nsresult nsMsgGroupThread::ChangeUnreadChildCount(int32_t delta)
+{
+  m_numUnreadChildren += delta;
+  return NS_OK;
+}
+
+nsresult nsMsgGroupThread::GetChildHdrForKey(nsMsgKey desiredKey, nsIMsgDBHdr **result, int32_t *resultIndex)
+{
+  uint32_t numChildren;
+  uint32_t childIndex = 0;
+  nsresult rv = NS_OK;        // XXX or should this default to an error?
+  
+  if (!result)
+    return NS_ERROR_NULL_POINTER;
+  
+  GetNumChildren(&numChildren);
+
+  for (childIndex = 0; childIndex < numChildren; childIndex++)
+  {
+    rv = GetChildHdrAt(childIndex, result);
+    if (NS_SUCCEEDED(rv) && *result)
+    {
+      nsMsgKey msgKey;
+      // we're only doing one level of threading, so check if caller is
+      // asking for children of the first message in the thread or not.
+      // if not, we will tell him there are no children.
+      (*result)->GetMessageKey(&msgKey);
+      
+      if (msgKey == desiredKey)
+        break;
+      NS_RELEASE(*result);
+    }
+  }
+  if (resultIndex)
+    *resultIndex = (int32_t) childIndex;
+  
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::GetFirstUnreadChild(nsIMsgDBHdr **result)
+{
+  NS_ENSURE_ARG(result);
+  uint32_t numChildren;
+  nsresult rv = NS_OK;
+  
+  GetNumChildren(&numChildren);
+  
+  if ((int32_t) numChildren < 0)
+    numChildren = 0;
+  
+  for (uint32_t childIndex = 0; childIndex < numChildren; childIndex++)
+  {
+    nsCOMPtr <nsIMsgDBHdr> child;
+    rv = GetChildHdrAt(childIndex, getter_AddRefs(child));
+    if (NS_SUCCEEDED(rv) && child)
+    {
+      nsMsgKey msgKey;
+      child->GetMessageKey(&msgKey);
+      
+      bool isRead;
+      rv = m_db->IsRead(msgKey, &isRead);
+      if (NS_SUCCEEDED(rv) && !isRead)
+      {
+        *result = child;
+        NS_ADDREF(*result);
+        break;
+      }
+    }
+  }
+  
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgGroupThread::GetNewestMsgDate(uint32_t *aResult) 
+{
+  // if this hasn't been set, figure it out by enumerating the msgs in the thread.
+  if (!m_newestMsgDate)
+  {
+    uint32_t numChildren;
+    nsresult rv = NS_OK;
+  
+    GetNumChildren(&numChildren);
+  
+    for (uint32_t childIndex = 0; childIndex < numChildren; childIndex++)
+    {
+      nsCOMPtr <nsIMsgDBHdr> child;
+      rv = GetChildHdrAt(childIndex, getter_AddRefs(child));
+      if (NS_SUCCEEDED(rv) && child)
+      {
+        uint32_t msgDate;
+        child->GetDateInSeconds(&msgDate);
+        if (msgDate > m_newestMsgDate)
+          m_newestMsgDate = msgDate;
+      }
+    }
+  
+  }
+  *aResult = m_newestMsgDate;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMsgGroupThread::SetNewestMsgDate(uint32_t aNewestMsgDate) 
+{
+  m_newestMsgDate = aNewestMsgDate;
+  return NS_OK;
+}
+
+nsMsgXFGroupThread::nsMsgXFGroupThread()
+{
+}
+
+nsMsgXFGroupThread::~nsMsgXFGroupThread()
+{
+}
+
+NS_IMETHODIMP nsMsgXFGroupThread::GetNumChildren(uint32_t *aNumChildren)
+{
+  NS_ENSURE_ARG_POINTER(aNumChildren);
+  *aNumChildren = m_folders.Length();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFGroupThread::GetChildHdrAt(uint32_t aIndex, nsIMsgDBHdr **aResult)
+{
+  if (aIndex >= m_folders.Length())
+    return NS_MSG_MESSAGE_NOT_FOUND;
+  return m_folders.ObjectAt(aIndex)->GetMessageHeader(m_keys[aIndex], aResult);
+}
+
+NS_IMETHODIMP nsMsgXFGroupThread::GetChildKeyAt(uint32_t aIndex, nsMsgKey *aResult)
+{
+  NS_ASSERTION(false, "shouldn't call this");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgXFGroupThread::RemoveChildAt(uint32_t aIndex)
+{
+  NS_ENSURE_TRUE(aIndex < m_folders.Length(), NS_MSG_MESSAGE_NOT_FOUND);
+
+  nsresult rv = nsMsgGroupThread::RemoveChildAt(aIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+  m_folders.RemoveElementAt(aIndex);
+  return NS_OK;
+}
+
+void nsMsgXFGroupThread::InsertMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr)
+{
+  nsCOMPtr<nsIMsgFolder> folder;
+  hdr->GetFolder(getter_AddRefs(folder));
+  m_folders.InsertObjectAt(folder, index);
+  nsMsgGroupThread::InsertMsgHdrAt(index, hdr);
+}
+
+void nsMsgXFGroupThread::SetMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr)
+{
+  nsCOMPtr<nsIMsgFolder> folder;
+  hdr->GetFolder(getter_AddRefs(folder));
+  m_folders.ReplaceObjectAt(folder, index);
+  nsMsgGroupThread::SetMsgHdrAt(index, hdr);
+}
+
+nsMsgViewIndex nsMsgXFGroupThread::FindMsgHdr(nsIMsgDBHdr *hdr)
+{
+  nsMsgKey msgKey;
+  hdr->GetMessageKey(&msgKey);
+  nsCOMPtr<nsIMsgFolder> folder;
+  hdr->GetFolder(getter_AddRefs(folder));
+  size_t index = 0;
+  while (true) {
+    index = m_keys.IndexOf(msgKey, index);
+    if (index == m_keys.NoIndex || m_folders[index] == folder)
+      break;
+    index++;
+  }
+  return (nsMsgViewIndex)index;
+}
+
+nsMsgViewIndex nsMsgXFGroupThread::AddMsgHdrInDateOrder(nsIMsgDBHdr *child, nsMsgDBView *view)
+{
+  nsMsgViewIndex insertIndex = nsMsgGroupThread::AddMsgHdrInDateOrder(child, view);
+  nsCOMPtr<nsIMsgFolder> folder;
+  child->GetFolder(getter_AddRefs(folder));
+  m_folders.InsertObjectAt(folder, insertIndex);
+  return insertIndex;
+}
+nsMsgViewIndex 
+nsMsgXFGroupThread::GetInsertIndexFromView(nsMsgDBView *view, 
+                                          nsIMsgDBHdr *child, 
+                                          nsMsgViewSortOrderValue threadSortOrder)
+{
+   return view->GetInsertIndexHelper(child, m_keys, &m_folders, threadSortOrder, nsMsgViewSortType::byDate);
+}
+
diff --git a/mailnews/base/src/nsMsgGroupThread.h b/mailnews/base/src/nsMsgGroupThread.h
new file mode 100644
index 000000000..3d1cb4fb4
--- /dev/null
+++ b/mailnews/base/src/nsMsgGroupThread.h
@@ -0,0 +1,87 @@
+/* -*- 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 "mozilla/Attributes.h"
+#include "msgCore.h"
+#include "nsCOMArray.h"
+#include "nsIMsgThread.h"
+#include "MailNewsTypes.h"
+#include "nsTArray.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgHdr.h"
+#include "nsMsgDBView.h"
+
+class nsMsgGroupView;
+
+class nsMsgGroupThread : public nsIMsgThread
+{
+public:
+  friend class nsMsgGroupView;
+
+  nsMsgGroupThread();
+  nsMsgGroupThread(nsIMsgDatabase *db);
+
+  NS_DECL_NSIMSGTHREAD
+  NS_DECL_ISUPPORTS
+
+protected:
+  virtual ~nsMsgGroupThread();
+
+  void      Init();
+  nsMsgViewIndex AddChildFromGroupView(nsIMsgDBHdr *child, nsMsgDBView *view);
+  nsresult  RemoveChild(nsMsgKey msgKey);
+  nsresult  RerootThread(nsIMsgDBHdr *newParentOfOldRoot, nsIMsgDBHdr *oldRoot, nsIDBChangeAnnouncer *announcer);
+
+  virtual nsMsgViewIndex AddMsgHdrInDateOrder(nsIMsgDBHdr *child, nsMsgDBView *view);
+  virtual nsMsgViewIndex GetInsertIndexFromView(nsMsgDBView *view, 
+                                          nsIMsgDBHdr *child, 
+                                          nsMsgViewSortOrderValue threadSortOrder);
+  nsresult ReparentNonReferenceChildrenOf(nsIMsgDBHdr *topLevelHdr, nsMsgKey newParentKey,
+                                                            nsIDBChangeAnnouncer *announcer);
+
+  nsresult ReparentChildrenOf(nsMsgKey oldParent, nsMsgKey newParent, nsIDBChangeAnnouncer *announcer);
+  nsresult ChangeUnreadChildCount(int32_t delta);
+  nsresult GetChildHdrForKey(nsMsgKey desiredKey, nsIMsgDBHdr **result, int32_t *resultIndex);
+  uint32_t NumRealChildren();
+  virtual void InsertMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr);
+  virtual void SetMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr);
+  virtual nsMsgViewIndex FindMsgHdr(nsIMsgDBHdr *hdr);
+
+  nsMsgKey        m_threadKey; 
+  uint32_t        m_numUnreadChildren;	
+  uint32_t        m_flags;
+  nsMsgKey        m_threadRootKey;
+  uint32_t        m_newestMsgDate;
+  nsTArray<nsMsgKey> m_keys;
+  bool            m_dummy; // top level msg is a dummy, e.g., grouped by age.
+  nsCOMPtr <nsIMsgDatabase> m_db; // should we make a weak ref or just a ptr?
+};
+
+class nsMsgXFGroupThread : public nsMsgGroupThread
+{
+public:
+  nsMsgXFGroupThread();
+
+  NS_IMETHOD GetNumChildren(uint32_t *aNumChildren) override;
+  NS_IMETHOD GetChildKeyAt(uint32_t aIndex, nsMsgKey *aResult) override;
+  NS_IMETHOD GetChildHdrAt(uint32_t aIndex, nsIMsgDBHdr **aResult) override;
+  NS_IMETHOD RemoveChildAt(uint32_t aIndex) override;
+protected:
+  virtual ~nsMsgXFGroupThread();
+
+  virtual void InsertMsgHdrAt(nsMsgViewIndex index,
+                              nsIMsgDBHdr *hdr) override;
+  virtual void SetMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr) override;
+  virtual nsMsgViewIndex FindMsgHdr(nsIMsgDBHdr *hdr) override;
+  virtual nsMsgViewIndex AddMsgHdrInDateOrder(nsIMsgDBHdr *child, 
+                                              nsMsgDBView *view) override;
+  virtual nsMsgViewIndex GetInsertIndexFromView(nsMsgDBView *view, 
+                                          nsIMsgDBHdr *child, 
+                                          nsMsgViewSortOrderValue threadSortOrder
+                                                ) override;
+
+  nsCOMArray<nsIMsgFolder> m_folders;
+};
+
diff --git a/mailnews/base/src/nsMsgGroupView.cpp b/mailnews/base/src/nsMsgGroupView.cpp
new file mode 100644
index 000000000..f3d9a2704
--- /dev/null
+++ b/mailnews/base/src/nsMsgGroupView.cpp
@@ -0,0 +1,1024 @@
+/* -*- 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 "nsMsgUtils.h"
+#include "nsMsgGroupView.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgThread.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIMsgSearchSession.h"
+#include "nsMsgGroupThread.h"
+#include "nsITreeColumns.h"
+#include "nsMsgMessageFlags.h"
+#include <plhash.h>
+#include "mozilla/Attributes.h"
+
+#define MSGHDR_CACHE_LOOK_AHEAD_SIZE  25    // Allocate this more to avoid reallocation on new mail.
+#define MSGHDR_CACHE_MAX_SIZE         8192  // Max msghdr cache entries.
+#define MSGHDR_CACHE_DEFAULT_SIZE     100
+
+nsMsgGroupView::nsMsgGroupView()
+{
+  m_dayChanged = false;
+  m_lastCurExplodedTime.tm_mday = 0;
+}
+
+nsMsgGroupView::~nsMsgGroupView()
+{
+}
+
+NS_IMETHODIMP nsMsgGroupView::Open(nsIMsgFolder *aFolder, nsMsgViewSortTypeValue aSortType, nsMsgViewSortOrderValue aSortOrder, nsMsgViewFlagsTypeValue aViewFlags, int32_t *aCount)
+{
+  nsresult rv = nsMsgDBView::Open(aFolder, aSortType, aSortOrder, aViewFlags, aCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+  PersistFolderInfo(getter_AddRefs(dbFolderInfo));
+
+  nsCOMPtr <nsISimpleEnumerator> headers;
+  rv = m_db->EnumerateMessages(getter_AddRefs(headers));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return OpenWithHdrs(headers, aSortType, aSortOrder, aViewFlags, aCount);
+}
+
+void nsMsgGroupView::InternalClose()
+{
+  m_groupsTable.Clear();
+  // nothing to do if we're not grouped.
+  if (!(m_viewFlags & nsMsgViewFlagsType::kGroupBySort))
+    return;
+
+  bool rcvDate = false;
+
+  if (m_sortType == nsMsgViewSortType::byReceived)
+    rcvDate = true;
+  if (m_db &&
+      ((m_sortType == nsMsgViewSortType::byDate) ||
+       (m_sortType == nsMsgViewSortType::byReceived)))
+  {
+    nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+    m_db->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+    if (dbFolderInfo)
+    {
+      uint32_t expandFlags = 0;
+      uint32_t num = GetSize();
+
+      for (uint32_t i = 0; i < num; i++)
+      {
+        if (m_flags[i] & MSG_VIEW_FLAG_ISTHREAD && ! (m_flags[i] & nsMsgMessageFlags::Elided))
+        {
+          nsCOMPtr <nsIMsgDBHdr> msgHdr;
+          GetMsgHdrForViewIndex(i, getter_AddRefs(msgHdr));
+          if (msgHdr)
+          {
+            uint32_t ageBucket;
+            nsresult rv = GetAgeBucketValue(msgHdr, &ageBucket, rcvDate);
+            if (NS_SUCCEEDED(rv))
+              expandFlags |=  1 << ageBucket;
+          }
+        }
+      }
+      dbFolderInfo->SetUint32Property("dateGroupFlags", expandFlags);
+    }
+  }
+}
+
+NS_IMETHODIMP nsMsgGroupView::Close()
+{
+  InternalClose();
+  return nsMsgDBView::Close();
+}
+
+// Set rcvDate to true to get the Received: date instead of the Date: date.
+nsresult nsMsgGroupView::GetAgeBucketValue(nsIMsgDBHdr *aMsgHdr, uint32_t * aAgeBucket, bool rcvDate)
+{
+  NS_ENSURE_ARG_POINTER(aMsgHdr);
+  NS_ENSURE_ARG_POINTER(aAgeBucket);
+
+  PRTime dateOfMsg;
+  nsresult rv;
+  if (!rcvDate)
+    rv = aMsgHdr->GetDate(&dateOfMsg);
+  else
+  {
+    uint32_t rcvDateSecs;
+    rv = aMsgHdr->GetUint32Property("dateReceived", &rcvDateSecs);
+    Seconds2PRTime(rcvDateSecs, &dateOfMsg);
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  PRTime currentTime = PR_Now();
+  PRExplodedTime currentExplodedTime;
+  PR_ExplodeTime(currentTime, PR_LocalTimeParameters, &currentExplodedTime);
+  PRExplodedTime explodedMsgTime;
+  PR_ExplodeTime(dateOfMsg, PR_LocalTimeParameters, &explodedMsgTime);
+
+  if (m_lastCurExplodedTime.tm_mday &&
+     m_lastCurExplodedTime.tm_mday != currentExplodedTime.tm_mday)
+    m_dayChanged = true; // this will cause us to rebuild the view.
+
+  m_lastCurExplodedTime = currentExplodedTime;
+  if (currentExplodedTime.tm_year == explodedMsgTime.tm_year &&
+      currentExplodedTime.tm_month == explodedMsgTime.tm_month &&
+      currentExplodedTime.tm_mday == explodedMsgTime.tm_mday)
+  {
+    // same day...
+    *aAgeBucket = 1;
+  }
+  // figure out how many days ago this msg arrived
+  else if (currentTime > dateOfMsg)
+  {
+    // setting the time variables to local time
+    int64_t GMTLocalTimeShift = currentExplodedTime.tm_params.tp_gmt_offset +
+      currentExplodedTime.tm_params.tp_dst_offset;
+    GMTLocalTimeShift *= PR_USEC_PER_SEC;
+    currentTime += GMTLocalTimeShift;
+    dateOfMsg += GMTLocalTimeShift;
+
+    // the most recent midnight, counting from current time
+    int64_t mostRecentMidnight = currentTime - currentTime % PR_USEC_PER_DAY;
+    int64_t yesterday = mostRecentMidnight - PR_USEC_PER_DAY;
+    // most recent midnight minus 6 days
+    int64_t mostRecentWeek = mostRecentMidnight - (PR_USEC_PER_DAY * 6);
+
+    // was the message sent yesterday?
+    if (dateOfMsg >= yesterday) // yes ....
+      *aAgeBucket = 2;
+    else if (dateOfMsg >= mostRecentWeek)
+      *aAgeBucket = 3;
+    else
+    {
+      int64_t lastTwoWeeks = mostRecentMidnight - PR_USEC_PER_DAY * 13;
+      *aAgeBucket = (dateOfMsg >= lastTwoWeeks) ? 4 : 5;
+    }
+  }
+  else
+  {
+    // All that remains is a future date.
+    *aAgeBucket = 6;
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgGroupView::HashHdr(nsIMsgDBHdr *msgHdr, nsString& aHashKey)
+{
+  nsCString cStringKey;
+  aHashKey.Truncate();
+  nsresult rv = NS_OK;
+  bool rcvDate = false;
+
+  switch (m_sortType)
+  {
+    case nsMsgViewSortType::bySubject:
+      (void) msgHdr->GetSubject(getter_Copies(cStringKey));
+      CopyASCIItoUTF16(cStringKey, aHashKey);
+      break;
+    case nsMsgViewSortType::byAuthor:
+      rv = nsMsgDBView::FetchAuthor(msgHdr, aHashKey);
+      break;
+    case nsMsgViewSortType::byRecipient:
+      (void) msgHdr->GetRecipients(getter_Copies(cStringKey));
+      CopyASCIItoUTF16(cStringKey, aHashKey);
+      break;
+    case nsMsgViewSortType::byAccount:
+    case nsMsgViewSortType::byTags:
+      {
+        nsCOMPtr <nsIMsgDatabase> dbToUse = m_db;
+
+        if (!dbToUse) // probably search view
+          GetDBForViewIndex(0, getter_AddRefs(dbToUse));
+
+        rv = (m_sortType == nsMsgViewSortType::byAccount)
+          ? FetchAccount(msgHdr, aHashKey)
+          : FetchTags(msgHdr, aHashKey);
+      }
+      break;
+    case nsMsgViewSortType::byAttachments:
+      {
+        uint32_t flags;
+        msgHdr->GetFlags(&flags);
+        aHashKey.Assign(flags & nsMsgMessageFlags::Attachment ? '1' : '0');
+        break;
+      }
+    case nsMsgViewSortType::byFlagged:
+      {
+        uint32_t flags;
+        msgHdr->GetFlags(&flags);
+        aHashKey.Assign(flags & nsMsgMessageFlags::Marked ? '1' : '0');
+        break;
+      }
+    case nsMsgViewSortType::byPriority:
+      {
+        nsMsgPriorityValue priority;
+        msgHdr->GetPriority(&priority);
+        aHashKey.AppendInt(priority);
+      }
+      break;
+    case nsMsgViewSortType::byStatus:
+      {
+        uint32_t status = 0;
+        GetStatusSortValue(msgHdr, &status);
+        aHashKey.AppendInt(status);
+      }
+      break;
+    case nsMsgViewSortType::byReceived:
+      rcvDate = true;
+      MOZ_FALLTHROUGH;
+    case nsMsgViewSortType::byDate:
+    {
+      uint32_t ageBucket;
+      rv = GetAgeBucketValue(msgHdr, &ageBucket, rcvDate);
+      if (NS_SUCCEEDED(rv))
+        aHashKey.AppendInt(ageBucket);
+      break;
+    }
+    case nsMsgViewSortType::byCustom:
+    {
+      nsIMsgCustomColumnHandler* colHandler = GetCurColumnHandler();
+      if (colHandler)
+      {
+        bool isString;
+        colHandler->IsString(&isString);
+        if (isString)
+          rv = colHandler->GetSortStringForRow(msgHdr, aHashKey);
+        else
+        {
+          uint32_t intKey;
+          rv = colHandler->GetSortLongForRow(msgHdr, &intKey);
+          aHashKey.AppendInt(intKey);
+        }
+      }
+      break;
+    }
+    case nsMsgViewSortType::byCorrespondent:
+      if (IsOutgoingMsg(msgHdr))
+        rv = FetchRecipients(msgHdr, aHashKey);
+      else
+        rv = FetchAuthor(msgHdr, aHashKey);
+      break;
+    default:
+      NS_ASSERTION(false, "no hash key for this type");
+      rv = NS_ERROR_FAILURE;
+  }
+  return rv;
+}
+
+nsMsgGroupThread *nsMsgGroupView::CreateGroupThread(nsIMsgDatabase *db)
+{
+  return new nsMsgGroupThread(db);
+}
+
+nsMsgGroupThread *nsMsgGroupView::AddHdrToThread(nsIMsgDBHdr *msgHdr, bool *pNewThread)
+{
+  nsMsgKey msgKey;
+  uint32_t msgFlags;
+  msgHdr->GetMessageKey(&msgKey);
+  msgHdr->GetFlags(&msgFlags);
+  nsString hashKey;
+  nsresult rv = HashHdr(msgHdr, hashKey);
+  if (NS_FAILED(rv))
+    return nullptr;
+
+//  if (m_sortType == nsMsgViewSortType::byDate)
+//    msgKey = ((nsPRUint32Key *) hashKey)->GetValue();
+  nsCOMPtr<nsIMsgThread> msgThread;
+  m_groupsTable.Get(hashKey, getter_AddRefs(msgThread));
+  bool newThread = !msgThread;
+  *pNewThread = newThread;
+  nsMsgViewIndex viewIndexOfThread; // index of first message in thread in view
+  nsMsgViewIndex threadInsertIndex; // index of newly added header in thread
+
+  nsMsgGroupThread *foundThread = static_cast<nsMsgGroupThread *>(msgThread.get());
+  if (foundThread) 
+  {
+    // find the view index of the root node of the thread in the view
+    viewIndexOfThread = GetIndexOfFirstDisplayedKeyInThread(foundThread,
+                                                            true);
+    if (viewIndexOfThread == nsMsgViewIndex_None)
+    {
+      // Something is wrong with the group table. Remove the old group and
+      // insert a new one.
+      m_groupsTable.Remove(hashKey);
+      foundThread = nullptr;
+      *pNewThread = newThread = true;
+    }
+  }
+  // If the thread does not already exist, create one
+  if (!foundThread)
+  {
+    foundThread = CreateGroupThread(m_db);
+    msgThread = do_QueryInterface(foundThread);
+    m_groupsTable.Put(hashKey, msgThread);
+    if (GroupViewUsesDummyRow())
+    {
+      foundThread->m_dummy = true;
+      msgFlags |=  MSG_VIEW_FLAG_DUMMY | MSG_VIEW_FLAG_HASCHILDREN;
+    }
+
+    viewIndexOfThread = GetInsertIndex(msgHdr);
+    if (viewIndexOfThread == nsMsgViewIndex_None)
+      viewIndexOfThread = m_keys.Length();
+
+    // add the thread root node to the view
+    InsertMsgHdrAt(viewIndexOfThread, msgHdr, msgKey,
+                   msgFlags | MSG_VIEW_FLAG_ISTHREAD | nsMsgMessageFlags::Elided, 0);
+
+    // For dummy rows, Have the header serve as the dummy node (it will be added
+    //  again for its actual content later.)
+    if (GroupViewUsesDummyRow())
+      foundThread->InsertMsgHdrAt(0, msgHdr);
+
+    // Calculate the (integer thread key); this really only needs to be done for
+    //  the byDate case where the expanded state of the groups can be easily
+    //  persisted and restored because of the bounded, consecutive value space
+    //  occupied.  We calculate an integer value in all cases mainly because
+    //  it's the sanest choice available...
+    // (The thread key needs to be an integer, so parse hash keys that are
+    //  stringified integers to real integers, and hash actual strings into
+    //  integers.)
+    if ((m_sortType == nsMsgViewSortType::byAttachments) ||
+        (m_sortType == nsMsgViewSortType::byFlagged) ||
+        (m_sortType == nsMsgViewSortType::byPriority) ||
+        (m_sortType == nsMsgViewSortType::byStatus) ||
+        (m_sortType == nsMsgViewSortType::byReceived) ||
+        (m_sortType == nsMsgViewSortType::byDate))
+      foundThread->m_threadKey =
+        atoi(NS_LossyConvertUTF16toASCII(hashKey).get());
+    else
+      foundThread->m_threadKey = (nsMsgKey)
+        PL_HashString(NS_LossyConvertUTF16toASCII(hashKey).get());
+  }
+  // Add the message to the thread as an actual content-bearing header.
+  // (If we use dummy rows, it was already added to the thread during creation.)
+  threadInsertIndex = foundThread->AddChildFromGroupView(msgHdr, this);
+  // check if new hdr became thread root
+  if (!newThread && threadInsertIndex == 0)
+  {
+    // update the root node's header (in the view) to be the same as the root
+    //  node in the thread.
+    SetMsgHdrAt(msgHdr, viewIndexOfThread, msgKey,
+                (msgFlags & ~(nsMsgMessageFlags::Elided)) |
+                  // maintain elided flag and dummy flag
+                  (m_flags[viewIndexOfThread] & (nsMsgMessageFlags::Elided
+                                                 | MSG_VIEW_FLAG_DUMMY))
+                  // ensure thread and has-children flags are set
+                  | MSG_VIEW_FLAG_ISTHREAD | MSG_VIEW_FLAG_HASCHILDREN, 0);
+    // update the content-bearing copy in the thread to match.  (the root and
+    //  first nodes in the thread should always be the same header.)
+    // note: the guy who used to be the root will still exist.  If our list of
+    //  nodes was [A A], a new node B is introduced which sorts to be the first
+    //  node, giving us [B A A], our copy makes that [B B A], and things are
+    //  right in the world (since we want the first two headers to be the same
+    //  since one is our dummy and one is real.)
+    if (GroupViewUsesDummyRow())
+      foundThread->SetMsgHdrAt(1, msgHdr); // replace the old duplicate dummy header.
+    // we do not update the content-bearing copy in the view to match; we leave
+    //  that up to OnNewHeader, which is the piece of code who gets to care
+    //  about whether the thread's children are shown or not (elided)
+  }
+
+  return foundThread;
+}
+
+NS_IMETHODIMP nsMsgGroupView::OpenWithHdrs(nsISimpleEnumerator *aHeaders, nsMsgViewSortTypeValue aSortType,
+                                        nsMsgViewSortOrderValue aSortOrder, nsMsgViewFlagsTypeValue aViewFlags,
+                                        int32_t *aCount)
+{
+  nsresult rv = NS_OK;
+
+  m_groupsTable.Clear();
+  if (aSortType == nsMsgViewSortType::byThread || aSortType == nsMsgViewSortType::byId
+    || aSortType == nsMsgViewSortType::byNone || aSortType == nsMsgViewSortType::bySize)
+    return NS_ERROR_INVALID_ARG;
+
+  m_sortType = aSortType;
+  m_sortOrder = aSortOrder;
+  m_viewFlags = aViewFlags | nsMsgViewFlagsType::kThreadedDisplay | nsMsgViewFlagsType::kGroupBySort;
+  SaveSortInfo(m_sortType, m_sortOrder);
+
+  if (m_sortType == nsMsgViewSortType::byCustom)
+  {
+    // If the desired sort is a custom column and there is no handler found,
+    // it hasn't been registered yet; after the custom column observer is
+    // notified with MsgCreateDBView and registers the handler, it will come
+    // back and build the view.
+    nsIMsgCustomColumnHandler* colHandler = GetCurColumnHandler();
+    if (!colHandler)
+      return rv;
+  }
+
+  bool hasMore;
+  nsCOMPtr <nsISupports> supports;
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  while (NS_SUCCEEDED(rv) && NS_SUCCEEDED(rv = aHeaders->HasMoreElements(&hasMore)) && hasMore)
+  {
+    rv = aHeaders->GetNext(getter_AddRefs(supports));
+    if (NS_SUCCEEDED(rv) && supports)
+    {
+      bool notUsed;
+      msgHdr = do_QueryInterface(supports);
+      AddHdrToThread(msgHdr, &notUsed);
+    }
+  }
+  uint32_t expandFlags = 0;
+  bool expandAll = m_viewFlags & nsMsgViewFlagsType::kExpandAll;
+  uint32_t viewFlag = (m_sortType == nsMsgViewSortType::byDate) ? MSG_VIEW_FLAG_DUMMY : 0;
+  if (viewFlag && m_db)
+  {
+    nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+    nsresult rv = m_db->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (dbFolderInfo)
+      dbFolderInfo->GetUint32Property("dateGroupFlags",  0, &expandFlags);
+  }
+  // go through the view updating the flags for threads with more than one message...
+  // and if grouped by date, expanding threads that were expanded before.
+  for (uint32_t viewIndex = 0; viewIndex < m_keys.Length(); viewIndex++)
+  {
+    nsCOMPtr <nsIMsgThread> thread;
+    GetThreadContainingIndex(viewIndex, getter_AddRefs(thread));
+    if (thread)
+    {
+      uint32_t numChildren;
+      thread->GetNumChildren(&numChildren);
+      if (numChildren > 1 || viewFlag)
+        OrExtraFlag(viewIndex, viewFlag | MSG_VIEW_FLAG_HASCHILDREN);
+      if (expandAll || expandFlags)
+      {
+        nsMsgGroupThread *groupThread = static_cast<nsMsgGroupThread *>((nsIMsgThread *) thread);
+        if (expandAll || expandFlags & (1 << groupThread->m_threadKey))
+        {
+          uint32_t numExpanded;
+          ExpandByIndex(viewIndex, &numExpanded);
+          viewIndex += numExpanded;
+        }
+      }
+    }
+  }
+  *aCount = m_keys.Length();
+  return rv;
+}
+
+// we wouldn't need this if we never instantiated this directly,
+// but instead used nsMsgThreadedDBView with the grouping flag set.
+// Or, we could get rid of the nsMsgThreadedDBView impl of this method.
+NS_IMETHODIMP nsMsgGroupView::GetViewType(nsMsgViewTypeValue *aViewType)
+{
+    NS_ENSURE_ARG_POINTER(aViewType);
+    *aViewType = nsMsgViewType::eShowAllThreads; 
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgGroupView::CopyDBView(nsMsgDBView *aNewMsgDBView, nsIMessenger *aMessengerInstance, 
+                                       nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater)
+{
+  nsMsgDBView::CopyDBView(aNewMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  nsMsgGroupView* newMsgDBView = (nsMsgGroupView *) aNewMsgDBView;
+
+  // If grouped, we need to clone the group thread hash table.
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort) {
+    for (auto iter = m_groupsTable.Iter(); !iter.Done(); iter.Next()) {
+      newMsgDBView->m_groupsTable.Put(iter.Key(), iter.UserData());
+    }
+  }
+  return NS_OK;
+}
+
+// E.g., if the day has changed, we need to close and re-open the view.
+// Or, if we're switching between grouping and threading in a cross-folder
+// saved search. In that case, we needed to build an enumerator based on the
+// old view type, and internally close the view based on its old type, but
+// rebuild the new view based on the new view type. So we pass the new
+// view flags to OpenWithHdrs.
+nsresult nsMsgGroupView::RebuildView(nsMsgViewFlagsTypeValue newFlags)
+{
+  nsCOMPtr <nsISimpleEnumerator> headers;
+  if (NS_SUCCEEDED(GetMessageEnumerator(getter_AddRefs(headers))))
+  {
+    int32_t count;
+    m_dayChanged = false;
+    AutoTArray<nsMsgKey, 1> preservedSelection;
+    nsMsgKey curSelectedKey;
+    SaveAndClearSelection(&curSelectedKey, preservedSelection);
+    InternalClose();
+    int32_t oldSize = GetSize();
+    // this is important, because the tree will ask us for our
+    // row count, which get determine from the number of keys.
+    m_keys.Clear();
+    // be consistent
+    m_flags.Clear();
+    m_levels.Clear();
+
+    // this needs to happen after we remove all the keys, since RowCountChanged() will call our GetRowCount()
+    if (mTree)
+      mTree->RowCountChanged(0, -oldSize);
+    SetSuppressChangeNotifications(true);
+    nsresult rv = OpenWithHdrs(headers, m_sortType, m_sortOrder, newFlags, &count);
+    SetSuppressChangeNotifications(false);
+    if (mTree)
+      mTree->RowCountChanged(0, GetSize());
+
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    // now, restore our desired selection
+    AutoTArray<nsMsgKey, 1> keyArray;
+    keyArray.AppendElement(curSelectedKey);
+
+    return RestoreSelection(curSelectedKey, keyArray);
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgGroupView::OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey aParentKey, bool ensureListed)
+{
+  if (!(m_viewFlags & nsMsgViewFlagsType::kGroupBySort))
+    return nsMsgDBView::OnNewHeader(newHdr, aParentKey, ensureListed);
+
+  // check if we're adding a header, and the current day has changed. If it has, we're just going to
+  // close and re-open the view so things will be correctly categorized.
+  if (m_dayChanged)
+    return RebuildView(m_viewFlags);
+
+  bool newThread;
+  nsMsgGroupThread *thread = AddHdrToThread(newHdr, &newThread);
+  if (thread)
+  {
+    // find the view index of (the root node of) the thread
+    nsMsgViewIndex threadIndex = ThreadIndexOfMsgHdr(newHdr);
+    // may need to fix thread counts
+    if (threadIndex != nsMsgViewIndex_None)
+    {
+      if (newThread)
+      {
+        // AddHdrToThread creates the header elided, so we need to un-elide it
+        //  if we want it expanded.
+        if(m_viewFlags & nsMsgViewFlagsType::kExpandAll)
+          m_flags[threadIndex] &= ~nsMsgMessageFlags::Elided;
+      }
+      else
+      {
+        m_flags[threadIndex] |= MSG_VIEW_FLAG_HASCHILDREN
+                                | MSG_VIEW_FLAG_ISTHREAD;
+      }
+
+      int32_t numRowsToInvalidate = 1;
+      // if the thread is expanded (not elided), we should add the header to
+      //  the view.
+      if (! (m_flags[threadIndex] & nsMsgMessageFlags::Elided))
+      {
+        uint32_t msgIndexInThread = thread->FindMsgHdr(newHdr);
+        bool insertedAtThreadRoot = !msgIndexInThread;
+        // Add any new display node and potentially fix-up changes in the root.
+        // (If this is a new thread and we are not using a dummy row, the only
+        //  node to display is the root node which has already been added by
+        //  AddHdrToThread.  And since there is just the one, no change in root
+        //  could have occurred, so we have nothing to do.)
+        if (!newThread || GroupViewUsesDummyRow())
+        {
+          // we never want to insert/update the root node, because
+          //  AddHdrToThread has already done that for us (in all cases).
+          if (insertedAtThreadRoot)
+            msgIndexInThread++;
+          // If this header is the new parent of the thread... AND
+          // If we are not using a dummy row, this means we need to append our
+          //  old node as the first child of the new root.
+          // (If we are using a dummy row, the old node's "content" node already
+          //  exists (at position threadIndex + 1) and we need to insert the
+          //  "content" copy of the new root node there, pushing our old
+          //  "content" node down.)
+          // Example mini-diagrams, wrapping the to-add thing with ()
+          //  No dummy row; we had: [A], now we have [B], we want [B (A)].
+          //  Dummy row; we had: [A A], now we have [B A], we want [B (B) A].
+          //  (Coming into this we're adding 'B')
+          if (!newThread && insertedAtThreadRoot && !GroupViewUsesDummyRow())
+          {
+            // grab a copy of the old root node ('A') from the thread so we can
+            //  insert it. (offset msgIndexInThread=1 is the right thing; we are
+            //  non-dummy.)
+            thread->GetChildHdrAt(msgIndexInThread, &newHdr);
+          } // nothing to do for dummy case, we're already inserting 'B'.
+          nsMsgKey msgKey;
+          uint32_t msgFlags;
+          newHdr->GetMessageKey(&msgKey);
+          newHdr->GetFlags(&msgFlags);
+          InsertMsgHdrAt(threadIndex + msgIndexInThread, newHdr, msgKey,
+                         msgFlags, 1);
+        }
+        // the call to NoteChange() has to happen after we add the key
+        // as NoteChange() will call RowCountChanged() which will call our GetRowCount()
+        // (msgIndexInThread states.  new thread: 0, old thread at root: 1)
+        if (newThread && GroupViewUsesDummyRow())
+          NoteChange(threadIndex, 2, nsMsgViewNotificationCode::insertOrDelete);
+        else
+          NoteChange(threadIndex + msgIndexInThread, 1,
+                     nsMsgViewNotificationCode::insertOrDelete);
+        numRowsToInvalidate = msgIndexInThread;
+      }
+      // we still need the addition notification for new threads when elided
+      else if (newThread)
+      {
+        NoteChange(threadIndex, 1,
+                   nsMsgViewNotificationCode::insertOrDelete);
+      }
+      NoteChange(threadIndex, numRowsToInvalidate, nsMsgViewNotificationCode::changed);
+    }
+  }
+  // if thread is expanded, we need to add hdr to view...
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgGroupView::OnHdrFlagsChanged(nsIMsgDBHdr *aHdrChanged, uint32_t aOldFlags,
+                                      uint32_t aNewFlags, nsIDBChangeListener *aInstigator)
+{
+  if (!(m_viewFlags & nsMsgViewFlagsType::kGroupBySort))
+    return nsMsgDBView::OnHdrFlagsChanged(aHdrChanged, aOldFlags, aNewFlags,
+                                          aInstigator);
+
+  nsCOMPtr <nsIMsgThread> thread;
+
+  // check if we're adding a header, and the current day has changed. If it has, we're just going to
+  // close and re-open the view so things will be correctly categorized.
+  if (m_dayChanged)
+    return RebuildView(m_viewFlags);
+
+  nsresult rv = GetThreadContainingMsgHdr(aHdrChanged, getter_AddRefs(thread));
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint32_t deltaFlags = (aOldFlags ^ aNewFlags);
+  if (deltaFlags & nsMsgMessageFlags::Read)
+    thread->MarkChildRead(aNewFlags & nsMsgMessageFlags::Read);
+
+  return nsMsgDBView::OnHdrFlagsChanged(aHdrChanged, aOldFlags, aNewFlags, aInstigator);
+}
+
+NS_IMETHODIMP nsMsgGroupView::OnHdrDeleted(nsIMsgDBHdr *aHdrDeleted, nsMsgKey aParentKey, int32_t aFlags,
+                            nsIDBChangeListener *aInstigator)
+{
+  if (!(m_viewFlags & nsMsgViewFlagsType::kGroupBySort))
+    return nsMsgDBView::OnHdrDeleted(aHdrDeleted, aParentKey, aFlags, aInstigator);
+
+  // check if we're adding a header, and the current day has changed. If it has, we're just going to
+  // close and re-open the view so things will be correctly categorized.
+  if (m_dayChanged)
+    return RebuildView(m_viewFlags);
+
+  nsCOMPtr <nsIMsgThread> thread;
+  nsMsgKey keyDeleted;
+  aHdrDeleted->GetMessageKey(&keyDeleted);
+
+  nsresult rv = GetThreadContainingMsgHdr(aHdrDeleted, getter_AddRefs(thread));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsMsgViewIndex viewIndexOfThread = GetIndexOfFirstDisplayedKeyInThread(
+                                       thread, true); // yes to dummy node
+  thread->RemoveChildHdr(aHdrDeleted, nullptr);
+
+  nsMsgGroupThread *groupThread = static_cast<nsMsgGroupThread *>((nsIMsgThread *) thread);
+
+  bool rootDeleted = viewIndexOfThread != nsMsgKey_None &&
+    m_keys[viewIndexOfThread] == keyDeleted;
+  rv = nsMsgDBView::OnHdrDeleted(aHdrDeleted, aParentKey, aFlags, aInstigator);
+  if (groupThread->m_dummy)
+  {
+    if (!groupThread->NumRealChildren())
+    {
+      thread->RemoveChildAt(0); // get rid of dummy
+      if (viewIndexOfThread != nsMsgKey_None)
+      {
+        RemoveByIndex(viewIndexOfThread);
+        if (m_deletingRows)
+          mIndicesToNoteChange.AppendElement(viewIndexOfThread);
+      }
+    }
+    else if (rootDeleted)
+    {
+      // reflect new thread root into view.dummy row.
+      nsCOMPtr<nsIMsgDBHdr> hdr;
+      thread->GetChildHdrAt(0, getter_AddRefs(hdr));
+      if (hdr)
+      {
+        nsMsgKey msgKey;
+        hdr->GetMessageKey(&msgKey);
+        SetMsgHdrAt(hdr, viewIndexOfThread, msgKey, m_flags[viewIndexOfThread], 0);
+      }
+    }
+  }
+  if (!groupThread->m_keys.Length())
+  {
+    nsString hashKey;
+    rv = HashHdr(aHdrDeleted, hashKey);
+    if (NS_SUCCEEDED(rv))
+      m_groupsTable.Remove(hashKey);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgGroupView::GetRowProperties(int32_t aRow, nsAString& aProperties)
+{
+  if (!IsValidIndex(aRow))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (m_flags[aRow] & MSG_VIEW_FLAG_DUMMY)
+  {
+    aProperties.AssignLiteral("dummy");
+    return NS_OK;
+  }
+
+  return nsMsgDBView::GetRowProperties(aRow, aProperties);
+}
+
+NS_IMETHODIMP nsMsgGroupView::GetCellProperties(int32_t aRow,
+                                                nsITreeColumn *aCol,
+                                                nsAString& aProperties)
+{
+  if (!IsValidIndex(aRow))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (m_flags[aRow] & MSG_VIEW_FLAG_DUMMY)
+  {
+    aProperties.AssignLiteral("dummy read");
+
+    if (!(m_flags[aRow] & nsMsgMessageFlags::Elided))
+      return NS_OK;
+
+    // Set unread property if a collapsed group thread has unread.
+    nsCOMPtr <nsIMsgDBHdr> msgHdr;
+    nsresult rv = GetMsgHdrForViewIndex(aRow, getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsString hashKey;
+    rv = HashHdr(msgHdr, hashKey);
+    if (NS_FAILED(rv))
+      return NS_OK;
+
+    nsCOMPtr<nsIMsgThread> msgThread;
+    m_groupsTable.Get(hashKey, getter_AddRefs(msgThread));
+    nsMsgGroupThread *groupThread = static_cast<nsMsgGroupThread *>(msgThread.get());
+    if (!groupThread)
+      return NS_OK;
+
+    uint32_t numUnrMsg = 0;
+    groupThread->GetNumUnreadChildren(&numUnrMsg);
+    if (numUnrMsg > 0)
+      aProperties.AppendLiteral(" hasUnread");
+
+    return NS_OK;
+  }
+
+  return nsMsgDBView::GetCellProperties(aRow, aCol, aProperties);
+}
+
+NS_IMETHODIMP nsMsgGroupView::CellTextForColumn(int32_t aRow,
+                                                const char16_t *aColumnName,
+                                                nsAString &aValue) {
+  if (!IsValidIndex(aRow))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (m_flags[aRow] & MSG_VIEW_FLAG_DUMMY && aColumnName[0] != 'u')
+  {
+    nsCOMPtr <nsIMsgDBHdr> msgHdr;
+    nsresult rv = GetMsgHdrForViewIndex(aRow, getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsString hashKey;
+    rv = HashHdr(msgHdr, hashKey);
+    if (NS_FAILED(rv))
+      return NS_OK;
+    nsCOMPtr<nsIMsgThread> msgThread;
+    m_groupsTable.Get(hashKey, getter_AddRefs(msgThread));
+    nsMsgGroupThread * groupThread = static_cast<nsMsgGroupThread *>(msgThread.get());
+    if (aColumnName[0] == 's'  && aColumnName[1] == 'u' )
+    {
+      uint32_t flags;
+      bool rcvDate = false;
+      msgHdr->GetFlags(&flags);
+      aValue.Truncate();
+      nsString tmp_str;
+      switch (m_sortType)
+      {
+        case nsMsgViewSortType::byReceived:
+          rcvDate = true;
+          MOZ_FALLTHROUGH;
+        case nsMsgViewSortType::byDate:
+        {
+          uint32_t ageBucket = 0;
+          GetAgeBucketValue(msgHdr, &ageBucket, rcvDate);
+          switch (ageBucket)
+          {
+          case 1:
+            if (m_kTodayString.IsEmpty())
+              m_kTodayString.Adopt(GetString(u"today"));
+            aValue.Assign(m_kTodayString);
+            break;
+          case 2:
+            if (m_kYesterdayString.IsEmpty())
+              m_kYesterdayString.Adopt(GetString(u"yesterday"));
+            aValue.Assign(m_kYesterdayString);
+            break;
+          case 3:
+            if (m_kLastWeekString.IsEmpty())
+              m_kLastWeekString.Adopt(GetString(u"last7Days"));
+            aValue.Assign(m_kLastWeekString);
+            break;
+          case 4:
+            if (m_kTwoWeeksAgoString.IsEmpty())
+              m_kTwoWeeksAgoString.Adopt(GetString(u"last14Days"));
+            aValue.Assign(m_kTwoWeeksAgoString);
+            break;
+          case 5:
+            if (m_kOldMailString.IsEmpty())
+              m_kOldMailString.Adopt(GetString(u"older"));
+            aValue.Assign(m_kOldMailString);
+            break;
+          default:
+            // Future date, error/spoofed.
+            if (m_kFutureDateString.IsEmpty())
+              m_kFutureDateString.Adopt(GetString(u"futureDate"));
+            aValue.Assign(m_kFutureDateString);
+            break;
+          }
+          break;
+        }
+        case nsMsgViewSortType::bySubject:
+          FetchSubject(msgHdr, m_flags[aRow], aValue);
+          break;
+        case nsMsgViewSortType::byAuthor:
+          FetchAuthor(msgHdr, aValue);
+          break;
+        case nsMsgViewSortType::byStatus:
+          rv = FetchStatus(m_flags[aRow], aValue);
+          if (aValue.IsEmpty()) {
+            tmp_str.Adopt(GetString(u"messagesWithNoStatus"));
+            aValue.Assign(tmp_str);
+          }
+          break;
+        case nsMsgViewSortType::byTags:
+          rv = FetchTags(msgHdr, aValue);
+          if (aValue.IsEmpty()) {
+            tmp_str.Adopt(GetString(u"untaggedMessages"));
+            aValue.Assign(tmp_str);
+          }
+          break;
+        case nsMsgViewSortType::byPriority:
+          FetchPriority(msgHdr, aValue);
+          if (aValue.IsEmpty()) {
+            tmp_str.Adopt(GetString(u"noPriority"));
+            aValue.Assign(tmp_str);
+          }
+          break;
+        case nsMsgViewSortType::byAccount:
+          FetchAccount(msgHdr, aValue);
+          break;
+        case nsMsgViewSortType::byRecipient:
+          FetchRecipients(msgHdr, aValue);
+          break;
+        case nsMsgViewSortType::byAttachments:
+          tmp_str.Adopt(GetString(flags & nsMsgMessageFlags::Attachment ?
+            u"attachments" : u"noAttachments"));
+          aValue.Assign(tmp_str);
+          break;
+        case nsMsgViewSortType::byFlagged:
+          tmp_str.Adopt(GetString(flags & nsMsgMessageFlags::Marked ?
+            u"groupFlagged" : u"notFlagged"));
+          aValue.Assign(tmp_str);
+          break;
+        // byLocation is a special case; we don't want to have duplicate
+        //  all this logic in nsMsgSearchDBView, and its hash key is what we
+        //  want anyways, so just copy it across.
+        case nsMsgViewSortType::byLocation:
+        case nsMsgViewSortType::byCorrespondent:
+          aValue = hashKey;
+          break;
+        case nsMsgViewSortType::byCustom:
+        {
+          nsIMsgCustomColumnHandler* colHandler = GetCurColumnHandler();
+          if (colHandler)
+          {
+            bool isString;
+            colHandler->IsString(&isString);
+            if (isString)
+              rv = colHandler->GetSortStringForRow(msgHdr.get(), aValue);
+            else
+            {
+              uint32_t intKey;
+              rv = colHandler->GetSortLongForRow(msgHdr.get(), &intKey);
+              aValue.AppendInt(intKey);
+            }
+          }
+          if (aValue.IsEmpty())
+            aValue.AssignLiteral("*");
+          break;
+        }
+
+        default:
+          NS_ASSERTION(false, "we don't sort by group for this type");
+          break;
+      }
+
+      if (groupThread)
+      {
+        // Get number of messages in group
+        nsAutoString formattedCountMsg;
+        uint32_t numMsg = groupThread->NumRealChildren();
+        formattedCountMsg.AppendInt(numMsg);
+
+        // Get number of unread messages
+        nsAutoString formattedCountUnrMsg;
+        uint32_t numUnrMsg = 0;
+        groupThread->GetNumUnreadChildren(&numUnrMsg);
+        formattedCountUnrMsg.AppendInt(numUnrMsg);
+
+        // Add text to header
+        aValue.Append(NS_LITERAL_STRING(" ("));
+        if (numUnrMsg)
+        {
+          aValue.Append(formattedCountUnrMsg);
+          aValue.Append(NS_LITERAL_STRING("/"));
+        }
+
+        aValue.Append(formattedCountMsg);
+        aValue.Append(NS_LITERAL_STRING(")"));
+      }
+    }
+    else if (aColumnName[0] == 't' && aColumnName[1] == 'o')
+    {
+      nsAutoString formattedCountString;
+      uint32_t numChildren = (groupThread) ? groupThread->NumRealChildren() : 0;
+      formattedCountString.AppendInt(numChildren);
+      aValue.Assign(formattedCountString);
+    }
+    return NS_OK;
+  }
+  return nsMsgDBView::CellTextForColumn(aRow, aColumnName, aValue);
+}
+
+NS_IMETHODIMP nsMsgGroupView::LoadMessageByViewIndex(nsMsgViewIndex aViewIndex)
+{
+  if (!IsValidIndex(aViewIndex))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (m_flags[aViewIndex] & MSG_VIEW_FLAG_DUMMY)
+  {
+    // if we used to have one item selected, and now we have more than one, we should clear the message pane.
+    nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(mMsgWindowWeak));
+    nsCOMPtr <nsIMsgWindowCommands> windowCommands;
+    if (msgWindow && NS_SUCCEEDED(msgWindow->GetWindowCommands(getter_AddRefs(windowCommands))) && windowCommands)
+      windowCommands->ClearMsgPane();
+    // since we are selecting a dummy row, we should also clear out m_currentlyDisplayedMsgUri
+    m_currentlyDisplayedMsgUri.Truncate();
+    return NS_OK;
+  }
+  else
+    return nsMsgDBView::LoadMessageByViewIndex(aViewIndex);
+}
+
+NS_IMETHODIMP nsMsgGroupView::GetThreadContainingMsgHdr(nsIMsgDBHdr *msgHdr, nsIMsgThread **pThread)
+{
+  if (!(m_viewFlags & nsMsgViewFlagsType::kGroupBySort))
+    return nsMsgDBView::GetThreadContainingMsgHdr(msgHdr, pThread);
+
+  nsString hashKey;
+  nsresult rv = HashHdr(msgHdr, hashKey);
+  *pThread = nullptr;
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIMsgThread> thread;
+    m_groupsTable.Get(hashKey, getter_AddRefs(thread));
+    thread.swap(*pThread);
+  }
+  return (*pThread) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+int32_t nsMsgGroupView::FindLevelInThread(nsIMsgDBHdr *msgHdr,
+                                          nsMsgViewIndex startOfThread, nsMsgViewIndex viewIndex)
+{
+  if (!(m_viewFlags & nsMsgViewFlagsType::kGroupBySort))
+    return nsMsgDBView::FindLevelInThread(msgHdr, startOfThread, viewIndex);
+  return (startOfThread == viewIndex) ? 0 : 1;
+}
+
+bool nsMsgGroupView::GroupViewUsesDummyRow()
+{
+  // Return true to always use a header row as root grouped parent row.
+  return true;
+}
+
+NS_IMETHODIMP nsMsgGroupView::AddColumnHandler(const nsAString& column,
+                                                 nsIMsgCustomColumnHandler* handler)
+{
+  nsMsgDBView::AddColumnHandler(column, handler);
+
+  // If the sortType is byCustom and the desired custom column is the one just
+  // registered, build the view.
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort &&
+      m_sortType == nsMsgViewSortType::byCustom)
+  {
+    nsAutoString curCustomColumn;
+    GetCurCustomColumn(curCustomColumn);
+    if (curCustomColumn == column)
+      RebuildView(m_viewFlags);
+  }
+
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMsgGroupView.h b/mailnews/base/src/nsMsgGroupView.h
new file mode 100644
index 000000000..6a2d526da
--- /dev/null
+++ b/mailnews/base/src/nsMsgGroupView.h
@@ -0,0 +1,74 @@
+/* -*- 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 _nsMsgGroupView_H_
+#define _nsMsgGroupView_H_
+
+#include "mozilla/Attributes.h"
+#include "nsMsgDBView.h"
+#include "nsInterfaceHashtable.h"
+
+class nsIMsgThread;
+class nsMsgGroupThread;
+
+// Please note that if you override a method of nsMsgDBView,
+// you will most likely want to check the m_viewFlags to see if
+// we're grouping, and if not, call the base class implementation.
+class nsMsgGroupView : public nsMsgDBView
+{
+public:
+  nsMsgGroupView();
+  virtual ~nsMsgGroupView();
+
+  NS_IMETHOD Open(nsIMsgFolder *folder, nsMsgViewSortTypeValue sortType,
+                  nsMsgViewSortOrderValue sortOrder, nsMsgViewFlagsTypeValue viewFlags,
+                  int32_t *pCount) override;
+  NS_IMETHOD OpenWithHdrs(nsISimpleEnumerator *aHeaders, nsMsgViewSortTypeValue aSortType,
+                                        nsMsgViewSortOrderValue aSortOrder, nsMsgViewFlagsTypeValue aViewFlags,
+                                        int32_t *aCount) override;
+  NS_IMETHOD GetViewType(nsMsgViewTypeValue *aViewType) override;
+  NS_IMETHOD CopyDBView(nsMsgDBView *aNewMsgDBView, nsIMessenger *aMessengerInstance,
+                        nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater);
+  NS_IMETHOD Close() override;
+  NS_IMETHOD OnHdrDeleted(nsIMsgDBHdr *aHdrDeleted, nsMsgKey aParentKey, int32_t aFlags, 
+                          nsIDBChangeListener *aInstigator) override;
+  NS_IMETHOD OnHdrFlagsChanged(nsIMsgDBHdr *aHdrChanged, uint32_t aOldFlags, 
+                               uint32_t aNewFlags, nsIDBChangeListener *aInstigator) override;
+
+  NS_IMETHOD LoadMessageByViewIndex(nsMsgViewIndex aViewIndex) override;
+  NS_IMETHOD GetCellProperties(int32_t aRow, nsITreeColumn *aCol, nsAString& aProperties) override;
+  NS_IMETHOD GetRowProperties(int32_t aRow, nsAString& aProperties) override;
+  NS_IMETHOD CellTextForColumn(int32_t aRow, const char16_t *aColumnName,
+                               nsAString &aValue) override;
+  NS_IMETHOD GetThreadContainingMsgHdr(nsIMsgDBHdr *msgHdr, nsIMsgThread **pThread) override;
+  NS_IMETHOD AddColumnHandler(const nsAString& column, nsIMsgCustomColumnHandler* handler) override;
+
+protected:
+  virtual void InternalClose();
+  nsMsgGroupThread *AddHdrToThread(nsIMsgDBHdr *msgHdr, bool *pNewThread);
+  virtual nsresult HashHdr(nsIMsgDBHdr *msgHdr, nsString& aHashKey);
+  nsresult GetAgeBucketValue(nsIMsgDBHdr *aMsgHdr, uint32_t * aAgeBucket, bool rcvDate = false); // helper function to get the age bucket for a hdr, useful when grouped by date
+  nsresult OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey aParentKey, bool /*ensureListed*/) override;
+  virtual int32_t FindLevelInThread(nsIMsgDBHdr *msgHdr, nsMsgViewIndex startOfThread, nsMsgViewIndex viewIndex) override;
+
+  // Returns true if we are grouped by a sort attribute that uses a dummy row.
+  bool GroupViewUsesDummyRow();
+  nsresult RebuildView(nsMsgViewFlagsTypeValue viewFlags);
+  virtual nsMsgGroupThread *CreateGroupThread(nsIMsgDatabase *db);
+
+  nsInterfaceHashtable <nsStringHashKey, nsIMsgThread> m_groupsTable;
+  PRExplodedTime m_lastCurExplodedTime;
+  bool m_dayChanged;
+
+private:
+  nsString m_kTodayString;
+  nsString m_kYesterdayString;
+  nsString m_kLastWeekString;
+  nsString m_kTwoWeeksAgoString;
+  nsString m_kOldMailString;
+  nsString m_kFutureDateString;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgMailSession.cpp b/mailnews/base/src/nsMsgMailSession.cpp
new file mode 100644
index 000000000..f9e396988
--- /dev/null
+++ b/mailnews/base/src/nsMsgMailSession.cpp
@@ -0,0 +1,761 @@
+/* -*- 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" // for pre-compiled headers
+#include "nsMsgBaseCID.h"
+#include "nsMsgMailSession.h"
+#include "nsIMsgMessageService.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIChromeRegistry.h"
+#include "nsIDirectoryService.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsPIDOMWindow.h"
+#include "nsIDocShell.h"
+#include "nsIDocument.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMElement.h"
+#include "nsIObserverService.h"
+#include "nsIAppStartup.h"
+#include "nsToolkitCompsCID.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIAppShellService.h"
+#include "nsAppShellCID.h"
+#include "nsIWindowMediator.h"
+#include "nsIWindowWatcher.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "prcmon.h"
+#include "nsThreadUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIProperties.h"
+#include "mozilla/Services.h"
+
+NS_IMPL_ISUPPORTS(nsMsgMailSession, nsIMsgMailSession, nsIFolderListener)
+
+nsMsgMailSession::nsMsgMailSession()
+{
+}
+
+
+nsMsgMailSession::~nsMsgMailSession()
+{
+  Shutdown();
+}
+
+nsresult nsMsgMailSession::Init()
+{
+  // Ensures the shutdown service is initialised
+  nsresult rv;
+  nsCOMPtr<nsIMsgShutdownService> shutdownService =
+    do_GetService(NS_MSGSHUTDOWNSERVICE_CONTRACTID, &rv);
+  return rv;
+}
+
+nsresult nsMsgMailSession::Shutdown()
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMailSession::AddFolderListener(nsIFolderListener *aListener,
+                                                  uint32_t aNotifyFlags)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+
+  // we don't care about the notification flags for equivalence purposes
+  size_t index = mListeners.IndexOf(aListener);
+  NS_ASSERTION(index == size_t(-1), "tried to add duplicate listener");
+  if (index == size_t(-1))
+  {
+    folderListener newListener(aListener, aNotifyFlags);
+    mListeners.AppendElement(newListener);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMailSession::RemoveFolderListener(nsIFolderListener *aListener)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+
+  mListeners.RemoveElement(aListener);
+  return NS_OK;
+}
+
+#define NOTIFY_FOLDER_LISTENERS(propertyflag_, propertyfunc_, params_) \
+  PR_BEGIN_MACRO                                                       \
+  nsTObserverArray<folderListener>::ForwardIterator iter(mListeners);  \
+  while (iter.HasMore()) {                                             \
+    const folderListener &fL = iter.GetNext();                         \
+    if (fL.mNotifyFlags & nsIFolderListener::propertyflag_)            \
+      fL.mListener->propertyfunc_ params_;                             \
+  }                                                                    \
+  PR_END_MACRO
+
+NS_IMETHODIMP
+nsMsgMailSession::OnItemPropertyChanged(nsIMsgFolder *aItem,
+                                        nsIAtom *aProperty,
+                                        const char* aOldValue,
+                                        const char* aNewValue)
+{
+  NOTIFY_FOLDER_LISTENERS(propertyChanged, OnItemPropertyChanged,
+                          (aItem, aProperty, aOldValue, aNewValue));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::OnItemUnicharPropertyChanged(nsIMsgFolder *aItem,
+                                               nsIAtom *aProperty,
+                                               const char16_t* aOldValue,
+                                               const char16_t* aNewValue)
+{
+  NOTIFY_FOLDER_LISTENERS(unicharPropertyChanged, OnItemUnicharPropertyChanged,
+                          (aItem, aProperty, aOldValue, aNewValue));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::OnItemIntPropertyChanged(nsIMsgFolder *aItem,
+                                           nsIAtom *aProperty,
+                                           int64_t aOldValue,
+                                           int64_t aNewValue)
+{
+  NOTIFY_FOLDER_LISTENERS(intPropertyChanged, OnItemIntPropertyChanged,
+                          (aItem, aProperty, aOldValue, aNewValue));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::OnItemBoolPropertyChanged(nsIMsgFolder *aItem,
+                                            nsIAtom *aProperty,
+                                            bool aOldValue,
+                                            bool aNewValue)
+{
+  NOTIFY_FOLDER_LISTENERS(boolPropertyChanged, OnItemBoolPropertyChanged,
+                          (aItem, aProperty, aOldValue, aNewValue));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::OnItemPropertyFlagChanged(nsIMsgDBHdr *aItem,
+                                            nsIAtom *aProperty,
+                                            uint32_t aOldValue,
+                                            uint32_t aNewValue)
+{
+  NOTIFY_FOLDER_LISTENERS(propertyFlagChanged, OnItemPropertyFlagChanged,
+                          (aItem, aProperty, aOldValue, aNewValue));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMailSession::OnItemAdded(nsIMsgFolder *aParentItem,
+                                            nsISupports *aItem)
+{
+  NOTIFY_FOLDER_LISTENERS(added, OnItemAdded, (aParentItem, aItem));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMailSession::OnItemRemoved(nsIMsgFolder *aParentItem,
+                                              nsISupports *aItem)
+{
+  NOTIFY_FOLDER_LISTENERS(removed, OnItemRemoved, (aParentItem, aItem));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMailSession::OnItemEvent(nsIMsgFolder *aFolder,
+                                            nsIAtom *aEvent)
+{
+  NOTIFY_FOLDER_LISTENERS(event, OnItemEvent, (aFolder, aEvent));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::AddUserFeedbackListener(nsIMsgUserFeedbackListener *aListener)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+
+  size_t index = mFeedbackListeners.IndexOf(aListener);
+  NS_ASSERTION(index == size_t(-1), "tried to add duplicate listener");
+  if (index == size_t(-1))
+    mFeedbackListeners.AppendElement(aListener);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::RemoveUserFeedbackListener(nsIMsgUserFeedbackListener *aListener)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+
+  mFeedbackListeners.RemoveElement(aListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::AlertUser(const nsAString &aMessage, nsIMsgMailNewsUrl *aUrl)
+{
+  bool listenersNotified = false;
+  nsTObserverArray<nsCOMPtr<nsIMsgUserFeedbackListener> >::ForwardIterator iter(mFeedbackListeners);
+  nsCOMPtr<nsIMsgUserFeedbackListener> listener;
+
+  while (iter.HasMore())
+  {
+    bool notified = false;
+    listener = iter.GetNext();
+    listener->OnAlert(aMessage, aUrl, &notified);
+    listenersNotified = listenersNotified || notified;
+  }
+
+  // If the listeners notified the user, then we don't need to. Also exit if
+  // aUrl is null because we won't have a nsIMsgWindow in that case.
+  if (listenersNotified || !aUrl)
+    return NS_OK;
+
+  // If the url hasn't got a message window, then the error was a generated as a
+  // result of background activity (e.g. autosync, biff, etc), and hence we
+  // shouldn't prompt either.
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+  aUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+
+  if (!msgWindow)
+    return NS_OK;
+
+  nsCOMPtr<nsIPrompt> dialog;
+  msgWindow->GetPromptDialog(getter_AddRefs(dialog));
+
+  if (!dialog) // if we didn't get one, use the default....
+  {
+    nsresult rv;
+    nsCOMPtr<nsIWindowWatcher> wwatch =
+      do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    wwatch->GetNewPrompter(0, getter_AddRefs(dialog));
+  }
+
+  if (dialog)
+    return dialog->Alert(nullptr, PromiseFlatString(aMessage).get());
+
+  return NS_OK;
+}
+
+nsresult nsMsgMailSession::GetTopmostMsgWindow(nsIMsgWindow **aMsgWindow)
+{
+  NS_ENSURE_ARG_POINTER(aMsgWindow);
+
+  *aMsgWindow = nullptr;
+
+  uint32_t count = mWindows.Count();
+
+  if (count == 1)
+  {
+    NS_ADDREF(*aMsgWindow = mWindows[0]);
+    return (*aMsgWindow) ? NS_OK : NS_ERROR_FAILURE;
+  }
+  else if (count > 1)
+  {
+    // If multiple message windows then we have lots more work.
+    nsresult rv;
+
+    // The msgWindows array does not hold z-order info. Use mediator to get
+    // the top most window then match that with the msgWindows array.
+    nsCOMPtr<nsIWindowMediator> windowMediator =
+      do_GetService(NS_WINDOWMEDIATOR_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsISimpleEnumerator> windowEnum;
+
+#if defined (XP_UNIX)
+    // The window managers under Unix/X11 do not support ZOrder information,
+    // so we have to use the normal enumeration call here.
+    rv = windowMediator->GetEnumerator(nullptr, getter_AddRefs(windowEnum));
+#else
+    rv = windowMediator->GetZOrderDOMWindowEnumerator(nullptr, true,
+                                                      getter_AddRefs(windowEnum));
+#endif
+
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsISupports> windowSupports;
+    nsCOMPtr<nsPIDOMWindowOuter> topMostWindow;
+    nsCOMPtr<nsIDOMDocument> domDocument;
+    nsCOMPtr<nsIDOMElement> domElement;
+    nsAutoString windowType;
+    bool more;
+
+    // loop to get the top most with attibute "mail:3pane" or "mail:messageWindow"
+    windowEnum->HasMoreElements(&more);
+    while (more)
+    {
+      rv = windowEnum->GetNext(getter_AddRefs(windowSupports));
+      NS_ENSURE_SUCCESS(rv, rv);
+      NS_ENSURE_TRUE(windowSupports, NS_ERROR_FAILURE);
+
+      topMostWindow = do_QueryInterface(windowSupports, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      NS_ENSURE_TRUE(topMostWindow, NS_ERROR_FAILURE);
+
+      domDocument = do_QueryInterface(topMostWindow->GetDoc());
+      NS_ENSURE_SUCCESS(rv, rv);
+      NS_ENSURE_TRUE(domDocument, NS_ERROR_FAILURE);
+
+      rv = domDocument->GetDocumentElement(getter_AddRefs(domElement));
+      NS_ENSURE_SUCCESS(rv, rv);
+      NS_ENSURE_TRUE(domElement, NS_ERROR_FAILURE);
+
+      rv = domElement->GetAttribute(NS_LITERAL_STRING("windowtype"), windowType);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (windowType.EqualsLiteral("mail:3pane") ||
+          windowType.EqualsLiteral("mail:messageWindow"))
+        break;
+
+      windowEnum->HasMoreElements(&more);
+    }
+
+    // identified the top most window
+    if (more)
+    {
+      // use this for the match
+      nsIDocShell *topDocShell = topMostWindow->GetDocShell();
+
+      // loop for the msgWindow array to find the match
+      nsCOMPtr<nsIDocShell> docShell;
+
+      while (count)
+      {
+        nsIMsgWindow *msgWindow = mWindows[--count];
+
+        rv = msgWindow->GetRootDocShell(getter_AddRefs(docShell));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        if (topDocShell == docShell)
+        {
+          NS_IF_ADDREF(*aMsgWindow = msgWindow);
+          break;
+        }
+      }
+    }
+  }
+
+  return (*aMsgWindow) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMsgMailSession::AddMsgWindow(nsIMsgWindow *msgWindow)
+{
+  NS_ENSURE_ARG_POINTER(msgWindow);
+
+  mWindows.AppendObject(msgWindow);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMailSession::RemoveMsgWindow(nsIMsgWindow *msgWindow)
+{
+  mWindows.RemoveObject(msgWindow);
+  // Mac keeps a hidden window open so the app doesn't shut down when
+  // the last window is closed. So don't shutdown the account manager in that
+  // case. Similarly, for suite, we don't want to disable mailnews when the
+  // last mail window is closed.
+#if !defined(XP_MACOSX) && !defined(MOZ_SUITE)
+  if (!mWindows.Count())
+  {
+    nsresult rv;
+    nsCOMPtr<nsIMsgAccountManager> accountManager = 
+      do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+    if (NS_FAILED(rv))
+      return rv;
+    accountManager->CleanupOnExit();
+  }
+#endif
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgMailSession::IsFolderOpenInWindow(nsIMsgFolder *folder, bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  *aResult = false;
+
+  uint32_t count = mWindows.Count();
+
+  for(uint32_t i = 0; i < count; i++)
+  {
+    nsCOMPtr<nsIMsgFolder> openFolder;
+    mWindows[i]->GetOpenFolder(getter_AddRefs(openFolder));
+    if (folder == openFolder.get())
+    {
+      *aResult = true;
+      break;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgMailSession::ConvertMsgURIToMsgURL(const char *aURI, nsIMsgWindow *aMsgWindow, char **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aURI);
+  NS_ENSURE_ARG_POINTER(aURL);
+
+  // convert the rdf msg uri into a url that represents the message...
+  nsCOMPtr <nsIMsgMessageService> msgService;
+  nsresult rv = GetMessageServiceFromURI(nsDependentCString(aURI), getter_AddRefs(msgService));
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIURI> tURI;
+  rv = msgService->GetUrlForUri(aURI, getter_AddRefs(tURI), aMsgWindow);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_NULL_POINTER);
+
+  nsAutoCString urlString;
+  if (NS_SUCCEEDED(tURI->GetSpec(urlString)))
+  {
+    *aURL = ToNewCString(urlString);
+    NS_ENSURE_ARG_POINTER(aURL);
+  }
+  return rv;
+}
+
+//----------------------------------------------------------------------------------------
+// GetSelectedLocaleDataDir - If a locale is selected, appends the selected locale to the
+//                            defaults data dir and returns that new defaults data dir
+//----------------------------------------------------------------------------------------
+nsresult
+nsMsgMailSession::GetSelectedLocaleDataDir(nsIFile *defaultsDir)
+{
+  NS_ENSURE_ARG_POINTER(defaultsDir);
+
+  bool baseDirExists = false;
+  nsresult rv = defaultsDir->Exists(&baseDirExists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (baseDirExists) {
+    nsCOMPtr<nsIXULChromeRegistry> packageRegistry =
+      mozilla::services::GetXULChromeRegistryService();
+    if (packageRegistry) {
+      nsAutoCString localeName;
+      rv = packageRegistry->GetSelectedLocale(NS_LITERAL_CSTRING("global-region"), false, localeName);
+
+      if (NS_SUCCEEDED(rv) && !localeName.IsEmpty()) {
+        bool localeDirExists = false;
+        nsCOMPtr<nsIFile> localeDataDir;
+
+        rv = defaultsDir->Clone(getter_AddRefs(localeDataDir));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        rv = localeDataDir->AppendNative(localeName);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        rv = localeDataDir->Exists(&localeDirExists);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        if (localeDirExists) {
+          // use locale provider instead
+          rv = defaultsDir->AppendNative(localeName);
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+//----------------------------------------------------------------------------------------
+// GetDataFilesDir - Gets the application's default folder and then appends the
+//                   subdirectory named passed in as param dirName. If there is a selected
+//                   locale, will append that to the dir path before returning the value
+//----------------------------------------------------------------------------------------
+NS_IMETHODIMP
+nsMsgMailSession::GetDataFilesDir(const char* dirName, nsIFile **dataFilesDir)
+{
+
+  NS_ENSURE_ARG_POINTER(dirName);
+  NS_ENSURE_ARG_POINTER(dataFilesDir);
+
+  nsresult rv;
+  nsCOMPtr<nsIProperties> directoryService =
+    do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIFile> defaultsDir;
+  rv = directoryService->Get(NS_APP_DEFAULTS_50_DIR,
+                             NS_GET_IID(nsIFile),
+                             getter_AddRefs(defaultsDir));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = defaultsDir->AppendNative(nsDependentCString(dirName));
+  if (NS_SUCCEEDED(rv))
+    rv = GetSelectedLocaleDataDir(defaultsDir);
+
+  NS_IF_ADDREF(*dataFilesDir = defaultsDir);
+
+  return rv;
+}
+
+/********************************************************************************/
+
+NS_IMPL_ISUPPORTS(nsMsgShutdownService, nsIMsgShutdownService, nsIUrlListener, nsIObserver)
+
+nsMsgShutdownService::nsMsgShutdownService()
+: mQuitMode(nsIAppStartup::eAttemptQuit),
+  mProcessedShutdown(false),
+  mQuitForced(false),
+  mReadyToQuit(false)
+{
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  if (observerService)
+  {
+    observerService->AddObserver(this, "quit-application-requested", false);
+    observerService->AddObserver(this, "quit-application-granted", false);
+    observerService->AddObserver(this, "quit-application", false);
+  }
+}
+
+nsMsgShutdownService::~nsMsgShutdownService()
+{
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  if (observerService)
+  {  
+    observerService->RemoveObserver(this, "quit-application-requested");
+    observerService->RemoveObserver(this, "quit-application-granted");
+    observerService->RemoveObserver(this, "quit-application");
+  }
+}
+
+nsresult nsMsgShutdownService::ProcessNextTask()
+{
+  bool shutdownTasksDone = true;
+
+  uint32_t count = mShutdownTasks.Length();
+  if (mTaskIndex < count)
+  {
+    shutdownTasksDone = false;
+
+    nsCOMPtr<nsIMsgShutdownTask> curTask = mShutdownTasks[mTaskIndex];
+    nsString taskName;
+    curTask->GetCurrentTaskName(taskName); 
+    SetStatusText(taskName);
+
+    nsCOMPtr<nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID);
+    NS_ENSURE_TRUE(mailSession, NS_ERROR_FAILURE);
+
+    nsCOMPtr<nsIMsgWindow> topMsgWindow;
+    mailSession->GetTopmostMsgWindow(getter_AddRefs(topMsgWindow));
+
+    bool taskIsRunning = true;
+    nsresult rv = curTask->DoShutdownTask(this, topMsgWindow, &taskIsRunning);
+    if (NS_FAILED(rv) || !taskIsRunning)
+    {
+      // We have failed, let's go on to the next task.
+      mTaskIndex++;
+      mMsgProgress->OnProgressChange(nullptr, nullptr, 0, 0, (int32_t)mTaskIndex, count);
+      ProcessNextTask();
+    }
+  }
+
+  if (shutdownTasksDone)
+  {
+    if (mMsgProgress)
+      mMsgProgress->OnStateChange(nullptr, nullptr, nsIWebProgressListener::STATE_STOP, NS_OK);
+    AttemptShutdown();
+  }
+
+  return NS_OK;
+}
+
+void nsMsgShutdownService::AttemptShutdown()
+{
+  if (mQuitForced)
+  {
+    PR_CEnterMonitor(this);
+    mReadyToQuit = true;
+    PR_CNotifyAll(this);
+    PR_CExitMonitor(this);
+  }
+  else
+  {
+    nsCOMPtr<nsIAppStartup> appStartup =
+      do_GetService(NS_APPSTARTUP_CONTRACTID);
+    NS_ENSURE_TRUE_VOID(appStartup);
+    NS_ENSURE_SUCCESS_VOID(appStartup->Quit(mQuitMode));
+  }
+}
+
+NS_IMETHODIMP nsMsgShutdownService::SetShutdownListener(nsIWebProgressListener *inListener)
+{
+  NS_ENSURE_TRUE(mMsgProgress, NS_ERROR_FAILURE);
+  mMsgProgress->RegisterListener(inListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgShutdownService::Observe(nsISupports *aSubject,
+                                            const char *aTopic,
+                                            const char16_t *aData)
+{
+  // Due to bug 459376 we don't always get quit-application-requested and
+  // quit-application-granted. quit-application-requested is preferred, but if
+  // we don't then we have to hook onto quit-application, but we don't want
+  // to do the checking twice so we set some flags to prevent that.
+  if (!strcmp(aTopic, "quit-application-granted"))
+  {
+    // Quit application has been requested and granted, therefore we will shut
+    // down. 
+    mProcessedShutdown = true;
+    return NS_OK;
+  }
+
+  // If we've already processed a shutdown notification, no need to do it again.
+  if (!strcmp(aTopic, "quit-application"))
+  {
+    if (mProcessedShutdown)
+      return NS_OK;
+    else
+      mQuitForced = true;
+  }
+
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  NS_ENSURE_STATE(observerService);
+  
+  nsCOMPtr<nsISimpleEnumerator> listenerEnum;
+  nsresult rv = observerService->EnumerateObservers("msg-shutdown", getter_AddRefs(listenerEnum));
+  if (NS_SUCCEEDED(rv) && listenerEnum)
+  {
+    bool hasMore;
+    listenerEnum->HasMoreElements(&hasMore);
+    if (!hasMore)
+      return NS_OK;
+
+    while (hasMore)
+    {
+      nsCOMPtr<nsISupports> curObject;
+      listenerEnum->GetNext(getter_AddRefs(curObject));
+      
+      nsCOMPtr<nsIMsgShutdownTask> curTask = do_QueryInterface(curObject);
+      if (curTask)
+      {
+        bool shouldRunTask;
+        curTask->GetNeedsToRunTask(&shouldRunTask);
+        if (shouldRunTask)
+          mShutdownTasks.AppendObject(curTask);
+      }
+      
+      listenerEnum->HasMoreElements(&hasMore);
+    }
+
+    if (mShutdownTasks.Count() < 1)
+      return NS_ERROR_FAILURE;
+    
+    mTaskIndex = 0;
+    
+    mMsgProgress = do_CreateInstance(NS_MSGPROGRESS_CONTRACTID);
+    NS_ENSURE_TRUE(mMsgProgress, NS_ERROR_FAILURE);
+    
+    nsCOMPtr<nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID);
+    NS_ENSURE_TRUE(mailSession, NS_ERROR_FAILURE);
+
+    nsCOMPtr<nsIMsgWindow> topMsgWindow;
+    mailSession->GetTopmostMsgWindow(getter_AddRefs(topMsgWindow));
+    
+    nsCOMPtr<mozIDOMWindowProxy> internalDomWin;
+    if (topMsgWindow)
+      topMsgWindow->GetDomWindow(getter_AddRefs(internalDomWin));
+    
+    if (!internalDomWin)
+    {
+      // First see if there is a window open. 
+      nsCOMPtr<nsIWindowMediator> winMed = do_GetService(NS_WINDOWMEDIATOR_CONTRACTID);
+      winMed->GetMostRecentWindow(nullptr, getter_AddRefs(internalDomWin));
+      
+      //If not use the hidden window.
+      if (!internalDomWin)
+      {
+        nsCOMPtr<nsIAppShellService> appShell(do_GetService(NS_APPSHELLSERVICE_CONTRACTID));
+        appShell->GetHiddenDOMWindow(getter_AddRefs(internalDomWin));
+        NS_ENSURE_TRUE(internalDomWin, NS_ERROR_FAILURE);  // bail if we don't get a window.
+      }
+    }
+
+    if (!mQuitForced)
+    {
+      nsCOMPtr<nsISupportsPRBool> stopShutdown = do_QueryInterface(aSubject);
+      stopShutdown->SetData(true);
+
+      // If the attempted quit was a restart, be sure to restart the app once
+      // the tasks have been run. This is usually the case when addons or
+      // updates are going to be installed.
+      if (aData && nsDependentString(aData).EqualsLiteral("restart"))
+        mQuitMode |= nsIAppStartup::eRestart;
+    }
+
+    mMsgProgress->OpenProgressDialog(internalDomWin, topMsgWindow, 
+                                     "chrome://messenger/content/shutdownWindow.xul", 
+                                     false, nullptr);
+
+    if (mQuitForced)
+    {
+      nsCOMPtr<nsIThread> thread(do_GetCurrentThread());
+
+      mReadyToQuit = false;
+      while (!mReadyToQuit)
+      {
+        PR_CEnterMonitor(this);
+        // Waiting for 50 milliseconds
+        PR_CWait(this, PR_MicrosecondsToInterval(50000UL));
+        PR_CExitMonitor(this);
+        NS_ProcessPendingEvents(thread);
+      }
+    }
+  }
+  
+  return NS_OK;
+}
+
+// nsIUrlListener
+NS_IMETHODIMP nsMsgShutdownService::OnStartRunningUrl(nsIURI *url)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgShutdownService::OnStopRunningUrl(nsIURI *url, nsresult aExitCode)
+{
+  mTaskIndex++;
+
+  if (mMsgProgress)
+  {
+    int32_t numTasks = mShutdownTasks.Count();
+    mMsgProgress->OnProgressChange(nullptr, nullptr, 0, 0, (int32_t)mTaskIndex, numTasks);
+  }
+
+  ProcessNextTask();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgShutdownService::GetNumTasks(int32_t *inNumTasks)
+{
+  *inNumTasks = mShutdownTasks.Count();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgShutdownService::StartShutdownTasks()
+{
+  ProcessNextTask();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgShutdownService::CancelShutdownTasks()
+{
+  AttemptShutdown();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgShutdownService::SetStatusText(const nsAString & inStatusString)
+{
+  nsString statusString(inStatusString);
+  if (mMsgProgress)
+    mMsgProgress->OnStatusChange(nullptr, nullptr, NS_OK, nsString(statusString).get());
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMsgMailSession.h b/mailnews/base/src/nsMsgMailSession.h
new file mode 100644
index 000000000..6e4f57411
--- /dev/null
+++ b/mailnews/base/src/nsMsgMailSession.h
@@ -0,0 +1,106 @@
+/* -*- 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 nsMsgMailSession_h___
+#define nsMsgMailSession_h___
+
+#include "nsIMsgMailSession.h"
+#include "nsISupports.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsIMsgWindow.h"
+#include "nsCOMArray.h"
+#include "nsIMsgShutdown.h"
+#include "nsIObserver.h"
+#include "nsIMutableArray.h"
+#include "nsIMsgProgress.h"
+#include "nsTArray.h"
+#include "nsTObserverArray.h"
+#include "nsIMsgUserFeedbackListener.h"
+#include "nsIUrlListener.h"
+
+///////////////////////////////////////////////////////////////////////////////////
+// The mail session is a replacement for the old 4.x MSG_Master object. It contains
+// mail session generic information such as the user's current mail identity, ....
+// I'm starting this off as an empty interface and as people feel they need to
+// add more information to it, they can. I think this is a better approach than 
+// trying to port over the old MSG_Master in its entirety as that had a lot of 
+// cruft in it....
+//////////////////////////////////////////////////////////////////////////////////
+
+class nsMsgMailSession : public nsIMsgMailSession,
+                         public nsIFolderListener
+{
+public:
+  nsMsgMailSession();
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIMSGMAILSESSION
+  NS_DECL_NSIFOLDERLISTENER
+
+  nsresult Init();
+  nsresult GetSelectedLocaleDataDir(nsIFile *defaultsDir);
+
+protected:
+  virtual ~nsMsgMailSession();
+
+  struct folderListener {
+    nsCOMPtr<nsIFolderListener> mListener;
+    uint32_t mNotifyFlags;
+
+    folderListener(nsIFolderListener *aListener, uint32_t aNotifyFlags)
+      : mListener(aListener), mNotifyFlags(aNotifyFlags) {}
+    folderListener(const folderListener &aListener)
+      : mListener(aListener.mListener), mNotifyFlags(aListener.mNotifyFlags) {}
+    ~folderListener() {}
+
+    int operator==(nsIFolderListener* aListener) const {
+      return mListener == aListener;
+    }
+    int operator==(const folderListener &aListener) const {
+      return mListener == aListener.mListener &&
+             mNotifyFlags == aListener.mNotifyFlags;
+    }
+  };
+
+  nsTObserverArray<folderListener> mListeners;
+  nsTObserverArray<nsCOMPtr<nsIMsgUserFeedbackListener> > mFeedbackListeners;
+
+  nsCOMArray<nsIMsgWindow> mWindows;
+  // stick this here temporarily
+  nsCOMPtr <nsIMsgWindow> m_temporaryMsgWindow;
+};
+
+/********************************************************************************/
+
+class nsMsgShutdownService : public nsIMsgShutdownService,
+                             public nsIUrlListener,
+                             public nsIObserver
+{
+public:
+  nsMsgShutdownService();
+  
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGSHUTDOWNSERVICE
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSIOBSERVER
+    
+protected:
+  nsresult ProcessNextTask();
+  void AttemptShutdown();
+  
+private:
+  virtual ~nsMsgShutdownService();
+
+  nsCOMArray<nsIMsgShutdownTask> mShutdownTasks;
+  nsCOMPtr<nsIMsgProgress>       mMsgProgress;
+  uint32_t                       mTaskIndex;
+  uint32_t                       mQuitMode;
+  bool mProcessedShutdown;
+  bool mQuitForced;
+  bool mReadyToQuit;
+};
+
+#endif /* nsMsgMailSession_h__ */
diff --git a/mailnews/base/src/nsMsgOfflineManager.cpp b/mailnews/base/src/nsMsgOfflineManager.cpp
new file mode 100644
index 000000000..be1fac4cb
--- /dev/null
+++ b/mailnews/base/src/nsMsgOfflineManager.cpp
@@ -0,0 +1,399 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * The offline manager service - manages going online and offline, and synchronization
+ */
+#include "msgCore.h"
+#include "netCore.h"
+#include "nsMsgOfflineManager.h"
+#include "nsIServiceManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsIImapService.h"
+#include "nsMsgImapCID.h"
+#include "nsIMsgSendLater.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgCompCID.h"
+#include "nsIIOService.h"
+#include "nsNetCID.h"
+#include "nsMsgNewsCID.h"
+#include "nsINntpService.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Services.h"
+#include "nsIArray.h"
+#include "nsArrayUtils.h"
+
+static NS_DEFINE_CID(kMsgSendLaterCID, NS_MSGSENDLATER_CID);
+
+NS_IMPL_ISUPPORTS(nsMsgOfflineManager,
+                              nsIMsgOfflineManager,
+                              nsIMsgSendLaterListener,
+                              nsIObserver,
+                              nsISupportsWeakReference,
+                              nsIUrlListener)
+
+nsMsgOfflineManager::nsMsgOfflineManager() :
+  m_inProgress (false),
+  m_sendUnsentMessages(false),
+  m_downloadNews(false),
+  m_downloadMail(false),
+  m_playbackOfflineImapOps(false),
+  m_goOfflineWhenDone(false),
+  m_curState(eNoState),
+  m_curOperation(eNoOp)
+{
+}
+
+nsMsgOfflineManager::~nsMsgOfflineManager()
+{
+}
+
+/* attribute nsIMsgWindow window; */
+NS_IMETHODIMP nsMsgOfflineManager::GetWindow(nsIMsgWindow * *aWindow)
+{
+  NS_ENSURE_ARG(aWindow);
+  *aWindow = m_window;
+  NS_IF_ADDREF(*aWindow);
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgOfflineManager::SetWindow(nsIMsgWindow * aWindow)
+{
+  m_window = aWindow;
+  if (m_window)
+    m_window->GetStatusFeedback(getter_AddRefs(m_statusFeedback));
+  else
+    m_statusFeedback = nullptr;
+  return NS_OK;
+}
+
+/* attribute boolean inProgress; */
+NS_IMETHODIMP nsMsgOfflineManager::GetInProgress(bool *aInProgress)
+{
+  NS_ENSURE_ARG(aInProgress);
+  *aInProgress = m_inProgress;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgOfflineManager::SetInProgress(bool aInProgress)
+{
+  m_inProgress = aInProgress;
+  return NS_OK;
+}
+
+nsresult nsMsgOfflineManager::StopRunning(nsresult exitStatus)
+{
+  m_inProgress = false;
+  return exitStatus;
+}
+
+nsresult nsMsgOfflineManager::AdvanceToNextState(nsresult exitStatus)
+{
+  // NS_BINDING_ABORTED is used for the user pressing stop, which
+  // should cause us to abort the offline process. Other errors
+  // should allow us to continue.
+  if (exitStatus == NS_BINDING_ABORTED)
+  {
+    return StopRunning(exitStatus);
+  }
+  if (m_curOperation == eGoingOnline)
+  {
+    switch (m_curState)
+    {
+    case eNoState:
+
+      m_curState = eSendingUnsent;
+      if (m_sendUnsentMessages)
+      {
+        SendUnsentMessages();
+      }
+      else
+        AdvanceToNextState(NS_OK);
+      break;
+    case eSendingUnsent:
+
+      m_curState = eSynchronizingOfflineImapChanges;
+      if (m_playbackOfflineImapOps)
+        return SynchronizeOfflineImapChanges();
+      else
+        AdvanceToNextState(NS_OK); // recurse to next state.
+      break;
+    case eSynchronizingOfflineImapChanges:
+      m_curState = eDone;
+      return StopRunning(exitStatus);
+      default:
+        NS_ASSERTION(false, "unhandled current state when going online");
+    }
+  }
+  else if (m_curOperation == eDownloadingForOffline)
+  {
+    switch (m_curState)
+    {
+      case eNoState:
+        m_curState = eDownloadingNews;
+        if (m_downloadNews)
+          DownloadOfflineNewsgroups();
+        else
+          AdvanceToNextState(NS_OK);
+        break;
+      case eSendingUnsent:
+        if (m_goOfflineWhenDone)
+        {
+          SetOnlineState(false);
+        }
+        break;
+      case eDownloadingNews:
+        m_curState = eDownloadingMail;
+        if (m_downloadMail)
+          DownloadMail();
+        else
+          AdvanceToNextState(NS_OK);
+        break;
+      case eDownloadingMail:
+        m_curState = eSendingUnsent;
+        if (m_sendUnsentMessages)
+          SendUnsentMessages();
+        else
+          AdvanceToNextState(NS_OK);
+        break;
+      default:
+        NS_ASSERTION(false, "unhandled current state when downloading for offline");
+    }
+
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgOfflineManager::SynchronizeOfflineImapChanges()
+{
+  nsresult rv = NS_OK;
+	nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return imapService->PlaybackAllOfflineOperations(m_window, this, getter_AddRefs(mOfflineImapSync));
+}
+
+nsresult nsMsgOfflineManager::SendUnsentMessages()
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgSendLater> pMsgSendLater(do_GetService(kMsgSendLaterCID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgAccountManager> accountManager = 
+           do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // now we have to iterate over the identities, finding the *unique* unsent messages folder
+  // for each one, determine if they have unsent messages, and if so, add them to the list
+  // of identities to send unsent messages from.
+  // However, I think there's only ever one unsent messages folder at the moment,
+  // so I think we'll go with that for now.
+  nsCOMPtr<nsIArray> identities;
+
+  if (NS_SUCCEEDED(rv) && accountManager)
+  {
+    rv = accountManager->GetAllIdentities(getter_AddRefs(identities));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  nsCOMPtr <nsIMsgIdentity> identityToUse;
+  uint32_t numIndentities;
+  identities->GetLength(&numIndentities);
+  for (uint32_t i = 0; i < numIndentities; i++)
+  {
+    nsCOMPtr<nsIMsgIdentity> thisIdentity(do_QueryElementAt(identities, i, &rv));
+    if (NS_SUCCEEDED(rv) && thisIdentity)
+    {
+      nsCOMPtr <nsIMsgFolder> outboxFolder;
+      pMsgSendLater->GetUnsentMessagesFolder(thisIdentity, getter_AddRefs(outboxFolder));
+      if (outboxFolder)
+      {
+        int32_t numMessages;
+        outboxFolder->GetTotalMessages(false, &numMessages);
+        if (numMessages > 0)
+        {
+          identityToUse = thisIdentity;
+          break;
+        }
+      }
+    }
+  }
+  if (identityToUse) 
+  { 
+#ifdef MOZ_SUITE
+    if (m_statusFeedback)
+      pMsgSendLater->SetStatusFeedback(m_statusFeedback);
+#endif
+
+    pMsgSendLater->AddListener(this);
+    rv = pMsgSendLater->SendUnsentMessages(identityToUse);
+    ShowStatus("sendingUnsent");
+    // if we succeeded, return - we'll run the next operation when the
+    // send finishes. Otherwise, advance to the next state.
+    if (NS_SUCCEEDED(rv))
+      return rv;
+  } 
+  return AdvanceToNextState(rv);
+
+}
+
+#define MESSENGER_STRING_URL       "chrome://messenger/locale/messenger.properties"
+
+nsresult nsMsgOfflineManager::ShowStatus(const char *statusMsgName)
+{
+  if (!mStringBundle)
+  {
+    nsCOMPtr<nsIStringBundleService> sBundleService = 
+      mozilla::services::GetStringBundleService();
+    NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED);
+    sBundleService->CreateBundle(MESSENGER_STRING_URL, getter_AddRefs(mStringBundle));
+    return NS_OK;
+  }
+
+  nsString statusString;
+  nsresult res = mStringBundle->GetStringFromName(NS_ConvertASCIItoUTF16(statusMsgName).get(),
+						  getter_Copies(statusString));
+
+  if (NS_SUCCEEDED(res) && m_statusFeedback)
+    m_statusFeedback->ShowStatusString(statusString);
+
+  return res;
+}
+
+nsresult nsMsgOfflineManager::DownloadOfflineNewsgroups()
+{
+	nsresult rv;
+  ShowStatus("downloadingNewsgroups");
+  nsCOMPtr<nsINntpService> nntpService(do_GetService(NS_NNTPSERVICE_CONTRACTID, &rv));
+  if (NS_SUCCEEDED(rv) && nntpService)
+    rv = nntpService->DownloadNewsgroupsForOffline(m_window, this);
+
+  if (NS_FAILED(rv))
+    return AdvanceToNextState(rv);
+  return rv;
+}
+
+nsresult nsMsgOfflineManager::DownloadMail()
+{
+  nsresult rv = NS_OK;
+  ShowStatus("downloadingMail");
+	nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return imapService->DownloadAllOffineImapFolders(m_window, this);
+  // ### we should do get new mail on pop servers, and download imap messages for offline use.
+}
+
+/* void goOnline (in boolean sendUnsentMessages, in boolean playbackOfflineImapOperations, in nsIMsgWindow aMsgWindow); */
+NS_IMETHODIMP nsMsgOfflineManager::GoOnline(bool sendUnsentMessages, bool playbackOfflineImapOperations, nsIMsgWindow *aMsgWindow)
+{
+  m_sendUnsentMessages = sendUnsentMessages;
+  m_playbackOfflineImapOps = playbackOfflineImapOperations;
+  m_curOperation = eGoingOnline;
+  m_curState = eNoState;
+  SetWindow(aMsgWindow);
+  SetOnlineState(true);
+  if (!m_sendUnsentMessages && !playbackOfflineImapOperations)
+    return NS_OK;
+  else
+    AdvanceToNextState(NS_OK);
+  return NS_OK;
+}
+
+/* void synchronizeForOffline (in boolean downloadNews, in boolean downloadMail, in boolean sendUnsentMessages, in boolean goOfflineWhenDone, in nsIMsgWindow aMsgWindow); */
+NS_IMETHODIMP nsMsgOfflineManager::SynchronizeForOffline(bool downloadNews, bool downloadMail, bool sendUnsentMessages, bool goOfflineWhenDone, nsIMsgWindow *aMsgWindow)
+{
+  m_curOperation = eDownloadingForOffline;
+  m_downloadNews = downloadNews;
+  m_downloadMail = downloadMail;
+  m_sendUnsentMessages = sendUnsentMessages;
+  SetWindow(aMsgWindow);
+  m_goOfflineWhenDone = goOfflineWhenDone;
+  m_curState = eNoState;
+  if (!downloadNews && !downloadMail && !sendUnsentMessages)
+  {
+    if (goOfflineWhenDone)
+      return SetOnlineState(false);
+  }
+  else
+    return AdvanceToNextState(NS_OK);
+  return NS_OK;
+}
+
+nsresult nsMsgOfflineManager::SetOnlineState(bool online)
+{
+  nsCOMPtr<nsIIOService> netService =
+    mozilla::services::GetIOService();
+  NS_ENSURE_TRUE(netService, NS_ERROR_UNEXPECTED);
+  return netService->SetOffline(!online);
+}
+
+  // nsIUrlListener methods
+
+NS_IMETHODIMP
+nsMsgOfflineManager::OnStartRunningUrl(nsIURI * aUrl)
+{
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgOfflineManager::OnStopRunningUrl(nsIURI * aUrl, nsresult aExitCode)
+{
+  mOfflineImapSync = nullptr;
+
+  AdvanceToNextState(aExitCode);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgOfflineManager::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *someData)
+{
+  return NS_OK;
+}
+
+// nsIMsgSendLaterListener implementation 
+NS_IMETHODIMP
+nsMsgOfflineManager::OnStartSending(uint32_t aTotalMessageCount)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgOfflineManager::OnMessageStartSending(uint32_t aCurrentMessage,
+                                           uint32_t aTotalMessageCount,
+                                           nsIMsgDBHdr *aMessageHeader,
+                                           nsIMsgIdentity *aIdentity)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgOfflineManager::OnMessageSendProgress(uint32_t aCurrentMessage,
+                                           uint32_t aTotalMessageCount,
+                                           uint32_t aMessageSendPercent,
+                                           uint32_t aMessageCopyPercent)
+{
+  if (m_statusFeedback && aTotalMessageCount)
+    return m_statusFeedback->ShowProgress((100 * aCurrentMessage) /
+                                          aTotalMessageCount);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgOfflineManager::OnMessageSendError(uint32_t aCurrentMessage,
+                                        nsIMsgDBHdr *aMessageHeader,
+                                        nsresult aStatus,
+                                        const char16_t *aMsg)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgOfflineManager::OnStopSending(nsresult aStatus,
+                                   const char16_t *aMsg, uint32_t aTotalTried, 
+                                   uint32_t aSuccessful)
+{
+#ifdef NS_DEBUG
+  if (NS_SUCCEEDED(aStatus))
+    printf("SendLaterListener::OnStopSending: Tried to send %d messages. %d successful.\n",
+            aTotalTried, aSuccessful);
+#endif
+  return AdvanceToNextState(aStatus);
+}
diff --git a/mailnews/base/src/nsMsgOfflineManager.h b/mailnews/base/src/nsMsgOfflineManager.h
new file mode 100644
index 000000000..07e6b347a
--- /dev/null
+++ b/mailnews/base/src/nsMsgOfflineManager.h
@@ -0,0 +1,85 @@
+/* -*- 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 nsMsgOfflineManager_h__
+#define nsMsgOfflineManager_h__
+
+#include "nscore.h"
+#include "nsIMsgOfflineManager.h"
+#include "nsCOMPtr.h"
+#include "nsIObserver.h"
+#include "nsWeakReference.h"
+#include "nsIUrlListener.h"
+#include "nsIMsgWindow.h"
+#include "nsIMsgSendLaterListener.h"
+#include "nsIStringBundle.h"
+
+class nsMsgOfflineManager
+	: public nsIMsgOfflineManager,
+      public nsIObserver,
+      public nsSupportsWeakReference,
+      public nsIMsgSendLaterListener,
+    public nsIUrlListener
+{
+public:
+
+  nsMsgOfflineManager();
+  
+  NS_DECL_THREADSAFE_ISUPPORTS
+ 
+  /* nsIMsgOfflineManager methods */
+  
+  NS_DECL_NSIMSGOFFLINEMANAGER
+  NS_DECL_NSIOBSERVER  
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSIMSGSENDLATERLISTENER
+
+  typedef enum 
+  {
+    eStarting = 0,
+	  eSynchronizingOfflineImapChanges = 1,
+    eDownloadingNews = 2,
+    eDownloadingMail = 3,
+	  eSendingUnsent = 4,
+    eDone = 5,
+    eNoState = 6  // we're not doing anything
+  } offlineManagerState;
+
+  typedef enum 
+  {
+    eGoingOnline = 0,
+    eDownloadingForOffline = 1,
+    eNoOp = 2 // no operation in progress
+  } offlineManagerOperation;
+
+private:
+  virtual ~nsMsgOfflineManager();
+
+  nsresult AdvanceToNextState(nsresult exitStatus);
+  nsresult SynchronizeOfflineImapChanges();
+  nsresult StopRunning(nsresult exitStatus);
+  nsresult SendUnsentMessages();
+  nsresult DownloadOfflineNewsgroups();
+  nsresult DownloadMail();
+
+  nsresult SetOnlineState(bool online);
+  nsresult ShowStatus(const char *statusMsgName);
+
+  bool m_inProgress;
+  bool m_sendUnsentMessages;
+  bool m_downloadNews;
+  bool m_downloadMail;
+  bool m_playbackOfflineImapOps;
+  bool m_goOfflineWhenDone;
+  offlineManagerState m_curState;
+  offlineManagerOperation m_curOperation;
+  nsCOMPtr <nsIMsgWindow> m_window;
+  nsCOMPtr <nsIMsgStatusFeedback> m_statusFeedback;
+  nsCOMPtr<nsIStringBundle>   mStringBundle;
+  nsCOMPtr<nsISupports> mOfflineImapSync;
+
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgPrintEngine.cpp b/mailnews/base/src/nsMsgPrintEngine.cpp
new file mode 100644
index 000000000..d2f8157ed
--- /dev/null
+++ b/mailnews/base/src/nsMsgPrintEngine.cpp
@@ -0,0 +1,741 @@
+/* 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/. */
+
+/**
+ * nsMsgPrintEngine.cpp provides a DocShell container for use in printing.
+ */
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+
+#include "nsIComponentManager.h"
+
+#include "nsISupports.h"
+
+#include "nsIURI.h"
+
+#include "nsPIDOMWindow.h"
+#include "mozIDOMWindow.h"
+#include "nsIContentViewer.h"
+#include "nsIMsgMessageService.h"
+#include "nsMsgUtils.h"
+#include "nsIWebProgress.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsMsgPrintEngine.h"
+#include "nsIDocumentLoader.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsThreadUtils.h"
+#include "nsAutoPtr.h"
+#include "mozilla/Services.h"
+
+// Interfaces Needed
+#include "nsIBaseWindow.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIWebNavigation.h"
+#include "nsIChannel.h"
+#include "nsIContentViewerFile.h"
+#include "nsServiceManagerUtils.h"
+
+static const char* kPrintingPromptService = "@mozilla.org/embedcomp/printingprompt-service;1";
+
+/////////////////////////////////////////////////////////////////////////
+// nsMsgPrintEngine implementation
+/////////////////////////////////////////////////////////////////////////
+
+nsMsgPrintEngine::nsMsgPrintEngine() :
+  mIsDoingPrintPreview(false),
+  mMsgInx(nsIMsgPrintEngine::MNAB_START)
+{
+  mCurrentlyPrintingURI = -1;
+}
+
+
+nsMsgPrintEngine::~nsMsgPrintEngine()
+{
+}
+
+// Implement AddRef and Release
+NS_IMPL_ISUPPORTS(nsMsgPrintEngine,
+                         nsIMsgPrintEngine, 
+                         nsIWebProgressListener, 
+                         nsIObserver,
+                         nsISupportsWeakReference)
+
+// nsIWebProgressListener implementation
+NS_IMETHODIMP
+nsMsgPrintEngine::OnStateChange(nsIWebProgress* aWebProgress, 
+                   nsIRequest *aRequest, 
+                   uint32_t progressStateFlags, 
+                   nsresult aStatus)
+{
+  nsresult rv = NS_OK;
+
+  // top-level document load data
+  if (progressStateFlags & nsIWebProgressListener::STATE_IS_DOCUMENT) {
+    if (progressStateFlags & nsIWebProgressListener::STATE_START) {
+      // Tell the user we are loading...
+      nsString msg;
+      GetString(u"LoadingMessageToPrint", msg);
+      SetStatusMessage(msg);
+    }
+
+    if (progressStateFlags & nsIWebProgressListener::STATE_STOP) {
+      nsCOMPtr<nsIDocumentLoader> docLoader(do_QueryInterface(aWebProgress));
+      if (docLoader) 
+      {
+        // Check to see if the document DOMWin that is finished loading is the same
+        // one as the mail msg that we started to load.
+        // We only want to print when the entire msg and all of its attachments
+        // have finished loading.
+        // The mail msg doc is the last one to receive the STATE_STOP notification
+        nsCOMPtr<nsISupports> container;
+        docLoader->GetContainer(getter_AddRefs(container));
+        nsCOMPtr<mozIDOMWindowProxy> domWindow(do_GetInterface(container));
+        if (domWindow.get() != mMsgDOMWin.get()) {
+          return NS_OK;
+        }
+      }
+      nsCOMPtr<nsIWebProgressListener> wpl(do_QueryInterface(mPrintPromptService));
+      if (wpl) {
+        wpl->OnStateChange(nullptr, nullptr, nsIWebProgressListener::STATE_STOP|nsIWebProgressListener::STATE_IS_DOCUMENT, NS_OK);
+        mPrintProgressListener = nullptr;
+        mPrintProgress         = nullptr;
+        mPrintProgressParams   = nullptr;
+      }
+
+      bool isPrintingCancelled = false;
+      if (mPrintSettings)
+      {
+        mPrintSettings->GetIsCancelled(&isPrintingCancelled);
+      }
+      if (!isPrintingCancelled) {
+        // if aWebProgress is a documentloader than the notification from
+        // loading the documents. If it is NULL (or not a DocLoader) then it 
+        // it coming from Printing
+        if (docLoader) {
+          // Now, fire off the print operation!
+          rv = NS_ERROR_FAILURE;
+
+          // Tell the user the message is loaded...
+          nsString msg;
+          GetString(u"MessageLoaded", msg);
+          SetStatusMessage(msg);
+
+          NS_ASSERTION(mDocShell,"can't print, there is no docshell");
+          if ( (!mDocShell) || (!aRequest) ) 
+          {
+            return StartNextPrintOperation();
+          }
+          nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(aRequest);
+          if (!aChannel) return NS_ERROR_FAILURE;
+
+          // Make sure this isn't just "about:blank" finishing....
+          nsCOMPtr<nsIURI> originalURI = nullptr;
+          if (NS_SUCCEEDED(aChannel->GetOriginalURI(getter_AddRefs(originalURI))) && originalURI)
+          {
+            nsAutoCString spec;
+
+            if (NS_SUCCEEDED(originalURI->GetSpec(spec)))
+            {      
+              if (spec.Equals("about:blank"))
+              {
+                return StartNextPrintOperation();
+              }
+            }
+          }
+
+          // If something bad happens here (menaing we can fire the PLEvent, highly unlikely)
+          // we will still ask the msg to print, but if the user "cancels" out of the 
+          // print dialog the hidden print window will not be "closed"
+          if (!FirePrintEvent()) 
+          {
+            PrintMsgWindow();
+          }
+        } else {
+          FireStartNextEvent();
+          rv = NS_OK;
+        }
+      } 
+      else 
+      {
+        if (mWindow) {
+          nsPIDOMWindowOuter::From(mWindow)->Close();
+        }
+      }
+    }
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgPrintEngine::OnProgressChange(nsIWebProgress *aWebProgress,
+                                     nsIRequest *aRequest,
+                                     int32_t aCurSelfProgress,
+                                     int32_t aMaxSelfProgress,
+                                     int32_t aCurTotalProgress,
+                                     int32_t aMaxTotalProgress)
+{
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgPrintEngine::OnLocationChange(nsIWebProgress* aWebProgress,
+                      nsIRequest* aRequest,
+                      nsIURI *location,
+                      uint32_t aFlags)
+{
+    NS_NOTREACHED("notification excluded in AddProgressListener(...)");
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgPrintEngine::OnStatusChange(nsIWebProgress* aWebProgress,
+                    nsIRequest* aRequest,
+                    nsresult aStatus,
+                    const char16_t* aMessage)
+{
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgPrintEngine::OnSecurityChange(nsIWebProgress *aWebProgress, 
+                      nsIRequest *aRequest, 
+                      uint32_t state)
+{
+    NS_NOTREACHED("notification excluded in AddProgressListener(...)");
+    return NS_OK;
+}
+
+NS_IMETHODIMP    
+nsMsgPrintEngine::SetWindow(mozIDOMWindowProxy *aWin)
+{
+  if (!aWin)
+  {
+    // It isn't an error to pass in null for aWin, in fact it means we are shutting
+    // down and we should start cleaning things up...
+    return NS_OK;
+  }
+
+  mWindow = aWin;
+
+  NS_ENSURE_TRUE(mWindow, NS_ERROR_FAILURE);
+  nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(mWindow);
+
+  window->GetDocShell()->SetAppType(nsIDocShell::APP_TYPE_MAIL);
+
+  nsCOMPtr<nsIDocShellTreeItem> docShellAsItem =
+    do_QueryInterface(window->GetDocShell());
+  NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIDocShellTreeItem> rootAsItem;
+  docShellAsItem->GetSameTypeRootTreeItem(getter_AddRefs(rootAsItem));
+
+  nsCOMPtr<nsIDocShellTreeItem> childItem;
+  rootAsItem->FindChildWithName(NS_LITERAL_STRING("content"), true,
+				false, nullptr, nullptr,
+				getter_AddRefs(childItem));
+
+  mDocShell = do_QueryInterface(childItem);
+
+  if(mDocShell)
+    SetupObserver();
+
+  return NS_OK;
+}
+
+/* void setParentWindow (in mozIDOMWindowProxy ptr); */
+NS_IMETHODIMP nsMsgPrintEngine::SetParentWindow(mozIDOMWindowProxy *ptr)
+{
+  mParentWindow = ptr;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgPrintEngine::ShowWindow(bool aShow)
+{
+  nsresult rv;
+
+  NS_ENSURE_TRUE(mWindow, NS_ERROR_NOT_INITIALIZED);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(mWindow);
+  nsCOMPtr <nsIDocShellTreeItem> treeItem =
+    do_QueryInterface(window->GetDocShell(), &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr <nsIDocShellTreeOwner> treeOwner;
+  rv = treeItem->GetTreeOwner(getter_AddRefs(treeOwner));
+  NS_ENSURE_SUCCESS(rv,rv);
+  
+  if (treeOwner) {
+    // disable (enable) the window
+    nsCOMPtr<nsIBaseWindow> baseWindow;
+    baseWindow = do_QueryInterface(treeOwner, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = baseWindow->SetEnabled(aShow);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    // hide or show the window
+    baseWindow->SetVisibility(aShow);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgPrintEngine::AddPrintURI(const char16_t *aMsgURI)
+{
+  NS_ENSURE_ARG_POINTER(aMsgURI);
+
+  mURIArray.AppendElement(nsDependentString(aMsgURI));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgPrintEngine::SetPrintURICount(int32_t aCount)
+{
+  mURICount = aCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgPrintEngine::StartPrintOperation(nsIPrintSettings* aPS)
+{
+  NS_ENSURE_ARG_POINTER(aPS);
+  mPrintSettings = aPS;
+
+  // Load the about:blank on the tail end...
+  nsresult rv = AddPrintURI(u"about:blank"); 
+  if (NS_FAILED(rv)) return rv; 
+  return StartNextPrintOperation();
+}
+
+//----------------------------------------------------------------------
+// Set up to use the "pluggable" Print Progress Dialog
+nsresult
+nsMsgPrintEngine::ShowProgressDialog(bool aIsForPrinting, bool& aDoNotify)
+{
+  nsresult rv;
+
+  // default to not notifying, that if something here goes wrong
+  // or we aren't going to show the progress dialog we can straight into 
+  // reflowing the doc for printing.
+  aDoNotify = false;
+
+  // Assume we can't do progress and then see if we can
+  bool showProgressDialog = false;
+
+  // if it is already being shown then don't bother to find out if it should be
+  // so skip this and leave mShowProgressDialog set to FALSE
+  nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv)) 
+  {
+    prefBranch->GetBoolPref("print.show_print_progress", &showProgressDialog);
+  }
+
+  // Turning off the showing of Print Progress in Prefs overrides
+  // whether the calling PS desire to have it on or off, so only check PS if 
+  // prefs says it's ok to be on.
+  if (showProgressDialog) 
+  {
+    mPrintSettings->GetShowPrintProgress(&showProgressDialog);
+  }
+
+  // Now open the service to get the progress dialog
+  // If we don't get a service, that's ok, then just don't show progress
+  if (showProgressDialog) {
+    if (!mPrintPromptService) 
+    {
+      mPrintPromptService = do_GetService(kPrintingPromptService);
+    }
+    if (mPrintPromptService) 
+    {
+      nsCOMPtr<mozIDOMWindowProxy> domWin(do_QueryInterface(mParentWindow));
+      if (!domWin) 
+      {
+        domWin = mWindow;
+      }
+
+      rv = mPrintPromptService->ShowProgress(domWin, mWebBrowserPrint, mPrintSettings, this, aIsForPrinting,
+                                            getter_AddRefs(mPrintProgressListener), 
+                                            getter_AddRefs(mPrintProgressParams), 
+                                            &aDoNotify);
+      if (NS_SUCCEEDED(rv)) {
+
+        showProgressDialog = mPrintProgressListener != nullptr && mPrintProgressParams != nullptr;
+
+        if (showProgressDialog) 
+        {
+          nsIWebProgressListener* wpl = static_cast<nsIWebProgressListener*>(mPrintProgressListener.get());
+          NS_ASSERTION(wpl, "nsIWebProgressListener is NULL!");
+          NS_ADDREF(wpl);
+          nsString msg;
+          if (mIsDoingPrintPreview) {
+            GetString(u"LoadingMailMsgForPrintPreview", msg);
+          } else {
+            GetString(u"LoadingMailMsgForPrint", msg);
+          }
+          if (!msg.IsEmpty()) 
+            mPrintProgressParams->SetDocTitle(msg.get());
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+
+NS_IMETHODIMP
+nsMsgPrintEngine::StartNextPrintOperation()
+{
+  nsresult      rv;
+
+  // Only do this the first time through...
+  if (mCurrentlyPrintingURI == -1)
+    InitializeDisplayCharset();
+
+  mCurrentlyPrintingURI++;
+
+  // First, check if we are at the end of this stuff!
+  if (mCurrentlyPrintingURI >= (int32_t)mURIArray.Length())
+  {
+    // This is the end...dum, dum, dum....my only friend...the end
+    NS_ENSURE_TRUE(mWindow, NS_ERROR_FAILURE);
+    nsPIDOMWindowOuter::From(mWindow)->Close();
+
+    // Tell the user we are done...
+    nsString msg;
+    GetString(u"PrintingComplete", msg);
+    SetStatusMessage(msg);
+    return NS_OK;
+  }
+
+  if (!mDocShell)
+    return StartNextPrintOperation();
+
+  const nsString &uri = mURIArray[mCurrentlyPrintingURI];
+  rv = FireThatLoadOperationStartup(uri);
+  if (NS_FAILED(rv))
+    return StartNextPrintOperation();
+  else
+    return rv;
+}
+
+NS_IMETHODIMP    
+nsMsgPrintEngine::SetStatusFeedback(nsIMsgStatusFeedback *aFeedback)
+{
+	mFeedback = aFeedback;
+	return NS_OK;
+}
+
+#define DATA_URL_PREFIX     "data:"
+#define ADDBOOK_URL_PREFIX     "addbook:"
+
+nsresult
+nsMsgPrintEngine::FireThatLoadOperationStartup(const nsString& uri)
+{
+  if (!uri.IsEmpty()) 
+    mLoadURI = uri;
+  else
+    mLoadURI.Truncate();
+
+  bool     notify = false;
+  nsresult rv     = NS_ERROR_FAILURE;
+  // Don't show dialog if we are out of URLs
+  //if ( mCurrentlyPrintingURI < mURIArray.Length() && !mIsDoingPrintPreview)
+  if ( mCurrentlyPrintingURI < (int32_t)mURIArray.Length())
+    rv = ShowProgressDialog(!mIsDoingPrintPreview, notify);
+  if (NS_FAILED(rv) || !notify) 
+    return FireThatLoadOperation(uri);
+  return NS_OK;
+}
+
+nsresult
+nsMsgPrintEngine::FireThatLoadOperation(const nsString& uri)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+  
+  nsCString uriCStr;
+  LossyCopyUTF16toASCII(uri, uriCStr);
+
+  nsCOMPtr <nsIMsgMessageService> messageService;
+  // if this is a data: url, skip it, because 
+  // we've already got something we can print
+  // and we know it is not a message.
+  //
+  // if this an about:blank url, skip it, because
+  // ...
+  //
+  // if this is an addbook: url, skip it, because
+  // we know that isn't a message.
+  //
+  // if this is a message part (or .eml file on disk)
+  // skip it, because we don't want to print the parent message
+  // we want to print the part.
+  // example:  imap://sspitzer@nsmail-1:143/fetch%3EUID%3E/INBOX%3E180958?part=1.1.2&type=application/x-message-display&filename=test"
+  if (!StringBeginsWith(uriCStr, NS_LITERAL_CSTRING(DATA_URL_PREFIX)) &&
+      !StringBeginsWith(uriCStr, NS_LITERAL_CSTRING(ADDBOOK_URL_PREFIX)) &&
+      !uriCStr.EqualsLiteral("about:blank") && 
+      uriCStr.Find(NS_LITERAL_CSTRING("type=application/x-message-display")) == -1) {
+    rv = GetMessageServiceFromURI(uriCStr, getter_AddRefs(messageService));
+  }
+
+  if (NS_SUCCEEDED(rv) && messageService) {
+    nsCOMPtr<nsIURI> dummyNull;
+    rv = messageService->DisplayMessageForPrinting(uriCStr.get(), mDocShell, nullptr, nullptr,
+                                                   getter_AddRefs(dummyNull));
+  }
+  //If it's not something we know about, then just load try loading it directly.
+  else
+  {
+    nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
+    if (webNav)
+      rv = webNav->LoadURI(uri.get(),                        // URI string
+                           nsIWebNavigation::LOAD_FLAGS_NONE, // Load flags
+                           nullptr,                            // Referring URI
+                           nullptr,                            // Post data
+                           nullptr);                           // Extra headers
+  }
+  return rv;
+}
+
+void
+nsMsgPrintEngine::InitializeDisplayCharset()
+{
+  // libmime always converts to UTF-8 (both HTML and XML)
+  if (mDocShell) 
+  {
+    nsCOMPtr<nsIContentViewer> cv;
+    mDocShell->GetContentViewer(getter_AddRefs(cv));
+    if (cv) 
+    {
+      cv->SetForceCharacterSet(NS_LITERAL_CSTRING("UTF-8"));
+    }
+  }
+}
+
+void
+nsMsgPrintEngine::SetupObserver()
+{
+  if (!mDocShell)
+    return;
+
+  if (mDocShell)
+  {
+    nsCOMPtr<nsIWebProgress> progress(do_GetInterface(mDocShell));
+    NS_ASSERTION(progress, "we were expecting a nsIWebProgress");
+    if (progress) 
+    {
+      (void) progress->AddProgressListener((nsIWebProgressListener *)this,
+                                        nsIWebProgress::NOTIFY_STATE_DOCUMENT);
+    }
+
+    // Cache a pointer to the mail message's DOMWindow 
+    // so later we know when we can print when the 
+    // document "loaded" msgs com thru via the Progress listener
+    mMsgDOMWin = do_GetInterface(mDocShell);
+  }
+}
+
+nsresult
+nsMsgPrintEngine::SetStatusMessage(const nsString& aMsgString)
+{
+  if ( (!mFeedback) || (aMsgString.IsEmpty()) )
+    return NS_OK;
+
+  mFeedback->ShowStatusString(aMsgString);
+  return NS_OK;
+}
+
+#define MESSENGER_STRING_URL       "chrome://messenger/locale/messenger.properties"
+
+void
+nsMsgPrintEngine::GetString(const char16_t *aStringName, nsString& outStr)
+{
+  outStr.Truncate();
+
+  if (!mStringBundle)
+  {
+    static const char propertyURL[] = MESSENGER_STRING_URL;
+
+    nsCOMPtr<nsIStringBundleService> sBundleService = 
+      mozilla::services::GetStringBundleService();
+    if (sBundleService)
+      sBundleService->CreateBundle(propertyURL, getter_AddRefs(mStringBundle));
+  }
+
+  if (mStringBundle)
+    mStringBundle->GetStringFromName(aStringName, getter_Copies(outStr));
+  return;
+}
+
+//-----------------------------------------------------------
+void
+nsMsgPrintEngine::PrintMsgWindow()
+{
+  const char* kMsgKeys[] = {"PrintingMessage",  "PrintPreviewMessage",
+                            "PrintingContact",  "PrintPreviewContact",
+                            "PrintingAddrBook", "PrintPreviewAddrBook"};
+
+  mDocShell->GetContentViewer(getter_AddRefs(mContentViewer));  
+  if (mContentViewer) 
+  {
+    mWebBrowserPrint = do_QueryInterface(mContentViewer);
+    if (mWebBrowserPrint) 
+    {
+      if (!mPrintSettings) 
+      {
+        mWebBrowserPrint->GetGlobalPrintSettings(getter_AddRefs(mPrintSettings));
+      }
+      
+      // fix for bug #118887 and bug #176016
+      // don't show the actual url when printing mail messages or addressbook cards.
+      // for mail, it can review the salt.  for addrbook, it's a data:// url, which
+      // means nothing to the end user.
+      // needs to be " " and not "" or nullptr, otherwise, we'll still print the url
+      mPrintSettings->SetDocURL(u" ");
+
+      nsresult rv = NS_ERROR_FAILURE;
+      if (mIsDoingPrintPreview) 
+      {
+        if (mStartupPPObs) {
+          rv = mStartupPPObs->Observe(nullptr, nullptr, nullptr);
+        }
+      } 
+      else 
+      {
+        mPrintSettings->SetPrintSilent(mCurrentlyPrintingURI != 0);
+        rv = mWebBrowserPrint->Print(mPrintSettings, (nsIWebProgressListener *)this);
+      }
+
+      if (NS_FAILED(rv))
+      {
+        mWebBrowserPrint = nullptr;
+        mContentViewer = nullptr;
+        bool isPrintingCancelled = false;
+        if (mPrintSettings)
+        {
+          mPrintSettings->GetIsCancelled(&isPrintingCancelled);
+        }
+        if (!isPrintingCancelled) 
+        {
+          StartNextPrintOperation();
+        } 
+        else 
+        {
+          if (mWindow) {
+            nsPIDOMWindowOuter::From(mWindow)->Close();
+          }
+        }
+      }
+      else
+      {
+        // Tell the user we started printing...
+        nsString msg;
+        GetString(NS_ConvertASCIItoUTF16(kMsgKeys[mMsgInx]).get(), msg);
+        SetStatusMessage(msg);
+      }
+    }
+  }
+}
+
+//---------------------------------------------------------------
+//-- Event Notification
+//---------------------------------------------------------------
+
+//---------------------------------------------------------------
+class nsPrintMsgWindowEvent : public mozilla::Runnable
+{
+public:
+  nsPrintMsgWindowEvent(nsMsgPrintEngine *mpe)
+    : mMsgPrintEngine(mpe)
+  {}
+
+  NS_IMETHOD Run()
+  {
+    if (mMsgPrintEngine) 
+      mMsgPrintEngine->PrintMsgWindow();
+    return NS_OK;
+  }
+
+private:
+  RefPtr<nsMsgPrintEngine> mMsgPrintEngine;
+};
+
+//-----------------------------------------------------------
+class nsStartNextPrintOpEvent : public mozilla::Runnable
+{
+public:
+  nsStartNextPrintOpEvent(nsMsgPrintEngine *mpe)
+    : mMsgPrintEngine(mpe)
+  {}
+
+  NS_IMETHOD Run()
+  {
+    if (mMsgPrintEngine) 
+      mMsgPrintEngine->StartNextPrintOperation();
+    return NS_OK;
+  }
+
+private:
+  RefPtr<nsMsgPrintEngine> mMsgPrintEngine;
+};
+
+//-----------------------------------------------------------
+bool
+nsMsgPrintEngine::FirePrintEvent()
+{
+  nsCOMPtr<nsIRunnable> event = new nsPrintMsgWindowEvent(this);
+  return NS_SUCCEEDED(NS_DispatchToCurrentThread(event));
+}
+
+//-----------------------------------------------------------
+nsresult
+nsMsgPrintEngine::FireStartNextEvent()
+{
+  nsCOMPtr<nsIRunnable> event = new nsStartNextPrintOpEvent(this);
+  return NS_DispatchToCurrentThread(event);
+}
+
+/* void setStartupPPObserver (in nsIObserver startupPPObs); */
+NS_IMETHODIMP nsMsgPrintEngine::SetStartupPPObserver(nsIObserver *startupPPObs)
+{
+  mStartupPPObs = startupPPObs;
+  return NS_OK;
+}
+
+/* attribute boolean doPrintPreview; */
+NS_IMETHODIMP nsMsgPrintEngine::GetDoPrintPreview(bool *aDoPrintPreview)
+{
+  NS_ENSURE_ARG_POINTER(aDoPrintPreview);
+  *aDoPrintPreview = mIsDoingPrintPreview;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgPrintEngine::SetDoPrintPreview(bool aDoPrintPreview)
+{
+  mIsDoingPrintPreview = aDoPrintPreview;
+  return NS_OK;
+}
+
+/* void setMsgType (in long aMsgType); */
+NS_IMETHODIMP nsMsgPrintEngine::SetMsgType(int32_t aMsgType)
+{
+  if (mMsgInx >= nsIMsgPrintEngine::MNAB_START && mMsgInx < nsIMsgPrintEngine::MNAB_END) 
+  {
+    mMsgInx = aMsgType;
+    return NS_OK;
+  }
+  return NS_ERROR_FAILURE;
+}
+
+/*=============== nsIObserver Interface ======================*/
+NS_IMETHODIMP nsMsgPrintEngine::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData)
+{
+  return FireThatLoadOperation(mLoadURI);
+}
diff --git a/mailnews/base/src/nsMsgPrintEngine.h b/mailnews/base/src/nsMsgPrintEngine.h
new file mode 100644
index 000000000..4f8a9cad0
--- /dev/null
+++ b/mailnews/base/src/nsMsgPrintEngine.h
@@ -0,0 +1,91 @@
+/* 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/. */
+
+// nsMsgPrintEngine.h: declaration of nsMsgPrintEngine class
+// implementing mozISimpleContainer,
+// which provides a DocShell container for use in simple programs
+// using the layout engine
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+
+#include "nsIDocShell.h"
+#include "nsIDocShell.h"
+#include "nsIMsgPrintEngine.h"
+#include "nsIStreamListener.h"
+#include "nsIWebProgressListener.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsIStringBundle.h"
+#include "nsIWebBrowserPrint.h"
+#include "nsIWebProgressListener.h"
+#include "nsWeakReference.h"
+#include "nsIPrintSettings.h"
+#include "nsIObserver.h"
+
+// Progress Dialog
+#include "nsIPrintProgress.h"
+#include "nsIPrintProgressParams.h"
+#include "nsIPrintingPromptService.h"
+
+class nsMsgPrintEngine : public nsIMsgPrintEngine,
+                         public nsIWebProgressListener,
+                         public nsIObserver,
+                         public nsSupportsWeakReference {
+
+public:
+  nsMsgPrintEngine();
+
+  // nsISupports
+  NS_DECL_ISUPPORTS
+
+  // nsIMsgPrintEngine interface
+  NS_DECL_NSIMSGPRINTENGINE
+
+  // For nsIWebProgressListener
+  NS_DECL_NSIWEBPROGRESSLISTENER
+
+  // For nsIObserver
+  NS_DECL_NSIOBSERVER
+
+  void PrintMsgWindow();
+  NS_IMETHOD  StartNextPrintOperation();
+
+protected:
+  virtual ~nsMsgPrintEngine();
+
+  bool        FirePrintEvent();
+  nsresult    FireStartNextEvent();
+  nsresult    FireThatLoadOperationStartup(const nsString& uri);
+  nsresult    FireThatLoadOperation(const nsString& uri);
+  void        InitializeDisplayCharset();
+  void        SetupObserver();
+  nsresult    SetStatusMessage(const nsString& aMsgString);
+  void GetString(const char16_t *aStringName, nsString& aOutString);
+  nsresult    ShowProgressDialog(bool aIsForPrinting, bool& aDoNotify);
+
+  nsCOMPtr<nsIDocShell>       mDocShell;
+  nsCOMPtr<mozIDOMWindowProxy> mWindow;
+  nsCOMPtr<mozIDOMWindowProxy> mParentWindow;
+  int32_t                     mURICount;
+  nsTArray<nsString>          mURIArray;
+  int32_t                     mCurrentlyPrintingURI;
+
+  nsCOMPtr<nsIContentViewer>  mContentViewer;
+  nsCOMPtr<nsIStringBundle>   mStringBundle;    // String bundles...
+  nsCOMPtr<nsIMsgStatusFeedback> mFeedback;     // Tell the user something why don't ya'
+  nsCOMPtr<nsIWebBrowserPrint> mWebBrowserPrint;
+  nsCOMPtr<nsIPrintSettings>   mPrintSettings;
+  nsCOMPtr<mozIDOMWindowProxy> mMsgDOMWin;
+  bool                         mIsDoingPrintPreview;
+  nsCOMPtr<nsIObserver>        mStartupPPObs;
+  int32_t                      mMsgInx;
+
+  // Progress Dialog
+  
+  nsCOMPtr<nsIPrintingPromptService> mPrintPromptService;
+  nsCOMPtr<nsIWebProgressListener> mPrintProgressListener;
+  nsCOMPtr<nsIPrintProgress>       mPrintProgress;
+  nsCOMPtr<nsIPrintProgressParams> mPrintProgressParams;
+  nsString                         mLoadURI;
+};
diff --git a/mailnews/base/src/nsMsgProgress.cpp b/mailnews/base/src/nsMsgProgress.cpp
new file mode 100644
index 000000000..02f26edbf
--- /dev/null
+++ b/mailnews/base/src/nsMsgProgress.cpp
@@ -0,0 +1,262 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgProgress.h"
+
+#include "nsIBaseWindow.h"
+#include "nsXPCOM.h"
+#include "nsIMutableArray.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIComponentManager.h"
+#include "nsError.h"
+#include "nsIWindowWatcher.h"
+#include "nsPIDOMWindow.h"
+#include "mozIDOMWindow.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Services.h"
+
+NS_IMPL_ISUPPORTS(nsMsgProgress, nsIMsgStatusFeedback, nsIMsgProgress,
+  nsIWebProgressListener, nsIProgressEventSink, nsISupportsWeakReference)
+
+
+nsMsgProgress::nsMsgProgress()
+{
+  m_closeProgress = false;
+  m_processCanceled = false;
+  m_pendingStateFlags = -1;
+  m_pendingStateValue = NS_OK;
+}
+
+nsMsgProgress::~nsMsgProgress()
+{
+  (void)ReleaseListeners();
+}
+
+NS_IMETHODIMP nsMsgProgress::OpenProgressDialog(mozIDOMWindowProxy *parentDOMWindow,
+                                                nsIMsgWindow *aMsgWindow,
+                                                const char *dialogURL,
+                                                bool inDisplayModal,
+                                                nsISupports *parameters)
+{
+  nsresult rv;
+
+  if (aMsgWindow)
+  {
+    SetMsgWindow(aMsgWindow);
+    aMsgWindow->SetStatusFeedback(this);
+  }
+
+  NS_ENSURE_ARG_POINTER(dialogURL);
+  NS_ENSURE_ARG_POINTER(parentDOMWindow);
+  nsCOMPtr<nsPIDOMWindowOuter> parent = nsPIDOMWindowOuter::From(parentDOMWindow);
+  parent = parent->GetOuterWindow();
+  NS_ENSURE_ARG_POINTER(parent);
+
+  // Set up window.arguments[0]...
+  nsCOMPtr<nsIMutableArray> array(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISupportsInterfacePointer> ifptr =
+    do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  ifptr->SetData(static_cast<nsIMsgProgress*>(this));
+  ifptr->SetDataIID(&NS_GET_IID(nsIMsgProgress));
+
+  array->AppendElement(ifptr, false);
+  array->AppendElement(parameters, false);
+
+  // Open the dialog.
+  nsCOMPtr<nsPIDOMWindowOuter> newWindow;
+
+  nsString chromeOptions(NS_LITERAL_STRING("chrome,dependent,centerscreen"));
+  if (inDisplayModal)
+    chromeOptions.AppendLiteral(",modal");
+
+  return parent->OpenDialog(NS_ConvertASCIItoUTF16(dialogURL),
+                            NS_LITERAL_STRING("_blank"),
+                            chromeOptions,
+                            array, getter_AddRefs(newWindow));
+}
+
+/* void closeProgressDialog (in boolean forceClose); */
+NS_IMETHODIMP nsMsgProgress::CloseProgressDialog(bool forceClose)
+{
+  m_closeProgress = true;
+  return OnStateChange(nullptr, nullptr, nsIWebProgressListener::STATE_STOP, forceClose ? NS_ERROR_FAILURE : NS_OK);
+}
+
+/* attribute boolean processCanceledByUser; */
+NS_IMETHODIMP nsMsgProgress::GetProcessCanceledByUser(bool *aProcessCanceledByUser)
+{
+  NS_ENSURE_ARG_POINTER(aProcessCanceledByUser);
+  *aProcessCanceledByUser = m_processCanceled;
+  return NS_OK;
+}
+NS_IMETHODIMP nsMsgProgress::SetProcessCanceledByUser(bool aProcessCanceledByUser)
+{
+  m_processCanceled = aProcessCanceledByUser;
+  OnStateChange(nullptr, nullptr, nsIWebProgressListener::STATE_STOP, NS_BINDING_ABORTED);
+  return NS_OK;
+}
+
+/* void RegisterListener (in nsIWebProgressListener listener); */
+NS_IMETHODIMP nsMsgProgress::RegisterListener(nsIWebProgressListener * listener)
+{
+  if (!listener) //Nothing to do with a null listener!
+    return NS_OK;
+
+  NS_ENSURE_ARG(this != listener); //Check for self-reference (see bug 271700)
+
+  m_listenerList.AppendObject(listener);
+  if (m_closeProgress || m_processCanceled)
+    listener->OnStateChange(nullptr, nullptr, nsIWebProgressListener::STATE_STOP, NS_OK);
+  else
+  {
+    listener->OnStatusChange(nullptr, nullptr, NS_OK, m_pendingStatus.get());
+    if (m_pendingStateFlags != -1)
+      listener->OnStateChange(nullptr, nullptr, m_pendingStateFlags, m_pendingStateValue);
+  }
+
+  return NS_OK;
+}
+
+/* void UnregisterListener (in nsIWebProgressListener listener); */
+NS_IMETHODIMP nsMsgProgress::UnregisterListener(nsIWebProgressListener *listener)
+{
+  if (listener)
+    m_listenerList.RemoveObject(listener);
+  return NS_OK;
+}
+
+/* void onStateChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long aStateFlags, in nsresult aStatus); */
+NS_IMETHODIMP nsMsgProgress::OnStateChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, uint32_t aStateFlags, nsresult aStatus)
+{
+  m_pendingStateFlags = aStateFlags;
+  m_pendingStateValue = aStatus;
+
+  nsCOMPtr<nsIMsgWindow> msgWindow (do_QueryReferent(m_msgWindow));
+  if (aStateFlags == nsIWebProgressListener::STATE_STOP && msgWindow && NS_FAILED(aStatus))
+  {
+    msgWindow->StopUrls();
+    msgWindow->SetStatusFeedback(nullptr);
+  }
+
+  for (int32_t i = m_listenerList.Count() - 1; i >= 0; i --)
+    m_listenerList[i]->OnStateChange(aWebProgress, aRequest, aStateFlags, aStatus);
+
+  return NS_OK;
+}
+
+/* void onProgressChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in long aCurSelfProgress, in long aMaxSelfProgress, in long aCurTotalProgress, in long aMaxTotalProgress); */
+NS_IMETHODIMP nsMsgProgress::OnProgressChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, int32_t aCurSelfProgress, int32_t aMaxSelfProgress, int32_t aCurTotalProgress, int32_t aMaxTotalProgress)
+{
+  for (int32_t i = m_listenerList.Count() - 1; i >= 0; i --)
+    m_listenerList[i]->OnProgressChange(aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress);
+  return NS_OK;
+}
+
+/* void onLocationChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsIURI location, in unsigned long aFlags); */
+NS_IMETHODIMP nsMsgProgress::OnLocationChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, nsIURI *location, uint32_t aFlags)
+{
+  return NS_OK;
+}
+
+/* void onStatusChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in nsresult aStatus, in wstring aMessage); */
+NS_IMETHODIMP nsMsgProgress::OnStatusChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, nsresult aStatus, const char16_t *aMessage)
+{
+  if (aMessage && *aMessage)
+    m_pendingStatus = aMessage;
+  for (int32_t i = m_listenerList.Count() - 1; i >= 0; i --)
+    m_listenerList[i]->OnStatusChange(aWebProgress, aRequest, aStatus, aMessage);
+  return NS_OK;
+}
+
+/* void onSecurityChange (in nsIWebProgress aWebProgress, in nsIRequest aRequest, in unsigned long state); */
+NS_IMETHODIMP nsMsgProgress::OnSecurityChange(nsIWebProgress *aWebProgress, nsIRequest *aRequest, uint32_t state)
+{
+  return NS_OK;
+}
+
+nsresult nsMsgProgress::ReleaseListeners()
+{
+  m_listenerList.Clear();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgProgress::ShowStatusString(const nsAString& aStatus)
+{
+  return OnStatusChange(nullptr, nullptr, NS_OK, PromiseFlatString(aStatus).get());
+}
+
+NS_IMETHODIMP nsMsgProgress::SetStatusString(const nsAString& aStatus)
+{
+  return OnStatusChange(nullptr, nullptr, NS_OK, PromiseFlatString(aStatus).get());
+}
+
+/* void startMeteors (); */
+NS_IMETHODIMP nsMsgProgress::StartMeteors()
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void stopMeteors (); */
+NS_IMETHODIMP nsMsgProgress::StopMeteors()
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void showProgress (in long percent); */
+NS_IMETHODIMP nsMsgProgress::ShowProgress(int32_t percent)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProgress::SetWrappedStatusFeedback(nsIMsgStatusFeedback * aJSStatusFeedback)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgProgress::SetMsgWindow(nsIMsgWindow *aMsgWindow)
+{
+  m_msgWindow = do_GetWeakReference(aMsgWindow);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgProgress::GetMsgWindow(nsIMsgWindow **aMsgWindow)
+{
+  NS_ENSURE_ARG_POINTER(aMsgWindow);
+
+  if (m_msgWindow)
+    CallQueryReferent(m_msgWindow.get(), aMsgWindow);
+  else
+    *aMsgWindow = nullptr;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgProgress::OnProgress(nsIRequest *request, nsISupports* ctxt,
+                                        int64_t aProgress, int64_t aProgressMax)
+{
+  // XXX: What should the nsIWebProgress be?
+  // XXX: This truncates 64-bit to 32-bit
+  return OnProgressChange(nullptr, request, int32_t(aProgress), int32_t(aProgressMax),
+                          int32_t(aProgress) /* current total progress */, int32_t(aProgressMax) /* max total progress */);
+}
+
+NS_IMETHODIMP nsMsgProgress::OnStatus(nsIRequest *request, nsISupports* ctxt,
+                                      nsresult aStatus, const char16_t* aStatusArg)
+{
+  nsresult rv;
+  nsCOMPtr<nsIStringBundleService> sbs =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(sbs, NS_ERROR_UNEXPECTED);
+  nsString str;
+  rv = sbs->FormatStatusMessage(aStatus, aStatusArg, getter_Copies(str));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ShowStatusString(str);
+}
diff --git a/mailnews/base/src/nsMsgProgress.h b/mailnews/base/src/nsMsgProgress.h
new file mode 100644
index 000000000..4450c6cce
--- /dev/null
+++ b/mailnews/base/src/nsMsgProgress.h
@@ -0,0 +1,47 @@
+/* -*- 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 nsMsgProgress_h_
+#define nsMsgProgress_h_
+
+#include "nsIMsgProgress.h"
+#include "nsCOMPtr.h"
+#include "nsCOMArray.h"
+#include "nsIDOMWindow.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsStringGlue.h"
+#include "nsIMsgWindow.h"
+#include "nsIProgressEventSink.h"
+#include "nsIStringBundle.h"
+#include "nsWeakReference.h"
+
+class nsMsgProgress : public nsIMsgProgress, 
+                      public nsIMsgStatusFeedback, 
+                      public nsIProgressEventSink,
+                      public nsSupportsWeakReference
+{
+public: 
+  nsMsgProgress();
+  
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIMSGPROGRESS
+  NS_DECL_NSIWEBPROGRESSLISTENER
+  NS_DECL_NSIMSGSTATUSFEEDBACK
+  NS_DECL_NSIPROGRESSEVENTSINK
+
+private:
+  virtual ~nsMsgProgress();
+  nsresult ReleaseListeners(void);
+  
+  bool                               m_closeProgress;
+  bool                               m_processCanceled;
+  nsString                           m_pendingStatus;
+  int32_t                            m_pendingStateFlags;
+  nsresult                           m_pendingStateValue;
+  nsWeakPtr                          m_msgWindow;
+  nsCOMArray<nsIWebProgressListener> m_listenerList;
+};
+
+#endif  // nsMsgProgress_h_
diff --git a/mailnews/base/src/nsMsgPurgeService.cpp b/mailnews/base/src/nsMsgPurgeService.cpp
new file mode 100644
index 000000000..98d9e7cce
--- /dev/null
+++ b/mailnews/base/src/nsMsgPurgeService.cpp
@@ -0,0 +1,486 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgPurgeService.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgUtils.h"
+#include "nsMsgSearchCore.h"
+#include "msgCore.h"
+#include "nsISpamSettings.h"
+#include "nsIMsgSearchTerm.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgProtocolInfo.h"
+#include "nsIMsgFilterPlugin.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "mozilla/Logging.h"
+#include "nsMsgFolderFlags.h"
+#include <stdlib.h>
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsArrayUtils.h"
+
+static PRLogModuleInfo *MsgPurgeLogModule = nullptr;
+
+NS_IMPL_ISUPPORTS(nsMsgPurgeService, nsIMsgPurgeService, nsIMsgSearchNotify)
+
+void OnPurgeTimer(nsITimer *timer, void *aPurgeService)
+{
+  nsMsgPurgeService *purgeService = (nsMsgPurgeService*)aPurgeService;
+  purgeService->PerformPurge();
+}
+
+nsMsgPurgeService::nsMsgPurgeService()
+{
+  mHaveShutdown = false;
+  mMinDelayBetweenPurges = 480;  // never purge a folder more than once every 8 hours (60 min/hour * 8 hours)
+  mPurgeTimerInterval = 5;  // fire the purge timer every 5 minutes, starting 5 minutes after the service is created (when we load accounts)
+}
+
+nsMsgPurgeService::~nsMsgPurgeService()
+{
+  if (mPurgeTimer)
+    mPurgeTimer->Cancel();
+
+  if(!mHaveShutdown)
+    Shutdown();
+}
+
+NS_IMETHODIMP nsMsgPurgeService::Init()
+{
+  nsresult rv;
+
+  if (!MsgPurgeLogModule)
+    MsgPurgeLogModule = PR_NewLogModule("MsgPurge");
+
+  // these prefs are here to help QA test this feature
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  if (NS_SUCCEEDED(rv))
+  {
+    int32_t min_delay;
+    rv = prefBranch->GetIntPref("mail.purge.min_delay", &min_delay);
+    if (NS_SUCCEEDED(rv) &&  min_delay)
+      mMinDelayBetweenPurges = min_delay;
+
+    int32_t purge_timer_interval;
+    rv = prefBranch->GetIntPref("mail.purge.timer_interval", &purge_timer_interval);
+    if (NS_SUCCEEDED(rv) &&  purge_timer_interval)
+      mPurgeTimerInterval = purge_timer_interval;
+  }
+
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("mail.purge.min_delay=%d minutes",mMinDelayBetweenPurges));
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("mail.purge.timer_interval=%d minutes",mPurgeTimerInterval));
+
+  // don't start purging right away.
+  // because the accounts aren't loaded and because the user might be trying to sign in
+  // or startup, etc.
+  SetupNextPurge();
+
+  mHaveShutdown = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgPurgeService::Shutdown()
+{
+  if (mPurgeTimer)
+  {
+    mPurgeTimer->Cancel();
+    mPurgeTimer = nullptr;
+  }
+
+  mHaveShutdown = true;
+  return NS_OK;
+}
+
+nsresult nsMsgPurgeService::SetupNextPurge()
+{
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("setting to check again in %d minutes",mPurgeTimerInterval));
+
+  // Convert mPurgeTimerInterval into milliseconds
+  uint32_t timeInMSUint32 = mPurgeTimerInterval * 60000;
+
+  // Can't currently reset a timer when it's in the process of
+  // calling Notify. So, just release the timer here and create a new one.
+  if(mPurgeTimer)
+    mPurgeTimer->Cancel();
+
+  mPurgeTimer = do_CreateInstance("@mozilla.org/timer;1");
+  mPurgeTimer->InitWithFuncCallback(OnPurgeTimer, (void*)this, timeInMSUint32,
+    nsITimer::TYPE_ONE_SHOT);
+
+  return NS_OK;
+}
+
+// This is the function that looks for the first folder to purge. It also
+// applies retention settings to any folder that hasn't had retention settings
+// applied in mMinDelayBetweenPurges minutes (default, 8 hours).
+// However, if we've spent more than .5 seconds in this loop, don't
+// apply any more retention settings because it might lock up the UI.
+// This might starve folders later on in the hierarchy, since we always
+// start at the top, but since we also apply retention settings when you
+// open a folder, or when you compact all folders, I think this will do
+// for now, until we have a cleanup on shutdown architecture.
+nsresult nsMsgPurgeService::PerformPurge()
+{
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("performing purge"));
+
+  nsresult rv;
+
+  nsCOMPtr <nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  bool keepApplyingRetentionSettings = true;
+
+  nsCOMPtr<nsIArray> allServers;
+  rv = accountManager->GetAllServers(getter_AddRefs(allServers));
+  if (NS_SUCCEEDED(rv) && allServers)
+  {
+    uint32_t numServers;
+    rv = allServers->GetLength(&numServers);
+    MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("%d servers", numServers));
+    nsCOMPtr<nsIMsgFolder> folderToPurge;
+    PRIntervalTime startTime = PR_IntervalNow();
+    int32_t purgeIntervalToUse = 0;
+    PRTime oldestPurgeTime = 0; // we're going to pick the least-recently purged folder
+
+    // apply retention settings to folders that haven't had retention settings
+    // applied in mMinDelayBetweenPurges minutes (default 8 hours)
+    // Because we get last purge time from the folder cache,
+    // this code won't open db's for folders until it decides it needs
+    // to apply retention settings, and since nsIMsgFolder::ApplyRetentionSettings
+    // will close any db's it opens, this code won't leave db's open.
+    for (uint32_t serverIndex=0; serverIndex < numServers; serverIndex++)
+    {
+      nsCOMPtr <nsIMsgIncomingServer> server =
+        do_QueryElementAt(allServers, serverIndex, &rv);
+      if (NS_SUCCEEDED(rv) && server)
+      {
+        if (keepApplyingRetentionSettings)
+        {
+          nsCOMPtr <nsIMsgFolder> rootFolder;
+          rv = server->GetRootFolder(getter_AddRefs(rootFolder));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          nsCOMPtr<nsIArray> childFolders;
+          rv = rootFolder->GetDescendants(getter_AddRefs(childFolders));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          uint32_t cnt = 0;
+          childFolders->GetLength(&cnt);
+
+          nsCOMPtr<nsISupports> supports;
+          nsCOMPtr<nsIUrlListener> urlListener;
+          nsCOMPtr<nsIMsgFolder> childFolder;
+
+          for (uint32_t index = 0; index < cnt; index++)
+          {
+            childFolder = do_QueryElementAt(childFolders, index);
+            if (childFolder)
+            {
+              uint32_t folderFlags;
+              (void) childFolder->GetFlags(&folderFlags);
+              if (folderFlags & nsMsgFolderFlags::Virtual)
+                continue;
+              PRTime curFolderLastPurgeTime = 0;
+              nsCString curFolderLastPurgeTimeString, curFolderUri;
+              rv = childFolder->GetStringProperty("LastPurgeTime", curFolderLastPurgeTimeString);
+              if (NS_FAILED(rv))
+                continue; // it is ok to fail, go on to next folder
+
+              if (!curFolderLastPurgeTimeString.IsEmpty())
+              {
+                PRTime theTime;
+                PR_ParseTimeString(curFolderLastPurgeTimeString.get(), false, &theTime);
+                curFolderLastPurgeTime = theTime;
+              }
+
+              childFolder->GetURI(curFolderUri);
+              MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("%s curFolderLastPurgeTime=%s (if blank, then never)", curFolderUri.get(), curFolderLastPurgeTimeString.get()));
+
+              // check if this folder is due to purge
+              // has to have been purged at least mMinDelayBetweenPurges minutes ago
+              // we don't want to purge the folders all the time - once a day is good enough
+              int64_t minDelayBetweenPurges(mMinDelayBetweenPurges);
+              int64_t microSecondsPerMinute(60000000);
+              PRTime nextPurgeTime = curFolderLastPurgeTime + (minDelayBetweenPurges * microSecondsPerMinute);
+              if (nextPurgeTime < PR_Now())
+              {
+                MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("purging %s", curFolderUri.get()));
+                childFolder->ApplyRetentionSettings();
+              }
+              PRIntervalTime elapsedTime = PR_IntervalNow() - startTime;
+              // check if more than 500 milliseconds have elapsed in this purge process
+              if (PR_IntervalToMilliseconds(elapsedTime) > 500)
+              {
+                keepApplyingRetentionSettings = false;
+                break;
+              }
+            }
+          }
+        }
+        nsCString type;
+        nsresult rv = server->GetType(type);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        nsCString realHostName;
+        server->GetRealHostName(realHostName);
+        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] %s (%s)", serverIndex, realHostName.get(), type.get()));
+
+        nsCOMPtr <nsISpamSettings> spamSettings;
+        rv = server->GetSpamSettings(getter_AddRefs(spamSettings));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        int32_t spamLevel;
+        spamSettings->GetLevel(&spamLevel);
+        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] spamLevel=%d (if 0, don't purge)", serverIndex, spamLevel));
+        if (!spamLevel)
+          continue;
+
+        // check if we are set up to purge for this server
+        // if not, skip it.
+        bool purgeSpam;
+        spamSettings->GetPurge(&purgeSpam);
+
+        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] purgeSpam=%s (if false, don't purge)", serverIndex, purgeSpam ? "true" : "false"));
+        if (!purgeSpam)
+          continue;
+
+        // check if the spam folder uri is set for this server
+        // if not skip it.
+        nsCString junkFolderURI;
+        rv = spamSettings->GetSpamFolderURI(getter_Copies(junkFolderURI));
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] junkFolderURI=%s (if empty, don't purge)", serverIndex, junkFolderURI.get()));
+        if (junkFolderURI.IsEmpty())
+          continue;
+
+        // if the junk folder doesn't exist
+        // because the folder pane isn't built yet, for example
+        // skip this account
+        nsCOMPtr<nsIMsgFolder> junkFolder;
+        GetExistingFolder(junkFolderURI, getter_AddRefs(junkFolder));
+
+        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] %s exists? %s (if doesn't exist, don't purge)", serverIndex, junkFolderURI.get(), junkFolder ? "true" : "false"));
+        if (!junkFolder)
+          continue;
+
+        PRTime curJunkFolderLastPurgeTime = 0;
+        nsCString curJunkFolderLastPurgeTimeString;
+        rv = junkFolder->GetStringProperty("curJunkFolderLastPurgeTime", curJunkFolderLastPurgeTimeString);
+        if (NS_FAILED(rv))
+          continue; // it is ok to fail, junk folder may not exist
+
+        if (!curJunkFolderLastPurgeTimeString.IsEmpty())
+        {
+          PRTime theTime;
+          PR_ParseTimeString(curJunkFolderLastPurgeTimeString.get(), false, &theTime);
+          curJunkFolderLastPurgeTime = theTime;
+        }
+
+        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] %s curJunkFolderLastPurgeTime=%s (if blank, then never)", serverIndex, junkFolderURI.get(), curJunkFolderLastPurgeTimeString.get()));
+
+        // check if this account is due to purge
+        // has to have been purged at least mMinDelayBetweenPurges minutes ago
+        // we don't want to purge the folders all the time
+        PRTime nextPurgeTime = curJunkFolderLastPurgeTime + mMinDelayBetweenPurges * 60000000 /* convert mMinDelayBetweenPurges to into microseconds */;
+        if (nextPurgeTime < PR_Now())
+        {
+          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] last purge greater than min delay", serverIndex));
+
+          nsCOMPtr <nsIMsgIncomingServer> junkFolderServer;
+          rv = junkFolder->GetServer(getter_AddRefs(junkFolderServer));
+          NS_ENSURE_SUCCESS(rv,rv);
+
+          bool serverBusy = false;
+          bool serverRequiresPassword = true;
+          bool passwordPromptRequired;
+          bool canSearchMessages = false;
+          junkFolderServer->GetPasswordPromptRequired(&passwordPromptRequired);
+          junkFolderServer->GetServerBusy(&serverBusy);
+          junkFolderServer->GetServerRequiresPasswordForBiff(&serverRequiresPassword);
+          junkFolderServer->GetCanSearchMessages(&canSearchMessages);
+          // Make sure we're logged on before doing the search (assuming we need to be)
+          // and make sure the server isn't already in the middle of downloading new messages
+          // and make sure a search isn't already going on
+          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] (search in progress? %s)", serverIndex, mSearchSession ? "true" : "false"));
+          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] (server busy? %s)", serverIndex, serverBusy ? "true" : "false"));
+          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] (serverRequiresPassword? %s)", serverIndex, serverRequiresPassword ? "true" : "false"));
+          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] (passwordPromptRequired? %s)", serverIndex, passwordPromptRequired ? "true" : "false"));
+          if (canSearchMessages && !mSearchSession && !serverBusy && (!serverRequiresPassword || !passwordPromptRequired))
+          {
+            int32_t purgeInterval;
+            spamSettings->GetPurgeInterval(&purgeInterval);
+
+            if ((oldestPurgeTime == 0) || (curJunkFolderLastPurgeTime < oldestPurgeTime))
+            {
+              MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] purging! searching for messages older than %d days", serverIndex, purgeInterval));
+              oldestPurgeTime = curJunkFolderLastPurgeTime;
+              purgeIntervalToUse = purgeInterval;
+              folderToPurge = junkFolder;
+              // if we've never purged this folder, do it...
+              if (curJunkFolderLastPurgeTime == 0)
+                break;
+            }
+          }
+          else {
+            NS_ASSERTION(canSearchMessages, "unexpected, you should be able to search");
+            MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] not a good time for this server, try again later", serverIndex));
+          }
+        }
+        else {
+          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("[%d] last purge too recent", serverIndex));
+        }
+      }
+    }
+    if (folderToPurge && purgeIntervalToUse != 0)
+      rv = SearchFolderToPurge(folderToPurge, purgeIntervalToUse);
+  }
+
+  // set up timer to check accounts again
+  SetupNextPurge();
+  return rv;
+}
+
+nsresult nsMsgPurgeService::SearchFolderToPurge(nsIMsgFolder *folder, int32_t purgeInterval)
+{
+  nsresult rv;
+  mSearchSession = do_CreateInstance(NS_MSGSEARCHSESSION_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mSearchSession->RegisterListener(this,
+                                   nsIMsgSearchSession::allNotifications);
+
+  // update the time we attempted to purge this folder
+  char dateBuf[100];
+  dateBuf[0] = '\0';
+  PRExplodedTime exploded;
+  PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &exploded);
+  PR_FormatTimeUSEnglish(dateBuf, sizeof(dateBuf), "%a %b %d %H:%M:%S %Y", &exploded);
+  folder->SetStringProperty("curJunkFolderLastPurgeTime", nsDependentCString(dateBuf));
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("curJunkFolderLastPurgeTime is now %s", dateBuf));
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = folder->GetServer(getter_AddRefs(server)); //we need to get the folder's server scope because imap can have local junk folder
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsMsgSearchScopeValue searchScope;
+  server->GetSearchScope(&searchScope);
+
+  mSearchSession->AddScopeTerm(searchScope, folder);
+
+  // look for messages older than the cutoff
+  // you can't also search by junk status, see
+  // nsMsgPurgeService::OnSearchHit()
+  nsCOMPtr <nsIMsgSearchTerm> searchTerm;
+  mSearchSession->CreateTerm(getter_AddRefs(searchTerm));
+  if (searchTerm)
+  {
+    searchTerm->SetAttrib(nsMsgSearchAttrib::AgeInDays);
+    searchTerm->SetOp(nsMsgSearchOp::IsGreaterThan);
+    nsCOMPtr<nsIMsgSearchValue> searchValue;
+    searchTerm->GetValue(getter_AddRefs(searchValue));
+    if (searchValue)
+    {
+      searchValue->SetAttrib(nsMsgSearchAttrib::AgeInDays);
+      searchValue->SetAge((uint32_t) purgeInterval);
+      searchTerm->SetValue(searchValue);
+    }
+    searchTerm->SetBooleanAnd(false);
+    mSearchSession->AppendTerm(searchTerm);
+  }
+
+  // we are about to search
+  // create mHdrsToDelete array (if not previously created)
+  if (!mHdrsToDelete)
+  {
+    mHdrsToDelete = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  else
+  {
+    uint32_t count;
+    mHdrsToDelete->GetLength(&count);
+    NS_ASSERTION(count == 0, "mHdrsToDelete is not empty");
+    if (count > 0)
+      mHdrsToDelete->Clear();  // this shouldn't happen
+  }
+
+  mSearchFolder = folder;
+  return mSearchSession->Search(nullptr);
+}
+
+NS_IMETHODIMP nsMsgPurgeService::OnNewSearch()
+{
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("on new search"));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgPurgeService::OnSearchHit(nsIMsgDBHdr* aMsgHdr, nsIMsgFolder *aFolder)
+{
+  NS_ENSURE_ARG_POINTER(aMsgHdr);
+
+  nsCString messageId;
+  nsCString author;
+  nsCString subject;
+
+  aMsgHdr->GetMessageId(getter_Copies(messageId));
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("messageId=%s", messageId.get()));
+  aMsgHdr->GetSubject(getter_Copies(subject));
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("subject=%s",subject.get()));
+  aMsgHdr->GetAuthor(getter_Copies(author));
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("author=%s",author.get()));
+
+  // double check that the message is junk before adding to
+  // the list of messages to delete
+  //
+  // note, we can't just search for messages that are junk
+  // because not all imap server support keywords
+  // (which we use for the junk score)
+  // so the junk status would be in the message db.
+  //
+  // see bug #194090
+  nsCString junkScoreStr;
+  nsresult rv = aMsgHdr->GetStringProperty("junkscore", getter_Copies(junkScoreStr));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("junkScore=%s (if empty or != nsIJunkMailPlugin::IS_SPAM_SCORE, don't add to list delete)", junkScoreStr.get()));
+
+  // if "junkscore" is not set, don't delete the message
+  if (junkScoreStr.IsEmpty())
+    return NS_OK;
+
+  if (atoi(junkScoreStr.get()) == nsIJunkMailPlugin::IS_SPAM_SCORE) {
+    MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("added message to delete"));
+    return mHdrsToDelete->AppendElement(aMsgHdr, false);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgPurgeService::OnSearchDone(nsresult status)
+{
+  if (NS_SUCCEEDED(status))
+  {
+    uint32_t count = 0;
+    if (mHdrsToDelete)
+      mHdrsToDelete->GetLength(&count);
+    MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("%d messages to delete", count));
+
+    if (count > 0) {
+      MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("delete messages"));
+      if (mSearchFolder)
+        mSearchFolder->DeleteMessages(mHdrsToDelete, nullptr, false /*delete storage*/, false /*isMove*/, nullptr, false /*allowUndo*/);
+    }
+  }
+  if (mHdrsToDelete)
+    mHdrsToDelete->Clear();
+  if (mSearchSession)
+    mSearchSession->UnregisterListener(this);
+  // don't cache the session
+  // just create another search session next time we search, rather than clearing scopes, terms etc.
+  // we also use mSearchSession to determine if the purge service is "busy"
+  mSearchSession = nullptr;
+  mSearchFolder = nullptr;
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMsgPurgeService.h b/mailnews/base/src/nsMsgPurgeService.h
new file mode 100644
index 000000000..d9757d65a
--- /dev/null
+++ b/mailnews/base/src/nsMsgPurgeService.h
@@ -0,0 +1,55 @@
+/* -*- 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 NSMSGPURGESERVICE_H
+#define NSMSGPURGESERVICE_H
+
+#include "msgCore.h"
+#include "nsIMsgPurgeService.h"
+#include "nsIMsgSearchSession.h"
+#include "nsITimer.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgSearchNotify.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgFolderCache.h"
+#include "nsIMsgFolderCacheElement.h"
+#include "nsIMutableArray.h"
+
+class nsMsgPurgeService
+	: public nsIMsgPurgeService,
+		public nsIMsgSearchNotify
+{
+public:
+	nsMsgPurgeService(); 
+
+	NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGPURGESERVICE
+	NS_DECL_NSIMSGSEARCHNOTIFY
+
+	nsresult PerformPurge();
+
+protected:
+	virtual ~nsMsgPurgeService();
+  int32_t FindServer(nsIMsgIncomingServer *server);
+  nsresult SetupNextPurge();
+  nsresult PurgeSurver(nsIMsgIncomingServer *server);
+  nsresult SearchFolderToPurge(nsIMsgFolder *folder, int32_t purgeInterval);
+
+protected:
+  nsCOMPtr<nsITimer> mPurgeTimer;
+  nsCOMPtr<nsIMsgSearchSession> mSearchSession;
+  nsCOMPtr<nsIMsgFolder> mSearchFolder;
+  nsCOMPtr<nsIMutableArray> mHdrsToDelete;
+  bool mHaveShutdown;
+
+private:
+  int32_t mMinDelayBetweenPurges;  // in minutes, how long must pass between two consecutive purges on the same junk folder?
+  int32_t mPurgeTimerInterval;  // in minutes, how often to check if we need to purge one of the junk folders?
+};
+
+
+
+#endif
+
diff --git a/mailnews/base/src/nsMsgQuickSearchDBView.cpp b/mailnews/base/src/nsMsgQuickSearchDBView.cpp
new file mode 100644
index 000000000..3f8c53d2d
--- /dev/null
+++ b/mailnews/base/src/nsMsgQuickSearchDBView.cpp
@@ -0,0 +1,882 @@
+/* -*- 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 "nsMsgQuickSearchDBView.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIMsgHdr.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsImapCore.h"
+#include "nsIMsgHdr.h"
+#include "nsIDBFolderInfo.h"
+#include "nsArrayEnumerator.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMutableArray.h"
+#include "nsMsgUtils.h"
+
+nsMsgQuickSearchDBView::nsMsgQuickSearchDBView()
+{
+  m_usingCachedHits = false;
+  m_cacheEmpty = true;
+}
+
+nsMsgQuickSearchDBView::~nsMsgQuickSearchDBView()
+{
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsMsgQuickSearchDBView, nsMsgDBView, nsIMsgDBView, nsIMsgSearchNotify)
+
+NS_IMETHODIMP nsMsgQuickSearchDBView::Open(nsIMsgFolder *folder, nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder, nsMsgViewFlagsTypeValue viewFlags, int32_t *pCount)
+{
+  nsresult rv = nsMsgDBView::Open(folder, sortType, sortOrder, viewFlags, pCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!m_db)
+    return NS_ERROR_NULL_POINTER;
+  if (pCount)
+    *pCount = 0;
+  m_viewFolder = nullptr;
+  return InitThreadedView(pCount);
+}
+
+NS_IMETHODIMP
+nsMsgQuickSearchDBView::CloneDBView(nsIMessenger *aMessengerInstance,
+                                    nsIMsgWindow *aMsgWindow,
+                                    nsIMsgDBViewCommandUpdater *aCmdUpdater,
+                                    nsIMsgDBView **_retval)
+{
+  nsMsgQuickSearchDBView* newMsgDBView = new nsMsgQuickSearchDBView();
+
+  if (!newMsgDBView)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv = CopyDBView(newMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_IF_ADDREF(*_retval = newMsgDBView);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgQuickSearchDBView::CopyDBView(nsMsgDBView *aNewMsgDBView,
+                                   nsIMessenger *aMessengerInstance,
+                                   nsIMsgWindow *aMsgWindow,
+                                   nsIMsgDBViewCommandUpdater *aCmdUpdater)
+{
+  nsMsgThreadedDBView::CopyDBView(aNewMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  nsMsgQuickSearchDBView* newMsgDBView = (nsMsgQuickSearchDBView *) aNewMsgDBView;
+
+  // now copy all of our private member data
+  newMsgDBView->m_origKeys = m_origKeys;
+  return NS_OK;
+}
+
+nsresult nsMsgQuickSearchDBView::DeleteMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool deleteStorage)
+{
+  for (nsMsgViewIndex i = 0; i < (nsMsgViewIndex) numIndices; i++) 
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr; 
+    (void) GetMsgHdrForViewIndex(indices[i],getter_AddRefs(msgHdr));
+    if (msgHdr)
+      RememberDeletedMsgHdr(msgHdr);
+  }
+
+  return nsMsgDBView::DeleteMessages(window, indices, numIndices, deleteStorage);
+}
+
+NS_IMETHODIMP nsMsgQuickSearchDBView::DoCommand(nsMsgViewCommandTypeValue aCommand)
+{
+  if (aCommand == nsMsgViewCommandType::markAllRead)
+  {
+    nsresult rv = NS_OK;
+    m_folder->EnableNotifications(nsIMsgFolder::allMessageCountNotifications, false, true /*dbBatching*/);
+
+    for (uint32_t i = 0; NS_SUCCEEDED(rv) && i < GetSize(); i++)
+    {
+      nsCOMPtr<nsIMsgDBHdr> msgHdr;
+      m_db->GetMsgHdrForKey(m_keys[i],getter_AddRefs(msgHdr)); 
+      rv = m_db->MarkHdrRead(msgHdr, true, nullptr);
+    }
+
+    m_folder->EnableNotifications(nsIMsgFolder::allMessageCountNotifications, true, true /*dbBatching*/);
+
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(m_folder);
+    if (NS_SUCCEEDED(rv) && imapFolder)
+      rv = imapFolder->StoreImapFlags(kImapMsgSeenFlag, true, m_keys.Elements(), 
+                                      m_keys.Length(), nullptr);
+
+    m_db->SetSummaryValid(true);
+    return rv;
+  }
+  else
+    return nsMsgDBView::DoCommand(aCommand);
+}
+
+NS_IMETHODIMP nsMsgQuickSearchDBView::GetViewType(nsMsgViewTypeValue *aViewType)
+{
+    NS_ENSURE_ARG_POINTER(aViewType);
+    *aViewType = nsMsgViewType::eShowQuickSearchResults; 
+    return NS_OK;
+}
+
+nsresult nsMsgQuickSearchDBView::AddHdr(nsIMsgDBHdr *msgHdr, nsMsgViewIndex *resultIndex)
+{
+  nsMsgKey msgKey;
+  msgHdr->GetMessageKey(&msgKey);
+  // protect against duplication.
+  if (m_origKeys.BinaryIndexOf(msgKey) == m_origKeys.NoIndex)
+  {
+    nsMsgViewIndex insertIndex = GetInsertIndexHelper(msgHdr, m_origKeys, nullptr,
+                    nsMsgViewSortOrder::ascending, nsMsgViewSortType::byId);
+    m_origKeys.InsertElementAt(insertIndex, msgKey);
+  }
+  if (m_viewFlags & (nsMsgViewFlagsType::kGroupBySort|
+                     nsMsgViewFlagsType::kThreadedDisplay))
+  {
+    nsMsgKey parentKey;
+    msgHdr->GetThreadParent(&parentKey);
+    return nsMsgThreadedDBView::OnNewHeader(msgHdr, parentKey, true);
+  }
+  else
+    return nsMsgDBView::AddHdr(msgHdr, resultIndex);
+}
+
+nsresult nsMsgQuickSearchDBView::OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey aParentKey, bool ensureListed)
+{
+  if (newHdr)
+  {
+    bool match=false;
+    nsCOMPtr <nsIMsgSearchSession> searchSession = do_QueryReferent(m_searchSession);
+    if (searchSession)
+      searchSession->MatchHdr(newHdr, m_db, &match);
+    if (match)
+    {
+      // put the new header in m_origKeys, so that expanding a thread will
+      // show the newly added header.
+      nsMsgKey newKey;
+      (void) newHdr->GetMessageKey(&newKey);
+      nsMsgViewIndex insertIndex = GetInsertIndexHelper(newHdr, m_origKeys, nullptr,
+                      nsMsgViewSortOrder::ascending, nsMsgViewSortType::byId);
+      m_origKeys.InsertElementAt(insertIndex, newKey);
+      nsMsgThreadedDBView::OnNewHeader(newHdr, aParentKey, ensureListed); // do not add a new message if there isn't a match.
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgQuickSearchDBView::OnHdrFlagsChanged(nsIMsgDBHdr *aHdrChanged, uint32_t aOldFlags, 
+                                       uint32_t aNewFlags, nsIDBChangeListener *aInstigator)
+{
+  nsresult rv = nsMsgGroupView::OnHdrFlagsChanged(aHdrChanged, aOldFlags, aNewFlags, aInstigator);
+
+  if (m_viewFolder &&
+      (m_viewFolder != m_folder) &&
+      (aOldFlags & nsMsgMessageFlags::Read) != (aNewFlags & nsMsgMessageFlags::Read))
+  {
+    // if we're displaying a single folder virtual folder for an imap folder,
+    // the search criteria might be on message body, and we might not have the
+    // message body offline, in which case we can't tell if the message 
+    // matched or not. But if the unread flag changed, we need to update the
+    // unread counts. Normally, VirtualFolderChangeListener::OnHdrFlagsChanged will
+    // handle this, but it won't work for body criteria when we don't have the
+    // body offline.
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(m_viewFolder);
+    if (imapFolder)
+    {
+      nsMsgViewIndex hdrIndex = FindHdr(aHdrChanged);
+      if (hdrIndex != nsMsgViewIndex_None)
+      {
+        nsCOMPtr <nsIMsgSearchSession> searchSession = do_QueryReferent(m_searchSession);
+        if (searchSession)
+        {
+          bool oldMatch, newMatch;
+          rv = searchSession->MatchHdr(aHdrChanged, m_db, &newMatch);
+          aHdrChanged->SetFlags(aOldFlags);
+          rv = searchSession->MatchHdr(aHdrChanged, m_db, &oldMatch);
+          aHdrChanged->SetFlags(aNewFlags); 
+          // if it doesn't match the criteria, VirtualFolderChangeListener::OnHdrFlagsChanged
+          // won't tweak the read/unread counts. So do it here:
+          if (!oldMatch && !newMatch)
+          {
+            nsCOMPtr <nsIMsgDatabase> virtDatabase;
+            nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+
+            rv = m_viewFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(virtDatabase));
+            NS_ENSURE_SUCCESS(rv, rv);
+            dbFolderInfo->ChangeNumUnreadMessages((aOldFlags & nsMsgMessageFlags::Read) ? 1 : -1);
+            m_viewFolder->UpdateSummaryTotals(true); // force update from db.
+            virtDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+          }
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgQuickSearchDBView::OnHdrPropertyChanged(nsIMsgDBHdr *aHdrChanged, bool aPreChange,
+                                        uint32_t *aStatus, nsIDBChangeListener *aInstigator)
+{
+  // If the junk mail plugin just activated on a message, then
+  // we'll allow filters to remove from view.
+  // Otherwise, just update the view line.
+  //
+  // Note this will not add newly matched headers to the view. This is
+  // probably a bug that needs fixing.
+
+  NS_ENSURE_ARG_POINTER(aStatus);
+  NS_ENSURE_ARG_POINTER(aHdrChanged);
+
+  nsMsgViewIndex index = FindHdr(aHdrChanged);
+  if (index == nsMsgViewIndex_None) // message does not appear in view
+    return NS_OK;
+
+  nsCString originStr;
+  (void) aHdrChanged->GetStringProperty("junkscoreorigin", getter_Copies(originStr));
+  // check for "plugin" with only first character for performance
+  bool plugin = (originStr.get()[0] == 'p');
+
+  if (aPreChange)
+  {
+    // first call, done prior to the change
+    *aStatus = plugin;
+    return NS_OK;
+  }
+
+  // second call, done after the change
+  bool wasPlugin = *aStatus;
+
+  bool match = true;
+  nsCOMPtr<nsIMsgSearchSession> searchSession(do_QueryReferent(m_searchSession));
+  if (searchSession)
+    searchSession->MatchHdr(aHdrChanged, m_db, &match);
+
+  if (!match && plugin && !wasPlugin)
+    RemoveByIndex(index); // remove hdr from view
+  else
+    NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgQuickSearchDBView::GetSearchSession(nsIMsgSearchSession* *aSession)
+{
+  NS_ASSERTION(false, "GetSearchSession method is not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP
+nsMsgQuickSearchDBView::SetSearchSession(nsIMsgSearchSession *aSession)
+{
+  m_searchSession = do_GetWeakReference(aSession);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgQuickSearchDBView::OnSearchHit(nsIMsgDBHdr* aMsgHdr, nsIMsgFolder *folder)
+{
+  NS_ENSURE_ARG(aMsgHdr);
+  if (!m_db)
+    return NS_ERROR_NULL_POINTER;
+  // remember search hit and when search is done, reconcile cache
+  // with new hits;
+  m_hdrHits.AppendObject(aMsgHdr);
+  nsMsgKey key;
+  aMsgHdr->GetMessageKey(&key);
+  // Is FindKey going to be expensive here? A lot of hits could make
+  // it a little bit slow to search through the view for every hit.
+  if (m_cacheEmpty || FindKey(key, false) == nsMsgViewIndex_None)
+    return AddHdr(aMsgHdr); 
+  else
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgQuickSearchDBView::OnSearchDone(nsresult status)
+{
+  // We're a single-folder virtual folder if viewFolder != folder, and that is
+  // the only case in which we want to be messing about with a results cache
+  // or unread counts.
+  if (m_db && m_viewFolder && m_viewFolder != m_folder)
+  {
+    nsTArray<nsMsgKey> keyArray;
+    nsCString searchUri;
+    m_viewFolder->GetURI(searchUri);
+    uint32_t count = m_hdrHits.Count();
+    // Build up message keys. The hits are in descending order but the cache
+    // expects them to be in ascending key order.
+    for (uint32_t i = count; i > 0; i--)
+    {
+      nsMsgKey key;
+      m_hdrHits[i-1]->GetMessageKey(&key);
+      keyArray.AppendElement(key);
+    }
+    nsMsgKey *staleHits;
+    uint32_t numBadHits;
+    if (m_db)
+    {
+      nsresult rv = m_db->RefreshCache(searchUri.get(), m_hdrHits.Count(),
+                                       keyArray.Elements(), &numBadHits, &staleHits);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr<nsIMsgDBHdr> hdrDeleted;
+
+      for (uint32_t i = 0; i < numBadHits; i++)
+      {
+        m_db->GetMsgHdrForKey(staleHits[i], getter_AddRefs(hdrDeleted));
+        if (hdrDeleted)
+          OnHdrDeleted(hdrDeleted, nsMsgKey_None, 0, this);
+      }
+      delete [] staleHits;
+    }
+    nsCOMPtr<nsIMsgDatabase> virtDatabase;
+    nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+    nsresult rv = m_viewFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(virtDatabase));
+    NS_ENSURE_SUCCESS(rv, rv);
+    uint32_t numUnread = 0;
+    size_t numTotal = m_origKeys.Length();
+
+    for (size_t i = 0; i < m_origKeys.Length(); i++)
+    {
+      bool isRead;
+      m_db->IsRead(m_origKeys[i], &isRead);
+      if (!isRead)
+        numUnread++;
+    }
+    dbFolderInfo->SetNumUnreadMessages(numUnread);
+    dbFolderInfo->SetNumMessages(numTotal);
+    m_viewFolder->UpdateSummaryTotals(true); // force update from db.
+    virtDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  if (m_sortType != nsMsgViewSortType::byThread)//we do not find levels for the results.
+  {
+    m_sortValid = false;       //sort the results 
+    Sort(m_sortType, m_sortOrder);
+  }
+  if (m_viewFolder && (m_viewFolder != m_folder))
+    SetMRUTimeForFolder(m_viewFolder);
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgQuickSearchDBView::OnNewSearch()
+{
+  int32_t oldSize = GetSize();
+
+  m_keys.Clear();
+  m_levels.Clear();
+  m_flags.Clear();
+  m_hdrHits.Clear();
+  // this needs to happen after we remove all the keys, since RowCountChanged() will call our GetRowCount()
+  if (mTree)
+    mTree->RowCountChanged(0, -oldSize);
+  uint32_t folderFlags = 0;
+  if (m_viewFolder)
+    m_viewFolder->GetFlags(&folderFlags);
+  // check if it's a virtual folder - if so, we should get the cached hits 
+  // from the db, and set a flag saying that we're using cached values.
+  if (folderFlags & nsMsgFolderFlags::Virtual)
+  {
+    nsCOMPtr<nsISimpleEnumerator> cachedHits;
+    nsCString searchUri;
+    m_viewFolder->GetURI(searchUri);
+    m_db->GetCachedHits(searchUri.get(), getter_AddRefs(cachedHits));
+    if (cachedHits)
+    {
+      bool hasMore;
+
+      m_usingCachedHits = true;
+      cachedHits->HasMoreElements(&hasMore);
+      m_cacheEmpty = !hasMore;
+      if (mTree)
+        mTree->BeginUpdateBatch();
+      while (hasMore)
+      {
+        nsCOMPtr <nsISupports> supports;
+        nsresult rv = cachedHits->GetNext(getter_AddRefs(supports));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "nsMsgDBEnumerator broken");
+        nsCOMPtr <nsIMsgDBHdr> pHeader = do_QueryInterface(supports);
+        if (pHeader && NS_SUCCEEDED(rv))
+          AddHdr(pHeader);
+        else
+          break;
+        cachedHits->HasMoreElements(&hasMore);
+      }
+      if (mTree)
+        mTree->EndUpdateBatch();
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgQuickSearchDBView::GetFirstMessageHdrToDisplayInThread(nsIMsgThread *threadHdr, nsIMsgDBHdr **result)
+{
+  uint32_t numChildren;
+  nsresult rv = NS_OK;
+  uint8_t minLevel = 0xff;
+  threadHdr->GetNumChildren(&numChildren);
+  nsMsgKey threadRootKey;
+  nsCOMPtr<nsIMsgDBHdr> rootParent;
+  int32_t rootIndex;
+  threadHdr->GetRootHdr(&rootIndex, getter_AddRefs(rootParent));
+  if (rootParent)
+    rootParent->GetMessageKey(&threadRootKey);
+  else
+    threadHdr->GetThreadKey(&threadRootKey);
+
+  nsCOMPtr <nsIMsgDBHdr> retHdr;
+
+  // iterate over thread, finding mgsHdr in view with the lowest level.
+  for (uint32_t childIndex = 0; childIndex < numChildren; childIndex++)
+  {
+    nsCOMPtr <nsIMsgDBHdr> child;
+    rv = threadHdr->GetChildHdrAt(childIndex, getter_AddRefs(child));
+    if (NS_SUCCEEDED(rv) && child)
+    {
+      nsMsgKey msgKey;
+      child->GetMessageKey(&msgKey);
+
+      // this works because we've already sorted m_keys by id.
+      nsMsgViewIndex keyIndex = m_origKeys.BinaryIndexOf(msgKey);
+      if (keyIndex != nsMsgViewIndex_None)
+      {
+        // this is the root, so it's the best we're going to do.
+        if (msgKey == threadRootKey)
+        {
+          retHdr = child;
+          break;
+        }
+        uint8_t level = 0;
+        nsMsgKey parentId;
+        child->GetThreadParent(&parentId);
+        nsCOMPtr <nsIMsgDBHdr> parent;
+        // count number of ancestors - that's our level
+        while (parentId != nsMsgKey_None)
+        {
+          rv = m_db->GetMsgHdrForKey(parentId, getter_AddRefs(parent));
+          if (parent)
+          {
+            nsMsgKey saveParentId = parentId;
+            parent->GetThreadParent(&parentId);
+            // message is it's own parent - bad, let's break out of here.
+            // Or we've got some circular ancestry.
+            if (parentId == saveParentId || level > numChildren)
+              break;
+            level++;
+          }
+          else // if we can't find the parent, don't loop forever.
+            break;
+        }
+        if (level < minLevel)
+        {
+          minLevel = level;
+          retHdr = child;
+        }
+      }
+    }
+  }
+  NS_IF_ADDREF(*result = retHdr);
+  return NS_OK; 
+}
+
+nsresult nsMsgQuickSearchDBView::SortThreads(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder)
+{
+  // don't need to sort by threads for group view.
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+    return NS_OK;
+  // iterate over the messages in the view, getting the thread id's
+  // sort m_keys so we can quickly find if a key is in the view. 
+  m_keys.Sort();
+  // array of the threads' root hdr keys.
+  nsTArray<nsMsgKey> threadRootIds;
+  nsCOMPtr <nsIMsgDBHdr> rootHdr;
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  nsCOMPtr <nsIMsgThread> threadHdr;
+  for (uint32_t i = 0; i < m_keys.Length(); i++)
+  {
+    GetMsgHdrForViewIndex(i, getter_AddRefs(msgHdr));
+    m_db->GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(threadHdr));
+    if (threadHdr)
+    {
+      nsMsgKey rootKey;
+      threadHdr->GetChildKeyAt(0, &rootKey);
+      nsMsgViewIndex threadRootIndex = threadRootIds.BinaryIndexOf(rootKey);
+      // if we already have that id in top level threads, ignore this msg.
+      if (threadRootIndex != nsMsgViewIndex_None)
+        continue;
+      // it would be nice if GetInsertIndexHelper always found the hdr, but it doesn't.
+      threadHdr->GetChildHdrAt(0, getter_AddRefs(rootHdr));
+      if (!rootHdr)
+        continue;
+      threadRootIndex = GetInsertIndexHelper(rootHdr, threadRootIds, nullptr,
+                                             nsMsgViewSortOrder::ascending,
+                                             nsMsgViewSortType::byId);
+      threadRootIds.InsertElementAt(threadRootIndex, rootKey);
+    }
+  }
+
+  m_sortType = nsMsgViewSortType::byNone; // sort from scratch
+  // need to sort the top level threads now by sort order, if it's not by id
+  // and ascending (which is the order per above).
+  if (!(sortType == nsMsgViewSortType::byId &&
+        sortOrder == nsMsgViewSortOrder::ascending))
+  {
+    m_keys.SwapElements(threadRootIds);
+    nsMsgDBView::Sort(sortType, sortOrder);
+    threadRootIds.SwapElements(m_keys);
+  }
+  m_keys.Clear();
+  m_levels.Clear();
+  m_flags.Clear();
+  // now we've build up the list of thread ids - need to build the view
+  // from that. So for each thread id, we need to list the messages in the thread.
+  uint32_t numThreads = threadRootIds.Length();
+  for (uint32_t threadIndex = 0; threadIndex < numThreads; threadIndex++)
+  {
+    m_db->GetMsgHdrForKey(threadRootIds[threadIndex], getter_AddRefs(rootHdr));
+    if (rootHdr)
+    {
+      nsCOMPtr <nsIMsgDBHdr> displayRootHdr;
+      m_db->GetThreadContainingMsgHdr(rootHdr, getter_AddRefs(threadHdr));
+      if (threadHdr)
+      {
+        nsMsgKey rootKey;
+        uint32_t rootFlags;
+        GetFirstMessageHdrToDisplayInThread(threadHdr, getter_AddRefs(displayRootHdr));
+        if (!displayRootHdr)
+          continue;
+        displayRootHdr->GetMessageKey(&rootKey);
+        displayRootHdr->GetFlags(&rootFlags);
+        rootFlags |= MSG_VIEW_FLAG_ISTHREAD;
+        m_keys.AppendElement(rootKey);
+        m_flags.AppendElement(rootFlags);
+        m_levels.AppendElement(0);
+
+        nsMsgViewIndex startOfThreadViewIndex = m_keys.Length();
+        nsMsgViewIndex rootIndex = startOfThreadViewIndex - 1;
+        uint32_t numListed = 0;
+        ListIdsInThreadOrder(threadHdr, rootKey, 1, &startOfThreadViewIndex, &numListed);
+        if (numListed > 0)
+          m_flags[rootIndex] = rootFlags | MSG_VIEW_FLAG_HASCHILDREN;
+      }
+    }
+  }
+
+  // The thread state is left expanded (despite viewFlags) so at least reflect
+  // the correct state.
+  m_viewFlags |= nsMsgViewFlagsType::kExpandAll;
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgQuickSearchDBView::ListCollapsedChildren(nsMsgViewIndex viewIndex,
+                                              nsIMutableArray *messageArray)
+{
+  nsCOMPtr<nsIMsgThread> threadHdr; 
+  nsresult rv = GetThreadContainingIndex(viewIndex, getter_AddRefs(threadHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint32_t numChildren;
+  threadHdr->GetNumChildren(&numChildren);
+  nsCOMPtr<nsIMsgDBHdr> rootHdr;
+  nsMsgKey rootKey;
+  GetMsgHdrForViewIndex(viewIndex, getter_AddRefs(rootHdr));
+  rootHdr->GetMessageKey(&rootKey);
+  // group threads can have the root key twice, one for the dummy row.
+  bool rootKeySkipped = false;
+  for (uint32_t i = 0; i < numChildren; i++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    threadHdr->GetChildHdrAt(i, getter_AddRefs(msgHdr));
+    if (msgHdr)
+    {
+      nsMsgKey msgKey;
+      msgHdr->GetMessageKey(&msgKey);
+      if (msgKey != rootKey || (GroupViewUsesDummyRow() && rootKeySkipped))
+      {
+        // if this hdr is in the original view, add it to new view.
+        if (m_origKeys.BinaryIndexOf(msgKey) != m_origKeys.NoIndex)
+          messageArray->AppendElement(msgHdr, false);
+      }
+      else
+      {
+        rootKeySkipped = true;
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsMsgQuickSearchDBView::ListIdsInThread(nsIMsgThread *threadHdr, nsMsgViewIndex startOfThreadViewIndex, uint32_t *pNumListed)
+{
+
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay && ! (m_viewFlags & nsMsgViewFlagsType::kGroupBySort))
+  {
+    nsMsgKey parentKey = m_keys[startOfThreadViewIndex++];
+    return ListIdsInThreadOrder(threadHdr, parentKey, 1, &startOfThreadViewIndex, pNumListed);
+  }
+
+  uint32_t numChildren;
+  threadHdr->GetNumChildren(&numChildren);
+  uint32_t i;
+  uint32_t viewIndex = startOfThreadViewIndex + 1;
+  nsCOMPtr<nsIMsgDBHdr> rootHdr;
+  nsMsgKey rootKey;
+  uint32_t rootFlags = m_flags[startOfThreadViewIndex];
+  *pNumListed = 0;
+  GetMsgHdrForViewIndex(startOfThreadViewIndex, getter_AddRefs(rootHdr));
+  rootHdr->GetMessageKey(&rootKey);
+  // group threads can have the root key twice, one for the dummy row.
+  bool rootKeySkipped = false;
+  for (i = 0; i < numChildren; i++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    threadHdr->GetChildHdrAt(i, getter_AddRefs(msgHdr));
+    if (msgHdr != nullptr)
+    {
+      nsMsgKey msgKey;
+      msgHdr->GetMessageKey(&msgKey);
+      if (msgKey != rootKey || (GroupViewUsesDummyRow() && rootKeySkipped))
+      {
+        nsMsgViewIndex threadRootIndex = m_origKeys.BinaryIndexOf(msgKey);
+        // if this hdr is in the original view, add it to new view.
+        if (threadRootIndex != nsMsgViewIndex_None)
+        {
+          uint32_t childFlags;
+          msgHdr->GetFlags(&childFlags);
+          InsertMsgHdrAt(viewIndex, msgHdr, msgKey, childFlags, 
+                        FindLevelInThread(msgHdr, startOfThreadViewIndex, viewIndex));
+          if (! (rootFlags & MSG_VIEW_FLAG_HASCHILDREN))
+            m_flags[startOfThreadViewIndex] = rootFlags | MSG_VIEW_FLAG_HASCHILDREN;
+
+          viewIndex++;
+          (*pNumListed)++;
+        }
+      }
+      else
+      {
+        rootKeySkipped = true;
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgQuickSearchDBView::ListIdsInThreadOrder(nsIMsgThread *threadHdr,
+                                             nsMsgKey parentKey, uint32_t level,
+                                             uint32_t callLevel,
+                                             nsMsgKey keyToSkip,
+                                             nsMsgViewIndex *viewIndex,
+                                             uint32_t *pNumListed)
+{
+  nsCOMPtr <nsISimpleEnumerator> msgEnumerator;
+  nsresult rv = threadHdr->EnumerateMessages(parentKey, getter_AddRefs(msgEnumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  // We use the numChildren as a sanity check on the thread structure.
+  uint32_t numChildren;
+  (void) threadHdr->GetNumChildren(&numChildren);
+  bool hasMore;
+  nsCOMPtr <nsISupports> supports;
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  while (NS_SUCCEEDED(rv) && NS_SUCCEEDED(rv = msgEnumerator->HasMoreElements(&hasMore)) &&
+         hasMore)
+  {
+    rv = msgEnumerator->GetNext(getter_AddRefs(supports));
+    if (NS_SUCCEEDED(rv) && supports)
+    {
+      msgHdr = do_QueryInterface(supports);
+      nsMsgKey msgKey;
+      msgHdr->GetMessageKey(&msgKey);
+      if (msgKey == keyToSkip)
+        continue;
+
+      // If we discover depths of more than numChildren, it means we have
+      // some sort of circular thread relationship and we bail out of the
+      // while loop before overflowing the stack with recursive calls.
+      // Technically, this is an error, but forcing a database rebuild
+      // is too destructive so we just return.
+      if (*pNumListed > numChildren || callLevel > numChildren)
+      {
+        NS_ERROR("loop in message threading while listing children");
+        return NS_OK;
+      }
+
+      int32_t childLevel = level;
+      if (m_origKeys.BinaryIndexOf(msgKey) != m_origKeys.NoIndex)
+      {
+        uint32_t msgFlags;
+        msgHdr->GetFlags(&msgFlags);
+        InsertMsgHdrAt(*viewIndex, msgHdr, msgKey, msgFlags & ~MSG_VIEW_FLAGS, level);
+        (*pNumListed)++;
+        (*viewIndex)++;
+        childLevel++;
+      }
+      rv = ListIdsInThreadOrder(threadHdr, msgKey, childLevel, callLevel + 1,
+                                keyToSkip, viewIndex, pNumListed);
+    }
+  }
+  return rv;
+}
+
+nsresult
+nsMsgQuickSearchDBView::ListIdsInThreadOrder(nsIMsgThread *threadHdr,
+                                             nsMsgKey parentKey, uint32_t level,
+                                             nsMsgViewIndex *viewIndex,
+                                             uint32_t *pNumListed)
+{
+  nsresult rv = ListIdsInThreadOrder(threadHdr, parentKey, level, level,
+                                     nsMsgKey_None, viewIndex, pNumListed);
+  // Because a quick search view might not have the actual thread root
+  // as its root, and thus might have a message that potentially has siblings
+  // as its root, and the enumerator will miss the siblings, we might need to
+  // make a pass looking for the siblings of the non-root root. We'll put
+  // those after the potential children of the root. So we will list the children
+  // of the faux root's parent, ignoring the faux root.
+  if (level == 1)
+  {
+    nsCOMPtr<nsIMsgDBHdr> root;
+    nsCOMPtr<nsIMsgDBHdr> rootParent;
+    nsMsgKey rootKey;
+    int32_t rootIndex;
+    threadHdr->GetRootHdr(&rootIndex, getter_AddRefs(rootParent));
+    if (rootParent)
+    {
+      rootParent->GetMessageKey(&rootKey);
+      if (rootKey != parentKey)
+        rv = ListIdsInThreadOrder(threadHdr, rootKey, level, level, parentKey,
+                                  viewIndex, pNumListed);
+    }
+  }
+  return rv;
+}
+
+nsresult nsMsgQuickSearchDBView::ExpansionDelta(nsMsgViewIndex index, int32_t *expansionDelta)
+{
+  *expansionDelta = 0;
+  if (index >= ((nsMsgViewIndex) m_keys.Length()))
+    return NS_MSG_MESSAGE_NOT_FOUND;
+
+  char flags = m_flags[index];
+
+  if (!(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    return NS_OK;
+
+  nsCOMPtr<nsIMsgThread> threadHdr; 
+  nsresult rv = GetThreadContainingIndex(index, getter_AddRefs(threadHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint32_t numChildren;
+  threadHdr->GetNumChildren(&numChildren);
+  nsCOMPtr<nsIMsgDBHdr> rootHdr;
+  nsMsgKey rootKey;
+  GetMsgHdrForViewIndex(index, getter_AddRefs(rootHdr));
+  rootHdr->GetMessageKey(&rootKey);
+  // group threads can have the root key twice, one for the dummy row.
+  bool rootKeySkipped = false;
+  for (uint32_t i = 0; i < numChildren; i++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    threadHdr->GetChildHdrAt(i, getter_AddRefs(msgHdr));
+    if (msgHdr)
+    {
+      nsMsgKey msgKey;
+      msgHdr->GetMessageKey(&msgKey);
+      if (msgKey != rootKey || (GroupViewUsesDummyRow() && rootKeySkipped))
+      {
+        // if this hdr is in the original view, add it to new view.
+        if (m_origKeys.BinaryIndexOf(msgKey) != m_origKeys.NoIndex)
+          (*expansionDelta)++;
+      }
+      else
+      {
+        rootKeySkipped = true;
+      }
+    }
+  }
+  if (! (flags & nsMsgMessageFlags::Elided))
+    *expansionDelta = - (*expansionDelta);
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsMsgQuickSearchDBView::OpenWithHdrs(nsISimpleEnumerator *aHeaders, 
+                                     nsMsgViewSortTypeValue aSortType,
+                                     nsMsgViewSortOrderValue aSortOrder, 
+                                     nsMsgViewFlagsTypeValue aViewFlags,
+                                     int32_t *aCount)
+{
+  if (aViewFlags & nsMsgViewFlagsType::kGroupBySort)
+    return nsMsgGroupView::OpenWithHdrs(aHeaders, aSortType, aSortOrder, 
+                                        aViewFlags, aCount);
+
+  m_sortType = aSortType;
+  m_sortOrder = aSortOrder;
+  m_viewFlags = aViewFlags;
+
+  bool hasMore;
+  nsCOMPtr<nsISupports> supports;
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  nsresult rv = NS_OK;
+  while (NS_SUCCEEDED(rv = aHeaders->HasMoreElements(&hasMore)) && hasMore)
+  {
+    rv = aHeaders->GetNext(getter_AddRefs(supports));
+    if (NS_SUCCEEDED(rv) && supports)
+    {
+      msgHdr = do_QueryInterface(supports);
+      AddHdr(msgHdr); 
+    }
+    else
+      break;
+  }
+  *aCount = m_keys.Length();
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgQuickSearchDBView::SetViewFlags(nsMsgViewFlagsTypeValue aViewFlags)
+{
+  nsresult rv = NS_OK;
+  // if the grouping has changed, rebuild the view
+  if ((m_viewFlags & nsMsgViewFlagsType::kGroupBySort) ^
+      (aViewFlags & nsMsgViewFlagsType::kGroupBySort))
+    rv = RebuildView(aViewFlags);
+  nsMsgDBView::SetViewFlags(aViewFlags);
+
+  return rv;
+}
+
+nsresult 
+nsMsgQuickSearchDBView::GetMessageEnumerator(nsISimpleEnumerator **enumerator)
+{
+  return GetViewEnumerator(enumerator);
+}
+
+NS_IMETHODIMP
+nsMsgQuickSearchDBView::OnHdrDeleted(nsIMsgDBHdr *aHdrDeleted,
+                                     nsMsgKey aParentKey,
+                                     int32_t aFlags,
+                                     nsIDBChangeListener *aInstigator)
+{
+  NS_ENSURE_ARG_POINTER(aHdrDeleted);
+  nsMsgKey msgKey;
+  aHdrDeleted->GetMessageKey(&msgKey);
+  size_t keyIndex = m_origKeys.BinaryIndexOf(msgKey);
+  if (keyIndex != m_origKeys.NoIndex)
+    m_origKeys.RemoveElementAt(keyIndex);
+  return nsMsgThreadedDBView::OnHdrDeleted(aHdrDeleted, aParentKey, aFlags,
+                                           aInstigator);
+}
+
+NS_IMETHODIMP nsMsgQuickSearchDBView::GetNumMsgsInView(int32_t *aNumMsgs)
+{
+  NS_ENSURE_ARG_POINTER(aNumMsgs);
+  *aNumMsgs = m_origKeys.Length();
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMsgQuickSearchDBView.h b/mailnews/base/src/nsMsgQuickSearchDBView.h
new file mode 100644
index 000000000..1db04a627
--- /dev/null
+++ b/mailnews/base/src/nsMsgQuickSearchDBView.h
@@ -0,0 +1,87 @@
+/* -*- 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 _nsMsgQuickSearchDBView_H_
+#define _nsMsgQuickSearchDBView_H_
+
+#include "mozilla/Attributes.h"
+#include "nsMsgThreadedDBView.h"
+#include "nsIMsgSearchNotify.h"
+#include "nsIMsgSearchSession.h"
+#include "nsCOMArray.h"
+#include "nsIMsgHdr.h"
+
+
+class nsMsgQuickSearchDBView : public nsMsgThreadedDBView, public nsIMsgSearchNotify
+{
+public:
+  nsMsgQuickSearchDBView();
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIMSGSEARCHNOTIFY
+
+  virtual const char * GetViewName(void) override {return "QuickSearchView"; }
+  NS_IMETHOD Open(nsIMsgFolder *folder, nsMsgViewSortTypeValue sortType, 
+                  nsMsgViewSortOrderValue sortOrder, 
+                  nsMsgViewFlagsTypeValue viewFlags, int32_t *pCount) override;
+  NS_IMETHOD OpenWithHdrs(nsISimpleEnumerator *aHeaders, 
+                          nsMsgViewSortTypeValue aSortType, 
+                          nsMsgViewSortOrderValue aSortOrder, 
+                          nsMsgViewFlagsTypeValue aViewFlags, 
+                          int32_t *aCount) override;
+  NS_IMETHOD CloneDBView(nsIMessenger *aMessengerInstance,
+                         nsIMsgWindow *aMsgWindow,
+                         nsIMsgDBViewCommandUpdater *aCommandUpdater,
+                         nsIMsgDBView **_retval) override;
+  NS_IMETHOD CopyDBView(nsMsgDBView *aNewMsgDBView,
+                        nsIMessenger *aMessengerInstance,
+                        nsIMsgWindow *aMsgWindow,
+                        nsIMsgDBViewCommandUpdater *aCmdUpdater) override;
+  NS_IMETHOD DoCommand(nsMsgViewCommandTypeValue aCommand) override;
+  NS_IMETHOD GetViewType(nsMsgViewTypeValue *aViewType) override;
+  NS_IMETHOD SetViewFlags(nsMsgViewFlagsTypeValue aViewFlags) override;
+  NS_IMETHOD SetSearchSession(nsIMsgSearchSession *aSearchSession) override;
+  NS_IMETHOD GetSearchSession(nsIMsgSearchSession* *aSearchSession) override;
+  NS_IMETHOD OnHdrFlagsChanged(nsIMsgDBHdr *aHdrChanged, uint32_t aOldFlags, 
+                               uint32_t aNewFlags, nsIDBChangeListener *aInstigator) override;
+  NS_IMETHOD OnHdrPropertyChanged(nsIMsgDBHdr *aHdrToChange, bool aPreChange, uint32_t *aStatus, 
+                                  nsIDBChangeListener * aInstigator) override;
+  NS_IMETHOD OnHdrDeleted(nsIMsgDBHdr *aHdrDeleted, nsMsgKey aParentKey,
+                          int32_t aFlags, nsIDBChangeListener *aInstigator) override;
+  NS_IMETHOD GetNumMsgsInView(int32_t *aNumMsgs) override;
+
+protected:
+  virtual ~nsMsgQuickSearchDBView();
+  nsWeakPtr m_searchSession;
+  nsTArray<nsMsgKey> m_origKeys;
+  bool      m_usingCachedHits;
+  bool      m_cacheEmpty;
+  nsCOMArray <nsIMsgDBHdr> m_hdrHits;
+  virtual nsresult AddHdr(nsIMsgDBHdr *msgHdr, nsMsgViewIndex *resultIndex = nullptr) override;
+  virtual nsresult OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey aParentKey, bool ensureListed) override;
+  virtual nsresult DeleteMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool deleteStorage) override;
+  virtual nsresult SortThreads(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder) override;
+  virtual nsresult GetFirstMessageHdrToDisplayInThread(nsIMsgThread *threadHdr, nsIMsgDBHdr **result) override;
+  virtual nsresult ExpansionDelta(nsMsgViewIndex index, int32_t *expansionDelta) override;
+  virtual nsresult ListCollapsedChildren(nsMsgViewIndex viewIndex,
+                                         nsIMutableArray *messageArray) override;
+  virtual nsresult ListIdsInThread(nsIMsgThread *threadHdr, nsMsgViewIndex startOfThreadViewIndex, uint32_t *pNumListed) override;
+  virtual nsresult ListIdsInThreadOrder(nsIMsgThread *threadHdr,
+                                        nsMsgKey parentKey, uint32_t level,
+                                        nsMsgViewIndex *viewIndex,
+                                        uint32_t *pNumListed) override;
+  virtual nsresult ListIdsInThreadOrder(nsIMsgThread *threadHdr,
+                                        nsMsgKey parentKey, uint32_t level,
+                                        uint32_t callLevel,
+                                        nsMsgKey keyToSkip,
+                                        nsMsgViewIndex *viewIndex,
+                                        uint32_t *pNumListed);
+  virtual nsresult GetMessageEnumerator(nsISimpleEnumerator **enumerator) override;
+  void      SavePreSearchInfo();
+  void      ClearPreSearchInfo();
+
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgRDFDataSource.cpp b/mailnews/base/src/nsMsgRDFDataSource.cpp
new file mode 100644
index 000000000..5cdbf5cc6
--- /dev/null
+++ b/mailnews/base/src/nsMsgRDFDataSource.cpp
@@ -0,0 +1,371 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgRDFDataSource.h"
+#include "nsRDFCID.h"
+#include "rdf.h"
+#include "plstr.h"
+#include "nsMsgRDFUtils.h"
+#include "nsEnumeratorUtils.h"
+#include "nsIObserverService.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Services.h"
+
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+
+nsMsgRDFDataSource::nsMsgRDFDataSource():
+    m_shuttingDown(false),
+    mInitialized(false)
+{
+}
+
+nsMsgRDFDataSource::~nsMsgRDFDataSource()
+{
+  // final shutdown happens here
+  NS_ASSERTION(!mInitialized, "Object going away without cleanup, possibly dangerous!");
+  if (mInitialized) Cleanup();
+}
+
+/* initialization happens here - object is constructed,
+   but possibly partially shut down
+*/
+nsresult
+nsMsgRDFDataSource::Init()
+{
+  NS_ENSURE_TRUE(!mInitialized, NS_ERROR_ALREADY_INITIALIZED);
+
+  nsresult rv;
+  /* Add an observer to XPCOM shutdown */
+  nsCOMPtr<nsIObserverService> obs =
+    mozilla::services::GetObserverService();
+  NS_ENSURE_TRUE(obs, NS_ERROR_UNEXPECTED);
+  rv = obs->AddObserver(static_cast<nsIObserver*>(this), NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  getRDFService();
+
+  mInitialized=true;
+  return rv;
+}
+
+void nsMsgRDFDataSource::Cleanup()
+{
+  mRDFService = nullptr;
+
+  // release the window
+  mWindow = nullptr;
+
+  mInitialized = false;
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsMsgRDFDataSource)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsMsgRDFDataSource)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mObservers)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mRDFService)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsMsgRDFDataSource)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObservers)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRDFService)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsMsgRDFDataSource)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsMsgRDFDataSource)
+
+NS_INTERFACE_MAP_BEGIN(nsMsgRDFDataSource)
+  NS_INTERFACE_MAP_ENTRY(nsIRDFDataSource)
+  NS_INTERFACE_MAP_ENTRY(nsIObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIMsgRDFDataSource)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIRDFDataSource)
+  NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsMsgRDFDataSource)
+NS_INTERFACE_MAP_END
+
+/* readonly attribute string URI; */
+NS_IMETHODIMP
+nsMsgRDFDataSource::GetURI(char * *aURI)
+{
+    NS_NOTREACHED("should be implemented by a subclass");
+    return NS_ERROR_UNEXPECTED;
+}
+
+
+/* nsIRDFResource GetSource (in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::GetSource(nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue, nsIRDFResource **_retval)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* nsISimpleEnumerator GetSources (in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::GetSources(nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue, nsISimpleEnumerator **_retval)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* nsIRDFNode GetTarget (in nsIRDFResource aSource, in nsIRDFResource aProperty, in boolean aTruthValue); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::GetTarget(nsIRDFResource *aSource, nsIRDFResource *aProperty, bool aTruthValue, nsIRDFNode **_retval)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* nsISimpleEnumerator GetTargets (in nsIRDFResource aSource, in nsIRDFResource aProperty, in boolean aTruthValue); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::GetTargets(nsIRDFResource *aSource, nsIRDFResource *aProperty, bool aTruthValue, nsISimpleEnumerator **_retval)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* void Assert (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::Assert(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* void Unassert (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::Unassert(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+NS_IMETHODIMP
+nsMsgRDFDataSource::Change(nsIRDFResource *aSource,
+                           nsIRDFResource *aProperty,
+                           nsIRDFNode *aOldTarget,
+                           nsIRDFNode *aNewTarget)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+NS_IMETHODIMP
+nsMsgRDFDataSource::Move(nsIRDFResource *aOldSource,
+                         nsIRDFResource *aNewSource,
+                         nsIRDFResource *aProperty,
+                         nsIRDFNode *aTarget)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* boolean HasAssertion (in nsIRDFResource aSource, in nsIRDFResource aProperty, in nsIRDFNode aTarget, in boolean aTruthValue); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::HasAssertion(nsIRDFResource *aSource, nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue, bool *_retval)
+{
+    *_retval = false;
+    return NS_OK;
+}
+
+
+/* void AddObserver (in nsIRDFObserver aObserver); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::AddObserver(nsIRDFObserver *aObserver)
+{
+  NS_ENSURE_ARG_POINTER(aObserver);
+  if (!mInitialized)
+      Init();
+  mObservers.AppendObject(aObserver);
+  return NS_OK;
+}
+
+/* void RemoveObserver (in nsIRDFObserver aObserver); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::RemoveObserver(nsIRDFObserver *aObserver)
+{
+  NS_ENSURE_ARG_POINTER(aObserver);
+  mObservers.RemoveObject(aObserver);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgRDFDataSource::HasArcIn(nsIRDFNode *aNode, nsIRDFResource *aArc, bool *result)
+{
+  *result = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgRDFDataSource::HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, bool *result)
+{
+  *result = false;
+  return NS_OK;
+}
+
+/* nsISimpleEnumerator ArcLabelsIn (in nsIRDFNode aNode); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::ArcLabelsIn(nsIRDFNode *aNode, nsISimpleEnumerator **_retval)
+{
+  return NS_NewEmptyEnumerator(_retval);
+}
+
+
+/* nsISimpleEnumerator ArcLabelsOut (in nsIRDFResource aSource); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::ArcLabelsOut(nsIRDFResource *aSource, nsISimpleEnumerator **_retval)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* nsISimpleEnumerator GetAllResources (); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::GetAllResources(nsISimpleEnumerator **_retval)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* nsISimpleEnumerator GetAllCmds (in nsIRDFResource aSource); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::GetAllCmds(nsIRDFResource *aSource, nsISimpleEnumerator **_retval)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* boolean IsCommandEnabled (in nsISupports aSources, in nsIRDFResource aCommand, in nsISupports aArguments); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::IsCommandEnabled(nsISupports *aSources, nsIRDFResource *aCommand, nsISupports *aArguments, bool *_retval)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+
+/* void DoCommand (in nsISupports aSources, in nsIRDFResource aCommand, in nsISupports aArguments); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::DoCommand(nsISupports *aSources, nsIRDFResource *aCommand, nsISupports *aArguments)
+{
+    return NS_RDF_NO_VALUE;
+}
+
+/* void BeginUpdateBatch (); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::BeginUpdateBatch()
+{
+    return NS_OK;
+}
+
+/* void EndUpdateBatch (); */
+NS_IMETHODIMP
+nsMsgRDFDataSource::EndUpdateBatch()
+{
+    return NS_OK;
+}
+
+
+/* XPCOM Shutdown observer */
+NS_IMETHODIMP
+nsMsgRDFDataSource::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *someData )
+{
+  if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
+    m_shuttingDown = true;
+    Cleanup();
+  }
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMsgRDFDataSource::GetWindow(nsIMsgWindow * *aWindow)
+{
+  if(!aWindow)
+    return NS_ERROR_NULL_POINTER;
+
+  *aWindow = mWindow;
+  NS_IF_ADDREF(*aWindow);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgRDFDataSource::SetWindow(nsIMsgWindow * aWindow)
+{
+  mWindow = aWindow;
+  return NS_OK;
+}
+
+
+nsIRDFService *
+nsMsgRDFDataSource::getRDFService()
+{
+    if (!mRDFService && !m_shuttingDown) {
+        nsresult rv;
+        mRDFService = do_GetService(kRDFServiceCID, &rv);
+        if (NS_FAILED(rv)) return nullptr;
+    }
+
+    return mRDFService;
+}
+
+nsresult nsMsgRDFDataSource::NotifyPropertyChanged(nsIRDFResource *resource,
+                                                   nsIRDFResource *propertyResource,
+                                                   nsIRDFNode *newNode,
+                                                   nsIRDFNode *oldNode /* = nullptr */)
+{
+
+  NotifyObservers(resource, propertyResource, newNode, oldNode, false, true);
+  return NS_OK;
+
+}
+
+nsresult nsMsgRDFDataSource::NotifyObservers(nsIRDFResource *subject,
+                                                nsIRDFResource *property,
+                                                nsIRDFNode *newObject,
+                                                nsIRDFNode *oldObject,
+                                                bool assert, bool change)
+{
+  NS_ASSERTION(!(change && assert),
+               "Can't change and assert at the same time!\n");
+  nsMsgRDFNotification note = { this, subject, property, newObject, oldObject };
+  if(change)
+    mObservers.EnumerateForwards(changeEnumFunc, &note);
+  else if (assert)
+    mObservers.EnumerateForwards(assertEnumFunc, &note);
+  else
+    mObservers.EnumerateForwards(unassertEnumFunc, &note);
+  return NS_OK;
+}
+
+bool
+nsMsgRDFDataSource::assertEnumFunc(nsIRDFObserver *aObserver, void *aData)
+{
+  nsMsgRDFNotification *note = (nsMsgRDFNotification *)aData;
+  aObserver->OnAssert(note->datasource,
+                     note->subject,
+                     note->property,
+                     note->newObject);
+  return true;
+}
+
+bool
+nsMsgRDFDataSource::unassertEnumFunc(nsIRDFObserver *aObserver, void *aData)
+{
+  nsMsgRDFNotification* note = (nsMsgRDFNotification *)aData;
+  aObserver->OnUnassert(note->datasource,
+                       note->subject,
+                       note->property,
+                       note->newObject);
+  return true;
+}
+
+bool
+nsMsgRDFDataSource::changeEnumFunc(nsIRDFObserver *aObserver, void *aData)
+{
+  nsMsgRDFNotification* note = (nsMsgRDFNotification *)aData;
+  aObserver->OnChange(note->datasource,
+                     note->subject,
+                     note->property,
+                     note->oldObject, note->newObject);
+  return true;
+}
diff --git a/mailnews/base/src/nsMsgRDFDataSource.h b/mailnews/base/src/nsMsgRDFDataSource.h
new file mode 100644
index 000000000..636ebb60a
--- /dev/null
+++ b/mailnews/base/src/nsMsgRDFDataSource.h
@@ -0,0 +1,66 @@
+/* -*- 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 __nsMsgRDFDataSource_h
+#define __nsMsgRDFDataSource_h
+
+#include "nsCOMPtr.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFService.h"
+#include "nsIServiceManager.h"
+#include "nsCOMArray.h"
+#include "nsIObserver.h"
+#include "nsITransactionManager.h"
+#include "nsIMsgWindow.h"
+#include "nsIMsgRDFDataSource.h"
+#include "nsWeakReference.h"
+#include "nsCycleCollectionParticipant.h"
+
+class nsMsgRDFDataSource : public nsIRDFDataSource,
+                           public nsIObserver,
+                           public nsSupportsWeakReference,
+                           public nsIMsgRDFDataSource
+{
+ public:
+  nsMsgRDFDataSource();
+  virtual nsresult Init();
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsMsgRDFDataSource,
+                                           nsIRDFDataSource)
+  NS_DECL_NSIMSGRDFDATASOURCE
+  NS_DECL_NSIRDFDATASOURCE
+  NS_DECL_NSIOBSERVER
+
+  // called to reset the datasource to an empty state
+  // if you need to release yourself as an observer/listener, do it here
+  virtual void Cleanup();
+
+ protected:
+  virtual ~nsMsgRDFDataSource();
+  nsIRDFService *getRDFService();
+  static bool assertEnumFunc(nsIRDFObserver *aObserver, void *aData);
+  static bool unassertEnumFunc(nsIRDFObserver *aObserver, void *aData);
+  static bool changeEnumFunc(nsIRDFObserver *aObserver, void *aData);
+  nsresult  NotifyObservers(nsIRDFResource *subject, nsIRDFResource *property,
+                            nsIRDFNode *newObject, nsIRDFNode *oldObject, 
+                            bool assert, bool change);
+
+  virtual nsresult NotifyPropertyChanged(nsIRDFResource *resource, 
+                    nsIRDFResource *propertyResource, nsIRDFNode *newNode, 
+                    nsIRDFNode *oldNode = nullptr);
+
+  nsCOMPtr<nsIMsgWindow> mWindow;
+
+  bool m_shuttingDown;
+  bool mInitialized;
+
+ private:
+  nsCOMPtr<nsIRDFService> mRDFService;
+  nsCOMArray<nsIRDFObserver> mObservers;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgRDFUtils.cpp b/mailnews/base/src/nsMsgRDFUtils.cpp
new file mode 100644
index 000000000..3202c73c9
--- /dev/null
+++ b/mailnews/base/src/nsMsgRDFUtils.cpp
@@ -0,0 +1,82 @@
+/* -*- 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 "nsMsgRDFUtils.h"
+#include "nsIServiceManager.h"
+#include "prprf.h"
+#include "nsCOMPtr.h"
+#include "nsMemory.h"
+
+nsresult createNode(const char16_t *str, nsIRDFNode **node, nsIRDFService *rdfService)
+{
+  nsresult rv;
+  nsCOMPtr<nsIRDFLiteral> value;
+
+  NS_ASSERTION(rdfService, "rdfService is null");
+  if (!rdfService) return NS_OK;
+
+  if (str) {
+    rv = rdfService->GetLiteral(str, getter_AddRefs(value));
+  } 
+  else {
+    rv = rdfService->GetLiteral(EmptyString().get(), getter_AddRefs(value));
+  }
+
+  if (NS_SUCCEEDED(rv)) {
+    *node = value;
+    NS_IF_ADDREF(*node);
+  }
+  return rv;
+}
+
+nsresult createIntNode(int32_t value, nsIRDFNode **node, nsIRDFService *rdfService)
+{
+  *node = nullptr;
+  nsresult rv; 
+  if (!rdfService) return NS_ERROR_NULL_POINTER;  
+  nsCOMPtr<nsIRDFInt> num;
+  rv = rdfService->GetIntLiteral(value, getter_AddRefs(num));
+  if(NS_SUCCEEDED(rv)) {
+    *node = num;
+    NS_IF_ADDREF(*node);
+  }
+  return rv;
+}
+
+nsresult createBlobNode(uint8_t *value, uint32_t &length, nsIRDFNode **node, nsIRDFService *rdfService)
+{
+  NS_ENSURE_ARG_POINTER(node);
+  NS_ENSURE_ARG_POINTER(rdfService);
+  
+  *node = nullptr;
+  nsCOMPtr<nsIRDFBlob> blob;
+  nsresult rv = rdfService->GetBlobLiteral(value, length, getter_AddRefs(blob));
+  NS_ENSURE_SUCCESS(rv,rv);
+  NS_IF_ADDREF(*node = blob);
+  return rv;
+}
+
+nsresult GetTargetHasAssertion(nsIRDFDataSource *dataSource, nsIRDFResource* folderResource,
+                               nsIRDFResource *property,bool tv, nsIRDFNode *target,bool* hasAssertion)
+{
+  NS_ENSURE_ARG_POINTER(hasAssertion);
+  
+  nsCOMPtr<nsIRDFNode> currentTarget;
+  
+  nsresult rv = dataSource->GetTarget(folderResource, property,tv, getter_AddRefs(currentTarget));
+  if(NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIRDFLiteral> value1(do_QueryInterface(target));
+    nsCOMPtr<nsIRDFLiteral> value2(do_QueryInterface(currentTarget));
+    if(value1 && value2)
+      //If the two values are equal then it has this assertion
+      *hasAssertion = (value1 == value2);
+  }
+  else
+    rv = NS_NOINTERFACE;
+  
+  return rv;
+  
+}
+
diff --git a/mailnews/base/src/nsMsgRDFUtils.h b/mailnews/base/src/nsMsgRDFUtils.h
new file mode 100644
index 000000000..3694ccc3b
--- /dev/null
+++ b/mailnews/base/src/nsMsgRDFUtils.h
@@ -0,0 +1,104 @@
+/* -*- 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/. */
+
+//This file holds some useful utility functions and declarations used by our datasources.
+
+#include "rdf.h"
+#include "nsIRDFResource.h"
+#include "nsIRDFNode.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFService.h"
+#include "nsStringGlue.h"
+
+// this is used for notification of observers using nsVoidArray
+typedef struct _nsMsgRDFNotification {
+  nsIRDFDataSource *datasource;
+  nsIRDFResource *subject;
+  nsIRDFResource *property;
+  nsIRDFNode *newObject;
+  nsIRDFNode *oldObject;
+} nsMsgRDFNotification;
+
+//Some property declarations
+
+#define NC_RDF_CHILD				NC_NAMESPACE_URI "child"
+#define NC_RDF_NAME					NC_NAMESPACE_URI "Name"
+#define NC_RDF_OPEN					NC_NAMESPACE_URI "open"
+#define NC_RDF_FOLDERTREENAME		NC_NAMESPACE_URI "FolderTreeName"
+#define NC_RDF_FOLDERTREESIMPLENAME		NC_NAMESPACE_URI "FolderTreeSimpleName"
+#define NC_RDF_FOLDER				NC_NAMESPACE_URI "Folder"
+#define NC_RDF_SPECIALFOLDER		NC_NAMESPACE_URI "SpecialFolder"
+#define NC_RDF_SERVERTYPE			NC_NAMESPACE_URI "ServerType"
+#define NC_RDF_CANCREATEFOLDERSONSERVER	NC_NAMESPACE_URI "CanCreateFoldersOnServer"
+#define NC_RDF_CANFILEMESSAGESONSERVER	NC_NAMESPACE_URI "CanFileMessagesOnServer"
+#define NC_RDF_ISSERVER				NC_NAMESPACE_URI "IsServer"
+#define NC_RDF_ISSECURE             NC_NAMESPACE_URI "IsSecure"
+#define NC_RDF_CANSUBSCRIBE			NC_NAMESPACE_URI "CanSubscribe"
+#define NC_RDF_SUPPORTSOFFLINE                  NC_NAMESPACE_URI "SupportsOffline"
+#define NC_RDF_CANFILEMESSAGES			NC_NAMESPACE_URI "CanFileMessages"
+#define NC_RDF_CANCREATESUBFOLDERS			NC_NAMESPACE_URI "CanCreateSubfolders"
+#define NC_RDF_CANRENAME			NC_NAMESPACE_URI "CanRename"
+#define NC_RDF_CANCOMPACT			NC_NAMESPACE_URI "CanCompact"
+#define NC_RDF_TOTALMESSAGES		NC_NAMESPACE_URI "TotalMessages"
+#define NC_RDF_TOTALUNREADMESSAGES	NC_NAMESPACE_URI "TotalUnreadMessages"
+#define NC_RDF_FOLDERSIZE               NC_NAMESPACE_URI "FolderSize"
+#define NC_RDF_CHARSET				NC_NAMESPACE_URI "Charset"
+#define NC_RDF_BIFFSTATE			NC_NAMESPACE_URI "BiffState"
+#define NC_RDF_HASUNREADMESSAGES	NC_NAMESPACE_URI "HasUnreadMessages"
+#define NC_RDF_SUBFOLDERSHAVEUNREADMESSAGES NC_NAMESPACE_URI "SubfoldersHaveUnreadMessages"
+#define NC_RDF_NOSELECT       NC_NAMESPACE_URI "NoSelect"
+#define NC_RDF_VIRTUALFOLDER   NC_NAMESPACE_URI "Virtual"
+#define NC_RDF_INVFEDITSEARCHSCOPE   NC_NAMESPACE_URI "InVFEditSearchScope"
+#define NC_RDF_IMAPSHARED     NC_NAMESPACE_URI "ImapShared"
+#define NC_RDF_NEWMESSAGES			NC_NAMESPACE_URI "NewMessages"
+#define NC_RDF_SYNCHRONIZE          NC_NAMESPACE_URI "Synchronize"
+#define NC_RDF_SYNCDISABLED         NC_NAMESPACE_URI "SyncDisabled"
+#define NC_RDF_KEY                      NC_NAMESPACE_URI "Key"
+#define NC_RDF_CANSEARCHMESSAGES			NC_NAMESPACE_URI "CanSearchMessages"
+#define NC_RDF_ISDEFERRED NC_NAMESPACE_URI "IsDeferred"
+
+//Sort Properties
+#define NC_RDF_SUBJECT_COLLATION_SORT	NC_NAMESPACE_URI "Subject?collation=true"
+#define NC_RDF_SENDER_COLLATION_SORT	NC_NAMESPACE_URI "Sender?collation=true"
+#define NC_RDF_RECIPIENT_COLLATION_SORT	NC_NAMESPACE_URI "Recipient?collation=true"
+#define NC_RDF_ORDERRECEIVED_SORT		NC_NAMESPACE_URI "OrderReceived?sort=true"
+#define NC_RDF_PRIORITY_SORT			NC_NAMESPACE_URI "Priority?sort=true"
+#define NC_RDF_DATE_SORT                NC_NAMESPACE_URI "Date?sort=true"
+#define NC_RDF_SIZE_SORT				NC_NAMESPACE_URI "Size?sort=true"
+#define NC_RDF_ISUNREAD_SORT			NC_NAMESPACE_URI "IsUnread?sort=true"
+#define NC_RDF_FLAGGED_SORT				NC_NAMESPACE_URI "Flagged?sort=true"
+
+#define NC_RDF_NAME_SORT				NC_NAMESPACE_URI "Name?sort=true"
+#define NC_RDF_FOLDERTREENAME_SORT		NC_NAMESPACE_URI "FolderTreeName?sort=true"
+
+//Folder Commands
+#define NC_RDF_DELETE				NC_NAMESPACE_URI "Delete"
+#define NC_RDF_REALLY_DELETE		NC_NAMESPACE_URI "ReallyDelete"
+#define NC_RDF_NEWFOLDER			NC_NAMESPACE_URI "NewFolder"
+#define NC_RDF_GETNEWMESSAGES		NC_NAMESPACE_URI "GetNewMessages"
+#define NC_RDF_COPY					NC_NAMESPACE_URI "Copy"
+#define NC_RDF_MOVE					NC_NAMESPACE_URI "Move"
+#define NC_RDF_COPYFOLDER			NC_NAMESPACE_URI "CopyFolder"
+#define NC_RDF_MOVEFOLDER			NC_NAMESPACE_URI "MoveFolder"
+#define NC_RDF_MARKALLMESSAGESREAD  NC_NAMESPACE_URI "MarkAllMessagesRead"
+#define NC_RDF_COMPACT				NC_NAMESPACE_URI "Compact"
+#define NC_RDF_COMPACTALL			NC_NAMESPACE_URI "CompactAll"
+#define NC_RDF_RENAME				NC_NAMESPACE_URI "Rename"
+#define NC_RDF_EMPTYTRASH   NC_NAMESPACE_URI "EmptyTrash"
+
+
+nsresult createNode(const char16_t *str, nsIRDFNode **, nsIRDFService *rdfService);
+
+//Given an int32_t creates an nsIRDFNode that is really an int literal.
+nsresult createIntNode(int32_t value, nsIRDFNode **node, nsIRDFService *rdfService);
+
+//Given an nsIRDFBlob creates an nsIRDFNode that is really an blob literal.
+nsresult createBlobNode(uint8_t *value, uint32_t &length,  nsIRDFNode **node, nsIRDFService *rdfService);
+
+//s Assertion for a datasource that will just call GetTarget on property.  When all of our 
+//datasource derive from our datasource baseclass, this should be moved there and the first
+//parameter will no longer be needed.
+nsresult GetTargetHasAssertion(nsIRDFDataSource *dataSource, nsIRDFResource* folderResource,
+							   nsIRDFResource *property,bool tv, nsIRDFNode *target,bool* hasAssertion);
diff --git a/mailnews/base/src/nsMsgSearchDBView.cpp b/mailnews/base/src/nsMsgSearchDBView.cpp
new file mode 100644
index 000000000..02cdb6ff6
--- /dev/null
+++ b/mailnews/base/src/nsMsgSearchDBView.cpp
@@ -0,0 +1,1433 @@
+/* -*- 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 "nsMsgSearchDBView.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgThread.h"
+#include "nsQuickSort.h"
+#include "nsIDBFolderInfo.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMsgCopyService.h"
+#include "nsICopyMsgStreamListener.h"
+#include "nsMsgUtils.h"
+#include "nsITreeColumns.h"
+#include "nsIMsgMessageService.h"
+#include "nsArrayUtils.h"
+#include "nsIMutableArray.h"
+#include "nsMsgGroupThread.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMsgSearchSession.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+
+static bool gReferenceOnlyThreading;
+
+nsMsgSearchDBView::nsMsgSearchDBView()
+{
+  // don't try to display messages for the search pane.
+  mSuppressMsgDisplay = true;
+  m_totalMessagesInView = 0;
+  m_nextThreadId = 1;
+}
+
+nsMsgSearchDBView::~nsMsgSearchDBView()
+{	
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsMsgSearchDBView, nsMsgDBView, nsIMsgDBView, 
+                             nsIMsgCopyServiceListener, nsIMsgSearchNotify)
+
+NS_IMETHODIMP nsMsgSearchDBView::Open(nsIMsgFolder *folder, 
+                                      nsMsgViewSortTypeValue sortType, 
+                                      nsMsgViewSortOrderValue sortOrder, 
+                                      nsMsgViewFlagsTypeValue viewFlags, 
+                                      int32_t *pCount)
+{
+  // dbViewWrapper.js likes to create search views with a sort order
+  // of byNone, in order to have the order be the order the search results
+  // are returned. But this doesn't work with threaded view, so make the
+  // sort order be byDate if we're threaded.
+
+  if (viewFlags & nsMsgViewFlagsType::kThreadedDisplay &&
+      sortType == nsMsgViewSortType::byNone)
+    sortType = nsMsgViewSortType::byDate;
+
+  nsresult rv = nsMsgDBView::Open(folder, sortType, sortOrder, 
+                                    viewFlags, pCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+  prefBranch->GetBoolPref("mail.strict_threading", &gReferenceOnlyThreading);
+
+  // our sort is automatically valid because we have no contents at this point!
+  m_sortValid = true;
+
+    if (pCount)
+      *pCount = 0;
+    m_folder = nullptr;
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater, nsIMsgDBView **_retval)
+{
+  nsMsgSearchDBView* newMsgDBView = new nsMsgSearchDBView();
+
+  if (!newMsgDBView)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv = CopyDBView(newMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  NS_IF_ADDREF(*_retval = newMsgDBView);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::CopyDBView(nsMsgDBView *aNewMsgDBView, nsIMessenger *aMessengerInstance, 
+                                       nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater)
+{
+  nsMsgGroupView::CopyDBView(aNewMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  nsMsgSearchDBView* newMsgDBView = (nsMsgSearchDBView *) aNewMsgDBView;
+
+  // now copy all of our private member data
+  newMsgDBView->mDestFolder = mDestFolder;
+  newMsgDBView->mCommand = mCommand;
+  newMsgDBView->mTotalIndices = mTotalIndices;
+  newMsgDBView->mCurIndex = mCurIndex;
+  newMsgDBView->m_folders.InsertObjectsAt(m_folders, 0);
+  newMsgDBView->m_curCustomColumn = m_curCustomColumn;
+  newMsgDBView->m_hdrsForEachFolder.InsertObjectsAt(m_hdrsForEachFolder, 0);
+  newMsgDBView->m_uniqueFoldersSelected.InsertObjectsAt(m_uniqueFoldersSelected, 0);
+
+  int32_t count = m_dbToUseList.Count();
+  for(int32_t i = 0; i < count; i++)
+  {
+    newMsgDBView->m_dbToUseList.AppendObject(m_dbToUseList[i]);
+    // register the new view with the database so it gets notifications
+    m_dbToUseList[i]->AddListener(newMsgDBView);
+  }
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    // We need to clone the thread and msg hdr hash tables.
+    for (auto iter = m_threadsTable.Iter(); !iter.Done(); iter.Next()) {
+      newMsgDBView->m_threadsTable.Put(iter.Key(), iter.UserData());
+    }
+    for (auto iter = m_hdrsTable.Iter(); !iter.Done(); iter.Next()) {
+      newMsgDBView->m_hdrsTable.Put(iter.Key(), iter.UserData());
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::Close()
+{
+  int32_t count = m_dbToUseList.Count();
+  
+  for(int32_t i = 0; i < count; i++)
+    m_dbToUseList[i]->RemoveListener(this);
+
+  m_dbToUseList.Clear();
+
+  return nsMsgGroupView::Close();
+}
+
+void nsMsgSearchDBView::InternalClose()
+{
+  m_threadsTable.Clear();
+  m_hdrsTable.Clear();
+  nsMsgGroupView::InternalClose();
+  m_folders.Clear();
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::GetCellText(int32_t aRow, nsITreeColumn* aCol, nsAString& aValue)
+{
+  NS_ENSURE_TRUE(IsValidIndex(aRow), NS_MSG_INVALID_DBVIEW_INDEX);
+  NS_ENSURE_ARG_POINTER(aCol);
+
+  const char16_t* colID;
+  aCol->GetIdConst(&colID);
+  // the only thing we contribute is location; dummy rows have no location, so
+  //  bail in that case.  otherwise, check if we are dealing with 'location'.
+  // location, need to check for "lo" not just "l" to avoid "label" column
+  if (!(m_flags[aRow] & MSG_VIEW_FLAG_DUMMY) &&
+      colID[0] == 'l' && colID[1] == 'o')
+    return FetchLocation(aRow, aValue);
+  else
+    return nsMsgGroupView::GetCellText(aRow, aCol, aValue);
+}
+
+nsresult nsMsgSearchDBView::HashHdr(nsIMsgDBHdr *msgHdr, nsString& aHashKey)
+{
+  if (m_sortType == nsMsgViewSortType::byLocation)
+  {
+    aHashKey.Truncate();
+    nsCOMPtr<nsIMsgFolder> folder;
+    msgHdr->GetFolder(getter_AddRefs(folder));
+    return folder->GetPrettiestName(aHashKey);
+  }
+  return nsMsgGroupView::HashHdr(msgHdr, aHashKey);
+}
+
+nsresult nsMsgSearchDBView::FetchLocation(int32_t aRow, nsAString& aLocationString)
+{
+  nsCOMPtr <nsIMsgFolder> folder;
+  nsresult rv = GetFolderForViewIndex(aRow, getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv,rv);
+  return folder->GetPrettiestName(aLocationString);
+}
+
+nsresult nsMsgSearchDBView::OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey aParentKey,
+                                        bool /*ensureListed*/)
+{
+   return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsMsgSearchDBView::OnHdrDeleted(nsIMsgDBHdr *aHdrDeleted, nsMsgKey aParentKey, 
+                                int32_t aFlags, nsIDBChangeListener *aInstigator)
+{
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+    return nsMsgGroupView::OnHdrDeleted(aHdrDeleted, aParentKey, 
+                                        aFlags, aInstigator);
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    nsMsgViewIndex deletedIndex = FindHdr(aHdrDeleted);
+    uint32_t savedFlags = 0;
+    if (deletedIndex != nsMsgViewIndex_None)
+    {
+      savedFlags = m_flags[deletedIndex];
+      RemoveByIndex(deletedIndex);
+    }
+
+    nsCOMPtr<nsIMsgThread> thread;
+    GetXFThreadFromMsgHdr(aHdrDeleted, getter_AddRefs(thread));
+    if (thread)
+    {
+      nsMsgXFViewThread *viewThread = static_cast<nsMsgXFViewThread*>(thread.get());
+      viewThread->RemoveChildHdr(aHdrDeleted, nullptr);
+      if (deletedIndex == nsMsgViewIndex_None && viewThread->MsgCount() == 1)
+      {
+        // remove the last child of a collapsed thread. Need to find the root,
+        // and remove the thread flags on it.
+        nsCOMPtr<nsIMsgDBHdr> rootHdr;
+        thread->GetRootHdr(nullptr, getter_AddRefs(rootHdr));
+        if (rootHdr)
+        {
+          nsMsgViewIndex threadIndex = GetThreadRootIndex(rootHdr);
+          if (threadIndex != nsMsgViewIndex_None)
+            AndExtraFlag(threadIndex, ~(MSG_VIEW_FLAG_ISTHREAD | 
+                                        nsMsgMessageFlags::Elided | 
+                                        MSG_VIEW_FLAG_HASCHILDREN));
+        }
+      }
+      else if (savedFlags & MSG_VIEW_FLAG_HASCHILDREN)
+{
+        if (savedFlags & nsMsgMessageFlags::Elided)
+        {
+          nsCOMPtr<nsIMsgDBHdr> rootHdr;
+          nsresult rv = thread->GetRootHdr(nullptr, getter_AddRefs(rootHdr));
+          NS_ENSURE_SUCCESS(rv, rv);
+          nsMsgKey msgKey;
+          uint32_t msgFlags;
+          rootHdr->GetMessageKey(&msgKey);
+          rootHdr->GetFlags(&msgFlags);
+          // promote the new thread root
+          if (viewThread->MsgCount() > 1)
+            msgFlags |= MSG_VIEW_FLAG_ISTHREAD | nsMsgMessageFlags::Elided | 
+                        MSG_VIEW_FLAG_HASCHILDREN;
+          InsertMsgHdrAt(deletedIndex, rootHdr, msgKey, msgFlags, 0);
+          if (!m_deletingRows)
+            NoteChange(deletedIndex, 1, nsMsgViewNotificationCode::insertOrDelete);
+        }
+        else if (viewThread->MsgCount() > 1)
+        {
+          OrExtraFlag(deletedIndex, MSG_VIEW_FLAG_ISTHREAD |
+                                    MSG_VIEW_FLAG_HASCHILDREN);
+        }
+      }
+    }
+  }
+  else
+  {
+    return nsMsgDBView::OnHdrDeleted(aHdrDeleted, aParentKey, 
+                                        aFlags, aInstigator);
+  }
+   return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::OnHdrFlagsChanged(nsIMsgDBHdr *aHdrChanged, uint32_t aOldFlags,
+                                      uint32_t aNewFlags, nsIDBChangeListener *aInstigator)
+{
+  // defer to base class if we're grouped or not threaded at all
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort ||
+      !(m_viewFlags && nsMsgViewFlagsType::kThreadedDisplay))
+    return nsMsgGroupView::OnHdrFlagsChanged(aHdrChanged, aOldFlags, 
+                                             aNewFlags, aInstigator);
+
+  nsCOMPtr <nsIMsgThread> thread;
+  bool foundMessageId;
+  // check if the hdr that changed is in a xf thread, and if the read flag
+  // changed, update the thread unread count. GetXFThreadFromMsgHdr returns
+  // the thread the header does or would belong to, so we need to also
+  // check that the header is actually in the thread.
+  GetXFThreadFromMsgHdr(aHdrChanged, getter_AddRefs(thread), &foundMessageId);
+  if (foundMessageId)
+  {
+    nsMsgXFViewThread *viewThread = static_cast<nsMsgXFViewThread*>(thread.get());
+    if (viewThread->HdrIndex(aHdrChanged) != -1)
+    {
+      uint32_t deltaFlags = (aOldFlags ^ aNewFlags);
+      if (deltaFlags & nsMsgMessageFlags::Read)
+        thread->MarkChildRead(aNewFlags & nsMsgMessageFlags::Read);
+    }
+  }
+  return nsMsgDBView::OnHdrFlagsChanged(aHdrChanged, aOldFlags,
+                                        aNewFlags, aInstigator);
+}
+
+void nsMsgSearchDBView::InsertMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr,
+                              nsMsgKey msgKey, uint32_t flags, uint32_t level)
+{
+  if ((int32_t) index < 0)
+  {
+    NS_ERROR("invalid insert index");
+    index = 0;
+    level = 0;
+  }
+  else if (index > m_keys.Length())
+  {
+    NS_ERROR("inserting past end of array");
+    index = m_keys.Length();
+  }
+  m_keys.InsertElementAt(index, msgKey);
+  m_flags.InsertElementAt(index, flags);
+  m_levels.InsertElementAt(index, level);
+  nsCOMPtr<nsIMsgFolder> folder;
+  hdr->GetFolder(getter_AddRefs(folder));
+  m_folders.InsertObjectAt(folder, index);
+}
+
+void nsMsgSearchDBView::SetMsgHdrAt(nsIMsgDBHdr *hdr, nsMsgViewIndex index, 
+                              nsMsgKey msgKey, uint32_t flags, uint32_t level)
+{
+  m_keys[index] = msgKey;
+  m_flags[index] = flags;
+  m_levels[index] = level;
+  nsCOMPtr<nsIMsgFolder> folder;
+  hdr->GetFolder(getter_AddRefs(folder));
+  m_folders.ReplaceObjectAt(folder, index);
+}
+
+bool nsMsgSearchDBView::InsertEmptyRows(nsMsgViewIndex viewIndex, int32_t numRows)
+{
+  for (int32_t i = 0; i < numRows; i++)
+    if (!m_folders.InsertObjectAt(nullptr, viewIndex + i))
+      return false;
+  return nsMsgDBView::InsertEmptyRows(viewIndex, numRows);
+}
+
+void nsMsgSearchDBView::RemoveRows(nsMsgViewIndex viewIndex, int32_t numRows)
+{
+  nsMsgDBView::RemoveRows(viewIndex, numRows);
+  for (int32_t i = 0; i < numRows; i++)
+    m_folders.RemoveObjectAt(viewIndex);
+}
+
+nsresult nsMsgSearchDBView::GetMsgHdrForViewIndex(nsMsgViewIndex index, 
+                                                  nsIMsgDBHdr **msgHdr)
+{
+  nsresult rv = NS_MSG_INVALID_DBVIEW_INDEX;
+  if (index == nsMsgViewIndex_None || index >= (uint32_t) m_folders.Count())
+    return rv;
+  nsIMsgFolder *folder = m_folders[index];
+  if (folder)
+  {
+    nsCOMPtr <nsIMsgDatabase> db;
+    rv = folder->GetMsgDatabase(getter_AddRefs(db));
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (db)
+      rv = db->GetMsgHdrForKey(m_keys[index], msgHdr);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::GetFolderForViewIndex(nsMsgViewIndex index, nsIMsgFolder **aFolder)
+{
+  NS_ENSURE_ARG_POINTER(aFolder);
+
+  if (index == nsMsgViewIndex_None || index >= (uint32_t) m_folders.Count())
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  NS_IF_ADDREF(*aFolder = m_folders[index]);
+  return *aFolder ? NS_OK : NS_ERROR_NULL_POINTER;
+}
+
+nsresult nsMsgSearchDBView::GetDBForViewIndex(nsMsgViewIndex index, nsIMsgDatabase **db)
+{
+  nsCOMPtr <nsIMsgFolder> aFolder;
+  nsresult rv = GetFolderForViewIndex(index, getter_AddRefs(aFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return aFolder->GetMsgDatabase(db);
+}
+
+nsresult nsMsgSearchDBView::AddHdrFromFolder(nsIMsgDBHdr *msgHdr, nsIMsgFolder *folder)
+{
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+    return nsMsgGroupView::OnNewHeader(msgHdr, nsMsgKey_None, true);
+  nsMsgKey msgKey;
+  uint32_t msgFlags;
+  msgHdr->GetMessageKey(&msgKey);
+  msgHdr->GetFlags(&msgFlags);
+
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    nsCOMPtr<nsIMsgThread> thread;
+    nsCOMPtr<nsIMsgDBHdr> threadRoot;
+    // if we find an xf thread in the hash table corresponding to the new msg's
+    // message id, a previous header must be a reference child of the new 
+    // message, which means we need to reparent later.
+    bool msgIsReferredTo;
+    GetXFThreadFromMsgHdr(msgHdr, getter_AddRefs(thread), &msgIsReferredTo);
+    bool newThread = !thread;
+    nsMsgXFViewThread *viewThread;
+    if (!thread)
+    {
+      viewThread = new nsMsgXFViewThread(this, m_nextThreadId++);
+      if (!viewThread)
+        return NS_ERROR_OUT_OF_MEMORY;
+      thread = do_QueryInterface(viewThread);
+    }
+    else
+    {
+      viewThread = static_cast<nsMsgXFViewThread*>(thread.get());
+      thread->GetChildHdrAt(0, getter_AddRefs(threadRoot));
+    }
+
+    AddMsgToHashTables(msgHdr, thread);
+    nsCOMPtr<nsIMsgDBHdr> parent;
+    uint32_t posInThread;
+    // We need to move threads in order to keep ourselves sorted
+    // correctly.  We want the index of the original thread...we can do this by
+    // getting the root header before we add the new header, and finding that.
+    if (newThread || !viewThread->MsgCount())
+    {
+      viewThread->AddHdr(msgHdr, false, posInThread,
+                         getter_AddRefs(parent));
+      nsMsgViewIndex insertIndex = GetIndexForThread(msgHdr);
+      NS_ASSERTION(insertIndex == m_levels.Length() || !m_levels[insertIndex],
+                    "inserting into middle of thread");
+      if (insertIndex == nsMsgViewIndex_None)
+        return NS_ERROR_FAILURE;
+      if (!(m_viewFlags & nsMsgViewFlagsType::kExpandAll))
+        msgFlags |= nsMsgMessageFlags::Elided;
+      InsertMsgHdrAt(insertIndex, msgHdr, msgKey, msgFlags, 0);
+      NoteChange(insertIndex, 1, nsMsgViewNotificationCode::insertOrDelete);
+    }
+    else
+    {
+      // get the thread root index before we add the header, because adding
+      // the header can change the sort position.
+      nsMsgViewIndex threadIndex = GetThreadRootIndex(threadRoot);
+      viewThread->AddHdr(msgHdr, msgIsReferredTo, posInThread,
+                         getter_AddRefs(parent));
+      if (threadIndex == nsMsgViewIndex_None)
+      {
+        NS_ERROR("couldn't find thread index for newly inserted header");
+        return NS_OK; // not really OK, but not failure exactly.
+      }
+      NS_ASSERTION(!m_levels[threadIndex], "threadRoot incorrect, or level incorrect");
+
+      bool moveThread = false;
+      if (m_sortType == nsMsgViewSortType::byDate)
+      {
+        uint32_t newestMsgInThread = 0, msgDate = 0;
+        viewThread->GetNewestMsgDate(&newestMsgInThread);
+        msgHdr->GetDateInSeconds(&msgDate);
+        moveThread = (msgDate == newestMsgInThread);
+      }
+      OrExtraFlag(threadIndex, MSG_VIEW_FLAG_HASCHILDREN | MSG_VIEW_FLAG_ISTHREAD);
+      if (!(m_flags[threadIndex] & nsMsgMessageFlags::Elided))
+      {
+        if (parent)
+        {
+          // since we know posInThread, we just want to insert the new hdr
+          // at threadIndex + posInThread, and then rebuild the view until we
+          // get to a sibling of the new hdr.
+          uint8_t newMsgLevel = viewThread->ChildLevelAt(posInThread);
+          InsertMsgHdrAt(threadIndex + posInThread, msgHdr, msgKey, msgFlags,
+                         newMsgLevel);
+
+          NoteChange(threadIndex + posInThread, 1, nsMsgViewNotificationCode::insertOrDelete);
+          for (nsMsgViewIndex viewIndex = threadIndex + ++posInThread;
+               posInThread < viewThread->MsgCount() && 
+               viewThread->ChildLevelAt(posInThread) > newMsgLevel; viewIndex++)
+          {
+            m_levels[viewIndex] = viewThread->ChildLevelAt(posInThread++);
+          }
+
+        }
+        else // The new header is the root, so we need to adjust 
+             // all the children.
+        {
+          InsertMsgHdrAt(threadIndex, msgHdr, msgKey, msgFlags, 0);
+
+          NoteChange(threadIndex, 1, nsMsgViewNotificationCode::insertOrDelete);
+          nsMsgViewIndex i;
+          for (i = threadIndex + 1; 
+               i < m_keys.Length() && (i == threadIndex + 1 || m_levels[i]); i++)
+            m_levels[i] = m_levels[i] + 1;
+          // turn off thread flags on old root.
+          AndExtraFlag(threadIndex + 1, ~(MSG_VIEW_FLAG_ISTHREAD | 
+                                          nsMsgMessageFlags::Elided | 
+                                          MSG_VIEW_FLAG_HASCHILDREN));
+
+          NoteChange(threadIndex + 1, i - threadIndex + 1, 
+                     nsMsgViewNotificationCode::changed);
+        }
+      }
+      else if (!parent)
+      {
+        // new parent came into collapsed thread
+        nsCOMPtr<nsIMsgFolder> msgFolder;
+        msgHdr->GetFolder(getter_AddRefs(msgFolder));
+        m_keys[threadIndex] = msgKey;
+        m_folders.ReplaceObjectAt(msgFolder, threadIndex);
+        m_flags[threadIndex] = msgFlags | MSG_VIEW_FLAG_ISTHREAD | 
+                                          nsMsgMessageFlags::Elided | 
+                                          MSG_VIEW_FLAG_HASCHILDREN;
+        NoteChange(threadIndex, 1, nsMsgViewNotificationCode::changed);
+
+      }
+      if (moveThread)
+        MoveThreadAt(threadIndex);
+    }
+  }
+  else
+  {
+    m_folders.AppendObject(folder);
+  // nsMsgKey_None means it's not a valid hdr.
+  if (msgKey != nsMsgKey_None)
+  {
+    msgHdr->GetFlags(&msgFlags);
+    m_keys.AppendElement(msgKey);
+    m_levels.AppendElement(0);
+    m_flags.AppendElement(msgFlags);
+      NoteChange(GetSize() - 1, 1, nsMsgViewNotificationCode::insertOrDelete);
+    }
+  }
+  return NS_OK;
+  }
+
+// This method removes the thread at threadIndex from the view 
+// and puts it back in its new position, determined by the sort order.
+// And, if the selection is affected, save and restore the selection.
+void nsMsgSearchDBView::MoveThreadAt(nsMsgViewIndex threadIndex)
+{
+  bool updatesSuppressed = mSuppressChangeNotification;
+  // Turn off tree notifications so that we don't reload the current message.
+  if (!updatesSuppressed)
+    SetSuppressChangeNotifications(true);
+
+  nsCOMPtr<nsIMsgDBHdr> threadHdr;
+  GetMsgHdrForViewIndex(threadIndex, getter_AddRefs(threadHdr));
+
+  uint32_t saveFlags = m_flags[threadIndex];
+  bool threadIsExpanded = !(saveFlags & nsMsgMessageFlags::Elided);
+  int32_t childCount = 0;
+  nsMsgKey preservedKey;
+  AutoTArray<nsMsgKey, 1> preservedSelection;
+  int32_t selectionCount;
+  int32_t currentIndex;
+  bool hasSelection = mTree && mTreeSelection &&
+                        ((NS_SUCCEEDED(mTreeSelection->GetCurrentIndex(&currentIndex)) &&
+                         currentIndex >= 0 && (uint32_t)currentIndex < GetSize()) ||
+                         (NS_SUCCEEDED(mTreeSelection->GetRangeCount(&selectionCount)) &&
+                          selectionCount > 0));
+
+
+  if (hasSelection)
+    SaveAndClearSelection(&preservedKey, preservedSelection);
+
+  if (threadIsExpanded)
+  {
+    ExpansionDelta(threadIndex, &childCount);
+    childCount = -childCount;
+  }
+  nsTArray<nsMsgKey> threadKeys;
+  nsTArray<uint32_t> threadFlags;
+  nsTArray<uint8_t> threadLevels;
+  nsCOMArray<nsIMsgFolder> threadFolders;
+
+  if (threadIsExpanded)
+  {
+    threadKeys.SetCapacity(childCount);
+    threadFlags.SetCapacity(childCount);
+    threadLevels.SetCapacity(childCount);
+    threadFolders.SetCapacity(childCount);
+    for (nsMsgViewIndex index = threadIndex + 1; 
+        index < (nsMsgViewIndex) GetSize() && m_levels[index]; index++)
+    {
+      threadKeys.AppendElement(m_keys[index]);
+      threadFlags.AppendElement(m_flags[index]);
+      threadLevels.AppendElement(m_levels[index]);
+      threadFolders.AppendObject(m_folders[index]);
+    }
+    uint32_t collapseCount;
+    CollapseByIndex(threadIndex, &collapseCount);
+  }
+  nsMsgDBView::RemoveByIndex(threadIndex);
+  m_folders.RemoveObjectAt(threadIndex);
+  nsMsgViewIndex newIndex = GetIndexForThread(threadHdr);
+  NS_ASSERTION(newIndex == m_levels.Length() || !m_levels[newIndex],
+                "inserting into middle of thread");
+  if (newIndex == nsMsgViewIndex_None)
+    newIndex = 0;
+  nsMsgKey msgKey;
+  uint32_t msgFlags;
+  threadHdr->GetMessageKey(&msgKey);
+  threadHdr->GetFlags(&msgFlags);
+  InsertMsgHdrAt(newIndex, threadHdr, msgKey, msgFlags, 0);
+
+  if (threadIsExpanded)
+  {
+    m_keys.InsertElementsAt(newIndex + 1, threadKeys);
+    m_flags.InsertElementsAt(newIndex + 1, threadFlags);
+    m_levels.InsertElementsAt(newIndex + 1, threadLevels);
+    m_folders.InsertObjectsAt(threadFolders, newIndex + 1);
+  }
+  m_flags[newIndex] = saveFlags;
+  // unfreeze selection.
+  if (hasSelection)
+    RestoreSelection(preservedKey, preservedSelection);
+
+  if (!updatesSuppressed)
+    SetSuppressChangeNotifications(false);
+  nsMsgViewIndex lowIndex = threadIndex < newIndex ? threadIndex : newIndex;
+  nsMsgViewIndex highIndex = lowIndex == threadIndex ? newIndex : threadIndex;
+  NoteChange(lowIndex, highIndex - lowIndex + childCount + 1,
+             nsMsgViewNotificationCode::changed);
+}
+
+nsresult
+nsMsgSearchDBView::GetMessageEnumerator(nsISimpleEnumerator **enumerator)
+{
+  // We do not have an m_db, so the default behavior (in nsMsgDBView) is not
+  //  what we want (it will crash).  We just want someone to enumerate the
+  //  headers that we already have.  Conveniently, nsMsgDBView already knows
+  //  how to do this with its view enumerator, so we just use that.
+  return nsMsgDBView::GetViewEnumerator(enumerator);
+}
+
+nsresult nsMsgSearchDBView::InsertHdrFromFolder(nsIMsgDBHdr *msgHdr, nsIMsgFolder *folder)
+{
+  nsMsgViewIndex insertIndex = nsMsgViewIndex_None;
+  // Threaded view always needs to go through AddHdrFromFolder since
+  // it handles the xf view thread object creation.
+  if (! (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    insertIndex = GetInsertIndex(msgHdr);
+
+  if (insertIndex == nsMsgViewIndex_None)
+    return AddHdrFromFolder(msgHdr, folder);
+
+  nsMsgKey msgKey;
+  uint32_t msgFlags;
+  msgHdr->GetMessageKey(&msgKey);
+  msgHdr->GetFlags(&msgFlags);
+  InsertMsgHdrAt(insertIndex, msgHdr, msgKey, msgFlags, 0);
+
+  // the call to NoteChange() has to happen after we add the key
+  // as NoteChange() will call RowCountChanged() which will call our GetRowCount()
+  NoteChange(insertIndex, 1, nsMsgViewNotificationCode::insertOrDelete);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::OnSearchHit(nsIMsgDBHdr* aMsgHdr, nsIMsgFolder *folder)
+{
+  NS_ENSURE_ARG(aMsgHdr);
+  NS_ENSURE_ARG(folder);
+
+  if (m_folders.IndexOf(folder) < 0 ) //do this just for new folder
+  {
+    nsCOMPtr<nsIMsgDatabase> dbToUse;
+    nsCOMPtr<nsIDBFolderInfo> folderInfo;
+    folder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(dbToUse));
+    if (dbToUse)
+    {
+      dbToUse->AddListener(this);
+      m_dbToUseList.AppendObject(dbToUse);
+    }
+  }
+  m_totalMessagesInView++;
+  if (m_sortValid)
+    return InsertHdrFromFolder(aMsgHdr, folder);
+  else
+    return AddHdrFromFolder(aMsgHdr, folder);
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::OnSearchDone(nsresult status)
+{
+  //we want to set imap delete model once the search is over because setting next
+  //message after deletion will happen before deleting the message and search scope
+  //can change with every search.
+  mDeleteModel = nsMsgImapDeleteModels::MoveToTrash;  //set to default in case it is non-imap folder
+  nsIMsgFolder *curFolder = m_folders.SafeObjectAt(0);
+  if (curFolder)   
+    GetImapDeleteModel(curFolder);
+  return NS_OK;
+}
+
+// for now also acts as a way of resetting the search datasource
+NS_IMETHODIMP
+nsMsgSearchDBView::OnNewSearch()
+{
+  int32_t oldSize = GetSize();
+
+  int32_t count = m_dbToUseList.Count();
+  for(int32_t j = 0; j < count; j++) 
+    m_dbToUseList[j]->RemoveListener(this);
+
+  m_dbToUseList.Clear();
+  m_folders.Clear();
+  m_keys.Clear();
+  m_levels.Clear();
+  m_flags.Clear();
+  m_totalMessagesInView = 0;
+
+  // needs to happen after we remove the keys, since RowCountChanged() will call our GetRowCount()
+  if (mTree) 
+    mTree->RowCountChanged(0, -oldSize);
+
+//    mSearchResults->Clear();
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::GetViewType(nsMsgViewTypeValue *aViewType)
+{
+    NS_ENSURE_ARG_POINTER(aViewType);
+    *aViewType = nsMsgViewType::eShowSearch;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::SetSearchSession(nsIMsgSearchSession *aSession)
+{
+  m_searchSession = do_GetWeakReference(aSession);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::OnAnnouncerGoingAway(nsIDBChangeAnnouncer *instigator)
+{
+  nsIMsgDatabase *db = static_cast<nsIMsgDatabase *>(instigator);
+  if (db)
+  {
+    db->RemoveListener(this);
+    m_dbToUseList.RemoveObject(db);
+  }
+  return NS_OK;
+}
+
+nsCOMArray<nsIMsgFolder>* nsMsgSearchDBView::GetFolders()
+{
+  return &m_folders;
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::GetCommandStatus(nsMsgViewCommandTypeValue command, bool *selectable_p, nsMsgViewCommandCheckStateValue *selected_p)
+{
+  if (command != nsMsgViewCommandType::runJunkControls)
+    return nsMsgDBView::GetCommandStatus(command, selectable_p, selected_p);
+
+  *selectable_p = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsMsgSearchDBView::DoCommandWithFolder(nsMsgViewCommandTypeValue command, nsIMsgFolder *destFolder)
+{
+    mCommand = command;
+    mDestFolder = destFolder;
+    return nsMsgDBView::DoCommandWithFolder(command, destFolder);
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::DoCommand(nsMsgViewCommandTypeValue command)
+{
+  mCommand = command;
+  if (command == nsMsgViewCommandType::deleteMsg ||
+      command == nsMsgViewCommandType::deleteNoTrash ||
+      command == nsMsgViewCommandType::selectAll ||
+      command == nsMsgViewCommandType::selectThread ||
+      command == nsMsgViewCommandType::selectFlagged ||
+      command == nsMsgViewCommandType::expandAll ||
+      command == nsMsgViewCommandType::collapseAll)
+    return nsMsgDBView::DoCommand(command);
+  nsresult rv = NS_OK;
+  nsMsgViewIndexArray selection;
+  GetSelectedIndices(selection);
+
+  nsMsgViewIndex *indices = selection.Elements();
+  int32_t numIndices = selection.Length();
+
+  // we need to break apart the selection by folders, and then call
+  // ApplyCommandToIndices with the command and the indices in the
+  // selection that are from that folder.
+
+  mozilla::UniquePtr<nsTArray<uint32_t>[]> indexArrays;
+  int32_t numArrays;
+  rv = PartitionSelectionByFolder(indices, numIndices, indexArrays, &numArrays);
+  NS_ENSURE_SUCCESS(rv, rv);
+  for (int32_t folderIndex = 0; folderIndex < numArrays; folderIndex++)
+  {
+    rv = ApplyCommandToIndices(command, (indexArrays.get())[folderIndex].Elements(), indexArrays[folderIndex].Length());
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return rv;
+}
+
+// This method removes the specified line from the view, and adjusts the
+// various flags and levels of affected messages.
+nsresult nsMsgSearchDBView::RemoveByIndex(nsMsgViewIndex index)
+{
+    if (!IsValidIndex(index))
+        return NS_MSG_INVALID_DBVIEW_INDEX;
+
+  if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    nsCOMPtr<nsIMsgThread> thread;
+    nsresult rv = GetMsgHdrForViewIndex(index, getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+    
+    GetXFThreadFromMsgHdr(msgHdr, getter_AddRefs(thread));
+    if (thread)
+    {
+      nsMsgXFViewThread *viewThread = static_cast<nsMsgXFViewThread*>(thread.get());
+      if (viewThread->MsgCount() == 2)
+      {
+        // if we removed the next to last message in the thread,
+        // we need to adjust the flags on the first message in the thread.
+        nsMsgViewIndex threadIndex = m_levels[index] ? index -1 : index;
+        if (threadIndex != nsMsgViewIndex_None)
+        {
+          AndExtraFlag(threadIndex, ~(MSG_VIEW_FLAG_ISTHREAD | nsMsgMessageFlags::Elided |
+                                      MSG_VIEW_FLAG_HASCHILDREN));
+          m_levels[threadIndex] = 0;
+          NoteChange(threadIndex, 1, nsMsgViewNotificationCode::changed);
+        }
+      }
+      // Bump up the level of all the descendents of the message
+      // that was removed, if the thread was expanded.
+      uint8_t removedLevel = m_levels[index];
+      nsMsgViewIndex i = index + 1;
+      if (i < m_levels.Length() && m_levels[i] > removedLevel)
+      {
+        // promote the child of the removed message.
+        uint8_t promotedLevel = m_levels[i];
+        m_levels[i] = promotedLevel - 1;
+        i++;
+        // now promote all the children of the promoted message.
+        for (; i < m_levels.Length() && 
+              m_levels[i] > promotedLevel; i++)
+          m_levels[i] = m_levels[i] - 1;
+      }
+    }
+  }
+  m_folders.RemoveObjectAt(index);
+    return nsMsgDBView::RemoveByIndex(index);
+}
+
+nsresult nsMsgSearchDBView::DeleteMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool deleteStorage)
+{
+   nsresult rv = GetFoldersAndHdrsForSelection(indices, numIndices);
+   NS_ENSURE_SUCCESS(rv, rv);
+   if (mDeleteModel != nsMsgImapDeleteModels::MoveToTrash)
+     deleteStorage = true;
+  if (mDeleteModel != nsMsgImapDeleteModels::IMAPDelete)
+    m_deletingRows = true;
+
+  // remember the deleted messages in case the user undoes the delete,
+  // and we want to restore the hdr to the view, even if it no
+  // longer matches the search criteria.
+  for (nsMsgViewIndex i = 0; i < (nsMsgViewIndex) numIndices; i++) 
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr; 
+    (void) GetMsgHdrForViewIndex(indices[i], getter_AddRefs(msgHdr));
+    if (msgHdr)
+      RememberDeletedMsgHdr(msgHdr);
+    // if we are deleting rows, save off the view indices
+    if (m_deletingRows)
+      mIndicesToNoteChange.AppendElement(indices[i]);
+
+  }
+  rv = deleteStorage ? ProcessRequestsInAllFolders(window)
+                     : ProcessRequestsInOneFolder(window);
+  if (NS_FAILED(rv))
+    m_deletingRows = false;
+  return rv;
+}
+
+nsresult 
+nsMsgSearchDBView::CopyMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool isMove, nsIMsgFolder *destFolder)
+{
+    GetFoldersAndHdrsForSelection(indices, numIndices);
+    return ProcessRequestsInOneFolder(window);
+}
+
+nsresult
+nsMsgSearchDBView::PartitionSelectionByFolder(nsMsgViewIndex *indices,
+                                              int32_t numIndices,
+                                              mozilla::UniquePtr<nsTArray<uint32_t>[]> &indexArrays,
+                                              int32_t *numArrays)
+{
+  nsMsgViewIndex i;
+  int32_t folderIndex;
+  nsCOMArray<nsIMsgFolder> uniqueFoldersSelected;
+  nsTArray<uint32_t> numIndicesSelected;
+  mCurIndex = 0;
+
+  //Build unique folder list based on headers selected by the user
+  for (i = 0; i < (nsMsgViewIndex) numIndices; i++)
+  {
+    nsIMsgFolder *curFolder = m_folders[indices[i]];
+    folderIndex = uniqueFoldersSelected.IndexOf(curFolder);
+    if (folderIndex < 0)
+    {
+      uniqueFoldersSelected.AppendObject(curFolder);
+      numIndicesSelected.AppendElement(1);
+    }
+    else
+    {
+      numIndicesSelected[folderIndex]++;
+    }
+  }
+
+  int32_t numFolders = uniqueFoldersSelected.Count();
+  indexArrays = mozilla::MakeUnique<nsTArray<uint32_t>[]>(numFolders);
+  *numArrays = numFolders;
+  NS_ENSURE_TRUE(indexArrays, NS_ERROR_OUT_OF_MEMORY);
+  for (folderIndex = 0; folderIndex < numFolders; folderIndex++)
+  {
+    (indexArrays.get())[folderIndex].SetCapacity(numIndicesSelected[folderIndex]);
+  }
+  for (i = 0; i < (nsMsgViewIndex) numIndices; i++) 
+  {
+    nsIMsgFolder *curFolder = m_folders[indices[i]];
+    int32_t folderIndex = uniqueFoldersSelected.IndexOf(curFolder);
+    (indexArrays.get())[folderIndex].AppendElement(indices[i]);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgSearchDBView::GetFoldersAndHdrsForSelection(nsMsgViewIndex *indices, int32_t numIndices)
+{
+  nsresult rv = NS_OK; 
+  mCurIndex = 0;
+  m_uniqueFoldersSelected.Clear();
+  m_hdrsForEachFolder.Clear();
+
+  nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = GetHeadersFromSelection(indices, numIndices, messages);
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint32_t numMsgs;
+  messages->GetLength(&numMsgs);
+
+  uint32_t i;
+  // Build unique folder list based on headers selected by the user
+  for (i = 0; i < numMsgs; i++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> hdr = do_QueryElementAt(messages, i, &rv);
+    if (hdr)
+    {
+      nsCOMPtr<nsIMsgFolder> curFolder;
+      hdr->GetFolder(getter_AddRefs(curFolder));
+      if (m_uniqueFoldersSelected.IndexOf(curFolder) < 0)
+        m_uniqueFoldersSelected.AppendObject(curFolder);
+    }
+  }
+
+  // Group the headers selected by each folder
+  uint32_t numFolders = m_uniqueFoldersSelected.Count();
+  for (uint32_t folderIndex = 0; folderIndex < numFolders; folderIndex++)
+  {
+    nsIMsgFolder *curFolder = m_uniqueFoldersSelected[folderIndex];
+    nsCOMPtr<nsIMutableArray> msgHdrsForOneFolder(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    for (i = 0; i < numMsgs; i++) 
+    {
+      nsCOMPtr<nsIMsgDBHdr> hdr = do_QueryElementAt(messages, i, &rv);
+      if (hdr)
+      {
+        nsCOMPtr<nsIMsgFolder> msgFolder;
+        hdr->GetFolder(getter_AddRefs(msgFolder));
+        if (NS_SUCCEEDED(rv) && msgFolder && msgFolder == curFolder) 
+        {
+          nsCOMPtr<nsISupports> hdrSupports = do_QueryInterface(hdr);
+          msgHdrsForOneFolder->AppendElement(hdrSupports, false);
+        }
+      }
+    }
+    m_hdrsForEachFolder.AppendElement(msgHdrsForOneFolder);
+  }
+  return rv;
+}
+
+nsresult
+nsMsgSearchDBView::ApplyCommandToIndicesWithFolder(nsMsgViewCommandTypeValue command, nsMsgViewIndex* indices,
+                    int32_t numIndices, nsIMsgFolder *destFolder)
+{
+  mCommand = command;
+  mDestFolder = destFolder;
+  return nsMsgDBView::ApplyCommandToIndicesWithFolder(command, indices, numIndices, destFolder);
+}
+
+// nsIMsgCopyServiceListener methods
+
+NS_IMETHODIMP
+nsMsgSearchDBView::OnStartCopy()
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::OnProgress(uint32_t aProgress, uint32_t aProgressMax)
+{
+  return NS_OK;
+}
+
+// believe it or not, these next two are msgcopyservice listener methods!
+NS_IMETHODIMP
+nsMsgSearchDBView::SetMessageKey(nsMsgKey aMessageKey)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::GetMessageId(nsACString& messageId)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::OnStopCopy(nsresult aStatus)
+{
+  if (NS_SUCCEEDED(aStatus))
+  {
+    mCurIndex++;
+    if ((int32_t) mCurIndex < m_uniqueFoldersSelected.Count())
+    {
+      nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(mMsgWindowWeak));
+      ProcessRequestsInOneFolder(msgWindow);
+    }
+  }
+  return NS_OK;
+}
+
+// end nsIMsgCopyServiceListener methods
+
+nsresult nsMsgSearchDBView::ProcessRequestsInOneFolder(nsIMsgWindow *window)
+{
+    nsresult rv = NS_OK;
+
+    // Folder operations like copy/move are not implemented for .eml files.
+    if (m_uniqueFoldersSelected.Count() == 0)
+      return NS_ERROR_NOT_IMPLEMENTED;
+
+    nsIMsgFolder *curFolder = m_uniqueFoldersSelected[mCurIndex];
+    NS_ASSERTION(curFolder, "curFolder is null");
+    nsCOMPtr<nsIMutableArray> messageArray = m_hdrsForEachFolder[mCurIndex];
+    NS_ASSERTION(messageArray, "messageArray is null");
+
+    // called for delete with trash, copy and move
+    if (mCommand == nsMsgViewCommandType::deleteMsg)
+        curFolder->DeleteMessages(messageArray, window, false /* delete storage */, false /* is move*/, this, true /*allowUndo*/);
+    else 
+    {
+      NS_ASSERTION(!(curFolder == mDestFolder), "The source folder and the destination folder are the same");
+      if (NS_SUCCEEDED(rv) && curFolder != mDestFolder)
+      {
+         nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+         if (NS_SUCCEEDED(rv))
+         {
+           if (mCommand == nsMsgViewCommandType::moveMessages)
+             copyService->CopyMessages(curFolder, messageArray, mDestFolder, true /* isMove */, this, window, true /*allowUndo*/);
+           else if (mCommand == nsMsgViewCommandType::copyMessages)
+             copyService->CopyMessages(curFolder, messageArray, mDestFolder, false /* isMove */, this, window, true /*allowUndo*/);
+         }
+      }
+    }
+    return rv;
+}
+
+nsresult nsMsgSearchDBView::ProcessRequestsInAllFolders(nsIMsgWindow *window)
+{
+  uint32_t numFolders = m_uniqueFoldersSelected.Count();
+  for (uint32_t folderIndex = 0; folderIndex < numFolders; folderIndex++)
+  {
+    nsIMsgFolder *curFolder = m_uniqueFoldersSelected[folderIndex];
+    NS_ASSERTION (curFolder, "curFolder is null");
+
+    nsCOMPtr<nsIMutableArray> messageArray = m_hdrsForEachFolder[folderIndex];
+    NS_ASSERTION(messageArray, "messageArray is null");
+
+    curFolder->DeleteMessages(messageArray, window, true /* delete storage */, false /* is move*/, nullptr/*copyServListener*/, false /*allowUndo*/ );
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::Sort(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder)
+{
+    if (!m_checkedCustomColumns && CustomColumnsInSortAndNotRegistered())
+      return NS_OK;
+
+    int32_t rowCountBeforeSort = GetSize();
+
+    if (!rowCountBeforeSort)
+        return NS_OK;
+
+    if (m_viewFlags & (nsMsgViewFlagsType::kThreadedDisplay |
+                      nsMsgViewFlagsType::kGroupBySort))
+    {
+      // ### This forgets which threads were expanded, and is sub-optimal
+      // since it rebuilds the thread objects.  
+      m_sortType = sortType;
+      m_sortOrder = sortOrder;
+      return RebuildView(m_viewFlags);
+    }
+
+    nsMsgKey preservedKey;
+    AutoTArray<nsMsgKey, 1> preservedSelection;
+    SaveAndClearSelection(&preservedKey, preservedSelection);
+
+    nsresult rv = nsMsgDBView::Sort(sortType,sortOrder);
+    // the sort may have changed the number of rows
+    // before we restore the selection, tell the tree
+    // do this before we call restore selection
+    // this is safe when there is no selection. 
+    rv = AdjustRowCount(rowCountBeforeSort, GetSize());
+
+    RestoreSelection(preservedKey, preservedSelection);
+    if (mTree) mTree->Invalidate();
+
+    NS_ENSURE_SUCCESS(rv,rv);
+    return rv;
+}
+
+// if nothing selected, return an NS_ERROR
+NS_IMETHODIMP
+nsMsgSearchDBView::GetHdrForFirstSelectedMessage(nsIMsgDBHdr **hdr)
+{
+  NS_ENSURE_ARG_POINTER(hdr);
+  int32_t index;
+
+  if (!mTreeSelection)
+  {
+    // We're in standalone mode, so use the message view index to get the header
+    // We can't use the key here because we don't have an m_db
+    index = m_currentlyDisplayedViewIndex;
+  }
+  else
+  {
+    nsresult rv = mTreeSelection->GetCurrentIndex(&index);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return GetMsgHdrForViewIndex(index, hdr);
+}
+
+NS_IMETHODIMP
+nsMsgSearchDBView::OpenWithHdrs(nsISimpleEnumerator *aHeaders,
+                                nsMsgViewSortTypeValue aSortType,
+                                nsMsgViewSortOrderValue aSortOrder,
+                                nsMsgViewFlagsTypeValue aViewFlags,
+                                int32_t *aCount)
+{
+  if (aViewFlags & nsMsgViewFlagsType::kGroupBySort)
+    return nsMsgGroupView::OpenWithHdrs(aHeaders, aSortType, aSortOrder, 
+                                        aViewFlags, aCount);
+
+  m_sortType = aSortType;
+  m_sortOrder = aSortOrder;
+  m_viewFlags = aViewFlags;
+  SaveSortInfo(m_sortType, m_sortOrder);
+
+  bool hasMore;
+  nsCOMPtr<nsISupports> supports;
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = NS_OK;
+  while (NS_SUCCEEDED(rv) && NS_SUCCEEDED(rv = aHeaders->HasMoreElements(&hasMore)) && hasMore)
+  {
+    rv = aHeaders->GetNext(getter_AddRefs(supports));
+    if (NS_SUCCEEDED(rv) && supports)
+    {
+      msgHdr = do_QueryInterface(supports);
+      msgHdr->GetFolder(getter_AddRefs(folder));
+      AddHdrFromFolder(msgHdr, folder); 
+    }
+  }
+  *aCount = m_keys.Length();
+  return rv;
+}
+
+nsresult
+nsMsgSearchDBView::GetFolderFromMsgURI(const char *aMsgURI, nsIMsgFolder **aFolder)
+{
+  nsCOMPtr <nsIMsgMessageService> msgMessageService;
+  nsresult rv = GetMessageServiceFromURI(nsDependentCString(aMsgURI), getter_AddRefs(msgMessageService));
+  NS_ENSURE_SUCCESS(rv,rv);
+  
+  nsCOMPtr <nsIMsgDBHdr> msgHdr;
+  rv = msgMessageService->MessageURIToMsgHdr(aMsgURI, getter_AddRefs(msgHdr));
+  NS_ENSURE_SUCCESS(rv,rv);
+  
+  return msgHdr->GetFolder(aFolder);
+}
+
+nsMsgViewIndex nsMsgSearchDBView::FindHdr(nsIMsgDBHdr *msgHdr, nsMsgViewIndex startIndex,
+                                          bool allowDummy)
+{
+  nsCOMPtr<nsIMsgDBHdr> curHdr;
+  uint32_t index;
+  // it would be nice to take advantage of sorted views when possible.
+  for (index = startIndex; index < GetSize(); index++)
+  {
+    GetMsgHdrForViewIndex(index, getter_AddRefs(curHdr));
+    if (curHdr == msgHdr &&
+        (allowDummy ||
+         !(m_flags[index] & MSG_VIEW_FLAG_DUMMY) ||
+         (m_flags[index] & nsMsgMessageFlags::Elided)))
+      break;
+  }
+  return index < GetSize() ? index : nsMsgViewIndex_None;
+}
+
+// This method looks for the XF thread that corresponds to this message hdr,
+// first by looking up the message id, then references, and finally, if subject
+// threading is turned on, the subject.
+nsresult nsMsgSearchDBView::GetXFThreadFromMsgHdr(nsIMsgDBHdr *msgHdr, 
+                                                  nsIMsgThread **pThread,
+                                                  bool *foundByMessageId)
+{
+  NS_ENSURE_ARG_POINTER(pThread);
+
+  nsAutoCString messageId;
+  msgHdr->GetMessageId(getter_Copies(messageId));
+  *pThread = nullptr;
+  m_threadsTable.Get(messageId, pThread);
+  // The caller may want to know if we found the thread by the msgHdr's
+  // messageId
+  if (foundByMessageId)
+    *foundByMessageId = *pThread != nullptr;
+  if (!*pThread)
+  {
+    uint16_t numReferences = 0;
+    msgHdr->GetNumReferences(&numReferences);
+    for (int32_t i = numReferences - 1; i >= 0  && !*pThread; i--)
+    {
+      nsAutoCString reference;
+      
+      msgHdr->GetStringReference(i, reference);
+      if (reference.IsEmpty())
+        break;
+
+      m_threadsTable.Get(reference, pThread);
+    }
+  }
+  // if we're threading by subject, and we couldn't find the thread by ref,
+  // just treat subject as an other ref.
+  if (!*pThread && !gReferenceOnlyThreading)
+  {
+    nsCString subject;
+    msgHdr->GetSubject(getter_Copies(subject));
+    // this is the raw rfc822 subject header, so this is OK
+    m_threadsTable.Get(subject, pThread);
+  }
+  return (*pThread) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+bool nsMsgSearchDBView::GetMsgHdrFromHash(nsCString &reference, nsIMsgDBHdr **hdr)
+{
+  return m_hdrsTable.Get(reference, hdr);
+}
+
+bool nsMsgSearchDBView::GetThreadFromHash(nsCString &reference,
+                                              nsIMsgThread **thread)
+{
+  return m_threadsTable.Get(reference, thread);
+}
+
+nsresult nsMsgSearchDBView::AddRefToHash(nsCString &reference, 
+                                         nsIMsgThread *thread)
+{
+  // Check if this reference is already is associated with a thread;
+  // If so, don't overwrite that association.
+  nsCOMPtr<nsIMsgThread> oldThread;
+  m_threadsTable.Get(reference, getter_AddRefs(oldThread));
+  if (oldThread)
+    return NS_OK;
+
+  m_threadsTable.Put(reference, thread);
+  return NS_OK;
+}
+
+nsresult nsMsgSearchDBView::AddMsgToHashTables(nsIMsgDBHdr *msgHdr,
+                                               nsIMsgThread *thread)
+{
+  NS_ENSURE_ARG_POINTER(msgHdr);
+
+  uint16_t numReferences = 0;
+  nsresult rv;
+
+  msgHdr->GetNumReferences(&numReferences);
+  for (int32_t i = 0; i < numReferences; i++)
+  {
+    nsAutoCString reference;
+
+    msgHdr->GetStringReference(i, reference);
+    if (reference.IsEmpty())
+      break;
+
+    rv = AddRefToHash(reference, thread);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCString messageId;
+  msgHdr->GetMessageId(getter_Copies(messageId));
+  m_hdrsTable.Put(messageId, msgHdr);
+  if (!gReferenceOnlyThreading)
+  {
+    nsCString subject;
+    msgHdr->GetSubject(getter_Copies(subject));
+    // if we're threading by subject, just treat subject as an other ref.
+    AddRefToHash(subject, thread);
+  }
+  return AddRefToHash(messageId, thread);
+}
+
+nsresult nsMsgSearchDBView::RemoveRefFromHash(nsCString &reference)
+{
+  m_threadsTable.Remove(reference);
+  return NS_OK;
+}
+
+nsresult nsMsgSearchDBView::RemoveMsgFromHashTables(nsIMsgDBHdr *msgHdr)
+{
+  NS_ENSURE_ARG_POINTER(msgHdr);
+
+  uint16_t numReferences = 0;
+  nsresult rv = NS_OK;
+
+  msgHdr->GetNumReferences(&numReferences);
+
+  for (int32_t i = 0; i < numReferences; i++)
+  {
+    nsAutoCString reference;
+    msgHdr->GetStringReference(i, reference);
+    if (reference.IsEmpty())
+      break;
+
+    rv = RemoveRefFromHash(reference);
+    if (NS_FAILED(rv))
+      break;
+  }
+  nsCString messageId;
+  msgHdr->GetMessageId(getter_Copies(messageId));
+  m_hdrsTable.Remove(messageId);
+  RemoveRefFromHash(messageId);
+  if (!gReferenceOnlyThreading)
+  {
+    nsCString subject;
+    msgHdr->GetSubject(getter_Copies(subject));
+    // if we're threading by subject, just treat subject as an other ref.
+    RemoveRefFromHash(subject);
+  }
+  return rv;
+}
+
+nsMsgGroupThread *nsMsgSearchDBView::CreateGroupThread(nsIMsgDatabase * /* db */)
+{
+  return new nsMsgXFGroupThread();
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::GetThreadContainingMsgHdr(nsIMsgDBHdr *msgHdr, 
+                                                      nsIMsgThread **pThread)
+{
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+    return nsMsgGroupView::GetThreadContainingMsgHdr(msgHdr, pThread);
+  else if (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+    return GetXFThreadFromMsgHdr(msgHdr, pThread);
+
+  // if not threaded, use the real thread. 
+  nsCOMPtr<nsIMsgDatabase> msgDB;
+  nsresult rv = GetDBForHeader(msgHdr, getter_AddRefs(msgDB));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return msgDB->GetThreadContainingMsgHdr(msgHdr, pThread);
+}
+
+nsresult
+nsMsgSearchDBView::ListIdsInThread(nsIMsgThread *threadHdr,
+                                   nsMsgViewIndex startOfThreadViewIndex,
+                                   uint32_t *pNumListed)
+{
+  NS_ENSURE_ARG_POINTER(threadHdr);
+  NS_ENSURE_ARG_POINTER(pNumListed);
+
+  // these children ids should be in thread order.
+  uint32_t i;
+  nsMsgViewIndex viewIndex = startOfThreadViewIndex + 1;
+  *pNumListed = 0;
+
+  uint32_t numChildren;
+  threadHdr->GetNumChildren(&numChildren);
+  NS_ASSERTION(numChildren, "Empty thread in view/db");
+  if (!numChildren)
+    return NS_OK;
+
+  numChildren--; // account for the existing thread root
+  if (!InsertEmptyRows(viewIndex, numChildren))
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  bool threadedView = m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay &&
+    !(m_viewFlags & nsMsgViewFlagsType::kGroupBySort);
+  nsMsgXFViewThread *viewThread;
+  if (threadedView)
+    viewThread = static_cast<nsMsgXFViewThread*>(threadHdr);
+
+  for (i = 1; i <= numChildren; i++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    threadHdr->GetChildHdrAt(i, getter_AddRefs(msgHdr));
+
+    if (msgHdr)
+    {
+      nsMsgKey msgKey;
+      uint32_t msgFlags;
+      msgHdr->GetMessageKey(&msgKey);
+      msgHdr->GetFlags(&msgFlags);
+      uint8_t level = (threadedView) ? viewThread->ChildLevelAt(i) : 1;
+      SetMsgHdrAt(msgHdr, viewIndex, msgKey, msgFlags & ~MSG_VIEW_FLAGS, 
+                  level);
+      (*pNumListed)++;
+      viewIndex++;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgSearchDBView::GetNumMsgsInView(int32_t *aNumMsgs)
+{
+  NS_ENSURE_ARG_POINTER(aNumMsgs);
+  *aNumMsgs = m_totalMessagesInView;
+  return NS_OK;
+}
+
diff --git a/mailnews/base/src/nsMsgSearchDBView.h b/mailnews/base/src/nsMsgSearchDBView.h
new file mode 100644
index 000000000..ff89f1d75
--- /dev/null
+++ b/mailnews/base/src/nsMsgSearchDBView.h
@@ -0,0 +1,146 @@
+/* -*- 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 _nsMsgSearchDBViews_H_
+#define _nsMsgSearchDBViews_H_
+
+#include "mozilla/Attributes.h"
+#include "nsMsgGroupView.h"
+#include "nsIMsgCopyServiceListener.h"
+#include "nsIMsgSearchNotify.h"
+#include "nsMsgXFViewThread.h"
+#include "nsCOMArray.h"
+#include "mozilla/UniquePtr.h"
+
+class nsMsgSearchDBView : public nsMsgGroupView, public nsIMsgCopyServiceListener, public nsIMsgSearchNotify
+{
+public:
+  nsMsgSearchDBView();
+
+  // these are tied together pretty intimately
+  friend class nsMsgXFViewThread;
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIMSGSEARCHNOTIFY
+  NS_DECL_NSIMSGCOPYSERVICELISTENER
+
+  NS_IMETHOD SetSearchSession(nsIMsgSearchSession *aSearchSession) override;
+
+  virtual const char *GetViewName(void) override { return "SearchView"; }
+  NS_IMETHOD Open(nsIMsgFolder *folder, nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder, 
+        nsMsgViewFlagsTypeValue viewFlags, int32_t *pCount) override;
+  NS_IMETHOD CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow,
+                         nsIMsgDBViewCommandUpdater *aCmdUpdater, nsIMsgDBView **_retval) override;
+  NS_IMETHOD CopyDBView(nsMsgDBView *aNewMsgDBView, nsIMessenger *aMessengerInstance, 
+                        nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater) override;
+  NS_IMETHOD Close() override;
+  NS_IMETHOD GetViewType(nsMsgViewTypeValue *aViewType) override;
+  NS_IMETHOD Sort(nsMsgViewSortTypeValue sortType,
+                  nsMsgViewSortOrderValue sortOrder) override;
+  NS_IMETHOD GetCommandStatus(nsMsgViewCommandTypeValue command,
+                              bool *selectable_p,
+                              nsMsgViewCommandCheckStateValue *selected_p) override;
+  NS_IMETHOD DoCommand(nsMsgViewCommandTypeValue command) override;
+  NS_IMETHOD DoCommandWithFolder(nsMsgViewCommandTypeValue command, nsIMsgFolder *destFolder) override;
+  NS_IMETHOD GetHdrForFirstSelectedMessage(nsIMsgDBHdr **hdr) override;
+  NS_IMETHOD OpenWithHdrs(nsISimpleEnumerator *aHeaders, 
+                          nsMsgViewSortTypeValue aSortType,
+                          nsMsgViewSortOrderValue aSortOrder, 
+                          nsMsgViewFlagsTypeValue aViewFlags,
+                          int32_t *aCount) override;
+  NS_IMETHOD OnHdrDeleted(nsIMsgDBHdr *aHdrDeleted, nsMsgKey aParentKey, 
+                          int32_t aFlags, nsIDBChangeListener *aInstigator) override;
+  NS_IMETHOD OnHdrFlagsChanged(nsIMsgDBHdr *aHdrChanged, uint32_t aOldFlags,
+                               uint32_t aNewFlags, nsIDBChangeListener *aInstigator) override;
+  NS_IMETHOD GetNumMsgsInView(int32_t *aNumMsgs) override;
+  // override to get location
+  NS_IMETHOD GetCellText(int32_t aRow, nsITreeColumn* aCol, nsAString& aValue) override;
+  virtual nsresult GetMsgHdrForViewIndex(nsMsgViewIndex index, nsIMsgDBHdr **msgHdr) override;
+  virtual nsresult OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey parentKey, bool ensureListed) override;
+  NS_IMETHOD GetFolderForViewIndex(nsMsgViewIndex index, nsIMsgFolder **folder) override;
+
+  NS_IMETHOD OnAnnouncerGoingAway(nsIDBChangeAnnouncer *instigator) override;
+
+  virtual nsCOMArray<nsIMsgFolder>* GetFolders() override;
+  virtual nsresult GetFolderFromMsgURI(const char *aMsgURI, nsIMsgFolder **aFolder) override;
+
+  NS_IMETHOD GetThreadContainingMsgHdr(nsIMsgDBHdr *msgHdr, nsIMsgThread **pThread) override;
+
+protected:
+  virtual ~nsMsgSearchDBView();
+  virtual void InternalClose() override;
+  virtual nsresult HashHdr(nsIMsgDBHdr *msgHdr, nsString& aHashKey) override;
+  virtual nsresult ListIdsInThread(nsIMsgThread *threadHdr, 
+                                   nsMsgViewIndex startOfThreadViewIndex, 
+                                   uint32_t *pNumListed) override;
+  nsresult FetchLocation(int32_t aRow, nsAString& aLocationString);
+  virtual nsresult AddHdrFromFolder(nsIMsgDBHdr *msgHdr, nsIMsgFolder *folder);
+  virtual nsresult GetDBForViewIndex(nsMsgViewIndex index, nsIMsgDatabase **db) override;
+  virtual nsresult RemoveByIndex(nsMsgViewIndex index) override;
+  virtual nsresult CopyMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool isMove, nsIMsgFolder *destFolder) override;
+  virtual nsresult DeleteMessages(nsIMsgWindow *window, nsMsgViewIndex *indices, int32_t numIndices, bool deleteStorage) override;
+  virtual void InsertMsgHdrAt(nsMsgViewIndex index, nsIMsgDBHdr *hdr,
+                              nsMsgKey msgKey, uint32_t flags, uint32_t level) override;
+  virtual void SetMsgHdrAt(nsIMsgDBHdr *hdr, nsMsgViewIndex index,
+                              nsMsgKey msgKey, uint32_t flags, uint32_t level) override;
+  virtual bool InsertEmptyRows(nsMsgViewIndex viewIndex, int32_t numRows) override;
+  virtual void RemoveRows(nsMsgViewIndex viewIndex, int32_t numRows) override;
+  virtual nsMsgViewIndex FindHdr(nsIMsgDBHdr *msgHdr, nsMsgViewIndex startIndex = 0,
+                                 bool allowDummy=false) override;
+  nsresult GetFoldersAndHdrsForSelection(nsMsgViewIndex *indices, int32_t numIndices);
+  nsresult GroupSearchResultsByFolder();
+  nsresult PartitionSelectionByFolder(nsMsgViewIndex *indices,
+                                      int32_t numIndices,
+                                      mozilla::UniquePtr<nsTArray<uint32_t>[]> &indexArrays,
+                                      int32_t *numArrays);
+
+  virtual nsresult ApplyCommandToIndicesWithFolder(nsMsgViewCommandTypeValue command, nsMsgViewIndex* indices,
+                    int32_t numIndices, nsIMsgFolder *destFolder) override;
+  void MoveThreadAt(nsMsgViewIndex threadIndex);
+  
+  virtual nsresult GetMessageEnumerator(nsISimpleEnumerator **enumerator) override;
+  virtual nsresult InsertHdrFromFolder(nsIMsgDBHdr *msgHdr, nsIMsgFolder *folder);
+
+  nsCOMArray<nsIMsgFolder> m_folders;
+  nsCOMArray<nsIMutableArray> m_hdrsForEachFolder;
+  nsCOMArray<nsIMsgFolder> m_uniqueFoldersSelected;
+  uint32_t mCurIndex;
+
+  nsMsgViewIndex* mIndicesForChainedDeleteAndFile;
+  int32_t mTotalIndices;
+  nsCOMArray<nsIMsgDatabase> m_dbToUseList;
+  nsMsgViewCommandTypeValue mCommand;
+  nsCOMPtr <nsIMsgFolder> mDestFolder;
+  nsWeakPtr m_searchSession;
+
+  nsresult ProcessRequestsInOneFolder(nsIMsgWindow *window);
+  nsresult ProcessRequestsInAllFolders(nsIMsgWindow *window);
+  // these are for doing threading of the search hits
+
+  // used for assigning thread id's to xfview threads.
+  nsMsgKey m_nextThreadId;
+  // this maps message-ids and reference message ids to
+  // the corresponding nsMsgXFViewThread object. If we're 
+  // doing subject threading, we would throw subjects
+  // into the same table.
+  nsInterfaceHashtable <nsCStringHashKey, nsIMsgThread> m_threadsTable;
+
+  // map message-ids to msg hdrs in the view, used for threading.
+  nsInterfaceHashtable <nsCStringHashKey, nsIMsgDBHdr> m_hdrsTable;
+  uint32_t m_totalMessagesInView;
+
+  virtual nsMsgGroupThread *CreateGroupThread(nsIMsgDatabase *db) override;
+  nsresult GetXFThreadFromMsgHdr(nsIMsgDBHdr *msgHdr, nsIMsgThread **pThread,
+                                 bool *foundByMessageId = nullptr);
+  bool     GetThreadFromHash(nsCString &reference, nsIMsgThread **thread);
+  bool     GetMsgHdrFromHash(nsCString &reference, nsIMsgDBHdr **hdr);
+  nsresult AddRefToHash(nsCString &reference, nsIMsgThread *thread);
+  nsresult AddMsgToHashTables(nsIMsgDBHdr *msgHdr, nsIMsgThread *thread);
+  nsresult RemoveRefFromHash(nsCString &reference);
+  nsresult RemoveMsgFromHashTables(nsIMsgDBHdr *msgHdr);
+  nsresult InitRefHash();
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgServiceProvider.cpp b/mailnews/base/src/nsMsgServiceProvider.cpp
new file mode 100644
index 000000000..224ae799d
--- /dev/null
+++ b/mailnews/base/src/nsMsgServiceProvider.cpp
@@ -0,0 +1,139 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsMsgServiceProvider.h"
+#include "nsIServiceManager.h"
+
+#include "nsRDFCID.h"
+#include "nsIRDFService.h"
+#include "nsIRDFRemoteDataSource.h"
+
+#include "nsIFileChannel.h"
+#include "nsNetUtil.h"
+#include "nsMsgBaseCID.h"
+
+#include "nsMailDirServiceDefs.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIDirectoryEnumerator.h"
+
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+static NS_DEFINE_CID(kRDFCompositeDataSourceCID, NS_RDFCOMPOSITEDATASOURCE_CID);
+static NS_DEFINE_CID(kRDFXMLDataSourceCID, NS_RDFXMLDATASOURCE_CID);
+
+nsMsgServiceProviderService::nsMsgServiceProviderService()
+{}
+
+nsMsgServiceProviderService::~nsMsgServiceProviderService()
+{}
+
+NS_IMPL_ISUPPORTS(nsMsgServiceProviderService, nsIRDFDataSource)
+
+nsresult
+nsMsgServiceProviderService::Init()
+{
+  nsresult rv;
+  nsCOMPtr<nsIRDFService> rdf = do_GetService(kRDFServiceCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  mInnerDataSource = do_CreateInstance(kRDFCompositeDataSourceCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  LoadISPFiles();
+  return NS_OK;
+}
+
+/**
+ * Looks for ISP configuration files in <.exe>\isp and any sub directories called isp
+ * located in the user's extensions directory.
+ */
+void nsMsgServiceProviderService::LoadISPFiles()
+{
+  nsresult rv;
+  nsCOMPtr<nsIProperties> dirSvc = do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);
+  if (NS_FAILED(rv))
+    return;
+
+  // Walk through the list of isp directories
+  nsCOMPtr<nsISimpleEnumerator> ispDirectories;
+  rv = dirSvc->Get(ISP_DIRECTORY_LIST,
+                   NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(ispDirectories));
+  if (NS_FAILED(rv))
+    return;
+
+  bool hasMore;
+  nsCOMPtr<nsIFile> ispDirectory;
+  while (NS_SUCCEEDED(ispDirectories->HasMoreElements(&hasMore)) && hasMore) 
+  {
+    nsCOMPtr<nsISupports> elem;
+    ispDirectories->GetNext(getter_AddRefs(elem));
+
+    ispDirectory = do_QueryInterface(elem);
+    if (ispDirectory)
+      LoadISPFilesFromDir(ispDirectory);
+  }
+}
+
+void nsMsgServiceProviderService::LoadISPFilesFromDir(nsIFile* aDir)
+{
+  nsresult rv;
+
+  bool check = false;
+  rv = aDir->Exists(&check);
+  if (NS_FAILED(rv) || !check)
+    return;
+
+  rv = aDir->IsDirectory(&check);
+  if (NS_FAILED(rv) || !check)
+    return;
+
+  nsCOMPtr<nsISimpleEnumerator> e;
+  rv = aDir->GetDirectoryEntries(getter_AddRefs(e));
+  if (NS_FAILED(rv))
+    return;
+
+  nsCOMPtr<nsIDirectoryEnumerator> files(do_QueryInterface(e));
+  if (!files)
+    return;
+
+  // we only care about the .rdf files in this directory
+  nsCOMPtr<nsIFile> file;
+  while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(file))) && file) {
+    nsAutoString leafName;
+    file->GetLeafName(leafName);
+    if (!StringEndsWith(leafName, NS_LITERAL_STRING(".rdf")))
+      continue;
+
+    nsAutoCString urlSpec;
+    rv = NS_GetURLSpecFromFile(file, urlSpec);
+    if (NS_SUCCEEDED(rv))
+      LoadDataSource(urlSpec.get());
+  }
+}
+
+nsresult
+nsMsgServiceProviderService::LoadDataSource(const char *aURI)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIRDFDataSource> ds =
+      do_CreateInstance(kRDFXMLDataSourceCID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIRDFRemoteDataSource> remote =
+      do_QueryInterface(ds, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  rv = remote->Init(aURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // for now load synchronously (async seems to be busted)
+  rv = remote->Refresh(true);
+  NS_ASSERTION(NS_SUCCEEDED(rv), "failed refresh?\n");
+
+  rv = mInnerDataSource->AddDataSource(ds);
+
+  return rv;
+}
diff --git a/mailnews/base/src/nsMsgServiceProvider.h b/mailnews/base/src/nsMsgServiceProvider.h
new file mode 100644
index 000000000..6697ebf83
--- /dev/null
+++ b/mailnews/base/src/nsMsgServiceProvider.h
@@ -0,0 +1,34 @@
+/* -*- 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 __nsMsgServiceProvider_h
+#define __nsMsgServiceProvider_h
+
+#include "nsIRDFDataSource.h"
+#include "nsIRDFRemoteDataSource.h"
+#include "nsIRDFCompositeDataSource.h"
+#include "nsCOMPtr.h"
+
+class nsMsgServiceProviderService : public nsIRDFDataSource
+{
+
+ public:
+  nsMsgServiceProviderService();
+
+  nsresult Init();
+  
+  NS_DECL_ISUPPORTS
+  NS_FORWARD_NSIRDFDATASOURCE(mInnerDataSource->)
+  
+ private:
+  virtual ~nsMsgServiceProviderService();
+
+  nsCOMPtr<nsIRDFCompositeDataSource> mInnerDataSource;
+  nsresult LoadDataSource(const char *aURL);
+
+  void LoadISPFilesFromDir(nsIFile* aDir);
+  void LoadISPFiles();
+};
+#endif
diff --git a/mailnews/base/src/nsMsgSpecialViews.cpp b/mailnews/base/src/nsMsgSpecialViews.cpp
new file mode 100644
index 000000000..3943a5ca2
--- /dev/null
+++ b/mailnews/base/src/nsMsgSpecialViews.cpp
@@ -0,0 +1,179 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"
+#include "nsMsgSpecialViews.h"
+#include "nsIMsgThread.h"
+#include "nsMsgMessageFlags.h"
+
+nsMsgThreadsWithUnreadDBView::nsMsgThreadsWithUnreadDBView()
+: m_totalUnwantedMessagesInView(0)
+{
+  
+}
+
+nsMsgThreadsWithUnreadDBView::~nsMsgThreadsWithUnreadDBView()
+{
+}
+
+NS_IMETHODIMP nsMsgThreadsWithUnreadDBView::GetViewType(nsMsgViewTypeValue *aViewType)
+{
+    NS_ENSURE_ARG_POINTER(aViewType);
+    *aViewType = nsMsgViewType::eShowThreadsWithUnread;
+    return NS_OK;
+}
+
+bool nsMsgThreadsWithUnreadDBView::WantsThisThread(nsIMsgThread *threadHdr)
+{
+  if (threadHdr)
+  {
+    uint32_t numNewChildren;
+
+    threadHdr->GetNumUnreadChildren(&numNewChildren);
+    if (numNewChildren > 0)
+      return true;
+    uint32_t numChildren;
+    threadHdr->GetNumChildren(&numChildren);
+    m_totalUnwantedMessagesInView += numChildren;
+  }
+  return false;
+}
+
+nsresult nsMsgThreadsWithUnreadDBView::AddMsgToThreadNotInView(nsIMsgThread *threadHdr, nsIMsgDBHdr *msgHdr, bool ensureListed)
+{
+  nsresult rv = NS_OK;
+
+  nsCOMPtr <nsIMsgDBHdr> parentHdr;
+  uint32_t msgFlags;
+  msgHdr->GetFlags(&msgFlags);
+  GetFirstMessageHdrToDisplayInThread(threadHdr, getter_AddRefs(parentHdr));
+  if (parentHdr && (ensureListed || !(msgFlags & nsMsgMessageFlags::Read)))
+  {
+    nsMsgKey key;
+    uint32_t numMsgsInThread;
+    rv = AddHdr(parentHdr);
+    threadHdr->GetNumChildren(&numMsgsInThread);
+    if (numMsgsInThread > 1)
+    {
+      parentHdr->GetMessageKey(&key);
+      nsMsgViewIndex viewIndex = FindViewIndex(key);
+      if (viewIndex != nsMsgViewIndex_None)
+        OrExtraFlag(viewIndex, nsMsgMessageFlags::Elided | MSG_VIEW_FLAG_HASCHILDREN);
+    }
+    m_totalUnwantedMessagesInView -= numMsgsInThread;
+  }
+  else
+    m_totalUnwantedMessagesInView++;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgThreadsWithUnreadDBView::CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater, nsIMsgDBView **_retval)
+{
+  nsMsgThreadsWithUnreadDBView* newMsgDBView = new nsMsgThreadsWithUnreadDBView();
+
+  if (!newMsgDBView)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv = CopyDBView(newMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  NS_IF_ADDREF(*_retval = newMsgDBView);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgThreadsWithUnreadDBView::GetNumMsgsInView(int32_t *aNumMsgs)
+{
+  nsresult rv = nsMsgDBView::GetNumMsgsInView(aNumMsgs);
+  NS_ENSURE_SUCCESS(rv, rv);
+  *aNumMsgs = *aNumMsgs - m_totalUnwantedMessagesInView;
+  return rv;
+}
+
+nsMsgWatchedThreadsWithUnreadDBView::nsMsgWatchedThreadsWithUnreadDBView()
+: m_totalUnwantedMessagesInView(0)
+{
+}
+
+NS_IMETHODIMP nsMsgWatchedThreadsWithUnreadDBView::GetViewType(nsMsgViewTypeValue *aViewType)
+{
+    NS_ENSURE_ARG_POINTER(aViewType);
+    *aViewType = nsMsgViewType::eShowWatchedThreadsWithUnread;
+    return NS_OK;
+}
+
+bool nsMsgWatchedThreadsWithUnreadDBView::WantsThisThread(nsIMsgThread *threadHdr)
+{
+  if (threadHdr)
+  {
+    uint32_t numNewChildren;
+    uint32_t threadFlags;
+
+    threadHdr->GetNumUnreadChildren(&numNewChildren);
+    threadHdr->GetFlags(&threadFlags);
+    if (numNewChildren > 0 && (threadFlags & nsMsgMessageFlags::Watched) != 0)
+      return true;
+    uint32_t numChildren;
+    threadHdr->GetNumChildren(&numChildren);
+    m_totalUnwantedMessagesInView += numChildren;
+  }
+  return false;
+}
+
+nsresult nsMsgWatchedThreadsWithUnreadDBView::AddMsgToThreadNotInView(nsIMsgThread *threadHdr, nsIMsgDBHdr *msgHdr, bool ensureListed)
+{
+  nsresult rv = NS_OK;
+  uint32_t threadFlags;
+  uint32_t msgFlags;
+  msgHdr->GetFlags(&msgFlags);
+  threadHdr->GetFlags(&threadFlags);
+  if (threadFlags & nsMsgMessageFlags::Watched)
+  {
+    nsCOMPtr <nsIMsgDBHdr> parentHdr;
+    GetFirstMessageHdrToDisplayInThread(threadHdr, getter_AddRefs(parentHdr));
+    if (parentHdr && (ensureListed || !(msgFlags & nsMsgMessageFlags::Read)))
+    {
+      uint32_t numChildren;
+      threadHdr->GetNumChildren(&numChildren);
+      rv = AddHdr(parentHdr);
+      if (numChildren > 1)
+      {
+        nsMsgKey key;
+        parentHdr->GetMessageKey(&key);
+        nsMsgViewIndex viewIndex = FindViewIndex(key);
+        if (viewIndex != nsMsgViewIndex_None)
+          OrExtraFlag(viewIndex, nsMsgMessageFlags::Elided | MSG_VIEW_FLAG_ISTHREAD | MSG_VIEW_FLAG_HASCHILDREN | nsMsgMessageFlags::Watched);
+      }
+      m_totalUnwantedMessagesInView -= numChildren;
+      return rv;
+    }
+  }
+  m_totalUnwantedMessagesInView++;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgWatchedThreadsWithUnreadDBView::CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater, nsIMsgDBView **_retval)
+{
+  nsMsgWatchedThreadsWithUnreadDBView* newMsgDBView = new nsMsgWatchedThreadsWithUnreadDBView();
+
+  if (!newMsgDBView)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv = CopyDBView(newMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  NS_IF_ADDREF(*_retval = newMsgDBView);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgWatchedThreadsWithUnreadDBView::GetNumMsgsInView(int32_t *aNumMsgs)
+{
+  nsresult rv = nsMsgDBView::GetNumMsgsInView(aNumMsgs);
+  NS_ENSURE_SUCCESS(rv, rv);
+  *aNumMsgs = *aNumMsgs - m_totalUnwantedMessagesInView;
+  return rv;
+}
diff --git a/mailnews/base/src/nsMsgSpecialViews.h b/mailnews/base/src/nsMsgSpecialViews.h
new file mode 100644
index 000000000..8f3757a35
--- /dev/null
+++ b/mailnews/base/src/nsMsgSpecialViews.h
@@ -0,0 +1,71 @@
+/* -*- 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 _nsMsgSpecialViews_H_
+#define _nsMsgSpecialViews_H_
+
+#include "mozilla/Attributes.h"
+#include "nsMsgThreadedDBView.h"
+
+class nsMsgThreadsWithUnreadDBView : public nsMsgThreadedDBView
+{
+public:
+  nsMsgThreadsWithUnreadDBView();
+  virtual ~nsMsgThreadsWithUnreadDBView();
+  virtual const char * GetViewName(void) override {return "ThreadsWithUnreadView"; }
+  NS_IMETHOD CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCommandUpdater, nsIMsgDBView **_retval) override;
+  NS_IMETHOD GetViewType(nsMsgViewTypeValue *aViewType) override;
+  NS_IMETHOD GetNumMsgsInView(int32_t *aNumMsgs) override;
+
+virtual bool WantsThisThread(nsIMsgThread *threadHdr) override;
+protected:
+  virtual nsresult AddMsgToThreadNotInView(nsIMsgThread *threadHdr, nsIMsgDBHdr *msgHdr, bool ensureListed) override;
+  uint32_t m_totalUnwantedMessagesInView;
+};
+
+class nsMsgWatchedThreadsWithUnreadDBView : public nsMsgThreadedDBView
+{
+public:
+  nsMsgWatchedThreadsWithUnreadDBView ();
+  NS_IMETHOD GetViewType(nsMsgViewTypeValue *aViewType) override;
+  NS_IMETHOD CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow,
+                         nsIMsgDBViewCommandUpdater *aCommandUpdater,
+                         nsIMsgDBView **_retval) override;
+  NS_IMETHOD GetNumMsgsInView(int32_t *aNumMsgs) override;
+  virtual const char *GetViewName(void) override { return "WatchedThreadsWithUnreadView"; }
+  virtual bool WantsThisThread(nsIMsgThread *threadHdr) override;
+protected:
+  virtual nsresult AddMsgToThreadNotInView(nsIMsgThread *threadHdr, nsIMsgDBHdr *msgHdr, bool ensureListed) override;
+  uint32_t m_totalUnwantedMessagesInView;
+
+};
+#ifdef DOING_CACHELESS_VIEW
+// This view will initially be used for cacheless IMAP.
+class nsMsgCachelessView : public nsMsgDBView
+{
+public:
+						nsMsgCachelessView();
+    NS_IMETHOD GetViewType(nsMsgViewTypeValue *aViewType);
+	virtual 			~nsMsgCachelessView();
+	virtual const char * 		GetViewName(void) {return "nsMsgCachelessView"; }
+	NS_IMETHOD Open(nsIMsgFolder *folder, nsMsgViewSortTypeValue viewType, int32_t *count);
+	nsresult				SetViewSize(int32_t setSize); // Override
+	virtual nsresult		AddNewMessages() ;
+	virtual nsresult		AddHdr(nsIMsgDBHdr *msgHdr);
+	// for news, xover line, potentially, for IMAP, imap line...
+	virtual nsresult		AddHdrFromServerLine(char *line, nsMsgKey *msgId) ;
+	virtual void		SetInitialSortState(void);
+	virtual	nsresult		Init(uint32_t *pCount);
+protected:
+	void				ClearPendingIds();
+
+	nsIMsgFolder		*m_folder;
+	nsMsgViewIndex		m_curStartSeq;
+	nsMsgViewIndex		m_curEndSeq;
+	bool				m_sizeInitialized;
+};
+
+#endif /* DOING_CACHELESS_VIEW */
+#endif
diff --git a/mailnews/base/src/nsMsgStatusFeedback.cpp b/mailnews/base/src/nsMsgStatusFeedback.cpp
new file mode 100644
index 000000000..7843886ed
--- /dev/null
+++ b/mailnews/base/src/nsMsgStatusFeedback.cpp
@@ -0,0 +1,303 @@
+/* -*- 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 "nsIWebProgress.h"
+#include "nsIXULBrowserWindow.h"
+#include "nsMsgStatusFeedback.h"
+#include "nsIDocument.h"
+#include "nsIDOMElement.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIChannel.h"
+#include "prinrval.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMimeMiscStatus.h"
+#include "nsIMsgWindow.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgFolder.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Services.h"
+#include "nsMsgUtils.h"
+
+#define MSGFEEDBACK_TIMER_INTERVAL 500
+
+nsMsgStatusFeedback::nsMsgStatusFeedback() :
+  m_lastPercent(0),
+  m_lastProgressTime(0)
+{
+  nsCOMPtr<nsIStringBundleService> bundleService =
+    mozilla::services::GetStringBundleService();
+
+  if (bundleService)
+    bundleService->CreateBundle("chrome://messenger/locale/messenger.properties",
+                                getter_AddRefs(mBundle));
+
+  m_msgLoadedAtom = MsgGetAtom("msgLoaded");
+}
+
+nsMsgStatusFeedback::~nsMsgStatusFeedback()
+{
+  mBundle = nullptr;
+}
+
+NS_IMPL_ISUPPORTS(nsMsgStatusFeedback, nsIMsgStatusFeedback,
+  nsIProgressEventSink, nsIWebProgressListener, nsISupportsWeakReference)
+
+//////////////////////////////////////////////////////////////////////////////////
+// nsMsgStatusFeedback::nsIWebProgressListener
+//////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP
+nsMsgStatusFeedback::OnProgressChange(nsIWebProgress* aWebProgress,
+                                      nsIRequest* aRequest,
+                                      int32_t aCurSelfProgress,
+                                      int32_t aMaxSelfProgress, 
+                                      int32_t aCurTotalProgress,
+                                      int32_t aMaxTotalProgress)
+{
+  int32_t percentage = 0;
+  if (aMaxTotalProgress > 0)
+  {
+    percentage =  (aCurTotalProgress * 100) / aMaxTotalProgress;
+    if (percentage)
+      ShowProgress(percentage);
+  }
+
+   return NS_OK;
+}
+      
+NS_IMETHODIMP
+nsMsgStatusFeedback::OnStateChange(nsIWebProgress* aWebProgress,
+                                   nsIRequest* aRequest,
+                                   uint32_t aProgressStateFlags,
+                                   nsresult aStatus)
+{
+  nsresult rv;
+
+  NS_ENSURE_TRUE(mBundle, NS_ERROR_NULL_POINTER);
+  if (aProgressStateFlags & STATE_IS_NETWORK)
+  {
+    if (aProgressStateFlags & STATE_START)
+    {
+      m_lastPercent = 0;
+      StartMeteors();
+      nsString loadingDocument;
+      rv = mBundle->GetStringFromName(u"documentLoading",
+                                      getter_Copies(loadingDocument));
+      if (NS_SUCCEEDED(rv))
+        ShowStatusString(loadingDocument);
+    }
+    else if (aProgressStateFlags & STATE_STOP)
+    {
+      // if we are loading message for display purposes, this STATE_STOP notification is 
+      // the only notification we get when layout is actually done rendering the message. We need
+      // to fire the appropriate msgHdrSink notification in this particular case.
+      nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+      if (channel) 
+      {
+        nsCOMPtr<nsIURI> uri; 
+        channel->GetURI(getter_AddRefs(uri));
+        nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl (do_QueryInterface(uri));
+        if (mailnewsUrl)
+        {
+          // get the url type
+          bool messageDisplayUrl;
+          mailnewsUrl->IsUrlType(nsIMsgMailNewsUrl::eDisplay, &messageDisplayUrl);
+
+          if (messageDisplayUrl)
+          {              
+            // get the header sink
+            nsCOMPtr<nsIMsgWindow> msgWindow;
+            mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+            if (msgWindow)
+            {
+              nsCOMPtr<nsIMsgHeaderSink> hdrSink;
+              msgWindow->GetMsgHeaderSink(getter_AddRefs(hdrSink));
+              if (hdrSink)
+                hdrSink->OnEndMsgDownload(mailnewsUrl);
+            }
+            // get the folder and notify that the msg has been loaded. We're 
+            // using NotifyPropertyFlagChanged. To be completely consistent,
+            // we'd send a similar notification that the old message was
+            // unloaded.
+            nsCOMPtr <nsIMsgDBHdr> msgHdr;
+            nsCOMPtr <nsIMsgFolder> msgFolder;
+            mailnewsUrl->GetFolder(getter_AddRefs(msgFolder));
+            nsCOMPtr <nsIMsgMessageUrl> msgUrl = do_QueryInterface(mailnewsUrl);
+            if (msgUrl)
+            {
+              // not sending this notification is not a fatal error...
+              (void) msgUrl->GetMessageHeader(getter_AddRefs(msgHdr));
+              if (msgFolder && msgHdr)
+                msgFolder->NotifyPropertyFlagChanged(msgHdr, m_msgLoadedAtom, 0, 1);
+            }
+          }
+        }
+      }
+      StopMeteors();
+      nsString documentDone;
+      rv = mBundle->GetStringFromName(u"documentDone",
+                                      getter_Copies(documentDone));
+      if (NS_SUCCEEDED(rv))
+        ShowStatusString(documentDone);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgStatusFeedback::OnLocationChange(nsIWebProgress* aWebProgress,
+                                                    nsIRequest* aRequest,
+                                                    nsIURI* aLocation,
+                                                    uint32_t aFlags)
+{
+   return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsMsgStatusFeedback::OnStatusChange(nsIWebProgress* aWebProgress,
+                                    nsIRequest* aRequest,
+                                    nsresult aStatus,
+                                    const char16_t* aMessage)
+{
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP 
+nsMsgStatusFeedback::OnSecurityChange(nsIWebProgress *aWebProgress, 
+                                    nsIRequest *aRequest, 
+                                    uint32_t state)
+{
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMsgStatusFeedback::ShowStatusString(const nsAString& aStatus)
+{
+  nsCOMPtr<nsIMsgStatusFeedback> jsStatusFeedback(do_QueryReferent(mJSStatusFeedbackWeak));
+  if (jsStatusFeedback)
+    jsStatusFeedback->ShowStatusString(aStatus);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgStatusFeedback::SetStatusString(const nsAString& aStatus)
+{
+  nsCOMPtr<nsIMsgStatusFeedback> jsStatusFeedback(do_QueryReferent(mJSStatusFeedbackWeak));
+  if (jsStatusFeedback)
+    jsStatusFeedback->SetStatusString(aStatus);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgStatusFeedback::ShowProgress(int32_t aPercentage)
+{
+  // if the percentage hasn't changed...OR if we are going from 0 to 100% in one step
+  // then don't bother....just fall out....
+  if (aPercentage == m_lastPercent || (m_lastPercent == 0 && aPercentage >= 100))
+    return NS_OK;
+  
+  m_lastPercent = aPercentage;
+
+  int64_t nowMS = 0;
+  if (aPercentage < 100)	// always need to do 100%
+  {
+    nowMS = PR_IntervalToMilliseconds(PR_IntervalNow());
+    if (nowMS < m_lastProgressTime + 250)
+      return NS_OK;
+  }
+
+  m_lastProgressTime = nowMS;
+  nsCOMPtr<nsIMsgStatusFeedback> jsStatusFeedback(do_QueryReferent(mJSStatusFeedbackWeak));
+  if (jsStatusFeedback)
+    jsStatusFeedback->ShowProgress(aPercentage);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgStatusFeedback::StartMeteors()
+{
+  nsCOMPtr<nsIMsgStatusFeedback> jsStatusFeedback(do_QueryReferent(mJSStatusFeedbackWeak));
+  if (jsStatusFeedback)
+    jsStatusFeedback->StartMeteors();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgStatusFeedback::StopMeteors()
+{
+  nsCOMPtr<nsIMsgStatusFeedback> jsStatusFeedback(do_QueryReferent(mJSStatusFeedbackWeak));
+  if (jsStatusFeedback)
+    jsStatusFeedback->StopMeteors();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgStatusFeedback::SetWrappedStatusFeedback(nsIMsgStatusFeedback * aJSStatusFeedback)
+{
+  NS_ENSURE_ARG_POINTER(aJSStatusFeedback);
+  mJSStatusFeedbackWeak = do_GetWeakReference(aJSStatusFeedback);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgStatusFeedback::OnProgress(nsIRequest *request, nsISupports* ctxt, 
+                                              int64_t aProgress, int64_t aProgressMax)
+{
+  // XXX: What should the nsIWebProgress be?
+  // XXX: this truncates 64-bit to 32-bit
+  return OnProgressChange(nullptr, request, int32_t(aProgress), int32_t(aProgressMax), 
+                          int32_t(aProgress) /* current total progress */, int32_t(aProgressMax) /* max total progress */);
+}
+
+NS_IMETHODIMP nsMsgStatusFeedback::OnStatus(nsIRequest *request, nsISupports* ctxt, 
+                                            nsresult aStatus, const char16_t* aStatusArg)
+{
+  nsresult rv;
+  nsCOMPtr<nsIURI> uri;
+  nsString accountName;
+  // fetching account name from nsIRequest
+  nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
+  rv = aChannel->GetURI(getter_AddRefs(uri));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgMailNewsUrl> url(do_QueryInterface(uri));
+  if (url)
+  {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    url->GetServer(getter_AddRefs(server));
+    if (server)
+      server->GetPrettyName(accountName);
+  }
+
+  // forming the status message
+  nsCOMPtr<nsIStringBundleService> sbs =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(sbs, NS_ERROR_UNEXPECTED);
+  nsString str;
+  rv = sbs->FormatStatusMessage(aStatus, aStatusArg, getter_Copies(str));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // prefixing the account name to the status message if status message isn't blank
+  // and doesn't already contain the account name.
+  nsString statusMessage;
+  if (!str.IsEmpty() && str.Find(accountName) == kNotFound)
+  {
+    nsCOMPtr<nsIStringBundle> bundle;
+    rv = sbs->CreateBundle(MSGS_URL, getter_AddRefs(bundle));
+    const char16_t *params[] = { accountName.get(),
+                                  str.get() };
+    rv = bundle->FormatStringFromName(
+      u"statusMessage",
+      params, 2, getter_Copies(statusMessage));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  else
+  {
+    statusMessage.Assign(str);
+  }
+  return ShowStatusString(statusMessage);
+}
diff --git a/mailnews/base/src/nsMsgStatusFeedback.h b/mailnews/base/src/nsMsgStatusFeedback.h
new file mode 100644
index 000000000..b7565377a
--- /dev/null
+++ b/mailnews/base/src/nsMsgStatusFeedback.h
@@ -0,0 +1,50 @@
+/* -*- 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 _nsMsgStatusFeedback_h
+#define _nsMsgStatusFeedback_h
+
+#include "nsIWebProgressListener.h"
+#include "nsIObserver.h"
+#include "nsITimer.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsIProgressEventSink.h"
+#include "nsIStringBundle.h"
+#include "nsWeakReference.h"
+#include "nsIAtom.h"
+
+class nsMsgStatusFeedback : public nsIMsgStatusFeedback,
+                            public nsIProgressEventSink,
+                            public nsIWebProgressListener,
+                            public nsSupportsWeakReference
+{
+public:
+  nsMsgStatusFeedback();
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIMSGSTATUSFEEDBACK
+  NS_DECL_NSIWEBPROGRESSLISTENER
+  NS_DECL_NSIPROGRESSEVENTSINK
+
+protected:
+  virtual ~nsMsgStatusFeedback();
+
+  bool             m_meteorsSpinning;
+  int32_t          m_lastPercent;
+  int64_t          m_lastProgressTime;
+
+  void BeginObserving();
+  void EndObserving();
+
+  // the JS status feedback implementation object...eventually this object
+  // will replace this very C++ class you are looking at.
+  nsWeakPtr mJSStatusFeedbackWeak;
+
+  nsCOMPtr<nsIStringBundle> mBundle;
+  nsCOMPtr <nsIAtom> m_msgLoadedAtom;
+};
+
+#endif // _nsMsgStatusFeedback_h
diff --git a/mailnews/base/src/nsMsgTagService.cpp b/mailnews/base/src/nsMsgTagService.cpp
new file mode 100644
index 000000000..75480c21a
--- /dev/null
+++ b/mailnews/base/src/nsMsgTagService.cpp
@@ -0,0 +1,560 @@
+/* -*- 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 "nsMsgTagService.h"
+#include "nsMsgBaseCID.h"
+#include "nsIPrefService.h"
+#include "nsISupportsPrimitives.h"
+#include "nsMsgI18N.h"
+#include "nsIPrefLocalizedString.h"
+#include "nsMsgDBView.h" // for labels migration
+#include "nsQuickSort.h"
+#include "nsMsgUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMemory.h"
+
+#define STRLEN(s) (sizeof(s) - 1)
+
+#define TAG_PREF_VERSION        "version"
+#define TAG_PREF_SUFFIX_TAG     ".tag"
+#define TAG_PREF_SUFFIX_COLOR   ".color"
+#define TAG_PREF_SUFFIX_ORDINAL ".ordinal"
+#define TAG_CMP_LESSER          -1
+#define TAG_CMP_EQUAL           0
+#define TAG_CMP_GREATER         1
+
+static bool gMigratingKeys = false;
+
+// comparison functions for nsQuickSort
+static int
+CompareMsgTagKeys(const void* aTagPref1, const void* aTagPref2, void* aData)
+{
+  return strcmp(*static_cast<const char* const*>(aTagPref1),
+                *static_cast<const char* const*>(aTagPref2));
+}
+
+static int
+CompareMsgTags(const void* aTagPref1, const void* aTagPref2, void* aData)
+{
+  // Sort nsMsgTag objects by ascending order, using their ordinal or key.
+  // The "smallest" value will be first in the sorted array,
+  // thus being the most important element.
+  nsMsgTag *element1 = *(nsMsgTag**) aTagPref1;
+  nsMsgTag *element2 = *(nsMsgTag**) aTagPref2;
+
+  // if we have only one element, it wins
+  if (!element1 && !element2)
+    return TAG_CMP_EQUAL;
+  if (!element2)
+    return TAG_CMP_LESSER;
+  if (!element1)
+    return TAG_CMP_GREATER;
+
+  // only use the key if the ordinal is not defined or empty
+  nsAutoCString value1, value2;
+  element1->GetOrdinal(value1);
+  if (value1.IsEmpty())
+    element1->GetKey(value1);
+  element2->GetOrdinal(value2);
+  if (value2.IsEmpty())
+    element2->GetKey(value2);
+
+  return strcmp(value1.get(), value2.get());
+}
+
+
+//
+//  nsMsgTag
+//
+NS_IMPL_ISUPPORTS(nsMsgTag, nsIMsgTag)
+
+nsMsgTag::nsMsgTag(const nsACString &aKey,
+                   const nsAString  &aTag,
+                   const nsACString &aColor,
+                   const nsACString &aOrdinal)
+: mTag(aTag),
+  mKey(aKey),
+  mColor(aColor),
+  mOrdinal(aOrdinal)
+{
+}
+
+nsMsgTag::~nsMsgTag()
+{
+}
+
+/* readonly attribute ACString key; */
+NS_IMETHODIMP nsMsgTag::GetKey(nsACString & aKey)
+{
+  aKey = mKey;
+  return NS_OK;
+}
+
+/* readonly attribute AString tag; */
+NS_IMETHODIMP nsMsgTag::GetTag(nsAString & aTag)
+{
+  aTag = mTag;
+  return NS_OK;
+}
+
+/* readonly attribute ACString color; */
+NS_IMETHODIMP nsMsgTag::GetColor(nsACString & aColor)
+{
+  aColor = mColor;
+  return NS_OK;
+}
+
+/* readonly attribute ACString ordinal; */
+NS_IMETHODIMP nsMsgTag::GetOrdinal(nsACString & aOrdinal)
+{
+  aOrdinal = mOrdinal;
+  return NS_OK;
+}
+
+
+//
+//  nsMsgTagService
+//
+NS_IMPL_ISUPPORTS(nsMsgTagService, nsIMsgTagService)
+
+nsMsgTagService::nsMsgTagService()
+{
+  m_tagPrefBranch = nullptr;
+  nsCOMPtr<nsIPrefService> prefService(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (prefService)
+    prefService->GetBranch("mailnews.tags.", getter_AddRefs(m_tagPrefBranch));
+  // need to figure out how to migrate the tags only once.
+  MigrateLabelsToTags();
+  RefreshKeyCache();
+}
+
+nsMsgTagService::~nsMsgTagService()
+{
+  /* destructor code */
+}
+
+/* wstring getTagForKey (in string key); */
+NS_IMETHODIMP nsMsgTagService::GetTagForKey(const nsACString &key, nsAString &_retval)
+{
+  nsAutoCString prefName(key);
+  if (!gMigratingKeys)
+    ToLowerCase(prefName);
+  prefName.AppendLiteral(TAG_PREF_SUFFIX_TAG);
+  return GetUnicharPref(prefName.get(), _retval);
+}
+
+/* void setTagForKey (in string key); */
+NS_IMETHODIMP nsMsgTagService::SetTagForKey(const nsACString &key, const nsAString &tag )
+{
+  nsAutoCString prefName(key);
+  ToLowerCase(prefName);
+  prefName.AppendLiteral(TAG_PREF_SUFFIX_TAG);
+  return SetUnicharPref(prefName.get(), tag);
+}
+
+/* void getKeyForTag (in wstring tag); */
+NS_IMETHODIMP nsMsgTagService::GetKeyForTag(const nsAString &aTag, nsACString &aKey)
+{
+  uint32_t count;
+  char **prefList;
+  nsresult rv = m_tagPrefBranch->GetChildList("", &count, &prefList);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // traverse the list, and look for a pref with the desired tag value.
+  for (uint32_t i = count; i--;)
+  {
+    // We are returned the tag prefs in the form "<key>.<tag_data_type>", but
+    // since we only want the tags, just check that the string ends with "tag".
+    nsDependentCString prefName(prefList[i]);
+    if (StringEndsWith(prefName, NS_LITERAL_CSTRING(TAG_PREF_SUFFIX_TAG)))
+    {
+      nsAutoString curTag;
+      GetUnicharPref(prefList[i], curTag);
+      if (aTag.Equals(curTag))
+      {
+        aKey = Substring(prefName, 0, prefName.Length() - STRLEN(TAG_PREF_SUFFIX_TAG));
+        break;
+      }
+    }
+  }
+  NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, prefList);
+  ToLowerCase(aKey);
+  return NS_OK;
+}
+
+/* ACString getTopKey (in ACString keylist); */
+NS_IMETHODIMP nsMsgTagService::GetTopKey(const nsACString & keyList, nsACString & _retval)
+{
+  _retval.Truncate();
+  // find the most important key
+  nsTArray<nsCString> keyArray;
+  ParseString(keyList, ' ', keyArray);
+  uint32_t keyCount = keyArray.Length();
+  nsCString *topKey = nullptr, *key, topOrdinal, ordinal;
+  for (uint32_t i = 0; i < keyCount; ++i)
+  {
+    key = &keyArray[i];
+    if (key->IsEmpty())
+      continue;
+
+    // ignore unknown keywords
+    nsAutoString tagValue;
+    nsresult rv = GetTagForKey(*key, tagValue);
+    if (NS_FAILED(rv) || tagValue.IsEmpty())
+      continue;
+
+    // new top key, judged by ordinal order?
+    rv = GetOrdinalForKey(*key, ordinal);
+    if (NS_FAILED(rv) || ordinal.IsEmpty())
+      ordinal = *key;
+    if ((ordinal < topOrdinal) || topOrdinal.IsEmpty())
+    {
+      topOrdinal = ordinal;
+      topKey = key; // copy actual result key only once - later
+    }
+  }
+  // return the most important key - if any
+  if (topKey)
+    _retval = *topKey;
+  return NS_OK;
+}
+
+/* void addTagForKey (in string key, in wstring tag, in string color, in string ordinal); */
+NS_IMETHODIMP nsMsgTagService::AddTagForKey(const nsACString &key,
+                                            const nsAString  &tag,
+                                            const nsACString &color,
+                                            const nsACString &ordinal)
+{
+  nsAutoCString prefName(key);
+  ToLowerCase(prefName);
+  prefName.AppendLiteral(TAG_PREF_SUFFIX_TAG);
+  nsresult rv = SetUnicharPref(prefName.get(), tag);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetColorForKey(key, color);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = RefreshKeyCache();
+  NS_ENSURE_SUCCESS(rv, rv);
+  return SetOrdinalForKey(key, ordinal);
+}
+
+/* void addTag (in wstring tag, in long color); */
+NS_IMETHODIMP nsMsgTagService::AddTag(const nsAString  &tag,
+                                      const nsACString &color,
+                                      const nsACString &ordinal)
+{
+  // figure out key from tag. Apply transformation stripping out
+  // illegal characters like <SP> and then convert to imap mod utf7.
+  // Then, check if we have a tag with that key yet, and if so,
+  // make it unique by appending A, AA, etc.
+  // Should we use an iterator?
+  nsAutoString transformedTag(tag);
+  MsgReplaceChar(transformedTag, " ()/{%*<>\\\"", '_');
+  nsAutoCString key;
+  CopyUTF16toMUTF7(transformedTag, key);
+  // We have an imap server that converts keys to upper case so we're going
+  // to normalize all keys to lower case (upper case looks ugly in prefs.js)
+  ToLowerCase(key);
+  nsAutoCString prefName(key);
+  while (true)
+  {
+    nsAutoString tagValue;
+    nsresult rv = GetTagForKey(prefName, tagValue);
+    if (NS_FAILED(rv) || tagValue.IsEmpty() || tagValue.Equals(tag))
+      return AddTagForKey(prefName, tag, color, ordinal);
+    prefName.Append('A');
+  }
+  NS_ASSERTION(false, "can't get here");
+  return NS_ERROR_FAILURE;
+}
+
+/* long getColorForKey (in string key); */
+NS_IMETHODIMP nsMsgTagService::GetColorForKey(const nsACString &key, nsACString  &_retval)
+{
+  nsAutoCString prefName(key);
+  if (!gMigratingKeys)
+    ToLowerCase(prefName);
+  prefName.AppendLiteral(TAG_PREF_SUFFIX_COLOR);
+  nsCString color;
+  nsresult rv = m_tagPrefBranch->GetCharPref(prefName.get(), getter_Copies(color));
+  if (NS_SUCCEEDED(rv))
+    _retval = color;
+  return NS_OK;
+}
+
+/* void setColorForKey (in ACString key, in ACString color); */
+NS_IMETHODIMP nsMsgTagService::SetColorForKey(const nsACString & key, const nsACString & color)
+{
+  nsAutoCString prefName(key);
+  ToLowerCase(prefName);
+  prefName.AppendLiteral(TAG_PREF_SUFFIX_COLOR);
+  if (color.IsEmpty())
+  {
+    m_tagPrefBranch->ClearUserPref(prefName.get());
+    return NS_OK;
+  }
+  return m_tagPrefBranch->SetCharPref(prefName.get(), nsCString(color).get());
+}
+
+/* ACString getOrdinalForKey (in ACString key); */
+NS_IMETHODIMP nsMsgTagService::GetOrdinalForKey(const nsACString & key, nsACString & _retval)
+{
+  nsAutoCString prefName(key);
+  if (!gMigratingKeys)
+    ToLowerCase(prefName);
+  prefName.AppendLiteral(TAG_PREF_SUFFIX_ORDINAL);
+  nsCString ordinal;
+  nsresult rv = m_tagPrefBranch->GetCharPref(prefName.get(), getter_Copies(ordinal));
+  _retval = ordinal;
+  return rv;
+}
+
+/* void setOrdinalForKey (in ACString key, in ACString ordinal); */
+NS_IMETHODIMP nsMsgTagService::SetOrdinalForKey(const nsACString & key, const nsACString & ordinal)
+{
+  nsAutoCString prefName(key);
+  ToLowerCase(prefName);
+  prefName.AppendLiteral(TAG_PREF_SUFFIX_ORDINAL);
+  if (ordinal.IsEmpty())
+  {
+    m_tagPrefBranch->ClearUserPref(prefName.get());
+    return NS_OK;
+  }
+  return m_tagPrefBranch->SetCharPref(prefName.get(), nsCString(ordinal).get());
+}
+
+/* void deleteTag (in wstring tag); */
+NS_IMETHODIMP nsMsgTagService::DeleteKey(const nsACString &key)
+{
+  // clear the associated prefs
+  nsAutoCString prefName(key);
+  if (!gMigratingKeys)
+    ToLowerCase(prefName);
+  nsresult rv = m_tagPrefBranch->DeleteBranch(prefName.get());
+  NS_ENSURE_SUCCESS(rv, rv);
+  return RefreshKeyCache();
+}
+
+/* void getAllTags (out unsigned long count, [array, size_is (count), retval] out nsIMsgTag tagArray); */
+NS_IMETHODIMP nsMsgTagService::GetAllTags(uint32_t *aCount, nsIMsgTag ***aTagArray)
+{
+  NS_ENSURE_ARG_POINTER(aCount);
+  NS_ENSURE_ARG_POINTER(aTagArray);
+
+  // preset harmless default values
+  *aCount = 0;
+  *aTagArray = nullptr;
+
+  // get the actual tag definitions
+  nsresult rv;
+  uint32_t prefCount;
+  char **prefList;
+  rv = m_tagPrefBranch->GetChildList("", &prefCount, &prefList);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // sort them by key for ease of processing
+  NS_QuickSort(prefList, prefCount, sizeof(char*), CompareMsgTagKeys, nullptr);
+
+  // build an array of nsIMsgTag elements from the orderered list
+  // it's at max the same size as the preflist, but usually only about half
+  nsIMsgTag** tagArray = (nsIMsgTag**) NS_Alloc(sizeof(nsIMsgTag*) * prefCount);
+
+  if (!tagArray)
+  {
+    NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList);
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+  uint32_t currentTagIndex = 0;
+  nsMsgTag *newMsgTag;
+  nsString tag;
+  nsCString lastKey, color, ordinal;
+  for (uint32_t i = prefCount; i--;)
+  {
+    // extract just the key from <key>.<info=tag|color|ordinal>
+    char *info = strrchr(prefList[i], '.');
+    if (info)
+    {
+      nsAutoCString key(Substring(prefList[i], info));
+      if (key != lastKey)
+      {
+        if (!key.IsEmpty())
+        {
+          // .tag MUST exist (but may be empty)
+          rv = GetTagForKey(key, tag);
+          if (NS_SUCCEEDED(rv))
+          {
+            // .color MAY exist
+            color.Truncate();
+            GetColorForKey(key, color);
+            // .ordinal MAY exist
+            rv = GetOrdinalForKey(key, ordinal);
+            if (NS_FAILED(rv))
+              ordinal.Truncate();
+            // store the tag info in our array
+            newMsgTag = new nsMsgTag(key, tag, color, ordinal);
+            if (!newMsgTag)
+            {
+              NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(currentTagIndex, tagArray);
+              NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList);
+              return NS_ERROR_OUT_OF_MEMORY;
+            }
+            NS_ADDREF(tagArray[currentTagIndex++] = newMsgTag);
+          }
+        }
+        lastKey = key;
+      }
+    }
+  }
+  NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList);
+
+  // sort the non-null entries by ordinal
+  NS_QuickSort(tagArray, currentTagIndex, sizeof(nsMsgTag*), CompareMsgTags,
+               nullptr);
+
+  // All done, now return the values (the idl's size_is(count) parameter
+  // ensures that the array is cut accordingly).
+  *aCount = currentTagIndex;
+  *aTagArray = tagArray;
+
+  return NS_OK;
+}
+
+nsresult nsMsgTagService::SetUnicharPref(const char *prefName,
+                              const nsAString &val)
+{
+  nsresult rv = NS_OK;
+  if (!val.IsEmpty())
+  {
+    nsCOMPtr<nsISupportsString> supportsString =
+      do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
+    if (supportsString)
+    {
+      supportsString->SetData(val);
+      rv = m_tagPrefBranch->SetComplexValue(prefName,
+                                            NS_GET_IID(nsISupportsString),
+                                            supportsString);
+    }
+  }
+  else
+  {
+    m_tagPrefBranch->ClearUserPref(prefName);
+  }
+  return rv;
+}
+
+nsresult nsMsgTagService::GetUnicharPref(const char *prefName,
+                              nsAString &prefValue)
+{
+  nsresult rv;
+  nsCOMPtr<nsISupportsString> supportsString =
+    do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
+  if (supportsString)
+  {
+    rv = m_tagPrefBranch->GetComplexValue(prefName,
+                                          NS_GET_IID(nsISupportsString),
+                                          getter_AddRefs(supportsString));
+    if (supportsString)
+      rv = supportsString->GetData(prefValue);
+    else
+      prefValue.Truncate();
+  }
+  return rv;
+}
+
+
+nsresult nsMsgTagService::MigrateLabelsToTags()
+{
+  nsCString prefString;
+
+  int32_t prefVersion = 0;
+  nsresult rv = m_tagPrefBranch->GetIntPref(TAG_PREF_VERSION, &prefVersion);
+  if (NS_SUCCEEDED(rv) && prefVersion > 1)
+    return rv;
+  else if (prefVersion == 1)
+  {
+    gMigratingKeys = true;
+  // need to convert the keys to lower case
+    nsIMsgTag **tagArray;
+    uint32_t numTags;
+    GetAllTags(&numTags, &tagArray);
+    for (uint32_t tagIndex = 0; tagIndex < numTags; tagIndex++)
+    {
+      nsAutoCString key, color, ordinal;
+      nsAutoString tagStr;
+      nsIMsgTag *tag = tagArray[tagIndex];
+      tag->GetKey(key);
+      tag->GetTag(tagStr);
+      tag->GetOrdinal(ordinal);
+      tag->GetColor(color);
+      DeleteKey(key);
+      ToLowerCase(key);
+      AddTagForKey(key, tagStr, color, ordinal);
+    }
+    NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(numTags, tagArray);
+    gMigratingKeys = false;
+  }
+  else 
+  {
+    nsCOMPtr<nsIPrefBranch> prefRoot(do_GetService(NS_PREFSERVICE_CONTRACTID));
+    nsCOMPtr<nsIPrefLocalizedString> pls;
+    nsString ucsval;
+    nsAutoCString labelKey("$label1");
+    for(int32_t i = 0; i < PREF_LABELS_MAX; )
+    {
+      prefString.Assign(PREF_LABELS_DESCRIPTION);
+      prefString.AppendInt(i + 1);
+      rv = prefRoot->GetComplexValue(prefString.get(),
+                                     NS_GET_IID(nsIPrefLocalizedString),
+                                     getter_AddRefs(pls));
+      NS_ENSURE_SUCCESS(rv, rv);
+      pls->ToString(getter_Copies(ucsval));
+
+      prefString.Assign(PREF_LABELS_COLOR);
+      prefString.AppendInt(i + 1);
+      nsCString csval;
+      rv = prefRoot->GetCharPref(prefString.get(), getter_Copies(csval));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = AddTagForKey(labelKey, ucsval, csval, EmptyCString());
+      NS_ENSURE_SUCCESS(rv, rv);
+      labelKey.SetCharAt(++i + '1', 6);
+    }
+  }
+  m_tagPrefBranch->SetIntPref(TAG_PREF_VERSION, 2);
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgTagService::IsValidKey(const nsACString &aKey, bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = m_keys.Contains(aKey);
+  return NS_OK;
+}
+
+// refresh the local tag key array m_keys from preferences
+nsresult nsMsgTagService::RefreshKeyCache()
+{
+  nsIMsgTag **tagArray;
+  uint32_t numTags;
+  nsresult rv = GetAllTags(&numTags, &tagArray);
+  NS_ENSURE_SUCCESS(rv, rv);
+  m_keys.Clear();
+
+  for (uint32_t tagIndex = 0; tagIndex < numTags; tagIndex++)
+  {
+    nsIMsgTag *tag = tagArray[tagIndex];
+    if (!tag) {
+      rv = NS_ERROR_FAILURE;
+      break;
+    }
+    nsAutoCString key;
+    tag->GetKey(key);
+    if (!m_keys.InsertElementAt(tagIndex, key)) {
+      rv = NS_ERROR_FAILURE;
+      break;
+    }
+  }
+  NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(numTags, tagArray);
+  return rv;
+}
diff --git a/mailnews/base/src/nsMsgTagService.h b/mailnews/base/src/nsMsgTagService.h
new file mode 100644
index 000000000..d31a81478
--- /dev/null
+++ b/mailnews/base/src/nsMsgTagService.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/. */
+
+#ifndef nsMsgTagService_h__
+#define nsMsgTagService_h__
+
+#include "nsIMsgTagService.h"
+#include "nsIPrefBranch.h"
+#include "nsCOMPtr.h"
+#include "nsStringGlue.h"
+#include "nsTArray.h"
+
+class nsMsgTag final : public nsIMsgTag
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGTAG
+
+  nsMsgTag(const nsACString &aKey,
+           const nsAString  &aTag,
+           const nsACString &aColor,
+           const nsACString &aOrdinal);
+
+protected:
+  ~nsMsgTag();
+
+  nsString  mTag;
+  nsCString mKey, mColor, mOrdinal;
+};
+
+
+class nsMsgTagService final : public nsIMsgTagService
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMSGTAGSERVICE
+
+  nsMsgTagService();
+
+private:
+  ~nsMsgTagService();
+
+protected:
+  nsresult SetUnicharPref(const char *prefName,
+                          const nsAString &prefValue);
+  nsresult GetUnicharPref(const char *prefName,
+                          nsAString &prefValue);
+  nsresult MigrateLabelsToTags();
+  nsresult RefreshKeyCache();
+
+  nsCOMPtr<nsIPrefBranch> m_tagPrefBranch;
+  nsTArray<nsCString> m_keys;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgThreadedDBView.cpp b/mailnews/base/src/nsMsgThreadedDBView.cpp
new file mode 100644
index 000000000..0a2a18fbc
--- /dev/null
+++ b/mailnews/base/src/nsMsgThreadedDBView.cpp
@@ -0,0 +1,983 @@
+/* -*- 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 "nsMsgThreadedDBView.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgThread.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIMsgSearchSession.h"
+#include "nsMsgMessageFlags.h"
+
+#define MSGHDR_CACHE_LOOK_AHEAD_SIZE  25    // Allocate this more to avoid reallocation on new mail.
+#define MSGHDR_CACHE_MAX_SIZE         8192  // Max msghdr cache entries.
+#define MSGHDR_CACHE_DEFAULT_SIZE     100
+
+nsMsgThreadedDBView::nsMsgThreadedDBView()
+{
+  /* member initializers and constructor code */
+  m_havePrevView = false;
+}
+
+nsMsgThreadedDBView::~nsMsgThreadedDBView()
+{
+  /* destructor code */
+}
+
+NS_IMETHODIMP nsMsgThreadedDBView::Open(nsIMsgFolder *folder, nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder, nsMsgViewFlagsTypeValue viewFlags, int32_t *pCount)
+{
+  nsresult rv = nsMsgDBView::Open(folder, sortType, sortOrder, viewFlags, pCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!m_db)
+    return NS_ERROR_NULL_POINTER;
+  // Preset msg hdr cache size for performance reason.
+  int32_t totalMessages, unreadMessages;
+  nsCOMPtr <nsIDBFolderInfo> dbFolderInfo;
+  PersistFolderInfo(getter_AddRefs(dbFolderInfo));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // save off sort type and order, view type and flags
+  dbFolderInfo->GetNumUnreadMessages(&unreadMessages);
+  dbFolderInfo->GetNumMessages(&totalMessages);
+  if (m_viewFlags & nsMsgViewFlagsType::kUnreadOnly)
+  { 
+    // Set unread msg size + extra entries to avoid reallocation on new mail.
+    totalMessages = (uint32_t)unreadMessages+MSGHDR_CACHE_LOOK_AHEAD_SIZE;  
+  }
+  else
+  {
+    if (totalMessages > MSGHDR_CACHE_MAX_SIZE) 
+      totalMessages = MSGHDR_CACHE_MAX_SIZE;        // use max default
+    else if (totalMessages > 0)
+      totalMessages += MSGHDR_CACHE_LOOK_AHEAD_SIZE;// allocate extra entries to avoid reallocation on new mail.
+  }
+  // if total messages is 0, then we probably don't have any idea how many headers are in the db
+  // so we have no business setting the cache size.
+  if (totalMessages > 0)
+    m_db->SetMsgHdrCacheSize((uint32_t)totalMessages);
+  
+  if (pCount)
+    *pCount = 0;
+  rv = InitThreadedView(pCount);
+
+  // this is a hack, but we're trying to find a way to correct
+  // incorrect total and unread msg counts w/o paying a big
+  // performance penalty. So, if we're not threaded, just add
+  // up the total and unread messages in the view and see if that
+  // matches what the db totals say. Except ignored threads are
+  // going to throw us off...hmm. Unless we just look at the
+  // unread counts which is what mostly tweaks people anyway...
+  int32_t unreadMsgsInView = 0;
+  if (!(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+  {
+    for (uint32_t i = m_flags.Length(); i > 0; )
+    {
+      if (!(m_flags[--i] & nsMsgMessageFlags::Read))
+        ++unreadMsgsInView;
+    }
+
+    if (unreadMessages != unreadMsgsInView)
+      m_db->SyncCounts();
+  }
+  m_db->SetMsgHdrCacheSize(MSGHDR_CACHE_DEFAULT_SIZE);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgThreadedDBView::Close()
+{
+  return nsMsgDBView::Close();
+}
+
+nsresult nsMsgThreadedDBView::InitThreadedView(int32_t *pCount)
+{
+  nsresult rv;
+  
+  m_keys.Clear();
+  m_flags.Clear();
+  m_levels.Clear(); 
+  m_prevKeys.Clear();
+  m_prevFlags.Clear();
+  m_prevLevels.Clear();
+  m_havePrevView = false;
+  nsresult getSortrv = NS_OK; // ### TODO m_db->GetSortInfo(&sortType, &sortOrder);
+  
+  // list all the ids into m_keys.
+  nsMsgKey startMsg = 0; 
+  do
+  {
+    const int32_t kIdChunkSize = 400;
+    int32_t  numListed = 0;
+    nsMsgKey idArray[kIdChunkSize];
+    int32_t  flagArray[kIdChunkSize];
+    char     levelArray[kIdChunkSize];
+
+    rv = ListThreadIds(&startMsg, (m_viewFlags & nsMsgViewFlagsType::kUnreadOnly) != 0, idArray, flagArray, 
+      levelArray, kIdChunkSize, &numListed, nullptr);
+    if (NS_SUCCEEDED(rv))
+    {
+      int32_t numAdded = AddKeys(idArray, flagArray, levelArray, m_sortType, numListed);
+      if (pCount)
+        *pCount += numAdded;
+    }
+    
+  } while (NS_SUCCEEDED(rv) && startMsg != nsMsgKey_None);
+  
+  if (NS_SUCCEEDED(getSortrv))
+  {
+    rv = InitSort(m_sortType, m_sortOrder);
+    SaveSortInfo(m_sortType, m_sortOrder);
+
+  }
+  return rv;
+}
+
+nsresult nsMsgThreadedDBView::SortThreads(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder)
+{
+  NS_PRECONDITION(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay, "trying to sort unthreaded threads");
+
+  uint32_t numThreads = 0;
+  // the idea here is that copy the current view,  then build up an m_keys and m_flags array of just the top level
+  // messages in the view, and then call nsMsgDBView::Sort(sortType, sortOrder).
+  // Then, we expand the threads in the result array that were expanded in the original view (perhaps by copying
+  // from the original view, but more likely just be calling expand).
+  for (uint32_t i = 0; i < m_keys.Length(); i++)
+  {
+    if (m_flags[i] & MSG_VIEW_FLAG_ISTHREAD)
+    {
+      if (numThreads < i)
+      {
+        m_keys[numThreads] = m_keys[i];
+        m_flags[numThreads] = m_flags[i];
+      }
+      m_levels[numThreads] = 0;
+      numThreads++;
+    }
+  }
+  m_keys.SetLength(numThreads);
+  m_flags.SetLength(numThreads);
+  m_levels.SetLength(numThreads);
+  //m_viewFlags &= ~nsMsgViewFlagsType::kThreadedDisplay;
+  m_sortType = nsMsgViewSortType::byNone; // sort from scratch
+  nsMsgDBView::Sort(sortType, sortOrder);
+  m_viewFlags |= nsMsgViewFlagsType::kThreadedDisplay;
+  SetSuppressChangeNotifications(true);
+  // Loop through the original array, for each thread that's expanded, find it in the new array
+  // and expand the thread. We have to update MSG_VIEW_FLAG_HAS_CHILDREN because
+  // we may be going from a flat sort, which doesn't maintain that flag,
+  // to a threaded sort, which requires that flag.
+  for (uint32_t j = 0; j < m_keys.Length(); j++)
+  {
+    uint32_t flags = m_flags[j];
+    if ((flags & (MSG_VIEW_FLAG_HASCHILDREN | nsMsgMessageFlags::Elided)) == MSG_VIEW_FLAG_HASCHILDREN)
+    {
+      uint32_t numExpanded;
+      m_flags[j] = flags | nsMsgMessageFlags::Elided;
+      ExpandByIndex(j, &numExpanded);
+      j += numExpanded;
+      if (numExpanded > 0)
+        m_flags[j - numExpanded] = flags | MSG_VIEW_FLAG_HASCHILDREN;
+    }
+    else if (flags & MSG_VIEW_FLAG_ISTHREAD && ! (flags & MSG_VIEW_FLAG_HASCHILDREN))
+    {
+      nsCOMPtr <nsIMsgDBHdr> msgHdr;
+      nsCOMPtr <nsIMsgThread> pThread;
+      m_db->GetMsgHdrForKey(m_keys[j], getter_AddRefs(msgHdr));
+      if (msgHdr)
+      {
+        m_db->GetThreadContainingMsgHdr(msgHdr, getter_AddRefs(pThread));
+        if (pThread)
+        {
+          uint32_t numChildren;
+          pThread->GetNumChildren(&numChildren);
+          if (numChildren > 1)
+            m_flags[j] = flags | MSG_VIEW_FLAG_HASCHILDREN | nsMsgMessageFlags::Elided;
+        }
+      }
+    }
+  }
+  SetSuppressChangeNotifications(false);
+
+  return NS_OK;
+}
+
+int32_t nsMsgThreadedDBView::AddKeys(nsMsgKey *pKeys, int32_t *pFlags, const char *pLevels, nsMsgViewSortTypeValue sortType, int32_t numKeysToAdd)
+
+{
+  int32_t	numAdded = 0;
+  // Allocate enough space first to avoid memory allocation/deallocation.
+  m_keys.SetCapacity(m_keys.Length() + numKeysToAdd);
+  m_flags.SetCapacity(m_flags.Length() + numKeysToAdd);
+  m_levels.SetCapacity(m_levels.Length() + numKeysToAdd);
+  for (int32_t i = 0; i < numKeysToAdd; i++)
+  {
+    int32_t threadFlag = pFlags[i];
+    int32_t flag = threadFlag;
+    
+    // skip ignored threads.
+    if ((threadFlag & nsMsgMessageFlags::Ignored) && !(m_viewFlags & nsMsgViewFlagsType::kShowIgnored))
+      continue;
+    
+    // skip ignored subthreads
+    nsCOMPtr <nsIMsgDBHdr> msgHdr;
+    m_db->GetMsgHdrForKey(pKeys[i], getter_AddRefs(msgHdr));
+    if (!(m_viewFlags & nsMsgViewFlagsType::kShowIgnored))
+    {
+      bool killed;
+      msgHdr->GetIsKilled(&killed);
+      if (killed)
+        continue;
+    }
+
+    // by default, make threads collapsed, unless we're in only viewing new msgs
+    
+    if (flag & MSG_VIEW_FLAG_HASCHILDREN)
+      flag |= nsMsgMessageFlags::Elided;
+    // should this be persistent? Doesn't seem to need to be.
+    flag |= MSG_VIEW_FLAG_ISTHREAD;
+    m_keys.AppendElement(pKeys[i]);
+    m_flags.AppendElement(flag);
+    m_levels.AppendElement(pLevels[i]);
+    numAdded++;
+    // we expand as we build the view, which allows us to insert at the end of the key array,
+    // instead of the middle, and is much faster.
+    if ((!(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay) || m_viewFlags & nsMsgViewFlagsType::kExpandAll) && flag & nsMsgMessageFlags::Elided)
+       ExpandByIndex(m_keys.Length() - 1, NULL);
+  }
+  return numAdded;
+}
+
+NS_IMETHODIMP nsMsgThreadedDBView::Sort(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder)
+{
+  nsresult rv;
+
+  int32_t rowCountBeforeSort = GetSize();
+
+  if (!rowCountBeforeSort) 
+  {
+    // still need to setup our flags even when no articles - bug 98183.
+    m_sortType = sortType;
+    if (sortType == nsMsgViewSortType::byThread && ! (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+      SetViewFlags(m_viewFlags | nsMsgViewFlagsType::kThreadedDisplay);
+    SaveSortInfo(sortType, sortOrder);
+    return NS_OK;
+  }
+
+  if (!m_checkedCustomColumns && CustomColumnsInSortAndNotRegistered())
+    return NS_OK;
+
+  // sort threads by sort order
+  bool sortThreads = m_viewFlags & (nsMsgViewFlagsType::kThreadedDisplay | nsMsgViewFlagsType::kGroupBySort);
+  
+  // if sort type is by thread, and we're already threaded, change sort type to byId
+  if (sortType == nsMsgViewSortType::byThread && (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay) != 0)
+    sortType = nsMsgViewSortType::byId;
+
+  nsMsgKey preservedKey;
+  AutoTArray<nsMsgKey, 1> preservedSelection;
+  SaveAndClearSelection(&preservedKey, preservedSelection);
+  // if the client wants us to forget our cached id arrays, they
+  // should build a new view. If this isn't good enough, we
+  // need a method to do that.
+  if (sortType != m_sortType || !m_sortValid || sortThreads)
+  {
+    SaveSortInfo(sortType, sortOrder);
+    if (sortType == nsMsgViewSortType::byThread)  
+    {
+      m_sortType = sortType;
+      m_viewFlags |= nsMsgViewFlagsType::kThreadedDisplay;
+      m_viewFlags &= ~nsMsgViewFlagsType::kGroupBySort;
+      if ( m_havePrevView)
+      {
+        // restore saved id array and flags array
+        m_keys = m_prevKeys;
+        m_flags = m_prevFlags;
+        m_levels = m_prevLevels;
+        m_sortValid = true;
+        
+        // the sort may have changed the number of rows
+        // before we restore the selection, tell the tree
+        // do this before we call restore selection
+        // this is safe when there is no selection.
+        rv = AdjustRowCount(rowCountBeforeSort, GetSize());
+        
+        RestoreSelection(preservedKey, preservedSelection);
+        if (mTree) mTree->Invalidate();
+        return NS_OK;
+      }
+      else
+      {
+        // set sort info in anticipation of what Init will do.
+        InitThreadedView(nullptr);	// build up thread list.
+        if (sortOrder != nsMsgViewSortOrder::ascending)
+          Sort(sortType, sortOrder);
+        
+        // the sort may have changed the number of rows
+        // before we update the selection, tell the tree
+        // do this before we call restore selection
+        // this is safe when there is no selection.
+        rv = AdjustRowCount(rowCountBeforeSort, GetSize());
+        
+        RestoreSelection(preservedKey, preservedSelection);
+        if (mTree) mTree->Invalidate();
+        return NS_OK;
+      }
+    }
+    else if (sortType  != nsMsgViewSortType::byThread && (m_sortType == nsMsgViewSortType::byThread  || sortThreads)/* && !m_havePrevView*/)
+    {
+      if (sortThreads)
+      {
+        SortThreads(sortType, sortOrder);
+        sortType = nsMsgViewSortType::byThread; // hack so base class won't do anything
+      }
+      else
+      {
+        // going from SortByThread to non-thread sort - must build new key, level,and flags arrays 
+        m_prevKeys = m_keys;
+        m_prevFlags = m_flags;
+        m_prevLevels = m_levels;
+        // do this before we sort, so that we'll use the cheap method
+        // of expanding.
+        m_viewFlags &= ~(nsMsgViewFlagsType::kThreadedDisplay | nsMsgViewFlagsType::kGroupBySort);
+        ExpandAll();
+        //			m_idArray.RemoveAll();
+        //			m_flags.Clear();
+        m_havePrevView = true;
+      }
+    }
+  }
+  else if (m_sortOrder != sortOrder)// check for toggling the sort
+  {
+    nsMsgDBView::Sort(sortType, sortOrder);
+  }
+  if (!sortThreads)
+  {
+    // call the base class in case we're not sorting by thread
+    rv = nsMsgDBView::Sort(sortType, sortOrder);
+    SaveSortInfo(sortType, sortOrder);
+  }
+  // the sort may have changed the number of rows
+  // before we restore the selection, tell the tree
+  // do this before we call restore selection
+  // this is safe when there is no selection.
+  rv = AdjustRowCount(rowCountBeforeSort, GetSize());
+
+  RestoreSelection(preservedKey, preservedSelection);
+  if (mTree) mTree->Invalidate();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return NS_OK;
+}
+
+// list the ids of the top-level thread ids starting at id == startMsg. This actually returns
+// the ids of the first message in each thread.
+nsresult nsMsgThreadedDBView::ListThreadIds(nsMsgKey *startMsg, bool unreadOnly, nsMsgKey *pOutput, int32_t *pFlags, char *pLevels, 
+									 int32_t numToList, int32_t *pNumListed, int32_t *pTotalHeaders)
+{
+  nsresult rv = NS_OK;
+  // N.B..don't ret before assigning numListed to *pNumListed
+  int32_t	numListed = 0;
+  
+  if (*startMsg > 0)
+  {
+    NS_ASSERTION(m_threadEnumerator != nullptr, "where's our iterator?");	// for now, we'll just have to rely on the caller leaving
+    // the iterator in the right place.
+  }
+  else
+  {
+    NS_ASSERTION(m_db, "no db");
+    if (!m_db) return NS_ERROR_UNEXPECTED;
+    rv = m_db->EnumerateThreads(getter_AddRefs(m_threadEnumerator));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  
+  bool hasMore = false;
+  
+  nsCOMPtr <nsIMsgThread> threadHdr ;
+  int32_t	threadsRemoved = 0;
+  while (numListed < numToList &&
+         NS_SUCCEEDED(rv = m_threadEnumerator->HasMoreElements(&hasMore)) &&
+         hasMore)
+  {
+    nsCOMPtr <nsISupports> supports;
+    rv = m_threadEnumerator->GetNext(getter_AddRefs(supports));
+    if (NS_FAILED(rv))
+    {
+      threadHdr = nullptr;
+      break;
+    }
+    threadHdr = do_QueryInterface(supports);
+    if (!threadHdr)
+      break;
+    nsCOMPtr <nsIMsgDBHdr> msgHdr;
+    uint32_t numChildren;
+    if (unreadOnly)
+      threadHdr->GetNumUnreadChildren(&numChildren);
+    else
+      threadHdr->GetNumChildren(&numChildren);
+    uint32_t threadFlags;
+    threadHdr->GetFlags(&threadFlags);
+    if (numChildren != 0)	// not empty thread
+    {
+      int32_t unusedRootIndex;
+      if (pTotalHeaders)
+        *pTotalHeaders += numChildren;
+      if (unreadOnly)
+        rv = threadHdr->GetFirstUnreadChild(getter_AddRefs(msgHdr));
+      else
+        rv = threadHdr->GetRootHdr(&unusedRootIndex, getter_AddRefs(msgHdr));
+      if (NS_SUCCEEDED(rv) && msgHdr != nullptr && WantsThisThread(threadHdr))
+      {
+        uint32_t msgFlags;
+        uint32_t newMsgFlags;
+        nsMsgKey msgKey;
+        msgHdr->GetMessageKey(&msgKey);
+        msgHdr->GetFlags(&msgFlags);
+        // turn off high byte of msg flags - used for view flags.
+        msgFlags &= ~MSG_VIEW_FLAGS;
+        pOutput[numListed] = msgKey;
+        pLevels[numListed] = 0;
+        // turn off these flags on msg hdr - they belong in thread
+        msgHdr->AndFlags(~(nsMsgMessageFlags::Watched), &newMsgFlags);
+        AdjustReadFlag(msgHdr, &msgFlags);
+        // try adding in MSG_VIEW_FLAG_ISTHREAD flag for unreadonly view.
+        pFlags[numListed] = msgFlags | MSG_VIEW_FLAG_ISTHREAD | threadFlags;
+        if (numChildren > 1)
+          pFlags[numListed] |= MSG_VIEW_FLAG_HASCHILDREN;
+        
+        numListed++;
+      }
+      else
+        NS_ASSERTION(NS_SUCCEEDED(rv) && msgHdr, "couldn't get header for some reason");
+    }
+    else if (threadsRemoved < 10 && !(threadFlags & (nsMsgMessageFlags::Watched | nsMsgMessageFlags::Ignored)))
+    {
+      // ### remove thread.
+      threadsRemoved++;	// don't want to remove all empty threads first time
+      // around as it will choke preformance for upgrade.
+#ifdef DEBUG_bienvenu
+      printf("removing empty non-ignored non-watched thread\n");
+#endif
+    }
+  }
+  
+  if (hasMore && threadHdr)
+  {
+    threadHdr->GetThreadKey(startMsg);
+  }
+  else
+  {
+    *startMsg = nsMsgKey_None;
+    nsCOMPtr <nsIDBChangeListener> dbListener = do_QueryInterface(m_threadEnumerator);
+    // this is needed to make the thread enumerator release its reference to the db.
+    if (dbListener)
+      dbListener->OnAnnouncerGoingAway(nullptr);
+    m_threadEnumerator = nullptr;
+  }
+  *pNumListed = numListed;
+  return rv;
+}
+
+void	nsMsgThreadedDBView::OnExtraFlagChanged(nsMsgViewIndex index, uint32_t extraFlag)
+{
+  if (IsValidIndex(index))
+  {
+    if (m_havePrevView)
+    {
+      nsMsgKey keyChanged = m_keys[index];
+      nsMsgViewIndex prevViewIndex = m_prevKeys.IndexOf(keyChanged);
+      if (prevViewIndex != nsMsgViewIndex_None)
+      {
+        uint32_t prevFlag = m_prevFlags[prevViewIndex];
+        // don't want to change the elided bit, or has children or is thread
+        if (prevFlag & nsMsgMessageFlags::Elided)
+          extraFlag |= nsMsgMessageFlags::Elided;
+        else
+          extraFlag &= ~nsMsgMessageFlags::Elided;
+        if (prevFlag & MSG_VIEW_FLAG_ISTHREAD)
+          extraFlag |= MSG_VIEW_FLAG_ISTHREAD;
+        else
+          extraFlag &= ~MSG_VIEW_FLAG_ISTHREAD;
+        if (prevFlag & MSG_VIEW_FLAG_HASCHILDREN)
+          extraFlag |= MSG_VIEW_FLAG_HASCHILDREN;
+        else
+          extraFlag &= ~MSG_VIEW_FLAG_HASCHILDREN;
+        m_prevFlags[prevViewIndex] = extraFlag; // will this be right?
+      }
+    }
+  }
+  // we don't really know what's changed, but to be on the safe side, set the sort invalid
+  // so that reverse sort will pick it up.
+  if (m_sortType == nsMsgViewSortType::byStatus || m_sortType == nsMsgViewSortType::byFlagged || 
+    m_sortType == nsMsgViewSortType::byUnread || m_sortType == nsMsgViewSortType::byPriority)
+    m_sortValid = false;
+}
+
+void nsMsgThreadedDBView::OnHeaderAddedOrDeleted()
+{
+  ClearPrevIdArray();
+}
+
+void nsMsgThreadedDBView::ClearPrevIdArray()
+{
+  m_prevKeys.Clear();
+  m_prevLevels.Clear();
+  m_prevFlags.Clear();
+  m_havePrevView = false;
+}
+
+nsresult nsMsgThreadedDBView::InitSort(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder)
+{
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+    return NS_OK; // nothing to do.
+
+  if (sortType == nsMsgViewSortType::byThread)
+  {
+    nsMsgDBView::Sort(nsMsgViewSortType::byId, sortOrder); // sort top level threads by id.
+    m_sortType = nsMsgViewSortType::byThread;
+    m_viewFlags |= nsMsgViewFlagsType::kThreadedDisplay;
+    m_viewFlags &= ~nsMsgViewFlagsType::kGroupBySort;
+    SetViewFlags(m_viewFlags); // persist the view flags.
+    //		m_db->SetSortInfo(m_sortType, sortOrder);
+  }
+//  else
+//    m_viewFlags &= ~nsMsgViewFlagsType::kThreadedDisplay;
+  
+  // by default, the unread only view should have all threads expanded.
+  if ((m_viewFlags & (nsMsgViewFlagsType::kUnreadOnly|nsMsgViewFlagsType::kExpandAll)) 
+      && (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    ExpandAll();
+  if (! (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    ExpandAll(); // for now, expand all and do a flat sort.
+  
+  Sort(sortType, sortOrder);
+  if (sortType != nsMsgViewSortType::byThread)	// forget prev view, since it has everything expanded.
+    ClearPrevIdArray();
+  return NS_OK;
+}
+
+nsresult nsMsgThreadedDBView::OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey aParentKey, bool ensureListed)
+{
+  if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+    return nsMsgGroupView::OnNewHeader(newHdr, aParentKey, ensureListed);
+
+  NS_ENSURE_TRUE(newHdr, NS_MSG_MESSAGE_NOT_FOUND);
+
+  nsMsgKey newKey;
+  newHdr->GetMessageKey(&newKey);
+
+  // views can override this behaviour, which is to append to view.
+  // This is the mail behaviour, but threaded views want
+  // to insert in order...
+  uint32_t msgFlags;
+  newHdr->GetFlags(&msgFlags);
+  if ((m_viewFlags & nsMsgViewFlagsType::kUnreadOnly) && !ensureListed &&
+      (msgFlags & nsMsgMessageFlags::Read))
+    return NS_OK;
+  // Currently, we only add the header in a threaded view if it's a thread.
+  // We used to check if this was the first header in the thread, but that's
+  // a bit harder in the unreadOnly view. But we'll catch it below.
+
+  // if not threaded display just add it to the view.
+  if (!(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    return AddHdr(newHdr);
+
+  // need to find the thread we added this to so we can change the hasnew flag
+  // added message to existing thread, but not to view
+  // Fix flags on thread header.
+  int32_t threadCount;
+  uint32_t threadFlags;
+  bool moveThread = false;
+  nsMsgViewIndex threadIndex = ThreadIndexOfMsg(newKey, nsMsgViewIndex_None, &threadCount, &threadFlags);
+  bool threadRootIsDisplayed = false;
+
+  nsCOMPtr <nsIMsgThread> threadHdr;
+  m_db->GetThreadContainingMsgHdr(newHdr, getter_AddRefs(threadHdr));
+  if (threadHdr && m_sortType == nsMsgViewSortType::byDate)
+  {
+    uint32_t newestMsgInThread = 0, msgDate = 0;
+    threadHdr->GetNewestMsgDate(&newestMsgInThread);
+    newHdr->GetDateInSeconds(&msgDate);
+    moveThread = (msgDate == newestMsgInThread);
+  }
+
+  if (threadIndex != nsMsgViewIndex_None)
+  {
+    threadRootIsDisplayed = (m_currentlyDisplayedViewIndex == threadIndex);
+    uint32_t flags = m_flags[threadIndex];
+    if (!(flags & MSG_VIEW_FLAG_HASCHILDREN))
+    {
+      flags |= MSG_VIEW_FLAG_HASCHILDREN | MSG_VIEW_FLAG_ISTHREAD;
+      if (!(m_viewFlags & nsMsgViewFlagsType::kUnreadOnly))
+        flags |= nsMsgMessageFlags::Elided;
+      m_flags[threadIndex] = flags;
+    }
+
+    if (!(flags & nsMsgMessageFlags::Elided))
+    { // thread is expanded
+      // insert child into thread
+      // levels of other hdrs may have changed!
+      uint32_t newFlags = msgFlags;
+      int32_t level = 0;
+      nsMsgViewIndex insertIndex = threadIndex;
+      if (aParentKey == nsMsgKey_None)
+      {
+        newFlags |= MSG_VIEW_FLAG_ISTHREAD | MSG_VIEW_FLAG_HASCHILDREN;
+      }
+      else
+      {
+        nsMsgViewIndex parentIndex = FindParentInThread(aParentKey, threadIndex);
+        level = m_levels[parentIndex] + 1;
+        insertIndex = GetInsertInfoForNewHdr(newHdr, parentIndex, level);
+      }
+      InsertMsgHdrAt(insertIndex, newHdr, newKey, newFlags, level);
+      // the call to NoteChange() has to happen after we add the key
+      // as NoteChange() will call RowCountChanged() which will call our GetRowCount()
+      NoteChange(insertIndex, 1, nsMsgViewNotificationCode::insertOrDelete);
+
+      if (aParentKey == nsMsgKey_None)
+      {
+        // this header is the new king! try collapsing the existing thread,
+        // removing it, installing this header as king, and expanding it.
+        CollapseByIndex(threadIndex, nullptr);
+        // call base class, so child won't get promoted.
+        // nsMsgDBView::RemoveByIndex(threadIndex);
+        ExpandByIndex(threadIndex, nullptr);
+      }
+    }
+    else if (aParentKey == nsMsgKey_None)
+    {
+      // if we have a collapsed thread which just got a new
+      // top of thread, change the keys array.
+      m_keys[threadIndex] = newKey;
+    }
+
+    // If this message is new, the thread is collapsed, it is the
+    // root and it was displayed, expand it so that the user does
+    // not find that their message has magically turned into a summary.
+    if (msgFlags & nsMsgMessageFlags::New &&
+        m_flags[threadIndex] & nsMsgMessageFlags::Elided &&
+        threadRootIsDisplayed)
+      ExpandByIndex(threadIndex, nullptr);
+
+    if (moveThread)
+      MoveThreadAt(threadIndex);
+    else
+      // note change, to update the parent thread's unread and total counts
+      NoteChange(threadIndex, 1, nsMsgViewNotificationCode::changed);
+  }
+  else if (threadHdr)
+    // adding msg to thread that's not in view.
+    AddMsgToThreadNotInView(threadHdr, newHdr, ensureListed);
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMsgThreadedDBView::OnParentChanged (nsMsgKey aKeyChanged, nsMsgKey oldParent, nsMsgKey newParent, nsIDBChangeListener *aInstigator)
+{
+  // we need to adjust the level of the hdr whose parent changed, and invalidate that row,
+  // iff we're in threaded mode.
+#if 0
+  // This code never runs due to the if (false) and Clang complains about it
+  // so it is ifdefed out for now.
+  if (false && m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)
+  {
+    nsMsgViewIndex childIndex = FindViewIndex(aKeyChanged);
+    if (childIndex != nsMsgViewIndex_None)
+    {
+      nsMsgViewIndex parentIndex = FindViewIndex(newParent);
+      int32_t newParentLevel = (parentIndex == nsMsgViewIndex_None) ? -1 : m_levels[parentIndex];
+      nsMsgViewIndex oldParentIndex = FindViewIndex(oldParent);
+      int32_t oldParentLevel = (oldParentIndex != nsMsgViewIndex_None || newParent == nsMsgKey_None) 
+        ? m_levels[oldParentIndex] : -1 ;
+      int32_t levelChanged = m_levels[childIndex];
+      int32_t parentDelta = oldParentLevel - newParentLevel;
+      m_levels[childIndex] = (newParent == nsMsgKey_None) ? 0 : newParentLevel + 1;
+      if (parentDelta > 0)
+      {
+        for (nsMsgViewIndex viewIndex = childIndex + 1; viewIndex < GetSize() && m_levels[viewIndex] > levelChanged;  viewIndex++)
+        {
+          m_levels[viewIndex] = m_levels[viewIndex] - parentDelta;
+          NoteChange(viewIndex, 1, nsMsgViewNotificationCode::changed);
+        }
+      }
+      NoteChange(childIndex, 1, nsMsgViewNotificationCode::changed);
+    }
+  }
+#endif
+  return NS_OK;
+}
+
+
+nsMsgViewIndex nsMsgThreadedDBView::GetInsertInfoForNewHdr(nsIMsgDBHdr *newHdr, nsMsgViewIndex parentIndex, int32_t targetLevel)
+{
+  uint32_t viewSize = GetSize();
+  while (++parentIndex < viewSize)
+  {
+    // loop until we find a message at a level less than or equal to the parent level
+    if (m_levels[parentIndex] < targetLevel)
+      break;
+  }
+  return parentIndex;
+}
+
+// This method removes the thread at threadIndex from the view 
+// and puts it back in its new position, determined by the sort order.
+// And, if the selection is affected, save and restore the selection.
+void nsMsgThreadedDBView::MoveThreadAt(nsMsgViewIndex threadIndex)
+{
+  // we need to check if the thread is collapsed or not...
+  // We want to turn off tree notifications so that we don't
+  // reload the current message.
+  // We also need to invalidate the range between where the thread was
+  // and where it ended up.
+  bool changesDisabled = mSuppressChangeNotification;
+  if (!changesDisabled)
+    SetSuppressChangeNotifications(true);
+
+  nsCOMPtr <nsIMsgDBHdr> threadHdr;
+
+  GetMsgHdrForViewIndex(threadIndex, getter_AddRefs(threadHdr));
+  int32_t childCount = 0;
+
+  nsMsgKey preservedKey;
+  AutoTArray<nsMsgKey, 1> preservedSelection;
+  int32_t selectionCount;
+  int32_t currentIndex;
+  bool hasSelection = mTree && mTreeSelection &&
+                        ((NS_SUCCEEDED(mTreeSelection->GetCurrentIndex(&currentIndex)) &&
+                         currentIndex >= 0 && (uint32_t)currentIndex < GetSize()) ||
+                         (NS_SUCCEEDED(mTreeSelection->GetRangeCount(&selectionCount)) &&
+                          selectionCount > 0));
+  if (hasSelection)
+    SaveAndClearSelection(&preservedKey, preservedSelection);
+  uint32_t saveFlags = m_flags[threadIndex];
+  bool threadIsExpanded = !(saveFlags & nsMsgMessageFlags::Elided);
+
+  if (threadIsExpanded)
+  {
+    ExpansionDelta(threadIndex, &childCount);
+    childCount = -childCount;
+  }
+  nsTArray<nsMsgKey> threadKeys;
+  nsTArray<uint32_t> threadFlags;
+  nsTArray<uint8_t> threadLevels;
+
+  if (threadIsExpanded)
+  {
+    threadKeys.SetCapacity(childCount);
+    threadFlags.SetCapacity(childCount);
+    threadLevels.SetCapacity(childCount);
+    for (nsMsgViewIndex index = threadIndex + 1; 
+        index < GetSize() && m_levels[index]; index++)
+    {
+      threadKeys.AppendElement(m_keys[index]);
+      threadFlags.AppendElement(m_flags[index]);
+      threadLevels.AppendElement(m_levels[index]);
+    }
+    uint32_t collapseCount;
+    CollapseByIndex(threadIndex, &collapseCount);
+  }
+  nsMsgDBView::RemoveByIndex(threadIndex);
+  nsMsgViewIndex newIndex = nsMsgViewIndex_None;
+  AddHdr(threadHdr, &newIndex);
+
+  // AddHdr doesn't always set newIndex, and getting it to do so
+  // is going to require some refactoring.
+  if (newIndex == nsMsgViewIndex_None)
+    newIndex = FindHdr(threadHdr);
+
+  if (threadIsExpanded)
+  {
+    m_keys.InsertElementsAt(newIndex + 1, threadKeys);
+    m_flags.InsertElementsAt(newIndex + 1, threadFlags);
+    m_levels.InsertElementsAt(newIndex + 1, threadLevels);
+  }
+  if (newIndex == nsMsgViewIndex_None)
+  {
+     NS_WARNING("newIndex=-1 in MoveThreadAt");
+     newIndex = 0;
+  }
+  m_flags[newIndex] = saveFlags;
+  // unfreeze selection.
+  if (hasSelection)
+    RestoreSelection(preservedKey, preservedSelection);
+
+  if (!changesDisabled)
+    SetSuppressChangeNotifications(false);
+  nsMsgViewIndex lowIndex = threadIndex < newIndex ? threadIndex : newIndex;
+  nsMsgViewIndex highIndex = lowIndex == threadIndex ? newIndex : threadIndex;
+  NoteChange(lowIndex, highIndex - lowIndex + childCount + 1,
+             nsMsgViewNotificationCode::changed);
+}
+nsresult nsMsgThreadedDBView::AddMsgToThreadNotInView(nsIMsgThread *threadHdr, nsIMsgDBHdr *msgHdr, bool ensureListed)
+{
+  nsresult rv = NS_OK;
+  uint32_t threadFlags;
+  threadHdr->GetFlags(&threadFlags);
+  if (!(threadFlags & nsMsgMessageFlags::Ignored))
+  {
+    bool msgKilled;
+    msgHdr->GetIsKilled(&msgKilled);
+    if (!msgKilled)
+      rv = nsMsgDBView::AddHdr(msgHdr);
+  }
+  return rv;
+}
+
+// This method just removes the specified line from the view. It does
+// NOT delete it from the database.
+nsresult nsMsgThreadedDBView::RemoveByIndex(nsMsgViewIndex index)
+{
+  nsresult rv = NS_OK;
+  int32_t flags;
+
+  if (!IsValidIndex(index))
+    return NS_MSG_INVALID_DBVIEW_INDEX;
+  
+  OnHeaderAddedOrDeleted();
+
+  flags = m_flags[index];
+
+  if (! (m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay)) 
+    return nsMsgDBView::RemoveByIndex(index);
+
+  nsCOMPtr<nsIMsgThread> threadHdr; 
+  GetThreadContainingIndex(index, getter_AddRefs(threadHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint32_t numThreadChildren = 0;
+  // If we can't get a thread, it's already deleted and thus has 0 children.
+  if (threadHdr)
+    threadHdr->GetNumChildren(&numThreadChildren);
+
+  // Check if we're the top level msg in the thread, and we're not collapsed.
+  if ((flags & MSG_VIEW_FLAG_ISTHREAD) &&
+      !(flags & nsMsgMessageFlags::Elided) &&
+      (flags & MSG_VIEW_FLAG_HASCHILDREN))
+  {
+    // Fix flags on thread header - newly promoted message should have
+    // flags set correctly.
+    if (threadHdr)
+    {
+      nsMsgDBView::RemoveByIndex(index);
+      nsCOMPtr<nsIMsgThread> nextThreadHdr;
+      // Above RemoveByIndex may now make index out of bounds.
+      if (IsValidIndex(index) && numThreadChildren > 0)
+      {
+        // unreadOnly
+        nsCOMPtr<nsIMsgDBHdr> msgHdr;
+        rv = threadHdr->GetChildHdrAt(0, getter_AddRefs(msgHdr));
+        if (msgHdr != nullptr)
+        {
+          uint32_t flag = 0;
+          msgHdr->GetFlags(&flag);
+          if (numThreadChildren > 1)
+            flag |= MSG_VIEW_FLAG_ISTHREAD | MSG_VIEW_FLAG_HASCHILDREN;
+
+          m_flags[index] = flag;
+          m_levels[index] = 0;
+        }
+      }
+    }
+    return rv;
+  }
+  else if (!(flags & MSG_VIEW_FLAG_ISTHREAD))
+  {
+    // We're not deleting the top level msg, but top level msg might be the
+    // only msg in thread now.
+    if (threadHdr && numThreadChildren == 1) 
+    {
+      nsMsgKey msgKey;
+      rv = threadHdr->GetChildKeyAt(0, &msgKey);
+      if (NS_SUCCEEDED(rv))
+      {
+        nsMsgViewIndex threadIndex = FindViewIndex(msgKey);
+        if (IsValidIndex(threadIndex))
+        {
+          uint32_t flags = m_flags[threadIndex];
+          flags &= ~(MSG_VIEW_FLAG_ISTHREAD |
+                     nsMsgMessageFlags::Elided |
+                     MSG_VIEW_FLAG_HASCHILDREN);
+          m_flags[threadIndex] = flags;
+          NoteChange(threadIndex, 1, nsMsgViewNotificationCode::changed);
+        }
+      }
+      
+    }
+    return nsMsgDBView::RemoveByIndex(index);
+  }
+  // Deleting collapsed thread header is special case. Child will be promoted,
+  // so just tell FE that line changed, not that it was deleted.
+  // Header has aleady been deleted from thread.
+  if (threadHdr && numThreadChildren > 0)
+  {
+    // change the id array and flags array to reflect the child header.
+    // If we're not deleting the header, we want the second header,
+    // Otherwise, the first one (which just got promoted).
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    rv = threadHdr->GetChildHdrAt(0, getter_AddRefs(msgHdr));
+    if (msgHdr != nullptr)
+    {
+      msgHdr->GetMessageKey(&m_keys[index]);
+
+      uint32_t flag = 0;
+      msgHdr->GetFlags(&flag);
+      flag |= MSG_VIEW_FLAG_ISTHREAD;
+
+      // if only hdr in thread (with one about to be deleted)
+      if (numThreadChildren == 1)
+      {
+        // adjust flags.
+        flag &=  ~MSG_VIEW_FLAG_HASCHILDREN;
+        flag &= ~nsMsgMessageFlags::Elided;
+        // tell FE that thread header needs to be repainted.
+        NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+      }
+      else
+      {
+        flag |= MSG_VIEW_FLAG_HASCHILDREN;
+        flag |= nsMsgMessageFlags::Elided;
+      }
+      m_flags[index] = flag;
+      mIndicesToNoteChange.RemoveElement(index);
+    }
+    else
+      NS_ASSERTION(false, "couldn't find thread child");	
+
+    NoteChange(index, 1, nsMsgViewNotificationCode::changed);	
+  }
+  else
+  {
+    // we may have deleted a whole, collapsed thread - if so,
+    // ensure that the current index will be noted as changed.
+    if (!mIndicesToNoteChange.Contains(index))
+      mIndicesToNoteChange.AppendElement(index);
+
+    rv = nsMsgDBView::RemoveByIndex(index);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgThreadedDBView::GetViewType(nsMsgViewTypeValue *aViewType)
+{
+    NS_ENSURE_ARG_POINTER(aViewType);
+    *aViewType = nsMsgViewType::eShowAllThreads; 
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgThreadedDBView::CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater, nsIMsgDBView **_retval)
+{
+  nsMsgThreadedDBView* newMsgDBView = new nsMsgThreadedDBView();
+
+  if (!newMsgDBView)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv = CopyDBView(newMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  NS_IF_ADDREF(*_retval = newMsgDBView);
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsMsgThreadedDBView.h b/mailnews/base/src/nsMsgThreadedDBView.h
new file mode 100644
index 000000000..948260c12
--- /dev/null
+++ b/mailnews/base/src/nsMsgThreadedDBView.h
@@ -0,0 +1,51 @@
+/* -*- 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 _nsMsgThreadedDBView_H_
+#define _nsMsgThreadedDBView_H_
+
+#include "mozilla/Attributes.h"
+#include "nsMsgGroupView.h"
+
+class nsMsgThreadedDBView : public nsMsgGroupView
+{
+public:
+  nsMsgThreadedDBView();
+  virtual ~nsMsgThreadedDBView();
+
+  NS_IMETHOD Open(nsIMsgFolder *folder, nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder, nsMsgViewFlagsTypeValue viewFlags, int32_t *pCount) override;
+  NS_IMETHOD CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCommandUpdater, nsIMsgDBView **_retval) override;
+  NS_IMETHOD Close() override;
+  int32_t AddKeys(nsMsgKey *pKeys, int32_t *pFlags, const char *pLevels, nsMsgViewSortTypeValue sortType, int32_t numKeysToAdd);
+  NS_IMETHOD Sort(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder) override;
+  NS_IMETHOD GetViewType(nsMsgViewTypeValue *aViewType) override;
+  NS_IMETHOD OnParentChanged (nsMsgKey aKeyChanged, nsMsgKey oldParent, nsMsgKey newParent, nsIDBChangeListener *aInstigator) override;
+
+protected:
+  virtual const char *GetViewName(void) override { return "ThreadedDBView"; }
+  nsresult InitThreadedView(int32_t *pCount);
+  virtual nsresult OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey aParentKey, bool ensureListed) override;
+  virtual nsresult AddMsgToThreadNotInView(nsIMsgThread *threadHdr, nsIMsgDBHdr *msgHdr, bool ensureListed);
+  nsresult ListThreadIds(nsMsgKey *startMsg, bool unreadOnly, nsMsgKey *pOutput, int32_t *pFlags, char *pLevels, 
+                        int32_t numToList, int32_t *pNumListed, int32_t *pTotalHeaders);
+  nsresult InitSort(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder);
+  virtual nsresult SortThreads(nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder);
+  virtual void  OnExtraFlagChanged(nsMsgViewIndex index, uint32_t extraFlag) override;
+  virtual void OnHeaderAddedOrDeleted() override;
+  void    ClearPrevIdArray();
+  virtual nsresult RemoveByIndex(nsMsgViewIndex index) override;
+  nsMsgViewIndex GetInsertInfoForNewHdr(nsIMsgDBHdr *newHdr, nsMsgViewIndex threadIndex, int32_t targetLevel);
+  void MoveThreadAt(nsMsgViewIndex threadIndex);
+
+  // these are used to save off the previous view so that bopping back and forth
+  // between two views is quick (e.g., threaded and flat sorted by date).
+  bool            m_havePrevView;
+  nsTArray<nsMsgKey> m_prevKeys;   //this is used for caching non-threaded view.
+  nsTArray<uint32_t> m_prevFlags;
+  nsTArray<uint8_t>  m_prevLevels;
+  nsCOMPtr <nsISimpleEnumerator> m_threadEnumerator;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgWindow.cpp b/mailnews/base/src/nsMsgWindow.cpp
new file mode 100644
index 000000000..b94cbc0e1
--- /dev/null
+++ b/mailnews/base/src/nsMsgWindow.cpp
@@ -0,0 +1,534 @@
+/* -*- 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 "nsMsgWindow.h"
+#include "nsIURILoader.h"
+#include "nsCURILoader.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIDOMElement.h"
+#include "mozIDOMWindow.h"
+#include "nsTransactionManagerCID.h"
+#include "nsIComponentManager.h"
+#include "nsILoadGroup.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIWebProgress.h"
+#include "nsIWebProgressListener.h"
+#include "nsPIDOMWindow.h"
+#include "nsIPrompt.h"
+#include "nsICharsetConverterManager.h"
+#include "nsIChannel.h"
+#include "nsIRequestObserver.h"
+#include "netCore.h"
+#include "prmem.h"
+#include "plbase64.h"
+#include "nsMsgI18N.h"
+#include "nsIWebNavigation.h"
+#include "nsMsgContentPolicy.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIAuthPrompt.h"
+#include "nsMsgUtils.h"
+
+// used to dispatch urls to default protocol handlers
+#include "nsCExternalHandlerService.h"
+#include "nsIExternalProtocolService.h"
+
+static NS_DEFINE_CID(kTransactionManagerCID, NS_TRANSACTIONMANAGER_CID);
+
+NS_IMPL_ISUPPORTS(nsMsgWindow,
+                              nsIMsgWindow,
+                              nsIURIContentListener,
+                              nsISupportsWeakReference,
+                              nsIMsgWindowTest)
+
+nsMsgWindow::nsMsgWindow()
+{
+  mCharsetOverride = false;
+  m_stopped = false;
+}
+
+nsMsgWindow::~nsMsgWindow()
+{
+  CloseWindow();
+}
+
+nsresult nsMsgWindow::Init()
+{
+  // register ourselves as a content listener with the uri dispatcher service
+  nsresult rv;
+  nsCOMPtr<nsIURILoader> dispatcher =
+           do_GetService(NS_URI_LOADER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = dispatcher->RegisterContentListener(this);
+  if (NS_FAILED(rv))
+    return rv;
+
+  // create Undo/Redo Transaction Manager
+  mTransactionManager = do_CreateInstance(kTransactionManagerCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return mTransactionManager->SetMaxTransactionCount(-1);
+}
+
+NS_IMETHODIMP nsMsgWindow::GetMessageWindowDocShell(nsIDocShell ** aDocShell)
+{
+  *aDocShell = nullptr;
+  nsCOMPtr<nsIDocShell> docShell(do_QueryReferent(mMessageWindowDocShellWeak));
+  if (!docShell)
+  {
+    // if we don't have a docshell, then we need to look up the message pane docshell
+    nsCOMPtr<nsIDocShell> rootShell(do_QueryReferent(mRootDocShellWeak));
+    if (rootShell)
+    {
+      nsCOMPtr<nsIDocShellTreeItem> msgDocShellItem;
+      if(rootShell)
+         rootShell->FindChildWithName(NS_LITERAL_STRING("messagepane"),
+                                      true, false, nullptr, nullptr,
+                                      getter_AddRefs(msgDocShellItem));
+      NS_ENSURE_TRUE(msgDocShellItem, NS_ERROR_FAILURE);
+      docShell = do_QueryInterface(msgDocShellItem);
+      // we don't own mMessageWindowDocShell so don't try to keep a reference to it!
+      mMessageWindowDocShellWeak = do_GetWeakReference(docShell);
+    }
+  }
+  docShell.swap(*aDocShell);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::CloseWindow()
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIURILoader> dispatcher = do_GetService(NS_URI_LOADER_CONTRACTID, &rv);
+  if (dispatcher) // on shut down it's possible dispatcher will be null.
+    rv = dispatcher->UnRegisterContentListener(this);
+
+  mMsgWindowCommands = nullptr;
+  mStatusFeedback = nullptr;
+
+  StopUrls();
+
+  nsCOMPtr<nsIDocShell> messagePaneDocShell(do_QueryReferent(mMessageWindowDocShellWeak));
+  if (messagePaneDocShell)
+  {
+    nsCOMPtr<nsIURIContentListener> listener(do_GetInterface(messagePaneDocShell));
+    if (listener)
+      listener->SetParentContentListener(nullptr);
+    SetRootDocShell(nullptr);
+    mMessageWindowDocShellWeak = nullptr;
+  }
+
+  // in case nsMsgWindow leaks, make sure other stuff doesn't leak.
+  mTransactionManager = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetStatusFeedback(nsIMsgStatusFeedback **aStatusFeedback)
+{
+  NS_ENSURE_ARG_POINTER(aStatusFeedback);
+  NS_IF_ADDREF(*aStatusFeedback = mStatusFeedback);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetStatusFeedback(nsIMsgStatusFeedback * aStatusFeedback)
+{
+  mStatusFeedback = aStatusFeedback;
+  nsCOMPtr<nsIDocShell> messageWindowDocShell;
+  GetMessageWindowDocShell(getter_AddRefs(messageWindowDocShell));
+
+  // register our status feedback object as a web progress listener
+  nsCOMPtr<nsIWebProgress> webProgress(do_GetInterface(messageWindowDocShell));
+  if (webProgress && mStatusFeedback && messageWindowDocShell)
+  {
+    nsCOMPtr<nsIWebProgressListener> webProgressListener = do_QueryInterface(mStatusFeedback);
+    webProgress->AddProgressListener(webProgressListener, nsIWebProgress::NOTIFY_ALL);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetWindowCommands(nsIMsgWindowCommands * aMsgWindowCommands)
+{
+  mMsgWindowCommands = aMsgWindowCommands;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetWindowCommands(nsIMsgWindowCommands **aMsgWindowCommands)
+{
+  NS_ENSURE_ARG_POINTER(aMsgWindowCommands);
+  NS_IF_ADDREF(*aMsgWindowCommands = mMsgWindowCommands);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetMsgHeaderSink(nsIMsgHeaderSink * *aMsgHdrSink)
+{
+  NS_ENSURE_ARG_POINTER(aMsgHdrSink);
+  NS_IF_ADDREF(*aMsgHdrSink = mMsgHeaderSink);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetMsgHeaderSink(nsIMsgHeaderSink * aMsgHdrSink)
+{
+  mMsgHeaderSink = aMsgHdrSink;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetTransactionManager(nsITransactionManager * *aTransactionManager)
+{
+  NS_ENSURE_ARG_POINTER(aTransactionManager);
+  NS_IF_ADDREF(*aTransactionManager = mTransactionManager);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetTransactionManager(nsITransactionManager * aTransactionManager)
+{
+  mTransactionManager = aTransactionManager;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetOpenFolder(nsIMsgFolder * *aOpenFolder)
+{
+  NS_ENSURE_ARG_POINTER(aOpenFolder);
+  NS_IF_ADDREF(*aOpenFolder = mOpenFolder);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetOpenFolder(nsIMsgFolder * aOpenFolder)
+{
+  mOpenFolder = aOpenFolder;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetRootDocShell(nsIDocShell * *aDocShell)
+{
+  if (mRootDocShellWeak)
+    CallQueryReferent(mRootDocShellWeak.get(), aDocShell);
+  else
+    *aDocShell = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetAuthPrompt(nsIAuthPrompt * *aAuthPrompt)
+{
+  NS_ENSURE_ARG_POINTER(aAuthPrompt);
+
+  // testing only
+  if (mAuthPrompt)
+  {
+    NS_ADDREF(*aAuthPrompt = mAuthPrompt);
+    return NS_OK;
+  }
+
+  if (!mRootDocShellWeak)
+    return NS_ERROR_FAILURE;
+
+  nsresult rv;
+  nsCOMPtr<nsIDocShell> docShell(do_QueryReferent(mRootDocShellWeak.get(), &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAuthPrompt> prompt = do_GetInterface(docShell, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  prompt.swap(*aAuthPrompt);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetAuthPrompt(nsIAuthPrompt* aAuthPrompt)
+{
+  mAuthPrompt = aAuthPrompt;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetRootDocShell(nsIDocShell * aDocShell)
+{
+  nsresult rv;
+  nsCOMPtr<nsIWebProgressListener> contentPolicyListener =
+    do_GetService(NS_MSGCONTENTPOLICY_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  // remove the content policy webProgressListener from the root doc shell
+  // we're currently holding, so we don't keep listening for loads that
+  // we don't care about
+  if (mRootDocShellWeak) {
+    nsCOMPtr<nsIWebProgress> oldWebProgress = 
+      do_QueryReferent(mRootDocShellWeak, &rv);
+    if (NS_SUCCEEDED(rv)) {
+      rv = oldWebProgress->RemoveProgressListener(contentPolicyListener);
+      NS_ASSERTION(NS_SUCCEEDED(rv), "failed to remove old progress listener");
+    } 
+  }
+  
+  // Query for the doc shell and release it
+  mRootDocShellWeak = nullptr;
+  if (aDocShell)
+  {
+    mRootDocShellWeak = do_GetWeakReference(aDocShell);
+
+    nsCOMPtr<nsIDocShell> messagePaneDocShell;
+    GetMessageWindowDocShell(getter_AddRefs(messagePaneDocShell));
+    nsCOMPtr<nsIURIContentListener> listener(do_GetInterface(messagePaneDocShell));
+    if (listener)
+      listener->SetParentContentListener(this);
+  
+    // set the contentPolicy webProgressListener on the root docshell for this
+    // window so that it can allow JavaScript for non-message content
+    nsCOMPtr<nsIWebProgress> docShellProgress = 
+      do_QueryInterface(aDocShell, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    
+    rv = docShellProgress->AddProgressListener(contentPolicyListener,
+                                               nsIWebProgress::NOTIFY_LOCATION);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetMailCharacterSet(nsACString& aMailCharacterSet)
+{
+  aMailCharacterSet = mMailCharacterSet;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetMailCharacterSet(const nsACString& aMailCharacterSet)
+{
+  mMailCharacterSet.Assign(aMailCharacterSet);
+
+  // Convert to a canonical charset name instead of using the charset name from the message header as is.
+  // This is needed for charset menu item to have a check mark correctly.
+  nsresult rv;
+  nsCOMPtr <nsICharsetConverterManager> ccm =
+    do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return ccm->GetCharsetAlias(PromiseFlatCString(aMailCharacterSet).get(),
+                              mMailCharacterSet);
+}
+
+NS_IMETHODIMP nsMsgWindow::GetCharsetOverride(bool *aCharsetOverride)
+{
+  NS_ENSURE_ARG_POINTER(aCharsetOverride);
+  *aCharsetOverride = mCharsetOverride;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetCharsetOverride(bool aCharsetOverride)
+{
+  mCharsetOverride = aCharsetOverride;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetDomWindow(mozIDOMWindowProxy **aWindow)
+{
+  NS_ENSURE_ARG_POINTER(aWindow);
+  if (mDomWindow)
+    CallQueryReferent(mDomWindow.get(), aWindow);
+  else
+    *aWindow = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetDomWindow(mozIDOMWindowProxy * aWindow)
+{
+  NS_ENSURE_ARG_POINTER(aWindow);
+  mDomWindow = do_GetWeakReference(aWindow);
+
+  nsCOMPtr<nsPIDOMWindowOuter> win = nsPIDOMWindowOuter::From(aWindow);
+  nsIDocShell *docShell = nullptr;
+  if (win)
+    docShell = win->GetDocShell();
+
+  nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(docShell));
+
+  if(docShellAsItem)
+  {
+    nsCOMPtr<nsIDocShellTreeItem> rootAsItem;
+    docShellAsItem->GetSameTypeRootTreeItem(getter_AddRefs(rootAsItem));
+
+    nsCOMPtr<nsIDocShell> rootAsShell(do_QueryInterface(rootAsItem));
+    SetRootDocShell(rootAsShell);
+
+    // force ourselves to figure out the message pane
+    nsCOMPtr<nsIDocShell> messageWindowDocShell;
+    GetMessageWindowDocShell(getter_AddRefs(messageWindowDocShell));
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetNotificationCallbacks(nsIInterfaceRequestor * aNotificationCallbacks)
+{
+  mNotificationCallbacks = aNotificationCallbacks;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks)
+{
+  NS_ENSURE_ARG_POINTER(aNotificationCallbacks);
+  NS_IF_ADDREF(*aNotificationCallbacks = mNotificationCallbacks);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::StopUrls()
+{
+  m_stopped = true;
+  nsCOMPtr<nsIWebNavigation> webnav(do_QueryReferent(mRootDocShellWeak));
+  return webnav ? webnav->Stop(nsIWebNavigation::STOP_NETWORK) : NS_ERROR_FAILURE;
+}
+
+// nsIURIContentListener support
+NS_IMETHODIMP nsMsgWindow::OnStartURIOpen(nsIURI* aURI, bool* aAbortOpen)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::DoContent(const nsACString& aContentType, bool aIsContentPreferred,
+                                     nsIRequest *request, nsIStreamListener **aContentHandler, bool *aAbortProcess)
+{
+  if (!aContentType.IsEmpty())
+  {
+    // forward the DoContent call to our docshell
+    nsCOMPtr<nsIDocShell> messageWindowDocShell;
+    GetMessageWindowDocShell(getter_AddRefs(messageWindowDocShell));
+    nsCOMPtr<nsIURIContentListener> ctnListener = do_QueryInterface(messageWindowDocShell);
+    if (ctnListener)
+    {
+        nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
+        if (!aChannel) return NS_ERROR_FAILURE;
+
+      // get the url for the channel...let's hope it is a mailnews url so we can set our msg hdr sink on it..
+      // right now, this is the only way I can think of to force the msg hdr sink into the mime converter so it can
+      // get too it later...
+      nsCOMPtr<nsIURI> uri;
+      aChannel->GetURI(getter_AddRefs(uri));
+      if (uri)
+      {
+        nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(uri));
+        if (mailnewsUrl)
+          mailnewsUrl->SetMsgWindow(this);
+      }
+      return ctnListener->DoContent(aContentType, aIsContentPreferred, request, aContentHandler, aAbortProcess);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgWindow::IsPreferred(const char * aContentType,
+                         char ** aDesiredContentType,
+                         bool * aCanHandleContent)
+{
+  *aCanHandleContent = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::CanHandleContent(const char * aContentType,
+                                            bool aIsContentPreferred,
+                                            char ** aDesiredContentType,
+                                            bool * aCanHandleContent)
+
+{
+  // the mail window knows nothing about the default content types
+  // its docshell can handle...ask the content area if it can handle
+  // the content type...
+
+  nsCOMPtr<nsIDocShell> messageWindowDocShell;
+  GetMessageWindowDocShell(getter_AddRefs(messageWindowDocShell));
+  nsCOMPtr<nsIURIContentListener> ctnListener (do_GetInterface(messageWindowDocShell));
+  if (ctnListener)
+    return ctnListener->CanHandleContent(aContentType, aIsContentPreferred,
+                                         aDesiredContentType, aCanHandleContent);
+  else
+    *aCanHandleContent = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetParentContentListener(nsIURIContentListener** aParent)
+{
+  NS_ENSURE_ARG_POINTER(aParent);
+  *aParent = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetParentContentListener(nsIURIContentListener* aParent)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetLoadCookie(nsISupports ** aLoadCookie)
+{
+  NS_ENSURE_ARG_POINTER(aLoadCookie);
+  *aLoadCookie = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetLoadCookie(nsISupports * aLoadCookie)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgWindow::GetPromptDialog(nsIPrompt **aPrompt)
+{
+  NS_ENSURE_ARG_POINTER(aPrompt);
+
+  // testing only
+  if (mPromptDialog)
+  {
+    NS_ADDREF(*aPrompt = mPromptDialog);
+    return NS_OK;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIDocShell> rootShell(do_QueryReferent(mRootDocShellWeak, &rv));
+  if (rootShell)
+  {
+    nsCOMPtr<nsIPrompt> dialog;
+    dialog = do_GetInterface(rootShell, &rv);
+    dialog.swap(*aPrompt);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsMsgWindow::SetPromptDialog(nsIPrompt* aPromptDialog)
+{
+  mPromptDialog = aPromptDialog;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgWindow::DisplayHTMLInMessagePane(const nsAString& title, const nsAString& body, bool clearMsgHdr)
+{
+  if (clearMsgHdr && mMsgWindowCommands)
+    mMsgWindowCommands->ClearMsgPane();
+
+  nsString htmlStr;
+  htmlStr.Append(NS_LITERAL_STRING("<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\"></head><body>"));
+  htmlStr.Append(body);
+  htmlStr.Append(NS_LITERAL_STRING("</body></html>"));
+
+  char *encodedHtml = PL_Base64Encode(NS_ConvertUTF16toUTF8(htmlStr).get(), 0, nullptr);
+  if (!encodedHtml)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsCString dataSpec;
+  dataSpec = "data:text/html;base64,";
+  dataSpec += encodedHtml;
+
+  PR_FREEIF(encodedHtml);
+
+  nsCOMPtr <nsIDocShell> docShell;
+  GetMessageWindowDocShell(getter_AddRefs(docShell));
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(docShell));
+  NS_ENSURE_TRUE(webNav, NS_ERROR_FAILURE);
+
+  return webNav->LoadURI(NS_ConvertASCIItoUTF16(dataSpec).get(),
+                         nsIWebNavigation::LOAD_FLAGS_NONE,
+                         nullptr, nullptr, nullptr);
+}
+
+NS_IMPL_GETSET(nsMsgWindow, Stopped, bool, m_stopped)
diff --git a/mailnews/base/src/nsMsgWindow.h b/mailnews/base/src/nsMsgWindow.h
new file mode 100644
index 000000000..6dd061990
--- /dev/null
+++ b/mailnews/base/src/nsMsgWindow.h
@@ -0,0 +1,61 @@
+/* -*- 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 _nsMsgWindow_h
+#define _nsMsgWindow_h
+
+#include "nsIMsgWindow.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsITransactionManager.h"
+#include "nsIMsgFolder.h"
+#include "nsIDocShell.h"
+#include "nsIURIContentListener.h"
+#include "nsIMimeMiscStatus.h"
+#include "nsWeakReference.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsCOMPtr.h"
+
+class nsMsgWindow : public nsIMsgWindow,
+                    public nsIURIContentListener,
+                    public nsIMsgWindowTest,
+                    public nsSupportsWeakReference
+{
+
+public:
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+
+  nsMsgWindow();
+  nsresult Init();
+  NS_DECL_NSIMSGWINDOW
+  NS_DECL_NSIURICONTENTLISTENER
+  NS_DECL_NSIMSGWINDOWTEST
+
+protected:
+  virtual ~nsMsgWindow();
+  nsCOMPtr<nsIMsgHeaderSink> mMsgHeaderSink;
+  nsCOMPtr<nsIMsgStatusFeedback> mStatusFeedback;
+  nsCOMPtr<nsITransactionManager> mTransactionManager;
+  nsCOMPtr<nsIMsgFolder> mOpenFolder;
+  nsCOMPtr<nsIMsgWindowCommands> mMsgWindowCommands;
+  // These are used by the backend protocol code to attach
+  // notification callbacks to channels, e.g., nsIBadCertListner2.
+  nsCOMPtr<nsIInterfaceRequestor> mNotificationCallbacks;
+  // prompt dialog used during testing only
+  nsCOMPtr<nsIPrompt> mPromptDialog;
+  // authorization prompt used during testing only
+  nsCOMPtr<nsIAuthPrompt> mAuthPrompt;
+
+  // let's not make this a strong ref - we don't own it.
+  nsWeakPtr mRootDocShellWeak;
+  nsWeakPtr mMessageWindowDocShellWeak;
+  nsWeakPtr mDomWindow; 
+
+  nsCString mMailCharacterSet;
+  bool      mCharsetOverride;
+  bool      m_stopped;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgXFViewThread.cpp b/mailnews/base/src/nsMsgXFViewThread.cpp
new file mode 100644
index 000000000..113aeef6f
--- /dev/null
+++ b/mailnews/base/src/nsMsgXFViewThread.cpp
@@ -0,0 +1,481 @@
+/* -*- 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 "nsMsgXFViewThread.h"
+#include "nsMsgSearchDBView.h"
+#include "nsMsgMessageFlags.h"
+
+NS_IMPL_ISUPPORTS(nsMsgXFViewThread, nsIMsgThread)
+
+nsMsgXFViewThread::nsMsgXFViewThread(nsMsgSearchDBView *view, nsMsgKey threadId)
+{
+  m_numUnreadChildren = 0;
+  m_numChildren = 0;
+  m_flags = 0;
+  m_newestMsgDate = 0;
+  m_view = view;
+  m_threadId = threadId;
+}
+
+nsMsgXFViewThread::~nsMsgXFViewThread()
+{
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::SetThreadKey(nsMsgKey threadKey)
+{
+  m_threadId = threadKey;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetThreadKey(nsMsgKey *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = m_threadId;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetFlags(uint32_t *aFlags)
+{
+  NS_ENSURE_ARG_POINTER(aFlags);
+  *aFlags = m_flags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::SetFlags(uint32_t aFlags)
+{
+  m_flags = aFlags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::SetSubject(const nsACString& aSubject)
+{
+  NS_ASSERTION(false, "shouldn't call this");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetSubject(nsACString& result)
+{
+  NS_ASSERTION(false, "shouldn't call this");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetNumChildren(uint32_t *aNumChildren)
+{
+  NS_ENSURE_ARG_POINTER(aNumChildren);
+  *aNumChildren = m_keys.Length();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetNumUnreadChildren (uint32_t *aNumUnreadChildren)
+{
+  NS_ENSURE_ARG_POINTER(aNumUnreadChildren);
+  *aNumUnreadChildren = m_numUnreadChildren;
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsMsgXFViewThread::AddChild(nsIMsgDBHdr *aNewHdr, nsIMsgDBHdr *aInReplyTo, 
+                            bool aThreadInThread, nsIDBChangeAnnouncer *aAnnouncer)
+{
+  uint32_t whereInserted;
+  return AddHdr(aNewHdr, false, whereInserted, nullptr);
+}
+
+// Returns the parent of the newly added header. If reparentChildren
+// is true, we believe that the new header is a parent of an existing
+// header, and we should find it, and reparent it.
+nsresult nsMsgXFViewThread::AddHdr(nsIMsgDBHdr *newHdr,
+                                   bool reparentChildren,
+                                   uint32_t &whereInserted,
+                                   nsIMsgDBHdr **outParent)
+{
+  nsCOMPtr<nsIMsgFolder> newHdrFolder;
+  newHdr->GetFolder(getter_AddRefs(newHdrFolder));
+
+  uint32_t newHdrFlags = 0;
+  uint32_t msgDate;
+  nsMsgKey newHdrKey = 0;
+
+  newHdr->GetMessageKey(&newHdrKey);
+  newHdr->GetDateInSeconds(&msgDate);
+  newHdr->GetFlags(&newHdrFlags);
+  if (msgDate > m_newestMsgDate)
+    SetNewestMsgDate(msgDate);
+
+  if (newHdrFlags & nsMsgMessageFlags::Watched)
+    SetFlags(m_flags | nsMsgMessageFlags::Watched);
+
+  ChangeChildCount(1);
+  if (! (newHdrFlags & nsMsgMessageFlags::Read))
+    ChangeUnreadChildCount(1);
+
+  if (m_numChildren == 1)
+  {
+    m_keys.InsertElementAt(0, newHdrKey);
+    m_levels.InsertElementAt(0, 0);
+    m_folders.InsertObjectAt(newHdrFolder, 0);
+    if (outParent)
+      *outParent = nullptr;
+    whereInserted = 0;
+    return NS_OK;
+  }
+
+  // Find our parent, if any, in the thread. Starting at the newest
+  // reference, and working our way back, see if we've mapped that reference
+  // to this thread.
+  uint16_t numReferences;
+  newHdr->GetNumReferences(&numReferences);
+  nsCOMPtr<nsIMsgDBHdr> parent;
+  int32_t parentIndex = -1;
+
+  for (int32_t i = numReferences - 1; i >= 0;  i--)
+  {
+    nsAutoCString reference;
+    newHdr->GetStringReference(i, reference);
+    if (reference.IsEmpty())
+      break;
+
+    // I could look for the thread from the reference, but getting
+    // the header directly should be fine. If it's not, that means
+    // that the parent isn't in this thread, though it should be.
+    m_view->GetMsgHdrFromHash(reference, getter_AddRefs(parent));
+    if (parent)
+    {
+      parentIndex = HdrIndex(parent);
+      if (parentIndex == -1)
+      {
+        NS_ERROR("how did we get in the wrong thread?");
+        parent = nullptr;
+      }
+      break;
+    }
+  }
+  if (parent)
+  {
+    if (outParent)
+      NS_ADDREF(*outParent = parent);
+    uint32_t parentLevel = m_levels[parentIndex];
+    nsMsgKey parentKey;
+    parent->GetMessageKey(&parentKey);
+    nsCOMPtr<nsIMsgFolder> parentFolder;
+    parent->GetFolder(getter_AddRefs(parentFolder));
+    // iterate over our parents' children until we find one we're older than,
+    // and insert ourselves before it, or as the last child. In other words,
+    // insert, sorted by date.
+    uint32_t msgDate, childDate;
+    newHdr->GetDateInSeconds(&msgDate);
+    nsCOMPtr<nsIMsgDBHdr> child;
+    nsMsgViewIndex i;
+    nsMsgViewIndex insertIndex = m_keys.Length();
+    uint32_t insertLevel = parentLevel + 1;
+    for (i = parentIndex; 
+         i < m_keys.Length() && (i == (nsMsgViewIndex)parentIndex || m_levels[i] >= parentLevel);
+         i++)
+    {
+      GetChildHdrAt(i, getter_AddRefs(child));
+      if (child)
+      {
+        if (reparentChildren && IsHdrParentOf(newHdr, child))
+        {
+          insertIndex = i;
+          // bump all the children of the current child, and the child
+          nsMsgViewIndex j = insertIndex;
+          uint8_t childLevel = m_levels[insertIndex];
+          do
+          {
+            m_levels[j] = m_levels[j] + 1;
+            j++;
+          }
+          while (j < m_keys.Length() && m_levels[j] > childLevel);
+          break;
+        }
+        else if (m_levels[i] == parentLevel + 1) // possible sibling
+        {
+          child->GetDateInSeconds(&childDate);
+          if (msgDate < childDate)
+          {
+            // if we think we need to reparent, remember this
+            // insert index, but keep looking for children.
+            insertIndex = i;
+            insertLevel = m_levels[i];
+            // if the sibling we're inserting after has children, we need
+            // to go after the children.
+            while (insertIndex + 1 < m_keys.Length() && m_levels[insertIndex + 1] > insertLevel)
+              insertIndex++;
+            if (!reparentChildren)
+              break;
+          }
+        }
+      }
+    }
+    m_keys.InsertElementAt(insertIndex, newHdrKey);
+    m_levels.InsertElementAt(insertIndex, insertLevel);
+    m_folders.InsertObjectAt(newHdrFolder, insertIndex);
+    whereInserted = insertIndex;
+  }
+  else
+  {
+    if (outParent)
+      *outParent = nullptr;
+    nsCOMPtr<nsIMsgDBHdr> rootHdr;
+    GetChildHdrAt(0, getter_AddRefs(rootHdr));
+    // If the new header is a parent of the root then it should be promoted. 
+    if (rootHdr && IsHdrParentOf(newHdr, rootHdr))
+    {
+      m_keys.InsertElementAt(0, newHdrKey);
+      m_levels.InsertElementAt(0, 0);
+      m_folders.InsertObjectAt(newHdrFolder, 0);
+      whereInserted = 0;
+      // Adjust level of old root hdr and its children
+      for (nsMsgViewIndex i = 1; i < m_keys.Length(); i++)
+        m_levels[i] = m_levels[1] + 1;
+    }
+    else
+    {
+      m_keys.AppendElement(newHdrKey);
+      m_levels.AppendElement(1);
+      m_folders.AppendObject(newHdrFolder);
+      if (outParent)
+        NS_IF_ADDREF(*outParent = rootHdr);
+      whereInserted = m_keys.Length() -1;
+    }
+  }
+
+  // ### TODO handle the case where the root header starts 
+  // with Re, and the new one doesn't, and is earlier. In that
+  // case, we want to promote the new header to root.
+
+//  PRTime newHdrDate;
+//  newHdr->GetDate(&newHdrDate);
+
+//  if (numChildren > 0 && !(newHdrFlags & nsMsgMessageFlags::HasRe))
+//  {
+//    PRTime topLevelHdrDate;
+
+//    nsCOMPtr<nsIMsgDBHdr> topLevelHdr;
+//    rv = GetRootHdr(nullptr, getter_AddRefs(topLevelHdr));
+//    if (NS_SUCCEEDED(rv) && topLevelHdr)
+//    {
+//      topLevelHdr->GetDate(&topLevelHdrDate);
+//      if (newHdrDate < topLevelHdrDate)
+      
+//    }
+//  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetChildHdrAt(uint32_t aIndex, nsIMsgDBHdr **aResult)
+{
+  if (aIndex >= m_keys.Length())
+    return NS_MSG_MESSAGE_NOT_FOUND;
+  nsCOMPtr<nsIMsgDatabase> db;
+  nsresult rv = m_folders[aIndex]->GetMsgDatabase(getter_AddRefs(db));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return db->GetMsgHdrForKey(m_keys[aIndex], aResult);
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::RemoveChildAt(uint32_t aIndex)
+{
+  m_keys.RemoveElementAt(aIndex);
+  m_levels.RemoveElementAt(aIndex);
+  m_folders.RemoveObjectAt(aIndex);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::RemoveChildHdr(nsIMsgDBHdr *child, nsIDBChangeAnnouncer *announcer)
+{
+  NS_ENSURE_ARG_POINTER(child);
+  nsMsgKey msgKey;
+  uint32_t msgFlags;
+  child->GetMessageKey(&msgKey);
+  child->GetFlags(&msgFlags);
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  child->GetFolder(getter_AddRefs(msgFolder));
+  // if this was the newest msg, clear the newest msg date so we'll recalc.
+  uint32_t date;
+  child->GetDateInSeconds(&date);
+  if (date == m_newestMsgDate)
+    SetNewestMsgDate(0);
+
+  for (uint32_t childIndex = 0; childIndex < m_keys.Length(); childIndex++)
+  {
+    if (m_keys[childIndex] == msgKey && m_folders[childIndex] == msgFolder)
+    {
+      uint8_t levelRemoved = m_keys[childIndex];
+      // Adjust the levels of all the children of this header
+      nsMsgViewIndex i;
+      for (i = childIndex + 1; 
+               i < m_keys.Length() && m_levels[i] > levelRemoved; i++)
+            m_levels[i] = m_levels[i] - 1;
+
+      m_view->NoteChange(childIndex + 1, i - childIndex + 1,
+                         nsMsgViewNotificationCode::changed);
+      m_keys.RemoveElementAt(childIndex);
+      m_levels.RemoveElementAt(childIndex);
+      m_folders.RemoveObjectAt(childIndex);
+      if (!(msgFlags & nsMsgMessageFlags::Read))
+        ChangeUnreadChildCount(-1);
+      ChangeChildCount(-1);
+      return NS_OK;
+    }
+  }
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetRootHdr(int32_t *aResultIndex, nsIMsgDBHdr **aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  if (aResultIndex)
+    *aResultIndex = 0;
+  return GetChildHdrAt(0, aResult);
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetChildKeyAt(uint32_t aIndex, nsMsgKey *aResult)
+{
+  NS_ASSERTION(false, "shouldn't call this");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetChild(nsMsgKey msgKey, nsIMsgDBHdr **aResult)
+{
+  NS_ASSERTION(false, "shouldn't call this");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+int32_t nsMsgXFViewThread::HdrIndex(nsIMsgDBHdr *hdr)
+{
+  nsMsgKey msgKey;
+  nsCOMPtr<nsIMsgFolder> folder;
+  hdr->GetMessageKey(&msgKey);
+  hdr->GetFolder(getter_AddRefs(folder));
+  for (uint32_t i = 0; i < m_keys.Length(); i++)
+  {
+    if (m_keys[i] == msgKey && m_folders[i] == folder)
+      return i;
+  }
+  return -1;
+}
+
+void nsMsgXFViewThread::ChangeUnreadChildCount(int32_t delta)
+{
+  m_numUnreadChildren += delta;
+}
+
+void nsMsgXFViewThread::ChangeChildCount(int32_t delta)
+{
+  m_numChildren += delta;
+}
+
+bool nsMsgXFViewThread::IsHdrParentOf(nsIMsgDBHdr *possibleParent, 
+                                        nsIMsgDBHdr *possibleChild)
+{
+  uint16_t referenceToCheck = 0;
+  possibleChild->GetNumReferences(&referenceToCheck);
+  nsAutoCString reference;
+
+  nsCString messageId;
+  possibleParent->GetMessageId(getter_Copies(messageId));
+
+  while (referenceToCheck > 0)
+  {
+    possibleChild->GetStringReference(referenceToCheck - 1, reference);
+
+    if (reference.Equals(messageId))
+      return true;
+    // if reference didn't match, check if this ref is for a non-existent
+    // header. If it is, continue looking at ancestors.
+    nsCOMPtr<nsIMsgDBHdr> refHdr;
+    m_view->GetMsgHdrFromHash(reference, getter_AddRefs(refHdr));
+    if (refHdr)
+      break;
+    referenceToCheck--;
+  }
+  return false;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetNewestMsgDate(uint32_t *aResult) 
+{
+  // if this hasn't been set, figure it out by enumerating the msgs in the thread.
+  if (!m_newestMsgDate)
+  {
+    uint32_t numChildren;
+    nsresult rv = NS_OK;
+  
+    GetNumChildren(&numChildren);
+
+    if ((int32_t) numChildren < 0)
+      numChildren = 0;
+ 
+    for (uint32_t childIndex = 0; childIndex < numChildren; childIndex++)
+    {
+      nsCOMPtr<nsIMsgDBHdr> child;
+      rv = GetChildHdrAt(childIndex, getter_AddRefs(child));
+      if (NS_SUCCEEDED(rv) && child)
+      {
+        uint32_t msgDate;
+        child->GetDateInSeconds(&msgDate);
+        if (msgDate > m_newestMsgDate)
+          m_newestMsgDate = msgDate;
+      }
+    }
+  }
+  *aResult = m_newestMsgDate;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::SetNewestMsgDate(uint32_t aNewestMsgDate) 
+{
+  m_newestMsgDate = aNewestMsgDate;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::MarkChildRead(bool aRead)
+{
+  ChangeUnreadChildCount(aRead ? -1 : 1);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFViewThread::GetFirstUnreadChild(nsIMsgDBHdr **aResult)
+{
+  NS_ENSURE_ARG(aResult);
+  uint32_t numChildren;
+  nsresult rv = NS_OK;
+  
+  GetNumChildren(&numChildren);
+
+  if ((int32_t) numChildren < 0)
+    numChildren = 0;
+  
+  for (uint32_t childIndex = 0; childIndex < numChildren; childIndex++)
+  {
+    nsCOMPtr<nsIMsgDBHdr> child;
+    rv = GetChildHdrAt(childIndex, getter_AddRefs(child));
+    if (NS_SUCCEEDED(rv) && child)
+    {
+      nsMsgKey msgKey;
+      child->GetMessageKey(&msgKey);
+      
+      bool isRead;
+      nsCOMPtr<nsIMsgDatabase> db;
+      nsresult rv = m_folders[childIndex]->GetMsgDatabase(getter_AddRefs(db));
+      if (NS_SUCCEEDED(rv))
+        rv = db->IsRead(msgKey, &isRead);
+      if (NS_SUCCEEDED(rv) && !isRead)
+      {
+        NS_ADDREF(*aResult = child);
+        break;
+      }
+    }
+  }
+  return rv;
+}
+NS_IMETHODIMP nsMsgXFViewThread::EnumerateMessages(nsMsgKey aParentKey,
+                                                   nsISimpleEnumerator **aResult)
+{
+  NS_ERROR("shouldn't call this");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
diff --git a/mailnews/base/src/nsMsgXFViewThread.h b/mailnews/base/src/nsMsgXFViewThread.h
new file mode 100644
index 000000000..5c404afa8
--- /dev/null
+++ b/mailnews/base/src/nsMsgXFViewThread.h
@@ -0,0 +1,54 @@
+/* -*- 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 nsMsgXFViewThread_h__
+#define nsMsgXFViewThread_h__
+
+#include "msgCore.h"
+#include "nsCOMArray.h"
+#include "nsIMsgThread.h"
+#include "MailNewsTypes.h"
+#include "nsTArray.h"
+#include "nsIMsgDatabase.h"
+#include "nsIMsgHdr.h"
+#include "nsMsgDBView.h"
+
+class nsMsgSearchDBView;
+
+class nsMsgXFViewThread : public nsIMsgThread
+{
+public:
+
+  nsMsgXFViewThread(nsMsgSearchDBView *view, nsMsgKey threadId);
+
+  NS_DECL_NSIMSGTHREAD
+  NS_DECL_ISUPPORTS
+
+  bool      IsHdrParentOf(nsIMsgDBHdr *possibleParent,
+                          nsIMsgDBHdr *possibleChild);
+
+  void      ChangeUnreadChildCount(int32_t delta);
+  void      ChangeChildCount(int32_t delta);
+
+  nsresult  AddHdr(nsIMsgDBHdr *newHdr, bool reparentChildren, 
+                   uint32_t &whereInserted, nsIMsgDBHdr **outParent);
+  int32_t   HdrIndex(nsIMsgDBHdr *hdr);
+  uint32_t  ChildLevelAt(uint32_t msgIndex) {return m_levels[msgIndex];}
+  uint32_t  MsgCount() {return m_numChildren;};
+
+protected:
+  virtual ~nsMsgXFViewThread();
+
+  nsMsgSearchDBView *m_view;
+  uint32_t        m_numUnreadChildren;
+  uint32_t        m_numChildren;
+  uint32_t        m_flags;
+  uint32_t        m_newestMsgDate;
+  nsMsgKey        m_threadId;
+  nsTArray<nsMsgKey> m_keys;
+  nsCOMArray<nsIMsgFolder> m_folders;
+  nsTArray<uint8_t> m_levels;
+};
+
+#endif
diff --git a/mailnews/base/src/nsMsgXFVirtualFolderDBView.cpp b/mailnews/base/src/nsMsgXFVirtualFolderDBView.cpp
new file mode 100644
index 000000000..cdc4f0b5a
--- /dev/null
+++ b/mailnews/base/src/nsMsgXFVirtualFolderDBView.cpp
@@ -0,0 +1,514 @@
+/* -*- 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 "nsMsgXFVirtualFolderDBView.h"
+#include "nsIMsgHdr.h"
+#include "nsIMsgThread.h"
+#include "nsQuickSort.h"
+#include "nsIDBFolderInfo.h"
+#include "nsMsgBaseCID.h"
+#include "nsIMsgCopyService.h"
+#include "nsICopyMsgStreamListener.h"
+#include "nsMsgUtils.h"
+#include "nsITreeColumns.h"
+#include "nsIMsgSearchSession.h"
+#include "nsMsgDBCID.h"
+#include "nsMsgMessageFlags.h"
+#include "nsServiceManagerUtils.h"
+
+nsMsgXFVirtualFolderDBView::nsMsgXFVirtualFolderDBView()
+{
+  mSuppressMsgDisplay = false;
+  m_doingSearch = false;
+  m_doingQuickSearch = false;
+  m_totalMessagesInView = 0;
+}
+
+nsMsgXFVirtualFolderDBView::~nsMsgXFVirtualFolderDBView()
+{
+}
+
+NS_IMETHODIMP nsMsgXFVirtualFolderDBView::Open(nsIMsgFolder *folder, 
+                                               nsMsgViewSortTypeValue sortType, 
+                                               nsMsgViewSortOrderValue sortOrder, 
+                                               nsMsgViewFlagsTypeValue viewFlags, 
+                                               int32_t *pCount)
+{
+  m_viewFolder = folder;
+  return nsMsgSearchDBView::Open(folder, sortType, sortOrder, viewFlags, pCount);
+}
+
+void nsMsgXFVirtualFolderDBView::RemovePendingDBListeners()
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgDBService> msgDBService = do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+  // UnregisterPendingListener will return an error when there are no more instances
+  // of this object registered as pending listeners.
+  while (NS_SUCCEEDED(rv))
+    rv = msgDBService->UnregisterPendingListener(this);
+}
+
+NS_IMETHODIMP nsMsgXFVirtualFolderDBView::Close()
+{
+  RemovePendingDBListeners();
+  return nsMsgSearchDBView::Close();
+}
+
+NS_IMETHODIMP
+nsMsgXFVirtualFolderDBView::CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow,
+                                        nsIMsgDBViewCommandUpdater *aCmdUpdater, nsIMsgDBView **_retval)
+{
+  nsMsgXFVirtualFolderDBView* newMsgDBView = new nsMsgXFVirtualFolderDBView();
+
+  if (!newMsgDBView)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv = CopyDBView(newMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  NS_IF_ADDREF(*_retval = newMsgDBView);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgXFVirtualFolderDBView::CopyDBView(nsMsgDBView *aNewMsgDBView, nsIMessenger *aMessengerInstance,
+                                       nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater)
+{
+  nsMsgSearchDBView::CopyDBView(aNewMsgDBView, aMessengerInstance, aMsgWindow, aCmdUpdater);
+
+  nsMsgXFVirtualFolderDBView* newMsgDBView = (nsMsgXFVirtualFolderDBView *) aNewMsgDBView;
+
+  newMsgDBView->m_viewFolder = m_viewFolder;
+  newMsgDBView->m_searchSession = m_searchSession;
+
+  int32_t scopeCount;
+  nsresult rv;
+  nsCOMPtr <nsIMsgSearchSession> searchSession =
+    do_QueryReferent(m_searchSession, &rv);
+  // It's OK not to have a search session.
+  NS_ENSURE_SUCCESS(rv, NS_OK);
+  nsCOMPtr<nsIMsgDBService> msgDBService =
+    do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  searchSession->CountSearchScopes(&scopeCount);
+  for (int32_t i = 0; i < scopeCount; i++)
+  {
+    nsMsgSearchScopeValue scopeId;
+    nsCOMPtr<nsIMsgFolder> searchFolder;
+    searchSession->GetNthSearchScope(i, &scopeId, getter_AddRefs(searchFolder));
+    if (searchFolder)
+      msgDBService->RegisterPendingListener(searchFolder, newMsgDBView);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFVirtualFolderDBView::GetViewType(nsMsgViewTypeValue *aViewType)
+{
+    NS_ENSURE_ARG_POINTER(aViewType);
+    *aViewType = nsMsgViewType::eShowVirtualFolderResults;
+    return NS_OK;
+}
+
+nsresult nsMsgXFVirtualFolderDBView::OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey aParentKey, bool /*ensureListed*/)
+{
+  if (newHdr)
+  {
+    bool match = false;
+    nsCOMPtr <nsIMsgSearchSession> searchSession = do_QueryReferent(m_searchSession);
+    if (searchSession)
+      searchSession->MatchHdr(newHdr, m_db, &match);
+    if (!match)
+      match = WasHdrRecentlyDeleted(newHdr);
+    if (match)
+    {
+      nsCOMPtr <nsIMsgFolder> folder;
+      newHdr->GetFolder(getter_AddRefs(folder));
+      bool saveDoingSearch = m_doingSearch;
+      m_doingSearch = false;
+      OnSearchHit(newHdr, folder);
+      m_doingSearch = saveDoingSearch;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFVirtualFolderDBView::OnHdrPropertyChanged(nsIMsgDBHdr *aHdrChanged,
+                bool aPreChange, uint32_t *aStatus, nsIDBChangeListener *aInstigator)
+{
+  // If the junk mail plugin just activated on a message, then
+  // we'll allow filters to remove from view.
+  // Otherwise, just update the view line.
+  //
+  // Note this will not add newly matched headers to the view. This is
+  // probably a bug that needs fixing.
+
+  NS_ENSURE_ARG_POINTER(aStatus);
+  NS_ENSURE_ARG_POINTER(aHdrChanged);
+
+  nsMsgViewIndex index = FindHdr(aHdrChanged);
+  if (index == nsMsgViewIndex_None) // message does not appear in view
+    return NS_OK;
+
+  nsCString originStr;
+  (void) aHdrChanged->GetStringProperty("junkscoreorigin", getter_Copies(originStr));
+  // check for "plugin" with only first character for performance
+  bool plugin = (originStr.get()[0] == 'p');
+
+  if (aPreChange)
+  {
+    // first call, done prior to the change
+    *aStatus = plugin;
+    return NS_OK;
+  }
+
+  // second call, done after the change
+  bool wasPlugin = *aStatus;
+
+  bool match = true;
+  nsCOMPtr<nsIMsgSearchSession> searchSession(do_QueryReferent(m_searchSession));
+  if (searchSession)
+    searchSession->MatchHdr(aHdrChanged, m_db, &match);
+
+  if (!match && plugin && !wasPlugin)
+    RemoveByIndex(index); // remove hdr from view
+  else
+    NoteChange(index, 1, nsMsgViewNotificationCode::changed);
+
+  return NS_OK;
+}
+
+void nsMsgXFVirtualFolderDBView::UpdateCacheAndViewForFolder(nsIMsgFolder *folder, nsMsgKey *newHits, uint32_t numNewHits)
+{
+  nsCOMPtr <nsIMsgDatabase> db;
+  nsresult rv = folder->GetMsgDatabase(getter_AddRefs(db));
+  if (NS_SUCCEEDED(rv) && db)
+  {
+    nsCString searchUri;
+    m_viewFolder->GetURI(searchUri);
+    uint32_t numBadHits;
+    nsMsgKey *badHits;
+    rv = db->RefreshCache(searchUri.get(), numNewHits, newHits,
+                     &numBadHits, &badHits);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIMsgDBHdr> badHdr;
+      for (uint32_t badHitIndex = 0; badHitIndex < numBadHits; badHitIndex++)
+      {
+        // ### of course, this isn't quite right, since we should be 
+        // using FindHdr, and we shouldn't be expanding the threads.
+        db->GetMsgHdrForKey(badHits[badHitIndex], getter_AddRefs(badHdr));
+        // let nsMsgSearchDBView decide what to do about this header
+        // getting removed.
+        if (badHdr)
+          OnHdrDeleted(badHdr, nsMsgKey_None, 0, this);
+      }
+      delete [] badHits;
+    }
+  }
+}
+
+void nsMsgXFVirtualFolderDBView::UpdateCacheAndViewForPrevSearchedFolders(nsIMsgFolder *curSearchFolder)
+{
+  // Handle the most recent folder with hits, if any.
+  if (m_curFolderGettingHits)
+  {
+    uint32_t count = m_hdrHits.Count();
+    nsTArray<nsMsgKey> newHits;
+    newHits.SetLength(count);
+    for (uint32_t i = 0; i < count; i++)
+      m_hdrHits[i]->GetMessageKey(&newHits[i]);
+
+    newHits.Sort();
+    UpdateCacheAndViewForFolder(m_curFolderGettingHits, newHits.Elements(), newHits.Length());
+    m_foldersSearchingOver.RemoveObject(m_curFolderGettingHits);
+  }
+
+  while (m_foldersSearchingOver.Count() > 0)
+  {
+    // this new folder has cached hits.
+    if (m_foldersSearchingOver[0] == curSearchFolder)
+    {
+      m_curFolderHasCachedHits = true;
+      m_foldersSearchingOver.RemoveObjectAt(0);
+      break;
+    }
+    else
+    {
+      // this must be a folder that had no hits with the current search.
+      // So all cached hits, if any, need to be removed.
+      UpdateCacheAndViewForFolder(m_foldersSearchingOver[0], nullptr, 0);
+      m_foldersSearchingOver.RemoveObjectAt(0);
+    }
+  }
+}
+NS_IMETHODIMP
+nsMsgXFVirtualFolderDBView::OnSearchHit(nsIMsgDBHdr* aMsgHdr, nsIMsgFolder *aFolder)
+{
+  NS_ENSURE_ARG(aMsgHdr);
+  NS_ENSURE_ARG(aFolder);
+
+  nsCOMPtr<nsIMsgDatabase> dbToUse;
+  nsCOMPtr<nsIDBFolderInfo> folderInfo;
+  aFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(dbToUse));
+
+  if (m_curFolderGettingHits != aFolder && m_doingSearch && !m_doingQuickSearch)
+  {
+    m_curFolderHasCachedHits = false;
+    // since we've gotten a hit for a new folder, the searches for
+    // any previous folders are done, so deal with stale cached hits
+    // for those folders now.
+    UpdateCacheAndViewForPrevSearchedFolders(aFolder);
+    m_curFolderGettingHits = aFolder;
+    m_hdrHits.Clear();
+    m_curFolderStartKeyIndex = m_keys.Length();
+  }
+  bool hdrInCache = false;
+  nsCString searchUri;
+  if (!m_doingQuickSearch)
+  {
+    m_viewFolder->GetURI(searchUri);
+    dbToUse->HdrIsInCache(searchUri.get(), aMsgHdr, &hdrInCache);    
+  }
+  if (!m_doingSearch || !m_curFolderHasCachedHits || !hdrInCache)
+  {
+    if (m_viewFlags & nsMsgViewFlagsType::kGroupBySort)
+      nsMsgGroupView::OnNewHeader(aMsgHdr, nsMsgKey_None, true);
+    else if (m_sortValid)
+      InsertHdrFromFolder(aMsgHdr, aFolder);
+    else
+      AddHdrFromFolder(aMsgHdr, aFolder);
+  }
+  m_hdrHits.AppendObject(aMsgHdr);
+  m_totalMessagesInView++;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgXFVirtualFolderDBView::OnSearchDone(nsresult status)
+{
+  NS_ENSURE_TRUE(m_viewFolder, NS_ERROR_NOT_INITIALIZED);
+
+  // handle any non verified hits we haven't handled yet.
+  if (NS_SUCCEEDED(status) && !m_doingQuickSearch && status != NS_MSG_SEARCH_INTERRUPTED)
+    UpdateCacheAndViewForPrevSearchedFolders(nullptr);
+
+  m_doingSearch = false;
+  //we want to set imap delete model once the search is over because setting next
+  //message after deletion will happen before deleting the message and search scope
+  //can change with every search.
+  mDeleteModel = nsMsgImapDeleteModels::MoveToTrash;  //set to default in case it is non-imap folder
+  nsIMsgFolder *curFolder = m_folders.SafeObjectAt(0);
+  if (curFolder)
+    GetImapDeleteModel(curFolder);
+
+  nsCOMPtr<nsIMsgDatabase> virtDatabase;
+  nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+  nsresult rv = m_viewFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(virtDatabase));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // count up the number of unread and total messages from the view, and set those in the
+  // folder - easier than trying to keep the count up to date in the face of
+  // search hits coming in while the user is reading/deleting messages.
+  uint32_t numUnread = 0;
+  for (uint32_t i = 0; i < m_flags.Length(); i++)
+    if (m_flags[i] & nsMsgMessageFlags::Elided)
+    {
+      nsCOMPtr<nsIMsgThread> thread;
+      GetThreadContainingIndex(i, getter_AddRefs(thread));
+      if (thread)
+      {
+        uint32_t unreadInThread;
+        thread->GetNumUnreadChildren(&unreadInThread);
+        numUnread += unreadInThread;
+      }
+    }
+    else
+    {
+      if (!(m_flags[i] & nsMsgMessageFlags::Read))
+        numUnread++;
+    }
+  dbFolderInfo->SetNumUnreadMessages(numUnread);
+  dbFolderInfo->SetNumMessages(m_totalMessagesInView);
+  m_viewFolder->UpdateSummaryTotals(true); // force update from db.
+  virtDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  if (!m_sortValid && m_sortType != nsMsgViewSortType::byThread && 
+      !(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+  {
+    m_sortValid = false;       //sort the results
+    Sort(m_sortType, m_sortOrder);
+  }
+  m_foldersSearchingOver.Clear();
+  m_curFolderGettingHits = nullptr;
+  return rv;
+}
+
+
+NS_IMETHODIMP
+nsMsgXFVirtualFolderDBView::OnNewSearch()
+{
+  int32_t oldSize = GetSize();
+
+  RemovePendingDBListeners();
+  m_doingSearch = true;
+  m_totalMessagesInView = 0;
+  m_folders.Clear();
+  m_keys.Clear();
+  m_levels.Clear();
+  m_flags.Clear();
+
+  // needs to happen after we remove the keys, since RowCountChanged() will call our GetRowCount()
+  if (mTree)
+    mTree->RowCountChanged(0, -oldSize);
+
+  // to use the search results cache, we'll need to iterate over the scopes in the
+  // search session, calling getNthSearchScope for i = 0; i < searchSession.countSearchScopes; i++
+  // and for each folder, then open the db and pull out the cached hits, add them to the view.
+  // For each hit in a new folder, we'll then clean up the stale hits from the previous folder(s).
+
+  int32_t scopeCount;
+  nsCOMPtr<nsIMsgSearchSession> searchSession = do_QueryReferent(m_searchSession);
+  NS_ENSURE_TRUE(searchSession, NS_OK); // just ignore
+  nsCOMPtr<nsIMsgDBService> msgDBService = do_GetService(NS_MSGDB_SERVICE_CONTRACTID);
+  searchSession->CountSearchScopes(&scopeCount);
+
+  // Figure out how many search terms the virtual folder has.
+  nsCOMPtr<nsIMsgDatabase> virtDatabase;
+  nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+  nsresult rv = m_viewFolder->GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo), getter_AddRefs(virtDatabase));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString terms;
+  dbFolderInfo->GetCharProperty("searchStr", terms);
+  nsCOMPtr<nsISupportsArray> searchTerms;
+  rv = searchSession->GetSearchTerms(getter_AddRefs(searchTerms));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCString curSearchAsString;
+
+  rv = MsgTermListToString(searchTerms, curSearchAsString);
+  // Trim off the initial AND/OR, which is irrelevant and inconsistent between
+  // what searchSpec.js generates, and what's in virtualFolders.dat.
+  curSearchAsString.Cut(0, StringBeginsWith(curSearchAsString, NS_LITERAL_CSTRING("AND")) ? 3 : 2);
+  terms.Cut(0, StringBeginsWith(terms, NS_LITERAL_CSTRING("AND")) ? 3 : 2);
+
+  NS_ENSURE_SUCCESS(rv, rv);
+  // If the search session search string doesn't match the vf search str, then we're doing
+  // quick search, which means we don't want to invalidate cached results, or
+  // used cached results.
+  m_doingQuickSearch = !curSearchAsString.Equals(terms);
+
+  if (mTree && !m_doingQuickSearch)
+    mTree->BeginUpdateBatch();
+
+  for (int32_t i = 0; i < scopeCount; i++)
+  {
+    nsMsgSearchScopeValue scopeId;
+    nsCOMPtr<nsIMsgFolder> searchFolder;
+    searchSession->GetNthSearchScope(i, &scopeId, getter_AddRefs(searchFolder));
+    if (searchFolder)
+    {
+      nsCOMPtr<nsISimpleEnumerator> cachedHits;
+      nsCOMPtr<nsIMsgDatabase> searchDB;
+      nsCString searchUri;
+      m_viewFolder->GetURI(searchUri);
+      nsresult rv = searchFolder->GetMsgDatabase(getter_AddRefs(searchDB));
+      if (NS_SUCCEEDED(rv) && searchDB)
+      {
+        if (msgDBService)
+          msgDBService->RegisterPendingListener(searchFolder, this);
+
+        m_foldersSearchingOver.AppendObject(searchFolder);
+        if (m_doingQuickSearch) // ignore cached hits in quick search case.
+          continue;
+        searchDB->GetCachedHits(searchUri.get(), getter_AddRefs(cachedHits));
+        bool hasMore;
+        if (cachedHits)
+        {
+          cachedHits->HasMoreElements(&hasMore);
+          if (hasMore)
+          {
+            mozilla::DebugOnly<nsMsgKey> prevKey = nsMsgKey_None;
+            while (hasMore)
+            {
+              nsCOMPtr <nsISupports> supports;
+              nsresult rv = cachedHits->GetNext(getter_AddRefs(supports));
+              NS_ASSERTION(NS_SUCCEEDED(rv), "nsMsgDBEnumerator broken");
+              nsCOMPtr <nsIMsgDBHdr> pHeader = do_QueryInterface(supports);
+              if (pHeader && NS_SUCCEEDED(rv))
+              {
+                nsMsgKey msgKey;
+                pHeader->GetMessageKey(&msgKey);
+                NS_ASSERTION(prevKey == nsMsgKey_None || msgKey > prevKey,
+                             "cached Hits not sorted");
+#ifdef DEBUG
+                prevKey = msgKey;
+#endif
+                AddHdrFromFolder(pHeader, searchFolder);
+              }
+              else
+                break;
+              cachedHits->HasMoreElements(&hasMore);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (mTree && !m_doingQuickSearch)
+    mTree->EndUpdateBatch();
+
+  m_curFolderStartKeyIndex = 0;
+  m_curFolderGettingHits = nullptr;
+  m_curFolderHasCachedHits = false;
+
+  // if we have cached hits, sort them.
+  if (GetSize() > 0)
+  {
+    // currently, we keep threaded views sorted while we build them.
+    if (m_sortType != nsMsgViewSortType::byThread &&
+      !(m_viewFlags & nsMsgViewFlagsType::kThreadedDisplay))
+    {
+      m_sortValid = false;       //sort the results
+      Sort(m_sortType, m_sortOrder);
+    }
+  }
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsMsgXFVirtualFolderDBView::DoCommand(nsMsgViewCommandTypeValue command)
+{
+    return nsMsgSearchDBView::DoCommand(command);
+}
+
+
+
+NS_IMETHODIMP nsMsgXFVirtualFolderDBView::GetMsgFolder(nsIMsgFolder **aMsgFolder)
+{
+  NS_ENSURE_ARG_POINTER(aMsgFolder);
+  NS_IF_ADDREF(*aMsgFolder = m_viewFolder);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgXFVirtualFolderDBView::SetViewFlags(nsMsgViewFlagsTypeValue aViewFlags)
+{
+  nsresult rv = NS_OK;
+  // if the grouping/threading has changed, rebuild the view
+  if ((m_viewFlags & (nsMsgViewFlagsType::kGroupBySort |
+                      nsMsgViewFlagsType::kThreadedDisplay)) !=
+      (aViewFlags & (nsMsgViewFlagsType::kGroupBySort |
+                     nsMsgViewFlagsType::kThreadedDisplay)))
+    rv = RebuildView(aViewFlags);
+  nsMsgDBView::SetViewFlags(aViewFlags);
+  return rv;
+}
+
+
+nsresult 
+nsMsgXFVirtualFolderDBView::GetMessageEnumerator(nsISimpleEnumerator **enumerator)
+{
+  return GetViewEnumerator(enumerator);
+}
diff --git a/mailnews/base/src/nsMsgXFVirtualFolderDBView.h b/mailnews/base/src/nsMsgXFVirtualFolderDBView.h
new file mode 100644
index 000000000..77a2623d4
--- /dev/null
+++ b/mailnews/base/src/nsMsgXFVirtualFolderDBView.h
@@ -0,0 +1,61 @@
+/* -*- 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 _nsMsgXFVirtualFolderDBView_H_
+#define _nsMsgXFVirtualFolderDBView_H_
+
+#include "mozilla/Attributes.h"
+#include "nsMsgSearchDBView.h"
+#include "nsIMsgCopyServiceListener.h"
+#include "nsIMsgSearchNotify.h"
+#include "nsCOMArray.h"
+
+class nsMsgGroupThread;
+
+class nsMsgXFVirtualFolderDBView : public nsMsgSearchDBView
+{
+public:
+  nsMsgXFVirtualFolderDBView();
+  virtual ~nsMsgXFVirtualFolderDBView();
+
+  // we override all the methods, currently. Might change...
+  NS_DECL_NSIMSGSEARCHNOTIFY
+
+  virtual const char * GetViewName(void) override {return "XFVirtualFolderView"; }
+  NS_IMETHOD Open(nsIMsgFolder *folder, nsMsgViewSortTypeValue sortType, nsMsgViewSortOrderValue sortOrder, 
+        nsMsgViewFlagsTypeValue viewFlags, int32_t *pCount) override;
+  NS_IMETHOD CloneDBView(nsIMessenger *aMessengerInstance, nsIMsgWindow *aMsgWindow, 
+                         nsIMsgDBViewCommandUpdater *aCmdUpdater, nsIMsgDBView **_retval) override;
+  NS_IMETHOD CopyDBView(nsMsgDBView *aNewMsgDBView, nsIMessenger *aMessengerInstance, 
+                        nsIMsgWindow *aMsgWindow, nsIMsgDBViewCommandUpdater *aCmdUpdater) override;
+  NS_IMETHOD Close() override;
+  NS_IMETHOD GetViewType(nsMsgViewTypeValue *aViewType) override;
+  NS_IMETHOD DoCommand(nsMsgViewCommandTypeValue command) override;
+  NS_IMETHOD SetViewFlags(nsMsgViewFlagsTypeValue aViewFlags) override;
+  NS_IMETHOD OnHdrPropertyChanged(nsIMsgDBHdr *aHdrToChange, bool aPreChange, uint32_t *aStatus, 
+                                 nsIDBChangeListener * aInstigator) override;
+  NS_IMETHOD GetMsgFolder(nsIMsgFolder **aMsgFolder) override;
+
+  virtual nsresult OnNewHeader(nsIMsgDBHdr *newHdr, nsMsgKey parentKey, bool ensureListed) override;
+  void UpdateCacheAndViewForPrevSearchedFolders(nsIMsgFolder *curSearchFolder);
+  void UpdateCacheAndViewForFolder(nsIMsgFolder *folder, nsMsgKey *newHits, uint32_t numNewHits);
+  void RemovePendingDBListeners();
+
+protected:
+
+  virtual nsresult GetMessageEnumerator(nsISimpleEnumerator **enumerator) override;
+
+  uint32_t m_cachedFolderArrayIndex; // array index of next folder with cached hits to deal with.
+  nsCOMArray<nsIMsgFolder> m_foldersSearchingOver;
+  nsCOMArray<nsIMsgDBHdr> m_hdrHits;
+  nsCOMPtr <nsIMsgFolder> m_curFolderGettingHits;
+  uint32_t m_curFolderStartKeyIndex; // keeps track of the index of the first hit from the cur folder
+  bool m_curFolderHasCachedHits;
+  bool m_doingSearch;
+  // Are we doing a quick search on top of the virtual folder search?
+  bool m_doingQuickSearch;
+};
+
+#endif
diff --git a/mailnews/base/src/nsSpamSettings.cpp b/mailnews/base/src/nsSpamSettings.cpp
new file mode 100644
index 000000000..e8318b75a
--- /dev/null
+++ b/mailnews/base/src/nsSpamSettings.cpp
@@ -0,0 +1,892 @@
+/* -*- 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 "nsSpamSettings.h"
+#include "nsIFile.h"
+#include "plstr.h"
+#include "prmem.h"
+#include "nsIMsgHdr.h"
+#include "nsNetUtil.h"
+#include "nsIMsgFolder.h"
+#include "nsMsgUtils.h"
+#include "nsMsgFolderFlags.h"
+#include "nsImapCore.h"
+#include "nsIImapIncomingServer.h"
+#include "nsIRDFService.h"
+#include "nsIRDFResource.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIStringBundle.h"
+#include "nsDateTimeFormatCID.h"
+#include "mozilla/Services.h"
+#include "mozilla/mailnews/MimeHeaderParser.h"
+#include "nsIArray.h"
+#include "nsArrayUtils.h"
+#include "nsMailDirServiceDefs.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIDirectoryEnumerator.h"
+#include "nsAbBaseCID.h"
+#include "nsIAbManager.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+
+using namespace mozilla::mailnews;
+
+nsSpamSettings::nsSpamSettings()
+{
+  mLevel = 0;
+  mMoveOnSpam = false;
+  mMoveTargetMode = nsISpamSettings::MOVE_TARGET_MODE_ACCOUNT;
+  mPurge = false;
+  mPurgeInterval = 14; // 14 days
+
+  mServerFilterTrustFlags = 0;
+
+  mUseWhiteList = false;
+  mUseServerFilter = false;
+
+  nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(mLogFile));
+  if (NS_SUCCEEDED(rv))
+    mLogFile->Append(NS_LITERAL_STRING("junklog.html"));
+}
+
+nsSpamSettings::~nsSpamSettings()
+{
+}
+
+NS_IMPL_ISUPPORTS(nsSpamSettings, nsISpamSettings, nsIUrlListener)
+
+NS_IMETHODIMP
+nsSpamSettings::GetLevel(int32_t *aLevel)
+{
+  NS_ENSURE_ARG_POINTER(aLevel);
+  *aLevel = mLevel;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::SetLevel(int32_t aLevel)
+{
+  NS_ASSERTION((aLevel >= 0 && aLevel <= 100), "bad level");
+  mLevel = aLevel;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSpamSettings::GetMoveTargetMode(int32_t *aMoveTargetMode)
+{
+  NS_ENSURE_ARG_POINTER(aMoveTargetMode);
+  *aMoveTargetMode = mMoveTargetMode;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::SetMoveTargetMode(int32_t aMoveTargetMode)
+{
+  NS_ASSERTION((aMoveTargetMode == nsISpamSettings::MOVE_TARGET_MODE_FOLDER || aMoveTargetMode == nsISpamSettings::MOVE_TARGET_MODE_ACCOUNT), "bad move target mode");
+  mMoveTargetMode = aMoveTargetMode;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::GetManualMark(bool *aManualMark)
+{
+  NS_ENSURE_ARG_POINTER(aManualMark);
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return prefBranch->GetBoolPref("mail.spam.manualMark", aManualMark);
+}
+
+NS_IMETHODIMP nsSpamSettings::GetManualMarkMode(int32_t *aManualMarkMode)
+{
+  NS_ENSURE_ARG_POINTER(aManualMarkMode);
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return prefBranch->GetIntPref("mail.spam.manualMarkMode", aManualMarkMode);
+}
+
+NS_IMETHODIMP nsSpamSettings::GetLoggingEnabled(bool *aLoggingEnabled)
+{
+  NS_ENSURE_ARG_POINTER(aLoggingEnabled);
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return prefBranch->GetBoolPref("mail.spam.logging.enabled", aLoggingEnabled);
+}
+
+NS_IMETHODIMP nsSpamSettings::GetMarkAsReadOnSpam(bool *aMarkAsReadOnSpam)
+{
+  NS_ENSURE_ARG_POINTER(aMarkAsReadOnSpam);
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return prefBranch->GetBoolPref("mail.spam.markAsReadOnSpam", aMarkAsReadOnSpam);
+}
+
+NS_IMPL_GETSET(nsSpamSettings, MoveOnSpam, bool, mMoveOnSpam)
+NS_IMPL_GETSET(nsSpamSettings, Purge, bool, mPurge)
+NS_IMPL_GETSET(nsSpamSettings, UseWhiteList, bool, mUseWhiteList)
+NS_IMPL_GETSET(nsSpamSettings, UseServerFilter, bool, mUseServerFilter)
+
+NS_IMETHODIMP nsSpamSettings::GetWhiteListAbURI(char * *aWhiteListAbURI)
+{
+  NS_ENSURE_ARG_POINTER(aWhiteListAbURI);
+  *aWhiteListAbURI = ToNewCString(mWhiteListAbURI);
+  return NS_OK;
+}
+NS_IMETHODIMP nsSpamSettings::SetWhiteListAbURI(const char * aWhiteListAbURI)
+{
+  mWhiteListAbURI = aWhiteListAbURI;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::GetActionTargetAccount(char * *aActionTargetAccount)
+{
+  NS_ENSURE_ARG_POINTER(aActionTargetAccount);
+  *aActionTargetAccount = ToNewCString(mActionTargetAccount);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::SetActionTargetAccount(const char * aActionTargetAccount)
+{
+  mActionTargetAccount = aActionTargetAccount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::GetActionTargetFolder(char * *aActionTargetFolder)
+{
+  NS_ENSURE_ARG_POINTER(aActionTargetFolder);
+  *aActionTargetFolder = ToNewCString(mActionTargetFolder);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::SetActionTargetFolder(const char * aActionTargetFolder)
+{
+  mActionTargetFolder = aActionTargetFolder;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::GetPurgeInterval(int32_t *aPurgeInterval)
+{
+  NS_ENSURE_ARG_POINTER(aPurgeInterval);
+  *aPurgeInterval = mPurgeInterval;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::SetPurgeInterval(int32_t aPurgeInterval)
+{
+  NS_ASSERTION(aPurgeInterval >= 0, "bad purge interval");
+  mPurgeInterval = aPurgeInterval;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSpamSettings::SetLogStream(nsIOutputStream *aLogStream)
+{
+  // if there is a log stream already, close it
+  if (mLogStream) {
+    // will flush
+    nsresult rv = mLogStream->Close();
+    NS_ENSURE_SUCCESS(rv,rv);
+  }
+
+  mLogStream = aLogStream;
+  return NS_OK;
+}
+
+#define LOG_HEADER "<!DOCTYPE html>\n<html>\n<head>\n<meta charset=\"UTF-8\">\n<style type=\"text/css\">body{font-family:Consolas,\"Lucida Console\",Monaco,\"Courier New\",Courier,monospace;font-size:small}</style>\n</head>\n<body>\n"
+#define LOG_HEADER_LEN (strlen(LOG_HEADER))
+
+NS_IMETHODIMP
+nsSpamSettings::GetLogStream(nsIOutputStream **aLogStream)
+{
+  NS_ENSURE_ARG_POINTER(aLogStream);
+
+  nsresult rv;
+
+  if (!mLogStream) {
+    // append to the end of the log file
+    rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mLogStream),
+                                        mLogFile,
+                                        PR_CREATE_FILE | PR_WRONLY | PR_APPEND,
+                                        0600);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    int64_t fileSize;
+    rv = mLogFile->GetFileSize(&fileSize);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // write the header at the start
+    if (fileSize == 0)
+    {
+      uint32_t writeCount;
+
+      rv = mLogStream->Write(LOG_HEADER, LOG_HEADER_LEN, &writeCount);
+      NS_ENSURE_SUCCESS(rv, rv);
+      NS_ASSERTION(writeCount == LOG_HEADER_LEN, "failed to write out log header");
+    }
+  }
+
+  NS_ADDREF(*aLogStream = mLogStream);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::Initialize(nsIMsgIncomingServer *aServer)
+{
+  NS_ENSURE_ARG_POINTER(aServer);
+  nsresult rv;
+  int32_t spamLevel;
+  rv = aServer->GetIntValue("spamLevel", &spamLevel);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetLevel(spamLevel);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool moveOnSpam;
+  rv = aServer->GetBoolValue("moveOnSpam", &moveOnSpam);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetMoveOnSpam(moveOnSpam);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t moveTargetMode;
+  rv = aServer->GetIntValue("moveTargetMode", &moveTargetMode);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetMoveTargetMode(moveTargetMode);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString spamActionTargetAccount;
+  rv = aServer->GetCharValue("spamActionTargetAccount", spamActionTargetAccount);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetActionTargetAccount(spamActionTargetAccount.get());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString spamActionTargetFolder;
+  rv = aServer->GetCharValue("spamActionTargetFolder", spamActionTargetFolder);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetActionTargetFolder(spamActionTargetFolder.get());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool useWhiteList;
+  rv = aServer->GetBoolValue("useWhiteList", &useWhiteList);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetUseWhiteList(useWhiteList);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString whiteListAbURI;
+  rv = aServer->GetCharValue("whiteListAbURI", whiteListAbURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetWhiteListAbURI(whiteListAbURI.get());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool purgeSpam;
+  rv = aServer->GetBoolValue("purgeSpam", &purgeSpam);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetPurge(purgeSpam);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t purgeSpamInterval;
+  rv = aServer->GetIntValue("purgeSpamInterval", &purgeSpamInterval);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetPurgeInterval(purgeSpamInterval);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool useServerFilter;
+  rv = aServer->GetBoolValue("useServerFilter", &useServerFilter);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetUseServerFilter(useServerFilter);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString serverFilterName;
+  rv = aServer->GetCharValue("serverFilterName", serverFilterName);
+  if (NS_SUCCEEDED(rv))
+    SetServerFilterName(serverFilterName);
+  int32_t serverFilterTrustFlags = 0;
+  rv = aServer->GetIntValue("serverFilterTrustFlags", &serverFilterTrustFlags);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = SetServerFilterTrustFlags(serverFilterTrustFlags);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  if (prefBranch)
+    prefBranch->GetCharPref("mail.trusteddomains",
+                            getter_Copies(mTrustedMailDomains));
+
+  mWhiteListDirArray.Clear();
+  if (!mWhiteListAbURI.IsEmpty())
+  {
+    nsCOMPtr<nsIAbManager> abManager(do_GetService(NS_ABMANAGER_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsTArray<nsCString> whiteListArray;
+    ParseString(mWhiteListAbURI, ' ', whiteListArray);
+
+    for (uint32_t index = 0; index < whiteListArray.Length(); index++)
+    {
+      nsCOMPtr<nsIAbDirectory> directory;
+      rv = abManager->GetDirectory(whiteListArray[index],
+                                   getter_AddRefs(directory));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (directory)
+        mWhiteListDirArray.AppendObject(directory);
+    }
+  }
+
+  // the next two preferences affect whether we try to whitelist our own
+  // address or domain. Spammers send emails with spoofed from address matching
+  // either the email address of the recipient, or the recipient's domain,
+  // hoping to get whitelisted.
+  //
+  // The terms to describe this get wrapped up in chains of negatives. A full
+  // definition of the boolean inhibitWhiteListingIdentityUser is "Suppress address
+  // book whitelisting if the sender matches an identity's email address"
+
+  rv = aServer->GetBoolValue("inhibitWhiteListingIdentityUser",
+                             &mInhibitWhiteListingIdentityUser);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = aServer->GetBoolValue("inhibitWhiteListingIdentityDomain",
+                             &mInhibitWhiteListingIdentityDomain);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // collect lists of identity users if needed
+  if (mInhibitWhiteListingIdentityDomain || mInhibitWhiteListingIdentityUser)
+  {
+    nsCOMPtr<nsIMsgAccountManager>
+      accountManager(do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgAccount> account;
+    rv = accountManager->FindAccountForServer(aServer, getter_AddRefs(account));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoCString accountKey;
+    if (account) 
+      account->GetKey(accountKey);
+
+    // Loop through all accounts, adding emails from this account, as well as
+    // from any accounts that defer to this account.
+    mEmails.Clear();
+    nsCOMPtr<nsIArray> accounts;
+    rv = accountManager->GetAccounts(getter_AddRefs(accounts));
+    NS_ENSURE_SUCCESS(rv, rv);
+    uint32_t accountCount = 0;
+    if (account && accounts) // no sense scanning accounts if we've nothing to match
+      accounts->GetLength(&accountCount);
+
+    for (uint32_t i = 0; i < accountCount; i++)
+    {
+      nsCOMPtr<nsIMsgAccount> loopAccount(do_QueryElementAt(accounts, i));
+      if (!loopAccount)
+        continue;
+      nsAutoCString loopAccountKey;
+      loopAccount->GetKey(loopAccountKey);
+      nsCOMPtr<nsIMsgIncomingServer> loopServer;
+      loopAccount->GetIncomingServer(getter_AddRefs(loopServer));
+      nsAutoCString deferredToAccountKey;
+      if (loopServer)
+        loopServer->GetCharValue("deferred_to_account", deferredToAccountKey);
+
+      // Add the emails for any account that defers to this one, or for the
+      // account itself.
+      if (accountKey.Equals(deferredToAccountKey) || accountKey.Equals(loopAccountKey))
+      {
+        nsCOMPtr<nsIArray> identities;
+        loopAccount->GetIdentities(getter_AddRefs(identities));
+        if (!identities)
+          continue;
+        uint32_t identityCount = 0;
+        identities->GetLength(&identityCount);
+        for (uint32_t j = 0; j < identityCount; ++j)
+        {
+          nsCOMPtr<nsIMsgIdentity> identity(do_QueryElementAt(identities, j, &rv));
+          if (NS_FAILED(rv) || !identity)
+            continue;
+          nsAutoCString email;
+          identity->GetEmail(email);
+          if (!email.IsEmpty())
+            mEmails.AppendElement(email);
+        }
+      }
+    }
+  }
+
+  return UpdateJunkFolderState();
+}
+
+nsresult nsSpamSettings::UpdateJunkFolderState()
+{
+  nsresult rv;
+
+  // if the spam folder uri changed on us, we need to unset the junk flag
+  // on the old spam folder
+  nsCString newJunkFolderURI;
+  rv = GetSpamFolderURI(getter_Copies(newJunkFolderURI));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!mCurrentJunkFolderURI.IsEmpty() && !mCurrentJunkFolderURI.Equals(newJunkFolderURI))
+  {
+    nsCOMPtr<nsIMsgFolder> oldJunkFolder;
+    rv = GetExistingFolder(mCurrentJunkFolderURI, getter_AddRefs(oldJunkFolder));
+    if (NS_SUCCEEDED(rv) && oldJunkFolder)
+    {
+      // remove the nsMsgFolderFlags::Junk on the old junk folder
+      // XXX TODO
+      // JUNK MAIL RELATED
+      // (in ClearFlag?) we need to make sure that this folder
+      // is not the junk folder for another account
+      // the same goes for set flag.  have fun with all that.
+      oldJunkFolder->ClearFlag(nsMsgFolderFlags::Junk);
+    }
+  }
+
+  mCurrentJunkFolderURI = newJunkFolderURI;
+
+  // only try to create the junk folder if we are moving junk
+  // and we have a non-empty uri
+  if (mMoveOnSpam && !mCurrentJunkFolderURI.IsEmpty()) {
+    // as the url listener, the spam settings will set the nsMsgFolderFlags::Junk folder flag
+    // on the junk mail folder, after it is created
+    rv = GetOrCreateFolder(mCurrentJunkFolderURI, this);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsSpamSettings::Clone(nsISpamSettings *aSpamSettings)
+{
+  NS_ENSURE_ARG_POINTER(aSpamSettings);
+
+  nsresult rv = aSpamSettings->GetUseWhiteList(&mUseWhiteList);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  (void)aSpamSettings->GetMoveOnSpam(&mMoveOnSpam);
+  (void)aSpamSettings->GetPurge(&mPurge);
+  (void)aSpamSettings->GetUseServerFilter(&mUseServerFilter);
+
+  rv = aSpamSettings->GetPurgeInterval(&mPurgeInterval);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = aSpamSettings->GetLevel(&mLevel);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = aSpamSettings->GetMoveTargetMode(&mMoveTargetMode);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCString actionTargetAccount;
+  rv = aSpamSettings->GetActionTargetAccount(getter_Copies(actionTargetAccount));
+  NS_ENSURE_SUCCESS(rv,rv);
+  mActionTargetAccount = actionTargetAccount;
+
+  nsCString actionTargetFolder;
+  rv = aSpamSettings->GetActionTargetFolder(getter_Copies(actionTargetFolder));
+  NS_ENSURE_SUCCESS(rv,rv);
+  mActionTargetFolder = actionTargetFolder;
+
+  nsCString whiteListAbURI;
+  rv = aSpamSettings->GetWhiteListAbURI(getter_Copies(whiteListAbURI));
+  NS_ENSURE_SUCCESS(rv,rv);
+  mWhiteListAbURI = whiteListAbURI;
+
+  aSpamSettings->GetServerFilterName(mServerFilterName);
+  aSpamSettings->GetServerFilterTrustFlags(&mServerFilterTrustFlags);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsSpamSettings::GetSpamFolderURI(char **aSpamFolderURI)
+{
+  NS_ENSURE_ARG_POINTER(aSpamFolderURI);
+
+  if (mMoveTargetMode == nsISpamSettings::MOVE_TARGET_MODE_FOLDER)
+    return GetActionTargetFolder(aSpamFolderURI);
+
+  // if the mode is nsISpamSettings::MOVE_TARGET_MODE_ACCOUNT
+  // the spam folder URI = account uri + "/Junk"
+  nsCString folderURI;
+  nsresult rv = GetActionTargetAccount(getter_Copies(folderURI));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // we might be trying to get the old spam folder uri
+  // in order to clear the flag
+  // if we didn't have one, bail out.
+  if (folderURI.IsEmpty())
+    return NS_OK;
+
+  nsCOMPtr<nsIRDFService> rdf(do_GetService("@mozilla.org/rdf/rdf-service;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIRDFResource> folderResource;
+  rv = rdf->GetResource(folderURI, getter_AddRefs(folderResource));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr <nsIMsgFolder> folder = do_QueryInterface(folderResource);
+  if (!folder)
+    return NS_ERROR_UNEXPECTED;
+
+  nsCOMPtr <nsIMsgIncomingServer> server;
+  rv = folder->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // see nsMsgFolder::SetPrettyName() for where the pretty name is set.
+
+  // Check for an existing junk folder - this will do a case-insensitive 
+  // search by URI - if we find a junk folder, use its URI.
+  nsCOMPtr<nsIMsgFolder> junkFolder;
+  folderURI.Append("/Junk");
+  if (NS_SUCCEEDED(server->GetMsgFolderFromURI(nullptr, folderURI,
+                                               getter_AddRefs(junkFolder))) &&
+      junkFolder)
+    junkFolder->GetURI(folderURI);
+
+  // XXX todo
+  // better not to make base depend in imap
+  // but doing it here, like in nsMsgCopy.cpp
+  // one day, we'll fix this (and nsMsgCopy.cpp) to use GetMsgFolderFromURI()
+  nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryInterface(server);
+  if (imapServer) {
+    // Make sure an specific IMAP folder has correct personal namespace
+    // see bug #197043
+    nsCString folderUriWithNamespace;
+    (void)imapServer->GetUriWithNamespacePrefixIfNecessary(kPersonalNamespace, folderURI,
+                                                           folderUriWithNamespace);
+    if (!folderUriWithNamespace.IsEmpty())
+      folderURI = folderUriWithNamespace;
+  }
+
+  *aSpamFolderURI = ToNewCString(folderURI);
+  if (!*aSpamFolderURI)
+    return NS_ERROR_OUT_OF_MEMORY;
+  else
+    return rv;
+}
+
+NS_IMETHODIMP nsSpamSettings::GetServerFilterName(nsACString &aFilterName)
+{
+  aFilterName = mServerFilterName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::SetServerFilterName(const nsACString &aFilterName)
+{
+  mServerFilterName = aFilterName;
+  mServerFilterFile = nullptr; // clear out our stored location value
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::GetServerFilterFile(nsIFile ** aFile)
+{
+  NS_ENSURE_ARG_POINTER(aFile);
+  if (!mServerFilterFile)
+  {
+    nsresult rv;
+    nsAutoCString serverFilterFileName;
+    GetServerFilterName(serverFilterFileName);
+    serverFilterFileName.Append(".sfd");
+
+    nsCOMPtr<nsIProperties> dirSvc = do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Walk through the list of isp directories
+    nsCOMPtr<nsISimpleEnumerator> ispDirectories;
+    rv = dirSvc->Get(ISP_DIRECTORY_LIST, NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(ispDirectories));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    bool hasMore;
+    nsCOMPtr<nsIFile> file;
+    while (NS_SUCCEEDED(ispDirectories->HasMoreElements(&hasMore)) && hasMore)
+    {
+      nsCOMPtr<nsISupports> elem;
+      ispDirectories->GetNext(getter_AddRefs(elem));
+      file = do_QueryInterface(elem);
+
+      if (file)
+      {
+        // append our desired leaf name then test to see if the file exists. If it does, we've found
+        // mServerFilterFile.
+        file->AppendNative(serverFilterFileName);
+        bool exists;
+        if (NS_SUCCEEDED(file->Exists(&exists)) && exists)
+        {
+          file.swap(mServerFilterFile);
+          break;
+        }
+      } // if file
+    } // until we find the location of mServerFilterName
+  } // if we haven't already stored mServerFilterFile
+
+  NS_IF_ADDREF(*aFile = mServerFilterFile);
+  return NS_OK;
+}
+
+
+NS_IMPL_GETSET(nsSpamSettings, ServerFilterTrustFlags, int32_t, mServerFilterTrustFlags)
+
+#define LOG_ENTRY_START_TAG "<p>\n"
+#define LOG_ENTRY_START_TAG_LEN (strlen(LOG_ENTRY_START_TAG))
+#define LOG_ENTRY_END_TAG "</p>\n"
+#define LOG_ENTRY_END_TAG_LEN (strlen(LOG_ENTRY_END_TAG))
+// Does this need to be localizable?
+#define LOG_ENTRY_TIMESTAMP "[$S] "
+
+NS_IMETHODIMP nsSpamSettings::LogJunkHit(nsIMsgDBHdr *aMsgHdr, bool aMoveMessage)
+{
+  bool loggingEnabled;
+  nsresult rv = GetLoggingEnabled(&loggingEnabled);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  if (!loggingEnabled)
+    return NS_OK;
+
+  PRTime date;
+
+  nsString authorValue;
+  nsString subjectValue;
+  nsString dateValue;
+
+  (void)aMsgHdr->GetDate(&date);
+  PRExplodedTime exploded;
+  PR_ExplodeTime(date, PR_LocalTimeParameters, &exploded);
+
+  if (!mDateFormatter)
+  {
+    mDateFormatter = do_CreateInstance(NS_DATETIMEFORMAT_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!mDateFormatter)
+    {
+      return NS_ERROR_FAILURE;
+    }
+  }
+  mDateFormatter->FormatPRExplodedTime(nullptr, kDateFormatShort,
+                                      kTimeFormatSeconds, &exploded,
+                                      dateValue);
+
+  (void)aMsgHdr->GetMime2DecodedAuthor(authorValue);
+  (void)aMsgHdr->GetMime2DecodedSubject(subjectValue);
+
+  nsCString buffer;
+  // this is big enough to hold a log entry.
+  // do this so we avoid growing and copying as we append to the log.
+#ifdef MOZILLA_INTERNAL_API
+  buffer.SetCapacity(512);
+#endif
+
+  nsCOMPtr<nsIStringBundleService> bundleService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(bundleService, NS_ERROR_UNEXPECTED);
+
+  nsCOMPtr<nsIStringBundle> bundle;
+  rv = bundleService->CreateBundle("chrome://messenger/locale/filter.properties",
+    getter_AddRefs(bundle));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  const char16_t *junkLogDetectFormatStrings[3] = { authorValue.get(), subjectValue.get(), dateValue.get() };
+  nsString junkLogDetectStr;
+  rv = bundle->FormatStringFromName(
+    u"junkLogDetectStr",
+    junkLogDetectFormatStrings, 3,
+    getter_Copies(junkLogDetectStr));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  buffer += NS_ConvertUTF16toUTF8(junkLogDetectStr);
+  buffer +=  "\n";
+
+  if (aMoveMessage) {
+    nsCString msgId;
+    aMsgHdr->GetMessageId(getter_Copies(msgId));
+
+    nsCString junkFolderURI;
+    rv = GetSpamFolderURI(getter_Copies(junkFolderURI));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    NS_ConvertASCIItoUTF16 msgIdValue(msgId);
+    NS_ConvertASCIItoUTF16 junkFolderURIValue(junkFolderURI);
+
+    const char16_t *logMoveFormatStrings[2] = { msgIdValue.get(), junkFolderURIValue.get() };
+    nsString logMoveStr;
+    rv = bundle->FormatStringFromName(
+      u"logMoveStr",
+      logMoveFormatStrings, 2,
+      getter_Copies(logMoveStr));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    buffer += NS_ConvertUTF16toUTF8(logMoveStr);
+    buffer += "\n";
+  }
+
+  return LogJunkString(buffer.get());
+}
+
+NS_IMETHODIMP nsSpamSettings::LogJunkString(const char *string)
+{
+  bool loggingEnabled;
+  nsresult rv = GetLoggingEnabled(&loggingEnabled);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  if (!loggingEnabled)
+    return NS_OK;
+
+  nsString dateValue;
+  PRExplodedTime exploded;
+  PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &exploded);
+
+  if (!mDateFormatter)
+  {
+    mDateFormatter = do_CreateInstance(NS_DATETIMEFORMAT_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!mDateFormatter)
+    {
+      return NS_ERROR_FAILURE;
+    }
+  }
+  mDateFormatter->FormatPRExplodedTime(nullptr, kDateFormatShort,
+                                       kTimeFormatSeconds, &exploded,
+                                       dateValue);
+
+  nsCString timestampString(LOG_ENTRY_TIMESTAMP);
+  MsgReplaceSubstring(timestampString, "$S", NS_ConvertUTF16toUTF8(dateValue).get());
+
+  nsCOMPtr <nsIOutputStream> logStream;
+  rv = GetLogStream(getter_AddRefs(logStream));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  uint32_t writeCount;
+
+  rv = logStream->Write(LOG_ENTRY_START_TAG, LOG_ENTRY_START_TAG_LEN, &writeCount);
+  NS_ENSURE_SUCCESS(rv,rv);
+  NS_ASSERTION(writeCount == LOG_ENTRY_START_TAG_LEN, "failed to write out start log tag");
+
+  rv = logStream->Write(timestampString.get(), timestampString.Length(), &writeCount);
+  NS_ENSURE_SUCCESS(rv,rv);
+  NS_ASSERTION(writeCount == timestampString.Length(), "failed to write out timestamp");
+
+  // HTML-escape the log for security reasons.
+  // We don't want someone to send us a message with a subject with
+  // HTML tags, especially <script>.
+  char *escapedBuffer = MsgEscapeHTML(string);
+  if (!escapedBuffer)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  uint32_t escapedBufferLen = strlen(escapedBuffer);
+  rv = logStream->Write(escapedBuffer, escapedBufferLen, &writeCount);
+  PR_Free(escapedBuffer);
+  NS_ENSURE_SUCCESS(rv,rv);
+  NS_ASSERTION(writeCount == escapedBufferLen, "failed to write out log hit");
+
+  rv = logStream->Write(LOG_ENTRY_END_TAG, LOG_ENTRY_END_TAG_LEN, &writeCount);
+  NS_ENSURE_SUCCESS(rv,rv);
+  NS_ASSERTION(writeCount == LOG_ENTRY_END_TAG_LEN, "failed to write out end log tag");
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::OnStartRunningUrl(nsIURI* aURL)
+{
+  // do nothing
+  // all the action happens in OnStopRunningUrl()
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsSpamSettings::OnStopRunningUrl(nsIURI* aURL, nsresult exitCode)
+{
+  nsCString junkFolderURI;
+  nsresult rv = GetSpamFolderURI(getter_Copies(junkFolderURI));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  if (junkFolderURI.IsEmpty())
+    return NS_ERROR_UNEXPECTED;
+
+  // when we get here, the folder should exist.
+  nsCOMPtr <nsIMsgFolder> junkFolder;
+  rv = GetExistingFolder(junkFolderURI, getter_AddRefs(junkFolder));
+  NS_ENSURE_SUCCESS(rv,rv);
+  if (!junkFolder)
+    return NS_ERROR_UNEXPECTED;
+
+  rv = junkFolder->SetFlag(nsMsgFolderFlags::Junk);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return rv;
+}
+
+NS_IMETHODIMP nsSpamSettings::CheckWhiteList(nsIMsgDBHdr *aMsgHdr, bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aMsgHdr);
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = false;  // default in case of error or no whitelisting
+
+  if (!mUseWhiteList || (!mWhiteListDirArray.Count() &&
+                          mTrustedMailDomains.IsEmpty()))
+    return NS_OK;
+
+  // do per-message processing
+
+  nsCString author;
+  aMsgHdr->GetAuthor(getter_Copies(author));
+
+  nsAutoCString authorEmailAddress;
+  ExtractEmail(EncodedHeader(author), authorEmailAddress);
+
+  if (authorEmailAddress.IsEmpty())
+    return NS_OK;
+
+  // should we skip whitelisting for the identity email?
+  if (mInhibitWhiteListingIdentityUser)
+  {
+    for (uint32_t i = 0; i < mEmails.Length(); ++i)
+    {
+      if (mEmails[i].Equals(authorEmailAddress, nsCaseInsensitiveCStringComparator()))
+        return NS_OK;
+    }
+  }
+
+  if (!mTrustedMailDomains.IsEmpty() || mInhibitWhiteListingIdentityDomain)
+  {
+    nsAutoCString domain;
+    int32_t atPos = authorEmailAddress.FindChar('@');
+    if (atPos >= 0)
+      domain = Substring(authorEmailAddress, atPos + 1);
+    if (!domain.IsEmpty())
+    {
+      if (!mTrustedMailDomains.IsEmpty() &&
+          MsgHostDomainIsTrusted(domain, mTrustedMailDomains))
+      {
+        *aResult = true;
+        return NS_OK;
+      }
+
+      if (mInhibitWhiteListingIdentityDomain)
+      {
+        for (uint32_t i = 0; i < mEmails.Length(); ++i)
+        {
+          nsAutoCString identityDomain;
+          int32_t atPos = mEmails[i].FindChar('@');
+          if (atPos >= 0)
+          {
+            identityDomain = Substring(mEmails[i], atPos + 1);
+            if (identityDomain.Equals(domain, nsCaseInsensitiveCStringComparator()))
+              return NS_OK; // don't whitelist
+          }
+        }
+      }
+    }
+  }
+
+  if (mWhiteListDirArray.Count())
+  {
+    nsCOMPtr<nsIAbCard> cardForAddress;
+    for (int32_t index = 0;
+         index < mWhiteListDirArray.Count() && !cardForAddress;
+         index++)
+    {
+      mWhiteListDirArray[index]->CardForEmailAddress(authorEmailAddress,
+                                                     getter_AddRefs(cardForAddress));
+    }
+    if (cardForAddress)
+    {
+      *aResult = true;
+      return NS_OK;
+    }
+  }
+  return NS_OK; // default return is false
+}
diff --git a/mailnews/base/src/nsSpamSettings.h b/mailnews/base/src/nsSpamSettings.h
new file mode 100644
index 000000000..9432a1835
--- /dev/null
+++ b/mailnews/base/src/nsSpamSettings.h
@@ -0,0 +1,71 @@
+/* -*- 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 nsSpamSettings_h__
+#define nsSpamSettings_h__
+
+#include "nsCOMPtr.h"
+#include "nsISpamSettings.h"
+#include "nsStringGlue.h"
+#include "nsIOutputStream.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIUrlListener.h"
+#include "nsIDateTimeFormat.h"
+#include "nsCOMArray.h"
+#include "nsIAbDirectory.h"
+#include "nsTArray.h"
+
+class nsSpamSettings : public nsISpamSettings, public nsIUrlListener
+{
+public:
+  nsSpamSettings();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSISPAMSETTINGS
+  NS_DECL_NSIURLLISTENER
+
+private:
+  virtual ~nsSpamSettings();
+
+  nsCOMPtr <nsIOutputStream> mLogStream;
+  nsCOMPtr<nsIFile> mLogFile;
+
+  int32_t mLevel; 
+  int32_t mPurgeInterval;
+  int32_t mMoveTargetMode;
+
+  bool mPurge;
+  bool mUseWhiteList;
+  bool mMoveOnSpam;
+  bool mUseServerFilter;
+  
+  nsCString mActionTargetAccount;
+  nsCString mActionTargetFolder;
+  nsCString mWhiteListAbURI;
+  nsCString mCurrentJunkFolderURI; // used to detect changes to the spam folder in ::initialize
+
+  nsCString mServerFilterName;
+  nsCOMPtr<nsIFile> mServerFilterFile;
+  int32_t  mServerFilterTrustFlags;
+
+  nsCOMPtr<nsIDateTimeFormat> mDateFormatter;
+
+  // array of address directories to use in junk whitelisting
+  nsCOMArray<nsIAbDirectory> mWhiteListDirArray;
+  // mail domains to use in junk whitelisting
+  nsCString mTrustedMailDomains;
+  // should we inhibit whitelisting address of identity?
+  bool mInhibitWhiteListingIdentityUser;
+  // should we inhibit whitelisting domain of identity?
+  bool mInhibitWhiteListingIdentityDomain;
+  // email addresses associated with this server
+  nsTArray<nsCString> mEmails;
+
+  // helper routine used by Initialize which unsets the junk flag on the previous junk folder
+  // for this account, and sets it on the new junk folder.
+  nsresult UpdateJunkFolderState();
+};
+
+#endif /* nsSpamSettings_h__ */
diff --git a/mailnews/base/src/nsStatusBarBiffManager.cpp b/mailnews/base/src/nsStatusBarBiffManager.cpp
new file mode 100644
index 000000000..49d9bfb52
--- /dev/null
+++ b/mailnews/base/src/nsStatusBarBiffManager.cpp
@@ -0,0 +1,251 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsStatusBarBiffManager.h"
+#include "nsMsgBiffManager.h"
+#include "nsIMsgMailSession.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsIObserverService.h"
+#include "nsIWindowMediator.h"
+#include "nsIMsgMailSession.h"
+#include "MailNewsTypes.h"
+#include "nsIMsgFolder.h" // TO include biffState enum. Change to bool later...
+#include "nsIFileChannel.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIURL.h"
+#include "nsNetUtil.h"
+#include "nsIFileURL.h"
+#include "nsIFile.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Services.h"
+
+// QueryInterface, AddRef, and Release
+//
+NS_IMPL_ISUPPORTS(nsStatusBarBiffManager, nsIStatusBarBiffManager, nsIFolderListener, nsIObserver)
+
+nsIAtom * nsStatusBarBiffManager::kBiffStateAtom = nullptr;
+
+nsStatusBarBiffManager::nsStatusBarBiffManager()
+: mInitialized(false), mCurrentBiffState(nsIMsgFolder::nsMsgBiffState_Unknown)
+{
+}
+
+nsStatusBarBiffManager::~nsStatusBarBiffManager()
+{
+    NS_IF_RELEASE(kBiffStateAtom);
+}
+
+#define NEW_MAIL_PREF_BRANCH             "mail.biff."
+#define CHAT_PREF_BRANCH                 "mail.chat."
+#define FEED_PREF_BRANCH                 "mail.feed."
+#define PREF_PLAY_SOUND                  "play_sound"
+#define PREF_SOUND_URL                   "play_sound.url"
+#define PREF_SOUND_TYPE                  "play_sound.type"
+#define SYSTEM_SOUND_TYPE 0
+#define CUSTOM_SOUND_TYPE 1
+#define PREF_CHAT_ENABLED                "mail.chat.enabled"
+#define PLAY_CHAT_NOTIFICATION_SOUND     "play-chat-notification-sound"
+
+nsresult nsStatusBarBiffManager::Init()
+{
+  if (mInitialized)
+    return NS_ERROR_ALREADY_INITIALIZED;
+
+  nsresult rv;
+
+  kBiffStateAtom = MsgNewAtom("BiffState").take();
+
+  nsCOMPtr<nsIMsgMailSession> mailSession = 
+    do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv); 
+  if(NS_SUCCEEDED(rv))
+    mailSession->AddFolderListener(this, nsIFolderListener::intPropertyChanged);
+
+  nsCOMPtr<nsIPrefBranch> pref(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool chatEnabled = false;
+  if (NS_SUCCEEDED(rv))
+    rv = pref->GetBoolPref(PREF_CHAT_ENABLED, &chatEnabled);
+  if (NS_SUCCEEDED(rv) && chatEnabled) {
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+    if (observerService)
+      observerService->AddObserver(this, PLAY_CHAT_NOTIFICATION_SOUND, false);
+  }
+
+  mInitialized = true;
+  return NS_OK;
+}
+
+nsresult nsStatusBarBiffManager::PlayBiffSound(const char *aPrefBranch)
+{
+  nsresult rv;
+  nsCOMPtr<nsIPrefService> prefSvc = (do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIPrefBranch> pref;
+  rv = prefSvc->GetBranch(aPrefBranch, getter_AddRefs(pref));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool playSound;
+  if (mServerType.EqualsLiteral("rss")) {
+    nsCOMPtr<nsIPrefBranch> prefFeed;
+    rv = prefSvc->GetBranch(FEED_PREF_BRANCH, getter_AddRefs(prefFeed));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = prefFeed->GetBoolPref(PREF_PLAY_SOUND, &playSound);
+  }
+  else {
+    rv = pref->GetBoolPref(PREF_PLAY_SOUND, &playSound);
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!playSound)
+    return NS_OK;
+
+  // lazily create the sound instance
+  if (!mSound)
+    mSound = do_CreateInstance("@mozilla.org/sound;1");
+
+  int32_t soundType = SYSTEM_SOUND_TYPE;
+  rv = pref->GetIntPref(PREF_SOUND_TYPE, &soundType);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool customSoundPlayed = false;
+
+  if (soundType == CUSTOM_SOUND_TYPE) {
+    nsCString soundURLSpec;
+    rv = pref->GetCharPref(PREF_SOUND_URL, getter_Copies(soundURLSpec));
+
+    if (NS_SUCCEEDED(rv) && !soundURLSpec.IsEmpty()) {
+      if (!strncmp(soundURLSpec.get(), "file://", 7)) {
+        nsCOMPtr<nsIURI> fileURI;
+        rv = NS_NewURI(getter_AddRefs(fileURI), soundURLSpec);
+        NS_ENSURE_SUCCESS(rv,rv);
+        nsCOMPtr<nsIFileURL> soundURL = do_QueryInterface(fileURI,&rv);
+        if (NS_SUCCEEDED(rv)) {
+          nsCOMPtr<nsIFile> soundFile;
+          rv = soundURL->GetFile(getter_AddRefs(soundFile));
+          if (NS_SUCCEEDED(rv)) {
+            bool soundFileExists = false;
+            rv = soundFile->Exists(&soundFileExists);
+            if (NS_SUCCEEDED(rv) && soundFileExists) {
+              rv = mSound->Play(soundURL);
+              if (NS_SUCCEEDED(rv))
+                customSoundPlayed = true;
+            }
+          }
+        }
+      }
+      else {
+        // todo, see if we can create a nsIFile using the string as a native path.
+        // if that fails, try playing a system sound
+        NS_ConvertUTF8toUTF16 utf16SoundURLSpec(soundURLSpec);
+        rv = mSound->PlaySystemSound(utf16SoundURLSpec);
+        if (NS_SUCCEEDED(rv))
+          customSoundPlayed = true;
+      }
+    }
+  }
+#ifndef XP_MACOSX
+  // if nothing played, play the default system sound
+  if (!customSoundPlayed) {
+    rv = mSound->PlayEventSound(nsISound::EVENT_NEW_MAIL_RECEIVED);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+#endif
+  return rv;
+}
+
+// nsIFolderListener methods....
+NS_IMETHODIMP 
+nsStatusBarBiffManager::OnItemAdded(nsIMsgFolder *parentItem, nsISupports *item)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsStatusBarBiffManager::OnItemRemoved(nsIMsgFolder *parentItem, nsISupports *item)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsStatusBarBiffManager::OnItemPropertyChanged(nsIMsgFolder *item, nsIAtom *property, const char *oldValue, const char *newValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsStatusBarBiffManager::OnItemIntPropertyChanged(nsIMsgFolder *item, nsIAtom *property, int64_t oldValue, int64_t newValue)
+{
+  if (kBiffStateAtom == property && mCurrentBiffState != newValue) {
+    // if we got new mail, attempt to play a sound.
+    // if we fail along the way, don't return.
+    // we still need to update the UI.    
+    if (newValue == nsIMsgFolder::nsMsgBiffState_NewMail) {
+      // Get the folder's server type.
+      nsCOMPtr<nsIMsgIncomingServer> server;
+      nsresult rv = item->GetServer(getter_AddRefs(server));
+      if (NS_SUCCEEDED(rv) && server)
+        server->GetType(mServerType);
+
+      // if we fail to play the biff sound, keep going.
+      (void)PlayBiffSound(NEW_MAIL_PREF_BRANCH);
+    }
+    mCurrentBiffState = newValue;
+
+    // don't care if notification fails
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+      
+    if (observerService)
+      observerService->NotifyObservers(static_cast<nsIStatusBarBiffManager*>(this), "mail:biff-state-changed", nullptr);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsStatusBarBiffManager::OnItemBoolPropertyChanged(nsIMsgFolder *item, nsIAtom *property, bool oldValue, bool newValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsStatusBarBiffManager::OnItemUnicharPropertyChanged(nsIMsgFolder *item, nsIAtom *property, const char16_t *oldValue, const char16_t *newValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsStatusBarBiffManager::OnItemPropertyFlagChanged(nsIMsgDBHdr *item, nsIAtom *property, uint32_t oldFlag, uint32_t newFlag)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsStatusBarBiffManager::OnItemEvent(nsIMsgFolder *item, nsIAtom *event)
+{
+  return NS_OK;
+}
+
+// nsIObserver implementation
+NS_IMETHODIMP
+nsStatusBarBiffManager::Observe(nsISupports *aSubject,
+                                const char *aTopic,
+                                const char16_t *aData)
+{
+  return PlayBiffSound(CHAT_PREF_BRANCH);
+}
+
+// nsIStatusBarBiffManager method....
+NS_IMETHODIMP
+nsStatusBarBiffManager::GetBiffState(int32_t *aBiffState)
+{
+  NS_ENSURE_ARG_POINTER(aBiffState);
+  *aBiffState = mCurrentBiffState;
+  return NS_OK;
+}
+ 
diff --git a/mailnews/base/src/nsStatusBarBiffManager.h b/mailnews/base/src/nsStatusBarBiffManager.h
new file mode 100644
index 000000000..cb85742e3
--- /dev/null
+++ b/mailnews/base/src/nsStatusBarBiffManager.h
@@ -0,0 +1,44 @@
+/* -*- 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 nsStatusBarBiffManager_h__
+#define nsStatusBarBiffManager_h__
+
+#include "nsIStatusBarBiffManager.h"
+
+#include "msgCore.h"
+#include "nsCOMPtr.h"
+#include "nsISound.h"
+#include "nsIObserver.h"
+
+class nsStatusBarBiffManager : public nsIStatusBarBiffManager,
+                               public nsIObserver
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIFOLDERLISTENER
+  NS_DECL_NSISTATUSBARBIFFMANAGER
+  NS_DECL_NSIOBSERVER
+
+  nsStatusBarBiffManager(); 
+  nsresult Init();
+
+private:
+  virtual ~nsStatusBarBiffManager();
+
+  bool     mInitialized;
+  int32_t  mCurrentBiffState;
+  nsCString mServerType;
+  nsCOMPtr<nsISound> mSound;
+  nsresult PlayBiffSound(const char *aPrefBranch);
+
+protected:
+  static nsIAtom* kBiffStateAtom;
+};
+
+
+
+#endif // nsStatusBarBiffManager_h__
+
diff --git a/mailnews/base/src/nsSubscribableServer.cpp b/mailnews/base/src/nsSubscribableServer.cpp
new file mode 100644
index 000000000..80f9c9b64
--- /dev/null
+++ b/mailnews/base/src/nsSubscribableServer.cpp
@@ -0,0 +1,805 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsSubscribableServer.h"
+#include "nsIMsgIncomingServer.h"
+#include "prmem.h"
+#include "rdf.h"
+#include "nsRDFCID.h"
+#include "nsIServiceManager.h"
+#include "nsMsgI18N.h"
+#include "nsMsgUtils.h"
+#include "nsCOMArray.h"
+#include "nsArrayEnumerator.h"
+#include "nsServiceManagerUtils.h"
+
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+
+nsSubscribableServer::nsSubscribableServer(void)
+{
+    mDelimiter = '.';
+    mShowFullName = true;
+    mTreeRoot = nullptr;
+    mStopped = false;
+}
+
+nsresult
+nsSubscribableServer::Init()
+{
+    nsresult rv;
+
+    rv = EnsureRDFService();
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "child"),
+                                  getter_AddRefs(kNC_Child));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Subscribed"),
+                                  getter_AddRefs(kNC_Subscribed));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetLiteral(u"true", getter_AddRefs(kTrueLiteral));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetLiteral(u"false", getter_AddRefs(kFalseLiteral));
+    NS_ENSURE_SUCCESS(rv,rv);
+    return NS_OK;
+}
+
+nsSubscribableServer::~nsSubscribableServer(void)
+{
+  mozilla::DebugOnly<nsresult> rv = FreeSubtree(mTreeRoot);
+  NS_ASSERTION(NS_SUCCEEDED(rv),"failed to free tree");
+}
+
+NS_IMPL_ISUPPORTS(nsSubscribableServer, nsISubscribableServer)
+
+NS_IMETHODIMP
+nsSubscribableServer::SetIncomingServer(nsIMsgIncomingServer *aServer)
+{
+  if (!aServer) {
+    mIncomingServerUri.AssignLiteral("");
+    return NS_OK;
+  }
+
+  // We intentionally do not store a pointer to the aServer here
+  // as it would create reference loops, because nsIImapIncomingServer
+  // and nsINntpIncomingServer keep a reference to an internal
+  // nsISubscribableServer object.
+  // We only need the URI of the server anyway.
+  return aServer->GetServerURI(mIncomingServerUri);
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetDelimiter(char *aDelimiter)
+{
+  if (!aDelimiter) return NS_ERROR_NULL_POINTER;
+  *aDelimiter = mDelimiter;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetDelimiter(char aDelimiter)
+{
+  mDelimiter = aDelimiter;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetAsSubscribed(const nsACString &path)
+{
+    nsresult rv = NS_OK;
+
+    SubscribeTreeNode *node = nullptr;
+    rv = FindAndCreateNode(path, &node);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NS_ASSERTION(node,"didn't find the node");
+    if (!node) return NS_ERROR_FAILURE;
+
+    node->isSubscribable = true;
+    node->isSubscribed = true;
+
+    rv = NotifyChange(node, kNC_Subscribed, node->isSubscribed);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    return rv;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::AddTo(const nsACString& aName, bool aAddAsSubscribed,
+                            bool aSubscribable, bool aChangeIfExists)
+{
+    nsresult rv = NS_OK;
+
+    if (mStopped) {
+#ifdef DEBUG_seth
+        printf("stopped!\n");
+#endif
+        return NS_ERROR_FAILURE;
+    }
+
+    SubscribeTreeNode *node = nullptr;
+
+    // todo, shouldn't we pass in aAddAsSubscribed, for the
+    // default value if we create it?
+    rv = FindAndCreateNode(aName, &node);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NS_ASSERTION(node,"didn't find the node");
+    if (!node) return NS_ERROR_FAILURE;
+
+    if (aChangeIfExists) {
+        node->isSubscribed = aAddAsSubscribed;
+        rv = NotifyChange(node, kNC_Subscribed, node->isSubscribed);
+        NS_ENSURE_SUCCESS(rv,rv);
+    }
+
+    node->isSubscribable = aSubscribable;
+    return rv;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetState(const nsACString &aPath, bool aState,
+                               bool *aStateChanged)
+{
+    nsresult rv = NS_OK;
+    NS_ASSERTION(!aPath.IsEmpty() && aStateChanged, "no path or stateChanged");
+    if (aPath.IsEmpty() || !aStateChanged) return NS_ERROR_NULL_POINTER;
+
+    NS_ASSERTION(MsgIsUTF8(aPath), "aPath is not in UTF-8");
+
+    *aStateChanged = false;
+
+    SubscribeTreeNode *node = nullptr;
+    rv = FindAndCreateNode(aPath, &node);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NS_ASSERTION(node,"didn't find the node");
+    if (!node) return NS_ERROR_FAILURE;
+
+    NS_ASSERTION(node->isSubscribable, "fix this");
+    if (!node->isSubscribable) {
+        return NS_OK;
+    }
+
+    if (node->isSubscribed == aState) {
+        return NS_OK;
+    }
+    else {
+        node->isSubscribed = aState;
+        *aStateChanged = true;
+        rv = NotifyChange(node, kNC_Subscribed, node->isSubscribed);
+        NS_ENSURE_SUCCESS(rv,rv);
+    }
+
+    return rv;
+}
+
+void
+nsSubscribableServer::BuildURIFromNode(SubscribeTreeNode *node, nsACString &uri)
+{
+    if (node->parent) {
+        BuildURIFromNode(node->parent, uri);
+        if (node->parent == mTreeRoot) {
+            uri += "/";
+        }
+        else {
+            uri += mDelimiter;
+        }
+    }
+
+    uri += node->name;
+    return;
+}
+
+nsresult
+nsSubscribableServer::NotifyAssert(SubscribeTreeNode *subjectNode, nsIRDFResource *property, SubscribeTreeNode *objectNode)
+{
+    nsresult rv;
+
+    bool hasObservers = true;
+    rv = EnsureSubscribeDS();
+    NS_ENSURE_SUCCESS(rv,rv);
+    rv = mSubscribeDS->GetHasObservers(&hasObservers);
+    NS_ENSURE_SUCCESS(rv,rv);
+    // no need to do all this work, there are no observers
+    if (!hasObservers) {
+        return NS_OK;
+    }
+
+    nsAutoCString subjectUri;
+    BuildURIFromNode(subjectNode, subjectUri);
+
+    // we could optimize this, since we know that objectUri == subjectUri + mDelimiter + object->name
+    // is it worth it?
+    nsAutoCString objectUri;
+    BuildURIFromNode(objectNode, objectUri);
+
+    nsCOMPtr <nsIRDFResource> subject;
+    nsCOMPtr <nsIRDFResource> object;
+
+    rv = EnsureRDFService();
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetResource(subjectUri, getter_AddRefs(subject));
+    NS_ENSURE_SUCCESS(rv,rv);
+    rv = mRDFService->GetResource(objectUri, getter_AddRefs(object));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = Notify(subject, property, object, true, false);
+    NS_ENSURE_SUCCESS(rv,rv);
+    return NS_OK;
+}
+
+nsresult
+nsSubscribableServer::EnsureRDFService()
+{
+    nsresult rv;
+
+    if (!mRDFService) {
+        mRDFService = do_GetService(kRDFServiceCID, &rv);
+        NS_ASSERTION(NS_SUCCEEDED(rv) && mRDFService, "failed to get rdf service");
+        NS_ENSURE_SUCCESS(rv,rv);
+        if (!mRDFService) return NS_ERROR_FAILURE;
+    }
+    return NS_OK;
+}
+
+nsresult
+nsSubscribableServer::NotifyChange(SubscribeTreeNode *subjectNode, nsIRDFResource *property, bool value)
+{
+    nsresult rv;
+    nsCOMPtr <nsIRDFResource> subject;
+
+    bool hasObservers = true;
+    rv = EnsureSubscribeDS();
+    NS_ENSURE_SUCCESS(rv,rv);
+    rv = mSubscribeDS->GetHasObservers(&hasObservers);
+    NS_ENSURE_SUCCESS(rv,rv);
+    // no need to do all this work, there are no observers
+    if (!hasObservers) {
+        return NS_OK;
+    }
+
+    nsAutoCString subjectUri;
+    BuildURIFromNode(subjectNode, subjectUri);
+
+    rv = EnsureRDFService();
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetResource(subjectUri, getter_AddRefs(subject));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    if (value) {
+        rv = Notify(subject,property,kTrueLiteral,false,true);
+    }
+    else {
+        rv = Notify(subject,property,kFalseLiteral,false,true);
+    }
+
+    NS_ENSURE_SUCCESS(rv,rv);
+    return NS_OK;
+}
+
+nsresult
+nsSubscribableServer::EnsureSubscribeDS()
+{
+    nsresult rv = NS_OK;
+
+    if (!mSubscribeDS) {
+        nsCOMPtr<nsIRDFDataSource> ds;
+
+        rv = EnsureRDFService();
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        rv = mRDFService->GetDataSource("rdf:subscribe", getter_AddRefs(ds));
+        NS_ENSURE_SUCCESS(rv,rv);
+        if (!ds) return NS_ERROR_FAILURE;
+
+        mSubscribeDS = do_QueryInterface(ds, &rv);
+        NS_ENSURE_SUCCESS(rv,rv);
+        if (!mSubscribeDS) return NS_ERROR_FAILURE;
+    }
+    return NS_OK;
+}
+
+nsresult
+nsSubscribableServer::Notify(nsIRDFResource *subject, nsIRDFResource *property, nsIRDFNode *object, bool isAssert, bool isChange)
+{
+    nsresult rv = NS_OK;
+
+    rv = EnsureSubscribeDS();
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mSubscribeDS->NotifyObservers(subject, property, object, isAssert, isChange);
+    NS_ENSURE_SUCCESS(rv,rv);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetSubscribeListener(nsISubscribeListener *aListener)
+{
+	mSubscribeListener = aListener;
+	return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetSubscribeListener(nsISubscribeListener **aListener)
+{
+	if (!aListener) return NS_ERROR_NULL_POINTER;
+	if (mSubscribeListener) {
+			*aListener = mSubscribeListener;
+			NS_ADDREF(*aListener);
+	}
+	return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SubscribeCleanup()
+{
+	NS_ASSERTION(false,"override this.");
+	return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::StartPopulatingWithUri(nsIMsgWindow *aMsgWindow, bool aForceToServer, const char *uri)
+{
+    mStopped = false;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::StartPopulating(nsIMsgWindow *aMsgWindow, bool aForceToServer, bool aGetOnlyNew /*ignored*/)
+{
+    nsresult rv = NS_OK;
+
+    mStopped = false;
+
+    rv = FreeSubtree(mTreeRoot);
+    mTreeRoot = nullptr;
+    NS_ENSURE_SUCCESS(rv,rv);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::StopPopulating(nsIMsgWindow *aMsgWindow)
+{
+    mStopped = true;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsSubscribableServer::UpdateSubscribed()
+{
+	NS_ASSERTION(false,"override this.");
+	return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::Subscribe(const char16_t *aName)
+{
+	NS_ASSERTION(false,"override this.");
+	return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::Unsubscribe(const char16_t *aName)
+{
+	NS_ASSERTION(false,"override this.");
+	return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetShowFullName(bool showFullName)
+{
+	mShowFullName = showFullName;
+	return NS_OK;
+}
+
+nsresult
+nsSubscribableServer::FreeSubtree(SubscribeTreeNode *node)
+{
+    nsresult rv = NS_OK;
+
+    if (node) {
+        // recursively free the children
+        if (node->firstChild) {
+            // will free node->firstChild
+            rv = FreeSubtree(node->firstChild);
+            NS_ENSURE_SUCCESS(rv,rv);
+            node->firstChild = nullptr;
+        }
+
+        // recursively free the siblings
+        if (node->nextSibling) {
+            // will free node->nextSibling
+            rv = FreeSubtree(node->nextSibling);
+            NS_ENSURE_SUCCESS(rv,rv);
+            node->nextSibling = nullptr;
+        }
+
+#ifdef HAVE_SUBSCRIBE_DESCRIPTION
+        NS_ASSERTION(node->description == nullptr, "you need to free the description");
+#endif
+        NS_Free(node->name);
+#if 0
+        node->name = nullptr;
+        node->parent = nullptr;
+        node->lastChild = nullptr;
+        node->cachedChild = nullptr;
+#endif
+
+        PR_Free(node);
+    }
+
+    return NS_OK;
+}
+
+nsresult
+nsSubscribableServer::CreateNode(SubscribeTreeNode *parent, const char *name, SubscribeTreeNode **result)
+{
+    NS_ASSERTION(result && name, "result or name is null");
+    if (!result || !name) return NS_ERROR_NULL_POINTER;
+
+    *result = (SubscribeTreeNode *) PR_Malloc(sizeof(SubscribeTreeNode));
+    if (!*result) return NS_ERROR_OUT_OF_MEMORY;
+
+    (*result)->name = strdup(name);
+    if (!(*result)->name) return NS_ERROR_OUT_OF_MEMORY;
+
+    (*result)->parent = parent;
+    (*result)->prevSibling = nullptr;
+    (*result)->nextSibling = nullptr;
+    (*result)->firstChild = nullptr;
+    (*result)->lastChild = nullptr;
+    (*result)->isSubscribed = false;
+    (*result)->isSubscribable = false;
+#ifdef HAVE_SUBSCRIBE_DESCRIPTION
+    (*result)->description = nullptr;
+#endif
+#ifdef HAVE_SUBSCRIBE_MESSAGES
+    (*result)->messages = 0;
+#endif
+    (*result)->cachedChild = nullptr;
+
+    if (parent) {
+        parent->cachedChild = *result;
+    }
+
+    return NS_OK;
+}
+
+nsresult
+nsSubscribableServer::AddChildNode(SubscribeTreeNode *parent, const char *name, SubscribeTreeNode **child)
+{
+    nsresult rv = NS_OK;
+    NS_ASSERTION(parent && child && name, "parent, child or name is null");
+    if (!parent || !child || !name) return NS_ERROR_NULL_POINTER;
+
+    if (!parent->firstChild) {
+        // CreateNode will set the parent->cachedChild
+        rv = CreateNode(parent, name, child);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        parent->firstChild = *child;
+        parent->lastChild = *child;
+
+        rv = NotifyAssert(parent, kNC_Child, *child);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        return NS_OK;
+    }
+    else {
+        if (parent->cachedChild) {
+            if (strcmp(parent->cachedChild->name,name) == 0) {
+                *child = parent->cachedChild;
+                return NS_OK;
+            }
+        }
+
+        SubscribeTreeNode *current = parent->firstChild;
+
+        /*
+         * insert in reverse alphabetical order
+         * this will reduce the # of strcmps
+         * since this is faster assuming:
+         *  1) the hostinfo.dat feeds us the groups in alphabetical order
+         *     since we control the hostinfo.dat file, we can guarantee this.
+         *  2) the server gives us the groups in alphabetical order
+         *     we can't guarantee this, but it seems to be a common thing
+         *
+         * because we have firstChild, lastChild, nextSibling, prevSibling
+         * we can efficiently reverse the order when dumping to hostinfo.dat
+         * or to GetTargets()
+         */
+        int32_t compare = strcmp(current->name, name);
+
+        while (current && (compare != 0)) {
+            if (compare < 0) {
+                // CreateNode will set the parent->cachedChild
+                rv = CreateNode(parent, name, child);
+                NS_ENSURE_SUCCESS(rv,rv);
+
+                (*child)->nextSibling = current;
+                (*child)->prevSibling = current->prevSibling;
+                current->prevSibling = (*child);
+                if (!(*child)->prevSibling) {
+                    parent->firstChild = (*child);
+                }
+                else {
+                    (*child)->prevSibling->nextSibling = (*child);
+                }
+
+                rv = NotifyAssert(parent, kNC_Child, *child);
+                NS_ENSURE_SUCCESS(rv,rv);
+                return NS_OK;
+            }
+            current = current->nextSibling;
+            if (current) {
+                NS_ASSERTION(current->name, "no name!");
+                compare = strcmp(current->name,name);
+            }
+            else {
+                compare = -1; // anything but 0, since that would be a match
+            }
+        }
+
+        if (compare == 0) {
+            // already exists;
+            *child = current;
+
+            // set the cachedChild
+            parent->cachedChild = *child;
+            return NS_OK;
+        }
+
+        // CreateNode will set the parent->cachedChild
+        rv = CreateNode(parent, name, child);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        (*child)->prevSibling = parent->lastChild;
+        (*child)->nextSibling = nullptr;
+        parent->lastChild->nextSibling = *child;
+        parent->lastChild = *child;
+
+        rv = NotifyAssert(parent, kNC_Child, *child);
+        NS_ENSURE_SUCCESS(rv,rv);
+        return NS_OK;
+    }
+    return NS_OK;
+}
+
+nsresult
+nsSubscribableServer::FindAndCreateNode(const nsACString &aPath,
+                                        SubscribeTreeNode **aResult)
+{
+  nsresult rv = NS_OK;
+  NS_ASSERTION(aResult, "no result");
+  if (!aResult) return NS_ERROR_NULL_POINTER;
+
+  if (!mTreeRoot) {
+      // the root has no parent, and its name is server uri
+      rv = CreateNode(nullptr, mIncomingServerUri.get(), &mTreeRoot);
+      NS_ENSURE_SUCCESS(rv,rv);
+  }
+
+  if (aPath.IsEmpty()) {
+      *aResult = mTreeRoot;
+      return NS_OK;
+  }
+
+  char *token = nullptr;
+  nsCString pathStr(aPath);
+  char *rest = pathStr.BeginWriting();
+
+  // todo do this only once
+  char delimstr[2];
+  delimstr[0] = mDelimiter;
+  delimstr[1] = '\0';
+
+  *aResult = nullptr;
+
+  SubscribeTreeNode *parent = mTreeRoot;
+  SubscribeTreeNode *child = nullptr;
+
+  token = NS_strtok(delimstr, &rest); 
+  // special case paths that start with the hierarchy delimiter.
+  // We want to include that delimiter in the first token name.
+  if (token && pathStr[0] == mDelimiter)
+    --token;
+  while (token && *token) {
+    rv = AddChildNode(parent, token, &child);
+    if (NS_FAILED(rv))
+      return rv;
+    token = NS_strtok(delimstr, &rest);
+    parent = child;
+  }
+
+  // the last child we add is the result
+  *aResult = child;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::HasChildren(const nsACString &aPath, bool *aHasChildren)
+{
+    nsresult rv = NS_OK;
+    NS_ASSERTION(aHasChildren, "no hasChildren");
+    if (!aHasChildren) return NS_ERROR_NULL_POINTER;
+
+    *aHasChildren = false;
+
+    SubscribeTreeNode *node = nullptr;
+    rv = FindAndCreateNode(aPath, &node);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NS_ASSERTION(node,"didn't find the node");
+    if (!node) return NS_ERROR_FAILURE;
+
+    *aHasChildren = (node->firstChild != nullptr);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsSubscribableServer::IsSubscribed(const nsACString &aPath,
+                                   bool *aIsSubscribed)
+{
+    NS_ENSURE_ARG_POINTER(aIsSubscribed);
+
+    *aIsSubscribed = false;
+
+    SubscribeTreeNode *node = nullptr;
+    nsresult rv = FindAndCreateNode(aPath, &node);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NS_ASSERTION(node,"didn't find the node");
+    if (!node) return NS_ERROR_FAILURE;
+
+    *aIsSubscribed = node->isSubscribed;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::IsSubscribable(const nsACString &aPath,
+                                     bool *aIsSubscribable)
+{
+    NS_ENSURE_ARG_POINTER(aIsSubscribable);
+
+    *aIsSubscribable = false;
+
+    SubscribeTreeNode *node = nullptr;
+    nsresult rv = FindAndCreateNode(aPath, &node);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NS_ASSERTION(node,"didn't find the node");
+    if (!node) return NS_ERROR_FAILURE;
+
+    *aIsSubscribable = node->isSubscribable;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetLeafName(const nsACString &aPath, nsAString &aLeafName)
+{
+    SubscribeTreeNode *node = nullptr;
+    nsresult rv = FindAndCreateNode(aPath, &node);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NS_ASSERTION(node,"didn't find the node");
+    if (!node) return NS_ERROR_FAILURE;
+
+    // XXX TODO FIXME
+    // I'm assuming that mShowFullName is true for NNTP, false for IMAP.
+    // for imap, the node name is in modified UTF7
+    // for news, the path is escaped UTF8
+    //
+    // when we switch to using the tree, this hack will go away.
+    if (mShowFullName) {
+       return NS_MsgDecodeUnescapeURLPath(aPath, aLeafName);
+    }
+
+    return CopyMUTF7toUTF16(nsDependentCString(node->name), aLeafName);
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetFirstChildURI(const nsACString &aPath,
+                                       nsACString &aResult)
+{
+    aResult.Truncate();
+
+    SubscribeTreeNode *node = nullptr;
+    nsresult rv = FindAndCreateNode(aPath, &node);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    NS_ASSERTION(node,"didn't find the node");
+    if (!node) return NS_ERROR_FAILURE;
+
+    // no children
+    if (!node->firstChild) return NS_ERROR_FAILURE;
+
+    BuildURIFromNode(node->firstChild, aResult);
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetChildren(const nsACString &aPath,
+                                  nsISimpleEnumerator **aResult)
+{
+    SubscribeTreeNode *node = nullptr;
+    nsresult rv = FindAndCreateNode(aPath, &node);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    NS_ASSERTION(node,"didn't find the node");
+    if (!node)
+      return NS_ERROR_FAILURE;
+
+    nsAutoCString uriPrefix;
+    NS_ASSERTION(mTreeRoot, "no tree root!");
+    if (!mTreeRoot)
+      return NS_ERROR_UNEXPECTED;
+
+    uriPrefix = mTreeRoot->name; // the root's name is the server uri
+    uriPrefix += "/";
+    if (!aPath.IsEmpty()) {
+        uriPrefix += aPath;
+        uriPrefix += mDelimiter;
+    }
+
+    // we inserted them in reverse alphabetical order.
+    // so pull them out in reverse to get the right order
+    // in the subscribe dialog
+    SubscribeTreeNode *current = node->lastChild;
+    // return failure if there are no children.
+    if (!current)
+      return NS_ERROR_FAILURE;
+
+    nsCOMArray<nsIRDFResource> result;
+
+    while (current) {
+        nsAutoCString uri;
+        uri = uriPrefix;
+        NS_ASSERTION(current->name, "no name");
+        if (!current->name)
+          return NS_ERROR_FAILURE;
+
+        uri += current->name;
+
+        nsCOMPtr <nsIRDFResource> res;
+        rv = EnsureRDFService();
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        // todo, is this creating nsMsgFolders?
+        mRDFService->GetResource(uri, getter_AddRefs(res));
+        result.AppendObject(res);
+
+        current = current->prevSibling;
+    }
+
+    return NS_NewArrayEnumerator(aResult, result);
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::CommitSubscribeChanges()
+{
+    NS_ASSERTION(false,"override this.");
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetSearchValue(const nsAString &aSearchValue)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetSupportsSubscribeSearch(bool *retVal)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
diff --git a/mailnews/base/src/nsSubscribableServer.h b/mailnews/base/src/nsSubscribableServer.h
new file mode 100644
index 000000000..cbbac78e5
--- /dev/null
+++ b/mailnews/base/src/nsSubscribableServer.h
@@ -0,0 +1,80 @@
+/* -*- 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 nsSubscribableServer_h__
+#define nsSubscribableServer_h__
+
+#include "nsCOMPtr.h"
+#include "nsStringGlue.h"
+#include "nsISubscribableServer.h"
+#include "nsIRDFService.h"
+#include "nsSubscribeDataSource.h"
+#include "nsIRDFResource.h"
+
+typedef struct _subscribeTreeNode {
+  char *name;
+  bool isSubscribed;
+  struct _subscribeTreeNode *prevSibling;
+  struct _subscribeTreeNode *nextSibling;
+  struct _subscribeTreeNode *firstChild;
+  struct _subscribeTreeNode *lastChild;
+  struct _subscribeTreeNode *parent;
+  struct _subscribeTreeNode *cachedChild;
+#ifdef HAVE_SUBSCRIBE_DESCRIPTION
+  char16_t *description;
+#endif
+#ifdef HAVE_SUBSCRIBE_MESSAGES
+  uint32_t messages;
+#endif
+  bool isSubscribable;
+} SubscribeTreeNode;
+
+#if defined(DEBUG_sspitzer) || defined(DEBUG_seth)
+#define DEBUG_SUBSCRIBE 1
+#endif
+
+class nsSubscribableServer : public nsISubscribableServer
+{
+ public:
+  nsSubscribableServer();
+
+  nsresult Init();
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSISUBSCRIBABLESERVER
+  
+private:
+  virtual ~nsSubscribableServer();
+
+  nsresult ConvertNameToUnichar(const char *inStr, char16_t **outStr);
+  nsCOMPtr <nsISubscribeListener> mSubscribeListener;
+  nsCString mIncomingServerUri;
+  nsCOMPtr <nsISubscribeDataSource> mSubscribeDS;
+  char mDelimiter;
+  bool mShowFullName;
+  bool mStopped;
+
+  nsCOMPtr <nsIRDFResource>      kNC_Child;
+  nsCOMPtr <nsIRDFResource>      kNC_Subscribed;
+  nsCOMPtr <nsIRDFLiteral>       kTrueLiteral;
+  nsCOMPtr <nsIRDFLiteral>       kFalseLiteral;
+
+  nsCOMPtr <nsIRDFService>       mRDFService;
+
+  SubscribeTreeNode *mTreeRoot;
+  nsresult FreeSubtree(SubscribeTreeNode *node);
+  nsresult CreateNode(SubscribeTreeNode *parent, const char *name, SubscribeTreeNode **result);
+  nsresult AddChildNode(SubscribeTreeNode *parent, const char *name, SubscribeTreeNode **child);
+  nsresult FindAndCreateNode(const nsACString &aPath,
+                             SubscribeTreeNode **aResult);
+  nsresult NotifyAssert(SubscribeTreeNode *subjectNode, nsIRDFResource *property, SubscribeTreeNode *objectNode);
+  nsresult NotifyChange(SubscribeTreeNode *subjectNode, nsIRDFResource *property, bool value);
+  nsresult Notify(nsIRDFResource *subject, nsIRDFResource *property, nsIRDFNode *object, bool isAssert, bool isChange);
+  void BuildURIFromNode(SubscribeTreeNode *node, nsACString &uri);
+  nsresult EnsureSubscribeDS();
+  nsresult EnsureRDFService();
+};
+
+#endif // nsSubscribableServer_h__
diff --git a/mailnews/base/src/nsSubscribeDataSource.cpp b/mailnews/base/src/nsSubscribeDataSource.cpp
new file mode 100644
index 000000000..fe13cffca
--- /dev/null
+++ b/mailnews/base/src/nsSubscribeDataSource.cpp
@@ -0,0 +1,673 @@
+/* -*- 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 "nsSubscribeDataSource.h"
+
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "nsIComponentManager.h"
+#include "rdf.h"
+#include "nsIServiceManager.h"
+#include "nsEnumeratorUtils.h"
+#include "nsStringGlue.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsCOMArray.h"
+#include "nsArrayEnumerator.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsMsgUtils.h"
+
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+
+nsSubscribeDataSource::nsSubscribeDataSource()
+{
+}
+
+nsSubscribeDataSource::~nsSubscribeDataSource()
+{
+}
+
+NS_IMPL_ISUPPORTS(nsSubscribeDataSource, nsIRDFDataSource, nsISubscribeDataSource) 
+
+nsresult
+nsSubscribeDataSource::Init()
+{
+    nsresult rv;
+
+    mRDFService = do_GetService(kRDFServiceCID, &rv);
+    NS_ASSERTION(NS_SUCCEEDED(rv) && mRDFService, "failed to get rdf service");
+    NS_ENSURE_SUCCESS(rv,rv);
+    if (!mRDFService) return NS_ERROR_FAILURE;
+
+    rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "child"),
+                                  getter_AddRefs(kNC_Child));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Name"),
+                                  getter_AddRefs(kNC_Name));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "LeafName"),
+                                  getter_AddRefs(kNC_LeafName));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Subscribed"),
+                                  getter_AddRefs(kNC_Subscribed));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "Subscribable"),
+                                  getter_AddRefs(kNC_Subscribable));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "ServerType"),
+                                  getter_AddRefs(kNC_ServerType));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetLiteral(u"true", getter_AddRefs(kTrueLiteral));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = mRDFService->GetLiteral(u"false", getter_AddRefs(kFalseLiteral));
+    NS_ENSURE_SUCCESS(rv,rv);
+	return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsSubscribeDataSource::GetURI(char * *aURI)
+{
+  if ((*aURI = strdup("rdf:subscribe")) == nullptr)
+    return NS_ERROR_OUT_OF_MEMORY;
+  else
+    return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsSubscribeDataSource::GetSource(nsIRDFResource *property, nsIRDFNode *target, bool tv, nsIRDFResource **source)
+{
+    NS_PRECONDITION(property != nullptr, "null ptr");
+    if (! property)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(target != nullptr, "null ptr");
+    if (! target)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(source != nullptr, "null ptr");
+    if (! source)
+        return NS_ERROR_NULL_POINTER;
+
+    *source = nullptr;
+    return NS_RDF_NO_VALUE;
+}
+
+NS_IMETHODIMP
+nsSubscribeDataSource::GetTarget(nsIRDFResource *source,
+                                nsIRDFResource *property,
+                                bool tv,
+                                nsIRDFNode **target /* out */)
+{
+	nsresult rv = NS_RDF_NO_VALUE;
+
+	NS_PRECONDITION(source != nullptr, "null ptr");
+	if (! source)
+		return NS_ERROR_NULL_POINTER;
+
+	NS_PRECONDITION(property != nullptr, "null ptr");
+	if (! property)
+		return NS_ERROR_NULL_POINTER;
+
+	NS_PRECONDITION(target != nullptr, "null ptr");
+	if (! target)
+		return NS_ERROR_NULL_POINTER;
+
+	*target = nullptr;
+
+	// we only have positive assertions in the subscribe data source.
+	if (! tv) return NS_RDF_NO_VALUE;
+
+    nsCOMPtr<nsISubscribableServer> server;
+    nsCString relativePath;
+    rv = GetServerAndRelativePathFromResource(source, getter_AddRefs(server), getter_Copies(relativePath));
+    if (NS_FAILED(rv) || !server)
+        return NS_RDF_NO_VALUE;
+
+    if (property == kNC_Name.get()) {
+        nsCOMPtr<nsIRDFLiteral> name;
+        rv = mRDFService->GetLiteral(NS_ConvertUTF8toUTF16(relativePath).get(),
+                                     getter_AddRefs(name));
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        if (!name) rv = NS_RDF_NO_VALUE;
+        if (rv == NS_RDF_NO_VALUE) return(rv);
+        return name->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+    }
+    else if (property == kNC_Child.get()) {
+        nsCString childUri;
+        rv = server->GetFirstChildURI(relativePath, childUri);
+        if (NS_FAILED(rv)) return NS_RDF_NO_VALUE;
+        if (childUri.IsEmpty()) return NS_RDF_NO_VALUE;
+
+        nsCOMPtr <nsIRDFResource> childResource;
+        rv = mRDFService->GetResource(childUri, getter_AddRefs(childResource));
+        NS_ENSURE_SUCCESS(rv,rv);
+        
+        return childResource->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+    }
+    else if (property == kNC_Subscribed.get()) {
+        bool isSubscribed;
+        rv = server->IsSubscribed(relativePath, &isSubscribed);
+        NS_ENSURE_SUCCESS(rv,rv);
+    
+        NS_IF_ADDREF(*target = (isSubscribed ? kTrueLiteral : kFalseLiteral));
+        return NS_OK;
+    }
+    else if (property == kNC_Subscribable.get()) {
+        bool isSubscribable;
+        rv = server->IsSubscribable(relativePath, &isSubscribable);
+        NS_ENSURE_SUCCESS(rv,rv);
+        
+        NS_IF_ADDREF(*target = (isSubscribable ? kTrueLiteral : kFalseLiteral));
+        return NS_OK;
+    }
+    else if (property == kNC_ServerType.get()) {
+        nsCString serverTypeStr;
+        rv = GetServerType(server, serverTypeStr);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        nsCOMPtr<nsIRDFLiteral> serverType;
+        rv = mRDFService->GetLiteral(NS_ConvertASCIItoUTF16(serverTypeStr).get(),
+                                     getter_AddRefs(serverType));
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        if (!serverType)
+          rv = NS_RDF_NO_VALUE;
+        if (rv == NS_RDF_NO_VALUE) 
+          return rv;
+        return serverType->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+    }
+    else if (property == kNC_LeafName.get()) {
+        nsString leafNameStr;
+        rv = server->GetLeafName(relativePath, leafNameStr); 
+        NS_ENSURE_SUCCESS(rv,rv);
+   
+        nsCOMPtr<nsIRDFLiteral> leafName;
+        rv = mRDFService->GetLiteral(leafNameStr.get(), getter_AddRefs(leafName));
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        if (!leafName)
+          rv = NS_RDF_NO_VALUE;
+        if (rv == NS_RDF_NO_VALUE)
+          return rv;
+        return leafName->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
+    }
+    else {
+        // do nothing
+    }
+
+  return(NS_RDF_NO_VALUE);
+}
+
+NS_IMETHODIMP
+nsSubscribeDataSource::GetTargets(nsIRDFResource *source,
+				nsIRDFResource *property,
+				bool tv,
+				nsISimpleEnumerator **targets /* out */)
+{
+	nsresult rv = NS_OK;
+
+	NS_PRECONDITION(source != nullptr, "null ptr");
+	if (! source)
+		return NS_ERROR_NULL_POINTER;
+
+	NS_PRECONDITION(property != nullptr, "null ptr");
+	if (! property)
+		return NS_ERROR_NULL_POINTER;
+
+	NS_PRECONDITION(targets != nullptr, "null ptr");
+	if (! targets)
+		return NS_ERROR_NULL_POINTER;
+
+    *targets = nullptr;
+
+	// we only have positive assertions in the subscribe data source.
+	if (!tv) return NS_RDF_NO_VALUE;
+
+    nsCOMPtr<nsISubscribableServer> server;
+    nsCString relativePath;  // UTF-8
+
+    rv = GetServerAndRelativePathFromResource(source, getter_AddRefs(server), getter_Copies(relativePath));
+    if (NS_FAILED(rv) || !server) {
+	    return NS_NewEmptyEnumerator(targets);
+    }
+
+    if (property == kNC_Child.get()) {
+        rv = server->GetChildren(relativePath, targets);
+        if (NS_FAILED(rv)) {
+            return NS_NewEmptyEnumerator(targets);
+        }
+        return rv;
+    }
+    else if (property == kNC_LeafName.get()) {
+        nsString leafNameStr;
+        rv = server->GetLeafName(relativePath, leafNameStr);
+        NS_ENSURE_SUCCESS(rv,rv);
+    
+        nsCOMPtr<nsIRDFLiteral> leafName;
+        rv = mRDFService->GetLiteral(leafNameStr.get(), getter_AddRefs(leafName));
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        return NS_NewSingletonEnumerator(targets, leafName);
+    }
+    else if (property == kNC_Subscribed.get()) {
+        bool isSubscribed;
+        rv = server->IsSubscribed(relativePath, &isSubscribed);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        return NS_NewSingletonEnumerator(targets,
+                 isSubscribed ? kTrueLiteral : kFalseLiteral);
+    }
+    else if (property == kNC_Subscribable.get()) {
+        bool isSubscribable;
+        rv = server->IsSubscribable(relativePath, &isSubscribable);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        return NS_NewSingletonEnumerator(targets,
+                 isSubscribable ? kTrueLiteral : kFalseLiteral);
+    }
+    else if (property == kNC_Name.get()) {
+        nsCOMPtr<nsIRDFLiteral> name;
+        rv = mRDFService->GetLiteral(NS_ConvertUTF8toUTF16(relativePath).get(),
+                                     getter_AddRefs(name));
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        return NS_NewSingletonEnumerator(targets, name);
+    }
+    else if (property == kNC_ServerType.get()) {
+        nsCString serverTypeStr;
+        rv = GetServerType(server, serverTypeStr);
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        nsCOMPtr<nsIRDFLiteral> serverType;
+        rv = mRDFService->GetLiteral(NS_ConvertASCIItoUTF16(serverTypeStr).get(),
+                                     getter_AddRefs(serverType));
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        return NS_NewSingletonEnumerator(targets, serverType);
+    }
+    else {
+        // do nothing
+    }
+
+	return NS_NewEmptyEnumerator(targets);
+}
+
+NS_IMETHODIMP
+nsSubscribeDataSource::Assert(nsIRDFResource *source,
+                       nsIRDFResource *property,
+                       nsIRDFNode *target,
+                       bool tv)
+{
+	return NS_RDF_ASSERTION_REJECTED;
+}
+
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::Unassert(nsIRDFResource *source,
+                         nsIRDFResource *property,
+                         nsIRDFNode *target)
+{
+  return NS_RDF_ASSERTION_REJECTED;
+}
+
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::Change(nsIRDFResource* aSource,
+                              nsIRDFResource* aProperty,
+                              nsIRDFNode* aOldTarget,
+                              nsIRDFNode* aNewTarget)
+{
+  return NS_RDF_ASSERTION_REJECTED;
+}
+
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::Move(nsIRDFResource* aOldSource,
+                            nsIRDFResource* aNewSource,
+                            nsIRDFResource* aProperty,
+                            nsIRDFNode* aTarget)
+{
+  return NS_RDF_ASSERTION_REJECTED;
+}
+
+nsresult
+nsSubscribeDataSource::GetServerType(nsISubscribableServer *server, nsACString& serverType)
+{
+  NS_ENSURE_ARG_POINTER(server);
+  nsresult rv;
+  nsCOMPtr<nsIMsgIncomingServer> incomingServer(do_QueryInterface(server, &rv));
+  NS_ENSURE_SUCCESS(rv,rv);
+  return incomingServer->GetType(serverType);
+}
+
+nsresult
+nsSubscribeDataSource::GetServerAndRelativePathFromResource(nsIRDFResource *source, nsISubscribableServer **server, char **relativePath)
+{
+    nsresult rv = NS_OK;
+
+    const char *sourceURI = nullptr;
+    rv = source->GetValueConst(&sourceURI);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(source, &rv));
+    // we expect this to fail sometimes, so don't assert
+    if (NS_FAILED(rv))
+      return rv;
+
+    nsCOMPtr<nsIMsgIncomingServer> incomingServer;
+    rv = folder->GetServer(getter_AddRefs(incomingServer));
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = incomingServer->QueryInterface(NS_GET_IID(nsISubscribableServer), (void**)server);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    nsCString serverURI;
+    rv = incomingServer->GetServerURI(serverURI);
+    NS_ENSURE_SUCCESS(rv,rv);
+ 
+    uint32_t serverURILen = serverURI.Length();
+    if (serverURILen == strlen(sourceURI))
+      *relativePath = nullptr;
+    else {
+      // XXX : perhaps, have to unescape before returning 
+      *relativePath = strdup(sourceURI + serverURILen + 1);
+      if (!*relativePath)
+        return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribeDataSource::HasAssertion(nsIRDFResource *source,
+                             nsIRDFResource *property,
+                             nsIRDFNode *target,
+                             bool tv,
+                             bool *hasAssertion /* out */)
+{
+    nsresult rv = NS_OK;
+
+	NS_PRECONDITION(source != nullptr, "null ptr");
+	if (! source)
+		return NS_ERROR_NULL_POINTER;
+
+	NS_PRECONDITION(property != nullptr, "null ptr");
+	if (! property)
+		return NS_ERROR_NULL_POINTER;
+
+	NS_PRECONDITION(target != nullptr, "null ptr");
+	if (! target)
+		return NS_ERROR_NULL_POINTER;
+
+	NS_PRECONDITION(hasAssertion != nullptr, "null ptr");
+	if (! hasAssertion)
+		return NS_ERROR_NULL_POINTER;
+
+	*hasAssertion = false;
+
+  // we only have positive assertions in the subscribe data source.
+	if (!tv) return NS_OK;
+
+	if (property == kNC_Child.get()) {
+    nsCOMPtr<nsISubscribableServer> server;
+    nsCString relativePath;
+
+    rv = GetServerAndRelativePathFromResource(source, getter_AddRefs(server), getter_Copies(relativePath));
+    if (NS_FAILED(rv) || !server) {
+        *hasAssertion = false;
+        return NS_OK;
+    }
+
+        // not everything has children
+        rv = server->HasChildren(relativePath, hasAssertion);
+        NS_ENSURE_SUCCESS(rv,rv);
+    }
+    else if (property == kNC_Name.get()) {
+        // everything has a name
+        *hasAssertion = true;
+    }
+    else if (property == kNC_LeafName.get()) {
+        // everything has a leaf name
+        *hasAssertion = true;
+    }
+    else if (property == kNC_Subscribed.get()) {
+        // everything is subscribed or not
+        *hasAssertion = true;
+    }
+    else if (property == kNC_Subscribable.get()) {
+        // everything is subscribable or not
+        *hasAssertion = true;
+    }
+    else if (property == kNC_ServerType.get()) {
+        // everything has a server type
+        *hasAssertion = true;
+    }
+    else {
+        // do nothing
+    }
+
+	return NS_OK;
+}
+
+
+NS_IMETHODIMP 
+nsSubscribeDataSource::HasArcIn(nsIRDFNode *aNode, nsIRDFResource *aArc, bool *result)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP 
+nsSubscribeDataSource::HasArcOut(nsIRDFResource *source, nsIRDFResource *aArc, bool *result)
+{
+    nsresult rv = NS_OK;
+
+    nsCOMPtr<nsISubscribableServer> server;
+    nsCString relativePath;
+
+    if (aArc == kNC_Child.get()) {
+    rv = GetServerAndRelativePathFromResource(source, getter_AddRefs(server), getter_Copies(relativePath));
+    if (NS_FAILED(rv) || !server) {
+	    *result = false;
+        return NS_OK;
+    }
+
+        bool hasChildren = false;
+        rv = server->HasChildren(relativePath, &hasChildren);
+        NS_ENSURE_SUCCESS(rv,rv);
+        *result = hasChildren;
+        return NS_OK;
+    }
+    else if ((aArc == kNC_Subscribed.get()) ||
+             (aArc == kNC_Subscribable.get()) ||
+             (aArc == kNC_LeafName.get()) ||
+             (aArc == kNC_ServerType.get()) ||
+             (aArc == kNC_Name.get())) {
+        *result = true;
+        return NS_OK;
+    }
+
+    *result = false;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::ArcLabelsIn(nsIRDFNode *node,
+                            nsISimpleEnumerator ** labels /* out */)
+{
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::ArcLabelsOut(nsIRDFResource *source,
+				   nsISimpleEnumerator **labels /* out */)
+{
+    nsresult rv = NS_OK;
+
+    NS_PRECONDITION(source != nullptr, "null ptr");
+    if (! source)
+	return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(labels != nullptr, "null ptr");
+    if (! labels)
+	return NS_ERROR_NULL_POINTER;
+
+    nsCOMPtr<nsISubscribableServer> server;
+    nsCString relativePath;
+
+    rv = GetServerAndRelativePathFromResource(source, getter_AddRefs(server), getter_Copies(relativePath));
+    if (NS_FAILED(rv) || !server) {
+        return NS_NewEmptyEnumerator(labels);
+    }
+
+    bool hasChildren = false;
+    rv = server->HasChildren(relativePath, &hasChildren);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    // Initialise with the number of items below, to save reallocating on each
+    // addition.
+    nsCOMArray<nsIRDFResource> array(hasChildren ? 6 : 5);
+
+    array.AppendObject(kNC_Subscribed);
+    array.AppendObject(kNC_Subscribable);
+    array.AppendObject(kNC_Name);
+    array.AppendObject(kNC_ServerType);
+    array.AppendObject(kNC_LeafName);
+
+    if (hasChildren) {
+        array.AppendObject(kNC_Child);
+    }
+
+    return NS_NewArrayEnumerator(labels, array);
+}
+
+NS_IMETHODIMP
+nsSubscribeDataSource::GetAllResources(nsISimpleEnumerator** aCursor)
+{
+	NS_NOTYETIMPLEMENTED("sorry!");
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::AddObserver(nsIRDFObserver *n)
+{
+  NS_ENSURE_ARG_POINTER(n);
+  mObservers.AppendElement(n);
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::RemoveObserver(nsIRDFObserver *n)
+{
+  NS_ENSURE_ARG_POINTER(n);
+  mObservers.RemoveElement(n);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribeDataSource::GetHasObservers(bool *hasObservers)
+{
+  NS_ENSURE_ARG_POINTER(hasObservers);
+  *hasObservers = !mObservers.IsEmpty();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribeDataSource::GetAllCmds(nsIRDFResource* source,
+                                     nsISimpleEnumerator/*<nsIRDFResource>*/** commands)
+{
+	return(NS_NewEmptyEnumerator(commands));
+}
+
+NS_IMETHODIMP
+nsSubscribeDataSource::IsCommandEnabled(nsISupports/*nsISupportsArray<nsIRDFResource>*/* aSources,
+                                        nsIRDFResource*   aCommand,
+                                        nsISupports/*nsISupportsArray<nsIRDFResource>*/* aArguments,
+                                        bool* aResult)
+{
+	return(NS_ERROR_NOT_IMPLEMENTED);
+}
+
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::DoCommand(nsISupports/*nsISupportsArray<nsIRDFResource>*/* aSources,
+                                 nsIRDFResource*   aCommand,
+                                 nsISupports/*nsISupportsArray<nsIRDFResource>*/* aArguments)
+{
+	return(NS_ERROR_NOT_IMPLEMENTED);
+}
+
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::BeginUpdateBatch()
+{
+        return NS_OK;
+}
+
+
+
+NS_IMETHODIMP
+nsSubscribeDataSource::EndUpdateBatch()
+{
+        return NS_OK;
+}
+
+
+
+NS_IMETHODIMP 
+nsSubscribeDataSource::GetSources(nsIRDFResource *aProperty, nsIRDFNode *aTarget, bool aTruthValue, nsISimpleEnumerator **_retval)
+{
+  NS_ASSERTION(false, "Not implemented");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+#define NOTIFY_SUBSCRIBE_LISTENERS(propertyfunc_, params_) \
+  PR_BEGIN_MACRO \
+  { \
+    nsTObserverArray<nsCOMPtr<nsIRDFObserver> >::ForwardIterator iter(mObservers); \
+    while (iter.HasMore()) \
+    { \
+      iter.GetNext()->propertyfunc_ params_; \
+    } \
+  } \
+  PR_END_MACRO
+
+NS_IMETHODIMP
+nsSubscribeDataSource::NotifyObservers(nsIRDFResource *subject,
+                                                nsIRDFResource *property,
+                                                nsIRDFNode *object,
+                                                bool assert, bool change)
+{
+  NS_ASSERTION(!(change && assert),
+               "Can't change and assert at the same time!\n");
+
+  if (change)
+    NOTIFY_SUBSCRIBE_LISTENERS(OnChange, (this, subject, property, nullptr, object));
+  else if (assert)
+    NOTIFY_SUBSCRIBE_LISTENERS(OnAssert, (this, subject, property, object));
+  else
+    NOTIFY_SUBSCRIBE_LISTENERS(OnUnassert, (this, subject, property, object));
+  return NS_OK;
+}
diff --git a/mailnews/base/src/nsSubscribeDataSource.h b/mailnews/base/src/nsSubscribeDataSource.h
new file mode 100644
index 000000000..bfe72c4c4
--- /dev/null
+++ b/mailnews/base/src/nsSubscribeDataSource.h
@@ -0,0 +1,50 @@
+/* -*- 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 nsSubscribeDataSource_h__
+#define nsSubscribeDataSource_h__
+
+#include "nsIRDFService.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFResource.h"
+#include "nsIRDFLiteral.h"
+#include "nsCOMPtr.h"
+#include "nsISubscribableServer.h"
+#include "nsTObserverArray.h"
+
+/**
+ * The subscribe data source.
+ */
+class nsSubscribeDataSource : public nsIRDFDataSource, public nsISubscribeDataSource
+{
+
+public:
+  nsSubscribeDataSource();
+
+  nsresult Init();
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIRDFDATASOURCE
+  NS_DECL_NSISUBSCRIBEDATASOURCE
+
+private:
+  virtual ~nsSubscribeDataSource();
+  nsCOMPtr <nsIRDFResource>      kNC_Child;
+  nsCOMPtr <nsIRDFResource>      kNC_Name;    
+  nsCOMPtr <nsIRDFResource>      kNC_LeafName;
+  nsCOMPtr <nsIRDFResource>      kNC_Subscribed;
+  nsCOMPtr <nsIRDFResource>      kNC_Subscribable;
+  nsCOMPtr <nsIRDFResource>      kNC_ServerType;
+  nsCOMPtr <nsIRDFLiteral>       kTrueLiteral;
+  nsCOMPtr <nsIRDFLiteral>       kFalseLiteral;
+
+  nsCOMPtr <nsIRDFService>       mRDFService;
+  nsTObserverArray<nsCOMPtr<nsIRDFObserver> >  mObservers;
+
+  nsresult GetServerAndRelativePathFromResource(nsIRDFResource *source, nsISubscribableServer **server, char **relativePath);
+  nsresult GetServerType(nsISubscribableServer *server, nsACString& serverType);
+};
+
+#endif /* nsSubscribedDataSource_h__ */
diff --git a/mailnews/base/src/virtualFolderWrapper.js b/mailnews/base/src/virtualFolderWrapper.js
new file mode 100644
index 000000000..efb4ed68a
--- /dev/null
+++ b/mailnews/base/src/virtualFolderWrapper.js
@@ -0,0 +1,255 @@
+/* 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/. */
+
+/*
+ * Wrap everything about virtual folders.
+ */
+
+this.EXPORTED_SYMBOLS = ['VirtualFolderHelper'];
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+Cu.import("resource:///modules/mailServices.js");
+Cu.import("resource:///modules/iteratorUtils.jsm");
+
+var VirtualFolderHelper = {
+  /**
+   * Create a new virtual folder (an actual nsIMsgFolder that did not previously
+   *  exist), wrapping it in a VirtualFolderWrapper, and returning that wrapper.
+   *
+   * If the call to addSubfolder fails (and therefore throws), we will NOT catch
+   *  it.
+   *
+   * @param aFolderName The name of the new folder to create.
+   * @param aParentFolder The folder in which to create the search folder.
+   * @param aSearchFolders A list of nsIMsgFolders that you want to use as the
+   *     sources for the virtual folder OR a string that is the already '|'
+   *     delimited list of folder URIs to use.
+   * @param aSearchTerms The search terms to use for the virtual folder.  This
+   *     should be a JS list/nsIMutableArray/nsISupportsArray of
+   *     nsIMsgSearchTermbs.
+   * @param aOnlineSearch Should the search attempt to use the server's search
+   *     capabilities when possible and appropriate?
+   *
+   * @return The VirtualFolderWrapper wrapping the newly created folder.  You
+   *     would probably only want this for its virtualFolder attribute which has
+   *     the nsIMsgFolder we created.  Be careful about accessing any of the
+   *     other attributes, as they will bring its message database back to life.
+   */
+  createNewVirtualFolder: function (aFolderName, aParentFolder, aSearchFolders,
+                                    aSearchTerms, aOnlineSearch) {
+    let msgFolder = aParentFolder.addSubfolder(aFolderName);
+    msgFolder.prettyName = aFolderName;
+    msgFolder.setFlag(Ci.nsMsgFolderFlags.Virtual);
+
+    let wrappedVirt = new VirtualFolderWrapper(msgFolder);
+    wrappedVirt.searchTerms = aSearchTerms;
+    wrappedVirt.searchFolders = aSearchFolders;
+    wrappedVirt.onlineSearch = aOnlineSearch;
+
+    let msgDatabase = msgFolder.msgDatabase;
+    msgDatabase.summaryValid = true;
+    msgDatabase.Close(true);
+
+    aParentFolder.NotifyItemAdded(msgFolder);
+    MailServices.accounts.saveVirtualFolders();
+
+    return wrappedVirt;
+  },
+
+  /**
+   * Given an existing nsIMsgFolder that is a virtual folder, wrap it into a
+   *  VirtualFolderWrapper.
+   */
+  wrapVirtualFolder: function (aMsgFolder) {
+    return new VirtualFolderWrapper(aMsgFolder);
+  },
+};
+
+/**
+ * Abstracts dealing with the properties of a virtual folder that differentiate
+ *  it from a non-virtual folder.  A virtual folder is an odd duck.  When
+ *  holding an nsIMsgFolder that is a virtual folder, it is distinguished by
+ *  the virtual flag and a number of properties that tell us the string
+ *  representation of its search, the folders it searches over, and whether we
+ *  use online searching or not.
+ * Virtual folders and their defining attributes are loaded from
+ *  virtualFolders.dat (in the profile directory) by the account manager at
+ *  startup, (re-)creating them if need be.  It also saves them back to the
+ *  file at shutdown.  The most important thing the account manager does is to
+ *  create VirtualFolderChangeListener instances that are registered with the
+ *  message database service.  This means that if one of the databases for the
+ *  folders that the virtual folder includes is opened for some reason (for
+ *  example, new messages are added to the folder because of a filter or they
+ *  are delivered there), the virtual folder gets a chance to know about this
+ *  and update the virtual folder's "cache" of information, such as the message
+ *  counts or the presence of the message in the folder.
+ * The odd part is that a lot of the virtual folder logic also happens as a
+ *  result of the nsMsgDBView subclasses being told the search query and the
+ *  underlying folders.  This makes for an odd collaboration of UI and backend
+ *  logic.
+ *
+ * Justification for this class:  Virtual folders aren't all that complex, but
+ *  they are complex enough that we don't want to have the same code duplicated
+ *  all over the place.  We also don't want to have a loose assembly of global
+ *  functions for working with them.  So here we are.
+ *
+ * Important! Accessing any of our attributes results in the message database
+ *  being loaded so that we can access the dBFolderInfo associated with the
+ *  database.  The message database is not automatically forgotten by the
+ *  folder, which can lead to an (effective) memory leak.  Please make sure
+ *  that you are playing your part in not leaking memory by only using the
+ *  wrapper when you have a serious need to access the database, and by
+ *  forcing the folder to forget about the database when you are done by
+ *  setting the database to null (unless you know with confidence someone else
+ *  definitely wants the database around and will clean it up.)
+ */
+function VirtualFolderWrapper(aVirtualFolder) {
+  this.virtualFolder = aVirtualFolder;
+};
+VirtualFolderWrapper.prototype = {
+  /**
+   * @return the list of nsIMsgFolders that this virtual folder is a
+   *     search over.
+   */
+  get searchFolders() {
+    let rdfService = Cc['@mozilla.org/rdf/rdf-service;1']
+                       .getService(Ci.nsIRDFService);
+    let virtualFolderUris =
+      this.dbFolderInfo.getCharProperty("searchFolderUri").split("|");
+    let folders = [];
+    for (let folderURI of virtualFolderUris) {
+      if (folderURI)
+        folders.push(rdfService.GetResource(folderURI)
+                               .QueryInterface(Ci.nsIMsgFolder));
+    }
+    return folders;
+  },
+  /**
+   * Set the search folders that back this virtual folder.
+   *
+   * @param aFolders Either a "|"-delimited string of folder URIs or a list of
+   *     nsIMsgFolders that fixIterator can traverse (JS array/nsIMutableArray/
+   *     nsISupportsArray).
+   */
+  set searchFolders(aFolders) {
+    if (typeof(aFolders) == "string") {
+      this.dbFolderInfo.setCharProperty("searchFolderUri", aFolders);
+    }
+    else {
+      let uris = Array.from(fixIterator(aFolders, Ci.nsIMsgFolder))
+                      .map(folder => folder.URI);
+      this.dbFolderInfo.setCharProperty("searchFolderUri", uris.join("|"));
+    }
+  },
+
+  /**
+   * @return a "|"-delimited string containing the URIs of the folders that back
+   *     this virtual folder.
+   */
+  get searchFolderURIs() {
+    return this.dbFolderInfo.getCharProperty("searchFolderUri");
+  },
+
+  /**
+   * @return the list of search terms that define this virtual folder.
+   */
+  get searchTerms() {
+    return this.searchTermsSession.searchTerms;
+  },
+  /**
+   * @return a newly created filter with the search terms loaded into it that
+   *     define this virtual folder.  The filter is apparently useful as an
+   *     nsIMsgSearchSession stand-in to some code.
+   */
+  get searchTermsSession() {
+    // Temporary means it doesn't get exposed to the UI and doesn't get saved to
+    //  disk.  Which is good, because this is just a trick to parse the string
+    //  into search terms.
+    let filterList = MailServices.filters.getTempFilterList(this.virtualFolder);
+    let tempFilter = filterList.createFilter("temp");
+    filterList.parseCondition(tempFilter, this.searchString);
+    return tempFilter;
+  },
+
+  /**
+   * Set the search string for this virtual folder to the stringified version of
+   *  the provided list of nsIMsgSearchTerm search terms.  If you already have
+   *  a strinigified version of the search constraint, just set |searchString|
+   *  directly.
+   *
+   * @param aTerms Some collection that fixIterator can traverse.  A JS list or
+   *     XPCOM array (nsIMutableArray or nsISupportsArray) should work.
+   */
+  set searchTerms(aTerms) {
+    let condition = "";
+    for (let term in fixIterator(aTerms, Ci.nsIMsgSearchTerm)) {
+      if (condition.length)
+        condition += " ";
+      if (term.matchAll) {
+        condition = "ALL";
+        break;
+      }
+      condition += (term.booleanAnd) ? "AND (" : "OR (";
+      condition += term.termAsString + ")";
+    }
+    this.searchString = condition;
+  },
+
+  /**
+   * @return the set of search terms that define this virtual folder as a
+   *     string.  You may prefer to use |searchTerms| which converts them
+   *     into a list of nsIMsgSearchTerms instead.
+   */
+  get searchString() {
+    return this.dbFolderInfo.getCharProperty("searchStr");
+  },
+  /**
+   * Set the search that defines this virtual folder from a string.  If you have
+   *  a list of nsIMsgSearchTerms, you should use |searchTerms| instead.
+   */
+  set searchString(aSearchString) {
+    this.dbFolderInfo.setCharProperty("searchStr", aSearchString);
+  },
+
+  /**
+   * @return whether the virtual folder is configured for online search.
+   */
+  get onlineSearch() {
+    return this.dbFolderInfo.getBooleanProperty("searchOnline", false);
+  },
+  /**
+   * Set whether the virtual folder is configured for online search.
+   */
+  set onlineSearch(aOnlineSearch) {
+    this.dbFolderInfo.setBooleanProperty("searchOnline", aOnlineSearch);
+  },
+
+  /**
+   * @return the dBFolderInfo associated with the virtual folder directly.  May
+   *     be null.  Will cause the message database to be opened, which may have
+   *     memory bloat/leak ramifications, so make sure the folder's database was
+   *     already going to be opened anyways or that you call
+   *     |cleanUpMessageDatabase|.
+   */
+  get dbFolderInfo() {
+    let msgDatabase = this.virtualFolder.msgDatabase;
+    return (msgDatabase && msgDatabase.dBFolderInfo);
+  },
+
+  /**
+   * Avoid memory bloat by making the virtual folder forget about its database.
+   *  If the database is actually in use (read: someone is keeping it alive by
+   *  having references to it from places other than the nsIMsgFolder), the
+   *  folder will be able to re-establish the reference for minimal cost.
+   */
+  cleanUpMessageDatabase:
+      function VirtualFolderWrapper_cleanUpMessageDatabase() {
+    this.virtualFolder.msgDatabase.Close(true);
+    this.virtualFolder.msgDatabase = null;
+  }
+};