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

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

1 files changed, 9095 insertions, 0 deletions

diff --git a/comm/mailnews/imap/src/nsImapMailFolder.cpp b/comm/mailnews/imap/src/nsImapMailFolder.cpp
new file mode 100644
index 0000000000..1ec8482383
--- /dev/null
+++ b/comm/mailnews/imap/src/nsImapMailFolder.cpp
@@ -0,0 +1,9095 @@
+/* -*- 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 "nsImapMailFolder.h"
+#include "nsIImapService.h"
+#include "nsIFile.h"
+#include "nsAnonymousTemporaryFile.h"
+#include "nsIUrlListener.h"
+#include "nsCOMPtr.h"
+#include "nsMsgFolderFlags.h"
+#include "nsISeekableStream.h"
+#include "nsThreadUtils.h"
+#include "nsIImapUrl.h"
+#include "nsImapUtils.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgMailSession.h"
+#include "nsITransactionManager.h"
+#include "nsImapUndoTxn.h"
+#include "../public/nsIImapHostSessionList.h"
+#include "nsIMsgCopyService.h"
+#include "nsICopyMessageStreamListener.h"
+#include "nsImapStringBundle.h"
+#include "nsIMsgFolderCacheElement.h"
+#include "nsTextFormatter.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsMsgI18N.h"
+#include "nsIMsgFilter.h"
+#include "nsIMsgFilterService.h"
+#include "nsIMsgSearchCustomTerm.h"
+#include "nsIMsgSearchTerm.h"
+#include "nsImapMoveCoalescer.h"
+#include "nsIPrompt.h"
+#include "nsIDocShell.h"
+#include "nsUnicharUtils.h"
+#include "nsIImapFlagAndUidState.h"
+#include "nsIImapHeaderXferInfo.h"
+#include "nsIMessenger.h"
+#include "nsIMsgSearchAdapter.h"
+#include "nsIImapMockChannel.h"
+#include "nsIProgressEventSink.h"
+#include "nsIMsgWindow.h"
+#include "nsIMsgFolder.h"  // TO include biffState enum. Change to bool later...
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgOfflineImapOperation.h"
+#include "nsImapOfflineSync.h"
+#include "nsIImapMailFolderSink.h"
+#include "nsIImapServerSink.h"
+#include "nsIMsgAccountManager.h"
+#include "nsQuickSort.h"
+#include "nsIImapMockChannel.h"
+#include "nsNetUtil.h"
+#include "nsImapNamespace.h"
+#include "nsIMsgFolderCompactor.h"
+#include "nsMsgMessageFlags.h"
+#include "nsISpamSettings.h"
+#include <time.h>
+#include "nsIMsgMailNewsUrl.h"
+#include "nsEmbedCID.h"
+#include "nsIMsgComposeService.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsIDirectoryEnumerator.h"
+#include "nsIMsgIdentity.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsIExternalProtocolService.h"
+#include "nsCExternalHandlerService.h"
+#include "prprf.h"
+#include "nsAutoSyncManager.h"
+#include "nsIMsgFilterCustomAction.h"
+#include "nsMsgReadStateTxn.h"
+#include "nsStringEnumerator.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsMsgLineBuffer.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/SlicedInputStream.h"
+#include "nsStringStream.h"
+#include "nsIStreamListener.h"
+#include "nsITimer.h"
+#include "nsReadableUtils.h"
+#include "UrlListener.h"
+#include "nsIObserverService.h"
+
+#define NS_PARSEMAILMSGSTATE_CID                   \
+  { /* 2B79AC51-1459-11d3-8097-006008128C4E */     \
+    0x2b79ac51, 0x1459, 0x11d3, {                  \
+      0x80, 0x97, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e \
+    }                                              \
+  }
+static NS_DEFINE_CID(kParseMailMsgStateCID, NS_PARSEMAILMSGSTATE_CID);
+
+#define NS_IIMAPHOSTSESSIONLIST_CID                  \
+  {                                                  \
+    0x479ce8fc, 0xe725, 0x11d2, {                    \
+      0xa5, 0x05, 0x00, 0x60, 0xb0, 0xfc, 0x04, 0xb7 \
+    }                                                \
+  }
+static NS_DEFINE_CID(kCImapHostSessionList, NS_IIMAPHOSTSESSIONLIST_CID);
+
+#define MAILNEWS_CUSTOM_HEADERS "mailnews.customHeaders"
+
+using namespace mozilla;
+
+extern LazyLogModule gAutoSyncLog;  // defined in nsAutoSyncManager.cpp
+extern LazyLogModule IMAP;          // defined in nsImapProtocol.cpp
+extern LazyLogModule IMAP_CS;  // For CONDSTORE, defined in nsImapProtocol.cpp
+extern LazyLogModule FILTERLOGMODULE;  // defined in nsMsgFilterService.cpp
+LazyLogModule IMAP_KW("IMAP_KW");      // for logging keyword (tag) processing
+
+/*
+    Copies the contents of srcDir into destDir.
+    destDir will be created if it doesn't exist.
+*/
+
+static nsresult RecursiveCopy(nsIFile* srcDir, nsIFile* destDir) {
+  bool isDir;
+  nsresult rv = srcDir->IsDirectory(&isDir);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!isDir) return NS_ERROR_INVALID_ARG;
+
+  bool exists;
+  rv = destDir->Exists(&exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!exists) {
+    rv = destDir->Create(nsIFile::DIRECTORY_TYPE, 0775);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCOMPtr<nsIDirectoryEnumerator> dirIterator;
+  rv = srcDir->GetDirectoryEntries(getter_AddRefs(dirIterator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool hasMore = false;
+  while (NS_SUCCEEDED(dirIterator->HasMoreElements(&hasMore)) && hasMore) {
+    nsCOMPtr<nsIFile> dirEntry;
+    rv = dirIterator->GetNextFile(getter_AddRefs(dirEntry));
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!dirEntry) continue;
+    rv = dirEntry->IsDirectory(&isDir);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (isDir) {
+      nsCOMPtr<nsIFile> newChild;
+      rv = destDir->Clone(getter_AddRefs(newChild));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsAutoString leafName;
+      dirEntry->GetLeafName(leafName);
+      newChild->AppendRelativePath(leafName);
+      rv = newChild->Exists(&exists);
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (!exists) {
+        rv = newChild->Create(nsIFile::DIRECTORY_TYPE, 0775);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      rv = RecursiveCopy(dirEntry, newChild);
+    } else {
+      rv = dirEntry->CopyTo(destDir, EmptyString());
+    }
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return rv;
+}
+
+//
+//  nsMsgQuota
+//
+NS_IMPL_ISUPPORTS(nsMsgQuota, nsIMsgQuota)
+
+nsMsgQuota::nsMsgQuota(const nsACString& aName, const uint64_t& aUsage,
+                       const uint64_t& aLimit)
+    : mName(aName), mUsage(aUsage), mLimit(aLimit) {}
+
+nsMsgQuota::~nsMsgQuota() {}
+
+/**
+ * Note: These quota access function are not called but still must be defined
+ * for the linker.
+ */
+NS_IMETHODIMP nsMsgQuota::GetName(nsACString& aName) {
+  aName = mName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgQuota::SetName(const nsACString& aName) {
+  mName = aName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgQuota::GetUsage(uint64_t* aUsage) {
+  *aUsage = mUsage;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgQuota::SetUsage(uint64_t aUsage) {
+  mUsage = aUsage;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgQuota::GetLimit(uint64_t* aLimit) {
+  *aLimit = mLimit;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgQuota::SetLimit(uint64_t aLimit) {
+  mLimit = aLimit;
+  return NS_OK;
+}
+
+//
+//  nsImapMailFolder
+//
+nsImapMailFolder::nsImapMailFolder()
+    : m_initialized(false),
+      m_haveDiscoveredAllFolders(false),
+      m_curMsgUid(0),
+      m_nextMessageByteLength(0),
+      m_urlRunning(false),
+      m_verifiedAsOnlineFolder(false),
+      m_explicitlyVerify(false),
+      m_folderIsNamespace(false),
+      m_folderNeedsSubscribing(false),
+      m_folderNeedsAdded(false),
+      m_folderNeedsACLListed(true),
+      m_performingBiff(false),
+      m_updatingFolder(false),
+      m_applyIncomingFilters(false),
+      m_downloadingFolderForOfflineUse(false),
+      m_filterListRequiresBody(false),
+      m_folderQuotaCommandIssued(false),
+      m_folderQuotaDataIsValid(false) {
+  m_boxFlags = 0;
+  m_uidValidity = kUidUnknown;
+  m_numServerRecentMessages = 0;
+  m_numServerUnseenMessages = 0;
+  m_numServerTotalMessages = 0;
+  m_nextUID = nsMsgKey_None;
+  m_hierarchyDelimiter = kOnlineHierarchySeparatorUnknown;
+  m_folderACL = nullptr;
+  m_aclFlags = 0;
+  m_supportedUserFlags = 0;
+  m_namespace = nullptr;
+  m_pendingPlaybackReq = nullptr;
+}
+
+nsImapMailFolder::~nsImapMailFolder() {
+  delete m_folderACL;
+
+  // cleanup any pending request
+  delete m_pendingPlaybackReq;
+}
+
+NS_IMPL_ADDREF_INHERITED(nsImapMailFolder, nsMsgDBFolder)
+NS_IMPL_RELEASE_INHERITED(nsImapMailFolder, nsMsgDBFolder)
+NS_IMPL_QUERY_HEAD(nsImapMailFolder)
+NS_IMPL_QUERY_BODY(nsIMsgImapMailFolder)
+NS_IMPL_QUERY_BODY(nsICopyMessageListener)
+NS_IMPL_QUERY_BODY(nsIImapMailFolderSink)
+NS_IMPL_QUERY_BODY(nsIImapMessageSink)
+NS_IMPL_QUERY_BODY(nsIUrlListener)
+NS_IMPL_QUERY_BODY(nsIMsgFilterHitNotify)
+NS_IMPL_QUERY_TAIL_INHERITING(nsMsgDBFolder)
+
+nsresult nsImapMailFolder::AddDirectorySeparator(nsIFile* path) {
+  if (mURI.Equals(kImapRootURI)) {
+    // don't concat the full separator with .sbd
+  } else {
+    // see if there's a dir with the same name ending with .sbd
+    nsAutoString leafName;
+    path->GetLeafName(leafName);
+    leafName.AppendLiteral(FOLDER_SUFFIX);
+    path->SetLeafName(leafName);
+  }
+
+  return NS_OK;
+}
+
+static bool nsShouldIgnoreFile(nsString& name) {
+  if (StringEndsWith(name, NS_LITERAL_STRING_FROM_CSTRING(SUMMARY_SUFFIX),
+                     nsCaseInsensitiveStringComparator)) {
+    name.SetLength(name.Length() -
+                   SUMMARY_SUFFIX_LENGTH);  // truncate the string
+    return false;
+  }
+  return true;
+}
+
+nsresult nsImapMailFolder::CreateChildFromURI(const nsACString& uri,
+                                              nsIMsgFolder** folder) {
+  nsImapMailFolder* newFolder = new nsImapMailFolder;
+  newFolder->Init(uri);
+  NS_ADDREF(*folder = newFolder);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::AddSubfolder(const nsAString& aName,
+                                             nsIMsgFolder** aChild) {
+  NS_ENSURE_ARG_POINTER(aChild);
+
+  int32_t flags = 0;
+  nsresult rv;
+
+  nsAutoCString uri(mURI);
+  uri.Append('/');
+
+  nsAutoCString escapedName;
+  rv = NS_MsgEscapeEncodeURLPath(aName, escapedName);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uri += escapedName.get();
+
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  rv = GetChildWithURI(uri, false /*deep*/, true /*case Insensitive*/,
+                       getter_AddRefs(msgFolder));
+  if (NS_SUCCEEDED(rv) && msgFolder) return NS_MSG_FOLDER_EXISTS;
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  rv = GetOrCreateFolder(uri, getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
+
+  // Ensure the containing dir exists.
+  nsCOMPtr<nsIFile> path;
+  rv = CreateDirectoryForFolder(getter_AddRefs(path));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  folder->GetFlags((uint32_t*)&flags);
+
+  flags |= nsMsgFolderFlags::Mail;
+
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  GetImapIncomingServer(getter_AddRefs(imapServer));
+  if (imapServer) {
+    bool setNewFoldersForOffline = false;
+    rv = imapServer->GetOfflineDownload(&setNewFoldersForOffline);
+    if (NS_SUCCEEDED(rv) && setNewFoldersForOffline)
+      flags |= nsMsgFolderFlags::Offline;
+  }
+
+  folder->SetParent(this);
+
+  folder->SetFlags(flags);
+
+  mSubFolders.AppendObject(folder);
+  folder.forget(aChild);
+
+  // New child needs to inherit hierarchyDelimiter.
+  nsCOMPtr<nsIMsgImapMailFolder> imapChild = do_QueryInterface(*aChild);
+  if (imapChild) {
+    imapChild->SetHierarchyDelimiter(m_hierarchyDelimiter);
+  }
+  NotifyFolderAdded(*aChild);
+  return rv;
+}
+
+// Creates a new child nsIMsgFolder locally, with no IMAP traffic.
+nsresult nsImapMailFolder::AddSubfolderWithPath(nsAString& name,
+                                                nsIFile* dbPath,
+                                                nsIMsgFolder** child,
+                                                bool brandNew) {
+  NS_ENSURE_ARG_POINTER(child);
+  nsresult rv;
+
+  nsAutoCString uri(mURI);
+  uri.Append('/');
+  AppendUTF16toUTF8(name, uri);
+
+  bool isServer;
+  rv = GetIsServer(&isServer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool isInbox = isServer && name.LowerCaseEqualsLiteral("inbox");
+
+  // will make sure mSubFolders does not have duplicates because of bogus msf
+  // files.
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  rv = GetChildWithURI(uri, false /*deep*/, isInbox /*case Insensitive*/,
+                       getter_AddRefs(msgFolder));
+  if (NS_SUCCEEDED(rv) && msgFolder) return NS_MSG_FOLDER_EXISTS;
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  rv = GetOrCreateFolder(uri, getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  folder->SetFilePath(dbPath);
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(folder, &rv);
+  mozilla::Unused << imapFolder;
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t flags = 0;
+  folder->GetFlags(&flags);
+
+  folder->SetParent(this);
+  flags |= nsMsgFolderFlags::Mail;
+
+  uint32_t pFlags;
+  GetFlags(&pFlags);
+  bool isParentInbox = pFlags & nsMsgFolderFlags::Inbox;
+
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Only set these if these are top level children or parent is inbox
+  if (isInbox)
+    flags |= nsMsgFolderFlags::Inbox;
+  else if (isServer || isParentInbox) {
+    nsMsgImapDeleteModel deleteModel;
+    imapServer->GetDeleteModel(&deleteModel);
+    if (deleteModel == nsMsgImapDeleteModels::MoveToTrash) {
+      nsAutoString trashName;
+      GetTrashFolderName(trashName);
+      if (name.Equals(trashName)) flags |= nsMsgFolderFlags::Trash;
+    }
+  }
+
+  // Make the folder offline if it is newly created and the offline_download
+  // pref is true, unless it's the Trash or Junk folder.
+  if (brandNew &&
+      !(flags & (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Junk))) {
+    bool setNewFoldersForOffline = false;
+    rv = imapServer->GetOfflineDownload(&setNewFoldersForOffline);
+    if (NS_SUCCEEDED(rv) && setNewFoldersForOffline)
+      flags |= nsMsgFolderFlags::Offline;
+  }
+
+  folder->SetFlags(flags);
+
+  if (folder) mSubFolders.AppendObject(folder);
+  folder.forget(child);
+  return NS_OK;
+}
+
+// Create child nsIMsgFolders by scanning the filesystem to find .msf files.
+// No IMAP traffic.
+nsresult nsImapMailFolder::CreateSubFolders(nsIFile* path) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDirectoryEnumerator> directoryEnumerator;
+  rv = path->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // For each .msf file in the directory...
+  bool hasMore = false;
+  while (NS_SUCCEEDED(directoryEnumerator->HasMoreElements(&hasMore)) &&
+         hasMore) {
+    nsCOMPtr<nsIFile> currentFolderPath;
+    rv = directoryEnumerator->GetNextFile(getter_AddRefs(currentFolderPath));
+    if (NS_FAILED(rv) || !currentFolderPath) continue;
+
+    nsAutoString currentFolderNameStr;    // online name
+    nsAutoString currentFolderDBNameStr;  // possibly munged name
+    currentFolderPath->GetLeafName(currentFolderNameStr);
+    // Skip if not an .msf file.
+    // (NOTE: nsShouldIgnoreFile() strips the trailing ".msf" here)
+    if (nsShouldIgnoreFile(currentFolderNameStr)) continue;
+
+    // OK, here we need to get the online name from the folder cache if we can.
+    // If we can, use that to create the sub-folder
+    nsCOMPtr<nsIFile> curFolder =
+        do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIFile> dbFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    dbFile->InitWithFile(currentFolderPath);
+    curFolder->InitWithFile(currentFolderPath);
+    // don't strip off the .msf in currentFolderPath.
+    currentFolderPath->SetLeafName(currentFolderNameStr);
+    currentFolderDBNameStr = currentFolderNameStr;
+    nsAutoString utfLeafName = currentFolderNameStr;
+
+    if (curFolder) {
+      nsCOMPtr<nsIMsgFolderCacheElement> cacheElement;
+      rv = GetFolderCacheElemFromFile(dbFile, getter_AddRefs(cacheElement));
+      if (NS_SUCCEEDED(rv) && cacheElement) {
+        nsCString onlineFullUtfName;
+
+        uint32_t folderFlags;
+        rv = cacheElement->GetCachedUInt32("flags", &folderFlags);
+        if (NS_SUCCEEDED(rv) &&
+            folderFlags & nsMsgFolderFlags::Virtual)  // ignore virtual folders
+          continue;
+        int32_t hierarchyDelimiter;
+        rv = cacheElement->GetCachedInt32("hierDelim", &hierarchyDelimiter);
+        if (NS_SUCCEEDED(rv) &&
+            hierarchyDelimiter == kOnlineHierarchySeparatorUnknown) {
+          currentFolderPath->Remove(false);
+          continue;  // blow away .msf files for folders with unknown delimiter.
+        }
+        rv = cacheElement->GetCachedString("onlineName", onlineFullUtfName);
+        if (NS_SUCCEEDED(rv) && !onlineFullUtfName.IsEmpty()) {
+          CopyFolderNameToUTF16(onlineFullUtfName, currentFolderNameStr);
+          char delimiter = 0;
+          GetHierarchyDelimiter(&delimiter);
+          int32_t leafPos = currentFolderNameStr.RFindChar(delimiter);
+          if (leafPos > 0) currentFolderNameStr.Cut(0, leafPos + 1);
+
+          // Take the full online name, and determine the leaf name.
+          CopyUTF8toUTF16(onlineFullUtfName, utfLeafName);
+          leafPos = utfLeafName.RFindChar(delimiter);
+          if (leafPos > 0) utfLeafName.Cut(0, leafPos + 1);
+        }
+      }
+    }
+    // make the imap folder remember the file spec it was created with.
+    nsCOMPtr<nsIFile> msfFilePath =
+        do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    msfFilePath->InitWithFile(currentFolderPath);
+    if (NS_SUCCEEDED(rv) && msfFilePath) {
+      // leaf name is the db name w/o .msf (nsShouldIgnoreFile strips it off)
+      // so this trims the .msf off the file spec.
+      msfFilePath->SetLeafName(currentFolderDBNameStr);
+    }
+    // Use the name as the uri for the folder.
+    nsCOMPtr<nsIMsgFolder> child;
+    AddSubfolderWithPath(utfLeafName, msfFilePath, getter_AddRefs(child));
+    if (child) {
+      // use the unicode name as the "pretty" name. Set it so it won't be
+      // automatically computed from the URI.
+      if (!currentFolderNameStr.IsEmpty())
+        child->SetPrettyName(currentFolderNameStr);
+      child->SetMsgDatabase(nullptr);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetSubFolders(
+    nsTArray<RefPtr<nsIMsgFolder>>& folders) {
+  bool isServer;
+  nsresult rv = GetIsServer(&isServer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!m_initialized) {
+    nsCOMPtr<nsIFile> pathFile;
+    rv = GetFilePath(getter_AddRefs(pathFile));
+    if (NS_FAILED(rv)) return rv;
+
+    // host directory does not need .sbd tacked on
+    if (!isServer) {
+      rv = AddDirectorySeparator(pathFile);
+      if (NS_FAILED(rv)) return rv;
+    }
+
+    m_initialized = true;  // need to set this here to avoid infinite recursion
+                           // from CreateSubfolders.
+    // we have to treat the root folder specially, because it's name
+    // doesn't end with .sbd
+
+    int32_t newFlags = nsMsgFolderFlags::Mail;
+    bool isDirectory = false;
+    pathFile->IsDirectory(&isDirectory);
+    if (isDirectory) {
+      newFlags |= (nsMsgFolderFlags::Directory | nsMsgFolderFlags::Elided);
+      if (!mIsServer) SetFlag(newFlags);
+      rv = CreateSubFolders(pathFile);
+    }
+    if (isServer) {
+      nsCOMPtr<nsIMsgFolder> inboxFolder;
+
+      GetFolderWithFlags(nsMsgFolderFlags::Inbox, getter_AddRefs(inboxFolder));
+      if (!inboxFolder) {
+        // create an inbox if we don't have one.
+        CreateClientSubfolderInfo("INBOX"_ns, kOnlineHierarchySeparatorUnknown,
+                                  0, true);
+      }
+    }
+
+    // Force initialisation recursively.
+    for (nsIMsgFolder* f : mSubFolders) {
+      nsTArray<RefPtr<nsIMsgFolder>> dummy;
+      rv = f->GetSubFolders(dummy);
+      if (NS_FAILED(rv)) {
+        break;
+      }
+    }
+
+    UpdateSummaryTotals(false);
+    if (NS_FAILED(rv)) return rv;
+  }
+
+  return nsMsgDBFolder::GetSubFolders(folders);
+}
+
+// Makes sure the database is open and exists.  If the database is valid then
+// returns NS_OK.  Otherwise returns a failure error value.
+nsresult nsImapMailFolder::GetDatabase() {
+  nsresult rv = NS_OK;
+  if (!mDatabase) {
+    nsCOMPtr<nsIMsgDBService> msgDBService =
+        do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Create the database, blowing it away if it needs to be rebuilt
+    rv = msgDBService->OpenFolderDB(this, false, getter_AddRefs(mDatabase));
+    if (NS_FAILED(rv))
+      rv = msgDBService->CreateNewDB(this, getter_AddRefs(mDatabase));
+
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // UpdateNewMessages/UpdateSummaryTotals can null mDatabase, so we save a
+    // local copy
+    nsCOMPtr<nsIMsgDatabase> database(mDatabase);
+    UpdateNewMessages();
+    if (mAddListener) database->AddListener(this);
+    UpdateSummaryTotals(true);
+    mDatabase = database;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::UpdateFolder(nsIMsgWindow* inMsgWindow) {
+  return UpdateFolderWithListener(inMsgWindow, nullptr);
+}
+
+NS_IMETHODIMP nsImapMailFolder::UpdateFolderWithListener(
+    nsIMsgWindow* aMsgWindow, nsIUrlListener* aUrlListener) {
+  nsresult rv;
+  // If this is the inbox, filters will be applied. Otherwise, we test the
+  // inherited folder property "applyIncomingFilters" (which defaults to empty).
+  // If this inherited property has the string value "true", we will apply
+  // filters even if this is not the inbox folder.
+  nsCString applyIncomingFilters;
+  GetInheritedStringProperty("applyIncomingFilters", applyIncomingFilters);
+  m_applyIncomingFilters = applyIncomingFilters.EqualsLiteral("true");
+
+  nsString folderName;
+  GetPrettyName(folderName);
+  MOZ_LOG(FILTERLOGMODULE, LogLevel::Debug,
+          ("(Imap) nsImapMailFolder::UpdateFolderWithListener() on folder '%s'",
+           NS_ConvertUTF16toUTF8(folderName).get()));
+  if (mFlags & nsMsgFolderFlags::Inbox || m_applyIncomingFilters) {
+    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+            ("(Imap) Preparing filter run on folder '%s'",
+             NS_ConvertUTF16toUTF8(folderName).get()));
+
+    if (!m_filterList) {
+      rv = GetFilterList(aMsgWindow, getter_AddRefs(m_filterList));
+      if (NS_FAILED(rv)) {
+        MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
+                ("(Imap) Loading of filter list failed"));
+      }
+    }
+
+    // if there's no msg window, but someone is updating the inbox, we're
+    // doing something biff-like, and may download headers, so make biff notify.
+    if (!aMsgWindow && mFlags & nsMsgFolderFlags::Inbox)
+      SetPerformingBiff(true);
+  }
+
+  if (m_filterList) {
+    nsCString listId;
+    m_filterList->GetListId(listId);
+    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+            ("(Imap) Preparing filter list %s", listId.get()));
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    rv = GetServer(getter_AddRefs(server));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    bool canFileMessagesOnServer = true;
+    rv = server->GetCanFileMessagesOnServer(&canFileMessagesOnServer);
+    // the mdn filter is for filing return receipts into the sent folder
+    // some servers (like AOL mail servers)
+    // can't file to the sent folder, so we don't add the filter for those
+    // servers
+    if (canFileMessagesOnServer) {
+      rv = server->ConfigureTemporaryFilters(m_filterList);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    // If a body filter is enabled for an offline folder, delay the filter
+    // application until after message has been downloaded.
+    m_filterListRequiresBody = false;
+
+    if (mFlags & nsMsgFolderFlags::Offline) {
+      nsCOMPtr<nsIMsgFilterService> filterService =
+          do_GetService("@mozilla.org/messenger/services/filters;1", &rv);
+      uint32_t filterCount = 0;
+      m_filterList->GetFilterCount(&filterCount);
+      for (uint32_t index = 0; index < filterCount && !m_filterListRequiresBody;
+           ++index) {
+        nsCOMPtr<nsIMsgFilter> filter;
+        m_filterList->GetFilterAt(index, getter_AddRefs(filter));
+        if (!filter) continue;
+        nsMsgFilterTypeType filterType;
+        filter->GetFilterType(&filterType);
+        if (!(filterType & nsMsgFilterType::Incoming)) continue;
+        bool enabled = false;
+        filter->GetEnabled(&enabled);
+        if (!enabled) continue;
+        nsTArray<RefPtr<nsIMsgSearchTerm>> searchTerms;
+        filter->GetSearchTerms(searchTerms);
+        for (nsIMsgSearchTerm* term : searchTerms) {
+          nsMsgSearchAttribValue attrib;
+          rv = term->GetAttrib(&attrib);
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (attrib == nsMsgSearchAttrib::Body)
+            m_filterListRequiresBody = true;
+          else if (attrib == nsMsgSearchAttrib::Custom) {
+            nsAutoCString customId;
+            rv = term->GetCustomId(customId);
+            nsCOMPtr<nsIMsgSearchCustomTerm> customTerm;
+            if (NS_SUCCEEDED(rv) && filterService)
+              rv = filterService->GetCustomTerm(customId,
+                                                getter_AddRefs(customTerm));
+            bool needsBody = false;
+            if (NS_SUCCEEDED(rv) && customTerm)
+              rv = customTerm->GetNeedsBody(&needsBody);
+            if (NS_SUCCEEDED(rv) && needsBody) m_filterListRequiresBody = true;
+          }
+          if (m_filterListRequiresBody) {
+            break;
+          }
+        }
+
+        // Also check if filter actions need the body, as this
+        // is supported in custom actions.
+        uint32_t numActions = 0;
+        filter->GetActionCount(&numActions);
+        for (uint32_t actionIndex = 0;
+             actionIndex < numActions && !m_filterListRequiresBody;
+             actionIndex++) {
+          nsCOMPtr<nsIMsgRuleAction> action;
+          rv = filter->GetActionAt(actionIndex, getter_AddRefs(action));
+          if (NS_FAILED(rv) || !action) continue;
+
+          nsCOMPtr<nsIMsgFilterCustomAction> customAction;
+          rv = action->GetCustomAction(getter_AddRefs(customAction));
+          if (NS_FAILED(rv) || !customAction) continue;
+
+          bool needsBody = false;
+          customAction->GetNeedsBody(&needsBody);
+          if (needsBody) m_filterListRequiresBody = true;
+        }
+      }
+    }
+    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+            ("(Imap) Filters require the message body: %s",
+             (m_filterListRequiresBody ? "true" : "false")));
+  }
+
+  bool isServer;
+  rv = GetIsServer(&isServer);
+  if (NS_SUCCEEDED(rv) && isServer) {
+    if (!m_haveDiscoveredAllFolders) {
+      bool hasSubFolders = false;
+      GetHasSubFolders(&hasSubFolders);
+      if (!hasSubFolders) {
+        rv = CreateClientSubfolderInfo(
+            "Inbox"_ns, kOnlineHierarchySeparatorUnknown, 0, false);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      m_haveDiscoveredAllFolders = true;
+    }
+  }
+
+  rv = GetDatabase();
+  if (NS_FAILED(rv)) {
+    ThrowAlertMsg("errorGettingDB", aMsgWindow);
+    return rv;
+  }
+
+  bool hasOfflineEvents = false;
+  GetFlag(nsMsgFolderFlags::OfflineEvents, &hasOfflineEvents);
+
+  if (!WeAreOffline()) {
+    if (hasOfflineEvents) {
+      // hold a reference to the offline sync object. If ProcessNextOperation
+      // runs a url, a reference will be added to it. Otherwise, it will get
+      // destroyed when the refptr goes out of scope.
+      RefPtr<nsImapOfflineSync> goOnline = new nsImapOfflineSync();
+      goOnline->Init(aMsgWindow, this, this, false);
+      if (goOnline) {
+        m_urlListener = aUrlListener;
+        return goOnline->ProcessNextOperation();
+      }
+    }
+  }
+
+  // Check it we're password protecting the local store.
+  if (!PromptForMasterPasswordIfNecessary()) return NS_ERROR_FAILURE;
+
+  bool canOpenThisFolder = true;
+  GetCanOpenFolder(&canOpenThisFolder);
+  // Don't run select if we can't select the folder...
+  if (!m_urlRunning && canOpenThisFolder && !isServer) {
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    /* Do a discovery in its own url if needed. Do before SELECT url. */
+    nsCOMPtr<nsIImapHostSessionList> hostSession =
+        do_GetService(kCImapHostSessionList, &rv);
+    if (NS_SUCCEEDED(rv) && hostSession) {
+      bool foundMailboxesAlready = false;
+      nsCString serverKey;
+      GetServerKey(serverKey);
+      hostSession->GetHaveWeEverDiscoveredFoldersForHost(serverKey.get(),
+                                                         foundMailboxesAlready);
+      if (!foundMailboxesAlready) {
+        bool discoveryInProgress = false;
+        // See if discovery in progress and not yet finished.
+        hostSession->GetDiscoveryForHostInProgress(serverKey.get(),
+                                                   discoveryInProgress);
+        if (!discoveryInProgress) {
+          nsCOMPtr<nsIMsgFolder> rootFolder;
+          rv = GetRootFolder(getter_AddRefs(rootFolder));
+          if (NS_SUCCEEDED(rv) && rootFolder) {
+            rv = imapService->DiscoverAllFolders(rootFolder, this, aMsgWindow);
+            if (NS_SUCCEEDED(rv))
+              hostSession->SetDiscoveryForHostInProgress(serverKey.get(), true);
+          }
+        }
+      }
+    }
+
+    nsCOMPtr<nsIURI> url;
+    rv = imapService->SelectFolder(this, m_urlListener, aMsgWindow,
+                                   getter_AddRefs(url));
+    if (NS_SUCCEEDED(rv)) {
+      m_urlRunning = true;
+      m_updatingFolder = true;
+    }
+    if (url) {
+      nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(url, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      mailnewsUrl->RegisterListener(this);
+      m_urlListener = aUrlListener;
+    }
+
+    // Allow IMAP folder auto-compact to occur when online or offline.
+    if (aMsgWindow) AutoCompact(aMsgWindow);
+
+    if (rv == NS_MSG_ERROR_OFFLINE || rv == NS_BINDING_ABORTED) {
+      rv = NS_OK;
+      NotifyFolderEvent(kFolderLoaded);
+    }
+  } else {
+    // Tell the front end that the folder is loaded if we're not going to
+    // actually run a url.
+    if (!m_updatingFolder)  // if we're already running an update url, we'll let
+                            // that one send the folder loaded
+      NotifyFolderEvent(kFolderLoaded);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::CreateSubfolder(const nsAString& folderName,
+                                                nsIMsgWindow* msgWindow) {
+  if (folderName.IsEmpty()) return NS_MSG_ERROR_INVALID_FOLDER_NAME;
+
+  nsresult rv;
+  nsAutoString trashName;
+  GetTrashFolderName(trashName);
+  if (folderName.Equals(trashName))  // Trash , a special folder
+  {
+    ThrowAlertMsg("folderExists", msgWindow);
+    return NS_MSG_FOLDER_EXISTS;
+  }
+  if (mIsServer &&
+      folderName.LowerCaseEqualsLiteral("inbox"))  // Inbox, a special folder
+  {
+    ThrowAlertMsg("folderExists", msgWindow);
+    return NS_MSG_FOLDER_EXISTS;
+  }
+
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIURI> url;
+  return imapService->CreateFolder(this, folderName, this, getter_AddRefs(url));
+}
+
+NS_IMETHODIMP nsImapMailFolder::CreateClientSubfolderInfo(
+    const nsACString& folderName, char hierarchyDelimiter, int32_t flags,
+    bool suppressNotification) {
+  nsresult rv = NS_OK;
+
+  // Get a directory based on our current path.
+  nsCOMPtr<nsIFile> path;
+  rv = CreateDirectoryForFolder(getter_AddRefs(path));
+  if (NS_FAILED(rv)) return rv;
+
+  NS_ConvertUTF8toUTF16 leafName(folderName);
+  nsAutoString folderNameStr;
+  nsAutoString parentName = leafName;
+  // use RFind, because folder can start with a delimiter and
+  // not be a leaf folder.
+  int32_t folderStart = leafName.RFindChar('/');
+  if (folderStart > 0) {
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder;
+    nsAutoCString uri(mURI);
+    leafName.Assign(Substring(parentName, folderStart + 1));
+    parentName.SetLength(folderStart);
+
+    rv = CreateDirectoryForFolder(getter_AddRefs(path));
+    NS_ENSURE_SUCCESS(rv, rv);
+    uri.Append('/');
+    uri.Append(NS_ConvertUTF16toUTF8(parentName));
+    nsCOMPtr<nsIMsgFolder> folder;
+    rv = GetOrCreateFolder(uri, getter_AddRefs(folder));
+    NS_ENSURE_SUCCESS(rv, rv);
+    imapFolder = do_QueryInterface(folder, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoCString leafnameC;
+    CopyUTF16toUTF8(leafName, leafnameC);
+    return imapFolder->CreateClientSubfolderInfo(leafnameC, hierarchyDelimiter,
+                                                 flags, suppressNotification);
+  }
+
+  // if we get here, it's really a leaf, and "this" is the parent.
+  folderNameStr = leafName;
+
+  // Create an empty database for this mail folder, set its name from the user
+  nsCOMPtr<nsIMsgDatabase> mailDBFactory;
+  nsCOMPtr<nsIMsgFolder> child;
+
+  nsCOMPtr<nsIMsgDBService> msgDBService =
+      do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgDatabase> unusedDB;
+  nsCOMPtr<nsIFile> dbFile;
+
+  // warning, path will be changed
+  rv = CreateFileForDB(folderNameStr, path, getter_AddRefs(dbFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Now let's create the actual new folder
+  rv = AddSubfolderWithPath(folderNameStr, dbFile, getter_AddRefs(child), true);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = msgDBService->OpenMailDBFromFile(dbFile, child, true, true,
+                                        getter_AddRefs(unusedDB));
+  if (rv == NS_MSG_ERROR_FOLDER_SUMMARY_MISSING) rv = NS_OK;
+
+  if (NS_SUCCEEDED(rv) && unusedDB) {
+    // need to set the folder name
+    nsCOMPtr<nsIDBFolderInfo> folderInfo;
+    rv = unusedDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(child, &rv);
+    if (NS_SUCCEEDED(rv)) {
+      nsAutoCString onlineName(m_onlineFolderName);
+      if (!onlineName.IsEmpty()) onlineName.Append(hierarchyDelimiter);
+      onlineName.Append(NS_ConvertUTF16toUTF8(folderNameStr));
+      imapFolder->SetVerifiedAsOnlineFolder(true);
+      imapFolder->SetOnlineName(onlineName);
+      imapFolder->SetHierarchyDelimiter(hierarchyDelimiter);
+      imapFolder->SetBoxFlags(flags);
+
+      // Now that the child is created and the boxflags are set we can be sure
+      // all special folder flags are known. The child may get its flags already
+      // in AddSubfolderWithPath if they were in FolderCache, but that's
+      // not always the case.
+      uint32_t flags = 0;
+      child->GetFlags(&flags);
+
+      // Set the offline use flag for the newly created folder if the
+      // offline_download preference is true, unless it's the Trash or Junk
+      // folder.
+      if (!(flags & (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Junk))) {
+        nsCOMPtr<nsIImapIncomingServer> imapServer;
+        rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+        NS_ENSURE_SUCCESS(rv, rv);
+        bool setNewFoldersForOffline = false;
+        rv = imapServer->GetOfflineDownload(&setNewFoldersForOffline);
+        if (NS_SUCCEEDED(rv) && setNewFoldersForOffline)
+          flags |= nsMsgFolderFlags::Offline;
+      } else {
+        flags &= ~nsMsgFolderFlags::Offline;  // clear offline flag if set
+      }
+
+      flags |= nsMsgFolderFlags::Elided;
+      child->SetFlags(flags);
+
+      nsString unicodeName;
+      rv = CopyFolderNameToUTF16(nsCString(folderName), unicodeName);
+      if (NS_SUCCEEDED(rv)) child->SetPrettyName(unicodeName);
+
+      // store the online name as the mailbox name in the db folder info
+      // I don't think anyone uses the mailbox name, so we'll use it
+      // to restore the online name when blowing away an imap db.
+      if (folderInfo)
+        folderInfo->SetMailboxName(NS_ConvertUTF8toUTF16(onlineName));
+    }
+
+    unusedDB->SetSummaryValid(true);
+    unusedDB->Commit(nsMsgDBCommitType::kLargeCommit);
+    unusedDB->Close(true);
+    // don't want to hold onto this newly created db.
+    child->SetMsgDatabase(nullptr);
+  }
+
+  if (!suppressNotification) {
+    if (NS_SUCCEEDED(rv) && child) {
+      NotifyFolderAdded(child);
+      child->NotifyFolderEvent(kFolderCreateCompleted);
+      nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+          do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+      if (notifier) notifier->NotifyFolderAdded(child);
+    } else {
+      NotifyFolderEvent(kFolderCreateFailed);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::List() {
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return imapService->ListFolder(this, this);
+}
+
+NS_IMETHODIMP nsImapMailFolder::RemoveLocalSelf() {
+  // Kill the local folder and its storage.
+  return nsMsgDBFolder::DeleteSelf(nullptr);
+}
+
+NS_IMETHODIMP nsImapMailFolder::CreateStorageIfMissing(
+    nsIUrlListener* urlListener) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMsgFolder> msgParent;
+  GetParent(getter_AddRefs(msgParent));
+
+  // parent is probably not set because *this* was probably created by rdf
+  // and not by folder discovery. So, we have to compute the parent.
+  if (!msgParent) {
+    nsAutoCString folderName(mURI);
+
+    int32_t leafPos = folderName.RFindChar('/');
+    nsAutoCString parentName(folderName);
+
+    if (leafPos > 0) {
+      // If there is a hierarchy, there is a parent.
+      // Don't strip off slash if it's the first character
+      parentName.SetLength(leafPos);
+      rv = GetOrCreateFolder(parentName, getter_AddRefs(msgParent));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  if (msgParent) {
+    nsString folderName;
+    GetName(folderName);
+    nsresult rv;
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    imapService->EnsureFolderExists(msgParent, folderName, nullptr,
+                                    urlListener);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetVerifiedAsOnlineFolder(
+    bool* aVerifiedAsOnlineFolder) {
+  NS_ENSURE_ARG_POINTER(aVerifiedAsOnlineFolder);
+  *aVerifiedAsOnlineFolder = m_verifiedAsOnlineFolder;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetVerifiedAsOnlineFolder(
+    bool aVerifiedAsOnlineFolder) {
+  m_verifiedAsOnlineFolder = aVerifiedAsOnlineFolder;
+  // mark ancestors as verified as well
+  if (aVerifiedAsOnlineFolder) {
+    nsCOMPtr<nsIMsgFolder> parent;
+    do {
+      GetParent(getter_AddRefs(parent));
+      if (parent) {
+        nsCOMPtr<nsIMsgImapMailFolder> imapParent = do_QueryInterface(parent);
+        if (imapParent) {
+          bool verifiedOnline;
+          imapParent->GetVerifiedAsOnlineFolder(&verifiedOnline);
+          if (verifiedOnline) break;
+          imapParent->SetVerifiedAsOnlineFolder(true);
+        }
+      }
+    } while (parent);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetOnlineDelimiter(char* onlineDelimiter) {
+  return GetHierarchyDelimiter(onlineDelimiter);
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetHierarchyDelimiter(
+    char aHierarchyDelimiter) {
+  m_hierarchyDelimiter = aHierarchyDelimiter;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetHierarchyDelimiter(
+    char* aHierarchyDelimiter) {
+  NS_ENSURE_ARG_POINTER(aHierarchyDelimiter);
+  if (mIsServer) {
+    // if it's the root folder, we don't know the delimiter. So look at the
+    // first child.
+    int32_t count = mSubFolders.Count();
+    if (count > 0) {
+      nsCOMPtr<nsIMsgImapMailFolder> childFolder(
+          do_QueryInterface(mSubFolders[0]));
+      if (childFolder) {
+        nsresult rv = childFolder->GetHierarchyDelimiter(aHierarchyDelimiter);
+        // some code uses m_hierarchyDelimiter directly, so we should set it.
+        m_hierarchyDelimiter = *aHierarchyDelimiter;
+        return rv;
+      }
+    }
+  }
+  ReadDBFolderInfo(false);  // update cache first.
+  *aHierarchyDelimiter = m_hierarchyDelimiter;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetBoxFlags(int32_t aBoxFlags) {
+  ReadDBFolderInfo(false);
+
+  m_boxFlags = aBoxFlags;
+  uint32_t newFlags = mFlags;
+
+  newFlags |= nsMsgFolderFlags::ImapBox;
+
+  if (m_boxFlags & kNoinferiors)
+    newFlags |= nsMsgFolderFlags::ImapNoinferiors;
+  else
+    newFlags &= ~nsMsgFolderFlags::ImapNoinferiors;
+  if (m_boxFlags & kNoselect)
+    newFlags |= nsMsgFolderFlags::ImapNoselect;
+  else
+    newFlags &= ~nsMsgFolderFlags::ImapNoselect;
+  if (m_boxFlags & kPublicMailbox)
+    newFlags |= nsMsgFolderFlags::ImapPublic;
+  else
+    newFlags &= ~nsMsgFolderFlags::ImapPublic;
+  if (m_boxFlags & kOtherUsersMailbox)
+    newFlags |= nsMsgFolderFlags::ImapOtherUser;
+  else
+    newFlags &= ~nsMsgFolderFlags::ImapOtherUser;
+  if (m_boxFlags & kPersonalMailbox)
+    newFlags |= nsMsgFolderFlags::ImapPersonal;
+  else
+    newFlags &= ~nsMsgFolderFlags::ImapPersonal;
+
+  // The following are all flags returned by XLIST.
+  // nsImapIncomingServer::DiscoveryDone checks for these folders.
+  if (m_boxFlags & kImapDrafts) newFlags |= nsMsgFolderFlags::Drafts;
+
+  if (m_boxFlags & kImapSpam) newFlags |= nsMsgFolderFlags::Junk;
+
+  if (m_boxFlags & kImapSent) newFlags |= nsMsgFolderFlags::SentMail;
+
+  if (m_boxFlags & kImapInbox) newFlags |= nsMsgFolderFlags::Inbox;
+
+  if (m_boxFlags & kImapXListTrash) {
+    nsCOMPtr<nsIImapIncomingServer> imapServer;
+    nsMsgImapDeleteModel deleteModel = nsMsgImapDeleteModels::MoveToTrash;
+    (void)GetImapIncomingServer(getter_AddRefs(imapServer));
+    if (imapServer) imapServer->GetDeleteModel(&deleteModel);
+    if (deleteModel == nsMsgImapDeleteModels::MoveToTrash)
+      newFlags |= nsMsgFolderFlags::Trash;
+  }
+  // Treat the GMail all mail folder as the archive folder.
+  if (m_boxFlags & (kImapAllMail | kImapArchive))
+    newFlags |= nsMsgFolderFlags::Archive;
+
+  SetFlags(newFlags);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetBoxFlags(int32_t* aBoxFlags) {
+  NS_ENSURE_ARG_POINTER(aBoxFlags);
+  *aBoxFlags = m_boxFlags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetExplicitlyVerify(bool* aExplicitlyVerify) {
+  NS_ENSURE_ARG_POINTER(aExplicitlyVerify);
+  *aExplicitlyVerify = m_explicitlyVerify;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetExplicitlyVerify(bool aExplicitlyVerify) {
+  m_explicitlyVerify = aExplicitlyVerify;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetNoSelect(bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  return GetFlag(nsMsgFolderFlags::ImapNoselect, aResult);
+}
+
+NS_IMETHODIMP nsImapMailFolder::ApplyRetentionSettings() {
+  int32_t numDaysToKeepOfflineMsgs = -1;
+
+  // Check if we've limited the offline storage by age.
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  nsresult rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+  NS_ENSURE_SUCCESS(rv, rv);
+  imapServer->GetAutoSyncMaxAgeDays(&numDaysToKeepOfflineMsgs);
+
+  nsCOMPtr<nsIMsgDatabase> holdDBOpen;
+  if (numDaysToKeepOfflineMsgs > 0) {
+    bool dbWasCached = mDatabase != nullptr;
+    rv = GetDatabase();
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIMsgEnumerator> hdrs;
+    rv = mDatabase->EnumerateMessages(getter_AddRefs(hdrs));
+    NS_ENSURE_SUCCESS(rv, rv);
+    bool hasMore = false;
+
+    PRTime cutOffDay =
+        MsgConvertAgeInDaysToCutoffDate(numDaysToKeepOfflineMsgs);
+
+    // so now cutOffDay is the PRTime cut-off point. Any offline msg with
+    // a date less than that will get marked for pending removal.
+    while (NS_SUCCEEDED(rv = hdrs->HasMoreElements(&hasMore)) && hasMore) {
+      nsCOMPtr<nsIMsgDBHdr> header;
+      rv = hdrs->GetNext(getter_AddRefs(header));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      uint32_t msgFlags;
+      PRTime msgDate;
+      header->GetFlags(&msgFlags);
+      if (msgFlags & nsMsgMessageFlags::Offline) {
+        header->GetDate(&msgDate);
+        MarkPendingRemoval(header, msgDate < cutOffDay);
+        // I'm horribly tempted to break out of the loop if we've found
+        // a message after the cut-off date, because messages will most likely
+        // be in date order in the db, but there are always edge cases.
+      }
+    }
+    if (!dbWasCached) {
+      holdDBOpen = mDatabase;
+      mDatabase = nullptr;
+    }
+  }
+  return nsMsgDBFolder::ApplyRetentionSettings();
+}
+
+/**
+ * The listener will get called when both the online expunge and the offline
+ * store compaction are finished (if the latter is needed).
+ */
+nsresult nsImapMailFolder::ExpungeAndCompact(nsIUrlListener* aListener,
+                                             nsIMsgWindow* aMsgWindow) {
+  GetDatabase();
+  // now's a good time to apply the retention settings. If we do delete any
+  // messages, the expunge is going to have to wait until the delete to
+  // finish before it can run, but the multiple-connection protection code
+  // should handle that.
+  if (mDatabase) ApplyRetentionSettings();
+
+  // Things to hold in existence until both expunge and compact are complete.
+  RefPtr<nsImapMailFolder> folder = this;
+  nsCOMPtr<nsIUrlListener> finalListener = aListener;
+  nsCOMPtr<nsIMsgWindow> msgWindow = aMsgWindow;
+
+  // doCompact implements OnStopRunningUrl()
+  // NOTE: The caller will be expecting that their listener will be invoked, so
+  // we need to be careful that all execution paths in here do that. We either
+  // call it directly, or pass it along to the foldercompactor to call.
+  auto doCompact = [folder, finalListener, msgWindow](
+                       nsIURI* url, nsresult status) -> nsresult {
+    nsCOMPtr<nsIMsgPluggableStore> msgStore;
+    nsresult rv = folder->GetMsgStore(getter_AddRefs(msgStore));
+    if (NS_FAILED(rv)) {
+      if (finalListener) {
+        return finalListener->OnStopRunningUrl(nullptr, rv);
+      }
+      return rv;
+    }
+    bool storeSupportsCompaction;
+    msgStore->GetSupportsCompaction(&storeSupportsCompaction);
+    if (storeSupportsCompaction && folder->mFlags & nsMsgFolderFlags::Offline) {
+      nsCOMPtr<nsIMsgFolderCompactor> folderCompactor =
+          do_CreateInstance("@mozilla.org/messenger/foldercompactor;1", &rv);
+      if (NS_FAILED(rv)) {
+        if (finalListener) {
+          return finalListener->OnStopRunningUrl(nullptr, rv);
+        }
+        return rv;
+      }
+      return folderCompactor->CompactFolders({folder}, finalListener,
+                                             msgWindow);
+    }
+    // Not going to run a compaction, so signal that we're all done.
+    if (finalListener) {
+      return finalListener->OnStopRunningUrl(nullptr, NS_OK);
+    }
+    return NS_OK;
+  };
+
+  if (WeAreOffline()) {
+    // Can't run an expunge. Kick off the next stage (compact) immediately.
+    return doCompact(nullptr, NS_OK);
+  }
+
+  // Run the expunge, followed by the compaction.
+  RefPtr<UrlListener> expungeListener = new UrlListener();
+  expungeListener->mStopFn = doCompact;
+  return Expunge(expungeListener, aMsgWindow);
+}
+
+// IMAP compact implies an Expunge.
+NS_IMETHODIMP nsImapMailFolder::Compact(nsIUrlListener* aListener,
+                                        nsIMsgWindow* aMsgWindow) {
+  return ExpungeAndCompact(aListener, aMsgWindow);
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::NotifyCompactCompleted() { return NS_OK; }
+
+NS_IMETHODIMP nsImapMailFolder::MarkPendingRemoval(nsIMsgDBHdr* aHdr,
+                                                   bool aMark) {
+  NS_ENSURE_ARG_POINTER(aHdr);
+  uint32_t offlineMessageSize;
+  aHdr->GetOfflineMessageSize(&offlineMessageSize);
+  aHdr->SetStringProperty("pendingRemoval", aMark ? "1"_ns : ""_ns);
+  if (!aMark) return NS_OK;
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+  rv = mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return dbFolderInfo->ChangeExpungedBytes(offlineMessageSize);
+}
+
+NS_IMETHODIMP nsImapMailFolder::Expunge(nsIUrlListener* aListener,
+                                        nsIMsgWindow* aMsgWindow) {
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return imapService->Expunge(this, aListener, aMsgWindow);
+}
+
+NS_IMETHODIMP nsImapMailFolder::CompactAll(nsIUrlListener* aListener,
+                                           nsIMsgWindow* aMsgWindow) {
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgFolderCompactor> folderCompactor =
+      do_CreateInstance("@mozilla.org/messenger/foldercompactor;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  rv = GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgWindow> msgWindow = aMsgWindow;
+
+  // Set up a callable which will start the compaction phase.
+  auto doCompact = [folderCompactor, rootFolder,
+                    listener = nsCOMPtr<nsIUrlListener>(aListener),
+                    msgWindow]() {
+    // Collect all the compactable folders.
+    nsTArray<RefPtr<nsIMsgFolder>> foldersToCompact;
+    nsTArray<RefPtr<nsIMsgFolder>> allDescendants;
+    rootFolder->GetDescendants(allDescendants);
+    for (auto folder : allDescendants) {
+      uint32_t flags;
+      folder->GetFlags(&flags);
+      if (flags &
+          (nsMsgFolderFlags::Virtual | nsMsgFolderFlags::ImapNoselect)) {
+        continue;
+      }
+      // Folder can be compacted?
+      nsCOMPtr<nsIMsgPluggableStore> msgStore;
+      folder->GetMsgStore(getter_AddRefs(msgStore));
+      if (!msgStore) {
+        continue;
+      }
+      bool storeSupportsCompaction;
+      msgStore->GetSupportsCompaction(&storeSupportsCompaction);
+      if (storeSupportsCompaction) {
+        foldersToCompact.AppendElement(folder);
+      }
+    }
+    nsresult rv =
+        folderCompactor->CompactFolders(foldersToCompact, listener, msgWindow);
+    if (NS_FAILED(rv) && listener) {
+      // Make sure the listener hears about the failure.
+      listener->OnStopRunningUrl(nullptr, rv);
+    }
+  };
+
+  // Collect all the expungeable folders.
+  nsTArray<RefPtr<nsIMsgImapMailFolder>> foldersToExpunge;
+  nsTArray<RefPtr<nsIMsgFolder>> allDescendants;
+  rootFolder->GetDescendants(allDescendants);
+  for (auto folder : allDescendants) {
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(folder));
+    if (!imapFolder) {
+      continue;
+    }
+    uint32_t folderFlags;
+    folder->GetFlags(&folderFlags);
+    if (!(folderFlags &
+          (nsMsgFolderFlags::Virtual | nsMsgFolderFlags::ImapNoselect))) {
+      foldersToExpunge.AppendElement(imapFolder);
+    }
+  }
+
+  if (!WeAreOffline() && !foldersToExpunge.IsEmpty()) {
+    // Kick off expunge on all the folders (the IMAP protocol will handle
+    // queuing them up as needed).
+
+    // A listener to track the completed expunges.
+    RefPtr<UrlListener> l = new UrlListener();
+    l->mStopFn = [expungeCount = foldersToExpunge.Length(), doCompact](
+                     nsIURI* url, nsresult status) mutable -> nsresult {
+      // NOTE: we're ignoring expunge result code - nothing much we can do
+      // here to recover, so just plough on.
+      --expungeCount;
+      if (expungeCount == 0) {
+        // All the expunges are done so start compacting.
+        doCompact();
+      }
+      return NS_OK;
+    };
+    // Go!
+    for (auto& imapFolder : foldersToExpunge) {
+      rv = imapFolder->Expunge(l, aMsgWindow);
+      if (NS_FAILED(rv)) {
+        // Make sure expungeCount is kept in sync!
+        l->OnStopRunningUrl(nullptr, rv);
+      }
+    }
+  } else {
+    // No expunging. Start the compaction immediately.
+    doCompact();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::UpdateStatus(nsIUrlListener* aListener,
+                                             nsIMsgWindow* aMsgWindow) {
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIURI> uri;
+  rv = imapService->UpdateFolderStatus(this, aListener, getter_AddRefs(uri));
+  if (uri && !aMsgWindow) {
+    nsCOMPtr<nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(uri, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    // if no msg window, we won't put up error messages (this is almost
+    // certainly a biff-inspired status)
+    mailNewsUrl->SetSuppressErrorMsgs(true);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::EmptyTrash(nsIUrlListener* aListener) {
+  nsCOMPtr<nsIMsgFolder> trashFolder;
+  nsresult rv = GetTrashFolder(getter_AddRefs(trashFolder));
+  if (NS_SUCCEEDED(rv)) {
+    nsCOMPtr<nsIMsgAccountManager> accountManager =
+        do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    // if we are emptying trash on exit and we are an aol server then don't
+    // perform this operation because it's causing a hang that we haven't been
+    // able to figure out yet this is an rtm fix and we'll look for the right
+    // solution post rtm.
+    bool empytingOnExit = false;
+    accountManager->GetEmptyTrashInProgress(&empytingOnExit);
+    if (empytingOnExit) {
+      nsCOMPtr<nsIImapIncomingServer> imapServer;
+      rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+      if (imapServer) {
+        bool isAOLServer = false;
+        imapServer->GetIsAOLServer(&isAOLServer);
+        if (isAOLServer)
+          return NS_ERROR_FAILURE;  // we will not be performing an empty
+                                    // trash....
+      }                             // if we fetched an imap server
+    }  // if emptying trash on exit which is done through the account manager.
+
+    if (WeAreOffline()) {
+      nsCOMPtr<nsIMsgDatabase> trashDB;
+      rv = trashFolder->GetMsgDatabase(getter_AddRefs(trashDB));
+      if (trashDB) {
+        nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb =
+            do_QueryInterface(trashDB, &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        nsMsgKey fakeKey;
+        opsDb->GetNextFakeOfflineMsgKey(&fakeKey);
+
+        nsCOMPtr<nsIMsgOfflineImapOperation> op;
+        rv = opsDb->GetOfflineOpForKey(fakeKey, true, getter_AddRefs(op));
+        trashFolder->SetFlag(nsMsgFolderFlags::OfflineEvents);
+        op->SetOperation(nsIMsgOfflineImapOperation::kDeleteAllMsgs);
+      }
+      return rv;
+    }
+
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (aListener)
+      rv = imapService->DeleteAllMessages(trashFolder, aListener);
+    else {
+      nsCOMPtr<nsIUrlListener> urlListener = do_QueryInterface(trashFolder);
+      rv = imapService->DeleteAllMessages(trashFolder, urlListener);
+    }
+    // Return an error if this failed. We want the empty trash on exit code
+    // to know if this fails so that it doesn't block waiting for empty trash to
+    // finish.
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Delete any subfolders under Trash.
+    nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+    rv = trashFolder->GetSubFolders(subFolders);
+    NS_ENSURE_SUCCESS(rv, rv);
+    while (!subFolders.IsEmpty()) {
+      RefPtr<nsIMsgFolder> f = subFolders.PopLastElement();
+      rv = trashFolder->PropagateDelete(f, true);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    nsCOMPtr<nsIDBFolderInfo> transferInfo;
+    rv = trashFolder->GetDBTransferInfo(getter_AddRefs(transferInfo));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // Bulk-delete all the messages by deleting the msf file and storage.
+    // This is a little kludgy.
+    rv = trashFolder->DeleteStorage();
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (transferInfo) trashFolder->SetDBTransferInfo(transferInfo);
+    trashFolder->SetSizeOnDisk(0);
+
+    // The trash folder has effectively been deleted.
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+    if (notifier) notifier->NotifyFolderDeleted(trashFolder);
+
+    return NS_OK;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::DeleteStorage() {
+  nsresult rv = nsMsgDBFolder::DeleteStorage();
+
+  // Should notify nsIMsgFolderListeners about the folder getting deleted?
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::Rename(const nsAString& newName,
+                                       nsIMsgWindow* msgWindow) {
+  if (mFlags & nsMsgFolderFlags::Virtual)
+    return nsMsgDBFolder::Rename(newName, msgWindow);
+  nsresult rv;
+  nsAutoString newNameStr(newName);
+  if (newNameStr.FindChar(m_hierarchyDelimiter, 0) != kNotFound) {
+    nsCOMPtr<nsIDocShell> docShell;
+    if (msgWindow) msgWindow->GetRootDocShell(getter_AddRefs(docShell));
+    if (docShell) {
+      nsCOMPtr<nsIStringBundle> bundle;
+      rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+      if (NS_SUCCEEDED(rv) && bundle) {
+        AutoTArray<nsString, 1> formatStrings;
+        formatStrings.AppendElement()->Append(m_hierarchyDelimiter);
+        nsString alertString;
+        rv = bundle->FormatStringFromName("imapSpecialChar2", formatStrings,
+                                          alertString);
+        nsCOMPtr<nsIPrompt> dialog(do_GetInterface(docShell));
+        // setting up the dialog title
+        nsCOMPtr<nsIMsgIncomingServer> server;
+        rv = GetServer(getter_AddRefs(server));
+        NS_ENSURE_SUCCESS(rv, rv);
+        nsString dialogTitle;
+        nsString accountName;
+        rv = server->GetPrettyName(accountName);
+        NS_ENSURE_SUCCESS(rv, rv);
+        AutoTArray<nsString, 1> titleParams = {accountName};
+        rv = bundle->FormatStringFromName("imapAlertDialogTitle", titleParams,
+                                          dialogTitle);
+
+        if (dialog && !alertString.IsEmpty())
+          dialog->Alert(dialogTitle.get(), alertString.get());
+      }
+    }
+    return NS_ERROR_FAILURE;
+  }
+  nsCOMPtr<nsIImapIncomingServer> incomingImapServer;
+  GetImapIncomingServer(getter_AddRefs(incomingImapServer));
+  if (incomingImapServer) RecursiveCloseActiveConnections(incomingImapServer);
+
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return imapService->RenameLeaf(this, newName, this, msgWindow);
+}
+
+NS_IMETHODIMP nsImapMailFolder::RecursiveCloseActiveConnections(
+    nsIImapIncomingServer* incomingImapServer) {
+  NS_ENSURE_ARG(incomingImapServer);
+
+  nsCOMPtr<nsIMsgImapMailFolder> folder;
+  int32_t count = mSubFolders.Count();
+  for (int32_t i = 0; i < count; i++) {
+    folder = do_QueryInterface(mSubFolders[i]);
+    if (folder) folder->RecursiveCloseActiveConnections(incomingImapServer);
+
+    incomingImapServer->CloseConnectionForFolder(mSubFolders[i]);
+  }
+  return NS_OK;
+}
+
+// this is called *after* we've done the rename on the server.
+NS_IMETHODIMP nsImapMailFolder::PrepareToRename() {
+  nsCOMPtr<nsIMsgImapMailFolder> folder;
+  int32_t count = mSubFolders.Count();
+  for (int32_t i = 0; i < count; i++) {
+    folder = do_QueryInterface(mSubFolders[i]);
+    if (folder) folder->PrepareToRename();
+  }
+
+  SetOnlineName(EmptyCString());
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::RenameLocal(const nsACString& newName,
+                                            nsIMsgFolder* parent) {
+  nsAutoCString leafname(newName);
+  nsAutoCString parentName;
+  // newName always in the canonical form "greatparent/parentname/leafname"
+  int32_t leafpos = leafname.RFindChar('/');
+  if (leafpos > 0) leafname.Cut(0, leafpos + 1);
+  m_msgParser = nullptr;
+  PrepareToRename();
+  CloseAndBackupFolderDB(leafname);
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIFile> oldPathFile;
+  rv = GetFilePath(getter_AddRefs(oldPathFile));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIFile> parentPathFile;
+  rv = parent->GetFilePath(getter_AddRefs(parentPathFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool isDirectory = false;
+  parentPathFile->IsDirectory(&isDirectory);
+  if (!isDirectory) AddDirectorySeparator(parentPathFile);
+
+  nsCOMPtr<nsIFile> dirFile;
+
+  int32_t count = mSubFolders.Count();
+  if (count > 0) {
+    rv = CreateDirectoryForFolder(getter_AddRefs(dirFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCOMPtr<nsIFile> oldSummaryFile;
+  rv = GetSummaryFileLocation(oldPathFile, getter_AddRefs(oldSummaryFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString newNameStr;
+  oldSummaryFile->Remove(false);
+  if (count > 0) {
+    newNameStr = leafname;
+    NS_MsgHashIfNecessary(newNameStr);
+    newNameStr.AppendLiteral(FOLDER_SUFFIX8);
+    nsAutoCString leafName;
+    dirFile->GetNativeLeafName(leafName);
+    if (!leafName.Equals(newNameStr))
+      return dirFile->MoveToNative(
+          nullptr,
+          newNameStr);  // in case of rename operation leaf names will differ
+
+    parentPathFile->AppendNative(
+        newNameStr);  // only for move we need to progress further in case the
+                      // parent differs
+    bool isDirectory = false;
+    parentPathFile->IsDirectory(&isDirectory);
+    if (!isDirectory) {
+      rv = parentPathFile->Create(nsIFile::DIRECTORY_TYPE, 0700);
+      NS_ENSURE_SUCCESS(rv, rv);
+    } else {
+      NS_ERROR("Directory already exists.");
+    }
+    rv = RecursiveCopy(dirFile, parentPathFile);
+    NS_ENSURE_SUCCESS(rv, rv);
+    dirFile->Remove(true);  // moving folders
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetPrettyName(nsAString& prettyName) {
+  return GetName(prettyName);
+}
+
+NS_IMETHODIMP nsImapMailFolder::UpdateSummaryTotals(bool force) {
+  // bug 72871 inserted the mIsServer check for IMAP
+  return mIsServer ? NS_OK : nsMsgDBFolder::UpdateSummaryTotals(force);
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetDeletable(bool* deletable) {
+  NS_ENSURE_ARG_POINTER(deletable);
+
+  bool isServer;
+  GetIsServer(&isServer);
+
+  *deletable = !(isServer || (mFlags & nsMsgFolderFlags::SpecialUse));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetSizeOnDisk(int64_t* size) {
+  NS_ENSURE_ARG_POINTER(size);
+
+  bool isServer = false;
+  nsresult rv = GetIsServer(&isServer);
+  // If this is the rootFolder, return 0 as a safe value.
+  if (NS_FAILED(rv) || isServer) mFolderSize = 0;
+
+  *size = mFolderSize;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetCanCreateSubfolders(bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = !(mFlags &
+               (nsMsgFolderFlags::ImapNoinferiors | nsMsgFolderFlags::Virtual));
+
+  bool isServer = false;
+  GetIsServer(&isServer);
+  if (!isServer) {
+    nsCOMPtr<nsIImapIncomingServer> imapServer;
+    nsresult rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+    bool dualUseFolders = true;
+    if (NS_SUCCEEDED(rv) && imapServer)
+      imapServer->GetDualUseFolders(&dualUseFolders);
+    if (!dualUseFolders && *aResult)
+      *aResult = (mFlags & nsMsgFolderFlags::ImapNoselect);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetCanSubscribe(bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = false;
+
+  bool isImapServer = false;
+  nsresult rv = GetIsServer(&isImapServer);
+  if (NS_FAILED(rv)) return rv;
+  // you can only subscribe to imap servers, not imap folders
+  *aResult = isImapServer;
+  return NS_OK;
+}
+
+nsresult nsImapMailFolder::GetServerKey(nsACString& serverKey) {
+  // look for matching imap folders, then pop folders
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = GetServer(getter_AddRefs(server));
+  if (NS_SUCCEEDED(rv)) rv = server->GetKey(serverKey);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetImapIncomingServer(
+    nsIImapIncomingServer** aImapIncomingServer) {
+  NS_ENSURE_ARG(aImapIncomingServer);
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  if (NS_SUCCEEDED(GetServer(getter_AddRefs(server))) && server) {
+    nsCOMPtr<nsIImapIncomingServer> incomingServer = do_QueryInterface(server);
+    NS_ENSURE_TRUE(incomingServer, NS_ERROR_NO_INTERFACE);
+    incomingServer.forget(aImapIncomingServer);
+    return NS_OK;
+  }
+  return NS_ERROR_NULL_POINTER;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::AddMessageDispositionState(
+    nsIMsgDBHdr* aMessage, nsMsgDispositionState aDispositionFlag) {
+  nsMsgDBFolder::AddMessageDispositionState(aMessage, aDispositionFlag);
+
+  // set the mark message answered flag on the server for this message...
+  if (aMessage) {
+    nsMsgKey msgKey;
+    aMessage->GetMessageKey(&msgKey);
+
+    if (aDispositionFlag == nsIMsgFolder::nsMsgDispositionState_Replied)
+      StoreImapFlags(kImapMsgAnsweredFlag, true, {msgKey}, nullptr);
+    else if (aDispositionFlag == nsIMsgFolder::nsMsgDispositionState_Forwarded)
+      StoreImapFlags(kImapMsgForwardedFlag, true, {msgKey}, nullptr);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::MarkMessagesRead(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& messages, bool markRead) {
+  // tell the folder to do it, which will mark them read in the db.
+  nsresult rv = nsMsgDBFolder::MarkMessagesRead(messages, markRead);
+  if (NS_SUCCEEDED(rv)) {
+    nsAutoCString messageIds;
+    nsTArray<nsMsgKey> keysToMarkRead;
+    rv = BuildIdsAndKeyArray(messages, messageIds, keysToMarkRead);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    StoreImapFlags(kImapMsgSeenFlag, markRead, keysToMarkRead, nullptr);
+    rv = GetDatabase();
+    if (NS_SUCCEEDED(rv)) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::MarkAllMessagesRead(nsIMsgWindow* aMsgWindow) {
+  nsresult rv = GetDatabase();
+  if (NS_SUCCEEDED(rv)) {
+    nsTArray<nsMsgKey> thoseMarked;
+    EnableNotifications(allMessageCountNotifications, false);
+    rv = mDatabase->MarkAllRead(thoseMarked);
+    EnableNotifications(allMessageCountNotifications, true);
+    if (NS_SUCCEEDED(rv) && thoseMarked.Length() > 0) {
+      rv = StoreImapFlags(kImapMsgSeenFlag, true, thoseMarked, nullptr);
+      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+
+      // Setup a undo-state
+      if (aMsgWindow)
+        rv = AddMarkAllReadUndoAction(aMsgWindow, thoseMarked.Elements(),
+                                      thoseMarked.Length());
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::MarkThreadRead(nsIMsgThread* thread) {
+  nsresult rv = GetDatabase();
+  if (NS_SUCCEEDED(rv)) {
+    nsTArray<nsMsgKey> keys;
+    rv = mDatabase->MarkThreadRead(thread, nullptr, keys);
+    if (NS_SUCCEEDED(rv) && keys.Length() > 0) {
+      rv = StoreImapFlags(kImapMsgSeenFlag, true, keys, nullptr);
+      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::ReadFromFolderCacheElem(
+    nsIMsgFolderCacheElement* element) {
+  nsresult rv = nsMsgDBFolder::ReadFromFolderCacheElem(element);
+  int32_t hierarchyDelimiter = kOnlineHierarchySeparatorUnknown;
+  nsCString onlineName;
+
+  element->GetCachedUInt32("boxFlags", (uint32_t*)&m_boxFlags);
+  if (NS_SUCCEEDED(element->GetCachedInt32("hierDelim", &hierarchyDelimiter)) &&
+      hierarchyDelimiter != kOnlineHierarchySeparatorUnknown)
+    m_hierarchyDelimiter = (char)hierarchyDelimiter;
+  rv = element->GetCachedString("onlineName", onlineName);
+  if (NS_SUCCEEDED(rv) && !onlineName.IsEmpty())
+    m_onlineFolderName.Assign(onlineName);
+
+  m_aclFlags = kAclInvalid;  // init to invalid value.
+  element->GetCachedUInt32("aclFlags", &m_aclFlags);
+  element->GetCachedInt32("serverTotal", &m_numServerTotalMessages);
+  element->GetCachedInt32("serverUnseen", &m_numServerUnseenMessages);
+  element->GetCachedInt32("serverRecent", &m_numServerRecentMessages);
+  element->GetCachedInt32("nextUID", &m_nextUID);
+  int32_t lastSyncTimeInSec;
+  if (NS_FAILED(element->GetCachedInt32("lastSyncTimeInSec",
+                                        (int32_t*)&lastSyncTimeInSec)))
+    lastSyncTimeInSec = 0U;
+
+  // make sure that auto-sync state object is created
+  InitAutoSyncState();
+  m_autoSyncStateObj->SetLastSyncTimeInSec(lastSyncTimeInSec);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::WriteToFolderCacheElem(
+    nsIMsgFolderCacheElement* element) {
+  nsresult rv = nsMsgDBFolder::WriteToFolderCacheElem(element);
+  element->SetCachedUInt32("boxFlags", (uint32_t)m_boxFlags);
+  element->SetCachedInt32("hierDelim", (int32_t)m_hierarchyDelimiter);
+  element->SetCachedString("onlineName", m_onlineFolderName);
+  element->SetCachedUInt32("aclFlags", m_aclFlags);
+  element->SetCachedInt32("serverTotal", m_numServerTotalMessages);
+  element->SetCachedInt32("serverUnseen", m_numServerUnseenMessages);
+  element->SetCachedInt32("serverRecent", m_numServerRecentMessages);
+  if (m_nextUID != (int32_t)nsMsgKey_None)
+    element->SetCachedInt32("nextUID", m_nextUID);
+
+  // store folder's last sync time
+  if (m_autoSyncStateObj) {
+    PRTime lastSyncTime;
+    m_autoSyncStateObj->GetLastSyncTime(&lastSyncTime);
+    // store in sec
+    element->SetCachedInt32("lastSyncTimeInSec",
+                            (int32_t)(lastSyncTime / PR_USEC_PER_SEC));
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::MarkMessagesFlagged(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& messages, bool markFlagged) {
+  nsresult rv;
+  // tell the folder to do it, which will mark them read in the db.
+  rv = nsMsgDBFolder::MarkMessagesFlagged(messages, markFlagged);
+  if (NS_SUCCEEDED(rv)) {
+    nsAutoCString messageIds;
+    nsTArray<nsMsgKey> keysToMarkFlagged;
+    rv = BuildIdsAndKeyArray(messages, messageIds, keysToMarkFlagged);
+    if (NS_FAILED(rv)) return rv;
+    rv = StoreImapFlags(kImapMsgFlaggedFlag, markFlagged, keysToMarkFlagged,
+                        nullptr);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = GetDatabase();
+    NS_ENSURE_SUCCESS(rv, rv);
+    mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetOnlineName(
+    const nsACString& aOnlineFolderName) {
+  nsresult rv;
+  nsCOMPtr<nsIMsgDatabase> db;
+  nsCOMPtr<nsIDBFolderInfo> folderInfo;
+  rv = GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(db));
+  // do this after GetDBFolderInfoAndDB, because it crunches m_onlineFolderName
+  // (not sure why)
+  m_onlineFolderName = aOnlineFolderName;
+  if (NS_SUCCEEDED(rv) && folderInfo) {
+    nsAutoString onlineName;
+    CopyUTF8toUTF16(aOnlineFolderName, onlineName);
+    rv = folderInfo->SetProperty("onlineName", onlineName);
+    rv = folderInfo->SetMailboxName(onlineName);
+    // so, when are we going to commit this? Definitely not every time!
+    // We could check if the online name has changed.
+    db->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  folderInfo = nullptr;
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetOnlineName(nsACString& aOnlineFolderName) {
+  ReadDBFolderInfo(false);  // update cache first.
+  aOnlineFolderName = m_onlineFolderName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetDBFolderInfoAndDB(nsIDBFolderInfo** folderInfo,
+                                       nsIMsgDatabase** db) {
+  NS_ENSURE_ARG_POINTER(folderInfo);
+  NS_ENSURE_ARG_POINTER(db);
+
+  nsresult rv = GetDatabase();
+  if (NS_FAILED(rv)) return rv;
+
+  NS_ADDREF(*db = mDatabase);
+
+  rv = (*db)->GetDBFolderInfo(folderInfo);
+  if (NS_FAILED(rv))
+    return rv;  // GetDBFolderInfo can't return NS_OK if !folderInfo
+
+  nsCString onlineName;
+  rv = (*folderInfo)->GetCharProperty("onlineName", onlineName);
+  if (NS_FAILED(rv)) return rv;
+
+  if (!onlineName.IsEmpty())
+    m_onlineFolderName.Assign(onlineName);
+  else {
+    nsAutoString autoOnlineName;
+    (*folderInfo)->GetMailboxName(autoOnlineName);
+    if (autoOnlineName.IsEmpty()) {
+      nsCString uri;
+      rv = GetURI(uri);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCString hostname;
+      rv = GetHostname(hostname);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCString onlineCName;
+      rv = nsImapURI2FullName(kImapRootURI, hostname.get(), uri.get(),
+                              getter_Copies(onlineCName));
+      // Note: check for unknown separator '^' only became needed
+      // with UTF8=ACCEPT modification and haven't found why. Online name
+      // contained the '^' delimiter and gmail said "NO" when folder under
+      // [Gmail] is created and selected.
+      if ((m_hierarchyDelimiter != '/') &&
+          (m_hierarchyDelimiter != kOnlineHierarchySeparatorUnknown))
+        onlineCName.ReplaceChar('/', m_hierarchyDelimiter);
+      // XXX: What if online name contains slashes? Breaks?
+      m_onlineFolderName.Assign(onlineCName);
+      CopyUTF8toUTF16(onlineCName, autoOnlineName);
+    }
+    (*folderInfo)->SetProperty("onlineName", autoOnlineName);
+  }
+  return rv;
+}
+
+/* static */
+nsresult nsImapMailFolder::BuildIdsAndKeyArray(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& messages, nsCString& msgIds,
+    nsTArray<nsMsgKey>& keyArray) {
+  keyArray.Clear();
+  keyArray.SetCapacity(messages.Length());
+  // build up message keys.
+  for (auto msgDBHdr : messages) {
+    nsMsgKey key;
+    nsresult rv = msgDBHdr->GetMessageKey(&key);
+    if (NS_SUCCEEDED(rv)) keyArray.AppendElement(key);
+  }
+  return AllocateUidStringFromKeys(keyArray, msgIds);
+}
+
+/* static */
+nsresult nsImapMailFolder::AllocateUidStringFromKeys(
+    const nsTArray<nsMsgKey>& keys, nsCString& msgIds) {
+  if (keys.IsEmpty()) return NS_ERROR_INVALID_ARG;
+  nsresult rv = NS_OK;
+  uint32_t startSequence;
+  startSequence = keys[0];
+  uint32_t curSequenceEnd = startSequence;
+  uint32_t total = keys.Length();
+  // sort keys and then generate ranges instead of singletons!
+  nsTArray<nsMsgKey> sorted(keys.Clone());
+  sorted.Sort();
+  for (uint32_t keyIndex = 0; keyIndex < total; keyIndex++) {
+    uint32_t curKey = sorted[keyIndex];
+    uint32_t nextKey =
+        (keyIndex + 1 < total) ? sorted[keyIndex + 1] : 0xFFFFFFFF;
+    bool lastKey = (nextKey == 0xFFFFFFFF);
+
+    if (lastKey) curSequenceEnd = curKey;
+    if (nextKey == (uint32_t)curSequenceEnd + 1 && !lastKey) {
+      curSequenceEnd = nextKey;
+      continue;
+    }
+    if (curSequenceEnd > startSequence) {
+      AppendUid(msgIds, startSequence);
+      msgIds += ':';
+      AppendUid(msgIds, curSequenceEnd);
+      if (!lastKey) msgIds += ',';
+      startSequence = nextKey;
+      curSequenceEnd = startSequence;
+    } else {
+      startSequence = nextKey;
+      curSequenceEnd = startSequence;
+      AppendUid(msgIds, sorted[keyIndex]);
+      if (!lastKey) msgIds += ',';
+    }
+  }
+  return rv;
+}
+
+nsresult nsImapMailFolder::MarkMessagesImapDeleted(nsTArray<nsMsgKey>* keyArray,
+                                                   bool deleted,
+                                                   nsIMsgDatabase* db) {
+  for (uint32_t kindex = 0; kindex < keyArray->Length(); kindex++) {
+    nsMsgKey key = keyArray->ElementAt(kindex);
+    db->MarkImapDeleted(key, deleted, nullptr);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::DeleteMessages(
+    nsTArray<RefPtr<nsIMsgDBHdr>> const& msgHeaders, nsIMsgWindow* msgWindow,
+    bool deleteStorage, bool isMove, nsIMsgCopyServiceListener* listener,
+    bool allowUndo) {
+  // *** jt - assuming delete is move to the trash folder for now
+  nsAutoCString uri;
+  bool deleteImmediatelyNoTrash = false;
+  nsAutoCString messageIds;
+  nsTArray<nsMsgKey> srcKeyArray;
+  bool deleteMsgs = true;  // used for toggling delete status - default is true
+  nsMsgImapDeleteModel deleteModel = nsMsgImapDeleteModels::MoveToTrash;
+  imapMessageFlagsType messageFlags = kImapMsgDeletedFlag;
+
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  nsresult rv = GetFlag(nsMsgFolderFlags::Trash, &deleteImmediatelyNoTrash);
+  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+
+  if (NS_SUCCEEDED(rv) && imapServer) {
+    imapServer->GetDeleteModel(&deleteModel);
+    if (deleteModel != nsMsgImapDeleteModels::MoveToTrash || deleteStorage)
+      deleteImmediatelyNoTrash = true;
+    // if we're deleting a message, we should pseudo-interrupt the msg
+    // load of the current message.
+    bool interrupted = false;
+    imapServer->PseudoInterruptMsgLoad(this, msgWindow, &interrupted);
+  }
+
+  rv = BuildIdsAndKeyArray(msgHeaders, messageIds, srcKeyArray);
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  nsCOMPtr<nsIMsgFolder> trashFolder;
+
+  if (!deleteImmediatelyNoTrash) {
+    rv = GetRootFolder(getter_AddRefs(rootFolder));
+    if (NS_SUCCEEDED(rv) && rootFolder) {
+      rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Trash,
+                                     getter_AddRefs(trashFolder));
+      NS_ASSERTION(trashFolder, "couldn't find trash");
+      // if we can't find the trash, we'll just have to do an imap delete and
+      // pretend this is the trash
+      if (!trashFolder) deleteImmediatelyNoTrash = true;
+    }
+  }
+
+  if ((NS_SUCCEEDED(rv) && deleteImmediatelyNoTrash) ||
+      deleteModel == nsMsgImapDeleteModels::IMAPDelete) {
+    if (allowUndo) {
+      // need to take care of these two delete models
+      RefPtr<nsImapMoveCopyMsgTxn> undoMsgTxn = new nsImapMoveCopyMsgTxn;
+      if (!undoMsgTxn ||
+          NS_FAILED(undoMsgTxn->Init(this, &srcKeyArray, messageIds.get(),
+                                     nullptr, true, isMove)))
+        return NS_ERROR_OUT_OF_MEMORY;
+
+      undoMsgTxn->SetTransactionType(nsIMessenger::eDeleteMsg);
+      // we're adding this undo action before the delete is successful. This is
+      // evil, but 4.5 did it as well.
+      nsCOMPtr<nsITransactionManager> txnMgr;
+      if (msgWindow) msgWindow->GetTransactionManager(getter_AddRefs(txnMgr));
+      if (txnMgr) txnMgr->DoTransaction(undoMsgTxn);
+    }
+
+    if (deleteModel == nsMsgImapDeleteModels::IMAPDelete && !deleteStorage) {
+      deleteMsgs = false;
+      for (nsIMsgDBHdr* msgHdr : msgHeaders) {
+        if (!msgHdr) {
+          continue;
+        }
+        uint32_t flags;
+        msgHdr->GetFlags(&flags);
+        if (!(flags & nsMsgMessageFlags::IMAPDeleted)) {
+          deleteMsgs = true;
+          break;
+        }
+      }
+    }
+    // if copy service listener is also a url listener, pass that
+    // url listener into StoreImapFlags.
+    nsCOMPtr<nsIUrlListener> urlListener = do_QueryInterface(listener);
+    if (deleteMsgs) messageFlags |= kImapMsgSeenFlag;
+    rv = StoreImapFlags(messageFlags, deleteMsgs, srcKeyArray, urlListener);
+
+    if (NS_SUCCEEDED(rv)) {
+      if (mDatabase) {
+        nsCOMPtr<nsIMsgDatabase> database(mDatabase);
+        if (deleteModel == nsMsgImapDeleteModels::IMAPDelete)
+          MarkMessagesImapDeleted(&srcKeyArray, deleteMsgs, database);
+        else {
+          EnableNotifications(allMessageCountNotifications,
+                              false);  //"remove it immediately" model
+          // Notify if this is an actual delete.
+          if (!isMove) {
+            nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(
+                "@mozilla.org/messenger/msgnotificationservice;1"));
+            if (notifier) notifier->NotifyMsgsDeleted(msgHeaders);
+          }
+          DeleteStoreMessages(msgHeaders);
+          database->DeleteMessages(srcKeyArray, nullptr);
+          EnableNotifications(allMessageCountNotifications, true);
+        }
+        if (listener) {
+          listener->OnStartCopy();
+          listener->OnStopCopy(NS_OK);
+        }
+        NotifyFolderEvent(kDeleteOrMoveMsgCompleted);
+      }
+    }
+    return rv;
+  }
+
+  // have to move the messages to the trash
+  if (trashFolder) {
+    nsCOMPtr<nsIMsgFolder> srcFolder;
+    nsCOMPtr<nsISupports> srcSupport;
+
+    rv = QueryInterface(NS_GET_IID(nsIMsgFolder), getter_AddRefs(srcFolder));
+    nsCOMPtr<nsIMsgCopyService> copyService =
+        do_GetService("@mozilla.org/messenger/messagecopyservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = copyService->CopyMessages(srcFolder, msgHeaders, trashFolder, true,
+                                   listener, msgWindow, allowUndo);
+  }
+
+  return rv;
+}
+
+// check if folder is the trash, or a descendent of the trash
+// so we can tell if the folders we're deleting from it should
+// be *really* deleted.
+bool nsImapMailFolder::TrashOrDescendentOfTrash(nsIMsgFolder* folder) {
+  NS_ENSURE_TRUE(folder, false);
+  nsCOMPtr<nsIMsgFolder> parent;
+  nsCOMPtr<nsIMsgFolder> curFolder = folder;
+  nsresult rv;
+  uint32_t flags = 0;
+  do {
+    rv = curFolder->GetFlags(&flags);
+    if (NS_FAILED(rv)) return false;
+    if (flags & nsMsgFolderFlags::Trash) return true;
+    curFolder->GetParent(getter_AddRefs(parent));
+    if (!parent) return false;
+    curFolder = parent;
+  } while (NS_SUCCEEDED(rv) && curFolder);
+  return false;
+}
+NS_IMETHODIMP
+nsImapMailFolder::DeleteSelf(nsIMsgWindow* msgWindow) {
+  nsCOMPtr<nsIMsgFolder> trashFolder;
+  nsresult rv;
+  uint32_t folderFlags;
+
+  // No IMAP shenanigans required for virtual folders.
+  GetFlags(&folderFlags);
+  if (folderFlags & nsMsgFolderFlags::Virtual) {
+    return nsMsgDBFolder::DeleteSelf(nullptr);
+  }
+
+  // "this" is the folder we're deleting from
+  bool deleteNoTrash = TrashOrDescendentOfTrash(this) || !DeleteIsMoveToTrash();
+  bool confirmDeletion = true;
+
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!deleteNoTrash) {
+    rv = GetTrashFolder(getter_AddRefs(trashFolder));
+    // If we can't find the trash folder and we are supposed to move it to the
+    // trash return failure.
+    if (NS_FAILED(rv) || !trashFolder) return NS_ERROR_FAILURE;
+    bool canHaveSubFoldersOfTrash = true;
+    trashFolder->GetCanCreateSubfolders(&canHaveSubFoldersOfTrash);
+    if (canHaveSubFoldersOfTrash)  // UW server doesn't set NOINFERIORS - check
+                                   // dual use pref
+    {
+      nsCOMPtr<nsIImapIncomingServer> imapServer;
+      rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+      NS_ENSURE_SUCCESS(rv, rv);
+      bool serverSupportsDualUseFolders;
+      imapServer->GetDualUseFolders(&serverSupportsDualUseFolders);
+      if (!serverSupportsDualUseFolders) canHaveSubFoldersOfTrash = false;
+    }
+    if (!canHaveSubFoldersOfTrash) deleteNoTrash = true;
+    nsCOMPtr<nsIPrefBranch> prefBranch(
+        do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    prefBranch->GetBoolPref("mailnews.confirm.moveFoldersToTrash",
+                            &confirmDeletion);
+  }
+
+  // If we are deleting folder immediately, ask user for confirmation.
+  bool confirmed = false;
+  if (confirmDeletion || deleteNoTrash) {
+    nsCOMPtr<nsIStringBundle> bundle;
+    rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString folderName;
+    rv = GetName(folderName);
+    NS_ENSURE_SUCCESS(rv, rv);
+    AutoTArray<nsString, 1> formatStrings = {folderName};
+
+    nsAutoString deleteFolderDialogTitle;
+    rv = bundle->GetStringFromName("imapDeleteFolderDialogTitle",
+                                   deleteFolderDialogTitle);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString deleteFolderButtonLabel;
+    rv = bundle->GetStringFromName("imapDeleteFolderButtonLabel",
+                                   deleteFolderButtonLabel);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString confirmationStr;
+    rv = bundle->FormatStringFromName(
+        (deleteNoTrash) ? "imapDeleteNoTrash" : "imapMoveFolderToTrash",
+        formatStrings, confirmationStr);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!msgWindow) return NS_ERROR_NULL_POINTER;
+    nsCOMPtr<nsIDocShell> docShell;
+    msgWindow->GetRootDocShell(getter_AddRefs(docShell));
+    nsCOMPtr<nsIPrompt> dialog;
+    if (docShell) dialog = do_GetInterface(docShell);
+    if (dialog) {
+      int32_t buttonPressed = 0;
+      // Default the dialog to "cancel".
+      const uint32_t buttonFlags =
+          (nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_0) +
+          (nsIPrompt::BUTTON_TITLE_CANCEL * nsIPrompt::BUTTON_POS_1);
+
+      bool dummyValue = false;
+      rv = dialog->ConfirmEx(deleteFolderDialogTitle.get(),
+                             confirmationStr.get(), buttonFlags,
+                             deleteFolderButtonLabel.get(), nullptr, nullptr,
+                             nullptr, &dummyValue, &buttonPressed);
+      NS_ENSURE_SUCCESS(rv, rv);
+      confirmed = !buttonPressed;  // "ok" is in position 0
+    }
+  } else {
+    confirmed = true;
+  }
+
+  if (confirmed) {
+    if (deleteNoTrash) {
+      rv = imapService->DeleteFolder(this, this, msgWindow);
+      nsMsgDBFolder::DeleteSelf(msgWindow);
+    } else {
+      bool match = false;
+      rv = MatchOrChangeFilterDestination(nullptr, false, &match);
+      if (match) {
+        bool confirm = false;
+        ConfirmFolderDeletionForFilter(msgWindow, &confirm);
+        if (!confirm) return NS_OK;
+      }
+      rv = imapService->MoveFolder(this, trashFolder, this, msgWindow);
+    }
+  }
+  return rv;
+}
+
+// FIXME: helper function to know whether we should check all IMAP folders
+// for new mail; this is necessary because of a legacy hidden preference
+// mail.check_all_imap_folders_for_new (now replaced by per-server preference
+// mail.server.%serverkey%.check_all_folders_for_new), still present in some
+// profiles.
+/*static*/
+bool nsImapMailFolder::ShouldCheckAllFolders(
+    nsIImapIncomingServer* imapServer) {
+  // Check legacy global preference to see if we should check all folders for
+  // new messages, or just the inbox and marked ones.
+  bool checkAllFolders = false;
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch =
+      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, false);
+  // This pref might not exist, which is OK.
+  (void)prefBranch->GetBoolPref("mail.check_all_imap_folders_for_new",
+                                &checkAllFolders);
+
+  if (checkAllFolders) return true;
+
+  // If the legacy preference doesn't exist or has its default value (False),
+  // the true preference is read.
+  imapServer->GetCheckAllFoldersForNew(&checkAllFolders);
+  return checkAllFolders;
+}
+
+// Called by Biff, or when user presses GetMsg button.
+NS_IMETHODIMP nsImapMailFolder::GetNewMessages(nsIMsgWindow* aWindow,
+                                               nsIUrlListener* aListener) {
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
+  if (NS_SUCCEEDED(rv) && rootFolder) {
+    nsCOMPtr<nsIImapIncomingServer> imapServer;
+    rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+    NS_ENSURE_SUCCESS(rv, rv);
+    bool performingBiff = false;
+    nsCOMPtr<nsIMsgIncomingServer> incomingServer =
+        do_QueryInterface(imapServer, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    incomingServer->GetPerformingBiff(&performingBiff);
+    m_urlListener = aListener;
+
+    // See if we should check all folders for new messages, or just the inbox
+    // and marked ones
+    bool checkAllFolders = ShouldCheckAllFolders(imapServer);
+
+    // Get new messages for inbox
+    nsCOMPtr<nsIMsgFolder> inbox;
+    rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox,
+                                        getter_AddRefs(inbox));
+    if (inbox) {
+      nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(inbox, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      imapFolder->SetPerformingBiff(performingBiff);
+      inbox->SetGettingNewMessages(true);
+      rv = inbox->UpdateFolder(aWindow);
+    }
+    // Get new messages for other folders if marked, or all of them if the pref
+    // is set
+    rv = imapServer->GetNewMessagesForNonInboxFolders(
+        rootFolder, aWindow, checkAllFolders, performingBiff);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::Shutdown(bool shutdownChildren) {
+  m_filterList = nullptr;
+  m_initialized = false;
+  // mPath is used to decide if folder pathname needs to be reconstructed in
+  // GetPath().
+  mPath = nullptr;
+  m_moveCoalescer = nullptr;
+  m_msgParser = nullptr;
+  if (m_playbackTimer) {
+    m_playbackTimer->Cancel();
+    m_playbackTimer = nullptr;
+  }
+  m_pendingOfflineMoves.Clear();
+  return nsMsgDBFolder::Shutdown(shutdownChildren);
+}
+
+nsresult nsImapMailFolder::GetBodysToDownload(
+    nsTArray<nsMsgKey>* keysOfMessagesToDownload) {
+  NS_ENSURE_ARG(keysOfMessagesToDownload);
+  NS_ENSURE_TRUE(mDatabase, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIMsgEnumerator> enumerator;
+  nsresult rv = mDatabase->EnumerateMessages(getter_AddRefs(enumerator));
+  if (NS_SUCCEEDED(rv) && enumerator) {
+    bool hasMore;
+    nsCOMPtr<nsIMsgDBHdr> header;
+    nsMsgKey msgKey;
+    while (NS_SUCCEEDED(rv = enumerator->HasMoreElements(&hasMore)) &&
+           hasMore) {
+      rv = enumerator->GetNext(getter_AddRefs(header));
+      NS_ENSURE_SUCCESS(rv, rv);
+      bool shouldStoreMsgOffline = false;
+      header->GetMessageKey(&msgKey);
+      // MsgFitsDownloadCriteria ignores nsMsgFolderFlags::Offline, which we
+      // want
+      if (m_downloadingFolderForOfflineUse)
+        MsgFitsDownloadCriteria(msgKey, &shouldStoreMsgOffline);
+      else
+        ShouldStoreMsgOffline(msgKey, &shouldStoreMsgOffline);
+      if (shouldStoreMsgOffline)
+        keysOfMessagesToDownload->AppendElement(msgKey);
+    }
+    if (MOZ_LOG_TEST(gAutoSyncLog, mozilla::LogLevel::Debug) && header) {
+      // Log this only if folder is not empty.
+      uint32_t msgFlags = 0;
+      header->GetFlags(&msgFlags);
+      MOZ_LOG(gAutoSyncLog, mozilla::LogLevel::Debug,
+              ("%s: num keys to download=%zu, last key=%d, last msg flag=0x%x "
+               "nsMsgMessageFlags::Offline=0x%x",
+               __func__, keysOfMessagesToDownload->Length(), msgKey, msgFlags,
+               nsMsgMessageFlags::Offline));
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::OnNewIdleMessages() {
+  nsresult rv;
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool checkAllFolders = ShouldCheckAllFolders(imapServer);
+
+  // only trigger biff if we're checking all new folders for new messages, or
+  // this particular folder, but excluding trash,junk, sent, and no select
+  // folders, by default.
+  if ((checkAllFolders &&
+       !(mFlags &
+         (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Junk |
+          nsMsgFolderFlags::SentMail | nsMsgFolderFlags::ImapNoselect))) ||
+      (mFlags & (nsMsgFolderFlags::CheckNew | nsMsgFolderFlags::Inbox)))
+    SetPerformingBiff(true);
+  return UpdateFolder(nullptr);
+}
+
+NS_IMETHODIMP nsImapMailFolder::UpdateImapMailboxInfo(
+    nsIImapProtocol* aProtocol, nsIMailboxSpec* aSpec) {
+  nsresult rv;
+  ChangeNumPendingTotalMessages(-mNumPendingTotalMessages);
+  ChangeNumPendingUnread(-mNumPendingUnreadMessages);
+  m_numServerRecentMessages = 0;  // clear this since we selected the folder.
+
+  if (!mDatabase) GetDatabase();
+
+  bool folderSelected;
+  rv = aSpec->GetFolderSelected(&folderSelected);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsTArray<nsMsgKey> existingKeys;
+  nsTArray<nsMsgKey> keysToDelete;
+  uint32_t numNewUnread;
+  nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+  int32_t imapUIDValidity = 0;
+  if (mDatabase) {
+    rv = mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+    if (NS_SUCCEEDED(rv) && dbFolderInfo) {
+      dbFolderInfo->GetImapUidValidity(&imapUIDValidity);
+      uint64_t mailboxHighestModSeq;
+      aSpec->GetHighestModSeq(&mailboxHighestModSeq);
+      MOZ_LOG(IMAP_CS, mozilla::LogLevel::Debug,
+              ("UpdateImapMailboxInfo(): Store highest MODSEQ=%" PRIu64
+               " for folder=%s",
+               mailboxHighestModSeq, m_onlineFolderName.get()));
+      char intStrBuf[40];
+      PR_snprintf(intStrBuf, sizeof(intStrBuf), "%llu", mailboxHighestModSeq);
+      dbFolderInfo->SetCharProperty(kModSeqPropertyName,
+                                    nsDependentCString(intStrBuf));
+    }
+    nsTArray<nsMsgKey> keys;
+    rv = mDatabase->ListAllKeys(keys);
+    NS_ENSURE_SUCCESS(rv, rv);
+    existingKeys.AppendElements(keys);
+    nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb =
+        do_QueryInterface(mDatabase, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    opsDb->ListAllOfflineDeletes(existingKeys);
+  }
+  int32_t folderValidity;
+  aSpec->GetFolder_UIDVALIDITY(&folderValidity);
+  nsCOMPtr<nsIImapFlagAndUidState> flagState;
+  aSpec->GetFlagState(getter_AddRefs(flagState));
+
+  // remember what the supported user flags are.
+  uint32_t supportedUserFlags;
+  aSpec->GetSupportedUserFlags(&supportedUserFlags);
+  SetSupportedUserFlags(supportedUserFlags);
+
+  m_uidValidity = folderValidity;
+
+  if (imapUIDValidity != folderValidity) {
+    NS_ASSERTION(imapUIDValidity == kUidUnknown,
+                 "uid validity seems to have changed, blowing away db");
+    nsCOMPtr<nsIFile> pathFile;
+    rv = GetFilePath(getter_AddRefs(pathFile));
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIMsgDBService> msgDBService =
+        do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIDBFolderInfo> transferInfo;
+    if (dbFolderInfo)
+      dbFolderInfo->GetTransferInfo(getter_AddRefs(transferInfo));
+
+    // A backup message database might have been created earlier, for example
+    // if the user requested a reindex. We'll use the earlier one if we can,
+    // otherwise we'll try to backup at this point.
+    nsresult rvbackup = OpenBackupMsgDatabase();
+    if (mDatabase) {
+      dbFolderInfo = nullptr;
+      if (NS_FAILED(rvbackup)) {
+        CloseAndBackupFolderDB(EmptyCString());
+        if (NS_FAILED(OpenBackupMsgDatabase()) && mBackupDatabase) {
+          mBackupDatabase->RemoveListener(this);
+          mBackupDatabase = nullptr;
+        }
+      } else
+        mDatabase->ForceClosed();
+    }
+    mDatabase = nullptr;
+
+    nsCOMPtr<nsIFile> summaryFile;
+    rv = GetSummaryFileLocation(pathFile, getter_AddRefs(summaryFile));
+    // Remove summary file.
+    if (NS_SUCCEEDED(rv) && summaryFile) summaryFile->Remove(false);
+
+    // Create a new summary file, update the folder message counts, and
+    // Close the summary file db.
+    rv = msgDBService->CreateNewDB(this, getter_AddRefs(mDatabase));
+
+    if (NS_FAILED(rv) && mDatabase) {
+      mDatabase->ForceClosed();
+      mDatabase = nullptr;
+    } else if (NS_SUCCEEDED(rv) && mDatabase) {
+      if (transferInfo) SetDBTransferInfo(transferInfo);
+
+      SummaryChanged();
+      if (mDatabase) {
+        if (mAddListener) mDatabase->AddListener(this);
+        rv = mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+      }
+    }
+    // store the new UIDVALIDITY value
+
+    if (NS_SUCCEEDED(rv) && dbFolderInfo) {
+      dbFolderInfo->SetImapUidValidity(folderValidity);
+      // need to forget highest mod seq when uid validity rolls.
+      MOZ_LOG(IMAP_CS, mozilla::LogLevel::Debug,
+              ("UpdateImapMailboxInfo(): UIDVALIDITY changed, reset highest "
+               "MODSEQ and UID for folder=%s",
+               m_onlineFolderName.get()));
+      dbFolderInfo->SetCharProperty(kModSeqPropertyName, EmptyCString());
+      dbFolderInfo->SetUint32Property(kHighestRecordedUIDPropertyName, 0);
+    }
+    // delete all my msgs, the keys are bogus now
+    // add every message in this folder
+    existingKeys.Clear();
+    //      keysToDelete.CopyArray(&existingKeys);
+
+    if (flagState) {
+      nsTArray<nsMsgKey> no_existingKeys;
+      FindKeysToAdd(no_existingKeys, m_keysToFetch, numNewUnread, flagState);
+    }
+    if (NS_FAILED(rv)) pathFile->Remove(false);
+
+  } else if (!flagState /*&& !NET_IsOffline() */)  // if there are no messages
+                                                   // on the server
+    keysToDelete = existingKeys.Clone();
+  else /* if ( !NET_IsOffline()) */
+  {
+    uint32_t boxFlags;
+    aSpec->GetBox_flags(&boxFlags);
+    // FindKeysToDelete and FindKeysToAdd require sorted lists
+    existingKeys.Sort();
+    FindKeysToDelete(existingKeys, keysToDelete, flagState, boxFlags);
+    // if this is the result of an expunge then don't grab headers
+    if (!(boxFlags & kJustExpunged))
+      FindKeysToAdd(existingKeys, m_keysToFetch, numNewUnread, flagState);
+  }
+  m_totalKeysToFetch = m_keysToFetch.Length();
+  if (!keysToDelete.IsEmpty() && mDatabase) {
+    nsTArray<RefPtr<nsIMsgDBHdr>> hdrsToDelete;
+    MsgGetHeadersFromKeys(mDatabase, keysToDelete, hdrsToDelete);
+    // Notify nsIMsgFolderListeners of a mass delete, but only if we actually
+    // have headers
+    if (!hdrsToDelete.IsEmpty()) {
+      nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+          do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+      if (notifier) notifier->NotifyMsgsDeleted(hdrsToDelete);
+    }
+    DeleteStoreMessages(hdrsToDelete);
+    EnableNotifications(nsIMsgFolder::allMessageCountNotifications, false);
+    mDatabase->DeleteMessages(keysToDelete, nullptr);
+    EnableNotifications(nsIMsgFolder::allMessageCountNotifications, true);
+  }
+  int32_t numUnreadFromServer;
+  aSpec->GetNumUnseenMessages(&numUnreadFromServer);
+
+  bool partialUIDFetch;
+  flagState->GetPartialUIDFetch(&partialUIDFetch);
+
+  // For partial UID fetches (i.e., occurs when CONDSTORE in effect), we can
+  // only trust the numUnread from the server. However, even that will only be
+  // correct if a recent imap STATUS occurred as indicated by
+  // numUnreadFromServer greater than -1.
+  if (partialUIDFetch) numNewUnread = numUnreadFromServer;
+
+  // If we are performing biff for this folder, tell the
+  // stand-alone biff about the new high water mark
+  if (m_performingBiff && numNewUnread &&
+      static_cast<int32_t>(numNewUnread) != -1) {
+    // We must ensure that the server knows that we are performing biff.
+    // Otherwise the stand-alone biff won't fire.
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    if (NS_SUCCEEDED(GetServer(getter_AddRefs(server))) && server)
+      server->SetPerformingBiff(true);
+    SetNumNewMessages(numNewUnread);
+  }
+  SyncFlags(flagState);
+  if (mDatabase && numUnreadFromServer > -1 &&
+      (int32_t)(mNumUnreadMessages + m_keysToFetch.Length()) >
+          numUnreadFromServer)
+    mDatabase->SyncCounts();
+
+  if (!m_keysToFetch.IsEmpty() && aProtocol)
+    PrepareToAddHeadersToMailDB(aProtocol);
+  else {
+    bool gettingNewMessages;
+    GetGettingNewMessages(&gettingNewMessages);
+    if (gettingNewMessages)
+      ProgressStatusString(aProtocol, "imapNoNewMessages", nullptr);
+    SetPerformingBiff(false);
+  }
+  aSpec->GetNumMessages(&m_numServerTotalMessages);
+  if (numUnreadFromServer > -1) m_numServerUnseenMessages = numUnreadFromServer;
+  aSpec->GetNumRecentMessages(&m_numServerRecentMessages);
+
+  // some servers don't return UIDNEXT on SELECT - don't crunch
+  // existing values in that case.
+  int32_t nextUID;
+  aSpec->GetNextUID(&nextUID);
+  if (nextUID != (int32_t)nsMsgKey_None) m_nextUID = nextUID;
+
+  return rv;
+}
+
+/**
+ * Called after successful imap STATUS response occurs. Have valid unseen value
+ * if folderstatus URL produced an imap STATUS. If a NOOP occurs instead (doing
+ * folderstatus from a connection SELECTed on the same folder) there is no
+ * UNSEEN returned by NOOP.
+ */
+NS_IMETHODIMP nsImapMailFolder::UpdateImapMailboxStatus(
+    nsIImapProtocol* aProtocol, nsIMailboxSpec* aSpec) {
+  NS_ENSURE_ARG_POINTER(aSpec);
+  int32_t numUnread, numTotal;
+  aSpec->GetNumUnseenMessages(&numUnread);
+  aSpec->GetNumMessages(&numTotal);
+  aSpec->GetNumRecentMessages(&m_numServerRecentMessages);
+  int32_t prevNextUID = m_nextUID;
+  aSpec->GetNextUID(&m_nextUID);
+  bool summaryChanged = false;
+
+  // If m_numServerUnseenMessages is 0, it means
+  // this is the first time we've done a Status.
+  // In that case, we count all the previous pending unread messages we know
+  // about as unread messages. We may want to do similar things with total
+  // messages, but the total messages include deleted messages if the folder
+  // hasn't been expunged.
+  int32_t previousUnreadMessages =
+      (m_numServerUnseenMessages)
+          ? m_numServerUnseenMessages
+          : mNumPendingUnreadMessages + mNumUnreadMessages;
+  if (numUnread == -1) {
+    // A noop occurred so don't know server's UNSEEN number, keep using the
+    // previously known unread count.
+    MOZ_LOG(IMAP, mozilla::LogLevel::Debug,
+            ("%s: folder=%s, unread was -1, set numUnread to previousUnread=%d",
+             __func__, m_onlineFolderName.get(), previousUnreadMessages));
+    numUnread = previousUnreadMessages;
+  }
+  if (numUnread != previousUnreadMessages || m_nextUID != prevNextUID) {
+    int32_t unreadDelta =
+        numUnread - (mNumPendingUnreadMessages + mNumUnreadMessages);
+    if (numUnread - previousUnreadMessages != unreadDelta)
+      NS_WARNING("unread count should match server count");
+    ChangeNumPendingUnread(unreadDelta);
+    if (unreadDelta > 0 &&
+        !(mFlags & (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Junk))) {
+      SetHasNewMessages(true);
+      SetNumNewMessages(unreadDelta);
+      SetBiffState(nsMsgBiffState_NewMail);
+    }
+    summaryChanged = true;
+  }
+  SetPerformingBiff(false);
+  if (m_numServerUnseenMessages != numUnread ||
+      m_numServerTotalMessages != numTotal) {
+    if (numUnread > m_numServerUnseenMessages ||
+        m_numServerTotalMessages > numTotal)
+      NotifyHasPendingMsgs();
+    summaryChanged = true;
+    m_numServerUnseenMessages = numUnread;
+    m_numServerTotalMessages = numTotal;
+  }
+  if (summaryChanged) SummaryChanged();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::ParseMsgHdrs(
+    nsIImapProtocol* aProtocol, nsIImapHeaderXferInfo* aHdrXferInfo) {
+  NS_ENSURE_ARG_POINTER(aHdrXferInfo);
+  int32_t numHdrs;
+  nsCOMPtr<nsIImapHeaderInfo> headerInfo;
+  nsCOMPtr<nsIImapUrl> aImapUrl;
+  nsImapAction imapAction = nsIImapUrl::nsImapTest;  // unused value.
+  if (!mDatabase) GetDatabase();
+
+  nsresult rv = aHdrXferInfo->GetNumHeaders(&numHdrs);
+  if (aProtocol) {
+    (void)aProtocol->GetRunningImapURL(getter_AddRefs(aImapUrl));
+    if (aImapUrl) aImapUrl->GetImapAction(&imapAction);
+  }
+  for (uint32_t i = 0; NS_SUCCEEDED(rv) && (int32_t)i < numHdrs; i++) {
+    rv = aHdrXferInfo->GetHeader(i, getter_AddRefs(headerInfo));
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!headerInfo) break;
+    int32_t msgSize;
+    nsMsgKey msgKey;
+    bool containsKey;
+    nsCString msgHdrs;
+    headerInfo->GetMsgSize(&msgSize);
+    headerInfo->GetMsgUid(&msgKey);
+    if (msgKey == nsMsgKey_None)  // not a valid uid.
+      continue;
+    if (imapAction == nsIImapUrl::nsImapMsgPreview) {
+      nsCOMPtr<nsIMsgDBHdr> msgHdr;
+      headerInfo->GetMsgHdrs(msgHdrs);
+      // create an input stream based on the hdr string.
+      nsCOMPtr<nsIStringInputStream> inputStream =
+          do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      inputStream->ShareData(msgHdrs.get(), msgHdrs.Length());
+      GetMessageHeader(msgKey, getter_AddRefs(msgHdr));
+      if (msgHdr) {
+        GetMsgPreviewTextFromStream(msgHdr, inputStream);
+      }
+      continue;
+    }
+    if (mDatabase &&
+        NS_SUCCEEDED(mDatabase->ContainsKey(msgKey, &containsKey)) &&
+        containsKey) {
+      NS_ERROR("downloading hdrs for hdr we already have");
+      continue;
+    }
+    nsresult rv = SetupHeaderParseStream(msgSize, EmptyCString(), nullptr);
+    NS_ENSURE_SUCCESS(rv, rv);
+    headerInfo->GetMsgHdrs(msgHdrs);
+    rv = ParseAdoptedHeaderLine(msgHdrs.get(), msgKey);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = NormalEndHeaderParseStream(aProtocol, aImapUrl);
+  }
+  return rv;
+}
+
+nsresult nsImapMailFolder::SetupHeaderParseStream(
+    uint32_t aSize, const nsACString& content_type, nsIMailboxSpec* boxSpec) {
+  if (!mDatabase) GetDatabase();
+  m_nextMessageByteLength = aSize;
+  if (!m_msgParser) {
+    nsresult rv;
+    m_msgParser = do_CreateInstance(kParseMailMsgStateCID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+  } else
+    m_msgParser->Clear();
+
+  m_msgParser->SetMailDB(mDatabase);
+  if (mBackupDatabase) m_msgParser->SetBackupMailDB(mBackupDatabase);
+  return m_msgParser->SetState(nsIMsgParseMailMsgState::ParseHeadersState);
+}
+
+nsresult nsImapMailFolder::ParseAdoptedHeaderLine(const char* aMessageLine,
+                                                  nsMsgKey aMsgKey) {
+  // we can get blocks that contain more than one line,
+  // but they never contain partial lines
+  const char* str = aMessageLine;
+  m_curMsgUid = aMsgKey;
+  m_msgParser->SetNewKey(m_curMsgUid);
+  // m_envelope_pos, for local folders,
+  // is the msg key. Setting this will set the msg key for the new header.
+
+  int32_t len = strlen(str);
+  char* currentEOL = PL_strstr(str, MSG_LINEBREAK);
+  const char* currentLine = str;
+  while (currentLine < (str + len)) {
+    if (currentEOL) {
+      m_msgParser->ParseAFolderLine(
+          currentLine, (currentEOL + MSG_LINEBREAK_LEN) - currentLine);
+      currentLine = currentEOL + MSG_LINEBREAK_LEN;
+      currentEOL = PL_strstr(currentLine, MSG_LINEBREAK);
+    } else {
+      m_msgParser->ParseAFolderLine(currentLine, PL_strlen(currentLine));
+      currentLine = str + len + 1;
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsImapMailFolder::NormalEndHeaderParseStream(
+    nsIImapProtocol* aProtocol, nsIImapUrl* imapUrl) {
+  nsCOMPtr<nsIMsgDBHdr> newMsgHdr;
+  nsresult rv;
+  NS_ENSURE_TRUE(m_msgParser, NS_ERROR_NULL_POINTER);
+
+  nsMailboxParseState parseState;
+  m_msgParser->GetState(&parseState);
+  if (parseState == nsIMsgParseMailMsgState::ParseHeadersState)
+    m_msgParser->ParseAFolderLine(CRLF, 2);
+  rv = m_msgParser->GetNewMsgHdr(getter_AddRefs(newMsgHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  char* headers;
+  int32_t headersSize;
+
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+  nsCOMPtr<nsIMsgMailNewsUrl> msgUrl;
+  if (imapUrl) {
+    msgUrl = do_QueryInterface(imapUrl, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    msgUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+  }
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryInterface(server);
+  rv = imapServer->GetIsGMailServer(&m_isGmailServer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  newMsgHdr->SetMessageKey(m_curMsgUid);
+  TweakHeaderFlags(aProtocol, newMsgHdr);
+  uint32_t messageSize;
+  if (NS_SUCCEEDED(newMsgHdr->GetMessageSize(&messageSize)))
+    mFolderSize += messageSize;
+  m_msgMovedByFilter = false;
+
+  nsMsgKey highestUID = 0;
+  nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+  if (mDatabase) mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+  if (dbFolderInfo)
+    dbFolderInfo->GetUint32Property(kHighestRecordedUIDPropertyName, 0,
+                                    &highestUID);
+
+  // If this is the inbox, try to apply filters. Otherwise, test the inherited
+  // folder property "applyIncomingFilters" (which defaults to empty). If this
+  // inherited property has the string value "true", then apply filters even
+  // if this is not the Inbox folder.
+  if (mFlags & nsMsgFolderFlags::Inbox || m_applyIncomingFilters) {
+    // Use highwater to determine whether to filter?
+    bool filterOnHighwater = false;
+    nsCOMPtr<nsIPrefBranch> prefBranch(
+        do_GetService(NS_PREFSERVICE_CONTRACTID));
+    if (prefBranch)
+      prefBranch->GetBoolPref("mail.imap.filter_on_new", &filterOnHighwater);
+
+    uint32_t msgFlags;
+    newMsgHdr->GetFlags(&msgFlags);
+
+    // clang-format off
+    bool doFilter = filterOnHighwater
+      // Filter on largest UUID and not deleted.
+      ? m_curMsgUid > highestUID && !(msgFlags & nsMsgMessageFlags::IMAPDeleted)
+      // Filter on unread and not deleted.
+      : !(msgFlags & (nsMsgMessageFlags::Read | nsMsgMessageFlags::IMAPDeleted));
+    // clang-format on
+
+    if (doFilter)
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+              ("(Imap) New message parsed, and filters will be run on it"));
+    else
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+              ("(Imap) New message parsed, but filters will not be run on it"));
+
+    if (doFilter) {
+      int32_t duplicateAction = nsIMsgIncomingServer::keepDups;
+      if (server) server->GetIncomingDuplicateAction(&duplicateAction);
+      if ((duplicateAction != nsIMsgIncomingServer::keepDups) &&
+          mFlags & nsMsgFolderFlags::Inbox) {
+        bool isDup;
+        server->IsNewHdrDuplicate(newMsgHdr, &isDup);
+        if (isDup) {
+          // we want to do something similar to applying filter hits.
+          // if a dup is marked read, it shouldn't trigger biff.
+          // Same for deleting it or moving it to trash.
+          switch (duplicateAction) {
+            case nsIMsgIncomingServer::deleteDups: {
+              uint32_t newFlags;
+              newMsgHdr->OrFlags(
+                  nsMsgMessageFlags::Read | nsMsgMessageFlags::IMAPDeleted,
+                  &newFlags);
+              StoreImapFlags(kImapMsgSeenFlag | kImapMsgDeletedFlag, true,
+                             {m_curMsgUid}, nullptr);
+              m_msgMovedByFilter = true;
+            } break;
+            case nsIMsgIncomingServer::moveDupsToTrash: {
+              nsCOMPtr<nsIMsgFolder> trash;
+              GetTrashFolder(getter_AddRefs(trash));
+              if (trash) {
+                nsCString trashUri;
+                trash->GetURI(trashUri);
+                nsresult err = MoveIncorporatedMessage(
+                    newMsgHdr, mDatabase, trashUri, nullptr, msgWindow);
+                if (NS_SUCCEEDED(err)) m_msgMovedByFilter = true;
+              }
+            } break;
+            case nsIMsgIncomingServer::markDupsRead: {
+              uint32_t newFlags;
+              newMsgHdr->OrFlags(nsMsgMessageFlags::Read, &newFlags);
+              StoreImapFlags(kImapMsgSeenFlag, true, {m_curMsgUid}, nullptr);
+            } break;
+          }
+          int32_t numNewMessages;
+          GetNumNewMessages(false, &numNewMessages);
+          SetNumNewMessages(numNewMessages - 1);
+        }
+      }
+      rv = m_msgParser->GetAllHeaders(&headers, &headersSize);
+
+      if (NS_SUCCEEDED(rv) && headers && !m_msgMovedByFilter &&
+          !m_filterListRequiresBody) {
+        if (m_filterList) {
+          GetMoveCoalescer();  // not sure why we're doing this here.
+          MOZ_LOG(FILTERLOGMODULE, LogLevel::Debug,
+                  ("(Imap) ApplyFilterToHdr from "
+                   "nsImapMailFolder::NormalEndHeaderParseStream()"));
+          m_filterList->ApplyFiltersToHdr(
+              nsMsgFilterType::InboxRule, newMsgHdr, this, mDatabase,
+              nsDependentCSubstring(headers, headersSize), this, msgWindow);
+          NotifyFolderEvent(kFiltersApplied);
+        }
+      }
+    }
+  }
+  // here we need to tweak flags from uid state..
+  if (mDatabase && (!m_msgMovedByFilter || ShowDeletedMessages())) {
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+    // Check if this header corresponds to a pseudo header
+    // we have from doing a pseudo-offline move and then downloading
+    // the real header from the server. In that case, we notify
+    // db/folder listeners that the pseudo-header has become the new
+    // header, i.e., the key has changed.
+    nsCString newMessageId;
+    newMsgHdr->GetMessageId(getter_Copies(newMessageId));
+    nsMsgKey pseudoKey =
+        m_pseudoHdrs.MaybeGet(newMessageId).valueOr(nsMsgKey_None);
+    if (notifier && pseudoKey != nsMsgKey_None) {
+      notifier->NotifyMsgKeyChanged(pseudoKey, newMsgHdr);
+      m_pseudoHdrs.Remove(newMessageId);
+    }
+    mDatabase->AddNewHdrToDB(newMsgHdr, true);
+    if (notifier) notifier->NotifyMsgAdded(newMsgHdr);
+    // mark the header as not yet reported classified
+    OrProcessingFlags(m_curMsgUid, nsMsgProcessingFlags::NotReportedClassified);
+  }
+  // adjust highestRecordedUID
+  if (dbFolderInfo) {
+    if (m_curMsgUid > highestUID) {
+      MOZ_LOG(IMAP_CS, mozilla::LogLevel::Debug,
+              ("NormalEndHeaderParseStream(): Store new highest UID=%" PRIu32
+               " for folder=%s",
+               m_curMsgUid, m_onlineFolderName.get()));
+      dbFolderInfo->SetUint32Property(kHighestRecordedUIDPropertyName,
+                                      m_curMsgUid);
+    }
+  }
+
+  if (m_isGmailServer) {
+    nsCOMPtr<nsIImapFlagAndUidState> flagState;
+    aProtocol->GetFlagAndUidState(getter_AddRefs(flagState));
+    nsCString msgIDValue;
+    nsCString threadIDValue;
+    nsCString labelsValue;
+    flagState->GetCustomAttribute(m_curMsgUid, "X-GM-MSGID"_ns, msgIDValue);
+    flagState->GetCustomAttribute(m_curMsgUid, "X-GM-THRID"_ns, threadIDValue);
+    flagState->GetCustomAttribute(m_curMsgUid, "X-GM-LABELS"_ns, labelsValue);
+    newMsgHdr->SetStringProperty("X-GM-MSGID", msgIDValue);
+    newMsgHdr->SetStringProperty("X-GM-THRID", threadIDValue);
+    newMsgHdr->SetStringProperty("X-GM-LABELS", labelsValue);
+  }
+
+  m_msgParser->Clear();  // clear out parser, because it holds onto a msg hdr.
+  m_msgParser->SetMailDB(nullptr);  // tell it to let go of the db too.
+  // I don't think we want to do this - it does bad things like set the size
+  // incorrectly.
+  //    m_msgParser->FinishHeader();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::AbortHeaderParseStream(
+    nsIImapProtocol* aProtocol) {
+  nsresult rv = NS_ERROR_FAILURE;
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::BeginCopy() {
+  NS_ENSURE_TRUE(m_copyState, NS_ERROR_NULL_POINTER);
+  nsresult rv;
+  if (m_copyState->m_tmpFile)  // leftover file spec nuke it
+  {
+    rv = m_copyState->m_tmpFile->Remove(false);
+    if (NS_FAILED(rv)) {
+      nsCString nativePath = m_copyState->m_tmpFile->HumanReadablePath();
+      MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+              ("couldn't remove prev temp file %s: %" PRIx32, nativePath.get(),
+               static_cast<uint32_t>(rv)));
+    }
+    m_copyState->m_tmpFile = nullptr;
+  }
+
+  rv = NS_OpenAnonymousTemporaryNsIFile(getter_AddRefs(m_copyState->m_tmpFile));
+  if (NS_FAILED(rv)) {
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("Couldn't create temp file: %" PRIx32, static_cast<uint32_t>(rv)));
+    OnCopyCompleted(m_copyState->m_srcSupport, rv);
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIOutputStream> fileOutputStream;
+  rv = MsgNewBufferedFileOutputStream(
+      getter_AddRefs(m_copyState->m_msgFileStream), m_copyState->m_tmpFile, -1,
+      00600);
+  if (NS_FAILED(rv))
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("couldn't create output file stream: %" PRIx32,
+             static_cast<uint32_t>(rv)));
+
+  if (!m_copyState->m_dataBuffer)
+    m_copyState->m_dataBuffer = (char*)PR_CALLOC(COPY_BUFFER_SIZE + 1);
+  NS_ENSURE_TRUE(m_copyState->m_dataBuffer, NS_ERROR_OUT_OF_MEMORY);
+  m_copyState->m_dataBufferSize = COPY_BUFFER_SIZE;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::CopyDataToOutputStreamForAppend(
+    nsIInputStream* aIStream, int32_t aLength, nsIOutputStream* outputStream) {
+  uint32_t readCount;
+  uint32_t writeCount;
+  if (!m_copyState) m_copyState = new nsImapMailCopyState();
+
+  if (aLength + m_copyState->m_leftOver > m_copyState->m_dataBufferSize) {
+    char* newBuffer = (char*)PR_REALLOC(m_copyState->m_dataBuffer,
+                                        aLength + m_copyState->m_leftOver + 1);
+    NS_ENSURE_TRUE(newBuffer, NS_ERROR_OUT_OF_MEMORY);
+    m_copyState->m_dataBuffer = newBuffer;
+    m_copyState->m_dataBufferSize = aLength + m_copyState->m_leftOver;
+  }
+
+  char *start, *end;
+  uint32_t linebreak_len = 1;
+
+  nsresult rv = aIStream->Read(
+      m_copyState->m_dataBuffer + m_copyState->m_leftOver, aLength, &readCount);
+  if (NS_FAILED(rv)) return rv;
+
+  m_copyState->m_leftOver += readCount;
+  m_copyState->m_dataBuffer[m_copyState->m_leftOver] = '\0';
+
+  start = m_copyState->m_dataBuffer;
+  if (m_copyState->m_eatLF) {
+    if (*start == '\n') start++;
+    m_copyState->m_eatLF = false;
+  }
+  end = PL_strpbrk(start, "\r\n");
+  if (end && *end == '\r' && *(end + 1) == '\n') linebreak_len = 2;
+
+  while (start && end) {
+    if (PL_strncasecmp(start, "X-Mozilla-Status:", 17) &&
+        PL_strncasecmp(start, "X-Mozilla-Status2:", 18) &&
+        PL_strncmp(start, "From - ", 7)) {
+      rv = outputStream->Write(start, end - start, &writeCount);
+      rv = outputStream->Write(CRLF, 2, &writeCount);
+    }
+    start = end + linebreak_len;
+    if (start >= m_copyState->m_dataBuffer + m_copyState->m_leftOver) {
+      m_copyState->m_leftOver = 0;
+      break;
+    }
+    linebreak_len = 1;
+
+    end = PL_strpbrk(start, "\r\n");
+    if (end && *end == '\r') {
+      if (*(end + 1) == '\n')
+        linebreak_len = 2;
+      else if (!*(end + 1))  // block might have split CRLF so remember if
+        m_copyState->m_eatLF = true;  // we should eat LF
+    }
+
+    if (start && !end) {
+      m_copyState->m_leftOver -= (start - m_copyState->m_dataBuffer);
+      memcpy(m_copyState->m_dataBuffer, start,
+             m_copyState->m_leftOver + 1);  // including null
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::CopyDataDone() {
+  m_copyState = nullptr;
+  return NS_OK;
+}
+
+// sICopyMessageListener methods, BeginCopy, CopyData, EndCopy, EndMove,
+// StartMessage, EndMessage
+NS_IMETHODIMP nsImapMailFolder::CopyData(nsIInputStream* aIStream,
+                                         int32_t aLength) {
+  NS_ENSURE_TRUE(
+      m_copyState && m_copyState->m_msgFileStream && m_copyState->m_dataBuffer,
+      NS_ERROR_NULL_POINTER);
+  nsresult rv = CopyDataToOutputStreamForAppend(aIStream, aLength,
+                                                m_copyState->m_msgFileStream);
+  if (NS_FAILED(rv)) {
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("CopyData failed: %" PRIx32, static_cast<uint32_t>(rv)));
+    OnCopyCompleted(m_copyState->m_srcSupport, rv);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::EndCopy(bool copySucceeded) {
+  nsresult rv = copySucceeded ? NS_OK : NS_ERROR_FAILURE;
+  if (copySucceeded && m_copyState && m_copyState->m_msgFileStream) {
+    nsCOMPtr<nsIUrlListener> urlListener;
+    m_copyState->m_msgFileStream->Close();
+    // m_tmpFile can be stale because we wrote to it
+    nsCOMPtr<nsIFile> tmpFile;
+    m_copyState->m_tmpFile->Clone(getter_AddRefs(tmpFile));
+    m_copyState->m_tmpFile = tmpFile;
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv =
+        QueryInterface(NS_GET_IID(nsIUrlListener), getter_AddRefs(urlListener));
+    rv = imapService->AppendMessageFromFile(
+        m_copyState->m_tmpFile, this, EmptyCString(), true,
+        m_copyState->m_selectedState, urlListener, m_copyState,
+        m_copyState->m_msgWindow);
+  }
+  if (NS_FAILED(rv) || !copySucceeded)
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("EndCopy failed: %" PRIx32, static_cast<uint32_t>(rv)));
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::EndMove(bool moveSucceeded) { return NS_OK; }
+// this is the beginning of the next message copied
+NS_IMETHODIMP nsImapMailFolder::StartMessage() { return NS_OK; }
+
+// just finished the current message.
+NS_IMETHODIMP nsImapMailFolder::EndMessage(nsMsgKey key) { return NS_OK; }
+
+NS_IMETHODIMP nsImapMailFolder::ApplyFilterHit(nsIMsgFilter* filter,
+                                               nsIMsgWindow* msgWindow,
+                                               bool* applyMore) {
+  //
+  //  This routine is called indirectly from ApplyFiltersToHdr in two
+  //  circumstances, controlled by m_filterListRequiresBody:
+  //
+  //  If false, after headers are parsed in NormalEndHeaderParseStream.
+  //  If true, after the message body is downloaded in NormalEndMsgWriteStream.
+  //
+  //  In NormalEndHeaderParseStream, the message has not been added to the
+  //  database, and it is important that database notifications and count
+  //  updates do not occur. In NormalEndMsgWriteStream, the message has been
+  //  added to the database, and database notifications and count updates
+  //  should be performed.
+  //
+
+  NS_ENSURE_ARG_POINTER(filter);
+  NS_ENSURE_ARG_POINTER(applyMore);
+
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr;
+  if (m_filterListRequiresBody)
+    GetMessageHeader(m_curMsgUid, getter_AddRefs(msgHdr));
+  else if (m_msgParser)
+    m_msgParser->GetNewMsgHdr(getter_AddRefs(msgHdr));
+  NS_ENSURE_TRUE(msgHdr,
+                 NS_ERROR_NULL_POINTER);  // fatal error, cannot apply filters
+
+  bool deleteToTrash = DeleteIsMoveToTrash();
+
+  nsTArray<RefPtr<nsIMsgRuleAction>> filterActionList;
+  rv = filter->GetSortedActionList(filterActionList);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t numActions = filterActionList.Length();
+
+  nsCString msgId;
+  msgHdr->GetMessageId(getter_Copies(msgId));
+  nsMsgKey msgKey;
+  msgHdr->GetMessageKey(&msgKey);
+  MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+          ("(Imap) Applying %" PRIu32
+           " filter actions on message with key %" PRIu32,
+           numActions, msgKeyToInt(msgKey)));
+  MOZ_LOG(FILTERLOGMODULE, LogLevel::Debug,
+          ("(Imap) Message ID: %s", msgId.get()));
+
+  bool loggingEnabled = false;
+  if (m_filterList && numActions)
+    (void)m_filterList->GetLoggingEnabled(&loggingEnabled);
+
+  bool msgIsNew = true;
+
+  rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsresult finalResult = NS_OK;  // result of all actions
+  for (uint32_t actionIndex = 0; actionIndex < numActions; actionIndex++) {
+    nsCOMPtr<nsIMsgRuleAction> filterAction(filterActionList[actionIndex]);
+    if (!filterAction) {
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Warning,
+              ("(Imap) Filter action at index %" PRIu32 " invalid, skipping",
+               actionIndex));
+      continue;
+    }
+
+    rv = NS_OK;  // result of the current action
+    nsMsgRuleActionType actionType;
+    if (NS_SUCCEEDED(filterAction->GetType(&actionType))) {
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+              ("(Imap) Running filter action at index %" PRIu32
+               ", action type = %i",
+               actionIndex, actionType));
+      if (loggingEnabled) (void)filter->LogRuleHit(filterAction, msgHdr);
+
+      nsCString actionTargetFolderUri;
+      if (actionType == nsMsgFilterAction::MoveToFolder ||
+          actionType == nsMsgFilterAction::CopyToFolder) {
+        rv = filterAction->GetTargetFolderUri(actionTargetFolderUri);
+        if (NS_FAILED(rv) || actionTargetFolderUri.IsEmpty()) {
+          // clang-format off
+          MOZ_LOG(FILTERLOGMODULE, LogLevel::Warning,
+                  ("(Imap) Target URI for Copy/Move action is empty, skipping"));
+          // clang-format on
+          NS_ASSERTION(false, "actionTargetFolderUri is empty");
+          continue;
+        }
+      }
+
+      uint32_t msgFlags;
+      msgHdr->GetFlags(&msgFlags);
+      bool isRead = (msgFlags & nsMsgMessageFlags::Read);
+
+      switch (actionType) {
+        case nsMsgFilterAction::Delete: {
+          if (deleteToTrash) {
+            // set value to trash folder
+            nsCOMPtr<nsIMsgFolder> mailTrash;
+            rv = GetTrashFolder(getter_AddRefs(mailTrash));
+            if (NS_SUCCEEDED(rv) && mailTrash) {
+              rv = mailTrash->GetURI(actionTargetFolderUri);
+              if (NS_FAILED(rv)) break;
+            }
+            // msgHdr->OrFlags(nsMsgMessageFlags::Read, &newFlags);  // mark
+            // read in trash.
+          } else {
+            mDatabase->MarkHdrRead(msgHdr, true, nullptr);
+            mDatabase->MarkImapDeleted(msgKey, true, nullptr);
+            rv = StoreImapFlags(kImapMsgSeenFlag | kImapMsgDeletedFlag, true,
+                                {msgKey}, nullptr);
+            if (NS_FAILED(rv)) break;
+            // this will prevent us from adding the header to the db.
+            m_msgMovedByFilter = true;
+          }
+          msgIsNew = false;
+        }
+          // note that delete falls through to move.
+          [[fallthrough]];
+        case nsMsgFilterAction::MoveToFolder: {
+          // if moving to a different file, do it.
+          nsCString uri;
+          rv = GetURI(uri);
+          if (NS_FAILED(rv)) break;
+
+          if (!actionTargetFolderUri.Equals(uri)) {
+            msgHdr->GetFlags(&msgFlags);
+            if (msgFlags & nsMsgMessageFlags::MDNReportNeeded && !isRead) {
+              mDatabase->MarkMDNNeeded(msgKey, false, nullptr);
+              mDatabase->MarkMDNSent(msgKey, true, nullptr);
+            }
+            nsresult rv = MoveIncorporatedMessage(
+                msgHdr, mDatabase, actionTargetFolderUri, filter, msgWindow);
+            if (NS_SUCCEEDED(rv)) {
+              m_msgMovedByFilter = true;
+            } else {
+              if (loggingEnabled) {
+                (void)filter->LogRuleHitFail(filterAction, msgHdr, rv,
+                                             "filterFailureMoveFailed"_ns);
+              }
+            }
+          }
+          // don't apply any more filters, even if it was a move to the same
+          // folder
+          *applyMore = false;
+        } break;
+        case nsMsgFilterAction::CopyToFolder: {
+          nsCString uri;
+          rv = GetURI(uri);
+          if (NS_FAILED(rv)) break;
+
+          if (!actionTargetFolderUri.Equals(uri)) {
+            // XXXshaver I'm not actually 100% what the right semantics are for
+            // MDNs and copied messages, but I suspect deep down inside that
+            // we probably want to suppress them only on the copies.
+            msgHdr->GetFlags(&msgFlags);
+            if (msgFlags & nsMsgMessageFlags::MDNReportNeeded && !isRead) {
+              mDatabase->MarkMDNNeeded(msgKey, false, nullptr);
+              mDatabase->MarkMDNSent(msgKey, true, nullptr);
+            }
+
+            nsCOMPtr<nsIMsgFolder> dstFolder;
+            rv = GetExistingFolder(actionTargetFolderUri,
+                                   getter_AddRefs(dstFolder));
+            if (NS_FAILED(rv)) break;
+
+            nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(
+                "@mozilla.org/messenger/messagecopyservice;1", &rv);
+            if (NS_FAILED(rv)) break;
+            rv = copyService->CopyMessages(this, {&*msgHdr}, dstFolder, false,
+                                           nullptr, msgWindow, false);
+            if (NS_FAILED(rv)) {
+              if (loggingEnabled) {
+                (void)filter->LogRuleHitFail(filterAction, msgHdr, rv,
+                                             "filterFailureCopyFailed"_ns);
+              }
+            }
+          }
+        } break;
+        case nsMsgFilterAction::MarkRead: {
+          mDatabase->MarkHdrRead(msgHdr, true, nullptr);
+          rv = StoreImapFlags(kImapMsgSeenFlag, true, {msgKey}, nullptr);
+          msgIsNew = false;
+        } break;
+        case nsMsgFilterAction::MarkUnread: {
+          mDatabase->MarkHdrRead(msgHdr, false, nullptr);
+          rv = StoreImapFlags(kImapMsgSeenFlag, false, {msgKey}, nullptr);
+          msgIsNew = true;
+        } break;
+        case nsMsgFilterAction::MarkFlagged: {
+          mDatabase->MarkHdrMarked(msgHdr, true, nullptr);
+          rv = StoreImapFlags(kImapMsgFlaggedFlag, true, {msgKey}, nullptr);
+        } break;
+        case nsMsgFilterAction::KillThread:
+        case nsMsgFilterAction::WatchThread: {
+          nsCOMPtr<nsIMsgThread> msgThread;
+          nsMsgKey threadKey;
+          mDatabase->GetThreadContainingMsgHdr(msgHdr,
+                                               getter_AddRefs(msgThread));
+          if (msgThread) {
+            msgThread->GetThreadKey(&threadKey);
+            if (actionType == nsMsgFilterAction::KillThread)
+              rv = mDatabase->MarkThreadIgnored(msgThread, threadKey, true,
+                                                nullptr);
+            else
+              rv = mDatabase->MarkThreadWatched(msgThread, threadKey, true,
+                                                nullptr);
+          } else {
+            if (actionType == nsMsgFilterAction::KillThread)
+              rv = msgHdr->SetUint32Property("ProtoThreadFlags",
+                                             nsMsgMessageFlags::Ignored);
+            else
+              rv = msgHdr->SetUint32Property("ProtoThreadFlags",
+                                             nsMsgMessageFlags::Watched);
+          }
+          if (actionType == nsMsgFilterAction::KillThread) {
+            mDatabase->MarkHdrRead(msgHdr, true, nullptr);
+            rv = StoreImapFlags(kImapMsgSeenFlag, true, {msgKey}, nullptr);
+            msgIsNew = false;
+          }
+        } break;
+        case nsMsgFilterAction::KillSubthread: {
+          mDatabase->MarkHeaderKilled(msgHdr, true, nullptr);
+          mDatabase->MarkHdrRead(msgHdr, true, nullptr);
+          rv = StoreImapFlags(kImapMsgSeenFlag, true, {msgKey}, nullptr);
+          msgIsNew = false;
+        } break;
+        case nsMsgFilterAction::ChangePriority: {
+          nsMsgPriorityValue filterPriority;  // a int32_t
+          filterAction->GetPriority(&filterPriority);
+          rv = mDatabase->SetUint32PropertyByHdr(
+              msgHdr, "priority", static_cast<uint32_t>(filterPriority));
+        } break;
+        case nsMsgFilterAction::AddTag: {
+          nsCString keyword;
+          filterAction->GetStrValue(keyword);
+          rv = AddKeywordsToMessages({&*msgHdr}, keyword);
+        } break;
+        case nsMsgFilterAction::JunkScore: {
+          nsAutoCString junkScoreStr;
+          int32_t junkScore;
+          filterAction->GetJunkScore(&junkScore);
+          junkScoreStr.AppendInt(junkScore);
+          rv = mDatabase->SetStringProperty(msgKey, "junkscore", junkScoreStr);
+          mDatabase->SetStringProperty(msgKey, "junkscoreorigin", "filter"_ns);
+
+          // If score is available, set up to store junk status on server.
+          if (junkScore == nsIJunkMailPlugin::IS_SPAM_SCORE ||
+              junkScore == nsIJunkMailPlugin::IS_HAM_SCORE) {
+            nsTArray<nsMsgKey>* keysToClassify = m_moveCoalescer->GetKeyBucket(
+                (junkScore == nsIJunkMailPlugin::IS_SPAM_SCORE) ? 0 : 1);
+            NS_ASSERTION(keysToClassify, "error getting key bucket");
+            if (keysToClassify) keysToClassify->AppendElement(msgKey);
+            if (msgIsNew && junkScore == nsIJunkMailPlugin::IS_SPAM_SCORE) {
+              msgIsNew = false;
+              mDatabase->MarkHdrNotNew(msgHdr, nullptr);
+              // nsMsgDBFolder::SendFlagNotifications by the call to
+              // SetBiffState(nsMsgBiffState_NoMail) will reset numNewMessages
+              // only if the message is also read and database notifications
+              // are active, but we are not going to mark it read in this
+              // action, preferring to leave the choice to the user.
+              // So correct numNewMessages.
+              if (m_filterListRequiresBody) {
+                msgHdr->GetFlags(&msgFlags);
+                if (!(msgFlags & nsMsgMessageFlags::Read)) {
+                  int32_t numNewMessages;
+                  GetNumNewMessages(false, &numNewMessages);
+                  SetNumNewMessages(--numNewMessages);
+                  SetHasNewMessages(numNewMessages != 0);
+                }
+              }
+            }
+          }
+        } break;
+        case nsMsgFilterAction::Forward: {
+          nsCString forwardTo;
+          filterAction->GetStrValue(forwardTo);
+          nsCOMPtr<nsIMsgIncomingServer> server;
+          rv = GetServer(getter_AddRefs(server));
+          if (NS_FAILED(rv)) break;
+          if (!forwardTo.IsEmpty()) {
+            nsCOMPtr<nsIMsgComposeService> compService =
+                do_GetService("@mozilla.org/messengercompose;1", &rv);
+            if (NS_FAILED(rv)) break;
+            rv = compService->ForwardMessage(
+                NS_ConvertUTF8toUTF16(forwardTo), msgHdr, msgWindow, server,
+                nsIMsgComposeService::kForwardAsDefault);
+          }
+        } break;
+
+        case nsMsgFilterAction::Reply: {
+          nsCString replyTemplateUri;
+          filterAction->GetStrValue(replyTemplateUri);
+          nsCOMPtr<nsIMsgIncomingServer> server;
+          rv = GetServer(getter_AddRefs(server));
+          if (NS_FAILED(rv)) break;
+          if (!replyTemplateUri.IsEmpty()) {
+            nsCOMPtr<nsIMsgComposeService> compService =
+                do_GetService("@mozilla.org/messengercompose;1", &rv);
+            if (NS_SUCCEEDED(rv) && compService) {
+              rv = compService->ReplyWithTemplate(msgHdr, replyTemplateUri,
+                                                  msgWindow, server);
+              if (NS_FAILED(rv)) {
+                NS_WARNING("ReplyWithTemplate failed");
+                if (rv == NS_ERROR_ABORT) {
+                  (void)filter->LogRuleHitFail(
+                      filterAction, msgHdr, rv,
+                      "filterFailureSendingReplyAborted"_ns);
+                } else {
+                  (void)filter->LogRuleHitFail(
+                      filterAction, msgHdr, rv,
+                      "filterFailureSendingReplyError"_ns);
+                }
+              }
+            }
+          }
+        } break;
+
+        case nsMsgFilterAction::StopExecution: {
+          // don't apply any more filters
+          *applyMore = false;
+          rv = NS_OK;
+        } break;
+
+        case nsMsgFilterAction::Custom: {
+          nsCOMPtr<nsIMsgFilterCustomAction> customAction;
+          rv = filterAction->GetCustomAction(getter_AddRefs(customAction));
+          if (NS_FAILED(rv)) break;
+
+          nsAutoCString value;
+          rv = filterAction->GetStrValue(value);
+          if (NS_FAILED(rv)) break;
+
+          rv = customAction->ApplyAction({&*msgHdr}, value, nullptr,
+                                         nsMsgFilterType::InboxRule, msgWindow);
+          // allow custom action to affect new
+          msgHdr->GetFlags(&msgFlags);
+          if (!(msgFlags & nsMsgMessageFlags::New)) msgIsNew = false;
+        } break;
+
+        default:
+          NS_ERROR("unexpected filter action");
+          rv = NS_ERROR_UNEXPECTED;
+          break;
+      }
+    }
+    if (NS_FAILED(rv)) {
+      finalResult = rv;
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
+              ("(Imap) Action execution failed with error: %" PRIx32,
+               static_cast<uint32_t>(rv)));
+      if (loggingEnabled) {
+        (void)filter->LogRuleHitFail(filterAction, msgHdr, rv,
+                                     "filterFailureAction"_ns);
+      }
+    } else {
+      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+              ("(Imap) Action execution succeeded"));
+    }
+  }
+  if (!msgIsNew) {
+    int32_t numNewMessages;
+    GetNumNewMessages(false, &numNewMessages);
+    // When database notifications are active, new counts will be reset
+    // to zero in nsMsgDBFolder::SendFlagNotifications by the call to
+    // SetBiffState(nsMsgBiffState_NoMail), so don't repeat them here.
+    if (!m_filterListRequiresBody) SetNumNewMessages(--numNewMessages);
+    if (mDatabase) mDatabase->MarkHdrNotNew(msgHdr, nullptr);
+    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+            ("(Imap) Message will not be marked new"));
+  }
+  MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
+          ("(Imap) Finished executing actions"));
+  return finalResult;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetImapFlags(const char* uids, int32_t flags,
+                                             nsIURI** url) {
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return imapService->SetMessageFlags(this, this, url, nsAutoCString(uids),
+                                      flags, true);
+}
+
+// "this" is the parent folder
+NS_IMETHODIMP nsImapMailFolder::PlaybackOfflineFolderCreate(
+    const nsAString& aFolderName, nsIMsgWindow* aWindow, nsIURI** url) {
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return imapService->CreateFolder(this, aFolderName, this, url);
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::ReplayOfflineMoveCopy(const nsTArray<nsMsgKey>& aMsgKeys,
+                                        bool isMove, nsIMsgFolder* aDstFolder,
+                                        nsIUrlListener* aUrlListener,
+                                        nsIMsgWindow* aWindow,
+                                        bool srcFolderOffline) {
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(aDstFolder);
+  if (imapFolder) {
+    nsImapMailFolder* destImapFolder =
+        static_cast<nsImapMailFolder*>(aDstFolder);
+    nsCOMPtr<nsIMsgDatabase> dstFolderDB;
+    aDstFolder->GetMsgDatabase(getter_AddRefs(dstFolderDB));
+    nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb =
+        do_QueryInterface(dstFolderDB, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (opsDb) {
+      // find the fake header in the destination db, and use that to
+      // set the pending attributes on the real headers. To do this,
+      // we need to iterate over the offline ops in the destination db,
+      // looking for ones with matching keys and source folder uri.
+      // If we find that offline op, its "key" will be the key of the fake
+      // header, so we just need to get the header for that key
+      // from the dest db.
+      nsTArray<nsMsgKey> offlineOps;
+      if (NS_SUCCEEDED(opsDb->ListAllOfflineOpIds(offlineOps))) {
+        nsTArray<RefPtr<nsIMsgDBHdr>> messages;
+        nsCString srcFolderUri;
+        GetURI(srcFolderUri);
+        nsCOMPtr<nsIMsgOfflineImapOperation> currentOp;
+        for (uint32_t opIndex = 0; opIndex < offlineOps.Length(); opIndex++) {
+          opsDb->GetOfflineOpForKey(offlineOps[opIndex], false,
+                                    getter_AddRefs(currentOp));
+          if (currentOp) {
+            nsCString opSrcUri;
+            currentOp->GetSourceFolderURI(opSrcUri);
+            if (opSrcUri.Equals(srcFolderUri)) {
+              nsMsgKey srcMessageKey;
+              currentOp->GetSrcMessageKey(&srcMessageKey);
+              for (auto key : aMsgKeys) {
+                if (srcMessageKey == key) {
+                  nsCOMPtr<nsIMsgDBHdr> fakeDestHdr;
+                  dstFolderDB->GetMsgHdrForKey(offlineOps[opIndex],
+                                               getter_AddRefs(fakeDestHdr));
+                  if (fakeDestHdr) messages.AppendElement(fakeDestHdr);
+                  break;
+                }
+              }
+            }
+          }
+        }
+        // 3rd parameter: Sets offline flag.
+        destImapFolder->SetPendingAttributes(messages, isMove,
+                                             srcFolderOffline);
+      }
+    }
+    // if we can't get the dst folder db, we should still try to playback
+    // the offline move/copy.
+  }
+
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIURI> resultUrl;
+  nsAutoCString uids;
+  AllocateUidStringFromKeys(aMsgKeys, uids);
+  rv = imapService->OnlineMessageCopy(this, uids, aDstFolder, true, isMove,
+                                      aUrlListener, getter_AddRefs(resultUrl),
+                                      nullptr, aWindow);
+  if (resultUrl) {
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(resultUrl, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIUrlListener> folderListener = do_QueryInterface(aDstFolder);
+    if (folderListener) mailnewsUrl->RegisterListener(folderListener);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::AddMoveResultPseudoKey(nsMsgKey aMsgKey) {
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgDBHdr> pseudoHdr;
+  rv = mDatabase->GetMsgHdrForKey(aMsgKey, getter_AddRefs(pseudoHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCString messageId;
+  pseudoHdr->GetMessageId(getter_Copies(messageId));
+  // err on the side of caution and ignore messages w/o messageid.
+  if (messageId.IsEmpty()) return NS_OK;
+  m_pseudoHdrs.InsertOrUpdate(messageId, aMsgKey);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::StoreImapFlags(int32_t flags, bool addFlags,
+                                               const nsTArray<nsMsgKey>& keys,
+                                               nsIUrlListener* aUrlListener) {
+  nsresult rv;
+  if (!WeAreOffline()) {
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoCString msgIds;
+    AllocateUidStringFromKeys(keys, msgIds);
+    if (addFlags)
+      imapService->AddMessageFlags(this, aUrlListener ? aUrlListener : this,
+                                   msgIds, flags, true);
+    else
+      imapService->SubtractMessageFlags(
+          this, aUrlListener ? aUrlListener : this, msgIds, flags, true);
+  } else {
+    rv = GetDatabase();
+    if (NS_SUCCEEDED(rv) && mDatabase) {
+      nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb =
+          do_QueryInterface(mDatabase, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      for (auto key : keys) {
+        nsCOMPtr<nsIMsgOfflineImapOperation> op;
+        rv = opsDb->GetOfflineOpForKey(key, true, getter_AddRefs(op));
+        SetFlag(nsMsgFolderFlags::OfflineEvents);
+        if (NS_SUCCEEDED(rv) && op) {
+          imapMessageFlagsType newFlags;
+          op->GetNewFlags(&newFlags);
+          op->SetFlagOperation(addFlags ? newFlags | flags : newFlags & ~flags);
+        }
+      }
+      opsDb->Commit(nsMsgDBCommitType::kLargeCommit);  // flush offline flags
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::LiteSelect(nsIUrlListener* aUrlListener,
+                                           nsIMsgWindow* aMsgWindow) {
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIURI> outUri;
+  return imapService->LiteSelectFolder(this, aUrlListener, aMsgWindow,
+                                       getter_AddRefs(outUri));
+}
+
+nsresult nsImapMailFolder::GetFolderOwnerUserName(nsACString& userName) {
+  if ((mFlags & nsMsgFolderFlags::ImapPersonal) ||
+      !(mFlags &
+        (nsMsgFolderFlags::ImapPublic | nsMsgFolderFlags::ImapOtherUser))) {
+    // this is one of our personal mail folders
+    // return our username on this host
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    nsresult rv = GetServer(getter_AddRefs(server));
+    return NS_FAILED(rv) ? rv : server->GetUsername(userName);
+  }
+
+  // the only other type of owner is if it's in the other users' namespace
+  if (!(mFlags & nsMsgFolderFlags::ImapOtherUser)) return NS_OK;
+
+  if (m_ownerUserName.IsEmpty()) {
+    nsCString onlineName;
+    GetOnlineName(onlineName);
+    m_ownerUserName = nsImapNamespaceList::GetFolderOwnerNameFromPath(
+        GetNamespaceForFolder(), onlineName.get());
+  }
+  userName = m_ownerUserName;
+  return NS_OK;
+}
+
+nsImapNamespace* nsImapMailFolder::GetNamespaceForFolder() {
+  if (!m_namespace) {
+#ifdef DEBUG_bienvenu
+    // Make sure this isn't causing us to open the database
+    NS_ASSERTION(m_hierarchyDelimiter != kOnlineHierarchySeparatorUnknown,
+                 "haven't set hierarchy delimiter");
+#endif
+    nsCString serverKey;
+    nsCString onlineName;
+    GetServerKey(serverKey);
+    GetOnlineName(onlineName);
+    char hierarchyDelimiter;
+    GetHierarchyDelimiter(&hierarchyDelimiter);
+
+    m_namespace = nsImapNamespaceList::GetNamespaceForFolder(
+        serverKey.get(), onlineName.get(), hierarchyDelimiter);
+    NS_ASSERTION(m_namespace, "didn't get namespace for folder");
+    if (m_namespace) {
+      nsImapNamespaceList::SuggestHierarchySeparatorForNamespace(
+          m_namespace, hierarchyDelimiter);
+      m_folderIsNamespace = nsImapNamespaceList::GetFolderIsNamespace(
+          serverKey.get(), onlineName.get(), hierarchyDelimiter, m_namespace);
+    }
+  }
+  return m_namespace;
+}
+
+void nsImapMailFolder::SetNamespaceForFolder(nsImapNamespace* ns) {
+#ifdef DEBUG_bienvenu
+  NS_ASSERTION(ns, "null namespace");
+#endif
+  m_namespace = ns;
+}
+
+NS_IMETHODIMP nsImapMailFolder::FolderPrivileges(nsIMsgWindow* window) {
+  NS_ENSURE_ARG_POINTER(window);
+  nsresult rv = NS_OK;  // if no window...
+  if (!m_adminUrl.IsEmpty()) {
+    nsCOMPtr<nsIExternalProtocolService> extProtService =
+        do_GetService(NS_EXTERNALPROTOCOLSERVICE_CONTRACTID);
+    if (extProtService) {
+      nsAutoCString scheme;
+      nsCOMPtr<nsIURI> uri;
+      if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(uri), m_adminUrl.get())))
+        return rv;
+      uri->GetScheme(scheme);
+      if (!scheme.IsEmpty()) {
+        // if the URL scheme does not correspond to an exposed protocol, then we
+        // need to hand this link click over to the external protocol handler.
+        bool isExposed;
+        rv = extProtService->IsExposedProtocol(scheme.get(), &isExposed);
+        if (NS_SUCCEEDED(rv) && !isExposed)
+          return extProtService->LoadURI(uri, nullptr, nullptr, nullptr, false,
+                                         false);
+      }
+    }
+  } else {
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = imapService->GetFolderAdminUrl(this, window, this, nullptr);
+    if (NS_SUCCEEDED(rv)) m_urlRunning = true;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetHasAdminUrl(bool* aBool) {
+  NS_ENSURE_ARG_POINTER(aBool);
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  nsresult rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+  nsCString manageMailAccountUrl;
+  if (NS_SUCCEEDED(rv) && imapServer)
+    rv = imapServer->GetManageMailAccountUrl(manageMailAccountUrl);
+  *aBool = (NS_SUCCEEDED(rv) && !manageMailAccountUrl.IsEmpty());
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetAdminUrl(nsACString& aResult) {
+  aResult = m_adminUrl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetAdminUrl(const nsACString& adminUrl) {
+  m_adminUrl = adminUrl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetHdrParser(
+    nsIMsgParseMailMsgState** aHdrParser) {
+  NS_ENSURE_ARG_POINTER(aHdrParser);
+  NS_IF_ADDREF(*aHdrParser = m_msgParser);
+  return NS_OK;
+}
+
+// this is used to issue an arbitrary imap command on the passed in msgs.
+// It assumes the command needs to be run in the selected state.
+NS_IMETHODIMP nsImapMailFolder::IssueCommandOnMsgs(const nsACString& command,
+                                                   const char* uids,
+                                                   nsIMsgWindow* aWindow,
+                                                   nsIURI** url) {
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return imapService->IssueCommandOnMsgs(this, aWindow, command,
+                                         nsDependentCString(uids), url);
+}
+
+NS_IMETHODIMP nsImapMailFolder::FetchCustomMsgAttribute(
+    const nsACString& attribute, const char* uids, nsIMsgWindow* aWindow,
+    nsIURI** url) {
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return imapService->FetchCustomMsgAttribute(this, aWindow, attribute,
+                                              nsDependentCString(uids), url);
+}
+
+nsresult nsImapMailFolder::MoveIncorporatedMessage(
+    nsIMsgDBHdr* mailHdr, nsIMsgDatabase* sourceDB,
+    const nsACString& destFolderUri, nsIMsgFilter* filter,
+    nsIMsgWindow* msgWindow) {
+  nsresult rv;
+  if (m_moveCoalescer) {
+    nsCOMPtr<nsIMsgFolder> destIFolder;
+    rv = GetOrCreateFolder(destFolderUri, getter_AddRefs(destIFolder));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (destIFolder) {
+      // check if the destination is a real folder (by checking for null parent)
+      // and if it can file messages (e.g., servers or news folders can't file
+      // messages). Or read only imap folders...
+      bool canFileMessages = true;
+      nsCOMPtr<nsIMsgFolder> parentFolder;
+      destIFolder->GetParent(getter_AddRefs(parentFolder));
+      if (parentFolder) destIFolder->GetCanFileMessages(&canFileMessages);
+      if (filter && (!parentFolder || !canFileMessages)) {
+        filter->SetEnabled(false);
+        m_filterList->SaveToDefaultFile();
+        destIFolder->ThrowAlertMsg("filterDisabled", msgWindow);
+        return NS_MSG_NOT_A_MAIL_FOLDER;
+      }
+      // put the header into the source db, since it needs to be there when we
+      // copy it and we need a valid header to pass to
+      // StartAsyncCopyMessagesInto
+      nsMsgKey keyToFilter;
+      mailHdr->GetMessageKey(&keyToFilter);
+
+      if (sourceDB && destIFolder) {
+        bool imapDeleteIsMoveToTrash = DeleteIsMoveToTrash();
+        m_moveCoalescer->AddMove(destIFolder, keyToFilter);
+        // For each folder, we need to keep track of the ids we want to move to
+        // that folder - we used to store them in the MSG_FolderInfo and then
+        // when we'd finished downloading headers, we'd iterate through all the
+        // folders looking for the ones that needed messages moved into them -
+        // perhaps instead we could keep track of nsIMsgFolder,
+        // nsTArray<nsMsgKey> pairs here in the imap code. nsTArray<nsMsgKey>
+        // *idsToMoveFromInbox = msgFolder->GetImapIdsToMoveFromInbox();
+        // idsToMoveFromInbox->AppendElement(keyToFilter);
+        if (imapDeleteIsMoveToTrash) {
+        }
+        bool isRead = false;
+        mailHdr->GetIsRead(&isRead);
+        if (imapDeleteIsMoveToTrash) rv = NS_OK;
+      }
+    }
+  } else
+    rv = NS_ERROR_UNEXPECTED;
+
+  // we have to return an error because we do not actually move the message
+  // it is done async and that can fail
+  return rv;
+}
+
+/**
+ * This method assumes that key arrays and flag states are sorted by increasing
+ * key.
+ */
+void nsImapMailFolder::FindKeysToDelete(const nsTArray<nsMsgKey>& existingKeys,
+                                        nsTArray<nsMsgKey>& keysToDelete,
+                                        nsIImapFlagAndUidState* flagState,
+                                        uint32_t boxFlags) {
+  bool showDeletedMessages = ShowDeletedMessages();
+  int32_t numMessageInFlagState;
+  bool partialUIDFetch;
+  uint32_t uidOfMessage;
+  imapMessageFlagsType flags;
+
+  flagState->GetNumberOfMessages(&numMessageInFlagState);
+  flagState->GetPartialUIDFetch(&partialUIDFetch);
+
+  // if we're doing a partialUIDFetch, just delete the keys from the db
+  // that have the deleted flag set (if not using imap delete model)
+  // and return.
+  if (partialUIDFetch) {
+    if (!showDeletedMessages) {
+      for (uint32_t i = 0; (int32_t)i < numMessageInFlagState; i++) {
+        flagState->GetUidOfMessage(i, &uidOfMessage);
+        // flag state will be zero filled up to first real uid, so ignore those.
+        if (uidOfMessage) {
+          flagState->GetMessageFlags(i, &flags);
+          if (flags & kImapMsgDeletedFlag)
+            keysToDelete.AppendElement(uidOfMessage);
+        }
+      }
+    } else if (boxFlags & kJustExpunged) {
+      // we've just issued an expunge with a partial flag state. We should
+      // delete headers with the imap deleted flag set, because we can't
+      // tell from the expunge response which messages were deleted.
+      nsCOMPtr<nsIMsgEnumerator> hdrs;
+      nsresult rv = GetMessages(getter_AddRefs(hdrs));
+      NS_ENSURE_SUCCESS_VOID(rv);
+      bool hasMore = false;
+      while (NS_SUCCEEDED(rv = hdrs->HasMoreElements(&hasMore)) && hasMore) {
+        nsCOMPtr<nsIMsgDBHdr> header;
+        rv = hdrs->GetNext(getter_AddRefs(header));
+        NS_ENSURE_SUCCESS_VOID(rv);
+        uint32_t msgFlags;
+        header->GetFlags(&msgFlags);
+        if (msgFlags & nsMsgMessageFlags::IMAPDeleted) {
+          nsMsgKey msgKey;
+          header->GetMessageKey(&msgKey);
+          keysToDelete.AppendElement(msgKey);
+        }
+      }
+    }
+    return;
+  }
+  // otherwise, we have a complete set of uid's and flags, so we delete
+  // anything that's in existingKeys but not in the flag state, as well
+  // as messages with the deleted flag set.
+  uint32_t total = existingKeys.Length();
+  int onlineIndex = 0;  // current index into flagState
+  for (uint32_t keyIndex = 0; keyIndex < total; keyIndex++) {
+    while (
+        (onlineIndex < numMessageInFlagState) &&
+        NS_SUCCEEDED(flagState->GetUidOfMessage(onlineIndex, &uidOfMessage)) &&
+        (existingKeys[keyIndex] > uidOfMessage))
+      onlineIndex++;
+
+    flagState->GetUidOfMessage(onlineIndex, &uidOfMessage);
+    flagState->GetMessageFlags(onlineIndex, &flags);
+    // delete this key if it is not there or marked deleted
+    if ((onlineIndex >= numMessageInFlagState) ||
+        (existingKeys[keyIndex] != uidOfMessage) ||
+        ((flags & kImapMsgDeletedFlag) && !showDeletedMessages)) {
+      nsMsgKey doomedKey = existingKeys[keyIndex];
+      if ((int32_t)doomedKey <= 0 && doomedKey != nsMsgKey_None) continue;
+
+      keysToDelete.AppendElement(existingKeys[keyIndex]);
+    }
+
+    flagState->GetUidOfMessage(onlineIndex, &uidOfMessage);
+    if (existingKeys[keyIndex] == uidOfMessage) onlineIndex++;
+  }
+}
+
+void nsImapMailFolder::FindKeysToAdd(const nsTArray<nsMsgKey>& existingKeys,
+                                     nsTArray<nsMsgKey>& keysToFetch,
+                                     uint32_t& numNewUnread,
+                                     nsIImapFlagAndUidState* flagState) {
+  bool showDeletedMessages = ShowDeletedMessages();
+  int dbIndex = 0;  // current index into existingKeys
+  int32_t existTotal, numberOfKnownKeys;
+  int32_t messageIndex;
+
+  numNewUnread = 0;
+  existTotal = numberOfKnownKeys = existingKeys.Length();
+  flagState->GetNumberOfMessages(&messageIndex);
+  bool partialUIDFetch;
+  flagState->GetPartialUIDFetch(&partialUIDFetch);
+
+  for (int32_t flagIndex = 0; flagIndex < messageIndex; flagIndex++) {
+    uint32_t uidOfMessage;
+    flagState->GetUidOfMessage(flagIndex, &uidOfMessage);
+    while ((flagIndex < numberOfKnownKeys) && (dbIndex < existTotal) &&
+           existingKeys[dbIndex] < uidOfMessage)
+      dbIndex++;
+
+    if ((flagIndex >= numberOfKnownKeys) || (dbIndex >= existTotal) ||
+        (existingKeys[dbIndex] != uidOfMessage)) {
+      numberOfKnownKeys++;
+
+      imapMessageFlagsType flags;
+      flagState->GetMessageFlags(flagIndex, &flags);
+      NS_ASSERTION(uidOfMessage != nsMsgKey_None, "got invalid msg key");
+      if (uidOfMessage && uidOfMessage != nsMsgKey_None &&
+          (showDeletedMessages || !(flags & kImapMsgDeletedFlag))) {
+        if (mDatabase) {
+          bool dbContainsKey;
+          if (NS_SUCCEEDED(
+                  mDatabase->ContainsKey(uidOfMessage, &dbContainsKey)) &&
+              dbContainsKey) {
+            // this is expected in the partial uid fetch case because the
+            // flag state does not contain all messages, so the db has
+            // messages the flag state doesn't know about.
+            if (!partialUIDFetch) NS_ERROR("db has key - flagState messed up?");
+            continue;
+          }
+        }
+        keysToFetch.AppendElement(uidOfMessage);
+        if (!(flags & kImapMsgSeenFlag)) numNewUnread++;
+      }
+    }
+  }
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetMsgHdrsToDownload(
+    bool* aMoreToDownload, int32_t* aTotalCount, nsTArray<nsMsgKey>& aKeys) {
+  NS_ENSURE_ARG_POINTER(aMoreToDownload);
+  NS_ENSURE_ARG_POINTER(aTotalCount);
+  aKeys.Clear();
+
+  *aMoreToDownload = false;
+  *aTotalCount = m_totalKeysToFetch;
+  if (m_keysToFetch.IsEmpty()) {
+    return NS_OK;
+  }
+
+  // if folder isn't open in a window, no reason to limit the number of headers
+  // we download.
+  nsCOMPtr<nsIMsgMailSession> session =
+      do_GetService("@mozilla.org/messenger/services/session;1");
+  bool folderOpen = false;
+  if (session) session->IsFolderOpenInWindow(this, &folderOpen);
+
+  int32_t hdrChunkSize = 200;
+  if (folderOpen) {
+    nsresult rv;
+    nsCOMPtr<nsIPrefBranch> prefBranch(
+        do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (prefBranch)
+      prefBranch->GetIntPref("mail.imap.hdr_chunk_size", &hdrChunkSize);
+  }
+  int32_t numKeysToFetch = m_keysToFetch.Length();
+  int32_t startIndex = 0;
+  if (folderOpen && hdrChunkSize > 0 &&
+      (int32_t)m_keysToFetch.Length() > hdrChunkSize) {
+    numKeysToFetch = hdrChunkSize;
+    *aMoreToDownload = true;
+    startIndex = m_keysToFetch.Length() - hdrChunkSize;
+  }
+  aKeys.AppendElements(&m_keysToFetch[startIndex], numKeysToFetch);
+  // Remove these for the incremental header download case, so that
+  // we know we don't have to download them again.
+  m_keysToFetch.RemoveElementsAt(startIndex, numKeysToFetch);
+
+  return NS_OK;
+}
+
+void nsImapMailFolder::PrepareToAddHeadersToMailDB(nsIImapProtocol* aProtocol) {
+  // now, tell it we don't need any bodies.
+  nsTArray<nsMsgKey> noBodies;
+  aProtocol->NotifyBodysToDownload(noBodies);
+}
+
+void nsImapMailFolder::TweakHeaderFlags(nsIImapProtocol* aProtocol,
+                                        nsIMsgDBHdr* tweakMe) {
+  if (mDatabase && aProtocol && tweakMe) {
+    tweakMe->SetMessageKey(m_curMsgUid);
+    tweakMe->SetMessageSize(m_nextMessageByteLength);
+
+    bool foundIt = false;
+
+    nsCOMPtr<nsIImapFlagAndUidState> flagState;
+    nsresult rv = aProtocol->GetFlagAndUidState(getter_AddRefs(flagState));
+    NS_ENSURE_SUCCESS_VOID(rv);
+    rv = flagState->HasMessage(m_curMsgUid, &foundIt);
+
+    if (NS_SUCCEEDED(rv) && foundIt) {
+      imapMessageFlagsType imap_flags;
+      nsCString customFlags;
+      flagState->GetMessageFlagsByUid(m_curMsgUid, &imap_flags);
+      if (imap_flags & kImapMsgCustomKeywordFlag) {
+        flagState->GetCustomFlags(m_curMsgUid, getter_Copies(customFlags));
+      }
+
+      // make a mask and clear these message flags
+      uint32_t mask = nsMsgMessageFlags::Read | nsMsgMessageFlags::Replied |
+                      nsMsgMessageFlags::Marked |
+                      nsMsgMessageFlags::IMAPDeleted |
+                      nsMsgMessageFlags::Labels;
+      uint32_t dbHdrFlags;
+
+      tweakMe->GetFlags(&dbHdrFlags);
+      tweakMe->AndFlags(~mask, &dbHdrFlags);
+
+      // set the new value for these flags
+      uint32_t newFlags = 0;
+      if (imap_flags & kImapMsgSeenFlag)
+        newFlags |= nsMsgMessageFlags::Read;
+      else  // if (imap_flags & kImapMsgRecentFlag)
+        newFlags |= nsMsgMessageFlags::New;
+
+      // Okay here is the MDN needed logic (if DNT header seen):
+      /* if server support user defined flag:
+         XXX TODO: Fix badly formatted comment which doesn't reflect the code.
+                    MDNSent flag set => clear kMDNNeeded flag
+                    MDNSent flag not set => do nothing, leave kMDNNeeded on
+                    else if
+                    not nsMsgMessageFlags::New => clear kMDNNeeded flag
+                   nsMsgMessageFlags::New => do nothing, leave kMDNNeeded on
+               */
+      uint16_t userFlags;
+      rv = aProtocol->GetSupportedUserFlags(&userFlags);
+      if (NS_SUCCEEDED(rv) && (userFlags & (kImapMsgSupportUserFlag |
+                                            kImapMsgSupportMDNSentFlag))) {
+        if (imap_flags & kImapMsgMDNSentFlag) {
+          newFlags |= nsMsgMessageFlags::MDNReportSent;
+          if (dbHdrFlags & nsMsgMessageFlags::MDNReportNeeded)
+            tweakMe->AndFlags(~nsMsgMessageFlags::MDNReportNeeded, &dbHdrFlags);
+        }
+      }
+
+      if (imap_flags & kImapMsgAnsweredFlag)
+        newFlags |= nsMsgMessageFlags::Replied;
+      if (imap_flags & kImapMsgFlaggedFlag)
+        newFlags |= nsMsgMessageFlags::Marked;
+      if (imap_flags & kImapMsgDeletedFlag)
+        newFlags |= nsMsgMessageFlags::IMAPDeleted;
+      if (imap_flags & kImapMsgForwardedFlag)
+        newFlags |= nsMsgMessageFlags::Forwarded;
+      if (newFlags) tweakMe->OrFlags(newFlags, &dbHdrFlags);
+      if (!customFlags.IsEmpty())
+        (void)HandleCustomFlags(m_curMsgUid, tweakMe, userFlags, customFlags);
+    }
+  }
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetupMsgWriteStream(nsIFile* aFile, bool addDummyEnvelope) {
+  nsresult rv;
+  aFile->Remove(false);
+  m_tempMessageStreamBytesWritten = 0;
+  rv = MsgNewBufferedFileOutputStream(
+      getter_AddRefs(m_tempMessageStream), aFile,
+      PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 00700);
+  if (m_tempMessageStream && addDummyEnvelope) {
+    nsAutoCString result;
+    char* ct;
+    uint32_t writeCount;
+    time_t now = time((time_t*)0);
+    ct = ctime(&now);
+    ct[24] = 0;
+    result = "From - ";
+    result += ct;
+    result += MSG_LINEBREAK;
+
+    rv = m_tempMessageStream->Write(result.get(), result.Length(), &writeCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_tempMessageStreamBytesWritten += writeCount;
+
+    result = "X-Mozilla-Status: 0001";
+    result += MSG_LINEBREAK;
+    rv = m_tempMessageStream->Write(result.get(), result.Length(), &writeCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_tempMessageStreamBytesWritten += writeCount;
+
+    result = "X-Mozilla-Status2: 00000000";
+    result += MSG_LINEBREAK;
+    rv = m_tempMessageStream->Write(result.get(), result.Length(), &writeCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_tempMessageStreamBytesWritten += writeCount;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::DownloadMessagesForOffline(
+    nsTArray<RefPtr<nsIMsgDBHdr>> const& messages, nsIMsgWindow* window) {
+  nsAutoCString messageIds;
+  nsTArray<nsMsgKey> srcKeyArray;
+  nsresult rv = BuildIdsAndKeyArray(messages, messageIds, srcKeyArray);
+  if (NS_FAILED(rv) || messageIds.IsEmpty()) return rv;
+
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = AcquireSemaphore(static_cast<nsIMsgFolder*>(this));
+  if (NS_FAILED(rv)) {
+    ThrowAlertMsg("operationFailedFolderBusy", window);
+    return rv;
+  }
+  return imapService->DownloadMessagesForOffline(messageIds, this, this,
+                                                 window);
+}
+
+NS_IMETHODIMP nsImapMailFolder::DownloadAllForOffline(nsIUrlListener* listener,
+                                                      nsIMsgWindow* msgWindow) {
+  nsresult rv;
+  nsCOMPtr<nsIURI> runningURI;
+  bool noSelect;
+  GetFlag(nsMsgFolderFlags::ImapNoselect, &noSelect);
+
+  if (!noSelect) {
+    nsAutoCString messageIdsToDownload;
+    nsTArray<nsMsgKey> msgsToDownload;
+
+    GetDatabase();
+    m_downloadingFolderForOfflineUse = true;
+
+    rv = AcquireSemaphore(static_cast<nsIMsgFolder*>(this));
+    if (NS_FAILED(rv)) {
+      m_downloadingFolderForOfflineUse = false;
+      ThrowAlertMsg("operationFailedFolderBusy", msgWindow);
+      return rv;
+    }
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Selecting the folder with nsIImapUrl::shouldStoreMsgOffline true will
+    // cause us to fetch any message bodies we don't have.
+    m_urlListener = listener;
+    rv = imapService->SelectFolder(this, this, msgWindow,
+                                   getter_AddRefs(runningURI));
+    if (NS_SUCCEEDED(rv)) {
+      nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(runningURI));
+      if (imapUrl) imapUrl->SetStoreResultsOffline(true);
+      m_urlRunning = true;
+    }
+  } else
+    rv = NS_MSG_FOLDER_UNREADABLE;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::ParseAdoptedMsgLine(const char* adoptedMessageLine,
+                                      nsMsgKey uidOfMessage,
+                                      nsIImapUrl* aImapUrl) {
+  NS_ENSURE_ARG_POINTER(aImapUrl);
+  uint32_t count = 0;
+  nsresult rv;
+  // remember the uid of the message we're downloading.
+  m_curMsgUid = uidOfMessage;
+  if (!m_offlineHeader) {
+    rv = GetMessageHeader(uidOfMessage, getter_AddRefs(m_offlineHeader));
+    if (NS_SUCCEEDED(rv) && !m_offlineHeader) rv = NS_ERROR_UNEXPECTED;
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = StartNewOfflineMessage();
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  // adoptedMessageLine is actually a string with a lot of message lines,
+  // separated by native line terminators we need to count the number of
+  // MSG_LINEBREAK's to determine how much to increment m_numOfflineMsgLines by.
+  const char* nextLine = adoptedMessageLine;
+  do {
+    m_numOfflineMsgLines++;
+    nextLine = PL_strstr(nextLine, MSG_LINEBREAK);
+    if (nextLine) nextLine += MSG_LINEBREAK_LEN;
+  } while (nextLine && *nextLine);
+
+  if (m_tempMessageStream) {
+    rv = m_tempMessageStream->Write(adoptedMessageLine,
+                                    PL_strlen(adoptedMessageLine), &count);
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_tempMessageStreamBytesWritten += count;
+  }
+  return NS_OK;
+}
+
+void nsImapMailFolder::EndOfflineDownload() {
+  if (m_tempMessageStream) {
+    m_tempMessageStream->Close();
+    m_tempMessageStream = nullptr;
+    ReleaseSemaphore(static_cast<nsIMsgFolder*>(this));
+    if (mDatabase) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  m_offlineHeader = nullptr;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::NormalEndMsgWriteStream(nsMsgKey uidOfMessage, bool markRead,
+                                          nsIImapUrl* imapUrl,
+                                          int32_t updatedMessageSize) {
+  if (updatedMessageSize != -1) {
+    // retrieve the message header to update size, if we don't already have it
+    nsCOMPtr<nsIMsgDBHdr> msgHeader = m_offlineHeader;
+    if (!msgHeader) GetMessageHeader(uidOfMessage, getter_AddRefs(msgHeader));
+    if (msgHeader) {
+      uint32_t msgSize;
+      msgHeader->GetMessageSize(&msgSize);
+      MOZ_LOG(IMAP, mozilla::LogLevel::Debug,
+              ("Updating stored message size from %u, new size %d", msgSize,
+               updatedMessageSize));
+      msgHeader->SetMessageSize(updatedMessageSize);
+      // only commit here if this isn't an offline message
+      // offline header gets committed in EndNewOfflineMessage() called below
+      if (mDatabase && !m_offlineHeader)
+        mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+    } else
+      NS_WARNING(
+          "Failed to get message header when trying to update message size");
+  }
+
+  if (m_offlineHeader) EndNewOfflineMessage(NS_OK);
+
+  m_curMsgUid = uidOfMessage;
+
+  // Apply filter now if it needed a body
+  if (m_filterListRequiresBody) {
+    if (m_filterList) {
+      nsCOMPtr<nsIMsgDBHdr> newMsgHdr;
+      GetMessageHeader(uidOfMessage, getter_AddRefs(newMsgHdr));
+      GetMoveCoalescer();
+      nsCOMPtr<nsIMsgWindow> msgWindow;
+      if (imapUrl) {
+        nsresult rv;
+        nsCOMPtr<nsIMsgMailNewsUrl> msgUrl;
+        msgUrl = do_QueryInterface(imapUrl, &rv);
+        if (msgUrl && NS_SUCCEEDED(rv))
+          msgUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+      }
+      m_filterList->ApplyFiltersToHdr(nsMsgFilterType::InboxRule, newMsgHdr,
+                                      this, mDatabase, EmptyCString(), this,
+                                      msgWindow);
+      NotifyFolderEvent(kFiltersApplied);
+    }
+    // Process filter plugins and other items normally done at the end of
+    // HeaderFetchCompleted.
+    bool pendingMoves = m_moveCoalescer && m_moveCoalescer->HasPendingMoves();
+    PlaybackCoalescedOperations();
+
+    bool filtersRun;
+    CallFilterPlugins(nullptr, &filtersRun);
+    int32_t numNewBiffMsgs = 0;
+    if (m_performingBiff) GetNumNewMessages(false, &numNewBiffMsgs);
+
+    if (!filtersRun && m_performingBiff && mDatabase && numNewBiffMsgs > 0 &&
+        (!pendingMoves || !ShowPreviewText())) {
+      // If we are performing biff for this folder, tell the
+      // stand-alone biff about the new high water mark
+      // We must ensure that the server knows that we are performing biff.
+      // Otherwise the stand-alone biff won't fire.
+      nsCOMPtr<nsIMsgIncomingServer> server;
+      if (NS_SUCCEEDED(GetServer(getter_AddRefs(server))) && server)
+        server->SetPerformingBiff(true);
+
+      SetBiffState(nsIMsgFolder::nsMsgBiffState_NewMail);
+      if (server) server->SetPerformingBiff(false);
+      m_performingBiff = false;
+    }
+
+    if (m_filterList) (void)m_filterList->FlushLogIfNecessary();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::AbortMsgWriteStream() {
+  m_offlineHeader = nullptr;
+  return NS_ERROR_FAILURE;
+}
+
+// message move/copy related methods
+NS_IMETHODIMP
+nsImapMailFolder::OnlineCopyCompleted(nsIImapProtocol* aProtocol,
+                                      ImapOnlineCopyState aCopyState) {
+  NS_ENSURE_ARG_POINTER(aProtocol);
+
+  nsresult rv;
+  if (aCopyState == ImapOnlineCopyStateType::kSuccessfulCopy) {
+    nsCOMPtr<nsIImapUrl> imapUrl;
+    rv = aProtocol->GetRunningImapURL(getter_AddRefs(imapUrl));
+    if (NS_FAILED(rv) || !imapUrl) return NS_ERROR_FAILURE;
+    nsImapAction action;
+    rv = imapUrl->GetImapAction(&action);
+    if (NS_FAILED(rv)) return rv;
+    if (action != nsIImapUrl::nsImapOnlineToOfflineMove)
+      return NS_ERROR_FAILURE;  // don't assert here...
+    nsCString messageIds;
+    rv = imapUrl->GetListOfMessageIds(messageIds);
+    if (NS_FAILED(rv)) return rv;
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return imapService->AddMessageFlags(this, nullptr, messageIds,
+                                        kImapMsgDeletedFlag, true);
+  }
+  /* unhandled copystate */
+  if (m_copyState)  // whoops, this is the wrong folder - should use the source
+                    // folder
+  {
+    nsCOMPtr<nsIMsgFolder> srcFolder;
+    srcFolder = do_QueryInterface(m_copyState->m_srcSupport, &rv);
+    if (srcFolder) srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgCompleted);
+  } else
+    rv = NS_ERROR_FAILURE;
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::CloseMockChannel(nsIImapMockChannel* aChannel) {
+  aChannel->Close();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::ReleaseUrlCacheEntry(nsIMsgMailNewsUrl* aUrl) {
+  NS_ENSURE_ARG_POINTER(aUrl);
+  return aUrl->SetMemCacheEntry(nullptr);
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::BeginMessageUpload() { return NS_ERROR_FAILURE; }
+
+nsresult nsImapMailFolder::HandleCustomFlags(nsMsgKey uidOfMessage,
+                                             nsIMsgDBHdr* dbHdr,
+                                             uint16_t userFlags,
+                                             nsCString& keywords) {
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  ToLowerCase(keywords);
+  bool messageClassified = true;
+  // ### TODO: we really should parse the keywords into space delimited keywords
+  // before checking
+  // Mac Mail, Yahoo uses "NotJunk"
+  if (FindInReadable("NonJunk"_ns, keywords,
+                     nsCaseInsensitiveCStringComparator) ||
+      FindInReadable("NotJunk"_ns, keywords,
+                     nsCaseInsensitiveCStringComparator)) {
+    nsAutoCString msgJunkScore;
+    msgJunkScore.AppendInt(nsIJunkMailPlugin::IS_HAM_SCORE);
+    mDatabase->SetStringProperty(uidOfMessage, "junkscore", msgJunkScore);
+  } else if (FindInReadable("Junk"_ns, keywords,
+                            nsCaseInsensitiveCStringComparator)) {
+    uint32_t newFlags;
+    dbHdr->AndFlags(~nsMsgMessageFlags::New, &newFlags);
+    nsAutoCString msgJunkScore;
+    msgJunkScore.AppendInt(nsIJunkMailPlugin::IS_SPAM_SCORE);
+    mDatabase->SetStringProperty(uidOfMessage, "junkscore", msgJunkScore);
+  } else
+    messageClassified = false;
+  if (messageClassified) {
+    // only set the junkscore origin if it wasn't set before.
+    nsCString existingProperty;
+    dbHdr->GetStringProperty("junkscoreorigin", existingProperty);
+    if (existingProperty.IsEmpty())
+      dbHdr->SetStringProperty("junkscoreorigin", "imapflag"_ns);
+  }
+
+  if (!(userFlags & kImapMsgSupportUserFlag)) {
+    nsCString localKeywords;
+    nsCString prevKeywords;
+    dbHdr->GetStringProperty("keywords", localKeywords);
+    dbHdr->GetStringProperty("prevkeywords", prevKeywords);
+    // localKeywords: tags currently stored in database for the message.
+    // keywords: tags stored in server and obtained when flags for the message
+    //           were last fetched. (Parameter of this function.)
+    // prevKeywords: saved keywords from previous call of this function.
+    // clang-format off
+    MOZ_LOG(IMAP_KW, mozilla::LogLevel::Debug,
+            ("UID=%" PRIu32 ", localKeywords=|%s| keywords=|%s|, prevKeywords=|%s|",
+             uidOfMessage, localKeywords.get(), keywords.get(), prevKeywords.get()));
+    // clang-format on
+
+    // Store keywords to detect changes on next call of this function.
+    dbHdr->SetStringProperty("prevkeywords", keywords);
+
+    // Parse the space separated strings into arrays.
+    nsTArray<nsCString> localKeywordArray;
+    nsTArray<nsCString> keywordArray;
+    nsTArray<nsCString> prevKeywordArray;
+    ParseString(localKeywords, ' ', localKeywordArray);
+    ParseString(keywords, ' ', keywordArray);
+    ParseString(prevKeywords, ' ', prevKeywordArray);
+
+    // If keyword not received now but was the last time, remove it from
+    // the localKeywords. This means the keyword was removed by another user
+    // sharing the folder.
+    for (uint32_t i = 0; i < prevKeywordArray.Length(); i++) {
+      bool inRcvd = keywordArray.Contains(prevKeywordArray[i]);
+      bool inLocal = localKeywordArray.Contains(prevKeywordArray[i]);
+      if (!inRcvd && inLocal)
+        localKeywordArray.RemoveElement(prevKeywordArray[i]);
+    }
+
+    // Combine local and rcvd keyword arrays into a single string
+    // so it can be passed to SetStringProperty(). If element of
+    // local already in rcvd, avoid duplicates in combined string.
+    nsAutoCString combinedKeywords;
+    for (uint32_t i = 0; i < localKeywordArray.Length(); i++) {
+      if (!keywordArray.Contains(localKeywordArray[i])) {
+        combinedKeywords.Append(localKeywordArray[i]);
+        combinedKeywords.Append(' ');
+      }
+    }
+    for (uint32_t i = 0; i < keywordArray.Length(); i++) {
+      combinedKeywords.Append(keywordArray[i]);
+      combinedKeywords.Append(' ');
+    }
+    MOZ_LOG(IMAP_KW, mozilla::LogLevel::Debug,
+            ("combinedKeywords stored = |%s|", combinedKeywords.get()));
+    // combinedKeywords are tags being stored in database for the message.
+    return dbHdr->SetStringProperty("keywords", combinedKeywords);
+  }
+  return (userFlags & kImapMsgSupportUserFlag)
+             ? dbHdr->SetStringProperty("keywords", keywords)
+             : NS_OK;
+}
+
+// synchronize the message flags in the database with the server flags
+nsresult nsImapMailFolder::SyncFlags(nsIImapFlagAndUidState* flagState) {
+  nsresult rv = GetDatabase();  // we need a database for this
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool partialUIDFetch;
+  flagState->GetPartialUIDFetch(&partialUIDFetch);
+
+  // update all of the database flags
+  int32_t messageIndex;
+  uint32_t messageSize;
+
+  // Take this opportunity to recalculate the folder size, if we're not a
+  // partial (condstore) fetch.
+  int64_t newFolderSize = 0;
+
+  flagState->GetNumberOfMessages(&messageIndex);
+
+  uint16_t supportedUserFlags;
+  flagState->GetSupportedUserFlags(&supportedUserFlags);
+
+  for (int32_t flagIndex = 0; flagIndex < messageIndex; flagIndex++) {
+    uint32_t uidOfMessage;
+    flagState->GetUidOfMessage(flagIndex, &uidOfMessage);
+    imapMessageFlagsType flags;
+    flagState->GetMessageFlags(flagIndex, &flags);
+    bool containsKey;
+    rv = mDatabase->ContainsKey(uidOfMessage, &containsKey);
+    // if we don't have the header, don't diddle the flags.
+    // GetMsgHdrForKey will create the header if it doesn't exist.
+    if (NS_FAILED(rv) || !containsKey) continue;
+
+    nsCOMPtr<nsIMsgDBHdr> dbHdr;
+    rv = mDatabase->GetMsgHdrForKey(uidOfMessage, getter_AddRefs(dbHdr));
+    if (NS_FAILED(rv)) continue;
+    if (NS_SUCCEEDED(dbHdr->GetMessageSize(&messageSize)))
+      newFolderSize += messageSize;
+
+    nsCString keywords;
+    if (NS_SUCCEEDED(
+            flagState->GetCustomFlags(uidOfMessage, getter_Copies(keywords))))
+      HandleCustomFlags(uidOfMessage, dbHdr, supportedUserFlags, keywords);
+
+    NotifyMessageFlagsFromHdr(dbHdr, uidOfMessage, flags);
+  }
+  if (!partialUIDFetch && newFolderSize != mFolderSize) {
+    int64_t oldFolderSize = mFolderSize;
+    mFolderSize = newFolderSize;
+    NotifyIntPropertyChanged(kFolderSize, oldFolderSize, mFolderSize);
+  }
+
+  return NS_OK;
+}
+
+// helper routine to sync the flags on a given header
+nsresult nsImapMailFolder::NotifyMessageFlagsFromHdr(nsIMsgDBHdr* dbHdr,
+                                                     nsMsgKey msgKey,
+                                                     uint32_t flags) {
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Although it may seem strange to keep a local reference of mDatabase here,
+  // the current lifetime management of databases requires that methods
+  // sometimes null the database when they think they opened it. Unfortunately
+  // experience shows this happens when we don't expect, so for crash protection
+  // best practice with the current flawed database management is to keep a
+  // local reference when there will be complex calls in a method. See bug
+  // 1312254.
+  nsCOMPtr<nsIMsgDatabase> database(mDatabase);
+  NS_ENSURE_STATE(database);
+
+  database->MarkHdrRead(dbHdr, (flags & kImapMsgSeenFlag) != 0, nullptr);
+  database->MarkHdrReplied(dbHdr, (flags & kImapMsgAnsweredFlag) != 0, nullptr);
+  database->MarkHdrMarked(dbHdr, (flags & kImapMsgFlaggedFlag) != 0, nullptr);
+  database->MarkImapDeleted(msgKey, (flags & kImapMsgDeletedFlag) != 0,
+                            nullptr);
+
+  uint32_t supportedFlags;
+  GetSupportedUserFlags(&supportedFlags);
+  if (supportedFlags & kImapMsgSupportForwardedFlag)
+    database->MarkForwarded(msgKey, (flags & kImapMsgForwardedFlag) != 0,
+                            nullptr);
+  if (supportedFlags & kImapMsgSupportMDNSentFlag)
+    database->MarkMDNSent(msgKey, (flags & kImapMsgMDNSentFlag) != 0, nullptr);
+
+  return NS_OK;
+}
+
+// message flags operation - this is called from the imap protocol,
+// proxied over from the imap thread to the ui thread, when a flag changes
+NS_IMETHODIMP
+nsImapMailFolder::NotifyMessageFlags(uint32_t aFlags,
+                                     const nsACString& aKeywords,
+                                     nsMsgKey aMsgKey,
+                                     uint64_t aHighestModSeq) {
+  if (NS_SUCCEEDED(GetDatabase()) && mDatabase) {
+    bool msgDeleted = aFlags & kImapMsgDeletedFlag;
+    if (aHighestModSeq || msgDeleted) {
+      nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+      mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+      if (dbFolderInfo) {
+        if (aHighestModSeq) {
+          char intStrBuf[40];
+          PR_snprintf(intStrBuf, sizeof(intStrBuf), "%llu", aHighestModSeq);
+          MOZ_LOG(IMAP_CS, mozilla::LogLevel::Debug,
+                  ("NotifyMessageFlags(): Store highest MODSEQ=%" PRIu64
+                   " for folder=%s",
+                   aHighestModSeq, m_onlineFolderName.get()));
+          dbFolderInfo->SetCharProperty(kModSeqPropertyName,
+                                        nsDependentCString(intStrBuf));
+        }
+        if (msgDeleted) {
+          uint32_t oldDeletedCount;
+          dbFolderInfo->GetUint32Property(kDeletedHdrCountPropertyName, 0,
+                                          &oldDeletedCount);
+          dbFolderInfo->SetUint32Property(kDeletedHdrCountPropertyName,
+                                          oldDeletedCount + 1);
+        }
+      }
+    }
+    nsCOMPtr<nsIMsgDBHdr> dbHdr;
+    bool containsKey;
+    nsresult rv = mDatabase->ContainsKey(aMsgKey, &containsKey);
+    // if we don't have the header, don't diddle the flags.
+    // GetMsgHdrForKey will create the header if it doesn't exist.
+    if (NS_FAILED(rv) || !containsKey) return rv;
+    rv = mDatabase->GetMsgHdrForKey(aMsgKey, getter_AddRefs(dbHdr));
+    if (NS_SUCCEEDED(rv) && dbHdr) {
+      uint32_t supportedUserFlags;
+      GetSupportedUserFlags(&supportedUserFlags);
+      NotifyMessageFlagsFromHdr(dbHdr, aMsgKey, aFlags);
+      nsCString keywords(aKeywords);
+      HandleCustomFlags(aMsgKey, dbHdr, supportedUserFlags, keywords);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::NotifyMessageDeleted(const char* onlineFolderName,
+                                       bool deleteAllMsgs,
+                                       const char* msgIdString) {
+  if (deleteAllMsgs) return NS_OK;
+
+  if (!msgIdString) return NS_OK;
+
+  nsTArray<nsMsgKey> affectedMessages;
+  ParseUidString(msgIdString, affectedMessages);
+
+  if (!ShowDeletedMessages()) {
+    GetDatabase();
+    NS_ENSURE_TRUE(mDatabase, NS_OK);
+    if (!ShowDeletedMessages()) {
+      if (!affectedMessages.IsEmpty())  // perhaps Search deleted these messages
+      {
+        DeleteStoreMessages(affectedMessages);
+        mDatabase->DeleteMessages(affectedMessages, nullptr);
+      }
+    } else  // && !imapDeleteIsMoveToTrash // TODO: can this ever be executed?
+      SetIMAPDeletedFlag(mDatabase, affectedMessages, false);
+  }
+  return NS_OK;
+}
+
+bool nsImapMailFolder::ShowDeletedMessages() {
+  nsresult rv;
+  nsCOMPtr<nsIImapHostSessionList> hostSession =
+      do_GetService(kCImapHostSessionList, &rv);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  bool showDeleted = false;
+  nsCString serverKey;
+  GetServerKey(serverKey);
+  hostSession->GetShowDeletedMessagesForHost(serverKey.get(), showDeleted);
+
+  return showDeleted;
+}
+
+bool nsImapMailFolder::DeleteIsMoveToTrash() {
+  nsresult err;
+  nsCOMPtr<nsIImapHostSessionList> hostSession =
+      do_GetService(kCImapHostSessionList, &err);
+  NS_ENSURE_SUCCESS(err, true);
+  bool rv = true;
+
+  nsCString serverKey;
+  GetServerKey(serverKey);
+  hostSession->GetDeleteIsMoveToTrashForHost(serverKey.get(), rv);
+  return rv;
+}
+
+nsresult nsImapMailFolder::GetTrashFolder(nsIMsgFolder** pTrashFolder) {
+  NS_ENSURE_ARG_POINTER(pTrashFolder);
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
+  if (NS_SUCCEEDED(rv) && rootFolder) {
+    rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Trash, pTrashFolder);
+    if (!*pTrashFolder) rv = NS_ERROR_FAILURE;
+  }
+  return rv;
+}
+
+// store nsMsgMessageFlags::IMAPDeleted in the specified mailhdr records
+void nsImapMailFolder::SetIMAPDeletedFlag(nsIMsgDatabase* mailDB,
+                                          const nsTArray<nsMsgKey>& msgids,
+                                          bool markDeleted) {
+  nsresult markStatus = NS_OK;
+  uint32_t total = msgids.Length();
+
+  for (uint32_t msgIndex = 0; NS_SUCCEEDED(markStatus) && (msgIndex < total);
+       msgIndex++)
+    markStatus =
+        mailDB->MarkImapDeleted(msgids[msgIndex], markDeleted, nullptr);
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetMessageSizeFromDB(const char* id, uint32_t* size) {
+  NS_ENSURE_ARG_POINTER(size);
+
+  *size = 0;
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (id) {
+    nsMsgKey key = msgKeyFromInt(ParseUint64Str(id));
+    nsCOMPtr<nsIMsgDBHdr> mailHdr;
+    rv = mDatabase->GetMsgHdrForKey(key, getter_AddRefs(mailHdr));
+    if (NS_SUCCEEDED(rv) && mailHdr) rv = mailHdr->GetMessageSize(size);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetCurMoveCopyMessageInfo(nsIImapUrl* runningUrl,
+                                            PRTime* aDate,
+                                            nsACString& aKeywords,
+                                            uint32_t* aResult) {
+  nsCOMPtr<nsISupports> copyState;
+  runningUrl->GetCopyState(getter_AddRefs(copyState));
+  if (copyState) {
+    nsCOMPtr<nsImapMailCopyState> mailCopyState = do_QueryInterface(copyState);
+    uint32_t supportedFlags = 0;
+    GetSupportedUserFlags(&supportedFlags);
+    if (mailCopyState &&
+        mailCopyState->m_curIndex < mailCopyState->m_messages.Length()) {
+      nsIMsgDBHdr* message =
+          mailCopyState->m_messages[mailCopyState->m_curIndex];
+      message->GetFlags(aResult);
+      if (aDate) message->GetDate(aDate);
+      if (supportedFlags & kImapMsgSupportUserFlag) {
+        // setup the custom imap keywords, which includes the message keywords
+        // plus any junk status
+        nsCString junkscore;
+        message->GetStringProperty("junkscore", junkscore);
+        bool isJunk = false, isNotJunk = false;
+        if (!junkscore.IsEmpty()) {
+          if (junkscore.EqualsLiteral("0"))
+            isNotJunk = true;
+          else
+            isJunk = true;
+        }
+
+        nsCString keywords;  // MsgFindKeyword can't use nsACString
+        message->GetStringProperty("keywords", keywords);
+        int32_t start;
+        int32_t length;
+        bool hasJunk = MsgFindKeyword("junk"_ns, keywords, &start, &length);
+        if (hasJunk && !isJunk)
+          keywords.Cut(start, length);
+        else if (!hasJunk && isJunk)
+          keywords.AppendLiteral(" Junk");
+        bool hasNonJunk =
+            MsgFindKeyword("nonjunk"_ns, keywords, &start, &length);
+        if (!hasNonJunk)
+          hasNonJunk = MsgFindKeyword("notjunk"_ns, keywords, &start, &length);
+        if (hasNonJunk && !isNotJunk)
+          keywords.Cut(start, length);
+        else if (!hasNonJunk && isNotJunk)
+          keywords.AppendLiteral(" NonJunk");
+
+        // Cleanup extra spaces
+        while (!keywords.IsEmpty() && keywords.First() == ' ')
+          keywords.Cut(0, 1);
+        while (!keywords.IsEmpty() && keywords.Last() == ' ')
+          keywords.Cut(keywords.Length() - 1, 1);
+        while (!keywords.IsEmpty() && (start = keywords.Find("  "_ns)) >= 0)
+          keywords.Cut(start, 1);
+        aKeywords.Assign(keywords);
+      }
+    }
+    // if we don't have a source header, and it's not the drafts folder,
+    // then mark the message read, since it must be an append to the
+    // fcc or templates folder.
+    else if (mailCopyState) {
+      *aResult = mailCopyState->m_newMsgFlags;
+      if (supportedFlags & kImapMsgSupportUserFlag)
+        aKeywords.Assign(mailCopyState->m_newMsgKeywords);
+    }
+  }
+  return NS_OK;
+}
+
+// nsIUrlListener implementation.
+NS_IMETHODIMP
+nsImapMailFolder::OnStartRunningUrl(nsIURI* aUrl) {
+  NS_ASSERTION(aUrl, "sanity check - need to be be running non-null url");
+  nsCOMPtr<nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(aUrl);
+  if (mailUrl) {
+    bool updatingFolder;
+    mailUrl->GetUpdatingFolder(&updatingFolder);
+    m_updatingFolder = updatingFolder;
+  }
+  m_urlRunning = true;
+  return NS_OK;
+}
+
+// nsIUrlListener implementation.
+// nsImapMailFolder passes itself as a listener when it kicks off operations
+// on the nsIImapService. So, when the operation completes, this gets called
+// to handle all the different operations, using a big switch statement.
+NS_IMETHODIMP
+nsImapMailFolder::OnStopRunningUrl(nsIURI* aUrl, nsresult aExitCode) {
+  nsresult rv;
+  bool endedOfflineDownload = false;
+  nsImapAction imapAction = nsIImapUrl::nsImapTest;
+  m_urlRunning = false;
+  m_updatingFolder = false;
+  nsCOMPtr<nsIMsgMailSession> session =
+      do_GetService("@mozilla.org/messenger/services/session;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (aUrl) {
+    nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(aUrl, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    bool downloadingForOfflineUse;
+    imapUrl->GetStoreResultsOffline(&downloadingForOfflineUse);
+    bool hasSemaphore = false;
+    // if we have the folder locked, clear it.
+    TestSemaphore(static_cast<nsIMsgFolder*>(this), &hasSemaphore);
+    if (hasSemaphore) ReleaseSemaphore(static_cast<nsIMsgFolder*>(this));
+    if (downloadingForOfflineUse) {
+      endedOfflineDownload = true;
+      EndOfflineDownload();
+    }
+    nsCOMPtr<nsIMsgWindow> msgWindow;
+    nsCOMPtr<nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(aUrl);
+    bool folderOpen = false;
+    if (mailUrl) mailUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+    if (session) session->IsFolderOpenInWindow(this, &folderOpen);
+#ifdef DEBUG_bienvenu
+    printf("stop running url %s\n", aUrl->GetSpecOrDefault().get());
+#endif
+
+    if (imapUrl) {
+      DisplayStatusMsg(imapUrl, EmptyString());
+      imapUrl->GetImapAction(&imapAction);
+      if (imapAction == nsIImapUrl::nsImapMsgFetch ||
+          imapAction == nsIImapUrl::nsImapMsgDownloadForOffline) {
+        ReleaseSemaphore(static_cast<nsIMsgFolder*>(this));
+        if (!endedOfflineDownload) EndOfflineDownload();
+      }
+
+      // Notify move, copy or delete (online operations)
+      // Not sure whether nsImapDeleteMsg is even used, deletes in all three
+      // models use nsImapAddMsgFlags.
+      nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+          do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+      if (notifier && m_copyState) {
+        if (imapAction == nsIImapUrl::nsImapOnlineMove) {
+          notifier->NotifyMsgsMoveCopyCompleted(true, m_copyState->m_messages,
+                                                this, {});
+        } else if (imapAction == nsIImapUrl::nsImapOnlineCopy) {
+          notifier->NotifyMsgsMoveCopyCompleted(false, m_copyState->m_messages,
+                                                this, {});
+        } else if (imapAction == nsIImapUrl::nsImapDeleteMsg) {
+          notifier->NotifyMsgsDeleted(m_copyState->m_messages);
+        }
+      }
+
+      switch (imapAction) {
+        case nsIImapUrl::nsImapDeleteMsg:
+        case nsIImapUrl::nsImapOnlineMove:
+        case nsIImapUrl::nsImapOnlineCopy:
+          if (NS_SUCCEEDED(aExitCode)) {
+            if (folderOpen)
+              UpdateFolder(msgWindow);
+            else
+              UpdatePendingCounts();
+          }
+
+          if (m_copyState) {
+            nsCOMPtr<nsIMsgFolder> srcFolder =
+                do_QueryInterface(m_copyState->m_srcSupport, &rv);
+            if (m_copyState->m_isMove && !m_copyState->m_isCrossServerOp) {
+              if (NS_SUCCEEDED(aExitCode)) {
+                nsCOMPtr<nsIMsgDatabase> srcDB;
+                if (srcFolder)
+                  rv = srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
+                if (NS_SUCCEEDED(rv) && srcDB) {
+                  RefPtr<nsImapMoveCopyMsgTxn> msgTxn;
+                  nsTArray<nsMsgKey> srcKeyArray;
+                  if (m_copyState->m_allowUndo) {
+                    msgTxn = m_copyState->m_undoMsgTxn;
+                    if (msgTxn) msgTxn->GetSrcKeyArray(srcKeyArray);
+                  } else {
+                    nsAutoCString messageIds;
+                    rv = BuildIdsAndKeyArray(m_copyState->m_messages,
+                                             messageIds, srcKeyArray);
+                    NS_ENSURE_SUCCESS(rv, rv);
+                  }
+
+                  if (!ShowDeletedMessages()) {
+                    // We only reach here for same-server operations
+                    // (!m_copyState->m_isCrossServerOp in if above), so we can
+                    // assume that the src is also imap that uses offline
+                    // storage.
+                    DeleteStoreMessages(srcKeyArray, srcFolder);
+                    srcDB->DeleteMessages(srcKeyArray, nullptr);
+                  } else
+                    MarkMessagesImapDeleted(&srcKeyArray, true, srcDB);
+                }
+                srcFolder->EnableNotifications(allMessageCountNotifications,
+                                               true);
+                // even if we're showing deleted messages,
+                // we still need to notify FE so it will show the imap deleted
+                // flag
+                srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgCompleted);
+                // is there a way to see that we think we have new msgs?
+                nsCOMPtr<nsIPrefBranch> prefBranch(
+                    do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+                if (NS_SUCCEEDED(rv)) {
+                  bool showPreviewText;
+                  prefBranch->GetBoolPref("mail.biff.alert.show_preview",
+                                          &showPreviewText);
+                  // if we're showing preview text, update ourselves if we got a
+                  // new unread message copied so that we can download the new
+                  // headers and have a chance to preview the msg bodies.
+                  if (!folderOpen && showPreviewText &&
+                      m_copyState->m_unreadCount > 0 &&
+                      !(mFlags &
+                        (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Junk)))
+                    UpdateFolder(msgWindow);
+                }
+              } else {
+                srcFolder->EnableNotifications(allMessageCountNotifications,
+                                               true);
+                srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgFailed);
+              }
+            }
+            if (m_copyState->m_msgWindow &&
+                m_copyState->m_undoMsgTxn &&  // may be null from filters
+                NS_SUCCEEDED(
+                    aExitCode))  // we should do this only if move/copy succeeds
+            {
+              nsCOMPtr<nsITransactionManager> txnMgr;
+              m_copyState->m_msgWindow->GetTransactionManager(
+                  getter_AddRefs(txnMgr));
+              if (txnMgr) {
+                RefPtr<nsImapMoveCopyMsgTxn> txn = m_copyState->m_undoMsgTxn;
+                mozilla::DebugOnly<nsresult> rv2 = txnMgr->DoTransaction(txn);
+                NS_ASSERTION(NS_SUCCEEDED(rv2), "doing transaction failed");
+              }
+            }
+            // nsImapUrl can hold a pointer to our m_copyState, so force a
+            // release here (see Bug 1586494).
+            imapUrl->SetCopyState(nullptr);
+            (void)OnCopyCompleted(m_copyState->m_srcSupport, aExitCode);
+          }
+
+          // we're the dest folder of a move/copy - if we're not open in the ui,
+          // then we should clear our nsMsgDatabase pointer. Otherwise, the db
+          // would be open until the user selected it and then selected another
+          // folder. but don't do this for the trash or inbox - we'll leave them
+          // open
+          if (!folderOpen &&
+              !(mFlags & (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Inbox)))
+            SetMsgDatabase(nullptr);
+          break;
+        case nsIImapUrl::nsImapSubtractMsgFlags: {
+          // this isn't really right - we'd like to know we were
+          // deleting a message to start with, but it probably
+          // won't do any harm.
+          imapMessageFlagsType flags = 0;
+          imapUrl->GetMsgFlags(&flags);
+          // we need to subtract the delete flag in db only in case when we show
+          // deleted msgs
+          if (flags & kImapMsgDeletedFlag && ShowDeletedMessages()) {
+            nsCOMPtr<nsIMsgDatabase> db;
+            rv = GetMsgDatabase(getter_AddRefs(db));
+            if (NS_SUCCEEDED(rv) && db) {
+              nsTArray<nsMsgKey> keyArray;
+              nsCString keyString;
+              imapUrl->GetListOfMessageIds(keyString);
+              ParseUidString(keyString.get(), keyArray);
+              MarkMessagesImapDeleted(&keyArray, false, db);
+              db->Commit(nsMsgDBCommitType::kLargeCommit);
+            }
+          }
+        } break;
+        case nsIImapUrl::nsImapAddMsgFlags: {
+          imapMessageFlagsType flags = 0;
+          imapUrl->GetMsgFlags(&flags);
+          if (flags & kImapMsgDeletedFlag) {
+            // we need to delete headers from db only when we don't show deleted
+            // msgs
+            if (!ShowDeletedMessages()) {
+              nsCOMPtr<nsIMsgDatabase> db;
+              rv = GetMsgDatabase(getter_AddRefs(db));
+              if (NS_SUCCEEDED(rv) && db) {
+                nsTArray<nsMsgKey> keyArray;
+                nsCString keyString;
+                imapUrl->GetListOfMessageIds(keyString);
+                ParseUidString(keyString.get(), keyArray);
+
+                // For pluggable stores that do not support compaction, we need
+                // to delete the messages now.
+                bool supportsCompaction = false;
+                nsCOMPtr<nsIMsgPluggableStore> offlineStore;
+                (void)GetMsgStore(getter_AddRefs(offlineStore));
+                if (offlineStore)
+                  offlineStore->GetSupportsCompaction(&supportsCompaction);
+
+                nsTArray<RefPtr<nsIMsgDBHdr>> msgHdrs;
+                if (notifier || !supportsCompaction) {
+                  MsgGetHeadersFromKeys(db, keyArray, msgHdrs);
+                }
+
+                // Notify listeners of delete.
+                if (notifier && !msgHdrs.IsEmpty()) {
+                  // XXX Currently, the DeleteMessages below gets executed twice
+                  // on deletes. Once in DeleteMessages, once here. The second
+                  // time, it silently fails to delete. This is why we're also
+                  // checking whether the array is empty.
+                  notifier->NotifyMsgsDeleted(msgHdrs);
+                }
+
+                if (!supportsCompaction && !msgHdrs.IsEmpty())
+                  DeleteStoreMessages(msgHdrs);
+
+                db->DeleteMessages(keyArray, nullptr);
+                db->SetSummaryValid(true);
+                db->Commit(nsMsgDBCommitType::kLargeCommit);
+              }
+            }
+          }
+        } break;
+        case nsIImapUrl::nsImapAppendMsgFromFile:
+        case nsIImapUrl::nsImapAppendDraftFromFile:
+          if (m_copyState) {
+            if (NS_SUCCEEDED(aExitCode)) {
+              UpdatePendingCounts();
+
+              m_copyState->m_curIndex++;
+              if (m_copyState->m_curIndex >= m_copyState->m_messages.Length()) {
+                nsCOMPtr<nsIUrlListener> saveUrlListener = m_urlListener;
+                if (folderOpen) {
+                  // This gives a way for the caller to get notified
+                  // when the UpdateFolder url is done.
+                  // (if the nsIMsgCopyServiceListener also implements
+                  // nsIUrlListener)
+                  if (m_copyState->m_listener)
+                    m_urlListener = do_QueryInterface(m_copyState->m_listener);
+                }
+                if (m_copyState->m_msgWindow && m_copyState->m_undoMsgTxn) {
+                  nsCOMPtr<nsITransactionManager> txnMgr;
+                  m_copyState->m_msgWindow->GetTransactionManager(
+                      getter_AddRefs(txnMgr));
+                  if (txnMgr) {
+                    RefPtr<nsImapMoveCopyMsgTxn> txn =
+                        m_copyState->m_undoMsgTxn;
+                    txnMgr->DoTransaction(txn);
+                  }
+                }
+                (void)OnCopyCompleted(m_copyState->m_srcSupport, aExitCode);
+                if (folderOpen ||
+                    imapAction == nsIImapUrl::nsImapAppendDraftFromFile) {
+                  UpdateFolderWithListener(msgWindow, m_urlListener);
+                  m_urlListener = saveUrlListener;
+                }
+              }
+            } else {
+              // clear the copyState if copy has failed
+              (void)OnCopyCompleted(m_copyState->m_srcSupport, aExitCode);
+            }
+          }
+          break;
+        case nsIImapUrl::nsImapMoveFolderHierarchy:
+          if (m_copyState)  // delete folder gets here, but w/o an m_copyState
+          {
+            nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(
+                "@mozilla.org/messenger/messagecopyservice;1", &rv);
+            NS_ENSURE_SUCCESS(rv, rv);
+            nsCOMPtr<nsIMsgFolder> srcFolder =
+                do_QueryInterface(m_copyState->m_srcSupport);
+            if (srcFolder) {
+              copyService->NotifyCompletion(m_copyState->m_srcSupport, this,
+                                            aExitCode);
+            }
+            m_copyState = nullptr;
+          }
+          break;
+        case nsIImapUrl::nsImapRenameFolder:
+          if (NS_FAILED(aExitCode)) {
+            NotifyFolderEvent(kRenameCompleted);
+          }
+          break;
+        case nsIImapUrl::nsImapDeleteAllMsgs:
+          if (NS_SUCCEEDED(aExitCode)) {
+            if (folderOpen)
+              UpdateFolder(msgWindow);
+            else {
+              ChangeNumPendingTotalMessages(-mNumPendingTotalMessages);
+              ChangeNumPendingUnread(-mNumPendingUnreadMessages);
+              m_numServerUnseenMessages = 0;
+            }
+          }
+          break;
+        case nsIImapUrl::nsImapListFolder:
+          if (NS_SUCCEEDED(aExitCode)) {
+            // listing folder will open db; don't leave the db open.
+            SetMsgDatabase(nullptr);
+            if (!m_verifiedAsOnlineFolder) {
+              // If folder is not verified, we remove it.
+              nsCOMPtr<nsIMsgFolder> parent;
+              rv = GetParent(getter_AddRefs(parent));
+              if (NS_SUCCEEDED(rv) && parent) {
+                nsCOMPtr<nsIMsgImapMailFolder> imapParent =
+                    do_QueryInterface(parent);
+                if (imapParent) this->RemoveLocalSelf();
+              }
+            }
+          }
+          break;
+        case nsIImapUrl::nsImapRefreshFolderUrls:
+          // we finished getting an admin url for the folder.
+          if (!m_adminUrl.IsEmpty()) FolderPrivileges(msgWindow);
+          break;
+        case nsIImapUrl::nsImapCreateFolder:
+          if (NS_FAILED(aExitCode))  // if success notification already done
+          {
+            NotifyFolderEvent(kFolderCreateFailed);
+          }
+          break;
+        case nsIImapUrl::nsImapSubscribe:
+          if (NS_SUCCEEDED(aExitCode) && msgWindow) {
+            nsCString canonicalFolderName;
+            imapUrl->CreateCanonicalSourceFolderPathString(
+                getter_Copies(canonicalFolderName));
+            nsCOMPtr<nsIMsgFolder> rootFolder;
+            nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
+            if (NS_SUCCEEDED(rv) && rootFolder) {
+              nsCOMPtr<nsIMsgImapMailFolder> imapRoot =
+                  do_QueryInterface(rootFolder);
+              if (imapRoot) {
+                nsCOMPtr<nsIMsgImapMailFolder> foundFolder;
+                rv = imapRoot->FindOnlineSubFolder(canonicalFolderName,
+                                                   getter_AddRefs(foundFolder));
+                if (NS_SUCCEEDED(rv) && foundFolder) {
+                  nsCString uri;
+                  nsCOMPtr<nsIMsgFolder> msgFolder =
+                      do_QueryInterface(foundFolder);
+                  if (msgFolder) {
+                    nsCOMPtr<nsIObserverService> obsServ =
+                        mozilla::services::GetObserverService();
+                    obsServ->NotifyObservers(msgFolder, "folder-subscribed",
+                                             nullptr);
+                  }
+                }
+              }
+            }
+          }
+          break;
+        case nsIImapUrl::nsImapExpungeFolder:
+          break;
+        default:
+          break;
+      }
+    }
+    // give base class a chance to send folder loaded notification...
+    rv = nsMsgDBFolder::OnStopRunningUrl(aUrl, aExitCode);
+  }
+  // if we're not running a url, we must not be getting new mail.
+  SetGettingNewMessages(false);
+
+  // If we're planning to inform another listener then do that now.
+  // Some folder methods can take a listener to inform when the operation
+  // is complete e.g. UpdateFolderWithListener(), DownloadAllForOffline(),
+  // GetNewMessages(). That listener is stashed in m_urlListener.
+  if (m_urlListener) {
+    nsCOMPtr<nsIUrlListener> saveListener = m_urlListener;
+    m_urlListener = nullptr;
+    saveListener->OnStopRunningUrl(aUrl, aExitCode);
+  }
+  return rv;
+}
+
+void nsImapMailFolder::UpdatePendingCounts() {
+  if (m_copyState) {
+    int32_t delta =
+        m_copyState->m_isCrossServerOp ? 1 : m_copyState->m_messages.Length();
+    if (!m_copyState->m_selectedState && m_copyState->m_messages.IsEmpty()) {
+      // special case from CopyFileMessage():
+      // - copied a single message in from a file
+      // - no previously-existing messages are involved
+      delta = 1;
+    }
+    ChangePendingTotal(delta);
+
+    // count the moves that were unread
+    int numUnread = m_copyState->m_unreadCount;
+    if (numUnread) {
+      m_numServerUnseenMessages +=
+          numUnread;  // adjust last status count by this delta.
+      ChangeNumPendingUnread(numUnread);
+    }
+    SummaryChanged();
+  }
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::ClearFolderRights() {
+  SetFolderNeedsACLListed(false);
+  delete m_folderACL;
+  m_folderACL = new nsMsgIMAPFolderACL(this);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::AddFolderRights(const nsACString& userName,
+                                  const nsACString& rights) {
+  SetFolderNeedsACLListed(false);
+  GetFolderACL()->SetFolderRightsForUser(userName, rights);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::RefreshFolderRights() {
+  if (GetFolderACL()->GetIsFolderShared())
+    SetFlag(nsMsgFolderFlags::PersonalShared);
+  else
+    ClearFlag(nsMsgFolderFlags::PersonalShared);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetCopyResponseUid(const char* msgIdString,
+                                     nsIImapUrl* aUrl) {  // CopyMessages() only
+  nsresult rv = NS_OK;
+  RefPtr<nsImapMoveCopyMsgTxn> msgTxn;
+  nsCOMPtr<nsISupports> copyState;
+
+  if (aUrl) aUrl->GetCopyState(getter_AddRefs(copyState));
+
+  if (copyState) {
+    nsCOMPtr<nsImapMailCopyState> mailCopyState =
+        do_QueryInterface(copyState, &rv);
+    if (NS_FAILED(rv)) return rv;
+    if (mailCopyState->m_undoMsgTxn) msgTxn = mailCopyState->m_undoMsgTxn;
+  } else if (aUrl && m_pendingOfflineMoves.Length()) {
+    nsCString urlSourceMsgIds, undoTxnSourceMsgIds;
+    aUrl->GetListOfMessageIds(urlSourceMsgIds);
+    RefPtr<nsImapMoveCopyMsgTxn> imapUndo = m_pendingOfflineMoves[0];
+    if (imapUndo) {
+      imapUndo->GetSrcMsgIds(undoTxnSourceMsgIds);
+      if (undoTxnSourceMsgIds.Equals(urlSourceMsgIds)) msgTxn = imapUndo;
+      // ### we should handle batched moves, but lets keep it simple for a2.
+      m_pendingOfflineMoves.Clear();
+    }
+  }
+  if (msgTxn) msgTxn->SetCopyResponseUid(msgIdString);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::StartMessage(nsIMsgMailNewsUrl* aUrl) {
+  nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(aUrl));
+  nsCOMPtr<nsISupports> copyState;
+  NS_ENSURE_TRUE(imapUrl, NS_ERROR_FAILURE);
+
+  imapUrl->GetCopyState(getter_AddRefs(copyState));
+  if (copyState) {
+    nsCOMPtr<nsICopyMessageStreamListener> listener =
+        do_QueryInterface(copyState);
+    if (listener) listener->StartMessage();
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::EndMessage(nsIMsgMailNewsUrl* aUrl, nsMsgKey uidOfMessage) {
+  nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(aUrl));
+  nsCOMPtr<nsISupports> copyState;
+  NS_ENSURE_TRUE(imapUrl, NS_ERROR_FAILURE);
+  imapUrl->GetCopyState(getter_AddRefs(copyState));
+  if (copyState) {
+    nsCOMPtr<nsICopyMessageStreamListener> listener =
+        do_QueryInterface(copyState);
+    if (listener) listener->EndMessage(uidOfMessage);
+  }
+  return NS_OK;
+}
+
+#define WHITESPACE " \015\012"  // token delimiter
+
+NS_IMETHODIMP
+nsImapMailFolder::NotifySearchHit(nsIMsgMailNewsUrl* aUrl,
+                                  const char* searchHitLine) {
+  NS_ENSURE_ARG_POINTER(aUrl);
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // expect search results in the form of "* SEARCH <hit> <hit> ..."
+  // expect search results in the form of "* SEARCH <hit> <hit> ..."
+  nsCString tokenString(searchHitLine);
+  char* currentPosition = PL_strcasestr(tokenString.get(), "SEARCH");
+  if (currentPosition) {
+    currentPosition += strlen("SEARCH");
+    bool shownUpdateAlert = false;
+    char* hitUidToken = NS_strtok(WHITESPACE, &currentPosition);
+    while (hitUidToken) {
+      long naturalLong;  // %l is 64 bits on OSF1
+      sscanf(hitUidToken, "%ld", &naturalLong);
+      nsMsgKey hitUid = (nsMsgKey)naturalLong;
+
+      nsCOMPtr<nsIMsgDBHdr> hitHeader;
+      rv = mDatabase->GetMsgHdrForKey(hitUid, getter_AddRefs(hitHeader));
+      if (NS_SUCCEEDED(rv) && hitHeader) {
+        nsCOMPtr<nsIMsgSearchSession> searchSession;
+        nsCOMPtr<nsIMsgSearchAdapter> searchAdapter;
+        aUrl->GetSearchSession(getter_AddRefs(searchSession));
+        if (searchSession) {
+          searchSession->GetRunningAdapter(getter_AddRefs(searchAdapter));
+          if (searchAdapter) searchAdapter->AddResultElement(hitHeader);
+        }
+      } else if (!shownUpdateAlert) {
+      }
+
+      hitUidToken = NS_strtok(WHITESPACE, &currentPosition);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetAppendMsgUid(nsMsgKey aKey, nsIImapUrl* aUrl) {
+  nsresult rv;
+  nsCOMPtr<nsISupports> copyState;
+  if (aUrl) aUrl->GetCopyState(getter_AddRefs(copyState));
+  if (copyState) {
+    nsCOMPtr<nsImapMailCopyState> mailCopyState =
+        do_QueryInterface(copyState, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    if (mailCopyState->m_undoMsgTxn)  // CopyMessages()
+    {
+      RefPtr<nsImapMoveCopyMsgTxn> msgTxn;
+      msgTxn = mailCopyState->m_undoMsgTxn;
+      msgTxn->AddDstKey(aKey);
+    } else if (mailCopyState->m_listener)  // CopyFileMessage();
+                                           // Draft/Template goes here
+    {
+      mailCopyState->m_appendUID = aKey;
+      mailCopyState->m_listener->SetMessageKey(aKey);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetMessageId(nsIImapUrl* aUrl, nsACString& messageId) {
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsISupports> copyState;
+
+  if (aUrl) aUrl->GetCopyState(getter_AddRefs(copyState));
+  if (copyState) {
+    nsCOMPtr<nsImapMailCopyState> mailCopyState =
+        do_QueryInterface(copyState, &rv);
+    if (NS_FAILED(rv)) return rv;
+    if (mailCopyState->m_listener)
+      rv = mailCopyState->m_listener->GetMessageId(messageId);
+  }
+  if (NS_SUCCEEDED(rv) && messageId.Length() > 0) {
+    if (messageId.First() == '<') messageId.Cut(0, 1);
+    if (messageId.Last() == '>') messageId.SetLength(messageId.Length() - 1);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::HeaderFetchCompleted(nsIImapProtocol* aProtocol) {
+  nsCOMPtr<nsIMsgWindow>
+      msgWindow;  // we might need this for the filter plugins.
+  if (mBackupDatabase) RemoveBackupMsgDatabase();
+
+  SetSizeOnDisk(mFolderSize);
+  int32_t numNewBiffMsgs = 0;
+  if (m_performingBiff) GetNumNewMessages(false, &numNewBiffMsgs);
+
+  bool pendingMoves = m_moveCoalescer && m_moveCoalescer->HasPendingMoves();
+  PlaybackCoalescedOperations();
+  if (aProtocol) {
+    // check if we should download message bodies because it's the inbox and
+    // the server is specified as one where where we download msg bodies
+    // automatically. Or if we autosyncing all offline folders.
+    nsCOMPtr<nsIImapIncomingServer> imapServer;
+    GetImapIncomingServer(getter_AddRefs(imapServer));
+
+    bool autoDownloadNewHeaders = false;
+    bool autoSyncOfflineStores = false;
+
+    if (imapServer) {
+      imapServer->GetAutoSyncOfflineStores(&autoSyncOfflineStores);
+      imapServer->GetDownloadBodiesOnGetNewMail(&autoDownloadNewHeaders);
+      if (m_filterListRequiresBody) autoDownloadNewHeaders = true;
+    }
+    bool notifiedBodies = false;
+    if (m_downloadingFolderForOfflineUse || autoSyncOfflineStores ||
+        autoDownloadNewHeaders) {
+      nsTArray<nsMsgKey> keysToDownload;
+      GetBodysToDownload(&keysToDownload);
+      if (!keysToDownload.IsEmpty() &&
+          (m_downloadingFolderForOfflineUse || autoDownloadNewHeaders)) {
+        // this is the case when DownloadAllForOffline is called.
+        notifiedBodies = true;
+        aProtocol->NotifyBodysToDownload(keysToDownload);
+      } else {
+        // create auto-sync state object lazily
+        InitAutoSyncState();
+        if (MOZ_LOG_TEST(gAutoSyncLog, mozilla::LogLevel::Debug)) {
+          int32_t flags = 0;
+          GetFlags((uint32_t*)&flags);
+          nsString folderName;
+          GetName(folderName);
+          nsCString utfLeafName;
+          CopyUTF16toUTF8(folderName, utfLeafName);
+          MOZ_LOG(gAutoSyncLog, mozilla::LogLevel::Debug,
+                  ("%s: foldername=%s, flags=0x%X, "
+                   "isOffline=%s, nsMsgFolderFlags::Offline=0x%X",
+                   __func__, utfLeafName.get(), flags,
+                   (flags & nsMsgFolderFlags::Offline) ? "true" : "false",
+                   nsMsgFolderFlags::Offline));
+          MOZ_LOG(gAutoSyncLog, mozilla::LogLevel::Debug,
+                  ("%s: created autosync obj, have keys to download=%s",
+                   __func__, keysToDownload.IsEmpty() ? "false" : "true"));
+        }
+        // make enough room for new downloads
+        m_autoSyncStateObj->ManageStorageSpace();  // currently a no-op
+
+        m_autoSyncStateObj->SetServerCounts(
+            m_numServerTotalMessages, m_numServerRecentMessages,
+            m_numServerUnseenMessages, m_nextUID);
+        m_autoSyncStateObj->OnNewHeaderFetchCompleted(keysToDownload);
+      }
+    }
+    if (!notifiedBodies) {
+      nsTArray<nsMsgKey> noBodies;
+      aProtocol->NotifyBodysToDownload(noBodies);
+    }
+
+    nsCOMPtr<nsIURI> runningUri;
+    aProtocol->GetRunningUrl(getter_AddRefs(runningUri));
+    if (runningUri) {
+      nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(runningUri);
+      if (mailnewsUrl) mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+    }
+  }
+
+  // delay calling plugins if filter application is also delayed
+  if (!m_filterListRequiresBody) {
+    bool filtersRun;
+    CallFilterPlugins(msgWindow, &filtersRun);
+    if (!filtersRun && m_performingBiff && mDatabase && numNewBiffMsgs > 0 &&
+        (!pendingMoves || !ShowPreviewText())) {
+      // If we are performing biff for this folder, tell the
+      // stand-alone biff about the new high water mark
+      // We must ensure that the server knows that we are performing biff.
+      // Otherwise the stand-alone biff won't fire.
+      nsCOMPtr<nsIMsgIncomingServer> server;
+      if (NS_SUCCEEDED(GetServer(getter_AddRefs(server))) && server)
+        server->SetPerformingBiff(true);
+
+      SetBiffState(nsIMsgFolder::nsMsgBiffState_NewMail);
+      if (server) server->SetPerformingBiff(false);
+      m_performingBiff = false;
+    }
+
+    if (m_filterList) (void)m_filterList->FlushLogIfNecessary();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetBiffStateAndUpdate(nsMsgBiffState biffState) {
+  SetBiffState(biffState);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetUidValidity(int32_t* uidValidity) {
+  NS_ENSURE_ARG(uidValidity);
+  if ((int32_t)m_uidValidity == kUidUnknown) {
+    nsCOMPtr<nsIMsgDatabase> db;
+    nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+    (void)GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo),
+                               getter_AddRefs(db));
+    if (db) db->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+
+    if (dbFolderInfo)
+      dbFolderInfo->GetImapUidValidity((int32_t*)&m_uidValidity);
+  }
+  *uidValidity = m_uidValidity;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetUidValidity(int32_t uidValidity) {
+  m_uidValidity = uidValidity;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::FillInFolderProps(nsIMsgImapFolderProps* aFolderProps) {
+  NS_ENSURE_ARG(aFolderProps);
+  const char* folderTypeStringID;
+  const char* folderTypeDescStringID = nullptr;
+  const char* folderQuotaStatusStringID;
+  nsString folderType;
+  nsString folderTypeDesc;
+  nsString folderQuotaStatusDesc;
+  nsCOMPtr<nsIStringBundle> bundle;
+  nsresult rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+  // if for some bizarre reason this fails, we'll still fall through to the
+  // normal sharing code
+  if (NS_SUCCEEDED(rv)) {
+    // get the latest committed imap capabilities bit mask.
+    eIMAPCapabilityFlags capability = kCapabilityUndefined;
+    imapServer->GetCapability(&capability);
+    bool haveACL = capability & kACLCapability;
+    bool haveQuota = capability & kQuotaCapability;
+
+    // Figure out what to display in the Quota tab of the folder properties.
+    // Does the server support quotas? This depends on the latest imap
+    // CAPABILITY response.
+    if (haveQuota) {
+      // Have quota capability. Have we asked the server for quota information?
+      if (m_folderQuotaCommandIssued) {
+        // Has the server replied with all the quota info?
+        if (m_folderQuotaDataIsValid) {
+          if (!m_folderQuota.IsEmpty()) {
+            // If so, set quota data to show in the quota tab
+            folderQuotaStatusStringID = nullptr;
+            aFolderProps->SetQuotaData(m_folderQuota);
+          } else {
+            // The server reported no quota limits on this folder.
+            folderQuotaStatusStringID = "imapQuotaStatusNoQuota2";
+          }
+        } else {
+          // The getquotaroot command was sent to the server but the complete
+          // response was not yet received when the folder properties were
+          // requested. This is rare. Request the folder properties again to
+          // obtain the quota data.
+          folderQuotaStatusStringID = "imapQuotaStatusInProgress";
+        }
+      } else {
+        // The folder is not open, so no quota information is available
+        folderQuotaStatusStringID = "imapQuotaStatusFolderNotOpen";
+      }
+    } else {
+      // Either the server doesn't support quotas, or we don't know if it does
+      // (e.g., because we don't have a connection yet). If the latter, we fall
+      // back to saying that no information is available because the folder is
+      // not yet open.
+      folderQuotaStatusStringID = (capability == kCapabilityUndefined)
+                                      ? "imapQuotaStatusFolderNotOpen"
+                                      : "imapQuotaStatusNotSupported";
+    }
+
+    if (!folderQuotaStatusStringID) {
+      // Display quota data
+      aFolderProps->ShowQuotaData(true);
+    } else {
+      // Hide quota data and show reason why it is not available
+      aFolderProps->ShowQuotaData(false);
+
+      rv = IMAPGetStringByName(folderQuotaStatusStringID,
+                               getter_Copies(folderQuotaStatusDesc));
+      if (NS_SUCCEEDED(rv)) aFolderProps->SetQuotaStatus(folderQuotaStatusDesc);
+    }
+
+    // See if the server supports ACL.
+    // If not, just set the folder description to a string that says
+    // the server doesn't support sharing, and return.
+    if (!haveACL) {
+      rv = IMAPGetStringByName("imapServerDoesntSupportAcl",
+                               getter_Copies(folderTypeDesc));
+      if (NS_SUCCEEDED(rv))
+        aFolderProps->SetFolderTypeDescription(folderTypeDesc);
+      aFolderProps->ServerDoesntSupportACL();
+      return NS_OK;
+    }
+  }
+  if (mFlags & nsMsgFolderFlags::ImapPublic) {
+    folderTypeStringID = "imapPublicFolderTypeName";
+    folderTypeDescStringID = "imapPublicFolderTypeDescription";
+  } else if (mFlags & nsMsgFolderFlags::ImapOtherUser) {
+    folderTypeStringID = "imapOtherUsersFolderTypeName";
+    nsCString owner;
+    nsString uniOwner;
+    GetFolderOwnerUserName(owner);
+    if (owner.IsEmpty()) {
+      IMAPGetStringByName(folderTypeStringID, getter_Copies(uniOwner));
+      // Another user's folder, for which we couldn't find an owner name
+      NS_ASSERTION(false, "couldn't get owner name for other user's folder");
+    } else {
+      CopyUTF8toUTF16(owner, uniOwner);
+    }
+    AutoTArray<nsString, 1> params = {uniOwner};
+    bundle->FormatStringFromName("imapOtherUsersFolderTypeDescription", params,
+                                 folderTypeDesc);
+  } else if (GetFolderACL()->GetIsFolderShared()) {
+    folderTypeStringID = "imapPersonalSharedFolderTypeName";
+    folderTypeDescStringID = "imapPersonalSharedFolderTypeDescription";
+  } else {
+    folderTypeStringID = "imapPersonalSharedFolderTypeName";
+    folderTypeDescStringID = "imapPersonalFolderTypeDescription";
+  }
+
+  rv = IMAPGetStringByName(folderTypeStringID, getter_Copies(folderType));
+  if (NS_SUCCEEDED(rv)) aFolderProps->SetFolderType(folderType);
+
+  if (folderTypeDesc.IsEmpty() && folderTypeDescStringID)
+    IMAPGetStringByName(folderTypeDescStringID, getter_Copies(folderTypeDesc));
+  if (!folderTypeDesc.IsEmpty())
+    aFolderProps->SetFolderTypeDescription(folderTypeDesc);
+
+  nsString rightsString;
+  rv = CreateACLRightsStringForFolder(rightsString);
+  if (NS_SUCCEEDED(rv)) aFolderProps->SetFolderPermissions(rightsString);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetAclFlags(uint32_t aclFlags) {
+  nsresult rv = NS_OK;
+  if (m_aclFlags != aclFlags) {
+    nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+    bool dbWasOpen = (mDatabase != nullptr);
+    rv = GetDatabase();
+
+    m_aclFlags = aclFlags;
+    if (mDatabase) {
+      rv = mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+      if (NS_SUCCEEDED(rv) && dbFolderInfo)
+        dbFolderInfo->SetUint32Property("aclFlags", aclFlags);
+      // if setting the acl flags caused us to open the db, release the ref
+      // because on startup, we might get acl on all folders,which will
+      // leave a lot of db's open.
+      if (!dbWasOpen) {
+        mDatabase->Close(true /* commit changes */);
+        mDatabase = nullptr;
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetAclFlags(uint32_t* aclFlags) {
+  NS_ENSURE_ARG_POINTER(aclFlags);
+  nsresult rv;
+  ReadDBFolderInfo(false);        // update cache first.
+  if (m_aclFlags == kAclInvalid)  // -1 means invalid value, so get it from db.
+  {
+    nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+    bool dbWasOpen = (mDatabase != nullptr);
+    rv = GetDatabase();
+
+    if (mDatabase) {
+      rv = mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+      if (NS_SUCCEEDED(rv) && dbFolderInfo) {
+        rv = dbFolderInfo->GetUint32Property("aclFlags", 0, aclFlags);
+        m_aclFlags = *aclFlags;
+      }
+      // if getting the acl flags caused us to open the db, release the ref
+      // because on startup, we might get acl on all folders,which will
+      // leave a lot of db's open.
+      if (!dbWasOpen) {
+        mDatabase->Close(true /* commit changes */);
+        mDatabase = nullptr;
+      }
+    }
+  } else
+    *aclFlags = m_aclFlags;
+  return NS_OK;
+}
+
+nsresult nsImapMailFolder::SetSupportedUserFlags(uint32_t userFlags) {
+  nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+  nsresult rv = GetDatabase();
+
+  m_supportedUserFlags = userFlags;
+  if (mDatabase) {
+    rv = mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+    if (NS_SUCCEEDED(rv) && dbFolderInfo)
+      dbFolderInfo->SetUint32Property("imapFlags", userFlags);
+  }
+  return rv;
+}
+
+nsresult nsImapMailFolder::GetSupportedUserFlags(uint32_t* userFlags) {
+  NS_ENSURE_ARG_POINTER(userFlags);
+
+  nsresult rv = NS_OK;
+
+  ReadDBFolderInfo(false);        // update cache first.
+  if (m_supportedUserFlags == 0)  // 0 means invalid value, so get it from db.
+  {
+    nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
+    rv = GetDatabase();
+
+    if (mDatabase) {
+      rv = mDatabase->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));
+      if (NS_SUCCEEDED(rv) && dbFolderInfo) {
+        rv = dbFolderInfo->GetUint32Property("imapFlags", 0, userFlags);
+        m_supportedUserFlags = *userFlags;
+      }
+    }
+  } else
+    *userFlags = m_supportedUserFlags;
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetCanOpenFolder(bool* aBool) {
+  NS_ENSURE_ARG_POINTER(aBool);
+  bool noSelect;
+  GetFlag(nsMsgFolderFlags::ImapNoselect, &noSelect);
+  *aBool = (noSelect) ? false : GetFolderACL()->GetCanIReadFolder();
+  return NS_OK;
+}
+
+///////// nsMsgIMAPFolderACL class ///////////////////////////////
+
+// This string is defined in the ACL RFC to be "anyone"
+#define IMAP_ACL_ANYONE_STRING "anyone"
+
+nsMsgIMAPFolderACL::nsMsgIMAPFolderACL(nsImapMailFolder* folder)
+    : m_rightsHash(24) {
+  NS_ASSERTION(folder, "need folder");
+  m_folder = folder;
+  m_aclCount = 0;
+  BuildInitialACLFromCache();
+}
+
+nsMsgIMAPFolderACL::~nsMsgIMAPFolderACL() {}
+
+// We cache most of our own rights in the MSG_FOLDER_PREF_* flags
+void nsMsgIMAPFolderACL::BuildInitialACLFromCache() {
+  nsAutoCString myrights;
+
+  uint32_t startingFlags;
+  m_folder->GetAclFlags(&startingFlags);
+
+  if (startingFlags & IMAP_ACL_READ_FLAG) myrights += "r";
+  if (startingFlags & IMAP_ACL_STORE_SEEN_FLAG) myrights += "s";
+  if (startingFlags & IMAP_ACL_WRITE_FLAG) myrights += "w";
+  if (startingFlags & IMAP_ACL_INSERT_FLAG) myrights += "i";
+  if (startingFlags & IMAP_ACL_POST_FLAG) myrights += "p";
+  if (startingFlags & IMAP_ACL_CREATE_SUBFOLDER_FLAG) myrights += "c";
+  if (startingFlags & IMAP_ACL_DELETE_FLAG) myrights += "dt";
+  if (startingFlags & IMAP_ACL_ADMINISTER_FLAG) myrights += "a";
+  if (startingFlags & IMAP_ACL_EXPUNGE_FLAG) myrights += "e";
+
+  if (!myrights.IsEmpty()) SetFolderRightsForUser(EmptyCString(), myrights);
+}
+
+void nsMsgIMAPFolderACL::UpdateACLCache() {
+  uint32_t startingFlags = 0;
+  m_folder->GetAclFlags(&startingFlags);
+
+  if (GetCanIReadFolder())
+    startingFlags |= IMAP_ACL_READ_FLAG;
+  else
+    startingFlags &= ~IMAP_ACL_READ_FLAG;
+
+  if (GetCanIStoreSeenInFolder())
+    startingFlags |= IMAP_ACL_STORE_SEEN_FLAG;
+  else
+    startingFlags &= ~IMAP_ACL_STORE_SEEN_FLAG;
+
+  if (GetCanIWriteFolder())
+    startingFlags |= IMAP_ACL_WRITE_FLAG;
+  else
+    startingFlags &= ~IMAP_ACL_WRITE_FLAG;
+
+  if (GetCanIInsertInFolder())
+    startingFlags |= IMAP_ACL_INSERT_FLAG;
+  else
+    startingFlags &= ~IMAP_ACL_INSERT_FLAG;
+
+  if (GetCanIPostToFolder())
+    startingFlags |= IMAP_ACL_POST_FLAG;
+  else
+    startingFlags &= ~IMAP_ACL_POST_FLAG;
+
+  if (GetCanICreateSubfolder())
+    startingFlags |= IMAP_ACL_CREATE_SUBFOLDER_FLAG;
+  else
+    startingFlags &= ~IMAP_ACL_CREATE_SUBFOLDER_FLAG;
+
+  if (GetCanIDeleteInFolder())
+    startingFlags |= IMAP_ACL_DELETE_FLAG;
+  else
+    startingFlags &= ~IMAP_ACL_DELETE_FLAG;
+
+  if (GetCanIAdministerFolder())
+    startingFlags |= IMAP_ACL_ADMINISTER_FLAG;
+  else
+    startingFlags &= ~IMAP_ACL_ADMINISTER_FLAG;
+
+  if (GetCanIExpungeFolder())
+    startingFlags |= IMAP_ACL_EXPUNGE_FLAG;
+  else
+    startingFlags &= ~IMAP_ACL_EXPUNGE_FLAG;
+
+  m_folder->SetAclFlags(startingFlags);
+}
+
+bool nsMsgIMAPFolderACL::SetFolderRightsForUser(const nsACString& userName,
+                                                const nsACString& rights) {
+  nsCString myUserName;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = m_folder->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  server->GetUsername(myUserName);
+
+  nsAutoCString ourUserName;
+  if (userName.IsEmpty())
+    ourUserName.Assign(myUserName);
+  else
+    ourUserName.Assign(userName);
+
+  if (ourUserName.IsEmpty()) return false;
+
+  ToLowerCase(ourUserName);
+  nsCString oldValue = m_rightsHash.Get(ourUserName);
+  if (!oldValue.IsEmpty()) {
+    m_rightsHash.Remove(ourUserName);
+    m_aclCount--;
+    NS_ASSERTION(m_aclCount >= 0, "acl count can't go negative");
+  }
+  m_aclCount++;
+  m_rightsHash.InsertOrUpdate(ourUserName, PromiseFlatCString(rights));
+
+  if (myUserName.Equals(ourUserName) ||
+      ourUserName.EqualsLiteral(IMAP_ACL_ANYONE_STRING))
+    // if this is setting an ACL for me, cache it in the folder pref flags
+    UpdateACLCache();
+
+  return true;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetOtherUsersWithAccess(
+    nsIUTF8StringEnumerator** aResult) {
+  return GetFolderACL()->GetOtherUsers(aResult);
+}
+
+nsresult nsMsgIMAPFolderACL::GetOtherUsers(nsIUTF8StringEnumerator** aResult) {
+  nsCString myUserName;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = m_folder->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+  server->GetUsername(myUserName);
+
+  // We need to filter out myUserName from m_rightsHash.
+  nsTArray<nsCString>* resultArray = new nsTArray<nsCString>;
+  for (auto iter = m_rightsHash.Iter(); !iter.Done(); iter.Next()) {
+    if (!iter.Key().Equals(myUserName)) resultArray->AppendElement(iter.Key());
+  }
+
+  // enumerator will free resultArray
+  return NS_NewAdoptingUTF8StringEnumerator(aResult, resultArray);
+}
+
+nsresult nsImapMailFolder::GetPermissionsForUser(const nsACString& otherUser,
+                                                 nsACString& aResult) {
+  nsCString str;
+  nsresult rv = GetFolderACL()->GetRightsStringForUser(otherUser, str);
+  NS_ENSURE_SUCCESS(rv, rv);
+  aResult = str;
+  return NS_OK;
+}
+
+nsresult nsMsgIMAPFolderACL::GetRightsStringForUser(
+    const nsACString& inUserName, nsCString& rights) {
+  nsCString userName;
+  userName.Assign(inUserName);
+  if (userName.IsEmpty()) {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+
+    nsresult rv = m_folder->GetServer(getter_AddRefs(server));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // we need the real user name to match with what the imap server returns
+    // in the acl response.
+    server->GetUsername(userName);
+  }
+  ToLowerCase(userName);
+  rights = m_rightsHash.Get(userName);
+  return NS_OK;
+}
+
+// First looks for individual user;  then looks for 'anyone' if the user isn't
+// found. Returns defaultIfNotFound, if neither are found.
+bool nsMsgIMAPFolderACL::GetFlagSetInRightsForUser(const nsACString& userName,
+                                                   char flag,
+                                                   bool defaultIfNotFound) {
+  nsCString flags;
+  nsresult rv = GetRightsStringForUser(userName, flags);
+  NS_ENSURE_SUCCESS(rv, defaultIfNotFound);
+  if (flags.IsEmpty()) {
+    nsCString anyoneFlags;
+    GetRightsStringForUser(nsLiteralCString(IMAP_ACL_ANYONE_STRING),
+                           anyoneFlags);
+    if (anyoneFlags.IsEmpty()) return defaultIfNotFound;
+    return (anyoneFlags.FindChar(flag) != kNotFound);
+  }
+  return (flags.FindChar(flag) != kNotFound);
+}
+
+bool nsMsgIMAPFolderACL::GetCanUserLookupFolder(const nsACString& userName) {
+  return GetFlagSetInRightsForUser(userName, 'l', false);
+}
+
+bool nsMsgIMAPFolderACL::GetCanUserReadFolder(const nsACString& userName) {
+  return GetFlagSetInRightsForUser(userName, 'r', false);
+}
+
+bool nsMsgIMAPFolderACL::GetCanUserStoreSeenInFolder(
+    const nsACString& userName) {
+  return GetFlagSetInRightsForUser(userName, 's', false);
+}
+
+bool nsMsgIMAPFolderACL::GetCanUserWriteFolder(const nsACString& userName) {
+  return GetFlagSetInRightsForUser(userName, 'w', false);
+}
+
+bool nsMsgIMAPFolderACL::GetCanUserInsertInFolder(const nsACString& userName) {
+  return GetFlagSetInRightsForUser(userName, 'i', false);
+}
+
+bool nsMsgIMAPFolderACL::GetCanUserPostToFolder(const nsACString& userName) {
+  return GetFlagSetInRightsForUser(userName, 'p', false);
+}
+
+bool nsMsgIMAPFolderACL::GetCanUserCreateSubfolder(const nsACString& userName) {
+  return GetFlagSetInRightsForUser(userName, 'c', false);
+}
+
+bool nsMsgIMAPFolderACL::GetCanUserDeleteInFolder(const nsACString& userName) {
+  return GetFlagSetInRightsForUser(userName, 'd', false) ||
+         GetFlagSetInRightsForUser(userName, 't', false);
+}
+
+bool nsMsgIMAPFolderACL::GetCanUserAdministerFolder(
+    const nsACString& userName) {
+  return GetFlagSetInRightsForUser(userName, 'a', false);
+}
+
+bool nsMsgIMAPFolderACL::GetCanILookupFolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 'l', true);
+}
+
+bool nsMsgIMAPFolderACL::GetCanIReadFolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 'r', true);
+}
+
+bool nsMsgIMAPFolderACL::GetCanIStoreSeenInFolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 's', true);
+}
+
+bool nsMsgIMAPFolderACL::GetCanIWriteFolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 'w', true);
+}
+
+bool nsMsgIMAPFolderACL::GetCanIInsertInFolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 'i', true);
+}
+
+bool nsMsgIMAPFolderACL::GetCanIPostToFolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 'p', true);
+}
+
+bool nsMsgIMAPFolderACL::GetCanICreateSubfolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 'c', true);
+}
+
+bool nsMsgIMAPFolderACL::GetCanIDeleteInFolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 'd', true) ||
+         GetFlagSetInRightsForUser(EmptyCString(), 't', true);
+}
+
+bool nsMsgIMAPFolderACL::GetCanIAdministerFolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 'a', true);
+}
+
+bool nsMsgIMAPFolderACL::GetCanIExpungeFolder() {
+  return GetFlagSetInRightsForUser(EmptyCString(), 'e', true) ||
+         GetFlagSetInRightsForUser(EmptyCString(), 'd', true);
+}
+
+// We use this to see if the ACLs think a folder is shared or not.
+// We will define "Shared" in 5.0 to mean:
+// At least one user other than the currently authenticated user has at least
+// one explicitly-listed ACL right on that folder.
+bool nsMsgIMAPFolderACL::GetIsFolderShared() {
+  // If we have more than one ACL count for this folder, which means that
+  // someone other than ourself has rights on it, then it is "shared."
+  if (m_aclCount > 1) return true;
+
+  // Or, if "anyone" has rights to it, it is shared.
+  nsCString anyonesRights =
+      m_rightsHash.Get(nsLiteralCString(IMAP_ACL_ANYONE_STRING));
+  return (!anyonesRights.IsEmpty());
+}
+
+bool nsMsgIMAPFolderACL::GetDoIHaveFullRightsForFolder() {
+  return (GetCanIReadFolder() && GetCanIWriteFolder() &&
+          GetCanIInsertInFolder() && GetCanIAdministerFolder() &&
+          GetCanICreateSubfolder() && GetCanIDeleteInFolder() &&
+          GetCanILookupFolder() && GetCanIStoreSeenInFolder() &&
+          GetCanIExpungeFolder() && GetCanIPostToFolder());
+}
+
+// Returns a newly allocated string describing these rights
+nsresult nsMsgIMAPFolderACL::CreateACLRightsString(nsAString& aRightsString) {
+  nsString curRight;
+  nsCOMPtr<nsIStringBundle> bundle;
+  nsresult rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (GetDoIHaveFullRightsForFolder()) {
+    nsAutoString result;
+    rv = bundle->GetStringFromName("imapAclFullRights", result);
+    aRightsString.Assign(result);
+    return rv;
+  }
+
+  if (GetCanIReadFolder()) {
+    bundle->GetStringFromName("imapAclReadRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  if (GetCanIWriteFolder()) {
+    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+    bundle->GetStringFromName("imapAclWriteRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  if (GetCanIInsertInFolder()) {
+    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+    bundle->GetStringFromName("imapAclInsertRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  if (GetCanILookupFolder()) {
+    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+    bundle->GetStringFromName("imapAclLookupRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  if (GetCanIStoreSeenInFolder()) {
+    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+    bundle->GetStringFromName("imapAclSeenRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  if (GetCanIDeleteInFolder()) {
+    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+    bundle->GetStringFromName("imapAclDeleteRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  if (GetCanIExpungeFolder()) {
+    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+    bundle->GetStringFromName("imapAclExpungeRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  if (GetCanICreateSubfolder()) {
+    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+    bundle->GetStringFromName("imapAclCreateRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  if (GetCanIPostToFolder()) {
+    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+    bundle->GetStringFromName("imapAclPostRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  if (GetCanIAdministerFolder()) {
+    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+    bundle->GetStringFromName("imapAclAdministerRight", curRight);
+    aRightsString.Append(curRight);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetFilePath(nsIFile** aPathName) {
+  // this will return a copy of mPath, which is what we want.
+  // this will also initialize mPath using parseURI if it isn't already done
+  return nsMsgDBFolder::GetFilePath(aPathName);
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetFilePath(nsIFile* aPathName) {
+  return nsMsgDBFolder::SetFilePath(
+      aPathName);  // call base class so mPath will get set
+}
+
+nsresult nsImapMailFolder::DisplayStatusMsg(nsIImapUrl* aImapUrl,
+                                            const nsAString& msg) {
+  nsCOMPtr<nsIImapMockChannel> mockChannel;
+  aImapUrl->GetMockChannel(getter_AddRefs(mockChannel));
+  if (mockChannel) {
+    nsCOMPtr<nsIProgressEventSink> progressSink;
+    mockChannel->GetProgressEventSink(getter_AddRefs(progressSink));
+    if (progressSink) {
+      progressSink->OnStatus(mockChannel, NS_OK,
+                             PromiseFlatString(msg).get());  // XXX i18n message
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::ProgressStatusString(nsIImapProtocol* aProtocol,
+                                       const char* aMsgName,
+                                       const char16_t* extraInfo) {
+  nsString progressMsg;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = GetServer(getter_AddRefs(server));
+  if (NS_SUCCEEDED(rv) && server) {
+    nsCOMPtr<nsIImapServerSink> serverSink = do_QueryInterface(server);
+    if (serverSink) serverSink->GetImapStringByName(aMsgName, progressMsg);
+  }
+  if (progressMsg.IsEmpty())
+    IMAPGetStringByName(aMsgName, getter_Copies(progressMsg));
+
+  if (aProtocol && !progressMsg.IsEmpty()) {
+    nsCOMPtr<nsIImapUrl> imapUrl;
+    aProtocol->GetRunningImapURL(getter_AddRefs(imapUrl));
+    if (imapUrl) {
+      if (extraInfo) {
+        nsString printfString;
+        nsTextFormatter::ssprintf(printfString, progressMsg.get(), extraInfo);
+        progressMsg = printfString;
+      }
+
+      DisplayStatusMsg(imapUrl, progressMsg);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::PercentProgress(nsIImapProtocol* aProtocol,
+                                  nsACString const& aFmtStringName,
+                                  nsAString const& aMailboxName,
+                                  int64_t aCurrentProgress,
+                                  int64_t aMaxProgress) {
+  if (aProtocol) {
+    nsCOMPtr<nsIImapUrl> imapUrl;
+    aProtocol->GetRunningImapURL(getter_AddRefs(imapUrl));
+    if (imapUrl) {
+      nsCOMPtr<nsIImapMockChannel> mockChannel;
+      imapUrl->GetMockChannel(getter_AddRefs(mockChannel));
+      if (mockChannel) {
+        nsCOMPtr<nsIProgressEventSink> progressSink;
+        mockChannel->GetProgressEventSink(getter_AddRefs(progressSink));
+        if (progressSink) {
+          progressSink->OnProgress(mockChannel, aCurrentProgress, aMaxProgress);
+
+          if (!aFmtStringName.IsEmpty()) {
+            // There's a progress message to format (the progress messages are
+            // all localized and expect three params).
+            nsAutoString current;
+            current.AppendInt(aCurrentProgress);
+            nsAutoString expected;
+            expected.AppendInt(aMaxProgress);
+            nsAutoString mailbox(aMailboxName);
+            AutoTArray<nsString, 3> params = {current, expected, mailbox};
+
+            nsCOMPtr<nsIStringBundle> bundle;
+            nsresult rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            nsString progressText;
+            rv = bundle->FormatStringFromName(
+                PromiseFlatCString(aFmtStringName).get(), params, progressText);
+            NS_ENSURE_SUCCESS(rv, rv);
+            if (!progressText.IsEmpty()) {
+              progressSink->OnStatus(mockChannel, NS_OK, progressText.get());
+            }
+          }
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::CopyNextStreamMessage(bool copySucceeded,
+                                        nsISupports* copyState) {
+  // if copy has failed it could be either user interrupted it or for some other
+  // reason don't do any subsequent copies or delete src messages if it is move
+  if (!copySucceeded) return NS_OK;
+  nsresult rv;
+  nsCOMPtr<nsImapMailCopyState> mailCopyState =
+      do_QueryInterface(copyState, &rv);
+  if (NS_FAILED(rv)) {
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("QI copyState failed: %" PRIx32, static_cast<uint32_t>(rv)));
+    return rv;  // this can fail...
+  }
+
+  if (!mailCopyState->m_streamCopy) return NS_OK;
+
+  uint32_t idx = mailCopyState->m_curIndex;
+  if (mailCopyState->m_isMove && idx) {
+    nsCOMPtr<nsIMsgFolder> srcFolder(
+        do_QueryInterface(mailCopyState->m_srcSupport, &rv));
+    if (NS_SUCCEEDED(rv) && srcFolder) {
+      // Create "array" of one message header to delete
+      idx--;
+      if (idx < mailCopyState->m_messages.Length()) {
+        RefPtr<nsIMsgDBHdr> msg = mailCopyState->m_messages[idx];
+        srcFolder->DeleteMessages({msg}, nullptr, true, true, nullptr, false);
+      }
+    }
+  }
+
+  if (mailCopyState->m_curIndex < mailCopyState->m_messages.Length()) {
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("CopyNextStreamMessage: %s %u of %u",
+             mailCopyState->m_isMove ? "Moving" : "Copying",
+             mailCopyState->m_curIndex,
+             (uint32_t)mailCopyState->m_messages.Length()));
+    nsIMsgDBHdr* message = mailCopyState->m_messages[mailCopyState->m_curIndex];
+    bool isRead;
+    message->GetIsRead(&isRead);
+    mailCopyState->m_unreadCount = (isRead) ? 0 : 1;
+    rv = CopyStreamMessage(message, this, mailCopyState->m_msgWindow,
+                           mailCopyState->m_isMove);
+  } else {
+    // Notify of move/copy completion in case we have some source headers
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+    if (notifier && !mailCopyState->m_messages.IsEmpty()) {
+      notifier->NotifyMsgsMoveCopyCompleted(
+          mailCopyState->m_isMove, mailCopyState->m_messages, this, {});
+    }
+    if (mailCopyState->m_isMove) {
+      nsCOMPtr<nsIMsgFolder> srcFolder(
+          do_QueryInterface(mailCopyState->m_srcSupport, &rv));
+      if (NS_SUCCEEDED(rv) && srcFolder) {
+        // we want to send this notification now that the source messages have
+        // been deleted.
+        nsCOMPtr<nsIMsgLocalMailFolder> popFolder(do_QueryInterface(srcFolder));
+        if (popFolder)  // needed if move pop->imap to notify FE
+          srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgCompleted);
+      }
+    }
+  }
+  if (NS_FAILED(rv)) (void)OnCopyCompleted(mailCopyState->m_srcSupport, rv);
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetUrlState(nsIImapProtocol* aProtocol,
+                              nsIMsgMailNewsUrl* aUrl, bool isRunning,
+                              bool aSuspend, nsresult statusCode) {
+  // If we have no path, then the folder has been shutdown, and there's
+  // no point in doing anything...
+  if (!mPath) return NS_OK;
+  if (!isRunning) {
+    ProgressStatusString(aProtocol, "imapDone", nullptr);
+    m_urlRunning = false;
+    // if no protocol, then we're reading from the mem or disk cache
+    // and we don't want to end the offline download just yet.
+    if (aProtocol) {
+      EndOfflineDownload();
+      m_downloadingFolderForOfflineUse = false;
+    }
+    nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(aUrl));
+    if (imapUrl) {
+      nsImapAction imapAction;
+      imapUrl->GetImapAction(&imapAction);
+      // if the server doesn't support copyUID, then SetCopyResponseUid won't
+      // get called, so we need to clear m_pendingOfflineMoves when the online
+      // move operation has finished.
+      if (imapAction == nsIImapUrl::nsImapOnlineMove)
+        m_pendingOfflineMoves.Clear();
+    }
+  }
+  if (aUrl && !aSuspend) return aUrl->SetUrlState(isRunning, statusCode);
+  return statusCode;
+}
+
+// used when copying from local mail folder, or other imap server)
+nsresult nsImapMailFolder::CopyMessagesWithStream(
+    nsIMsgFolder* srcFolder, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
+    bool isMove, bool isCrossServerOp, nsIMsgWindow* msgWindow,
+    nsIMsgCopyServiceListener* listener, bool allowUndo) {
+  NS_ENSURE_ARG_POINTER(srcFolder);
+  nsresult rv;
+  rv = InitCopyState(srcFolder, messages, isMove, false, isCrossServerOp, 0,
+                     EmptyCString(), listener, msgWindow, allowUndo);
+  if (NS_FAILED(rv)) return rv;
+
+  m_copyState->m_streamCopy = true;
+
+  // ** jt - needs to create server to server move/copy undo msg txn
+  if (m_copyState->m_allowUndo) {
+    nsAutoCString messageIds;
+    nsTArray<nsMsgKey> srcKeyArray;
+    rv = BuildIdsAndKeyArray(messages, messageIds, srcKeyArray);
+
+    RefPtr<nsImapMoveCopyMsgTxn> undoMsgTxn = new nsImapMoveCopyMsgTxn;
+
+    if (!undoMsgTxn ||
+        NS_FAILED(undoMsgTxn->Init(srcFolder, &srcKeyArray, messageIds.get(),
+                                   this, true, isMove)))
+      return NS_ERROR_OUT_OF_MEMORY;
+
+    if (isMove) {
+      if (mFlags & nsMsgFolderFlags::Trash)
+        undoMsgTxn->SetTransactionType(nsIMessenger::eDeleteMsg);
+      else
+        undoMsgTxn->SetTransactionType(nsIMessenger::eMoveMsg);
+    } else
+      undoMsgTxn->SetTransactionType(nsIMessenger::eCopyMsg);
+    m_copyState->m_undoMsgTxn = undoMsgTxn;
+  }
+  if (NS_SUCCEEDED(rv)) CopyStreamMessage(messages[0], this, msgWindow, isMove);
+  return rv;  // we are clearing copy state in CopyMessages on failure
+}
+
+nsresult nsImapMailFolder::GetClearedOriginalOp(
+    nsIMsgOfflineImapOperation* op, nsIMsgOfflineImapOperation** originalOp,
+    nsIMsgDatabase** originalDB) {
+  nsCOMPtr<nsIMsgOfflineImapOperation> returnOp;
+  nsOfflineImapOperationType opType;
+  op->GetOperation(&opType);
+  NS_ASSERTION(opType & nsIMsgOfflineImapOperation::kMoveResult,
+               "not an offline move op");
+
+  nsCString sourceFolderURI;
+  op->GetSourceFolderURI(sourceFolderURI);
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> sourceFolder;
+  rv = GetOrCreateFolder(sourceFolderURI, getter_AddRefs(sourceFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDBFolderInfo> folderInfo;
+  sourceFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), originalDB);
+  if (*originalDB) {
+    nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb =
+        do_QueryInterface(*originalDB, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsMsgKey originalKey;
+    op->GetMessageKey(&originalKey);
+    rv =
+        opsDb->GetOfflineOpForKey(originalKey, false, getter_AddRefs(returnOp));
+    if (NS_SUCCEEDED(rv) && returnOp) {
+      nsCString moveDestination;
+      nsCString thisFolderURI;
+      GetURI(thisFolderURI);
+      returnOp->GetDestinationFolderURI(moveDestination);
+      if (moveDestination.Equals(thisFolderURI))
+        returnOp->ClearOperation(nsIMsgOfflineImapOperation::kMoveResult);
+    }
+  }
+  returnOp.forget(originalOp);
+  return rv;
+}
+
+nsresult nsImapMailFolder::GetOriginalOp(
+    nsIMsgOfflineImapOperation* op, nsIMsgOfflineImapOperation** originalOp,
+    nsIMsgDatabase** originalDB) {
+  nsCOMPtr<nsIMsgOfflineImapOperation> returnOp;
+  nsCString sourceFolderURI;
+  op->GetSourceFolderURI(sourceFolderURI);
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> sourceFolder;
+  rv = GetOrCreateFolder(sourceFolderURI, getter_AddRefs(sourceFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIDBFolderInfo> folderInfo;
+  sourceFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), originalDB);
+  if (*originalDB) {
+    nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb =
+        do_QueryInterface(*originalDB, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsMsgKey originalKey;
+    op->GetMessageKey(&originalKey);
+    rv =
+        opsDb->GetOfflineOpForKey(originalKey, false, getter_AddRefs(returnOp));
+  }
+  returnOp.forget(originalOp);
+  return rv;
+}
+
+nsresult nsImapMailFolder::FindOpenRange(nsMsgKey& fakeBase,
+                                         uint32_t srcCount) {
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsMsgKey newBase = fakeBase - 1;
+  uint32_t freeCount = 0;
+  while (freeCount != srcCount && newBase > 0) {
+    bool containsKey;
+    if (NS_SUCCEEDED(mDatabase->ContainsKey(newBase, &containsKey)) &&
+        !containsKey)
+      freeCount++;
+    else
+      freeCount = 0;
+    newBase--;
+  }
+  if (!newBase) return NS_ERROR_FAILURE;
+  fakeBase = newBase;
+  return NS_OK;
+}
+
+// Helper to synchronously copy a message from one msgStore to another.
+static nsresult CopyStoreMessage(nsIMsgDBHdr* srcHdr, nsIMsgDBHdr* destHdr,
+                                 uint64_t& bytesCopied) {
+  nsresult rv;
+
+  // Boilerplate setup.
+  nsCOMPtr<nsIMsgFolder> srcFolder;
+  rv = srcHdr->GetFolder(getter_AddRefs(srcFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgFolder> destFolder;
+  rv = destHdr->GetFolder(getter_AddRefs(destFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgPluggableStore> destStore;
+  rv = destFolder->GetMsgStore(getter_AddRefs(destStore));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Copy message into the msgStore.
+  nsCOMPtr<nsIInputStream> srcStream;
+  rv = srcFolder->GetLocalMsgStream(srcHdr, getter_AddRefs(srcStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIOutputStream> destStream;
+  rv = destFolder->GetOfflineStoreOutputStream(destHdr,
+                                               getter_AddRefs(destStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = SyncCopyStream(srcStream, destStream, bytesCopied);
+  if (NS_SUCCEEDED(rv)) {
+    rv = destStore->FinishNewMessage(destStream, destHdr);
+  } else {
+    destStore->DiscardNewMessage(destStream, destHdr);
+  }
+  return rv;
+}
+
+// This imap folder is the destination of an offline move/copy.
+// We are either offline, or doing a pseudo-offline delete (where we do an
+// offline delete, load the next message, then playback the offline delete).
+nsresult nsImapMailFolder::CopyMessagesOffline(
+    nsIMsgFolder* srcFolder, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
+    bool isMove, nsIMsgWindow* msgWindow, nsIMsgCopyServiceListener* listener) {
+  nsresult rv;
+  nsresult stopit = NS_OK;
+  nsCOMPtr<nsIMsgDatabase> sourceMailDB;
+  nsCOMPtr<nsIDBFolderInfo> srcDbFolderInfo;
+  srcFolder->GetDBFolderInfoAndDB(getter_AddRefs(srcDbFolderInfo),
+                                  getter_AddRefs(sourceMailDB));
+  bool deleteToTrash = false;
+  bool deleteImmediately = false;
+  uint32_t srcCount = messages.Length();
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+
+  nsTArray<RefPtr<nsIMsgDBHdr>> msgHdrsCopied;
+  nsTArray<RefPtr<nsIMsgDBHdr>> destMsgHdrs;
+
+  if (NS_SUCCEEDED(rv) && imapServer) {
+    nsMsgImapDeleteModel deleteModel;
+    imapServer->GetDeleteModel(&deleteModel);
+    deleteToTrash = (deleteModel == nsMsgImapDeleteModels::MoveToTrash);
+    deleteImmediately = (deleteModel == nsMsgImapDeleteModels::DeleteNoTrash);
+  }
+
+  // This array is used only when we are actually removing the messages from the
+  // source database.
+  nsTArray<nsMsgKey> keysToDelete(
+      (isMove && (deleteToTrash || deleteImmediately)) ? srcCount : 0);
+
+  if (sourceMailDB) {
+    // save the future ops in the source DB, if this is not a imap->local
+    // copy/move
+    nsCOMPtr<nsITransactionManager> txnMgr;
+    if (msgWindow) msgWindow->GetTransactionManager(getter_AddRefs(txnMgr));
+    if (txnMgr) txnMgr->BeginBatch(nullptr);
+    nsCOMPtr<nsIMsgDatabase> database;
+    GetMsgDatabase(getter_AddRefs(database));
+    if (database) {
+      // get the highest key in the dest db, so we can make up our fake keys
+      nsMsgKey fakeBase = 1;
+      nsCOMPtr<nsIDBFolderInfo> folderInfo;
+      rv = database->GetDBFolderInfo(getter_AddRefs(folderInfo));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsMsgKey highWaterMark = nsMsgKey_None;
+      folderInfo->GetHighWater(&highWaterMark);
+      fakeBase += highWaterMark;
+      nsMsgKey fakeTop = fakeBase + srcCount;
+      // Check that we have enough room for the fake headers. If fakeTop
+      // is <= highWaterMark, we've overflowed.
+      if (fakeTop <= highWaterMark || fakeTop == nsMsgKey_None) {
+        rv = FindOpenRange(fakeBase, srcCount);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      // N.B. We must not return out of the for loop - we need the matching
+      // end notifications to be sent.
+      // We don't need to acquire the semaphor since this is synchronous
+      // on the UI thread but we should check if the offline store is locked.
+      bool isLocked;
+      GetLocked(&isLocked);
+      nsTArray<nsMsgKey> addedKeys;
+      nsTArray<nsMsgKey> srcKeyArray;
+      nsCOMArray<nsIMsgDBHdr> addedHdrs;
+      nsCOMArray<nsIMsgDBHdr> srcMsgs;
+      nsOfflineImapOperationType moveCopyOpType;
+      nsOfflineImapOperationType deleteOpType =
+          nsIMsgOfflineImapOperation::kDeletedMsg;
+      if (!deleteToTrash)
+        deleteOpType = nsIMsgOfflineImapOperation::kMsgMarkedDeleted;
+      nsCString messageIds;
+      rv = BuildIdsAndKeyArray(messages, messageIds, srcKeyArray);
+      // put fake message in destination db, delete source if move
+      EnableNotifications(nsIMsgFolder::allMessageCountNotifications, false);
+      nsCString originalSrcFolderURI;
+      srcFolder->GetURI(originalSrcFolderURI);
+      nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb =
+          do_QueryInterface(sourceMailDB, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      for (uint32_t sourceKeyIndex = 0;
+           NS_SUCCEEDED(stopit) && (sourceKeyIndex < srcCount);
+           sourceKeyIndex++) {
+        bool messageReturningHome = false;
+        RefPtr<nsIMsgDBHdr> message = messages[sourceKeyIndex];
+        nsMsgKey originalKey;
+        if (message) {
+          rv = message->GetMessageKey(&originalKey);
+        } else {
+          NS_ERROR("bad msg in src array");
+          continue;
+        }
+        nsCOMPtr<nsIMsgOfflineImapOperation> sourceOp;
+        rv = opsDb->GetOfflineOpForKey(originalKey, true,
+                                       getter_AddRefs(sourceOp));
+        if (NS_SUCCEEDED(rv) && sourceOp) {
+          srcFolder->SetFlag(nsMsgFolderFlags::OfflineEvents);
+          nsCOMPtr<nsIMsgDatabase> originalDB;
+          nsOfflineImapOperationType opType;
+          sourceOp->GetOperation(&opType);
+          // if we already have an offline op for this key, then we need to see
+          // if it was moved into the source folder while offline
+          if (opType ==
+              nsIMsgOfflineImapOperation::kMoveResult)  // offline move
+          {
+            // gracious me, we are moving something we already moved while
+            // offline! find the original operation and clear it!
+            nsCOMPtr<nsIMsgOfflineImapOperation> originalOp;
+            GetClearedOriginalOp(sourceOp, getter_AddRefs(originalOp),
+                                 getter_AddRefs(originalDB));
+            nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDbOriginal =
+                do_QueryInterface(originalDB, &rv);
+            if (NS_SUCCEEDED(rv) && originalOp) {
+              nsCString srcFolderURI;
+              srcFolder->GetURI(srcFolderURI);
+              sourceOp->GetSourceFolderURI(originalSrcFolderURI);
+              sourceOp->GetMessageKey(&originalKey);
+              if (isMove) opsDb->RemoveOfflineOp(sourceOp);
+              sourceOp = originalOp;
+              if (originalSrcFolderURI.Equals(srcFolderURI)) {
+                messageReturningHome = true;
+                opsDbOriginal->RemoveOfflineOp(originalOp);
+              }
+            }
+          }
+          if (!messageReturningHome) {
+            nsCString folderURI;
+            GetURI(folderURI);
+            if (isMove) {
+              uint32_t msgSize;
+              uint32_t msgFlags;
+              imapMessageFlagsType newImapFlags = 0;
+              message->GetMessageSize(&msgSize);
+              message->GetFlags(&msgFlags);
+              sourceOp->SetDestinationFolderURI(folderURI);  // offline move
+              sourceOp->SetOperation(nsIMsgOfflineImapOperation::kMsgMoved);
+              sourceOp->SetMsgSize(msgSize);
+              newImapFlags = msgFlags & 0x7;
+              if (msgFlags & nsMsgMessageFlags::Forwarded)
+                newImapFlags |= kImapMsgForwardedFlag;
+              sourceOp->SetNewFlags(newImapFlags);
+            } else {
+              sourceOp->AddMessageCopyOperation(folderURI);  // offline copy
+            }
+
+            sourceOp->GetOperation(&moveCopyOpType);
+            srcMsgs.AppendObject(message);
+          }
+        } else {
+          stopit = NS_ERROR_FAILURE;
+        }
+
+        nsCOMPtr<nsIMsgDBHdr> mailHdr;
+        rv =
+            sourceMailDB->GetMsgHdrForKey(originalKey, getter_AddRefs(mailHdr));
+
+        if (NS_SUCCEEDED(rv) && mailHdr) {
+          // Copy the DB hdr into the destination folder.
+          bool successfulCopy = false;
+          nsMsgKey srcDBhighWaterMark;
+          srcDbFolderInfo->GetHighWater(&srcDBhighWaterMark);
+
+          nsCOMPtr<nsIMsgDBHdr> newMailHdr;
+          rv = database->CopyHdrFromExistingHdr(fakeBase + sourceKeyIndex,
+                                                mailHdr, true,
+                                                getter_AddRefs(newMailHdr));
+          if (!newMailHdr || NS_FAILED(rv)) {
+            NS_ASSERTION(false, "failed to copy hdr");
+            stopit = rv;
+          }
+
+          if (NS_SUCCEEDED(stopit)) {
+            bool hasMsgOffline = false;
+
+            destMsgHdrs.AppendElement(newMailHdr);
+            srcFolder->HasMsgOffline(originalKey, &hasMsgOffline);
+            newMailHdr->SetUint32Property("pseudoHdr", 1);
+
+            if (hasMsgOffline && !isLocked) {
+              uint64_t bytesCopied;
+              stopit = CopyStoreMessage(mailHdr, newMailHdr, bytesCopied);
+              if (NS_SUCCEEDED(stopit)) {
+                uint32_t unused;
+                newMailHdr->OrFlags(nsMsgMessageFlags::Offline, &unused);
+                newMailHdr->SetOfflineMessageSize(bytesCopied);
+              }
+            } else {
+              database->MarkOffline(fakeBase + sourceKeyIndex, false, nullptr);
+            }
+
+            nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb =
+                do_QueryInterface(database, &rv);
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            nsCOMPtr<nsIMsgOfflineImapOperation> destOp;
+            opsDb->GetOfflineOpForKey(fakeBase + sourceKeyIndex, true,
+                                      getter_AddRefs(destOp));
+            if (destOp) {
+              // check if this is a move back to the original mailbox, in which
+              // case we just delete the offline operation.
+              if (messageReturningHome) {
+                opsDb->RemoveOfflineOp(destOp);
+              } else {
+                SetFlag(nsMsgFolderFlags::OfflineEvents);
+                destOp->SetSourceFolderURI(originalSrcFolderURI);
+                destOp->SetSrcMessageKey(originalKey);
+                addedKeys.AppendElement(fakeBase + sourceKeyIndex);
+                addedHdrs.AppendObject(newMailHdr);
+              }
+            } else {
+              stopit = NS_ERROR_FAILURE;
+            }
+          }
+          successfulCopy = NS_SUCCEEDED(stopit);
+          nsMsgKey msgKey;
+          mailHdr->GetMessageKey(&msgKey);
+          if (isMove && successfulCopy) {
+            if (deleteToTrash || deleteImmediately)
+              keysToDelete.AppendElement(msgKey);
+            else
+              sourceMailDB->MarkImapDeleted(msgKey, true,
+                                            nullptr);  // offline delete
+          }
+          if (successfulCopy) {
+            // This is for both moves and copies
+            msgHdrsCopied.AppendElement(mailHdr);
+          }
+        }
+      }  // End message loop.
+      EnableNotifications(nsIMsgFolder::allMessageCountNotifications, true);
+      RefPtr<nsImapOfflineTxn> addHdrMsgTxn = new nsImapOfflineTxn(
+          this, &addedKeys, nullptr, this, isMove,
+          nsIMsgOfflineImapOperation::kAddedHeader, addedHdrs);
+      if (addHdrMsgTxn && txnMgr) txnMgr->DoTransaction(addHdrMsgTxn);
+      RefPtr<nsImapOfflineTxn> undoMsgTxn =
+          new nsImapOfflineTxn(srcFolder, &srcKeyArray, messageIds.get(), this,
+                               isMove, moveCopyOpType, srcMsgs);
+      if (undoMsgTxn) {
+        if (isMove) {
+          undoMsgTxn->SetTransactionType(nsIMessenger::eMoveMsg);
+          nsCOMPtr<nsIMsgImapMailFolder> srcIsImap(
+              do_QueryInterface(srcFolder));
+          // remember this undo transaction so we can hook up the result
+          // msg ids in the undo transaction.
+          if (srcIsImap) {
+            nsImapMailFolder* srcImapFolder =
+                static_cast<nsImapMailFolder*>(srcFolder);
+            srcImapFolder->m_pendingOfflineMoves.AppendElement(undoMsgTxn);
+          }
+        } else {
+          undoMsgTxn->SetTransactionType(nsIMessenger::eCopyMsg);
+        }
+        // we're adding this undo action before the delete is successful. This
+        // is evil, but 4.5 did it as well.
+        if (txnMgr) txnMgr->DoTransaction(undoMsgTxn);
+      }
+      undoMsgTxn =
+          new nsImapOfflineTxn(srcFolder, &srcKeyArray, messageIds.get(), this,
+                               isMove, deleteOpType, srcMsgs);
+      if (undoMsgTxn) {
+        if (isMove) {
+          if (mFlags & nsMsgFolderFlags::Trash) {
+            undoMsgTxn->SetTransactionType(nsIMessenger::eDeleteMsg);
+          } else {
+            undoMsgTxn->SetTransactionType(nsIMessenger::eMoveMsg);
+          }
+        } else {
+          undoMsgTxn->SetTransactionType(nsIMessenger::eCopyMsg);
+        }
+        if (txnMgr) txnMgr->DoTransaction(undoMsgTxn);
+      }
+
+      if (isMove) sourceMailDB->Commit(nsMsgDBCommitType::kLargeCommit);
+      database->Commit(nsMsgDBCommitType::kLargeCommit);
+      SummaryChanged();
+      srcFolder->SummaryChanged();
+    }
+    if (txnMgr) txnMgr->EndBatch(false);
+  }
+
+  if (!msgHdrsCopied.IsEmpty()) {
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+    if (notifier) {
+      notifier->NotifyMsgsMoveCopyCompleted(isMove, msgHdrsCopied, this,
+                                            destMsgHdrs);
+    }
+  }
+
+  // NOTE (Bug 1787963):
+  // If we're performing a move, by rights we should be deleting the source
+  // message(s) here. But that would mean they won't be available when we try
+  // to run the offline move operation once we're back online. So we'll just
+  // leave things as they are:
+  //  - the message(s) copied into the destination folder
+  //  - the original message(s) left in the source folder
+  //  - the offline move operation all queued up for when we go back online
+  // When we do go back online, the offline move op will be performed and
+  // the source message(s) will be deleted. For real.
+  // Would be nice to have some marker to hide or grey out messages which are
+  // in this state of impending doom... but it's a pretty obscure corner case
+  // and we've already got quite enough of those.
+  //
+  // BUT... CopyMessagesOffline() is also used when online (ha!), *if* we're
+  // copying between folders on the same nsIMsgIncomingServer, in order to
+  // support undo. In that case we _do_ want to go ahead with the delete now.
+
+  bool sameServer;
+  rv = IsOnSameServer(srcFolder, this, &sameServer);
+
+  if (NS_SUCCEEDED(rv) && sameServer && isMove &&
+      (deleteToTrash || deleteImmediately)) {
+    DeleteStoreMessages(keysToDelete, srcFolder);
+    srcFolder->EnableNotifications(nsIMsgFolder::allMessageCountNotifications,
+                                   false);
+    sourceMailDB->DeleteMessages(keysToDelete, nullptr);
+    srcFolder->EnableNotifications(nsIMsgFolder::allMessageCountNotifications,
+                                   true);
+  }
+  nsCOMPtr<nsISupports> srcSupport = do_QueryInterface(srcFolder);
+  OnCopyCompleted(srcSupport, rv);
+
+  if (isMove) {
+    srcFolder->NotifyFolderEvent(NS_SUCCEEDED(rv) ? kDeleteOrMoveMsgCompleted
+                                                  : kDeleteOrMoveMsgFailed);
+  }
+  return rv;
+}
+
+void nsImapMailFolder::SetPendingAttributes(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& messages, bool aIsMove,
+    bool aSetOffline) {
+  GetDatabase();
+  if (!mDatabase) return;
+
+  uint32_t supportedUserFlags;
+  GetSupportedUserFlags(&supportedUserFlags);
+
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch(
+      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  nsCString dontPreserve;
+
+  // These preferences exist so that extensions can control which properties
+  // are preserved in the database when a message is moved or copied. All
+  // properties are preserved except those listed in these preferences
+  if (aIsMove)
+    prefBranch->GetCharPref("mailnews.database.summary.dontPreserveOnMove",
+                            dontPreserve);
+  else
+    prefBranch->GetCharPref("mailnews.database.summary.dontPreserveOnCopy",
+                            dontPreserve);
+
+  // We'll add spaces at beginning and end so we can search for space-name-space
+  nsCString dontPreserveEx(" "_ns);
+  dontPreserveEx.Append(dontPreserve);
+  dontPreserveEx.Append(' ');
+
+  // these properties are set as integers below, so don't set them again
+  // in the iteration through the properties
+  dontPreserveEx.AppendLiteral(
+      "offlineMsgSize msgOffset flags priority pseudoHdr ");
+
+  // these fields are either copied separately when the server does not support
+  // custom IMAP flags, or managed directly through the flags
+  dontPreserveEx.AppendLiteral("keywords label ");
+
+  // check if any msg hdr has special flags or properties set
+  // that we need to set on the dest hdr
+  for (auto msgDBHdr : messages) {
+    if (!(supportedUserFlags & kImapMsgSupportUserFlag)) {
+      nsCString keywords;
+      msgDBHdr->GetStringProperty("keywords", keywords);
+      if (!keywords.IsEmpty())
+        mDatabase->SetAttributeOnPendingHdr(msgDBHdr, "keywords",
+                                            keywords.get());
+    }
+
+    nsTArray<nsCString> properties;
+    nsresult rv = msgDBHdr->GetProperties(properties);
+    NS_ENSURE_SUCCESS_VOID(rv);
+
+    nsCString sourceString;
+    for (auto property : properties) {
+      nsAutoCString propertyEx(" "_ns);
+      propertyEx.Append(property);
+      propertyEx.Append(' ');
+      if (dontPreserveEx.Find(propertyEx) != kNotFound) continue;
+
+      nsCString sourceString;
+      msgDBHdr->GetStringProperty(property.get(), sourceString);
+      mDatabase->SetAttributeOnPendingHdr(msgDBHdr, property.get(),
+                                          sourceString.get());
+    }
+
+    // Carry over HasRe flag.
+    uint32_t flags;
+    uint32_t storeFlags = 0;
+    msgDBHdr->GetFlags(&flags);
+    if (flags & nsMsgMessageFlags::HasRe) {
+      storeFlags = nsMsgMessageFlags::HasRe;
+      mDatabase->SetUint32AttributeOnPendingHdr(msgDBHdr, "flags", storeFlags);
+    }
+
+    uint32_t messageSize;
+    uint64_t messageOffset;
+    nsCString storeToken;
+    msgDBHdr->GetMessageOffset(&messageOffset);
+    msgDBHdr->GetOfflineMessageSize(&messageSize);
+    msgDBHdr->GetStringProperty("storeToken", storeToken);
+    if (messageSize) {
+      mDatabase->SetUint32AttributeOnPendingHdr(msgDBHdr, "offlineMsgSize",
+                                                messageSize);
+      mDatabase->SetUint64AttributeOnPendingHdr(msgDBHdr, "msgOffset",
+                                                messageOffset);
+      // Not always setting "flags" attribute to nsMsgMessageFlags::Offline
+      // here because it can cause missing parts (inline or attachments)
+      // when messages are moved or copied manually or by filter action.
+      if (aSetOffline)
+        mDatabase->SetUint32AttributeOnPendingHdr(
+            msgDBHdr, "flags", storeFlags | nsMsgMessageFlags::Offline);
+      mDatabase->SetAttributeOnPendingHdr(msgDBHdr, "storeToken",
+                                          storeToken.get());
+    }
+    nsMsgPriorityValue priority;
+    msgDBHdr->GetPriority(&priority);
+    if (priority != 0) {
+      nsAutoCString priorityStr;
+      priorityStr.AppendInt(priority);
+      mDatabase->SetAttributeOnPendingHdr(msgDBHdr, "priority",
+                                          priorityStr.get());
+    }
+  }
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::CopyMessages(
+    nsIMsgFolder* srcFolder, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
+    bool isMove, nsIMsgWindow* msgWindow, nsIMsgCopyServiceListener* listener,
+    bool isFolder,  // isFolder for future use when we do cross-server folder
+                    // move/copy
+    bool allowUndo) {
+  UpdateTimestamps(allowUndo);
+
+  nsresult rv;
+  nsCOMPtr<nsISupports> srcSupport = do_QueryInterface(srcFolder);
+
+  bool sameServer;
+  rv = IsOnSameServer(srcFolder, this, &sameServer);
+  if (NS_FAILED(rv)) goto done;
+
+  // in theory, if allowUndo is true, then this is a user initiated
+  // action, and we should do it pseudo-offline. If it's not
+  // user initiated (e.g., mail filters firing), then allowUndo is
+  // false, and we should just do the action.
+  if (!WeAreOffline() && sameServer && allowUndo) {
+    // complete the copy operation as in offline mode
+    rv = CopyMessagesOffline(srcFolder, messages, isMove, msgWindow, listener);
+
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "error offline copy");
+    // We'll warn if this fails, but we should still try to play back
+    // offline ops, because it's possible the copy got far enough to
+    // create the offline ops.
+
+    // We make sure that the source folder is an imap folder by limiting
+    // pseudo-offline operations to the same imap server. If we extend the code
+    // to cover non imap folders in the future (i.e. imap folder->local folder),
+    // then the following downcast will cause either a crash or compiler error.
+    // Do not forget to change it accordingly.
+    nsImapMailFolder* srcImapFolder = static_cast<nsImapMailFolder*>(srcFolder);
+
+    // if there is no pending request, create a new one, and set the timer.
+    // Otherwise use the existing one to reset the timer. it is callback
+    // function's responsibility to delete the new request object
+    if (!srcImapFolder->m_pendingPlaybackReq) {
+      srcImapFolder->m_pendingPlaybackReq =
+          new nsPlaybackRequest(srcImapFolder, msgWindow);
+    }
+
+    // Create and start a new playback one-shot timer. If there is already a
+    // timer created that has not timed out, cancel it.
+    if (srcImapFolder->m_playbackTimer)
+      srcImapFolder->m_playbackTimer->Cancel();
+    rv = NS_NewTimerWithFuncCallback(
+        getter_AddRefs(srcImapFolder->m_playbackTimer), PlaybackTimerCallback,
+        (void*)srcImapFolder->m_pendingPlaybackReq,
+        PLAYBACK_TIMER_INTERVAL_IN_MS, nsITimer::TYPE_ONE_SHOT,
+        "nsImapMailFolder::PlaybackTimerCallback", nullptr);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("Could not start m_playbackTimer timer");
+    }
+    return rv;
+  } else {
+    // sort the message array by key
+
+    nsTArray<nsMsgKey> keyArray(messages.Length());
+    for (nsIMsgDBHdr* aMessage : messages) {
+      if (!aMessage) {
+        continue;
+      }
+      nsMsgKey key;
+      aMessage->GetMessageKey(&key);
+      keyArray.AppendElement(key);
+    }
+    keyArray.Sort();
+
+    nsTArray<RefPtr<nsIMsgDBHdr>> sortedMsgs;
+    rv = MessagesInKeyOrder(keyArray, srcFolder, sortedMsgs);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (WeAreOffline())
+      return CopyMessagesOffline(srcFolder, sortedMsgs, isMove, msgWindow,
+                                 listener);
+
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // 3rd parameter: Do not set offline flag.
+    SetPendingAttributes(sortedMsgs, isMove, false);
+
+    // if the folders aren't on the same server, do a stream base copy
+    if (!sameServer) {
+      rv = CopyMessagesWithStream(srcFolder, sortedMsgs, isMove, true,
+                                  msgWindow, listener, allowUndo);
+      goto done;
+    }
+
+    nsAutoCString messageIds;
+    rv = AllocateUidStringFromKeys(keyArray, messageIds);
+    if (NS_FAILED(rv)) goto done;
+
+    nsCOMPtr<nsIUrlListener> urlListener;
+    rv =
+        QueryInterface(NS_GET_IID(nsIUrlListener), getter_AddRefs(urlListener));
+    rv = InitCopyState(srcSupport, sortedMsgs, isMove, true, false, 0,
+                       EmptyCString(), listener, msgWindow, allowUndo);
+    if (NS_FAILED(rv)) goto done;
+
+    m_copyState->m_curIndex = m_copyState->m_messages.Length();
+
+    if (isMove)
+      srcFolder->EnableNotifications(
+          allMessageCountNotifications,
+          false);  // disable message count notification
+
+    nsCOMPtr<nsIURI> resultUrl;
+    nsCOMPtr<nsISupports> copySupport = do_QueryInterface(m_copyState);
+    rv = imapService->OnlineMessageCopy(
+        srcFolder, messageIds, this, true, isMove, urlListener,
+        getter_AddRefs(resultUrl), copySupport, msgWindow);
+    if (NS_SUCCEEDED(rv) && m_copyState->m_allowUndo) {
+      RefPtr<nsImapMoveCopyMsgTxn> undoMsgTxn = new nsImapMoveCopyMsgTxn;
+      if (!undoMsgTxn ||
+          NS_FAILED(undoMsgTxn->Init(srcFolder, &keyArray, messageIds.get(),
+                                     this, true, isMove)))
+        return NS_ERROR_OUT_OF_MEMORY;
+
+      if (isMove) {
+        if (mFlags & nsMsgFolderFlags::Trash)
+          undoMsgTxn->SetTransactionType(nsIMessenger::eDeleteMsg);
+        else
+          undoMsgTxn->SetTransactionType(nsIMessenger::eMoveMsg);
+      } else
+        undoMsgTxn->SetTransactionType(nsIMessenger::eCopyMsg);
+      m_copyState->m_undoMsgTxn = undoMsgTxn;
+    }
+
+  }  // endif
+
+done:
+  if (NS_FAILED(rv)) {
+    (void)OnCopyCompleted(srcSupport, rv);
+    if (isMove) {
+      srcFolder->EnableNotifications(
+          allMessageCountNotifications,
+          true);  // enable message count notification
+      NotifyFolderEvent(kDeleteOrMoveMsgFailed);
+    }
+  }
+  return rv;
+}
+
+// This is used when copying an imap or local/pop3 folder to an imap server.
+// It does not allow completely moving an imap or local/pop3 folder to an imap
+// server since only the messages can be moved between servers.
+class nsImapFolderCopyState final : public nsIUrlListener,
+                                    public nsIMsgCopyServiceListener {
+ public:
+  nsImapFolderCopyState(nsIMsgFolder* destParent, nsIMsgFolder* srcFolder,
+                        bool isMoveMessages, nsIMsgWindow* msgWindow,
+                        nsIMsgCopyServiceListener* listener);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSIMSGCOPYSERVICELISTENER
+
+  nsresult StartNextCopy();
+  nsresult AdvanceToNextFolder(nsresult aStatus);
+
+ protected:
+  ~nsImapFolderCopyState();
+  RefPtr<nsImapMailFolder> m_newDestFolder;
+  nsCOMPtr<nsISupports> m_origSrcFolder;
+  nsCOMPtr<nsIMsgFolder> m_curDestParent;
+  nsCOMPtr<nsIMsgFolder> m_curSrcFolder;
+  bool m_isMoveMessages;
+  nsCOMPtr<nsIMsgCopyServiceListener> m_copySrvcListener;
+  nsCOMPtr<nsIMsgWindow> m_msgWindow;
+  int32_t m_childIndex;
+  nsCOMArray<nsIMsgFolder> m_srcChildFolders;
+  nsCOMArray<nsIMsgFolder> m_destParents;
+};
+
+NS_IMPL_ISUPPORTS(nsImapFolderCopyState, nsIUrlListener,
+                  nsIMsgCopyServiceListener)
+
+nsImapFolderCopyState::nsImapFolderCopyState(
+    nsIMsgFolder* destParent, nsIMsgFolder* srcFolder, bool isMoveMessages,
+    nsIMsgWindow* msgWindow, nsIMsgCopyServiceListener* listener) {
+  m_origSrcFolder = do_QueryInterface(srcFolder);
+  m_curDestParent = destParent;
+  m_curSrcFolder = srcFolder;
+  m_isMoveMessages = isMoveMessages;
+  m_msgWindow = msgWindow;
+  m_copySrvcListener = listener;
+  m_childIndex = -1;
+  // NOTE: The nsImapMailFolder doesn't keep a reference to us, so we're
+  // relying on our use as a listener by nsImapService and nsMsgCopyService
+  // to keep our refcount from zeroing!
+  // Might be safer to add a kungfudeathgrip on ourselves for the duration
+  // of the operation? Would need to make sure we catch all error conditions.
+}
+
+nsImapFolderCopyState::~nsImapFolderCopyState() {}
+
+nsresult nsImapFolderCopyState::StartNextCopy() {
+  nsresult rv;
+  // Create the destination folder (our OnStopRunningUrl() will be called
+  // when done).
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsString folderName;
+  m_curSrcFolder->GetName(folderName);
+  return imapService->EnsureFolderExists(m_curDestParent, folderName,
+                                         m_msgWindow, this);
+}
+
+nsresult nsImapFolderCopyState::AdvanceToNextFolder(nsresult aStatus) {
+  nsresult rv = NS_OK;
+  m_childIndex++;
+  if (m_childIndex >= m_srcChildFolders.Count()) {
+    if (m_newDestFolder)
+      m_newDestFolder->OnCopyCompleted(m_origSrcFolder, aStatus);
+  } else {
+    m_curDestParent = m_destParents[m_childIndex];
+    m_curSrcFolder = m_srcChildFolders[m_childIndex];
+    rv = StartNextCopy();
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapFolderCopyState::OnStartRunningUrl(nsIURI* aUrl) {
+  NS_ASSERTION(aUrl, "sanity check - need to be be running non-null url");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapFolderCopyState::OnStopRunningUrl(nsIURI* aUrl, nsresult aExitCode) {
+  if (NS_FAILED(aExitCode)) {
+    if (m_copySrvcListener) m_copySrvcListener->OnStopCopy(aExitCode);
+    return aExitCode;  // or NS_OK???
+  }
+  nsresult rv = NS_OK;
+  if (aUrl) {
+    nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(aUrl);
+    if (imapUrl) {
+      nsImapAction imapAction = nsIImapUrl::nsImapTest;
+      imapUrl->GetImapAction(&imapAction);
+
+      switch (imapAction) {
+        case nsIImapUrl::nsImapEnsureExistsFolder: {
+          // Our EnsureFolderExists() call has completed successfully,
+          // so our dest folder is ready.
+          nsCOMPtr<nsIMsgFolder> newMsgFolder;
+          nsString folderName;
+          nsCString utfLeafName;
+          m_curSrcFolder->GetName(folderName);
+          bool utf8AcceptEnabled;
+          nsCOMPtr<nsIMsgImapMailFolder> imapFolder =
+              do_QueryInterface(m_curDestParent);
+          rv = imapFolder->GetShouldUseUtf8FolderName(&utf8AcceptEnabled);
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (utf8AcceptEnabled) {
+            CopyUTF16toUTF8(folderName, utfLeafName);
+          } else {
+            CopyUTF16toMUTF7(folderName, utfLeafName);
+          }
+          // Create the nsIMsgFolder object which represents the folder on
+          // the IMAP server.
+          rv = m_curDestParent->FindSubFolder(utfLeafName,
+                                              getter_AddRefs(newMsgFolder));
+          NS_ENSURE_SUCCESS(rv, rv);
+          // Save the first new folder so we can send a notification to the
+          // copy service when this whole process is done.
+          if (!m_newDestFolder)
+            m_newDestFolder =
+                static_cast<nsImapMailFolder*>(newMsgFolder.get());
+
+          // Check if the source folder has children. If it does, list them
+          // into m_srcChildFolders, and set m_destParents for the
+          // corresponding indexes to the newly created folder.
+          nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+          rv = m_curSrcFolder->GetSubFolders(subFolders);
+          NS_ENSURE_SUCCESS(rv, rv);
+          uint32_t childIndex = 0;
+          for (nsIMsgFolder* folder : subFolders) {
+            m_srcChildFolders.InsertElementAt(m_childIndex + childIndex + 1,
+                                              folder);
+            m_destParents.InsertElementAt(m_childIndex + childIndex + 1,
+                                          newMsgFolder);
+            ++childIndex;
+          }
+
+          // Now kick off a copy (or move) of messages to the new folder.
+          nsCOMPtr<nsIMsgEnumerator> enumerator;
+          rv = m_curSrcFolder->GetMessages(getter_AddRefs(enumerator));
+          nsTArray<RefPtr<nsIMsgDBHdr>> msgArray;
+          bool hasMore = false;
+
+          if (enumerator) rv = enumerator->HasMoreElements(&hasMore);
+
+          // Early-out for empty folder.
+          if (!hasMore) return AdvanceToNextFolder(NS_OK);
+
+          while (NS_SUCCEEDED(rv) && hasMore) {
+            nsCOMPtr<nsIMsgDBHdr> hdr;
+            rv = enumerator->GetNext(getter_AddRefs(hdr));
+            NS_ENSURE_SUCCESS(rv, rv);
+            msgArray.AppendElement(hdr);
+            rv = enumerator->HasMoreElements(&hasMore);
+          }
+
+          nsCOMPtr<nsIMsgCopyService> copyService =
+              do_GetService("@mozilla.org/messenger/messagecopyservice;1", &rv);
+          NS_ENSURE_SUCCESS(rv, rv);
+          rv = copyService->CopyMessages(m_curSrcFolder, msgArray, newMsgFolder,
+                                         m_isMoveMessages, this, m_msgWindow,
+                                         false /* allowUndo */);
+        } break;
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapFolderCopyState::OnStartCopy() { return NS_OK; }
+
+/* void OnProgress (in uint32_t aProgress, in uint32_t aProgressMax); */
+NS_IMETHODIMP nsImapFolderCopyState::OnProgress(uint32_t aProgress,
+                                                uint32_t aProgressMax) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void SetMessageKey (in nsMsgKey aKey); */
+NS_IMETHODIMP nsImapFolderCopyState::SetMessageKey(nsMsgKey aKey) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [noscript] void GetMessageId (in nsCString aMessageId); */
+NS_IMETHODIMP nsImapFolderCopyState::GetMessageId(nsACString& messageId) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void OnStopCopy (in nsresult aStatus); */
+NS_IMETHODIMP nsImapFolderCopyState::OnStopCopy(nsresult aStatus) {
+  if (NS_SUCCEEDED(aStatus)) return AdvanceToNextFolder(aStatus);
+  if (m_copySrvcListener) {
+    (void)m_copySrvcListener->OnStopCopy(aStatus);
+    m_copySrvcListener = nullptr;
+  }
+
+  return NS_OK;
+}
+
+// "this" is the destination (parent) imap folder that srcFolder is copied to.
+// srcFolder may be another imap or a local/pop3 folder.
+NS_IMETHODIMP
+nsImapMailFolder::CopyFolder(nsIMsgFolder* srcFolder, bool isMoveFolder,
+                             nsIMsgWindow* msgWindow,
+                             nsIMsgCopyServiceListener* listener) {
+  NS_ENSURE_ARG_POINTER(srcFolder);
+  nsresult rv;
+  bool sameServer;
+  rv = IsOnSameServer(this, srcFolder, &sameServer);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (sameServer && isMoveFolder) {
+    // Do a pure folder move within the same IMAP account/server, where
+    // "pure" means the folder AND messages are copied to the destination and
+    // then both are removed from source account.
+    uint32_t folderFlags = 0;
+    if (srcFolder) srcFolder->GetFlags(&folderFlags);
+
+    // if our source folder is a virtual folder
+    if (folderFlags & nsMsgFolderFlags::Virtual) {
+      nsCOMPtr<nsIMsgFolder> newMsgFolder;
+      nsString folderName;
+      srcFolder->GetName(folderName);
+
+      nsAutoString safeFolderName(folderName);
+      NS_MsgHashIfNecessary(safeFolderName);
+
+      srcFolder->ForceDBClosed();
+
+      nsCOMPtr<nsIFile> oldPathFile;
+      rv = srcFolder->GetFilePath(getter_AddRefs(oldPathFile));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIFile> summaryFile;
+      GetSummaryFileLocation(oldPathFile, getter_AddRefs(summaryFile));
+
+      nsCOMPtr<nsIFile> newPathFile;
+      rv = GetFilePath(getter_AddRefs(newPathFile));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      bool isDirectory = false;
+      newPathFile->IsDirectory(&isDirectory);
+      if (!isDirectory) {
+        AddDirectorySeparator(newPathFile);
+        rv = newPathFile->Create(nsIFile::DIRECTORY_TYPE, 0700);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+
+      rv = CheckIfFolderExists(folderName, this, msgWindow);
+      if (NS_FAILED(rv)) return rv;
+
+      rv = summaryFile->CopyTo(newPathFile, EmptyString());
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = AddSubfolder(safeFolderName, getter_AddRefs(newMsgFolder));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      newMsgFolder->SetPrettyName(folderName);
+
+      uint32_t flags;
+      srcFolder->GetFlags(&flags);
+      newMsgFolder->SetFlags(flags);
+
+      NotifyFolderAdded(newMsgFolder);
+
+      // now remove the old folder
+      nsCOMPtr<nsIMsgFolder> msgParent;
+      srcFolder->GetParent(getter_AddRefs(msgParent));
+      srcFolder->SetParent(nullptr);
+      if (msgParent) {
+        // The files have already been moved, so delete storage false.
+        msgParent->PropagateDelete(srcFolder, false);
+        oldPathFile->Remove(false);  // berkeley mailbox
+        srcFolder->DeleteStorage();
+
+        nsCOMPtr<nsIFile> parentPathFile;
+        rv = msgParent->GetFilePath(getter_AddRefs(parentPathFile));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        AddDirectorySeparator(parentPathFile);
+        nsCOMPtr<nsIDirectoryEnumerator> children;
+        parentPathFile->GetDirectoryEntries(getter_AddRefs(children));
+        bool more;
+        // checks if the directory is empty or not
+        if (children && NS_SUCCEEDED(children->HasMoreElements(&more)) && !more)
+          parentPathFile->Remove(true);
+      }
+    } else  // non-virtual folder
+    {
+      nsCOMPtr<nsIImapService> imapService =
+          do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr<nsISupports> srcSupport = do_QueryInterface(srcFolder);
+      bool match = false;
+      bool confirmed = false;
+      if (mFlags & nsMsgFolderFlags::Trash) {
+        rv = srcFolder->MatchOrChangeFilterDestination(nullptr, false, &match);
+        if (match) {
+          srcFolder->ConfirmFolderDeletionForFilter(msgWindow, &confirmed);
+          // should we return an error to copy service?
+          // or send a notification?
+          if (!confirmed) return NS_OK;
+        }
+      }
+      rv = InitCopyState(srcSupport, {}, false, false, false, 0, EmptyCString(),
+                         listener, msgWindow, false);
+      if (NS_FAILED(rv)) return OnCopyCompleted(srcSupport, rv);
+
+      rv = imapService->MoveFolder(srcFolder, this, this, msgWindow);
+    }
+  } else {
+    // !sameServer OR it's a copy. Unit tests expect a successful folder
+    // copy within the same IMAP server even though the UI forbids copy and
+    // only allows moves inside the same server. folderCopier, set below,
+    // handles the folder copy within an IMAP server (needed by unit tests) and
+    // the folder move or copy from another account or server into an IMAP
+    // account/server. The folder move from another account is "impure" since
+    // just the messages are moved and the source folder remains in place.
+    RefPtr<nsImapFolderCopyState> folderCopier = new nsImapFolderCopyState(
+        this, srcFolder,
+        isMoveFolder,  // Always copy folders; if true only move the messages
+        msgWindow, listener);
+    // NOTE: the copystate object must hold itself in existence until complete,
+    // as we're not keeping hold of it here.
+    rv = folderCopier->StartNextCopy();
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::CopyFileMessage(nsIFile* file, nsIMsgDBHdr* msgToReplace,
+                                  bool isDraftOrTemplate, uint32_t aNewMsgFlags,
+                                  const nsACString& aNewMsgKeywords,
+                                  nsIMsgWindow* msgWindow,
+                                  nsIMsgCopyServiceListener* listener) {
+  nsresult rv = NS_ERROR_NULL_POINTER;
+  nsMsgKey key = nsMsgKey_None;
+  nsAutoCString messageId;
+  nsTArray<RefPtr<nsIMsgDBHdr>> messages;
+
+  nsCOMPtr<nsIImapService> imapService =
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+  if (NS_FAILED(rv)) return OnCopyCompleted(file, rv);
+
+  if (msgToReplace) {
+    rv = msgToReplace->GetMessageKey(&key);
+    if (NS_SUCCEEDED(rv)) {
+      messageId.AppendInt((int32_t)key);
+      // We have an existing message to replace because the user has deleted or
+      // detached one or more attachments. So tell SetPendingAttributes() to
+      // not set several pending offline items (offset, message size, etc.) for
+      // the message to be replaced by setting message size temporarily to zero.
+      // The original message is not actually "replaced" but is imap deleted
+      // and a new message with the same body but with some deleted or detached
+      // attachments is imap appended from the file to the folder.
+      uint32_t saveMsgSize;
+      msgToReplace->GetOfflineMessageSize(&saveMsgSize);
+      msgToReplace->SetOfflineMessageSize(0);
+      SetPendingAttributes({msgToReplace}, false, false);
+      msgToReplace->SetOfflineMessageSize(saveMsgSize);
+      messages.AppendElement(msgToReplace);
+    }
+  }
+
+  bool isMove = (msgToReplace ? true : false);
+  rv = InitCopyState(file, messages, isMove, isDraftOrTemplate, false,
+                     aNewMsgFlags, aNewMsgKeywords, listener, msgWindow, false);
+  if (NS_FAILED(rv)) return OnCopyCompleted(file, rv);
+
+  m_copyState->m_streamCopy = true;
+  rv = imapService->AppendMessageFromFile(file, this, messageId, true,
+                                          isDraftOrTemplate, this, m_copyState,
+                                          msgWindow);
+  if (NS_FAILED(rv)) return OnCopyCompleted(file, rv);
+
+  return rv;
+}
+
+nsresult nsImapMailFolder::CopyStreamMessage(
+    nsIMsgDBHdr* message,
+    nsIMsgFolder* dstFolder,  // should be this
+    nsIMsgWindow* aMsgWindow, bool isMove) {
+  NS_ENSURE_ARG_POINTER(message);
+  if (!m_copyState)
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("CopyStreamMessage failed with null m_copyState"));
+  NS_ENSURE_TRUE(m_copyState, NS_ERROR_NULL_POINTER);
+  nsresult rv;
+  nsCOMPtr<nsICopyMessageStreamListener> copyStreamListener = do_CreateInstance(
+      "@mozilla.org/messenger/copymessagestreamlistener;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsICopyMessageListener> copyListener(
+      do_QueryInterface(dstFolder, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> srcFolder(
+      do_QueryInterface(m_copyState->m_srcSupport, &rv));
+  if (NS_FAILED(rv))
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("CopyStreaMessage failed with null m_copyState->m_srcSupport"));
+  if (NS_FAILED(rv)) return rv;
+  rv = copyStreamListener->Init(copyListener);
+  if (NS_FAILED(rv))
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("CopyStreaMessage failed in copyStreamListener->Init"));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCString uri;
+  srcFolder->GetUriForMsg(message, uri);
+
+  if (!m_copyState->m_msgService)
+    rv = GetMessageServiceFromURI(uri,
+                                  getter_AddRefs(m_copyState->m_msgService));
+
+  if (NS_SUCCEEDED(rv) && m_copyState->m_msgService) {
+    nsCOMPtr<nsIStreamListener> streamListener(
+        do_QueryInterface(copyStreamListener, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // put up status message here, if copying more than one message.
+    if (m_copyState->m_messages.Length() > 1) {
+      nsString dstFolderName, progressText;
+      GetName(dstFolderName);
+      nsAutoString curMsgString;
+      nsAutoString totalMsgString;
+      totalMsgString.AppendInt((int32_t)m_copyState->m_messages.Length());
+      curMsgString.AppendInt(m_copyState->m_curIndex + 1);
+
+      AutoTArray<nsString, 3> formatStrings = {curMsgString, totalMsgString,
+                                               dstFolderName};
+
+      nsCOMPtr<nsIStringBundle> bundle;
+      rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = bundle->FormatStringFromName("imapCopyingMessageOf2", formatStrings,
+                                        progressText);
+      nsCOMPtr<nsIMsgStatusFeedback> statusFeedback;
+      if (m_copyState->m_msgWindow)
+        m_copyState->m_msgWindow->GetStatusFeedback(
+            getter_AddRefs(statusFeedback));
+      if (statusFeedback) {
+        statusFeedback->ShowStatusString(progressText);
+        int32_t percent;
+        percent = (100 * m_copyState->m_curIndex) /
+                  (int32_t)m_copyState->m_messages.Length();
+        statusFeedback->ShowProgress(percent);
+      }
+    }
+    rv = m_copyState->m_msgService->CopyMessage(
+        uri, streamListener, isMove && !m_copyState->m_isCrossServerOp, nullptr,
+        aMsgWindow);
+    if (NS_FAILED(rv))
+      MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+              ("CopyMessage failed: uri %s", uri.get()));
+  }
+  return rv;
+}
+
+nsImapMailCopyState::nsImapMailCopyState()
+    : m_isMove(false),
+      m_selectedState(false),
+      m_isCrossServerOp(false),
+      m_curIndex(0),
+      m_streamCopy(false),
+      m_dataBuffer(nullptr),
+      m_dataBufferSize(0),
+      m_leftOver(0),
+      m_allowUndo(false),
+      m_eatLF(false),
+      m_newMsgFlags(0),
+      m_appendUID(nsMsgKey_None) {}
+
+nsImapMailCopyState::~nsImapMailCopyState() {
+  PR_Free(m_dataBuffer);
+  if (m_tmpFile) m_tmpFile->Remove(false);
+}
+
+NS_IMPL_ISUPPORTS(nsImapMailCopyState, nsImapMailCopyState)
+
+nsresult nsImapMailFolder::InitCopyState(
+    nsISupports* srcSupport, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
+    bool isMove, bool selectedState, bool acrossServers, uint32_t newMsgFlags,
+    const nsACString& newMsgKeywords, nsIMsgCopyServiceListener* listener,
+    nsIMsgWindow* msgWindow, bool allowUndo) {
+  NS_ENSURE_ARG_POINTER(srcSupport);
+
+  NS_ENSURE_TRUE(!m_copyState, NS_ERROR_FAILURE);
+
+  m_copyState = new nsImapMailCopyState();
+
+  m_copyState->m_isCrossServerOp = acrossServers;
+  m_copyState->m_srcSupport = srcSupport;
+
+  m_copyState->m_messages = messages.Clone();
+  if (!m_copyState->m_isCrossServerOp) {
+    uint32_t numUnread = 0;
+    for (nsIMsgDBHdr* message : m_copyState->m_messages) {
+      // if the message is not there, then assume what the caller tells us to.
+      bool isRead = false;
+      uint32_t flags;
+      if (message) {
+        message->GetFlags(&flags);
+        isRead = flags & nsMsgMessageFlags::Read;
+      }
+      if (!isRead) numUnread++;
+    }
+    m_copyState->m_unreadCount = numUnread;
+  } else {
+    nsIMsgDBHdr* message = m_copyState->m_messages[m_copyState->m_curIndex];
+    // if the key is not there, then assume what the caller tells us to.
+    bool isRead = false;
+    uint32_t flags;
+    if (message) {
+      message->GetFlags(&flags);
+      isRead = flags & nsMsgMessageFlags::Read;
+    }
+    m_copyState->m_unreadCount = (isRead) ? 0 : 1;
+  }
+
+  m_copyState->m_isMove = isMove;
+  m_copyState->m_newMsgFlags = newMsgFlags;
+  m_copyState->m_newMsgKeywords = newMsgKeywords;
+  m_copyState->m_allowUndo = allowUndo;
+  m_copyState->m_selectedState = selectedState;
+  m_copyState->m_msgWindow = msgWindow;
+  if (listener) m_copyState->m_listener = listener;
+  return NS_OK;
+}
+
+nsresult nsImapMailFolder::CopyFileToOfflineStore(nsIFile* srcFile,
+                                                  nsMsgKey msgKey) {
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool storeOffline = (mFlags & nsMsgFolderFlags::Offline) && !WeAreOffline();
+
+  if (msgKey == nsMsgKey_None) {
+    // To support send filters, we need to store the message in the database
+    // when it is copied to the FCC folder. In that case, we know the UID of the
+    // message and therefore have the correct msgKey. In other cases, where
+    // we don't need the offline message copied, don't add to db.
+    if (!storeOffline) return NS_OK;
+
+    mDatabase->GetNextFakeOfflineMsgKey(&msgKey);
+  }
+
+  nsCOMPtr<nsIMsgDBHdr> fakeHdr;
+  rv = mDatabase->CreateNewHdr(msgKey, getter_AddRefs(fakeHdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+  fakeHdr->SetUint32Property("pseudoHdr", 1);
+
+  // Should we add this to the offline store?
+  nsCOMPtr<nsIOutputStream> offlineStore;
+  if (storeOffline) {
+    rv = GetOfflineStoreOutputStream(fakeHdr, getter_AddRefs(offlineStore));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // We set an offline kMoveResult because in any case we want to update this
+  // msgHdr with one downloaded from the server, with possible additional
+  // headers added.
+  nsCOMPtr<nsIMsgOfflineImapOperation> op;
+  nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb = do_QueryInterface(mDatabase, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = opsDb->GetOfflineOpForKey(msgKey, true, getter_AddRefs(op));
+  if (NS_SUCCEEDED(rv) && op) {
+    nsCString destFolderUri;
+    GetURI(destFolderUri);
+    op->SetOperation(nsIMsgOfflineImapOperation::kMoveResult);
+    op->SetDestinationFolderURI(destFolderUri);
+    SetFlag(nsMsgFolderFlags::OfflineEvents);
+  }
+
+  nsCOMPtr<nsIInputStream> inputStream;
+  nsCOMPtr<nsIMsgParseMailMsgState> msgParser =
+      do_CreateInstance("@mozilla.org/messenger/messagestateparser;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  msgParser->SetMailDB(mDatabase);
+
+  rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), srcFile);
+  if (NS_SUCCEEDED(rv) && inputStream) {
+    // Now, parse the temp file to (optionally) copy to
+    // the offline store for the cur folder.
+    RefPtr<nsMsgLineStreamBuffer> inputStreamBuffer =
+        new nsMsgLineStreamBuffer(FILE_IO_BUFFER_SIZE, true, false);
+    int64_t fileSize;
+    srcFile->GetFileSize(&fileSize);
+    uint32_t bytesWritten;
+    rv = NS_OK;
+    msgParser->SetState(nsIMsgParseMailMsgState::ParseHeadersState);
+    msgParser->SetNewMsgHdr(fakeHdr);
+    bool needMoreData = false;
+    char* newLine = nullptr;
+    uint32_t numBytesInLine = 0;
+    if (offlineStore) {
+      const char* envelope = "From " CRLF;
+      offlineStore->Write(envelope, strlen(envelope), &bytesWritten);
+      fileSize += bytesWritten;
+    }
+    do {
+      newLine = inputStreamBuffer->ReadNextLine(inputStream, numBytesInLine,
+                                                needMoreData);
+      if (newLine) {
+        msgParser->ParseAFolderLine(newLine, numBytesInLine);
+        if (offlineStore)
+          rv = offlineStore->Write(newLine, numBytesInLine, &bytesWritten);
+
+        free(newLine);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    } while (newLine);
+
+    msgParser->FinishHeader();
+    uint32_t resultFlags;
+    if (offlineStore)
+      fakeHdr->OrFlags(nsMsgMessageFlags::Offline | nsMsgMessageFlags::Read,
+                       &resultFlags);
+    else
+      fakeHdr->OrFlags(nsMsgMessageFlags::Read, &resultFlags);
+    if (offlineStore) fakeHdr->SetOfflineMessageSize(fileSize);
+    mDatabase->AddNewHdrToDB(fakeHdr, true /* notify */);
+
+    // Call FinishNewMessage before setting pending attributes, as in
+    //   maildir it copies from tmp to cur and may change the storeToken
+    //   to get a unique filename.
+    if (offlineStore) {
+      nsCOMPtr<nsIMsgPluggableStore> msgStore;
+      GetMsgStore(getter_AddRefs(msgStore));
+      if (msgStore) msgStore->FinishNewMessage(offlineStore, fakeHdr);
+    }
+
+    // We are copying from a file to offline store so set offline flag.
+    SetPendingAttributes({&*fakeHdr}, false, true);
+
+    // Gloda needs this notification to index the fake message.
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+    if (notifier) notifier->NotifyMsgsClassified({&*fakeHdr}, false, false);
+    inputStream->Close();
+    inputStream = nullptr;
+  }
+  if (offlineStore) offlineStore->Close();
+  return rv;
+}
+
+nsresult nsImapMailFolder::OnCopyCompleted(nsISupports* srcSupport,
+                                           nsresult rv) {
+  // if it's a file, and the copy succeeded, then fcc the offline
+  // store, and add a kMoveResult offline op.
+  if (NS_SUCCEEDED(rv) && m_copyState) {
+    nsCOMPtr<nsIFile> srcFile(do_QueryInterface(srcSupport));
+    if (srcFile)
+      (void)CopyFileToOfflineStore(srcFile, m_copyState->m_appendUID);
+  }
+  m_copyState = nullptr;
+  nsresult result;
+  nsCOMPtr<nsIMsgCopyService> copyService =
+      do_GetService("@mozilla.org/messenger/messagecopyservice;1", &result);
+  NS_ENSURE_SUCCESS(result, result);
+  return copyService->NotifyCompletion(srcSupport, this, rv);
+}
+
+nsresult nsImapMailFolder::CreateBaseMessageURI(const nsACString& aURI) {
+  return nsCreateImapBaseMessageURI(aURI, mBaseMessageURI);
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetFolderURL(nsACString& aFolderURL) {
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rootFolder->GetURI(aFolderURL);
+  if (rootFolder == this) return NS_OK;
+
+  NS_ASSERTION(mURI.Length() > aFolderURL.Length(),
+               "Should match with a folder name!");
+  nsCString escapedName;
+  MsgEscapeString(Substring(mURI, aFolderURL.Length()),
+                  nsINetUtil::ESCAPE_URL_PATH, escapedName);
+  if (escapedName.IsEmpty()) return NS_ERROR_OUT_OF_MEMORY;
+  aFolderURL.Append(escapedName);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetFolderNeedsSubscribing(bool* bVal) {
+  NS_ENSURE_ARG_POINTER(bVal);
+  *bVal = m_folderNeedsSubscribing;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetFolderNeedsSubscribing(bool bVal) {
+  m_folderNeedsSubscribing = bVal;
+  return NS_OK;
+}
+
+nsMsgIMAPFolderACL* nsImapMailFolder::GetFolderACL() {
+  if (!m_folderACL) m_folderACL = new nsMsgIMAPFolderACL(this);
+  return m_folderACL;
+}
+
+nsresult nsImapMailFolder::CreateACLRightsStringForFolder(
+    nsAString& rightsString) {
+  GetFolderACL();  // lazy create
+  NS_ENSURE_TRUE(m_folderACL, NS_ERROR_NULL_POINTER);
+  return m_folderACL->CreateACLRightsString(rightsString);
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetFolderNeedsACLListed(bool* bVal) {
+  NS_ENSURE_ARG_POINTER(bVal);
+  bool dontNeedACLListed = !m_folderNeedsACLListed;
+  // if we haven't acl listed, and it's not a no select folder or the inbox,
+  //  then we'll list the acl if it's not a namespace.
+  if (m_folderNeedsACLListed &&
+      !(mFlags & (nsMsgFolderFlags::ImapNoselect | nsMsgFolderFlags::Inbox)))
+    GetIsNamespace(&dontNeedACLListed);
+  *bVal = !dontNeedACLListed;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetFolderNeedsACLListed(bool bVal) {
+  m_folderNeedsACLListed = bVal;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetIsNamespace(bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  nsresult rv = NS_OK;
+  if (!m_namespace) {
+#ifdef DEBUG_bienvenu
+    // Make sure this isn't causing us to open the database
+    NS_ASSERTION(m_hierarchyDelimiter != kOnlineHierarchySeparatorUnknown,
+                 "hierarchy delimiter not set");
+#endif
+
+    nsCString onlineName, serverKey;
+    GetServerKey(serverKey);
+    GetOnlineName(onlineName);
+    char hierarchyDelimiter;
+    GetHierarchyDelimiter(&hierarchyDelimiter);
+
+    nsCOMPtr<nsIImapHostSessionList> hostSession =
+        do_GetService(kCImapHostSessionList, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    m_namespace = nsImapNamespaceList::GetNamespaceForFolder(
+        serverKey.get(), onlineName.get(), hierarchyDelimiter);
+    if (m_namespace == nullptr) {
+      if (mFlags & nsMsgFolderFlags::ImapOtherUser)
+        rv = hostSession->GetDefaultNamespaceOfTypeForHost(
+            serverKey.get(), kOtherUsersNamespace, m_namespace);
+      else if (mFlags & nsMsgFolderFlags::ImapPublic)
+        rv = hostSession->GetDefaultNamespaceOfTypeForHost(
+            serverKey.get(), kPublicNamespace, m_namespace);
+      else
+        rv = hostSession->GetDefaultNamespaceOfTypeForHost(
+            serverKey.get(), kPersonalNamespace, m_namespace);
+    }
+    NS_ASSERTION(m_namespace, "failed to get namespace");
+    if (m_namespace) {
+      nsImapNamespaceList::SuggestHierarchySeparatorForNamespace(
+          m_namespace, hierarchyDelimiter);
+      m_folderIsNamespace = nsImapNamespaceList::GetFolderIsNamespace(
+          serverKey.get(), onlineName.get(), hierarchyDelimiter, m_namespace);
+    }
+  }
+  *aResult = m_folderIsNamespace;
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetIsNamespace(bool isNamespace) {
+  m_folderIsNamespace = isNamespace;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::ResetNamespaceReferences() {
+  nsCString serverKey;
+  nsCString onlineName;
+  GetServerKey(serverKey);
+  GetOnlineName(onlineName);
+  char hierarchyDelimiter;
+  GetHierarchyDelimiter(&hierarchyDelimiter);
+  m_namespace = nsImapNamespaceList::GetNamespaceForFolder(
+      serverKey.get(), onlineName.get(), hierarchyDelimiter);
+  m_folderIsNamespace = m_namespace ? nsImapNamespaceList::GetFolderIsNamespace(
+                                          serverKey.get(), onlineName.get(),
+                                          hierarchyDelimiter, m_namespace)
+                                    : false;
+
+  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+  nsresult rv = GetSubFolders(subFolders);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (nsIMsgFolder* f : subFolders) {
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(f, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = imapFolder->ResetNamespaceReferences();
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::FindOnlineSubFolder(
+    const nsACString& targetOnlineName, nsIMsgImapMailFolder** aResultFolder) {
+  *aResultFolder = nullptr;
+  nsresult rv = NS_OK;
+
+  nsCString onlineName;
+  GetOnlineName(onlineName);
+
+  if (onlineName.Equals(targetOnlineName)) {
+    return QueryInterface(NS_GET_IID(nsIMsgImapMailFolder),
+                          (void**)aResultFolder);
+  }
+
+  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+  rv = GetSubFolders(subFolders);
+  NS_ENSURE_SUCCESS(rv, rv);
+  for (nsIMsgFolder* f : subFolders) {
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(f, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = imapFolder->FindOnlineSubFolder(targetOnlineName, aResultFolder);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (*aResultFolder) {
+      return NS_OK;  // Found it!
+    }
+  }
+  return NS_OK;  // Not found.
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetFolderNeedsAdded(bool* bVal) {
+  NS_ENSURE_ARG_POINTER(bVal);
+  *bVal = m_folderNeedsAdded;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetFolderNeedsAdded(bool bVal) {
+  m_folderNeedsAdded = bVal;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetFolderQuotaCommandIssued(bool* aCmdIssued) {
+  NS_ENSURE_ARG_POINTER(aCmdIssued);
+  *aCmdIssued = m_folderQuotaCommandIssued;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetFolderQuotaCommandIssued(bool aCmdIssued) {
+  m_folderQuotaCommandIssued = aCmdIssued;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetFolderQuotaData(
+    uint32_t aAction, const nsACString& aFolderQuotaRoot,
+    uint64_t aFolderQuotaUsage, uint64_t aFolderQuotaLimit) {
+  switch (aAction) {
+    case kInvalidateQuota:
+      // Reset to initialize evaluation of a new quotaroot imap response. This
+      // clears any previous array data and marks the quota data for this folder
+      // invalid.
+      m_folderQuotaDataIsValid = false;
+      m_folderQuota.Clear();
+      break;
+    case kStoreQuota:
+      // Store folder's quota data to an array. This will occur zero or more
+      // times for a folder.
+      m_folderQuota.AppendElement(new nsMsgQuota(
+          aFolderQuotaRoot, aFolderQuotaUsage, aFolderQuotaLimit));
+      break;
+    case kValidateQuota:
+      // GETQUOTAROOT command was successful and OK response has occurred. This
+      // indicates that all the untagged QUOTA responses have occurred so mark
+      // as valid.
+      m_folderQuotaDataIsValid = true;
+      break;
+    default:
+      // Called with undefined aAction parameter.
+      NS_ASSERTION(false, "undefined action");
+  }
+  return NS_OK;
+}
+
+// Provide the quota array for status bar notification.
+NS_IMETHODIMP nsImapMailFolder::GetQuota(
+    nsTArray<RefPtr<nsIMsgQuota>>& aArray) {
+  if (m_folderQuotaDataIsValid) {
+    aArray = m_folderQuota.Clone();
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::PerformExpand(nsIMsgWindow* aMsgWindow) {
+  nsresult rv;
+  bool usingSubscription = false;
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = imapServer->GetUsingSubscription(&usingSubscription);
+  if (NS_SUCCEEDED(rv) && !usingSubscription) {
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = imapService->DiscoverChildren(this, this, m_onlineFolderName);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::RenameClient(nsIMsgWindow* msgWindow,
+                                             nsIMsgFolder* msgFolder,
+                                             const nsACString& oldName,
+                                             const nsACString& newName) {
+  nsresult rv;
+  nsCOMPtr<nsIFile> pathFile;
+  rv = GetFilePath(getter_AddRefs(pathFile));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIMsgImapMailFolder> oldImapFolder =
+      do_QueryInterface(msgFolder, &rv);
+  if (NS_FAILED(rv)) return rv;
+
+  char hierarchyDelimiter = '/';
+  oldImapFolder->GetHierarchyDelimiter(&hierarchyDelimiter);
+  int32_t boxflags = 0;
+  oldImapFolder->GetBoxFlags(&boxflags);
+
+  nsAutoString newLeafName;
+  NS_ConvertUTF8toUTF16 newNameString(newName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  newLeafName = newNameString;
+  nsAutoString folderNameStr;
+  int32_t folderStart = newLeafName.RFindChar(
+      '/');  // internal use of hierarchyDelimiter is always '/'
+  if (folderStart > 0) {
+    newLeafName = Substring(newNameString, folderStart + 1);
+    CreateDirectoryForFolder(
+        getter_AddRefs(pathFile));  // needed when we move a folder to a folder
+                                    // with no subfolders.
+  }
+
+  // if we get here, it's really a leaf, and "this" is the parent.
+  folderNameStr = newLeafName;
+
+  // Create an empty database for this mail folder, set its name from the user
+  nsCOMPtr<nsIMsgDatabase> mailDBFactory;
+  nsCOMPtr<nsIMsgFolder> child;
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder;
+
+  nsCOMPtr<nsIMsgDBService> msgDBService =
+      do_GetService("@mozilla.org/msgDatabase/msgDBService;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgDatabase> unusedDB;
+  nsCOMPtr<nsIFile> dbFile;
+
+  // warning, path will be changed
+  rv = CreateFileForDB(folderNameStr, pathFile, getter_AddRefs(dbFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Use openMailDBFromFile() and not OpenFolderDB() here, since we don't use
+  // the DB.
+  rv = msgDBService->OpenMailDBFromFile(dbFile, nullptr, true, true,
+                                        getter_AddRefs(unusedDB));
+  if (NS_SUCCEEDED(rv) && unusedDB) {
+    // need to set the folder name
+    nsCOMPtr<nsIDBFolderInfo> folderInfo;
+    rv = unusedDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+
+    // Now let's create the actual new folder
+    rv = AddSubfolderWithPath(folderNameStr, dbFile, getter_AddRefs(child));
+    if (!child || NS_FAILED(rv)) return rv;
+    nsAutoString unicodeName;
+    rv = CopyFolderNameToUTF16(NS_ConvertUTF16toUTF8(folderNameStr),
+                               unicodeName);
+    if (NS_SUCCEEDED(rv)) child->SetPrettyName(unicodeName);
+    imapFolder = do_QueryInterface(child);
+    if (imapFolder) {
+      nsAutoCString onlineName(m_onlineFolderName);
+
+      if (!onlineName.IsEmpty()) onlineName.Append(hierarchyDelimiter);
+      onlineName.Append(NS_ConvertUTF16toUTF8(folderNameStr));
+      imapFolder->SetVerifiedAsOnlineFolder(true);
+      imapFolder->SetOnlineName(onlineName);
+      imapFolder->SetHierarchyDelimiter(hierarchyDelimiter);
+      imapFolder->SetBoxFlags(boxflags);
+      // store the online name as the mailbox name in the db folder info
+      // I don't think anyone uses the mailbox name, so we'll use it
+      // to restore the online name when blowing away an imap db.
+      if (folderInfo) {
+        nsAutoString unicodeOnlineName;
+        CopyUTF8toUTF16(onlineName, unicodeOnlineName);
+        folderInfo->SetMailboxName(unicodeOnlineName);
+      }
+      bool changed = false;
+      msgFolder->MatchOrChangeFilterDestination(
+          child, false /*caseInsensitive*/, &changed);
+      if (changed) msgFolder->AlertFilterChanged(msgWindow);
+    }
+    unusedDB->SetSummaryValid(true);
+    unusedDB->Commit(nsMsgDBCommitType::kLargeCommit);
+    unusedDB->Close(true);
+    child->RenameSubFolders(msgWindow, msgFolder);
+    nsCOMPtr<nsIMsgFolder> msgParent;
+    msgFolder->GetParent(getter_AddRefs(msgParent));
+    msgFolder->SetParent(nullptr);
+    // Reset online status now that the folder is renamed.
+    nsCOMPtr<nsIMsgImapMailFolder> oldImapFolder = do_QueryInterface(msgFolder);
+    if (oldImapFolder) oldImapFolder->SetVerifiedAsOnlineFolder(false);
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
+        do_GetService("@mozilla.org/messenger/msgnotificationservice;1"));
+    if (notifier) notifier->NotifyFolderRenamed(msgFolder, child);
+
+    // Do not propagate the deletion until after we have (synchronously)
+    // notified all listeners about the rename.  This allows them to access
+    // properties on the source folder without experiencing failures.
+    if (msgParent) msgParent->PropagateDelete(msgFolder, true);
+    NotifyFolderAdded(child);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::RenameSubFolders(nsIMsgWindow* msgWindow,
+                                                 nsIMsgFolder* oldFolder) {
+  m_initialized = true;
+  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
+  nsresult rv = oldFolder->GetSubFolders(subFolders);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (nsIMsgFolder* msgFolder : subFolders) {
+    nsCOMPtr<nsIMsgImapMailFolder> folder(do_QueryInterface(msgFolder, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    char hierarchyDelimiter = '/';
+    folder->GetHierarchyDelimiter(&hierarchyDelimiter);
+
+    int32_t boxflags;
+    folder->GetBoxFlags(&boxflags);
+
+    bool verified;
+    folder->GetVerifiedAsOnlineFolder(&verified);
+
+    nsCOMPtr<nsIFile> oldPathFile;
+    rv = msgFolder->GetFilePath(getter_AddRefs(oldPathFile));
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIFile> newParentPathFile;
+    rv = GetFilePath(getter_AddRefs(newParentPathFile));
+    if (NS_FAILED(rv)) return rv;
+
+    rv = AddDirectorySeparator(newParentPathFile);
+    nsAutoCString oldLeafName;
+    oldPathFile->GetNativeLeafName(oldLeafName);
+    newParentPathFile->AppendNative(oldLeafName);
+
+    nsCOMPtr<nsIFile> newPathFile =
+        do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    newPathFile->InitWithFile(newParentPathFile);
+
+    nsCOMPtr<nsIFile> dbFilePath = newPathFile;
+
+    nsCOMPtr<nsIMsgFolder> child;
+
+    nsString folderName;
+    rv = msgFolder->GetName(folderName);
+    if (folderName.IsEmpty() || NS_FAILED(rv)) return rv;
+
+    nsCString utfLeafName;
+    bool utf8AcceptEnabled;
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(msgFolder);
+    rv = imapFolder->GetShouldUseUtf8FolderName(&utf8AcceptEnabled);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (utf8AcceptEnabled) {
+      CopyUTF16toUTF8(folderName, utfLeafName);
+    } else {
+      CopyUTF16toMUTF7(folderName, utfLeafName);
+    }
+
+    // XXX : Fix this non-sense by fixing AddSubfolderWithPath
+    nsAutoString unicodeLeafName;
+    CopyUTF8toUTF16(utfLeafName, unicodeLeafName);
+
+    rv = AddSubfolderWithPath(unicodeLeafName, dbFilePath,
+                              getter_AddRefs(child));
+    if (!child || NS_FAILED(rv)) return rv;
+
+    child->SetName(folderName);
+    imapFolder = do_QueryInterface(child);
+    nsCString onlineName;
+    GetOnlineName(onlineName);
+    nsAutoCString onlineCName(onlineName);
+    onlineCName.Append(hierarchyDelimiter);
+    onlineCName.Append(utfLeafName);
+    if (imapFolder) {
+      imapFolder->SetVerifiedAsOnlineFolder(verified);
+      imapFolder->SetOnlineName(onlineCName);
+      imapFolder->SetHierarchyDelimiter(hierarchyDelimiter);
+      imapFolder->SetBoxFlags(boxflags);
+
+      bool changed = false;
+      msgFolder->MatchOrChangeFilterDestination(
+          child, false /*caseInsensitive*/, &changed);
+      if (changed) msgFolder->AlertFilterChanged(msgWindow);
+      child->RenameSubFolders(msgWindow, msgFolder);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::IsCommandEnabled(const nsACString& command,
+                                                 bool* result) {
+  NS_ENSURE_ARG_POINTER(result);
+  *result = !(WeAreOffline() && (command.EqualsLiteral("cmd_renameFolder") ||
+                                 command.EqualsLiteral("cmd_compactFolder") ||
+                                 command.EqualsLiteral("button_compact") ||
+                                 command.EqualsLiteral("cmd_delete") ||
+                                 command.EqualsLiteral("button_delete")));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetCanFileMessages(bool* aCanFileMessages) {
+  nsresult rv;
+  *aCanFileMessages = true;
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = GetServer(getter_AddRefs(server));
+  if (NS_SUCCEEDED(rv) && server)
+    rv = server->GetCanFileMessagesOnServer(aCanFileMessages);
+
+  if (*aCanFileMessages)
+    rv = nsMsgDBFolder::GetCanFileMessages(aCanFileMessages);
+
+  if (*aCanFileMessages) {
+    bool noSelect;
+    GetFlag(nsMsgFolderFlags::ImapNoselect, &noSelect);
+    *aCanFileMessages =
+        (noSelect) ? false : GetFolderACL()->GetCanIInsertInFolder();
+    return NS_OK;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetCanDeleteMessages(bool* aCanDeleteMessages) {
+  NS_ENSURE_ARG_POINTER(aCanDeleteMessages);
+  *aCanDeleteMessages = GetFolderACL()->GetCanIDeleteInFolder();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetPerformingBiff(bool* aPerformingBiff) {
+  NS_ENSURE_ARG_POINTER(aPerformingBiff);
+  *aPerformingBiff = m_performingBiff;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetPerformingBiff(bool aPerformingBiff) {
+  m_performingBiff = aPerformingBiff;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetFilterList(nsIMsgFilterList* aMsgFilterList) {
+  m_filterList = aMsgFilterList;
+  return nsMsgDBFolder::SetFilterList(aMsgFilterList);
+}
+
+nsresult nsImapMailFolder::GetMoveCoalescer() {
+  if (!m_moveCoalescer)
+    m_moveCoalescer = new nsImapMoveCoalescer(this, nullptr /* msgWindow */);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::StoreCustomKeywords(nsIMsgWindow* aMsgWindow,
+                                      const nsACString& aFlagsToAdd,
+                                      const nsACString& aFlagsToSubtract,
+                                      const nsTArray<nsMsgKey>& aKeysToStore,
+                                      nsIURI** _retval) {
+  if (aKeysToStore.IsEmpty()) return NS_OK;
+  nsresult rv = NS_OK;
+  if (WeAreOffline()) {
+    GetDatabase();
+    if (!mDatabase) return NS_ERROR_UNEXPECTED;
+    nsCOMPtr<nsIMsgOfflineOpsDatabase> opsDb =
+        do_QueryInterface(mDatabase, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    for (auto key : aKeysToStore) {
+      nsCOMPtr<nsIMsgOfflineImapOperation> op;
+      nsresult rv2 = opsDb->GetOfflineOpForKey(key, true, getter_AddRefs(op));
+      if (NS_FAILED(rv2)) rv = rv2;
+      SetFlag(nsMsgFolderFlags::OfflineEvents);
+      if (NS_SUCCEEDED(rv2) && op) {
+        if (!aFlagsToAdd.IsEmpty())
+          op->AddKeywordToAdd(PromiseFlatCString(aFlagsToAdd).get());
+        if (!aFlagsToSubtract.IsEmpty())
+          op->AddKeywordToRemove(PromiseFlatCString(aFlagsToSubtract).get());
+      }
+    }
+    mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);  // flush offline ops
+    return rv;
+  }
+
+  nsCOMPtr<nsIImapService> imapService(
+      do_GetService("@mozilla.org/messenger/imapservice;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsAutoCString msgIds;
+  AllocateUidStringFromKeys(aKeysToStore, msgIds);
+  nsCOMPtr<nsIURI> retUri;
+  rv = imapService->StoreCustomKeywords(this, aMsgWindow, aFlagsToAdd,
+                                        aFlagsToSubtract, msgIds,
+                                        getter_AddRefs(retUri));
+  if (_retval) {
+    retUri.forget(_retval);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::NotifyIfNewMail() {
+  return PerformBiffNotifications();
+}
+
+bool nsImapMailFolder::ShowPreviewText() {
+  bool showPreviewText = false;
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  if (prefBranch)
+    prefBranch->GetBoolPref("mail.biff.alert.show_preview", &showPreviewText);
+  return showPreviewText;
+}
+
+nsresult nsImapMailFolder::PlaybackCoalescedOperations() {
+  if (m_moveCoalescer) {
+    nsTArray<nsMsgKey>* junkKeysToClassify = m_moveCoalescer->GetKeyBucket(0);
+    if (junkKeysToClassify && !junkKeysToClassify->IsEmpty())
+      StoreCustomKeywords(m_moveCoalescer->GetMsgWindow(), "Junk"_ns,
+                          EmptyCString(), *junkKeysToClassify, nullptr);
+    junkKeysToClassify->Clear();
+    nsTArray<nsMsgKey>* nonJunkKeysToClassify =
+        m_moveCoalescer->GetKeyBucket(1);
+    if (nonJunkKeysToClassify && !nonJunkKeysToClassify->IsEmpty())
+      StoreCustomKeywords(m_moveCoalescer->GetMsgWindow(), "NonJunk"_ns,
+                          EmptyCString(), *nonJunkKeysToClassify, nullptr);
+    nonJunkKeysToClassify->Clear();
+    return m_moveCoalescer->PlaybackMoves(ShowPreviewText());
+  }
+  return NS_OK;  // must not be any coalesced operations
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetJunkScoreForMessages(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
+    const nsACString& aJunkScore) {
+  nsresult rv = nsMsgDBFolder::SetJunkScoreForMessages(aMessages, aJunkScore);
+  if (NS_SUCCEEDED(rv)) {
+    nsAutoCString messageIds;
+    nsTArray<nsMsgKey> keys;
+    nsresult rv = BuildIdsAndKeyArray(aMessages, messageIds, keys);
+    NS_ENSURE_SUCCESS(rv, rv);
+    StoreCustomKeywords(
+        nullptr, aJunkScore.EqualsLiteral("0") ? "NonJunk"_ns : "Junk"_ns,
+        aJunkScore.EqualsLiteral("0") ? "Junk"_ns : "NonJunk"_ns, keys,
+        nullptr);
+    if (mDatabase) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::OnMessageClassified(const nsACString& aMsgURI,
+                                      nsMsgJunkStatus aClassification,
+                                      uint32_t aJunkPercent) {
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!aMsgURI.IsEmpty())  // not end of batch
+  {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    rv = GetMsgDBHdrFromURI(aMsgURI, getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsMsgKey msgKey;
+    rv = msgHdr->GetMessageKey(&msgKey);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // check if this message needs junk classification
+
+    uint32_t processingFlags;
+    GetProcessingFlags(msgKey, &processingFlags);
+
+    if (processingFlags & nsMsgProcessingFlags::ClassifyJunk) {
+      nsMsgDBFolder::OnMessageClassified(aMsgURI, aClassification,
+                                         aJunkPercent);
+
+      GetMoveCoalescer();
+      if (m_moveCoalescer) {
+        nsTArray<nsMsgKey>* keysToClassify = m_moveCoalescer->GetKeyBucket(
+            (aClassification == nsIJunkMailPlugin::JUNK) ? 0 : 1);
+        NS_ASSERTION(keysToClassify, "error getting key bucket");
+        if (keysToClassify) keysToClassify->AppendElement(msgKey);
+      }
+      if (aClassification == nsIJunkMailPlugin::JUNK) {
+        nsCOMPtr<nsISpamSettings> spamSettings;
+        rv = server->GetSpamSettings(getter_AddRefs(spamSettings));
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        bool markAsReadOnSpam;
+        (void)spamSettings->GetMarkAsReadOnSpam(&markAsReadOnSpam);
+        if (markAsReadOnSpam) {
+          m_junkMessagesToMarkAsRead.AppendElement(msgHdr);
+        }
+
+        bool willMoveMessage = false;
+
+        // don't do the move when we are opening up
+        // the junk mail folder or the trash folder
+        // or when manually classifying messages in those folders
+        if (!(mFlags & nsMsgFolderFlags::Junk ||
+              mFlags & nsMsgFolderFlags::Trash)) {
+          bool moveOnSpam;
+          (void)spamSettings->GetMoveOnSpam(&moveOnSpam);
+          if (moveOnSpam) {
+            nsCString spamFolderURI;
+            rv = spamSettings->GetSpamFolderURI(spamFolderURI);
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            if (!spamFolderURI.IsEmpty()) {
+              rv = FindFolder(spamFolderURI, getter_AddRefs(mSpamFolder));
+              NS_ENSURE_SUCCESS(rv, rv);
+              if (mSpamFolder) {
+                rv = mSpamFolder->SetFlag(nsMsgFolderFlags::Junk);
+                NS_ENSURE_SUCCESS(rv, rv);
+                mSpamKeysToMove.AppendElement(msgKey);
+                willMoveMessage = true;
+              } else {
+                // XXX TODO
+                // JUNK MAIL RELATED
+                // the listener should do
+                // rv = folder->SetFlag(nsMsgFolderFlags::Junk);
+                // NS_ENSURE_SUCCESS(rv,rv);
+                // if (NS_SUCCEEDED(GetMoveCoalescer())) {
+                //   m_moveCoalescer->AddMove(folder, msgKey);
+                //   willMoveMessage = true;
+                // }
+                rv = GetOrCreateJunkFolder(spamFolderURI,
+                                           nullptr /* aListener */);
+                NS_ASSERTION(NS_SUCCEEDED(rv), "GetOrCreateJunkFolder failed");
+              }
+            }
+          }
+        }
+        rv = spamSettings->LogJunkHit(msgHdr, willMoveMessage);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+  }
+
+  else  // end of batch
+  {
+    // Parent will apply post bayes filters.
+    nsMsgDBFolder::OnMessageClassified(EmptyCString(),
+                                       nsIJunkMailPlugin::UNCLASSIFIED, 0);
+
+    if (!m_junkMessagesToMarkAsRead.IsEmpty()) {
+      rv = MarkMessagesRead(m_junkMessagesToMarkAsRead, true);
+      NS_ENSURE_SUCCESS(rv, rv);
+      m_junkMessagesToMarkAsRead.Clear();
+    }
+    if (!mSpamKeysToMove.IsEmpty()) {
+      GetMoveCoalescer();
+      for (uint32_t keyIndex = 0; keyIndex < mSpamKeysToMove.Length();
+           keyIndex++) {
+        // If an upstream filter moved this message, don't move it here.
+        nsMsgKey msgKey = mSpamKeysToMove.ElementAt(keyIndex);
+        nsMsgProcessingFlagType processingFlags;
+        GetProcessingFlags(msgKey, &processingFlags);
+        if (!(processingFlags & nsMsgProcessingFlags::FilterToMove)) {
+          if (m_moveCoalescer && mSpamFolder)
+            m_moveCoalescer->AddMove(mSpamFolder, msgKey);
+        } else {
+          // We don't need the FilterToMove flag anymore.
+          AndProcessingFlags(msgKey, ~nsMsgProcessingFlags::FilterToMove);
+        }
+      }
+      mSpamKeysToMove.Clear();
+    }
+
+    // Let's not hold onto the spam folder reference longer than necessary.
+    mSpamFolder = nullptr;
+
+    bool pendingMoves = m_moveCoalescer && m_moveCoalescer->HasPendingMoves();
+    PlaybackCoalescedOperations();
+    // If we are performing biff for this folder, tell the server object
+    if ((!pendingMoves || !ShowPreviewText()) && m_performingBiff) {
+      // we don't need to adjust the num new messages in this folder because
+      // the playback moves code already did that.
+      (void)PerformBiffNotifications();
+      server->SetPerformingBiff(false);
+      m_performingBiff = false;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::GetShouldDownloadAllHeaders(bool* aResult) {
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = false;
+  // for just the inbox, we check if the filter list has arbitrary headers.
+  // for all folders, check if we have a spam plugin that requires all headers
+  if (mFlags & nsMsgFolderFlags::Inbox) {
+    nsCOMPtr<nsIMsgFilterList> filterList;
+    nsresult rv = GetFilterList(nullptr, getter_AddRefs(filterList));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = filterList->GetShouldDownloadAllHeaders(aResult);
+    if (*aResult) return rv;
+  }
+  nsCOMPtr<nsIMsgFilterPlugin> filterPlugin;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+
+  if (NS_SUCCEEDED(GetServer(getter_AddRefs(server))))
+    server->GetSpamFilterPlugin(getter_AddRefs(filterPlugin));
+
+  return (filterPlugin) ? filterPlugin->GetShouldDownloadAllHeaders(aResult)
+                        : NS_OK;
+}
+
+void nsImapMailFolder::GetTrashFolderName(nsAString& aFolderName) {
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  nsresult rv;
+  rv = GetServer(getter_AddRefs(server));
+  if (NS_FAILED(rv)) return;
+  imapServer = do_QueryInterface(server, &rv);
+  if (NS_FAILED(rv)) return;
+  imapServer->GetTrashFolderName(aFolderName);
+  return;
+}
+NS_IMETHODIMP nsImapMailFolder::FetchMsgPreviewText(
+    nsTArray<nsMsgKey> const& aKeysToFetch, nsIUrlListener* aUrlListener,
+    bool* aAsyncResults) {
+  NS_ENSURE_ARG_POINTER(aAsyncResults);
+
+  nsTArray<nsMsgKey> keysToFetchFromServer;
+
+  *aAsyncResults = false;
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIMsgMessageService> msgService =
+      do_GetService("@mozilla.org/messenger/messageservice;1?type=imap", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (uint32_t i = 0; i < aKeysToFetch.Length(); i++) {
+    nsCOMPtr<nsIMsgDBHdr> msgHdr;
+    nsCString prevBody;
+    rv = GetMessageHeader(aKeysToFetch[i], getter_AddRefs(msgHdr));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // ignore messages that already have a preview body.
+    msgHdr->GetStringProperty("preview", prevBody);
+    if (!prevBody.IsEmpty()) continue;
+
+    /* check if message is in memory cache or offline store. */
+    nsCOMPtr<nsIURI> url;
+    nsCOMPtr<nsIInputStream> inputStream;
+    nsCString messageUri;
+    rv = GetUriForMsg(msgHdr, messageUri);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = msgService->GetUrlForUri(messageUri, nullptr, getter_AddRefs(url));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Lets look in the offline store.
+    uint32_t msgFlags;
+    msgHdr->GetFlags(&msgFlags);
+    if (msgFlags & nsMsgMessageFlags::Offline) {
+      rv = GetLocalMsgStream(msgHdr, getter_AddRefs(inputStream));
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = GetMsgPreviewTextFromStream(msgHdr, inputStream);
+      NS_ENSURE_SUCCESS(rv, rv);
+    } else {
+      nsMsgKey msgKey;
+      msgHdr->GetMessageKey(&msgKey);
+      keysToFetchFromServer.AppendElement(msgKey);
+    }
+  }
+  if (!keysToFetchFromServer.IsEmpty()) {
+    uint32_t msgCount = keysToFetchFromServer.Length();
+    nsAutoCString messageIds;
+    AllocateImapUidString(keysToFetchFromServer.Elements(), msgCount, nullptr,
+                          messageIds);
+    nsCOMPtr<nsIImapService> imapService =
+        do_GetService("@mozilla.org/messenger/imapservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIURI> outUri;
+    rv = imapService->GetBodyStart(this, aUrlListener, messageIds, 2048,
+                                   getter_AddRefs(outUri));
+    *aAsyncResults = true;  // the preview text will be available async...
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::AddKeywordsToMessages(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
+    const nsACString& aKeywords) {
+  nsresult rv = nsMsgDBFolder::AddKeywordsToMessages(aMessages, aKeywords);
+  if (NS_SUCCEEDED(rv)) {
+    nsAutoCString messageIds;
+    nsTArray<nsMsgKey> keys;
+    rv = BuildIdsAndKeyArray(aMessages, messageIds, keys);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = StoreCustomKeywords(nullptr, aKeywords, EmptyCString(), keys, nullptr);
+    if (mDatabase) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::RemoveKeywordsFromMessages(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
+    const nsACString& aKeywords) {
+  nsresult rv = nsMsgDBFolder::RemoveKeywordsFromMessages(aMessages, aKeywords);
+  if (NS_SUCCEEDED(rv)) {
+    nsAutoCString messageIds;
+    nsTArray<nsMsgKey> keys;
+    nsresult rv = BuildIdsAndKeyArray(aMessages, messageIds, keys);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = StoreCustomKeywords(nullptr, EmptyCString(), aKeywords, keys, nullptr);
+    if (mDatabase) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetCustomIdentity(nsIMsgIdentity** aIdentity) {
+  NS_ENSURE_ARG_POINTER(aIdentity);
+  if (mFlags & nsMsgFolderFlags::ImapOtherUser) {
+    nsresult rv;
+    bool delegateOtherUsersFolders = false;
+    nsCOMPtr<nsIPrefBranch> prefBranch(
+        do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    prefBranch->GetBoolPref("mail.imap.delegateOtherUsersFolders",
+                            &delegateOtherUsersFolders);
+    // if we're automatically delegating other user's folders, we need to
+    // cons up an e-mail address for the other user. We do that by
+    // taking the other user's name and the current user's domain name,
+    // assuming they'll be the same. So, <otherUsersName>@<ourDomain>
+    if (delegateOtherUsersFolders) {
+      nsCOMPtr<nsIMsgIncomingServer> server = do_QueryReferent(mServer, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr<nsIMsgAccountManager> accountManager =
+          do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr<nsIMsgIdentity> ourIdentity;
+      nsCOMPtr<nsIMsgIdentity> retIdentity;
+      nsCOMPtr<nsIMsgAccount> account;
+      nsCString foldersUserName;
+      nsCString ourEmailAddress;
+
+      accountManager->FindAccountForServer(server, getter_AddRefs(account));
+      NS_ENSURE_SUCCESS(rv, rv);
+      account->GetDefaultIdentity(getter_AddRefs(ourIdentity));
+      NS_ENSURE_SUCCESS(rv, rv);
+      ourIdentity->GetEmail(ourEmailAddress);
+      int32_t atPos = ourEmailAddress.FindChar('@');
+      if (atPos != kNotFound) {
+        nsCString otherUsersEmailAddress;
+        GetFolderOwnerUserName(otherUsersEmailAddress);
+        otherUsersEmailAddress.Append(
+            Substring(ourEmailAddress, atPos, ourEmailAddress.Length()));
+        nsTArray<RefPtr<nsIMsgIdentity>> identities;
+        rv = accountManager->GetIdentitiesForServer(server, identities);
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        for (auto identity : identities) {
+          if (!identity) continue;
+          nsCString identityEmail;
+          identity->GetEmail(identityEmail);
+          if (identityEmail.Equals(otherUsersEmailAddress)) {
+            retIdentity = identity;
+            break;
+          }
+        }
+        if (!retIdentity) {
+          // create the identity
+          rv = accountManager->CreateIdentity(getter_AddRefs(retIdentity));
+          NS_ENSURE_SUCCESS(rv, rv);
+          retIdentity->SetEmail(otherUsersEmailAddress);
+          nsCOMPtr<nsIMsgAccount> account;
+          accountManager->FindAccountForServer(server, getter_AddRefs(account));
+          NS_ENSURE_SUCCESS(rv, rv);
+          account->AddIdentity(retIdentity);
+        }
+      }
+      if (retIdentity) {
+        retIdentity.forget(aIdentity);
+        return NS_OK;
+      }
+    }
+  }
+  return nsMsgDBFolder::GetCustomIdentity(aIdentity);
+}
+
+NS_IMETHODIMP nsImapMailFolder::ChangePendingTotal(int32_t aDelta) {
+  ChangeNumPendingTotalMessages(aDelta);
+  if (aDelta > 0) NotifyHasPendingMsgs();
+  return NS_OK;
+}
+
+void nsImapMailFolder::NotifyHasPendingMsgs() {
+  InitAutoSyncState();
+  nsresult rv;
+  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr =
+      do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv)) autoSyncMgr->OnFolderHasPendingMsgs(m_autoSyncStateObj);
+}
+
+/* void changePendingUnread (in long aDelta); */
+NS_IMETHODIMP nsImapMailFolder::ChangePendingUnread(int32_t aDelta) {
+  ChangeNumPendingUnread(aDelta);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetServerRecent(int32_t* aServerRecent) {
+  NS_ENSURE_ARG_POINTER(aServerRecent);
+  *aServerRecent = m_numServerRecentMessages;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetServerTotal(int32_t* aServerTotal) {
+  NS_ENSURE_ARG_POINTER(aServerTotal);
+  *aServerTotal = m_numServerTotalMessages;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetServerUnseen(int32_t* aServerUnseen) {
+  NS_ENSURE_ARG_POINTER(aServerUnseen);
+  *aServerUnseen = m_numServerUnseenMessages;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetServerNextUID(int32_t* aNextUID) {
+  NS_ENSURE_ARG_POINTER(aNextUID);
+  *aNextUID = m_nextUID;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetAutoSyncStateObj(
+    nsIAutoSyncState** autoSyncStateObj) {
+  NS_ENSURE_ARG_POINTER(autoSyncStateObj);
+
+  // create auto-sync state object lazily
+  InitAutoSyncState();
+
+  NS_IF_ADDREF(*autoSyncStateObj = m_autoSyncStateObj);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::InitiateAutoSync(nsIUrlListener* aUrlListener) {
+  nsCString folderName;
+  GetURI(folderName);
+  MOZ_LOG(gAutoSyncLog, mozilla::LogLevel::Debug,
+          ("%s: Updating folder: %s", __func__, folderName.get()));
+
+  // HACK: if UpdateFolder finds out that it can't open
+  // the folder, it doesn't set the url listener and returns
+  // no error. In this case, we return success from this call
+  // but the caller never gets a notification on its url listener.
+  bool canOpenThisFolder = true;
+  GetCanOpenFolder(&canOpenThisFolder);
+
+  if (!canOpenThisFolder) {
+    MOZ_LOG(gAutoSyncLog, mozilla::LogLevel::Debug,
+            ("%s: Cannot update folder: %s", __func__, folderName.get()));
+    return NS_ERROR_FAILURE;
+  }
+
+  // create auto-sync state object lazily
+  InitAutoSyncState();
+
+  // make sure we get the counts from the folder cache.
+  ReadDBFolderInfo(false);
+
+  nsresult rv = m_autoSyncStateObj->ManageStorageSpace();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t syncState;
+  m_autoSyncStateObj->GetState(&syncState);
+  if (syncState == nsAutoSyncState::stUpdateNeeded)
+    return m_autoSyncStateObj->UpdateFolder();
+
+  // We only want to init the autosyncStateObj server counts the first time
+  // we update, and update it when the STATUS call finishes. This deals with
+  // the case where biff is doing a STATUS on a non-inbox folder, which
+  // can make autosync think the counts aren't changing.
+  PRTime lastUpdateTime;
+  m_autoSyncStateObj->GetLastUpdateTime(&lastUpdateTime);
+  if (!lastUpdateTime)
+    m_autoSyncStateObj->SetServerCounts(m_numServerTotalMessages,
+                                        m_numServerRecentMessages,
+                                        m_numServerUnseenMessages, m_nextUID);
+  // Issue a STATUS command and see if any counts changed.
+  m_autoSyncStateObj->SetState(nsAutoSyncState::stStatusIssued);
+  // The OnStopRunningUrl method of the autosync state obj
+  // will check if the counts or next uid have changed,
+  // and if so, will issue an UpdateFolder().
+  rv = UpdateStatus(m_autoSyncStateObj, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // record the last update time
+  m_autoSyncStateObj->SetLastUpdateTime(PR_Now());
+
+  return NS_OK;
+}
+
+/* static */
+void nsImapMailFolder::PlaybackTimerCallback(nsITimer* aTimer, void* aClosure) {
+  nsPlaybackRequest* request = static_cast<nsPlaybackRequest*>(aClosure);
+
+  NS_ASSERTION(request->SrcFolder->m_pendingPlaybackReq == request,
+               "wrong playback request pointer");
+
+  RefPtr<nsImapOfflineSync> offlineSync = new nsImapOfflineSync();
+  offlineSync->Init(request->MsgWindow, nullptr, request->SrcFolder, true);
+  if (offlineSync) {
+    mozilla::DebugOnly<nsresult> rv = offlineSync->ProcessNextOperation();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "pseudo-offline playback is not successful");
+  }
+
+  // release request struct and timer
+  request->SrcFolder->m_pendingPlaybackReq = nullptr;
+  request->SrcFolder->m_playbackTimer = nullptr;  // Just to flag timed out
+  delete request;
+}
+
+void nsImapMailFolder::InitAutoSyncState() {
+  if (!m_autoSyncStateObj) m_autoSyncStateObj = new nsAutoSyncState(this);
+}
+
+NS_IMETHODIMP nsImapMailFolder::HasMsgOffline(nsMsgKey msgKey, bool* _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+  *_retval = false;
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  nsresult rv = GetOfflineMsgFolder(msgKey, getter_AddRefs(msgFolder));
+  if (NS_SUCCEEDED(rv) && msgFolder) *_retval = true;
+  return NS_OK;
+}
+
+nsresult nsImapMailFolder::GetOfflineMsgFolder(nsMsgKey msgKey,
+                                               nsIMsgFolder** aMsgFolder) {
+  // Check if we have the message in the current folder.
+  NS_ENSURE_ARG_POINTER(aMsgFolder);
+  nsCOMPtr<nsIMsgFolder> subMsgFolder;
+  nsresult rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgDBHdr> hdr;
+  rv = mDatabase->GetMsgHdrForKey(msgKey, getter_AddRefs(hdr));
+  if (NS_FAILED(rv)) return rv;
+
+  if (hdr) {
+    uint32_t msgFlags = 0;
+    hdr->GetFlags(&msgFlags);
+    // Check if we already have this message body offline
+    if ((msgFlags & nsMsgMessageFlags::Offline)) {
+      NS_IF_ADDREF(*aMsgFolder = this);
+      return NS_OK;
+    }
+  }
+
+  if (!*aMsgFolder) {
+    // Checking the existence of message in other folders in case of GMail
+    // Server
+    bool isGMail;
+    nsCOMPtr<nsIImapIncomingServer> imapServer;
+    rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = imapServer->GetIsGMailServer(&isGMail);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (isGMail) {
+      nsCString labels;
+      nsTArray<nsCString> labelNames;
+      hdr->GetStringProperty("X-GM-LABELS", labels);
+      ParseString(labels, ' ', labelNames);
+      nsCOMPtr<nsIMsgFolder> rootFolder;
+      nsCOMPtr<nsIMsgImapMailFolder> subFolder;
+      for (uint32_t i = 0; i < labelNames.Length(); i++) {
+        rv = GetRootFolder(getter_AddRefs(rootFolder));
+        if (NS_SUCCEEDED(rv) && (rootFolder)) {
+          nsCOMPtr<nsIMsgImapMailFolder> imapRootFolder =
+              do_QueryInterface(rootFolder);
+          if (labelNames[i].EqualsLiteral("\"\\\\Draft\""))
+            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Drafts,
+                                                getter_AddRefs(subMsgFolder));
+          if (labelNames[i].EqualsLiteral("\"\\\\Inbox\""))
+            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox,
+                                                getter_AddRefs(subMsgFolder));
+          if (labelNames[i].EqualsLiteral("\"\\\\All Mail\""))
+            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Archive,
+                                                getter_AddRefs(subMsgFolder));
+          if (labelNames[i].EqualsLiteral("\"\\\\Trash\""))
+            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Trash,
+                                                getter_AddRefs(subMsgFolder));
+          if (labelNames[i].EqualsLiteral("\"\\\\Spam\""))
+            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Junk,
+                                                getter_AddRefs(subMsgFolder));
+          if (labelNames[i].EqualsLiteral("\"\\\\Sent\""))
+            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::SentMail,
+                                                getter_AddRefs(subMsgFolder));
+          if (FindInReadable("[Imap]/"_ns, labelNames[i],
+                             nsCaseInsensitiveCStringComparator)) {
+            labelNames[i].ReplaceSubstring("[Imap]/", "");
+            imapRootFolder->FindOnlineSubFolder(labelNames[i],
+                                                getter_AddRefs(subFolder));
+            subMsgFolder = do_QueryInterface(subFolder);
+          }
+          if (!subMsgFolder) {
+            imapRootFolder->FindOnlineSubFolder(labelNames[i],
+                                                getter_AddRefs(subFolder));
+            subMsgFolder = do_QueryInterface(subFolder);
+          }
+          if (subMsgFolder) {
+            nsCOMPtr<nsIMsgDatabase> db;
+            subMsgFolder->GetMsgDatabase(getter_AddRefs(db));
+            if (db) {
+              nsCOMPtr<nsIMsgDBHdr> retHdr;
+              nsCString gmMsgID;
+              hdr->GetStringProperty("X-GM-MSGID", gmMsgID);
+              rv = db->GetMsgHdrForGMMsgID(gmMsgID.get(),
+                                           getter_AddRefs(retHdr));
+              if (NS_FAILED(rv)) return rv;
+              if (retHdr) {
+                uint32_t gmFlags = 0;
+                retHdr->GetFlags(&gmFlags);
+                if ((gmFlags & nsMsgMessageFlags::Offline)) {
+                  subMsgFolder.forget(aMsgFolder);
+                  // Focus on first positive result.
+                  return NS_OK;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsImapMailFolder::GetOfflineFileStream(nsMsgKey msgKey,
+                                                uint64_t* offset,
+                                                uint32_t* size,
+                                                nsIInputStream** aFileStream) {
+  NS_ENSURE_ARG(aFileStream);
+  nsCOMPtr<nsIMsgFolder> offlineFolder;
+  nsresult rv = GetOfflineMsgFolder(msgKey, getter_AddRefs(offlineFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!offlineFolder) return NS_ERROR_FAILURE;
+
+  rv = GetDatabase();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (offlineFolder == this) {
+    return nsMsgDBFolder::GetOfflineFileStream(msgKey, offset, size,
+                                               aFileStream);
+  }
+
+  // The message we want is stored in a different folder (hackery for gmail).
+  nsCOMPtr<nsIMsgDBHdr> hdr;
+  rv = mDatabase->GetMsgHdrForKey(msgKey, getter_AddRefs(hdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString gmMsgID;
+  hdr->GetStringProperty("X-GM-MSGID", gmMsgID);
+  nsCOMPtr<nsIMsgDatabase> db;
+  offlineFolder->GetMsgDatabase(getter_AddRefs(db));
+  rv = db->GetMsgHdrForGMMsgID(gmMsgID.get(), getter_AddRefs(hdr));
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!hdr) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsMsgKey newMsgKey;
+  hdr->GetMessageKey(&newMsgKey);
+
+  // We _know_ it's a nsImapMailFolder.
+  nsImapMailFolder* other = static_cast<nsImapMailFolder*>(offlineFolder.get());
+  return other->GetOfflineFileStream(newMsgKey, offset, size, aFileStream);
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetLocalMsgStream(nsIMsgDBHdr* hdr,
+                                                  nsIInputStream** stream) {
+  nsMsgKey key;
+  hdr->GetMessageKey(&key);
+
+  uint64_t offset = 0;
+  uint32_t size = 0;
+  nsCOMPtr<nsIInputStream> rawStream;
+  nsresult rv =
+      GetOfflineFileStream(key, &offset, &size, getter_AddRefs(rawStream));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<SlicedInputStream> slicedStream =
+      new SlicedInputStream(rawStream.forget(), offset, uint64_t(size));
+  slicedStream.forget(stream);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetIncomingServerType(nsACString& serverType) {
+  serverType.AssignLiteral("imap");
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetShouldUseUtf8FolderName(bool* aUseUTF8) {
+  *aUseUTF8 = false;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  nsresult rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryInterface(server, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  imapServer->GetUtf8AcceptEnabled(aUseUTF8);
+  return NS_OK;
+}
+
+void nsImapMailFolder::DeleteStoreMessages(
+    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages) {
+  // Delete messages for pluggable stores that do not support compaction.
+  nsCOMPtr<nsIMsgPluggableStore> offlineStore;
+  (void)GetMsgStore(getter_AddRefs(offlineStore));
+
+  if (offlineStore) {
+    bool supportsCompaction;
+    offlineStore->GetSupportsCompaction(&supportsCompaction);
+    if (!supportsCompaction) offlineStore->DeleteMessages(aMessages);
+  }
+}
+
+void nsImapMailFolder::DeleteStoreMessages(
+    const nsTArray<nsMsgKey>& aMessages) {
+  DeleteStoreMessages(aMessages, this);
+}
+
+void nsImapMailFolder::DeleteStoreMessages(const nsTArray<nsMsgKey>& aMessages,
+                                           nsIMsgFolder* aFolder) {
+  // Delete messages for pluggable stores that do not support compaction.
+  NS_ASSERTION(aFolder, "Missing Source Folder");
+  nsCOMPtr<nsIMsgPluggableStore> offlineStore;
+  (void)aFolder->GetMsgStore(getter_AddRefs(offlineStore));
+  if (offlineStore) {
+    bool supportsCompaction;
+    offlineStore->GetSupportsCompaction(&supportsCompaction);
+    if (!supportsCompaction) {
+      nsCOMPtr<nsIMsgDatabase> db;
+      aFolder->GetMsgDatabase(getter_AddRefs(db));
+      nsresult rv = NS_ERROR_FAILURE;
+      nsTArray<RefPtr<nsIMsgDBHdr>> messages;
+      if (db) rv = MsgGetHeadersFromKeys(db, aMessages, messages);
+      if (NS_SUCCEEDED(rv))
+        offlineStore->DeleteMessages(messages);
+      else
+        NS_WARNING("Failed to get database");
+    }
+  }
+}