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

60 files changed, 46186 insertions, 0 deletions

diff --git a/mailnews/imap/public/moz.build b/mailnews/imap/public/moz.build
new file mode 100644
index 0000000000..c531cc82bb
--- /dev/null
+++ b/mailnews/imap/public/moz.build
@@ -0,0 +1,32 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPIDL_SOURCES += [
+    'nsIAutoSyncFolderStrategy.idl',
+    'nsIAutoSyncManager.idl',
+    'nsIAutoSyncMsgStrategy.idl',
+    'nsIAutoSyncState.idl',
+    'nsIImapFlagAndUidState.idl',
+    'nsIImapHeaderXferInfo.idl',
+    'nsIImapIncomingServer.idl',
+    'nsIImapMailFolderSink.idl',
+    'nsIImapMessageSink.idl',
+    'nsIImapMockChannel.idl',
+    'nsIImapProtocol.idl',
+    'nsIImapProtocolSink.idl',
+    'nsIImapServerSink.idl',
+    'nsIImapService.idl',
+    'nsIImapUrl.idl',
+    'nsIMailboxSpec.idl',
+    'nsIMsgImapMailFolder.idl',
+]
+
+XPIDL_MODULE = 'msgimap'
+
+EXPORTS += [
+    'nsIIMAPHostSessionList.h',
+    'nsMsgImapCID.h',
+]
+
diff --git a/mailnews/imap/public/nsIAutoSyncFolderStrategy.idl b/mailnews/imap/public/nsIAutoSyncFolderStrategy.idl
new file mode 100644
index 0000000000..d58b6085f1
--- /dev/null
+++ b/mailnews/imap/public/nsIAutoSyncFolderStrategy.idl
@@ -0,0 +1,23 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+#include "nsISupports.idl"
+#include "nsIAutoSyncMsgStrategy.idl"
+
+interface nsIMsgAccount;
+
+[scriptable, uuid(d3bf91cc-37bb-4752-9994-1a8473e46a90)] 
+interface nsIAutoSyncFolderStrategy : nsISupports {
+
+  /**
+   * Returns a relative-priority for the second folder by comparing with the first one.
+   */
+  nsAutoSyncStrategyDecisionType sort(in nsIMsgFolder aFolder1, in nsIMsgFolder aFolder2);
+  
+  /**
+   * Tests whether the given folder should be excluded or not.
+   */
+  boolean isExcluded(in nsIMsgFolder aFolder);
+
+};
diff --git a/mailnews/imap/public/nsIAutoSyncManager.idl b/mailnews/imap/public/nsIAutoSyncManager.idl
new file mode 100644
index 0000000000..0dee48963e
--- /dev/null
+++ b/mailnews/imap/public/nsIAutoSyncManager.idl
@@ -0,0 +1,194 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+#include "nsISupports.idl"
+
+interface nsIAutoSyncMsgStrategy;
+interface nsIAutoSyncFolderStrategy;
+interface nsIMsgDBHdr;
+interface nsIAutoSyncState;
+interface nsIAutoSyncMgrListener;
+interface nsIMsgFolder;
+interface nsIMsgAccount;
+
+[scriptable, uuid(41ec36a7-1a53-4ca3-b698-dca6452a8761)] 
+interface nsIAutoSyncMgrListener : nsISupports {
+
+  /**
+   * Queue types
+   */
+  const long PriorityQueue = 1;
+  const long UpdateQueue = 2;
+  const long DiscoveryQueue = 3;
+
+  /**
+   * It is called on the listener when a new folder is added into
+   * the queue
+   *
+   * @param aQType type of the queue
+   * @param aFolder folder that is added into the queue
+   */
+  void onFolderAddedIntoQ(in long aQType, in nsIMsgFolder aFolder);
+  
+  /**
+   * It is called on the listener when a folder is removed from
+   * the queue
+   *
+   * @param aQType type of the queue
+   * @param aFolder folder that is removed from the queue
+   */
+  void onFolderRemovedFromQ(in long aQType, in nsIMsgFolder aFolder);
+  
+  /**
+   * It is called on the listener when a message download is successfully started
+   *
+   * @param aFolder folder in which the download is started 
+   * @param aNumberOfMessages number of the messages that will be downloaded 
+   * @param aTotalPending  total number of messages waiting to be downloaded 
+   */
+  void onDownloadStarted(in nsIMsgFolder aFolder, in unsigned long aNumberOfMessages, 
+                         in unsigned long aTotalPending);
+  /**
+   * It is called on the listener when a message download on the given folder 
+   * is completed
+   */
+  void onDownloadCompleted(in nsIMsgFolder aFolder);
+  
+  /**
+   * It is called on the listener when an error occurs during the message download
+   */
+  void onDownloadError(in nsIMsgFolder aFolder);
+  
+  /*
+   * Auto-Sync manager is running or waiting for idle 
+   */
+  void onStateChanged(in boolean aRunning);
+  
+  /**
+   * It is called on the listener after the auto-sync manager starts to process 
+   * existing headers of the given folder to find missing message bodies
+   * (mostly for debugging purposes)
+   */
+  void onDiscoveryQProcessed(in nsIMsgFolder aFolder, in unsigned long aNumberOfHdrsProcessed, 
+                             in unsigned long aLeftToProcess);
+  
+  /**
+   * It is called on the listener after the auto-sync manager updates the given folder 
+   * (mostly for debugging purposes)
+   */
+  void onAutoSyncInitiated(in nsIMsgFolder aFolder);
+};
+
+
+[scriptable, uuid(7fe0b48e-f5d8-4747-beb7-888c9cced3a5)]
+interface nsIAutoSyncManager : nsISupports {
+
+  /** 
+   * Download models
+   */
+  const long dmParallel = 0;
+  const long dmChained = 1;
+
+  /**
+   * Suggested minimum grouping size in bytes for message downloads.
+   * Setting this attribute to 0 resets its value to the 
+   * hardcoded default.
+   */
+  attribute unsigned long groupSize;
+
+  /**
+   * Active strategy function to prioritize
+   * messages in the download queue
+   */
+  attribute nsIAutoSyncMsgStrategy msgStrategy;
+
+  /**
+   * Active strategy function to prioritize
+   * folders in the download queue
+   */
+  attribute nsIAutoSyncFolderStrategy folderStrategy;
+
+  /**
+   * Adds a listener to notify about auto-sync events
+   */
+  void addListener(in nsIAutoSyncMgrListener aListener);
+  
+  /**
+   * Removes the listener from notification list
+   */
+  void removeListener(in nsIAutoSyncMgrListener aListener);
+    
+  /**
+   * Tests the given message to make sure that whether 
+   * it fits the download criteria or not
+   */
+  boolean doesMsgFitDownloadCriteria(in nsIMsgDBHdr aMsgHdr);
+  
+  /**
+   * Called by the nsAutoSyncState object when the download
+   * queue is changed. Given interface is already addref'd.
+   */
+  void onDownloadQChanged(in nsIAutoSyncState aAutoSyncStateObj);
+  
+  /**
+   * Called by the nsAutoSyncState object when the download
+   * is started. Given interface is already addref'd.
+   */
+  void onDownloadStarted(in nsIAutoSyncState aAutoSyncStateObj, in nsresult aStartCode);
+  
+  /**
+   * Called by the nsAutoSyncState object when the download
+   * completed. Given interface is already addref'd.
+   */
+  void onDownloadCompleted(in nsIAutoSyncState aAutoSyncStateObj, in nsresult aExitCode);
+  
+  /**
+   * Number of elements in the discovery queue.
+   * @see nsAutoSyncManager.h for details
+   */
+  readonly attribute unsigned long discoveryQLength;
+  
+  /**
+   * Number of elements in the update queue.
+   * @see nsAutoSyncManager.h for details
+   */
+  readonly attribute unsigned long updateQLength;
+  
+  /**
+   * Number of elements in the download queue (a.k.a priority queue).
+   * @see nsAutoSyncManager.h for details
+   */
+  readonly attribute unsigned long downloadQLength;
+
+  /**
+   * Active download model; Chained (serial), or Parallel
+   */
+  attribute long downloadModel;
+
+  /**
+   * The imap folder corresponding to aAutoSyncState has had a message
+   * added to it. Autosync may want to add this folder to the update q.
+   *
+   * @param aAutoSyncState state obj for folder needing updating
+   */
+  void onFolderHasPendingMsgs(in nsIAutoSyncState aAutoSyncState);
+
+  /// Pause autosync (e.g., we're downloading for offline).
+  void pause();
+  
+  /// Resume normal autosync activities (e.g., we've come back online).
+  void resume();
+};
+
+%{C++
+#define NS_AUTOSYNCMANAGER_CID  \
+{ /* C358C568-47B2-42b2-8146-3C0F8D1FAD6E */  \
+  0xc358c568, 0x47b2, 0x42b2,                 \
+  { 0x81, 0x46, 0x3c, 0xf, 0x8d, 0x1f, 0xad, 0x6e }}
+#define NS_AUTOSYNCMANAGER_CLASSNAME \
+  "Auto-Sync Manager"
+#define NS_AUTOSYNCMANAGER_CONTRACTID \
+  "@mozilla.org/imap/autosyncmgr;1"
+%}
+
diff --git a/mailnews/imap/public/nsIAutoSyncMsgStrategy.idl b/mailnews/imap/public/nsIAutoSyncMsgStrategy.idl
new file mode 100644
index 0000000000..93633a2cb5
--- /dev/null
+++ b/mailnews/imap/public/nsIAutoSyncMsgStrategy.idl
@@ -0,0 +1,35 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+#include "nsISupports.idl"
+
+interface nsIMsgFolder;
+interface nsIMsgDBHdr;
+
+typedef long nsAutoSyncStrategyDecisionType;
+
+[scriptable,uuid(0365bec5-3753-43c2-b13e-441747815f37)]
+interface nsAutoSyncStrategyDecisions
+{
+  /// same priority
+  const nsAutoSyncStrategyDecisionType Same         = 0x00000001;
+  /// higher priority
+  const nsAutoSyncStrategyDecisionType Higher       = 0x00000002;
+  /// lower priority
+  const nsAutoSyncStrategyDecisionType Lower        = 0x00000004;
+};
+
+[scriptable, uuid(9cb4baff-3112-4cf8-8463-f81b0aa78f93)] 
+interface nsIAutoSyncMsgStrategy : nsISupports {
+
+  /**
+   * Returns a relative-priority for the second message by comparing with the first message.
+   */
+  nsAutoSyncStrategyDecisionType sort(in nsIMsgFolder aFolder, in nsIMsgDBHdr aMsgHdr1, in nsIMsgDBHdr aMsgHdr2);
+  
+  /**
+   * Tests whether the given message should be excluded or not.
+   */
+  boolean isExcluded(in nsIMsgFolder aFolder, in nsIMsgDBHdr aMsgHdr);
+};
diff --git a/mailnews/imap/public/nsIAutoSyncState.idl b/mailnews/imap/public/nsIAutoSyncState.idl
new file mode 100644
index 0000000000..d03697e11c
--- /dev/null
+++ b/mailnews/imap/public/nsIAutoSyncState.idl
@@ -0,0 +1,130 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIMsgFolder;
+interface nsIArray;
+interface nsIMutableArray;
+
+[scriptable, uuid(7512f927-b8f0-48c4-b101-03e859e61281)]
+interface nsIAutoSyncState : nsISupports {
+
+  /**
+   * Auto-Sync states.
+   *
+   * ***WARNING***: If you change these, be sure to update stateStrings in
+   * nsAutoSyncState.cpp. If you do not, out-of-bounds memory accesses may
+   * happen.
+   */
+
+  /** sync'd and no pending messages */
+  const long stCompletedIdle = 0;     
+
+  /** STATUS issued. Will check to see if  any counts changed since last STATUS */
+  const long stStatusIssued = 1;
+
+  /**
+   * Status found new messages. Update should be issued next. Status most
+   * likely was issued by non-autosync code (e.g., check other folders for
+   * new messages).
+   */
+  const long stUpdateNeeded = 2;
+
+  /** Update issued. Will figure out if there are any bodies to download */
+  const long stUpdateIssued = 3;
+
+  /** Message body download in progress */
+  const long stDownloadInProgress = 4;
+
+  /** ready to download the next group of messages */
+  const long stReadyToDownload = 5;
+
+  /**
+   * Puts the download queue offset to its previous position. 
+   */
+  void rollback();
+  
+  /**
+   * Clears the download queue. Resets the offsets.
+   */
+  void resetDownloadQ();
+  
+  /**
+   * Rollbacks the offset to the previous position and
+   * changes the state to ready-to-download.
+   */
+  void tryCurrentGroupAgain(in unsigned long aRetryCount);
+  
+  /**
+   * Resets the retry counter.
+   */
+  void resetRetryCounter();
+  
+  /**
+   * Tests whether the given folder has the same imap server. 
+   */
+  boolean isSibling(in nsIAutoSyncState aAnotherStateObj);
+
+  /**
+   * Update the folder to find new message headers to download
+   */
+  void updateFolder();
+
+  /**
+   * Downloads the bodies of the given messages from the server.
+   */
+  void downloadMessagesForOffline(in nsIArray aMessageList);
+
+  /**
+   * Populates the given array with the keys of the messages that will 
+   * be downloaded next.
+   *
+   * @param aSuggestedGroupSizeLimit suggested size per group in bytes
+   * @param aActualGroupSize total size of the messages in bytes in the group
+   */
+  nsIMutableArray getNextGroupOfMessages(in unsigned long aSuggestedGroupSizeLimit, 
+                                         out unsigned long aActualGroupSize);
+  
+  /**
+   * Iterates through the existing headers of the folder to find 
+   * the messages not downloaded yet. 
+   *
+   * @param aNumberOfHeadersToProcess number of headers to be processed
+   *                                  at this pass
+   *
+   * @return the number of headers left to process
+   */
+  unsigned long processExistingHeaders(in unsigned long aNumberOfHeadersToProcess);
+
+  /**
+   * Last time the existing headers are completely processed. 
+   */
+  [noscript]readonly attribute PRTime lastSyncTime;
+  
+  /**
+   * Last time the owner folder is updated.
+   */
+  [noscript]attribute PRTime lastUpdateTime;
+  
+  /**
+   * Download operation state. 
+   */
+  attribute long state;
+  
+  /**
+   * Number of messages waiting to be downloaded.
+   */
+  readonly attribute long pendingMessageCount;
+  
+  /**
+   * Total number of messages in the download queue.
+   */
+  readonly attribute long totalMessageCount;
+  
+  /**
+   * The folder this auto-sync object is related to.
+   */
+  readonly attribute nsIMsgFolder ownerFolder;
+};
diff --git a/mailnews/imap/public/nsIIMAPHostSessionList.h b/mailnews/imap/public/nsIIMAPHostSessionList.h
new file mode 100644
index 0000000000..e3ce35d4ff
--- /dev/null
+++ b/mailnews/imap/public/nsIIMAPHostSessionList.h
@@ -0,0 +1,100 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsIImapHostSessionList_H_
+#define _nsIImapHostSessionList_H_
+
+#include "nsISupports.h"
+#include "nsImapCore.h"
+
+class nsIMAPBodyShellCache;
+class nsIMAPBodyShell;
+class nsIImapIncomingServer;
+
+// f4d89e3e-77da-492c-962b-7835f0742c22
+#define NS_IIMAPHOSTSESSIONLIST_IID \
+{ 0xf4d89e3e, 0x77da, 0x492c, {0x96, 0x2b, 0x78, 0x35, 0xf0, 0x74, 0x2c, 0x22 } }
+
+// this is an interface to a linked list of host info's    
+class nsIImapHostSessionList : public nsISupports
+{
+public:
+  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IIMAPHOSTSESSIONLIST_IID)
+
+  // Host List
+  NS_IMETHOD  AddHostToList(const char *serverKey, nsIImapIncomingServer *server) = 0;
+  NS_IMETHOD ResetAll() = 0;
+
+  // Capabilities
+  NS_IMETHOD  GetHostHasAdminURL(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD  SetHostHasAdminURL(const char *serverKey, bool hasAdminUrl) = 0;
+  // Subscription
+  NS_IMETHOD  GetHostIsUsingSubscription(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD  SetHostIsUsingSubscription(const char *serverKey, bool usingSubscription) = 0;
+
+  // Passwords
+  NS_IMETHOD  GetPasswordForHost(const char *serverKey, nsString &result) = 0;
+  NS_IMETHOD  SetPasswordForHost(const char *serverKey, const char *password) = 0;
+  NS_IMETHOD  GetPasswordVerifiedOnline(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD  SetPasswordVerifiedOnline(const char *serverKey) = 0;
+
+  // OnlineDir
+  NS_IMETHOD GetOnlineDirForHost(const char *serverKey,
+                                 nsString &result) = 0;
+  NS_IMETHOD SetOnlineDirForHost(const char *serverKey,
+                                 const char *onlineDir) = 0;
+
+  // Delete is move to trash folder
+  NS_IMETHOD GetDeleteIsMoveToTrashForHost(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD SetDeleteIsMoveToTrashForHost(const char *serverKey, bool isMoveToTrash) = 0;
+  NS_IMETHOD GetShowDeletedMessagesForHost(const char *serverKey, bool &result) = 0;
+
+  NS_IMETHOD SetShowDeletedMessagesForHost(const char *serverKey, bool showDeletedMessages) = 0;
+
+  // Get namespaces
+  NS_IMETHOD GetGotNamespacesForHost(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD SetGotNamespacesForHost(const char *serverKey, bool gotNamespaces) = 0;
+
+  // Folders
+  NS_IMETHOD SetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool discovered) = 0;
+  NS_IMETHOD GetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool &result) = 0;
+
+  // Trash Folder
+  NS_IMETHOD SetOnlineTrashFolderExistsForHost(const char *serverKey, bool exists) = 0;
+  NS_IMETHOD GetOnlineTrashFolderExistsForHost(const char *serverKey, bool &result) = 0;
+  
+  // INBOX
+  NS_IMETHOD  GetOnlineInboxPathForHost(const char *serverKey, nsString &result) = 0;
+  NS_IMETHOD  GetShouldAlwaysListInboxForHost(const char *serverKey, bool &result) = 0;
+  NS_IMETHOD  SetShouldAlwaysListInboxForHost(const char *serverKey, bool shouldList) = 0;
+
+  // Namespaces
+  NS_IMETHOD  GetNamespaceForMailboxForHost(const char *serverKey, const char *mailbox_name, nsIMAPNamespace * & result) = 0;
+  NS_IMETHOD  SetNamespaceFromPrefForHost(const char *serverKey, const char *namespacePref, EIMAPNamespaceType type) = 0;
+  NS_IMETHOD  AddNewNamespaceForHost(const char *serverKey, nsIMAPNamespace *ns) = 0;
+  NS_IMETHOD  ClearServerAdvertisedNamespacesForHost(const char *serverKey) = 0;
+  NS_IMETHOD  ClearPrefsNamespacesForHost(const char *serverKey) = 0;
+  NS_IMETHOD  GetDefaultNamespaceOfTypeForHost(const char *serverKey, EIMAPNamespaceType type, nsIMAPNamespace * & result) = 0;
+  NS_IMETHOD  SetNamespacesOverridableForHost(const char *serverKey, bool overridable) = 0;
+  NS_IMETHOD  GetNamespacesOverridableForHost(const char *serverKey,bool &result) = 0;
+  NS_IMETHOD  GetNumberOfNamespacesForHost(const char *serverKey, uint32_t &result) = 0;
+  NS_IMETHOD  GetNamespaceNumberForHost(const char *serverKey, int32_t n, nsIMAPNamespace * &result) = 0;
+  // ### dmb hoo boy, how are we going to do this?
+  NS_IMETHOD  CommitNamespacesForHost(nsIImapIncomingServer *server) = 0;
+  NS_IMETHOD  FlushUncommittedNamespacesForHost(const char *serverKey, bool &result) = 0;
+  
+  // Hierarchy Delimiters
+  NS_IMETHOD  SetNamespaceHierarchyDelimiterFromMailboxForHost(const char *serverKey, const char *boxName, char delimiter) = 0;
+
+  // Message Body Shells
+  NS_IMETHOD  AddShellToCacheForHost(const char *serverKey, nsIMAPBodyShell *shell) = 0;
+  NS_IMETHOD  FindShellInCacheForHost(const char *serverKey, const char *mailboxName, const char *UID, IMAP_ContentModifiedType modType, nsIMAPBodyShell **result) = 0;
+  NS_IMETHOD  ClearShellCacheForHost(const char *serverKey) = 0;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsIImapHostSessionList,
+                              NS_IIMAPHOSTSESSIONLIST_IID)
+
+#endif
diff --git a/mailnews/imap/public/nsIImapFlagAndUidState.idl b/mailnews/imap/public/nsIImapFlagAndUidState.idl
new file mode 100644
index 0000000000..4a7498b9ba
--- /dev/null
+++ b/mailnews/imap/public/nsIImapFlagAndUidState.idl
@@ -0,0 +1,74 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+[scriptable, uuid(290412eb-5824-4087-8984-05450c9397be)]
+interface nsIImapFlagAndUidState : nsISupports
+{
+  readonly attribute long numberOfMessages;
+  readonly attribute long numberOfRecentMessages;
+
+  /**
+   * If a full update, the total number of deleted messages
+   * in the folder; if a partial update, the number of deleted
+   * messages in the partial update
+   **/
+  readonly attribute long numberOfDeletedMessages;
+
+  /**
+   * If this is true, instead of fetching 1:* (FLAGS), and putting all
+   * UIDs and flags in the array, we only fetched the uids and flags
+   * that changed since the last time we were selected on this folder.
+   * This means we have a sparse array, and should not assume missing
+   * UIDs have been deleted.
+   **/
+  readonly attribute boolean partialUIDFetch;
+
+  /**
+   * Set of flags the server supports storing per message. See nsImapCore.h
+   * for the set of flags.
+   */
+  readonly attribute unsigned short supportedUserFlags;
+
+  /**
+   * OR's the  passed in flags with the previous flags because we want to
+   * accumulate the FLAGS and PERMANENTFLAGS response.
+   *
+   * @param aFlags - flags to OR with current flags.
+   */
+  void orSupportedUserFlags(in unsigned short aFlags);
+
+  void getUidOfMessage(in long zeroBasedIndex, out unsigned long result);
+  void getMessageFlags(in long zeroBasedIndex, out unsigned short result);
+  void setMessageFlags(in long zeroBasedIndex, in unsigned short flags);
+  void expungeByIndex(in unsigned long zeroBasedIndex);
+  void addUidFlagPair(in unsigned long uid, in unsigned short flags, in unsigned long zeroBasedIndex);
+  void addUidCustomFlagPair(in unsigned long uid, in string customFlag);
+  string getCustomFlags(in unsigned long uid); // returns space-separated keywords
+  void reset();
+  void clearCustomFlags(in unsigned long uid);
+  /**
+   * Adds custom attributes to a hash table for the purpose of storing them
+   * them.
+   * @param aUid   UID of the associated msg
+   * @param aCustomAttributeName   Name of the custom attribute value
+   * @param aCustomAttributeValue   Value of the attribute,
+   */
+  void setCustomAttribute(in unsigned long aUid,
+                          in ACString aCustomAttributeName,
+                          in ACString aCustomAttributeValue);
+
+  /**
+   * Gets the custom attributes from the hash table where they were stored earlier
+   * them.
+   * @param aUid   UID of the associated msg
+   * @param aCustomAttributeName   Name of the custom attribute value
+   * @param aCustomAttributeValue   Value of the attribute,
+   */
+  ACString getCustomAttribute(in unsigned long aUid,
+                              in ACString aCustomAttributeName);
+};
+
diff --git a/mailnews/imap/public/nsIImapHeaderXferInfo.idl b/mailnews/imap/public/nsIImapHeaderXferInfo.idl
new file mode 100644
index 0000000000..b2b2e7840f
--- /dev/null
+++ b/mailnews/imap/public/nsIImapHeaderXferInfo.idl
@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "MailNewsTypes2.idl"
+
+[scriptable, uuid(38f8f784-b092-11d6-ba4b-00108335942a)]
+interface nsIImapHeaderInfo : nsISupports {
+    attribute nsMsgKey  msgUid;
+    attribute long      msgSize;
+    [noscript] void getMsgHdrs ([shared] out string aMsgHdrs); // this doesn't copy the msgHdrs
+    void cacheLine(in string line, in unsigned long uid);
+    void resetCache();
+};
+
+[scriptable, uuid(f0842eda-af29-4ecd-82e1-fba91bd65d66)]
+interface nsIImapHeaderXferInfo : nsISupports {
+  readonly attribute long numHeaders;
+  nsIImapHeaderInfo  getHeader(in long hdrIndex);
+};
+
diff --git a/mailnews/imap/public/nsIImapIncomingServer.idl b/mailnews/imap/public/nsIImapIncomingServer.idl
new file mode 100644
index 0000000000..2c687e0f30
--- /dev/null
+++ b/mailnews/imap/public/nsIImapIncomingServer.idl
@@ -0,0 +1,105 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIURI;
+interface nsIImapUrl;
+interface nsIImapProtocol;
+interface nsIMsgFolder;
+interface nsIMsgWindow;
+
+typedef long nsMsgImapDeleteModel;
+
+[scriptable, uuid(bbfc33de-fe89-11d3-a564-0060b0fc04b7)]
+interface nsMsgImapDeleteModels
+{
+  const long IMAPDelete = 0;    /* delete with a big red x */
+  const long MoveToTrash = 1;   /* delete moves message to the trash */
+  const long DeleteNoTrash = 2; /* delete is shift delete - don't create or use trash */
+};
+
+[scriptable, uuid(ea6a0765-07b8-40df-924c-9004ed707251)]
+interface nsIImapIncomingServer : nsISupports {
+
+  attribute long maximumConnectionsNumber;
+  attribute ACString forceSelect;
+  attribute long timeOutLimits;
+  attribute ACString adminUrl;
+  attribute ACString serverDirectory;
+  /// RFC 2971 ID response stored as a pref
+  attribute ACString serverIDPref;
+  attribute boolean cleanupInboxOnExit;
+  attribute nsMsgImapDeleteModel deleteModel;
+  attribute boolean dualUseFolders;
+  attribute long emptyTrashThreshhold;
+  attribute ACString personalNamespace;
+  attribute ACString publicNamespace;
+  attribute ACString otherUsersNamespace;
+  attribute boolean offlineDownload;
+  attribute boolean overrideNamespaces;
+  attribute boolean usingSubscription;
+  attribute ACString manageMailAccountUrl;
+  attribute boolean fetchByChunks;
+  attribute boolean mimePartsOnDemand;
+  attribute boolean sendID;
+  attribute boolean isAOLServer;
+  attribute boolean capabilityACL;
+  attribute boolean capabilityQuota;
+  attribute boolean useIdle;
+  attribute boolean checkAllFoldersForNew;
+
+  /// Is this a GMail Server?
+  attribute boolean isGMailServer;
+
+  /**
+   * See IMAP RFC 4551
+   **/
+  attribute boolean useCondStore;
+
+  /**
+   * See IMAP RFC 4978
+   */
+  attribute boolean useCompressDeflate;
+
+  attribute AString trashFolderName;
+
+  attribute boolean downloadBodiesOnGetNewMail;
+  attribute boolean autoSyncOfflineStores;
+
+  /// Max age of messages we will autosync to, or keep in offline store.
+  attribute long autoSyncMaxAgeDays;
+
+  void GetImapConnectionAndLoadUrl(in nsIImapUrl aImapUrl,
+                                   in nsISupports aConsumer);
+
+  void RemoveConnection(in nsIImapProtocol aImapConnection);
+  void ResetNamespaceReferences();
+  void pseudoInterruptMsgLoad(in nsIMsgFolder aImapFolder, in nsIMsgWindow aMsgWindow, out boolean interrupted);
+  void ResetConnection(in ACString folderName);
+  void CloseConnectionForFolder(in nsIMsgFolder aMsgFolder);
+  void reDiscoverAllFolders();
+  nsIURI subscribeToFolder(in AString name, in boolean subscribe);
+  void GetNewMessagesForNonInboxFolders(in nsIMsgFolder aRootFolder,
+                                        in nsIMsgWindow aWindow,
+                                        in boolean forceAllFolders,
+                                        in boolean performingBiff);
+  /**
+   * Get the password from the nsIMsgIncomingServer. May prompt the user
+   * if there's no password in the password manager or cached in the 
+   * server object.
+   * @param aWindow  msgWindow to associate the password prompt with
+   * @return Password string.
+   * @exception NS_ERROR_FAILURE  The password could not be obtained.
+   * @note NS_MSG_PASSWORD_PROMPT_CANCELLED is a success code that is returned
+   *       if the prompt was presented to the user but the user cancelled the
+   *       prompt.
+   */
+  ACString PromptPassword(in nsIMsgWindow aWindow);
+  attribute boolean doingLsub;
+
+  ACString getUriWithNamespacePrefixIfNecessary(in long namespaceType, in ACString originalUri);
+  attribute boolean shuttingDown;
+};
diff --git a/mailnews/imap/public/nsIImapMailFolderSink.idl b/mailnews/imap/public/nsIImapMailFolderSink.idl
new file mode 100644
index 0000000000..465e72b1d6
--- /dev/null
+++ b/mailnews/imap/public/nsIImapMailFolderSink.idl
@@ -0,0 +1,103 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "MailNewsTypes2.idl"
+
+#include "nsIImapProtocol.idl"
+#include "nsIMailboxSpec.idl"
+
+interface nsIMsgMailNewsUrl;
+interface nsIImapMockChannel;
+interface nsIImapHeaderXferInfo;
+
+typedef long ImapOnlineCopyState;
+
+[scriptable, uuid(5f7484b0-68b4-11d3-a53e-0060b0fc04b7)]
+interface ImapOnlineCopyStateType
+{
+   const long kInProgress = 0;
+   const long kSuccessfulCopy = 1;
+   const long kSuccessfulMove = 2;
+   const long kSuccessfulDelete = 3;
+   const long kFailedDelete = 4;
+   const long kReadyForAppendData = 5;
+   const long kFailedAppend = 6;
+   const long kInterruptedState = 7;
+   const long kFailedCopy = 8;
+   const long kFailedMove = 9;
+};
+
+[scriptable, uuid(525e1278-a39d-46d6-9dbc-b48c7e1d4faa)]
+interface nsIImapMailFolderSink : nsISupports {
+  attribute boolean folderNeedsACLListed;
+  attribute boolean folderNeedsSubscribing;
+  attribute boolean folderNeedsAdded;
+  attribute unsigned long aclFlags;
+  attribute long uidValidity;
+  /**
+   * Whether we have asked the server for this folder's quota information.
+   * If the server supports quotas, this occurs when the folder is opened.
+   */
+  attribute boolean folderQuotaCommandIssued;
+
+  /**
+   * Set FolderQuotaData information
+   * @param aFolderQuotaRoot    The IMAP quota root for this folder, 
+   *                            as returned by the GETQUOTAROOT IMAP command.
+   * @param aFolderQuotaUsedKB  Used space, in KB, on this folder's quota root.
+   * @param aFolderQuotaMaxKB   Size, in KB, of this folder's quota root.
+   **/
+  void setFolderQuotaData(in ACString aFolderQuotaRoot, in unsigned long aFolderQuotaUsedKB, 
+                          in unsigned long aFolderQuotaMaxKB);
+
+  /// Should we download all the rfc822 headers of messages, instead of subset.
+  readonly attribute boolean shouldDownloadAllHeaders;
+  readonly attribute char onlineDelimiter;
+  void OnNewIdleMessages();
+  // Tell mail master about the newly selected mailbox
+  void UpdateImapMailboxInfo(in nsIImapProtocol aProtocol,
+                             in nsIMailboxSpec aSpec);
+  void UpdateImapMailboxStatus(in nsIImapProtocol aProtocol,
+                               in nsIMailboxSpec aSpec);
+  /**
+   * Used when downloading headers in chunks.
+   * @param aSpec Mailbox spec of folder we're downloading headers for.
+   * @returns true if more to download, false otherwise.
+   * @returns total count of headers to download (across all chunks)
+   * @returns an array of msg keys to download, array size is this chunk's size
+   */
+  void getMsgHdrsToDownload(out boolean aMore, out long aTotalCount,
+                            out unsigned long aCount,
+                            [retval, array, size_is(aCount)] out nsMsgKey aKeys);
+  void parseMsgHdrs(in nsIImapProtocol aProtocol, in nsIImapHeaderXferInfo aHdrXferInfo);
+  void AbortHeaderParseStream(in nsIImapProtocol aProtocol) ;
+  
+  void OnlineCopyCompleted(in nsIImapProtocol aProtocol, in ImapOnlineCopyState aCopyState);
+  void StartMessage(in nsIMsgMailNewsUrl aUrl);
+  void EndMessage(in nsIMsgMailNewsUrl aUrl, in nsMsgKey uidOfMessage);
+
+  void NotifySearchHit(in nsIMsgMailNewsUrl aUrl, in string hitLine);
+
+  void copyNextStreamMessage(in boolean copySucceeded, in nsISupports copyState);
+  void closeMockChannel(in nsIImapMockChannel aChannel);
+  void setUrlState(in nsIImapProtocol aProtocol, in nsIMsgMailNewsUrl aUrl,
+                   in boolean isRunning, in boolean aSuspend,
+                   in nsresult status);
+  void releaseUrlCacheEntry(in nsIMsgMailNewsUrl aUrl);
+
+  void headerFetchCompleted(in nsIImapProtocol aProtocol);
+  void setBiffStateAndUpdate(in long biffState);
+  void progressStatusString(in nsIImapProtocol aProtocol, in string aMsgId, in wstring extraInfo);
+  void percentProgress(in nsIImapProtocol aProtocol, in wstring aMessage, 
+                       in long long aCurrentProgress, in long long aMaxProgressProgressInfo);
+
+  void clearFolderRights();
+  void setCopyResponseUid(in string msgIdString,
+                                in nsIImapUrl aUrl);
+  void setAppendMsgUid(in nsMsgKey newKey,
+                             in nsIImapUrl aUrl);
+  ACString getMessageId(in nsIImapUrl aUrl);
+};
diff --git a/mailnews/imap/public/nsIImapMessageSink.idl b/mailnews/imap/public/nsIImapMessageSink.idl
new file mode 100644
index 0000000000..420ea76423
--- /dev/null
+++ b/mailnews/imap/public/nsIImapMessageSink.idl
@@ -0,0 +1,80 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "MailNewsTypes2.idl"
+#include "nsIImapUrl.idl"
+
+interface nsIMsgMailNewsUrl;
+
+[scriptable, uuid(6ffb6a92-e43a-405f-92ea-92cf81a5e17b)]
+
+interface nsIImapMessageSink : nsISupports {
+  // set up messge download output stream
+  void setupMsgWriteStream(in nsIFile aFile, in boolean aAppendDummyEnvelope);
+
+  /**
+   * Used by the imap protocol code to notify the core backend code about
+   * downloaded imap messages.
+   *
+   * @param aAdoptedMsgLine  a string with a lot of message lines,
+   *                         separated by native line terminators.
+   * @param aUidOfMsg        IMAP UID of the fetched message.
+   * @param aImapUrl         IMAP Url used to fetch the message.
+   */
+  void parseAdoptedMsgLine(in string aAdoptedMsgLine, in nsMsgKey aUidOfMsg,
+                           in nsIImapUrl aImapUrl);
+
+  /**
+   * Notify the backend that the imap protocol is done downloading a message
+   *
+   * @param aUidOfMsg           IMAP UID of the fetched message.
+   * @param aMarkMsgRead        Set the SEEN flag on the message.
+   * @param aImapUrl            IMAP Url used to fetch the message.
+   * @param aUpdatedMessageSize if this parameter is not -1, the stored size of the message
+   *                            should be set to this value to reflect the actual size of
+   *                            the downloaded message.
+   */
+  void normalEndMsgWriteStream(in nsMsgKey aUidOfMessage,
+                               in boolean aMarkMsgRead, in nsIImapUrl aImapUrl,
+                               in long aUpdatedMessageSize);
+
+  void abortMsgWriteStream();
+
+  void beginMessageUpload();
+
+  /**
+   *  Notify the message sink that one or more flags have changed
+   *  For Condstore servers, also update the highestMod Sequence
+   *  @param   aFlags         - The new flags for the message
+   *  @param   aKeywords        keywords for the message
+   *  @param   aMessageKey    - The UID of the message that changed
+   *  @param   aHighestModSeq - The highest mod seq the parser has seen
+   *                            for this folder
+  **/
+  void notifyMessageFlags(in unsigned long aFlags, in ACString aKeywords,
+                          in nsMsgKey aMessageKey,
+                          in unsigned long long aHighestModSeq);
+
+  void notifyMessageDeleted(in string aOnlineFolderName,in boolean aDeleteAllMsgs,in string aMsgIdString);
+
+  void getMessageSizeFromDB(in string aId, out unsigned long aSize);
+
+  void setContentModified(in nsIImapUrl aImapUrl, in nsImapContentModifiedType aModified);
+  
+  /**
+   * For a message stored in a file, get the message metadata needed to copy
+   * that message to an imap folder
+   *
+   * @param aRunningUrl  message URL
+   * @param aDate        message date
+   * @param aKeywords    message custom keywords (if supported by the server),
+   *                     including messages tags and junk status
+   *
+   * @return             message flags
+   */
+  unsigned long getCurMoveCopyMessageInfo(in nsIImapUrl aRunningUrl, 
+                                          out PRTime aDate, out ACString aKeywords);
+};
diff --git a/mailnews/imap/public/nsIImapMockChannel.idl b/mailnews/imap/public/nsIImapMockChannel.idl
new file mode 100644
index 0000000000..ab4e6b996b
--- /dev/null
+++ b/mailnews/imap/public/nsIImapMockChannel.idl
@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+/*
+    Because imap protocol connections (which are channels) run through a cache,
+    it isn't always the case that when you want to run a url, you actually get
+    a connection back right away. Often times, the url goes into a queue until
+    a connection becomes available.
+
+    Unfortunately, if we want to be a truly pluggable protocol with necko, necko
+    requires the ability to get a channel back right away when it wants to run 
+    a url. It doesn't let you wait until an imap connection becomes available.
+
+    So I've created the notion of a "mock channel". This mock channel is what
+    gets returned to necko (or other callers) when they ask the imap service
+    for a new channel for a url. The mock channel has "mock" implementations
+    of nsIChannel. Eventually, when we actually assign the url to a real
+    channel, we set the real channel on the mock channel. From that point forward,
+    the mock channel forwards channel calls directly to the real channel.
+
+    In short, this class is how I'm solving the problem where necko wants
+    a channel back as soon as they ask for when with the fact that it
+    may be a while until the url is loaded into a connection.
+ */
+
+#include "nsISupports.idl"
+#include "nsIChannel.idl"
+
+interface nsIStreamListener;
+interface nsIProgressEventSink;
+interface nsIURI;
+interface nsIImapProtocol;
+
+[scriptable, uuid(e0178cd5-d37b-4bde-9ab8-752083536225)]
+
+interface nsIImapMockChannel : nsIChannel
+{
+  attribute nsIProgressEventSink progressEventSink;
+  void GetChannelListener(out nsIStreamListener aChannelListener);
+  void GetChannelContext(out nsISupports aChannelContext);
+  void Close();
+  void setImapProtocol(in nsIImapProtocol aProtocol);
+  [noscript] void setSecurityInfo(in nsISupports securityInfo);
+
+  void setURI(in nsIURI uri);
+};
diff --git a/mailnews/imap/public/nsIImapProtocol.idl b/mailnews/imap/public/nsIImapProtocol.idl
new file mode 100644
index 0000000000..83b19a4990
--- /dev/null
+++ b/mailnews/imap/public/nsIImapProtocol.idl
@@ -0,0 +1,71 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIURI;
+interface nsIImapUrl;
+interface nsIImapProtocol;
+interface nsIImapIncomingServer;
+interface nsIMsgFolder;
+interface nsIImapHostSessionList;
+interface nsIMsgWindow;
+interface nsIImapFlagAndUidState;
+
+[scriptable, uuid(290412eb-5824-4087-8984-05450c9397be)]
+interface nsIImapProtocol : nsISupports {
+  void LoadImapUrl(in nsIURI aUrl, in nsISupports aConsumer);
+
+  /**
+   * IsBusy returns true if the connection is currently processing a url
+   * and false otherwise.
+   */
+  void IsBusy(out boolean aIsConnectionBusy,
+              out boolean isInboxConnection);
+
+  /** Protocol instance examines the url, looking at the host name,
+   * user name and folder the action would be on in order to figure out
+   * if it can process this url. I decided to push the semantics about
+   * whether a connection can handle a url down into the connection level
+   * instead of in the connection cache.
+   */
+  void CanHandleUrl(in nsIImapUrl aImapUrl, out boolean aCanRunUrl,
+                    out boolean hasToWait);
+
+  /**
+   * Initialize a protocol object.
+   * @param aHostSessionList host session list service
+   * @param aServer imap server the protocol object will be talking to
+   */
+  void Initialize(in nsIImapHostSessionList aHostSessionList, in nsIImapIncomingServer aServer);
+
+  void NotifyBodysToDownload(out unsigned long keys, in unsigned long count);
+  // methods to get data from the imap parser flag state.
+  void GetFlagsForUID(in unsigned long uid, out boolean foundIt, out unsigned short flags, out string customFlags);
+  void GetSupportedUserFlags(out unsigned short flags);
+
+  void GetRunningImapURL(out nsIImapUrl aImapUrl);
+
+  void GetRunningUrl(out nsIURI aUrl);
+
+  readonly attribute nsIImapFlagAndUidState flagAndUidState;
+  /**
+   * Tell thread to die - only call from the UI thread
+   *
+   * @param aIsSafeToClose false if we're dropping a timed out connection.
+   */
+  void tellThreadToDie(in boolean aIsSafeToClose);
+
+  // Get last active time stamp
+  void GetLastActiveTimeStamp(out PRTime aTimeStamp);
+
+  void pseudoInterruptMsgLoad(in nsIMsgFolder imapFolder, in nsIMsgWindow aMsgWindow, out boolean interrupted);
+  void GetSelectedMailboxName(out string folderName);
+  // Reset folder connection to authenticated state
+  void ResetToAuthenticatedState();
+
+  void OverrideConnectionInfo(in wstring pHost, in unsigned short pPort, in string pCookieData);
+};
+
diff --git a/mailnews/imap/public/nsIImapProtocolSink.idl b/mailnews/imap/public/nsIImapProtocolSink.idl
new file mode 100644
index 0000000000..07b5330650
--- /dev/null
+++ b/mailnews/imap/public/nsIImapProtocolSink.idl
@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+interface nsIMsgWindow;
+interface nsIMsgMailNewsUrl;
+
+/**
+ * Helper interface that contains operations MUST be proxied
+ * over UI thread.
+ */
+[scriptable, uuid(1217cd9d-7678-4026-b323-0d4b45816af0)]
+interface nsIImapProtocolSink : nsISupports {
+  
+  /**
+   * Does general cleanup for the imap protocol object.
+   */
+  void closeStreams();
+  /**
+   * Get the msg window associated with a url
+   *
+   * @param aUrl url whose msgWindow we want.
+   * @returns msgWindow associated with url.
+   */
+  nsIMsgWindow getUrlWindow(in nsIMsgMailNewsUrl aUrl);
+
+  /**
+   * Setup main thread proxies.
+   */
+  void setupMainThreadProxies();
+};
diff --git a/mailnews/imap/public/nsIImapServerSink.idl b/mailnews/imap/public/nsIImapServerSink.idl
new file mode 100644
index 0000000000..77fdcb2d97
--- /dev/null
+++ b/mailnews/imap/public/nsIImapServerSink.idl
@@ -0,0 +1,169 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "MailNewsTypes2.idl"
+
+interface nsIMsgWindow;
+interface nsIMsgMailNewsUrl;
+interface nsIImapProtocol;
+interface nsIImapUrl;
+interface nsIImapMockChannel;
+
+/**
+ * nsIImapServerSink is designed to be used as a proxy to the application's UI
+ * thread from the running IMAP threads.
+ */
+[scriptable, uuid(2160c641-e4fa-4bbc-ab8b-d9ba45069027)]
+interface nsIImapServerSink : nsISupports {
+  /**
+   * Check if the given folder path is a possible IMAP mailbox.
+   * @param folderPath folder path to check
+   * @param hierarchyDelimiter IMAP hierarchy delimiter in canonical format,
+   *                           i.e., hierarchy delimiter has been replaced
+   *                           with '/'
+   * @param boxFlags IMAP folder flags (for subscription, namespaces etc.)
+   * @return true if it's a new mailbox
+   */
+  boolean possibleImapMailbox(in ACString folderPath,
+                              in char hierarchyDelimiter, in long boxFlags);
+  boolean folderNeedsACLInitialized(in ACString folderPath);
+  void addFolderRights(in ACString folderPath, in ACString userName, in ACString rights);
+  void refreshFolderRights(in ACString folderPath);
+  void discoveryDone();
+  void onlineFolderDelete(in ACString folderName);
+  void onlineFolderCreateFailed(in ACString aFolderName);
+  void onlineFolderRename(in nsIMsgWindow msgWindow, in ACString oldName, in ACString newName);
+  boolean folderIsNoSelect(in ACString folderName);
+  void setFolderAdminURL(in ACString folderName, in ACString adminUrl);
+  boolean folderVerifiedOnline(in ACString folderName);
+
+  void setCapability(in unsigned long long capability);
+  /// RFC 2971 ID server response
+  void setServerID(in ACString aServerID);
+  boolean loadNextQueuedUrl(in nsIImapProtocol protocol);
+
+  /**
+   * Prepare to retry the given URL.
+   * @param imapUrl the url we're going to retry
+   * @return channel to associate with the url. We return this because access
+   *         to the channel should only happen on the ui thread.
+   */
+  nsIImapMockChannel prepareToRetryUrl(in nsIImapUrl imapUrl);
+
+  /**
+   * Suspend the url. This puts it at the end of the queue. If the queue is
+   * empty, the url will get resumed immediately. Currently, the plan is
+   * do this when we have to download a lot of headers in chunks, though we
+   * could find other uses for it.
+   * @param imapUrl url to suspend
+   */
+  void suspendUrl(in nsIImapUrl aImapUrl);
+
+  /**
+   * Retry the given URL.
+   * @param imapUrl url to retry
+   * @param channel the channel to associate with the url
+   */
+  void retryUrl(in nsIImapUrl imapUrl, in nsIImapMockChannel channel);
+
+  /**
+   * If previous URL failed, this gives server chance to abort URLs with same
+   * mock channel.
+   */
+  void abortQueuedUrls();
+  AString getImapStringByName(in string msgName);
+  /**
+   * Alerts the user that the login to the IMAP server failed. Asks whether the
+   * connection should: retry, cancel, or request a new password.
+   *
+   * @param aMsgWindow The message window associated with this action (cannot
+   *                   be null).
+   * @return           The button pressed. 0 for retry, 1 for cancel,
+   *                   2 for enter a new password.
+   */
+  int32_t promptLoginFailed(in nsIMsgWindow aMsgWindow);
+
+  /**
+   * Alerts the user with the given string (FE = 'Front End').
+   *
+   * @param aAlertString The string to alert the user with.
+   * @param aUrl         The running url.
+   */
+  void fEAlert(in AString aAlertString, in nsIMsgMailNewsUrl aUrl);
+
+  /**
+   * Alerts the user with a localized string. It will attempt to fill in
+   * the hostname into the string if necessary.
+   *
+   * @param aMsgName  The id of the string to present to the user..
+   * @param aUrl    The running url.
+   */
+  void fEAlertWithName(in string aMsgName, in nsIMsgMailNewsUrl aUrl);
+  /**
+   * Takes a response from the server and prepends it with IMAP_SERVER_SAID 
+   *
+   * @param aServerString  The string to alert the user with.
+   * @param url            The running url.
+   */
+  void fEAlertFromServer(in ACString aServerString, in nsIMsgMailNewsUrl aUrl);
+
+  void commitNamespaces();
+
+  /**
+   * Returns a password via the out param, if we were able to prompt for one,
+   * or had one stored.
+   * If there is already a password prompt up, we return false, but we
+   * ask the async prompt service to notify us when we can put up a prompt.
+   * When that notification is received, we prompt the user and set the
+   * password on the protocol object, and signal a monitor that the imap
+   * thread should be waiting on.
+   *
+   * rv is NS_MSG_PASSWORD_PROMPT_CANCELLED if the user cancels the
+   * password prompt. That's not an exception, however.
+   *
+   * @param aProtocol imap protocol object requesting the password.
+   * @param aNewPasswordRequested Forces password prompt immediately
+   * @param aPassword returns the password, unless we had to prompt or use the,
+   *                  login manager and there was already a prompt up.
+   */
+  void asyncGetPassword(in nsIImapProtocol aProtocol,
+                        in boolean aNewPasswordRequested,
+                        out ACString aPassword);
+
+  attribute boolean userAuthenticated;
+  void setMailServerUrls(in ACString manageMailAccount, in ACString manageLists, in ACString manageFilters);
+
+  /** Used by the imap thread when upgrading from the socketType
+   * trySTARTTLS.
+   * @param aSucceeded whether STARTTLS succeeded. If it did, the server
+   * will set the socket type to alwaysSTARTTLS, otherwise plain.
+   */
+  void UpdateTrySTARTTLSPref(in boolean aSucceeded);
+
+  readonly attribute ACString arbitraryHeaders;
+  void forgetPassword();
+
+  readonly attribute boolean showAttachmentsInline;
+  string cramMD5Hash(in string decodedChallenge, in string key);
+  /// String to send to the imap server as the login user name.
+  readonly attribute ACString loginUsername;
+  /// String to send to the imap server as the user name.
+  readonly attribute ACString originalUsername;
+  /// Internal pref key, unique over all servers
+  readonly attribute ACString serverKey;
+  /// password for server login
+  readonly attribute ACString serverPassword;
+  /// remove a connection to the server
+  void removeServerConnection(in nsIImapProtocol aProtocol);
+  /// is the imap server shutting down?
+  readonly attribute boolean serverShuttingDown;
+  /// reset the connection for a particular folder
+  void resetServerConnection(in ACString aFolderName);
+  /// tell the server if listing using lsub command
+  void setServerDoingLsub(in boolean aDoingLsub);
+  /// set force select string
+  void SetServerForceSelect(in ACString forceSelect);
+};
diff --git a/mailnews/imap/public/nsIImapService.idl b/mailnews/imap/public/nsIImapService.idl
new file mode 100644
index 0000000000..0a8521ee6c
--- /dev/null
+++ b/mailnews/imap/public/nsIImapService.idl
@@ -0,0 +1,258 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The IMAP Service is an interfaced designed to make building and running imap urls
+// easier. Clients typically go to the imap service and ask it do things such as:
+// get new mail, etc....
+//
+// Oh and in case you couldn't tell by the name, the imap service is a service! and you
+// should go through the service manager to obtain an instance of it.
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include "nsISupports.idl"
+#include "nsIImapUrl.idl"
+
+interface nsIImapMessageSink;
+interface nsIUrlListener;
+interface nsIURI;
+interface nsIFile;
+interface nsIMsgFolder;
+interface nsIMsgWindow;
+interface nsIImapIncomingServer;
+interface nsICacheStorage;
+
+[scriptable, uuid(aba44b3d-7a0f-4987-8794-96d2de66d966)]
+interface nsIImapService : nsISupports
+{
+  // You can pass in null for the url listener and the url if you don't require either.....
+  void selectFolder(in nsIMsgFolder aImapMailFolder,
+                    in nsIUrlListener aUrlListener,
+                    in nsIMsgWindow   aMsgWindow,
+                    out nsIURI aURL);
+
+  /**
+   * Select the folder on the imap server without doing a sync of flags or
+   * headers. This is used for offline playback, where we don't want to
+   * download hdrs we don't have, because they may have been offline deleted.
+   *
+   * @param aImapMailFolder     the folder to select
+   * @param aUrlListener        url listener, can be null
+   * @param aMsgWindow          msg window url is running in, can be null
+   *
+   * @returns the url created to run the lite select in.
+   */
+  nsIURI liteSelectFolder(in nsIMsgFolder aImapMailFolder,
+                          in nsIUrlListener aUrlListener,
+                          in nsIMsgWindow aMsgWindow);
+
+  void addImapFetchToUrl(in nsIURI aURL,
+                         in nsIMsgFolder aImapMailFolder,
+                         in ACString aMessageIdentifierList,
+                         in ACString aAdditionalHeader);
+
+  void fetchMessage(in nsIImapUrl aUrl,
+                    in nsImapState aImapAction,
+                    in nsIMsgFolder aImapMailFolder,
+                    in nsIImapMessageSink aImapMessageSink,
+                    in nsIMsgWindow aMsgWindow,
+                    in nsISupports aConsumer,
+                    in ACString aMessageIdentifierList,
+                    in boolean convertDataToText,
+                    in ACString additionalHeader,
+                    out nsIURI aOutURL);
+
+  void noop(in nsIMsgFolder aImapMailFolder,
+            in nsIUrlListener aUrlListener,
+            out nsIURI aURL);
+
+  void getHeaders(in nsIMsgFolder aImapMailFolder,
+                  in nsIUrlListener aUrlListener,
+                  out nsIURI aURL,
+                  in ACString aMessageIdentifierList,
+                  in boolean aMessageIdsAreUID);
+
+  nsIURI getBodyStart(in nsIMsgFolder aImapMailFolder,
+                      in nsIUrlListener aUrlListener,
+                      in ACString aMessageIdentifierList,
+                      in long numBytes);
+
+  /**
+   * Issue an EXPUNGE on the target folder.
+   *
+   * @param aImapMailFolder     the folder to expunge
+   * @param aUrlListener        url listener, can be null
+   * @param aMsgWindow          msg window url is running in, can be null
+   *
+   * @returns the url created to run the expunge.
+   */
+  void expunge(in nsIMsgFolder aImapMailFolder,
+               in nsIUrlListener aUrlListener,
+               in nsIMsgWindow aMsgWindow,
+               out nsIURI aURL);
+
+  /**
+   * Issue a STATUS on the target folder.
+   *
+   * @param aImapMailFolder     the folder to expunge
+   * @param aUrlListener        url listener, can be null
+   *
+   * @returns the url created to run the status.
+   */
+  nsIURI updateFolderStatus(in nsIMsgFolder aImapMailFolder,
+                            in nsIUrlListener aUrlListener);
+
+  /**
+   * Verify that we can login.
+   *
+   * @param aImapMailFolder - any old imap folder - we just need it to
+   *                          set url sinks.
+   * @param aMsgWindow    - nsIMsgWindow to use for notification callbacks.
+   * @return - the url that we run.
+   */
+  nsIURI verifyLogon(in nsIMsgFolder aImapMailFolder,
+                     in nsIUrlListener aUrlListener,
+                     in nsIMsgWindow aMsgWindow);
+
+  void biff(in nsIMsgFolder aImapMailFolder,
+            in nsIUrlListener aUrlListener,
+            out nsIURI aURL,
+            in unsigned long aUidHighWater);
+
+  void deleteMessages(in nsIMsgFolder aImapMailFolder,
+                      in nsIUrlListener aUrlListener,
+                      out nsIURI aURL,
+                      in ACString aMessageIdentifierList,
+                      in boolean aMessageIdsAreUID);
+
+  void deleteAllMessages(in nsIMsgFolder aImapMailFolder,
+                         in nsIUrlListener aUrlListener,
+                         out nsIURI aURL);
+
+  void addMessageFlags(in nsIMsgFolder aImapMailFolder,
+                       in nsIUrlListener aUrlListener,
+                       out nsIURI aURL,
+                       in ACString aMessageIdentifierList,
+                       in imapMessageFlagsType aFlags,
+                       in boolean aMessageIdsAreUID);
+
+  void subtractMessageFlags(in nsIMsgFolder aImapMailFolder,
+                            in nsIUrlListener aUrlListener,
+                            out nsIURI aURL,
+                            in ACString aMessageIdentifierList,
+                            in imapMessageFlagsType aFlags,
+                            in boolean aMessageIdsAreUID);
+
+  void setMessageFlags(in nsIMsgFolder aImapMailFolder,
+                       in nsIUrlListener aUrlListener,
+                       out nsIURI aURL,
+                       in ACString aMessageIdentifierList,
+                       in imapMessageFlagsType aFlags,
+                       in boolean aMessageIdsAreUID);
+
+  void discoverAllFolders(in nsIMsgFolder aImapMailFolder,
+                          in nsIUrlListener aUrlListener,
+                          in nsIMsgWindow aMsgWindow,
+                          out nsIURI aURL);
+
+  void discoverAllAndSubscribedFolders(in nsIMsgFolder aImapMailFolder,
+                                       in nsIUrlListener aUrlListener,
+                                       out nsIURI aURL);
+
+  void discoverChildren(in nsIMsgFolder aImapMailFolder,
+                        in nsIUrlListener aUrlListener,
+                        in ACString folderPath,
+                        out nsIURI aURL);
+
+  void onlineMessageCopy(in nsIMsgFolder aSrcFolder,
+                         in ACString aMessageIds,
+                         in nsIMsgFolder aDstFolder,
+                         in boolean aIdsAreUids,
+                         in boolean aIsMove,
+                         in nsIUrlListener aUrlListener,
+                         out nsIURI aURL,
+                         in nsISupports aCopyState,
+                         in nsIMsgWindow aWindow);
+
+
+  void appendMessageFromFile(in nsIFile aFile,
+                             in nsIMsgFolder aDstFolder,
+                             in ACString aMessageId,
+                             in boolean idsAreUids,
+                             in boolean aInSelectedState,
+                             in nsIUrlListener aUrlListener,
+                             out nsIURI aURL,
+                             in nsISupports aCopyState,
+                             in nsIMsgWindow aMsgWindow);
+
+  void downloadMessagesForOffline(in ACString aMessageIds, in nsIMsgFolder aSrcFolder,
+                      in nsIUrlListener aListener, in nsIMsgWindow   aMsgWindow);
+
+  nsIURI moveFolder(in nsIMsgFolder aSrcFolder,
+                    in nsIMsgFolder aDstFolder,
+                    in nsIUrlListener aUrlListener,
+                    in nsIMsgWindow msgWindow);
+
+  nsIURI renameLeaf(in nsIMsgFolder aSrcFolder,
+                    in AString aLeafName,
+                    in nsIUrlListener aUrlListener,
+                    in nsIMsgWindow msgWindow);
+
+  nsIURI deleteFolder(in nsIMsgFolder aFolder,
+                      in nsIUrlListener aUrlListener,
+                      in nsIMsgWindow aMsgWindow);
+
+  nsIURI createFolder(in nsIMsgFolder aParentFolder,
+                      in AString aLeafName,
+                      in nsIUrlListener aUrlListener);
+
+  nsIURI listFolder(in nsIMsgFolder aMailFolder,
+                    in nsIUrlListener aUrlListener);
+
+  nsIURI subscribeFolder(in nsIMsgFolder aMailFolder,
+                         in AString mailboxName,
+                         in nsIUrlListener aUrlListener);
+
+  nsIURI unsubscribeFolder(in nsIMsgFolder aMailFolder,
+                           in AString mailboxName,
+                           in nsIUrlListener aUrlListener);
+
+  // this method will first check if the folder exists but is
+  // not subscribed to, in which case it will subscribe to the folder.
+  // otherwise, it will try to create the folder. It will try to do this
+  // with one url.
+  nsIURI ensureFolderExists(in nsIMsgFolder aParentFolder,
+                            in AString aLeafName,
+                            in nsIUrlListener aUrlListener);
+
+
+  nsIURI getFolderAdminUrl(in nsIMsgFolder aMailFolder,
+                           in nsIMsgWindow   aMsgWindow,
+                           in nsIUrlListener aUrlListener);
+
+  nsIURI issueCommandOnMsgs(in nsIMsgFolder aMailFolder,
+                            in nsIMsgWindow aMsgWindow,
+                            in ACString aCommand,
+                            in ACString aMessageIdentifierList);
+
+  nsIURI fetchCustomMsgAttribute(in nsIMsgFolder aMailFolder,
+                                 in nsIMsgWindow aMsgWindow,
+                                 in ACString aAttribute,
+                                 in ACString aMessageIdentifierList);
+
+  nsIURI storeCustomKeywords(in nsIMsgFolder aMailFolder,
+                             in nsIMsgWindow aMsgWindow,
+                             in ACString flagsToAdd,
+                             in ACString flagsToSubtract,
+                             in ACString aMessageIdentifierList);
+
+  void getListOfFoldersOnServer(in nsIImapIncomingServer aServer, in nsIMsgWindow aMsgWindow);
+  void getListOfFoldersWithPath(in nsIImapIncomingServer aServer, in nsIMsgWindow aMsgWindow, in ACString folderPath);
+
+  nsISupports playbackAllOfflineOperations(in nsIMsgWindow aMsgWindow, in nsIUrlListener aListener);
+  void downloadAllOffineImapFolders(in nsIMsgWindow aMsgWindow, in nsIUrlListener aListener);
+
+  readonly attribute nsICacheStorage cacheStorage;
+};
diff --git a/mailnews/imap/public/nsIImapUrl.idl b/mailnews/imap/public/nsIImapUrl.idl
new file mode 100644
index 0000000000..03d0e03e0b
--- /dev/null
+++ b/mailnews/imap/public/nsIImapUrl.idl
@@ -0,0 +1,207 @@
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIImapMailFolderSink;
+interface nsIImapMessageSink;
+interface nsIImapServerSink;
+interface nsIImapMockChannel;
+interface nsIFile;
+
+typedef long nsImapAction;
+typedef long nsImapState;
+
+typedef unsigned short imapMessageFlagsType;
+
+typedef long nsImapContentModifiedType;
+
+[scriptable, uuid(2e91901e-ff6c-11d3-b9fa-00108335942a)]
+interface nsImapContentModifiedTypes
+{
+  const long IMAP_CONTENT_NOT_MODIFIED = 0;
+  const long IMAP_CONTENT_MODIFIED_VIEW_INLINE = 1;
+  const long IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS = 2;
+  const long IMAP_CONTENT_FORCE_CONTENT_NOT_MODIFIED = 3;
+} ;
+
+[scriptable, uuid(fe2a8f9e-2886-4146-9896-27fff660c69f)]
+interface nsIImapUrl : nsISupports
+{
+  ///////////////////////////////////////////////////////////////////////////////
+  // Getters and Setters for the imap specific event sinks to bind to to the url
+  ///////////////////////////////////////////////////////////////////////////////
+  attribute nsIImapMailFolderSink imapMailFolderSink;
+  attribute nsIImapMessageSink imapMessageSink;
+  attribute nsIImapServerSink imapServerSink;
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Getters and Setters for the imap url state
+  ///////////////////////////////////////////////////////////////////////////////
+  attribute nsImapAction imapAction;
+  readonly attribute nsImapState requiredImapState;
+  readonly attribute string imapPartToFetch;
+  readonly attribute ACString customAttributeToFetch;
+  attribute ACString customAttributeResult;
+  readonly attribute ACString command;
+  attribute ACString customCommandResult;
+  readonly attribute ACString customAddFlags;
+  readonly attribute ACString customSubtractFlags;
+  void allocateCanonicalPath(in string aServerPath, in char aOnlineDelimiter, out string aAllocatedPath);
+  void allocateServerPath(in string aCanonicalPath, in char aOnlineDelimiter, out string aAllocatedPath);
+  string createServerSourceFolderPathString();
+  string createCanonicalSourceFolderPathString();
+  string createServerDestinationFolderPathString();
+
+  string addOnlineDirectoryIfNecessary(in string onlineMailboxName);
+  void createSearchCriteriaString (out string aResult);
+  readonly attribute ACString listOfMessageIds;
+
+  boolean messageIdsAreUids();
+  readonly attribute imapMessageFlagsType msgFlags; // kAddMsgFlags or kSubtractMsgFlags only
+
+  readonly attribute long numBytesToFetch;
+  attribute char onlineSubDirSeparator;
+  attribute boolean allowContentChange;
+  attribute boolean mimePartSelectorDetected;
+  attribute nsImapContentModifiedType contentModified;
+  attribute boolean fetchPartsOnDemand;  // set to true if we're fetching a msg for display and want to not download parts
+  attribute boolean msgLoadingFromCache; // true if this msg load is coming from a cache, so we can know to mark it read
+  attribute boolean externalLinkUrl; // true if we ran this url because the user clicked on a link.
+  attribute boolean validUrl; // false if we couldn't parse url for whatever reason.
+  attribute nsISupports copyState;
+  attribute nsIFile msgFile;
+  attribute nsIImapMockChannel mockChannel;
+  /**
+   * Set to true if we should store the msg(s) for offline use if we can,
+   * e.g., we're fetching a message and the folder is configured for offline
+   * use and we're not doing mime parts on demand.
+   */
+  attribute boolean storeResultsOffline;
+  /**
+   * If we fallback from fetching by parts to fetching the whole message,
+   *  because all the parts were inline, this tells us we should store
+   * the message offline.
+   */
+  attribute boolean storeOfflineOnFallback;
+
+  /**
+   * This attribute defaults to false, but if we only want to use the offline
+   * cache (disk, memory, or offline store) to fetch the message, then we set
+   * this to true. Currently, nsIMsgMessageService.streamMessage does this.
+   */
+  attribute boolean localFetchOnly;
+
+  /// Server disconnected first time so we're retrying.
+  attribute boolean rerunningUrl;
+
+  /**
+   * Do we have more headers to download? This is set when we decide to
+   * download newest headers first, followed by older headers in a subsequent
+   * run of the url, which allows other urls to run against the folder in the
+   * meantime.
+   */
+  attribute boolean moreHeadersToDownload;
+
+  /**
+   * @{
+   * This is used to tell the runner of the url more about the status of
+   * the command, beyond whether it was successful or not. For example,
+   * subtracting flags from a UID that doesn't exist isn't an error
+   * (the server returns OK), but the backend code may want to know about it.
+   */
+  attribute long extraStatus;
+
+  /**
+   * Current possible extra status values
+   */
+  const long ImapStatusNone = 0;
+  const long ImapStatusFlagChangeFailed = 1;
+  const long ImapStatusFlagsNotSettable = 2;
+  /** @} */
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Enumerated types specific to imap urls...
+  ///////////////////////////////////////////////////////////////////////////////
+
+  // the following are nsImapState enums.
+  // we have a basic set of imap url actions. These actions are nsImapActions.
+  // Certain actions require us to be in the authenticated state and others require us to
+  // be in the selected state. nsImapState is used to store the state the url needs to
+  // be in. You'll later see us refer to the imap url state in the imap protocol when we
+  // are processing the current url. Don't confuse nsImapState with the generic url state
+  // used to keep track of whether the url is running or not...
+  const long nsImapAuthenticatedState = 0;
+  const long nsImapSelectedState = 1;
+
+  const long nsImapActionSendText = 0;      // a state used for testing purposes to send raw url text straight to the server....
+  // nsImapAuthenticatedStateUrl urls
+  // since the following url actions require us to be in the authenticated
+  // state, the high bit is left blank....
+  const long nsImapTest  = 0x00000001;
+  const long nsImapCreateFolder  = 0x00000005;
+  const long nsImapDeleteFolder  = 0x00000006;
+  const long nsImapRenameFolder  = 0x00000007;
+  const long nsImapMoveFolderHierarchy = 0x00000008;
+  const long nsImapLsubFolders  = 0x00000009;
+  const long nsImapGetMailAccountUrl = 0x0000000A;
+  const long nsImapDiscoverChildrenUrl = 0x0000000B;
+  const long nsImapDiscoverAllBoxesUrl = 0x0000000D;
+  const long nsImapDiscoverAllAndSubscribedBoxesUrl  = 0x0000000E;
+  const long nsImapAppendMsgFromFile = 0x0000000F;
+  const long nsImapSubscribe = 0x00000010;
+  const long nsImapUnsubscribe = 0x00000011;
+  const long nsImapRefreshACL  = 0x00000012;
+  const long nsImapRefreshAllACLs  = 0x00000013;
+  const long nsImapListFolder  = 0x00000014;
+  const long nsImapUpgradeToSubscription = 0x00000015;
+  const long nsImapFolderStatus  = 0x00000016;
+  const long nsImapRefreshFolderUrls = 0x00000017;
+  const long nsImapEnsureExistsFolder = 0x00000018;
+  const long nsImapOfflineToOnlineCopy = 0x00000019;
+  const long nsImapOfflineToOnlineMove = 0x0000001A;
+  const long nsImapVerifylogon = 0x0000001B;
+  // it's okay to add more imap actions that require us to
+  // be in the authenticated state here without renumbering
+  // the imap selected state url actions. just make sure you don't
+  // set the high bit...
+
+  // nsImapSelectedState urls. Note, the high bit is always set for
+  // imap actions which require us to be in the selected state
+  const long nsImapSelectFolder  = 0x10000002;
+  const long nsImapLiteSelectFolder = 0x10000003;
+  const long nsImapExpungeFolder = 0x10000004;
+  const long nsImapMsgFetch  = 0x10000018;
+  const long nsImapMsgHeader = 0x10000019;
+  const long nsImapSearch  = 0x1000001A;
+  const long nsImapDeleteMsg = 0x1000001B;
+  const long nsImapDeleteAllMsgs = 0x1000001C;
+  const long nsImapAddMsgFlags = 0x1000001D;
+  const long nsImapSubtractMsgFlags  = 0x1000001E;
+  const long nsImapSetMsgFlags = 0x1000001F;
+  const long nsImapOnlineCopy  = 0x10000020;
+  const long nsImapOnlineMove  = 0x10000021;
+  const long nsImapOnlineToOfflineCopy = 0x10000022;
+  const long nsImapOnlineToOfflineMove = 0x10000023;
+  const long nsImapMsgPreview = 0x10000024;
+  const long nsImapBiff  = 0x10000026;
+  const long nsImapSelectNoopFolder  = 0x10000027;
+  const long nsImapAppendDraftFromFile = 0x10000028;
+  const long nsImapUidExpunge = 0x10000029;
+  const long nsImapSaveMessageToDisk = 0x10000030;
+  const long nsImapOpenMimePart = 0x10000031;
+  const long nsImapMsgDownloadForOffline  = 0x10000032;
+  const long nsImapDeleteFolderAndMsgs = 0x10000033;
+  const long nsImapUserDefinedMsgCommand = 0x10000034;
+  const long nsImapUserDefinedFetchAttribute = 0x10000035;
+  const long nsImapMsgFetchPeek = 0x10000036;
+  const long nsImapMsgStoreCustomKeywords = 0x10000037;
+
+  /// Constant for the default IMAP port number
+  const int32_t DEFAULT_IMAP_PORT = 143;
+
+  /// Constant for the default IMAP over ssl port number
+  const int32_t DEFAULT_IMAPS_PORT = 993;
+};
diff --git a/mailnews/imap/public/nsIMailboxSpec.idl b/mailnews/imap/public/nsIMailboxSpec.idl
new file mode 100644
index 0000000000..5888ecbf37
--- /dev/null
+++ b/mailnews/imap/public/nsIMailboxSpec.idl
@@ -0,0 +1,43 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIImapFlagAndUidState.idl"
+
+interface nsIMAPNamespace;
+
+[scriptable, uuid(a9fbbc80-5291-4ed8-a7f7-c2fcad231269)]
+interface nsIMailboxSpec : nsISupports
+{
+  attribute long folder_UIDVALIDITY;
+  /**
+   * The highest modification sequence number the parser has seen 
+   * for this mailbox. See IMAP RFC 4551
+   **/
+  attribute unsigned long long highestModSeq;
+  attribute long numMessages;
+  attribute long numUnseenMessages;
+  attribute long numRecentMessages;
+
+  /// If server supports UIDNEXT, we store the result here.
+  attribute long nextUID;
+
+  attribute unsigned long box_flags;
+  attribute unsigned long supportedUserFlags;
+
+  attribute ACString allocatedPathName;
+  attribute AString unicharPathName;
+  attribute char hierarchyDelimiter;
+  attribute ACString hostName;
+
+  attribute nsIImapFlagAndUidState flagState;
+
+  attribute boolean folderSelected;
+  attribute boolean discoveredFromLsub;
+
+  attribute boolean onlineVerified;
+
+  [noscript] attribute nsIMAPNamespace  namespaceForFolder;
+};
diff --git a/mailnews/imap/public/nsIMsgImapMailFolder.idl b/mailnews/imap/public/nsIMsgImapMailFolder.idl
new file mode 100644
index 0000000000..f86f622b45
--- /dev/null
+++ b/mailnews/imap/public/nsIMsgImapMailFolder.idl
@@ -0,0 +1,215 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIMsgFolder.idl"
+#include "nsIStringEnumerator.idl"
+
+interface nsIMsgWindow;
+interface nsIImapIncomingServer;
+interface nsIMsgParseMailMsgState;
+interface nsIAutoSyncState;
+
+/**
+ * This is a simple interface which allows the IMAP folder to update some
+ * values that the folder props js code will use to update the sharing and
+ * quota tabs in the folder properties.
+ */
+[scriptable, uuid(09D99F2C-3E23-4f8c-A536-5C277BAA9585)] 
+interface nsIMsgImapFolderProps : nsISupports {
+
+    void setFolderType(in AString folderType);
+    void setFolderTypeDescription(in AString folderTypeDescription);
+    void setFolderPermissions(in AString permissions);
+    void serverDoesntSupportACL();
+
+    /**
+     * Toggles the display of quota information in the Quota tab of the folder properties.
+     * If on, the quota root, usage, and percentage used are displayed.
+     * If off, a status message is displayed. The status message can be set with setQuotaStatus().
+     * @param showData If true, display the quota root, usage information and usage percentage bar.
+     *                 If false, display the status message.
+     */
+    void showQuotaData(in boolean showData);
+
+    /**
+     * Sets the status string displayed in the Quota tab of the folder properties if quota
+     * information is not visible.
+     */
+    void setQuotaStatus(in AString folderQuotaStatus);
+
+    /**
+     * Updates the quota data displayed in the Quota tab.
+     */
+    void setQuotaData(in ACString quotaroot, in unsigned long usedKB, in unsigned long maxKB);
+};
+
+[scriptable, uuid(fea0f455-7adf-4683-bf2f-c95c3fff03df)]
+interface nsIMsgImapMailFolder : nsISupports {
+  void removeSubFolder(in nsIMsgFolder folder);
+  void createClientSubfolderInfo(in ACString folderName, in char hierarchyDelimiter,
+                                 in long flags, in boolean suppressNotification);
+  void list();
+  void renameLocal(in ACString newname, in nsIMsgFolder parent);
+  void prepareToRename();
+  void performExpand(in nsIMsgWindow aMsgWindow);
+  void recursiveCloseActiveConnections(in nsIImapIncomingServer aImapServer);
+  void renameClient(in nsIMsgWindow msgWindow, in nsIMsgFolder msgFolder, in ACString oldName, in ACString newName);
+
+  // these are used for offline synchronization
+  void storeImapFlags(in long aFlags, in boolean aAddFlags, [array, size_is (aNumKeys)] 
+      in nsMsgKey aKeysToFlag, in unsigned long aNumKeys, in nsIUrlListener aUrlListener);
+  nsIURI setImapFlags(in string uids, in long flags);
+  void replayOfflineMoveCopy([array, size_is (numKeys)] in nsMsgKey keys, in unsigned long numKeys, in boolean isMove, in nsIMsgFolder aDstFolder,
+                         in nsIUrlListener aUrlListener, in nsIMsgWindow aWindow);
+  nsIURI playbackOfflineFolderCreate(in AString folderName, in nsIMsgWindow aWindow);
+  /**
+   * This is called by the offline sync code to tell the imap folder to
+   * remember info about the header with this key (messageId and key) because
+   * it's an offline move result header, and we need to generate an
+   * nsIMsgFolderListener.msgKeyChanged notification when we download the
+   * real header from the imap server.
+   *
+   * @param aMsgKey msg key of move result pseudo hdr.
+   */
+  void addMoveResultPseudoKey(in nsMsgKey aMsgKey);
+  /**
+   * Select this folder on the imap server without doing a sync of flags or
+   * headers. This is used for offline playback, where we don't want to
+   * download hdrs we don't have, because they may have been offline deleted.
+   *
+   * @param aUrlListener        url listener, can be null
+   * @param aWindow          msg window url is running in, can be null
+   */
+  void liteSelect(in nsIUrlListener aUrlListener, in nsIMsgWindow aWindow);
+
+  void fillInFolderProps(in nsIMsgImapFolderProps aFolderProps);
+  void resetNamespaceReferences();
+  void folderPrivileges(in nsIMsgWindow aWindow);
+  nsIMsgImapMailFolder findOnlineSubFolder(in ACString onlineName);
+  void addFolderRights(in ACString userName, in ACString rights);
+  void refreshFolderRights();
+
+  /**
+   * Mark/unmark the header as pending removal from the offline store. If mark,
+   * this also increases the expungedBytes count on the folder so we know
+   * there's more local disk space to be reclaimed.
+   *
+   * @param aHdr     msg hdr to mark pending removal from offline store.
+   * @param aMark    whether to set or clear the pending removal status.
+   *
+   */
+  void markPendingRemoval(in nsIMsgDBHdr aHdr, in boolean aMark);
+
+  /**
+   * Issue an expunge of this folder to the imap server.
+   *
+   * @param aUrlListener     url listener, can be null
+   * @param aWindow          msg window url is running in, can be null
+   *
+   * @returns                status of attempt to run url.
+   */
+  void expunge(in nsIUrlListener aListener, in nsIMsgWindow aMsgWindow);
+
+  void updateStatus(in nsIUrlListener aListener, in nsIMsgWindow aMsgWindow);
+  void updateFolderWithListener(in nsIMsgWindow aMsgWindow, in nsIUrlListener aListener);
+  // 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.
+  nsIURI issueCommandOnMsgs(in ACString command, in string uids, in nsIMsgWindow aWindow);
+  nsIURI fetchCustomMsgAttribute(in ACString msgAttribute, in string uids, in nsIMsgWindow aWindow);
+  nsIURI storeCustomKeywords(in nsIMsgWindow aMsgWindow,
+                      in ACString aFlagsToAdd,
+                      in ACString aFlagsToSubtract,
+                      [array, size_is (aNumKeys)] in nsMsgKey aKeysToStore,
+                      in unsigned long aNumKeys);
+
+  void notifyIfNewMail();
+
+  void initiateAutoSync(in nsIUrlListener aUrlListener);
+
+  attribute boolean verifiedAsOnlineFolder;
+  attribute boolean explicitlyVerify;
+  attribute char hierarchyDelimiter;
+  attribute long boxFlags;
+  attribute ACString onlineName;
+  attribute boolean isNamespace;
+  readonly attribute boolean canOpenFolder;
+  attribute ACString adminUrl;
+  readonly attribute boolean hasAdminUrl;
+  attribute boolean performingBiff;
+  readonly attribute nsIMsgParseMailMsgState hdrParser;
+  readonly attribute nsIImapIncomingServer imapIncomingServer;
+  readonly attribute nsIAutoSyncState autoSyncStateObj;
+  /**
+   * @{
+   * These are used to access the response to the STATUS or SELECT command.
+   * The counts include deleted messages, or headers we haven't downloaded yet.
+   */
+  readonly attribute long serverTotal;
+  readonly attribute long serverUnseen;
+  readonly attribute long serverRecent;
+  readonly attribute long serverNextUID;
+  /** @} */
+
+  /**
+   * Quota
+   * |valid| indicates whether the server has provided quota information on
+   * this folder. This can be false
+   * - if the server does not supports quotas,
+   * - if there are no storage quotas on this folder, or
+   * - if the folder has never been opened.
+   * If it is true and maxKB > 0, the folder has a storage quota and
+   * the usedKB and maxKB attributes are set to the values provided by
+   * the server (in kilobytes), for this quota root.
+   * Lotus Notes sends us maxKB = 0, usedKB > 0 for unlimited quota.
+   */
+  void getQuota(out boolean valid, out unsigned long usedKB, out unsigned long maxKB);
+
+  /**
+   * List all (human) users apart from the current user who have access to
+   * this folder.
+   *
+   * You can find out which rights they have with getRightsForUser().
+   */
+  nsIUTF8StringEnumerator getOtherUsersWithAccess();
+
+  /**
+   * Which access rights a certain user has for this folder.
+   *
+   * @return list of flags
+   * e.g. "lrswipcd" for write access and "lrs" for read only access.
+   *
+   * See RFC 2086 (e.g. Cyrus) and RFC 4314 (e.g. dovecot)
+   *
+   * l = locate = visible in folder list
+   * r = read = list mails, get/read mail contents
+   * s = set seen flag = mark read. Does not affect other users.
+   * d (or t) = delete mails
+   * w = write = change (other) flags of existing mails
+   * i = insert = add mails to this folder
+   * p = post = send mail directly to the submission address for folder
+   * c (or k) = create subfolders
+   * (e = expunge = compress)
+   * (x = delete folder)
+   * a = admin = change permissions
+   */
+  ACString getPermissionsForUser(in ACString username);
+
+  /**
+   * Change the number of "pending" messages in a folder,
+   *  messages we know about, but don't have the headers for yet
+   *
+   * @param aDelta amount to change total by.
+   */
+  void changePendingTotal(in long aDelta);
+
+  /**
+   * Change the number of "pending" unread messages in a folder,
+   * unread messages we know about, but don't have the headers for yet
+   *
+   * @param aDelta amount to change the unread count by.
+   */
+  void changePendingUnread(in long aDelta);
+};
diff --git a/mailnews/imap/public/nsMsgImapCID.h b/mailnews/imap/public/nsMsgImapCID.h
new file mode 100644
index 0000000000..2ba83a28fe
--- /dev/null
+++ b/mailnews/imap/public/nsMsgImapCID.h
@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsMsgImapCID_h__
+#define nsMsgImapCID_h__
+
+#include "nsISupports.h"
+#include "nsIFactory.h"
+#include "nsIComponentManager.h"
+#include "nsMsgBaseCID.h"
+
+#define NS_IMAPURL_CID							\
+{ /* 21A89611-DC0D-11d2-806C-006008128C4E */	\
+  0x21a89611, 0xdc0d, 0x11d2,					\
+   { 0x80, 0x6c, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e }}
+
+#define NS_IMAPPROTOCOLINFO_CONTRACTID \
+  NS_MSGPROTOCOLINFO_CONTRACTID_PREFIX "imap"
+
+#define NS_IMAPINCOMINGSERVER_CONTRACTID  \
+  NS_MSGINCOMINGSERVER_CONTRACTID_PREFIX "imap"
+
+#define NS_IMAPSERVICE_CONTRACTID \
+  "@mozilla.org/messenger/imapservice;1"
+
+#define NS_IMAPSERVICE_CID						  \
+{ /* C5852B22-EBE2-11d2-95AD-000064657374 */      \
+ 0xc5852b22, 0xebe2, 0x11d2,                      \
+ {0x95, 0xad, 0x0, 0x0, 0x64, 0x65, 0x73, 0x74}}
+
+#define NS_IMAPPROTOCOL_CID							\
+{ /* 8C0C40D1-E173-11d2-806E-006008128C4E */		\
+  0x8c0c40d1, 0xe173, 0x11d2,						\
+    { 0x80, 0x6e, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e }}
+
+
+#define NS_IIMAPHOSTSESSIONLIST_CID					\
+{ /* 479ce8fc-e725-11d2-a505-0060b0fc04b7 */		\
+  0x479ce8fc, 0xe725, 0x11d2,						\
+	{0xa5, 0x05, 0x00, 0x60, 0xb0, 0xfc, 0x04, 0xb7 }}
+
+#define NS_IMAPINCOMINGSERVER_CID				  \
+{ /* 8D3675E0-ED46-11d2-8077-006008128C4E */      \
+ 0x8d3675e0, 0xed46, 0x11d2,	                  \
+ {0x80, 0x77, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e}}
+
+#define NS_IMAPRESOURCE_CID						\
+{ /* fa32d000-f6a0-11d2-af8d-001083002da8 */	\
+  0xfa32d000, 0xf6a0, 0x11d2,					\
+  { 0xaf, 0x8d, 0x00, 0x10, 0x83, 0x00, 0x2d, 0xa8 }}
+
+// 4ECA51DF-6734-11d3-989A-001083010E9B
+#define NS_IMAPMOCKCHANNEL_CID \
+	{0x4eca51df, 0x6734, 0x11d3, \
+	{0x98, 0x9a, 0x0, 0x10, 0x83, 0x1, 0xe, 0x9b}}
+
+#endif // nsMsgImapCID_h__
diff --git a/mailnews/imap/src/moz.build b/mailnews/imap/src/moz.build
new file mode 100644
index 0000000000..e62ec5fa8e
--- /dev/null
+++ b/mailnews/imap/src/moz.build
@@ -0,0 +1,33 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXPORTS += [
+    'nsImapCore.h',
+]
+
+SOURCES += [
+    'nsAutoSyncManager.cpp',
+    'nsAutoSyncState.cpp',
+    'nsIMAPBodyShell.cpp',
+    'nsImapFlagAndUidState.cpp',
+    'nsIMAPGenericParser.cpp',
+    'nsIMAPHostSessionList.cpp',
+    'nsImapIncomingServer.cpp',
+    'nsImapMailFolder.cpp',
+    'nsIMAPNamespace.cpp',
+    'nsImapOfflineSync.cpp',
+    'nsImapProtocol.cpp',
+    'nsImapSearchResults.cpp',
+    'nsImapServerResponseParser.cpp',
+    'nsImapService.cpp',
+    'nsImapStringBundle.cpp',
+    'nsImapUndoTxn.cpp',
+    'nsImapUrl.cpp',
+    'nsImapUtils.cpp',
+    'nsSyncRunnableHelpers.cpp',
+]
+
+FINAL_LIBRARY = 'mail'
+
diff --git a/mailnews/imap/src/nsAutoSyncManager.cpp b/mailnews/imap/src/nsAutoSyncManager.cpp
new file mode 100644
index 0000000000..9778919c7b
--- /dev/null
+++ b/mailnews/imap/src/nsAutoSyncManager.cpp
@@ -0,0 +1,1412 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.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 "nsAutoSyncManager.h"
+#include "nsAutoSyncState.h"
+#include "nsIIdleService.h"
+#include "nsImapMailFolder.h"
+#include "nsMsgImapCID.h"
+#include "nsIObserverService.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIMsgMailSession.h"
+#include "nsMsgFolderFlags.h"
+#include "nsImapIncomingServer.h"
+#include "nsMsgUtils.h"
+#include "nsIIOService.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Services.h"
+#include "nsArrayUtils.h"
+#include "mozilla/Logging.h"
+
+using namespace mozilla;
+
+NS_IMPL_ISUPPORTS(nsDefaultAutoSyncMsgStrategy, nsIAutoSyncMsgStrategy)
+
+const char* kAppIdleNotification = "mail:appIdle";
+const char* kStartupDoneNotification = "mail-startup-done";
+PRLogModuleInfo *gAutoSyncLog;
+
+// recommended size of each group of messages per download
+static const uint32_t kDefaultGroupSize = 50U*1024U /* 50K */;
+
+nsDefaultAutoSyncMsgStrategy::nsDefaultAutoSyncMsgStrategy()
+{
+}
+
+nsDefaultAutoSyncMsgStrategy::~nsDefaultAutoSyncMsgStrategy()
+{
+}
+
+NS_IMETHODIMP nsDefaultAutoSyncMsgStrategy::Sort(nsIMsgFolder *aFolder, 
+  nsIMsgDBHdr *aMsgHdr1, nsIMsgDBHdr *aMsgHdr2, nsAutoSyncStrategyDecisionType *aDecision)
+{
+  NS_ENSURE_ARG_POINTER(aDecision);
+
+  uint32_t msgSize1 = 0, msgSize2 = 0;
+  PRTime msgDate1 = 0, msgDate2 = 0;
+  
+  if (!aMsgHdr1 || !aMsgHdr2)
+  {
+    *aDecision = nsAutoSyncStrategyDecisions::Same;
+    return NS_OK;
+  }
+
+  aMsgHdr1->GetMessageSize(&msgSize1);
+  aMsgHdr1->GetDate(&msgDate1);
+  
+  aMsgHdr2->GetMessageSize(&msgSize2);
+  aMsgHdr2->GetDate(&msgDate2);
+  
+  //Special case: if message size is larger than a 
+  // certain size, then place it to the bottom of the q
+  if (msgSize2 > kFirstPassMessageSize && msgSize1 > kFirstPassMessageSize)
+    *aDecision = msgSize2 > msgSize1 ? 
+        nsAutoSyncStrategyDecisions::Lower : nsAutoSyncStrategyDecisions::Higher;
+  else if (msgSize2 > kFirstPassMessageSize)
+    *aDecision = nsAutoSyncStrategyDecisions::Lower;
+  else if (msgSize1 > kFirstPassMessageSize)
+    *aDecision = nsAutoSyncStrategyDecisions::Higher;
+  else
+  {
+    // Most recent and smallest first
+    if (msgDate1 < msgDate2)
+      *aDecision = nsAutoSyncStrategyDecisions::Higher;
+    else if (msgDate1 > msgDate2)
+      *aDecision = nsAutoSyncStrategyDecisions::Lower;
+    else 
+    {
+      if (msgSize1 > msgSize2)
+        *aDecision = nsAutoSyncStrategyDecisions::Higher;
+      else if (msgSize1 < msgSize2)
+        *aDecision = nsAutoSyncStrategyDecisions::Lower;
+      else
+        *aDecision = nsAutoSyncStrategyDecisions::Same;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDefaultAutoSyncMsgStrategy::IsExcluded(nsIMsgFolder *aFolder, 
+  nsIMsgDBHdr *aMsgHdr, bool *aDecision)
+{
+  NS_ENSURE_ARG_POINTER(aDecision);
+  NS_ENSURE_ARG_POINTER(aMsgHdr);
+  NS_ENSURE_ARG_POINTER(aFolder);
+  nsCOMPtr<nsIMsgIncomingServer> server;
+
+  nsresult rv = aFolder->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIImapIncomingServer> imapServer(do_QueryInterface(server, &rv));
+  int32_t offlineMsgAgeLimit = -1;
+  imapServer->GetAutoSyncMaxAgeDays(&offlineMsgAgeLimit);
+  NS_ENSURE_SUCCESS(rv, rv);
+  PRTime msgDate;
+  aMsgHdr->GetDate(&msgDate);
+  *aDecision = offlineMsgAgeLimit > 0 &&
+    msgDate < MsgConvertAgeInDaysToCutoffDate(offlineMsgAgeLimit);
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsDefaultAutoSyncFolderStrategy, nsIAutoSyncFolderStrategy)
+
+nsDefaultAutoSyncFolderStrategy::nsDefaultAutoSyncFolderStrategy()
+{
+}
+
+nsDefaultAutoSyncFolderStrategy::~nsDefaultAutoSyncFolderStrategy()
+{
+}
+
+NS_IMETHODIMP nsDefaultAutoSyncFolderStrategy::Sort(nsIMsgFolder *aFolderA, 
+  nsIMsgFolder *aFolderB, nsAutoSyncStrategyDecisionType *aDecision)
+{
+  NS_ENSURE_ARG_POINTER(aDecision);
+
+  if (!aFolderA || !aFolderB)
+  {
+    *aDecision = nsAutoSyncStrategyDecisions::Same;
+    return NS_OK;
+  }
+  
+  bool isInbox1, isInbox2, isDrafts1, isDrafts2, isTrash1, isTrash2;
+  aFolderA->GetFlag(nsMsgFolderFlags::Inbox, &isInbox1);
+  aFolderB->GetFlag(nsMsgFolderFlags::Inbox, &isInbox2);
+  //
+  aFolderA->GetFlag(nsMsgFolderFlags::Drafts, &isDrafts1);
+  aFolderB->GetFlag(nsMsgFolderFlags::Drafts, &isDrafts2);
+  //
+  aFolderA->GetFlag(nsMsgFolderFlags::Trash, &isTrash1);
+  aFolderB->GetFlag(nsMsgFolderFlags::Trash, &isTrash2);
+  
+  //Follow this order;
+  // INBOX > DRAFTS > SUBFOLDERS > TRASH
+
+  // test whether the folder is opened by the user.
+  // we give high priority to the folders explicitly opened by 
+  // the user.
+  nsresult rv;
+  bool folderAOpen = false;
+  bool folderBOpen = false;
+  nsCOMPtr<nsIMsgMailSession> session =
+           do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv) && session) 
+  {
+    session->IsFolderOpenInWindow(aFolderA, &folderAOpen);
+    session->IsFolderOpenInWindow(aFolderB, &folderBOpen);
+  }
+
+  if (folderAOpen == folderBOpen)
+  {
+    // if both of them or none of them are opened by the user 
+    // make your decision based on the folder type
+    if (isInbox2 || (isDrafts2 && !isInbox1) || isTrash1)
+      *aDecision = nsAutoSyncStrategyDecisions::Higher;
+    else if (isInbox1 || (isDrafts1 && !isDrafts2) || isTrash2)
+      *aDecision = nsAutoSyncStrategyDecisions::Lower;
+    else
+      *aDecision = nsAutoSyncStrategyDecisions::Same;
+  }
+  else
+  {
+    // otherwise give higher priority to opened one
+    *aDecision = folderBOpen ? nsAutoSyncStrategyDecisions::Higher :
+                               nsAutoSyncStrategyDecisions::Lower;
+  }
+    
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsDefaultAutoSyncFolderStrategy::IsExcluded(nsIMsgFolder *aFolder, bool *aDecision)
+{
+  NS_ENSURE_ARG_POINTER(aDecision);
+  NS_ENSURE_ARG_POINTER(aFolder);
+  uint32_t folderFlags;
+  aFolder->GetFlags(&folderFlags);
+  // exclude saved search
+  *aDecision = (folderFlags & nsMsgFolderFlags::Virtual);
+  if (!*aDecision)
+  {
+    // Exclude orphans
+    nsCOMPtr<nsIMsgFolder> parent;
+    aFolder->GetParent(getter_AddRefs(parent));
+    if (!parent)
+      *aDecision = true;
+  }
+  return NS_OK;
+}
+
+#define NOTIFY_LISTENERS_STATIC(obj_, propertyfunc_, params_) \
+  PR_BEGIN_MACRO \
+  nsTObserverArray<nsCOMPtr<nsIAutoSyncMgrListener> >::ForwardIterator iter(obj_->mListeners); \
+  nsCOMPtr<nsIAutoSyncMgrListener> listener; \
+  while (iter.HasMore()) { \
+    listener = iter.GetNext(); \
+    listener->propertyfunc_ params_; \
+  } \
+  PR_END_MACRO
+
+#define NOTIFY_LISTENERS(propertyfunc_, params_) \
+  NOTIFY_LISTENERS_STATIC(this, propertyfunc_, params_)
+
+nsAutoSyncManager::nsAutoSyncManager()
+{
+  mGroupSize = kDefaultGroupSize;
+
+  mIdleState = notIdle;
+  mStartupDone = false;
+  mDownloadModel = dmChained;
+  mUpdateState = completed;
+  mPaused = false;
+
+  nsresult rv;
+  mIdleService = do_GetService("@mozilla.org/widget/idleservice;1", &rv);
+  if (mIdleService)
+    mIdleService->AddIdleObserver(this, kIdleTimeInSec);
+
+  // Observe xpcom-shutdown event and app-idle changes
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+
+  rv = observerService->AddObserver(this,
+                                    NS_XPCOM_SHUTDOWN_OBSERVER_ID,
+                                    false);
+  observerService->AddObserver(this, kAppIdleNotification, false);
+  observerService->AddObserver(this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC, false);
+  observerService->AddObserver(this, NS_IOSERVICE_GOING_OFFLINE_TOPIC, false);
+  observerService->AddObserver(this, kStartupDoneNotification, false);
+  gAutoSyncLog = PR_NewLogModule("ImapAutoSync");
+}
+
+nsAutoSyncManager::~nsAutoSyncManager()
+{
+}
+
+void nsAutoSyncManager::InitTimer()
+{
+  if (!mTimer)
+  {
+    nsresult rv;
+    mTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "failed to create timer in nsAutoSyncManager");
+
+    mTimer->InitWithFuncCallback(TimerCallback, (void *) this, 
+                                 kTimerIntervalInMs, nsITimer::TYPE_REPEATING_SLACK);
+  }
+}
+
+void nsAutoSyncManager::StopTimer()
+{
+  if (mTimer)
+  {
+    mTimer->Cancel();
+    mTimer = nullptr;
+  }
+}
+
+void nsAutoSyncManager::StartTimerIfNeeded()
+{
+  if ((mUpdateQ.Count() > 0 || mDiscoveryQ.Count() > 0) && !mTimer)
+    InitTimer();
+}
+
+void nsAutoSyncManager::TimerCallback(nsITimer *aTimer, void *aClosure)
+{
+  if (!aClosure)
+    return;
+
+  nsAutoSyncManager *autoSyncMgr = static_cast<nsAutoSyncManager*>(aClosure);
+  if (autoSyncMgr->GetIdleState() == notIdle ||
+    (autoSyncMgr->mDiscoveryQ.Count() <= 0 && autoSyncMgr->mUpdateQ.Count() <= 0))
+  {
+    // Idle will create a new timer automatically if discovery Q or update Q is not empty
+    autoSyncMgr->StopTimer();
+  }
+
+  // process folders within the discovery queue
+  if (autoSyncMgr->mDiscoveryQ.Count() > 0)
+  {
+    nsCOMPtr<nsIAutoSyncState> autoSyncStateObj(autoSyncMgr->mDiscoveryQ[0]);
+    if (autoSyncStateObj)
+    {
+      uint32_t leftToProcess;
+      nsresult rv = autoSyncStateObj->ProcessExistingHeaders(kNumberOfHeadersToProcess, &leftToProcess);
+
+      nsCOMPtr<nsIMsgFolder> folder;
+      autoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+      if (folder)
+        NOTIFY_LISTENERS_STATIC(autoSyncMgr, OnDiscoveryQProcessed, (folder, kNumberOfHeadersToProcess, leftToProcess));
+
+      if (NS_SUCCEEDED(rv) && 0 == leftToProcess)
+      {
+        autoSyncMgr->mDiscoveryQ.RemoveObjectAt(0);
+        if (folder)
+          NOTIFY_LISTENERS_STATIC(autoSyncMgr, OnFolderRemovedFromQ, (nsIAutoSyncMgrListener::DiscoveryQueue, folder));
+      }
+    }
+  }
+
+  if (autoSyncMgr->mUpdateQ.Count() > 0)
+  {
+    if (autoSyncMgr->mUpdateState == completed)
+    {
+      nsCOMPtr<nsIAutoSyncState> autoSyncStateObj(autoSyncMgr->mUpdateQ[0]);
+      if (autoSyncStateObj)
+      {
+        int32_t state;
+        nsresult rv = autoSyncStateObj->GetState(&state);
+        if (NS_SUCCEEDED(rv) && (state == nsAutoSyncState::stCompletedIdle ||
+                                 state == nsAutoSyncState::stUpdateNeeded))
+        {
+          nsCOMPtr<nsIMsgFolder> folder; 
+          autoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+          if (folder)
+          {
+            nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(folder, &rv);
+            NS_ENSURE_SUCCESS_VOID(rv);
+            rv = imapFolder->InitiateAutoSync(autoSyncMgr);
+            if (NS_SUCCEEDED(rv))
+            {
+              autoSyncMgr->mUpdateState = initiated;
+              NOTIFY_LISTENERS_STATIC(autoSyncMgr, OnAutoSyncInitiated, (folder));
+            }
+          }
+        }
+      } 
+    }
+    // if initiation is not successful for some reason, or 
+    // if there is an on going download for this folder, 
+    // remove it from q and continue with the next one  
+    if (autoSyncMgr->mUpdateState != initiated)
+    {
+      nsCOMPtr<nsIMsgFolder> folder;
+      autoSyncMgr->mUpdateQ[0]->GetOwnerFolder(getter_AddRefs(folder));
+      
+      autoSyncMgr->mUpdateQ.RemoveObjectAt(0);
+      
+      if (folder)
+        NOTIFY_LISTENERS_STATIC(autoSyncMgr, OnFolderRemovedFromQ, (nsIAutoSyncMgrListener::UpdateQueue, folder));
+    }
+      
+  }//endif
+
+}
+
+/**
+ * Populates aChainedQ with the auto-sync state objects that are not owned by 
+ * the same imap server. 
+ * Assumes that aChainedQ initially empty.
+ */
+void nsAutoSyncManager::ChainFoldersInQ(const nsCOMArray<nsIAutoSyncState> &aQueue,
+      nsCOMArray<nsIAutoSyncState> &aChainedQ)
+{
+  if (aQueue.Count() > 0)
+    aChainedQ.AppendObject(aQueue[0]);
+  
+  int32_t pqElemCount = aQueue.Count();
+  for (int32_t pqidx = 1; pqidx < pqElemCount; pqidx++)
+  {
+    bool chained = false;
+    int32_t needToBeReplacedWith = -1;
+    int32_t elemCount = aChainedQ.Count();
+    for (int32_t idx = 0; idx < elemCount; idx++)
+    {
+      bool isSibling;
+      nsresult rv = aChainedQ[idx]->IsSibling(aQueue[pqidx], &isSibling);
+      
+      if (NS_SUCCEEDED(rv) && isSibling)
+      {
+        // this prevent us to overwrite a lower priority sibling in
+        // download-in-progress state with a higher priority one. 
+        // we have to wait until its download is completed before 
+        // switching to new one. 
+        int32_t state;
+        aQueue[pqidx]->GetState(&state);
+        if (aQueue[pqidx] != aChainedQ[idx] && 
+            state == nsAutoSyncState::stDownloadInProgress)
+          needToBeReplacedWith = idx;
+        else
+          chained = true;
+          
+        break;
+      }
+    }//endfor
+    
+    if (needToBeReplacedWith > -1)
+      aChainedQ.ReplaceObjectAt(aQueue[pqidx], needToBeReplacedWith);
+    else if (!chained)
+      aChainedQ.AppendObject(aQueue[pqidx]);
+      
+  }//endfor
+}
+
+/**
+ * Searches the given queue for another folder owned by the same imap server.
+ */
+nsIAutoSyncState* 
+nsAutoSyncManager::SearchQForSibling(const nsCOMArray<nsIAutoSyncState> &aQueue, 
+                          nsIAutoSyncState *aAutoSyncStateObj, int32_t aStartIdx, int32_t *aIndex)
+{
+  if (aIndex)
+    *aIndex = -1;
+  
+  if (aAutoSyncStateObj)
+  {
+    bool isSibling;
+    int32_t elemCount = aQueue.Count();
+    for (int32_t idx = aStartIdx; idx < elemCount; idx++)
+    {
+      nsresult rv = aAutoSyncStateObj->IsSibling(aQueue[idx], &isSibling);
+      
+      if (NS_SUCCEEDED(rv) && isSibling && aAutoSyncStateObj != aQueue[idx])
+      {
+        if (aIndex) 
+          *aIndex = idx;
+        
+        return aQueue[idx];
+      }
+    }
+  }
+  return nullptr;  
+}
+
+/**
+ * Searches for the next folder owned by the same imap server in the given queue,
+ * starting from the index of the given folder.
+ */
+nsIAutoSyncState* 
+nsAutoSyncManager::GetNextSibling(const nsCOMArray<nsIAutoSyncState> &aQueue, 
+                                          nsIAutoSyncState *aAutoSyncStateObj, int32_t *aIndex)
+{ 
+
+  if (aIndex)
+    *aIndex = -1;
+  
+  if (aAutoSyncStateObj)
+  {
+    bool located = false;
+    bool isSibling;
+    int32_t elemCount = aQueue.Count();
+    for (int32_t idx = 0; idx < elemCount; idx++)
+    {
+      if (!located)
+      {
+        located = (aAutoSyncStateObj == aQueue[idx]);
+        continue;
+      }
+      
+      nsresult rv = aAutoSyncStateObj->IsSibling(aQueue[idx], &isSibling);
+      if (NS_SUCCEEDED(rv) && isSibling)
+      {
+        if (aIndex) 
+          *aIndex = idx;
+        
+        return aQueue[idx];
+      }
+    }
+  }
+  return nullptr;  
+}
+
+/** 
+ * Checks whether there is another folder in the given q that is owned 
+ * by the same imap server or not.
+ *
+ * @param aQueue the queue that will be searched for a sibling
+ * @param aAutoSyncStateObj the auto-sync state object that we are looking
+ *                          a sibling for
+ * @param aState the state of the sibling. -1 means "any state"
+ * @param aIndex [out] the index of the found sibling, if it is provided by the
+ *               caller (not null)
+ * @return true if found, false otherwise
+ */
+bool nsAutoSyncManager::DoesQContainAnySiblingOf(const nsCOMArray<nsIAutoSyncState> &aQueue, 
+                                                   nsIAutoSyncState *aAutoSyncStateObj,
+                                                   const int32_t aState, int32_t *aIndex)
+{
+  if (aState == -1)
+    return (nullptr != SearchQForSibling(aQueue, aAutoSyncStateObj, 0, aIndex));
+    
+  int32_t offset = 0;
+  nsIAutoSyncState *autoSyncState;
+  while ((autoSyncState = SearchQForSibling(aQueue, aAutoSyncStateObj, offset, &offset)))
+  {
+    int32_t state;
+    nsresult rv = autoSyncState->GetState(&state);
+    if (NS_SUCCEEDED(rv) && aState == state)
+      break;
+    else
+      offset++;
+  }
+  if (aIndex)
+    *aIndex = offset;
+    
+  return (nullptr != autoSyncState);
+}
+
+/**
+ * Searches the given queue for the highest priority folder owned by the
+ * same imap server.
+ */
+nsIAutoSyncState* 
+nsAutoSyncManager::GetHighestPrioSibling(const nsCOMArray<nsIAutoSyncState> &aQueue, 
+                                      nsIAutoSyncState *aAutoSyncStateObj, int32_t *aIndex)
+{
+  return SearchQForSibling(aQueue, aAutoSyncStateObj, 0, aIndex);
+}
+
+// to chain update folder actions
+NS_IMETHODIMP nsAutoSyncManager::OnStartRunningUrl(nsIURI* aUrl)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsAutoSyncManager::OnStopRunningUrl(nsIURI* aUrl, nsresult aExitCode)
+{
+  mUpdateState = completed;
+  if (mUpdateQ.Count() > 0)
+    mUpdateQ.RemoveObjectAt(0);
+
+  return aExitCode;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::Pause()
+{
+  StopTimer();
+  mPaused = true;
+  MOZ_LOG(gAutoSyncLog, LogLevel::Debug, ("autosync paused\n"));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::Resume()
+{
+  mPaused = false;
+  StartTimerIfNeeded();
+  MOZ_LOG(gAutoSyncLog, LogLevel::Debug, ("autosync resumed\n"));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::Observe(nsISupports*, const char *aTopic, const char16_t *aSomeData)
+{
+  if (!PL_strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID))
+  {
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+    if (observerService)
+    {
+      observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+      observerService->RemoveObserver(this, kAppIdleNotification);
+      observerService->RemoveObserver(this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC);
+      observerService->RemoveObserver(this, NS_IOSERVICE_GOING_OFFLINE_TOPIC);
+      observerService->RemoveObserver(this, kStartupDoneNotification);
+    }
+
+    // cancel and release the timer
+    if (mTimer)
+    {
+       mTimer->Cancel();
+       mTimer = nullptr;
+    }
+    // unsubscribe from idle service
+    if (mIdleService)
+       mIdleService->RemoveIdleObserver(this, kIdleTimeInSec);
+
+    return NS_OK;
+  }
+  else if (!PL_strcmp(aTopic, kStartupDoneNotification))
+  {
+    mStartupDone = true; 
+  }
+  else if (!PL_strcmp(aTopic, kAppIdleNotification))
+  {
+    if (nsDependentString(aSomeData).EqualsLiteral("idle"))
+    {
+      IdleState prevIdleState = GetIdleState();
+
+      // we were already idle (either system or app), so
+      // just remember that we're app idle and return.
+      SetIdleState(appIdle);
+      if (prevIdleState != notIdle)
+        return NS_OK;
+
+       return StartIdleProcessing();
+     }
+     // we're back from appIdle - if already notIdle, just return;
+     else if (GetIdleState() == notIdle)
+       return NS_OK;
+
+    SetIdleState(notIdle);
+    NOTIFY_LISTENERS(OnStateChanged, (false));
+    return NS_OK;
+  }
+  else if (!PL_strcmp(aTopic, NS_IOSERVICE_OFFLINE_STATUS_TOPIC))
+  {
+    if (nsDependentString(aSomeData).EqualsLiteral(NS_IOSERVICE_ONLINE))
+      Resume();
+  }
+  else if (!PL_strcmp(aTopic, NS_IOSERVICE_GOING_OFFLINE_TOPIC))
+  {
+    Pause();
+  }
+  // we're back from system idle
+  else if (!PL_strcmp(aTopic, "back"))
+  {
+    // if we're app idle when we get back from system idle, we ignore
+    // it, since we'll keep doing our idle stuff.
+    if (GetIdleState() != appIdle)
+    {
+      SetIdleState(notIdle);
+      NOTIFY_LISTENERS(OnStateChanged, (false));
+    }
+    return NS_OK;
+  }
+  else // we've gone system idle
+  {
+    // Check if we were already idle. We may have gotten
+    // multiple system idle notificatons. In that case,
+    // just remember that we're systemIdle and return;
+    if (GetIdleState() != notIdle)
+      return NS_OK;
+
+    // we might want to remember if we were app idle, because
+    // coming back from system idle while app idle shouldn't stop
+    // app indexing. But I think it's OK for now just leave ourselves
+    // in appIdle state.
+    if (GetIdleState() != appIdle)
+      SetIdleState(systemIdle);
+    if (WeAreOffline())
+      return NS_OK;
+    return StartIdleProcessing();
+  }
+  return NS_OK;
+}
+
+nsresult nsAutoSyncManager::StartIdleProcessing()
+{
+  if (mPaused)
+    return NS_OK;
+    
+  StartTimerIfNeeded();
+  
+  // Ignore idle events sent during the startup
+  if (!mStartupDone)
+    return NS_OK;
+    
+  // notify listeners that auto-sync is running
+  NOTIFY_LISTENERS(OnStateChanged, (true));
+    
+  nsCOMArray<nsIAutoSyncState> chainedQ;
+  nsCOMArray<nsIAutoSyncState> *queue = &mPriorityQ;
+  if (mDownloadModel == dmChained) 
+  {
+    ChainFoldersInQ(mPriorityQ, chainedQ);
+    queue = &chainedQ;
+  }
+  
+  // to store the folders that should be removed from the priority
+  // queue at the end of the iteration.
+  nsCOMArray<nsIAutoSyncState> foldersToBeRemoved;
+  
+  // process folders in the priority queue 
+  int32_t elemCount = queue->Count();
+  for (int32_t idx = 0; idx < elemCount; idx++)
+  {
+    nsCOMPtr<nsIAutoSyncState> autoSyncStateObj((*queue)[idx]);
+    if (!autoSyncStateObj)
+      continue;
+    
+    int32_t state;
+    autoSyncStateObj->GetState(&state);
+    
+    //TODO: Test cached-connection availability in parallel mode
+    // and do not exceed (cached-connection count - 1)
+    
+    if (state != nsAutoSyncState::stReadyToDownload)
+      continue;
+    
+    nsresult rv = DownloadMessagesForOffline(autoSyncStateObj);
+    if (NS_FAILED(rv))
+    {
+      // special case: this folder does not have any message to download
+      // (see bug 457342), remove it explicitly from the queue when iteration
+      // is over.
+      // Note that in normal execution flow, folders are removed from priority
+      // queue only in OnDownloadCompleted when all messages are downloaded
+      // successfully. This is the only place we change this flow.
+      if (NS_ERROR_NOT_AVAILABLE == rv)
+        foldersToBeRemoved.AppendObject(autoSyncStateObj);
+      
+      HandleDownloadErrorFor(autoSyncStateObj, rv);
+    }// endif
+  }//endfor
+  
+  // remove folders with no pending messages from the priority queue
+  elemCount = foldersToBeRemoved.Count();
+  for (int32_t idx = 0; idx < elemCount; idx++)
+  {
+    nsCOMPtr<nsIAutoSyncState> autoSyncStateObj(foldersToBeRemoved[idx]);
+    if (!autoSyncStateObj)
+      continue;
+    
+    nsCOMPtr<nsIMsgFolder> folder;
+    autoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+    if (folder)
+      NOTIFY_LISTENERS(OnDownloadCompleted, (folder));
+
+    autoSyncStateObj->SetState(nsAutoSyncState::stCompletedIdle);
+
+    if (mPriorityQ.RemoveObject(autoSyncStateObj))
+      NOTIFY_LISTENERS(OnFolderRemovedFromQ,
+                      (nsIAutoSyncMgrListener::PriorityQueue, folder));
+  }
+    
+  return AutoUpdateFolders();
+}
+
+/**
+ * Updates offline imap folders that are not synchronized recently. This is
+ * called whenever we're idle.
+ */
+nsresult nsAutoSyncManager::AutoUpdateFolders()
+{
+  nsresult rv;
+
+  // iterate through each imap account and update offline folders automatically
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIArray> accounts;
+  rv = accountManager->GetAccounts(getter_AddRefs(accounts));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  uint32_t accountCount;
+  accounts->GetLength(&accountCount);
+
+  for (uint32_t i = 0; i < accountCount; ++i) 
+  {
+    nsCOMPtr<nsIMsgAccount> account(do_QueryElementAt(accounts, i, &rv));
+    if (!account)
+      continue;
+
+    nsCOMPtr<nsIMsgIncomingServer> incomingServer;
+    rv = account->GetIncomingServer(getter_AddRefs(incomingServer));
+    if (!incomingServer)
+      continue;
+
+    nsCString type;
+    rv = incomingServer->GetType(type);
+
+    if (!type.EqualsLiteral("imap"))
+      continue;
+
+    // if we haven't logged onto this server yet, then skip this server.
+    bool passwordRequired;
+    incomingServer->GetServerRequiresPasswordForBiff(&passwordRequired);
+    if (passwordRequired)
+      continue;
+
+    nsCOMPtr<nsIMsgFolder> rootFolder;
+    nsCOMPtr<nsIArray> allDescendants;
+
+    rv = incomingServer->GetRootFolder(getter_AddRefs(rootFolder));
+    if (rootFolder)
+    {
+      if (NS_FAILED(rv))
+        continue;
+
+      rv = rootFolder->GetDescendants(getter_AddRefs(allDescendants));
+      if (!allDescendants)
+        continue;
+
+      uint32_t cnt = 0;
+      rv = allDescendants->GetLength(&cnt);
+      if (NS_FAILED(rv))
+        continue;
+
+      for (uint32_t i = 0; i < cnt; i++)
+      {
+        nsCOMPtr<nsIMsgFolder> folder(do_QueryElementAt(allDescendants, i, &rv));
+        if (NS_FAILED(rv))
+          continue;
+
+        uint32_t folderFlags;
+        rv = folder->GetFlags(&folderFlags);
+        // Skip this folder if not offline or is a saved search or is no select.
+        if (NS_FAILED(rv) || !(folderFlags & nsMsgFolderFlags::Offline) ||
+            folderFlags & (nsMsgFolderFlags::Virtual |
+                           nsMsgFolderFlags::ImapNoselect))
+          continue;
+
+        nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(folder, &rv);
+        if (NS_FAILED(rv))
+          continue;
+
+        nsCOMPtr<nsIImapIncomingServer> imapServer;
+        rv = imapFolder->GetImapIncomingServer(getter_AddRefs(imapServer));
+        if (imapServer)
+        {
+          bool autoSyncOfflineStores = false;
+          rv = imapServer->GetAutoSyncOfflineStores(&autoSyncOfflineStores);
+
+          // skip if AutoSyncOfflineStores pref is not set for this folder
+          if (NS_FAILED(rv) || !autoSyncOfflineStores)
+            continue;
+        }
+
+        nsCOMPtr<nsIAutoSyncState> autoSyncState;
+        rv = imapFolder->GetAutoSyncStateObj(getter_AddRefs(autoSyncState));
+        NS_ASSERTION(autoSyncState, "*** nsAutoSyncState shouldn't be NULL, check owner folder");
+
+        // shouldn't happen but let's be defensive here
+        if (!autoSyncState)
+          continue;
+
+        int32_t state;
+        rv = autoSyncState->GetState(&state);
+
+        if (NS_SUCCEEDED(rv) && nsAutoSyncState::stCompletedIdle == state)
+        {
+          // ensure that we wait for at least nsMsgIncomingServer::BiffMinutes between
+          // each update of the same folder
+          PRTime lastUpdateTime;
+          rv = autoSyncState->GetLastUpdateTime(&lastUpdateTime);
+          PRTime span = GetUpdateIntervalFor(autoSyncState) * (PR_USEC_PER_SEC * 60UL);
+          if ( NS_SUCCEEDED(rv) && ((lastUpdateTime + span) < PR_Now()) )
+          {          
+            if (mUpdateQ.IndexOf(autoSyncState) == -1)
+            {
+              mUpdateQ.AppendObject(autoSyncState);
+              if (folder)
+                NOTIFY_LISTENERS(OnFolderAddedIntoQ, (nsIAutoSyncMgrListener::UpdateQueue, folder));
+            }
+          }
+        }
+
+        // check last sync time
+        PRTime lastSyncTime;
+        rv = autoSyncState->GetLastSyncTime(&lastSyncTime);
+        if ( NS_SUCCEEDED(rv) && ((lastSyncTime + kAutoSyncFreq) < PR_Now()) )
+        {
+          // add this folder into discovery queue to process existing headers
+          // and discover messages not downloaded yet
+          if (mDiscoveryQ.IndexOf(autoSyncState) == -1)
+          {
+            mDiscoveryQ.AppendObject(autoSyncState);
+            if (folder)
+              NOTIFY_LISTENERS(OnFolderAddedIntoQ, (nsIAutoSyncMgrListener::DiscoveryQueue, folder));
+          }
+        }
+      }//endfor
+    }//endif
+  }//endfor
+
+  // lazily create the timer if there is something to process in the queue
+  // when timer is done, it will self destruct
+  StartTimerIfNeeded();
+  
+  return rv;
+}
+
+/**
+ * Places the given folder into the priority queue based on active
+ * strategy function.
+ */
+void nsAutoSyncManager::ScheduleFolderForOfflineDownload(nsIAutoSyncState *aAutoSyncStateObj)
+{
+  if (aAutoSyncStateObj && (mPriorityQ.IndexOf(aAutoSyncStateObj) == -1))
+  {
+    nsCOMPtr<nsIAutoSyncFolderStrategy> folStrategy;
+    GetFolderStrategy(getter_AddRefs(folStrategy));
+
+    if (mPriorityQ.Count() <= 0)
+    {
+      // make sure that we don't insert a folder excluded by the given strategy
+      nsCOMPtr<nsIMsgFolder> folder;
+      aAutoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+      if (folder)
+      {
+        bool excluded = false;
+        if (folStrategy)
+          folStrategy->IsExcluded(folder, &excluded);
+
+        if (!excluded)
+        {
+          mPriorityQ.AppendObject(aAutoSyncStateObj); // insert into the first spot
+          NOTIFY_LISTENERS(OnFolderAddedIntoQ, (nsIAutoSyncMgrListener::PriorityQueue, folder));
+        }
+      }
+    }
+    else
+    {
+      // find the right spot for the given folder      
+      uint32_t qidx = mPriorityQ.Count();
+      while (qidx > 0) 
+      {
+        --qidx;
+
+        nsCOMPtr<nsIMsgFolder> folderA, folderB;
+        mPriorityQ[qidx]->GetOwnerFolder(getter_AddRefs(folderA));
+        aAutoSyncStateObj->GetOwnerFolder(getter_AddRefs(folderB));
+        
+        bool excluded = false;
+        if (folderB && folStrategy)
+          folStrategy->IsExcluded(folderB, &excluded);
+
+        if (excluded)
+          break;
+
+        nsAutoSyncStrategyDecisionType decision = nsAutoSyncStrategyDecisions::Same;
+        if (folderA && folderB && folStrategy)
+          folStrategy->Sort(folderA, folderB, &decision);
+
+        if (decision == nsAutoSyncStrategyDecisions::Higher && 0 == qidx)
+          mPriorityQ.InsertObjectAt(aAutoSyncStateObj, 0);
+        else if (decision == nsAutoSyncStrategyDecisions::Higher)
+          continue;
+        else if (decision == nsAutoSyncStrategyDecisions::Lower)
+          mPriorityQ.InsertObjectAt(aAutoSyncStateObj, qidx+1);
+        else //  decision == nsAutoSyncStrategyDecisions::Same
+          mPriorityQ.InsertObjectAt(aAutoSyncStateObj, qidx);
+
+        NOTIFY_LISTENERS(OnFolderAddedIntoQ, (nsIAutoSyncMgrListener::PriorityQueue, folderB));
+        break;
+      }//endwhile
+    }
+  }//endif
+}
+
+/**
+ * Zero aSizeLimit means no limit 
+ */
+nsresult nsAutoSyncManager::DownloadMessagesForOffline(nsIAutoSyncState *aAutoSyncStateObj, uint32_t aSizeLimit)
+{
+  if (!aAutoSyncStateObj)
+    return NS_ERROR_INVALID_ARG;
+
+  int32_t count;
+  nsresult rv = aAutoSyncStateObj->GetPendingMessageCount(&count);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // special case: no more message to download for this folder:
+  // see HandleDownloadErrorFor for recovery policy
+  if (!count)
+    return NS_ERROR_NOT_AVAILABLE;
+
+  nsCOMPtr<nsIMutableArray> messagesToDownload;
+  uint32_t totalSize = 0;
+  rv = aAutoSyncStateObj->GetNextGroupOfMessages(mGroupSize, &totalSize, getter_AddRefs(messagesToDownload));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // there are pending messages but the cumulative size is zero:
+  // treat as special case.
+  // Note that although it shouldn't happen, we know that sometimes
+  // imap servers manifest messages as zero length. By returning
+  // NS_ERROR_NOT_AVAILABLE we cause this folder to be removed from
+  // the priority queue temporarily (until the next idle or next update)
+  // in an effort to prevent it blocking other folders of the same account
+  // being synced.
+  if (!totalSize)
+    return NS_ERROR_NOT_AVAILABLE;
+
+  // ensure that we don't exceed the given size limit for this particular group
+  if (aSizeLimit && aSizeLimit < totalSize)
+    return NS_ERROR_FAILURE;
+
+  uint32_t length;
+  rv = messagesToDownload->GetLength(&length);
+  if (NS_SUCCEEDED(rv) && length > 0)
+  {
+    rv = aAutoSyncStateObj->DownloadMessagesForOffline(messagesToDownload);
+
+    int32_t totalCount;
+    (void) aAutoSyncStateObj->GetTotalMessageCount(&totalCount);
+
+    nsCOMPtr<nsIMsgFolder> folder;
+    aAutoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+    if (NS_SUCCEEDED(rv) && folder)
+      NOTIFY_LISTENERS(OnDownloadStarted, (folder, length, totalCount));
+  }
+
+  return rv;
+}
+
+/**
+ * Assuming that the download operation on the given folder has been failed at least once, 
+ * execute these steps:
+ *  - put the auto-sync state into ready-to-download mode
+ *  - rollback the message offset so we can try the same group again (unless the retry
+ *     count is reached to the given limit)
+ *  - if parallel model is active, wait to be resumed by the next idle
+ *  - if chained model is active, search the priority queue to find a sibling to continue 
+ *    with.
+ */
+nsresult nsAutoSyncManager::HandleDownloadErrorFor(nsIAutoSyncState *aAutoSyncStateObj,
+                                                   const nsresult error)
+{
+  if (!aAutoSyncStateObj)
+    return NS_ERROR_INVALID_ARG;
+  
+  // ensure that an error occured
+  if (NS_SUCCEEDED(error))
+    return NS_OK;
+    
+  // NS_ERROR_NOT_AVAILABLE is a special case/error happens when the queued folder
+  // doesn't have any message to download (see bug 457342). In such case we shouldn't
+  // retry the current message group, nor notify listeners. Simply continuing with the
+  // next sibling in the priority queue would suffice.
+    
+  if (NS_ERROR_NOT_AVAILABLE != error)
+  {
+    // force the auto-sync state to try downloading the same group at least
+    // kGroupRetryCount times before it moves to the next one
+    aAutoSyncStateObj->TryCurrentGroupAgain(kGroupRetryCount);
+    
+    nsCOMPtr<nsIMsgFolder> folder;
+    aAutoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+    if (folder)
+      NOTIFY_LISTENERS(OnDownloadError, (folder));
+  }
+  
+  // if parallel model, don't do anything else
+  
+  if (mDownloadModel == dmChained)
+  {
+    // switch to the next folder in the chain and continue downloading
+    nsIAutoSyncState *autoSyncStateObj = aAutoSyncStateObj;
+    nsIAutoSyncState *nextAutoSyncStateObj = nullptr;
+    while ( (nextAutoSyncStateObj = GetNextSibling(mPriorityQ, autoSyncStateObj)) )
+    {
+      autoSyncStateObj = nextAutoSyncStateObj;
+      nsresult rv = DownloadMessagesForOffline(autoSyncStateObj);
+      if (NS_SUCCEEDED(rv))
+        break;
+      else if (rv == NS_ERROR_NOT_AVAILABLE)
+        // next folder in the chain also doesn't have any message to download
+        // switch to next one if any
+        continue;
+      else
+        autoSyncStateObj->TryCurrentGroupAgain(kGroupRetryCount);
+    }
+  }
+  
+  return NS_OK;
+}
+
+uint32_t nsAutoSyncManager::GetUpdateIntervalFor(nsIAutoSyncState *aAutoSyncStateObj)
+{
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = aAutoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+  if (NS_FAILED(rv))
+    return kDefaultUpdateInterval;
+  
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = folder->GetServer(getter_AddRefs(server));
+  if (NS_FAILED(rv))
+    return kDefaultUpdateInterval;
+
+  if (server)
+  {
+    int32_t interval;
+    rv = server->GetBiffMinutes(&interval);
+    
+    if (NS_SUCCEEDED(rv))
+      return (uint32_t)interval;
+  }
+
+  return kDefaultUpdateInterval;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::GetGroupSize(uint32_t *aGroupSize)
+{
+  NS_ENSURE_ARG_POINTER(aGroupSize);
+  *aGroupSize = mGroupSize;
+  return NS_OK;
+}
+NS_IMETHODIMP nsAutoSyncManager::SetGroupSize(uint32_t aGroupSize)
+{
+  mGroupSize = aGroupSize ? aGroupSize : kDefaultGroupSize;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::GetMsgStrategy(nsIAutoSyncMsgStrategy * *aMsgStrategy)
+{
+  NS_ENSURE_ARG_POINTER(aMsgStrategy);
+  
+  // lazily create if it is not done already
+  if (!mMsgStrategyImpl)
+  {
+    mMsgStrategyImpl = new nsDefaultAutoSyncMsgStrategy;
+    if (!mMsgStrategyImpl)
+      return NS_ERROR_OUT_OF_MEMORY;
+  }
+  
+  NS_IF_ADDREF(*aMsgStrategy = mMsgStrategyImpl);
+  return NS_OK;
+}
+NS_IMETHODIMP nsAutoSyncManager::SetMsgStrategy(nsIAutoSyncMsgStrategy * aMsgStrategy)
+{
+  mMsgStrategyImpl = aMsgStrategy;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::GetFolderStrategy(nsIAutoSyncFolderStrategy * *aFolderStrategy)
+{
+  NS_ENSURE_ARG_POINTER(aFolderStrategy);
+  
+  // lazily create if it is not done already
+  if (!mFolderStrategyImpl)
+  {
+    mFolderStrategyImpl = new nsDefaultAutoSyncFolderStrategy;
+    if (!mFolderStrategyImpl)
+      return NS_ERROR_OUT_OF_MEMORY;
+  }
+    
+  NS_IF_ADDREF(*aFolderStrategy = mFolderStrategyImpl);
+  return NS_OK;
+}
+NS_IMETHODIMP nsAutoSyncManager::SetFolderStrategy(nsIAutoSyncFolderStrategy * aFolderStrategy)
+{
+  mFolderStrategyImpl = aFolderStrategy;
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsAutoSyncManager::DoesMsgFitDownloadCriteria(nsIMsgDBHdr *aMsgHdr, bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  uint32_t msgFlags = 0;
+  aMsgHdr->GetFlags(&msgFlags);
+
+  // check whether this message is marked imap deleted or not 
+  *aResult = !(msgFlags & nsMsgMessageFlags::IMAPDeleted);
+  if (!(*aResult))
+    return NS_OK;
+
+  bool shouldStoreMsgOffline = true;
+  nsCOMPtr<nsIMsgFolder> folder;
+  aMsgHdr->GetFolder(getter_AddRefs(folder));
+  if (folder)
+  {
+    nsMsgKey msgKey;
+    nsresult rv = aMsgHdr->GetMessageKey(&msgKey);
+    // a cheap way to get the size limit for this folder and make
+    // sure that we don't have this message offline already
+    if (NS_SUCCEEDED(rv))
+      folder->ShouldStoreMsgOffline(msgKey, &shouldStoreMsgOffline);
+  }
+
+  *aResult &= shouldStoreMsgOffline;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::OnDownloadQChanged(nsIAutoSyncState *aAutoSyncStateObj)
+{
+  nsCOMPtr<nsIAutoSyncState> autoSyncStateObj(aAutoSyncStateObj);
+  if (!autoSyncStateObj)
+    return NS_ERROR_INVALID_ARG;
+
+  if (mPaused)
+    return NS_OK;
+  // We want to start downloading immediately unless the folder is excluded.
+  bool excluded = false;
+  nsCOMPtr<nsIAutoSyncFolderStrategy> folStrategy;
+  nsCOMPtr<nsIMsgFolder> folder;
+
+  GetFolderStrategy(getter_AddRefs(folStrategy));
+  autoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+
+  if (folder && folStrategy)
+    folStrategy->IsExcluded(folder, &excluded);
+
+  nsresult rv = NS_OK;
+
+  if (!excluded)
+  {
+    // Add this folder into the priority queue.
+    autoSyncStateObj->SetState(nsAutoSyncState::stReadyToDownload);
+    ScheduleFolderForOfflineDownload(autoSyncStateObj);
+
+    // If we operate in parallel mode or if there is no sibling downloading messages at the moment,
+    // we can download the first group of the messages for this folder
+    if (mDownloadModel == dmParallel ||
+        !DoesQContainAnySiblingOf(mPriorityQ, autoSyncStateObj, nsAutoSyncState::stDownloadInProgress))
+    {
+      // this will download the first group of messages immediately;
+      // to ensure that we don't end up downloading a large single message in not-idle time, 
+      // we enforce a limit. If there is no message fits into this limit we postpone the 
+      // download until the next idle.
+      if (GetIdleState() == notIdle)
+        rv =  DownloadMessagesForOffline(autoSyncStateObj, kFirstGroupSizeLimit);
+      else
+        rv = DownloadMessagesForOffline(autoSyncStateObj);
+      
+      if (NS_FAILED(rv))
+        autoSyncStateObj->TryCurrentGroupAgain(kGroupRetryCount);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP 
+nsAutoSyncManager::OnDownloadStarted(nsIAutoSyncState *aAutoSyncStateObj, nsresult aStartCode)
+{
+  nsCOMPtr<nsIAutoSyncState> autoSyncStateObj(aAutoSyncStateObj);
+  if (!autoSyncStateObj)
+    return NS_ERROR_INVALID_ARG;
+
+  // resume downloads during next idle time
+  if (NS_FAILED(aStartCode))
+    autoSyncStateObj->SetState(nsAutoSyncState::stReadyToDownload);  
+  
+  return aStartCode;
+}
+
+NS_IMETHODIMP 
+nsAutoSyncManager::OnDownloadCompleted(nsIAutoSyncState *aAutoSyncStateObj, nsresult aExitCode)
+{
+  nsCOMPtr<nsIAutoSyncState> autoSyncStateObj(aAutoSyncStateObj);
+  if (!autoSyncStateObj)
+    return NS_ERROR_INVALID_ARG;    
+
+  nsresult rv = aExitCode;
+
+  if (NS_FAILED(aExitCode))
+  {
+    // retry the same group kGroupRetryCount times
+    // try again if TB still idle, otherwise wait for the next idle time
+    autoSyncStateObj->TryCurrentGroupAgain(kGroupRetryCount);
+    if (GetIdleState() != notIdle)
+    {
+      rv = DownloadMessagesForOffline(autoSyncStateObj);
+      if (NS_FAILED(rv))
+        rv = HandleDownloadErrorFor(autoSyncStateObj, rv);
+    }
+    return rv;
+  }
+      
+  // download is successful, reset the retry counter of the folder
+  autoSyncStateObj->ResetRetryCounter();
+  
+  nsCOMPtr<nsIMsgFolder> folder;
+  aAutoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+  if (folder)
+    NOTIFY_LISTENERS(OnDownloadCompleted, (folder));
+      
+  int32_t count;
+  rv = autoSyncStateObj->GetPendingMessageCount(&count);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  nsIAutoSyncState *nextFolderToDownload = nullptr;
+  if (count > 0)
+  {
+    autoSyncStateObj->SetState(nsAutoSyncState::stReadyToDownload);
+    
+    // in parallel model, we continue downloading the same folder as long as it has
+    // more pending messages
+    nextFolderToDownload = autoSyncStateObj;
+    
+    // in chained model, ensure that we are always downloading the highest priority 
+    // folder first 
+    if (mDownloadModel == dmChained)
+    {
+      // switch to higher priority folder and continue to download, 
+      // if any added recently
+      int32_t myIndex = mPriorityQ.IndexOf(autoSyncStateObj);
+      
+      int32_t siblingIndex;
+      nsIAutoSyncState *sibling = GetHighestPrioSibling(mPriorityQ, autoSyncStateObj, &siblingIndex);
+      
+      // lesser index = higher priority
+      if (sibling && myIndex > -1 && siblingIndex < myIndex) 
+        nextFolderToDownload = sibling;
+    }
+  }
+  else 
+  {
+    autoSyncStateObj->SetState(nsAutoSyncState::stCompletedIdle);
+    
+    nsCOMPtr<nsIMsgFolder> folder;
+    nsresult rv = autoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+    
+    if (NS_SUCCEEDED(rv) && mPriorityQ.RemoveObject(autoSyncStateObj))
+      NOTIFY_LISTENERS(OnFolderRemovedFromQ, (nsIAutoSyncMgrListener::PriorityQueue, folder));
+
+    //find the next folder owned by the same server in the queue and continue downloading
+    if (mDownloadModel == dmChained)
+      nextFolderToDownload = GetHighestPrioSibling(mPriorityQ, autoSyncStateObj);
+      
+  }//endif
+  
+  // continue downloading if TB is still in idle state
+  if (nextFolderToDownload && GetIdleState() != notIdle)
+  {
+    rv = DownloadMessagesForOffline(nextFolderToDownload);
+    if (NS_FAILED(rv))
+      rv = HandleDownloadErrorFor(nextFolderToDownload, rv);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::GetDownloadModel(int32_t *aDownloadModel)
+{
+  NS_ENSURE_ARG_POINTER(aDownloadModel);
+  *aDownloadModel = mDownloadModel;
+  return NS_OK;
+}
+NS_IMETHODIMP nsAutoSyncManager::SetDownloadModel(int32_t aDownloadModel)
+{
+  mDownloadModel = aDownloadModel;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::AddListener(nsIAutoSyncMgrListener *aListener)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+  mListeners.AppendElementUnlessExists(aListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncManager::RemoveListener(nsIAutoSyncMgrListener *aListener)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+  mListeners.RemoveElement(aListener);
+  return NS_OK;
+}
+
+/* readonly attribute unsigned long discoveryQLength; */
+NS_IMETHODIMP nsAutoSyncManager::GetDiscoveryQLength(uint32_t *aDiscoveryQLength)
+{
+  NS_ENSURE_ARG_POINTER(aDiscoveryQLength);
+  *aDiscoveryQLength = mDiscoveryQ.Count();
+  return NS_OK;
+}
+
+/* readonly attribute unsigned long uploadQLength; */
+NS_IMETHODIMP nsAutoSyncManager::GetUpdateQLength(uint32_t *aUpdateQLength)
+{
+  NS_ENSURE_ARG_POINTER(aUpdateQLength);
+  *aUpdateQLength = mUpdateQ.Count();
+  return NS_OK;
+}
+
+/* readonly attribute unsigned long downloadQLength; */
+NS_IMETHODIMP nsAutoSyncManager::GetDownloadQLength(uint32_t *aDownloadQLength)
+{
+  NS_ENSURE_ARG_POINTER(aDownloadQLength);
+  *aDownloadQLength = mPriorityQ.Count();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoSyncManager::OnFolderHasPendingMsgs(nsIAutoSyncState *aAutoSyncStateObj)
+{
+  NS_ENSURE_ARG_POINTER(aAutoSyncStateObj);
+  if (mUpdateQ.IndexOf(aAutoSyncStateObj) == -1)
+  {
+    nsCOMPtr<nsIMsgFolder> folder;
+    aAutoSyncStateObj->GetOwnerFolder(getter_AddRefs(folder));
+    // If this folder isn't the trash, add it to the update q.
+    if (folder)
+    {
+      bool isTrash;
+      folder->GetFlag(nsMsgFolderFlags::Trash, &isTrash);
+      if (!isTrash)
+      {
+        bool isSentOrArchive;
+        folder->IsSpecialFolder(nsMsgFolderFlags::SentMail|
+                                nsMsgFolderFlags::Archive,
+                                true, &isSentOrArchive);
+        // Sent or archive folders go to the q front, the rest to the end.
+        if (isSentOrArchive)
+          mUpdateQ.InsertObjectAt(aAutoSyncStateObj, 0);
+        else
+          mUpdateQ.AppendObject(aAutoSyncStateObj);
+        aAutoSyncStateObj->SetState(nsAutoSyncState::stUpdateNeeded);
+        NOTIFY_LISTENERS(OnFolderAddedIntoQ,
+                        (nsIAutoSyncMgrListener::UpdateQueue, folder));
+      }
+    }
+  }
+  return NS_OK;
+}
+
+void nsAutoSyncManager::SetIdleState(IdleState st) 
+{ 
+  mIdleState = st;
+}
+
+nsAutoSyncManager::IdleState nsAutoSyncManager::GetIdleState() const 
+{ 
+  return mIdleState; 
+}
+
+NS_IMPL_ISUPPORTS(nsAutoSyncManager, nsIObserver, nsIUrlListener, nsIAutoSyncManager)
diff --git a/mailnews/imap/src/nsAutoSyncManager.h b/mailnews/imap/src/nsAutoSyncManager.h
new file mode 100644
index 0000000000..2b98b7b82e
--- /dev/null
+++ b/mailnews/imap/src/nsAutoSyncManager.h
@@ -0,0 +1,265 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsAutoSyncManager_h__
+#define nsAutoSyncManager_h__
+
+#include "nsAutoPtr.h"
+#include "nsStringGlue.h"
+#include "nsCOMArray.h"
+#include "nsIObserver.h"
+#include "nsIUrlListener.h"
+#include "nsITimer.h"
+#include "nsTObserverArray.h"
+#include "nsIAutoSyncManager.h"
+#include "nsIAutoSyncMsgStrategy.h"
+#include "nsIAutoSyncFolderStrategy.h"
+#include "prtime.h"
+
+class nsImapMailFolder;
+class nsIMsgDBHdr;
+class nsIIdleService;
+class nsIMsgFolder;
+
+/* Auto-Sync
+ *
+ * Background:
+ *  it works only with offline imap folders. "autosync_offline_stores" pref
+ *  enables/disables auto-sync mechanism. Note that setting "autosync_offline_stores"
+ *  to false, or setting folder to not-offline doesn't stop synchronization
+ *  process for already queued folders.
+ *
+ * Auto-Sync policy:
+ *  o It kicks in during system idle time, and tries to download as much messages
+ *    as possible based on given folder and message prioritization strategies/rules.
+ *    Default folder prioritization strategy dictates to sort the folders based on the
+ *    following order:  INBOX > DRAFTS > SUBFOLDERS > TRASH.
+ *    Similarly, default message prioritization strategy dictates to download the most
+ *    recent and smallest message first. Also, by sorting the messages by size in the 
+ *    queue, it tries to maximize the number of messages downloaded.
+ *  o It downloads the messages in groups. Default groups size is defined by |kDefaultGroupSize|. 
+ *  o It downloads the messages larger than the group size one-by-one.
+ *  o If new messages arrive when not idle, it downloads the messages that do fit into
+ *    |kFirstGroupSizeLimit| size limit immediately, without waiting for idle time, unless there is
+ *    a sibling (a folder owned by the same imap server) in stDownloadInProgress state in the q
+ *  o If new messages arrive when idle, it downloads all the messages without any restriction.
+ *  o If new messages arrive into a folder while auto-sync is downloading other messages of the
+ *    same folder, it simply puts the new messages into the folder's download queue, and
+ *    re-prioritize the messages. That behavior makes sure that the high priority
+ *    (defined by the message strategy) get downloaded first always.
+ *  o If new messages arrive into a folder while auto-sync is downloading messages of a lower
+ *    priority folder, auto-sync switches the folders in the queue and starts downloading the
+ *    messages of the higher priority folder next time it downloads a message group.
+ *  o Currently there is no way to stop/pause/cancel a message download. The smallest
+ *    granularity is the message group size.
+ *  o Auto-Sync manager periodically (kAutoSyncFreq) checks folder for existing messages
+ *    w/o bodies. It persists the last time the folder is checked in the local database of the
+ *    folder. We call this process 'Discovery'. This process is asynchronous and processes
+ *    |kNumberOfHeadersToProcess| number of headers at each cycle. Since it works on local data,
+ *    it doesn't consume lots of system resources, it does its job fast.
+ *  o Discovery is necessary especially when the user makes a transition from not-offline 
+ *    to offline mode.
+ *  o Update frequency is defined by nsMsgIncomingServer::BiffMinutes.
+ *
+ * Error Handling:
+ *  o if the user moves/deletes/filters all messages of a folder already queued, auto-sync
+ *    deals with that situation by skipping the folder in question, and continuing with the
+ *    next in chain.
+ *  o If the message size is zero, auto-sync ignores the message.
+ *  o If the download of the message group fails for some reason, auto-sync tries to
+ *    download the same group |kGroupRetryCount| times. If it still fails, continues with the
+ *    next group of messages.
+ *
+ * Download Model:
+ *  Parallel model should be used with the imap servers that do not have any "max number of sessions
+ *  per IP" limit, and when the bandwidth is significantly large.
+ *
+ * How it really works:
+ * The AutoSyncManager gets an idle notification. First it processes any
+ * folders in the discovery queue (which means it schedules message download
+ * for any messages it previously determined it should download). Then it sets
+ * a timer, and in the timer callback, it processes the update q, by calling 
+ * InitiateAutoSync on the first folder in the update q.
+ */
+ 
+/**
+ * Default strategy implementation to prioritize messages in the download queue.   
+ */
+class nsDefaultAutoSyncMsgStrategy final : public nsIAutoSyncMsgStrategy
+{
+  static const uint32_t kFirstPassMessageSize = 60U*1024U; // 60K
+
+  public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIAUTOSYNCMSGSTRATEGY
+
+    nsDefaultAutoSyncMsgStrategy();
+
+  private:
+    ~nsDefaultAutoSyncMsgStrategy();
+};
+
+/**
+ * Default strategy implementation to prioritize folders in the download queue.  
+ */
+class nsDefaultAutoSyncFolderStrategy final : public nsIAutoSyncFolderStrategy
+{
+  public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIAUTOSYNCFOLDERSTRATEGY
+
+    nsDefaultAutoSyncFolderStrategy();
+
+  private:
+    ~nsDefaultAutoSyncFolderStrategy();
+};
+
+// see the end of the page for auto-sync internals
+
+/**
+ * Manages background message download operations for offline imap folders. 
+ */
+class nsAutoSyncManager final : public nsIObserver,
+                                public nsIUrlListener,
+                                public nsIAutoSyncManager
+{
+  static const PRTime kAutoSyncFreq = 60UL * (PR_USEC_PER_SEC * 60UL);  // 1hr
+  static const uint32_t kDefaultUpdateInterval = 10UL;                  // 10min
+  static const int32_t kTimerIntervalInMs = 400;
+  static const uint32_t kNumberOfHeadersToProcess = 250U;
+  // enforced size of the first group that will be downloaded before idle time
+  static const uint32_t kFirstGroupSizeLimit = 60U*1024U /* 60K */; 
+  static const int32_t kIdleTimeInSec = 10;
+  static const uint32_t kGroupRetryCount = 3;
+
+  enum IdleState { systemIdle, appIdle, notIdle };
+  enum UpdateState { initiated, completed };
+      
+  public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIOBSERVER
+    NS_DECL_NSIURLLISTENER
+    NS_DECL_NSIAUTOSYNCMANAGER
+
+    nsAutoSyncManager();
+
+  private:
+    ~nsAutoSyncManager();
+
+    void SetIdleState(IdleState st);
+    IdleState GetIdleState() const;
+    nsresult StartIdleProcessing();
+    nsresult AutoUpdateFolders(); 
+    void ScheduleFolderForOfflineDownload(nsIAutoSyncState *aAutoSyncStateObj);
+    nsresult DownloadMessagesForOffline(nsIAutoSyncState *aAutoSyncStateObj, uint32_t aSizeLimit = 0);
+    nsresult HandleDownloadErrorFor(nsIAutoSyncState *aAutoSyncStateObj, const nsresult error);
+
+    // Helper methods for priority Q operations
+    static
+    void ChainFoldersInQ(const nsCOMArray<nsIAutoSyncState> &aQueue,
+                          nsCOMArray<nsIAutoSyncState> &aChainedQ);
+    static
+    nsIAutoSyncState* SearchQForSibling(const nsCOMArray<nsIAutoSyncState> &aQueue,
+                          nsIAutoSyncState *aAutoSyncStateObj, int32_t aStartIdx, int32_t *aIndex = nullptr);
+    static
+    bool DoesQContainAnySiblingOf(const nsCOMArray<nsIAutoSyncState> &aQueue, 
+                          nsIAutoSyncState *aAutoSyncStateObj, const int32_t aState, 
+                          int32_t *aIndex = nullptr);
+    static 
+    nsIAutoSyncState* GetNextSibling(const nsCOMArray<nsIAutoSyncState> &aQueue, 
+                          nsIAutoSyncState *aAutoSyncStateObj, int32_t *aIndex = nullptr);
+    static 
+    nsIAutoSyncState* GetHighestPrioSibling(const nsCOMArray<nsIAutoSyncState> &aQueue, 
+                          nsIAutoSyncState *aAutoSyncStateObj, int32_t *aIndex = nullptr);
+
+    /// timer to process existing keys and updates
+    void InitTimer();
+    static void TimerCallback(nsITimer *aTimer, void *aClosure);
+    void StopTimer();
+    void StartTimerIfNeeded();
+
+    /// pref helpers
+    uint32_t GetUpdateIntervalFor(nsIAutoSyncState *aAutoSyncStateObj);
+
+  protected:
+    nsCOMPtr<nsIAutoSyncMsgStrategy> mMsgStrategyImpl;
+    nsCOMPtr<nsIAutoSyncFolderStrategy> mFolderStrategyImpl;
+    // contains the folders that will be downloaded on background
+    nsCOMArray<nsIAutoSyncState> mPriorityQ;
+    // contains the folders that will be examined for existing headers and
+    // adds the headers we don't have offline into the autosyncState
+    // object's download queue.
+    nsCOMArray<nsIAutoSyncState> mDiscoveryQ;
+    // contains the folders that will be checked for new messages with STATUS,
+    // and if there are any, we'll call UpdateFolder on them.
+    nsCOMArray<nsIAutoSyncState> mUpdateQ;
+    // this is the update state for the current folder.
+    UpdateState mUpdateState;
+
+    // This is set if auto sync has been completely paused.
+    bool mPaused;
+    // This is set if we've finished startup and should start
+    // paying attention to idle notifications.
+    bool mStartupDone;
+
+  private:
+    uint32_t mGroupSize;
+    IdleState mIdleState;
+    int32_t mDownloadModel;
+    nsCOMPtr<nsIIdleService> mIdleService;
+    nsCOMPtr<nsITimer> mTimer;
+    nsTObserverArray<nsCOMPtr<nsIAutoSyncMgrListener> > mListeners;
+};
+
+#endif
+
+/*
+How queues inter-relate:
+
+nsAutoSyncState has an internal priority queue to store messages waiting to be
+downloaded. nsAutoSyncMsgStrategy object determines the order in this queue,
+nsAutoSyncManager uses this queue to manage downloads. Two events cause a
+change in this queue: 
+
+1) nsImapMailFolder::HeaderFetchCompleted: is triggered when TB notices that
+there are pending messages on the server -- via IDLE command from the server, 
+via explicit select from the user, or via automatic Update during idle time. If 
+it turns out that there are pending messages on the server, it adds them into 
+nsAutoSyncState's download queue.
+
+2) nsAutoSyncState::ProcessExistingHeaders: is triggered for every imap folder 
+every hour or so (see kAutoSyncFreq). nsAutoSyncManager uses an internal queue called Discovery 
+queue to keep track of this task. The purpose of ProcessExistingHeaders() 
+method is to check existing headers of a given folder in batches and discover 
+the messages without bodies, in asynchronous fashion. This process is 
+sequential, one and only one folder at any given time, very similar to 
+indexing. Again, if it turns out that the folder in hand has messages w/o 
+bodies, ProcessExistingHeaders adds them into nsAutoSyncState's download queue.
+
+Any change in nsAutoSyncState's download queue, notifies nsAutoSyncManager and 
+nsAutoSyncManager puts the requesting  nsAutoSyncState into its internal 
+priority queue (called mPriorityQ) -- if the folder is not already there. 
+nsAutoSyncFolderStrategy object determines the order in this queue. This queue 
+is processed in two modes: chained and parallel. 
+
+i) Chained: One folder per imap server any given time. Folders owned by 
+different imap servers are simultaneous.
+
+ii) Parallel: All folders at the same time, using all cached-connections - 
+a.k.a 'Folders gone wild' mode.
+
+The order the folders are added into the mPriorityQ doesn't matter since every
+time a batch completed for an imap server, nsAutoSyncManager adjusts the order.
+So, lets say that updating a sub-folder starts downloading message immediately,
+when an higher priority folder is added into the queue, nsAutoSyncManager
+switches to this higher priority folder instead of processing the next group of
+messages of the lower priority one. Setting group size too high might delay
+this switch at worst. 
+
+And finally, Update queue helps nsAutoSyncManager to keep track of folders 
+waiting to be updated. With the latest change, we update one and only one
+folder at any given time. Default frequency of updating is 10 min (kDefaultUpdateInterval). 
+We add folders into the update queue during idle time, if they are not in mPriorityQ already.
+
+*/
diff --git a/mailnews/imap/src/nsAutoSyncState.cpp b/mailnews/imap/src/nsAutoSyncState.cpp
new file mode 100644
index 0000000000..7b1aeabbe1
--- /dev/null
+++ b/mailnews/imap/src/nsAutoSyncState.cpp
@@ -0,0 +1,765 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.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 "nsAutoSyncState.h"
+#include "nsImapMailFolder.h"
+#include "nsMsgImapCID.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsMsgKeyArray.h"
+#include "nsIMsgWindow.h"
+#include "nsIMsgMailSession.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIAutoSyncManager.h"
+#include "nsIAutoSyncMsgStrategy.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "mozilla/Logging.h"
+
+using namespace mozilla;
+
+extern PRLogModuleInfo *gAutoSyncLog;
+
+MsgStrategyComparatorAdaptor::MsgStrategyComparatorAdaptor(nsIAutoSyncMsgStrategy* aStrategy, 
+  nsIMsgFolder *aFolder, nsIMsgDatabase *aDatabase) : mStrategy(aStrategy), mFolder(aFolder), 
+    mDatabase(aDatabase)
+{
+}
+
+/** @return True if the elements are equals; false otherwise. */
+bool MsgStrategyComparatorAdaptor::Equals(const nsMsgKey& a, const nsMsgKey& b) const
+{
+  nsCOMPtr<nsIMsgDBHdr> hdrA;
+  nsCOMPtr<nsIMsgDBHdr> hdrB;
+
+  mDatabase->GetMsgHdrForKey(a, getter_AddRefs(hdrA));
+  mDatabase->GetMsgHdrForKey(b, getter_AddRefs(hdrB));
+
+  if (hdrA && hdrB)
+  {
+    nsresult rv = NS_OK;
+    nsAutoSyncStrategyDecisionType decision = nsAutoSyncStrategyDecisions::Same;
+
+    nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(mFolder);
+    if (mStrategy)
+      rv = mStrategy->Sort(folder, hdrA, hdrB, &decision);
+
+    if (NS_SUCCEEDED(rv))
+      return (decision == nsAutoSyncStrategyDecisions::Same);
+  }
+
+  return false;
+}
+
+/** @return True if (a < b); false otherwise. */
+bool MsgStrategyComparatorAdaptor::LessThan(const nsMsgKey& a, const nsMsgKey& b) const
+{
+  nsCOMPtr<nsIMsgDBHdr> hdrA;
+  nsCOMPtr<nsIMsgDBHdr> hdrB;
+
+  mDatabase->GetMsgHdrForKey(a, getter_AddRefs(hdrA));
+  mDatabase->GetMsgHdrForKey(b, getter_AddRefs(hdrB));
+
+  if (hdrA && hdrB)
+  {
+    nsresult rv = NS_OK;
+    nsAutoSyncStrategyDecisionType decision = nsAutoSyncStrategyDecisions::Same;
+
+    nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(mFolder);
+    if (mStrategy)
+      rv = mStrategy->Sort(folder, hdrA, hdrB, &decision);
+
+    if (NS_SUCCEEDED(rv))
+      return (decision == nsAutoSyncStrategyDecisions::Lower);
+  }
+
+  return false;
+}
+
+nsAutoSyncState::nsAutoSyncState(nsImapMailFolder *aOwnerFolder, PRTime aLastSyncTime)
+  : mSyncState(stCompletedIdle), mOffset(0U), mLastOffset(0U), mLastServerTotal(0),
+    mLastServerRecent(0), mLastServerUnseen(0), mLastNextUID(0),
+    mLastSyncTime(aLastSyncTime), mLastUpdateTime(0UL), mProcessPointer(0U),
+    mIsDownloadQChanged(false), mRetryCounter(0U)
+{
+  mOwnerFolder = do_GetWeakReference(static_cast<nsIMsgImapMailFolder*>(aOwnerFolder));
+}
+
+nsAutoSyncState::~nsAutoSyncState()
+{
+}
+
+// TODO:XXXemre should be implemented when we start
+// doing space management
+nsresult nsAutoSyncState::ManageStorageSpace()
+{
+  return NS_OK;
+}
+
+nsresult nsAutoSyncState::PlaceIntoDownloadQ(const nsTArray<nsMsgKey> &aMsgKeyList)
+{
+  nsresult rv = NS_OK;
+  if (!aMsgKeyList.IsEmpty())
+  {
+    nsCOMPtr <nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+        
+    nsCOMPtr<nsIMsgDatabase> database;
+    rv = folder->GetMsgDatabase(getter_AddRefs(database));
+    if (!database)
+      return NS_ERROR_FAILURE;
+    
+    nsCOMPtr<nsIAutoSyncManager> autoSyncMgr = do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+    
+    nsCOMPtr<nsIAutoSyncMsgStrategy> msgStrategy;
+    autoSyncMgr->GetMsgStrategy(getter_AddRefs(msgStrategy));
+    
+    // increase the array size
+    mDownloadQ.SetCapacity(mDownloadQ.Length() + aMsgKeyList.Length());
+    
+    // remove excluded messages
+    int32_t elemCount = aMsgKeyList.Length();
+    for (int32_t idx = 0; idx < elemCount; idx++)
+    {
+      nsCOMPtr<nsIMsgDBHdr> hdr;
+      bool containsKey;
+      database->ContainsKey(aMsgKeyList[idx], &containsKey);
+      if (!containsKey)
+        continue;
+      rv = database->GetMsgHdrForKey(aMsgKeyList[idx], getter_AddRefs(hdr));
+      if(!hdr)
+        continue; // can't get message header, continue with the next one
+      
+      bool doesFit = true;
+      rv = autoSyncMgr->DoesMsgFitDownloadCriteria(hdr, &doesFit);
+      if (NS_SUCCEEDED(rv) && !mDownloadSet.Contains(aMsgKeyList[idx]) && doesFit)
+      {
+        bool excluded = false;
+        if (msgStrategy)
+        {
+          rv = msgStrategy->IsExcluded(folder, hdr, &excluded);
+          
+          if (NS_SUCCEEDED(rv) && !excluded)
+          {
+            mIsDownloadQChanged = true;
+            mDownloadSet.PutEntry(aMsgKeyList[idx]);
+            mDownloadQ.AppendElement(aMsgKeyList[idx]);
+          }
+        }
+      }
+    }//endfor
+
+    if (mIsDownloadQChanged)
+    {
+      LogOwnerFolderName("Download Q is created for ");
+      LogQWithSize(mDownloadQ, 0);
+      rv = autoSyncMgr->OnDownloadQChanged(this);
+    }
+    
+  }
+  return rv;
+}
+
+nsresult nsAutoSyncState::SortQueueBasedOnStrategy(nsTArray<nsMsgKey> &aQueue)
+{
+  nsresult rv;
+  nsCOMPtr <nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgDatabase> database;
+  rv = folder->GetMsgDatabase(getter_AddRefs(database));
+  if (!database)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr = do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIAutoSyncMsgStrategy> msgStrategy;
+  rv = autoSyncMgr->GetMsgStrategy(getter_AddRefs(msgStrategy));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  MsgStrategyComparatorAdaptor strategyComp(msgStrategy, folder, database);
+  aQueue.Sort(strategyComp);
+
+  return rv;
+}
+
+// This method is a hack to prioritize newly inserted messages,
+// without changing the size of the queue. It is required since 
+// we cannot sort ranges in nsTArray.
+nsresult nsAutoSyncState::SortSubQueueBasedOnStrategy(nsTArray<nsMsgKey> &aQueue,
+                                                      uint32_t aStartingOffset)
+{
+  NS_ASSERTION(aStartingOffset < aQueue.Length(), "*** Starting offset is out of range");
+
+  // Copy already downloaded messages into a temporary queue,
+  // we want to exclude them from the sort.
+  nsTArray<nsMsgKey> tmpQ;
+  tmpQ.AppendElements(aQueue.Elements(), aStartingOffset);
+
+  // Remove already downloaded messages and sort the resulting queue
+  aQueue.RemoveElementsAt(0, aStartingOffset);
+
+  nsresult rv = SortQueueBasedOnStrategy(aQueue);
+
+  // copy excluded messages back
+  aQueue.InsertElementsAt(0, tmpQ);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsAutoSyncState::GetNextGroupOfMessages(uint32_t aSuggestedGroupSizeLimit, 
+                                                      uint32_t *aActualGroupSize, 
+                                                      nsIMutableArray **aMessagesList)
+{
+  NS_ENSURE_ARG_POINTER(aMessagesList);
+  NS_ENSURE_ARG_POINTER(aActualGroupSize);
+
+  *aActualGroupSize = 0;
+
+  nsresult rv;
+  nsCOMPtr <nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgDatabase> database;
+  folder->GetMsgDatabase(getter_AddRefs(database));
+
+  nsCOMPtr<nsIMutableArray> group = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  if (database)
+  {
+    if (!mDownloadQ.IsEmpty())
+    {
+      // sort the download queue if new items are added since the last time
+      if (mIsDownloadQChanged)
+      {
+        // we want to sort only pending messages. mOffset is
+        // the position of the first pending message in the download queue
+        rv = (mOffset > 0)
+          ? SortSubQueueBasedOnStrategy(mDownloadQ, mOffset)
+          : SortQueueBasedOnStrategy(mDownloadQ);
+
+        if (NS_SUCCEEDED(rv))
+          mIsDownloadQChanged = false;
+      }
+
+      nsCOMPtr<nsIAutoSyncManager> autoSyncMgr = do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      uint32_t msgCount = mDownloadQ.Length();
+      uint32_t idx = mOffset;
+
+      nsCOMPtr<nsIAutoSyncMsgStrategy> msgStrategy;
+      autoSyncMgr->GetMsgStrategy(getter_AddRefs(msgStrategy));
+
+      for (; idx < msgCount; idx++)
+      {
+        bool containsKey = false;
+        database->ContainsKey(mDownloadQ[idx], &containsKey);
+        if (!containsKey)
+        {
+          mDownloadSet.RemoveEntry(mDownloadQ[idx]);
+          mDownloadQ.RemoveElementAt(idx--);
+          msgCount--;
+          continue;
+        }
+        nsCOMPtr<nsIMsgDBHdr> qhdr;
+        database->GetMsgHdrForKey(mDownloadQ[idx], getter_AddRefs(qhdr));
+        if(!qhdr)
+          continue; //maybe deleted, skip it!
+
+        // ensure that we don't have this message body offline already,
+        // possible if the user explicitly selects this message prior
+        // to auto-sync kicks in
+        bool hasMessageOffline;
+        folder->HasMsgOffline(mDownloadQ[idx], &hasMessageOffline);
+        if (hasMessageOffline)
+          continue;
+
+        // this check point allows msg strategy function
+        // to do last minute decisions based on the current
+        // state of TB such as the size of the message store etc.
+        if (msgStrategy)
+        {
+          bool excluded = false;
+          if (NS_SUCCEEDED(msgStrategy->IsExcluded(folder, qhdr, &excluded)) && excluded)
+            continue;
+        }
+
+        uint32_t msgSize;
+        qhdr->GetMessageSize(&msgSize);
+        // ignore 0 byte messages; the imap parser asserts when we try 
+        // to download them, and there's no point anyway.
+        if (!msgSize)
+          continue;
+
+        if (!*aActualGroupSize && msgSize >= aSuggestedGroupSizeLimit) 
+        {
+          *aActualGroupSize = msgSize;
+          group->AppendElement(qhdr, false);
+          idx++;
+          break;
+        }
+        else if ((*aActualGroupSize) + msgSize > aSuggestedGroupSizeLimit)
+          break;
+        else
+        {
+          group->AppendElement(qhdr, false);
+          *aActualGroupSize += msgSize;
+        }
+      }// endfor
+
+      mLastOffset = mOffset;
+      mOffset = idx;
+    }
+
+    LogOwnerFolderName("Next group of messages to be downloaded.");
+    LogQWithSize(group.get(), 0);
+  } //endif
+
+   // return it to the caller
+  NS_IF_ADDREF(*aMessagesList = group);
+
+  return NS_OK;
+}
+
+/**
+ * Usually called by nsAutoSyncManager when the last sync time is expired.
+ */
+NS_IMETHODIMP nsAutoSyncState::ProcessExistingHeaders(uint32_t aNumOfHdrsToProcess, uint32_t *aLeftToProcess)
+{
+  NS_ENSURE_ARG_POINTER(aLeftToProcess);
+
+  nsresult rv;
+  nsCOMPtr <nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgDatabase> database;
+  rv = folder->GetMsgDatabase(getter_AddRefs(database));
+  if (!database)
+    return NS_ERROR_FAILURE;
+
+  // create a queue to process existing headers for the first time
+  if (mExistingHeadersQ.IsEmpty())
+  {
+    RefPtr<nsMsgKeyArray> keys = new nsMsgKeyArray;
+    rv = database->ListAllKeys(keys);
+    NS_ENSURE_SUCCESS(rv, rv);
+    keys->Sort();
+    mExistingHeadersQ.AppendElements(keys->m_keys);
+    mProcessPointer = 0;
+  }
+
+  // process the existing headers and find the messages not downloaded yet
+  uint32_t lastIdx = mProcessPointer;
+  nsTArray<nsMsgKey> msgKeys;
+  uint32_t keyCount = mExistingHeadersQ.Length();
+  for (; mProcessPointer < (lastIdx + aNumOfHdrsToProcess) && mProcessPointer < keyCount; mProcessPointer++)
+  {
+    bool hasMessageOffline;
+    folder->HasMsgOffline(mExistingHeadersQ[mProcessPointer], &hasMessageOffline);
+    if (!hasMessageOffline)
+      msgKeys.AppendElement(mExistingHeadersQ[mProcessPointer]);
+  }
+  if (!msgKeys.IsEmpty())
+  {
+    nsCString folderName;
+    folder->GetURI(folderName);
+    MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
+          ("%d messages will be added into the download q of folder %s\n",
+            msgKeys.Length(), folderName.get()));
+
+    rv = PlaceIntoDownloadQ(msgKeys);
+    if (NS_FAILED(rv))
+      mProcessPointer = lastIdx;
+  }
+
+  *aLeftToProcess = keyCount - mProcessPointer;
+
+  // cleanup if we are done processing
+  if (0 == *aLeftToProcess)
+  {
+    mLastSyncTime = PR_Now();
+    mExistingHeadersQ.Clear();
+    mProcessPointer = 0;
+    folder->SetMsgDatabase(nullptr);
+  }
+
+  return rv;
+}
+
+void nsAutoSyncState::OnNewHeaderFetchCompleted(const nsTArray<nsMsgKey> &aMsgKeyList)
+{
+  SetLastUpdateTime(PR_Now());
+  if (!aMsgKeyList.IsEmpty())
+    PlaceIntoDownloadQ(aMsgKeyList);
+}
+
+NS_IMETHODIMP nsAutoSyncState::UpdateFolder()
+{
+  nsresult rv;
+  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr = do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIUrlListener> autoSyncMgrListener = do_QueryInterface(autoSyncMgr, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryReferent(mOwnerFolder, &rv);
+  SetState(nsAutoSyncState::stUpdateIssued);
+  return imapFolder->UpdateFolderWithListener(nullptr, autoSyncMgrListener);
+}
+
+NS_IMETHODIMP nsAutoSyncState::OnStartRunningUrl(nsIURI* aUrl)
+{
+  nsresult rv = NS_OK;
+    
+  // if there is a problem to start the download, set rv with the
+  // corresponding error code. In that case, AutoSyncManager is going to
+  // set the autosync state to nsAutoSyncState::stReadyToDownload
+  // to resume downloading another time
+  
+  // TODO: is there a way to make sure that download started without
+  // problem through nsIURI interface?
+
+  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr = do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  return autoSyncMgr->OnDownloadStarted(this, rv);
+}
+
+NS_IMETHODIMP nsAutoSyncState::OnStopRunningUrl(nsIURI* aUrl, nsresult aExitCode)
+{
+  nsresult rv;
+  nsCOMPtr <nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr = do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIUrlListener> autoSyncMgrListener = do_QueryInterface(autoSyncMgr, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (mSyncState == stStatusIssued)
+  {
+    nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryReferent(mOwnerFolder, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    int32_t serverTotal, serverUnseen, serverRecent, serverNextUID;
+    imapFolder->GetServerTotal(&serverTotal);
+    imapFolder->GetServerUnseen(&serverUnseen);
+    imapFolder->GetServerRecent(&serverRecent);
+    imapFolder->GetServerNextUID(&serverNextUID);
+    if (serverNextUID != mLastNextUID || serverTotal != mLastServerTotal ||
+        serverUnseen != mLastServerUnseen || serverRecent != mLastServerRecent)
+    {
+      nsCString folderName;
+      ownerFolder->GetURI(folderName);
+      MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
+             ("folder %s status changed serverNextUID = %lx lastNextUID = %lx\n", folderName.get(),
+              serverNextUID, mLastNextUID));
+      MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
+             ("serverTotal = %lx lastServerTotal = %lx serverRecent = %lx lastServerRecent = %lx\n",
+              serverTotal, mLastServerTotal, serverRecent, mLastServerRecent));
+      SetServerCounts(serverTotal, serverRecent, serverUnseen, serverNextUID);
+      SetState(nsAutoSyncState::stUpdateIssued);
+      return imapFolder->UpdateFolderWithListener(nullptr, autoSyncMgrListener);
+    }
+    else
+    {
+      ownerFolder->SetMsgDatabase(nullptr);
+      // nothing more to do.
+      SetState(nsAutoSyncState::stCompletedIdle);
+      // autoSyncMgr needs this notification, so manufacture it.
+      return autoSyncMgrListener->OnStopRunningUrl(nullptr, NS_OK);
+    }
+  }
+  //XXXemre how we recover from this error?
+  rv = ownerFolder->ReleaseSemaphore(ownerFolder);
+  NS_ASSERTION(NS_SUCCEEDED(rv), "*** Cannot release folder semaphore");
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(aUrl);
+  if (mailUrl)
+    rv = mailUrl->UnRegisterListener(this);
+
+  return autoSyncMgr->OnDownloadCompleted(this, aExitCode);
+}
+
+NS_IMETHODIMP nsAutoSyncState::GetState(int32_t *aState)
+{
+  NS_ENSURE_ARG_POINTER(aState);
+  *aState = mSyncState;
+  return NS_OK;
+}
+
+const char *stateStrings[] = {"idle", "status issued", "update needed",
+                              "update issued", "downloading",
+                              "ready to download"};
+
+NS_IMETHODIMP nsAutoSyncState::SetState(int32_t aState)
+{
+  mSyncState = aState;
+  if (aState == stCompletedIdle)
+  {
+    ResetDownloadQ();
+    //tell folder to let go of its cached msg db pointer
+    nsresult rv;
+    nsCOMPtr<nsIMsgMailSession> session =
+             do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+    if (NS_SUCCEEDED(rv) && session)
+    {
+      nsCOMPtr <nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      bool folderOpen;
+      uint32_t folderFlags;
+      ownerFolder->GetFlags(&folderFlags);
+      session->IsFolderOpenInWindow(ownerFolder, &folderOpen);
+      if (!folderOpen && ! (folderFlags & nsMsgFolderFlags::Inbox))
+        ownerFolder->SetMsgDatabase(nullptr);
+    }
+  }
+  nsCString logStr("Sync State set to ");
+  logStr.Append(stateStrings[aState]);
+  logStr.Append(" for ");
+  LogOwnerFolderName(logStr.get());
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncState::TryCurrentGroupAgain(uint32_t aRetryCount)
+{
+  SetState(stReadyToDownload);
+
+  nsresult rv;
+  if (++mRetryCounter > aRetryCount)
+  {
+    ResetRetryCounter();
+    rv = NS_ERROR_FAILURE;
+  }
+  else
+    rv = Rollback();
+    
+  return rv;
+}
+
+NS_IMETHODIMP nsAutoSyncState::ResetRetryCounter()
+{
+  mRetryCounter = 0;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncState::GetPendingMessageCount(int32_t *aMsgCount)
+{
+  NS_ENSURE_ARG_POINTER(aMsgCount);
+  *aMsgCount = mDownloadQ.Length() - mOffset;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncState::GetTotalMessageCount(int32_t *aMsgCount)
+{
+  NS_ENSURE_ARG_POINTER(aMsgCount);
+  *aMsgCount = mDownloadQ.Length();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncState::GetOwnerFolder(nsIMsgFolder **aFolder)
+{
+  NS_ENSURE_ARG_POINTER(aFolder);
+  
+  nsresult rv;
+  nsCOMPtr <nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  NS_IF_ADDREF(*aFolder = ownerFolder);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncState::Rollback()
+{
+  mOffset = mLastOffset;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncState::ResetDownloadQ()
+{
+  mOffset = mLastOffset = 0;
+  mDownloadSet.Clear();
+  mDownloadQ.Clear();
+  mDownloadQ.Compact();
+  
+  return NS_OK;
+}
+
+/**
+ * Tests whether the given folder is owned by the same imap server
+ * or not.
+ */
+NS_IMETHODIMP nsAutoSyncState::IsSibling(nsIAutoSyncState *aAnotherStateObj, bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = false;
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgFolder> folderA, folderB;
+  
+  rv = GetOwnerFolder(getter_AddRefs(folderA));
+  NS_ENSURE_SUCCESS(rv,rv);
+  
+  rv = aAnotherStateObj->GetOwnerFolder(getter_AddRefs(folderB));
+  NS_ENSURE_SUCCESS(rv,rv);
+  
+  nsCOMPtr <nsIMsgIncomingServer> serverA, serverB;
+  rv = folderA->GetServer(getter_AddRefs(serverA));
+  NS_ENSURE_SUCCESS(rv,rv);
+  rv = folderB->GetServer(getter_AddRefs(serverB));
+  NS_ENSURE_SUCCESS(rv,rv);
+  
+  bool isSibling;
+  rv = serverA->Equals(serverB, &isSibling);
+  
+  if (NS_SUCCEEDED(rv))
+    *aResult = isSibling;
+  
+  return rv;
+}
+
+
+NS_IMETHODIMP nsAutoSyncState::DownloadMessagesForOffline(nsIArray *aMessagesList)
+{
+  NS_ENSURE_ARG_POINTER(aMessagesList);
+  
+  uint32_t count;
+  nsresult rv = aMessagesList->GetLength(&count);
+  NS_ENSURE_SUCCESS(rv,rv);
+  
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  
+  nsAutoCString messageIds;
+  nsTArray<nsMsgKey> msgKeys;
+  
+  rv = nsImapMailFolder::BuildIdsAndKeyArray(aMessagesList, messageIds, msgKeys);  
+  if (NS_FAILED(rv) || messageIds.IsEmpty()) 
+    return rv;
+
+  // acquire semaphore for offline store. If it fails, we won't download
+  nsCOMPtr <nsIMsgFolder> folder = do_QueryReferent(mOwnerFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  rv = folder->AcquireSemaphore(folder);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString folderName;
+  folder->GetURI(folderName);
+  MOZ_LOG(gAutoSyncLog, LogLevel::Debug, ("downloading %s for %s", messageIds.get(),
+           folderName.get()));
+  // start downloading
+  rv = imapService->DownloadMessagesForOffline(messageIds, 
+                                               folder, 
+                                               this, 
+                                               nullptr);
+  if (NS_SUCCEEDED(rv))
+    SetState(stDownloadInProgress);                                              
+
+  return rv;
+}
+
+NS_IMETHODIMP nsAutoSyncState::GetLastSyncTime(PRTime *aLastSyncTime)
+{
+  NS_ENSURE_ARG_POINTER(aLastSyncTime);
+  *aLastSyncTime = mLastSyncTime;
+  return NS_OK;
+}
+
+void nsAutoSyncState::SetLastSyncTimeInSec(int32_t aLastSyncTime)
+{
+  mLastSyncTime = ((PRTime)aLastSyncTime * PR_USEC_PER_SEC);
+}
+
+
+NS_IMETHODIMP nsAutoSyncState::GetLastUpdateTime(PRTime *aLastUpdateTime)
+{
+  NS_ENSURE_ARG_POINTER(aLastUpdateTime);
+  *aLastUpdateTime = mLastUpdateTime;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoSyncState::SetLastUpdateTime(PRTime aLastUpdateTime)
+{
+  mLastUpdateTime = aLastUpdateTime;
+  return NS_OK;
+}
+
+void nsAutoSyncState::SetServerCounts(int32_t total, int32_t recent,
+                                      int32_t unseen, int32_t nextUID)
+{
+  mLastServerTotal = total;
+  mLastServerRecent = recent;
+  mLastServerUnseen = unseen;
+  mLastNextUID = nextUID;
+}
+
+NS_IMPL_ISUPPORTS(nsAutoSyncState, nsIAutoSyncState, nsIUrlListener)
+
+
+void nsAutoSyncState::LogQWithSize(nsTArray<nsMsgKey>& q, uint32_t toOffset)
+{
+  nsCOMPtr <nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder);
+  if (ownerFolder)
+  {
+    nsCOMPtr<nsIMsgDatabase> database;
+    ownerFolder->GetMsgDatabase(getter_AddRefs(database));
+    
+    uint32_t x = q.Length();
+    while (x > toOffset && database) 
+    {
+      x--;
+      nsCOMPtr<nsIMsgDBHdr> h;
+      database->GetMsgHdrForKey(q[x], getter_AddRefs(h));
+      uint32_t s;
+      if (h)
+      {
+        h->GetMessageSize(&s);
+        MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
+              ("Elem #%d, size: %u bytes\n", x+1, s));
+      }
+      else
+        MOZ_LOG(gAutoSyncLog, LogLevel::Debug, ("unable to get header for key %ul", q[x]));
+    }
+  }
+}
+
+void nsAutoSyncState::LogQWithSize(nsIMutableArray *q, uint32_t toOffset)
+{
+  nsCOMPtr <nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder);
+  if (ownerFolder)
+  {
+    nsCOMPtr<nsIMsgDatabase> database;
+    ownerFolder->GetMsgDatabase(getter_AddRefs(database));
+
+    uint32_t x;
+    q->GetLength(&x);
+    while (x > toOffset && database) 
+    {
+      x--;
+      nsCOMPtr<nsIMsgDBHdr> h;
+      q->QueryElementAt(x, NS_GET_IID(nsIMsgDBHdr),
+                        getter_AddRefs(h));
+      uint32_t s;
+      if (h)
+      {
+        h->GetMessageSize(&s);
+        MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
+              ("Elem #%d, size: %u bytes\n", x+1, s));
+      }
+      else
+        MOZ_LOG(gAutoSyncLog, LogLevel::Debug, ("null header in q at index %ul", x));
+    }
+  }
+}
+
+void nsAutoSyncState::LogOwnerFolderName(const char *s)
+{
+  nsCOMPtr <nsIMsgFolder> ownerFolder = do_QueryReferent(mOwnerFolder);
+  if (ownerFolder)
+  {
+    nsCString folderName;
+    ownerFolder->GetURI(folderName);
+    MOZ_LOG(gAutoSyncLog, LogLevel::Debug,
+           ("*** %s Folder: %s ***\n", s, folderName.get()));
+  }
+}
diff --git a/mailnews/imap/src/nsAutoSyncState.h b/mailnews/imap/src/nsAutoSyncState.h
new file mode 100644
index 0000000000..c28c10d60e
--- /dev/null
+++ b/mailnews/imap/src/nsAutoSyncState.h
@@ -0,0 +1,107 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsAutoSyncState_h__
+#define nsAutoSyncState_h__
+
+#include "MailNewsTypes.h"
+#include "nsIAutoSyncState.h"
+#include "nsIAutoSyncManager.h" 
+#include "nsIUrlListener.h"
+#include "nsWeakPtr.h"
+#include "nsTHashtable.h"
+#include "nsHashKeys.h"
+#include "nsTArray.h"
+#include "prlog.h"
+#include "nsIWeakReferenceUtils.h"
+
+class nsImapMailFolder;
+class nsIAutoSyncMsgStrategy;
+class nsIMsgDatabase;
+
+/**
+ * An adaptor class to make msg strategy nsTArray.Sort()
+ * compatible.
+ */
+class MsgStrategyComparatorAdaptor 
+{
+ public:
+  MsgStrategyComparatorAdaptor(nsIAutoSyncMsgStrategy* aStrategy, 
+    nsIMsgFolder *aFolder, nsIMsgDatabase *aDatabase);
+
+  /** @return True if the elements are equals; false otherwise. */
+  bool Equals(const nsMsgKey& a, const nsMsgKey& b) const;
+  
+  /** @return True if (a < b); false otherwise. */
+  bool LessThan(const nsMsgKey& a, const nsMsgKey& b) const;
+  
+ private:
+  MsgStrategyComparatorAdaptor();
+  
+ private:
+  nsIAutoSyncMsgStrategy *mStrategy;
+  nsIMsgFolder *mFolder;
+  nsIMsgDatabase *mDatabase;
+};
+
+
+/**
+ * Facilitates auto-sync capabilities for imap folders.
+ */
+class nsAutoSyncState final : public nsIAutoSyncState, public nsIUrlListener
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIAUTOSYNCSTATE
+  NS_DECL_NSIURLLISTENER
+
+  nsAutoSyncState(nsImapMailFolder *aOwnerFolder, PRTime aLastSyncTime = 0UL);
+
+  /// Called by owner folder when new headers are fetched from the server
+  void OnNewHeaderFetchCompleted(const nsTArray<nsMsgKey> &aMsgKeyList);
+
+  /// Sets the last sync time in lower precision (seconds)
+  void SetLastSyncTimeInSec(int32_t aLastSyncTime);
+
+  /// Manages storage space for auto-sync operations 
+  nsresult ManageStorageSpace();
+
+  void SetServerCounts(int32_t total, int32_t recent, int32_t unseen,
+                       int32_t nextUID);
+
+ private:
+  ~nsAutoSyncState();
+  
+  nsresult PlaceIntoDownloadQ(const nsTArray<nsMsgKey> &aMsgKeyList);
+  nsresult SortQueueBasedOnStrategy(nsTArray<nsMsgKey> &aQueue);
+  nsresult SortSubQueueBasedOnStrategy(nsTArray<nsMsgKey> &aQueue, 
+                                    uint32_t aStartingOffset);
+
+  void LogOwnerFolderName(const char *s);
+  void LogQWithSize(nsTArray<nsMsgKey>& q, uint32_t toOffset = 0);
+  void LogQWithSize(nsIMutableArray *q, uint32_t toOffset = 0);
+
+ private:
+  int32_t mSyncState;
+  nsWeakPtr mOwnerFolder;
+  uint32_t mOffset;
+  uint32_t mLastOffset;
+
+  // used to tell if the Server counts have changed.
+  int32_t mLastServerTotal;
+  int32_t mLastServerRecent;
+  int32_t mLastServerUnseen;
+  int32_t mLastNextUID;
+
+  PRTime mLastSyncTime;
+  PRTime mLastUpdateTime;
+  uint32_t mProcessPointer;
+  bool mIsDownloadQChanged;
+  uint32_t mRetryCounter;
+  nsTHashtable<nsUint32HashKey> mDownloadSet;
+  nsTArray<nsMsgKey> mDownloadQ;
+  nsTArray<nsMsgKey> mExistingHeadersQ;
+};
+
+#endif
diff --git a/mailnews/imap/src/nsIMAPBodyShell.cpp b/mailnews/imap/src/nsIMAPBodyShell.cpp
new file mode 100644
index 0000000000..087fe20337
--- /dev/null
+++ b/mailnews/imap/src/nsIMAPBodyShell.cpp
@@ -0,0 +1,1333 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"
+#include "nsIMAPHostSessionList.h"
+#include "nsIMAPBodyShell.h"
+#include "nsImapProtocol.h"
+#include "nsImapStringBundle.h"
+
+#include "nsMimeTypes.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsITransport.h"
+#include "nsServiceManagerUtils.h"
+
+// need to talk to Rich about this...
+#define IMAP_EXTERNAL_CONTENT_HEADER "X-Mozilla-IMAP-Part"
+
+// imapbody.cpp
+// Implementation of the nsIMAPBodyShell and associated classes
+// These are used to parse IMAP BODYSTRUCTURE responses, and intelligently (?)
+// figure out what parts we need to display inline.
+
+/*
+        Create a nsIMAPBodyShell from a full BODYSTRUCUTRE response from the parser.
+
+        The body shell represents a single, top-level object, the message.  The message body
+        might be treated as either a container or a leaf (just like any arbitrary part).
+
+        Steps for creating a part:
+        1. Pull out the paren grouping for the part
+        2. Create a generic part object with that buffer
+        3. The factory will return either a leaf or container, depending on what it really is.
+        4. It is responsible for parsing its children, if there are any
+*/
+
+
+///////////// nsIMAPBodyShell ////////////////////////////////////
+
+NS_IMPL_ISUPPORTS0(nsIMAPBodyShell)
+
+nsIMAPBodyShell::nsIMAPBodyShell(nsImapProtocol *protocolConnection,
+                                 nsIMAPBodypartMessage *message, uint32_t UID,
+                                 const char *folderName)
+{
+  m_isValid = false;
+  m_isBeingGenerated = false;
+  m_cached = false;
+  m_gotAttachmentPref = false;
+  m_generatingWholeMessage = false;
+  m_generatingPart = NULL;
+  m_protocolConnection = protocolConnection;
+  m_message = message;
+  NS_ASSERTION(m_protocolConnection, "non null connection");
+  if (!m_protocolConnection)
+    return;
+  m_prefetchQueue = new nsIMAPMessagePartIDArray();
+  if (!m_prefetchQueue)
+    return;
+  m_UID = "";
+  m_UID.AppendInt(UID);
+#ifdef DEBUG_chrisf
+  NS_ASSERTION(folderName);
+#endif
+  if (!folderName)
+    return;
+  m_folderName = NS_strdup(folderName);
+  if (!m_folderName)
+    return;
+  
+  SetContentModified(GetShowAttachmentsInline() ? IMAP_CONTENT_MODIFIED_VIEW_INLINE : IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS);
+
+  SetIsValid(m_message != nullptr);
+}
+
+nsIMAPBodyShell::~nsIMAPBodyShell()
+{
+  delete m_message;
+  delete m_prefetchQueue;
+  PR_Free(m_folderName);
+}
+
+void nsIMAPBodyShell::SetIsValid(bool valid)
+{
+  m_isValid = valid;
+}
+
+bool nsIMAPBodyShell::GetShowAttachmentsInline()
+{
+  if (!m_gotAttachmentPref)
+  {
+    m_showAttachmentsInline = !m_protocolConnection || m_protocolConnection->GetShowAttachmentsInline();
+    m_gotAttachmentPref = true;
+  }
+  
+  return m_showAttachmentsInline;
+}
+
+// Fills in buffer (and adopts storage) for header object
+void nsIMAPBodyShell::AdoptMessageHeaders(char *headers, const char *partNum)
+{
+  if (!GetIsValid())
+    return;
+  
+  if (!partNum)
+    partNum = "0";
+  
+  // we are going to say that a message header object only has
+  // part data, and no header data.
+  nsIMAPBodypart *foundPart = m_message->FindPartWithNumber(partNum);
+  if (foundPart)
+  {
+    nsIMAPBodypartMessage *messageObj = foundPart->GetnsIMAPBodypartMessage();
+    if (messageObj)
+    {
+      messageObj->AdoptMessageHeaders(headers);
+      if (!messageObj->GetIsValid())
+        SetIsValid(false);
+    }
+    else
+    {
+      // We were filling in message headers for a given part number.
+      // We looked up that part number, found an object, but it
+      // wasn't of type message/rfc822.
+      // Something's wrong.
+      NS_ASSERTION(false, "object not of type message rfc822");
+    }
+  }
+  else
+    SetIsValid(false);
+}
+
+// Fills in buffer (and adopts storage) for MIME headers in appropriate object.
+// If object can't be found, sets isValid to false.
+void nsIMAPBodyShell::AdoptMimeHeader(const char *partNum, char *mimeHeader)
+{
+  if (!GetIsValid())
+    return;
+  
+  NS_ASSERTION(partNum, "null partnum in body shell");
+  
+  nsIMAPBodypart *foundPart = m_message->FindPartWithNumber(partNum);
+  
+  if (foundPart)
+  {
+    foundPart->AdoptHeaderDataBuffer(mimeHeader);
+    if (!foundPart->GetIsValid())
+      SetIsValid(false);
+  }
+  else
+  {
+    SetIsValid(false);
+  }
+}
+
+
+void nsIMAPBodyShell::AddPrefetchToQueue(nsIMAPeFetchFields fields, const char *partNumber)
+{
+  nsIMAPMessagePartID *newPart = new nsIMAPMessagePartID(fields, partNumber);
+  if (newPart)
+  {
+    m_prefetchQueue->AppendElement(newPart);
+  }
+  else
+  {
+    // HandleMemoryFailure();
+  }
+}
+
+// Flushes all of the prefetches that have been queued up in the prefetch queue,
+// freeing them as we go
+void nsIMAPBodyShell::FlushPrefetchQueue()
+{
+  m_protocolConnection->PipelinedFetchMessageParts(GetUID(), m_prefetchQueue);
+  m_prefetchQueue->RemoveAndFreeAll();
+}
+
+// Requires that the shell is valid when called
+// Performs a preflight check on all message parts to see if they are all
+// inline.  Returns true if all parts are inline, false otherwise.
+bool nsIMAPBodyShell::PreflightCheckAllInline()
+{
+  bool rv = m_message->PreflightCheckAllInline(this);
+  //	if (rv)
+  //		MOZ_LOG(IMAP, out, ("BODYSHELL: All parts inline.  Reverting to whole message download."));
+  return rv;
+}
+
+// When partNum is NULL, Generates a whole message and intelligently
+// leaves out parts that are not inline.
+
+// When partNum is not NULL, Generates a MIME part that hasn't been downloaded yet
+// Ok, here's how we're going to do this.  Essentially, this
+// will be the mirror image of the "normal" generation.
+// All parts will be left out except a single part which is
+// explicitly specified.  All relevant headers will be included.
+// Libmime will extract only the part of interest, so we don't
+// have to worry about the other parts.  This also has the
+// advantage that it looks like it will be more workable for
+// nested parts.  For instance, if a user clicks on a link to
+// a forwarded message, then that forwarded message may be 
+// generated along with any images that the forwarded message
+// contains, for instance.
+
+
+int32_t nsIMAPBodyShell::Generate(char *partNum)
+{
+  m_isBeingGenerated = true;
+  m_generatingPart = partNum;
+  int32_t contentLength = 0;
+  
+  if (!GetIsValid() || PreflightCheckAllInline())
+  {
+    // We don't have a valid shell, or all parts are going to be inline anyway.  Fall back to fetching the whole message.
+#ifdef DEBUG_chrisf
+    NS_ASSERTION(GetIsValid());
+#endif
+    m_generatingWholeMessage = true;
+    uint32_t messageSize = m_protocolConnection->GetMessageSize(GetUID().get(), true);
+    m_protocolConnection->SetContentModified(IMAP_CONTENT_NOT_MODIFIED);	// So that when we cache it, we know we have the whole message
+    if (!DeathSignalReceived())
+      m_protocolConnection->FallbackToFetchWholeMsg(GetUID(), messageSize);
+    contentLength = (int32_t) messageSize;	// ugh
+  }
+  else
+  {
+    // We have a valid shell.
+    bool streamCreated = false;
+    m_generatingWholeMessage = false;
+    
+    ////// PASS 1 : PREFETCH ///////
+    // First, prefetch any additional headers/data that we need
+    if (!GetPseudoInterrupted())
+      m_message->Generate(this, false, true); // This queues up everything we need to prefetch
+    // Now, run a single pipelined prefetch  (neato!)
+    FlushPrefetchQueue();
+    
+    ////// PASS 2 : COMPUTE STREAM SIZE ///////
+    // Next, figure out the size from the parts that we're going to fill in,
+    // plus all of the MIME headers, plus the message header itself
+    if (!GetPseudoInterrupted())
+      contentLength = m_message->Generate(this, false, false);
+    
+    // Setup the stream
+    if (!GetPseudoInterrupted() && !DeathSignalReceived())
+    {
+      nsresult rv = 
+        m_protocolConnection->BeginMessageDownLoad(contentLength, MESSAGE_RFC822);
+      if (NS_FAILED(rv))
+      {
+        m_generatingPart = nullptr;
+        m_protocolConnection->AbortMessageDownLoad();
+        return 0;
+      }
+      else
+      {
+        streamCreated = true;
+      }
+    }
+    
+    ////// PASS 3 : GENERATE ///////
+    // Generate the message
+    if (!GetPseudoInterrupted() && !DeathSignalReceived())
+      m_message->Generate(this, true, false);
+    
+    // Close the stream here - normal.  If pseudointerrupted, the connection will abort the download stream
+    if (!GetPseudoInterrupted() && !DeathSignalReceived())
+      m_protocolConnection->NormalMessageEndDownload();
+    else if (streamCreated)
+      m_protocolConnection->AbortMessageDownLoad();
+    
+    m_generatingPart = NULL;
+    
+  }
+  
+  m_isBeingGenerated = false;
+  return contentLength;
+}
+
+bool nsIMAPBodyShell::GetPseudoInterrupted()
+{
+  bool rv = m_protocolConnection->GetPseudoInterrupted();
+  return rv;
+}
+
+bool nsIMAPBodyShell::DeathSignalReceived()
+{
+  bool rv = m_protocolConnection->DeathSignalReceived();
+  return rv;
+}
+
+
+///////////// nsIMAPBodypart ////////////////////////////////////
+
+nsIMAPBodypart::nsIMAPBodypart(char *partNumber, nsIMAPBodypart *parentPart)
+{
+  SetIsValid(true);
+  m_parentPart = parentPart;
+  m_partNumberString = partNumber;	// storage adopted
+  m_partData = NULL;
+  m_headerData = NULL;
+  m_boundaryData = NULL;	// initialize from parsed BODYSTRUCTURE
+  m_contentLength = 0;
+  m_partLength = 0;
+  
+  m_contentType = NULL;
+  m_bodyType = NULL;
+  m_bodySubType = NULL;
+  m_bodyID = NULL;
+  m_bodyDescription = NULL;
+  m_bodyEncoding = NULL;
+}
+
+nsIMAPBodypart::~nsIMAPBodypart()
+{
+  PR_FREEIF(m_partNumberString);
+  PR_FREEIF(m_contentType);
+  PR_FREEIF(m_bodyType);
+  PR_FREEIF(m_bodySubType);
+  PR_FREEIF(m_bodyID);
+  PR_FREEIF(m_bodyDescription);
+  PR_FREEIF(m_bodyEncoding);
+  PR_FREEIF(m_partData);
+  PR_FREEIF(m_headerData);
+  PR_FREEIF(m_boundaryData);
+}
+
+void nsIMAPBodypart::SetIsValid(bool valid)
+{
+  m_isValid = valid;
+  if (!m_isValid)
+  {
+    //MOZ_LOG(IMAP, out, ("BODYSHELL: Part is invalid.  Part Number: %s Content-Type: %s", m_partNumberString, m_contentType));
+  }
+}
+
+// Adopts storage for part data buffer.  If NULL, sets isValid to false.
+void nsIMAPBodypart::AdoptPartDataBuffer(char *buf)
+{
+  m_partData = buf;
+  if (!m_partData)
+  {
+    SetIsValid(false);
+  }
+}
+
+// Adopts storage for header data buffer.  If NULL, sets isValid to false.
+void nsIMAPBodypart::AdoptHeaderDataBuffer(char *buf)
+{
+  m_headerData = buf;
+  if (!m_headerData)
+  {
+    SetIsValid(false);
+  }
+}
+
+// Finds the part with given part number
+// Returns a nsIMAPBodystructure of the matched part if it is this
+// or one of its children.  Returns NULL otherwise.
+nsIMAPBodypart *nsIMAPBodypart::FindPartWithNumber(const char *partNum)
+{
+  // either brute force, or do it the smart way - look at the number.
+  // (the parts should be ordered, and hopefully indexed by their number)
+  
+  if (m_partNumberString && !PL_strcasecmp(partNum, m_partNumberString))
+    return this;
+  
+  //if (!m_partNumberString && !PL_strcasecmp(partNum, "1"))
+  //	return this;
+  
+  return NULL;
+}
+
+/*
+void nsIMAPBodypart::PrefetchMIMEHeader()
+{
+if (!m_headerData && !m_shell->DeathSignalReceived())
+{
+m_shell->GetConnection()->FetchMessage(m_shell->GetUID(), kMIMEHeader, true, 0, 0, m_partNumberString);
+// m_headerLength will be filled in when it is adopted from the parser
+}
+if (!m_headerData)
+{
+SetIsValid(false);
+}
+}
+*/
+
+void nsIMAPBodypart::QueuePrefetchMIMEHeader(nsIMAPBodyShell *aShell)
+{
+  aShell->AddPrefetchToQueue(kMIMEHeader, m_partNumberString);
+}
+
+int32_t nsIMAPBodypart::GenerateMIMEHeader(nsIMAPBodyShell *aShell, bool stream, bool prefetch)
+{
+  if (prefetch && !m_headerData)
+  {
+    QueuePrefetchMIMEHeader(aShell);
+    return 0;
+  }
+  else if (m_headerData)
+  {
+    int32_t mimeHeaderLength = 0;
+    
+    if (!ShouldFetchInline(aShell))
+    {
+      // if this part isn't inline, add the X-Mozilla-IMAP-Part header
+      char *xPartHeader = PR_smprintf("%s: %s", IMAP_EXTERNAL_CONTENT_HEADER, m_partNumberString);
+      if (xPartHeader)
+      {
+        if (stream)
+        {
+          aShell->GetConnection()->Log("SHELL","GENERATE-XHeader",m_partNumberString);
+          aShell->GetConnection()->HandleMessageDownLoadLine(xPartHeader, false);
+        }
+        mimeHeaderLength += PL_strlen(xPartHeader);
+        PR_Free(xPartHeader);
+      }
+    }
+    
+    mimeHeaderLength += PL_strlen(m_headerData);
+    if (stream)
+    {
+      aShell->GetConnection()->Log("SHELL","GENERATE-MIMEHeader",m_partNumberString);
+      aShell->GetConnection()->HandleMessageDownLoadLine(m_headerData, false);  // all one line?  Can we do that?
+    }
+    
+    return mimeHeaderLength;
+  }
+  else 
+  {
+    SetIsValid(false);	// prefetch didn't adopt a MIME header
+    return 0;
+  }
+}
+
+int32_t nsIMAPBodypart::GeneratePart(nsIMAPBodyShell *aShell, bool stream, bool prefetch)
+{
+  if (prefetch)
+    return 0;	// don't need to prefetch anything
+  
+  if (m_partData)	// we have prefetched the part data
+  {
+    if (stream)
+    {
+      aShell->GetConnection()->Log("SHELL","GENERATE-Part-Prefetched",m_partNumberString);
+      aShell->GetConnection()->HandleMessageDownLoadLine(m_partData, false);
+    }
+    return PL_strlen(m_partData);
+  }
+  else	// we are fetching and streaming this part's body as we go
+  {
+    if (stream && !aShell->DeathSignalReceived())
+    {
+      char *generatingPart = aShell->GetGeneratingPart();
+      bool fetchingSpecificPart = (generatingPart && !PL_strcmp(generatingPart, m_partNumberString));
+      
+      aShell->GetConnection()->Log("SHELL","GENERATE-Part-Inline",m_partNumberString);
+      aShell->GetConnection()->FetchTryChunking(aShell->GetUID(), kMIMEPart, true, m_partNumberString, m_partLength, !fetchingSpecificPart);
+    }
+    return m_partLength;	// the part length has been filled in from the BODYSTRUCTURE response
+  }
+}
+
+int32_t nsIMAPBodypart::GenerateBoundary(nsIMAPBodyShell *aShell, bool stream, bool prefetch, bool lastBoundary)
+{
+  if (prefetch)
+    return 0;	// don't need to prefetch anything
+  
+  if (m_boundaryData)
+  {
+    if (!lastBoundary)
+    {
+      if (stream)
+      {
+        aShell->GetConnection()->Log("SHELL","GENERATE-Boundary",m_partNumberString);
+        aShell->GetConnection()->HandleMessageDownLoadLine(m_boundaryData, false);
+      }
+      return PL_strlen(m_boundaryData);
+    }
+    else	// the last boundary
+    {
+      char *lastBoundaryData = PR_smprintf("%s--", m_boundaryData);
+      if (lastBoundaryData)
+      {
+        if (stream)
+        {
+          aShell->GetConnection()->Log("SHELL","GENERATE-Boundary-Last",m_partNumberString);
+          aShell->GetConnection()->HandleMessageDownLoadLine(lastBoundaryData, false);
+        }
+        int32_t rv = PL_strlen(lastBoundaryData);
+        PR_Free(lastBoundaryData);
+        return rv;
+      }
+      else
+      {
+        //HandleMemoryFailure();
+        return 0;
+      }
+    }
+  }
+  else
+    return 0;
+}
+
+int32_t nsIMAPBodypart::GenerateEmptyFilling(nsIMAPBodyShell *aShell, bool stream, bool prefetch)
+{
+  if (prefetch)
+    return 0; // don't need to prefetch anything
+
+  const nsString &emptyString = aShell->GetConnection()->
+    GetEmptyMimePartString();
+  if (!emptyString.IsEmpty())
+  {
+    if (stream)
+    {
+      nsImapProtocol *conn = aShell->GetConnection();
+      conn->Log("SHELL", "GENERATE-Filling", m_partNumberString);
+      conn->HandleMessageDownLoadLine(NS_ConvertUTF16toUTF8(emptyString).get(),
+                                      false);
+    }
+    return emptyString.Length();
+  }
+  else
+    return 0;
+}
+
+
+// Returns true if the prefs say that this content type should
+// explicitly be kept in when filling in the shell
+bool nsIMAPBodypart::ShouldExplicitlyFetchInline()
+{
+	 return false;
+}
+
+
+// Returns true if the prefs say that this content type should
+// explicitly be left out when filling in the shell
+bool nsIMAPBodypart::ShouldExplicitlyNotFetchInline()
+{
+  return false;
+}
+
+
+///////////// nsIMAPBodypartLeaf /////////////////////////////
+
+
+nsIMAPBodypartLeaf::nsIMAPBodypartLeaf(char *partNum,
+                                       nsIMAPBodypart *parentPart,
+                                       char *bodyType, char *bodySubType,
+                                       char *bodyID, char *bodyDescription,
+                                       char *bodyEncoding, int32_t partLength,
+                                       bool preferPlainText)
+  : nsIMAPBodypart(partNum, parentPart), mPreferPlainText(preferPlainText)
+{
+  m_bodyType = bodyType;
+  m_bodySubType = bodySubType;
+  m_bodyID = bodyID;
+  m_bodyDescription = bodyDescription;
+  m_bodyEncoding = bodyEncoding;
+  m_partLength = partLength;
+  if (m_bodyType && m_bodySubType)
+  {
+    m_contentType = PR_smprintf("%s/%s", m_bodyType, m_bodySubType);
+  }
+  SetIsValid(true);
+}
+
+nsIMAPBodypartType nsIMAPBodypartLeaf::GetType()
+{
+  return IMAP_BODY_LEAF;
+}
+
+int32_t nsIMAPBodypartLeaf::Generate(nsIMAPBodyShell *aShell, bool stream, bool prefetch)
+{
+  int32_t len = 0;
+  
+  if (GetIsValid())
+  {
+    
+    if (stream && !prefetch)
+      aShell->GetConnection()->Log("SHELL","GENERATE-Leaf",m_partNumberString);
+    
+    // Stream out the MIME part boundary
+    //GenerateBoundary();
+    NS_ASSERTION(m_parentPart, "part has no parent");
+    //nsIMAPBodypartMessage *parentMessage = m_parentPart ? m_parentPart->GetnsIMAPBodypartMessage() : NULL;
+    
+    // Stream out the MIME header of this part, if this isn't the only body part of a message
+    //if (parentMessage ? !parentMessage->GetIsTopLevelMessage() : true)
+    if ((m_parentPart->GetType() != IMAP_BODY_MESSAGE_RFC822)
+      && !aShell->GetPseudoInterrupted())
+      len += GenerateMIMEHeader(aShell, stream, prefetch);
+    
+    if (!aShell->GetPseudoInterrupted())
+    {
+      if (ShouldFetchInline(aShell))
+      {
+        // Fetch and stream the content of this part
+        len += GeneratePart(aShell, stream, prefetch);
+      }
+      else
+      {
+        // fill in the filling within the empty part
+        len += GenerateEmptyFilling(aShell, stream, prefetch);
+      }
+    }
+  }
+  m_contentLength = len;
+  return m_contentLength;
+}
+
+
+
+// returns true if this part should be fetched inline for generation.
+bool nsIMAPBodypartLeaf::ShouldFetchInline(nsIMAPBodyShell *aShell)
+{
+  char *generatingPart = aShell->GetGeneratingPart();
+  if (generatingPart)
+  {
+    // If we are generating a specific part
+    if (!PL_strcmp(generatingPart, m_partNumberString))
+    {
+      // This is the part we're generating
+      return true;
+    }
+    else
+    {
+      // If this is the only body part of a message, and that
+      // message is the part being generated, then this leaf should
+      // be inline as well.
+      if ((m_parentPart->GetType() == IMAP_BODY_MESSAGE_RFC822) &&
+        (!PL_strcmp(m_parentPart->GetPartNumberString(), generatingPart)))
+        return true;
+      
+      // The parent of this part is a multipart
+      if (m_parentPart->GetType() == IMAP_BODY_MULTIPART)
+      {
+        // This is the first text part of a forwarded message
+        // with a multipart body, and that message is being generated,
+        // then generate this part.
+        nsIMAPBodypart *grandParent = m_parentPart->GetParentPart();
+        // grandParent must exist, since multiparts need parents
+        NS_ASSERTION(grandParent, "grandparent doesn't exist for multi-part alt");
+        if (grandParent && 
+          (grandParent->GetType() == IMAP_BODY_MESSAGE_RFC822) &&
+          (!PL_strcmp(grandParent->GetPartNumberString(), generatingPart)) &&
+          (m_partNumberString[PL_strlen(m_partNumberString)-1] == '1') &&
+          !PL_strcasecmp(m_bodyType, "text"))
+          return true;	// we're downloading it inline
+        
+        
+        // This is a child of a multipart/appledouble attachment,
+        // and that multipart/appledouble attachment is being generated
+        if (m_parentPart &&
+          !PL_strcasecmp(m_parentPart->GetBodySubType(), "appledouble") &&
+          !PL_strcmp(m_parentPart->GetPartNumberString(), generatingPart))
+          return true;	// we're downloading it inline
+      }
+      
+      // Leave out all other leaves if this isn't the one
+      // we're generating.
+      // Maybe change later to check parents, etc.
+      return false;
+    }
+  }
+  else
+  {
+    // We are generating the whole message, possibly (hopefully)
+    // leaving out non-inline parts
+    
+    if (ShouldExplicitlyFetchInline())
+      return true;
+    if (ShouldExplicitlyNotFetchInline())
+      return false;
+    
+    // If the parent is a message (this is the only body part of that
+    // message), and that message should be inline, then its body
+    // should inherit the inline characteristics of that message
+    if (m_parentPart->GetType() == IMAP_BODY_MESSAGE_RFC822)
+      return m_parentPart->ShouldFetchInline(aShell);
+    
+    // View Attachments As Links is on.
+    if (!(aShell->GetContentModified() == IMAP_CONTENT_MODIFIED_VIEW_INLINE))
+    {
+      // The last text part is still displayed inline,
+      // even if View Attachments As Links is on.
+      nsIMAPBodypart *grandParentPart = m_parentPart->GetParentPart();
+      if ((mPreferPlainText ||
+           !PL_strcasecmp(m_parentPart->GetBodySubType(), "mixed")) &&
+          !PL_strcmp(m_partNumberString, "1") &&
+          !PL_strcasecmp(m_bodyType, "text"))
+        return true;         // we're downloading it inline
+
+      if ((!PL_strcasecmp(m_parentPart->GetBodySubType(), "alternative") ||
+           (grandParentPart &&
+            !PL_strcasecmp(grandParentPart->GetBodySubType(), "alternative"))) &&
+          !PL_strcasecmp(m_bodyType, "text") &&
+          ((!PL_strcasecmp(m_bodySubType, "plain") && mPreferPlainText) ||
+           (!PL_strcasecmp(m_bodySubType, "html") && !mPreferPlainText)))
+        return true;
+
+      // This is the first text part of a top-level multipart.
+      // For instance, a message with multipart body, where the first
+      // part is multipart, and this is the first leaf of that first part.
+      if (m_parentPart->GetType() == IMAP_BODY_MULTIPART &&
+          (PL_strlen(m_partNumberString) >= 2) &&
+          !PL_strcmp(m_partNumberString + PL_strlen(m_partNumberString) - 2, ".1") && // this is the first text type on this level
+          (!PL_strcmp(m_parentPart->GetPartNumberString(), "1") || !PL_strcmp(m_parentPart->GetPartNumberString(), "2")) && 
+          !PL_strcasecmp(m_bodyType, "text"))
+        return true;
+      // This is the first text part of a top-level multipart of the toplevelmessage
+      // This 'assumes' the text body is first leaf. This is not required for valid email.
+      // The only other way is to get content-disposition = attachment and exclude those text parts.
+      if (m_parentPart->GetType() == IMAP_BODY_MULTIPART &&
+          !PL_strcasecmp(m_bodyType, "text") &&
+          !PL_strcmp(m_parentPart->GetPartNumberString(), "0") &&
+          !PL_strcmp(m_partNumberString, "1"))
+         return true;
+
+      // we may have future problems needing tests here
+
+      return false;  // we can leave it on the server
+    }
+#ifdef XP_MACOSX
+    // If it is either applesingle, or a resource fork for appledouble
+    if (!PL_strcasecmp(m_contentType, "application/applefile"))
+    {
+      // if it is appledouble
+      if (m_parentPart->GetType() == IMAP_BODY_MULTIPART &&
+        !PL_strcasecmp(m_parentPart->GetBodySubType(), "appledouble"))
+      {
+        // This is the resource fork of a multipart/appledouble.
+        // We inherit the inline attributes of the parent,
+        // which was derived from its OTHER child.  (The data fork.)
+        return m_parentPart->ShouldFetchInline(aShell);
+      }
+      else	// it is applesingle
+      {
+        return false;	// we can leave it on the server
+      }
+    }
+#endif // XP_MACOSX
+    
+    // Leave out parts with type application/*
+    if (!PL_strcasecmp(m_bodyType, "APPLICATION") &&	// If it is of type "application"
+      PL_strncasecmp(m_bodySubType, "x-pkcs7", 7)	// and it's not a signature (signatures are inline)
+      )
+      return false;	// we can leave it on the server
+    if (!PL_strcasecmp(m_bodyType, "AUDIO"))
+      return false;
+    // Here's where we can add some more intelligence -- let's leave out
+    // any other parts that we know we can't display inline.
+    return true;	// we're downloading it inline
+  }
+}
+
+
+
+bool nsIMAPBodypartMultipart::IsLastTextPart(const char *partNumberString)
+{
+ // iterate backwards over the parent's part list and if the part is
+  // text, compare it to the part number string
+  for (int i = m_partList->Length() - 1; i >= 0; i--)
+  {
+      nsIMAPBodypart *part = m_partList->ElementAt(i);
+      if (!PL_strcasecmp(part->GetBodyType(), "text"))
+        return !PL_strcasecmp(part->GetPartNumberString(), partNumberString);
+  }
+  return false;
+}
+
+bool nsIMAPBodypartLeaf::PreflightCheckAllInline(nsIMAPBodyShell *aShell)
+{
+  // only need to check this part, since it has no children.
+  return ShouldFetchInline(aShell);
+}
+
+
+///////////// nsIMAPBodypartMessage ////////////////////////
+
+nsIMAPBodypartMessage::nsIMAPBodypartMessage(char *partNum,
+                                             nsIMAPBodypart *parentPart,
+                                             bool topLevelMessage,
+                                             char *bodyType, char *bodySubType,
+                                             char *bodyID,
+                                             char *bodyDescription,
+                                             char *bodyEncoding,
+                                             int32_t partLength,
+                                             bool preferPlainText)
+ : nsIMAPBodypartLeaf(partNum, parentPart, bodyType, bodySubType, bodyID,
+                      bodyDescription, bodyEncoding, partLength,
+                      preferPlainText)
+{
+  m_topLevelMessage = topLevelMessage;
+  if (m_topLevelMessage)
+  {
+    m_partNumberString = PR_smprintf("0");
+    if (!m_partNumberString)
+    {
+      SetIsValid(false);
+      return;
+    }
+  }
+  m_body = NULL;
+  m_headers = new nsIMAPMessageHeaders(m_partNumberString, this);  // We always have a Headers object
+  if (!m_headers || !m_headers->GetIsValid())
+  {
+    SetIsValid(false);
+    return;
+  }
+  SetIsValid(true);
+}
+
+void nsIMAPBodypartMessage::SetBody(nsIMAPBodypart *body)
+{
+  if (m_body)
+    delete m_body;
+  m_body = body;
+}
+
+
+nsIMAPBodypartType nsIMAPBodypartMessage::GetType()
+{
+  return IMAP_BODY_MESSAGE_RFC822;
+}
+
+nsIMAPBodypartMessage::~nsIMAPBodypartMessage()
+{
+  delete m_headers;
+  delete m_body;
+}
+
+int32_t nsIMAPBodypartMessage::Generate(nsIMAPBodyShell *aShell, bool stream, bool prefetch)
+{
+  if (!GetIsValid())
+    return 0;
+  
+  m_contentLength = 0;
+  
+  if (stream && !prefetch)
+    aShell->GetConnection()->Log("SHELL","GENERATE-MessageRFC822",m_partNumberString);
+  
+  if (!m_topLevelMessage && !aShell->GetPseudoInterrupted())  // not the top-level message - we need the MIME header as well as the message header
+  {
+    // but we don't need the MIME headers of a message/rfc822 part if this content
+    // type is in (part of) the main msg header. In other words, we still need
+    // these MIME headers if this message/rfc822 body part is enclosed in the msg
+    // body (most likely as a body part of a multipart/mixed msg).
+    //       Don't fetch (bug 128888)              Do fetch (bug 168097)
+    //  ----------------------------------  -----------------------------------
+    //  message/rfc822  (parent part)       message/rfc822
+    //   message/rfc822 <<<---               multipart/mixed  (parent part)
+    //    multipart/mixed                     message/rfc822  <<<---
+    //     text/html   (body text)             multipart/mixed
+    //     text/plain  (attachment)             text/html   (body text)
+    //     application/msword (attachment)      text/plain  (attachment)
+    //                                          application/msword (attachment)
+    // "<<<---" points to the part we're examining here.
+    if ( PL_strcasecmp(m_bodyType, "message") || PL_strcasecmp(m_bodySubType, "rfc822") ||
+      PL_strcasecmp(m_parentPart->GetBodyType(), "message") || PL_strcasecmp(m_parentPart->GetBodySubType(), "rfc822") )
+      m_contentLength += GenerateMIMEHeader(aShell, stream, prefetch);
+  }
+  
+  if (!aShell->GetPseudoInterrupted())
+    m_contentLength += m_headers->Generate(aShell, stream, prefetch);
+  if (!aShell->GetPseudoInterrupted())
+    m_contentLength += m_body->Generate(aShell, stream, prefetch);
+  
+  return m_contentLength;
+}
+
+
+
+
+bool nsIMAPBodypartMessage::ShouldFetchInline(nsIMAPBodyShell *aShell)
+{
+  if (m_topLevelMessage)	// the main message should always be defined as "inline"
+    return true;
+  
+  char *generatingPart = aShell->GetGeneratingPart();
+  if (generatingPart)
+  {
+    // If we are generating a specific part
+    // Always generate containers (just don't fill them in)
+    // because it is low cost (everything is cached)
+    // and it gives the message its full MIME structure,
+    // to avoid any potential mishap.
+    return true;
+  }
+  else
+  {
+    // Generating whole message
+    
+    if (ShouldExplicitlyFetchInline())
+      return true;
+    if (ShouldExplicitlyNotFetchInline())
+      return false;
+    
+    
+    // Message types are inline, by default.
+    return true;
+  }
+}
+
+bool nsIMAPBodypartMessage::PreflightCheckAllInline(nsIMAPBodyShell *aShell)
+{
+  if (!ShouldFetchInline(aShell))
+    return false;
+  
+  return m_body->PreflightCheckAllInline(aShell);
+}
+
+// Fills in buffer (and adopts storage) for header object
+void nsIMAPBodypartMessage::AdoptMessageHeaders(char *headers)
+{
+  if (!GetIsValid())
+    return;
+  
+  // we are going to say that the message headers only have
+  // part data, and no header data.
+  m_headers->AdoptPartDataBuffer(headers);
+  if (!m_headers->GetIsValid())
+    SetIsValid(false);
+}
+
+// Finds the part with given part number
+// Returns a nsIMAPBodystructure of the matched part if it is this
+// or one of its children.  Returns NULL otherwise.
+nsIMAPBodypart *nsIMAPBodypartMessage::FindPartWithNumber(const char *partNum)
+{
+  // either brute force, or do it the smart way - look at the number.
+  // (the parts should be ordered, and hopefully indexed by their number)
+  
+  if (!PL_strcasecmp(partNum, m_partNumberString))
+    return this;
+  
+  return m_body->FindPartWithNumber(partNum);
+}
+
+///////////// nsIMAPBodypartMultipart ////////////////////////
+
+
+nsIMAPBodypartMultipart::nsIMAPBodypartMultipart(char *partNum, nsIMAPBodypart *parentPart) : 
+nsIMAPBodypart(partNum, parentPart)
+{
+  if (!m_parentPart  || (m_parentPart->GetType() == IMAP_BODY_MESSAGE_RFC822))
+  {
+    // the multipart (this) will inherit the part number of its parent
+    PR_FREEIF(m_partNumberString);
+    if (!m_parentPart)
+    {
+      m_partNumberString = PR_smprintf("0");
+    }
+    else
+      m_partNumberString = NS_strdup(m_parentPart->GetPartNumberString());
+  }
+  m_partList = new nsTArray<nsIMAPBodypart*>();
+  m_bodyType = NS_strdup("multipart");
+  if (m_partList && m_parentPart && m_bodyType)
+    SetIsValid(true);
+  else
+    SetIsValid(false);
+}
+
+nsIMAPBodypartType nsIMAPBodypartMultipart::GetType()
+{
+  return IMAP_BODY_MULTIPART;
+}
+
+nsIMAPBodypartMultipart::~nsIMAPBodypartMultipart()
+{
+  for (int i = m_partList->Length() - 1; i >= 0; i--)
+  {
+    delete m_partList->ElementAt(i);
+  }
+  delete m_partList;
+}
+
+void
+nsIMAPBodypartMultipart::SetBodySubType(char *bodySubType)
+{
+  PR_FREEIF(m_bodySubType);
+  PR_FREEIF(m_contentType);
+  m_bodySubType = bodySubType;
+  if (m_bodyType && m_bodySubType)
+    m_contentType = PR_smprintf("%s/%s", m_bodyType, m_bodySubType);
+}
+
+
+int32_t nsIMAPBodypartMultipart::Generate(nsIMAPBodyShell *aShell, bool stream, bool prefetch)
+{
+  int32_t len = 0;
+  
+  if (GetIsValid())
+  {
+    if (stream && !prefetch)
+      aShell->GetConnection()->Log("SHELL","GENERATE-Multipart",m_partNumberString);
+    
+    // Stream out the MIME header of this part
+    
+    bool parentIsMessageType = GetParentPart() ? (GetParentPart()->GetType() == IMAP_BODY_MESSAGE_RFC822) : true;
+    
+    // If this is multipart/signed, then we always want to generate the MIME headers of this multipart.
+    // Otherwise, we only want to do it if the parent is not of type "message"
+    bool needMIMEHeader = !parentIsMessageType;  // !PL_strcasecmp(m_bodySubType, "signed") ? true : !parentIsMessageType;
+    if (needMIMEHeader && !aShell->GetPseudoInterrupted())  // not a message body's type
+    {
+      len += GenerateMIMEHeader(aShell, stream, prefetch);
+    }
+    
+    if (ShouldFetchInline(aShell))
+    {
+      for (size_t i = 0; i < m_partList->Length(); i++)
+      {
+        if (!aShell->GetPseudoInterrupted())
+          len += GenerateBoundary(aShell, stream, prefetch, false);
+        if (!aShell->GetPseudoInterrupted())
+          len += m_partList->ElementAt(i)->Generate(aShell, stream, prefetch);
+      }
+      if (!aShell->GetPseudoInterrupted())
+        len += GenerateBoundary(aShell, stream, prefetch, true);
+    }
+    else
+    {
+      // fill in the filling within the empty part
+      if (!aShell->GetPseudoInterrupted())
+        len += GenerateEmptyFilling(aShell, stream, prefetch);
+    }
+  }
+  m_contentLength = len;
+  return m_contentLength;
+}
+
+
+bool nsIMAPBodypartMultipart::ShouldFetchInline(nsIMAPBodyShell *aShell)
+{
+  char *generatingPart = aShell->GetGeneratingPart();
+  if (generatingPart)
+  {
+    // If we are generating a specific part
+    // Always generate containers (just don't fill them in)
+    // because it is low cost (everything is cached)
+    // and it gives the message its full MIME structure,
+    // to avoid any potential mishap.
+    return true;
+  }
+  else
+  {
+    // Generating whole message
+    
+    if (ShouldExplicitlyFetchInline())
+      return true;
+    if (ShouldExplicitlyNotFetchInline())
+      return false;
+
+    if (!PL_strcasecmp(m_bodySubType, "alternative"))
+      return true;
+
+    nsIMAPBodypart *grandparentPart = m_parentPart->GetParentPart();
+
+    // if we're a multipart sub-part of multipart alternative, we need to 
+    // be fetched because mime will always display us.
+    if (!PL_strcasecmp(m_parentPart->GetBodySubType(), "alternative") &&
+        GetType() == IMAP_BODY_MULTIPART)
+      return true;
+    // If "Show Attachments as Links" is on, and
+    // the parent of this multipart is not a message,
+    // then it's not inline.
+    if (!(aShell->GetContentModified() == IMAP_CONTENT_MODIFIED_VIEW_INLINE) &&
+      (m_parentPart->GetType() != IMAP_BODY_MESSAGE_RFC822) &&
+      (m_parentPart->GetType() == IMAP_BODY_MULTIPART ?
+      (grandparentPart ? grandparentPart->GetType() != IMAP_BODY_MESSAGE_RFC822 : true)
+      : true))
+      return false;
+    
+    // multiparts are always inline (even multipart/appledouble)
+    // (their children might not be, though)
+    return true;
+  }
+}
+
+bool nsIMAPBodypartMultipart::PreflightCheckAllInline(nsIMAPBodyShell *aShell)
+{
+  bool rv = ShouldFetchInline(aShell);
+  
+  size_t i = 0;
+  while (rv && (i < m_partList->Length()))
+  {
+    rv = m_partList->ElementAt(i)->PreflightCheckAllInline(aShell);
+    i++;
+  }
+  
+  return rv;
+}
+
+nsIMAPBodypart	*nsIMAPBodypartMultipart::FindPartWithNumber(const char *partNum)
+{
+  NS_ASSERTION(partNum, "null part passed into FindPartWithNumber");
+  
+  // check this
+  if (!PL_strcmp(partNum, m_partNumberString))
+    return this;
+  
+  // check children
+  for (int i = m_partList->Length() - 1; i >= 0; i--)
+  {
+    nsIMAPBodypart *foundPart = m_partList->ElementAt(i)->FindPartWithNumber(partNum);
+    if (foundPart)
+      return foundPart;
+  }
+  
+  // not this, or any of this's children
+  return NULL;
+}
+
+
+
+///////////// nsIMAPMessageHeaders ////////////////////////////////////
+
+
+
+nsIMAPMessageHeaders::nsIMAPMessageHeaders(char *partNum, nsIMAPBodypart *parentPart) : 
+nsIMAPBodypart(partNum, parentPart)
+{
+  if (!partNum)
+  {
+    SetIsValid(false);
+    return;
+  }
+  m_partNumberString = NS_strdup(partNum);
+  if (!m_partNumberString)
+  {
+    SetIsValid(false);
+    return;
+  }
+  if (!m_parentPart || !m_parentPart->GetnsIMAPBodypartMessage())
+  {
+    // Message headers created without a valid Message parent
+    NS_ASSERTION(false, "creating message headers with invalid message parent");
+    SetIsValid(false);
+  }
+}
+
+nsIMAPBodypartType nsIMAPMessageHeaders::GetType()
+{
+  return IMAP_BODY_MESSAGE_HEADER;
+}
+
+void nsIMAPMessageHeaders::QueuePrefetchMessageHeaders(nsIMAPBodyShell *aShell)
+{
+  
+  if (!m_parentPart->GetnsIMAPBodypartMessage()->GetIsTopLevelMessage())	// not top-level headers
+    aShell->AddPrefetchToQueue(kRFC822HeadersOnly, m_partNumberString);
+  else
+    aShell->AddPrefetchToQueue(kRFC822HeadersOnly, NULL);
+}
+
+int32_t nsIMAPMessageHeaders::Generate(nsIMAPBodyShell *aShell, bool stream, bool prefetch)
+{
+  // prefetch the header
+  if (prefetch && !m_partData && !aShell->DeathSignalReceived())
+  {
+    QueuePrefetchMessageHeaders(aShell);
+  }
+  
+  if (stream && !prefetch)
+    aShell->GetConnection()->Log("SHELL","GENERATE-MessageHeaders",m_partNumberString);
+  
+  // stream out the part data
+  if (ShouldFetchInline(aShell))
+  {
+    if (!aShell->GetPseudoInterrupted())
+      m_contentLength = GeneratePart(aShell, stream, prefetch);
+  }
+  else
+  {
+    m_contentLength = 0;	// don't fill in any filling for the headers
+  }
+  return m_contentLength;
+}
+
+bool nsIMAPMessageHeaders::ShouldFetchInline(nsIMAPBodyShell *aShell)
+{
+  return m_parentPart->ShouldFetchInline(aShell);
+}
+
+
+///////////// nsIMAPBodyShellCache ////////////////////////////////////
+
+#if 0  // mscott - commenting out because it does not appear to be used
+static int
+imap_shell_cache_strcmp (const void *a, const void *b)
+{
+  return PL_strcmp ((const char *) a, (const char *) b);
+}
+#endif
+
+nsIMAPBodyShellCache::nsIMAPBodyShellCache()
+: m_shellHash(20)
+{
+  m_shellList = new nsTArray<nsIMAPBodyShell*>();
+}
+
+/* static */ nsIMAPBodyShellCache *nsIMAPBodyShellCache::Create()
+{
+  nsIMAPBodyShellCache *cache = new nsIMAPBodyShellCache();
+  if (!cache || !cache->m_shellList)
+    return NULL;
+  
+  return cache;
+}
+
+nsIMAPBodyShellCache::~nsIMAPBodyShellCache()
+{
+  while (EjectEntry()) ;
+  delete m_shellList;
+}
+
+// We'll use an LRU scheme here.
+// We will add shells in numerical order, so the
+// least recently used one will be in slot 0.
+bool nsIMAPBodyShellCache::EjectEntry()
+{
+  if (m_shellList->Length() < 1)
+    return false;
+
+  nsIMAPBodyShell *removedShell = m_shellList->ElementAt(0);
+
+  m_shellList->RemoveElementAt(0);
+  m_shellHash.Remove(removedShell->GetUID());
+
+  return true;
+}
+
+void nsIMAPBodyShellCache::Clear()
+{
+  while (EjectEntry()) ;
+}
+
+bool nsIMAPBodyShellCache::AddShellToCache(nsIMAPBodyShell *shell)
+{
+  // If it's already in the cache, then just return.
+  // This has the side-effect of re-ordering the LRU list
+  // to put this at the top, which is good, because it's what we want.
+  if (FindShellForUID(shell->GetUID(), shell->GetFolderName(), shell->GetContentModified()))
+    return true;
+
+  // OK, so it's not in the cache currently.
+
+  // First, for safety sake, remove any entry with the given UID,
+  // just in case we have a collision between two messages in different
+  // folders with the same UID.
+  RefPtr<nsIMAPBodyShell> foundShell;
+  m_shellHash.Get(shell->GetUID(), getter_AddRefs(foundShell));
+  if (foundShell)
+  {
+    m_shellHash.Remove(foundShell->GetUID());
+    m_shellList->RemoveElement(foundShell);
+  }
+
+  // Add the new one to the cache
+  m_shellList->AppendElement(shell);
+
+  m_shellHash.Put(shell->GetUID(), shell);
+  shell->SetIsCached(true);
+
+  // while we're not over our size limit, eject entries
+  bool rv = true;
+  while (GetSize() > GetMaxSize())
+    rv = EjectEntry();
+
+  return rv;
+
+}
+
+nsIMAPBodyShell *nsIMAPBodyShellCache::FindShellForUID(nsCString &UID, const char *mailboxName,
+                                                       IMAP_ContentModifiedType modType)
+{
+  RefPtr<nsIMAPBodyShell> foundShell;
+  m_shellHash.Get(UID, getter_AddRefs(foundShell));
+  if (!foundShell)
+    return nullptr;
+  // Make sure the content-modified types are compatible.
+  // This allows us to work seamlessly while people switch between
+  // View Attachments Inline and View Attachments As Links.
+  // Enforce the invariant that any cached shell we use
+  // match the current content-modified settings.
+  if (modType != foundShell->GetContentModified())
+    return nullptr;
+
+  // mailbox names must match also.
+  if (PL_strcmp(mailboxName, foundShell->GetFolderName()))
+    return nullptr;
+
+  // adjust the LRU stuff. This defeats the performance gain of the hash if
+  // it actually is found since this is linear.
+  m_shellList->RemoveElement(foundShell);
+  m_shellList->AppendElement(foundShell);// Adds to end
+
+  return foundShell;
+}
+
+///////////// nsIMAPMessagePartID ////////////////////////////////////
+
+
+nsIMAPMessagePartID::nsIMAPMessagePartID(nsIMAPeFetchFields fields, const char *partNumberString)
+: m_partNumberString(partNumberString),
+  m_fields(fields)
+{
+}
+
+nsIMAPMessagePartIDArray::nsIMAPMessagePartIDArray()
+{
+}
+
+nsIMAPMessagePartIDArray::~nsIMAPMessagePartIDArray()
+{
+  RemoveAndFreeAll();
+}
+
+void nsIMAPMessagePartIDArray::RemoveAndFreeAll()
+{
+  uint32_t n = Length();
+  for (uint32_t i = 0; i < n; i++)
+  {
+     nsIMAPMessagePartID *part = GetPart(i);
+     delete part;
+  }
+  Clear();
+}
diff --git a/mailnews/imap/src/nsIMAPBodyShell.h b/mailnews/imap/src/nsIMAPBodyShell.h
new file mode 100644
index 0000000000..1c8d58ae50
--- /dev/null
+++ b/mailnews/imap/src/nsIMAPBodyShell.h
@@ -0,0 +1,361 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* 
+nsIMAPBodyShell and associated classes
+*/ 
+
+#ifndef IMAPBODY_H
+#define IMAPBODY_H
+
+#include "mozilla/Attributes.h"
+#include "nsImapCore.h"
+#include "nsStringGlue.h"
+#include "nsRefPtrHashtable.h"
+#include "nsTArray.h"
+
+class nsImapProtocol;
+
+typedef enum _nsIMAPBodypartType {
+	IMAP_BODY_MESSAGE_RFC822,
+	IMAP_BODY_MESSAGE_HEADER,
+	IMAP_BODY_LEAF,
+	IMAP_BODY_MULTIPART
+} nsIMAPBodypartType;
+
+class nsIMAPBodyShell;
+class nsIMAPBodypartMessage;
+
+class nsIMAPBodypart
+{
+public:
+	// Construction
+	virtual bool GetIsValid() { return m_isValid; }
+	virtual void	SetIsValid(bool valid);
+	virtual nsIMAPBodypartType	GetType() = 0;
+
+	// Generation
+    // Generates an HTML representation of this part.  Returns content length generated, -1 if failed.
+    virtual int32_t Generate(nsIMAPBodyShell *aShell, bool /*stream*/, bool /* prefetch */) { return -1; }
+    virtual void AdoptPartDataBuffer(char *buf);    // Adopts storage for part data buffer.  If NULL, sets isValid to false.
+    virtual void AdoptHeaderDataBuffer(char *buf);  // Adopts storage for header data buffer.  If NULL, sets isValid to false.
+    virtual bool ShouldFetchInline(nsIMAPBodyShell *aShell) { return true; }  // returns true if this part should be fetched inline for generation.
+    virtual bool PreflightCheckAllInline(nsIMAPBodyShell *aShell) { return true; }
+
+	virtual bool ShouldExplicitlyFetchInline();
+	virtual bool ShouldExplicitlyNotFetchInline();
+        virtual bool IsLastTextPart(const char *partNumberString) {return true;}
+
+protected:
+    // If stream is false, simply returns the content length that will be generated
+    // the body of the part itself
+    virtual int32_t GeneratePart(nsIMAPBodyShell *aShell, bool stream, bool prefetch);
+    // the MIME headers of the part
+    virtual int32_t GenerateMIMEHeader(nsIMAPBodyShell *aShell, bool stream, bool prefetch); 
+    // Generates the MIME boundary wrapper for this part.
+    virtual int32_t GenerateBoundary(nsIMAPBodyShell *aShell, bool stream, bool prefetch, bool lastBoundary);
+    // lastBoundary indicates whether or not this should be the boundary for the
+    // final MIME part of the multipart message.
+    // Generates (possibly empty) filling for a part that won't be filled in inline.
+    virtual int32_t GenerateEmptyFilling(nsIMAPBodyShell *aShell, bool stream, bool prefetch);
+
+	// Part Numbers / Hierarchy
+public:
+	virtual char	*GetPartNumberString() { return m_partNumberString; }
+	virtual nsIMAPBodypart	*FindPartWithNumber(const char *partNum);	// Returns the part object with the given number
+	virtual nsIMAPBodypart	*GetParentPart() { return m_parentPart; }	// Returns the parent of this part.
+																		// We will define a part of type message/rfc822 to be the
+																		// parent of its body and header.
+																		// A multipart is a parent of its child parts.
+																		// All other leafs do not have children.
+
+	// Other / Helpers
+public:
+	virtual ~nsIMAPBodypart();
+	virtual nsIMAPBodypartMessage	*GetnsIMAPBodypartMessage() { return NULL; }
+
+	const char	*GetBodyType() { return m_bodyType; }
+	const char	*GetBodySubType() { return m_bodySubType; }
+    void SetBoundaryData(char *boundaryData) { m_boundaryData = boundaryData; }
+
+protected:
+    virtual void QueuePrefetchMIMEHeader(nsIMAPBodyShell *aShell);
+	//virtual void	PrefetchMIMEHeader();			// Initiates a prefetch for the MIME header of this part.
+    nsIMAPBodypart(char *partNumber, nsIMAPBodypart *parentPart);
+
+protected:
+	bool	m_isValid;				// If this part is valid.
+	char	*m_partNumberString;	// string representation of this part's full-hierarchy number.  Define 0 to be the top-level message
+	char	*m_partData;			// data for this part.  NULL if not filled in yet.
+	char	*m_headerData;			// data for this part's MIME header.  NULL if not filled in yet.
+	char	*m_boundaryData;		// MIME boundary for this part
+	int32_t	m_partLength;
+	int32_t	m_contentLength;		// Total content length which will be Generate()'d.  -1 if not filled in yet.
+	nsIMAPBodypart	*m_parentPart;	// Parent of this part
+
+	// Fields	- Filled in from parsed BODYSTRUCTURE response (as well as others)
+	char	*m_contentType;			// constructed from m_bodyType and m_bodySubType
+	char	*m_bodyType;
+	char	*m_bodySubType;
+	char	*m_bodyID;
+	char	*m_bodyDescription;
+	char	*m_bodyEncoding;
+	// we ignore extension data for now
+};
+
+
+
+// Message headers
+// A special type of nsIMAPBodypart
+// These may be headers for the top-level message,
+// or any body part of type message/rfc822.
+class nsIMAPMessageHeaders : public nsIMAPBodypart
+{
+public:
+    nsIMAPMessageHeaders(char *partNum, nsIMAPBodypart *parentPart);
+    virtual nsIMAPBodypartType	GetType() override;
+    // Generates an HTML representation of this part.  Returns content length generated, -1 if failed.
+    virtual int32_t Generate(nsIMAPBodyShell *aShell, bool stream,
+                             bool prefetch) override;
+    virtual bool ShouldFetchInline(nsIMAPBodyShell *aShell) override;
+    virtual void QueuePrefetchMessageHeaders(nsIMAPBodyShell *aShell);
+};
+
+
+class nsIMAPBodypartMultipart : public nsIMAPBodypart
+{
+public:
+    nsIMAPBodypartMultipart(char *partNum, nsIMAPBodypart *parentPart);
+	virtual nsIMAPBodypartType	GetType() override;
+	virtual ~nsIMAPBodypartMultipart();
+    virtual bool ShouldFetchInline(nsIMAPBodyShell *aShell) override;
+    virtual bool PreflightCheckAllInline(nsIMAPBodyShell *aShell) override;
+    // Generates an HTML representation of this part.  Returns content length generated, -1 if failed.
+    virtual int32_t Generate(nsIMAPBodyShell *aShell, bool stream,
+                             bool prefetch) override;
+    // Returns the part object with the given number
+	virtual nsIMAPBodypart	*FindPartWithNumber(const char *partNum
+                                                ) override;
+    virtual bool IsLastTextPart(const char *partNumberString) override;
+    void AppendPart(nsIMAPBodypart *part)  { m_partList->AppendElement(part); }
+    void SetBodySubType(char *bodySubType);
+
+protected:
+    nsTArray<nsIMAPBodypart*>  *m_partList;  // An ordered list of top-level body parts for this shell
+};
+
+
+// The name "leaf" is somewhat misleading, since a part of type message/rfc822 is technically
+// a leaf, even though it can contain other parts within it.
+class nsIMAPBodypartLeaf : public nsIMAPBodypart
+{
+public:
+  nsIMAPBodypartLeaf(char *partNum, nsIMAPBodypart *parentPart, char *bodyType,
+                     char *bodySubType, char *bodyID, char *bodyDescription,
+                     char *bodyEncoding, int32_t partLength,
+                     bool preferPlainText);
+    virtual nsIMAPBodypartType	GetType() override;
+    // Generates an HTML representation of this part.  Returns content length generated, -1 if failed.
+    virtual int32_t Generate(nsIMAPBodyShell *aShell, bool stream, bool prefetch) override;
+    // returns true if this part should be fetched inline for generation.
+    virtual bool ShouldFetchInline(nsIMAPBodyShell *aShell) override;
+    virtual bool PreflightCheckAllInline(nsIMAPBodyShell *aShell) override;
+private:
+  bool mPreferPlainText;
+};
+
+
+class nsIMAPBodypartMessage : public nsIMAPBodypartLeaf
+{
+public:
+  nsIMAPBodypartMessage(char *partNum, nsIMAPBodypart *parentPart,
+                        bool topLevelMessage, char *bodyType,
+                        char *bodySubType, char *bodyID,
+                        char *bodyDescription, char *bodyEncoding,
+                        int32_t partLength, bool preferPlainText);
+    void SetBody(nsIMAPBodypart *body);
+	virtual nsIMAPBodypartType	GetType() override;
+	virtual ~nsIMAPBodypartMessage();
+    virtual int32_t Generate(nsIMAPBodyShell *aShell, bool stream,
+                             bool prefetch) override;
+    virtual bool ShouldFetchInline(nsIMAPBodyShell *aShell) override;
+    virtual bool PreflightCheckAllInline(nsIMAPBodyShell *aShell) override;
+	// Returns the part object with the given number
+	virtual nsIMAPBodypart	*FindPartWithNumber(const char *partNum
+                                                ) override;
+	void	AdoptMessageHeaders(char *headers);			// Fills in buffer (and adopts storage) for header object
+														// partNum specifies the message part number to which the
+														// headers correspond.  NULL indicates the top-level message
+	virtual nsIMAPBodypartMessage	*GetnsIMAPBodypartMessage() override { return this; }
+	virtual	bool		GetIsTopLevelMessage() { return m_topLevelMessage; }
+
+protected:
+	nsIMAPMessageHeaders		*m_headers;				// Every body shell should have headers
+	nsIMAPBodypart			*m_body;	
+	bool					m_topLevelMessage;		// Whether or not this is the top-level message
+
+};
+
+
+class nsIMAPMessagePartIDArray;
+
+// We will refer to a Body "Shell" as a hierarchical object representation of a parsed BODYSTRUCTURE
+// response.  A shell contains representations of Shell "Parts."  A Body Shell can undergo essentially
+// two operations: Construction and Generation.
+// Shell Construction occurs from a parsed a BODYSTRUCTURE response, split into empty parts.
+// Shell Generation generates a "MIME Shell" of the message and streams it to libmime for
+// display.  The MIME Shell has selected (inline) parts filled in, and leaves all others
+// for on-demand retrieval through explicit part fetches.
+
+class nsIMAPBodyShell : public nsISupports
+{
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  nsIMAPBodyShell(nsImapProtocol *protocolConnection,
+                  nsIMAPBodypartMessage *message, uint32_t UID,
+                  const char *folderName);
+  // To be used after a shell is uncached
+  void SetConnection(nsImapProtocol *con) { m_protocolConnection = con; }
+  virtual bool GetIsValid() { return m_isValid; }
+  virtual void SetIsValid(bool valid);
+
+  // Prefetch
+  // Adds a message body part to the queue to be prefetched
+  // in a single, pipelined command
+  void AddPrefetchToQueue(nsIMAPeFetchFields, const char *partNum);
+  // Runs a single pipelined command which fetches all of the
+  // elements in the prefetch queue
+  void FlushPrefetchQueue();
+  // Fills in buffer (and adopts storage) for header object
+  // partNum specifies the message part number to which the
+  // headers correspond.  NULL indicates the top-level message
+  void AdoptMessageHeaders(char *headers, const char *partNum);
+  // Fills in buffer (and adopts storage) for MIME headers in appropriate object.
+  // If object can't be found, sets isValid to false.
+  void AdoptMimeHeader(const char *partNum, char *mimeHeader);
+
+  // Generation
+  // Streams out an HTML representation of this IMAP message, going along and
+  // fetching parts it thinks it needs, and leaving empty shells for the parts
+  // it doesn't.
+  // Returns number of bytes generated, or -1 if invalid.
+  // If partNum is not NULL, then this works to generates a MIME part that hasn't been downloaded yet
+  // and leaves out all other parts.  By default, to generate a normal message, partNum should be NULL.
+  virtual int32_t Generate(char *partNum);
+
+  // Returns TRUE if the user has the pref "Show Attachments Inline" set.
+  // Returns FALSE if the setting is "Show Attachments as Links"
+  virtual bool GetShowAttachmentsInline();
+  // Returns true if all parts are inline, false otherwise. Does not generate anything.
+  bool PreflightCheckAllInline();
+
+  // Helpers
+  nsImapProtocol *GetConnection() { return m_protocolConnection; }
+  bool GetPseudoInterrupted();
+  bool DeathSignalReceived();
+  nsCString &GetUID() { return m_UID; }
+  const char *GetFolderName() { return m_folderName; }
+  char *GetGeneratingPart() { return m_generatingPart; }
+  // Returns true if this is in the process of being generated,
+  // so we don't re-enter
+  bool IsBeingGenerated() { return m_isBeingGenerated; }
+  bool IsShellCached() { return m_cached; }
+  void SetIsCached(bool isCached) { m_cached = isCached; }
+  bool GetGeneratingWholeMessage() { return m_generatingWholeMessage; }
+  IMAP_ContentModifiedType	GetContentModified() { return m_contentModified; }
+  void SetContentModified(IMAP_ContentModifiedType modType) { m_contentModified = modType; }
+protected:
+  virtual ~nsIMAPBodyShell();
+
+  nsIMAPBodypartMessage *m_message;
+
+  nsIMAPMessagePartIDArray        *m_prefetchQueue; // array of pipelined part prefetches.  Ok, so it's not really a queue.
+
+  bool                            m_isValid;
+  nsImapProtocol                  *m_protocolConnection;  // Connection, for filling in parts
+  nsCString                       m_UID;                  // UID of this message
+  char                            *m_folderName;          // folder that contains this message
+  char                            *m_generatingPart;      // If a specific part is being generated, this is it.  Otherwise, NULL.
+  bool                            m_isBeingGenerated;     // true if this body shell is in the process of being generated
+  bool                            m_gotAttachmentPref;    // Whether or not m_showAttachmentsInline has been initialized 
+  bool                            m_showAttachmentsInline; // Whether or not we should display attachment inline
+  bool                            m_cached;                 // Whether or not this shell is cached
+  bool                            m_generatingWholeMessage; // whether or not we are generating the whole (non-MPOD) message
+                                                          // Set to false if we are generating by parts
+  // under what conditions the content has been modified.
+  // Either IMAP_CONTENT_MODIFIED_VIEW_INLINE or IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS
+  IMAP_ContentModifiedType        m_contentModified; 
+};
+
+
+
+// This class caches shells, so we don't have to always go and re-fetch them.
+// This does not cache any of the filled-in inline parts;  those are cached individually
+// in the libnet memory cache.  (ugh, how will we do that?)
+// Since we'll only be retrieving shells for messages over a given size, and since the
+// shells themselves won't be very large, this cache will not grow very big (relatively)
+// and should handle most common usage scenarios.
+
+// A body cache is associated with a given host, spanning folders.
+// It should pay attention to UIDVALIDITY.
+
+class nsIMAPBodyShellCache
+{
+public:
+  static nsIMAPBodyShellCache *Create();
+  virtual ~nsIMAPBodyShellCache();
+
+  // Adds shell to cache, possibly ejecting
+  // another entry based on scheme in EjectEntry().
+  bool AddShellToCache(nsIMAPBodyShell *shell);
+  // Looks up a shell in the cache given the message's UID.
+  nsIMAPBodyShell *FindShellForUID(nsCString &UID, const char *mailboxName,
+                                   IMAP_ContentModifiedType modType);
+  void Clear();
+
+protected:
+  nsIMAPBodyShellCache();
+  // Chooses an entry to eject;  deletes that entry;  and ejects it from the
+  // cache, clearing up a new space.  Returns true if it found an entry
+  // to eject, false otherwise.
+  bool EjectEntry();
+  uint32_t GetSize() { return m_shellList->Length(); }
+  uint32_t GetMaxSize() { return 20; }
+  nsTArray<nsIMAPBodyShell*> *m_shellList; // For maintenance
+  // For quick lookup based on UID
+  nsRefPtrHashtable <nsCStringHashKey, nsIMAPBodyShell> m_shellHash;
+};
+
+// MessagePartID and MessagePartIDArray are used for pipelining prefetches.
+
+class nsIMAPMessagePartID
+{
+public:
+  nsIMAPMessagePartID(nsIMAPeFetchFields fields, const char *partNumberString);
+  nsIMAPeFetchFields GetFields() { return m_fields; }
+  const char *GetPartNumberString() { return m_partNumberString; }
+
+protected:
+  const char *m_partNumberString;
+  nsIMAPeFetchFields m_fields;
+};
+
+
+class nsIMAPMessagePartIDArray : public nsTArray<nsIMAPMessagePartID*> {
+public:
+  nsIMAPMessagePartIDArray();
+  ~nsIMAPMessagePartIDArray();
+
+  void RemoveAndFreeAll();
+  uint32_t GetNumParts() { return Length(); }
+  nsIMAPMessagePartID *GetPart(uint32_t i)
+  {
+    NS_ASSERTION(i < Length(), "invalid message part #");
+    return ElementAt(i);
+  }
+};
+
+
+#endif // IMAPBODY_H
diff --git a/mailnews/imap/src/nsIMAPGenericParser.cpp b/mailnews/imap/src/nsIMAPGenericParser.cpp
new file mode 100644
index 0000000000..3053ab5401
--- /dev/null
+++ b/mailnews/imap/src/nsIMAPGenericParser.cpp
@@ -0,0 +1,484 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"  // for pre-compiled headers
+
+#include "nsImapCore.h"
+#include "nsImapProtocol.h"
+#include "nsIMAPGenericParser.h"
+#include "nsStringGlue.h"
+
+////////////////// nsIMAPGenericParser /////////////////////////
+
+
+nsIMAPGenericParser::nsIMAPGenericParser() :
+fNextToken(nullptr),
+fCurrentLine(nullptr),
+fLineOfTokens(nullptr),
+fStartOfLineOfTokens(nullptr),
+fCurrentTokenPlaceHolder(nullptr),
+fAtEndOfLine(false),
+fParserState(stateOK)
+{
+}
+
+nsIMAPGenericParser::~nsIMAPGenericParser()
+{
+  PR_FREEIF( fCurrentLine );
+  PR_FREEIF( fStartOfLineOfTokens);
+}
+
+void nsIMAPGenericParser::HandleMemoryFailure()
+{
+  SetConnected(false);
+}
+
+void nsIMAPGenericParser::ResetLexAnalyzer()
+{
+  PR_FREEIF( fCurrentLine );
+  PR_FREEIF( fStartOfLineOfTokens );
+  
+  fNextToken = fCurrentLine = fLineOfTokens = fStartOfLineOfTokens = fCurrentTokenPlaceHolder = nullptr;
+  fAtEndOfLine = false;
+}
+
+bool nsIMAPGenericParser::LastCommandSuccessful()
+{
+  return fParserState == stateOK;
+}
+
+void nsIMAPGenericParser::SetSyntaxError(bool error, const char *msg)
+{
+  if (error)
+      fParserState |= stateSyntaxErrorFlag;
+  else
+      fParserState &= ~stateSyntaxErrorFlag;
+  NS_ASSERTION(!error, "syntax error in generic parser");	
+}
+
+void nsIMAPGenericParser::SetConnected(bool connected)
+{
+  if (connected)
+      fParserState &= ~stateDisconnectedFlag;
+  else
+      fParserState |= stateDisconnectedFlag;
+}
+
+void nsIMAPGenericParser::skip_to_CRLF()
+{
+  while (Connected() && !fAtEndOfLine)
+    AdvanceToNextToken();
+}
+
+// fNextToken initially should point to
+// a string after the initial open paren ("(")
+// After this call, fNextToken points to the
+// first character after the matching close
+// paren.  Only call AdvanceToNextToken() to get the NEXT
+// token after the one returned in fNextToken.
+void nsIMAPGenericParser::skip_to_close_paren()
+{
+  int numberOfCloseParensNeeded = 1;
+  while (ContinueParse())
+  {
+    // go through fNextToken, account for nested parens
+    const char *loc;
+    for (loc = fNextToken; loc && *loc; loc++)
+    {
+      if (*loc == '(')
+        numberOfCloseParensNeeded++;
+      else if (*loc == ')')
+      {
+        numberOfCloseParensNeeded--;
+        if (numberOfCloseParensNeeded == 0)
+        {
+          fNextToken = loc + 1;
+          if (!fNextToken || !*fNextToken)
+            AdvanceToNextToken();
+          return;
+        }
+      }
+      else if (*loc == '{' || *loc == '"') {
+        // quoted or literal  
+        fNextToken = loc;
+        char *a = CreateString();
+        PR_FREEIF(a);
+        break; // move to next token
+      }
+    }
+    if (ContinueParse())
+      AdvanceToNextToken();
+  }
+}
+
+void nsIMAPGenericParser::AdvanceToNextToken()
+{
+  if (!fCurrentLine || fAtEndOfLine)
+    AdvanceToNextLine();
+  if (Connected())
+  {
+    if (!fStartOfLineOfTokens)
+    {
+      // this is the first token of the line; setup tokenizer now
+      fStartOfLineOfTokens = PL_strdup(fCurrentLine);
+      if (!fStartOfLineOfTokens)
+      {
+        HandleMemoryFailure();
+        return;
+      }
+      fLineOfTokens = fStartOfLineOfTokens;
+      fCurrentTokenPlaceHolder = fStartOfLineOfTokens;
+    }
+    fNextToken = NS_strtok(WHITESPACE, &fCurrentTokenPlaceHolder);
+    if (!fNextToken)
+    {
+      fAtEndOfLine = true;
+      fNextToken = CRLF;
+    }
+  }
+}
+
+void nsIMAPGenericParser::AdvanceToNextLine()
+{
+  PR_FREEIF( fCurrentLine );
+  PR_FREEIF( fStartOfLineOfTokens);
+  
+  bool ok = GetNextLineForParser(&fCurrentLine);
+  if (!ok)
+  {
+    SetConnected(false);
+    fStartOfLineOfTokens = nullptr;
+    fLineOfTokens = nullptr;
+    fCurrentTokenPlaceHolder = nullptr;
+    fAtEndOfLine = true;
+    fNextToken = CRLF;
+  }
+  else if (!fCurrentLine)
+  {
+    HandleMemoryFailure();
+  }
+  else
+  {
+     fNextToken = nullptr;
+     // determine if there are any tokens (without calling AdvanceToNextToken);
+     // otherwise we are already at end of line
+     NS_ASSERTION(strlen(WHITESPACE) == 3, "assume 3 chars of whitespace");
+     char *firstToken = fCurrentLine;
+     while (*firstToken && (*firstToken == WHITESPACE[0] ||
+            *firstToken == WHITESPACE[1] || *firstToken == WHITESPACE[2]))
+       firstToken++;
+     fAtEndOfLine = (*firstToken == '\0');
+  }
+}
+
+// advances |fLineOfTokens| by |bytesToAdvance| bytes
+void nsIMAPGenericParser::AdvanceTokenizerStartingPoint(int32_t bytesToAdvance)
+{
+  NS_PRECONDITION(bytesToAdvance>=0, "bytesToAdvance must not be negative");
+  if (!fStartOfLineOfTokens)
+  {
+    AdvanceToNextToken();  // the tokenizer was not yet initialized, do it now
+    if (!fStartOfLineOfTokens)
+      return;
+  }
+    
+  if(!fStartOfLineOfTokens)
+      return;
+  // The last call to AdvanceToNextToken() cleared the token separator to '\0'
+  // iff |fCurrentTokenPlaceHolder|.  We must recover this token separator now.
+  if (fCurrentTokenPlaceHolder)
+  {
+    int endTokenOffset = fCurrentTokenPlaceHolder - fStartOfLineOfTokens - 1;
+    if (endTokenOffset >= 0)
+      fStartOfLineOfTokens[endTokenOffset] = fCurrentLine[endTokenOffset];
+  }
+
+  NS_ASSERTION(bytesToAdvance + (fLineOfTokens-fStartOfLineOfTokens) <=
+    (int32_t)strlen(fCurrentLine), "cannot advance beyond end of fLineOfTokens");
+  fLineOfTokens += bytesToAdvance;
+  fCurrentTokenPlaceHolder = fLineOfTokens;
+}
+
+// RFC3501:  astring = 1*ASTRING-CHAR / string
+//           string  = quoted / literal
+// This function leaves us off with fCurrentTokenPlaceHolder immediately after
+// the end of the Astring.  Call AdvanceToNextToken() to get the token after it.
+char *nsIMAPGenericParser::CreateAstring()
+{
+  if (*fNextToken == '{')
+    return CreateLiteral();		// literal
+  else if (*fNextToken == '"')
+    return CreateQuoted();		// quoted
+  else
+    return CreateAtom(true); // atom
+}
+
+// Create an atom
+// This function does not advance the parser.
+// Call AdvanceToNextToken() to get the next token after the atom.
+// RFC3501:  atom            = 1*ATOM-CHAR
+//           ASTRING-CHAR    = ATOM-CHAR / resp-specials
+//           ATOM-CHAR       = <any CHAR except atom-specials>
+//           atom-specials   = "(" / ")" / "{" / SP / CTL / list-wildcards /
+//                             quoted-specials / resp-specials
+//           list-wildcards  = "%" / "*"
+//           quoted-specials = DQUOTE / "\"
+//           resp-specials   = "]"
+// "Characters are 7-bit US-ASCII unless otherwise specified." [RFC3501, 1.2.]
+char *nsIMAPGenericParser::CreateAtom(bool isAstring)
+{
+  char *rv = PL_strdup(fNextToken);
+  if (!rv)
+  {
+    HandleMemoryFailure();
+    return nullptr;
+  }
+  // We wish to stop at the following characters (in decimal ascii)
+  // 1-31 (CTL), 32 (SP), 34 '"', 37 '%', 40-42 "()*", 92 '\\', 123 '{'
+  // also, ']' is only allowed in astrings
+  char *last = rv;
+  char c = *last;
+  while ((c > 42 || c == 33 || c == 35 || c == 36 || c == 38 || c == 39)
+         && c != '\\' && c != '{' && (isAstring || c != ']'))
+     c = *++last;
+  if (rv == last) {
+     SetSyntaxError(true, "no atom characters found");
+     PL_strfree(rv);
+     return nullptr;
+  }
+  if (*last)
+  {
+    // not the whole token was consumed  
+    *last = '\0';
+    AdvanceTokenizerStartingPoint((fNextToken - fLineOfTokens) + (last-rv));
+  }
+  return rv;
+}
+
+// CreateNilString return either NULL (for "NIL") or a string
+// Call with fNextToken pointing to the thing which we think is the nilstring.
+// This function leaves us off with fCurrentTokenPlaceHolder immediately after
+// the end of the string.
+// Regardless of type, call AdvanceToNextToken() to get the token after it.
+// RFC3501:   nstring  = string / nil
+//            nil      = "NIL"
+char *nsIMAPGenericParser::CreateNilString()
+{
+  if (!PL_strncasecmp(fNextToken, "NIL", 3))
+  {
+    // check if there is text after "NIL" in fNextToken,
+    // equivalent handling as in CreateQuoted
+    if (fNextToken[3])
+      AdvanceTokenizerStartingPoint((fNextToken - fLineOfTokens) + 3);
+    return NULL;
+  }
+  else
+    return CreateString();
+}
+
+
+// Create a string, which can either be quoted or literal,
+// but not an atom.
+// This function leaves us off with fCurrentTokenPlaceHolder immediately after
+// the end of the String.  Call AdvanceToNextToken() to get the token after it.
+char *nsIMAPGenericParser::CreateString()
+{
+  if (*fNextToken == '{')
+  {
+    char *rv = CreateLiteral();		// literal
+    return (rv);
+  }
+  else if (*fNextToken == '"')
+  {
+    char *rv = CreateQuoted();		// quoted
+    return (rv);
+  }
+  else
+  {
+    SetSyntaxError(true, "string does not start with '{' or '\"'");
+    return NULL;
+  }
+}
+
+// This function sets fCurrentTokenPlaceHolder immediately after the end of the
+// closing quote.  Call AdvanceToNextToken() to get the token after it.
+// QUOTED_CHAR     ::= <any TEXT_CHAR except quoted_specials> /
+//                     "\" quoted_specials
+// TEXT_CHAR       ::= <any CHAR except CR and LF>
+// quoted_specials ::= <"> / "\"
+// Note that according to RFC 1064 and RFC 2060, CRs and LFs are not allowed 
+// inside a quoted string.  It is sufficient to read from the current line only.
+char *nsIMAPGenericParser::CreateQuoted(bool /*skipToEnd*/)
+{
+  // one char past opening '"'
+  char *currentChar = fCurrentLine + (fNextToken - fStartOfLineOfTokens) + 1;
+  
+  int escapeCharsCut = 0;
+  nsCString returnString(currentChar);
+  int charIndex;
+  for (charIndex = 0; returnString.CharAt(charIndex) != '"'; charIndex++)
+  {
+    if (!returnString.CharAt(charIndex))
+    {
+      SetSyntaxError(true, "no closing '\"' found in quoted");
+      return nullptr;
+    }
+    else if (returnString.CharAt(charIndex) == '\\')
+    {
+      // eat the escape character, but keep the escaped character
+      returnString.Cut(charIndex, 1);
+      escapeCharsCut++;
+    }
+  }
+  // +2 because of the start and end quotes
+  AdvanceTokenizerStartingPoint((fNextToken - fLineOfTokens) +
+                                charIndex + escapeCharsCut + 2);
+
+  returnString.SetLength(charIndex);
+  return ToNewCString(returnString);
+}
+
+
+// This function leaves us off with fCurrentTokenPlaceHolder immediately after
+// the end of the literal string.  Call AdvanceToNextToken() to get the token
+// after the literal string.
+// RFC3501:  literal = "{" number "}" CRLF *CHAR8
+//                       ; Number represents the number of CHAR8s
+//           CHAR8   = %x01-ff
+//                       ; any OCTET except NUL, %x00
+char *nsIMAPGenericParser::CreateLiteral()
+{
+  int32_t numberOfCharsInMessage = atoi(fNextToken + 1);
+  uint32_t numBytes = numberOfCharsInMessage + 1;
+  NS_ASSERTION(numBytes, "overflow!");
+  if (!numBytes)
+    return nullptr;
+  char *returnString = (char *)PR_Malloc(numBytes);
+  if (!returnString)
+  {
+    HandleMemoryFailure();
+    return nullptr;
+  }
+
+  int32_t currentLineLength = 0;
+  int32_t charsReadSoFar = 0;
+  int32_t bytesToCopy = 0;
+  while (charsReadSoFar < numberOfCharsInMessage)
+  {
+    AdvanceToNextLine();
+    if (!ContinueParse())
+      break;
+    
+    currentLineLength = strlen(fCurrentLine);
+    bytesToCopy = (currentLineLength > numberOfCharsInMessage - charsReadSoFar ?
+                   numberOfCharsInMessage - charsReadSoFar : currentLineLength);
+    NS_ASSERTION(bytesToCopy, "zero-length line?");
+    memcpy(returnString + charsReadSoFar, fCurrentLine, bytesToCopy); 
+    charsReadSoFar += bytesToCopy;
+  }
+  
+  if (ContinueParse())
+  {
+    if (currentLineLength == bytesToCopy)
+    {
+      // We have consumed the entire line.
+      // Consider the input  "{4}\r\n"  "L1\r\n"  " A2\r\n"  which is read
+      // line-by-line.  Reading an Astring, this should result in "L1\r\n".
+      // Note that the second line is "L1\r\n", where the "\r\n" is part of
+      // the literal.  Hence, we now read the next line to ensure that the
+      // next call to AdvanceToNextToken() leads to fNextToken=="A2" in our
+      // example.
+      AdvanceToNextLine();
+    }
+    else
+      AdvanceTokenizerStartingPoint(bytesToCopy);
+  }
+  
+  returnString[charsReadSoFar] = 0;
+  return returnString;
+}
+
+
+// Call this to create a buffer containing all characters within
+// a given set of parentheses.
+// Call this with fNextToken[0]=='(', that is, the open paren
+// of the group.
+// It will allocate and return all characters up to and including the corresponding
+// closing paren, and leave the parser in the right place afterwards.
+char *nsIMAPGenericParser::CreateParenGroup()
+{
+  NS_ASSERTION(fNextToken[0] == '(', "we don't have a paren group!");
+  
+  int numOpenParens = 0;
+  AdvanceTokenizerStartingPoint(fNextToken - fLineOfTokens);
+  
+  // Build up a buffer containing the paren group.
+  nsCString returnString;
+  char *parenGroupStart = fCurrentTokenPlaceHolder;
+  NS_ASSERTION(parenGroupStart[0] == '(', "we don't have a paren group (2)!");
+  while (*fCurrentTokenPlaceHolder)
+  {
+    if (*fCurrentTokenPlaceHolder == '{')  // literal
+    {
+      // Ensure it is a properly formatted literal.
+      NS_ASSERTION(!strcmp("}\r\n", fCurrentTokenPlaceHolder + strlen(fCurrentTokenPlaceHolder) - 3), "not a literal");
+      
+      // Append previous characters and the "{xx}\r\n" to buffer.
+      returnString.Append(parenGroupStart);
+      
+      // Append literal itself.
+      AdvanceToNextToken();
+      if (!ContinueParse())
+        break;
+      char *lit = CreateLiteral();
+      NS_ASSERTION(lit, "syntax error or out of memory");
+      if (!lit)
+        break;
+      returnString.Append(lit);
+      PR_Free(lit);
+      if (!ContinueParse())
+        break;
+      parenGroupStart = fCurrentTokenPlaceHolder;
+    }
+    else if (*fCurrentTokenPlaceHolder == '"')  // quoted
+    {
+      // Append the _escaped_ version of the quoted string:
+      // just skip it (because the quoted string must be on the same line).
+      AdvanceToNextToken();
+      if (!ContinueParse())
+        break;
+      char *q = CreateQuoted();
+      if (!q)
+        break;
+      PR_Free(q);
+      if (!ContinueParse())
+        break;
+    }
+    else
+    {
+      // Append this character to the buffer.
+      char c = *fCurrentTokenPlaceHolder++;
+      if (c == '(')
+        numOpenParens++;
+      else if (c == ')')
+      {
+        numOpenParens--;
+        if (numOpenParens == 0)
+          break;
+      }
+    }
+  }
+  
+  if (numOpenParens != 0 || !ContinueParse())
+  {
+    SetSyntaxError(true, "closing ')' not found in paren group");
+    return nullptr;
+  }
+
+  returnString.Append(parenGroupStart, fCurrentTokenPlaceHolder - parenGroupStart);
+  AdvanceToNextToken();  
+  return ToNewCString(returnString);
+}
+
diff --git a/mailnews/imap/src/nsIMAPGenericParser.h b/mailnews/imap/src/nsIMAPGenericParser.h
new file mode 100644
index 0000000000..34f66e4ff5
--- /dev/null
+++ b/mailnews/imap/src/nsIMAPGenericParser.h
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* 
+nsIMAPGenericParser is the base parser class used by the server parser and body shell parser
+*/ 
+
+#ifndef nsIMAPGenericParser_H
+#define nsIMAPGenericParser_H
+
+#include "nsImapCore.h"
+
+#define WHITESPACE " \015\012"     // token delimiter 
+
+
+class nsIMAPGenericParser 
+{
+
+public:
+	nsIMAPGenericParser();
+	virtual ~nsIMAPGenericParser();
+
+  // Add any specific stuff in the derived class
+  virtual bool       LastCommandSuccessful();
+
+  bool SyntaxError() { return (fParserState & stateSyntaxErrorFlag) != 0; }
+  bool ContinueParse() { return fParserState == stateOK; }
+  bool Connected() { return !(fParserState & stateDisconnectedFlag); }
+  void SetConnected(bool error);
+    
+protected:
+
+	// This is a pure virtual member which must be overridden in the derived class
+	// for each different implementation of a nsIMAPGenericParser.
+	// For instance, one implementation (the nsIMAPServerState) might get the next line
+	// from an open socket, whereas another implementation might just get it from a buffer somewhere.
+	// This fills in nextLine with the buffer, and returns true if everything is OK.
+	// Returns false if there was some error encountered.  In that case, we reset the parser.
+	virtual bool	GetNextLineForParser(char **nextLine) = 0;	
+
+  virtual void	HandleMemoryFailure();
+  void skip_to_CRLF();
+  void skip_to_close_paren();
+  char *CreateString();
+  char *CreateAstring();
+  char *CreateNilString();
+  char *CreateLiteral();
+  char *CreateAtom(bool isAstring = false);
+  char *CreateQuoted(bool skipToEnd = true);
+  char *CreateParenGroup();
+  virtual void SetSyntaxError(bool error, const char *msg);
+
+  void AdvanceToNextToken();
+  void AdvanceToNextLine();
+  void AdvanceTokenizerStartingPoint(int32_t bytesToAdvance);
+  void ResetLexAnalyzer();
+
+protected:
+	// use with care
+  const char     *fNextToken;
+  char           *fCurrentLine;
+	char					 *fLineOfTokens;
+  char           *fStartOfLineOfTokens;
+  char           *fCurrentTokenPlaceHolder;
+  bool            fAtEndOfLine;
+
+private:
+  enum nsIMAPGenericParserState { stateOK = 0,
+                                  stateSyntaxErrorFlag = 0x1,
+                                  stateDisconnectedFlag = 0x2 };
+  uint32_t fParserState;
+};
+
+#endif
diff --git a/mailnews/imap/src/nsIMAPHostSessionList.cpp b/mailnews/imap/src/nsIMAPHostSessionList.cpp
new file mode 100644
index 0000000000..650faf9d4f
--- /dev/null
+++ b/mailnews/imap/src/nsIMAPHostSessionList.cpp
@@ -0,0 +1,701 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"
+#include "nsIMAPHostSessionList.h"
+#include "nsIMAPBodyShell.h"
+#include "nsIMAPNamespace.h"
+#include "nsISupportsUtils.h"
+#include "nsIImapIncomingServer.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIObserverService.h"
+#include "nsServiceManagerUtils.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Services.h"
+
+nsIMAPHostInfo::nsIMAPHostInfo(const char *serverKey,
+                               nsIImapIncomingServer *server)
+{
+  fServerKey = serverKey;
+  NS_ASSERTION(server, "*** Fatal null imap incoming server...\n");
+  server->GetServerDirectory(fOnlineDir);
+  fNextHost = NULL;
+  fCachedPassword = NULL;
+  fCapabilityFlags = kCapabilityUndefined;
+  fHierarchyDelimiters = NULL;
+#ifdef DEBUG_bienvenu1
+  fHaveWeEverDiscoveredFolders = true; // try this, see what bad happens - we'll need to
+  // figure out a way to make new accounts have it be false
+#else
+  fHaveWeEverDiscoveredFolders = false; // try this, see what bad happens
+#endif
+  fCanonicalOnlineSubDir = NULL;
+  fNamespaceList = nsIMAPNamespaceList::CreatensIMAPNamespaceList();
+  fUsingSubscription = true;
+  server->GetUsingSubscription(&fUsingSubscription);
+  fOnlineTrashFolderExists = false;
+  fShouldAlwaysListInbox = true;
+  fShellCache = nsIMAPBodyShellCache::Create();
+  fPasswordVerifiedOnline = false;
+  fDeleteIsMoveToTrash = true;
+  fShowDeletedMessages = false;
+  fGotNamespaces = false;
+  fHaveAdminURL = false;
+  fNamespacesOverridable = true;
+  server->GetOverrideNamespaces(&fNamespacesOverridable);
+  fTempNamespaceList = nsIMAPNamespaceList::CreatensIMAPNamespaceList();
+}
+
+nsIMAPHostInfo::~nsIMAPHostInfo()
+{
+  PR_Free(fCachedPassword);
+  PR_Free(fHierarchyDelimiters);
+  delete fNamespaceList;
+  delete fTempNamespaceList;
+  delete fShellCache;
+}
+
+NS_IMPL_ISUPPORTS(nsIMAPHostSessionList,
+                              nsIImapHostSessionList,
+                              nsIObserver,
+                              nsISupportsWeakReference)
+
+
+nsIMAPHostSessionList::nsIMAPHostSessionList()
+{
+  gCachedHostInfoMonitor = PR_NewMonitor(/* "accessing-hostlist-monitor"*/);
+  fHostInfoList = nullptr;
+}
+
+nsIMAPHostSessionList::~nsIMAPHostSessionList()
+{
+  ResetAll();
+  PR_DestroyMonitor(gCachedHostInfoMonitor);
+}
+
+nsresult nsIMAPHostSessionList::Init()
+{
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  NS_ENSURE_TRUE(observerService, NS_ERROR_UNEXPECTED);
+  observerService->AddObserver(this, "profile-before-change", true);
+  observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsIMAPHostSessionList::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *someData)
+{
+  if (!strcmp(aTopic, "profile-before-change"))
+    ResetAll();
+  else if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID))
+  {
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+    NS_ENSURE_TRUE(observerService, NS_ERROR_UNEXPECTED);
+    observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+    observerService->RemoveObserver(this, "profile-before-change");
+  }
+  return NS_OK;
+}
+
+nsIMAPHostInfo *nsIMAPHostSessionList::FindHost(const char *serverKey)
+{
+  nsIMAPHostInfo *host;
+
+  // ### should also check userName here, if NON NULL
+  for (host = fHostInfoList; host; host = host->fNextHost)
+  {
+    if (host->fServerKey.Equals(serverKey, nsCaseInsensitiveCStringComparator()))
+      return host;
+  }
+  return host;
+}
+
+// reset any cached connection info - delete the lot of 'em
+NS_IMETHODIMP nsIMAPHostSessionList::ResetAll()
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *nextHost = NULL;
+  for (nsIMAPHostInfo *host = fHostInfoList; host; host = nextHost)
+  {
+    nextHost = host->fNextHost;
+    delete host;
+  }
+  fHostInfoList = NULL;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsIMAPHostSessionList::AddHostToList(const char *serverKey,
+                                     nsIImapIncomingServer *server)
+{
+  nsIMAPHostInfo *newHost=NULL;
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  if (!FindHost(serverKey))
+  {
+    // stick it on the front
+    newHost = new nsIMAPHostInfo(serverKey, server);
+    if (newHost)
+    {
+      newHost->fNextHost = fHostInfoList;
+      fHostInfoList = newHost;
+    }
+  }
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (newHost == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetPasswordForHost(const char *serverKey, nsString &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    CopyASCIItoUTF16(nsDependentCString(host->fCachedPassword), result);
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetPasswordForHost(const char *serverKey, const char *password)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+  {
+    PR_FREEIF(host->fCachedPassword);
+    if (password)
+      host->fCachedPassword = NS_strdup(password);
+  }
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetPasswordVerifiedOnline(const char *serverKey)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fPasswordVerifiedOnline = true;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetPasswordVerifiedOnline(const char *serverKey, bool &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fPasswordVerifiedOnline;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetOnlineDirForHost(const char *serverKey,
+                                                         nsString &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    CopyASCIItoUTF16(host->fOnlineDir, result);
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetOnlineDirForHost(const char *serverKey,
+                                                         const char *onlineDir)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+  {
+    if (onlineDir)
+      host->fOnlineDir = onlineDir;
+  }
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetDeleteIsMoveToTrashForHost(const char *serverKey, bool &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fDeleteIsMoveToTrash;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetShowDeletedMessagesForHost(const char *serverKey, bool &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fShowDeletedMessages;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetDeleteIsMoveToTrashForHost(const char *serverKey, bool isMoveToTrash)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fDeleteIsMoveToTrash = isMoveToTrash;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetShowDeletedMessagesForHost(const char *serverKey, bool showDeletedMessages)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fShowDeletedMessages = showDeletedMessages;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetGotNamespacesForHost(const char *serverKey, bool &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fGotNamespaces;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetGotNamespacesForHost(const char *serverKey, bool gotNamespaces)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fGotNamespaces = gotNamespaces;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetHostIsUsingSubscription(const char *serverKey, bool &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fUsingSubscription;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetHostIsUsingSubscription(const char *serverKey, bool usingSubscription)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fUsingSubscription = usingSubscription;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetHostHasAdminURL(const char *serverKey, bool &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fHaveAdminURL;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetHostHasAdminURL(const char *serverKey, bool haveAdminURL)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fHaveAdminURL = haveAdminURL;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fHaveWeEverDiscoveredFolders;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool discovered)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fHaveWeEverDiscoveredFolders = discovered;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetOnlineTrashFolderExistsForHost(const char *serverKey, bool exists)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fOnlineTrashFolderExists = exists;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetOnlineTrashFolderExistsForHost(const char *serverKey, bool &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fOnlineTrashFolderExists;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::AddNewNamespaceForHost(const char *serverKey, nsIMAPNamespace *ns)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fNamespaceList->AddNewNamespace(ns);
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetNamespaceFromPrefForHost(const char *serverKey,
+                                                                 const char *namespacePref, EIMAPNamespaceType nstype)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+  {
+    if (namespacePref)
+    {
+      int numNamespaces = host->fNamespaceList->UnserializeNamespaces(namespacePref, nullptr, 0);
+      char **prefixes = (char**) PR_CALLOC(numNamespaces * sizeof(char*));
+      if (prefixes)
+      {
+        int len = host->fNamespaceList->UnserializeNamespaces(namespacePref, prefixes, numNamespaces);
+        for (int i = 0; i < len; i++)
+        {
+          char *thisns = prefixes[i];
+          char delimiter = '/';	// a guess
+          if (PL_strlen(thisns) >= 1)
+            delimiter = thisns[PL_strlen(thisns)-1];
+          nsIMAPNamespace *ns = new nsIMAPNamespace(nstype, thisns, delimiter, true);
+          if (ns)
+            host->fNamespaceList->AddNewNamespace(ns);
+          PR_FREEIF(thisns);
+        }
+        PR_Free(prefixes);
+      }
+    }
+  }
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetNamespaceForMailboxForHost(const char *serverKey, const char *mailbox_name, nsIMAPNamespace * &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fNamespaceList->GetNamespaceForMailbox(mailbox_name);
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+
+NS_IMETHODIMP nsIMAPHostSessionList::ClearPrefsNamespacesForHost(const char *serverKey)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fNamespaceList->ClearNamespaces(true, false, true);
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+
+NS_IMETHODIMP nsIMAPHostSessionList::ClearServerAdvertisedNamespacesForHost(const char *serverKey)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fNamespaceList->ClearNamespaces(false, true, true);
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetDefaultNamespaceOfTypeForHost(const char *serverKey, EIMAPNamespaceType type, nsIMAPNamespace * &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fNamespaceList->GetDefaultNamespaceOfType(type);
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetNamespacesOverridableForHost(const char *serverKey, bool &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fNamespacesOverridable;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetNamespacesOverridableForHost(const char *serverKey, bool overridable)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    host->fNamespacesOverridable = overridable;
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetNumberOfNamespacesForHost(const char *serverKey, uint32_t &result)
+{
+  int32_t intResult = 0;
+
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    intResult = host->fNamespaceList->GetNumberOfNamespaces();
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  NS_ASSERTION(intResult >= 0, "negative number of namespaces");
+  result = (uint32_t) intResult;
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP	nsIMAPHostSessionList::GetNamespaceNumberForHost(const char *serverKey, int32_t n, nsIMAPNamespace * &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+    result = host->fNamespaceList->GetNamespaceNumber(n);
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+nsresult nsIMAPHostSessionList::SetNamespacesPrefForHost(nsIImapIncomingServer *aHost,
+                                                         EIMAPNamespaceType type,
+                                                         const char *pref)
+{
+  if (type == kPersonalNamespace)
+    aHost->SetPersonalNamespace(nsDependentCString(pref));
+  else if (type == kPublicNamespace)
+    aHost->SetPublicNamespace(nsDependentCString(pref));
+  else if (type == kOtherUsersNamespace)
+    aHost->SetOtherUsersNamespace(nsDependentCString(pref));
+  else
+    NS_ASSERTION(false, "bogus namespace type");
+  return NS_OK;
+
+}
+// do we need this? What should we do about the master thing?
+// Make sure this is running in the Mozilla thread when called
+NS_IMETHODIMP nsIMAPHostSessionList::CommitNamespacesForHost(nsIImapIncomingServer *aHost)
+{
+  NS_ENSURE_ARG_POINTER(aHost);
+  nsCString serverKey;
+  nsCOMPtr <nsIMsgIncomingServer> incomingServer = do_QueryInterface(aHost);
+  if (!incomingServer)
+    return NS_ERROR_NULL_POINTER;
+
+  nsresult rv = incomingServer->GetKey(serverKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey.get());
+  if (host)
+  {
+    host->fGotNamespaces = true;	// so we only issue NAMESPACE once per host per session.
+    EIMAPNamespaceType type = kPersonalNamespace;
+    for (int i = 1; i <= 3; i++)
+    {
+      switch(i)
+      {
+      case 1:
+        type = kPersonalNamespace;
+        break;
+      case 2:
+        type = kPublicNamespace;
+        break;
+      case 3:
+        type = kOtherUsersNamespace;
+        break;
+      default:
+        type = kPersonalNamespace;
+        break;
+      }
+
+      int32_t numInNS = host->fNamespaceList->GetNumberOfNamespaces(type);
+      if (numInNS == 0)
+        SetNamespacesPrefForHost(aHost, type, "");
+      else if (numInNS >= 1)
+      {
+        char *pref = PR_smprintf("");
+        for (int count = 1; count <= numInNS; count++)
+        {
+          nsIMAPNamespace *ns = host->fNamespaceList->GetNamespaceNumber(count, type);
+          if (ns)
+          {
+            if (count > 1)
+            {
+              // append the comma
+              char *tempPref = PR_smprintf("%s,",pref);
+              PR_FREEIF(pref);
+              pref = tempPref;
+            }
+            char *tempPref = PR_smprintf("%s\"%s\"",pref,ns->GetPrefix());
+            PR_FREEIF(pref);
+            pref = tempPref;
+          }
+        }
+        if (pref)
+        {
+          SetNamespacesPrefForHost(aHost, type, pref);
+          PR_Free(pref);
+        }
+      }
+    }
+    // clear, but don't delete the entries in, the temp namespace list
+    host->fTempNamespaceList->ClearNamespaces(true, true, false);
+
+    // Now reset all of libmsg's namespace references.
+    // Did I mention this needs to be running in the mozilla thread?
+    aHost->ResetNamespaceReferences();
+  }
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::FlushUncommittedNamespacesForHost(const char *serverKey, bool &result)
+{
+	PR_EnterMonitor(gCachedHostInfoMonitor);
+	nsIMAPHostInfo *host = FindHost(serverKey);
+	if (host)
+		host->fTempNamespaceList->ClearNamespaces(true, true, true);
+	PR_ExitMonitor(gCachedHostInfoMonitor);
+	return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+
+// Returns NULL if there is no personal namespace on the given host
+NS_IMETHODIMP nsIMAPHostSessionList::GetOnlineInboxPathForHost(const char *serverKey, nsString &result)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+  {
+    nsIMAPNamespace *ns = NULL;
+    ns = host->fNamespaceList->GetDefaultNamespaceOfType(kPersonalNamespace);
+    if (ns)
+    {
+      CopyASCIItoUTF16(nsDependentCString(ns->GetPrefix()), result);
+      result.AppendLiteral("INBOX");
+    }
+  }
+  else
+    result.Truncate();
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::GetShouldAlwaysListInboxForHost(const char* /*serverKey*/, bool &result)
+{
+	result = true;
+
+	/*
+	PR_EnterMonitor(gCachedHostInfoMonitor);
+	nsIMAPHostInfo *host = FindHost(serverKey);
+	if (host)
+		ret = host->fShouldAlwaysListInbox;
+	PR_ExitMonitor(gCachedHostInfoMonitor);
+	*/
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetShouldAlwaysListInboxForHost(const char *serverKey, bool shouldList)
+{
+	PR_EnterMonitor(gCachedHostInfoMonitor);
+	nsIMAPHostInfo *host = FindHost(serverKey);
+	if (host)
+		host->fShouldAlwaysListInbox = shouldList;
+	PR_ExitMonitor(gCachedHostInfoMonitor);
+	return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::SetNamespaceHierarchyDelimiterFromMailboxForHost(const char *serverKey, const char *boxName, char delimiter)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host)
+  {
+    nsIMAPNamespace *ns = host->fNamespaceList->GetNamespaceForMailbox(boxName);
+    if (ns && !ns->GetIsDelimiterFilledIn())
+      ns->SetDelimiter(delimiter, true);
+  }
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host) ? NS_OK : NS_ERROR_ILLEGAL_VALUE ;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::AddShellToCacheForHost(const char *serverKey, nsIMAPBodyShell *shell)
+{
+        nsresult rv = NS_OK;
+	PR_EnterMonitor(gCachedHostInfoMonitor);
+	nsIMAPHostInfo *host = FindHost(serverKey);
+	if (host)
+	{
+		if (host->fShellCache)
+		{
+			if (!host->fShellCache->AddShellToCache(shell))
+                                rv = NS_ERROR_UNEXPECTED;
+		}
+	}
+        else
+                rv = NS_ERROR_ILLEGAL_VALUE;
+
+	PR_ExitMonitor(gCachedHostInfoMonitor);
+	return rv;
+}
+
+NS_IMETHODIMP nsIMAPHostSessionList::FindShellInCacheForHost(const char *serverKey, const char *mailboxName, const char *UID,
+                                                             IMAP_ContentModifiedType modType, nsIMAPBodyShell **shell)
+{
+  nsCString uidString(UID);
+
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host && host->fShellCache)
+    NS_IF_ADDREF(*shell = host->fShellCache->FindShellForUID(uidString,
+                                                             mailboxName,
+                                                             modType));
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
+NS_IMETHODIMP 
+nsIMAPHostSessionList::ClearShellCacheForHost(const char *serverKey)
+{
+  PR_EnterMonitor(gCachedHostInfoMonitor);
+  nsIMAPHostInfo *host = FindHost(serverKey);
+  if (host && host->fShellCache)
+    host->fShellCache->Clear();
+  PR_ExitMonitor(gCachedHostInfoMonitor);
+  return (host == NULL) ? NS_ERROR_ILLEGAL_VALUE : NS_OK;
+}
+
diff --git a/mailnews/imap/src/nsIMAPHostSessionList.h b/mailnews/imap/src/nsIMAPHostSessionList.h
new file mode 100644
index 0000000000..5f601fe435
--- /dev/null
+++ b/mailnews/imap/src/nsIMAPHostSessionList.h
@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsIMAPHostSessionList_H_
+#define _nsIMAPHostSessionList_H_
+
+#include "mozilla/Attributes.h"
+#include "nsImapCore.h"
+#include "nsIIMAPHostSessionList.h"
+#include "nsIObserver.h"
+#include "nsWeakReference.h"
+#include "nspr.h"
+
+class nsIMAPNamespaceList;
+class nsIImapIncomingServer;
+
+class nsIMAPHostInfo
+{
+public:
+  friend class nsIMAPHostSessionList;
+
+  nsIMAPHostInfo(const char *serverKey, nsIImapIncomingServer *server);
+  ~nsIMAPHostInfo();
+protected:
+  nsCString fServerKey;
+  char *fCachedPassword;
+  nsCString fOnlineDir;
+  nsIMAPHostInfo *fNextHost;
+  eIMAPCapabilityFlags fCapabilityFlags;
+  char *fHierarchyDelimiters;// string of top-level hierarchy delimiters
+  bool fHaveWeEverDiscoveredFolders;
+  char *fCanonicalOnlineSubDir;
+  nsIMAPNamespaceList *fNamespaceList, *fTempNamespaceList;
+  bool fNamespacesOverridable;
+  bool fUsingSubscription;
+  bool fOnlineTrashFolderExists;
+  bool fShouldAlwaysListInbox;
+  bool fHaveAdminURL;
+  bool fPasswordVerifiedOnline;
+  bool fDeleteIsMoveToTrash;
+  bool fShowDeletedMessages;
+  bool fGotNamespaces;
+  nsIMAPBodyShellCache *fShellCache;
+};
+
+// this is an interface to a linked list of host info's    
+class nsIMAPHostSessionList : public nsIImapHostSessionList, public nsIObserver, public nsSupportsWeakReference
+{
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIOBSERVER  
+
+  nsIMAPHostSessionList();
+  nsresult Init();
+  // Host List
+  NS_IMETHOD AddHostToList(const char *serverKey, 
+                            nsIImapIncomingServer *server) override;
+  NS_IMETHOD ResetAll() override;
+
+  // Capabilities
+  NS_IMETHOD GetHostHasAdminURL(const char *serverKey, bool &result) override;
+  NS_IMETHOD SetHostHasAdminURL(const char *serverKey, bool hasAdminUrl) override;
+  // Subscription
+  NS_IMETHOD GetHostIsUsingSubscription(const char *serverKey, bool &result) override;
+  NS_IMETHOD SetHostIsUsingSubscription(const char *serverKey, bool usingSubscription) override;
+
+  // Passwords
+  NS_IMETHOD GetPasswordForHost(const char *serverKey, nsString &result) override;
+  NS_IMETHOD SetPasswordForHost(const char *serverKey, const char *password) override;
+  NS_IMETHOD GetPasswordVerifiedOnline(const char *serverKey, bool &result) override;
+  NS_IMETHOD SetPasswordVerifiedOnline(const char *serverKey) override;
+
+  // OnlineDir
+  NS_IMETHOD GetOnlineDirForHost(const char *serverKey,
+                                 nsString &result) override;
+  NS_IMETHOD SetOnlineDirForHost(const char *serverKey,
+                                 const char *onlineDir) override;
+
+  // Delete is move to trash folder
+  NS_IMETHOD GetDeleteIsMoveToTrashForHost(const char *serverKey, bool &result) override;
+  NS_IMETHOD SetDeleteIsMoveToTrashForHost(const char *serverKey, bool isMoveToTrash) override;
+  // imap delete model (or not)
+  NS_IMETHOD GetShowDeletedMessagesForHost(const char *serverKey, bool &result) override;
+  NS_IMETHOD SetShowDeletedMessagesForHost(const char *serverKey, bool showDeletedMessages) override;
+
+  // Get namespaces
+  NS_IMETHOD GetGotNamespacesForHost(const char *serverKey, bool &result) override;
+  NS_IMETHOD SetGotNamespacesForHost(const char *serverKey, bool gotNamespaces) override;
+  // Folders
+  NS_IMETHOD SetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool discovered) override;
+  NS_IMETHOD GetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool &result) override;
+
+  // Trash Folder
+  NS_IMETHOD SetOnlineTrashFolderExistsForHost(const char *serverKey, bool exists) override;
+  NS_IMETHOD GetOnlineTrashFolderExistsForHost(const char *serverKey, bool &result) override;
+
+  // INBOX
+  NS_IMETHOD GetOnlineInboxPathForHost(const char *serverKey, nsString &result) override;
+  NS_IMETHOD GetShouldAlwaysListInboxForHost(const char *serverKey, bool &result) override;
+  NS_IMETHOD SetShouldAlwaysListInboxForHost(const char *serverKey, bool shouldList) override;
+
+  // Namespaces
+  NS_IMETHOD GetNamespaceForMailboxForHost(const char *serverKey, const char *mailbox_name, nsIMAPNamespace *&result) override;
+  NS_IMETHOD SetNamespaceFromPrefForHost(const char *serverKey, const char *namespacePref, EIMAPNamespaceType type) override;
+  NS_IMETHOD AddNewNamespaceForHost(const char *serverKey, nsIMAPNamespace *ns) override;
+  NS_IMETHOD ClearServerAdvertisedNamespacesForHost(const char *serverKey) override;
+  NS_IMETHOD ClearPrefsNamespacesForHost(const char *serverKey) override;
+  NS_IMETHOD GetDefaultNamespaceOfTypeForHost(const char *serverKey, EIMAPNamespaceType type, nsIMAPNamespace *&result) override;
+  NS_IMETHOD SetNamespacesOverridableForHost(const char *serverKey, bool overridable) override;
+  NS_IMETHOD GetNamespacesOverridableForHost(const char *serverKey,bool &result) override;
+  NS_IMETHOD GetNumberOfNamespacesForHost(const char *serverKey, uint32_t &result) override;
+  NS_IMETHOD GetNamespaceNumberForHost(const char *serverKey, int32_t n, nsIMAPNamespace * &result) override;
+  // ### dmb hoo boy, how are we going to do this?
+  NS_IMETHOD CommitNamespacesForHost(nsIImapIncomingServer *host) override;
+  NS_IMETHOD FlushUncommittedNamespacesForHost(const char *serverKey, bool &result) override;
+
+  // Hierarchy Delimiters
+  NS_IMETHOD SetNamespaceHierarchyDelimiterFromMailboxForHost(const char *serverKey, const char *boxName, char delimiter) override;
+
+  // Message Body Shells
+  NS_IMETHOD AddShellToCacheForHost(const char *serverKey, nsIMAPBodyShell *shell) override;
+  NS_IMETHOD FindShellInCacheForHost(const char *serverKey, const char *mailboxName, const char *UID, IMAP_ContentModifiedType modType, nsIMAPBodyShell	**result) override;
+  NS_IMETHOD ClearShellCacheForHost(const char *serverKey) override;
+  PRMonitor *gCachedHostInfoMonitor;
+  nsIMAPHostInfo *fHostInfoList;
+protected:
+  virtual ~nsIMAPHostSessionList();
+  nsresult SetNamespacesPrefForHost(nsIImapIncomingServer *aHost,
+                                    EIMAPNamespaceType type,
+                                    const char *pref);
+  nsIMAPHostInfo *FindHost(const char *serverKey);
+};
+#endif
diff --git a/mailnews/imap/src/nsIMAPNamespace.cpp b/mailnews/imap/src/nsIMAPNamespace.cpp
new file mode 100644
index 0000000000..d46352373b
--- /dev/null
+++ b/mailnews/imap/src/nsIMAPNamespace.cpp
@@ -0,0 +1,650 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"  // for pre-compiled headers
+
+#include "nsImapCore.h"
+#include "nsIMAPNamespace.h"
+#include "nsImapProtocol.h"
+#include "nsMsgImapCID.h"
+#include "nsImapUrl.h"
+#include "nsStringGlue.h"
+#include "nsServiceManagerUtils.h"
+
+//////////////////// nsIMAPNamespace  /////////////////////////////////////////////////////////////
+
+static NS_DEFINE_CID(kCImapHostSessionListCID, NS_IIMAPHOSTSESSIONLIST_CID);
+
+nsIMAPNamespace::nsIMAPNamespace(EIMAPNamespaceType type, const char *prefix, char delimiter, bool from_prefs)
+{
+	m_namespaceType = type;
+	m_prefix = PL_strdup(prefix);
+	m_fromPrefs = from_prefs;
+
+	m_delimiter = delimiter;
+	m_delimiterFilledIn = !m_fromPrefs;	// if it's from the prefs, we can't be sure about the delimiter until we list it.
+}
+
+nsIMAPNamespace::~nsIMAPNamespace()
+{
+	PR_FREEIF(m_prefix);
+}
+
+void nsIMAPNamespace::SetDelimiter(char delimiter, bool delimiterFilledIn)
+{
+  m_delimiter = delimiter;
+  m_delimiterFilledIn = delimiterFilledIn;
+}
+
+// returns -1 if this box is not part of this namespace,
+// or the length of the prefix if it is part of this namespace
+int nsIMAPNamespace::MailboxMatchesNamespace(const char *boxname)
+{
+	if (!boxname) return -1;
+
+	// If the namespace is part of the boxname
+    if (!m_prefix || !*m_prefix)
+        return 0;
+
+	if (PL_strstr(boxname, m_prefix) == boxname)
+		return PL_strlen(m_prefix);
+
+	// If the boxname is part of the prefix
+	// (Used for matching Personal mailbox with Personal/ namespace, etc.)
+	if (PL_strstr(m_prefix, boxname) == m_prefix)
+		return PL_strlen(boxname);
+	return -1;
+}
+
+
+nsIMAPNamespaceList *nsIMAPNamespaceList::CreatensIMAPNamespaceList()
+{
+	nsIMAPNamespaceList *rv = new nsIMAPNamespaceList();
+	return rv;
+}
+
+nsIMAPNamespaceList::nsIMAPNamespaceList()
+{
+}
+
+int nsIMAPNamespaceList::GetNumberOfNamespaces()
+{
+	return m_NamespaceList.Length();
+}
+
+
+nsresult nsIMAPNamespaceList::InitFromString(const char *nameSpaceString, EIMAPNamespaceType nstype)
+{
+	nsresult rv = NS_OK;
+	if (nameSpaceString)
+	{
+		int numNamespaces = UnserializeNamespaces(nameSpaceString, nullptr, 0);
+		char **prefixes = (char**) PR_CALLOC(numNamespaces * sizeof(char*));
+		if (prefixes)
+		{
+			int len = UnserializeNamespaces(nameSpaceString, prefixes, numNamespaces);
+			for (int i = 0; i < len; i++)
+			{
+				char *thisns = prefixes[i];
+				char delimiter = '/';	// a guess
+				if (PL_strlen(thisns) >= 1)
+					delimiter = thisns[PL_strlen(thisns)-1];
+				nsIMAPNamespace *ns = new nsIMAPNamespace(nstype, thisns, delimiter, true);
+				if (ns)
+					AddNewNamespace(ns);
+				PR_FREEIF(thisns);
+			}
+			PR_Free(prefixes);
+		}
+	}
+
+	return rv;
+}
+
+nsresult nsIMAPNamespaceList::OutputToString(nsCString &string)
+{
+	nsresult rv = NS_OK;
+
+	return rv;
+}
+
+
+int nsIMAPNamespaceList::GetNumberOfNamespaces(EIMAPNamespaceType type)
+{
+	int nodeIndex = 0, count = 0;
+	for (nodeIndex = m_NamespaceList.Length() - 1; nodeIndex >= 0; nodeIndex--)
+	{
+		nsIMAPNamespace *nspace = m_NamespaceList.ElementAt(nodeIndex);
+		if (nspace->GetType() == type)
+		{
+			count++;
+		}
+	}
+	return count;
+}
+
+int nsIMAPNamespaceList::AddNewNamespace(nsIMAPNamespace *ns)
+{
+	// If the namespace is from the NAMESPACE response, then we should see if there
+	// are any namespaces previously set by the preferences, or the default namespace.  If so, remove these.
+
+	if (!ns->GetIsNamespaceFromPrefs())
+	{
+		int nodeIndex;
+        // iterate backwards because we delete elements
+		for (nodeIndex = m_NamespaceList.Length() - 1; nodeIndex >= 0; nodeIndex--)
+		{
+			nsIMAPNamespace *nspace = m_NamespaceList.ElementAt(nodeIndex);
+			// if we find existing namespace(s) that matches the 
+			// new one, we'll just remove the old ones and let the
+			// new one get added when we've finished checking for
+			// matching namespaces or namespaces that came from prefs.
+			if (nspace &&
+                            (nspace->GetIsNamespaceFromPrefs() ||
+                            (!PL_strcmp(ns->GetPrefix(), nspace->GetPrefix()) &&
+			     ns->GetType() == nspace->GetType() &&
+			     ns->GetDelimiter() == nspace->GetDelimiter())))
+			{
+				m_NamespaceList.RemoveElementAt(nodeIndex);
+				delete nspace; 
+			}
+		}
+	}
+
+	// Add the new namespace to the list.  This must come after the removing code,
+	// or else we could never add the initial kDefaultNamespace type to the list.
+	m_NamespaceList.AppendElement(ns);
+
+	return 0;
+}
+
+
+// chrisf - later, fix this to know the real concept of "default" namespace of a given type
+nsIMAPNamespace *nsIMAPNamespaceList::GetDefaultNamespaceOfType(EIMAPNamespaceType type)
+{
+	nsIMAPNamespace *rv = 0, *firstOfType = 0;
+
+	int nodeIndex, count = m_NamespaceList.Length();
+	for (nodeIndex= 0; nodeIndex < count && !rv; nodeIndex++)
+	{
+		nsIMAPNamespace *ns = m_NamespaceList.ElementAt(nodeIndex);
+		if (ns->GetType() == type)
+		{
+			if (!firstOfType)
+				firstOfType = ns;
+			if (!(*(ns->GetPrefix())))
+			{
+				// This namespace's prefix is ""
+				// Therefore it is the default
+				rv = ns;
+			}
+		}
+	}
+	if (!rv)
+		rv = firstOfType;
+	return rv;
+}
+
+nsIMAPNamespaceList::~nsIMAPNamespaceList()
+{
+	ClearNamespaces(true, true, true);
+}
+
+// ClearNamespaces removes and deletes the namespaces specified, and if there are no namespaces left,
+void nsIMAPNamespaceList::ClearNamespaces(bool deleteFromPrefsNamespaces, bool deleteServerAdvertisedNamespaces, bool reallyDelete)
+{
+	int nodeIndex;
+	
+    // iterate backwards because we delete elements
+	for (nodeIndex = m_NamespaceList.Length() - 1; nodeIndex >= 0; nodeIndex--)
+	{
+		nsIMAPNamespace *ns = m_NamespaceList.ElementAt(nodeIndex);
+		if (ns->GetIsNamespaceFromPrefs())
+		{
+			if (deleteFromPrefsNamespaces)
+			{
+				m_NamespaceList.RemoveElementAt(nodeIndex);
+				if (reallyDelete)
+					delete ns;
+			}
+		}
+		else if (deleteServerAdvertisedNamespaces)
+		{
+			m_NamespaceList.RemoveElementAt(nodeIndex);
+			if (reallyDelete)
+				delete ns;
+		}
+	}
+}
+
+nsIMAPNamespace *nsIMAPNamespaceList::GetNamespaceNumber(int nodeIndex)
+{
+  NS_ASSERTION(nodeIndex >= 0 && nodeIndex < GetNumberOfNamespaces(), "invalid IMAP namespace node index");
+  if (nodeIndex < 0) nodeIndex = 0;
+
+  // XXX really could be just ElementAt; that's why we have the assertion
+  return m_NamespaceList.SafeElementAt(nodeIndex);
+}
+
+nsIMAPNamespace *nsIMAPNamespaceList::GetNamespaceNumber(int nodeIndex, EIMAPNamespaceType type)
+{
+  int nodeCount, count = 0;
+  for (nodeCount = m_NamespaceList.Length() - 1; nodeCount >= 0; nodeCount--)
+  {
+    nsIMAPNamespace *nspace = m_NamespaceList.ElementAt(nodeCount);
+    if (nspace->GetType() == type)
+    {
+      count++;
+      if (count == nodeIndex)
+        return nspace;
+    }
+  }
+  return nullptr;
+}
+
+nsIMAPNamespace *nsIMAPNamespaceList::GetNamespaceForMailbox(const char *boxname)
+{
+  // We want to find the LONGEST substring that matches the beginning of this mailbox's path.
+  // This accounts for nested namespaces  (i.e. "Public/" and "Public/Users/")
+  
+  // Also, we want to match the namespace's mailbox to that namespace also:
+  // The Personal box will match the Personal/ namespace, etc.
+  
+  // these lists shouldn't be too long (99% chance there won't be more than 3 or 4)
+  // so just do a linear search
+  
+  int lengthMatched = -1;
+  int currentMatchedLength = -1;
+  nsIMAPNamespace *rv = nullptr;
+  int nodeIndex = 0;
+  
+  if (!PL_strcasecmp(boxname, "INBOX"))
+    return GetDefaultNamespaceOfType(kPersonalNamespace);
+  
+  for (nodeIndex = m_NamespaceList.Length() - 1; nodeIndex >= 0; nodeIndex--)
+  {
+    nsIMAPNamespace *nspace = m_NamespaceList.ElementAt(nodeIndex);
+    currentMatchedLength = nspace->MailboxMatchesNamespace(boxname);
+    if (currentMatchedLength > lengthMatched)
+    {
+      rv = nspace;
+      lengthMatched = currentMatchedLength;
+    }
+  }
+  
+  return rv;
+}
+
+#define SERIALIZER_SEPARATORS ","
+
+/**
+ * If len is one, copies the first element of prefixes into serializedNamespaces.
+ * If len > 1, copies len strings from prefixes into serializedNamespaces
+ * as a comma-separated list of quoted strings.
+ */
+nsresult nsIMAPNamespaceList::SerializeNamespaces(char **prefixes, int len,
+                                                  nsCString &serializedNamespaces)
+{
+  if (len <= 0)
+    return NS_OK;
+
+  if (len == 1)
+  {
+    serializedNamespaces.Assign(prefixes[0]);
+    return NS_OK;
+  }
+
+  for (int i = 0; i < len; i++)
+  {
+    if (i > 0)
+      serializedNamespaces.AppendLiteral(",");
+
+    serializedNamespaces.AppendLiteral("\"");
+    serializedNamespaces.Append(prefixes[i]);
+    serializedNamespaces.AppendLiteral("\"");
+  }
+  return NS_OK;
+}
+
+/* str is the string which needs to be unserialized.
+   If prefixes is NULL, simply returns the number of namespaces in str.  (len is ignored)
+   If prefixes is not NULL, it should be an array of length len which is to be filled in
+   with newly-allocated string.  Returns the number of strings filled in.
+*/
+int nsIMAPNamespaceList::UnserializeNamespaces(const char *str, char **prefixes, int len)
+{
+  if (!str)
+    return 0;
+  if (!prefixes)
+  {
+    if (str[0] != '"')
+      return 1;
+    else
+    {
+      int count = 0;
+      char *ourstr = PL_strdup(str);
+      char *origOurStr = ourstr;
+      if (ourstr)
+      {
+        char *token = NS_strtok(SERIALIZER_SEPARATORS, &ourstr );
+        while (token != nullptr)
+        {
+          token = NS_strtok(SERIALIZER_SEPARATORS, &ourstr );
+          count++;
+        }
+        PR_Free(origOurStr);
+      }
+      return count;
+    }
+  }
+  else
+  {
+    if ((str[0] != '"') && (len >= 1))
+    {
+      prefixes[0] = PL_strdup(str);
+      return 1;
+    }
+    else
+    {
+      int count = 0;
+      char *ourstr = PL_strdup(str);
+      char *origOurStr = ourstr;
+      if (ourstr)
+      {
+        char *token = NS_strtok(SERIALIZER_SEPARATORS, &ourstr );
+        while ((count < len) && (token != nullptr))
+        {
+          
+          char *current = PL_strdup(token), *where = current;
+          if (where[0] == '"')
+            where++;
+          if (where[PL_strlen(where)-1] == '"')
+            where[PL_strlen(where)-1] = 0;
+          prefixes[count] = PL_strdup(where);
+          PR_FREEIF(current);
+          token = NS_strtok(SERIALIZER_SEPARATORS, &ourstr );
+          count++;
+        }
+        PR_Free(origOurStr);
+      }
+      return count;
+    }
+  }
+}
+
+
+
+
+char *nsIMAPNamespaceList::AllocateCanonicalFolderName(const char *onlineFolderName, char delimiter)
+{
+  char *canonicalPath = nullptr;
+  if (delimiter)
+    canonicalPath = nsImapUrl::ReplaceCharsInCopiedString(onlineFolderName, delimiter , '/');
+  else
+    canonicalPath = PL_strdup(onlineFolderName);
+  
+  // eat any escape characters for escaped dir separators
+  if (canonicalPath)
+  {
+    char *currentEscapeSequence = strstr(canonicalPath, "\\/");
+    while (currentEscapeSequence)
+    {
+      strcpy(currentEscapeSequence, currentEscapeSequence+1);
+      currentEscapeSequence = strstr(currentEscapeSequence+1, "\\/");
+    }
+  }
+  
+  return canonicalPath;
+}
+
+
+
+/*
+  GetFolderNameWithoutNamespace takes as input a folder name
+  in canonical form, and the namespace for the given folder.  It returns an allocated
+  string of the folder's path with the namespace string stripped out.  For instance,
+  when passed the folder Folders/a/b where the namespace is "Folders/", it will return
+  "a/b".  Similarly, if the folder name is "#news/comp/mail/imap" in canonical form,
+  with a real delimiter of "." and a namespace of "#news.", it will return "comp/mail/imap".
+  The return value is always in canonical form.
+*/
+char* nsIMAPNamespaceList::GetFolderNameWithoutNamespace(nsIMAPNamespace *namespaceForFolder, const char *canonicalFolderName)
+{
+  NS_ASSERTION(canonicalFolderName, "null folder name");
+#ifdef DEBUG
+  NS_ASSERTION(namespaceForFolder || !PL_strcasecmp(canonicalFolderName, "INBOX"), "need namespace or INBOX");
+#endif
+  
+  char *retFolderName = nullptr;
+  
+  if (!PL_strcasecmp(canonicalFolderName, "INBOX"))
+    return PL_strdup(canonicalFolderName);
+  
+  // convert the canonical path to the online path
+  char *convertedFolderName = nsIMAPNamespaceList::AllocateServerFolderName(canonicalFolderName, namespaceForFolder->GetDelimiter());
+  if (convertedFolderName)
+  {
+    char *beginFolderPath = nullptr;
+    if (strlen(convertedFolderName) <= strlen(namespaceForFolder->GetPrefix()))
+      beginFolderPath = convertedFolderName;
+    else
+      beginFolderPath = convertedFolderName + strlen(namespaceForFolder->GetPrefix());
+    NS_ASSERTION(beginFolderPath, "empty folder path");
+    retFolderName = nsIMAPNamespaceList::AllocateCanonicalFolderName(beginFolderPath, namespaceForFolder->GetDelimiter());
+    PR_Free(convertedFolderName);
+  }
+  
+  NS_ASSERTION(retFolderName, "returning null folder name");
+  return retFolderName;
+}
+
+
+nsIMAPNamespace* nsIMAPNamespaceList::GetNamespaceForFolder(const char *hostName,
+                                                    const char *canonicalFolderName,
+                                                    char delimiter)
+{
+  if (!hostName || !canonicalFolderName)
+    return nullptr;
+  
+  nsIMAPNamespace *resultNamespace = nullptr;
+  nsresult rv;
+  char *convertedFolderName = nsIMAPNamespaceList::AllocateServerFolderName(canonicalFolderName, delimiter);
+
+  if (convertedFolderName)
+  {
+
+    nsCOMPtr<nsIImapHostSessionList> hostSessionList = 
+             do_GetService(kCImapHostSessionListCID, &rv);
+    if (NS_FAILED(rv)) 
+      return nullptr;
+    hostSessionList->GetNamespaceForMailboxForHost(hostName, convertedFolderName, resultNamespace);
+    PR_Free(convertedFolderName);
+  }
+  else
+  {
+    NS_ASSERTION(false, "couldn't get converted folder name");
+  }
+  
+  return resultNamespace;
+}
+
+/* static */
+char *nsIMAPNamespaceList::AllocateServerFolderName(const char *canonicalFolderName, char delimiter)
+{
+  if (delimiter)
+    return nsImapUrl::ReplaceCharsInCopiedString(canonicalFolderName, '/', delimiter);
+  else
+    return NS_strdup(canonicalFolderName);
+}
+
+/*
+	GetFolderOwnerNameFromPath takes as inputs a folder name
+	in canonical form, and a namespace for that folder.
+	The namespace MUST be of type kOtherUsersNamespace, hence the folder MUST be
+	owned by another user.  This function extracts the folder owner's name from the
+	canonical name of the folder, and returns an allocated copy of that owner's name
+*/
+/* static */
+char *nsIMAPNamespaceList::GetFolderOwnerNameFromPath(nsIMAPNamespace *namespaceForFolder, const char *canonicalFolderName)
+{
+  if (!namespaceForFolder || !canonicalFolderName)
+  {
+    NS_ASSERTION(false,"null namespace or canonical folder name");
+    return nullptr;
+  }
+  
+  char *rv = nullptr;
+  
+  // convert the canonical path to the online path
+  char *convertedFolderName = AllocateServerFolderName(canonicalFolderName, namespaceForFolder->GetDelimiter());
+  if (convertedFolderName)
+  {
+#ifdef DEBUG
+    NS_ASSERTION(strlen(convertedFolderName) > strlen(namespaceForFolder->GetPrefix()), "server folder name invalid");
+#endif
+    if (strlen(convertedFolderName) > strlen(namespaceForFolder->GetPrefix()))
+    {
+      char *owner = convertedFolderName + strlen(namespaceForFolder->GetPrefix());
+      NS_ASSERTION(owner, "couldn't find folder owner");
+      char *nextDelimiter = strchr(owner, namespaceForFolder->GetDelimiter());
+      // if !nextDelimiter, then the path is of the form Shared/Users/chrisf   (no subfolder)
+      if (nextDelimiter)
+      {
+        *nextDelimiter = 0;
+      }
+      rv = PL_strdup(owner);
+    }
+    PR_Free(convertedFolderName);
+  }
+  else
+  {
+    NS_ASSERTION(false, "couldn't allocate server folder name");
+  }
+  
+  return rv;
+}
+
+/*
+GetFolderIsNamespace returns TRUE if the given folder is the folder representing
+a namespace.
+*/
+
+bool nsIMAPNamespaceList::GetFolderIsNamespace(const char *hostName,
+                                                 const char *canonicalFolderName,
+                                                 char delimiter,nsIMAPNamespace *namespaceForFolder)
+{
+  NS_ASSERTION(namespaceForFolder, "null namespace");
+  
+  bool rv = false;
+  
+  const char *prefix = namespaceForFolder->GetPrefix();
+  NS_ASSERTION(prefix, "namespace has no prefix");
+  if (!prefix || !*prefix)	// empty namespace prefix
+    return false;
+  
+  char *convertedFolderName = AllocateServerFolderName(canonicalFolderName, delimiter);
+  if (convertedFolderName)
+  {
+    bool lastCharIsDelimiter = (prefix[strlen(prefix) - 1] == delimiter);
+    
+    if (lastCharIsDelimiter)
+    {
+      rv = ((strncmp(convertedFolderName, prefix, strlen(convertedFolderName)) == 0) &&
+        (strlen(convertedFolderName) == strlen(prefix) - 1));
+    }
+    else
+    {
+      rv = (strcmp(convertedFolderName, prefix) == 0);
+    }
+    
+    PR_Free(convertedFolderName);
+  }
+  else
+  {
+    NS_ASSERTION(false, "couldn't allocate server folder name");
+  }
+  
+  return rv;
+}
+
+/*
+  SuggestHierarchySeparatorForNamespace takes a namespace from libmsg
+  and a hierarchy delimiter.  If the namespace has not been filled in from
+  online NAMESPACE command yet, it fills in the suggested delimiter to be
+  used from then on (until it is overridden by an online response).
+*/
+
+void nsIMAPNamespaceList::SuggestHierarchySeparatorForNamespace(nsIMAPNamespace *namespaceForFolder, char delimiterFromFolder)
+{
+  NS_ASSERTION(namespaceForFolder, "need namespace");
+  if (namespaceForFolder && !namespaceForFolder->GetIsDelimiterFilledIn())
+    namespaceForFolder->SetDelimiter(delimiterFromFolder, false);
+}
+
+
+/*
+ GenerateFullFolderNameWithDefaultNamespace takes a folder name in canonical form,
+  converts it to online form, allocates a string to contain the full online server name
+  including the namespace prefix of the default namespace of the given type, in the form:
+  PR_smprintf("%s%s", prefix, onlineServerName) if there is a NULL owner
+  PR_smprintf("%s%s%c%s", prefix, owner, delimiter, onlineServerName) if there is an owner
+  It then converts this back to canonical form and returns it (allocated) to libmsg.
+  It returns NULL if there is no namespace of the given type.
+  If nsUsed is not passed in as NULL, then *nsUsed is filled in and returned;  it is the
+  namespace used for generating the folder name.
+*/
+char *nsIMAPNamespaceList::GenerateFullFolderNameWithDefaultNamespace(const char *hostName,
+                                                                                const char *canonicalFolderName,
+                                                                                const char *owner,
+                                                                                EIMAPNamespaceType nsType,
+                                                                                nsIMAPNamespace **nsUsed)
+{
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIImapHostSessionList> hostSession = 
+           do_GetService(kCImapHostSessionListCID, &rv);
+  NS_ENSURE_SUCCESS(rv, nullptr);
+  nsIMAPNamespace *ns;
+  char *fullFolderName = nullptr;
+  rv = hostSession->GetDefaultNamespaceOfTypeForHost(hostName, nsType, ns);
+  NS_ENSURE_SUCCESS(rv, nullptr);
+  if (ns)
+  {
+    if (nsUsed)
+      *nsUsed = ns;
+    const char *prefix = ns->GetPrefix();
+    char *convertedFolderName = AllocateServerFolderName(canonicalFolderName, ns->GetDelimiter());
+    if (convertedFolderName)
+    {
+      char *convertedReturnName = nullptr;
+      if (owner)
+      {
+        convertedReturnName = PR_smprintf("%s%s%c%s", prefix, owner, ns->GetDelimiter(), convertedFolderName);
+      }
+      else
+      {
+        convertedReturnName = PR_smprintf("%s%s", prefix, convertedFolderName);
+      }
+      
+      if (convertedReturnName)
+      {
+        fullFolderName = AllocateCanonicalFolderName(convertedReturnName, ns->GetDelimiter());
+        PR_Free(convertedReturnName);
+      }
+      PR_Free(convertedFolderName);
+    }
+    else
+    {
+      NS_ASSERTION(false, "couldn't allocate server folder name");
+    }
+  }
+  else
+  {
+    // Could not find other users namespace on the given host
+    NS_WARNING("couldn't find namespace for given host");
+  }
+  return (fullFolderName);
+}
+
diff --git a/mailnews/imap/src/nsIMAPNamespace.h b/mailnews/imap/src/nsIMAPNamespace.h
new file mode 100644
index 0000000000..327f78416a
--- /dev/null
+++ b/mailnews/imap/src/nsIMAPNamespace.h
@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsIMAPNamespace_H_
+#define _nsIMAPNamespace_H_
+
+#include "nsTArray.h"
+
+class nsIMAPNamespace
+{
+  
+public:
+  nsIMAPNamespace(EIMAPNamespaceType type, const char *prefix, char delimiter, bool from_prefs);
+  
+  ~nsIMAPNamespace();
+  
+  EIMAPNamespaceType    GetType() { return m_namespaceType; }
+  const char *          GetPrefix() { return m_prefix; }
+  char                  GetDelimiter() { return m_delimiter; }
+  void                  SetDelimiter(char delimiter, bool delimiterFilledIn);
+  bool                  GetIsDelimiterFilledIn() { return m_delimiterFilledIn; }
+  bool                  GetIsNamespaceFromPrefs() { return m_fromPrefs; }
+  
+  // returns -1 if this box is not part of this namespace,
+  // or the length of the prefix if it is part of this namespace
+  int                   MailboxMatchesNamespace(const char *boxname);
+  
+protected:
+  EIMAPNamespaceType m_namespaceType;
+  char    *m_prefix;
+  char    m_delimiter;
+  bool    m_fromPrefs;
+  bool    m_delimiterFilledIn;
+  
+};
+
+
+// represents an array of namespaces for a given host
+class nsIMAPNamespaceList
+{
+public:
+  ~nsIMAPNamespaceList();
+  
+  static nsIMAPNamespaceList *CreatensIMAPNamespaceList();
+  
+  nsresult InitFromString(const char *nameSpaceString, EIMAPNamespaceType nstype);
+  nsresult OutputToString(nsCString &OutputString);
+  int UnserializeNamespaces(const char *str, char **prefixes, int len);
+  nsresult SerializeNamespaces(char **prefixes, int len, nsCString &serializedNamespace);
+  
+  void ClearNamespaces(bool deleteFromPrefsNamespaces, bool deleteServerAdvertisedNamespaces, bool reallyDelete);
+  int	GetNumberOfNamespaces();
+  int	GetNumberOfNamespaces(EIMAPNamespaceType);
+  nsIMAPNamespace *GetNamespaceNumber(int nodeIndex);
+  nsIMAPNamespace *GetNamespaceNumber(int nodeIndex, EIMAPNamespaceType);
+  
+  nsIMAPNamespace *GetDefaultNamespaceOfType(EIMAPNamespaceType type);
+  int AddNewNamespace(nsIMAPNamespace *ns);
+  nsIMAPNamespace *GetNamespaceForMailbox(const char *boxname);
+  static nsIMAPNamespace* GetNamespaceForFolder(const char *hostName,
+                                           const char *canonicalFolderName,
+                                           char delimiter);
+  static bool GetFolderIsNamespace(const char *hostName,
+                              const char *canonicalFolderName,
+                              char delimiter,nsIMAPNamespace *namespaceForFolder);
+  static char* GetFolderNameWithoutNamespace(nsIMAPNamespace *namespaceForFolder, const char *canonicalFolderName);
+  static char *AllocateServerFolderName(const char *canonicalFolderName, char delimiter);
+  static char *GetFolderOwnerNameFromPath(nsIMAPNamespace *namespaceForFolder, const char *canonicalFolderName);
+  static char *AllocateCanonicalFolderName(const char *onlineFolderName, char delimiter);
+  static void  SuggestHierarchySeparatorForNamespace(nsIMAPNamespace *namespaceForFolder, char delimiterFromFolder);
+  static char *GenerateFullFolderNameWithDefaultNamespace(const char *hostName,
+                                                                                const char *canonicalFolderName,
+                                                                                const char *owner,
+                                                                                EIMAPNamespaceType nsType,
+                                                                                nsIMAPNamespace **nsUsed);
+
+protected:
+  nsIMAPNamespaceList();	// use CreatensIMAPNamespaceList to create one
+  
+  nsTArray<nsIMAPNamespace*> m_NamespaceList;
+  
+};
+
+
+#endif
diff --git a/mailnews/imap/src/nsImapCore.h b/mailnews/imap/src/nsImapCore.h
new file mode 100644
index 0000000000..5fd0e1c1f4
--- /dev/null
+++ b/mailnews/imap/src/nsImapCore.h
@@ -0,0 +1,188 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsImapCore_H_
+#define _nsImapCore_H_
+
+#include "MailNewsTypes.h"
+#include "nsStringGlue.h"
+#include "nsIMailboxSpec.h"
+#include "nsIImapFlagAndUidState.h"
+
+class nsIMAPNamespace;
+class nsImapProtocol;
+class nsImapFlagAndUidState;
+
+/* imap message flags */
+typedef uint16_t imapMessageFlagsType;
+
+/* used for communication between imap thread and event sinks */
+#define kNoFlags     0x00 /* RFC flags */
+#define kMarked      0x01
+#define kUnmarked    0x02
+#define kNoinferiors 0x04
+#define kNoselect    0x08
+#define kImapTrash   0x10 /* Navigator flag */
+#define kJustExpunged 0x20 /* This update is a post expunge url update. */
+#define kPersonalMailbox 0x40 /* this mailbox is in the personal namespace */
+#define kPublicMailbox 0x80 /* this mailbox is in the public namespace */
+#define kOtherUsersMailbox 0x100 /* this mailbox is in the other users' namespace */
+#define kNameSpace 0x200 /* this mailbox IS a namespace */
+#define kNewlyCreatedFolder 0x400 /* this folder was just created */
+#define kImapDrafts 0x800 /* XLIST says this is the drafts folder */
+#define kImapSpam 0x1000 /* XLIST says this is the spam folder */
+#define kImapSent 0x2000 /* XLIST says this is the sent folder */
+#define kImapInbox 0x4000 /* XLIST says this is the INBOX folder */
+#define kImapAllMail 0x8000 /* XLIST says this is AllMail (GMail) */
+#define kImapXListTrash 0x10000 /* XLIST says this is the trash */
+#define kNonExistent 0x20000 /* RFC 5258, LIST-EXTENDED */
+#define kSubscribed 0x40000 /* RFC 5258, LIST-EXTENDED */
+#define kRemote 0x80000 /* RFC 5258, LIST-EXTENDED */
+#define kHasChildren 0x100000 /* RFC 5258, LIST-EXTENDED */
+#define kHasNoChildren 0x200000 /* RFC 5258, LIST-EXTENDED */
+#define kImapArchive 0x400000 /* RFC 5258, LIST-EXTENDED */
+
+/* flags for individual messages */
+/* currently the ui only offers \Seen and \Flagged */
+#define kNoImapMsgFlag                0x0000
+#define kImapMsgSeenFlag              0x0001
+#define kImapMsgAnsweredFlag          0x0002
+#define kImapMsgFlaggedFlag           0x0004
+#define kImapMsgDeletedFlag           0x0008
+#define kImapMsgDraftFlag             0x0010
+#define kImapMsgRecentFlag            0x0020
+#define	kImapMsgForwardedFlag         0x0040		/* Not always supported, check mailbox folder */
+#define kImapMsgMDNSentFlag           0x0080		/* Not always supported. check mailbox folder */
+#define kImapMsgCustomKeywordFlag     0x0100            /* this msg has a custom keyword */
+#define kImapMsgLabelFlags            0x0E00            /* supports 5 labels only supported if the folder supports keywords */
+#define kImapMsgSupportMDNSentFlag    0x2000
+#define kImapMsgSupportForwardedFlag  0x4000
+/**
+ * We use a separate xlist trash flag so we can prefer the GMail trash
+ * over an existing Trash folder we may have created.
+ */
+#define kImapMsgSupportUserFlag       0x8000		
+/* This seems to be the most cost effective way of
+* piggying back the server support user flag info.
+*/
+
+/* if a url creator does not know the hierarchyDelimiter, use this */
+#define kOnlineHierarchySeparatorUnknown '^'
+#define kOnlineHierarchySeparatorNil '|'
+
+#define IMAP_URL_TOKEN_SEPARATOR ">"
+#define kUidUnknown -1
+// Special initial value meaning ACLs need to be loaded from DB.
+#define kAclInvalid ((uint32_t) -1)
+
+// this has to do with Mime Parts on Demand. It used to live in net.h
+// I'm not sure where this will live, but here is OK temporarily
+typedef enum {
+	IMAP_CONTENT_NOT_MODIFIED = 0,
+	IMAP_CONTENT_MODIFIED_VIEW_INLINE,
+	IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS,
+	IMAP_CONTENT_FORCE_CONTENT_NOT_MODIFIED
+} IMAP_ContentModifiedType;
+
+// I think this should really go in an imap.h equivalent file
+typedef enum {
+    kPersonalNamespace = 0,
+    kOtherUsersNamespace,
+    kPublicNamespace,
+    kDefaultNamespace,
+    kUnknownNamespace
+} EIMAPNamespaceType;
+
+
+/**
+ * IMAP server feature, mostly CAPABILITY responses
+ *
+ * one of the cap flags below
+ */
+typedef uint64_t eIMAPCapabilityFlag;
+/**
+ * IMAP server features, mostly CAPABILITY responses
+ *
+ * any set of the cap flags below, i.e.
+ * i.e. 0, 1 or more |eIMAPCapabilityFlag|.
+ */
+typedef uint64_t eIMAPCapabilityFlags;
+
+const eIMAPCapabilityFlag kCapabilityUndefined = 0x00000000;
+const eIMAPCapabilityFlag kCapabilityDefined = 0x00000001;
+const eIMAPCapabilityFlag kHasAuthLoginCapability = 0x00000002;  /* AUTH LOGIN (not the same as kHasAuthOldLoginCapability) */
+const eIMAPCapabilityFlag kHasAuthOldLoginCapability = 0x00000004;  /* original IMAP login method */
+const eIMAPCapabilityFlag kHasXSenderCapability = 0x00000008;
+const eIMAPCapabilityFlag kIMAP4Capability = 0x00000010;           /* RFC1734 */
+const eIMAPCapabilityFlag kIMAP4rev1Capability = 0x00000020;       /* RFC2060 */
+const eIMAPCapabilityFlag kIMAP4other = 0x00000040;                        /* future rev?? */
+const eIMAPCapabilityFlag kNoHierarchyRename = 0x00000080;                         /* no hierarchy rename */
+const eIMAPCapabilityFlag kACLCapability = 0x00000100;           /* ACL extension */
+const eIMAPCapabilityFlag kNamespaceCapability = 0x00000200;     /* IMAP4 Namespace Extension */
+const eIMAPCapabilityFlag kHasIDCapability = 0x00000400;  /* client user agent id extension */
+const eIMAPCapabilityFlag kXServerInfoCapability = 0x00000800;  /* XSERVERINFO extension for admin urls */
+const eIMAPCapabilityFlag kHasAuthPlainCapability = 0x00001000; /* new form of auth plain base64 login */
+const eIMAPCapabilityFlag kUidplusCapability = 0x00002000;   /* RFC 2359 UIDPLUS extension */
+const eIMAPCapabilityFlag kLiteralPlusCapability = 0x00004000; /* RFC 2088 LITERAL+ extension */
+const eIMAPCapabilityFlag kAOLImapCapability = 0x00008000;     /* aol imap extensions */
+const eIMAPCapabilityFlag kHasLanguageCapability = 0x00010000; /* language extensions */
+const eIMAPCapabilityFlag kHasCRAMCapability = 0x00020000; /* CRAM auth extension */
+const eIMAPCapabilityFlag kQuotaCapability = 0x00040000; /* RFC 2087 quota extension */
+const eIMAPCapabilityFlag kHasIdleCapability = 0x00080000;  /* RFC 2177 idle extension */
+const eIMAPCapabilityFlag kHasAuthNTLMCapability = 0x00100000;  /* AUTH NTLM extension */
+const eIMAPCapabilityFlag kHasAuthMSNCapability = 0x00200000;   /* AUTH MSN extension */
+const eIMAPCapabilityFlag kHasStartTLSCapability =0x00400000;   /* STARTTLS support */
+const eIMAPCapabilityFlag kHasAuthNoneCapability = 0x00800000; /* needs no login */
+const eIMAPCapabilityFlag kHasAuthGssApiCapability = 0x01000000; /* GSSAPI AUTH */
+const eIMAPCapabilityFlag kHasCondStoreCapability = 0x02000000; /* RFC 3551 CondStore extension */
+const eIMAPCapabilityFlag kHasEnableCapability = 0x04000000; /* RFC 5161 ENABLE extension */
+const eIMAPCapabilityFlag kHasXListCapability = 0x08000000;  /* XLIST extension */
+const eIMAPCapabilityFlag kHasCompressDeflateCapability = 0x10000000;  /* RFC 4978 COMPRESS extension */
+const eIMAPCapabilityFlag kHasAuthExternalCapability = 0x20000000;  /* RFC 2222 SASL AUTH EXTERNAL */
+const eIMAPCapabilityFlag kHasMoveCapability = 0x40000000;  /* Proposed MOVE RFC */
+const eIMAPCapabilityFlag kHasHighestModSeqCapability = 0x80000000;  /* Subset of RFC 3551 */
+// above are 32bit; below start the uint64_t bits 33-64
+const eIMAPCapabilityFlag kHasListExtendedCapability = 0x100000000LL;  /* RFC 5258 */
+const eIMAPCapabilityFlag kHasSpecialUseCapability = 0x200000000LL;  /* RFC 6154: Sent, Draft etc. folders */
+const eIMAPCapabilityFlag kGmailImapCapability = 0x400000000LL;  /* X-GM-EXT-1 capability extension for gmail */
+const eIMAPCapabilityFlag kHasXOAuth2Capability = 0x800000000LL;  /* AUTH XOAUTH2 extension */
+
+
+// this used to be part of the connection object class - maybe we should move it into 
+// something similar
+typedef enum {
+    kEveryThingRFC822,
+    kEveryThingRFC822Peek,
+    kHeadersRFC822andUid,
+    kUid,
+    kFlags,
+    kRFC822Size,
+    kRFC822HeadersOnly,
+    kMIMEPart,
+    kMIMEHeader,
+    kBodyStart
+} nsIMAPeFetchFields;
+
+typedef struct _utf_name_struct {
+	bool toUtf7Imap;
+	unsigned char *sourceString;
+	unsigned char *convertedString;
+} utf_name_struct;
+
+typedef struct _ProgressInfo {
+  char16_t *message;
+  int32_t currentProgress;
+  int32_t maxProgress;
+} ProgressInfo;
+
+typedef enum {
+    eContinue,
+    eContinueNew,
+    eListMyChildren,
+    eNewServerDirectory,
+    eCancelled 
+} EMailboxDiscoverStatus;
+
+#endif
diff --git a/mailnews/imap/src/nsImapFlagAndUidState.cpp b/mailnews/imap/src/nsImapFlagAndUidState.cpp
new file mode 100644
index 0000000000..deae831db3
--- /dev/null
+++ b/mailnews/imap/src/nsImapFlagAndUidState.cpp
@@ -0,0 +1,321 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"  // for pre-compiled headers
+
+#include "nsImapCore.h"
+#include "nsImapFlagAndUidState.h"
+#include "nsMsgUtils.h"
+#include "prcmon.h"
+#include "nspr.h"
+
+NS_IMPL_ISUPPORTS(nsImapFlagAndUidState, nsIImapFlagAndUidState)
+
+using namespace mozilla;
+
+NS_IMETHODIMP nsImapFlagAndUidState::GetNumberOfMessages(int32_t *result)
+{
+  if (!result)
+    return NS_ERROR_NULL_POINTER;
+  *result = fUids.Length();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::GetUidOfMessage(int32_t zeroBasedIndex, uint32_t *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  PR_CEnterMonitor(this);
+  *aResult = fUids.SafeElementAt(zeroBasedIndex, nsMsgKey_None);
+  PR_CExitMonitor(this);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::GetMessageFlags(int32_t zeroBasedIndex, uint16_t *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = fFlags.SafeElementAt(zeroBasedIndex, kNoImapMsgFlag);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::SetMessageFlags(int32_t zeroBasedIndex, unsigned short flags)
+{
+  if (zeroBasedIndex < (int32_t)fUids.Length())
+    fFlags[zeroBasedIndex] = flags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::GetNumberOfRecentMessages(int32_t *result)
+{
+  if (!result)
+    return NS_ERROR_NULL_POINTER;
+  
+  PR_CEnterMonitor(this);
+  uint32_t counter = 0;
+  int32_t numUnseenMessages = 0;
+  
+  for (counter = 0; counter < fUids.Length(); counter++)
+  {
+    if (fFlags[counter] & kImapMsgRecentFlag)
+      numUnseenMessages++;
+  }
+  PR_CExitMonitor(this);
+  
+  *result = numUnseenMessages;
+  
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::GetPartialUIDFetch(bool *aPartialUIDFetch)
+{
+  NS_ENSURE_ARG_POINTER(aPartialUIDFetch);
+  *aPartialUIDFetch = fPartialUIDFetch;
+  return NS_OK;
+}
+
+/* amount to expand for imap entry flags when we need more */
+
+nsImapFlagAndUidState::nsImapFlagAndUidState(int32_t numberOfMessages)
+  : fUids(numberOfMessages),
+    fFlags(numberOfMessages),
+    m_customFlagsHash(10),
+    m_customAttributesHash(10),
+    mLock("nsImapFlagAndUidState.mLock")
+{
+  fSupportedUserFlags = 0;
+  fNumberDeleted = 0;
+  fPartialUIDFetch = true;
+}
+
+nsImapFlagAndUidState::~nsImapFlagAndUidState()
+{
+}
+
+NS_IMETHODIMP
+nsImapFlagAndUidState::OrSupportedUserFlags(uint16_t flags)
+{
+  fSupportedUserFlags |= flags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapFlagAndUidState::GetSupportedUserFlags(uint16_t *aFlags)
+{
+  NS_ENSURE_ARG_POINTER(aFlags);
+  *aFlags = fSupportedUserFlags;
+  return NS_OK;
+}
+
+// we need to reset our flags, (re-read all) but chances are the memory allocation needed will be
+// very close to what we were already using
+
+NS_IMETHODIMP nsImapFlagAndUidState::Reset()
+{
+  PR_CEnterMonitor(this);
+  fNumberDeleted = 0;
+  m_customFlagsHash.Clear();
+  fUids.Clear();
+  fFlags.Clear();
+  fPartialUIDFetch = true;
+  PR_CExitMonitor(this);
+  return NS_OK;
+}
+
+
+// Remove (expunge) a message from our array, since now it is gone for good
+
+NS_IMETHODIMP nsImapFlagAndUidState::ExpungeByIndex(uint32_t msgIndex)
+{
+  // protect ourselves in case the server gave us an index key of -1 or 0
+  if ((int32_t) msgIndex <= 0)
+    return NS_ERROR_INVALID_ARG;
+
+  if ((uint32_t) fUids.Length() < msgIndex)
+    return NS_ERROR_INVALID_ARG;
+
+  PR_CEnterMonitor(this);
+  msgIndex--;  // msgIndex is 1-relative
+  if (fFlags[msgIndex] & kImapMsgDeletedFlag) // see if we already had counted this one as deleted
+    fNumberDeleted--;
+  fUids.RemoveElementAt(msgIndex);
+  fFlags.RemoveElementAt(msgIndex);
+  PR_CExitMonitor(this);
+  return NS_OK;
+}
+
+
+// adds to sorted list, protects against duplicates and going past array bounds.
+NS_IMETHODIMP nsImapFlagAndUidState::AddUidFlagPair(uint32_t uid, imapMessageFlagsType flags, uint32_t zeroBasedIndex)
+{
+  if (uid == nsMsgKey_None) // ignore uid of -1
+    return NS_OK;
+  // check for potential overflow in buffer size for uid array
+  if (zeroBasedIndex > 0x3FFFFFFF)
+    return NS_ERROR_INVALID_ARG;
+  PR_CEnterMonitor(this);
+  // make sure there is room for this pair
+  if (zeroBasedIndex >= fUids.Length())
+  {
+    int32_t sizeToGrowBy = zeroBasedIndex - fUids.Length() + 1;
+    fUids.InsertElementsAt(fUids.Length(), sizeToGrowBy, 0);
+    fFlags.InsertElementsAt(fFlags.Length(), sizeToGrowBy, 0);
+  }
+
+  fUids[zeroBasedIndex] = uid;
+  fFlags[zeroBasedIndex] = flags;
+  if (flags & kImapMsgDeletedFlag)
+    fNumberDeleted++;
+  PR_CExitMonitor(this);
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsImapFlagAndUidState::GetNumberOfDeletedMessages(int32_t *numDeletedMessages)
+{
+  NS_ENSURE_ARG_POINTER(numDeletedMessages);
+  *numDeletedMessages = NumberOfDeletedMessages();
+  return NS_OK;
+}
+
+int32_t nsImapFlagAndUidState::NumberOfDeletedMessages()
+{
+  return fNumberDeleted;
+}
+	
+// since the uids are sorted, start from the back (rb)
+
+uint32_t  nsImapFlagAndUidState::GetHighestNonDeletedUID()
+{
+  uint32_t msgIndex = fUids.Length();
+  do 
+  {
+    if (msgIndex <= 0)
+      return(0);
+    msgIndex--;
+    if (fUids[msgIndex] && !(fFlags[msgIndex] & kImapMsgDeletedFlag))
+      return fUids[msgIndex];
+  }
+  while (msgIndex > 0);
+  return 0;
+}
+
+
+// Has the user read the last message here ? Used when we first open the inbox to see if there
+// really is new mail there.
+
+bool nsImapFlagAndUidState::IsLastMessageUnseen()
+{
+  uint32_t msgIndex = fUids.Length();
+  
+  if (msgIndex <= 0)
+    return false;
+  msgIndex--;
+  // if last message is deleted, it was probably filtered the last time around
+  if (fUids[msgIndex] && (fFlags[msgIndex] & (kImapMsgSeenFlag | kImapMsgDeletedFlag)))
+    return false;
+  return true; 
+}
+
+// find a message flag given a key with non-recursive binary search, since some folders
+// may have thousand of messages, once we find the key set its index, or the index of
+// where the key should be inserted
+
+imapMessageFlagsType nsImapFlagAndUidState::GetMessageFlagsFromUID(uint32_t uid, bool *foundIt, int32_t *ndx)
+{
+  PR_CEnterMonitor(this);
+  *ndx = (int32_t) fUids.IndexOfFirstElementGt(uid) - 1;
+  *foundIt = *ndx >= 0 && fUids[*ndx] == uid;
+  imapMessageFlagsType retFlags = (*foundIt) ? fFlags[*ndx] : kNoImapMsgFlag;
+  PR_CExitMonitor(this);
+  return retFlags;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::AddUidCustomFlagPair(uint32_t uid, const char *customFlag)
+{
+  if (!customFlag)
+    return NS_OK;
+
+  MutexAutoLock mon(mLock);
+  nsCString ourCustomFlags;
+  nsCString oldValue;
+  if (m_customFlagsHash.Get(uid, &oldValue))
+  {
+    // We'll store multiple keys as space-delimited since space is not
+    // a valid character in a keyword. First, we need to look for the
+    // customFlag in the existing flags;
+    nsDependentCString customFlagString(customFlag);
+    int32_t existingCustomFlagPos = oldValue.Find(customFlagString);
+    uint32_t customFlagLen = customFlagString.Length();
+    while (existingCustomFlagPos != kNotFound)
+    {
+      // if existing flags ends with this exact flag, or flag + ' '
+      // and the flag is at the beginning of the string or there is ' ' + flag
+      // then we have this flag already;
+      if (((oldValue.Length() == existingCustomFlagPos + customFlagLen) ||
+           (oldValue.CharAt(existingCustomFlagPos + customFlagLen) == ' ')) &&
+           ((existingCustomFlagPos == 0) ||
+            (oldValue.CharAt(existingCustomFlagPos - 1) == ' ')))
+        return NS_OK;
+      // else, advance to next flag
+      existingCustomFlagPos = MsgFind(oldValue, customFlagString, false, existingCustomFlagPos + customFlagLen);
+    }
+    ourCustomFlags.Assign(oldValue);
+    ourCustomFlags.AppendLiteral(" ");
+    ourCustomFlags.Append(customFlag);
+    m_customFlagsHash.Remove(uid);
+  }
+  else
+  {
+    ourCustomFlags.Assign(customFlag);
+  }
+  m_customFlagsHash.Put(uid, ourCustomFlags);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::GetCustomFlags(uint32_t uid, char **customFlags)
+{
+  MutexAutoLock mon(mLock);
+  nsCString value;
+  if (m_customFlagsHash.Get(uid, &value))
+  {
+    *customFlags = NS_strdup(value.get());
+    return (*customFlags) ? NS_OK : NS_ERROR_FAILURE;
+  }
+  *customFlags = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::ClearCustomFlags(uint32_t uid)
+{
+  MutexAutoLock mon(mLock);
+  m_customFlagsHash.Remove(uid);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::SetCustomAttribute(uint32_t aUid,
+                                                        const nsACString &aCustomAttributeName,
+                                                        const nsACString &aCustomAttributeValue)
+{
+  nsCString key;
+  key.AppendInt((int64_t)aUid);
+  key.Append(aCustomAttributeName);
+  nsCString value;
+  value.Assign(aCustomAttributeValue);
+  m_customAttributesHash.Put(key, value);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapFlagAndUidState::GetCustomAttribute(uint32_t aUid,
+                                                        const nsACString &aCustomAttributeName,
+                                                        nsACString &aCustomAttributeValue)
+{
+  nsCString key;
+  key.AppendInt((int64_t)aUid);
+  key.Append(aCustomAttributeName);
+  nsCString val;
+  m_customAttributesHash.Get(key, &val);
+  aCustomAttributeValue.Assign(val);
+  return NS_OK;
+}
diff --git a/mailnews/imap/src/nsImapFlagAndUidState.h b/mailnews/imap/src/nsImapFlagAndUidState.h
new file mode 100644
index 0000000000..6bf5f3fbe0
--- /dev/null
+++ b/mailnews/imap/src/nsImapFlagAndUidState.h
@@ -0,0 +1,55 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsImapFlagAndUidState_h___
+#define nsImapFlagAndUidState_h___
+
+#include "MailNewsTypes.h"
+#include "nsTArray.h"
+#include "nsIImapFlagAndUidState.h"
+#include "mozilla/Mutex.h"
+
+const int32_t kImapFlagAndUidStateSize =	100;
+
+#include "nsBaseHashtable.h"
+#include "nsDataHashtable.h"
+
+class nsImapFlagAndUidState : public nsIImapFlagAndUidState
+{
+public:
+    NS_DECL_THREADSAFE_ISUPPORTS
+    nsImapFlagAndUidState(int numberOfMessages);
+
+    NS_DECL_NSIIMAPFLAGANDUIDSTATE
+
+    int32_t               NumberOfDeletedMessages();
+    
+    imapMessageFlagsType  GetMessageFlagsFromUID(uint32_t uid, bool *foundIt, int32_t *ndx);
+
+    bool         IsLastMessageUnseen(void);
+    bool         GetPartialUIDFetch() {return fPartialUIDFetch;}
+    void         SetPartialUIDFetch(bool isPartial) {fPartialUIDFetch = isPartial;}
+    uint32_t     GetHighestNonDeletedUID();
+    uint16_t     GetSupportedUserFlags() { return fSupportedUserFlags; }
+
+private:
+  virtual ~nsImapFlagAndUidState();
+
+    nsTArray<nsMsgKey>      fUids;
+    nsTArray<imapMessageFlagsType> fFlags;
+    // Hash table, mapping uids to extra flags
+    nsDataHashtable<nsUint32HashKey, nsCString> m_customFlagsHash;
+    // Hash table, mapping UID+customAttributeName to customAttributeValue.
+    nsDataHashtable<nsCStringHashKey, nsCString> m_customAttributesHash;
+    uint16_t                fSupportedUserFlags;
+    int32_t                 fNumberDeleted;
+    bool                    fPartialUIDFetch;
+    mozilla::Mutex mLock;
+};
+
+
+
+
+#endif
diff --git a/mailnews/imap/src/nsImapIncomingServer.cpp b/mailnews/imap/src/nsImapIncomingServer.cpp
new file mode 100644
index 0000000000..77a34985bf
--- /dev/null
+++ b/mailnews/imap/src/nsImapIncomingServer.cpp
@@ -0,0 +1,3382 @@
+/* -*- 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 "nsMsgImapCID.h"
+
+#include "netCore.h"
+#include "nsIMAPHostSessionList.h"
+#include "nsImapIncomingServer.h"
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgIdentity.h"
+#include "nsIImapUrl.h"
+#include "nsIUrlListener.h"
+#include "nsThreadUtils.h"
+#include "nsImapProtocol.h"
+#include "nsCOMPtr.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsMsgFolderFlags.h"
+#include "prmem.h"
+#include "plstr.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgWindow.h"
+#include "nsImapMailFolder.h"
+#include "nsImapUtils.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIImapService.h"
+#include "nsMsgI18N.h"
+#include "nsIImapMockChannel.h"
+// for the memory cache...
+#include "nsICacheEntry.h"
+#include "nsImapUrl.h"
+#include "nsIMsgProtocolInfo.h"
+#include "nsIMsgMailSession.h"
+#include "nsIMAPNamespace.h"
+#include "nsArrayUtils.h"
+#include "nsITimer.h"
+#include "nsMsgUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsCRTGlue.h"
+#include "mozilla/Services.h"
+
+using namespace mozilla;
+
+#define PREF_TRASH_FOLDER_NAME "trash_folder_name"
+#define DEFAULT_TRASH_FOLDER_NAME "Trash"
+
+static NS_DEFINE_CID(kImapProtocolCID, NS_IMAPPROTOCOL_CID);
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+static NS_DEFINE_CID(kSubscribableServerCID, NS_SUBSCRIBABLESERVER_CID);
+static NS_DEFINE_CID(kCImapHostSessionListCID, NS_IIMAPHOSTSESSIONLIST_CID);
+
+NS_IMPL_ADDREF_INHERITED(nsImapIncomingServer, nsMsgIncomingServer)
+NS_IMPL_RELEASE_INHERITED(nsImapIncomingServer, nsMsgIncomingServer)
+
+NS_INTERFACE_MAP_BEGIN(nsImapIncomingServer)
+  NS_INTERFACE_MAP_ENTRY(nsIImapServerSink)
+  NS_INTERFACE_MAP_ENTRY(nsIImapIncomingServer)
+  NS_INTERFACE_MAP_ENTRY(nsISubscribableServer)
+  NS_INTERFACE_MAP_ENTRY(nsIUrlListener)
+NS_INTERFACE_MAP_END_INHERITING(nsMsgIncomingServer)
+
+nsImapIncomingServer::nsImapIncomingServer()
+  : mLock("nsImapIncomingServer.mLock")
+{
+  m_capability = kCapabilityUndefined;
+  mDoingSubscribeDialog = false;
+  mDoingLsub = false;
+  m_canHaveFilters = true;
+  m_userAuthenticated = false;
+  m_shuttingDown = false;
+}
+
+nsImapIncomingServer::~nsImapIncomingServer()
+{
+  mozilla::DebugOnly<nsresult> rv = ClearInner();
+  NS_ASSERTION(NS_SUCCEEDED(rv), "ClearInner failed");
+  CloseCachedConnections();
+}
+
+NS_IMETHODIMP nsImapIncomingServer::SetKey(const nsACString& aKey)  // override nsMsgIncomingServer's implementation...
+{
+  nsMsgIncomingServer::SetKey(aKey);
+
+  // okay now that the key has been set, we need to add ourselves to the
+  // host session list...
+
+  // every time we create an imap incoming server, we need to add it to the
+  // host session list!!
+
+  nsresult rv;
+  nsCOMPtr<nsIImapHostSessionList> hostSession = do_GetService(kCImapHostSessionListCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString key(aKey);
+  hostSession->AddHostToList(key.get(), this);
+  nsMsgImapDeleteModel deleteModel = nsMsgImapDeleteModels::MoveToTrash; // default to trash
+  GetDeleteModel(&deleteModel);
+  hostSession->SetDeleteIsMoveToTrashForHost(key.get(), deleteModel == nsMsgImapDeleteModels::MoveToTrash);
+  hostSession->SetShowDeletedMessagesForHost(key.get(), deleteModel == nsMsgImapDeleteModels::IMAPDelete);
+
+  nsAutoCString onlineDir;
+  rv = GetServerDirectory(onlineDir);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!onlineDir.IsEmpty())
+    hostSession->SetOnlineDirForHost(key.get(), onlineDir.get());
+
+  nsCString personalNamespace;
+  nsCString publicNamespace;
+  nsCString otherUsersNamespace;
+
+  rv = GetPersonalNamespace(personalNamespace);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = GetPublicNamespace(publicNamespace);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = GetOtherUsersNamespace(otherUsersNamespace);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (personalNamespace.IsEmpty() && publicNamespace.IsEmpty() && otherUsersNamespace.IsEmpty())
+      personalNamespace.AssignLiteral("\"\"");
+
+  hostSession->SetNamespaceFromPrefForHost(key.get(), personalNamespace.get(),
+                                           kPersonalNamespace);
+
+  if (!publicNamespace.IsEmpty())
+      hostSession->SetNamespaceFromPrefForHost(key.get(), publicNamespace.get(),
+                                               kPublicNamespace);
+
+  if (!otherUsersNamespace.IsEmpty())
+      hostSession->SetNamespaceFromPrefForHost(key.get(), otherUsersNamespace.get(),
+                                               kOtherUsersNamespace);
+  return rv;
+}
+
+// construct the pretty name to show to the user if they haven't
+// specified one. This should be overridden for news and mail.
+NS_IMETHODIMP
+nsImapIncomingServer::GetConstructedPrettyName(nsAString& retval)
+{
+  nsAutoCString username;
+  nsAutoCString hostName;
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+           do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIMsgIdentity> identity;
+  rv = accountManager->GetFirstIdentityForServer(this, getter_AddRefs(identity));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsAutoString emailAddress;
+
+  if (NS_SUCCEEDED(rv) && identity)
+  {
+    nsCString identityEmailAddress;
+    identity->GetEmail(identityEmailAddress);
+    CopyASCIItoUTF16(identityEmailAddress, emailAddress);
+  }
+  else
+  {
+    rv = GetRealUsername(username);
+    NS_ENSURE_SUCCESS(rv,rv);
+    rv = GetRealHostName(hostName);
+    NS_ENSURE_SUCCESS(rv,rv);
+    if (!username.IsEmpty() && !hostName.IsEmpty()) {
+      CopyASCIItoUTF16(username, emailAddress);
+      emailAddress.Append('@');
+      emailAddress.Append(NS_ConvertASCIItoUTF16(hostName));
+    }
+  }
+
+  return GetFormattedStringFromName(emailAddress, "imapDefaultAccountName", retval);
+}
+
+
+NS_IMETHODIMP nsImapIncomingServer::GetLocalStoreType(nsACString& type)
+{
+  type.AssignLiteral("imap");
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::GetLocalDatabaseType(nsACString& type)
+{
+  type.AssignLiteral("imap");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetServerDirectory(nsACString& serverDirectory)
+{
+  return GetCharValue("server_sub_directory", serverDirectory);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetServerDirectory(const nsACString& serverDirectory)
+{
+  nsCString serverKey;
+  nsresult rv = GetKey(serverKey);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIImapHostSessionList> hostSession = do_GetService(kCImapHostSessionListCID, &rv);
+    if (NS_SUCCEEDED(rv))
+      hostSession->SetOnlineDirForHost(serverKey.get(), PromiseFlatCString(serverDirectory).get());
+  }
+  return SetCharValue("server_sub_directory", serverDirectory);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetOverrideNamespaces(bool *bVal)
+{
+  return GetBoolValue("override_namespaces", bVal);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetOverrideNamespaces(bool bVal)
+{
+  nsCString serverKey;
+  GetKey(serverKey);
+  if (!serverKey.IsEmpty())
+  {
+    nsresult rv;
+    nsCOMPtr<nsIImapHostSessionList> hostSession = do_GetService(kCImapHostSessionListCID, &rv);
+    if (NS_SUCCEEDED(rv))
+      hostSession->SetNamespacesOverridableForHost(serverKey.get(), bVal);
+  }
+  return SetBoolValue("override_namespaces", bVal);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetUsingSubscription(bool *bVal)
+{
+  return GetBoolValue("using_subscription", bVal);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetUsingSubscription(bool bVal)
+{
+  nsCString serverKey;
+  GetKey(serverKey);
+  if (!serverKey.IsEmpty())
+  {
+    nsresult rv;
+    nsCOMPtr<nsIImapHostSessionList> hostSession = do_GetService(kCImapHostSessionListCID, &rv);
+    if (NS_SUCCEEDED(rv))
+      hostSession->SetHostIsUsingSubscription(serverKey.get(), bVal);
+  }
+  return SetBoolValue("using_subscription", bVal);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetMaximumConnectionsNumber(int32_t *aMaxConnections)
+{
+  NS_ENSURE_ARG_POINTER(aMaxConnections);
+
+  nsresult rv = GetIntValue("max_cached_connections", aMaxConnections);
+  // Get our maximum connection count. We need at least 1. If the value is 0,
+  // we use the default of 5. If it's negative, we treat that as 1.
+  if (NS_SUCCEEDED(rv) && *aMaxConnections > 0)
+    return NS_OK;
+
+  *aMaxConnections = (NS_FAILED(rv) || (*aMaxConnections == 0)) ? 5 : 1;
+  (void)SetMaximumConnectionsNumber(*aMaxConnections);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetMaximumConnectionsNumber(int32_t aMaxConnections)
+{
+  return SetIntValue("max_cached_connections", aMaxConnections);
+}
+
+NS_IMPL_SERVERPREF_STR(nsImapIncomingServer, ForceSelect,
+                       "force_select")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, DualUseFolders,
+                        "dual_use_folders")
+
+NS_IMPL_SERVERPREF_STR(nsImapIncomingServer, AdminUrl,
+                       "admin_url")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, CleanupInboxOnExit,
+                        "cleanup_inbox_on_exit")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, OfflineDownload,
+                        "offline_download")
+
+NS_IMPL_SERVERPREF_INT(nsImapIncomingServer, EmptyTrashThreshhold,
+                       "empty_trash_threshhold")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, DownloadBodiesOnGetNewMail,
+                        "download_bodies_on_get_new_mail")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, AutoSyncOfflineStores,
+                        "autosync_offline_stores")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, UseIdle,
+                        "use_idle")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, CheckAllFoldersForNew,
+                        "check_all_folders_for_new")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, UseCondStore,
+                        "use_condstore")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, IsGMailServer,
+                        "is_gmail")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, UseCompressDeflate,
+                        "use_compress_deflate")
+
+NS_IMPL_SERVERPREF_INT(nsImapIncomingServer, AutoSyncMaxAgeDays,
+                        "autosync_max_age_days")
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetShuttingDown(bool *retval)
+{
+  NS_ENSURE_ARG_POINTER(retval);
+  *retval = m_shuttingDown;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetShuttingDown(bool val)
+{
+  m_shuttingDown = val;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetDeleteModel(int32_t *retval)
+{
+  NS_ENSURE_ARG(retval);
+  return GetIntValue("delete_model", retval);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetDeleteModel(int32_t ivalue)
+{
+  nsresult rv = SetIntValue("delete_model", ivalue);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIImapHostSessionList> hostSession =
+        do_GetService(kCImapHostSessionListCID, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+    hostSession->SetDeleteIsMoveToTrashForHost(m_serverKey.get(), ivalue == nsMsgImapDeleteModels::MoveToTrash);
+    hostSession->SetShowDeletedMessagesForHost(m_serverKey.get(), ivalue == nsMsgImapDeleteModels::IMAPDelete);
+
+    nsAutoString trashFolderName;
+    nsresult rv = GetTrashFolderName(trashFolderName);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsAutoCString trashFolderNameUtf7;
+      rv = CopyUTF16toMUTF7(trashFolderName, trashFolderNameUtf7);
+      if (NS_SUCCEEDED(rv))
+      {
+        nsCOMPtr<nsIMsgFolder> trashFolder;
+        // XXX GetFolder only returns folders one level below root.
+        //     trashFolderName is a leaf name. So this will not find INBOX.Trash
+        rv = GetFolder(trashFolderNameUtf7, getter_AddRefs(trashFolder));
+        NS_ENSURE_SUCCESS(rv, rv);
+        nsCString trashURI;
+        trashFolder->GetURI(trashURI);
+        GetMsgFolderFromURI(trashFolder, trashURI, getter_AddRefs(trashFolder));
+        if (NS_SUCCEEDED(rv) && trashFolder)
+        {
+           // If the trash folder is used, set the flag, otherwise clear it.
+          if (ivalue == nsMsgImapDeleteModels::MoveToTrash)
+            trashFolder->SetFlag(nsMsgFolderFlags::Trash);
+          else
+            trashFolder->ClearFlag(nsMsgFolderFlags::Trash);
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMPL_SERVERPREF_INT(nsImapIncomingServer, TimeOutLimits,
+                       "timeout")
+
+NS_IMPL_SERVERPREF_STR(nsImapIncomingServer, ServerIDPref,
+                       "serverIDResponse")
+
+NS_IMPL_SERVERPREF_STR(nsImapIncomingServer, PersonalNamespace,
+                       "namespace.personal")
+
+NS_IMPL_SERVERPREF_STR(nsImapIncomingServer, PublicNamespace,
+                       "namespace.public")
+
+NS_IMPL_SERVERPREF_STR(nsImapIncomingServer, OtherUsersNamespace,
+                       "namespace.other_users")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, FetchByChunks,
+                       "fetch_by_chunks")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, MimePartsOnDemand,
+                       "mime_parts_on_demand")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, SendID,
+                       "send_client_info")
+
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, CapabilityACL,
+                       "cacheCapa.acl")
+NS_IMPL_SERVERPREF_BOOL(nsImapIncomingServer, CapabilityQuota,
+                       "cacheCapa.quota")
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetIsAOLServer(bool *aBool)
+{
+  NS_ENSURE_ARG_POINTER(aBool);
+  *aBool = ((m_capability & kAOLImapCapability) != 0);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetIsAOLServer(bool aBool)
+{
+  if (aBool)
+    m_capability |= kAOLImapCapability;
+  else
+    m_capability &= ~kAOLImapCapability;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::UpdateTrySTARTTLSPref(bool aStartTLSSucceeded)
+{
+  SetSocketType(aStartTLSSucceeded ? nsMsgSocketType::alwaysSTARTTLS :
+                                     nsMsgSocketType::plain);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetImapConnectionAndLoadUrl(nsIImapUrl* aImapUrl,
+                                                  nsISupports* aConsumer)
+{
+  nsCOMPtr<nsIImapProtocol> aProtocol;
+
+  nsresult rv = GetImapConnection(aImapUrl, getter_AddRefs(aProtocol));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl = do_QueryInterface(aImapUrl, &rv);
+  if (aProtocol)
+  {
+    rv = aProtocol->LoadImapUrl(mailnewsurl, aConsumer);
+    // *** jt - in case of the time out situation or the connection gets
+    // terminated by some unforseen problems let's give it a second chance
+    // to run the url
+    if (NS_FAILED(rv) && rv != NS_ERROR_ILLEGAL_VALUE)
+    {
+      NS_ASSERTION(false, "shouldn't get an error loading url");
+      rv = aProtocol->LoadImapUrl(mailnewsurl, aConsumer);
+    }
+  }
+  else
+  {   // unable to get an imap connection to run the url; add to the url
+     // queue
+    nsImapProtocol::LogImapUrl("queuing url", aImapUrl);
+    PR_CEnterMonitor(this);
+    m_urlQueue.AppendObject(aImapUrl);
+    m_urlConsumers.AppendElement(aConsumer);
+    NS_IF_ADDREF(aConsumer);
+    PR_CExitMonitor(this);
+    // let's try running it now - maybe the connection is free now.
+    bool urlRun;
+    rv = LoadNextQueuedUrl(nullptr, &urlRun);
+  }
+
+  return rv;
+}
+
+
+NS_IMETHODIMP
+nsImapIncomingServer::PrepareToRetryUrl(nsIImapUrl *aImapUrl, nsIImapMockChannel **aChannel)
+{
+  NS_ENSURE_ARG_POINTER(aChannel);
+  NS_ENSURE_ARG_POINTER(aImapUrl);
+  // maybe there's more we could do here, but this is all we need now.
+  return aImapUrl->GetMockChannel(aChannel);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SuspendUrl(nsIImapUrl *aImapUrl)
+{
+  NS_ENSURE_ARG_POINTER(aImapUrl);
+  nsImapProtocol::LogImapUrl("suspending url", aImapUrl);
+  PR_CEnterMonitor(this);
+  m_urlQueue.AppendObject(aImapUrl);
+  m_urlConsumers.AppendElement(nullptr);
+  PR_CExitMonitor(this);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::RetryUrl(nsIImapUrl *aImapUrl, nsIImapMockChannel *aChannel)
+{
+  nsresult rv;
+  // Get current thread envent queue
+  aImapUrl->SetMockChannel(aChannel);
+  nsCOMPtr <nsIImapProtocol> protocolInstance;
+  nsImapProtocol::LogImapUrl("creating protocol instance to retry queued url", aImapUrl);
+  nsCOMPtr<nsIThread> thread(do_GetCurrentThread());
+  rv = GetImapConnection(aImapUrl, getter_AddRefs(protocolInstance));
+  if (NS_SUCCEEDED(rv) && protocolInstance)
+  {
+    nsCOMPtr<nsIURI> url = do_QueryInterface(aImapUrl, &rv);
+    if (NS_SUCCEEDED(rv) && url)
+    {
+      nsImapProtocol::LogImapUrl("retrying  url", aImapUrl);
+      rv = protocolInstance->LoadImapUrl(url, nullptr); // ### need to save the display consumer.
+      NS_ASSERTION(NS_SUCCEEDED(rv), "failed running queued url");
+    }
+  }
+  return rv;
+}
+
+// checks to see if there are any queued urls on this incoming server,
+// and if so, tries to run the oldest one. Returns true if the url is run
+// on the passed in protocol connection.
+NS_IMETHODIMP
+nsImapIncomingServer::LoadNextQueuedUrl(nsIImapProtocol *aProtocol, bool *aResult)
+{
+  if (WeAreOffline())
+    return NS_MSG_ERROR_OFFLINE;
+
+  nsresult rv = NS_OK;
+  bool urlRun = false;
+  bool keepGoing = true;
+  nsCOMPtr <nsIImapProtocol>  protocolInstance ;
+
+  MutexAutoLock mon(mLock);
+  int32_t cnt = m_urlQueue.Count();
+
+  while (cnt > 0 && !urlRun && keepGoing)
+  {
+    nsCOMPtr<nsIImapUrl> aImapUrl(m_urlQueue[0]);
+    nsCOMPtr<nsIMsgMailNewsUrl> aMailNewsUrl(do_QueryInterface(aImapUrl, &rv));
+
+    bool removeUrlFromQueue = false;
+    if (aImapUrl)
+    {
+      nsImapProtocol::LogImapUrl("considering playing queued url", aImapUrl);
+      rv = DoomUrlIfChannelHasError(aImapUrl, &removeUrlFromQueue);
+      NS_ENSURE_SUCCESS(rv, rv);
+      // if we didn't doom the url, lets run it.
+      if (!removeUrlFromQueue)
+      {
+        nsISupports *aConsumer = m_urlConsumers.ElementAt(0);
+        NS_IF_ADDREF(aConsumer);
+
+        nsImapProtocol::LogImapUrl("creating protocol instance to play queued url", aImapUrl);
+        rv = GetImapConnection(aImapUrl, getter_AddRefs(protocolInstance));
+        if (NS_SUCCEEDED(rv) && protocolInstance)
+        {
+          nsCOMPtr<nsIURI> url = do_QueryInterface(aImapUrl, &rv);
+          if (NS_SUCCEEDED(rv) && url)
+          {
+            nsImapProtocol::LogImapUrl("playing queued url", aImapUrl);
+            rv = protocolInstance->LoadImapUrl(url, aConsumer);
+            NS_ASSERTION(NS_SUCCEEDED(rv), "failed running queued url");
+            bool isInbox;
+            protocolInstance->IsBusy(&urlRun, &isInbox);
+            if (!urlRun)
+              nsImapProtocol::LogImapUrl("didn't need to run", aImapUrl);
+            removeUrlFromQueue = true;
+          }
+        }
+        else
+        {
+          nsImapProtocol::LogImapUrl("failed creating protocol instance to play queued url", aImapUrl);
+          keepGoing = false;
+        }
+        NS_IF_RELEASE(aConsumer);
+      }
+      if (removeUrlFromQueue)
+      {
+        m_urlQueue.RemoveObjectAt(0);
+        m_urlConsumers.RemoveElementAt(0);
+      }
+    }
+    cnt = m_urlQueue.Count();
+  }
+  if (aResult)
+    *aResult = urlRun && aProtocol && aProtocol == protocolInstance;
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::AbortQueuedUrls()
+{
+  nsresult rv = NS_OK;
+
+  MutexAutoLock mon(mLock);
+  int32_t cnt = m_urlQueue.Count();
+
+  while (cnt > 0)
+  {
+    nsCOMPtr<nsIImapUrl> aImapUrl(m_urlQueue[cnt - 1]);
+    bool removeUrlFromQueue = false;
+
+    if (aImapUrl)
+    {
+      rv = DoomUrlIfChannelHasError(aImapUrl, &removeUrlFromQueue);
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (removeUrlFromQueue)
+      {
+        m_urlQueue.RemoveObjectAt(cnt - 1);
+        m_urlConsumers.RemoveElementAt(cnt - 1);
+      }
+    }
+    cnt--;
+  }
+
+  return rv;
+}
+
+// if this url has a channel with an error, doom it and its mem cache entries,
+// and notify url listeners.
+nsresult nsImapIncomingServer::DoomUrlIfChannelHasError(nsIImapUrl *aImapUrl, bool *urlDoomed)
+{
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIMsgMailNewsUrl> aMailNewsUrl(do_QueryInterface(aImapUrl, &rv));
+
+  if (aMailNewsUrl && aImapUrl)
+  {
+    nsCOMPtr <nsIImapMockChannel> mockChannel;
+
+    if (NS_SUCCEEDED(aImapUrl->GetMockChannel(getter_AddRefs(mockChannel))) && mockChannel)
+    {
+      nsresult requestStatus;
+      nsCOMPtr<nsIRequest> request = do_QueryInterface(mockChannel);
+      if (!request)
+        return NS_ERROR_FAILURE;
+      request->GetStatus(&requestStatus);
+      if (NS_FAILED(requestStatus))
+      {
+        nsresult res;
+        *urlDoomed = true;
+        nsImapProtocol::LogImapUrl("dooming url", aImapUrl);
+
+        mockChannel->Close(); // try closing it to get channel listener nulled out.
+
+        if (aMailNewsUrl)
+        {
+          nsCOMPtr<nsICacheEntry> cacheEntry;
+          res = aMailNewsUrl->GetMemCacheEntry(getter_AddRefs(cacheEntry));
+          if (NS_SUCCEEDED(res) && cacheEntry)
+            cacheEntry->AsyncDoom(nullptr);
+          // we're aborting this url - tell listeners
+          aMailNewsUrl->SetUrlState(false, NS_MSG_ERROR_URL_ABORTED);
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::RemoveConnection(nsIImapProtocol* aImapConnection)
+{
+  PR_CEnterMonitor(this);
+  if (aImapConnection)
+    m_connectionCache.RemoveObject(aImapConnection);
+
+  PR_CExitMonitor(this);
+  return NS_OK;
+}
+
+bool
+nsImapIncomingServer::ConnectionTimeOut(nsIImapProtocol* aConnection)
+{
+  bool retVal = false;
+  if (!aConnection) return retVal;
+  nsresult rv;
+
+  int32_t timeoutInMinutes = 0;
+  rv = GetTimeOutLimits(&timeoutInMinutes);
+  if (NS_FAILED(rv) || timeoutInMinutes <= 0 || timeoutInMinutes > 29)
+  {
+    timeoutInMinutes = 29;
+    SetTimeOutLimits(timeoutInMinutes);
+  }
+
+  PRTime cacheTimeoutLimits = timeoutInMinutes * 60 * PR_USEC_PER_SEC;
+  PRTime lastActiveTimeStamp;
+  rv = aConnection->GetLastActiveTimeStamp(&lastActiveTimeStamp);
+
+  if (PR_Now() - lastActiveTimeStamp >= cacheTimeoutLimits)
+  {
+      nsCOMPtr<nsIImapProtocol> aProtocol(do_QueryInterface(aConnection,
+                                                            &rv));
+      if (NS_SUCCEEDED(rv) && aProtocol)
+      {
+        RemoveConnection(aConnection);
+        aProtocol->TellThreadToDie(false);
+        retVal = true;
+      }
+  }
+  return retVal;
+}
+
+nsresult
+nsImapIncomingServer::GetImapConnection(nsIImapUrl * aImapUrl,
+                                        nsIImapProtocol ** aImapConnection)
+{
+  NS_ENSURE_ARG_POINTER(aImapUrl);
+
+  nsresult rv = NS_OK;
+  bool canRunUrlImmediately = false;
+  bool canRunButBusy = false;
+  nsCOMPtr<nsIImapProtocol> connection;
+  nsCOMPtr<nsIImapProtocol> freeConnection;
+  bool isBusy = false;
+  bool isInboxConnection = false;
+
+  PR_CEnterMonitor(this);
+
+  int32_t maxConnections;
+  (void)GetMaximumConnectionsNumber(&maxConnections);
+
+  int32_t cnt = m_connectionCache.Count();
+
+  *aImapConnection = nullptr;
+  // iterate through the connection cache for a connection that can handle this url.
+  bool userCancelled = false;
+
+  // loop until we find a connection that can run the url, or doesn't have to wait?
+  for (int32_t i = cnt - 1; i >= 0 && !canRunUrlImmediately && !canRunButBusy; i--)
+  {
+    connection = m_connectionCache[i];
+    if (connection)
+    {
+      bool badConnection = ConnectionTimeOut(connection);
+      if (!badConnection)
+      {
+        badConnection = NS_FAILED(connection->CanHandleUrl(aImapUrl,
+                                                           &canRunUrlImmediately,
+                                                           &canRunButBusy));
+#ifdef DEBUG_bienvenu
+        nsAutoCString curSelectedFolderName;
+        if (connection)
+          connection->GetSelectedMailboxName(getter_Copies(curSelectedFolderName));
+        // check that no other connection is in the same selected state.
+        if (!curSelectedFolderName.IsEmpty())
+        {
+          for (uint32_t j = 0; j < cnt; j++)
+          {
+            if (j != i)
+            {
+              nsCOMPtr<nsIImapProtocol> otherConnection = do_QueryElementAt(m_connectionCache, j);
+              if (otherConnection)
+              {
+                nsAutoCString otherSelectedFolderName;
+                otherConnection->GetSelectedMailboxName(getter_Copies(otherSelectedFolderName));
+                NS_ASSERTION(!curSelectedFolderName.Equals(otherSelectedFolderName), "two connections selected on same folder");
+              }
+
+            }
+          }
+        }
+#endif // DEBUG_bienvenu
+      }
+      if (badConnection)
+      {
+        connection = nullptr;
+        continue;
+      }
+    }
+
+    // if this connection is wrong, but it's not busy, check if we should designate
+    // it as the free connection.
+    if (!canRunUrlImmediately && !canRunButBusy && connection)
+    {
+        rv = connection->IsBusy(&isBusy, &isInboxConnection);
+        if (NS_FAILED(rv))
+          continue;
+        // if max connections is <= 1, we have to re-use the inbox connection.
+        if (!isBusy && (!isInboxConnection || maxConnections <= 1))
+        {
+          if (!freeConnection)
+            freeConnection = connection;
+          else  // check which is the better free connection to use.
+          {     // We prefer one not in the selected state.
+            nsAutoCString selectedFolderName;
+            connection->GetSelectedMailboxName(getter_Copies(selectedFolderName));
+            if (selectedFolderName.IsEmpty())
+              freeConnection = connection;
+          }
+        }
+    }
+    // don't leave this loop with connection set if we can't use it!
+    if (!canRunButBusy && !canRunUrlImmediately)
+      connection = nullptr;
+  }
+
+  nsImapState requiredState;
+  aImapUrl->GetRequiredImapState(&requiredState);
+  // refresh cnt in case we killed one or more dead connections. This
+  // will prevent us from not spinning up a new connection when all
+  // connections were dead.
+  cnt = m_connectionCache.Count();
+  // if we got here and we have a connection, then we should return it!
+  if (canRunUrlImmediately && connection)
+  {
+    *aImapConnection = connection;
+    NS_IF_ADDREF(*aImapConnection);
+  }
+  else if (canRunButBusy)
+  {
+    // do nothing; return NS_OK; for queuing
+  }
+  else if (userCancelled)
+  {
+    rv = NS_BINDING_ABORTED;  // user cancelled
+  }
+  // CanHandleUrl will pretend that some types of urls require a selected state url
+  // (e.g., a folder delete or msg append) but we shouldn't create new connections
+  // for these types of urls if we have a free connection. So we check the actual
+  // required state here.
+  else if (cnt < maxConnections
+      && (!freeConnection || requiredState == nsIImapUrl::nsImapSelectedState))
+    rv = CreateProtocolInstance(aImapConnection);
+  else if (freeConnection)
+  {
+    *aImapConnection = freeConnection;
+    NS_IF_ADDREF(*aImapConnection);
+  }
+  else // cannot get anyone to handle the url queue it
+  {
+    if (cnt >= maxConnections)
+      nsImapProtocol::LogImapUrl("exceeded connection cache limit", aImapUrl);
+      // caller will queue the url
+  }
+
+  PR_CExitMonitor(this);
+  return rv;
+}
+
+nsresult
+nsImapIncomingServer::CreateProtocolInstance(nsIImapProtocol ** aImapConnection)
+{
+  // create a new connection and add it to the connection cache
+  // we may need to flag the protocol connection as busy so we don't get
+  // a race condition where someone else goes through this code
+
+  int32_t authMethod;
+  GetAuthMethod(&authMethod);
+  nsresult rv;
+  // pre-flight that we have nss - on the ui thread - for MD5 etc.
+  switch (authMethod)
+  {
+    case nsMsgAuthMethod::passwordEncrypted:
+    case nsMsgAuthMethod::secure:
+    case nsMsgAuthMethod::anything:
+      {
+        nsCOMPtr<nsISupports> dummyUsedToEnsureNSSIsInitialized =
+          do_GetService("@mozilla.org/psm;1", &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      break;
+    default:
+      break;
+  }
+  nsIImapProtocol * protocolInstance;
+  rv = CallCreateInstance(kImapProtocolCID, &protocolInstance);
+  if (NS_SUCCEEDED(rv) && protocolInstance)
+  {
+    nsCOMPtr<nsIImapHostSessionList> hostSession =
+      do_GetService(kCImapHostSessionListCID, &rv);
+    if (NS_SUCCEEDED(rv))
+      rv = protocolInstance->Initialize(hostSession, this);
+  }
+
+  // take the protocol instance and add it to the connectionCache
+  if (protocolInstance)
+    m_connectionCache.AppendObject(protocolInstance);
+  *aImapConnection = protocolInstance; // this is already ref counted.
+  return rv;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::CloseConnectionForFolder(nsIMsgFolder *aMsgFolder)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIImapProtocol> connection;
+  bool isBusy = false, isInbox = false;
+  nsCString inFolderName;
+  nsCString connectionFolderName;
+  nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(aMsgFolder);
+
+  if (!imapFolder)
+    return NS_ERROR_NULL_POINTER;
+
+  int32_t cnt = m_connectionCache.Count();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  imapFolder->GetOnlineName(inFolderName);
+  PR_CEnterMonitor(this);
+
+  for (int32_t i = 0; i < cnt; ++i)
+  {
+    connection = m_connectionCache[i];
+    if (connection)
+    {
+      rv = connection->GetSelectedMailboxName(getter_Copies(connectionFolderName));
+      if (connectionFolderName.Equals(inFolderName))
+      {
+        rv = connection->IsBusy(&isBusy, &isInbox);
+        if (!isBusy)
+          rv = connection->TellThreadToDie(true);
+        break; // found it, end of the loop
+      }
+    }
+  }
+
+  PR_CExitMonitor(this);
+  return rv;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::ResetConnection(const nsACString& folderName)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIImapProtocol> connection;
+  bool isBusy = false, isInbox = false;
+  nsCString curFolderName;
+
+  int32_t cnt = m_connectionCache.Count();
+
+  PR_CEnterMonitor(this);
+
+  for (int32_t i = 0; i < cnt; ++i)
+  {
+    connection = m_connectionCache[i];
+    if (connection)
+    {
+      rv = connection->GetSelectedMailboxName(getter_Copies(curFolderName));
+      if (curFolderName.Equals(folderName))
+      {
+        rv = connection->IsBusy(&isBusy, &isInbox);
+        if (!isBusy)
+            rv = connection->ResetToAuthenticatedState();
+        break; // found it, end of the loop
+      }
+    }
+  }
+
+  PR_CExitMonitor(this);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::PerformExpand(nsIMsgWindow *aMsgWindow)
+{
+  nsCString password;
+  nsresult rv;
+  rv = GetPassword(password);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (password.IsEmpty())
+    return NS_OK;
+
+  rv = ResetFoldersToUnverified(nullptr);
+
+  nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+  rv = GetRootFolder(getter_AddRefs(rootMsgFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!rootMsgFolder) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIThread> thread(do_GetCurrentThread());
+  rv = imapService->DiscoverAllFolders(rootMsgFolder,
+                                       this, aMsgWindow, nullptr);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::VerifyLogon(nsIUrlListener *aUrlListener,
+                                  nsIMsgWindow *aMsgWindow, nsIURI **aURL)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  // this will create the resource if it doesn't exist, but it shouldn't
+  // do anything on disk.
+  rv = GetRootFolder(getter_AddRefs(rootFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return imapService->VerifyLogon(rootFolder, aUrlListener, aMsgWindow, aURL);
+}
+
+NS_IMETHODIMP nsImapIncomingServer::PerformBiff(nsIMsgWindow* aMsgWindow)
+{
+  nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+  nsresult rv = GetRootMsgFolder(getter_AddRefs(rootMsgFolder));
+  if(NS_SUCCEEDED(rv))
+  {
+    SetPerformingBiff(true);
+    rv = rootMsgFolder->GetNewMessages(aMsgWindow, nullptr);
+  }
+  return rv;
+}
+
+
+NS_IMETHODIMP
+nsImapIncomingServer::CloseCachedConnections()
+{
+  nsCOMPtr<nsIImapProtocol> connection;
+  PR_CEnterMonitor(this);
+
+  // iterate through the connection cache closing open connections.
+  int32_t cnt = m_connectionCache.Count();
+
+  for (int32_t i = cnt; i > 0; --i)
+  {
+    connection = m_connectionCache[i - 1];
+    if (connection)
+      connection->TellThreadToDie(true);
+  }
+
+  PR_CExitMonitor(this);
+  return NS_OK;
+}
+
+nsresult
+nsImapIncomingServer::CreateRootFolderFromUri(const nsCString &serverUri,
+                                              nsIMsgFolder **rootFolder)
+{
+  nsImapMailFolder *newRootFolder = new nsImapMailFolder;
+  if (!newRootFolder)
+    return NS_ERROR_OUT_OF_MEMORY;
+  newRootFolder->Init(serverUri.get());
+  NS_ADDREF(*rootFolder = newRootFolder);
+  return NS_OK;
+}
+
+// nsIImapServerSink impl
+// aNewFolder will not be set if we're listing for the subscribe UI, since that's the way 4.x worked.
+NS_IMETHODIMP nsImapIncomingServer::PossibleImapMailbox(const nsACString& folderPath,
+                                                        char hierarchyDelimiter,
+                                                        int32_t boxFlags, bool *aNewFolder)
+{
+  NS_ENSURE_ARG_POINTER(aNewFolder);
+  NS_ENSURE_TRUE(!folderPath.IsEmpty(), NS_ERROR_FAILURE);
+
+  // folderPath is in canonical format, i.e., hierarchy separator has been replaced with '/'
+  nsresult rv;
+  bool found = false;
+  bool haveParent = false;
+  nsCOMPtr<nsIMsgImapMailFolder> hostFolder;
+  nsCOMPtr<nsIMsgFolder> aFolder;
+  bool explicitlyVerify = false;
+
+  *aNewFolder = false;
+  nsCOMPtr<nsIMsgFolder> a_nsIFolder;
+  rv = GetRootFolder(getter_AddRefs(a_nsIFolder));
+
+  if(NS_FAILED(rv))
+    return rv;
+
+  nsAutoCString dupFolderPath(folderPath);
+  if (dupFolderPath.Last() == '/')
+  {
+    dupFolderPath.SetLength(dupFolderPath.Length()-1);
+    if (dupFolderPath.IsEmpty())
+      return NS_ERROR_FAILURE;
+    // *** this is what we did in 4.x in order to list uw folder only
+    // mailbox in order to get the \NoSelect flag
+    explicitlyVerify = !(boxFlags & kNameSpace);
+  }
+  if (mDoingSubscribeDialog)
+  {
+    // Make sure the imapmailfolder object has the right delimiter because the unsubscribed
+    // folders (those not in the 'lsub' list) have the delimiter set to the default ('^').
+    if (a_nsIFolder && !dupFolderPath.IsEmpty())
+    {
+      nsCOMPtr<nsIMsgFolder> msgFolder;
+      bool isNamespace = false;
+      bool noSelect = false;
+
+      rv = a_nsIFolder->FindSubFolder(dupFolderPath, getter_AddRefs(msgFolder));
+      NS_ENSURE_SUCCESS(rv,rv);
+      m_subscribeFolders.AppendObject(msgFolder);
+      noSelect = (boxFlags & kNoselect) != 0;
+      nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(msgFolder, &rv);
+      NS_ENSURE_SUCCESS(rv,rv);
+      imapFolder->SetHierarchyDelimiter(hierarchyDelimiter);
+      isNamespace = (boxFlags & kNameSpace) != 0;
+      if (!isNamespace)
+        rv = AddTo(dupFolderPath, mDoingLsub && !noSelect/* add as subscribed */,
+                   !noSelect, mDoingLsub /* change if exists */);
+      NS_ENSURE_SUCCESS(rv,rv);
+      return rv;
+    }
+  }
+
+  hostFolder = do_QueryInterface(a_nsIFolder, &rv);
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsAutoCString tempFolderName(dupFolderPath);
+  nsAutoCString tokenStr, remStr, changedStr;
+  int32_t slashPos = tempFolderName.FindChar('/');
+  if (slashPos > 0)
+  {
+    tokenStr = StringHead(tempFolderName, slashPos);
+    remStr = Substring(tempFolderName, slashPos);
+  }
+  else
+    tokenStr.Assign(tempFolderName);
+
+  if ((int32_t(PL_strcasecmp(tokenStr.get(), "INBOX"))==0) && (strcmp(tokenStr.get(), "INBOX") != 0))
+    changedStr.Append("INBOX");
+  else
+    changedStr.Append(tokenStr);
+
+  if (slashPos > 0 )
+    changedStr.Append(remStr);
+
+  dupFolderPath.Assign(changedStr);
+  nsAutoCString folderName(dupFolderPath);
+
+  nsAutoCString uri;
+  nsCString serverUri;
+  GetServerURI(serverUri);
+  uri.Assign(serverUri);
+  int32_t leafPos = folderName.RFindChar('/');
+  nsAutoCString parentName(folderName);
+  nsAutoCString parentUri(uri);
+
+  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);
+    folderName.Cut(0, leafPos + 1);	// get rid of the parent name
+    haveParent = true;
+    parentUri.Append('/');
+    parentUri.Append(parentName);
+  }
+  if (MsgLowerCaseEqualsLiteral(folderPath, "inbox") &&
+    hierarchyDelimiter == kOnlineHierarchySeparatorNil)
+  {
+    hierarchyDelimiter = '/'; // set to default in this case (as in 4.x)
+    hostFolder->SetHierarchyDelimiter(hierarchyDelimiter);
+  }
+
+  nsCOMPtr <nsIMsgFolder> child;
+
+  // nsCString possibleName(aSpec->allocatedPathName);
+  uri.Append('/');
+  uri.Append(dupFolderPath);
+  bool caseInsensitive = MsgLowerCaseEqualsLiteral(dupFolderPath, "inbox");
+  a_nsIFolder->GetChildWithURI(uri, true, caseInsensitive, getter_AddRefs(child));
+  // if we couldn't find this folder by URI, tell the imap code it's a new folder to us
+  *aNewFolder = !child;
+  if (child)
+    found = true;
+  if (!found)
+  {
+    // trying to find/discover the parent
+    if (haveParent)
+    {
+      nsCOMPtr <nsIMsgFolder> parent;
+      bool parentIsNew;
+      caseInsensitive = MsgLowerCaseEqualsLiteral(parentName, "inbox");
+      a_nsIFolder->GetChildWithURI(parentUri, true, caseInsensitive, getter_AddRefs(parent));
+      if (!parent /* || parentFolder->GetFolderNeedsAdded()*/)
+      {
+        PossibleImapMailbox(parentName, hierarchyDelimiter, kNoselect | // be defensive
+          ((boxFlags  & //only inherit certain flags from the child
+          (kPublicMailbox | kOtherUsersMailbox | kPersonalMailbox))), &parentIsNew);
+      }
+    }
+    rv = hostFolder->CreateClientSubfolderInfo(dupFolderPath, hierarchyDelimiter,boxFlags, false);
+    NS_ENSURE_SUCCESS(rv, rv);
+    caseInsensitive = MsgLowerCaseEqualsLiteral(dupFolderPath, "inbox");
+    a_nsIFolder->GetChildWithURI(uri, true, caseInsensitive, getter_AddRefs(child));
+  }
+  if (child)
+  {
+    nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(child);
+    if (imapFolder)
+    {
+      nsAutoCString onlineName;
+      nsAutoString unicodeName;
+      imapFolder->SetVerifiedAsOnlineFolder(true);
+      imapFolder->SetHierarchyDelimiter(hierarchyDelimiter);
+      if (boxFlags & kImapTrash)
+      {
+        int32_t deleteModel;
+        GetDeleteModel(&deleteModel);
+        if (deleteModel == nsMsgImapDeleteModels::MoveToTrash)
+          child->SetFlag(nsMsgFolderFlags::Trash);
+      }
+
+      imapFolder->SetBoxFlags(boxFlags);
+      imapFolder->SetExplicitlyVerify(explicitlyVerify);
+      imapFolder->GetOnlineName(onlineName);
+
+      // online name needs to use the correct hierarchy delimiter (I think...)
+      // or the canonical path - one or the other, but be consistent.
+      MsgReplaceChar(dupFolderPath, '/', hierarchyDelimiter);
+      if (hierarchyDelimiter != '/')
+        nsImapUrl::UnescapeSlashes(dupFolderPath.BeginWriting());
+
+      // GMail gives us a localized name for the inbox but doesn't let
+      // us select that localized name.
+      if (boxFlags & kImapInbox)
+        imapFolder->SetOnlineName(NS_LITERAL_CSTRING("INBOX"));
+      else if (onlineName.IsEmpty() || !onlineName.Equals(dupFolderPath))
+        imapFolder->SetOnlineName(dupFolderPath);
+
+      if (hierarchyDelimiter != '/')
+        nsImapUrl::UnescapeSlashes(folderName.BeginWriting());
+      if (NS_SUCCEEDED(CopyMUTF7toUTF16(folderName, unicodeName)))
+        child->SetPrettyName(unicodeName);
+    }
+  }
+  if (!found && child)
+    child->SetMsgDatabase(nullptr); // close the db, so we don't hold open all the .msf files for new folders
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::AddFolderRights(const nsACString& mailboxName, const nsACString& userName,
+                                                    const nsACString& rights)
+{
+  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(mailboxName, getter_AddRefs(foundFolder));
+      if (NS_SUCCEEDED(rv) && foundFolder)
+        return foundFolder->AddFolderRights(userName, rights);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::FolderNeedsACLInitialized(const nsACString& folderPath,
+                                                              bool *aNeedsACLInitialized)
+{
+  NS_ENSURE_ARG_POINTER(aNeedsACLInitialized);
+  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(folderPath, getter_AddRefs(foundFolder));
+      if (NS_SUCCEEDED(rv) && foundFolder)
+      {
+        nsCOMPtr <nsIImapMailFolderSink> folderSink = do_QueryInterface(foundFolder);
+        if (folderSink)
+          return folderSink->GetFolderNeedsACLListed(aNeedsACLInitialized);
+      }
+    }
+  }
+  *aNeedsACLInitialized = false; // maybe we want to say TRUE here...
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::RefreshFolderRights(const nsACString& folderPath)
+{
+  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(folderPath, getter_AddRefs(foundFolder));
+      if (NS_SUCCEEDED(rv) && foundFolder)
+        return foundFolder->RefreshFolderRights();
+    }
+  }
+  return rv;
+}
+
+nsresult nsImapIncomingServer::GetFolder(const nsACString& name, nsIMsgFolder** pFolder)
+{
+  NS_ENSURE_ARG_POINTER(pFolder);
+  NS_ENSURE_TRUE(!name.IsEmpty(), NS_ERROR_FAILURE);
+  nsresult rv;
+  *pFolder = nullptr;
+
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  rv = GetRootFolder(getter_AddRefs(rootFolder));
+  if (NS_SUCCEEDED(rv) && rootFolder)
+  {
+    nsCString uri;
+    rv = rootFolder->GetURI(uri);
+    if (NS_SUCCEEDED(rv) && !uri.IsEmpty())
+    {
+      nsAutoCString uriString(uri);
+      uriString.Append('/');
+      uriString.Append(name);
+      nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr<nsIRDFResource> res;
+      rv = rdf->GetResource(uriString, getter_AddRefs(res));
+      if (NS_SUCCEEDED(rv))
+      {
+        nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(res, &rv));
+        if (NS_SUCCEEDED(rv) && folder)
+          folder.swap(*pFolder);
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP  nsImapIncomingServer::OnlineFolderDelete(const nsACString& aFolderName)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP  nsImapIncomingServer::OnlineFolderCreateFailed(const nsACString& aFolderName)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::OnlineFolderRename(nsIMsgWindow *msgWindow, const nsACString& oldName,
+                                                       const nsACString& newName)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+  if (!newName.IsEmpty())
+  {
+    nsCOMPtr<nsIMsgFolder> me;
+    rv = GetFolder(oldName, getter_AddRefs(me));
+    if (NS_FAILED(rv))
+      return rv;
+
+    nsCOMPtr<nsIMsgFolder> parent;
+    nsCString tmpNewName (newName);
+    int32_t folderStart = tmpNewName.RFindChar('/');
+    if (folderStart > 0)
+    {
+      rv = GetFolder(StringHead(tmpNewName, folderStart), getter_AddRefs(parent));
+    }
+    else  // root is the parent
+      rv = GetRootFolder(getter_AddRefs(parent));
+    if (NS_SUCCEEDED(rv) && parent)
+    {
+      nsCOMPtr<nsIMsgImapMailFolder> folder;
+      folder = do_QueryInterface(me, &rv);
+      if (NS_SUCCEEDED(rv))
+      {
+        folder->RenameLocal(tmpNewName, parent);
+        nsCOMPtr<nsIMsgImapMailFolder> parentImapFolder = do_QueryInterface(parent);
+
+        if (parentImapFolder)
+          parentImapFolder->RenameClient(msgWindow, me, oldName, tmpNewName);
+
+        nsCOMPtr <nsIMsgFolder> newFolder;
+        nsString unicodeNewName;
+        // tmpNewName is imap mod utf7. It needs to be convert to utf8.
+        CopyMUTF7toUTF16(tmpNewName, unicodeNewName);
+        CopyUTF16toUTF8(unicodeNewName, tmpNewName);
+        rv = GetFolder(tmpNewName, getter_AddRefs(newFolder));
+        if (NS_SUCCEEDED(rv))
+        {
+          nsCOMPtr <nsIAtom> folderRenameAtom;
+          folderRenameAtom = MsgGetAtom("RenameCompleted");
+          newFolder->NotifyFolderEvent(folderRenameAtom);
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP  nsImapIncomingServer::FolderIsNoSelect(const nsACString& aFolderName, bool *result)
+{
+  NS_ENSURE_ARG_POINTER(result);
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  nsresult rv = GetFolder(aFolderName, getter_AddRefs(msgFolder));
+  if (NS_SUCCEEDED(rv) && msgFolder)
+  {
+    uint32_t flags;
+    msgFolder->GetFlags(&flags);
+    *result = ((flags & nsMsgFolderFlags::ImapNoselect) != 0);
+  }
+  else
+   *result = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::SetFolderAdminURL(const nsACString& aFolderName, const nsACString& aFolderAdminUrl)
+{
+  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(aFolderName, getter_AddRefs(foundFolder));
+      if (NS_SUCCEEDED(rv) && foundFolder)
+        return foundFolder->SetAdminUrl(aFolderAdminUrl);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP  nsImapIncomingServer::FolderVerifiedOnline(const nsACString& folderName, bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = false;
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
+  if (NS_SUCCEEDED(rv) && rootFolder)
+  {
+    nsCOMPtr<nsIMsgFolder> folder;
+    rv = rootFolder->FindSubFolder(folderName, getter_AddRefs(folder));
+    if (NS_SUCCEEDED(rv) && folder)
+    {
+      nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(folder);
+      if (imapFolder)
+        imapFolder->GetVerifiedAsOnlineFolder(aResult);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::DiscoveryDone()
+{
+  if (mDoingSubscribeDialog)
+    return NS_OK;
+
+  nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+  nsresult rv = GetRootFolder(getter_AddRefs(rootMsgFolder));
+  if (NS_SUCCEEDED(rv) && rootMsgFolder)
+  {
+    // GetResource() may return a node which is not in the folder
+    // tree hierarchy but in the rdf cache in case of the non-existing default
+    // Sent, Drafts, and Templates folders. The resouce will be eventually
+    // released when the rdf service shuts down. When we create the default
+    // folders later on in the imap server, the subsequent GetResource() of the
+    // same uri will get us the cached rdf resource which should have the folder
+    // flag set appropriately.
+    nsCOMPtr<nsIRDFService> rdf(do_GetService("@mozilla.org/rdf/rdf-service;1",
+                                              &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgAccountManager> accountMgr = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIMsgIdentity> identity;
+    rv = accountMgr->GetFirstIdentityForServer(this, getter_AddRefs(identity));
+    if (NS_SUCCEEDED(rv) && identity)
+    {
+      nsCString folderUri;
+      identity->GetFccFolder(folderUri);
+      nsCString existingUri;
+
+      if (CheckSpecialFolder(rdf, folderUri, nsMsgFolderFlags::SentMail,
+                             existingUri))
+      {
+        identity->SetFccFolder(existingUri);
+        identity->SetFccFolderPickerMode(NS_LITERAL_CSTRING("1"));
+      }
+      identity->GetDraftFolder(folderUri);
+      if (CheckSpecialFolder(rdf, folderUri, nsMsgFolderFlags::Drafts,
+                             existingUri))
+      {
+        identity->SetDraftFolder(existingUri);
+        identity->SetDraftsFolderPickerMode(NS_LITERAL_CSTRING("1"));
+      }
+      bool archiveEnabled;
+      identity->GetArchiveEnabled(&archiveEnabled);
+      if (archiveEnabled)
+      {
+        identity->GetArchiveFolder(folderUri);
+        if (CheckSpecialFolder(rdf, folderUri, nsMsgFolderFlags::Archive,
+                               existingUri))
+        {
+          identity->SetArchiveFolder(existingUri);
+          identity->SetArchivesFolderPickerMode(NS_LITERAL_CSTRING("1"));
+        }
+      }
+      identity->GetStationeryFolder(folderUri);
+      nsCOMPtr<nsIRDFResource> res;
+      if (!folderUri.IsEmpty() && NS_SUCCEEDED(rdf->GetResource(folderUri, getter_AddRefs(res))))
+      {
+        nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(res, &rv));
+        if (NS_SUCCEEDED(rv))
+          rv = folder->SetFlag(nsMsgFolderFlags::Templates);
+      }
+    }
+
+    nsCOMPtr<nsISpamSettings> spamSettings;
+    rv = GetSpamSettings(getter_AddRefs(spamSettings));
+    if (NS_SUCCEEDED(rv) && spamSettings)
+    {
+      nsCString spamFolderUri, existingUri;
+      spamSettings->GetSpamFolderURI(getter_Copies(spamFolderUri));
+      if (CheckSpecialFolder(rdf, spamFolderUri, nsMsgFolderFlags::Junk,
+                             existingUri))
+      {
+        // This only sets the cached values in the spam settings object.
+        spamSettings->SetActionTargetFolder(existingUri.get());
+        spamSettings->SetMoveTargetMode(nsISpamSettings::MOVE_TARGET_MODE_FOLDER);
+        // Set the preferences too so that the values persist.
+        SetCharValue("spamActionTargetFolder", existingUri);
+        SetIntValue("moveTargetMode", nsISpamSettings::MOVE_TARGET_MODE_FOLDER);
+      }
+    }
+
+    bool isGMailServer;
+    GetIsGMailServer(&isGMailServer);
+
+    // Verify there is only one trash folder. Another might be present if
+    // the trash name has been changed. Or we might be a gmail server and
+    // want to switch to gmail's trash folder.
+    nsCOMPtr<nsIArray> trashFolders;
+    rv = rootMsgFolder->GetFoldersWithFlags(nsMsgFolderFlags::Trash,
+                                            getter_AddRefs(trashFolders));
+
+    if (NS_SUCCEEDED(rv) && trashFolders)
+    {
+      uint32_t numFolders;
+      trashFolders->GetLength(&numFolders);
+      nsAutoString trashName;
+      if (NS_SUCCEEDED(GetTrashFolderName(trashName)))
+      {
+        for (uint32_t i = 0; i < numFolders; i++)
+        {
+          nsCOMPtr<nsIMsgFolder> trashFolder(do_QueryElementAt(trashFolders, i));
+          if (trashFolder)
+          {
+            // If we're a gmail server, we clear the trash flags from folder(s)
+            // without the kImapXListTrash flag. For normal servers, we clear
+            // the trash folder flag if the folder name doesn't match the
+            // pref trash folder name.
+            if (isGMailServer)
+            {
+              nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(trashFolder));
+              int32_t boxFlags;
+              imapFolder->GetBoxFlags(&boxFlags);
+              if (boxFlags & kImapXListTrash)
+              {
+                continue;
+              }
+            }
+            else
+            {
+              // trashName is the leaf name on the folder URI, which will be
+              // different from the folder GetName if the trash name is
+              // localized.
+              nsAutoCString trashURL;
+              trashFolder->GetFolderURL(trashURL);
+              int32_t leafPos = trashURL.RFindChar('/');
+              nsAutoCString unescapedName;
+              MsgUnescapeString(Substring(trashURL, leafPos + 1),
+                                nsINetUtil::ESCAPE_URL_PATH, unescapedName);
+              nsAutoString nameUnicode;
+              if (NS_FAILED(CopyMUTF7toUTF16(unescapedName, nameUnicode)) ||
+                  trashName.Equals(nameUnicode))
+              {
+                continue;
+              }
+              if (numFolders == 1)
+              {
+                // We got here because the preferred trash folder does not
+                // exist, but a folder got discovered to be the trash folder.
+                SetUnicharValue(PREF_TRASH_FOLDER_NAME, nameUnicode);
+                continue;
+              }
+            }
+            trashFolder->ClearFlag(nsMsgFolderFlags::Trash);
+          }
+        }
+      }
+    }
+  }
+
+  bool usingSubscription = true;
+  GetUsingSubscription(&usingSubscription);
+
+  nsCOMArray<nsIMsgImapMailFolder> unverifiedFolders;
+  GetUnverifiedFolders(unverifiedFolders);
+
+  int32_t count = unverifiedFolders.Count();
+  for (int32_t k = 0; k < count; ++k)
+  {
+    bool explicitlyVerify = false;
+    bool hasSubFolders = false;
+    uint32_t folderFlags;
+    nsCOMPtr<nsIMsgImapMailFolder> currentImapFolder(unverifiedFolders[k]);
+    nsCOMPtr<nsIMsgFolder> currentFolder(do_QueryInterface(currentImapFolder, &rv));
+    if (NS_FAILED(rv))
+      continue;
+
+    currentFolder->GetFlags(&folderFlags);
+    if (folderFlags & nsMsgFolderFlags::Virtual) // don't remove virtual folders
+      continue;
+
+    if ((!usingSubscription ||
+         (NS_SUCCEEDED(currentImapFolder->GetExplicitlyVerify(&explicitlyVerify)) &&
+          explicitlyVerify)) ||
+        ((NS_SUCCEEDED(currentFolder->GetHasSubFolders(&hasSubFolders)) &&
+          hasSubFolders) &&
+         !NoDescendentsAreVerified(currentFolder)))
+    {
+      bool isNamespace;
+      currentImapFolder->GetIsNamespace(&isNamespace);
+      if (!isNamespace) // don't list namespaces explicitly
+      {
+        // If there are no subfolders and this is unverified, we don't want to
+        // run this url. That is, we want to undiscover the folder.
+        // If there are subfolders and no descendants are verified, we want to
+        // undiscover all of the folders.
+        // Only if there are subfolders and at least one of them is verified
+        // do we want to refresh that folder's flags, because it won't be going
+        // away.
+        currentImapFolder->SetExplicitlyVerify(false);
+        currentImapFolder->List();
+      }
+    }
+    else
+      DeleteNonVerifiedFolders(currentFolder);
+  }
+
+  return rv;
+}
+
+// Check if the special folder corresponding to the uri exists. If not, check
+// if there already exists a folder with the special folder flag (the server may
+// have told us about a folder to use through XLIST). If so, return the uri of
+// the existing special folder. If not, set the special flag on the folder so
+// it will be there if and when the folder is created.
+// Return true if we found an existing special folder different than
+// the one specified in prefs, and the one specified by prefs doesn't exist.
+bool nsImapIncomingServer::CheckSpecialFolder(nsIRDFService *rdf,
+                                                nsCString &folderUri,
+                                                uint32_t folderFlag,
+                                                nsCString &existingUri)
+{
+  nsCOMPtr<nsIRDFResource> res;
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+  nsresult rv = GetRootFolder(getter_AddRefs(rootMsgFolder));
+  NS_ENSURE_SUCCESS(rv, false);
+  nsCOMPtr<nsIMsgFolder> existingFolder;
+  rootMsgFolder->GetFolderWithFlags(folderFlag, getter_AddRefs(existingFolder));
+
+  if (!folderUri.IsEmpty() && NS_SUCCEEDED(rdf->GetResource(folderUri, getter_AddRefs(res))))
+  {
+    folder = do_QueryInterface(res, &rv);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIMsgFolder> parent;
+      folder->GetParent(getter_AddRefs(parent));
+      if (parent)
+      {
+        existingFolder = nullptr;
+      }
+      if (!existingFolder)
+      {
+        folder->SetFlag(folderFlag);
+      }
+
+      nsString folderName;
+      folder->GetPrettyName(folderName);
+      // this will set the localized name based on the folder flag.
+      folder->SetPrettyName(folderName);
+    }
+  }
+
+  if (existingFolder)
+  {
+    existingFolder->GetURI(existingUri);
+    return true;
+  }
+
+  return false;
+}
+
+nsresult nsImapIncomingServer::DeleteNonVerifiedFolders(nsIMsgFolder *curFolder)
+{
+  bool autoUnsubscribeFromNoSelectFolders = true;
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv))
+    prefBranch->GetBoolPref("mail.imap.auto_unsubscribe_from_noselect_folders", &autoUnsubscribeFromNoSelectFolders);
+
+  nsCOMPtr<nsISimpleEnumerator> subFolders;
+
+  rv = curFolder->GetSubFolders(getter_AddRefs(subFolders));
+  if(NS_SUCCEEDED(rv))
+  {
+    bool moreFolders;
+
+    while (NS_SUCCEEDED(subFolders->HasMoreElements(&moreFolders)) && moreFolders)
+    {
+      nsCOMPtr<nsISupports> child;
+      rv = subFolders->GetNext(getter_AddRefs(child));
+      if (NS_SUCCEEDED(rv) && child)
+      {
+        bool childVerified = false;
+        nsCOMPtr <nsIMsgImapMailFolder> childImapFolder = do_QueryInterface(child, &rv);
+        if (NS_SUCCEEDED(rv) && childImapFolder)
+        {
+          uint32_t flags;
+
+          nsCOMPtr <nsIMsgFolder> childFolder = do_QueryInterface(child, &rv);
+          rv = childImapFolder->GetVerifiedAsOnlineFolder(&childVerified);
+
+          rv = childFolder->GetFlags(&flags);
+          bool folderIsNoSelectFolder = NS_SUCCEEDED(rv) && ((flags & nsMsgFolderFlags::ImapNoselect) != 0);
+
+          bool usingSubscription = true;
+          GetUsingSubscription(&usingSubscription);
+          if (usingSubscription)
+          {
+            bool folderIsNameSpace = false;
+            bool noDescendentsAreVerified = NoDescendentsAreVerified(childFolder);
+            bool shouldDieBecauseNoSelect = (folderIsNoSelectFolder ?
+              ((noDescendentsAreVerified || AllDescendentsAreNoSelect(childFolder)) && !folderIsNameSpace)
+              : false);
+            if (!childVerified && (noDescendentsAreVerified || shouldDieBecauseNoSelect))
+            {
+            }
+          }
+          else
+          {
+          }
+        }
+      }
+    }
+  }
+
+  nsCOMPtr<nsIMsgFolder> parent;
+  rv = curFolder->GetParent(getter_AddRefs(parent));
+
+  if (NS_SUCCEEDED(rv) && parent)
+  {
+    nsCOMPtr<nsIMsgImapMailFolder> imapParent = do_QueryInterface(parent);
+    if (imapParent)
+      imapParent->RemoveSubFolder(curFolder);
+  }
+
+  return rv;
+}
+
+bool nsImapIncomingServer::NoDescendentsAreVerified(nsIMsgFolder *parentFolder)
+{
+  bool nobodyIsVerified = true;
+  nsCOMPtr<nsISimpleEnumerator> subFolders;
+  nsresult rv = parentFolder->GetSubFolders(getter_AddRefs(subFolders));
+  if(NS_SUCCEEDED(rv))
+  {
+    bool moreFolders;
+    while (NS_SUCCEEDED(subFolders->HasMoreElements(&moreFolders)) &&
+           moreFolders && nobodyIsVerified)
+    {
+      nsCOMPtr<nsISupports> child;
+      rv = subFolders->GetNext(getter_AddRefs(child));
+      if (NS_SUCCEEDED(rv) && child)
+      {
+        bool childVerified = false;
+        nsCOMPtr <nsIMsgImapMailFolder> childImapFolder = do_QueryInterface(child, &rv);
+        if (NS_SUCCEEDED(rv) && childImapFolder)
+        {
+          nsCOMPtr <nsIMsgFolder> childFolder = do_QueryInterface(child, &rv);
+          rv = childImapFolder->GetVerifiedAsOnlineFolder(&childVerified);
+          nobodyIsVerified = !childVerified && NoDescendentsAreVerified(childFolder);
+        }
+      }
+    }
+  }
+  return nobodyIsVerified;
+}
+
+
+bool nsImapIncomingServer::AllDescendentsAreNoSelect(nsIMsgFolder *parentFolder)
+{
+  bool allDescendentsAreNoSelect = true;
+  nsCOMPtr<nsISimpleEnumerator> subFolders;
+  nsresult rv = parentFolder->GetSubFolders(getter_AddRefs(subFolders));
+  if(NS_SUCCEEDED(rv))
+  {
+    bool moreFolders;
+    while (NS_SUCCEEDED(subFolders->HasMoreElements(&moreFolders)) &&
+           moreFolders && allDescendentsAreNoSelect)
+    {
+      nsCOMPtr<nsISupports> child;
+      rv = subFolders->GetNext(getter_AddRefs(child));
+      if (NS_SUCCEEDED(rv) && child)
+      {
+        bool childIsNoSelect = false;
+        nsCOMPtr <nsIMsgImapMailFolder> childImapFolder = do_QueryInterface(child, &rv);
+        if (NS_SUCCEEDED(rv) && childImapFolder)
+        {
+          uint32_t flags;
+          nsCOMPtr <nsIMsgFolder> childFolder = do_QueryInterface(child, &rv);
+          rv = childFolder->GetFlags(&flags);
+          childIsNoSelect = NS_SUCCEEDED(rv) && (flags & nsMsgFolderFlags::ImapNoselect);
+          allDescendentsAreNoSelect = !childIsNoSelect && AllDescendentsAreNoSelect(childFolder);
+        }
+      }
+    }
+  }
+#if 0
+  int numberOfSubfolders = parentFolder->GetNumSubFolders();
+
+  for (int childIndex=0; allDescendantsAreNoSelect && (childIndex < numberOfSubfolders); childIndex++)
+  {
+    MSG_IMAPFolderInfoMail *currentChild = (MSG_IMAPFolderInfoMail *) parentFolder->GetSubFolder(childIndex);
+    allDescendentsAreNoSelect = (currentChild->GetFolderPrefFlags() & MSG_FOLDER_PREF_IMAPNOSELECT) &&
+      AllDescendentsAreNoSelect(currentChild);
+  }
+#endif // 0
+  return allDescendentsAreNoSelect;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::PromptLoginFailed(nsIMsgWindow *aMsgWindow,
+                                        int32_t *aResult)
+{
+  nsAutoCString hostName;
+  GetRealHostName(hostName);
+
+  return MsgPromptLoginFailed(aMsgWindow, hostName, aResult);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::FEAlert(const nsAString& aAlertString,
+                              nsIMsgMailNewsUrl *aUrl)
+{
+  GetStringBundle();
+
+  if (m_stringBundle)
+  {
+    nsAutoString hostName;
+    nsresult rv = GetPrettyName(hostName);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsString message;
+      nsString tempString(aAlertString);
+      const char16_t *params[] = { hostName.get(), tempString.get() };
+
+      rv = m_stringBundle->FormatStringFromName(
+        u"imapServerAlert",
+        params, 2, getter_Copies(message));
+      if (NS_SUCCEEDED(rv))
+        return AlertUser(message, aUrl);
+    }
+  }
+  return AlertUser(aAlertString, aUrl);
+}
+
+nsresult nsImapIncomingServer::AlertUser(const nsAString& aString,
+                                         nsIMsgMailNewsUrl *aUrl)
+{
+  nsresult rv;
+  nsCOMPtr <nsIMsgMailSession> mailSession =
+    do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return mailSession->AlertUser(aString, aUrl);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::FEAlertWithName(const char* aMsgName, nsIMsgMailNewsUrl *aUrl)
+{
+  // don't bother the user if we're shutting down.
+  if (m_shuttingDown)
+    return NS_OK;
+
+  GetStringBundle();
+
+  nsString message;
+
+  if (m_stringBundle)
+  {
+    nsAutoCString hostName;
+    nsresult rv = GetHostName(hostName);
+    if (NS_SUCCEEDED(rv))
+    {
+      const NS_ConvertUTF8toUTF16 hostName16(hostName);
+      const char16_t *params[] = { hostName16.get() };
+      rv = m_stringBundle->FormatStringFromName(
+        NS_ConvertASCIItoUTF16(aMsgName).get(),
+        params, 1,getter_Copies(message));
+      if (NS_SUCCEEDED(rv))
+        return AlertUser(message, aUrl);
+    }
+  }
+
+  // Error condition
+  message.AssignLiteral("String Name ");
+  message.AppendASCII(aMsgName);
+  FEAlert(message, aUrl);
+  return NS_OK;
+}
+
+NS_IMETHODIMP  nsImapIncomingServer::FEAlertFromServer(const nsACString& aServerString,
+                                                       nsIMsgMailNewsUrl *aUrl)
+{
+  NS_ENSURE_TRUE(!aServerString.IsEmpty(), NS_OK);
+
+  nsCString message(aServerString);
+  message.Trim(" \t\b\r\n");
+  if (message.Last() != '.')
+    message.Append('.');
+
+  // Skip over the first two words (the command tag and "NO").
+  // Find the first word break.
+  int32_t pos = message.FindChar(' ');
+
+  // Find the second word break.
+  if (pos != -1)
+    pos = message.FindChar(' ', pos + 1);
+
+  // Adjust the message.
+  if (pos != -1)
+    message = Substring(message, pos + 1);
+
+  nsString hostName;
+  GetPrettyName(hostName);
+
+  const char16_t *formatStrings[] =
+  {
+    hostName.get(),
+    nullptr,
+    nullptr
+  };
+
+  nsString msgName;
+  int32_t numStrings;
+  nsString fullMessage;
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(aUrl);
+  NS_ENSURE_TRUE(imapUrl, NS_ERROR_INVALID_ARG);
+
+  nsImapState imapState;
+  nsImapAction imapAction;
+
+  imapUrl->GetRequiredImapState(&imapState);
+  imapUrl->GetImapAction(&imapAction);
+  nsString folderName;
+
+  NS_ConvertUTF8toUTF16 unicodeMsg(message);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  if (imapState == nsIImapUrl::nsImapSelectedState ||
+      imapAction == nsIImapUrl::nsImapFolderStatus)
+  {
+    aUrl->GetFolder(getter_AddRefs(folder));
+    if (folder)
+      folder->GetPrettyName(folderName);
+    numStrings = 3;
+    msgName.AssignLiteral("imapFolderCommandFailed");
+    formatStrings[1] = folderName.get();
+  }
+  else
+  {
+    msgName.AssignLiteral("imapServerCommandFailed");
+    numStrings = 2;
+  }
+
+  formatStrings[numStrings -1] = unicodeMsg.get();
+
+  nsresult rv = GetStringBundle();
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (m_stringBundle)
+  {
+    rv = m_stringBundle->FormatStringFromName(msgName.get(),
+      formatStrings, numStrings, getter_Copies(fullMessage));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return AlertUser(fullMessage, aUrl);
+}
+
+#define IMAP_MSGS_URL       "chrome://messenger/locale/imapMsgs.properties"
+
+nsresult nsImapIncomingServer::GetStringBundle()
+{
+  if (m_stringBundle)
+    return NS_OK;
+
+  nsCOMPtr<nsIStringBundleService> sBundleService =
+    mozilla::services::GetStringBundleService();
+  NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED);
+  return sBundleService->CreateBundle(IMAP_MSGS_URL, getter_AddRefs(m_stringBundle));
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetImapStringByName(const char* msgName, nsAString& aString)
+{
+  nsresult rv = NS_OK;
+  GetStringBundle();
+  if (m_stringBundle)
+  {
+    nsString res_str;
+    rv = m_stringBundle->GetStringFromName(
+       NS_ConvertASCIItoUTF16(msgName).get(),
+       getter_Copies(res_str));
+    aString.Assign(res_str);
+    if (NS_SUCCEEDED(rv))
+      return rv;
+  }
+  aString.AssignLiteral("String Name ");
+  // mscott: FIX ME
+  aString.AppendASCII(msgName);
+  return NS_OK;
+}
+
+nsresult nsImapIncomingServer::ResetFoldersToUnverified(nsIMsgFolder *parentFolder)
+{
+  nsresult rv = NS_OK;
+  if (!parentFolder)
+  {
+    nsCOMPtr<nsIMsgFolder> rootFolder;
+    rv = GetRootFolder(getter_AddRefs(rootFolder));
+    NS_ENSURE_SUCCESS(rv, rv);
+    return ResetFoldersToUnverified(rootFolder);
+  }
+  else
+  {
+    nsCOMPtr<nsISimpleEnumerator> subFolders;
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(parentFolder, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = imapFolder->SetVerifiedAsOnlineFolder(false);
+    rv = parentFolder->GetSubFolders(getter_AddRefs(subFolders));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    bool moreFolders = false;
+    while (NS_SUCCEEDED(subFolders->HasMoreElements(&moreFolders)) && moreFolders)
+    {
+      nsCOMPtr<nsISupports> child;
+      rv = subFolders->GetNext(getter_AddRefs(child));
+      if (NS_SUCCEEDED(rv) && child)
+      {
+        nsCOMPtr<nsIMsgFolder> childFolder = do_QueryInterface(child, &rv);
+        if (NS_SUCCEEDED(rv) && childFolder)
+        {
+          rv = ResetFoldersToUnverified(childFolder);
+          if (NS_FAILED(rv))
+            break;
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+void
+nsImapIncomingServer::GetUnverifiedFolders(nsCOMArray<nsIMsgImapMailFolder> &aFoldersArray)
+{
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  if (NS_FAILED(GetRootFolder(getter_AddRefs(rootFolder))) || !rootFolder)
+    return;
+
+  nsCOMPtr<nsIMsgImapMailFolder> imapRoot(do_QueryInterface(rootFolder));
+  // don't need to verify the root.
+  if (imapRoot)
+    imapRoot->SetVerifiedAsOnlineFolder(true);
+
+  GetUnverifiedSubFolders(rootFolder, aFoldersArray);
+}
+
+void
+nsImapIncomingServer::GetUnverifiedSubFolders(nsIMsgFolder *parentFolder,
+                                              nsCOMArray<nsIMsgImapMailFolder> &aFoldersArray)
+{
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(parentFolder));
+
+  bool verified = false, explicitlyVerify = false;
+  if (imapFolder)
+  {
+    nsresult rv = imapFolder->GetVerifiedAsOnlineFolder(&verified);
+    if (NS_SUCCEEDED(rv))
+      rv = imapFolder->GetExplicitlyVerify(&explicitlyVerify);
+
+    if (NS_SUCCEEDED(rv) && (!verified || explicitlyVerify))
+      aFoldersArray.AppendObject(imapFolder);
+  }
+
+  nsCOMPtr<nsISimpleEnumerator> subFolders;
+  if (NS_SUCCEEDED(parentFolder->GetSubFolders(getter_AddRefs(subFolders))))
+  {
+    bool moreFolders;
+
+    while (NS_SUCCEEDED(subFolders->HasMoreElements(&moreFolders)) && moreFolders)
+    {
+      nsCOMPtr<nsISupports> child;
+      subFolders->GetNext(getter_AddRefs(child));
+      if (child)
+      {
+        nsCOMPtr<nsIMsgFolder> childFolder(do_QueryInterface(child));
+        if (childFolder)
+          GetUnverifiedSubFolders(childFolder, aFoldersArray);
+      }
+    }
+  }
+}
+
+NS_IMETHODIMP nsImapIncomingServer::ForgetSessionPassword()
+{
+  nsresult rv = nsMsgIncomingServer::ForgetSessionPassword();
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // fix for bugscape bug #15485
+  // if we use turbo, and we logout, we need to make sure
+  // the server doesn't think it's authenticated.
+  // the biff timer continues to fire when you use turbo
+  // (see #143848).  if we exited, we've set the password to null
+  // but if we're authenticated, and the biff timer goes off
+  // we'll still perform biff, because we use m_userAuthenticated
+  // to determine if we require a password for biff.
+  // (if authenticated, we don't require a password
+  // see nsMsgBiffManager::PerformBiff())
+  // performing biff without a password will pop up the prompt dialog
+  // which is pretty wacky, when it happens after you quit the application
+  m_userAuthenticated = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::GetServerRequiresPasswordForBiff(bool *aServerRequiresPasswordForBiff)
+{
+  NS_ENSURE_ARG_POINTER(aServerRequiresPasswordForBiff);
+  // if the user has already been authenticated, we've got the password
+  *aServerRequiresPasswordForBiff = !m_userAuthenticated;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::ForgetPassword()
+{
+  return nsMsgIncomingServer::ForgetPassword();
+}
+
+
+NS_IMETHODIMP
+nsImapIncomingServer::AsyncGetPassword(nsIImapProtocol *aProtocol,
+                                       bool aNewPasswordRequested,
+                                       nsACString &aPassword)
+{
+  if (m_password.IsEmpty())
+  {
+    // We're now going to need to do something that will end up with us either
+    // poking login manager or prompting the user. We need to ensure we only
+    // do one prompt at a time (and login manager could cause a master password
+    // prompt), so we need to use the async prompter.
+    nsresult rv;
+    nsCOMPtr<nsIMsgAsyncPrompter> asyncPrompter =
+      do_GetService(NS_MSGASYNCPROMPTER_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIMsgAsyncPromptListener> promptListener(do_QueryInterface(aProtocol));
+    rv = asyncPrompter->QueueAsyncAuthPrompt(m_serverKey, aNewPasswordRequested,
+                                             promptListener);
+    // Explict NS_ENSURE_SUCCESS for debug purposes as errors tend to get
+    // hidden.
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  if (!m_password.IsEmpty())
+    aPassword = m_password;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::PromptPassword(nsIMsgWindow *aMsgWindow,
+                                     nsACString &aPassword)
+{
+  nsString passwordTitle;
+  GetImapStringByName("imapEnterPasswordPromptTitle", passwordTitle);
+  NS_ENSURE_STATE(m_stringBundle);
+
+  nsAutoCString userName;
+  GetRealUsername(userName);
+
+  nsAutoCString hostName;
+  GetRealHostName(hostName);
+
+  nsresult rv = GetStringBundle();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ConvertASCIItoUTF16 finalUserName(userName);
+  NS_ConvertASCIItoUTF16 finalHostName(hostName);
+
+  const char16_t *formatStrings[] = { finalUserName.get(), finalHostName.get() };
+
+  nsString passwordText;
+  rv = m_stringBundle->FormatStringFromName(
+    u"imapEnterServerPasswordPrompt",
+    formatStrings, 2, getter_Copies(passwordText));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = GetPasswordWithUI(passwordText, passwordTitle, aMsgWindow, aPassword);
+  if (NS_SUCCEEDED(rv))
+    m_password = aPassword;
+  return rv;
+}
+
+// for the nsIImapServerSink interface
+NS_IMETHODIMP nsImapIncomingServer::SetCapability(eIMAPCapabilityFlags capability)
+{
+  m_capability = capability;
+  SetIsGMailServer((capability & kGmailImapCapability) != 0);
+  SetCapabilityACL(capability & kACLCapability);
+  SetCapabilityQuota(capability & kQuotaCapability);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::SetServerID(const nsACString &aServerID)
+{
+  return SetServerIDPref(aServerID);
+}
+
+NS_IMETHODIMP  nsImapIncomingServer::CommitNamespaces()
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapHostSessionList> hostSession = do_GetService(kCImapHostSessionListCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return hostSession->CommitNamespacesForHost(this);
+}
+
+NS_IMETHODIMP nsImapIncomingServer::PseudoInterruptMsgLoad(nsIMsgFolder *aImapFolder, nsIMsgWindow *aMsgWindow,
+                                                          bool *interrupted)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIImapProtocol> connection;
+  PR_CEnterMonitor(this);
+  // iterate through the connection cache for a connection that is loading
+  // a message in this folder and should be pseudo-interrupted.
+  int32_t cnt = m_connectionCache.Count();
+
+  for (int32_t i = 0; i < cnt; ++i)
+  {
+    connection = m_connectionCache[i];
+    if (connection)
+      rv = connection->PseudoInterruptMsgLoad(aImapFolder, aMsgWindow, interrupted);
+  }
+
+  PR_CExitMonitor(this);
+  return rv;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::ResetNamespaceReferences()
+{
+  nsCOMPtr <nsIMsgFolder> rootFolder;
+  nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
+  if (NS_SUCCEEDED(rv) && rootFolder)
+  {
+    nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(rootFolder);
+    if (imapFolder)
+      rv = imapFolder->ResetNamespaceReferences();
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::SetUserAuthenticated(bool aUserAuthenticated)
+{
+  m_userAuthenticated = aUserAuthenticated;
+  if (aUserAuthenticated)
+  {
+    nsresult rv;
+    nsCOMPtr<nsIMsgAccountManager> accountManager =
+      do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    accountManager->SetUserNeedsToAuthenticate(false);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::GetUserAuthenticated(bool *aUserAuthenticated)
+{
+  NS_ENSURE_ARG_POINTER(aUserAuthenticated);
+  *aUserAuthenticated = m_userAuthenticated;
+  return NS_OK;
+}
+
+/* void SetMailServerUrls (in string manageMailAccount, in string manageLists, in string manageFilters); */
+NS_IMETHODIMP  nsImapIncomingServer::SetMailServerUrls(const nsACString& manageMailAccount, const nsACString& manageLists,
+                                                       const nsACString& manageFilters)
+{
+  return SetManageMailAccountUrl(manageMailAccount);
+}
+
+NS_IMETHODIMP nsImapIncomingServer::SetManageMailAccountUrl(const nsACString& manageMailAccountUrl)
+{
+  m_manageMailAccountUrl = manageMailAccountUrl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::GetManageMailAccountUrl(nsACString& manageMailAccountUrl)
+{
+  manageMailAccountUrl = m_manageMailAccountUrl;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::StartPopulatingWithUri(nsIMsgWindow *aMsgWindow, bool aForceToServer /*ignored*/, const char *uri)
+{
+  NS_ENSURE_ARG_POINTER (uri);
+
+  nsresult rv;
+  mDoingSubscribeDialog = true;
+
+  rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  rv = mInner->StartPopulatingWithUri(aMsgWindow, aForceToServer, uri);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // imap always uses the canonical delimiter form of paths for subscribe ui.
+  rv = SetDelimiter('/');
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = SetShowFullName(false);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCString serverUri;
+  rv = GetServerURI(serverUri);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+/*
+    if uri = imap://user@host/foo/bar, the serverUri is imap://user@host
+    to get path from uri, skip over imap://user@host + 1 (for the /)
+*/
+  const char *path = uri + serverUri.Length() + 1;
+  return imapService->GetListOfFoldersWithPath(this, aMsgWindow, nsDependentCString(path));
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::StartPopulating(nsIMsgWindow *aMsgWindow, bool aForceToServer /*ignored*/, bool aGetOnlyNew)
+{
+  nsresult rv;
+  mDoingSubscribeDialog = true;
+
+  rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  rv = mInner->StartPopulating(aMsgWindow, aForceToServer, aGetOnlyNew);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // imap always uses the canonical delimiter form of paths for subscribe ui.
+  rv = SetDelimiter('/');
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  rv = SetShowFullName(false);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return imapService->GetListOfFoldersOnServer(this, aMsgWindow);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::OnStartRunningUrl(nsIURI *url)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::OnStopRunningUrl(nsIURI *url, nsresult exitCode)
+{
+  nsresult rv = exitCode;
+
+  // xxx todo get msgWindow from url
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(url);
+  if (imapUrl) {
+    nsImapAction imapAction = nsIImapUrl::nsImapTest;
+    imapUrl->GetImapAction(&imapAction);
+    switch (imapAction) {
+    case nsIImapUrl::nsImapDiscoverAllAndSubscribedBoxesUrl:
+    case nsIImapUrl::nsImapDiscoverChildrenUrl:
+      rv = UpdateSubscribed();
+      NS_ENSURE_SUCCESS(rv, rv);
+      mDoingSubscribeDialog = false;
+      rv = StopPopulating(msgWindow);
+      NS_ENSURE_SUCCESS(rv, rv);
+      break;
+    case nsIImapUrl::nsImapDiscoverAllBoxesUrl:
+      if (NS_SUCCEEDED(exitCode))
+        DiscoveryDone();
+      break;
+    case nsIImapUrl::nsImapFolderStatus:
+    {
+      nsCOMPtr<nsIMsgFolder> msgFolder;
+      nsCOMPtr<nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(imapUrl);
+      mailUrl->GetFolder(getter_AddRefs(msgFolder));
+      if (msgFolder)
+      {
+        nsresult rv;
+        nsCOMPtr<nsIMsgMailSession> session =
+                 do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        bool folderOpen;
+        rv = session->IsFolderOpenInWindow(msgFolder, &folderOpen);
+        if (NS_SUCCEEDED(rv) && !folderOpen && msgFolder)
+          msgFolder->SetMsgDatabase(nullptr);
+        nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(msgFolder);
+        m_foldersToStat.RemoveObject(imapFolder);
+      }
+      // if we get an error running the url, it's better
+      // not to chain the next url.
+      if (NS_FAILED(exitCode) && exitCode != NS_MSG_ERROR_IMAP_COMMAND_FAILED)
+        m_foldersToStat.Clear();
+      if (m_foldersToStat.Count() > 0)
+        m_foldersToStat[0]->UpdateStatus(this, nullptr);
+      break;
+    }
+    default:
+        break;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetIncomingServer(nsIMsgIncomingServer *aServer)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->SetIncomingServer(aServer);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetShowFullName(bool showFullName)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->SetShowFullName(showFullName);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetDelimiter(char *aDelimiter)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->GetDelimiter(aDelimiter);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetDelimiter(char aDelimiter)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->SetDelimiter(aDelimiter);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetAsSubscribed(const nsACString &path)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->SetAsSubscribed(path);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::UpdateSubscribed()
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::AddTo(const nsACString &aName, bool addAsSubscribed,
+                            bool aSubscribable, bool changeIfExists)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // RFC 3501 allows UTF-8 in addition to modified UTF-7
+  // If it's not UTF-8, it cannot be MUTF7, either. We just ignore it.
+  // (otherwise we'll crash. see #63186)
+  if (!MsgIsUTF8(aName))
+    return NS_OK;
+
+  if (!NS_IsAscii(aName.BeginReading(), aName.Length())) {
+    nsAutoCString name;
+    CopyUTF16toMUTF7(NS_ConvertUTF8toUTF16(aName), name);
+    return mInner->AddTo(name, addAsSubscribed, aSubscribable, changeIfExists);
+  }
+  return mInner->AddTo(aName, addAsSubscribed, aSubscribable, changeIfExists);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::StopPopulating(nsIMsgWindow *aMsgWindow)
+{
+  nsCOMPtr<nsISubscribeListener> listener;
+  (void) GetSubscribeListener(getter_AddRefs(listener));
+
+  if (listener)
+    listener->OnDonePopulating();
+
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->StopPopulating(aMsgWindow);
+}
+
+
+NS_IMETHODIMP
+nsImapIncomingServer::SubscribeCleanup()
+{
+  m_subscribeFolders.Clear();
+  return ClearInner();
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetSubscribeListener(nsISubscribeListener *aListener)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->SetSubscribeListener(aListener);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetSubscribeListener(nsISubscribeListener **aListener)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->GetSubscribeListener(aListener);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::Subscribe(const char16_t *aName)
+{
+  NS_ENSURE_ARG_POINTER(aName);
+  
+  return SubscribeToFolder(nsDependentString(aName), true, nullptr);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::Unsubscribe(const char16_t *aName)
+{
+  NS_ENSURE_ARG_POINTER(aName);
+
+  return SubscribeToFolder(nsDependentString(aName), false, nullptr);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SubscribeToFolder(const nsAString& aName, bool subscribe, nsIURI **aUri)
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+  rv = GetRootFolder(getter_AddRefs(rootMsgFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Locate the folder so that the correct hierarchical delimiter is used in the
+  // folder pathnames, otherwise root's (ie, '^') is used and this is wrong.
+
+  // aName is not a genuine UTF-16 but just a zero-padded modified UTF-7
+  NS_LossyConvertUTF16toASCII folderCName(aName);
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  if (rootMsgFolder && !aName.IsEmpty())
+    rv = rootMsgFolder->FindSubFolder(folderCName, getter_AddRefs(msgFolder));
+
+  nsCOMPtr<nsIThread> thread(do_GetCurrentThread());
+
+  nsAutoString unicodeName;
+  rv = CopyMUTF7toUTF16(folderCName, unicodeName);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (subscribe)
+    rv = imapService->SubscribeFolder(msgFolder, unicodeName, nullptr, aUri);
+  else
+    rv = imapService->UnsubscribeFolder(msgFolder, unicodeName, nullptr, nullptr);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetDoingLsub(bool doingLsub)
+{
+  mDoingLsub = doingLsub;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetDoingLsub(bool *doingLsub)
+{
+  NS_ENSURE_ARG_POINTER(doingLsub);
+  *doingLsub = mDoingLsub;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::ReDiscoverAllFolders()
+{
+  return PerformExpand(nullptr);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetState(const nsACString &path, bool state,
+                               bool *stateChanged)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->SetState(path, state, stateChanged);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::HasChildren(const nsACString &path, bool *aHasChildren)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->HasChildren(path, aHasChildren);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::IsSubscribed(const nsACString &path,
+                                   bool *aIsSubscribed)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->IsSubscribed(path, aIsSubscribed);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::IsSubscribable(const nsACString &path, bool *aIsSubscribable)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->IsSubscribable(path, aIsSubscribable);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetLeafName(const nsACString &path, nsAString &aLeafName)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->GetLeafName(path, aLeafName);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetFirstChildURI(const nsACString &path, nsACString &aResult)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->GetFirstChildURI(path, aResult);
+}
+
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetChildren(const nsACString &aPath,
+                                  nsISimpleEnumerator **aResult)
+{
+  nsresult rv = EnsureInner();
+  NS_ENSURE_SUCCESS(rv,rv);
+  return mInner->GetChildren(aPath, aResult);
+}
+
+nsresult
+nsImapIncomingServer::EnsureInner()
+{
+  nsresult rv = NS_OK;
+
+  if (mInner)
+    return NS_OK;
+
+  mInner = do_CreateInstance(kSubscribableServerCID,&rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return SetIncomingServer(this);
+}
+
+nsresult
+nsImapIncomingServer::ClearInner()
+{
+  nsresult rv = NS_OK;
+  if (mInner)
+  {
+    rv = mInner->SetSubscribeListener(nullptr);
+    NS_ENSURE_SUCCESS(rv,rv);
+    rv = mInner->SetIncomingServer(nullptr);
+    NS_ENSURE_SUCCESS(rv,rv);
+    mInner = nullptr;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::CommitSubscribeChanges()
+{
+  return ReDiscoverAllFolders();
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetCanBeDefaultServer(bool *canBeDefaultServer)
+{
+  NS_ENSURE_ARG_POINTER(canBeDefaultServer);
+  *canBeDefaultServer = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetCanCompactFoldersOnServer(bool *canCompactFoldersOnServer)
+{
+  NS_ENSURE_ARG_POINTER(canCompactFoldersOnServer);
+  // Initialize canCompactFoldersOnServer true, a default value for IMAP
+  *canCompactFoldersOnServer = true;
+  GetPrefForServerAttribute("canCompactFoldersOnServer", canCompactFoldersOnServer);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetCanUndoDeleteOnServer(bool *canUndoDeleteOnServer)
+{
+  NS_ENSURE_ARG_POINTER(canUndoDeleteOnServer);
+  // Initialize canUndoDeleteOnServer true, a default value for IMAP
+  *canUndoDeleteOnServer = true;
+  GetPrefForServerAttribute("canUndoDeleteOnServer", canUndoDeleteOnServer);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetCanSearchMessages(bool *canSearchMessages)
+{
+  NS_ENSURE_ARG_POINTER(canSearchMessages);
+  // Initialize canSearchMessages true, a default value for IMAP
+  *canSearchMessages = true;
+  GetPrefForServerAttribute("canSearchMessages", canSearchMessages);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetCanEmptyTrashOnExit(bool *canEmptyTrashOnExit)
+{
+  NS_ENSURE_ARG_POINTER(canEmptyTrashOnExit);
+  // Initialize canEmptyTrashOnExit true, a default value for IMAP
+  *canEmptyTrashOnExit = true;
+  GetPrefForServerAttribute("canEmptyTrashOnExit", canEmptyTrashOnExit);
+  return NS_OK;
+}
+
+nsresult
+nsImapIncomingServer::CreateHostSpecificPrefName(const char *prefPrefix, nsAutoCString &prefName)
+{
+  NS_ENSURE_ARG_POINTER(prefPrefix);
+
+  nsCString hostName;
+  nsresult rv = GetHostName(hostName);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  prefName = prefPrefix;
+  prefName.Append('.');
+  prefName.Append(hostName);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetSupportsDiskSpace(bool *aSupportsDiskSpace)
+{
+  NS_ENSURE_ARG_POINTER(aSupportsDiskSpace);
+  nsAutoCString prefName;
+  nsresult rv = CreateHostSpecificPrefName("default_supports_diskspace", prefName);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv))
+     rv = prefBranch->GetBoolPref(prefName.get(), aSupportsDiskSpace);
+
+  // Couldn't get the default value with the hostname.
+  // Fall back on IMAP default value
+  if (NS_FAILED(rv)) // set default value
+     *aSupportsDiskSpace = true;
+  return NS_OK;
+}
+
+// count number of non-busy connections in cache
+NS_IMETHODIMP
+nsImapIncomingServer::GetNumIdleConnections(int32_t *aNumIdleConnections)
+{
+  NS_ENSURE_ARG_POINTER(aNumIdleConnections);
+  *aNumIdleConnections = 0;
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIImapProtocol> connection;
+  bool isBusy = false;
+  bool isInboxConnection;
+  PR_CEnterMonitor(this);
+
+  int32_t cnt = m_connectionCache.Count();
+
+  // loop counting idle connections
+  for (int32_t i = 0; i < cnt; ++i)
+  {
+    connection = m_connectionCache[i];
+    if (connection)
+    {
+      rv = connection->IsBusy(&isBusy, &isInboxConnection);
+      if (NS_FAILED(rv))
+        continue;
+      if (!isBusy)
+        (*aNumIdleConnections)++;
+    }
+  }
+  PR_CExitMonitor(this);
+  return rv;
+}
+
+
+/**
+ * Get the preference that tells us whether the imap server in question allows
+ * us to create subfolders. Some ISPs might not want users to create any folders
+ * besides the existing ones.
+ * We do want to identify all those servers that don't allow creation of subfolders
+ * and take them out of the account picker in the Copies and Folder panel.
+ */
+NS_IMETHODIMP
+nsImapIncomingServer::GetCanCreateFoldersOnServer(bool *aCanCreateFoldersOnServer)
+{
+  NS_ENSURE_ARG_POINTER(aCanCreateFoldersOnServer);
+  // Initialize aCanCreateFoldersOnServer true, a default value for IMAP
+  *aCanCreateFoldersOnServer = true;
+  GetPrefForServerAttribute("canCreateFolders", aCanCreateFoldersOnServer);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetOfflineSupportLevel(int32_t *aSupportLevel)
+{
+  NS_ENSURE_ARG_POINTER(aSupportLevel);
+  nsresult rv = NS_OK;
+
+  rv = GetIntValue("offline_support_level", aSupportLevel);
+  if (*aSupportLevel != OFFLINE_SUPPORT_LEVEL_UNDEFINED)
+    return rv;
+
+  nsAutoCString prefName;
+  rv = CreateHostSpecificPrefName("default_offline_support_level", prefName);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv))
+    rv = prefBranch->GetIntPref(prefName.get(), aSupportLevel);
+
+  // Couldn't get the pref value with the hostname.
+  // Fall back on IMAP default value
+  if (NS_FAILED(rv)) // set default value
+    *aSupportLevel = OFFLINE_SUPPORT_LEVEL_REGULAR;
+  return NS_OK;
+}
+
+// Called only during the migration process. This routine enables the generation of
+// unique account name based on the username, hostname and the port. If the port
+// is valid and not a default one, it will be appended to the account name.
+NS_IMETHODIMP
+nsImapIncomingServer::GeneratePrettyNameForMigration(nsAString& aPrettyName)
+{
+  nsCString userName;
+  nsCString hostName;
+
+/**
+  * Pretty name for migrated account is of format username@hostname:<port>,
+  * provided the port is valid and not the default
+*/
+  // Get user name to construct pretty name
+  nsresult rv = GetUsername(userName);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get host name to construct pretty name
+  rv = GetHostName(hostName);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t defaultServerPort;
+  int32_t defaultSecureServerPort;
+
+  // Here, the final contract ID is already known, so use it directly for efficiency.
+  nsCOMPtr <nsIMsgProtocolInfo> protocolInfo = do_GetService(NS_IMAPPROTOCOLINFO_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // Get the default port
+  rv = protocolInfo->GetDefaultServerPort(false, &defaultServerPort);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // Get the default secure port
+  rv = protocolInfo->GetDefaultServerPort(true, &defaultSecureServerPort);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // Get the current server port
+  int32_t serverPort = PORT_NOT_SET;
+  rv = GetPort(&serverPort);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // Is the server secure ?
+  int32_t socketType;
+  rv = GetSocketType(&socketType);
+  NS_ENSURE_SUCCESS(rv,rv);
+  bool isSecure = (socketType == nsMsgSocketType::SSL);
+
+  // Is server port a default port ?
+  bool isItDefaultPort = false;
+  if (((serverPort == defaultServerPort) && !isSecure)||
+      ((serverPort == defaultSecureServerPort) && isSecure))
+      isItDefaultPort = true;
+
+  // Construct pretty name from username and hostname
+  nsAutoString constructedPrettyName;
+  CopyASCIItoUTF16(userName,constructedPrettyName);
+  constructedPrettyName.Append('@');
+  constructedPrettyName.Append(NS_ConvertASCIItoUTF16(hostName));
+
+  // If the port is valid and not default, add port value to the pretty name
+  if ((serverPort > 0) && (!isItDefaultPort)) {
+    constructedPrettyName.Append(':');
+    constructedPrettyName.AppendInt(serverPort);
+  }
+
+  // Format the pretty name
+  return GetFormattedStringFromName(constructedPrettyName,
+                                    "imapDefaultAccountName",
+                                    aPrettyName);
+}
+
+nsresult
+nsImapIncomingServer::GetFormattedStringFromName(const nsAString& aValue,
+                                                 const char* aName,
+                                                 nsAString& aResult)
+{
+  nsresult rv = GetStringBundle();
+  if (m_stringBundle)
+  {
+    nsString tmpVal (aValue);
+    const char16_t *formatStrings[] = { tmpVal.get() };
+
+    nsString result;
+    rv = m_stringBundle->FormatStringFromName(
+      NS_ConvertASCIItoUTF16(aName).get(),
+      formatStrings, 1, getter_Copies(result));
+    aResult.Assign(result);
+  }
+  return rv;
+}
+
+nsresult
+nsImapIncomingServer::GetPrefForServerAttribute(const char *prefSuffix, bool *prefValue)
+{
+  // Any caller of this function must initialize prefValue with a default value
+  // as this code will not set prefValue when the pref does not exist and return
+  // NS_OK anyway
+
+  if (!mPrefBranch)
+    return NS_ERROR_NOT_INITIALIZED;
+
+  NS_ENSURE_ARG_POINTER(prefValue);
+
+  if (NS_FAILED(mPrefBranch->GetBoolPref(prefSuffix, prefValue)))
+    mDefPrefBranch->GetBoolPref(prefSuffix, prefValue);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetCanFileMessagesOnServer(bool *aCanFileMessagesOnServer)
+{
+  NS_ENSURE_ARG_POINTER(aCanFileMessagesOnServer);
+  // Initialize aCanFileMessagesOnServer true, a default value for IMAP
+  *aCanFileMessagesOnServer = true;
+  GetPrefForServerAttribute("canFileMessages", aCanFileMessagesOnServer);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetSearchValue(const nsAString &searchValue)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetSupportsSubscribeSearch(bool *retVal)
+{
+  NS_ENSURE_ARG_POINTER(retVal);
+  *retVal = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetFilterScope(nsMsgSearchScopeValue *filterScope)
+{
+  NS_ENSURE_ARG_POINTER(filterScope);
+  // If the inbox is enabled for offline use, then use the offline filter
+  // scope, else use the online filter scope.
+  //
+  // XXX We use the same scope for all folders with the same incoming server,
+  // yet it is possible to set the offline flag separately for each folder.
+  // Manual filters could perhaps check the offline status of each folder,
+  // though it's hard to see how to make that work since we only store filters
+  // per server.
+  //
+  nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+  nsresult rv = GetRootMsgFolder(getter_AddRefs(rootMsgFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgFolder> offlineInboxMsgFolder;
+  rv = rootMsgFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox |
+                                           nsMsgFolderFlags::Offline,
+                                         getter_AddRefs(offlineInboxMsgFolder));
+
+  *filterScope = offlineInboxMsgFolder ? nsMsgSearchScope::offlineMailFilter
+                                       : nsMsgSearchScope::onlineMailFilter;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetSearchScope(nsMsgSearchScopeValue *searchScope)
+{
+  NS_ENSURE_ARG_POINTER(searchScope);
+ *searchScope = WeAreOffline() ? nsMsgSearchScope::offlineMail : nsMsgSearchScope::onlineMail;
+  return NS_OK;
+}
+
+// This is a recursive function. It gets new messages for current folder
+// first if it is marked, then calls itself recursively for each subfolder.
+NS_IMETHODIMP
+nsImapIncomingServer::GetNewMessagesForNonInboxFolders(nsIMsgFolder *aFolder,
+                                                       nsIMsgWindow *aWindow,
+                                                       bool forceAllFolders,
+                                                       bool performingBiff)
+{
+  NS_ENSURE_ARG_POINTER(aFolder);
+  static bool gGotStatusPref = false;
+  static bool gUseStatus = false;
+
+  bool isServer;
+  (void) aFolder->GetIsServer(&isServer);
+  // Check this folder for new messages if it is marked to be checked
+  // or if we are forced to check all folders
+  uint32_t flags = 0;
+  aFolder->GetFlags(&flags);
+  nsresult rv;
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(aFolder, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  bool canOpen;
+  imapFolder->GetCanOpenFolder(&canOpen);
+  if (canOpen && ((forceAllFolders &&
+                 !(flags & (nsMsgFolderFlags::Inbox | nsMsgFolderFlags::Trash |
+                   nsMsgFolderFlags::Junk | nsMsgFolderFlags::Virtual))) ||
+                flags & nsMsgFolderFlags::CheckNew))
+  {
+    // Get new messages for this folder.
+    aFolder->SetGettingNewMessages(true);
+    if (performingBiff)
+      imapFolder->SetPerformingBiff(true);
+    bool isOpen = false;
+    nsCOMPtr <nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID);
+    if (mailSession && aFolder)
+      mailSession->IsFolderOpenInWindow(aFolder, &isOpen);
+    // eventually, the gGotStatusPref should go away, once we work out the kinks
+    // from using STATUS.
+    if (!gGotStatusPref)
+    {
+      nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID);
+      if(prefBranch)
+        prefBranch->GetBoolPref("mail.imap.use_status_for_biff", &gUseStatus);
+      gGotStatusPref = true;
+    }
+    if (gUseStatus && !isOpen)
+    {
+      if (!isServer && m_foldersToStat.IndexOf(imapFolder) == -1)
+        m_foldersToStat.AppendObject(imapFolder);
+    }
+    else
+      aFolder->UpdateFolder(aWindow);
+  }
+
+  // Loop through all subfolders to get new messages for them.
+  nsCOMPtr<nsISimpleEnumerator> enumerator;
+  rv = aFolder->GetSubFolders(getter_AddRefs(enumerator));
+  if (NS_FAILED(rv))
+    return rv;
+
+  bool hasMore;
+  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore)
+  {
+    nsCOMPtr<nsISupports> item;
+    enumerator->GetNext(getter_AddRefs(item));
+
+    nsCOMPtr<nsIMsgFolder> msgFolder(do_QueryInterface(item));
+    if (!msgFolder)
+    {
+      NS_WARNING("Not an nsIMsgFolder");
+      continue;
+    }
+    GetNewMessagesForNonInboxFolders(msgFolder, aWindow, forceAllFolders,
+                                     performingBiff);
+  }
+  if (isServer && m_foldersToStat.Count() > 0)
+    m_foldersToStat[0]->UpdateStatus(this, nullptr);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetArbitraryHeaders(nsACString &aResult)
+{
+  nsCOMPtr <nsIMsgFilterList> filterList;
+  nsresult rv = GetFilterList(nullptr, getter_AddRefs(filterList));
+  NS_ENSURE_SUCCESS(rv,rv);
+  return filterList->GetArbitraryHeaders(aResult);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetShowAttachmentsInline(bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = true; // true per default
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  prefBranch->GetBoolPref("mail.inline_attachments", aResult);
+  return NS_OK; // In case this pref is not set we need to return NS_OK.
+}
+
+NS_IMETHODIMP nsImapIncomingServer::SetSocketType(int32_t aSocketType)
+{
+  int32_t oldSocketType;
+  nsresult rv = GetSocketType(&oldSocketType);
+  if (NS_SUCCEEDED(rv) && oldSocketType != aSocketType)
+    CloseCachedConnections();
+  return nsMsgIncomingServer::SetSocketType(aSocketType);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::OnUserOrHostNameChanged(const nsACString& oldName,
+                                              const nsACString& newName,
+                                              bool hostnameChanged)
+{
+  nsresult rv;
+  // 1. Do common things in the base class.
+  rv = nsMsgIncomingServer::OnUserOrHostNameChanged(oldName, newName, hostnameChanged);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // 2. Reset 'HaveWeEverDiscoveredFolders' flag so the new folder list can be
+  //    reloaded (ie, DiscoverMailboxList() will be invoked in nsImapProtocol).
+  nsCOMPtr<nsIImapHostSessionList> hostSessionList = do_GetService(kCImapHostSessionListCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsAutoCString serverKey;
+  rv = GetKey(serverKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+  hostSessionList->SetHaveWeEverDiscoveredFoldersForHost(serverKey.get(), false);
+  // 3. Make all the existing folders 'unverified' so that they can be
+  //    removed from the folder pane after users log into the new server.
+  ResetFoldersToUnverified(nullptr);
+  return NS_OK;
+}
+
+// use canonical format in originalUri & convertedUri
+NS_IMETHODIMP
+nsImapIncomingServer::GetUriWithNamespacePrefixIfNecessary(int32_t namespaceType,
+                                                           const nsACString& originalUri,
+                                                           nsACString& convertedUri)
+{
+  nsresult rv = NS_OK;
+  nsAutoCString serverKey;
+  rv = GetKey(serverKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIImapHostSessionList> hostSessionList = do_GetService(kCImapHostSessionListCID, &rv);
+  nsIMAPNamespace *ns = nullptr;
+  rv = hostSessionList->GetDefaultNamespaceOfTypeForHost(serverKey.get(), (EIMAPNamespaceType)namespaceType, ns);
+  if (ns)
+  {
+    nsAutoCString namespacePrefix(ns->GetPrefix());
+    if (!namespacePrefix.IsEmpty())
+    {
+      // check if namespacePrefix is the same as the online directory; if so, ignore it.
+      nsAutoCString onlineDir;
+      rv = GetServerDirectory(onlineDir);
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (!onlineDir.IsEmpty())
+      {
+        char delimiter = ns->GetDelimiter();
+          if ( onlineDir.Last() != delimiter )
+            onlineDir += delimiter;
+          if (onlineDir.Equals(namespacePrefix))
+            return NS_OK;
+      }
+
+      MsgReplaceChar(namespacePrefix, ns->GetDelimiter(), '/'); // use canonical format
+      nsCString uri(originalUri);
+      int32_t index = uri.Find("//");           // find scheme
+      index = uri.FindChar('/', index + 2);       // find '/' after scheme
+      // it may be the case that this is the INBOX uri, in which case
+      // we don't want to prepend the namespace. In that case, the uri ends with "INBOX",
+      // but the namespace is "INBOX/", so they don't match.
+      if (MsgFind(uri, namespacePrefix, false, index + 1) != index + 1 &&
+          !MsgLowerCaseEqualsLiteral(Substring(uri, index + 1), "inbox"))
+        uri.Insert(namespacePrefix, index + 1);   // insert namespace prefix
+      convertedUri = uri;
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::GetTrashFolderName(nsAString& retval)
+{
+  nsresult rv = GetUnicharValue(PREF_TRASH_FOLDER_NAME, retval);
+  if (NS_FAILED(rv))
+    return rv;
+  if (retval.IsEmpty())
+    retval = NS_LITERAL_STRING(DEFAULT_TRASH_FOLDER_NAME);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapIncomingServer::SetTrashFolderName(const nsAString& chvalue)
+{
+  // clear trash flag from the old pref
+  nsAutoString oldTrashName;
+  nsresult rv = GetTrashFolderName(oldTrashName);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsAutoCString oldTrashNameUtf7;
+    rv = CopyUTF16toMUTF7(oldTrashName, oldTrashNameUtf7);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIMsgFolder> oldFolder;
+      rv = GetFolder(oldTrashNameUtf7, getter_AddRefs(oldFolder));
+      if (NS_SUCCEEDED(rv) && oldFolder)
+        oldFolder->ClearFlag(nsMsgFolderFlags::Trash);
+    }
+  }
+  return SetUnicharValue(PREF_TRASH_FOLDER_NAME, chvalue);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetMsgFolderFromURI(nsIMsgFolder *aFolderResource,
+                                          const nsACString& aURI,
+                                          nsIMsgFolder **aFolder)
+{
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  bool namespacePrefixAdded = false;
+  nsCString folderUriWithNamespace;
+
+  // Check if the folder exists as is...
+  nsresult rv = GetExistingMsgFolder(aURI, folderUriWithNamespace,
+                                     namespacePrefixAdded, false,
+                                     getter_AddRefs(msgFolder));
+
+  // Or try again with a case-insensitive lookup
+  if (NS_FAILED(rv) || !msgFolder)
+    rv = GetExistingMsgFolder(aURI, folderUriWithNamespace,
+                              namespacePrefixAdded, true,
+                              getter_AddRefs(msgFolder));
+
+  if (NS_FAILED(rv) || !msgFolder) {
+    // we didn't find the folder so we will have to create a new one.
+    if (namespacePrefixAdded)
+    {
+      nsCOMPtr <nsIRDFService> rdf = do_GetService("@mozilla.org/rdf/rdf-service;1", &rv);
+      NS_ENSURE_SUCCESS(rv,rv);
+
+      nsCOMPtr<nsIRDFResource> resource;
+      rv = rdf->GetResource(folderUriWithNamespace, getter_AddRefs(resource));
+      NS_ENSURE_SUCCESS(rv,rv);
+
+      nsCOMPtr <nsIMsgFolder> folderResource;
+      folderResource = do_QueryInterface(resource, &rv);
+      NS_ENSURE_SUCCESS(rv,rv);
+      msgFolder = folderResource;
+    }
+    else
+      msgFolder = aFolderResource;
+  }
+
+  msgFolder.swap(*aFolder);
+  return NS_OK;
+}
+
+nsresult
+nsImapIncomingServer::GetExistingMsgFolder(const nsACString& aURI,
+                                           nsACString& aFolderUriWithNamespace,
+                                           bool& aNamespacePrefixAdded,
+                                           bool aCaseInsensitive,
+                                           nsIMsgFolder **aFolder)
+{
+  nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+  nsresult rv = GetRootMsgFolder(getter_AddRefs(rootMsgFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  aNamespacePrefixAdded = false;
+  // Check if the folder exists as is...Even if we have a personal namespace,
+  // it might be in another namespace (e.g., shared) and this will catch that.
+  rv = rootMsgFolder->GetChildWithURI(aURI, true, aCaseInsensitive, aFolder);
+
+  // If we couldn't find the folder as is, check if we need to prepend the
+  // personal namespace
+  if (!*aFolder)
+  {
+    GetUriWithNamespacePrefixIfNecessary(kPersonalNamespace, aURI,
+                                         aFolderUriWithNamespace);
+    if (!aFolderUriWithNamespace.IsEmpty())
+    {
+      aNamespacePrefixAdded = true;
+      rv = rootMsgFolder->GetChildWithURI(aFolderUriWithNamespace, true,
+                                          aCaseInsensitive, aFolder);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::CramMD5Hash(const char *decodedChallenge, const char *key, char **result)
+{
+  NS_ENSURE_ARG_POINTER(decodedChallenge);
+  NS_ENSURE_ARG_POINTER(key);
+
+  unsigned char resultDigest[DIGEST_LENGTH];
+  nsresult rv = MSGCramMD5(decodedChallenge, strlen(decodedChallenge), key, strlen(key), resultDigest);
+  NS_ENSURE_SUCCESS(rv, rv);
+  *result = (char *) malloc(DIGEST_LENGTH);
+  if (*result)
+    memcpy(*result, resultDigest, DIGEST_LENGTH);
+  return (*result) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetLoginUsername(nsACString &aLoginUsername)
+{
+  return GetRealUsername(aLoginUsername);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetOriginalUsername(nsACString &aUsername)
+{
+  return GetUsername(aUsername);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetServerKey(nsACString &aServerKey)
+{
+  return GetKey(aServerKey);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetServerPassword(nsACString &aPassword)
+{
+  return GetPassword(aPassword);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::RemoveServerConnection(nsIImapProtocol* aProtocol)
+{
+  return RemoveConnection(aProtocol);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::GetServerShuttingDown(bool* aShuttingDown)
+{
+  return GetShuttingDown(aShuttingDown);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::ResetServerConnection(const nsACString& aFolderName)
+{
+  return ResetConnection(aFolderName);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetServerDoingLsub(bool aDoingLsub)
+{
+  return SetDoingLsub(aDoingLsub);
+}
+
+NS_IMETHODIMP
+nsImapIncomingServer::SetServerForceSelect(const nsACString &aForceSelect)
+{
+  return SetForceSelect(aForceSelect);
+}
diff --git a/mailnews/imap/src/nsImapIncomingServer.h b/mailnews/imap/src/nsImapIncomingServer.h
new file mode 100644
index 0000000000..0948a3178c
--- /dev/null
+++ b/mailnews/imap/src/nsImapIncomingServer.h
@@ -0,0 +1,137 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsImapIncomingServer_h
+#define __nsImapIncomingServer_h
+
+#include "mozilla/Attributes.h"
+#include "msgCore.h"
+#include "nsIImapIncomingServer.h"
+#include "nsMsgIncomingServer.h"
+#include "nsIImapServerSink.h"
+#include "nsIStringBundle.h"
+#include "nsISubscribableServer.h"
+#include "nsIUrlListener.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsCOMArray.h"
+#include "nsTArray.h"
+#include "mozilla/Mutex.h"
+
+class nsIRDFService;
+
+/* get some implementation from nsMsgIncomingServer */
+class nsImapIncomingServer : public nsMsgIncomingServer,
+                             public nsIImapIncomingServer,
+                             public nsIImapServerSink,
+                             public nsISubscribableServer,
+                             public nsIUrlListener
+{
+public:
+    NS_DECL_ISUPPORTS_INHERITED
+
+    nsImapIncomingServer();
+
+    // overriding nsMsgIncomingServer methods
+  NS_IMETHOD SetKey(const nsACString& aKey) override;  // override nsMsgIncomingServer's implementation...
+  NS_IMETHOD GetLocalStoreType(nsACString& type) override;
+  NS_IMETHOD GetLocalDatabaseType(nsACString& type) override;
+
+  NS_DECL_NSIIMAPINCOMINGSERVER
+  NS_DECL_NSIIMAPSERVERSINK
+  NS_DECL_NSISUBSCRIBABLESERVER
+  NS_DECL_NSIURLLISTENER
+
+  NS_IMETHOD PerformBiff(nsIMsgWindow *aMsgWindow) override;
+  NS_IMETHOD PerformExpand(nsIMsgWindow *aMsgWindow) override;
+  NS_IMETHOD CloseCachedConnections() override;
+  NS_IMETHOD GetConstructedPrettyName(nsAString& retval) override;
+  NS_IMETHOD GetCanBeDefaultServer(bool *canBeDefaultServer) override;
+  NS_IMETHOD GetCanCompactFoldersOnServer(bool *canCompactFoldersOnServer
+                                          ) override;
+  NS_IMETHOD GetCanUndoDeleteOnServer(bool *canUndoDeleteOnServer) override;
+  NS_IMETHOD GetCanSearchMessages(bool *canSearchMessages) override;
+  NS_IMETHOD GetCanEmptyTrashOnExit(bool *canEmptyTrashOnExit) override;
+  NS_IMETHOD GetOfflineSupportLevel(int32_t *aSupportLevel) override;
+  NS_IMETHOD GeneratePrettyNameForMigration(nsAString& aPrettyName) override;
+  NS_IMETHOD GetSupportsDiskSpace(bool *aSupportsDiskSpace) override;
+  NS_IMETHOD GetCanCreateFoldersOnServer(bool *aCanCreateFoldersOnServer
+                                         ) override;
+  NS_IMETHOD GetCanFileMessagesOnServer(bool *aCanFileMessagesOnServer
+                                        ) override;
+  NS_IMETHOD GetFilterScope(nsMsgSearchScopeValue *filterScope) override;
+  NS_IMETHOD GetSearchScope(nsMsgSearchScopeValue *searchScope) override;
+  NS_IMETHOD GetServerRequiresPasswordForBiff(bool *aServerRequiresPasswordForBiff
+                                              ) override;
+  NS_IMETHOD OnUserOrHostNameChanged(const nsACString& oldName,
+                                     const nsACString& newName,
+                                     bool hostnameChanged) override;
+  NS_IMETHOD GetNumIdleConnections(int32_t *aNumIdleConnections);
+  NS_IMETHOD ForgetSessionPassword() override;
+  NS_IMETHOD GetMsgFolderFromURI(nsIMsgFolder *aFolderResource,
+                                 const nsACString& aURI,
+                                 nsIMsgFolder **aFolder) override;
+  NS_IMETHOD SetSocketType(int32_t aSocketType) override;
+  NS_IMETHOD VerifyLogon(nsIUrlListener *aUrlListener, nsIMsgWindow *aMsgWindow,
+                         nsIURI **aURL) override;
+
+protected:
+  virtual ~nsImapIncomingServer();
+  nsresult GetFolder(const nsACString& name, nsIMsgFolder** pFolder);
+  virtual nsresult CreateRootFolderFromUri(const nsCString &serverUri,
+                                           nsIMsgFolder **rootFolder) override;
+  nsresult ResetFoldersToUnverified(nsIMsgFolder *parentFolder);
+  void GetUnverifiedSubFolders(nsIMsgFolder *parentFolder,
+                               nsCOMArray<nsIMsgImapMailFolder> &aFoldersArray);
+  void GetUnverifiedFolders(nsCOMArray<nsIMsgImapMailFolder> &aFolderArray);
+  nsresult DeleteNonVerifiedFolders(nsIMsgFolder *parentFolder);
+  bool NoDescendentsAreVerified(nsIMsgFolder *parentFolder);
+  bool AllDescendentsAreNoSelect(nsIMsgFolder *parentFolder);
+
+  nsresult GetStringBundle();
+  static nsresult AlertUser(const nsAString& aString, nsIMsgMailNewsUrl *aUrl);
+
+private:
+  nsresult SubscribeToFolder(const char16_t *aName, bool subscribe);
+  nsresult GetImapConnection(nsIImapUrl* aImapUrl,
+                             nsIImapProtocol** aImapConnection);
+  nsresult CreateProtocolInstance(nsIImapProtocol ** aImapConnection);
+  nsresult CreateHostSpecificPrefName(const char *prefPrefix, nsAutoCString &prefName);
+
+  nsresult DoomUrlIfChannelHasError(nsIImapUrl *aImapUrl, bool *urlDoomed);
+  bool ConnectionTimeOut(nsIImapProtocol* aImapConnection);
+  nsresult GetFormattedStringFromName(const nsAString& aValue, const char* aName, nsAString& aResult);
+  nsresult GetPrefForServerAttribute(const char *prefSuffix, bool *prefValue);
+  bool CheckSpecialFolder(nsIRDFService *rdf, nsCString &folderUri,
+                            uint32_t folderFlag, nsCString &existingUri);
+
+  nsCOMArray<nsIImapProtocol> m_connectionCache;
+  nsCOMArray<nsIImapUrl> m_urlQueue;
+  nsCOMPtr<nsIStringBundle>	m_stringBundle;
+  nsCOMArray<nsIMsgFolder> m_subscribeFolders; // used to keep folder resources around while subscribe UI is up.
+  nsCOMArray<nsIMsgImapMailFolder> m_foldersToStat; // folders to check for new mail with Status
+  nsTArray<nsISupports*> m_urlConsumers;
+  eIMAPCapabilityFlags          m_capability;
+  nsCString         m_manageMailAccountUrl;
+  bool              m_userAuthenticated;
+  bool              mDoingSubscribeDialog;
+  bool              mDoingLsub;
+  bool              m_shuttingDown;
+
+  mozilla::Mutex mLock;
+  // subscribe dialog stuff
+  nsresult AddFolderToSubscribeDialog(const char *parentUri, const char *uri,const char *folderName);
+  nsCOMPtr <nsISubscribableServer> mInner;
+  nsresult EnsureInner();
+  nsresult ClearInner();
+
+  // Utility function for checking folder existence
+  nsresult GetExistingMsgFolder(const nsACString& aURI,
+                                nsACString& folderUriWithNamespace,
+                                bool& namespacePrefixAdded,
+                                bool caseInsensitive,
+                                nsIMsgFolder **aFolder);
+};
+
+#endif
diff --git a/mailnews/imap/src/nsImapMailFolder.cpp b/mailnews/imap/src/nsImapMailFolder.cpp
new file mode 100644
index 0000000000..12e6873601
--- /dev/null
+++ b/mailnews/imap/src/nsImapMailFolder.cpp
@@ -0,0 +1,9868 @@
+/* -*- 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 "nsMsgImapCID.h"
+#include "nsImapMailFolder.h"
+#include "nsIFile.h"
+#include "nsIFolderListener.h"
+#include "nsCOMPtr.h"
+#include "nsAutoPtr.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "nsMsgDBCID.h"
+#include "nsMsgFolderFlags.h"
+#include "nsImapFlagAndUidState.h"
+#include "nsISeekableStream.h"
+#include "nsThreadUtils.h"
+#include "nsIImapUrl.h"
+#include "nsImapUtils.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgMailSession.h"
+#include "nsMsgKeyArray.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgLocalCID.h"
+#include "nsImapUndoTxn.h"
+#include "nsIIMAPHostSessionList.h"
+#include "nsIMsgCopyService.h"
+#include "nsICopyMsgStreamListener.h"
+#include "nsImapStringBundle.h"
+#include "nsIMsgFolderCacheElement.h"
+#include "nsTextFormatter.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsMsgI18N.h"
+#include "nsICacheSession.h"
+#include "nsIDOMWindow.h"
+#include "nsIMsgFilter.h"
+#include "nsIMsgFilterService.h"
+#include "nsIMsgSearchCustomTerm.h"
+#include "nsIMsgSearchTerm.h"
+#include "nsImapMoveCoalescer.h"
+#include "nsIPrompt.h"
+#include "nsIPromptService.h"
+#include "nsIDocShell.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.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 "nsIMsgOfflineImapOperation.h"
+#include "nsImapOfflineSync.h"
+#include "nsIMsgAccountManager.h"
+#include "nsQuickSort.h"
+#include "nsIImapMockChannel.h"
+#include "nsIWebNavigation.h"
+#include "nsNetUtil.h"
+#include "nsIMAPNamespace.h"
+#include "nsIMsgFolderCompactor.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMimeHeaders.h"
+#include "nsIMsgMdnGenerator.h"
+#include "nsISpamSettings.h"
+#include <time.h>
+#include "nsIMsgMailNewsUrl.h"
+#include "nsEmbedCID.h"
+#include "nsIMsgComposeService.h"
+#include "nsMsgCompCID.h"
+#include "nsICacheEntry.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsIMsgIdentity.h"
+#include "nsIMsgFolderNotificationService.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsIExternalProtocolService.h"
+#include "nsCExternalHandlerService.h"
+#include "prprf.h"
+#include "nsIMutableArray.h"
+#include "nsArrayUtils.h"
+#include "nsArrayEnumerator.h"
+#include "nsAutoSyncManager.h"
+#include "nsIMsgFilterCustomAction.h"
+#include "nsMsgReadStateTxn.h"
+#include "nsIStringEnumerator.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsAlgorithm.h"
+#include "nsMsgLineBuffer.h"
+#include <algorithm>
+#include "mozilla/Logging.h"
+#include "mozilla/Attributes.h"
+#include "nsStringStream.h"
+#include "nsIStreamListener.h"
+
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+static NS_DEFINE_CID(kParseMailMsgStateCID, NS_PARSEMAILMSGSTATE_CID);
+static NS_DEFINE_CID(kCImapHostSessionList, NS_IIMAPHOSTSESSIONLIST_CID);
+
+extern PRLogModuleInfo *gAutoSyncLog;
+extern PRLogModuleInfo* IMAP;
+
+#define MAILNEWS_CUSTOM_HEADERS "mailnews.customHeaders"
+
+/*
+    Copies the contents of srcDir into destDir.
+    destDir will be created if it doesn't exist.
+*/
+
+static
+nsresult RecursiveCopy(nsIFile* srcDir, nsIFile* destDir)
+{
+  nsresult rv;
+  bool isDir;
+
+  rv = srcDir->IsDirectory(&isDir);
+  if (NS_FAILED(rv)) return rv;
+  if (!isDir) return NS_ERROR_INVALID_ARG;
+
+  bool exists;
+  rv = destDir->Exists(&exists);
+  if (NS_SUCCEEDED(rv) && !exists)
+    rv = destDir->Create(nsIFile::DIRECTORY_TYPE, 0775);
+  if (NS_FAILED(rv)) return rv;
+
+  bool hasMore = false;
+  nsCOMPtr<nsISimpleEnumerator> dirIterator;
+  rv = srcDir->GetDirectoryEntries(getter_AddRefs(dirIterator));
+  if (NS_FAILED(rv)) return rv;
+
+  rv = dirIterator->HasMoreElements(&hasMore);
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIFile> dirEntry;
+
+  while (hasMore)
+  {
+    nsCOMPtr<nsISupports> supports;
+    rv = dirIterator->GetNext(getter_AddRefs(supports));
+    dirEntry = do_QueryInterface(supports);
+    if (NS_SUCCEEDED(rv) && dirEntry)
+    {
+      rv = dirEntry->IsDirectory(&isDir);
+      if (NS_SUCCEEDED(rv))
+      {
+        if (isDir)
+        {
+          nsCOMPtr<nsIFile> newChild;
+          rv = destDir->Clone(getter_AddRefs(newChild));
+          if (NS_SUCCEEDED(rv))
+          {
+            nsAutoString leafName;
+            dirEntry->GetLeafName(leafName);
+            newChild->AppendRelativePath(leafName);
+            rv = newChild->Exists(&exists);
+            if (NS_SUCCEEDED(rv) && !exists)
+              rv = newChild->Create(nsIFile::DIRECTORY_TYPE, 0775);
+            rv = RecursiveCopy(dirEntry, newChild);
+          }
+        }
+        else
+          rv = dirEntry->CopyTo(destDir, EmptyString());
+      }
+
+    }
+    rv = dirIterator->HasMoreElements(&hasMore);
+    if (NS_FAILED(rv)) return rv;
+  }
+
+  return rv;
+}
+
+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_folderQuotaCommandIssued(false),
+    m_folderQuotaDataIsValid(false),
+    m_updatingFolder(false),
+    m_compactingOfflineStore(false),
+    m_expunging(false),
+    m_applyIncomingFilters(false),
+    m_downloadingFolderForOfflineUse(false),
+    m_filterListRequiresBody(false),
+    m_folderQuotaUsedKB(0),
+    m_folderQuotaMaxKB(0)
+{
+  MOZ_COUNT_CTOR(nsImapMailFolder); // double count these for now.
+
+  m_moveCoalescer = nullptr;
+  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()
+{
+  MOZ_COUNT_DTOR(nsImapMailFolder);
+
+  NS_IF_RELEASE(m_moveCoalescer);
+  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.Append(NS_LITERAL_STRING(FOLDER_SUFFIX));
+    path->SetLeafName(leafName);
+  }
+
+  return NS_OK;
+}
+
+static bool
+nsShouldIgnoreFile(nsString& name)
+{
+  int32_t len = name.Length();
+  if (len > 4 && name.RFind(SUMMARY_SUFFIX, true) == len - 4)
+  {
+    name.SetLength(len-4); // truncate the string
+    return false;
+  }
+  return true;
+}
+
+nsresult nsImapMailFolder::CreateChildFromURI(const nsCString &uri, nsIMsgFolder **folder)
+{
+  nsImapMailFolder *newFolder = new nsImapMailFolder;
+  if (!newFolder)
+    return NS_ERROR_OUT_OF_MEMORY;
+  newFolder->Init(uri.get());
+  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;
+  nsCOMPtr<nsIRDFService> rdf = do_GetService("@mozilla.org/rdf/rdf-service;1", &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsAutoCString uri(mURI);
+  uri.Append('/');
+
+  // If AddSubFolder starts getting called for folders other than virtual folders,
+  // we'll have to do convert those names to modified utf-7. For now, the account manager code
+  // that loads the virtual folders for each account, expects utf8 not modified utf-7.
+  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<nsIRDFResource> res;
+  rv = rdf->GetResource(uri, getter_AddRefs(res));
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(res, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  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.swap(*aChild);
+
+  nsCOMPtr <nsIMsgImapMailFolder> imapChild = do_QueryInterface(*aChild);
+  if (imapChild)
+  {
+    imapChild->SetOnlineName(NS_LossyConvertUTF16toASCII(aName));
+    imapChild->SetHierarchyDelimiter(m_hierarchyDelimiter);
+  }
+  NotifyItemAdded(*aChild);
+  return rv;
+}
+
+nsresult nsImapMailFolder::AddSubfolderWithPath(nsAString& name, nsIFile *dbPath,
+                                             nsIMsgFolder **child, bool brandNew)
+{
+  NS_ENSURE_ARG_POINTER(child);
+  nsresult rv;
+  nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+  NS_ENSURE_SUCCESS(rv, 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<nsIRDFResource> res;
+  rv = rdf->GetResource(uri, getter_AddRefs(res));
+  if (NS_FAILED(rv))
+    return rv;
+
+  nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(res, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  folder->SetFilePath(dbPath);
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(folder, &rv);
+  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.swap(*child);
+  return NS_OK;
+}
+
+nsresult nsImapMailFolder::CreateSubFolders(nsIFile *path)
+{
+  nsresult rv = NS_OK;
+  nsAutoString currentFolderNameStr;    // online name
+  nsAutoString currentFolderDBNameStr;  // possibly munged name
+  nsCOMPtr<nsIMsgFolder> child;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr <nsISimpleEnumerator> children;
+  rv = path->GetDirectoryEntries(getter_AddRefs(children));
+  bool more = false;
+  if (children)
+    children->HasMoreElements(&more);
+  nsCOMPtr<nsIFile> dirEntry;
+
+  while (more)
+  {
+    nsCOMPtr<nsISupports> supports;
+    rv = children->GetNext(getter_AddRefs(supports));
+    dirEntry = do_QueryInterface(supports);
+    if (NS_FAILED(rv) || !dirEntry)
+      break;
+    rv = children->HasMoreElements(&more);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr <nsIFile> currentFolderPath = do_QueryInterface(dirEntry);
+    currentFolderPath->GetLeafName(currentFolderNameStr);
+    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 <nsIMsgFolderCacheElement> cacheElement;
+    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 utf7LeafName = currentFolderNameStr;
+
+    if (curFolder)
+    {
+      rv = GetFolderCacheElemFromFile(dbFile, getter_AddRefs(cacheElement));
+      if (NS_SUCCEEDED(rv) && cacheElement)
+      {
+        nsCString onlineFullUtf7Name;
+
+        uint32_t folderFlags;
+        rv = cacheElement->GetInt32Property("flags", (int32_t *) &folderFlags);
+        if (NS_SUCCEEDED(rv) && folderFlags & nsMsgFolderFlags::Virtual) //ignore virtual folders
+          continue;
+        int32_t hierarchyDelimiter;
+        rv = cacheElement->GetInt32Property("hierDelim", &hierarchyDelimiter);
+        if (NS_SUCCEEDED(rv) && hierarchyDelimiter == kOnlineHierarchySeparatorUnknown)
+        {
+          currentFolderPath->Remove(false);
+          continue; // blow away .msf files for folders with unknown delimiter.
+        }
+        rv = cacheElement->GetStringProperty("onlineName", onlineFullUtf7Name);
+        if (NS_SUCCEEDED(rv) && !onlineFullUtf7Name.IsEmpty())
+        {
+          CopyMUTF7toUTF16(onlineFullUtf7Name, currentFolderNameStr);
+          char delimiter = 0;
+          GetHierarchyDelimiter(&delimiter);
+          int32_t leafPos = currentFolderNameStr.RFindChar(delimiter);
+          if (leafPos > 0)
+            currentFolderNameStr.Cut(0, leafPos + 1);
+
+          // take the utf7 full online name, and determine the utf7 leaf name
+          CopyASCIItoUTF16(onlineFullUtf7Name, utf7LeafName);
+          leafPos = utf7LeafName.RFindChar(delimiter);
+          if (leafPos > 0)
+            utf7LeafName.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 utf7 name as the uri for the folder.
+    AddSubfolderWithPath(utf7LeafName, 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, which is in utf7 form.
+      if (!currentFolderNameStr.IsEmpty())
+        child->SetPrettyName(currentFolderNameStr);
+      child->SetMsgDatabase(nullptr);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetSubFolders(nsISimpleEnumerator **aResult)
+{
+  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(NS_LITERAL_CSTRING("INBOX"), kOnlineHierarchySeparatorUnknown, 0, true);
+      }
+    }
+
+    int32_t count = mSubFolders.Count();
+    nsCOMPtr<nsISimpleEnumerator> dummy;
+    for (int32_t i = 0; i < count; i++)
+      mSubFolders[i]->GetSubFolders(getter_AddRefs(dummy));
+
+    UpdateSummaryTotals(false);
+    if (NS_FAILED(rv)) return rv;
+  }
+
+  return aResult ? NS_NewArrayEnumerator(aResult, mSubFolders) : NS_ERROR_NULL_POINTER;
+}
+
+//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(NS_MSGDB_SERVICE_CONTRACTID, &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;
+  bool selectFolder = false;
+
+  // 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");
+
+  if (mFlags & nsMsgFolderFlags::Inbox || m_applyIncomingFilters)
+  {
+    if (!m_filterList)
+      rv = GetFilterList(aMsgWindow, getter_AddRefs(m_filterList));
+    // 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)
+  {
+    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(NS_MSGFILTERSERVICE_CONTRACTID, &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;
+        nsCOMPtr<nsISupportsArray> searchTerms;
+        uint32_t numSearchTerms = 0;
+        filter->GetSearchTerms(getter_AddRefs(searchTerms));
+        if (searchTerms)
+          searchTerms->Count(&numSearchTerms);
+        for (uint32_t termIndex = 0;
+             termIndex < numSearchTerms && !m_filterListRequiresBody;
+             termIndex++)
+        {
+          nsCOMPtr<nsIMsgSearchTerm> term;
+          rv = searchTerms->QueryElementAt(termIndex,
+                                           NS_GET_IID(nsIMsgSearchTerm),
+                                           getter_AddRefs(term));
+          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;
+          }
+        }
+
+        // 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;
+        }
+      }
+    }
+  }
+
+  selectFolder = true;
+
+  bool isServer;
+  rv = GetIsServer(&isServer);
+  if (NS_SUCCEEDED(rv) && isServer)
+  {
+    if (!m_haveDiscoveredAllFolders)
+    {
+      bool hasSubFolders = false;
+      GetHasSubFolders(&hasSubFolders);
+      if (!hasSubFolders)
+      {
+        rv = CreateClientSubfolderInfo(NS_LITERAL_CSTRING("Inbox"), kOnlineHierarchySeparatorUnknown,0, false);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      m_haveDiscoveredAllFolders = true;
+    }
+    selectFolder = false;
+  }
+  rv = GetDatabase();
+  if (NS_FAILED(rv))
+  {
+    ThrowAlertMsg("errorGettingDB", aMsgWindow);
+    return rv;
+  }
+  bool canOpenThisFolder = true;
+  GetCanOpenFolder(&canOpenThisFolder);
+
+  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(aMsgWindow, this, this);
+      if (goOnline)
+      {
+        m_urlListener = aUrlListener;
+        return goOnline->ProcessNextOperation();
+      }
+    }
+  }
+
+  // Check it we're password protecting the local store.
+  if (!PromptForMasterPasswordIfNecessary())
+    return NS_ERROR_FAILURE;
+
+  if (!canOpenThisFolder)
+    selectFolder = false;
+  // don't run select if we can't select the folder...
+  if (NS_SUCCEEDED(rv) && !m_urlRunning && selectFolder)
+  {
+    nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    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(mFolderLoadedAtom);
+    }
+  }
+  else if (NS_SUCCEEDED(rv))  // 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(mFolderLoadedAtom);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetMessages(nsISimpleEnumerator* *result)
+{
+  NS_ENSURE_ARG_POINTER(result);
+  if (!mDatabase)
+    GetDatabase();
+  if (mDatabase)
+    return mDatabase->EnumerateMessages(result);
+  return NS_ERROR_UNEXPECTED;
+}
+
+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;
+  }
+  else if (mIsServer && folderName.LowerCaseEqualsLiteral("inbox"))  // Inbox, a special folder
+  {
+    ThrowAlertMsg("folderExists", msgWindow);
+    return NS_MSG_FOLDER_EXISTS;
+  }
+
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  return imapService->CreateFolder(this, folderName, this, nullptr);
+}
+
+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_ConvertASCIItoUTF16 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<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIRDFResource> res;
+    nsCOMPtr<nsIMsgImapMailFolder> parentFolder;
+    nsAutoCString uri (mURI);
+    leafName.Assign(Substring(parentName, folderStart + 1));
+    parentName.SetLength(folderStart);
+
+    rv = CreateDirectoryForFolder(getter_AddRefs(path));
+    if (NS_FAILED(rv))
+      return rv;
+    uri.Append('/');
+    uri.Append(NS_LossyConvertUTF16toASCII(parentName));
+    rv = rdf->GetResource(uri, getter_AddRefs(res));
+    if (NS_FAILED(rv))
+      return rv;
+    parentFolder = do_QueryInterface(res, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoCString leafnameC;
+    LossyCopyUTF16toASCII(leafName, leafnameC);
+    return parentFolder->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(NS_MSGDB_SERVICE_CONTRACTID, &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_LossyConvertUTF16toASCII(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 = CopyMUTF7toUTF16(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_ConvertASCIItoUTF16(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)
+  {
+    nsCOMPtr <nsIAtom> folderCreateAtom;
+    if(NS_SUCCEEDED(rv) && child)
+    {
+      NotifyItemAdded(child);
+      folderCreateAtom = MsgGetAtom("FolderCreateCompleted");
+      child->NotifyFolderEvent(folderCreateAtom);
+      nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+      if (notifier)
+        notifier->NotifyFolderAdded(child);
+    }
+    else
+    {
+      folderCreateAtom = MsgGetAtom("FolderCreateFailed");
+      NotifyFolderEvent(folderCreateAtom);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::List()
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return imapService->ListFolder(this, this, nullptr);
+}
+
+NS_IMETHODIMP nsImapMailFolder::RemoveSubFolder (nsIMsgFolder *which)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMutableArray> folders(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+  NS_ENSURE_TRUE(folders, rv);
+  nsCOMPtr<nsISupports> folderSupport = do_QueryInterface(which, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  folders->AppendElement(folderSupport, false);
+  rv = nsMsgDBFolder::DeleteSubFolders(folders, nullptr);
+  which->Delete();
+  return rv;
+}
+
+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);
+      // get the corresponding RDF resource
+      // RDF will create the folder resource if it doesn't already exist
+      nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr<nsIRDFResource> resource;
+      rv = rdf->GetResource(parentName, getter_AddRefs(resource));
+      if (NS_FAILED(rv)) return rv;
+      msgParent = do_QueryInterface(resource, &rv);
+    }
+  }
+  if (msgParent)
+  {
+    nsString folderName;
+    GetName(folderName);
+    nsresult rv;
+    nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr <nsIURI> uri;
+    imapService->EnsureFolderExists(msgParent, folderName, urlListener, getter_AddRefs(uri));
+  }
+  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 <nsISimpleEnumerator> hdrs;
+    rv = mDatabase->EnumerateMessages(getter_AddRefs(hdrs));
+    NS_ENSURE_SUCCESS(rv, rv);
+    bool hasMore = false;
+
+    PRTime cutOffDay =
+      MsgConvertAgeInDaysToCutoffDate(numDaysToKeepOfflineMsgs);
+
+    nsCOMPtr <nsIMsgDBHdr> pHeader;
+    // 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<nsISupports> supports;
+      rv = hdrs->GetNext(getter_AddRefs(supports));
+      NS_ENSURE_SUCCESS(rv, rv);
+      pHeader = do_QueryInterface(supports, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      uint32_t msgFlags;
+      PRTime msgDate;
+      pHeader->GetFlags(&msgFlags);
+      if (msgFlags & nsMsgMessageFlags::Offline)
+      {
+        pHeader->GetDate(&msgDate);
+        MarkPendingRemoval(pHeader, 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).
+ */
+NS_IMETHODIMP nsImapMailFolder::Compact(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();
+
+  m_urlListener = aListener;
+  // We should be able to compact the offline store now that this should
+  // just be called by the UI.
+  if (aMsgWindow && (mFlags & nsMsgFolderFlags::Offline))
+  {
+    m_compactingOfflineStore = true;
+    CompactOfflineStore(aMsgWindow, this);
+  }
+  if (WeAreOffline())
+    return NS_OK;
+  m_expunging = true;
+  return Expunge(this, aMsgWindow);
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::NotifyCompactCompleted()
+{
+  if (!m_expunging && m_urlListener)
+  {
+    m_urlListener->OnStopRunningUrl(nullptr, NS_OK);
+    m_urlListener = nullptr;
+  }
+  m_compactingOfflineStore = false;
+  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" : "");
+  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(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return imapService->Expunge(this, aListener, aMsgWindow, nullptr);
+}
+
+NS_IMETHODIMP nsImapMailFolder::CompactAll(nsIUrlListener *aListener,
+                                               nsIMsgWindow *aMsgWindow,
+                                               bool aCompactOfflineAlso)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMutableArray> folderArray, offlineFolderArray;
+
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  nsCOMPtr<nsIArray> allDescendents;
+  rv = GetRootFolder(getter_AddRefs(rootFolder));
+  if (NS_SUCCEEDED(rv) && rootFolder)
+  {
+    rootFolder->GetDescendants(getter_AddRefs(allDescendents));
+    uint32_t cnt = 0;
+    rv = allDescendents->GetLength(&cnt);
+    NS_ENSURE_SUCCESS(rv, rv);
+    folderArray = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+    NS_ENSURE_TRUE(folderArray, rv);
+    if (aCompactOfflineAlso)
+    {
+      offlineFolderArray = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+      NS_ENSURE_TRUE(offlineFolderArray, rv);
+    }
+    for (uint32_t i = 0; i < cnt; i++)
+    {
+      nsCOMPtr<nsIMsgFolder> folder = do_QueryElementAt(allDescendents, i, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      uint32_t folderFlags;
+      folder->GetFlags(&folderFlags);
+      if (! (folderFlags & (nsMsgFolderFlags::Virtual | nsMsgFolderFlags::ImapNoselect)))
+      {
+        rv = folderArray->AppendElement(folder, false);
+        if (aCompactOfflineAlso)
+          offlineFolderArray->AppendElement(folder, false);
+      }
+    }
+    rv = folderArray->GetLength(&cnt);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (cnt == 0)
+      return NotifyCompactCompleted();
+  }
+  nsCOMPtr <nsIMsgFolderCompactor> folderCompactor =
+    do_CreateInstance(NS_MSGLOCALFOLDERCOMPACTOR_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return folderCompactor->CompactFolders(folderArray, offlineFolderArray,
+                                         aListener, aMsgWindow);
+}
+
+NS_IMETHODIMP nsImapMailFolder::UpdateStatus(nsIUrlListener *aListener, nsIMsgWindow *aMsgWindow)
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &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(nsIMsgWindow *aMsgWindow, nsIUrlListener *aListener)
+{
+  nsCOMPtr<nsIMsgFolder> trashFolder;
+  nsresult rv = GetTrashFolder(getter_AddRefs(trashFolder));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &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.
+
+    nsCOMPtr<nsIMsgDatabase> trashDB;
+    if (WeAreOffline())
+    {
+      nsCOMPtr <nsIMsgDatabase> trashDB;
+      rv = trashFolder->GetMsgDatabase(getter_AddRefs(trashDB));
+      if (trashDB)
+      {
+        nsMsgKey fakeKey;
+        trashDB->GetNextFakeOfflineMsgKey(&fakeKey);
+
+        nsCOMPtr <nsIMsgOfflineImapOperation> op;
+        rv = trashDB->GetOfflineOpForKey(fakeKey, true, getter_AddRefs(op));
+        trashFolder->SetFlag(nsMsgFolderFlags::OfflineEvents);
+        op->SetOperation(nsIMsgOfflineImapOperation::kDeleteAllMsgs);
+      }
+      return rv;
+    }
+    nsCOMPtr <nsIDBFolderInfo> transferInfo;
+    rv = trashFolder->GetDBTransferInfo(getter_AddRefs(transferInfo));
+    rv = trashFolder->Delete(); // delete summary spec
+    trashFolder->SetDBTransferInfo(transferInfo);
+
+    trashFolder->SetSizeOnDisk(0);
+    nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (aListener)
+      rv = imapService->DeleteAllMessages(trashFolder, aListener, nullptr);
+    else
+    {
+      nsCOMPtr<nsIUrlListener> urlListener = do_QueryInterface(trashFolder);
+      rv = imapService->DeleteAllMessages(trashFolder, urlListener, nullptr);
+    }
+    // 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);
+
+    bool hasSubfolders = false;
+    rv = trashFolder->GetHasSubFolders(&hasSubfolders);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (hasSubfolders)
+    {
+      nsCOMPtr<nsISimpleEnumerator> enumerator;
+      nsCOMPtr<nsISupports> item;
+      nsCOMArray<nsIMsgFolder> array;
+
+      rv = trashFolder->GetSubFolders(getter_AddRefs(enumerator));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      bool hasMore;
+      while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore)
+      {
+        rv = enumerator->GetNext(getter_AddRefs(item));
+        if (NS_SUCCEEDED(rv))
+        {
+          nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(item, &rv));
+          if (NS_SUCCEEDED(rv))
+            array.AppendObject(folder);
+        }
+      }
+      for (int32_t i = array.Count() - 1; i >= 0; i--)
+      {
+        trashFolder->PropagateDelete(array[i], true, aMsgWindow);
+        // Remove the object, presumably to free it up before we delete the next.
+        array.RemoveObjectAt(i);
+      }
+    }
+
+    // The trash folder has effectively been deleted
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+    if (notifier)
+      notifier->NotifyFolderDeleted(trashFolder);
+
+    return NS_OK;
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::Delete()
+{
+  nsresult rv;
+  if (!mDatabase)
+  {
+    // Check if anyone has this db open. If so, do a force closed.
+    nsCOMPtr<nsIMsgDBService> msgDBService = do_GetService(NS_MSGDB_SERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    msgDBService->CachedDBForFolder(this, getter_AddRefs(mDatabase));
+  }
+  if (mDatabase)
+  {
+    mDatabase->ForceClosed();
+    mDatabase = nullptr;
+  }
+
+  nsCOMPtr<nsIFile> path;
+  rv = GetFilePath(getter_AddRefs(path));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIFile> summaryLocation;
+    rv = GetSummaryFileLocation(path, getter_AddRefs(summaryLocation));
+    if (NS_SUCCEEDED(rv))
+    {
+      bool exists = false;
+      rv = summaryLocation->Exists(&exists);
+      if (NS_SUCCEEDED(rv) && exists)
+      {
+        rv = summaryLocation->Remove(false);
+        if (NS_FAILED(rv))
+          NS_WARNING("failed to remove imap summary file");
+      }
+    }
+  }
+  if (mPath)
+    mPath->Remove(false);
+  // 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)
+      {
+        const char16_t *formatStrings[] =
+        {
+          (const char16_t*)(intptr_t)m_hierarchyDelimiter
+        };
+        nsString alertString;
+        rv = bundle->FormatStringFromName(
+          u"imapSpecialChar",
+          formatStrings, 1, getter_Copies(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);
+        const char16_t *titleParams[] = { accountName.get() };
+        rv = bundle->FormatStringFromName(
+          u"imapAlertDialogTitle",
+          titleParams, 1, getter_Copies(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(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return imapService->RenameLeaf(this, newName, this, msgWindow, nullptr);
+}
+
+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)
+{
+  // XXX Here it's assumed that IMAP folder names are stored locally
+  // in modified UTF-7 (ASCII-only) as is stored remotely.  If we ever change
+  // this, we have to work with nsString instead of nsCString
+  // (ref. bug 264071)
+  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));
+
+  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 += ".sbd";
+    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);
+    incomingServer.swap(*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, 1, nullptr);
+    else if (aDispositionFlag == nsIMsgFolder::nsMsgDispositionState_Forwarded)
+      StoreImapFlags(kImapMsgForwardedFlag, true, &msgKey, 1, nullptr);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::MarkMessagesRead(nsIArray *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.Elements(), keysToMarkRead.Length(), nullptr);
+    rv = GetDatabase();
+    if (NS_SUCCEEDED(rv))
+      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetLabelForMessages(nsIArray *aMessages, nsMsgLabelValue aLabel)
+{
+  NS_ENSURE_ARG(aMessages);
+
+  nsresult rv = nsMsgDBFolder::SetLabelForMessages(aMessages, aLabel);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsAutoCString messageIds;
+    nsTArray<nsMsgKey> keysToLabel;
+    nsresult rv = BuildIdsAndKeyArray(aMessages, messageIds, keysToLabel);
+    NS_ENSURE_SUCCESS(rv, rv);
+    StoreImapFlags((aLabel << 9), true, keysToLabel.Elements(), keysToLabel.Length(), 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))
+  {
+    nsMsgKey *thoseMarked;
+    uint32_t numMarked;
+    EnableNotifications(allMessageCountNotifications, false, true /*dbBatching*/);
+    rv = mDatabase->MarkAllRead(&numMarked, &thoseMarked);
+    EnableNotifications(allMessageCountNotifications, true, true /*dbBatching*/);
+    if (NS_SUCCEEDED(rv) && numMarked)
+    {
+      rv = StoreImapFlags(kImapMsgSeenFlag, true, thoseMarked,
+                          numMarked, nullptr);
+      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+
+      // Setup a undo-state
+      if (aMsgWindow)
+        rv = AddMarkAllReadUndoAction(aMsgWindow, thoseMarked, numMarked);
+      free(thoseMarked);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::MarkThreadRead(nsIMsgThread *thread)
+{
+  nsresult rv = GetDatabase();
+  if(NS_SUCCEEDED(rv))
+  {
+    nsMsgKey *keys;
+    uint32_t numKeys;
+    rv = mDatabase->MarkThreadRead(thread, nullptr, &numKeys, &keys);
+    if (NS_SUCCEEDED(rv) && numKeys)
+    {
+      rv = StoreImapFlags(kImapMsgSeenFlag, true, keys, numKeys, nullptr);
+      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+      free(keys);
+    }
+  }
+  return rv;
+}
+
+
+NS_IMETHODIMP nsImapMailFolder::ReadFromFolderCacheElem(nsIMsgFolderCacheElement *element)
+{
+  nsresult rv = nsMsgDBFolder::ReadFromFolderCacheElem(element);
+  int32_t hierarchyDelimiter = kOnlineHierarchySeparatorUnknown;
+  nsCString onlineName;
+
+  element->GetInt32Property("boxFlags", &m_boxFlags);
+  if (NS_SUCCEEDED(element->GetInt32Property("hierDelim", &hierarchyDelimiter))
+      && hierarchyDelimiter != kOnlineHierarchySeparatorUnknown)
+    m_hierarchyDelimiter = (char) hierarchyDelimiter;
+  rv = element->GetStringProperty("onlineName", onlineName);
+  if (NS_SUCCEEDED(rv) && !onlineName.IsEmpty())
+    m_onlineFolderName.Assign(onlineName);
+
+  m_aclFlags = kAclInvalid; // init to invalid value.
+  element->GetInt32Property("aclFlags", (int32_t *) &m_aclFlags);
+  element->GetInt32Property("serverTotal", &m_numServerTotalMessages);
+  element->GetInt32Property("serverUnseen", &m_numServerUnseenMessages);
+  element->GetInt32Property("serverRecent", &m_numServerRecentMessages);
+  element->GetInt32Property("nextUID", &m_nextUID);
+  int32_t lastSyncTimeInSec;
+  if ( NS_FAILED(element->GetInt32Property("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->SetInt32Property("boxFlags", m_boxFlags);
+  element->SetInt32Property("hierDelim", (int32_t) m_hierarchyDelimiter);
+  element->SetStringProperty("onlineName", m_onlineFolderName);
+  element->SetInt32Property("aclFlags", (int32_t) m_aclFlags);
+  element->SetInt32Property("serverTotal", m_numServerTotalMessages);
+  element->SetInt32Property("serverUnseen", m_numServerUnseenMessages);
+  element->SetInt32Property("serverRecent", m_numServerRecentMessages);
+  if (m_nextUID != (int32_t) nsMsgKey_None)
+    element->SetInt32Property("nextUID", m_nextUID);
+
+  // store folder's last sync time
+  if (m_autoSyncStateObj)
+  {
+    PRTime lastSyncTime;
+    m_autoSyncStateObj->GetLastSyncTime(&lastSyncTime);
+    // store in sec
+    element->SetInt32Property("lastSyncTimeInSec", (int32_t) (lastSyncTime / PR_USEC_PER_SEC));
+  }
+   
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::MarkMessagesFlagged(nsIArray *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.Elements(),
+                        keysToMarkFlagged.Length(), 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;
+    CopyASCIItoUTF16(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));
+      if (m_hierarchyDelimiter != '/')
+        MsgReplaceChar(onlineCName, '/', m_hierarchyDelimiter);
+      m_onlineFolderName.Assign(onlineCName);
+      CopyASCIItoUTF16(onlineCName, autoOnlineName);
+    }
+    (*folderInfo)->SetProperty("onlineName", autoOnlineName);
+  }
+  return rv;
+}
+
+/* static */ nsresult
+nsImapMailFolder::BuildIdsAndKeyArray(nsIArray* messages,
+                                      nsCString& msgIds,
+                                      nsTArray<nsMsgKey>& keyArray)
+{
+  NS_ENSURE_ARG_POINTER(messages);
+  nsresult rv;
+  uint32_t count = 0;
+  uint32_t i;
+  rv = messages->GetLength(&count);
+  if (NS_FAILED(rv)) return rv;
+
+  // build up message keys.
+  for (i = 0; i < count; i++)
+  {
+    nsMsgKey key;
+    nsCOMPtr <nsIMsgDBHdr> msgDBHdr = do_QueryElementAt(messages, i, &rv);
+    if (msgDBHdr)
+      rv = msgDBHdr->GetMessageKey(&key);
+    if (NS_SUCCEEDED(rv))
+      keyArray.AppendElement(key);
+  }
+  return AllocateUidStringFromKeys(keyArray.Elements(), keyArray.Length(), msgIds);
+}
+
+static int CompareKey (const void *v1, const void *v2, void *)
+{
+  // QuickSort callback to compare array values
+  nsMsgKey i1 = *(nsMsgKey *)v1;
+  nsMsgKey i2 = *(nsMsgKey *)v2;
+  return i1 - i2;
+}
+
+/* static */nsresult
+nsImapMailFolder::AllocateUidStringFromKeys(nsMsgKey *keys, uint32_t numKeys, nsCString &msgIds)
+{
+  if (!numKeys)
+    return NS_ERROR_INVALID_ARG;
+  nsresult rv = NS_OK;
+  uint32_t startSequence;
+  startSequence = keys[0];
+  uint32_t curSequenceEnd = startSequence;
+  uint32_t total = numKeys;
+  // sort keys and then generate ranges instead of singletons!
+  NS_QuickSort(keys, numKeys, sizeof(nsMsgKey), CompareKey, nullptr);
+  for (uint32_t keyIndex = 0; keyIndex < total; keyIndex++)
+  {
+    uint32_t curKey = keys[keyIndex];
+    uint32_t nextKey = (keyIndex + 1 < total) ? keys[keyIndex + 1] : 0xFFFFFFFF;
+    bool lastKey = (nextKey == 0xFFFFFFFF);
+
+    if (lastKey)
+      curSequenceEnd = curKey;
+    if (nextKey == (uint32_t) curSequenceEnd + 1 && !lastKey)
+    {
+      curSequenceEnd = nextKey;
+      continue;
+    }
+    else if (curSequenceEnd > startSequence)
+    {
+      AppendUid(msgIds, startSequence);
+      msgIds += ':';
+      AppendUid(msgIds,curSequenceEnd);
+      if (!lastKey)
+        msgIds += ',';
+      startSequence = nextKey;
+      curSequenceEnd = startSequence;
+    }
+    else
+    {
+      startSequence = nextKey;
+      curSequenceEnd = startSequence;
+      AppendUid(msgIds, keys[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(nsIArray *messages,
+                                               nsIMsgWindow *msgWindow,
+                                               bool deleteStorage, bool isMove,
+                                               nsIMsgCopyServiceListener* listener,
+                                               bool allowUndo)
+{
+  // *** jt - assuming delete is move to the trash folder for now
+  nsCOMPtr<nsIRDFResource> res;
+  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(messages, 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)
+    {
+      uint32_t cnt, flags;
+      rv = messages->GetLength(&cnt);
+      NS_ENSURE_SUCCESS(rv, rv);
+      deleteMsgs = false;
+      for (uint32_t i=0; i <cnt; i++)
+      {
+        nsCOMPtr <nsIMsgDBHdr> msgHdr = do_QueryElementAt(messages, i);
+        if (msgHdr)
+        {
+          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.Elements(),
+                        srcKeyArray.Length(), urlListener);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      if (mDatabase)
+      {
+        nsCOMPtr<nsIMsgDatabase> database(mDatabase);
+        if (deleteModel == nsMsgImapDeleteModels::IMAPDelete)
+          MarkMessagesImapDeleted(&srcKeyArray, deleteMsgs, database);
+        else
+        {
+          EnableNotifications(allMessageCountNotifications, false, true /*dbBatching*/);  //"remove it immediately" model
+          // Notify if this is an actual delete.
+          if (!isMove)
+          {
+            nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+            if (notifier)
+              notifier->NotifyMsgsDeleted(messages);
+          }
+          DeleteStoreMessages(messages);
+          database->DeleteMessages(srcKeyArray.Length(), srcKeyArray.Elements(), nullptr);
+          EnableNotifications(allMessageCountNotifications, true, true /*dbBatching*/);
+        }
+        NotifyFolderEvent(mDeleteOrMoveMsgCompletedAtom);
+      }
+    }
+    return rv;
+  }
+  else  // have to move the messages to the trash
+  {
+    if(trashFolder)
+    {
+      nsCOMPtr<nsIMsgFolder> srcFolder;
+      nsCOMPtr<nsISupports>srcSupport;
+      uint32_t count = 0;
+      rv = messages->GetLength(&count);
+
+      rv = QueryInterface(NS_GET_IID(nsIMsgFolder), getter_AddRefs(srcFolder));
+      nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = copyService->CopyMessages(srcFolder, messages, 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::DeleteSubFolders(nsIArray* folders, nsIMsgWindow *msgWindow)
+{
+  nsCOMPtr<nsIMsgFolder> curFolder;
+  nsCOMPtr<nsIUrlListener> urlListener;
+  nsCOMPtr<nsIMsgFolder> trashFolder;
+  int32_t i;
+  uint32_t folderCount = 0;
+  nsresult rv;
+  // "this" is the folder we're deleting from
+  bool deleteNoTrash = TrashOrDescendentOfTrash(this) || !DeleteIsMoveToTrash();
+  bool confirmed = false;
+  bool confirmDeletion = true;
+
+  nsCOMPtr<nsIMutableArray> foldersRemaining(do_CreateInstance(NS_ARRAY_CONTRACTID));
+  folders->GetLength(&folderCount);
+
+  for (i = folderCount - 1; i >= 0; i--)
+  {
+    curFolder = do_QueryElementAt(folders, i, &rv);
+    if (NS_SUCCEEDED(rv))
+    {
+      uint32_t folderFlags;
+      curFolder->GetFlags(&folderFlags);
+      if (folderFlags & nsMsgFolderFlags::Virtual)
+      {
+        RemoveSubFolder(curFolder);
+        // since the folder pane only allows single selection, we can do this
+        deleteNoTrash = confirmed = true;
+        confirmDeletion = false;
+      }
+      else
+        foldersRemaining->InsertElementAt(curFolder, 0, false);
+    }
+  }
+
+  foldersRemaining->GetLength(&folderCount);
+
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &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 (!confirmed && (confirmDeletion || deleteNoTrash)) //let us alert the user if we are deleting folder immediately
+  {
+    nsCOMPtr<nsIStringBundle> bundle;
+    rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString folderName;
+    rv = curFolder->GetName(folderName);
+    NS_ENSURE_SUCCESS(rv, rv);
+    const char16_t *formatStrings[1] = { folderName.get() };
+
+    nsAutoString deleteFolderDialogTitle;
+    rv = bundle->GetStringFromName(
+      u"imapDeleteFolderDialogTitle",
+      getter_Copies(deleteFolderDialogTitle));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString deleteFolderButtonLabel;
+    rv = bundle->GetStringFromName(
+      u"imapDeleteFolderButtonLabel",
+      getter_Copies(deleteFolderButtonLabel));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString confirmationStr;
+    rv = bundle->FormatStringFromName((deleteNoTrash) ?
+        u"imapDeleteNoTrash" :
+        u"imapMoveFolderToTrash",
+      formatStrings, 1, getter_Copies(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)
+  {
+    for (i = 0; i < (int32_t) folderCount; i++)
+    {
+      curFolder = do_QueryElementAt(foldersRemaining, i, &rv);
+      if (NS_SUCCEEDED(rv))
+      {
+        urlListener = do_QueryInterface(curFolder);
+        if (deleteNoTrash)
+          rv = imapService->DeleteFolder(curFolder,
+                                         urlListener,
+                                         msgWindow,
+                                         nullptr);
+        else
+        {
+          bool confirm = false;
+          bool match = false;
+          rv = curFolder->MatchOrChangeFilterDestination(nullptr, false, &match);
+          if (match)
+          {
+            curFolder->ConfirmFolderDeletionForFilter(msgWindow, &confirm);
+            if (!confirm)
+              return NS_OK;
+          }
+          rv = imapService->MoveFolder(curFolder,
+                                       trashFolder,
+                                       urlListener,
+                                       msgWindow,
+                                       nullptr);
+        }
+      }
+    }
+  }
+  //delete subfolders only if you are  deleting things from trash
+  return confirmed && deleteNoTrash ? nsMsgDBFolder::DeleteSubFolders(foldersRemaining, msgWindow) : 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;
+  NS_IF_RELEASE(m_moveCoalescer);
+  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 <nsISimpleEnumerator> enumerator;
+  nsresult rv = mDatabase->EnumerateMessages(getter_AddRefs(enumerator));
+  if (NS_SUCCEEDED(rv) && enumerator)
+  {
+    bool hasMore;
+    while (NS_SUCCEEDED(rv = enumerator->HasMoreElements(&hasMore)) && hasMore)
+    {
+      nsCOMPtr <nsISupports> supports;
+      rv = enumerator->GetNext(getter_AddRefs(supports));
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr <nsIMsgDBHdr> pHeader = do_QueryInterface(supports, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      bool shouldStoreMsgOffline = false;
+      nsMsgKey msgKey;
+      pHeader->GetMessageKey(&msgKey);
+      // MsgFitsDownloadCriteria ignores nsMsgFolderFlags::Offline, which we want
+      if (m_downloadingFolderForOfflineUse)
+        MsgFitsDownloadCriteria(msgKey, &shouldStoreMsgOffline);
+      else
+        ShouldStoreMsgOffline(msgKey, &shouldStoreMsgOffline);
+      if (shouldStoreMsgOffline)
+        keysOfMessagesToDownload->AppendElement(msgKey);
+    }
+  }
+  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.
+  m_numServerUnseenMessages = 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);
+      char intStrBuf[40];
+      PR_snprintf(intStrBuf, sizeof(intStrBuf), "%llu",  mailboxHighestModSeq);
+      dbFolderInfo->SetCharProperty(kModSeqPropertyName, nsDependentCString(intStrBuf));
+    }
+    RefPtr<nsMsgKeyArray> keys = new nsMsgKeyArray;
+    if (!keys)
+      return NS_ERROR_OUT_OF_MEMORY;
+    rv = mDatabase->ListAllKeys(keys);
+    NS_ENSURE_SUCCESS(rv, rv);
+    existingKeys.AppendElements(keys->m_keys);
+    mDatabase->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(NS_MSGDB_SERVICE_CONTRACTID, &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.
+      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;
+  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)
+  {
+    nsCOMPtr<nsIMutableArray> hdrsToDelete(do_CreateInstance(NS_ARRAY_CONTRACTID));
+    MsgGetHeadersFromKeys(mDatabase, keysToDelete, hdrsToDelete);
+    // Notify nsIMsgFolderListeners of a mass delete, but only if we actually have headers
+    uint32_t numHdrs;
+    hdrsToDelete->GetLength(&numHdrs);
+    if (numHdrs)
+    {
+      nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+      if (notifier)
+        notifier->NotifyMsgsDeleted(hdrsToDelete);
+    }
+    DeleteStoreMessages(hdrsToDelete);
+    EnableNotifications(nsIMsgFolder::allMessageCountNotifications, false, false);
+    mDatabase->DeleteMessages(keysToDelete.Length(), keysToDelete.Elements(), nullptr);
+    EnableNotifications(nsIMsgFolder::allMessageCountNotifications, true, false);
+  }
+  int32_t numUnreadFromServer;
+  aSpec->GetNumUnseenMessages(&numUnreadFromServer);
+  
+  bool partialUIDFetch;
+  flagState->GetPartialUIDFetch(&partialUIDFetch);
+  
+  // For partial UID fetches, we can only trust the numUnread from the server.
+  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)
+  {
+    // 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 && (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);
+  aSpec->GetNumUnseenMessages(&m_numServerUnseenMessages);
+  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;
+}
+
+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 != 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;
+    const char *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, strlen(msgHdrs));
+      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, 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);
+
+    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));
+
+    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, 1, 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, 1, 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.
+          m_filterList->ApplyFiltersToHdr(nsMsgFilterType::InboxRule, newMsgHdr,
+                                          this, mDatabase, headers, headersSize,
+                                          this, msgWindow);
+          NotifyFolderEvent(mFiltersAppliedAtom);
+        }
+      }
+    }
+  }
+  // here we need to tweak flags from uid state..
+  if (mDatabase && (!m_msgMovedByFilter || ShowDeletedMessages()))
+  {
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+    // 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;
+    nsMsgKey pseudoKey = nsMsgKey_None;
+    newMsgHdr->GetMessageId(getter_Copies(newMessageId));
+    m_pseudoHdrs.Get(newMessageId, &pseudoKey);
+    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)
+      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, NS_LITERAL_CSTRING("X-GM-MSGID"), msgIDValue);
+    flagState->GetCustomAttribute(m_curMsgUid, NS_LITERAL_CSTRING("X-GM-THRID"), threadIDValue);
+    flagState->GetCustomAttribute(m_curMsgUid, NS_LITERAL_CSTRING("X-GM-LABELS"), labelsValue);
+    newMsgHdr->SetStringProperty("X-GM-MSGID", msgIDValue.get());
+    newMsgHdr->SetStringProperty("X-GM-THRID", threadIDValue.get());
+    newMsgHdr->SetStringProperty("X-GM-LABELS", labelsValue.get());
+  }
+
+  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(nsIMsgDBHdr *message)
+{
+  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->GetNativePath(nativePath);
+      MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("couldn't remove prev temp file %s: %lx\n", nativePath.get(), rv));
+    }
+    m_copyState->m_tmpFile = nullptr;
+  }
+  if (message)
+    m_copyState->m_message = do_QueryInterface(message, &rv);
+
+  rv = GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR,
+                                       "nscpmsg.txt",
+                                        getter_AddRefs(m_copyState->m_tmpFile));
+  if (NS_FAILED(rv))
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("couldn't find nscpmsg.txt:%lx\n", rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // create a unique file, since multiple copies may be open on multiple folders
+  rv = m_copyState->m_tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
+  if (NS_FAILED(rv))
+  {
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("couldn't create temp nscpmsg.txt:%lx\n", rv));
+    // Last ditch attempt to create a temp file, because virus checker might
+    // be locking the previous temp file, and CreateUnique fails if the file
+    // is locked. Use the message key to make a unique name.
+    if (message)
+    {
+      nsCString tmpFileName("nscpmsg-");
+      nsMsgKey msgKey;
+      message->GetMessageKey(&msgKey);
+      tmpFileName.AppendInt(msgKey);
+      tmpFileName.Append(".txt");
+      m_copyState->m_tmpFile->SetNativeLeafName(tmpFileName);
+      rv = m_copyState->m_tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
+      if (NS_FAILED(rv))
+      {
+        MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("couldn't create temp nscpmsg.txt:%lx\n", rv));
+        OnCopyCompleted(m_copyState->m_srcSupport, rv);
+        return 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:%lx\n", 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:%lx\n", 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(NS_IMAPSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    rv = QueryInterface(NS_GET_IID(nsIUrlListener), getter_AddRefs(urlListener));
+    nsCOMPtr<nsISupports> copySupport;
+    if (m_copyState)
+      copySupport = do_QueryInterface(m_copyState);
+    rv = imapService->AppendMessageFromFile(m_copyState->m_tmpFile,
+                                            this, EmptyCString(), true,
+                                            m_copyState->m_selectedState,
+                                            urlListener, nullptr,
+                                            copySupport,
+                                            m_copyState->m_msgWindow);
+  }
+  if (NS_FAILED(rv) || !copySucceeded)
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("EndCopy failed:%lx\n", 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;
+
+  // look at action - currently handle move
+#ifdef DEBUG_bienvenu
+  printf("got a rule hit!\n");
+#endif
+
+  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();
+
+  nsCOMPtr<nsIArray> filterActionList;
+
+  rv = filter->GetSortedActionList(getter_AddRefs(filterActionList));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t numActions;
+  rv = filterActionList->GetLength(&numActions);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool loggingEnabled = false;
+  if (m_filterList && numActions)
+    (void)m_filterList->GetLoggingEnabled(&loggingEnabled);
+
+  bool msgIsNew = true;
+
+  for (uint32_t actionIndex = 0; actionIndex < numActions; actionIndex++)
+  {
+    nsCOMPtr<nsIMsgRuleAction> filterAction;
+    rv = filterActionList->QueryElementAt(actionIndex, NS_GET_IID(nsIMsgRuleAction),
+                                                       getter_AddRefs(filterAction));
+    if (NS_FAILED(rv) || !filterAction)
+      continue;
+
+    nsMsgRuleActionType actionType;
+    if (NS_SUCCEEDED(filterAction->GetType(&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())
+        {
+          NS_ASSERTION(false, "actionTargetFolderUri is empty");
+          continue;
+        }
+      }
+
+      uint32_t msgFlags;
+      nsMsgKey    msgKey;
+      nsAutoCString trashNameVal;
+
+      msgHdr->GetFlags(&msgFlags);
+      msgHdr->GetMessageKey(&msgKey);
+      bool isRead = (msgFlags & nsMsgMessageFlags::Read);
+      nsresult rv = GetDatabase();
+      NS_ENSURE_SUCCESS(rv, rv);
+      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);
+            // msgHdr->OrFlags(nsMsgMessageFlags::Read, &newFlags);  // mark read in trash.
+          }
+          else  // (!deleteToTrash)
+          {
+            mDatabase->MarkHdrRead(msgHdr, true, nullptr);
+            mDatabase->MarkImapDeleted(msgKey, true, nullptr);
+            StoreImapFlags(kImapMsgSeenFlag | kImapMsgDeletedFlag, true,
+                           &msgKey, 1, nullptr);
+            m_msgMovedByFilter = true; // this will prevent us from adding the header to the db.
+          }
+          msgIsNew = false;
+        }
+        // note that delete falls through to move.
+        MOZ_FALLTHROUGH;
+        case nsMsgFilterAction::MoveToFolder:
+        {
+          // if moving to a different file, do it.
+          nsCString uri;
+          rv = GetURI(uri);
+
+          if (!actionTargetFolderUri.Equals(uri))
+          {
+            msgHdr->GetFlags(&msgFlags);
+
+            if (msgFlags & nsMsgMessageFlags::MDNReportNeeded && !isRead)
+            {
+               mDatabase->MarkMDNNeeded(msgKey, false, nullptr);
+               mDatabase->MarkMDNSent(msgKey, true, nullptr);
+            }
+            nsresult err = MoveIncorporatedMessage(msgHdr, mDatabase, actionTargetFolderUri, filter, msgWindow);
+            if (NS_SUCCEEDED(err))
+              m_msgMovedByFilter = true;
+          }
+          // 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 (!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<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+            NS_ENSURE_TRUE(messageArray, rv);
+            messageArray->AppendElement(msgHdr, false);
+
+            nsCOMPtr<nsIMsgFolder> dstFolder;
+            rv = GetExistingFolder(actionTargetFolderUri, getter_AddRefs(dstFolder));
+            NS_ENSURE_SUCCESS(rv, rv);
+
+            nsCOMPtr<nsIMsgCopyService> copyService =
+              do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+            NS_ENSURE_SUCCESS(rv, rv);
+            rv = copyService->CopyMessages(this, messageArray, dstFolder,
+                                           false, nullptr, msgWindow, false);
+            NS_ENSURE_SUCCESS(rv, rv);
+          }
+        }
+        break;
+        case nsMsgFilterAction::MarkRead:
+        {
+          mDatabase->MarkHdrRead(msgHdr, true, nullptr);
+          StoreImapFlags(kImapMsgSeenFlag, true, &msgKey, 1, nullptr);
+          msgIsNew = false;
+        }
+        break;
+        case nsMsgFilterAction::MarkUnread:
+        {
+          mDatabase->MarkHdrRead(msgHdr, false, nullptr);
+          StoreImapFlags(kImapMsgSeenFlag, false, &msgKey, 1, nullptr);
+          msgIsNew = true;
+        }
+        break;
+        case nsMsgFilterAction::MarkFlagged:
+        {
+          mDatabase->MarkHdrMarked(msgHdr, true, nullptr);
+          StoreImapFlags(kImapMsgFlaggedFlag, true, &msgKey, 1, 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)
+              mDatabase->MarkThreadIgnored(msgThread, threadKey, true, nullptr);
+            else
+              mDatabase->MarkThreadWatched(msgThread, threadKey, true, nullptr);
+          }
+          else
+          {
+            if (actionType == nsMsgFilterAction::KillThread)
+              msgHdr->SetUint32Property("ProtoThreadFlags", nsMsgMessageFlags::Ignored);
+            else
+              msgHdr->SetUint32Property("ProtoThreadFlags", nsMsgMessageFlags::Watched);
+          }
+          if (actionType == nsMsgFilterAction::KillThread)
+          {
+            mDatabase->MarkHdrRead(msgHdr, true, nullptr);
+            StoreImapFlags(kImapMsgSeenFlag, true, &msgKey, 1, nullptr);
+            msgIsNew = false;
+          }
+        }
+        break;
+        case nsMsgFilterAction::KillSubthread:
+        {
+          mDatabase->MarkHeaderKilled(msgHdr, true, nullptr);
+          mDatabase->MarkHdrRead(msgHdr, true, nullptr);
+          StoreImapFlags(kImapMsgSeenFlag, true, &msgKey, 1, nullptr);
+          msgIsNew = false;
+        }
+        break;
+        case nsMsgFilterAction::ChangePriority:
+        {
+          nsMsgPriorityValue filterPriority; // a int32_t
+          filterAction->GetPriority(&filterPriority);
+          mDatabase->SetUint32PropertyByHdr(msgHdr, "priority",
+                                            static_cast<uint32_t>(filterPriority));
+        }
+        break;
+        case nsMsgFilterAction::Label:
+        {
+          nsMsgLabelValue filterLabel;
+          filterAction->GetLabel(&filterLabel);
+          mDatabase->SetUint32PropertyByHdr(msgHdr, "label",
+                                            static_cast<uint32_t>(filterLabel));
+          StoreImapFlags((filterLabel << 9), true, &msgKey, 1, nullptr);
+        }
+        break;
+        case nsMsgFilterAction::AddTag:
+        {
+          nsCString keyword;
+          filterAction->GetStrValue(keyword);
+          nsCOMPtr<nsIMutableArray> messageArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+          NS_ENSURE_TRUE(messageArray, rv);
+          messageArray->AppendElement(msgHdr, false);
+          AddKeywordsToMessages(messageArray, keyword);
+          break;
+        }
+        case nsMsgFilterAction::JunkScore:
+        {
+          nsAutoCString junkScoreStr;
+          int32_t junkScore;
+          filterAction->GetJunkScore(&junkScore);
+          junkScoreStr.AppendInt(junkScore);
+          mDatabase->SetStringProperty(msgKey, "junkscore", junkScoreStr.get());
+          mDatabase->SetStringProperty(msgKey, "junkscoreorigin", "filter");
+
+          // 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));
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (!forwardTo.IsEmpty())
+          {
+            nsCOMPtr<nsIMsgComposeService> compService =
+              do_GetService (NS_MSGCOMPOSESERVICE_CONTRACTID, &rv);
+            NS_ENSURE_SUCCESS(rv, rv);
+            rv = compService->ForwardMessage(NS_ConvertASCIItoUTF16(forwardTo),
+                                             msgHdr, msgWindow, server,
+                                             nsIMsgComposeService::kForwardAsDefault);
+          }
+        }
+        break;
+
+      case nsMsgFilterAction::Reply:
+        {
+          nsCString replyTemplateUri;
+          filterAction->GetStrValue(replyTemplateUri);
+          nsCOMPtr <nsIMsgIncomingServer> server;
+          GetServer(getter_AddRefs(server));
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (!replyTemplateUri.IsEmpty())
+          {
+            nsCOMPtr <nsIMsgComposeService> compService = do_GetService (NS_MSGCOMPOSESERVICE_CONTRACTID) ;
+            if (compService) {
+              rv = compService->ReplyWithTemplate(msgHdr, replyTemplateUri.get(), msgWindow, server);
+              if (NS_FAILED(rv)) {
+                NS_WARNING("ReplyWithTemplate failed");
+                if (rv == NS_ERROR_ABORT) {
+                  filter->LogRuleHitFail(filterAction, msgHdr, rv, "Sending reply aborted");
+                } else {
+                  filter->LogRuleHitFail(filterAction, msgHdr, rv, "Error sending reply");
+                }
+              }
+            }
+          }
+        }
+        break;
+
+        case nsMsgFilterAction::StopExecution:
+        {
+          // don't apply any more filters
+          *applyMore = false;
+        }
+        break;
+
+        case nsMsgFilterAction::Custom:
+        {
+          nsCOMPtr<nsIMsgFilterCustomAction> customAction;
+          rv = filterAction->GetCustomAction(getter_AddRefs(customAction));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          nsAutoCString value;
+          filterAction->GetStrValue(value);
+
+          nsCOMPtr<nsIMutableArray> messageArray(
+              do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+          NS_ENSURE_TRUE(messageArray, rv);
+          messageArray->AppendElement(msgHdr, false);
+
+          customAction->Apply(messageArray, value, nullptr,
+                              nsMsgFilterType::InboxRule, msgWindow);
+          // allow custom action to affect new
+          msgHdr->GetFlags(&msgFlags);
+          if (!(msgFlags & nsMsgMessageFlags::New))
+            msgIsNew = false;
+        }
+        break;
+
+        default:
+          break;
+      }
+    }
+  }
+  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);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::SetImapFlags(const char *uids, int32_t flags, nsIURI **url)
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &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(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return imapService->CreateFolder(this, aFolderName, this, url);
+}
+
+NS_IMETHODIMP 
+nsImapMailFolder::ReplayOfflineMoveCopy(nsMsgKey *aMsgKeys, uint32_t aNumKeys,
+                                        bool isMove, nsIMsgFolder *aDstFolder,
+                                        nsIUrlListener *aUrlListener, nsIMsgWindow *aWindow)
+{
+  nsresult rv;
+
+  nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(aDstFolder);
+  if (imapFolder)
+  {
+    nsImapMailFolder *destImapFolder = static_cast<nsImapMailFolder*>(aDstFolder);
+    nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID));
+    nsCOMPtr<nsIMsgDatabase> dstFolderDB;
+    aDstFolder->GetMsgDatabase(getter_AddRefs(dstFolderDB));
+    if (dstFolderDB)
+    {
+      // 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(dstFolderDB->ListAllOfflineOpIds(&offlineOps)))
+      {
+        nsCString srcFolderUri;
+        GetURI(srcFolderUri);
+        nsCOMPtr<nsIMsgOfflineImapOperation> currentOp;
+        for (uint32_t opIndex = 0; opIndex < offlineOps.Length(); opIndex++)
+        {
+          dstFolderDB->GetOfflineOpForKey(offlineOps[opIndex], false,
+                                          getter_AddRefs(currentOp));
+          if (currentOp)
+          {
+            nsCString opSrcUri;
+            currentOp->GetSourceFolderURI(getter_Copies(opSrcUri));
+            if (opSrcUri.Equals(srcFolderUri))
+            {
+              nsMsgKey srcMessageKey;
+              currentOp->GetSrcMessageKey(&srcMessageKey);
+              for (uint32_t msgIndex = 0; msgIndex < aNumKeys; msgIndex++)
+              {
+                if (srcMessageKey == aMsgKeys[msgIndex])
+                {
+                  nsCOMPtr<nsIMsgDBHdr> fakeDestHdr;
+                  dstFolderDB->GetMsgHdrForKey(offlineOps[opIndex],
+                    getter_AddRefs(fakeDestHdr));
+                  if (fakeDestHdr)
+                    messages->AppendElement(fakeDestHdr, false);
+                  break;
+                }
+              }
+            }
+          }
+        }
+        destImapFolder->SetPendingAttributes(messages, isMove);
+      }
+    }
+    // if we can't get the dst folder db, we should still try to playback
+    // the offline move/copy.
+  }
+
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr <nsIURI> resultUrl;
+  nsAutoCString uids;
+  AllocateUidStringFromKeys(aMsgKeys, aNumKeys, 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.Put(messageId, aMsgKey);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::StoreImapFlags(int32_t flags, bool addFlags,
+                                               nsMsgKey *keys, uint32_t numKeys,
+                                               nsIUrlListener *aUrlListener)
+{
+  nsresult rv;
+  if (!WeAreOffline())
+  {
+    nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoCString msgIds;
+    AllocateUidStringFromKeys(keys, numKeys, msgIds);
+    if (addFlags)
+      imapService->AddMessageFlags(this, aUrlListener ? aUrlListener : this,
+                                   nullptr, msgIds, flags, true);
+    else
+      imapService->SubtractMessageFlags(this, aUrlListener ? aUrlListener : this,
+                                        nullptr, msgIds, flags, true);
+  }
+  else
+  {
+    rv = GetDatabase();
+    if (NS_SUCCEEDED(rv) && mDatabase)
+    {
+      uint32_t total = numKeys;
+      for (uint32_t keyIndex = 0; keyIndex < total; keyIndex++)
+      {
+        nsCOMPtr <nsIMsgOfflineImapOperation> op;
+        rv = mDatabase->GetOfflineOpForKey(keys[keyIndex], true, getter_AddRefs(op));
+        SetFlag(nsMsgFolderFlags::OfflineEvents);
+        if (NS_SUCCEEDED(rv) && op)
+        {
+          imapMessageFlagsType newFlags;
+          op->GetNewFlags(&newFlags);
+          op->SetFlagOperation(addFlags ? newFlags | flags : newFlags & ~flags);
+        }
+      }
+      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit); // flush offline flags
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::LiteSelect(nsIUrlListener *aUrlListener,
+                                           nsIMsgWindow *aMsgWindow)
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return imapService->LiteSelectFolder(this, aUrlListener,
+                                       aMsgWindow, nullptr);
+}
+
+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->LoadUrl(uri);
+      }
+    }
+  }
+  else
+  {
+    nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &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(NS_IMAPSERVICE_CONTRACTID, &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(NS_IMAPSERVICE_CONTRACTID, &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<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIRDFResource> res;
+    rv = rdf->GetResource(destFolderUri, getter_AddRefs(res));
+    if (NS_FAILED(rv))
+      return rv;
+
+    nsCOMPtr<nsIMsgFolder> destIFolder(do_QueryInterface(res, &rv));
+    if (NS_FAILED(rv))
+      return 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 <nsISimpleEnumerator> hdrs;
+      nsresult rv = GetMessages(getter_AddRefs(hdrs));
+      NS_ENSURE_SUCCESS_VOID(rv);
+      bool hasMore = false;
+      nsCOMPtr <nsIMsgDBHdr> pHeader;
+      while (NS_SUCCEEDED(rv = hdrs->HasMoreElements(&hasMore)) && hasMore)
+      {
+        nsCOMPtr <nsISupports> supports;
+        rv = hdrs->GetNext(getter_AddRefs(supports));
+        NS_ENSURE_SUCCESS_VOID(rv);
+        pHeader = do_QueryInterface(supports, &rv);
+        NS_ENSURE_SUCCESS_VOID(rv);
+        uint32_t msgFlags;
+        pHeader->GetFlags(&msgFlags);
+        if (msgFlags & nsMsgMessageFlags::IMAPDeleted)
+        {
+          nsMsgKey msgKey;
+          pHeader->GetMessageKey(&msgKey);
+          keysToDelete.AppendElement(msgKey);
+        }
+      }
+    }
+    return;
+  }
+  // otherwise, we have a complete set of uid's and flags, so we delete
+  // anything thats 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) &&
+         (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;
+      else
+        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,
+                                                     uint32_t *aLength,
+                                                     nsMsgKey **aKeys)
+{
+  NS_ENSURE_ARG_POINTER(aMoreToDownload);
+  NS_ENSURE_ARG_POINTER(aTotalCount);
+  NS_ENSURE_ARG_POINTER(aLength);
+  NS_ENSURE_ARG_POINTER(aKeys);
+
+  *aMoreToDownload = false;
+  *aTotalCount = m_totalKeysToFetch;
+  if (m_keysToFetch.IsEmpty())
+  {
+    *aLength = 0;
+    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(NS_MSGMAILSESSION_CONTRACTID);
+  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 = (nsMsgKey *) nsMemory::Clone(&m_keysToFetch[startIndex],
+                                       numKeysToFetch * sizeof(nsMsgKey));
+  NS_ENSURE_TRUE(*aKeys, NS_ERROR_OUT_OF_MEMORY);
+  // 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);
+  *aLength = numKeysToFetch;
+
+  return NS_OK;
+}
+
+void nsImapMailFolder::PrepareToAddHeadersToMailDB(nsIImapProtocol* aProtocol)
+{
+  // now, tell it we don't need any bodies.
+  aProtocol->NotifyBodysToDownload(nullptr, 0);
+}
+
+void nsImapMailFolder::TweakHeaderFlags(nsIImapProtocol* aProtocol, nsIMsgDBHdr *tweakMe)
+{
+  if (mDatabase && aProtocol && tweakMe)
+  {
+    tweakMe->SetMessageKey(m_curMsgUid);
+    tweakMe->SetMessageSize(m_nextMessageByteLength);
+
+    bool foundIt = false;
+    imapMessageFlagsType imap_flags;
+
+    nsCString customFlags;
+    nsresult rv = aProtocol->GetFlagsForUID(m_curMsgUid, &foundIt, &imap_flags, getter_Copies(customFlags));
+    if (NS_SUCCEEDED(rv) && foundIt)
+    {
+      // 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:
+                    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;
+
+      // db label flags are 0x0E000000 and imap label flags are 0x0E00
+      // so we need to shift 16 bits to the left to convert them.
+      if (imap_flags & kImapMsgLabelFlags)
+      {
+        // we need to set label attribute on header because the dbview code
+        // does msgHdr->GetLabel when asked to paint a row
+        tweakMe->SetLabel((imap_flags & kImapMsgLabelFlags) >> 9);
+        newFlags |= (imap_flags & kImapMsgLabelFlags) << 16;
+      }
+      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);
+  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;
+
+    m_tempMessageStream->Write(result.get(), result.Length(), &writeCount);
+    result = "X-Mozilla-Status: 0001";
+    result += MSG_LINEBREAK;
+    m_tempMessageStream->Write(result.get(), result.Length(), &writeCount);
+    result =  "X-Mozilla-Status2: 00000000";
+    result += MSG_LINEBREAK;
+    m_tempMessageStream->Write(result.get(), result.Length(), &writeCount);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::DownloadMessagesForOffline(nsIArray *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(NS_IMAPSERVICE_CONTRACTID, &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(NS_IMAPSERVICE_CONTRACTID, &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)
+  {
+    nsCOMPtr <nsISeekableStream> seekable (do_QueryInterface(m_tempMessageStream));
+    if (seekable)
+      seekable->Seek(PR_SEEK_END, 0);
+    rv = m_tempMessageStream->Write(adoptedMessageLine,
+                PL_strlen(adoptedMessageLine), &count);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  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();
+
+  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, nullptr, 0, this,
+                                      msgWindow);
+      NotifyFolderEvent(mFiltersAppliedAtom);
+    }
+    // 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(NS_IMAPSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+    return imapService->AddMessageFlags(this, nullptr, nullptr,
+                                      messageIds,
+                                      kImapMsgDeletedFlag,
+                                      true);
+  }
+  /* unhandled copystate */
+  else 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(mDeleteOrMoveMsgCompletedAtom);
+  }
+  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;
+  // Mac Mail uses "NotJunk"
+  if (keywords.Find("NonJunk", CaseInsensitiveCompare) != kNotFound ||
+      keywords.Find("NotJunk", CaseInsensitiveCompare) != kNotFound)
+  {
+    nsAutoCString msgJunkScore;
+    msgJunkScore.AppendInt(nsIJunkMailPlugin::IS_HAM_SCORE);
+    mDatabase->SetStringProperty(uidOfMessage, "junkscore", msgJunkScore.get());
+  }
+  // ### TODO: we really should parse the keywords into space delimited keywords before checking
+  else if (keywords.Find("Junk", CaseInsensitiveCompare) != kNotFound)
+  {
+    uint32_t newFlags;
+    dbHdr->AndFlags(~nsMsgMessageFlags::New, &newFlags);
+    nsAutoCString msgJunkScore;
+    msgJunkScore.AppendInt(nsIJunkMailPlugin::IS_SPAM_SCORE);
+    mDatabase->SetStringProperty(uidOfMessage, "junkscore", msgJunkScore.get());
+  }
+  else
+    messageClassified = false;
+  if (messageClassified)
+  {
+    // only set the junkscore origin if it wasn't set before. 
+    nsCString existingProperty;
+    dbHdr->GetStringProperty("junkscoreorigin", getter_Copies(existingProperty));
+    if (existingProperty.IsEmpty())
+      dbHdr->SetStringProperty("junkscoreorigin", "imapflag");
+  }
+  return (userFlags & kImapMsgSupportUserFlag) ?
+          dbHdr->SetStringProperty("keywords", keywords.get()) : 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);
+    nsCOMPtr<nsIMsgDBHdr> dbHdr;
+    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;
+
+    rv = mDatabase->GetMsgHdrForKey(uidOfMessage, getter_AddRefs(dbHdr));
+    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(kFolderSizeAtom, 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);
+  // this turns on labels, but it doesn't handle the case where the user
+  // unlabels a message on one machine, and expects it to be unlabeled
+  // on their other machines. If I turn that on, I'll be removing all the labels
+  // that were assigned before we started storing them on the server, which will
+  // make some people very unhappy.
+  if (flags & kImapMsgLabelFlags)
+    database->SetLabel(msgKey, (flags & kImapMsgLabelFlags) >> 9);
+  else
+  {
+    if (supportedFlags & kImapMsgLabelFlags)
+      database->SetLabel(msgKey, 0);
+  }
+  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);
+          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.Length(), affectedMessages.Elements(), 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::SetContentModified(nsIImapUrl *aImapUrl, nsImapContentModifiedType modified)
+{
+  return aImapUrl->SetContentModified(modified);
+}
+
+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_message)
+    {
+      nsMsgLabelValue label;
+      mailCopyState->m_message->GetFlags(aResult);
+      if (supportedFlags & (kImapMsgSupportUserFlag | kImapMsgLabelFlags))
+      {
+        mailCopyState->m_message->GetLabel(&label);
+        if (label != 0)
+          *aResult |= label << 25;
+      }
+      if (aDate)
+        mailCopyState->m_message->GetDate(aDate);
+      if (supportedFlags & kImapMsgSupportUserFlag)
+      {
+        // setup the custom imap keywords, which includes the message keywords
+        // plus any junk status
+        nsCString junkscore;
+        mailCopyState->m_message->GetStringProperty("junkscore",
+                                                    getter_Copies(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
+        mailCopyState->m_message->GetStringProperty("keywords",
+                                                    getter_Copies(keywords));
+        int32_t start;
+        int32_t length;
+        bool hasJunk = MsgFindKeyword(NS_LITERAL_CSTRING("junk"),
+                                        keywords, &start, &length);
+        if (hasJunk && !isJunk)
+          keywords.Cut(start, length);
+        else if (!hasJunk && isJunk)
+          keywords.AppendLiteral(" Junk");
+        bool hasNonJunk = MsgFindKeyword(NS_LITERAL_CSTRING("nonjunk"),
+                                           keywords, &start, &length);
+        if (!hasNonJunk)
+          hasNonJunk = MsgFindKeyword(NS_LITERAL_CSTRING("notjunk"),
+                                      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_LITERAL_CSTRING("  "))) >= 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;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::OnStartRunningUrl(nsIURI *aUrl)
+{
+  NS_PRECONDITION(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;
+}
+
+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(NS_MSGMAILSESSION_CONTRACTID, &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(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+      if (notifier && m_copyState)
+      {
+        if (imapAction == nsIImapUrl::nsImapOnlineMove)
+          notifier->NotifyMsgsMoveCopyCompleted(true, m_copyState->m_messages, this, nullptr);
+        else if (imapAction == nsIImapUrl::nsImapOnlineCopy)
+          notifier->NotifyMsgsMoveCopyCompleted(false, m_copyState->m_messages, this, nullptr);
+        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.Length(), srcKeyArray.Elements(), nullptr);
+                }
+                else
+                  MarkMessagesImapDeleted(&srcKeyArray, true, srcDB);
+              }
+              srcFolder->EnableNotifications(allMessageCountNotifications, true, true/* dbBatching*/);
+              // even if we're showing deleted messages,
+              // we still need to notify FE so it will show the imap deleted flag
+              srcFolder->NotifyFolderEvent(mDeleteOrMoveMsgCompletedAtom);
+              // 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, true/* dbBatching*/);
+              srcFolder->NotifyFolderEvent(mDeleteOrMoveMsgFailedAtom);
+            }
+
+          }
+          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)
+            {
+              mozilla::DebugOnly<nsresult> rv2 = txnMgr->DoTransaction(m_copyState->m_undoMsgTxn);
+              NS_ASSERTION(NS_SUCCEEDED(rv2), "doing transaction failed");
+            }
+          }
+          (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;
+                uint32_t numHdrs = 0;
+                nsCOMPtr<nsIMsgPluggableStore> offlineStore;
+                (void) GetMsgStore(getter_AddRefs(offlineStore));
+                if (offlineStore)
+                  offlineStore->GetSupportsCompaction(&supportsCompaction);
+
+                nsCOMPtr<nsIMutableArray> msgHdrs;
+                if (notifier || !supportsCompaction)
+                {
+                  msgHdrs = do_CreateInstance(NS_ARRAY_CONTRACTID);
+                  NS_ENSURE_STATE(msgHdrs);
+                  MsgGetHeadersFromKeys(db, keyArray, msgHdrs);
+                  msgHdrs->GetLength(&numHdrs);
+                }
+
+                // Notify listeners of delete.
+                if (notifier && numHdrs)
+                {
+                  // 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 && numHdrs)
+                  DeleteStoreMessages(msgHdrs);
+
+                db->DeleteMessages(keyArray.Length(), keyArray.Elements(), 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_totalCount)
+              {
+                nsCOMPtr<nsIUrlListener> saveUrlListener = m_urlListener;
+                if (folderOpen)
+                {
+                  // This gives a way for the caller to get notified
+                  // when the UpdateFolder url is done.
+                  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)
+                    txnMgr->DoTransaction(m_copyState->m_undoMsgTxn);
+                }
+                (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(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+          NS_ENSURE_SUCCESS(rv, rv);
+          nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryInterface(m_copyState->m_srcSupport);
+          if (srcFolder)
+          {
+            nsCOMPtr<nsIMsgFolder> destFolder;
+            nsString srcName;
+            srcFolder->GetName(srcName);
+            GetChildNamed(srcName, getter_AddRefs(destFolder));
+            if (destFolder)
+              copyService->NotifyCompletion(m_copyState->m_srcSupport, destFolder, aExitCode);
+          }
+          m_copyState = nullptr;
+        }
+        break;
+      case nsIImapUrl::nsImapRenameFolder:
+        if (NS_FAILED(aExitCode))
+        {
+          nsCOMPtr <nsIAtom> folderRenameAtom;
+          folderRenameAtom = MsgGetAtom("RenameCompleted");
+          NotifyFolderEvent(folderRenameAtom);
+        }
+        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)
+                  imapParent->RemoveSubFolder(this);
+              }
+            }
+          }
+        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
+        {
+          nsCOMPtr <nsIAtom> folderCreateAtom;
+          folderCreateAtom = MsgGetAtom("FolderCreateFailed");
+          NotifyFolderEvent(folderCreateAtom);
+        }
+        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)
+                {
+                  msgFolder->GetURI(uri);
+                  nsCOMPtr<nsIMsgWindowCommands> windowCommands;
+                  msgWindow->GetWindowCommands(getter_AddRefs(windowCommands));
+                  if (windowCommands)
+                    windowCommands->SelectFolder(uri);
+                }
+              }
+            }
+          }
+        }
+        break;
+      case nsIImapUrl::nsImapExpungeFolder:
+        m_expunging = false;
+        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);
+  // don't send OnStopRunning notification if still compacting offline store.
+  if (m_urlListener && (imapAction != nsIImapUrl::nsImapExpungeFolder ||
+                        !m_compactingOfflineStore))
+  {
+    nsCOMPtr<nsIUrlListener> saveListener = m_urlListener;
+    m_urlListener = nullptr;
+    saveListener->OnStopRunningUrl(aUrl, aExitCode);
+  }
+  return rv;
+}
+
+void nsImapMailFolder::UpdatePendingCounts()
+{
+  if (m_copyState)
+  {
+    ChangePendingTotal(m_copyState->m_isCrossServerOp ? 1 : m_copyState->m_totalCount);
+
+    // 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);
+      // this is the case when DownloadAllForOffline is called.
+      if (!keysToDownload.IsEmpty() && (m_downloadingFolderForOfflineUse ||
+                                        autoDownloadNewHeaders))
+      {
+        notifiedBodies = true;
+        aProtocol->NotifyBodysToDownload(keysToDownload.Elements(), keysToDownload.Length());
+      }
+      else
+      {
+        // create auto-sync state object lazily
+        InitAutoSyncState();
+
+        // make enough room for new downloads
+        m_autoSyncStateObj->ManageStorageSpace();
+        m_autoSyncStateObj->SetServerCounts(m_numServerTotalMessages,
+                                            m_numServerRecentMessages,
+                                            m_numServerUnseenMessages,
+                                            m_nextUID);
+        m_autoSyncStateObj->OnNewHeaderFetchCompleted(keysToDownload);
+      }
+    }
+    if (!notifiedBodies)
+      aProtocol->NotifyBodysToDownload(nullptr, 0/*keysToFetch.Length() */);
+   
+    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);
+
+  // get the host session list and get server capabilities.
+  eIMAPCapabilityFlags capability = kCapabilityUndefined;
+
+  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))
+  {
+    bool haveACL = false;
+    bool haveQuota = false;
+    imapServer->GetCapabilityACL(&haveACL);
+    imapServer->GetCapabilityQuota(&haveQuota);
+
+    // Figure out what to display in the Quota tab of the folder properties.
+    // Does the server support quotas?
+    if (haveQuota)
+    {
+      // Have we asked the server for quota information?
+      if(m_folderQuotaCommandIssued)
+      {
+        // Has the server replied with storage quota info?
+        if(m_folderQuotaDataIsValid)
+        {
+          // If so, set quota data
+          folderQuotaStatusStringID = nullptr;
+          aFolderProps->SetQuotaData(m_folderQuotaRoot, m_folderQuotaUsedKB, m_folderQuotaMaxKB);
+        }
+        else
+        {
+          // If not, there is no storage quota set on this folder
+          folderQuotaStatusStringID = "imapQuotaStatusNoQuota";
+        }
+      }
+      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 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())
+    {
+      rv = 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
+    {
+      // is this right? It doesn't leak, does it?
+      CopyASCIItoUTF16(owner, uniOwner);
+    }
+    const char16_t *params[] = { uniOwner.get() };
+    rv = bundle->FormatStringFromName(
+      u"imapOtherUsersFolderTypeDescription",
+      params, 1, getter_Copies(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)
+    rv = 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);
+
+  // we need the real user name to match with what the imap server returns
+  // in the acl response.
+  server->GetRealUsername(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, &oldValue);
+  if (!oldValue.IsEmpty())
+  {
+    m_rightsHash.Remove(ourUserName);
+    m_aclCount--;
+    NS_ASSERTION(m_aclCount >= 0, "acl count can't go negative");
+  }
+  m_aclCount++;
+  m_rightsHash.Put(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);
+}
+
+class AdoptUTF8StringEnumerator final : public nsIUTF8StringEnumerator
+{
+public:
+  AdoptUTF8StringEnumerator(nsTArray<nsCString>* array) :
+    mStrings(array), mIndex(0)
+  {}
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIUTF8STRINGENUMERATOR
+private:
+  ~AdoptUTF8StringEnumerator()
+  {
+    delete mStrings;
+  }
+
+  nsTArray<nsCString>* mStrings;
+  uint32_t             mIndex;
+};
+
+NS_IMPL_ISUPPORTS(AdoptUTF8StringEnumerator, nsIUTF8StringEnumerator)
+
+NS_IMETHODIMP
+AdoptUTF8StringEnumerator::HasMore(bool *aResult)
+{
+  *aResult = mIndex < mStrings->Length();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+AdoptUTF8StringEnumerator::GetNext(nsACString& aResult)
+{
+  if (mIndex >= mStrings->Length())
+    return NS_ERROR_UNEXPECTED;
+
+  aResult.Assign((*mStrings)[mIndex]);
+  ++mIndex;
+  return NS_OK;
+}
+
+nsresult nsMsgIMAPFolderACL::GetOtherUsers(nsIUTF8StringEnumerator** aResult)
+{
+  nsTArray<nsCString>* resultArray = new nsTArray<nsCString>;
+  for (auto iter = m_rightsHash.Iter(); !iter.Done(); iter.Next()) {
+    resultArray->AppendElement(iter.Key());
+  }
+
+  // enumerator will free resultArray
+  *aResult = new AdoptUTF8StringEnumerator(resultArray);
+  return NS_OK;
+}
+
+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->GetRealUsername(userName);
+  }
+  ToLowerCase(userName);
+  m_rightsHash.Get(userName, &rights);
+  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(NS_LITERAL_CSTRING(IMAP_ACL_ANYONE_STRING), anyoneFlags);
+    if (anyoneFlags.IsEmpty())
+      return defaultIfNotFound;
+    else
+      return (anyoneFlags.FindChar(flag) != kNotFound);
+  }
+  else
+    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(NS_LITERAL_CSTRING(IMAP_ACL_ANYONE_STRING), &anyonesRights);
+  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(u"imapAclFullRights",
+                                   getter_Copies(result));
+    aRightsString.Assign(result);
+    return rv;
+  }
+  else
+  {
+    if (GetCanIReadFolder())
+    {
+      bundle->GetStringFromName(u"imapAclReadRight",
+                                getter_Copies(curRight));
+      aRightsString.Append(curRight);
+    }
+    if (GetCanIWriteFolder())
+    {
+      if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+      bundle->GetStringFromName(u"imapAclWriteRight",
+                                getter_Copies(curRight));
+      aRightsString.Append(curRight);
+    }
+    if (GetCanIInsertInFolder())
+    {
+      if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+      bundle->GetStringFromName(u"imapAclInsertRight",
+                                getter_Copies(curRight));
+      aRightsString.Append(curRight);
+    }
+    if (GetCanILookupFolder())
+    {
+      if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+      bundle->GetStringFromName(u"imapAclLookupRight",
+                                getter_Copies(curRight));
+      aRightsString.Append(curRight);
+    }
+    if (GetCanIStoreSeenInFolder())
+    {
+      if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+      bundle->GetStringFromName(u"imapAclSeenRight",
+                                getter_Copies(curRight));
+      aRightsString.Append(curRight);
+    }
+    if (GetCanIDeleteInFolder())
+    {
+      if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+      bundle->GetStringFromName(u"imapAclDeleteRight",
+                                getter_Copies(curRight));
+      aRightsString.Append(curRight);
+    }
+    if (GetCanIExpungeFolder())
+    {
+      if (!aRightsString.IsEmpty())
+        aRightsString.AppendLiteral(", ");
+      bundle->GetStringFromName(u"imapAclExpungeRight",
+                                getter_Copies(curRight));
+      aRightsString.Append(curRight);
+    }
+    if (GetCanICreateSubfolder())
+    {
+      if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+      bundle->GetStringFromName(u"imapAclCreateRight",
+                                getter_Copies(curRight));
+      aRightsString.Append(curRight);
+    }
+    if (GetCanIPostToFolder())
+    {
+      if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+      bundle->GetStringFromName(u"imapAclPostRight",
+                                getter_Copies(curRight));
+      aRightsString.Append(curRight);
+    }
+    if (GetCanIAdministerFolder())
+    {
+      if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
+      bundle->GetStringFromName(u"imapAclAdministerRight",
+                                getter_Copies(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)
+    {
+        nsCOMPtr<nsIRequest> request = do_QueryInterface(mockChannel);
+        if (!request) return NS_ERROR_FAILURE;
+      progressSink->OnStatus(request, nullptr, 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)
+      {
+        char16_t *printfString = nsTextFormatter::smprintf(progressMsg.get(), extraInfo);
+        if (printfString)
+          progressMsg.Adopt(printfString);
+      }
+
+      DisplayStatusMsg(imapUrl, progressMsg);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::PercentProgress(nsIImapProtocol* aProtocol,
+                                  const char16_t * aMessage,
+                                  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)
+        {
+            nsCOMPtr<nsIRequest> request = do_QueryInterface(mockChannel);
+            if (!request) return NS_ERROR_FAILURE;
+            progressSink->OnProgress(request, nullptr,
+                                     aCurrentProgress,
+                                     aMaxProgress);
+            if (aMessage)
+              progressSink->OnStatus(request, nullptr, NS_OK, aMessage); // XXX i18n message
+        }
+      }
+    }
+  }
+  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:%lx\n", rv));
+    return rv; // this can fail...
+  }
+
+  if (!mailCopyState->m_streamCopy)
+    return NS_OK;
+
+  MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("CopyNextStreamMessage: Copying %ld of %ld\n", mailCopyState->m_curIndex, mailCopyState->m_totalCount));
+  if (mailCopyState->m_curIndex < mailCopyState->m_totalCount)
+  {
+    mailCopyState->m_message = do_QueryElementAt(mailCopyState->m_messages,
+                                                 mailCopyState->m_curIndex,
+                                                 &rv);
+    if (NS_SUCCEEDED(rv))
+    {
+      bool isRead;
+      mailCopyState->m_message->GetIsRead(&isRead);
+      mailCopyState->m_unreadCount = (isRead) ? 0 : 1;
+      rv = CopyStreamMessage(mailCopyState->m_message,
+                             this, mailCopyState->m_msgWindow, mailCopyState->m_isMove);
+    }
+    else
+    {
+      MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("QueryElementAt %ld failed:%lx\n", mailCopyState->m_curIndex, rv));
+    }
+  }
+  else
+  {
+    // Notify of move/copy completion in case we have some source headers
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+    if (notifier)
+    {
+      uint32_t numHdrs;
+      mailCopyState->m_messages->GetLength(&numHdrs);
+      if (numHdrs)
+        notifier->NotifyMsgsMoveCopyCompleted(mailCopyState->m_isMove, mailCopyState->m_messages, this, nullptr);
+    }
+    if (mailCopyState->m_isMove)
+    {
+      nsCOMPtr<nsIMsgFolder> srcFolder(do_QueryInterface(mailCopyState->m_srcSupport, &rv));
+      if (NS_SUCCEEDED(rv) && srcFolder)
+      {
+        srcFolder->DeleteMessages(mailCopyState->m_messages, nullptr,
+          true, true, nullptr, false);
+        // we want to send this notification after the source messages have
+        // been deleted.
+        nsCOMPtr<nsIMsgLocalMailFolder> popFolder(do_QueryInterface(srcFolder));
+        if (popFolder)   //needed if move pop->imap to notify FE
+          srcFolder->NotifyFolderEvent(mDeleteOrMoveMsgCompletedAtom);
+      }
+    }
+  }
+  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,
+                                nsIArray* messages,
+                                bool isMove,
+                                bool isCrossServerOp,
+                                nsIMsgWindow *msgWindow,
+                                nsIMsgCopyServiceListener* listener,
+                                bool allowUndo)
+{
+  NS_ENSURE_ARG_POINTER(srcFolder);
+  NS_ENSURE_ARG_POINTER(messages);
+  nsresult rv;
+  nsCOMPtr<nsISupports> aSupport(do_QueryInterface(srcFolder, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = InitCopyState(aSupport, 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;
+  }
+  nsCOMPtr<nsIMsgDBHdr> msg;
+  msg = do_QueryElementAt(messages, 0, &rv);
+  if (NS_SUCCEEDED(rv))
+    CopyStreamMessage(msg, 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(getter_Copies(sourceFolderURI));
+
+  nsCOMPtr<nsIRDFResource> res;
+  nsresult rv;
+  nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = rdf->GetResource(sourceFolderURI, getter_AddRefs(res));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIMsgFolder> sourceFolder(do_QueryInterface(res, &rv));
+    if (NS_SUCCEEDED(rv) && sourceFolder)
+    {
+      if (sourceFolder)
+      {
+        nsCOMPtr <nsIDBFolderInfo> folderInfo;
+        sourceFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), originalDB);
+        if (*originalDB)
+        {
+          nsMsgKey originalKey;
+          op->GetMessageKey(&originalKey);
+          rv = (*originalDB)->GetOfflineOpForKey(originalKey, false, getter_AddRefs(returnOp));
+          if (NS_SUCCEEDED(rv) && returnOp)
+          {
+            nsCString moveDestination;
+            nsCString thisFolderURI;
+            GetURI(thisFolderURI);
+            returnOp->GetDestinationFolderURI(getter_Copies(moveDestination));
+            if (moveDestination.Equals(thisFolderURI))
+              returnOp->ClearOperation(nsIMsgOfflineImapOperation::kMoveResult);
+          }
+        }
+      }
+    }
+  }
+  returnOp.swap(*originalOp);
+  return rv;
+}
+
+nsresult nsImapMailFolder::GetOriginalOp(nsIMsgOfflineImapOperation *op, nsIMsgOfflineImapOperation **originalOp, nsIMsgDatabase **originalDB)
+{
+  nsCOMPtr<nsIMsgOfflineImapOperation> returnOp;
+  nsCString sourceFolderURI;
+  op->GetSourceFolderURI(getter_Copies(sourceFolderURI));
+
+  nsCOMPtr<nsIRDFResource> res;
+  nsresult rv;
+
+  nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = rdf->GetResource(sourceFolderURI, getter_AddRefs(res));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIMsgFolder> sourceFolder(do_QueryInterface(res, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr <nsIDBFolderInfo> folderInfo;
+    sourceFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), originalDB);
+    if (*originalDB)
+    {
+      nsMsgKey originalKey;
+      op->GetMessageKey(&originalKey);
+      rv = (*originalDB)->GetOfflineOpForKey(originalKey, false, getter_AddRefs(returnOp));
+    }
+  }
+  returnOp.swap(*originalOp);
+  return rv;
+}
+
+nsresult nsImapMailFolder::CopyOfflineMsgBody(nsIMsgFolder *srcFolder,
+                                              nsIMsgDBHdr *destHdr,
+                                              nsIMsgDBHdr *origHdr,
+                                              nsIInputStream *inputStream,
+                                              nsIOutputStream *outputStream)
+{
+  nsresult rv;
+  nsCOMPtr <nsISeekableStream> seekable (do_QueryInterface(outputStream, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint64_t messageOffset;
+  uint32_t messageSize;
+  origHdr->GetMessageOffset(&messageOffset);
+  if (!messageOffset)
+  {
+    // Some offline stores may contain a bug where the storeToken is set but
+    // the messageOffset is zero. Detect cases like this, and use storeToken
+    // to set the missing messageOffset. Note this assumes mbox.
+    nsCOMPtr<nsIMsgPluggableStore> offlineStore;
+    (void) GetMsgStore(getter_AddRefs(offlineStore));
+    if (offlineStore)
+    {
+      nsAutoCString type;
+      offlineStore->GetStoreType(type);
+      if (type.EqualsLiteral("mbox"))
+      {
+        nsCString storeToken;
+        origHdr->GetStringProperty("storeToken", getter_Copies(storeToken));
+        if (!storeToken.IsEmpty())
+          messageOffset = ParseUint64Str(storeToken.get());
+      }
+    }
+  }
+  origHdr->GetOfflineMessageSize(&messageSize);
+  if (!messageSize)
+  {
+    nsCOMPtr<nsIMsgLocalMailFolder> localFolder = do_QueryInterface(srcFolder);
+    if (localFolder)   //can just use regular message size
+      origHdr->GetMessageSize(&messageSize);
+  }
+  int64_t tellPos;
+  seekable->Tell(&tellPos);
+  destHdr->SetMessageOffset(tellPos);
+  nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(inputStream);
+  NS_ASSERTION(seekStream, "non seekable stream - can't read from offline msg");
+  if (seekStream)
+  {
+    rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, messageOffset);
+    if (NS_SUCCEEDED(rv))
+    {
+      // now, copy the dest folder offline store msg to the temp file
+      char *inputBuffer = (char *) PR_Malloc(FILE_IO_BUFFER_SIZE);
+      int32_t bytesLeft;
+      uint32_t bytesRead, bytesWritten;
+      bytesLeft = messageSize;
+      rv = (inputBuffer) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+      while (bytesLeft > 0 && NS_SUCCEEDED(rv))
+      {
+        rv = inputStream->Read(inputBuffer, FILE_IO_BUFFER_SIZE, &bytesRead);
+        if (NS_SUCCEEDED(rv) && bytesRead > 0)
+        {
+          rv = outputStream->Write(inputBuffer, std::min((int32_t) bytesRead, bytesLeft), &bytesWritten);
+          NS_ASSERTION((int32_t) bytesWritten == std::min((int32_t) bytesRead, bytesLeft), "wrote out incorrect number of bytes");
+        }
+        else
+          break;
+        bytesLeft -= bytesRead;
+      }
+      PR_FREEIF(inputBuffer);
+    }
+  }
+  if (NS_SUCCEEDED(rv))
+  {
+    outputStream->Flush();
+    uint32_t resultFlags;
+    destHdr->OrFlags(nsMsgMessageFlags::Offline, &resultFlags);
+    destHdr->SetOfflineMessageSize(messageSize);
+  }
+  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;
+}
+
+// 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,
+                               nsIArray* messages,
+                               bool isMove,
+                               nsIMsgWindow *msgWindow,
+                               nsIMsgCopyServiceListener* listener)
+{
+  NS_ENSURE_ARG(messages);
+  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->GetLength(&srcCount);
+  nsCOMPtr<nsIImapIncomingServer> imapServer;
+  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
+  nsCOMPtr<nsIMutableArray> msgHdrsCopied(do_CreateInstance(NS_ARRAY_CONTRACTID));
+  nsCOMPtr<nsIMutableArray> destMsgHdrs(do_CreateInstance(NS_ARRAY_CONTRACTID));
+
+  if (!msgHdrsCopied || !destMsgHdrs)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  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);
+      nsCOMPtr<nsIInputStream> inputStream;
+      bool reusable = false;
+      nsCOMPtr<nsIOutputStream> outputStream;
+      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, false);
+      for (uint32_t sourceKeyIndex = 0; NS_SUCCEEDED(stopit) && (sourceKeyIndex < srcCount); sourceKeyIndex++)
+      {
+        bool messageReturningHome = false;
+        nsCString originalSrcFolderURI;
+        srcFolder->GetURI(originalSrcFolderURI);
+        nsCOMPtr<nsIMsgDBHdr> message;
+        message = do_QueryElementAt(messages, sourceKeyIndex);
+        nsMsgKey originalKey;
+        if (message)
+          rv = message->GetMessageKey(&originalKey);
+        else
+        {
+          NS_ERROR("bad msg in src array");
+          continue;
+        }
+        nsMsgKey msgKey;
+        message->GetMessageKey(&msgKey);
+        nsCOMPtr <nsIMsgOfflineImapOperation> sourceOp;
+        rv = sourceMailDB->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;
+            rv = GetClearedOriginalOp(sourceOp, getter_AddRefs(originalOp), getter_AddRefs(originalDB));
+            if (originalOp)
+            {
+              nsCString srcFolderURI;
+              srcFolder->GetURI(srcFolderURI);
+              sourceOp->GetSourceFolderURI(getter_Copies(originalSrcFolderURI));
+              sourceOp->GetMessageKey(&originalKey);
+              if (isMove)
+                sourceMailDB->RemoveOfflineOp(sourceOp);
+              sourceOp = originalOp;
+              if (originalSrcFolderURI.Equals(srcFolderURI))
+              {
+                messageReturningHome = true;
+                originalDB->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.get()); // 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.get()); // offline copy
+
+            sourceOp->GetOperation(&moveCopyOpType);
+            srcMsgs.AppendObject(message);
+          }
+          bool hasMsgOffline = false;
+          srcFolder->HasMsgOffline(originalKey, &hasMsgOffline);
+        }
+        else
+          stopit = NS_ERROR_FAILURE;
+
+        nsCOMPtr <nsIMsgDBHdr> mailHdr;
+        rv = sourceMailDB->GetMsgHdrForKey(originalKey, getter_AddRefs(mailHdr));
+        if (NS_SUCCEEDED(rv) && mailHdr)
+        {
+          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, false);
+            srcFolder->HasMsgOffline(originalKey, &hasMsgOffline);
+            newMailHdr->SetUint32Property("pseudoHdr", 1);
+            if (!reusable)
+              (void)srcFolder->GetMsgInputStream(newMailHdr, &reusable,
+                                                 getter_AddRefs(inputStream));
+
+            if (inputStream && hasMsgOffline && !isLocked)
+            {
+              rv = GetOfflineStoreOutputStream(newMailHdr,
+                                               getter_AddRefs(outputStream));
+              NS_ENSURE_SUCCESS(rv, rv);
+
+              CopyOfflineMsgBody(srcFolder, newMailHdr, mailHdr, inputStream,
+                                 outputStream);
+              nsCOMPtr<nsIMsgPluggableStore> offlineStore;
+              (void) GetMsgStore(getter_AddRefs(offlineStore));
+              if (offlineStore)
+                offlineStore->FinishNewMessage(outputStream, newMailHdr);
+            }
+            else
+              database->MarkOffline(fakeBase + sourceKeyIndex, false, nullptr);
+
+            nsCOMPtr <nsIMsgOfflineImapOperation> destOp;
+            database->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)
+                database->RemoveOfflineOp(destOp);
+              else
+              {
+                SetFlag(nsMsgFolderFlags::OfflineEvents);
+                destOp->SetSourceFolderURI(originalSrcFolderURI.get());
+                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, false);
+        }
+      }
+      EnableNotifications(nsIMsgFolder::allMessageCountNotifications, true, false);
+      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 (outputStream)
+        outputStream->Close();
+
+      if (isMove)
+        sourceMailDB->Commit(nsMsgDBCommitType::kLargeCommit);
+      database->Commit(nsMsgDBCommitType::kLargeCommit);
+      SummaryChanged();
+      srcFolder->SummaryChanged();
+    }
+    if (txnMgr)
+      txnMgr->EndBatch(false);
+  }
+
+  // Do this before delete, as it destroys the messages
+  uint32_t numHdrs;
+  msgHdrsCopied->GetLength(&numHdrs);
+  if (numHdrs)
+  {
+    nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+    if (notifier)
+      notifier->NotifyMsgsMoveCopyCompleted(isMove, msgHdrsCopied, this, destMsgHdrs);
+  }
+
+  if (isMove && NS_SUCCEEDED(rv) && (deleteToTrash || deleteImmediately))
+  {
+    DeleteStoreMessages(keysToDelete, srcFolder);
+    srcFolder->EnableNotifications(nsIMsgFolder::allMessageCountNotifications, false, false);
+    sourceMailDB->DeleteMessages(keysToDelete.Length(), keysToDelete.Elements(),
+                                 nullptr);
+    srcFolder->EnableNotifications(nsIMsgFolder::allMessageCountNotifications, true, false);
+  }
+
+  nsCOMPtr<nsISupports> srcSupport = do_QueryInterface(srcFolder);
+  OnCopyCompleted(srcSupport, rv);
+
+  if (isMove)
+    srcFolder->NotifyFolderEvent(NS_SUCCEEDED(rv) ?
+                                 mDeleteOrMoveMsgCompletedAtom :
+                                 mDeleteOrMoveMsgFailedAtom);
+  return rv;
+}
+
+void nsImapMailFolder::SetPendingAttributes(nsIArray* messages, bool aIsMove)
+{
+
+  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",
+                            getter_Copies(dontPreserve));
+  else
+    prefBranch->GetCharPref("mailnews.database.summary.dontPreserveOnCopy",
+                            getter_Copies(dontPreserve));
+
+  // We'll add spaces at beginning and end so we can search for space-name-space
+  nsCString dontPreserveEx(NS_LITERAL_CSTRING(" "));
+  dontPreserveEx.Append(dontPreserve);
+  dontPreserveEx.AppendLiteral(" ");
+
+  // 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 ");
+
+  uint32_t i, count;
+
+  rv = messages->GetLength(&count);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  // check if any msg hdr has special flags or properties set
+  // that we need to set on the dest hdr
+  for (i = 0; i < count; i++)
+  {
+    nsCOMPtr <nsIMsgDBHdr> msgDBHdr = do_QueryElementAt(messages, i, &rv);
+    if (mDatabase && msgDBHdr)
+    {
+      if (!(supportedUserFlags & kImapMsgSupportUserFlag))
+      {
+        nsMsgLabelValue label;
+        msgDBHdr->GetLabel(&label);
+        if (label != 0)
+        {
+          nsAutoCString labelStr;
+          labelStr.AppendInt(label);
+          mDatabase->SetAttributeOnPendingHdr(msgDBHdr, "label", labelStr.get());
+        }
+        nsCString keywords;
+        msgDBHdr->GetStringProperty("keywords", getter_Copies(keywords));
+        if (!keywords.IsEmpty())
+          mDatabase->SetAttributeOnPendingHdr(msgDBHdr, "keywords", keywords.get());
+      }
+
+      // do this even if the server supports user-defined flags.
+      nsCOMPtr<nsIUTF8StringEnumerator> propertyEnumerator;
+      nsresult rv = msgDBHdr->GetPropertyEnumerator(getter_AddRefs(propertyEnumerator));
+      NS_ENSURE_SUCCESS_VOID(rv);
+
+      nsAutoCString property;
+      nsCString sourceString;
+      bool hasMore;
+      while (NS_SUCCEEDED(propertyEnumerator->HasMore(&hasMore)) && hasMore)
+      {
+        propertyEnumerator->GetNext(property);
+        nsAutoCString propertyEx(NS_LITERAL_CSTRING(" "));
+        propertyEx.Append(property);
+        propertyEx.AppendLiteral(" ");
+        if (dontPreserveEx.Find(propertyEx) != kNotFound)
+          continue;
+
+        nsCString sourceString;
+        msgDBHdr->GetStringProperty(property.get(), getter_Copies(sourceString));
+        mDatabase->SetAttributeOnPendingHdr(msgDBHdr, property.get(), sourceString.get());
+      }
+
+      uint32_t messageSize;
+      uint64_t messageOffset;
+      nsCString storeToken;
+      msgDBHdr->GetMessageOffset(&messageOffset);
+      msgDBHdr->GetOfflineMessageSize(&messageSize);
+      msgDBHdr->GetStringProperty("storeToken", getter_Copies(storeToken));
+      if (messageSize)
+      {
+        mDatabase->SetUint32AttributeOnPendingHdr(msgDBHdr, "offlineMsgSize",
+                                                  messageSize);
+        mDatabase->SetUint64AttributeOnPendingHdr(msgDBHdr, "msgOffset",
+                                                  messageOffset);
+        mDatabase->SetUint32AttributeOnPendingHdr(msgDBHdr, "flags",
+                                                  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,
+                               nsIArray* 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 <nsIMsgIncomingServer> srcServer;
+  nsCOMPtr <nsIMsgIncomingServer> dstServer;
+  nsCOMPtr<nsISupports> srcSupport = do_QueryInterface(srcFolder);
+  bool sameServer = false;
+
+  rv = srcFolder->GetServer(getter_AddRefs(srcServer));
+  if(NS_FAILED(rv)) goto done;
+
+  rv = GetServer(getter_AddRefs(dstServer));
+  if(NS_FAILED(rv)) goto done;
+
+  NS_ENSURE_TRUE(dstServer, NS_ERROR_NULL_POINTER);
+  
+  rv = dstServer->Equals(srcServer, &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);
+    
+    // lazily create playback timer if it is not already
+    // created
+    if (!srcImapFolder->m_playbackTimer) 
+    {
+      rv = srcImapFolder->CreatePlaybackTimer();
+      NS_ENSURE_SUCCESS(rv,rv);
+    }
+    
+    if (srcImapFolder->m_playbackTimer) 
+    {
+      // 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);
+        if (!srcImapFolder->m_pendingPlaybackReq)
+          return NS_ERROR_OUT_OF_MEMORY;
+      }
+              
+      srcImapFolder->m_playbackTimer->InitWithFuncCallback(PlaybackTimerCallback, (void *) srcImapFolder->m_pendingPlaybackReq, 
+                                        PLAYBACK_TIMER_INTERVAL_IN_MS, nsITimer::TYPE_ONE_SHOT);
+    }
+    return rv;
+  }
+  else 
+  {
+    // sort the message array by key
+
+    uint32_t numMsgs = 0;
+    messages->GetLength(&numMsgs);
+    nsTArray<nsMsgKey> keyArray(numMsgs);
+    for (uint32_t i = 0; i < numMsgs; i++)
+    {
+      nsCOMPtr<nsIMsgDBHdr> aMessage = do_QueryElementAt(messages, i, &rv);
+      if (NS_SUCCEEDED(rv) && aMessage)
+      {
+        nsMsgKey key;
+        aMessage->GetMessageKey(&key);
+        keyArray.AppendElement(key);
+      }
+    }
+    keyArray.Sort();
+
+    nsCOMPtr<nsIMutableArray> sortedMsgs(do_CreateInstance(NS_ARRAY_CONTRACTID));
+    rv = MessagesInKeyOrder(keyArray, srcFolder, sortedMsgs);
+    NS_ENSURE_SUCCESS(rv, rv);
+    
+    if (WeAreOffline())
+      return CopyMessagesOffline(srcFolder, sortedMsgs, isMove, msgWindow, listener);
+    
+    nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv,rv);
+    
+    SetPendingAttributes(sortedMsgs, isMove);
+
+    // 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.Elements(), numMsgs, 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_totalCount;
+
+    if (isMove)
+      srcFolder->EnableNotifications(allMessageCountNotifications, false, true/* dbBatching*/);  //disable message count notification
+
+    nsCOMPtr<nsISupports> copySupport = do_QueryInterface(m_copyState);
+    rv = imapService->OnlineMessageCopy(srcFolder, messageIds,
+                                        this, true, isMove,
+                                        urlListener, nullptr,
+                                        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, true/* dbBatching*/);  //enable message count notification
+      NotifyFolderEvent(mDeleteOrMoveMsgFailedAtom);
+    }
+  }
+  return rv;
+}
+
+class nsImapFolderCopyState final : public nsIUrlListener, public nsIMsgCopyServiceListener
+{
+public:
+  nsImapFolderCopyState(nsIMsgFolder *destParent, nsIMsgFolder *srcFolder,
+                    bool isMoveFolder, 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_isMoveFolder;
+  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 isMoveFolder, nsIMsgWindow *msgWindow, nsIMsgCopyServiceListener *listener)
+{
+  m_origSrcFolder = do_QueryInterface(srcFolder);
+  m_curDestParent = destParent;
+  m_curSrcFolder = srcFolder;
+  m_isMoveFolder = isMoveFolder;
+  m_msgWindow = msgWindow;
+  m_copySrvcListener = listener;
+  m_childIndex = -1;
+}
+
+nsImapFolderCopyState::~nsImapFolderCopyState()
+{
+}
+
+nsresult
+nsImapFolderCopyState::StartNextCopy()
+{
+  nsresult rv;
+  // first make sure dest folder exists.
+  nsCOMPtr <nsIImapService> imapService = do_GetService (NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsString folderName;
+  m_curSrcFolder->GetName(folderName);
+
+  return imapService->EnsureFolderExists(m_curDestParent,
+                                         folderName,
+                                         this, nullptr);
+}
+
+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);
+    Release();
+  }
+  else
+  {
+    m_curDestParent = m_destParents[m_childIndex];
+    m_curSrcFolder = m_srcChildFolders[m_childIndex];
+    rv = StartNextCopy();
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapFolderCopyState::OnStartRunningUrl(nsIURI *aUrl)
+{
+  NS_PRECONDITION(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);
+    Release();
+    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:
+        {
+          nsCOMPtr<nsIMsgFolder> newMsgFolder;
+          nsString folderName;
+          nsCString utf7LeafName;
+          m_curSrcFolder->GetName(folderName);
+          rv = CopyUTF16toMUTF7(folderName, utf7LeafName);
+          rv = m_curDestParent->FindSubFolder(utf7LeafName, 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.
+          nsCOMPtr<nsISimpleEnumerator> enumerator;
+          rv = m_curSrcFolder->GetSubFolders(getter_AddRefs(enumerator));
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          nsCOMPtr<nsISupports> item;
+          bool hasMore = false;
+          uint32_t childIndex = 0;
+          while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore)
+          {
+            rv = enumerator->GetNext(getter_AddRefs(item));
+            nsCOMPtr<nsIMsgFolder> folder(do_QueryInterface(item, &rv));
+            if (NS_SUCCEEDED(rv))
+            {
+              m_srcChildFolders.InsertElementAt(m_childIndex + childIndex + 1, folder);
+              m_destParents.InsertElementAt(m_childIndex + childIndex + 1, newMsgFolder);
+            }
+            ++childIndex;
+          }
+
+          rv = m_curSrcFolder->GetMessages(getter_AddRefs(enumerator));
+          nsCOMPtr<nsIMutableArray> msgArray(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+          NS_ENSURE_TRUE(msgArray, rv);
+          hasMore = false;
+
+          if (enumerator)
+            rv = enumerator->HasMoreElements(&hasMore);
+
+          if (!hasMore)
+            return AdvanceToNextFolder(NS_OK);
+
+          while (NS_SUCCEEDED(rv) && hasMore)
+          {
+            rv = enumerator->GetNext(getter_AddRefs(item));
+            NS_ENSURE_SUCCESS(rv, rv);
+            rv = msgArray->AppendElement(item, false);
+            NS_ENSURE_SUCCESS(rv, rv);
+            rv = enumerator->HasMoreElements(&hasMore);
+          }
+
+          nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+          NS_ENSURE_SUCCESS(rv, rv);
+          rv = copyService->CopyMessages(m_curSrcFolder,
+                             msgArray, newMsgFolder,
+                             m_isMoveFolder,
+                             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;
+  }
+  Release();
+
+  return NS_OK;
+}
+
+// "this" is the parent of the copied folder.
+NS_IMETHODIMP
+nsImapMailFolder::CopyFolder(nsIMsgFolder* srcFolder,
+                               bool isMoveFolder,
+                               nsIMsgWindow *msgWindow,
+                               nsIMsgCopyServiceListener* listener)
+{
+  NS_ENSURE_ARG_POINTER(srcFolder);
+
+  nsresult rv = NS_OK;
+
+  if (isMoveFolder)   //move folder permitted when dstFolder and the srcFolder are on same server
+  {
+    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);
+
+      NotifyItemAdded(newMsgFolder);
+
+      // now remove the old folder
+      nsCOMPtr<nsIMsgFolder> msgParent;
+      srcFolder->GetParent(getter_AddRefs(msgParent));
+      srcFolder->SetParent(nullptr);
+      if (msgParent)
+      {
+        msgParent->PropagateDelete(srcFolder, false, msgWindow);  // The files have already been moved, so delete storage false
+        oldPathFile->Remove(false);  //berkeley mailbox
+        nsCOMPtr <nsIMsgDatabase> srcDB; // we need to force closed the source db
+        srcFolder->Delete();
+
+        nsCOMPtr<nsIFile> parentPathFile;
+        rv = msgParent->GetFilePath(getter_AddRefs(parentPathFile));
+        NS_ENSURE_SUCCESS(rv,rv);
+
+        AddDirectorySeparator(parentPathFile);
+        nsCOMPtr <nsISimpleEnumerator> 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 (NS_IMAPSERVICE_CONTRACTID, &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, nullptr, false, false, false,
+                         0, EmptyCString(), listener, msgWindow, false);
+      if (NS_FAILED(rv))
+        return OnCopyCompleted(srcSupport, rv);
+
+      rv = imapService->MoveFolder(srcFolder,
+                                   this,
+                                   this,
+                                   msgWindow,
+                                   nullptr);
+    }
+  }
+  else // copying folder (should only be across server?)
+  {
+    nsImapFolderCopyState *folderCopier = new nsImapFolderCopyState(this, srcFolder, isMoveFolder, msgWindow, listener);
+    NS_ADDREF(folderCopier); // it owns itself.
+    return 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;
+    nsCOMPtr<nsIUrlListener> urlListener;
+    nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID));
+    nsCOMPtr<nsISupports> srcSupport = do_QueryInterface(file, &rv);
+
+    if (!messages)
+      return OnCopyCompleted(srcSupport, rv);
+
+    nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+    if (NS_FAILED(rv))
+      return OnCopyCompleted(srcSupport, rv);
+
+    rv = QueryInterface(NS_GET_IID(nsIUrlListener), getter_AddRefs(urlListener));
+
+    if (msgToReplace)
+    {
+        rv = msgToReplace->GetMessageKey(&key);
+        if (NS_SUCCEEDED(rv))
+        {
+          messageId.AppendInt((int32_t) key);
+          // Perhaps we have the message offline, but even if we do it is
+          // not valid, since the only time we do a file copy for an
+          // existing message is when we are changing the message.
+          // So set the offline size to 0 to force SetPendingAttributes to
+          // clear the offline message flag.
+          msgToReplace->SetOfflineMessageSize(0);
+          messages->AppendElement(msgToReplace, false);
+          SetPendingAttributes(messages, false);
+        }
+    }
+
+    bool isMove = (msgToReplace ? true : false);
+    rv = InitCopyState(srcSupport, messages, isMove, isDraftOrTemplate,
+                       false, aNewMsgFlags, aNewMsgKeywords, listener, 
+                       msgWindow, false);
+    if (NS_FAILED(rv))
+      return OnCopyCompleted(srcSupport, rv);
+
+    m_copyState->m_streamCopy = true;
+    nsCOMPtr<nsISupports> copySupport;
+    if( m_copyState )
+      copySupport = do_QueryInterface(m_copyState);
+    if (!isDraftOrTemplate)
+    {
+      m_copyState->m_totalCount = 1;
+      // This makes the IMAP APPEND set the INTERNALDATE for the msg copy
+      // we make when detaching/deleting attachments to the original msg date.
+      m_copyState->m_message = msgToReplace;
+    }
+    rv = imapService->AppendMessageFromFile(file, this, messageId,
+                                            true, isDraftOrTemplate,
+                                            urlListener, nullptr,
+                                            copySupport,
+                                            msgWindow);
+    if (NS_FAILED(rv))
+      return OnCopyCompleted(srcSupport, rv);
+
+    return rv;
+}
+
+nsresult
+nsImapMailFolder::CopyStreamMessage(nsIMsgDBHdr* message,
+                                    nsIMsgFolder* dstFolder, // should be this
+                                    nsIMsgWindow *aMsgWindow,
+                                    bool isMove)
+{
+  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(NS_COPYMESSAGESTREAMLISTENER_CONTRACTID, &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(srcFolder, copyListener, nullptr);
+  if (NS_FAILED(rv))
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("CopyStreaMessage failed in copyStreamListener->Init"));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCOMPtr<nsIMsgDBHdr> msgHdr(do_QueryInterface(message, &rv));
+  if (NS_FAILED(rv)) return rv;
+
+  nsCString uri;
+  srcFolder->GetUriForMsg(msgHdr, 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_totalCount > 1)
+    {
+      nsString dstFolderName, progressText;
+      GetName(dstFolderName);
+      nsAutoString curMsgString;
+      nsAutoString totalMsgString;
+      totalMsgString.AppendInt(m_copyState->m_totalCount);
+      curMsgString.AppendInt(m_copyState->m_curIndex + 1);
+
+      const char16_t *formatStrings[3] = {curMsgString.get(),
+                                            totalMsgString.get(),
+                                            dstFolderName.get()
+                                            };
+
+      nsCOMPtr <nsIStringBundle> bundle;
+      rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = bundle->FormatStringFromName(
+        u"imapCopyingMessageOf2",
+        formatStrings, 3, getter_Copies(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_totalCount;
+          statusFeedback->ShowProgress(percent);
+      }
+    }
+    nsCOMPtr<nsIURI> dummyNull;
+    rv = m_copyState->m_msgService->CopyMessage(uri.get(), streamListener,
+                                                isMove && !m_copyState->m_isCrossServerOp, nullptr, aMsgWindow,
+                                                getter_AddRefs(dummyNull));
+    if (NS_FAILED(rv))
+      MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("CopyMessage failed: uri %s\n", uri.get()));
+  } 
+  return rv;
+}
+
+nsImapMailCopyState::nsImapMailCopyState() :
+    m_isMove(false), m_selectedState(false),
+    m_isCrossServerOp(false), m_curIndex(0),
+    m_totalCount(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_msgService && m_message)
+  {
+    nsCOMPtr <nsIMsgFolder> srcFolder = do_QueryInterface(m_srcSupport);
+    if (srcFolder)
+    {
+      nsCString uri;
+      srcFolder->GetUriForMsg(m_message, uri);
+    }
+  }
+  if (m_tmpFile)
+    m_tmpFile->Remove(false);
+}
+
+
+NS_IMPL_ISUPPORTS(nsImapMailCopyState, nsImapMailCopyState)
+
+nsresult
+nsImapMailFolder::InitCopyState(nsISupports* srcSupport,
+                                nsIArray* 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);
+  nsresult rv;
+
+  m_copyState = new nsImapMailCopyState();
+  NS_ENSURE_TRUE(m_copyState,NS_ERROR_OUT_OF_MEMORY);
+
+  m_copyState->m_isCrossServerOp = acrossServers;
+  m_copyState->m_srcSupport = do_QueryInterface(srcSupport, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  m_copyState->m_messages = messages;
+  if (messages)
+    rv = messages->GetLength(&m_copyState->m_totalCount);
+  if (!m_copyState->m_isCrossServerOp)
+  {
+    if (NS_SUCCEEDED(rv))
+    {
+        uint32_t numUnread = 0;
+        for (uint32_t keyIndex=0; keyIndex < m_copyState->m_totalCount; keyIndex++)
+        {
+          nsCOMPtr<nsIMsgDBHdr> message = do_QueryElementAt(m_copyState->m_messages, keyIndex, &rv);
+          // 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;
+          }
+          if (!isRead)
+            numUnread++;
+        }
+        m_copyState->m_unreadCount = numUnread;
+    }
+  }
+  else
+  {
+    nsCOMPtr<nsIMsgDBHdr> message =
+        do_QueryElementAt(m_copyState->m_messages,
+                          m_copyState->m_curIndex, &rv);
+      // 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 = do_QueryInterface(listener, &rv);
+  return rv;
+}
+
+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;
+  rv = mDatabase->GetOfflineOpForKey(msgKey, true, getter_AddRefs(op));
+  if (NS_SUCCEEDED(rv) && op)
+  {
+    nsCString destFolderUri;
+    GetURI(destFolderUri);
+    op->SetOperation(nsIMsgOfflineImapOperation::kMoveResult);
+    op->SetDestinationFolderURI(destFolderUri.get());
+    SetFlag(nsMsgFolderFlags::OfflineEvents);
+  }
+
+  nsCOMPtr<nsIInputStream> inputStream;
+  nsCOMPtr<nsIMsgParseMailMsgState> msgParser =
+    do_CreateInstance(NS_PARSEMAILMSGSTATE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  msgParser->SetMailDB(mDatabase);
+
+  uint64_t offset = 0;
+  if (offlineStore)
+  {
+    // Tell the parser to use the offset that will be in the dest stream,
+    //   not the temp file.
+    fakeHdr->GetMessageOffset(&offset);
+  }
+  msgParser->SetEnvelopePos(offset);
+
+  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.
+    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);
+
+        NS_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);
+    }
+
+    nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+    messages->AppendElement(fakeHdr, false);
+
+    SetPendingAttributes(messages, false);
+    // Gloda needs this notification to index the fake message.
+    nsCOMPtr<nsIMsgFolderNotificationService>
+      notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+    if (notifier)
+      notifier->NotifyMsgsClassified(messages, false, false);
+    inputStream->Close();
+    inputStream = nullptr;
+    delete inputStreamBuffer;
+  }
+  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(NS_MSGCOPYSERVICE_CONTRACTID, &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;
+
+  nsCOMPtr<nsISimpleEnumerator> enumerator;
+  GetSubFolders(getter_AddRefs(enumerator));
+  if (!enumerator)
+    return NS_OK;
+
+  nsresult rv;
+  bool hasMore;
+  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore)
+  {
+    nsCOMPtr<nsISupports> item;
+    rv = enumerator->GetNext(getter_AddRefs(item));
+    if (NS_FAILED(rv))
+      break;
+
+    nsCOMPtr<nsIMsgImapMailFolder> folder(do_QueryInterface(item, &rv));
+    if (NS_FAILED(rv))
+      return rv;
+
+    folder->ResetNamespaceReferences();
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::FindOnlineSubFolder(const nsACString& targetOnlineName, nsIMsgImapMailFolder **aResultFolder)
+{
+  nsresult rv = NS_OK;
+
+  nsCString onlineName;
+  GetOnlineName(onlineName);
+
+  if (onlineName.Equals(targetOnlineName))
+    return QueryInterface(NS_GET_IID(nsIMsgImapMailFolder), (void **) aResultFolder);
+
+  nsCOMPtr<nsISimpleEnumerator> enumerator;
+  GetSubFolders(getter_AddRefs(enumerator));
+  if (!enumerator)
+    return NS_OK;
+
+  bool hasMore;
+  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore)
+  {
+    nsCOMPtr<nsISupports> item;
+    rv = enumerator->GetNext(getter_AddRefs(item));
+    if (NS_FAILED(rv))
+      break;
+
+    nsCOMPtr<nsIMsgImapMailFolder> folder(do_QueryInterface(item, &rv));
+    if (NS_FAILED(rv))
+      return rv;
+
+    rv = folder->FindOnlineSubFolder(targetOnlineName, aResultFolder);
+    if (*aResultFolder)
+     return rv;
+  }
+  return rv;
+}
+
+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(const nsACString &aFolderQuotaRoot,
+                                                   uint32_t aFolderQuotaUsedKB,
+                                                    uint32_t aFolderQuotaMaxKB)
+{
+  m_folderQuotaDataIsValid = true;
+  m_folderQuotaRoot = aFolderQuotaRoot;
+  m_folderQuotaUsedKB = aFolderQuotaUsedKB;
+  m_folderQuotaMaxKB = aFolderQuotaMaxKB;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetQuota(bool* aValid,
+                                         uint32_t* aUsed, uint32_t* aMax)
+{
+  NS_ENSURE_ARG_POINTER(aValid);
+  NS_ENSURE_ARG_POINTER(aUsed);
+  NS_ENSURE_ARG_POINTER(aMax);
+  *aValid = m_folderQuotaDataIsValid;
+  *aUsed = m_folderQuotaUsedKB;
+  *aMax = m_folderQuotaMaxKB;
+  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(NS_IMAPSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = imapService->DiscoverChildren( this, this, m_onlineFolderName, nullptr);
+  }
+  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_ConvertASCIItoUTF16 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(NS_MSGDB_SERVICE_CONTRACTID, &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 = CopyMUTF7toUTF16(NS_LossyConvertUTF16toASCII(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_LossyConvertUTF16toASCII(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;
+        CopyASCIItoUTF16(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(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
+    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, nullptr);
+    NotifyItemAdded(child);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::RenameSubFolders(nsIMsgWindow *msgWindow, nsIMsgFolder *oldFolder)
+{
+  m_initialized = true;
+  nsCOMPtr<nsISimpleEnumerator> enumerator;
+  nsresult rv = oldFolder->GetSubFolders(getter_AddRefs(enumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool hasMore;
+  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore)
+  {
+    nsCOMPtr<nsISupports> item;
+    if (NS_FAILED(enumerator->GetNext(getter_AddRefs(item))))
+      continue;
+
+    nsCOMPtr<nsIMsgFolder> msgFolder(do_QueryInterface(item, &rv));
+    if (NS_FAILED(rv))
+      return rv;
+
+    nsCOMPtr<nsIMsgImapMailFolder> folder(do_QueryInterface(msgFolder, &rv));
+    if (NS_FAILED(rv))
+      return 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);
+
+    nsCString newPathStr;
+    newParentPathFile->GetNativePath(newPathStr);
+
+    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 utf7LeafName;
+    rv = CopyUTF16toMUTF7(folderName, utf7LeafName);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // XXX : Fix this non-sense by fixing AddSubfolderWithPath
+    nsAutoString unicodeLeafName;
+    CopyASCIItoUTF16(utf7LeafName, unicodeLeafName);
+
+    rv = AddSubfolderWithPath(unicodeLeafName, dbFilePath, getter_AddRefs(child));
+    if (!child || NS_FAILED(rv)) return rv;
+
+    child->SetName(folderName);
+    nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(child);
+    nsCString onlineName;
+    GetOnlineName(onlineName);
+    nsAutoCString onlineCName(onlineName);
+    onlineCName.Append(hierarchyDelimiter);
+    onlineCName.Append(utf7LeafName);
+    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 */);
+    NS_ENSURE_TRUE (m_moveCoalescer, NS_ERROR_OUT_OF_MEMORY);
+    m_moveCoalescer->AddRef();
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::StoreCustomKeywords(nsIMsgWindow *aMsgWindow, const nsACString& aFlagsToAdd,
+                                      const nsACString& aFlagsToSubtract, nsMsgKey *aKeysToStore, uint32_t aNumKeys, nsIURI **_retval)
+{
+  nsresult rv;
+  if (WeAreOffline())
+  {
+    GetDatabase();
+    if (mDatabase)
+    {
+      for (uint32_t keyIndex = 0; keyIndex < aNumKeys; keyIndex++)
+      {
+        nsCOMPtr <nsIMsgOfflineImapOperation> op;
+        rv = mDatabase->GetOfflineOpForKey(aKeysToStore[keyIndex], true, getter_AddRefs(op));
+        SetFlag(nsMsgFolderFlags::OfflineEvents);
+        if (NS_SUCCEEDED(rv) && 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(NS_IMAPSERVICE_CONTRACTID, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsAutoCString msgIds;
+  AllocateUidStringFromKeys(aKeysToStore, aNumKeys, msgIds);
+  return imapService->StoreCustomKeywords(this, aMsgWindow, aFlagsToAdd,
+                                          aFlagsToSubtract, msgIds, _retval);
+}
+
+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(), NS_LITERAL_CSTRING("Junk"), EmptyCString(), junkKeysToClassify->Elements(), junkKeysToClassify->Length(), nullptr);
+    junkKeysToClassify->Clear();
+    nsTArray<nsMsgKey> *nonJunkKeysToClassify = m_moveCoalescer->GetKeyBucket(1);
+    if (nonJunkKeysToClassify && !nonJunkKeysToClassify->IsEmpty())
+      StoreCustomKeywords(m_moveCoalescer->GetMsgWindow(), NS_LITERAL_CSTRING("NonJunk"), EmptyCString(), nonJunkKeysToClassify->Elements(), nonJunkKeysToClassify->Length(), nullptr);
+    nonJunkKeysToClassify->Clear();
+    return m_moveCoalescer->PlaybackMoves(ShowPreviewText());
+  }
+  return NS_OK; // must not be any coalesced operations
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::SetJunkScoreForMessages(nsIArray *aMessages, const nsACString& aJunkScore)
+{
+  NS_ENSURE_ARG(aMessages);
+
+  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.Equals("0") ? NS_LITERAL_CSTRING("NonJunk") : NS_LITERAL_CSTRING("Junk"), EmptyCString(), keys.Elements(),
+      keys.Length(), nullptr);
+    if (mDatabase)
+      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMailFolder::OnMessageClassified(const char * aMsgURI,
+  nsMsgJunkStatus aClassification,
+  uint32_t aJunkPercent)
+{
+  nsCOMPtr <nsIMsgIncomingServer> server;
+  nsresult rv = GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aMsgURI) // 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)
+        {
+          if (!m_junkMessagesToMarkAsRead)
+          {
+            m_junkMessagesToMarkAsRead = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+            NS_ENSURE_SUCCESS(rv, rv);
+          }
+          m_junkMessagesToMarkAsRead->AppendElement(msgHdr, false);
+        }
+
+        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(getter_Copies(spamFolderURI));
+            NS_ENSURE_SUCCESS(rv,rv);
+
+            if (!spamFolderURI.IsEmpty())
+            {
+              rv = GetExistingFolder(spamFolderURI, getter_AddRefs(mSpamFolder));
+              if (NS_SUCCEEDED(rv) && 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 = GetOrCreateFolder(spamFolderURI, nullptr /* aListener */);
+                NS_ASSERTION(NS_SUCCEEDED(rv), "GetOrCreateFolder failed");
+              }
+            }
+          }
+        }
+        rv = spamSettings->LogJunkHit(msgHdr, willMoveMessage);
+        NS_ENSURE_SUCCESS(rv,rv);
+      }
+    }
+  }
+
+  else // end of batch
+  {
+    // Parent will apply post bayes filters.
+    nsMsgDBFolder::OnMessageClassified(nullptr, nsIJunkMailPlugin::UNCLASSIFIED, 0);
+
+    if (m_junkMessagesToMarkAsRead)
+    {
+      uint32_t count;
+      m_junkMessagesToMarkAsRead->GetLength(&count);
+      if (count > 0)
+      {
+        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 arbitary 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(nsMsgKey *aKeysToFetch, uint32_t aNumKeys,
+                                                 bool aLocalOnly, nsIUrlListener *aUrlListener,
+                                                 bool *aAsyncResults)
+{
+  NS_ENSURE_ARG_POINTER(aKeysToFetch);
+  NS_ENSURE_ARG_POINTER(aAsyncResults);
+
+  nsTArray<nsMsgKey> keysToFetchFromServer;
+
+  *aAsyncResults = false;
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr <nsIMsgMessageService> msgService = do_QueryInterface(imapService, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (uint32_t i = 0; i < aNumKeys; 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", getter_Copies(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.get(), getter_AddRefs(url), nullptr);
+    NS_ENSURE_SUCCESS(rv,rv);
+
+    // Lets look in the offline store.
+    uint32_t msgFlags;
+    msgHdr->GetFlags(&msgFlags);
+    nsMsgKey msgKey;
+    msgHdr->GetMessageKey(&msgKey);
+    if (msgFlags & nsMsgMessageFlags::Offline)
+    {
+      int64_t messageOffset;
+      uint32_t messageSize;
+      GetOfflineFileStream(msgKey, &messageOffset, &messageSize, getter_AddRefs(inputStream));
+      if (inputStream)
+        rv = GetMsgPreviewTextFromStream(msgHdr, inputStream);
+    }
+    else if (!aLocalOnly) {
+      keysToFetchFromServer.AppendElement(msgKey);
+    }
+  }
+  if (!keysToFetchFromServer.IsEmpty())
+  {
+    uint32_t msgCount = keysToFetchFromServer.Length();
+    nsAutoCString messageIds;
+    AllocateImapUidString(keysToFetchFromServer.Elements(), msgCount,
+                         nullptr, messageIds);
+    rv = imapService->GetBodyStart(this, aUrlListener,
+                                   messageIds, 2048, nullptr);
+    *aAsyncResults = true; // the preview text will be available async...
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::AddKeywordsToMessages(nsIArray *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.Elements(), keys.Length(), nullptr);
+    if (mDatabase)
+      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMailFolder::RemoveKeywordsFromMessages(nsIArray *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.Elements(), keys.Length(), 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(NS_MSGACCOUNTMANAGER_CONTRACTID, &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()));
+        nsCOMPtr<nsIArray> identities;
+        rv = accountManager->GetIdentitiesForServer(server, getter_AddRefs(identities));
+        NS_ENSURE_SUCCESS(rv, rv);
+        uint32_t numIdentities;
+        rv = identities->GetLength(&numIdentities);
+        NS_ENSURE_SUCCESS(rv, rv);
+        for (uint32_t identityIndex = 0; identityIndex < numIdentities; identityIndex++)
+        {
+          nsCOMPtr<nsIMsgIdentity> identity = do_QueryElementAt(identities, identityIndex);
+          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.swap(*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, ("Updating folder: %s\n", 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, ("Cannot update folder: %s\n", 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;
+}
+
+nsresult nsImapMailFolder::CreatePlaybackTimer()
+{
+  nsresult rv = NS_OK;
+  if (!m_playbackTimer)
+  {
+    m_playbackTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
+    NS_ASSERTION(NS_SUCCEEDED(rv),"failed to create pseudo-offline operation timer in nsImapMailFolder");
+  }
+  return rv;
+}
+
+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(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
+  request->SrcFolder->m_pendingPlaybackReq = nullptr;
+  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;
+
+}
+
+NS_IMETHODIMP 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", getter_Copies(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].Equals("\"\\\\Draft\""))
+             rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Drafts,
+                                                 getter_AddRefs(subMsgFolder));
+          if (labelNames[i].Equals("\"\\\\Inbox\""))
+             rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox,
+                                                 getter_AddRefs(subMsgFolder));
+          if (labelNames[i].Equals("\"\\\\All Mail\""))
+             rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Archive,
+                                                 getter_AddRefs(subMsgFolder));
+          if (labelNames[i].Equals("\"\\\\Trash\""))
+             rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Trash,
+                                                 getter_AddRefs(subMsgFolder));
+          if (labelNames[i].Equals("\"\\\\Spam\""))
+             rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Junk,
+                                                 getter_AddRefs(subMsgFolder));
+          if (labelNames[i].Equals("\"\\\\Sent\""))
+             rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::SentMail,
+                                                 getter_AddRefs(subMsgFolder));
+          if (labelNames[i].Find("[Imap]/", CaseInsensitiveCompare) != kNotFound)
+          {
+            MsgReplaceSubstring(labelNames[i], "[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", getter_Copies(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;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetOfflineFileStream(nsMsgKey msgKey, int64_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);
+
+  nsCOMPtr<nsIMsgDBHdr> hdr;
+  rv = mDatabase->GetMsgHdrForKey(msgKey, getter_AddRefs(hdr));
+  if (NS_FAILED(rv))
+    return rv;
+  if (hdr)
+  {
+    nsCString gmMsgID;
+    hdr->GetStringProperty("X-GM-MSGID", getter_Copies(gmMsgID));
+    nsCOMPtr<nsIMsgDatabase> db;
+    offlineFolder->GetMsgDatabase(getter_AddRefs(db));
+    rv = db->GetMsgHdrForGMMsgID(gmMsgID.get(), getter_AddRefs(hdr));
+    if (NS_FAILED(rv))
+      return rv;
+    nsMsgKey newMsgKey;
+    hdr->GetMessageKey(&newMsgKey);
+    return offlineFolder->GetOfflineFileStream(newMsgKey, offset, size, aFileStream);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailFolder::GetIncomingServerType(nsACString& serverType)
+{
+  serverType.AssignLiteral("imap");
+  return NS_OK;
+}
+
+void nsImapMailFolder::DeleteStoreMessages(nsIArray* 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(nsTArray<nsMsgKey> &aMessages)
+{
+  DeleteStoreMessages(aMessages, this);
+}
+
+void nsImapMailFolder::DeleteStoreMessages(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;
+      nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID));
+      if (db)
+        rv = MsgGetHeadersFromKeys(db, aMessages, messages);
+      if (NS_SUCCEEDED(rv))
+        offlineStore->DeleteMessages(messages);
+      else
+        NS_WARNING("Failed to get database");
+    }
+  }
+}
diff --git a/mailnews/imap/src/nsImapMailFolder.h b/mailnews/imap/src/nsImapMailFolder.h
new file mode 100644
index 0000000000..b2a9430b36
--- /dev/null
+++ b/mailnews/imap/src/nsImapMailFolder.h
@@ -0,0 +1,550 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef nsImapMailFolder_h__
+#define nsImapMailFolder_h__
+
+#include "mozilla/Attributes.h"
+#include "nsImapCore.h"
+#include "nsMsgDBFolder.h"
+#include "nsIImapMailFolderSink.h"
+#include "nsIImapMessageSink.h"
+#include "nsICopyMessageListener.h"
+#include "nsIImapService.h"
+#include "nsIUrlListener.h"
+#include "nsAutoPtr.h"
+#include "nsIImapIncomingServer.h" // we need this for its IID
+#include "nsIMsgParseMailMsgState.h"
+#include "nsITransactionManager.h"
+#include "nsImapUndoTxn.h"
+#include "nsIMsgMessageService.h"
+#include "nsIMsgFilterHitNotify.h"
+#include "nsIMsgFilterList.h"
+#include "prmon.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgThread.h"
+#include "nsIImapMailFolderSink.h"
+#include "nsIImapServerSink.h"
+#include "nsIMsgFilterPlugin.h"
+#include "nsIThread.h"
+#include "nsDataHashtable.h"
+#include "nsIMutableArray.h"
+#include "nsITimer.h"
+#include "nsCOMArray.h"
+#include "nsAutoSyncState.h"
+#include "nsIRequestObserver.h"
+
+class nsImapMoveCoalescer;
+class nsIMsgIdentity;
+class nsIMsgOfflineImapOperation;
+
+#define COPY_BUFFER_SIZE 16384
+
+#define NS_IMAPMAILCOPYSTATE_IID \
+{ 0xb64534f0, 0x3d53, 0x11d3, \
+    { 0xac, 0x2a, 0x00, 0x80, 0x5f, 0x8a, 0xc9, 0x68 } }
+
+class nsImapMailCopyState: public nsISupports
+{
+public:
+    NS_DECLARE_STATIC_IID_ACCESSOR(NS_IMAPMAILCOPYSTATE_IID)
+
+    NS_DECL_THREADSAFE_ISUPPORTS
+
+    nsImapMailCopyState();
+
+    nsCOMPtr<nsISupports> m_srcSupport; // source file spec or folder
+    nsCOMPtr<nsIArray> m_messages; // array of source messages
+    RefPtr<nsImapMoveCopyMsgTxn> m_undoMsgTxn; // undo object with this copy operation
+    nsCOMPtr<nsIMsgDBHdr> m_message; // current message to be copied
+    nsCOMPtr<nsIMsgCopyServiceListener> m_listener; // listener of this copy
+                                                    // operation
+    nsCOMPtr<nsIFile> m_tmpFile; // temp file spec for copy operation
+    nsCOMPtr<nsIMsgWindow> m_msgWindow; // msg window for copy operation
+
+    nsCOMPtr<nsIMsgMessageService> m_msgService; // source folder message service; can
+                                        // be Nntp, Mailbox, or Imap
+    bool m_isMove;             // is a move
+    bool m_selectedState;      // needs to be in selected state; append msg
+    bool m_isCrossServerOp; // are we copying between imap servers?
+    uint32_t m_curIndex; // message index to the message array which we are
+                         // copying
+    uint32_t m_totalCount;// total count of messages we have to do
+    uint32_t m_unreadCount; // num unread messages we're moving
+    bool m_streamCopy;
+    char *m_dataBuffer; // temporary buffer for this copy operation
+    nsCOMPtr<nsIOutputStream> m_msgFileStream;         // temporary file (processed mail)
+    uint32_t m_dataBufferSize;
+    uint32_t m_leftOver;
+    bool m_allowUndo;
+    bool m_eatLF;
+    uint32_t m_newMsgFlags; // only used if there's no m_message
+    nsCString m_newMsgKeywords; // ditto 
+    // If the server supports UIDPLUS, this is the UID for the append,
+    // if we're doing an append.
+    nsMsgKey m_appendUID;
+
+private:
+    virtual ~nsImapMailCopyState();
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsImapMailCopyState, NS_IMAPMAILCOPYSTATE_IID)
+
+// ACLs for this folder.
+// Generally, we will try to always query this class when performing
+// an operation on the folder.
+// If the server doesn't support ACLs, none of this data will be filled in.
+// Therefore, we can assume that if we look up ourselves and don't find
+// any info (and also look up "anyone") then we have full rights, that is, ACLs don't exist.
+class nsImapMailFolder;
+
+#define IMAP_ACL_READ_FLAG 0x0000001 /* SELECT, CHECK, FETCH, PARTIAL, SEARCH, COPY from folder */
+#define IMAP_ACL_STORE_SEEN_FLAG 0x0000002 /* STORE SEEN flag */
+#define IMAP_ACL_WRITE_FLAG 0x0000004 /* STORE flags other than SEEN and DELETED */
+#define IMAP_ACL_INSERT_FLAG 0x0000008 /* APPEND, COPY into folder */
+#define IMAP_ACL_POST_FLAG 0x0000010 /* Can I send mail to the submission address for folder? */
+#define IMAP_ACL_CREATE_SUBFOLDER_FLAG 0x0000020 /* Can I CREATE a subfolder of this folder? */
+#define IMAP_ACL_DELETE_FLAG 0x0000040 /* STORE DELETED flag */
+#define IMAP_ACL_ADMINISTER_FLAG 0x0000080 /* perform SETACL */
+#define IMAP_ACL_RETRIEVED_FLAG 0x0000100 /* ACL info for this folder has been initialized */
+#define IMAP_ACL_EXPUNGE_FLAG 0x0000200 // can EXPUNGE or do implicit EXPUNGE on CLOSE
+#define IMAP_ACL_DELETE_FOLDER 0x0000400 // can DELETE/RENAME folder
+
+class nsMsgIMAPFolderACL
+{
+public:
+  nsMsgIMAPFolderACL(nsImapMailFolder *folder);
+  ~nsMsgIMAPFolderACL();
+
+  bool SetFolderRightsForUser(const nsACString& userName, const nsACString& rights);
+
+public:
+
+  // generic for any user, although we might not use them in
+  // DO NOT use these for looking up information about the currently authenticated user.
+  // (There are some different checks and defaults we do).
+  // Instead, use the functions below, GetICan....()
+  bool GetCanUserLookupFolder(const nsACString& userName);      // Is folder visible to LIST/LSUB?
+  bool GetCanUserReadFolder(const nsACString& userName);        // SELECT, CHECK, FETCH, PARTIAL, SEARCH, COPY from folder?
+  bool GetCanUserStoreSeenInFolder(const nsACString& userName); // STORE SEEN flag?
+  bool GetCanUserWriteFolder(const nsACString& userName);       // STORE flags other than SEEN and DELETED?
+  bool GetCanUserInsertInFolder(const nsACString& userName);    // APPEND, COPY into folder?
+  bool GetCanUserPostToFolder(const nsACString& userName);      // Can I send mail to the submission address for folder?
+  bool GetCanUserCreateSubfolder(const nsACString& userName);   // Can I CREATE a subfolder of this folder?
+  bool GetCanUserDeleteInFolder(const nsACString& userName);    // STORE DELETED flag, perform EXPUNGE?
+  bool GetCanUserAdministerFolder(const nsACString& userName);  // perform SETACL?
+
+  // Functions to find out rights for the currently authenticated user.
+
+  bool GetCanILookupFolder();      // Is folder visible to LIST/LSUB?
+  bool GetCanIReadFolder();        // SELECT, CHECK, FETCH, PARTIAL, SEARCH, COPY from folder?
+  bool GetCanIStoreSeenInFolder(); // STORE SEEN flag?
+  bool GetCanIWriteFolder();       // STORE flags other than SEEN and DELETED?
+  bool GetCanIInsertInFolder();    // APPEND, COPY into folder?
+  bool GetCanIPostToFolder();      // Can I send mail to the submission address for folder?
+  bool GetCanICreateSubfolder();   // Can I CREATE a subfolder of this folder?
+  bool GetCanIDeleteInFolder();    // STORE DELETED flag?
+  bool GetCanIAdministerFolder();  // perform SETACL?
+  bool GetCanIExpungeFolder();     // perform EXPUNGE?
+
+  bool GetDoIHaveFullRightsForFolder(); // Returns TRUE if I have full rights on this folder (all of the above return TRUE)
+
+  bool GetIsFolderShared(); // 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.
+
+  // Returns a newly allocated string describing these rights
+  nsresult CreateACLRightsString(nsAString& rightsString);
+
+  nsresult GetRightsStringForUser(const nsACString& userName, nsCString &rights);
+
+  nsresult GetOtherUsers(nsIUTF8StringEnumerator** aResult);
+
+protected:
+  bool GetFlagSetInRightsForUser(const nsACString& userName, char flag, bool defaultIfNotFound);
+  void BuildInitialACLFromCache();
+  void UpdateACLCache();
+
+protected:
+  nsDataHashtable <nsCStringHashKey, nsCString> m_rightsHash; // Hash table, mapping username strings to rights strings.
+  nsImapMailFolder *m_folder;
+  int32_t        m_aclCount;
+
+};
+
+/**
+ * Encapsulates parameters required to playback offline ops
+ * on given folder.
+ */
+struct nsPlaybackRequest
+{
+  explicit nsPlaybackRequest(nsImapMailFolder *srcFolder, nsIMsgWindow *msgWindow)
+    : SrcFolder(srcFolder), MsgWindow(msgWindow)
+  {
+  }
+  nsImapMailFolder *SrcFolder;
+  nsCOMPtr<nsIMsgWindow> MsgWindow;
+};
+
+class nsImapMailFolder :  public nsMsgDBFolder,
+                          public nsIMsgImapMailFolder,
+                          public nsIImapMailFolderSink,
+                          public nsIImapMessageSink,
+                          public nsICopyMessageListener,
+                          public nsIMsgFilterHitNotify
+{
+ static const uint32_t PLAYBACK_TIMER_INTERVAL_IN_MS = 500; 
+public:
+  nsImapMailFolder();
+
+  NS_DECL_ISUPPORTS_INHERITED
+
+  // nsIMsgFolder methods:
+  NS_IMETHOD GetSubFolders(nsISimpleEnumerator **aResult) override;
+
+  NS_IMETHOD GetMessages(nsISimpleEnumerator* *result) override;
+  NS_IMETHOD UpdateFolder(nsIMsgWindow *aWindow) override;
+
+  NS_IMETHOD CreateSubfolder(const nsAString& folderName,nsIMsgWindow *msgWindow ) override;
+  NS_IMETHOD AddSubfolder(const nsAString& aName, nsIMsgFolder** aChild) override;
+  NS_IMETHODIMP CreateStorageIfMissing(nsIUrlListener* urlListener) override;
+
+  NS_IMETHOD Compact(nsIUrlListener *aListener, nsIMsgWindow *aMsgWindow) override;
+  NS_IMETHOD CompactAll(nsIUrlListener *aListener, nsIMsgWindow *aMsgWindow,
+                        bool aCompactOfflineAlso) override;
+  NS_IMETHOD EmptyTrash(nsIMsgWindow *msgWindow, nsIUrlListener *aListener) override;
+  NS_IMETHOD CopyDataToOutputStreamForAppend(nsIInputStream *aIStream,
+                     int32_t aLength, nsIOutputStream *outputStream) override;
+  NS_IMETHOD CopyDataDone() override;
+  NS_IMETHOD Delete () override;
+  NS_IMETHOD Rename (const nsAString& newName, nsIMsgWindow *msgWindow) override;
+  NS_IMETHOD RenameSubFolders(nsIMsgWindow *msgWindow, nsIMsgFolder *oldFolder) override;
+  NS_IMETHOD GetNoSelect(bool *aResult) override;
+
+  NS_IMETHOD GetPrettyName(nsAString& prettyName) override; // Override of the base, for top-level mail folder
+
+  NS_IMETHOD GetFolderURL(nsACString& url) override;
+
+  NS_IMETHOD UpdateSummaryTotals(bool force) override;
+
+  NS_IMETHOD GetDeletable (bool *deletable) override;
+
+  NS_IMETHOD GetSizeOnDisk(int64_t *size) override;
+
+  NS_IMETHOD GetCanCreateSubfolders(bool *aResult) override;
+  NS_IMETHOD GetCanSubscribe(bool *aResult) override;
+
+  NS_IMETHOD ApplyRetentionSettings() override;
+
+  NS_IMETHOD AddMessageDispositionState(nsIMsgDBHdr *aMessage, nsMsgDispositionState aDispositionFlag) override;
+  NS_IMETHOD MarkMessagesRead(nsIArray *messages, bool markRead) override;
+  NS_IMETHOD MarkAllMessagesRead(nsIMsgWindow *aMsgWindow) override;
+  NS_IMETHOD MarkMessagesFlagged(nsIArray *messages, bool markFlagged) override;
+  NS_IMETHOD MarkThreadRead(nsIMsgThread *thread) override;
+  NS_IMETHOD SetLabelForMessages(nsIArray *aMessages, nsMsgLabelValue aLabel) override;
+  NS_IMETHOD SetJunkScoreForMessages(nsIArray *aMessages, const nsACString& aJunkScore) override;
+  NS_IMETHOD DeleteSubFolders(nsIArray *folders, nsIMsgWindow *msgWindow) override;
+  NS_IMETHOD ReadFromFolderCacheElem(nsIMsgFolderCacheElement *element) override;
+  NS_IMETHOD WriteToFolderCacheElem(nsIMsgFolderCacheElement *element) override;
+
+  NS_IMETHOD GetDBFolderInfoAndDB(nsIDBFolderInfo **folderInfo,
+                                  nsIMsgDatabase **db) override;
+  NS_IMETHOD DeleteMessages(nsIArray *messages,
+                            nsIMsgWindow *msgWindow, bool
+                            deleteStorage, bool isMove,
+                            nsIMsgCopyServiceListener* listener, bool allowUndo) override;
+  NS_IMETHOD CopyMessages(nsIMsgFolder *srcFolder,
+                          nsIArray* messages,
+                          bool isMove, nsIMsgWindow *msgWindow,
+                          nsIMsgCopyServiceListener* listener, bool isFolder,
+                          bool allowUndo) override;
+  NS_IMETHOD CopyFolder(nsIMsgFolder *srcFolder, bool isMove, nsIMsgWindow *msgWindow,
+                        nsIMsgCopyServiceListener* listener) override;
+  NS_IMETHOD CopyFileMessage(nsIFile* file,
+                              nsIMsgDBHdr* msgToReplace,
+                              bool isDraftOrTemplate,
+                              uint32_t aNewMsgFlags,
+                              const nsACString &aNewMsgKeywords,
+                              nsIMsgWindow *msgWindow,
+                              nsIMsgCopyServiceListener* listener) override;
+  NS_IMETHOD GetNewMessages(nsIMsgWindow *aWindow, nsIUrlListener *aListener) override;
+
+  NS_IMETHOD GetFilePath(nsIFile** aPathName) override;
+  NS_IMETHOD SetFilePath(nsIFile * aPath) override;
+
+  NS_IMETHOD Shutdown(bool shutdownChildren) override;
+
+  NS_IMETHOD DownloadMessagesForOffline(nsIArray *messages, nsIMsgWindow *msgWindow) override;
+
+  NS_IMETHOD DownloadAllForOffline(nsIUrlListener *listener, nsIMsgWindow *msgWindow) override;
+  NS_IMETHOD GetCanFileMessages(bool *aCanFileMessages) override;
+  NS_IMETHOD GetCanDeleteMessages(bool *aCanDeleteMessages) override;
+  NS_IMETHOD FetchMsgPreviewText(nsMsgKey *aKeysToFetch, uint32_t aNumKeys,
+                                 bool aLocalOnly, nsIUrlListener *aUrlListener,
+                                 bool *aAsyncResults) override;
+
+  NS_IMETHOD AddKeywordsToMessages(nsIArray *aMessages, const nsACString& aKeywords) override;
+  NS_IMETHOD RemoveKeywordsFromMessages(nsIArray *aMessages, const nsACString& aKeywords) override;
+
+  NS_IMETHOD NotifyCompactCompleted() override;
+
+  // overrides nsMsgDBFolder::HasMsgOffline()
+  NS_IMETHOD HasMsgOffline(nsMsgKey msgKey, bool *_retval) override;
+  // overrides nsMsgDBFolder::GetOfflineFileStream()
+  NS_IMETHOD GetOfflineFileStream(nsMsgKey msgKey, int64_t *offset, uint32_t *size, nsIInputStream **aFileStream) override;
+
+  NS_DECL_NSIMSGIMAPMAILFOLDER
+  NS_DECL_NSIIMAPMAILFOLDERSINK
+  NS_DECL_NSIIMAPMESSAGESINK
+  NS_DECL_NSICOPYMESSAGELISTENER
+
+  // nsIUrlListener methods
+  NS_IMETHOD OnStartRunningUrl(nsIURI * aUrl) override;
+  NS_IMETHOD OnStopRunningUrl(nsIURI * aUrl, nsresult aExitCode) override;
+
+  NS_DECL_NSIMSGFILTERHITNOTIFY
+  NS_DECL_NSIJUNKMAILCLASSIFICATIONLISTENER
+
+  NS_IMETHOD IsCommandEnabled(const nsACString& command, bool *result) override;
+  NS_IMETHOD SetFilterList(nsIMsgFilterList *aMsgFilterList) override;
+  NS_IMETHOD GetCustomIdentity(nsIMsgIdentity **aIdentity) override;
+
+ /**
+  * This method is used to locate a folder where a msg could be present, not just
+  * the folder where the message first arrives, this method searches for the existence
+  * of msg in all the folders/labels that we retrieve from X-GM-LABELS also.
+  * overrides nsMsgDBFolder::GetOfflineMsgFolder()
+  *  @param msgKey key  of the msg for which we are trying to get the folder;
+  *  @param aMsgFolder  required folder;
+  */
+  NS_IMETHOD GetOfflineMsgFolder(nsMsgKey msgKey, nsIMsgFolder **aMsgFolder) override;
+
+  NS_IMETHOD GetIncomingServerType(nsACString& serverType) override;
+
+  nsresult AddSubfolderWithPath(nsAString& name, nsIFile *dbPath, nsIMsgFolder **child, bool brandNew = false);
+  nsresult MoveIncorporatedMessage(nsIMsgDBHdr *mailHdr,
+                                  nsIMsgDatabase *sourceDB,
+                                  const nsACString& destFolder,
+                                  nsIMsgFilter *filter,
+                                  nsIMsgWindow *msgWindow);
+
+  // send notification to copy service listener.
+  nsresult OnCopyCompleted(nsISupports *srcSupport, nsresult exitCode);
+
+  static nsresult  AllocateUidStringFromKeys(nsMsgKey *keys, uint32_t numKeys, nsCString &msgIds);
+  static nsresult  BuildIdsAndKeyArray(nsIArray* messages, nsCString& msgIds, nsTArray<nsMsgKey>& keyArray);
+
+  // these might end up as an nsIImapMailFolder attribute.
+  nsresult SetSupportedUserFlags(uint32_t userFlags);
+  nsresult GetSupportedUserFlags(uint32_t *userFlags);
+
+  // Find the start of a range of msgKeys that can hold srcCount headers.
+  nsresult FindOpenRange(nsMsgKey &fakeBase, uint32_t srcCount);
+
+protected:
+  virtual ~nsImapMailFolder();
+  // Helper methods
+
+  virtual nsresult CreateChildFromURI(const nsCString &uri, nsIMsgFolder **folder) override;
+  void FindKeysToAdd(const nsTArray<nsMsgKey> &existingKeys, nsTArray<nsMsgKey>
+    &keysToFetch, uint32_t &numNewUnread, nsIImapFlagAndUidState *flagState);
+  void FindKeysToDelete(const nsTArray<nsMsgKey> &existingKeys, nsTArray<nsMsgKey>
+    &keysToFetch, nsIImapFlagAndUidState *flagState, uint32_t boxFlags);
+  void PrepareToAddHeadersToMailDB(nsIImapProtocol* aProtocol);
+  void TweakHeaderFlags(nsIImapProtocol* aProtocol, nsIMsgDBHdr *tweakMe);
+
+  nsresult SyncFlags(nsIImapFlagAndUidState *flagState);
+  nsresult HandleCustomFlags(nsMsgKey uidOfMessage, nsIMsgDBHdr *dbHdr,
+                             uint16_t userFlags, nsCString& keywords);
+  nsresult NotifyMessageFlagsFromHdr(nsIMsgDBHdr *dbHdr, nsMsgKey msgKey,
+                                     uint32_t flags);
+
+  nsresult SetupHeaderParseStream(uint32_t size, const nsACString& content_type, nsIMailboxSpec *boxSpec);
+  nsresult  ParseAdoptedHeaderLine(const char *messageLine, nsMsgKey msgKey);
+  nsresult  NormalEndHeaderParseStream(nsIImapProtocol *aProtocol, nsIImapUrl *imapUrl);
+
+  void EndOfflineDownload();
+
+  /**
+   * At the end of a file-to-folder copy operation, copy the file to the
+   * offline store and/or add to the message database, (if needed).
+   *
+   * @param srcFile       file containing the message key
+   * @param msgKey        key to use for the new messages
+   */   
+  nsresult CopyFileToOfflineStore(nsIFile *srcFile, nsMsgKey msgKey);
+
+  nsresult MarkMessagesImapDeleted(nsTArray<nsMsgKey> *keyArray, bool deleted, nsIMsgDatabase *db);
+
+  // Notifies imap autosync that it should update this folder when it
+  // gets a chance.
+  void NotifyHasPendingMsgs();
+  void UpdatePendingCounts();
+  void SetIMAPDeletedFlag(nsIMsgDatabase *mailDB, const nsTArray<nsMsgKey> &msgids, bool markDeleted);
+  virtual bool ShowDeletedMessages();
+  virtual bool DeleteIsMoveToTrash();
+  nsresult GetFolder(const nsACString& name, nsIMsgFolder **pFolder);
+  nsresult GetTrashFolder(nsIMsgFolder **pTrashFolder);
+  bool TrashOrDescendentOfTrash(nsIMsgFolder* folder);
+  static bool ShouldCheckAllFolders(nsIImapIncomingServer *imapServer);
+  nsresult GetServerKey(nsACString& serverKey);
+  nsresult DisplayStatusMsg(nsIImapUrl *aImapUrl, const nsAString& msg);
+
+  //nsresult RenameLocal(const char *newName);
+  nsresult AddDirectorySeparator(nsIFile *path);
+  nsresult CreateSubFolders(nsIFile *path);
+  nsresult GetDatabase() override;
+
+  nsresult        GetFolderOwnerUserName(nsACString& userName);
+  nsIMAPNamespace *GetNamespaceForFolder();
+  void            SetNamespaceForFolder(nsIMAPNamespace *ns);
+
+  nsMsgIMAPFolderACL * GetFolderACL();
+  nsresult CreateACLRightsStringForFolder(nsAString& rightsString);
+  nsresult GetBodysToDownload(nsTArray<nsMsgKey> *keysOfMessagesToDownload);
+  // Uber message copy service
+  nsresult CopyMessagesWithStream(nsIMsgFolder* srcFolder,
+                                    nsIArray* messages,
+                                    bool isMove,
+                                    bool isCrossServerOp,
+                                    nsIMsgWindow *msgWindow,
+                                    nsIMsgCopyServiceListener* listener, bool allowUndo);
+  nsresult CopyStreamMessage(nsIMsgDBHdr* message, nsIMsgFolder* dstFolder,
+                            nsIMsgWindow *msgWindow, bool isMove);
+  nsresult InitCopyState(nsISupports* srcSupport,
+                          nsIArray* messages,
+                          bool isMove,
+                          bool selectedState,
+                          bool acrossServers,
+                          uint32_t newMsgFlags,
+                          const nsACString &newMsgKeywords,
+                          nsIMsgCopyServiceListener* listener,
+                          nsIMsgWindow *msgWindow,
+                          bool allowUndo);
+  nsresult GetMoveCoalescer();
+  nsresult PlaybackCoalescedOperations();
+  virtual nsresult CreateBaseMessageURI(const nsACString& aURI) override;
+  // offline-ish methods
+  nsresult GetClearedOriginalOp(nsIMsgOfflineImapOperation *op, nsIMsgOfflineImapOperation **originalOp, nsIMsgDatabase **originalDB);
+  nsresult GetOriginalOp(nsIMsgOfflineImapOperation *op, nsIMsgOfflineImapOperation **originalOp, nsIMsgDatabase **originalDB);
+  nsresult CopyMessagesOffline(nsIMsgFolder* srcFolder,
+                                nsIArray* messages,
+                                bool isMove,
+                                nsIMsgWindow *msgWindow,
+                                nsIMsgCopyServiceListener* listener);
+  void SetPendingAttributes(nsIArray* messages, bool aIsMove);
+
+  nsresult CopyOfflineMsgBody(nsIMsgFolder *srcFolder, nsIMsgDBHdr *destHdr,
+                              nsIMsgDBHdr *origHdr, nsIInputStream *inputStream,
+                              nsIOutputStream *outputStream);
+
+  void GetTrashFolderName(nsAString &aFolderName);
+  bool ShowPreviewText();
+
+  // Pseudo-Offline operation playback timer
+  static void PlaybackTimerCallback(nsITimer *aTimer, void *aClosure);
+
+  nsresult CreatePlaybackTimer();
+
+  // Allocate and initialize associated auto-sync state object.
+  void InitAutoSyncState();
+
+  bool m_initialized;
+  bool m_haveDiscoveredAllFolders;
+  nsCOMPtr<nsIMsgParseMailMsgState> m_msgParser;
+  nsCOMPtr<nsIMsgFilterList> m_filterList;
+  nsCOMPtr<nsIMsgFilterPlugin> m_filterPlugin;  // XXX should be a list
+  // used with filter plugins to know when we've finished classifying and can playback moves
+  bool m_msgMovedByFilter;
+  nsImapMoveCoalescer *m_moveCoalescer; // strictly owned by the nsImapMailFolder
+  nsCOMPtr<nsIMutableArray> m_junkMessagesToMarkAsRead;
+  /// list of keys to be moved to the junk folder
+  nsTArray<nsMsgKey> mSpamKeysToMove;
+  /// the junk destination folder
+  nsCOMPtr<nsIMsgFolder> mSpamFolder;
+  nsMsgKey m_curMsgUid;
+  uint32_t m_uidValidity;
+
+  // These three vars are used to store counts from STATUS or SELECT command
+  // They include deleted messages, so they can differ from the generic
+  // folder total and unread counts.
+  int32_t m_numServerRecentMessages;
+  int32_t m_numServerUnseenMessages;
+  int32_t m_numServerTotalMessages;
+  // if server supports UIDNEXT, we store it here.
+  int32_t m_nextUID;
+
+  int32_t  m_nextMessageByteLength;
+  nsCOMPtr<nsIUrlListener> m_urlListener;
+  bool m_urlRunning;
+
+  // undo move/copy transaction support
+  RefPtr<nsMsgTxn> m_pendingUndoTxn;
+  RefPtr<nsImapMailCopyState> m_copyState;
+  char m_hierarchyDelimiter;
+  int32_t m_boxFlags;
+  nsCString m_onlineFolderName;
+  nsCString m_ownerUserName;  // username of the "other user," as in
+  // "Other Users' Mailboxes"
+
+  nsCString m_adminUrl;   // url to run to set admin privileges for this folder
+  nsIMAPNamespace  *m_namespace;
+  bool m_verifiedAsOnlineFolder;
+  bool m_explicitlyVerify; // whether or not we need to explicitly verify this through LIST
+  bool m_folderIsNamespace;
+  bool m_folderNeedsSubscribing;
+  bool m_folderNeedsAdded;
+  bool m_folderNeedsACLListed;
+  bool m_performingBiff;
+  bool m_folderQuotaCommandIssued;
+  bool m_folderQuotaDataIsValid;
+  bool m_updatingFolder;
+  // These two vars are used to keep track of compaction state so we can know
+  // when to send a done notification.
+  bool m_compactingOfflineStore;
+  bool m_expunging;
+  bool m_applyIncomingFilters; // apply filters to this folder, even if not the inbox
+  nsMsgIMAPFolderACL *m_folderACL;
+  uint32_t     m_aclFlags;
+  uint32_t     m_supportedUserFlags;
+
+  // determines if we are on GMail server
+  bool m_isGmailServer;
+  // offline imap support
+  bool m_downloadingFolderForOfflineUse;
+  bool m_filterListRequiresBody;
+
+  // auto-sync (automatic message download) support
+  RefPtr<nsAutoSyncState> m_autoSyncStateObj;
+
+  // Quota support
+  nsCString m_folderQuotaRoot;
+  uint32_t m_folderQuotaUsedKB;
+  uint32_t m_folderQuotaMaxKB;
+
+  // Pseudo-Offline Playback support
+  nsPlaybackRequest *m_pendingPlaybackReq;
+  nsCOMPtr<nsITimer> m_playbackTimer;
+  nsTArray<RefPtr<nsImapMoveCopyMsgTxn> > m_pendingOfflineMoves;
+  // hash table of mapping between messageids and message keys
+  // for pseudo hdrs.
+  nsDataHashtable<nsCStringHashKey, nsMsgKey> m_pseudoHdrs;
+
+  nsTArray<nsMsgKey> m_keysToFetch;
+  uint32_t m_totalKeysToFetch;
+
+  /**
+   * delete if appropriate local storage for messages in this folder
+   *
+   * @parm aMessages array (of nsIMsgDBHdr) of messages to delete
+   *       (or an array of message keys)
+   * @parm aSrcFolder the folder containing the messages (optional)
+   */
+  void DeleteStoreMessages(nsIArray* aMessages);
+  void DeleteStoreMessages(nsTArray<nsMsgKey> &aMessages);
+  static void DeleteStoreMessages(nsTArray<nsMsgKey> &aMessages, nsIMsgFolder* aFolder);
+};
+#endif
diff --git a/mailnews/imap/src/nsImapOfflineSync.cpp b/mailnews/imap/src/nsImapOfflineSync.cpp
new file mode 100644
index 0000000000..df31bd2995
--- /dev/null
+++ b/mailnews/imap/src/nsImapOfflineSync.cpp
@@ -0,0 +1,1292 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"
+#include "netCore.h"
+#include "nsNetUtil.h"
+#include "nsImapOfflineSync.h"
+#include "nsImapMailFolder.h"
+#include "nsMsgFolderFlags.h"
+#include "nsIRDFService.h"
+#include "nsMsgBaseCID.h"
+#include "nsRDFCID.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMsgAccountManager.h"
+#include "nsINntpIncomingServer.h"
+#include "nsIRequestObserver.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsISeekableStream.h"
+#include "nsIMsgCopyService.h"
+#include "nsImapProtocol.h"
+#include "nsMsgUtils.h"
+#include "nsIMutableArray.h"
+#include "nsIAutoSyncManager.h"
+#include "nsAlgorithm.h"
+#include "nsArrayUtils.h"
+#include <algorithm>
+
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+
+NS_IMPL_ISUPPORTS(nsImapOfflineSync, nsIUrlListener, nsIMsgCopyServiceListener, nsIDBChangeListener)
+
+nsImapOfflineSync::nsImapOfflineSync(nsIMsgWindow *window, nsIUrlListener *listener, nsIMsgFolder *singleFolderOnly, bool isPseudoOffline)
+{
+  m_singleFolderToUpdate = singleFolderOnly;
+  m_window = window;
+  // not the perfect place for this, but I think it will work.
+  if (m_window)
+    m_window->SetStopped(false);
+
+  mCurrentPlaybackOpType = nsIMsgOfflineImapOperation::kFlagsChanged;
+  m_mailboxupdatesStarted = false;
+  m_mailboxupdatesFinished = false;
+  m_createdOfflineFolders = false;
+  m_pseudoOffline = isPseudoOffline;
+  m_KeyIndex = 0;
+  mCurrentUIDValidity = nsMsgKey_None;
+  m_listener = listener;
+}
+
+nsImapOfflineSync::~nsImapOfflineSync()
+{
+}
+
+void      nsImapOfflineSync::SetWindow(nsIMsgWindow *window)
+{
+  m_window = window;
+}
+
+NS_IMETHODIMP nsImapOfflineSync::OnStartRunningUrl(nsIURI* url)
+{
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapOfflineSync::OnStopRunningUrl(nsIURI* url, nsresult exitCode)
+{
+  nsresult rv = exitCode;
+
+  // where do we make sure this gets cleared when we start running urls?
+  bool stopped = false;
+  if (m_window)
+    m_window->GetStopped(&stopped);
+
+  if (m_curTempFile)
+  {
+    m_curTempFile->Remove(false);
+    m_curTempFile = nullptr;
+  }
+  // NS_BINDING_ABORTED is used for the user pressing stop, which
+  // should cause us to abort the offline process. Other errors
+  // should allow us to continue.
+  if (stopped)
+  {
+    if (m_listener)
+      m_listener->OnStopRunningUrl(url, NS_BINDING_ABORTED);
+    return NS_OK;
+  }
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(url);
+
+  if (imapUrl)
+    nsImapProtocol::LogImapUrl(NS_SUCCEEDED(rv) ?
+                               "offline imap url succeeded " :
+                               "offline imap url failed ", imapUrl);
+
+  // If we succeeded, or it was an imap move/copy that timed out, clear the
+  // operation.
+  bool moveCopy = mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kMsgCopy ||
+    mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kMsgMoved;
+  if (NS_SUCCEEDED(exitCode) || exitCode == NS_MSG_ERROR_IMAP_COMMAND_FAILED ||
+      (moveCopy && exitCode == NS_ERROR_NET_TIMEOUT))
+  {
+    ClearCurrentOps();
+    rv = ProcessNextOperation();
+  }
+  // else if it's a non-stop error, and we're doing multiple folders,
+  // go to the next folder.
+  else if (!m_singleFolderToUpdate)
+  {
+    if (AdvanceToNextFolder())
+      rv = ProcessNextOperation();
+    else if (m_listener)
+      m_listener->OnStopRunningUrl(url, rv);
+  }
+
+  return rv;
+}
+
+/**
+ * Leaves m_currentServer at the next imap or local mail "server" that
+ * might have offline events to playback. If no more servers,
+ * m_currentServer will be left at nullptr and the function returns false.
+ * Also, sets up m_serverEnumerator to enumerate over the server.
+ */
+bool nsImapOfflineSync::AdvanceToNextServer()
+{
+  nsresult rv = NS_OK;
+
+  if (!m_allServers)
+  {
+    NS_ASSERTION(!m_currentServer, "this shouldn't be set");
+    m_currentServer = nullptr;
+    nsCOMPtr<nsIMsgAccountManager> accountManager = 
+             do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+    NS_ASSERTION(accountManager && NS_SUCCEEDED(rv), "couldn't get account mgr");
+    if (!accountManager || NS_FAILED(rv))
+      return false;
+
+    rv = accountManager->GetAllServers(getter_AddRefs(m_allServers));
+    NS_ENSURE_SUCCESS(rv, false);
+  }
+  uint32_t serverIndex = 0;
+  if (m_currentServer)
+  {
+    rv = m_allServers->IndexOf(0, m_currentServer, &serverIndex);
+    if (NS_FAILED(rv))
+      serverIndex = -1;
+
+    // Move to the next server
+    ++serverIndex;
+  }
+  m_currentServer = nullptr;
+  uint32_t numServers;
+  m_allServers->GetLength(&numServers);
+  nsCOMPtr <nsIMsgFolder> rootFolder;
+
+  while (serverIndex < numServers)
+  {
+    nsCOMPtr<nsIMsgIncomingServer> server(do_QueryElementAt(m_allServers, serverIndex));
+    serverIndex++;
+
+    nsCOMPtr<nsINntpIncomingServer> newsServer = do_QueryInterface(server);
+    if (newsServer) // news servers aren't involved in offline imap
+      continue;
+
+    if (server)
+    {
+      m_currentServer = server;
+      server->GetRootFolder(getter_AddRefs(rootFolder));
+      if (rootFolder)
+      {
+        rv = rootFolder->GetDescendants(getter_AddRefs(m_allFolders));
+        if (NS_SUCCEEDED(rv))
+        {
+          rv = m_allFolders->Enumerate(getter_AddRefs(m_serverEnumerator));
+          if (NS_SUCCEEDED(rv) && m_serverEnumerator)
+          {
+            bool hasMore = false;
+            rv = m_serverEnumerator->HasMoreElements(&hasMore);
+            if (NS_SUCCEEDED(rv) && hasMore)
+              return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Sets m_currentFolder to the next folder to process.
+ *
+ * @return  True if next folder to process was found, otherwise false.
+ */
+bool nsImapOfflineSync::AdvanceToNextFolder()
+{
+  // we always start by changing flags
+  mCurrentPlaybackOpType = nsIMsgOfflineImapOperation::kFlagsChanged;
+
+  if (m_currentFolder)
+  {
+    m_currentFolder->SetMsgDatabase(nullptr);
+    m_currentFolder = nullptr;
+  }
+
+  bool hasMore = false;
+  if (m_currentServer)
+    m_serverEnumerator->HasMoreElements(&hasMore);
+  if (!hasMore)
+    hasMore = AdvanceToNextServer();
+
+  if (hasMore)
+  {
+    nsCOMPtr<nsISupports> supports;
+    nsresult rv = m_serverEnumerator->GetNext(getter_AddRefs(supports));
+    if (NS_SUCCEEDED(rv))
+      m_currentFolder = do_QueryInterface(supports);
+  }
+  ClearDB();
+  return m_currentFolder;
+}
+
+void nsImapOfflineSync::AdvanceToFirstIMAPFolder()
+{
+  m_currentServer = nullptr;
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder;
+  while (!imapFolder && AdvanceToNextFolder())
+  {
+    imapFolder = do_QueryInterface(m_currentFolder);
+  }
+}
+
+void nsImapOfflineSync::ProcessFlagOperation(nsIMsgOfflineImapOperation *op)
+{
+  nsCOMPtr <nsIMsgOfflineImapOperation> currentOp = op;
+  nsTArray<nsMsgKey> matchingFlagKeys;
+  uint32_t currentKeyIndex = m_KeyIndex;
+
+  imapMessageFlagsType matchingFlags;
+  currentOp->GetNewFlags(&matchingFlags);
+  imapMessageFlagsType flagOperation;
+  imapMessageFlagsType newFlags;
+  bool flagsMatch = true;
+  do
+  { // loop for all messsages with the same flags
+    if (flagsMatch)
+    {
+      nsMsgKey curKey;
+      currentOp->GetMessageKey(&curKey);
+      matchingFlagKeys.AppendElement(curKey);
+      currentOp->SetPlayingBack(true);
+      m_currentOpsToClear.AppendObject(currentOp);
+    }
+    currentOp = nullptr;
+    if (++currentKeyIndex < m_CurrentKeys.Length())
+      m_currentDB->GetOfflineOpForKey(m_CurrentKeys[currentKeyIndex], false,
+        getter_AddRefs(currentOp));
+    if (currentOp)
+    {
+      currentOp->GetFlagOperation(&flagOperation);
+      currentOp->GetNewFlags(&newFlags);
+    }
+    flagsMatch = (flagOperation & nsIMsgOfflineImapOperation::kFlagsChanged)
+                  && (newFlags == matchingFlags);
+  } while (currentOp);
+
+  if (!matchingFlagKeys.IsEmpty())
+  {
+    nsAutoCString uids;
+    nsImapMailFolder::AllocateUidStringFromKeys(matchingFlagKeys.Elements(), matchingFlagKeys.Length(), uids);
+    uint32_t curFolderFlags;
+    m_currentFolder->GetFlags(&curFolderFlags);
+
+    if (uids.get() && (curFolderFlags & nsMsgFolderFlags::ImapBox)) 
+    {
+      nsresult rv = NS_OK;
+      nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(m_currentFolder);
+      nsCOMPtr <nsIURI> uriToSetFlags;
+      if (imapFolder)
+      {
+        rv = imapFolder->SetImapFlags(uids.get(), matchingFlags, getter_AddRefs(uriToSetFlags));
+        if (NS_SUCCEEDED(rv) && uriToSetFlags)
+        {
+          nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(uriToSetFlags);
+          if (mailnewsUrl)
+            mailnewsUrl->RegisterListener(this);
+        }
+      }
+    }
+  }
+  else
+    ProcessNextOperation();
+}
+
+void nsImapOfflineSync::ProcessKeywordOperation(nsIMsgOfflineImapOperation *op)
+{
+  nsCOMPtr <nsIMsgOfflineImapOperation> currentOp = op;
+  nsTArray<nsMsgKey> matchingKeywordKeys;
+  uint32_t currentKeyIndex = m_KeyIndex;
+
+  nsAutoCString keywords;
+  if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kAddKeywords)
+    currentOp->GetKeywordsToAdd(getter_Copies(keywords));
+  else
+    currentOp->GetKeywordsToRemove(getter_Copies(keywords));
+  bool keywordsMatch = true;	
+  do
+  { // loop for all messsages with the same keywords
+    if (keywordsMatch)
+    {
+      nsMsgKey curKey;
+      currentOp->GetMessageKey(&curKey);
+      matchingKeywordKeys.AppendElement(curKey);
+      currentOp->SetPlayingBack(true);
+      m_currentOpsToClear.AppendObject(currentOp);
+    }
+    currentOp = nullptr;
+    if (++currentKeyIndex < m_CurrentKeys.Length())
+      m_currentDB->GetOfflineOpForKey(m_CurrentKeys[currentKeyIndex], false,
+        getter_AddRefs(currentOp));
+    if (currentOp)
+    {
+      nsAutoCString curOpKeywords;
+      nsOfflineImapOperationType operation;
+      currentOp->GetOperation(&operation);
+      if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kAddKeywords)
+        currentOp->GetKeywordsToAdd(getter_Copies(curOpKeywords));
+      else
+        currentOp->GetKeywordsToRemove(getter_Copies(curOpKeywords));
+      keywordsMatch = (operation & mCurrentPlaybackOpType)
+                  && (curOpKeywords.Equals(keywords));
+    }
+  } while (currentOp);
+
+  if (!matchingKeywordKeys.IsEmpty())
+  {
+    uint32_t curFolderFlags;
+    m_currentFolder->GetFlags(&curFolderFlags);
+
+    if (curFolderFlags & nsMsgFolderFlags::ImapBox)
+    {
+      nsresult rv = NS_OK;
+      nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(m_currentFolder);
+      nsCOMPtr <nsIURI> uriToStoreCustomKeywords;
+      if (imapFolder)
+      {
+        rv = imapFolder->StoreCustomKeywords(m_window, 
+                    (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kAddKeywords) ? keywords : EmptyCString(), 
+                    (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kRemoveKeywords) ? keywords : EmptyCString(), 
+                    matchingKeywordKeys.Elements(), 
+                    matchingKeywordKeys.Length(), getter_AddRefs(uriToStoreCustomKeywords));
+        if (NS_SUCCEEDED(rv) && uriToStoreCustomKeywords)
+        {
+          nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(uriToStoreCustomKeywords);
+          if (mailnewsUrl)
+            mailnewsUrl->RegisterListener(this);
+        }
+      }
+    }
+  }
+  else
+    ProcessNextOperation();
+}
+
+void
+nsImapOfflineSync::ProcessAppendMsgOperation(nsIMsgOfflineImapOperation *currentOp, int32_t opType)
+{
+  nsCOMPtr <nsIMsgDBHdr> mailHdr;
+  nsMsgKey msgKey;
+  currentOp->GetMessageKey(&msgKey);
+  nsresult rv = m_currentDB->GetMsgHdrForKey(msgKey, getter_AddRefs(mailHdr)); 
+  if (NS_SUCCEEDED(rv) && mailHdr)
+  {
+    uint64_t messageOffset;
+    uint32_t messageSize;
+    mailHdr->GetMessageOffset(&messageOffset);
+    mailHdr->GetOfflineMessageSize(&messageSize);
+    nsCOMPtr<nsIFile> tmpFile;
+
+    if (NS_FAILED(GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR,
+                                                  "nscpmsg.txt",
+                                                  getter_AddRefs(tmpFile))))
+      return;
+
+    if (NS_FAILED(tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600)))
+      return;
+
+    nsCOMPtr <nsIOutputStream> outputStream;
+    rv = MsgNewBufferedFileOutputStream(getter_AddRefs(outputStream), tmpFile, PR_WRONLY | PR_CREATE_FILE, 00600);
+    if (NS_SUCCEEDED(rv) && outputStream)
+    {
+      nsCString moveDestination;
+      currentOp->GetDestinationFolderURI(getter_Copies(moveDestination));
+      nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv));
+      nsCOMPtr<nsIRDFResource> res;
+      if (NS_FAILED(rv)) return ; // ### return error code.
+      rv = rdf->GetResource(moveDestination, getter_AddRefs(res));
+      if (NS_SUCCEEDED(rv))
+      {
+        nsCOMPtr<nsIMsgFolder> destFolder(do_QueryInterface(res, &rv));
+        if (NS_SUCCEEDED(rv) && destFolder)
+        {
+          nsCOMPtr <nsIInputStream> offlineStoreInputStream;
+          bool reusable;
+          rv = destFolder->GetMsgInputStream(
+                 mailHdr, &reusable, getter_AddRefs(offlineStoreInputStream));
+          if (NS_SUCCEEDED(rv) && offlineStoreInputStream)
+          {
+            nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(offlineStoreInputStream);
+            NS_ASSERTION(seekStream, "non seekable stream - can't read from offline msg");
+            if (seekStream)
+            {
+              rv = seekStream->Seek(PR_SEEK_SET, messageOffset);
+              if (NS_SUCCEEDED(rv))
+              {
+                // now, copy the dest folder offline store msg to the temp file
+                int32_t inputBufferSize = FILE_IO_BUFFER_SIZE;
+                char *inputBuffer = (char *) PR_Malloc(inputBufferSize);
+
+                int32_t bytesLeft;
+                uint32_t bytesRead, bytesWritten;
+                bytesLeft = messageSize;
+                rv = inputBuffer ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+                while (bytesLeft > 0 && NS_SUCCEEDED(rv))
+                {
+                  int32_t bytesToRead = std::min(inputBufferSize, bytesLeft);
+                  rv = offlineStoreInputStream->Read(inputBuffer, bytesToRead, &bytesRead);
+                  if (NS_SUCCEEDED(rv) && bytesRead > 0)
+                  {
+                    rv = outputStream->Write(inputBuffer, bytesRead, &bytesWritten);
+                    NS_ASSERTION(bytesWritten == bytesRead, "wrote out incorrect number of bytes");
+                  }
+                  else
+                    break;
+                  bytesLeft -= bytesRead;
+                }
+                PR_FREEIF(inputBuffer);
+
+                outputStream->Flush();
+                outputStream->Close();
+                if (NS_SUCCEEDED(rv))
+                {
+                  nsCOMPtr<nsIFile> cloneTmpFile;
+                  // clone the tmp file to defeat nsIFile's stat/size caching.
+                  tmpFile->Clone(getter_AddRefs(cloneTmpFile));
+                  m_curTempFile = do_QueryInterface(cloneTmpFile);
+                  nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID);
+                  if (copyService)
+                    rv = copyService->CopyFileMessage(cloneTmpFile, destFolder,
+                    /* nsIMsgDBHdr* msgToReplace */ nullptr,
+                    true /* isDraftOrTemplate */,
+                    0, // new msg flags - are there interesting flags here?
+                    EmptyCString(), /* are there keywords we should get? */
+                      this,
+                      m_window);
+                }
+                else
+                  tmpFile->Remove(false);
+              }
+              currentOp->SetPlayingBack(true);
+              m_currentOpsToClear.AppendObject(currentOp);
+              m_currentDB->DeleteHeader(mailHdr, nullptr, true, true);
+            }
+          }
+          // want to close in failure case too
+          outputStream->Close();
+        }
+      }
+    }
+  }
+  else
+  {
+    m_currentDB->RemoveOfflineOp(currentOp);
+    ProcessNextOperation();
+  }
+}
+
+void nsImapOfflineSync::ClearCurrentOps()
+{
+  int32_t opCount = m_currentOpsToClear.Count();
+  for (int32_t i = opCount - 1; i >= 0; i--)
+  {
+    m_currentOpsToClear[i]->SetPlayingBack(false);
+    m_currentOpsToClear[i]->ClearOperation(mCurrentPlaybackOpType);
+    m_currentOpsToClear.RemoveObjectAt(i);
+  }
+}
+
+void nsImapOfflineSync::ProcessMoveOperation(nsIMsgOfflineImapOperation *op)
+{
+  nsTArray<nsMsgKey> matchingFlagKeys;
+  uint32_t currentKeyIndex = m_KeyIndex;
+  nsCString moveDestination;
+  op->GetDestinationFolderURI(getter_Copies(moveDestination));
+  bool moveMatches = true;
+  nsCOMPtr <nsIMsgOfflineImapOperation> currentOp = op;
+  do 
+  {	// loop for all messsages with the same destination
+    if (moveMatches)
+    {
+      nsMsgKey curKey;
+      currentOp->GetMessageKey(&curKey);
+      matchingFlagKeys.AppendElement(curKey);
+      currentOp->SetPlayingBack(true);
+      m_currentOpsToClear.AppendObject(currentOp);
+    }
+    currentOp = nullptr;
+    
+    if (++currentKeyIndex < m_CurrentKeys.Length())
+    {
+      nsCString nextDestination;
+      nsresult rv = m_currentDB->GetOfflineOpForKey(m_CurrentKeys[currentKeyIndex], false, getter_AddRefs(currentOp));
+      moveMatches = false;
+      if (NS_SUCCEEDED(rv) && currentOp)
+      {
+        nsOfflineImapOperationType opType; 
+        currentOp->GetOperation(&opType);
+        if (opType & nsIMsgOfflineImapOperation::kMsgMoved)
+        {
+          currentOp->GetDestinationFolderURI(getter_Copies(nextDestination));
+          moveMatches = moveDestination.Equals(nextDestination);
+        }
+      }
+    }
+  } 
+  while (currentOp);
+  
+  nsCOMPtr<nsIMsgFolder> destFolder;
+  GetExistingFolder(moveDestination, getter_AddRefs(destFolder));
+  // if the dest folder doesn't really exist, these operations are
+  // going to fail, so clear them out and move on.
+  if (!destFolder)
+  {
+    NS_ERROR("trying to playing back move to non-existent folder");
+    ClearCurrentOps();
+    ProcessNextOperation();
+    return;
+  }
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(m_currentFolder);
+  if (imapFolder && DestFolderOnSameServer(destFolder))
+  {
+    imapFolder->ReplayOfflineMoveCopy(matchingFlagKeys.Elements(), matchingFlagKeys.Length(), true, destFolder,
+      this, m_window);
+  }
+  else
+  {
+    nsresult rv;
+    nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+    if (NS_SUCCEEDED(rv))
+    {
+      for (uint32_t keyIndex = 0; keyIndex < matchingFlagKeys.Length(); keyIndex++)
+      {
+        nsCOMPtr<nsIMsgDBHdr> mailHdr = nullptr;
+        rv = m_currentFolder->GetMessageHeader(matchingFlagKeys.ElementAt(keyIndex), getter_AddRefs(mailHdr));
+        if (NS_SUCCEEDED(rv) && mailHdr)
+        {
+          uint32_t msgSize;
+          // in case of a move, the header has already been deleted,
+          // so we've really got a fake header. We need to get its flags and
+          // size from the offline op to have any chance of doing the move.
+          mailHdr->GetMessageSize(&msgSize);
+          if (!msgSize)
+          {
+            imapMessageFlagsType newImapFlags;
+            uint32_t msgFlags = 0;
+            op->GetMsgSize(&msgSize);
+            op->GetNewFlags(&newImapFlags);
+            // first three bits are the same
+            msgFlags |= (newImapFlags & 0x07);
+            if (newImapFlags & kImapMsgForwardedFlag)
+              msgFlags |= nsMsgMessageFlags::Forwarded;
+            mailHdr->SetFlags(msgFlags);
+            mailHdr->SetMessageSize(msgSize);
+          }
+          messages->AppendElement(mailHdr, false);
+        }
+      }
+      nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+      if (copyService)
+        copyService->CopyMessages(m_currentFolder, messages, destFolder, true, this, m_window, false);
+    }
+  }
+}
+
+// I'm tempted to make this a method on nsIMsgFolder, but that interface
+// is already so huge, and there are only a few places in the code that do this.
+// If there end up to be more places that need this, then we can reconsider.
+bool nsImapOfflineSync::DestFolderOnSameServer(nsIMsgFolder *destFolder)
+{
+  nsCOMPtr<nsIMsgIncomingServer> srcServer;
+  nsCOMPtr<nsIMsgIncomingServer> dstServer;
+
+  bool sameServer = false;
+  if (NS_SUCCEEDED(m_currentFolder->GetServer(getter_AddRefs(srcServer))) 
+    && NS_SUCCEEDED(destFolder->GetServer(getter_AddRefs(dstServer))))
+    dstServer->Equals(srcServer, &sameServer);
+  return sameServer;
+}
+
+void nsImapOfflineSync::ProcessCopyOperation(nsIMsgOfflineImapOperation *aCurrentOp)
+{
+  nsCOMPtr<nsIMsgOfflineImapOperation> currentOp = aCurrentOp;
+
+  nsTArray<nsMsgKey> matchingFlagKeys;
+  uint32_t currentKeyIndex = m_KeyIndex;
+  nsCString copyDestination;
+  currentOp->GetCopyDestination(0, getter_Copies(copyDestination));
+  bool copyMatches = true;
+  nsresult rv;
+
+  do { // loop for all messsages with the same destination
+    if (copyMatches)
+    {
+      nsMsgKey curKey;
+      currentOp->GetMessageKey(&curKey);
+      matchingFlagKeys.AppendElement(curKey);
+      currentOp->SetPlayingBack(true);
+      m_currentOpsToClear.AppendObject(currentOp);
+    }
+    currentOp = nullptr;
+
+    if (++currentKeyIndex < m_CurrentKeys.Length())
+    {
+      nsCString nextDestination;
+      rv = m_currentDB->GetOfflineOpForKey(m_CurrentKeys[currentKeyIndex],
+                                           false, getter_AddRefs(currentOp));
+      copyMatches = false;
+      if (NS_SUCCEEDED(rv) && currentOp)
+      {
+        nsOfflineImapOperationType opType; 
+        currentOp->GetOperation(&opType);
+        if (opType & nsIMsgOfflineImapOperation::kMsgCopy)
+        {
+          currentOp->GetCopyDestination(0, getter_Copies(nextDestination));
+          copyMatches = copyDestination.Equals(nextDestination);
+        }
+      }
+    }
+  } 
+  while (currentOp);
+
+  nsAutoCString uids;
+  nsCOMPtr<nsIMsgFolder> destFolder;
+  GetExistingFolder(copyDestination, getter_AddRefs(destFolder));
+  // if the dest folder doesn't really exist, these operations are
+  // going to fail, so clear them out and move on.
+  if (!destFolder)
+  {
+    NS_ERROR("trying to playing back copy to non-existent folder");
+    ClearCurrentOps();
+    ProcessNextOperation();
+    return;
+  }
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(m_currentFolder);
+  if (imapFolder && DestFolderOnSameServer(destFolder))
+  {
+    rv = imapFolder->ReplayOfflineMoveCopy(matchingFlagKeys.Elements(), matchingFlagKeys.Length(), false, destFolder,
+                   this, m_window);
+  }
+  else
+  {
+    nsCOMPtr<nsIMutableArray> messages(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv));
+    if (messages && NS_SUCCEEDED(rv))
+    {
+      for (uint32_t keyIndex = 0; keyIndex < matchingFlagKeys.Length(); keyIndex++)
+      {
+        nsCOMPtr<nsIMsgDBHdr> mailHdr = nullptr;
+        rv = m_currentFolder->GetMessageHeader(matchingFlagKeys.ElementAt(keyIndex), getter_AddRefs(mailHdr));
+        if (NS_SUCCEEDED(rv) && mailHdr)
+          messages->AppendElement(mailHdr, false);
+      }
+      nsCOMPtr<nsIMsgCopyService> copyService = do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
+      if (copyService)
+        copyService->CopyMessages(m_currentFolder, messages, destFolder, false, this, m_window, false);
+    }
+  }
+}
+
+void nsImapOfflineSync::ProcessEmptyTrash()
+{
+  m_currentFolder->EmptyTrash(m_window, this);
+  ClearDB(); // EmptyTrash closes and deletes the trash db.
+}
+
+// returns true if we found a folder to create, false if we're done creating folders.
+bool nsImapOfflineSync::CreateOfflineFolders()
+{
+  while (m_currentFolder)
+  {
+    uint32_t flags;
+    m_currentFolder->GetFlags(&flags);
+    bool offlineCreate = (flags & nsMsgFolderFlags::CreatedOffline) != 0;
+    if (offlineCreate)
+    {
+      if (CreateOfflineFolder(m_currentFolder))
+        return true;
+    }
+    AdvanceToNextFolder();
+  }
+  return false;
+}
+
+bool nsImapOfflineSync::CreateOfflineFolder(nsIMsgFolder *folder)
+{
+  nsCOMPtr<nsIMsgFolder> parent;
+  folder->GetParent(getter_AddRefs(parent));
+
+  nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(parent);
+  nsCOMPtr <nsIURI> createFolderURI;
+  nsCString onlineName;
+  imapFolder->GetOnlineName(onlineName);
+
+  NS_ConvertASCIItoUTF16 folderName(onlineName);
+  nsresult rv = imapFolder->PlaybackOfflineFolderCreate(folderName, nullptr,  getter_AddRefs(createFolderURI));
+  if (createFolderURI && NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(createFolderURI);
+    if (mailnewsUrl)
+      mailnewsUrl->RegisterListener(this);
+  }
+  return NS_SUCCEEDED(rv) ? true : false;	// this is asynch, we have to return and be called again by the OfflineOpExitFunction
+}
+
+int32_t nsImapOfflineSync::GetCurrentUIDValidity()
+{
+  if (m_currentFolder)
+  {
+    nsCOMPtr <nsIImapMailFolderSink> imapFolderSink = do_QueryInterface(m_currentFolder);
+    if (imapFolderSink)
+      imapFolderSink->GetUidValidity(&mCurrentUIDValidity);
+  }
+  return mCurrentUIDValidity; 
+}
+
+/**
+ * Playing back offline operations is one giant state machine that runs through
+ * ProcessNextOperation.
+ * The first state is creating online any folders created offline (we do this
+ * first, so we can play back any operations in them in the next pass)
+ */
+nsresult nsImapOfflineSync::ProcessNextOperation()
+{
+  nsresult rv = NS_OK;
+
+  // if we haven't created offline folders, and we're updating all folders,
+  // first, find offline folders to create.
+  if (!m_createdOfflineFolders)
+  {
+    if (m_singleFolderToUpdate)
+    {
+      if (!m_pseudoOffline)
+      {
+        AdvanceToFirstIMAPFolder();
+        if (CreateOfflineFolders())
+          return NS_OK;
+      }
+    }
+    else
+    {
+      if (CreateOfflineFolders())
+        return NS_OK;
+      m_currentServer = nullptr;
+      AdvanceToNextFolder();
+    }
+    m_createdOfflineFolders = true;
+  }
+  // if updating one folder only, restore m_currentFolder to that folder
+  if (m_singleFolderToUpdate)
+    m_currentFolder = m_singleFolderToUpdate;
+  
+  uint32_t folderFlags;
+  nsCOMPtr <nsIDBFolderInfo> folderInfo;
+  while (m_currentFolder && !m_currentDB)
+  {
+    m_currentFolder->GetFlags(&folderFlags);
+    // need to check if folder has offline events, /* or is configured for offline */
+    // shouldn't need to check if configured for offline use, since any folder with
+    // events should have nsMsgFolderFlags::OfflineEvents set.
+    if (folderFlags & (nsMsgFolderFlags::OfflineEvents /* | nsMsgFolderFlags::Offline */))
+    {
+      m_currentFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(m_currentDB));
+      if (m_currentDB)
+        m_currentDB->AddListener(this);
+    }
+
+    if (m_currentDB)
+    {
+      m_CurrentKeys.Clear();
+      m_KeyIndex = 0;
+      if (NS_FAILED(m_currentDB->ListAllOfflineOpIds(&m_CurrentKeys)) || m_CurrentKeys.IsEmpty())
+      {
+        ClearDB();
+        folderInfo = nullptr; // can't hold onto folderInfo longer than db
+        m_currentFolder->ClearFlag(nsMsgFolderFlags::OfflineEvents);
+      }
+      else
+      {
+        // trash any ghost msgs
+        bool deletedGhostMsgs = false;
+        for (uint32_t fakeIndex=0; fakeIndex < m_CurrentKeys.Length(); fakeIndex++)
+        {
+          nsCOMPtr <nsIMsgOfflineImapOperation> currentOp; 
+          m_currentDB->GetOfflineOpForKey(m_CurrentKeys[fakeIndex], false, getter_AddRefs(currentOp));
+          if (currentOp)
+          {
+            nsOfflineImapOperationType opType; 
+            currentOp->GetOperation(&opType);
+            
+            if (opType == nsIMsgOfflineImapOperation::kMoveResult)
+            {
+              nsMsgKey curKey;
+              currentOp->GetMessageKey(&curKey);
+              m_currentDB->RemoveOfflineOp(currentOp);
+              deletedGhostMsgs = true;
+
+              // Remember the pseudo headers before we delete them,
+              // and when we download new headers, tell listeners about the
+              // message key change between the pseudo headers and the real
+              // downloaded headers. Note that we're not currently sending
+              // a msgsDeleted notifcation for these headers, but the
+              // db listeners are notified about the deletion.
+              // for imap folders, we should adjust the pending counts, because we
+              // have a header that we know about, but don't have in the db.
+              nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(m_currentFolder);
+              if (imapFolder)
+              {
+                bool hdrIsRead;
+                m_currentDB->IsRead(curKey, &hdrIsRead);
+                imapFolder->ChangePendingTotal(1);
+                if (!hdrIsRead)
+                  imapFolder->ChangePendingUnread(1);
+                imapFolder->AddMoveResultPseudoKey(curKey);
+              }
+              m_currentDB->DeleteMessage(curKey, nullptr, false);
+            }
+          }
+        }
+        
+        if (deletedGhostMsgs)
+          m_currentFolder->SummaryChanged();
+        
+        m_CurrentKeys.Clear();
+        if (NS_FAILED(m_currentDB->ListAllOfflineOpIds(&m_CurrentKeys)) || m_CurrentKeys.IsEmpty())
+        {
+          ClearDB();
+        }
+        else if (folderFlags & nsMsgFolderFlags::ImapBox)
+        {
+          // if pseudo offline, falls through to playing ops back.
+          if (!m_pseudoOffline) 
+          {
+            // there are operations to playback so check uid validity
+            SetCurrentUIDValidity(0); // force initial invalid state
+            // do a lite select here and hook ourselves up as a listener.
+            nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(m_currentFolder, &rv);
+            if (imapFolder)
+              rv = imapFolder->LiteSelect(this, m_window);
+            // this is async, we will be called again by OnStopRunningUrl.
+            return rv;
+          }
+        }
+      }
+    }
+    
+    if (!m_currentDB)
+    {
+      // only advance if we are doing all folders
+      if (!m_singleFolderToUpdate)
+        AdvanceToNextFolder();
+      else
+        m_currentFolder = nullptr;	// force update of this folder now.
+    }
+    
+  }
+  
+  if (m_currentFolder)
+    m_currentFolder->GetFlags(&folderFlags);
+  // do the current operation
+  if (m_currentDB)
+  {
+    bool currentFolderFinished = false;
+    if (!folderInfo)
+      m_currentDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
+    // user canceled the lite select! if GetCurrentUIDValidity() == 0
+    if (folderInfo && (m_KeyIndex < m_CurrentKeys.Length()) &&
+        (m_pseudoOffline || (GetCurrentUIDValidity() != 0) ||
+        !(folderFlags & nsMsgFolderFlags::ImapBox)))
+    {
+      int32_t curFolderUidValidity;
+      folderInfo->GetImapUidValidity(&curFolderUidValidity);
+      bool uidvalidityChanged = (!m_pseudoOffline && folderFlags & nsMsgFolderFlags::ImapBox) && (GetCurrentUIDValidity() != curFolderUidValidity);
+      nsCOMPtr <nsIMsgOfflineImapOperation> currentOp;
+      if (uidvalidityChanged)
+        DeleteAllOfflineOpsForCurrentDB();
+      else
+        m_currentDB->GetOfflineOpForKey(m_CurrentKeys[m_KeyIndex], false, getter_AddRefs(currentOp));
+
+      if (currentOp)
+      {
+        nsOfflineImapOperationType opType; 
+        currentOp->GetOperation(&opType);
+        // loop until we find the next db record that matches the current playback operation
+        while (currentOp && !(opType & mCurrentPlaybackOpType))
+        {
+          // remove operations with no type.
+          if (!opType)
+            m_currentDB->RemoveOfflineOp(currentOp);
+          currentOp = nullptr;
+          ++m_KeyIndex;
+          if (m_KeyIndex < m_CurrentKeys.Length())
+            m_currentDB->GetOfflineOpForKey(m_CurrentKeys[m_KeyIndex],
+                                            false, getter_AddRefs(currentOp));
+          if (currentOp)
+            currentOp->GetOperation(&opType);
+        }
+        // if we did not find a db record that matches the current playback operation,
+        // then move to the next playback operation and recurse.  
+        if (!currentOp)
+        {
+          // we are done with the current type
+          if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kFlagsChanged)
+          {
+            mCurrentPlaybackOpType = nsIMsgOfflineImapOperation::kAddKeywords;
+            // recurse to deal with next type of operation
+            m_KeyIndex = 0;
+            ProcessNextOperation();
+          }
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kAddKeywords)
+          {
+            mCurrentPlaybackOpType = nsIMsgOfflineImapOperation::kRemoveKeywords;
+            // recurse to deal with next type of operation
+            m_KeyIndex = 0;
+            ProcessNextOperation();
+          }
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kRemoveKeywords)
+          {
+            mCurrentPlaybackOpType = nsIMsgOfflineImapOperation::kMsgCopy;
+            // recurse to deal with next type of operation
+            m_KeyIndex = 0;
+            ProcessNextOperation();
+          }
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kMsgCopy)
+          {
+            mCurrentPlaybackOpType = nsIMsgOfflineImapOperation::kMsgMoved;
+            // recurse to deal with next type of operation
+            m_KeyIndex = 0;
+            ProcessNextOperation();
+          }
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kMsgMoved)
+          {
+            mCurrentPlaybackOpType = nsIMsgOfflineImapOperation::kAppendDraft;
+            // recurse to deal with next type of operation
+            m_KeyIndex = 0;
+            ProcessNextOperation();
+          }
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kAppendDraft)
+          {
+            mCurrentPlaybackOpType = nsIMsgOfflineImapOperation::kAppendTemplate;
+            // recurse to deal with next type of operation
+            m_KeyIndex = 0;
+            ProcessNextOperation();
+          }
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kAppendTemplate)
+          {
+            mCurrentPlaybackOpType = nsIMsgOfflineImapOperation::kDeleteAllMsgs;
+            m_KeyIndex = 0;
+            ProcessNextOperation();
+          }
+          else
+          {
+            DeleteAllOfflineOpsForCurrentDB();
+            currentFolderFinished = true;
+          }
+          
+        }
+        else
+        {
+          if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kFlagsChanged)
+            ProcessFlagOperation(currentOp);
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kAddKeywords
+            ||mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kRemoveKeywords)
+            ProcessKeywordOperation(currentOp);
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kMsgCopy)
+            ProcessCopyOperation(currentOp);
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kMsgMoved)
+            ProcessMoveOperation(currentOp);
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kAppendDraft)
+            ProcessAppendMsgOperation(currentOp, nsIMsgOfflineImapOperation::kAppendDraft);
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kAppendTemplate)
+            ProcessAppendMsgOperation(currentOp, nsIMsgOfflineImapOperation::kAppendTemplate);
+          else if (mCurrentPlaybackOpType == nsIMsgOfflineImapOperation::kDeleteAllMsgs)
+          {
+            // empty trash is going to delete the db, so we'd better release the
+            // reference to the offline operation first.
+            currentOp = nullptr;
+            ProcessEmptyTrash();
+          }
+          else
+            NS_ERROR("invalid playback op type");
+        }
+      }
+      else
+        currentFolderFinished = true;
+    }
+    else
+      currentFolderFinished = true;
+    
+    if (currentFolderFinished)
+    {
+      ClearDB();
+      if (!m_singleFolderToUpdate)
+      {
+        AdvanceToNextFolder();
+        ProcessNextOperation();
+        return NS_OK;
+      }
+      else
+        m_currentFolder = nullptr;
+    }
+  }
+  
+  if (!m_currentFolder && !m_mailboxupdatesStarted)
+  {
+    m_mailboxupdatesStarted = true;
+    
+    // if we are updating more than one folder then we need the iterator
+    if (!m_singleFolderToUpdate)
+    {
+      m_currentServer = nullptr;
+      AdvanceToNextFolder();
+    }
+    if (m_singleFolderToUpdate)
+    {
+      m_singleFolderToUpdate->ClearFlag(nsMsgFolderFlags::OfflineEvents);
+      m_singleFolderToUpdate->UpdateFolder(m_window);
+      nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(m_singleFolderToUpdate));
+      if (imapFolder)
+      {
+        nsCOMPtr<nsIUrlListener> saveListener = m_listener;
+//        m_listener = nullptr;
+//        imapFolder->UpdateFolderWithListener(m_window, saveListener);
+      }
+    }
+  }
+  // if we get here, then I *think* we're done. Not sure, though.
+#ifdef DEBUG_bienvenu
+  printf("done with offline imap sync\n");
+#endif
+  nsCOMPtr <nsIUrlListener> saveListener = m_listener;
+  m_listener = nullptr;
+
+  if (saveListener)
+    saveListener->OnStopRunningUrl(nullptr /* don't know url */, rv);
+  return rv;
+}
+
+
+void nsImapOfflineSync::DeleteAllOfflineOpsForCurrentDB()
+{
+  m_KeyIndex = 0;
+  nsCOMPtr <nsIMsgOfflineImapOperation> currentOp;
+  m_currentDB->GetOfflineOpForKey(m_CurrentKeys[m_KeyIndex], false, getter_AddRefs(currentOp));
+  while (currentOp)
+  {
+    // NS_ASSERTION(currentOp->GetOperationFlags() == 0);
+    // delete any ops that have already played back
+    m_currentDB->RemoveOfflineOp(currentOp);
+    currentOp = nullptr;
+    
+    if (++m_KeyIndex < m_CurrentKeys.Length())
+      m_currentDB->GetOfflineOpForKey(m_CurrentKeys[m_KeyIndex], false, getter_AddRefs(currentOp));
+  }
+  m_currentDB->Commit(nsMsgDBCommitType::kLargeCommit);
+  // turn off nsMsgFolderFlags::OfflineEvents
+  if (m_currentFolder)
+    m_currentFolder->ClearFlag(nsMsgFolderFlags::OfflineEvents);
+}
+
+nsImapOfflineDownloader::nsImapOfflineDownloader(nsIMsgWindow *aMsgWindow, nsIUrlListener *aListener) : nsImapOfflineSync(aMsgWindow, aListener)
+{
+  // pause auto-sync service
+  nsresult rv;
+  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr = do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
+  if (NS_SUCCEEDED(rv)) 
+    autoSyncMgr->Pause();    
+}
+
+nsImapOfflineDownloader::~nsImapOfflineDownloader()
+{
+}
+
+nsresult nsImapOfflineDownloader::ProcessNextOperation()
+{
+  nsresult rv = NS_OK;
+  if (!m_mailboxupdatesStarted)
+  {
+    m_mailboxupdatesStarted = true;
+    // Update the INBOX first so the updates on the remaining
+    // folders pickup the results of any filter moves.
+    nsCOMPtr<nsIMsgAccountManager> accountManager = 
+             do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIArray> servers;
+    rv = accountManager->GetAllServers(getter_AddRefs(servers));
+    if (NS_FAILED(rv)) return rv;
+  }
+  if (!m_mailboxupdatesFinished)
+  {
+    if (AdvanceToNextServer())
+    {
+      nsCOMPtr <nsIMsgFolder> rootMsgFolder;
+      m_currentServer->GetRootFolder(getter_AddRefs(rootMsgFolder));
+      nsCOMPtr<nsIMsgFolder> inbox;
+      if (rootMsgFolder)
+      {
+          rootMsgFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox,
+                                            getter_AddRefs(inbox));
+          if (inbox)
+          {
+            nsCOMPtr <nsIMsgFolder> offlineImapFolder;
+            nsCOMPtr <nsIMsgImapMailFolder> imapInbox = do_QueryInterface(inbox);
+            if (imapInbox)
+            {
+              rootMsgFolder->GetFolderWithFlags(nsMsgFolderFlags::Offline,
+                                                getter_AddRefs(offlineImapFolder));
+              if (!offlineImapFolder)
+              {
+                // no imap folders configured for offline use - check if the account is set up
+                // so that we always download inbox msg bodies for offline use
+                nsCOMPtr <nsIImapIncomingServer> imapServer = do_QueryInterface(m_currentServer);
+                if (imapServer)
+                {
+                  bool downloadBodiesOnGetNewMail = false;
+                  imapServer->GetDownloadBodiesOnGetNewMail(&downloadBodiesOnGetNewMail);
+                  if (downloadBodiesOnGetNewMail)
+                    offlineImapFolder = inbox;
+                }
+              }
+            }
+            // if this isn't an imap inbox, or we have an offline imap sub-folder, then update the inbox.
+            // otherwise, it's an imap inbox for an account with no folders configured for offline use,
+            // so just advance to the next server.
+            if (!imapInbox || offlineImapFolder)
+            {
+              // here we should check if this a pop3 server/inbox, and the user doesn't want
+              // to download pop3 mail for offline use.
+              if (!imapInbox)
+              {
+              }
+              rv = inbox->GetNewMessages(m_window, this);
+              if (NS_SUCCEEDED(rv))
+                return rv; // otherwise, fall through.
+            }
+          }
+      }
+      return ProcessNextOperation(); // recurse and do next server.
+    }
+    else
+    {
+      m_allServers = nullptr;
+      m_mailboxupdatesFinished = true;
+    }
+  }
+
+  while (AdvanceToNextFolder())
+  {
+    uint32_t folderFlags;
+
+    ClearDB();
+    nsCOMPtr <nsIMsgImapMailFolder> imapFolder;
+    if (m_currentFolder)
+      imapFolder = do_QueryInterface(m_currentFolder);
+    m_currentFolder->GetFlags(&folderFlags);
+    // need to check if folder has offline events, or is configured for offline
+    if (imapFolder && folderFlags & nsMsgFolderFlags::Offline &&
+      ! (folderFlags & nsMsgFolderFlags::Virtual))
+    {
+      rv = m_currentFolder->DownloadAllForOffline(this, m_window);
+      if (NS_SUCCEEDED(rv) || rv == NS_BINDING_ABORTED)
+        return rv;
+      // if this fails and the user didn't cancel/stop, fall through to code that advances to next folder
+    }
+  }
+  if (m_listener)
+    m_listener->OnStopRunningUrl(nullptr, NS_OK);
+  return rv;
+}
+
+
+NS_IMETHODIMP nsImapOfflineSync::OnStartCopy()
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void OnProgress (in uint32_t aProgress, in uint32_t aProgressMax); */
+NS_IMETHODIMP nsImapOfflineSync::OnProgress(uint32_t aProgress, uint32_t aProgressMax)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void SetMessageKey (in uint32_t aKey); */
+NS_IMETHODIMP nsImapOfflineSync::SetMessageKey(uint32_t aKey)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [noscript] void GetMessageId (in nsCString aMessageId); */
+NS_IMETHODIMP nsImapOfflineSync::GetMessageId(nsACString& messageId)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void OnStopCopy (in nsresult aStatus); */
+NS_IMETHODIMP nsImapOfflineSync::OnStopCopy(nsresult aStatus)
+{
+  return OnStopRunningUrl(nullptr, aStatus);
+}
+
+void nsImapOfflineSync::ClearDB()
+{
+  m_currentOpsToClear.Clear();
+  if (m_currentDB)
+    m_currentDB->RemoveListener(this);
+  m_currentDB = nullptr;
+}
+
+NS_IMETHODIMP
+nsImapOfflineSync::OnHdrPropertyChanged(nsIMsgDBHdr *aHdrToChange,
+    bool aPreChange, uint32_t *aStatus, nsIDBChangeListener * aInstigator)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsImapOfflineSync::OnHdrFlagsChanged(nsIMsgDBHdr *aHdrChanged,
+    uint32_t aOldFlags, uint32_t aNewFlags, nsIDBChangeListener *aInstigator)
+{
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapOfflineSync::OnHdrDeleted(nsIMsgDBHdr *aHdrChanged,
+    nsMsgKey aParentKey, int32_t aFlags, nsIDBChangeListener *aInstigator)
+{
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapOfflineSync::OnHdrAdded(nsIMsgDBHdr *aHdrAdded,
+    nsMsgKey aParentKey, int32_t aFlags, nsIDBChangeListener *aInstigator)
+{
+    return NS_OK;
+}
+
+/* void OnParentChanged (in nsMsgKey aKeyChanged, in nsMsgKey oldParent, in nsMsgKey newParent, in nsIDBChangeListener aInstigator); */
+NS_IMETHODIMP
+nsImapOfflineSync::OnParentChanged(nsMsgKey aKeyChanged,
+    nsMsgKey oldParent, nsMsgKey newParent, nsIDBChangeListener *aInstigator)
+{
+    return NS_OK;
+}
+
+/* void OnAnnouncerGoingAway (in nsIDBChangeAnnouncer instigator); */
+NS_IMETHODIMP
+nsImapOfflineSync::OnAnnouncerGoingAway(nsIDBChangeAnnouncer *instigator)
+{
+  ClearDB();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapOfflineSync::OnEvent(nsIMsgDatabase *aDB, const char *aEvent)
+{
+  return NS_OK;
+}
+
+/* void OnReadChanged (in nsIDBChangeListener instigator); */
+NS_IMETHODIMP
+nsImapOfflineSync::OnReadChanged(nsIDBChangeListener *instigator)
+{
+    return NS_OK;
+}
+
+/* void OnJunkScoreChanged (in nsIDBChangeListener instigator); */
+NS_IMETHODIMP
+nsImapOfflineSync::OnJunkScoreChanged(nsIDBChangeListener *instigator)
+{
+    return NS_OK;
+}
+
diff --git a/mailnews/imap/src/nsImapOfflineSync.h b/mailnews/imap/src/nsImapOfflineSync.h
new file mode 100644
index 0000000000..c339e8463d
--- /dev/null
+++ b/mailnews/imap/src/nsImapOfflineSync.h
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsImapOfflineSync_H_
+#define _nsImapOfflineSync_H_
+
+
+#include "mozilla/Attributes.h"
+#include "nsIMsgDatabase.h"
+#include "nsIUrlListener.h"
+#include "nsIMsgOfflineImapOperation.h"
+#include "nsIMsgWindow.h"
+#include "nsIMsgFolder.h"
+#include "nsCOMArray.h"
+#include "nsIDBChangeListener.h"
+
+class nsImapOfflineSync : public nsIUrlListener,
+                          public nsIMsgCopyServiceListener,
+                          public nsIDBChangeListener {
+public: // set to one folder to playback one folder only
+  nsImapOfflineSync(nsIMsgWindow *window, nsIUrlListener *listener,
+                    nsIMsgFolder *singleFolderOnly = nullptr,
+                    bool isPseudoOffline = false);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIURLLISTENER
+  NS_DECL_NSIMSGCOPYSERVICELISTENER
+  NS_DECL_NSIDBCHANGELISTENER
+  virtual nsresult  ProcessNextOperation(); // this kicks off playback
+
+  int32_t   GetCurrentUIDValidity();
+  void      SetCurrentUIDValidity(int32_t uidvalidity) { mCurrentUIDValidity = uidvalidity; }
+
+  void      SetPseudoOffline(bool pseudoOffline) {m_pseudoOffline = pseudoOffline;}
+  bool      ProcessingStaleFolderUpdate() { return m_singleFolderToUpdate != nullptr; }
+
+  bool      CreateOfflineFolder(nsIMsgFolder *folder);
+  void      SetWindow(nsIMsgWindow *window);
+protected:
+  virtual ~nsImapOfflineSync();
+
+  bool      CreateOfflineFolders();
+  bool      DestFolderOnSameServer(nsIMsgFolder *destFolder);
+  bool      AdvanceToNextServer();
+  bool      AdvanceToNextFolder();
+  void      AdvanceToFirstIMAPFolder();
+  void      DeleteAllOfflineOpsForCurrentDB();
+  void      ClearCurrentOps();
+  // Clears m_currentDB, and unregister listener.
+  void      ClearDB();
+  void      ProcessFlagOperation(nsIMsgOfflineImapOperation *currentOp);
+  void      ProcessKeywordOperation(nsIMsgOfflineImapOperation *op);
+  void      ProcessMoveOperation(nsIMsgOfflineImapOperation *currentOp);
+  void      ProcessCopyOperation(nsIMsgOfflineImapOperation *currentOp);
+  void      ProcessEmptyTrash();
+  void      ProcessAppendMsgOperation(nsIMsgOfflineImapOperation *currentOp,
+                                      nsOfflineImapOperationType opType);
+
+  nsCOMPtr <nsIMsgFolder> m_currentFolder;
+  nsCOMPtr <nsIMsgFolder> m_singleFolderToUpdate;
+  nsCOMPtr <nsIMsgWindow> m_window;
+  nsCOMPtr <nsIArray> m_allServers;
+  nsCOMPtr <nsIArray> m_allFolders;
+  nsCOMPtr <nsIMsgIncomingServer> m_currentServer;
+  nsCOMPtr <nsISimpleEnumerator> m_serverEnumerator;
+  nsCOMPtr <nsIFile> m_curTempFile;
+
+  nsTArray<nsMsgKey> m_CurrentKeys;
+  nsCOMArray<nsIMsgOfflineImapOperation> m_currentOpsToClear;
+  uint32_t      m_KeyIndex;
+  nsCOMPtr <nsIMsgDatabase> m_currentDB;
+  nsCOMPtr <nsIUrlListener> m_listener;
+  int32_t	mCurrentUIDValidity;
+  int32_t	mCurrentPlaybackOpType;	// kFlagsChanged -> kMsgCopy -> kMsgMoved
+  bool	m_mailboxupdatesStarted;
+  bool          m_mailboxupdatesFinished;
+  bool	m_pseudoOffline;		// for queueing online events in offline db
+  bool	m_createdOfflineFolders;
+  
+};
+
+class nsImapOfflineDownloader : public nsImapOfflineSync
+{
+public:
+  nsImapOfflineDownloader(nsIMsgWindow *window, nsIUrlListener *listener);
+  virtual ~nsImapOfflineDownloader();
+  virtual nsresult  ProcessNextOperation() override; // this kicks off download
+};
+
+#endif
diff --git a/mailnews/imap/src/nsImapProtocol.cpp b/mailnews/imap/src/nsImapProtocol.cpp
new file mode 100644
index 0000000000..2a3d1e9ff2
--- /dev/null
+++ b/mailnews/imap/src/nsImapProtocol.cpp
@@ -0,0 +1,10046 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// as does this
+#include "msgCore.h"  // for pre-compiled headers
+#include "nsMsgUtils.h"
+
+#include "nsIServiceManager.h"
+#include "nsICharsetConverterManager.h"
+#include "nsIStringBundle.h"
+#include "nsVersionComparator.h"
+
+#include "nsMsgImapCID.h"
+#include "nsThreadUtils.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsImapCore.h"
+#include "nsImapProtocol.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMAPHostSessionList.h"
+#include "nsIMAPBodyShell.h"
+#include "nsImapMailFolder.h"
+#include "nsIMsgAccountManager.h"
+#include "nsImapServerResponseParser.h"
+#include "nspr.h"
+#include "plbase64.h"
+#include "nsIImapService.h"
+#include "nsISocketTransportService.h"
+#include "nsIStreamListenerTee.h"
+#include "nsNetUtil.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIPipe.h"
+#include "nsIMsgFolder.h"
+#include "nsMsgMessageFlags.h"
+#include "nsImapStringBundle.h"
+#include "nsICopyMsgStreamListener.h"
+#include "nsTextFormatter.h"
+#include "nsIMsgHdr.h"
+#include "nsMsgI18N.h"
+#include <algorithm>
+// for the memory cache...
+#include "nsICacheEntry.h"
+#include "nsICacheStorage.h"
+#include "nsICacheEntryOpenCallback.h"
+
+#include "nsIPrompt.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellLoadInfo.h"
+#include "nsILoadInfo.h"
+#include "nsIMessengerWindowService.h"
+#include "nsIWindowMediator.h"
+#include "nsIWindowWatcher.h"
+#include "nsCOMPtr.h"
+#include "nsMimeTypes.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsXPCOMCIDInternal.h"
+#include "nsIXULAppInfo.h"
+#include "nsSyncRunnableHelpers.h"
+
+PRLogModuleInfo *IMAP;
+
+// netlib required files
+#include "nsIStreamListener.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIImapIncomingServer.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsIPrefLocalizedString.h"
+#include "nsImapUtils.h"
+#include "nsIStreamConverterService.h"
+#include "nsIProxyInfo.h"
+#include "nsISSLSocketControl.h"
+#include "nsProxyRelease.h"
+#include "nsDebug.h"
+#include "nsMsgCompressIStream.h"
+#include "nsMsgCompressOStream.h"
+#include "nsAlgorithm.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Attributes.h"
+#include "nsIPrincipal.h"
+#include "nsContentSecurityManager.h"
+
+using namespace mozilla;
+
+#define ONE_SECOND ((uint32_t)1000)    // one second
+
+#define OUTPUT_BUFFER_SIZE (4096*2) // mscott - i should be able to remove this if I can use nsMsgLineBuffer???
+
+#define IMAP_ENV_HEADERS "From To Cc Bcc Subject Date Message-ID "
+#define IMAP_DB_HEADERS "Priority X-Priority References Newsgroups In-Reply-To Content-Type Reply-To"
+#define IMAP_ENV_AND_DB_HEADERS IMAP_ENV_HEADERS IMAP_DB_HEADERS
+static const PRIntervalTime kImapSleepTime = PR_MillisecondsToInterval(60000);
+static int32_t gPromoteNoopToCheckCount = 0;
+static const uint32_t kFlagChangesBeforeCheck = 10;
+static const int32_t kMaxSecondsBeforeCheck = 600;
+
+class AutoProxyReleaseMsgWindow
+{
+  public:
+    AutoProxyReleaseMsgWindow()
+      : mMsgWindow()
+    {}
+    ~AutoProxyReleaseMsgWindow()
+    {
+      NS_ReleaseOnMainThread(dont_AddRef(mMsgWindow));
+    }
+    nsIMsgWindow** StartAssignment()
+    {
+      MOZ_ASSERT(!mMsgWindow);
+      return &mMsgWindow;
+    }
+    operator nsIMsgWindow*()
+    {
+      return mMsgWindow;
+    }
+  private:
+    nsIMsgWindow* mMsgWindow;
+};
+
+nsIMsgWindow**
+getter_AddRefs(AutoProxyReleaseMsgWindow& aSmartPtr)
+{
+  return aSmartPtr.StartAssignment();
+}
+
+NS_IMPL_ISUPPORTS(nsMsgImapHdrXferInfo, nsIImapHeaderXferInfo)
+
+nsMsgImapHdrXferInfo::nsMsgImapHdrXferInfo()
+  : m_hdrInfos(kNumHdrsToXfer)
+{
+  m_nextFreeHdrInfo = 0;
+}
+
+nsMsgImapHdrXferInfo::~nsMsgImapHdrXferInfo()
+{
+}
+
+NS_IMETHODIMP nsMsgImapHdrXferInfo::GetNumHeaders(int32_t *aNumHeaders)
+{
+  *aNumHeaders = m_nextFreeHdrInfo;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgImapHdrXferInfo::GetHeader(int32_t hdrIndex, nsIImapHeaderInfo **aResult)
+{
+  // If the header index is more than (or equal to) our next free pointer, then
+  // its a header we haven't really got and the caller has done something
+  // wrong.
+  NS_ENSURE_TRUE(hdrIndex < m_nextFreeHdrInfo, NS_ERROR_NULL_POINTER);
+
+  *aResult = m_hdrInfos.SafeObjectAt(hdrIndex);
+  if (!*aResult)
+    return NS_ERROR_NULL_POINTER;
+
+  NS_ADDREF(*aResult);
+  return NS_OK;
+}
+
+static const int32_t kInitLineHdrCacheSize = 512; // should be about right
+
+nsIImapHeaderInfo* nsMsgImapHdrXferInfo::StartNewHdr()
+{
+  if (m_nextFreeHdrInfo >= kNumHdrsToXfer)
+    return nullptr;
+
+  nsIImapHeaderInfo *result = m_hdrInfos.SafeObjectAt(m_nextFreeHdrInfo++);
+  if (result)
+    return result;
+
+  nsMsgImapLineDownloadCache *lineCache = new nsMsgImapLineDownloadCache();
+  if (!lineCache)
+    return nullptr;
+
+  lineCache->GrowBuffer(kInitLineHdrCacheSize);
+
+  m_hdrInfos.AppendObject(lineCache);
+
+  return lineCache;
+}
+
+// maybe not needed...
+void nsMsgImapHdrXferInfo::FinishCurrentHdr()
+{
+  // nothing to do?
+}
+
+void nsMsgImapHdrXferInfo::ResetAll()
+{
+  int32_t count = m_hdrInfos.Count();
+  for (int32_t i = 0; i < count; i++)
+  {
+    nsIImapHeaderInfo *hdrInfo = m_hdrInfos[i];
+    if (hdrInfo)
+      hdrInfo->ResetCache();
+  }
+  m_nextFreeHdrInfo = 0;
+}
+
+void nsMsgImapHdrXferInfo::ReleaseAll()
+{
+  m_hdrInfos.Clear();
+  m_nextFreeHdrInfo = 0;
+}
+
+NS_IMPL_ISUPPORTS(nsMsgImapLineDownloadCache, nsIImapHeaderInfo)
+
+// **** helper class for downloading line ****
+nsMsgImapLineDownloadCache::nsMsgImapLineDownloadCache()
+{
+    fLineInfo = (msg_line_info *) PR_CALLOC(sizeof( msg_line_info));
+    fLineInfo->uidOfMessage = nsMsgKey_None;
+    m_msgSize = 0;
+}
+
+nsMsgImapLineDownloadCache::~nsMsgImapLineDownloadCache()
+{
+    PR_Free( fLineInfo);
+}
+
+uint32_t nsMsgImapLineDownloadCache::CurrentUID()
+{
+    return fLineInfo->uidOfMessage;
+}
+
+uint32_t nsMsgImapLineDownloadCache::SpaceAvailable()
+{
+    return kDownLoadCacheSize - m_bufferPos;
+}
+
+msg_line_info *nsMsgImapLineDownloadCache::GetCurrentLineInfo()
+{
+  AppendBuffer("", 1); // null terminate the buffer
+  fLineInfo->adoptedMessageLine = GetBuffer();
+  return fLineInfo;
+}
+
+NS_IMETHODIMP nsMsgImapLineDownloadCache::ResetCache()
+{
+    ResetWritePos();
+    return NS_OK;
+}
+
+bool nsMsgImapLineDownloadCache::CacheEmpty()
+{
+    return m_bufferPos == 0;
+}
+
+NS_IMETHODIMP nsMsgImapLineDownloadCache::CacheLine(const char *line, uint32_t uid)
+{
+    NS_ASSERTION((PL_strlen(line) + 1) <= SpaceAvailable(),
+                 "Oops... line length greater than space available");
+
+    fLineInfo->uidOfMessage = uid;
+
+    AppendString(line);
+    return NS_OK;
+}
+
+/* attribute nsMsgKey msgUid; */
+NS_IMETHODIMP nsMsgImapLineDownloadCache::GetMsgUid(nsMsgKey *aMsgUid)
+{
+    *aMsgUid = fLineInfo->uidOfMessage;
+    return NS_OK;
+}
+NS_IMETHODIMP nsMsgImapLineDownloadCache::SetMsgUid(nsMsgKey aMsgUid)
+{
+    fLineInfo->uidOfMessage = aMsgUid;
+    return NS_OK;
+}
+
+/* attribute long msgSize; */
+NS_IMETHODIMP nsMsgImapLineDownloadCache::GetMsgSize(int32_t *aMsgSize)
+{
+    *aMsgSize = m_msgSize;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsMsgImapLineDownloadCache::SetMsgSize(int32_t aMsgSize)
+{
+    m_msgSize = aMsgSize;
+    return NS_OK;
+}
+
+/* attribute string msgHdrs; */
+NS_IMETHODIMP nsMsgImapLineDownloadCache::GetMsgHdrs(const char **aMsgHdrs)
+{
+  // this doesn't copy the string
+    AppendBuffer("", 1); // null terminate the buffer
+    *aMsgHdrs = GetBuffer();
+    return NS_OK;
+}
+
+/* the following macros actually implement addref, release and query interface for our component. */
+
+NS_IMPL_ADDREF_INHERITED(nsImapProtocol, nsMsgProtocol)
+NS_IMPL_RELEASE_INHERITED(nsImapProtocol, nsMsgProtocol )
+
+NS_INTERFACE_MAP_BEGIN(nsImapProtocol)
+   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIImapProtocol)
+   NS_INTERFACE_MAP_ENTRY(nsIRunnable)
+   NS_INTERFACE_MAP_ENTRY(nsIImapProtocol)
+   NS_INTERFACE_MAP_ENTRY(nsIInputStreamCallback)
+   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+   NS_INTERFACE_MAP_ENTRY(nsIImapProtocolSink)
+   NS_INTERFACE_MAP_ENTRY(nsIMsgAsyncPromptListener)
+NS_INTERFACE_MAP_END_THREADSAFE
+
+static int32_t gTooFastTime = 2;
+static int32_t gIdealTime = 4;
+static int32_t gChunkAddSize = 16384;
+static int32_t gChunkSize = 250000;
+static int32_t gChunkThreshold = gChunkSize + gChunkSize/2;
+static bool gChunkSizeDirty = false;
+static bool gFetchByChunks = true;
+static bool gInitialized = false;
+static bool gHideUnusedNamespaces = true;
+static bool gHideOtherUsersFromList = false;
+static bool gUseEnvelopeCmd = false;
+static bool gUseLiteralPlus = true;
+static bool gExpungeAfterDelete = false;
+static bool gCheckDeletedBeforeExpunge = false; //bug 235004
+static int32_t gResponseTimeout = 60;
+static nsCString gForceSelectDetect;
+static nsTArray<nsCString> gForceSelectServersArray;
+
+// let delete model control expunging, i.e., don't ever expunge when the
+// user chooses the imap delete model, otherwise, expunge when over the
+// threshhold. This is the normal TB behavior.
+static const int32_t kAutoExpungeDeleteModel = 0;
+// Expunge whenever the folder is opened
+static const int32_t kAutoExpungeAlways = 1;
+// Expunge when over the threshhold, independent of the delete model.
+static const int32_t kAutoExpungeOnThreshold = 2;
+static int32_t gExpungeOption = kAutoExpungeDeleteModel;
+static int32_t gExpungeThreshold = 20;
+
+const int32_t kAppBufSize = 100;
+// can't use static nsCString because it shows up as a leak.
+static char gAppName[kAppBufSize];
+static char gAppVersion[kAppBufSize];
+
+nsresult nsImapProtocol::GlobalInitialization(nsIPrefBranch *aPrefBranch)
+{
+    gInitialized = true;
+
+    aPrefBranch->GetIntPref("mail.imap.chunk_fast", &gTooFastTime);   // secs we read too little too fast
+    aPrefBranch->GetIntPref("mail.imap.chunk_ideal", &gIdealTime);    // secs we read enough in good time
+    aPrefBranch->GetIntPref("mail.imap.chunk_add", &gChunkAddSize);   // buffer size to add when wasting time
+    aPrefBranch->GetIntPref("mail.imap.chunk_size", &gChunkSize);
+    aPrefBranch->GetIntPref("mail.imap.min_chunk_size_threshold",
+                            &gChunkThreshold);
+    aPrefBranch->GetBoolPref("mail.imap.hide_other_users",
+                             &gHideOtherUsersFromList);
+    aPrefBranch->GetBoolPref("mail.imap.hide_unused_namespaces",
+                             &gHideUnusedNamespaces);
+    aPrefBranch->GetIntPref("mail.imap.noop_check_count",
+                            &gPromoteNoopToCheckCount);
+    aPrefBranch->GetBoolPref("mail.imap.use_envelope_cmd",
+                             &gUseEnvelopeCmd);
+    aPrefBranch->GetBoolPref("mail.imap.use_literal_plus", &gUseLiteralPlus);
+    aPrefBranch->GetBoolPref("mail.imap.expunge_after_delete",
+                             &gExpungeAfterDelete);
+    aPrefBranch->GetBoolPref("mail.imap.check_deleted_before_expunge",
+                             &gCheckDeletedBeforeExpunge);
+    aPrefBranch->GetIntPref("mail.imap.expunge_option", &gExpungeOption);
+    aPrefBranch->GetIntPref("mail.imap.expunge_threshold_number",
+                            &gExpungeThreshold);
+    aPrefBranch->GetIntPref("mailnews.tcptimeout", &gResponseTimeout);
+    aPrefBranch->GetCharPref("mail.imap.force_select_detect",
+                             getter_Copies(gForceSelectDetect));
+    ParseString(gForceSelectDetect, ';', gForceSelectServersArray);
+
+    nsCOMPtr<nsIXULAppInfo> appInfo(do_GetService(XULAPPINFO_SERVICE_CONTRACTID));
+
+    if (appInfo)
+    {
+      nsCString appName, appVersion;
+      appInfo->GetName(appName);
+      appInfo->GetVersion(appVersion);
+      PL_strncpyz(gAppName, appName.get(), kAppBufSize);
+      PL_strncpyz(gAppVersion, appVersion.get(), kAppBufSize);
+    }
+    return NS_OK;
+}
+
+nsImapProtocol::nsImapProtocol() : nsMsgProtocol(nullptr),
+    m_dataAvailableMonitor("imapDataAvailable"),
+    m_urlReadyToRunMonitor("imapUrlReadyToRun"),
+    m_pseudoInterruptMonitor("imapPseudoInterrupt"),
+    m_dataMemberMonitor("imapDataMember"),
+    m_threadDeathMonitor("imapThreadDeath"),
+    m_waitForBodyIdsMonitor("imapWaitForBodyIds"),
+    m_fetchBodyListMonitor("imapFetchBodyList"),
+    m_passwordReadyMonitor("imapPasswordReady"),
+    mLock("nsImapProtocol.mLock"),
+    m_parser(*this)
+{
+  m_urlInProgress = false;
+  m_idle = false;
+  m_retryUrlOnError = false;
+  m_useIdle = true; // by default, use it
+  m_useCondStore = true;
+  m_useCompressDeflate = true;
+  m_ignoreExpunges = false;
+  m_prefAuthMethods = kCapabilityUndefined;
+  m_failedAuthMethods = 0;
+  m_currentAuthMethod = kCapabilityUndefined;
+  m_socketType = nsMsgSocketType::trySTARTTLS;
+  m_connectionStatus = NS_OK;
+  m_safeToCloseConnection = false;
+  m_hostSessionList = nullptr;
+  m_flagState = nullptr;
+  m_fetchBodyIdList = nullptr;
+  m_isGmailServer = false;
+  m_fetchingWholeMessage = false;
+
+  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+  NS_ASSERTION(prefBranch, "FAILED to create the preference service");
+
+  // read in the accept languages preference
+  if (prefBranch)
+  {
+    if (!gInitialized)
+      GlobalInitialization(prefBranch);
+
+    nsCOMPtr<nsIPrefLocalizedString> prefString;
+    prefBranch->GetComplexValue("intl.accept_languages",
+                                NS_GET_IID(nsIPrefLocalizedString),
+                                getter_AddRefs(prefString));
+    if (prefString)
+      prefString->ToString(getter_Copies(mAcceptLanguages));
+
+    nsCString customDBHeaders;
+    prefBranch->GetCharPref("mailnews.customDBHeaders",
+                            getter_Copies(customDBHeaders));
+
+    ParseString(customDBHeaders, ' ', mCustomDBHeaders);
+    prefBranch->GetBoolPref("mailnews.display.prefer_plaintext", &m_preferPlainText);
+
+    nsAutoCString customHeaders;;
+    prefBranch->GetCharPref("mailnews.customHeaders",
+                            getter_Copies(customHeaders));
+    customHeaders.StripWhitespace();
+    ParseString(customHeaders, ':', mCustomHeaders);
+  }
+
+    // ***** Thread support *****
+  m_thread = nullptr;
+  m_imapThreadIsRunning = false;
+  m_currentServerCommandTagNumber = 0;
+  m_active = false;
+  m_folderNeedsSubscribing = false;
+  m_folderNeedsACLRefreshed = false;
+  m_threadShouldDie = false;
+  m_inThreadShouldDie = false;
+  m_pseudoInterrupted = false;
+  m_nextUrlReadyToRun = false;
+  m_trackingTime = false;
+  m_curFetchSize = 0;
+  m_startTime = 0;
+  m_endTime = 0;
+  m_lastActiveTime = 0;
+  m_lastProgressTime = 0;
+  ResetProgressInfo();
+
+  m_tooFastTime = 0;
+  m_idealTime = 0;
+  m_chunkAddSize = 0;
+  m_chunkStartSize = 0;
+  m_fetchByChunks = true;
+  m_sendID = true;
+  m_chunkSize = 0;
+  m_chunkThreshold = 0;
+  m_fromHeaderSeen = false;
+  m_closeNeededBeforeSelect = false;
+  m_needNoop = false;
+  m_noopCount = 0;
+  m_fetchBodyListIsNew = false;
+  m_flagChangeCount = 0;
+  m_lastCheckTime = PR_Now();
+
+  m_checkForNewMailDownloadsHeaders = true;  // this should be on by default
+  m_hierarchyNameState = kNoOperationInProgress;
+  m_discoveryStatus = eContinue;
+
+  m_overRideUrlConnectionInfo = false;
+  // m_dataOutputBuf is used by Send Data
+  m_dataOutputBuf = (char *) PR_CALLOC(sizeof(char) * OUTPUT_BUFFER_SIZE);
+  m_allocatedSize = OUTPUT_BUFFER_SIZE;
+
+  // used to buffer incoming data by ReadNextLine
+  m_inputStreamBuffer = new nsMsgLineStreamBuffer(OUTPUT_BUFFER_SIZE, true /* allocate new lines */, false /* leave CRLFs on the returned string */);
+  m_currentBiffState = nsIMsgFolder::nsMsgBiffState_Unknown;
+  m_progressStringName.Truncate();
+
+  // since these are embedded in the nsImapProtocol object, but passed
+  // through proxied xpcom methods, just AddRef them here.
+  m_hdrDownloadCache = new nsMsgImapHdrXferInfo();
+  m_downloadLineCache = new nsMsgImapLineDownloadCache();
+
+  // subscription
+  m_autoSubscribe = true;
+  m_autoUnsubscribe = true;
+  m_autoSubscribeOnOpen = true;
+  m_deletableChildren = nullptr;
+
+  mFolderLastModSeq = 0;
+
+  Configure(gTooFastTime, gIdealTime, gChunkAddSize, gChunkSize,
+                    gChunkThreshold, gFetchByChunks);
+  m_forceSelect = false;
+
+  // where should we do this? Perhaps in the factory object?
+  if (!IMAP)
+    IMAP = PR_NewLogModule("IMAP");
+}
+
+nsresult nsImapProtocol::Configure(int32_t TooFastTime, int32_t IdealTime,
+                  int32_t ChunkAddSize, int32_t ChunkSize, int32_t ChunkThreshold,
+                  bool FetchByChunks)
+{
+  m_tooFastTime = TooFastTime;    // secs we read too little too fast
+  m_idealTime = IdealTime;    // secs we read enough in good time
+  m_chunkAddSize = ChunkAddSize;    // buffer size to add when wasting time
+  m_chunkStartSize = m_chunkSize = ChunkSize;
+  m_chunkThreshold = ChunkThreshold;
+  m_fetchByChunks = FetchByChunks;
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsImapProtocol::Initialize(nsIImapHostSessionList * aHostSessionList,
+                           nsIImapIncomingServer *aServer)
+{
+  NS_PRECONDITION(aHostSessionList && aServer,
+     "oops...trying to initialize with a null host session list or server!");
+  if (!aHostSessionList || !aServer)
+    return NS_ERROR_NULL_POINTER;
+
+  nsresult rv = m_downloadLineCache->GrowBuffer(kDownLoadCacheSize);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  m_flagState = new nsImapFlagAndUidState(kImapFlagAndUidStateSize);
+  if (!m_flagState)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  aServer->GetUseIdle(&m_useIdle);
+  aServer->GetForceSelect(m_forceSelectValue);
+  aServer->GetUseCondStore(&m_useCondStore);
+  aServer->GetUseCompressDeflate(&m_useCompressDeflate);
+  NS_ADDREF(m_flagState);
+
+  m_hostSessionList = aHostSessionList; // no ref count...host session list has life time > connection
+  m_parser.SetHostSessionList(aHostSessionList);
+  m_parser.SetFlagState(m_flagState);
+
+  // Initialize the empty mime part string on the main thread.
+  nsCOMPtr<nsIStringBundle> bundle;
+  rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = bundle->GetStringFromName(u"imapEmptyMimePart",
+    getter_Copies(m_emptyMimePartString));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Now initialize the thread for the connection
+  if (m_thread == nullptr)
+  {
+    nsresult rv = NS_NewThread(getter_AddRefs(m_iThread), this);
+    if (NS_FAILED(rv))
+    {
+      NS_ASSERTION(m_iThread, "Unable to create imap thread.\n");
+      return rv;
+    }
+    m_iThread->GetPRThread(&m_thread);
+
+  }
+  return NS_OK;
+}
+
+nsImapProtocol::~nsImapProtocol()
+{
+  PR_Free(m_fetchBodyIdList);
+
+  NS_IF_RELEASE(m_flagState);
+
+  PR_Free(m_dataOutputBuf);
+  delete m_inputStreamBuffer;
+
+  // **** We must be out of the thread main loop function
+  NS_ASSERTION(!m_imapThreadIsRunning, "Oops, thread is still running.\n");
+}
+
+const nsCString&
+nsImapProtocol::GetImapHostName()
+{
+  if (m_runningUrl && m_hostName.IsEmpty())
+  {
+    nsCOMPtr<nsIURI> url = do_QueryInterface(m_runningUrl);
+    url->GetAsciiHost(m_hostName);
+  }
+
+  return m_hostName;
+}
+
+const nsCString&
+nsImapProtocol::GetImapUserName()
+{
+  if (m_userName.IsEmpty() && m_imapServerSink)
+  {
+    m_imapServerSink->GetOriginalUsername(m_userName);
+  }
+  return m_userName;
+}
+
+const char*
+nsImapProtocol::GetImapServerKey()
+{
+  if (m_serverKey.IsEmpty() && m_imapServerSink)
+  {
+    m_imapServerSink->GetServerKey(m_serverKey);
+  }
+  return m_serverKey.get();
+}
+
+nsresult
+nsImapProtocol::SetupSinkProxy()
+{
+  nsresult res;
+  if (m_runningUrl)
+  {
+    if (!m_imapMailFolderSink)
+    {
+      nsCOMPtr<nsIImapMailFolderSink> aImapMailFolderSink;
+      (void) m_runningUrl->GetImapMailFolderSink(getter_AddRefs(aImapMailFolderSink));
+      if (aImapMailFolderSink)
+      {
+        m_imapMailFolderSink = new ImapMailFolderSinkProxy(aImapMailFolderSink);
+      }
+    }
+
+    if (!m_imapMessageSink)
+    {
+      nsCOMPtr<nsIImapMessageSink> aImapMessageSink;
+      (void) m_runningUrl->GetImapMessageSink(getter_AddRefs(aImapMessageSink));
+      if (aImapMessageSink) {
+        m_imapMessageSink = new ImapMessageSinkProxy(aImapMessageSink);
+      } else {
+        return NS_ERROR_ILLEGAL_VALUE;
+      }
+    }
+    if (!m_imapServerSink)
+    {
+      nsCOMPtr<nsIImapServerSink> aImapServerSink;
+      res = m_runningUrl->GetImapServerSink(getter_AddRefs(aImapServerSink));
+      if (aImapServerSink) {
+        m_imapServerSink = new ImapServerSinkProxy(aImapServerSink);
+      } else {
+        return NS_ERROR_ILLEGAL_VALUE;
+      }
+    }
+    if (!m_imapProtocolSink)
+    {
+      nsCOMPtr<nsIImapProtocolSink> anImapProxyHelper(do_QueryInterface(NS_ISUPPORTS_CAST(nsIImapProtocolSink*, this), &res));
+      m_imapProtocolSink = new ImapProtocolSinkProxy(anImapProxyHelper);
+    }
+  }
+  return NS_OK;
+}
+
+static void SetSecurityCallbacksFromChannel(nsISocketTransport* aTrans, nsIChannel* aChannel)
+{
+  nsCOMPtr<nsIInterfaceRequestor> callbacks;
+  aChannel->GetNotificationCallbacks(getter_AddRefs(callbacks));
+
+  nsCOMPtr<nsILoadGroup> loadGroup;
+  aChannel->GetLoadGroup(getter_AddRefs(loadGroup));
+
+  nsCOMPtr<nsIInterfaceRequestor> securityCallbacks;
+  MsgNewNotificationCallbacksAggregation(callbacks, loadGroup,
+                                         getter_AddRefs(securityCallbacks));
+  if (securityCallbacks)
+    aTrans->SetSecurityCallbacks(securityCallbacks);
+}
+
+// Setup With Url is intended to set up data which is held on a PER URL basis and not
+// a per connection basis. If you have data which is independent of the url we are currently
+// running, then you should put it in Initialize().
+// This is only ever called from the UI thread. It is called from LoadUrl, right
+// before the url gets run - i.e., the url is next in line to run.
+nsresult nsImapProtocol::SetupWithUrl(nsIURI * aURL, nsISupports* aConsumer)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+  NS_PRECONDITION(aURL, "null URL passed into Imap Protocol");
+  if (aURL)
+  {
+    m_runningUrl = do_QueryInterface(aURL, &rv);
+    if (NS_FAILED(rv)) return rv;
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl);
+    nsCOMPtr<nsIMsgIncomingServer> server = do_QueryReferent(m_server);
+    if (!server)
+    {
+      rv = mailnewsUrl->GetServer(getter_AddRefs(server));
+      NS_ENSURE_SUCCESS(rv, rv);
+      m_server = do_GetWeakReference(server);
+    }
+    nsCOMPtr <nsIMsgFolder> folder;
+    mailnewsUrl->GetFolder(getter_AddRefs(folder));
+    mFolderLastModSeq = 0;
+    mFolderTotalMsgCount = 0;
+    mFolderHighestUID = 0;
+    m_uidValidity = kUidUnknown;
+    if (folder)
+    {
+      nsCOMPtr<nsIMsgDatabase> folderDB;
+      nsCOMPtr<nsIDBFolderInfo> folderInfo;
+      folder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(folderDB));
+      if (folderInfo)
+      {
+        nsCString modSeqStr;
+        folderInfo->GetCharProperty(kModSeqPropertyName, modSeqStr);
+        mFolderLastModSeq = ParseUint64Str(modSeqStr.get());
+        folderInfo->GetNumMessages(&mFolderTotalMsgCount);
+        folderInfo->GetUint32Property(kHighestRecordedUIDPropertyName, 0, &mFolderHighestUID);
+        folderInfo->GetImapUidValidity(&m_uidValidity);
+      }
+    }
+    nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryInterface(server);
+    nsCOMPtr<nsIStreamListener> aRealStreamListener = do_QueryInterface(aConsumer);
+    m_runningUrl->GetMockChannel(getter_AddRefs(m_mockChannel));
+    imapServer->GetIsGMailServer(&m_isGmailServer);
+    if (!m_mockChannel)
+    {
+
+      nsCOMPtr<nsIPrincipal> nullPrincipal =
+        do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // there are several imap operations that aren't initiated via a nsIChannel::AsyncOpen call on the mock channel.
+      // such as selecting a folder. nsImapProtocol now insists on a mock channel when processing a url.
+      nsCOMPtr<nsIChannel> channel;
+      rv = NS_NewChannel(getter_AddRefs(channel),
+                         aURL,
+                         nullPrincipal,
+                         nsILoadInfo::SEC_NORMAL,
+                         nsIContentPolicy::TYPE_OTHER);
+      m_mockChannel = do_QueryInterface(channel);
+
+      // Certain imap operations (not initiated by the IO Service via AsyncOpen) can be interrupted by  the stop button on the toolbar.
+      // We do this by using the loadgroup of the docshell for the message pane. We really shouldn't be doing this..
+      // See the comment in nsMsgMailNewsUrl::GetLoadGroup.
+      nsCOMPtr<nsILoadGroup> loadGroup;
+      mailnewsUrl->GetLoadGroup(getter_AddRefs(loadGroup)); // get the message pane load group
+      nsCOMPtr<nsIRequest> ourRequest = do_QueryInterface(m_mockChannel);
+      if (loadGroup)
+        loadGroup->AddRequest(ourRequest, nullptr /* context isupports */);
+    }
+
+    if (m_mockChannel)
+    {
+      m_mockChannel->SetImapProtocol(this);
+      // if we have a listener from a mock channel, over-ride the consumer that was passed in
+      nsCOMPtr<nsIStreamListener> channelListener;
+      m_mockChannel->GetChannelListener(getter_AddRefs(channelListener));
+      if (channelListener) // only over-ride if we have a non null channel listener
+        aRealStreamListener = channelListener;
+      m_mockChannel->GetChannelContext(getter_AddRefs(m_channelContext));
+      nsCOMPtr<nsIMsgWindow> msgWindow;
+      GetMsgWindow(getter_AddRefs(msgWindow));
+      if (!msgWindow)
+        GetTopmostMsgWindow(getter_AddRefs(msgWindow));
+      if (msgWindow)
+      {
+        nsCOMPtr<nsIDocShell> docShell;
+        msgWindow->GetMessageWindowDocShell(getter_AddRefs(docShell));
+        nsCOMPtr<nsIInterfaceRequestor> ir(do_QueryInterface(docShell));
+        nsCOMPtr<nsIInterfaceRequestor> interfaceRequestor;
+        msgWindow->GetNotificationCallbacks(getter_AddRefs(interfaceRequestor));
+        nsCOMPtr<nsIInterfaceRequestor> aggregateIR;
+        MsgNewInterfaceRequestorAggregation(interfaceRequestor, ir, getter_AddRefs(aggregateIR));
+        m_mockChannel->SetNotificationCallbacks(aggregateIR);
+      }
+    }
+
+    // since we'll be making calls directly from the imap thread to the channel listener,
+    // we need to turn it into a proxy object....we'll assume that the listener is on the same thread
+    // as the event sink queue
+    if (aRealStreamListener)
+    {
+      NS_ASSERTION(!m_channelListener, "shouldn't already have a channel listener");
+      m_channelListener = new StreamListenerProxy(aRealStreamListener);
+    }
+
+    server->GetRealHostName(m_realHostName);
+    int32_t authMethod;
+    (void) server->GetAuthMethod(&authMethod);
+    InitPrefAuthMethods(authMethod, server);
+    (void) server->GetSocketType(&m_socketType);
+    bool shuttingDown;
+    (void) imapServer->GetShuttingDown(&shuttingDown);
+    if (!shuttingDown)
+      (void) imapServer->GetUseIdle(&m_useIdle);
+    else
+      m_useIdle = false;
+    imapServer->GetFetchByChunks(&m_fetchByChunks);
+    imapServer->GetSendID(&m_sendID);
+
+    nsAutoString trashFolderName;
+    if (NS_SUCCEEDED(imapServer->GetTrashFolderName(trashFolderName)))
+      CopyUTF16toMUTF7(trashFolderName, m_trashFolderName);
+
+    nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+    if (prefBranch)
+    {
+      bool preferPlainText;
+      prefBranch->GetBoolPref("mailnews.display.prefer_plaintext", &preferPlainText);
+      // If the pref has changed since the last time we ran a url,
+      // clear the shell cache for this host.
+      if (preferPlainText != m_preferPlainText)
+      {
+        m_hostSessionList->ClearShellCacheForHost(GetImapServerKey());
+        m_preferPlainText = preferPlainText;
+      }
+    }
+
+    if ( m_runningUrl && !m_transport /* and we don't have a transport yet */)
+    {
+      // extract the file name and create a file transport...
+      int32_t port=-1;
+      server->GetPort(&port);
+
+      if (port <= 0)
+      {
+        int32_t socketType;
+        // Be a bit smarter about setting the default port
+        port = (NS_SUCCEEDED(server->GetSocketType(&socketType)) &&
+                socketType == nsMsgSocketType::SSL) ?
+               nsIImapUrl::DEFAULT_IMAPS_PORT : nsIImapUrl::DEFAULT_IMAP_PORT;
+      }
+      nsCOMPtr<nsISocketTransportService> socketService =
+               do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+      if (NS_SUCCEEDED(rv) && aURL)
+      {
+        aURL->GetPort(&port);
+
+        Log("SetupWithUrl", nullptr, "clearing IMAP_CONNECTION_IS_OPEN");
+        ClearFlag(IMAP_CONNECTION_IS_OPEN);
+        const char *connectionType = nullptr;
+
+        if (m_socketType == nsMsgSocketType::SSL)
+          connectionType = "ssl";
+        else if (m_socketType == nsMsgSocketType::alwaysSTARTTLS)
+          connectionType = "starttls";
+        // This can go away once we think everyone is migrated
+        // away from the trySTARTTLS socket type.
+        else if (m_socketType == nsMsgSocketType::trySTARTTLS)
+          connectionType =  "starttls";
+
+        nsCOMPtr<nsIProxyInfo> proxyInfo;
+        if (m_mockChannel)
+          rv = MsgExamineForProxy(m_mockChannel, getter_AddRefs(proxyInfo));
+        if (NS_FAILED(rv))
+          proxyInfo = nullptr;
+
+        const nsACString *socketHost;
+        uint16_t socketPort;
+
+        if (m_overRideUrlConnectionInfo)
+        {
+          socketHost = &m_logonHost;
+          socketPort = m_logonPort;
+        }
+        else
+        {
+          socketHost = &m_realHostName;
+          socketPort = port;
+        }
+        rv = socketService->CreateTransport(&connectionType, connectionType != nullptr,
+                                            *socketHost, socketPort, proxyInfo,
+                                            getter_AddRefs(m_transport));
+        if (NS_FAILED(rv) && m_socketType == nsMsgSocketType::trySTARTTLS)
+        {
+          connectionType = nullptr;
+          m_socketType = nsMsgSocketType::plain;
+          rv = socketService->CreateTransport(&connectionType, connectionType != nullptr,
+                                              *socketHost, socketPort, proxyInfo,
+                                              getter_AddRefs(m_transport));
+        }
+        // remember so we can know whether we can issue a start tls or not...
+        m_connectionType = connectionType;
+        if (m_transport && m_mockChannel)
+        {
+          uint8_t qos;
+          rv = GetQoSBits(&qos);
+          if (NS_SUCCEEDED(rv))
+            m_transport->SetQoSBits(qos);
+
+          // Ensure that the socket can get the notification callbacks
+          SetSecurityCallbacksFromChannel(m_transport, m_mockChannel);
+
+          // open buffered, blocking input stream
+          rv = m_transport->OpenInputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(m_inputStream));
+          if (NS_FAILED(rv)) return rv;
+
+          // open buffered, blocking output stream
+          rv = m_transport->OpenOutputStream(nsITransport::OPEN_BLOCKING, 0, 0, getter_AddRefs(m_outputStream));
+          if (NS_FAILED(rv)) return rv;
+          SetFlag(IMAP_CONNECTION_IS_OPEN);
+        }
+      }
+    } // if m_runningUrl
+
+    if (m_transport && m_mockChannel)
+    {
+      m_transport->SetTimeout(nsISocketTransport::TIMEOUT_CONNECT, gResponseTimeout + 60);
+      int32_t readWriteTimeout = gResponseTimeout;
+      if (m_runningUrl)
+      {
+        m_runningUrl->GetImapAction(&m_imapAction);
+        // this is a silly hack, but the default of 100 seconds is way too long
+        // for things like APPEND, which should come back immediately.
+        if (m_imapAction == nsIImapUrl::nsImapAppendMsgFromFile ||
+            m_imapAction == nsIImapUrl::nsImapAppendDraftFromFile)
+        {
+          readWriteTimeout = 20;
+        }
+        else if (m_imapAction == nsIImapUrl::nsImapOnlineMove ||
+                 m_imapAction == nsIImapUrl::nsImapOnlineCopy)
+        {
+          nsCString messageIdString;
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+          uint32_t copyCount = CountMessagesInIdString(messageIdString.get());
+          // If we're move/copying a large number of messages,
+          // which should be rare, increase the timeout based on number
+          // of messages. 40 messages per second should be sufficiently slow.
+          if (copyCount > 2400) // 40 * 60, 60 is default read write timeout
+            readWriteTimeout = std::max(readWriteTimeout, (int32_t)copyCount/40);
+        }
+      }
+      m_transport->SetTimeout(nsISocketTransport::TIMEOUT_READ_WRITE, readWriteTimeout);
+      // set the security info for the mock channel to be the security status for our underlying transport.
+      nsCOMPtr<nsISupports> securityInfo;
+      m_transport->GetSecurityInfo(getter_AddRefs(securityInfo));
+      m_mockChannel->SetSecurityInfo(securityInfo);
+
+      SetSecurityCallbacksFromChannel(m_transport, m_mockChannel);
+
+      nsCOMPtr<nsITransportEventSink> sink = do_QueryInterface(m_mockChannel);
+      if (sink) {
+        nsCOMPtr<nsIThread> thread = do_GetMainThread();
+        m_transport->SetEventSink(sink, thread);
+      }
+
+      // and if we have a cache entry that we are saving the message to, set the security info on it too.
+      // since imap only uses the memory cache, passing this on is the right thing to do.
+      nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl);
+      if (mailnewsUrl)
+      {
+        nsCOMPtr<nsICacheEntry> cacheEntry;
+        mailnewsUrl->GetMemCacheEntry(getter_AddRefs(cacheEntry));
+        if (cacheEntry)
+          cacheEntry->SetSecurityInfo(securityInfo);
+      }
+    }
+  } // if aUR
+
+  return rv;
+}
+
+
+// when the connection is done processing the current state, free any per url state data...
+void nsImapProtocol::ReleaseUrlState(bool rerunning)
+{
+  // clear out the socket's reference to the notification callbacks for this transaction
+  {
+    MutexAutoLock mon(mLock);
+    if (m_transport)
+    {
+      m_transport->SetSecurityCallbacks(nullptr);
+      m_transport->SetEventSink(nullptr, nullptr);
+    }
+  }
+
+  if (m_mockChannel && !rerunning)
+  {
+    // Proxy the close of the channel to the ui thread.
+    if (m_imapMailFolderSink)
+      m_imapMailFolderSink->CloseMockChannel(m_mockChannel);
+    else
+      m_mockChannel->Close();
+
+    {
+      // grab a lock so m_mockChannel doesn't get cleared out
+      // from under us.
+      MutexAutoLock mon(mLock);
+      if (m_mockChannel)
+      {
+        // Proxy the release of the channel to the main thread.  This is something
+        // that the xpcom proxy system should do for us!
+        NS_ReleaseOnMainThread(m_mockChannel.forget());
+      }
+    }
+  }
+
+  m_channelContext = nullptr; // this might be the url - null it out before the final release of the url
+  m_imapMessageSink = nullptr;
+
+  // Proxy the release of the listener to the main thread.  This is something
+  // that the xpcom proxy system should do for us!
+  {
+    // grab a lock so the m_channelListener doesn't get cleared.
+    MutexAutoLock mon(mLock);
+    if (m_channelListener)
+    {
+      NS_ReleaseOnMainThread(m_channelListener.forget());
+    }
+  }
+  m_channelInputStream = nullptr;
+  m_channelOutputStream = nullptr;
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl;
+  nsCOMPtr<nsIImapMailFolderSink> saveFolderSink;
+
+  {
+    MutexAutoLock mon(mLock);
+    if (m_runningUrl)
+    {
+      mailnewsurl = do_QueryInterface(m_runningUrl);
+      // It is unclear what 'saveFolderSink' is used for, most likely to hold
+      // a reference for a little longer. See bug 1324893 and bug 391259.
+      saveFolderSink = m_imapMailFolderSink;
+
+      m_runningUrl = nullptr; // force us to release our last reference on the url
+      m_urlInProgress = false;
+    }
+  }
+  // Need to null this out whether we have an m_runningUrl or not
+  m_imapMailFolderSink = nullptr;
+
+  // we want to make sure the imap protocol's last reference to the url gets released
+  // back on the UI thread. This ensures that the objects the imap url hangs on to
+  // properly get released back on the UI thread.
+  if (mailnewsurl)
+  {
+    NS_ReleaseOnMainThread(mailnewsurl.forget());
+  }
+  saveFolderSink = nullptr;
+}
+
+
+class nsImapThreadShutdownEvent : public mozilla::Runnable {
+public:
+  nsImapThreadShutdownEvent(nsIThread *thread) : mThread(thread) {
+  }
+  NS_IMETHOD Run() {
+    mThread->Shutdown();
+    return NS_OK;
+  }
+private:
+  nsCOMPtr<nsIThread> mThread;
+};
+
+
+NS_IMETHODIMP nsImapProtocol::Run()
+{
+  PR_CEnterMonitor(this);
+  NS_ASSERTION(!m_imapThreadIsRunning,
+                 "Oh. oh. thread is already running. What's wrong here?");
+    if (m_imapThreadIsRunning)
+    {
+        PR_CExitMonitor(this);
+        return NS_OK;
+    }
+
+  m_imapThreadIsRunning = true;
+  PR_CExitMonitor(this);
+
+  // call the platform specific main loop ....
+  ImapThreadMainLoop();
+
+  if (m_runningUrl)
+  {
+    NS_ReleaseOnMainThread(m_runningUrl.forget());
+  }
+
+  // close streams via UI thread if it's not already done
+  if (m_imapProtocolSink)
+    m_imapProtocolSink->CloseStreams();
+
+  m_imapMailFolderSink = nullptr;
+  m_imapMessageSink = nullptr;
+
+  // shutdown this thread, but do it from the main thread
+  nsCOMPtr<nsIRunnable> ev = new nsImapThreadShutdownEvent(m_iThread);
+  if (NS_FAILED(NS_DispatchToMainThread(ev)))
+    NS_WARNING("Failed to dispatch nsImapThreadShutdownEvent");
+  m_iThread = nullptr;
+
+  // Release protocol object on the main thread to avoid destruction of 'this'
+  // on the IMAP thread, which causes grief for weak references.
+  nsCOMPtr<nsIImapProtocol> releaseOnMain(this);
+  NS_ReleaseOnMainThread(releaseOnMain.forget());
+  return NS_OK;
+}
+
+//
+// Must be called from UI thread only
+//
+NS_IMETHODIMP nsImapProtocol::CloseStreams()
+{
+  // make sure that it is called by the UI thread
+  MOZ_ASSERT(NS_IsMainThread(), "CloseStreams() should not be called from an off UI thread");
+
+  {
+    MutexAutoLock mon(mLock);
+    if (m_transport)
+    {
+        // make sure the transport closes (even if someone is still indirectly
+        // referencing it).
+        m_transport->Close(NS_ERROR_ABORT);
+        m_transport = nullptr;
+    }
+    m_inputStream = nullptr;
+    m_outputStream = nullptr;
+    m_channelListener = nullptr;
+    m_channelContext = nullptr;
+    if (m_mockChannel)
+    {
+        m_mockChannel->Close();
+        m_mockChannel = nullptr;
+    }
+    m_channelInputStream = nullptr;
+    m_channelOutputStream = nullptr;
+
+    // Close scope because we must let go of the monitor before calling
+    // RemoveConnection to unblock anyone who tries to get a monitor to the
+    // protocol object while holding onto a monitor to the server.
+  }
+  nsCOMPtr<nsIMsgIncomingServer> me_server = do_QueryReferent(m_server);
+  if (me_server)
+  {
+      nsresult result;
+      nsCOMPtr<nsIImapIncomingServer>
+          aImapServer(do_QueryInterface(me_server, &result));
+      if (NS_SUCCEEDED(result))
+          aImapServer->RemoveConnection(this);
+      me_server = nullptr;
+  }
+  m_server = nullptr;
+  // take this opportunity of being on the UI thread to
+  // persist chunk prefs if they've changed
+  if (gChunkSizeDirty)
+  {
+    nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
+    if (prefBranch)
+    {
+      prefBranch->SetIntPref("mail.imap.chunk_size", gChunkSize);
+      prefBranch->SetIntPref("mail.imap.min_chunk_size_threshold", gChunkThreshold);
+      gChunkSizeDirty = false;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapProtocol::GetUrlWindow(nsIMsgMailNewsUrl *aUrl,
+                                           nsIMsgWindow **aMsgWindow)
+{
+  NS_ENSURE_ARG_POINTER(aUrl);
+  NS_ENSURE_ARG_POINTER(aMsgWindow);
+  return aUrl->GetMsgWindow(aMsgWindow);
+}
+
+NS_IMETHODIMP nsImapProtocol::SetupMainThreadProxies()
+{
+  return SetupSinkProxy();
+}
+
+NS_IMETHODIMP nsImapProtocol::OnInputStreamReady(nsIAsyncInputStream *inStr)
+{
+  // should we check if it's a close vs. data available?
+  if (m_idle)
+  {
+    uint64_t bytesAvailable = 0;
+    (void) inStr->Available(&bytesAvailable);
+    // check if data available - might be a close
+    if (bytesAvailable != 0)
+    {
+      ReentrantMonitorAutoEnter mon(m_urlReadyToRunMonitor);
+      m_lastActiveTime = PR_Now();
+      m_nextUrlReadyToRun = true;
+      mon.Notify();
+    }
+  }
+  return NS_OK;
+}
+
+// this is to be called from the UI thread. It sets m_threadShouldDie,
+// and then signals the imap thread, which, when it wakes up, should exit.
+// The imap thread cleanup code will check m_safeToCloseConnection.
+NS_IMETHODIMP
+nsImapProtocol::TellThreadToDie(bool aIsSafeToClose)
+{
+  NS_WARNING_ASSERTION(NS_IsMainThread(),
+                       "TellThreadToDie(aIsSafeToClose) should only be called from UI thread");
+  MutexAutoLock mon(mLock);
+
+  nsCOMPtr<nsIMsgIncomingServer> me_server = do_QueryReferent(m_server);
+  if (me_server)
+  {
+    nsresult rv;
+    nsCOMPtr<nsIImapIncomingServer>
+      aImapServer(do_QueryInterface(me_server, &rv));
+    if (NS_SUCCEEDED(rv))
+      aImapServer->RemoveConnection(this);
+    m_server = nullptr;
+    me_server = nullptr;
+  }
+  {
+    ReentrantMonitorAutoEnter deathMon(m_threadDeathMonitor);
+    m_safeToCloseConnection = aIsSafeToClose;
+    m_threadShouldDie = true;
+  }
+  ReentrantMonitorAutoEnter readyMon(m_urlReadyToRunMonitor);
+  m_nextUrlReadyToRun = true;
+  readyMon.Notify();
+  return NS_OK;
+}
+
+void
+nsImapProtocol::TellThreadToDie()
+{
+  nsresult rv = NS_OK;
+  NS_WARNING_ASSERTION(!NS_IsMainThread(),
+                       "TellThreadToDie() should not be called from UI thread");
+
+  // prevent re-entering this method because it may lock the UI.
+  if (m_inThreadShouldDie)
+    return;
+  m_inThreadShouldDie = true;
+
+  // This routine is called only from the imap protocol thread.
+  // The UI thread causes this to be called by calling TellThreadToDie.
+  // In that case, m_safeToCloseConnection will be FALSE if it's dropping a
+  // timed out connection, true when closing a cached connection.
+  // We're using PR_CEnter/ExitMonitor because Monitors don't like having
+  // us to hold one monitor and call code that gets a different monitor. And
+  // some of the methods we call here use Monitors.
+  PR_CEnterMonitor(this);
+
+  m_urlInProgress = true;  // let's say it's busy so no one tries to use
+                                // this about to die connection.
+  bool urlWritingData = false;
+  bool connectionIdle = !m_runningUrl;
+
+  if (!connectionIdle)
+    urlWritingData = m_imapAction == nsIImapUrl::nsImapAppendMsgFromFile
+      || m_imapAction == nsIImapUrl::nsImapAppendDraftFromFile;
+
+  bool closeNeeded = GetServerStateParser().GetIMAPstate() ==
+                nsImapServerResponseParser::kFolderSelected && m_safeToCloseConnection;
+  nsCString command;
+  // if a url is writing data, we can't even logout, so we're just
+  // going to close the connection as if the user pressed stop.
+  if (m_currentServerCommandTagNumber > 0 && !urlWritingData)
+  {
+    bool isAlive = false;
+    if (m_transport)
+      rv = m_transport->IsAlive(&isAlive);
+
+    if (TestFlag(IMAP_CONNECTION_IS_OPEN) && m_idle && isAlive)
+      EndIdle(false);
+
+    if (NS_SUCCEEDED(rv) && isAlive && closeNeeded && GetDeleteIsMoveToTrash() &&
+        TestFlag(IMAP_CONNECTION_IS_OPEN) && m_outputStream)
+      Close(true, connectionIdle);
+
+    if (NS_SUCCEEDED(rv) && isAlive && TestFlag(IMAP_CONNECTION_IS_OPEN) &&
+        NS_SUCCEEDED(GetConnectionStatus()) && m_outputStream)
+      Logout(true, connectionIdle);
+  }
+  PR_CExitMonitor(this);
+  // close streams via UI thread
+  if (m_imapProtocolSink)
+  {
+    m_imapProtocolSink->CloseStreams();
+    m_imapProtocolSink = nullptr;
+  }
+  Log("TellThreadToDie", nullptr, "close socket connection");
+
+  {
+    ReentrantMonitorAutoEnter mon(m_threadDeathMonitor);
+    m_threadShouldDie = true;
+  }
+  {
+    ReentrantMonitorAutoEnter dataMon(m_dataAvailableMonitor);
+    dataMon.Notify();
+  }
+  ReentrantMonitorAutoEnter urlReadyMon(m_urlReadyToRunMonitor);
+  urlReadyMon.NotifyAll();
+}
+
+NS_IMETHODIMP
+nsImapProtocol::GetLastActiveTimeStamp(PRTime* aTimeStamp)
+{
+  if (aTimeStamp)
+    *aTimeStamp = m_lastActiveTime;
+  return NS_OK;
+}
+
+static void DoomCacheEntry(nsIMsgMailNewsUrl *url);
+NS_IMETHODIMP
+nsImapProtocol::PseudoInterruptMsgLoad(nsIMsgFolder *aImapFolder, nsIMsgWindow *aMsgWindow, bool *interrupted)
+{
+  NS_ENSURE_ARG (interrupted);
+
+  *interrupted = false;
+
+  PR_CEnterMonitor(this);
+
+  if (m_runningUrl && !TestFlag(IMAP_CLEAN_UP_URL_STATE))
+  {
+    nsImapAction imapAction;
+    m_runningUrl->GetImapAction(&imapAction);
+
+    if (imapAction == nsIImapUrl::nsImapMsgFetch)
+    {
+      nsresult rv = NS_OK;
+      nsCOMPtr<nsIImapUrl> runningImapURL;
+
+      rv = GetRunningImapURL(getter_AddRefs(runningImapURL));
+      if (NS_SUCCEEDED(rv) && runningImapURL)
+      {
+        nsCOMPtr <nsIMsgFolder> runningImapFolder;
+        nsCOMPtr <nsIMsgWindow> msgWindow;
+        nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(runningImapURL);
+        mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+        mailnewsUrl->GetFolder(getter_AddRefs(runningImapFolder));
+        if (aImapFolder == runningImapFolder && msgWindow == aMsgWindow)
+        {
+          PseudoInterrupt(true);
+          *interrupted = true;
+        }
+        // If we're interrupted, doom any incomplete cache entry.
+        DoomCacheEntry(mailnewsUrl);
+      }
+    }
+  }
+  PR_CExitMonitor(this);
+#ifdef DEBUG_bienvenu
+  printf("interrupt msg load : %s\n", (*interrupted) ? "TRUE" : "FALSE");
+#endif
+  return NS_OK;
+}
+
+void
+nsImapProtocol::ImapThreadMainLoop()
+{
+  MOZ_LOG(IMAP, LogLevel::Debug, ("ImapThreadMainLoop entering [this=%x]\n", this));
+
+  PRIntervalTime sleepTime = kImapSleepTime;
+  while (!DeathSignalReceived())
+  {
+    nsresult rv = NS_OK;
+    bool readyToRun;
+
+    // wait for an URL to process...
+    {
+      ReentrantMonitorAutoEnter mon(m_urlReadyToRunMonitor);
+
+      while (NS_SUCCEEDED(rv) && !DeathSignalReceived() &&
+             !m_nextUrlReadyToRun && !m_threadShouldDie)
+        rv = mon.Wait(sleepTime);
+
+      readyToRun = m_nextUrlReadyToRun;
+      m_nextUrlReadyToRun = false;
+    }
+    // This will happen if the UI thread signals us to die
+    if (m_threadShouldDie)
+    {
+      TellThreadToDie();
+      break;
+    }
+
+    if (NS_FAILED(rv) && PR_PENDING_INTERRUPT_ERROR == PR_GetError())
+    {
+      printf("error waiting for monitor\n");
+      break;
+    }
+
+    if (readyToRun && m_runningUrl)
+    {
+      if (m_currentServerCommandTagNumber && m_transport)
+      {
+        bool isAlive;
+        rv = m_transport->IsAlive(&isAlive);
+        // if the transport is not alive, and we've ever sent a command with this connection, kill it.
+        // otherwise, we've probably just not finished setting it so don't kill it!
+        if (NS_FAILED(rv) || !isAlive)
+        {
+          // This says we never started running the url, which is the case.
+          m_runningUrl->SetRerunningUrl(false);
+          RetryUrl();
+          return;
+        }
+      }
+      //
+      // NOTE: Though we cleared m_nextUrlReadyToRun above, it may have been
+      //       set by LoadImapUrl, which runs on the main thread.  Because of this,
+      //       we must not try to clear m_nextUrlReadyToRun here.
+      //
+      if (ProcessCurrentURL())
+      {
+        m_nextUrlReadyToRun = true;
+        m_imapMailFolderSink = nullptr;
+      }
+      else
+      {
+        // see if we want to go into idle mode. Might want to check a pref here too.
+        if (m_useIdle && !m_urlInProgress && GetServerStateParser().GetCapabilityFlag() & kHasIdleCapability
+          && GetServerStateParser().GetIMAPstate()
+                == nsImapServerResponseParser::kFolderSelected)
+        {
+          Idle(); // for now, lets just do it. We'll probably want to use a timer
+        }
+        else // if not idle, don't need to remember folder sink
+          m_imapMailFolderSink = nullptr;
+      }
+    }
+    else if (m_idle && !m_threadShouldDie)
+    {
+      HandleIdleResponses();
+    }
+    if (!GetServerStateParser().Connected())
+      break;
+#ifdef DEBUG_bienvenu
+    else
+      printf("ready to run but no url and not idle\n");
+#endif
+    // This can happen if the UI thread closes cached connections in the
+    // OnStopRunningUrl notification.
+    if (m_threadShouldDie)
+      TellThreadToDie();
+  }
+  m_imapThreadIsRunning = false;
+
+  MOZ_LOG(IMAP, LogLevel::Debug, ("ImapThreadMainLoop leaving [this=%x]\n", this));
+}
+
+void nsImapProtocol::HandleIdleResponses()
+{
+  // int32_t oldRecent = GetServerStateParser().NumberOfRecentMessages();
+  nsAutoCString commandBuffer(GetServerCommandTag());
+  commandBuffer.Append(" IDLE" CRLF);
+
+  do
+  {
+    ParseIMAPandCheckForNewMail(commandBuffer.get());
+  }
+  while (m_inputStreamBuffer->NextLineAvailable() && GetServerStateParser().Connected());
+
+  //  if (oldRecent != GetServerStateParser().NumberOfRecentMessages())
+  //  We might check that something actually changed, but for now we can
+  // just assume it. OnNewIdleMessages must run a url, so that
+  // we'll go back into asyncwait mode.
+  if (GetServerStateParser().Connected() && m_imapMailFolderSink)
+    m_imapMailFolderSink->OnNewIdleMessages();
+}
+
+void nsImapProtocol::EstablishServerConnection()
+{
+#define ESC_LENGTH(x) (sizeof(x) - 1)
+#define ESC_OK                      "* OK"
+#define ESC_OK_LEN                  ESC_LENGTH(ESC_OK)
+#define ESC_PREAUTH                 "* PREAUTH"
+#define ESC_PREAUTH_LEN             ESC_LENGTH(ESC_PREAUTH)
+#define ESC_CAPABILITY_STAR         "* "
+#define ESC_CAPABILITY_STAR_LEN     ESC_LENGTH(ESC_CAPABILITY_STAR)
+#define ESC_CAPABILITY_OK           "* OK ["
+#define ESC_CAPABILITY_OK_LEN       ESC_LENGTH(ESC_CAPABILITY_OK)
+#define ESC_CAPABILITY_GREETING     (ESC_CAPABILITY_OK "CAPABILITY")
+#define ESC_CAPABILITY_GREETING_LEN ESC_LENGTH(ESC_CAPABILITY_GREETING)
+
+  char * serverResponse = CreateNewLineFromSocket(); // read in the greeting
+
+  // record the fact that we've received a greeting for this connection so we don't ever
+  // try to do it again..
+  if (serverResponse)
+    SetFlag(IMAP_RECEIVED_GREETING);
+
+  if (!PL_strncasecmp(serverResponse, ESC_OK, ESC_OK_LEN))
+  {
+    SetConnectionStatus(NS_OK);
+
+    if (!PL_strncasecmp(serverResponse, ESC_CAPABILITY_GREETING, ESC_CAPABILITY_GREETING_LEN))
+    {
+      nsAutoCString tmpstr(serverResponse);
+      int32_t endIndex = tmpstr.FindChar(']', ESC_CAPABILITY_GREETING_LEN);
+      if (endIndex >= 0)
+      {
+        // Allocate the new buffer here. This buffer will be passed to
+        // ParseIMAPServerResponse() where it will be used to fill the
+        // fCurrentLine field and will be freed by the next call to
+        // ResetLexAnalyzer().
+        char *fakeServerResponse = (char*)PR_Malloc(PL_strlen(serverResponse));
+        // Munge the greeting into something that would pass for an IMAP
+        // server's response to a "CAPABILITY" command.
+        strcpy(fakeServerResponse, ESC_CAPABILITY_STAR);
+        strcat(fakeServerResponse, serverResponse + ESC_CAPABILITY_OK_LEN);
+        fakeServerResponse[endIndex - ESC_CAPABILITY_OK_LEN + ESC_CAPABILITY_STAR_LEN] = '\0';
+        // Tell the response parser that we just issued a "CAPABILITY" and
+        // got the following back.
+        GetServerStateParser().ParseIMAPServerResponse("1 CAPABILITY", true, fakeServerResponse);
+      }
+    }
+  }
+  else if (!PL_strncasecmp(serverResponse, ESC_PREAUTH, ESC_PREAUTH_LEN))
+  {
+    // we've been pre-authenticated.
+    // we can skip the whole password step, right into the
+    // kAuthenticated state
+    GetServerStateParser().PreauthSetAuthenticatedState();
+
+    if (GetServerStateParser().GetCapabilityFlag() == kCapabilityUndefined)
+      Capability();
+
+    if ( !(GetServerStateParser().GetCapabilityFlag() &
+          (kIMAP4Capability | kIMAP4rev1Capability | kIMAP4other) ) )
+    {
+      // AlertUserEvent_UsingId(MK_MSG_IMAP_SERVER_NOT_IMAP4);
+      SetConnectionStatus(NS_ERROR_FAILURE);        // stop netlib
+    }
+    else
+    {
+      // let's record the user as authenticated.
+      m_imapServerSink->SetUserAuthenticated(true);
+
+      ProcessAfterAuthenticated();
+      // the connection was a success
+      SetConnectionStatus(NS_OK);
+     }
+  }
+
+  PR_Free(serverResponse); // we don't care about the greeting yet...
+
+#undef ESC_LENGTH
+#undef ESC_OK
+#undef ESC_OK_LEN
+#undef ESC_PREAUTH
+#undef ESC_PREAUTH_LEN
+#undef ESC_CAPABILITY_STAR
+#undef ESC_CAPABILITY_STAR_LEN
+#undef ESC_CAPABILITY_OK
+#undef ESC_CAPABILITY_OK_LEN
+#undef ESC_CAPABILITY_GREETING
+#undef ESC_CAPABILITY_GREETING_LEN
+}
+
+// This can get called from the UI thread or an imap thread.
+// It makes sure we don't get left with partial messages in
+// the memory cache.
+static void DoomCacheEntry(nsIMsgMailNewsUrl *url)
+{
+  bool readingFromMemCache = false;
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(url);
+  imapUrl->GetMsgLoadingFromCache(&readingFromMemCache);
+  if (!readingFromMemCache)
+  {
+    nsCOMPtr<nsICacheEntry> cacheEntry;
+    url->GetMemCacheEntry(getter_AddRefs(cacheEntry));
+    if (cacheEntry)
+      cacheEntry->AsyncDoom(nullptr);
+  }
+}
+
+// returns true if another url was run, false otherwise.
+bool nsImapProtocol::ProcessCurrentURL()
+{
+  nsresult rv = NS_OK;
+  if (m_idle)
+    EndIdle();
+
+  if (m_retryUrlOnError)
+  {
+    // we clear this flag if we're re-running immediately, because that
+    // means we never sent a start running url notification, and later we
+    // don't send start running notification if we think we're rerunning
+    // the url (see first call to SetUrlState below). This means we won't
+    // send a start running notification, which means our stop running
+    // notification will be ignored because we don't think we were running.
+    m_runningUrl->SetRerunningUrl(false);
+    return RetryUrl();
+  }
+  Log("ProcessCurrentURL", nullptr, "entering");
+  (void) GetImapHostName(); // force m_hostName to get set.
+
+
+  bool    logonFailed = false;
+  bool anotherUrlRun = false;
+  bool rerunningUrl = false;
+  bool isExternalUrl;
+  bool validUrl = true;
+
+  PseudoInterrupt(false);  // clear this if left over from previous url.
+
+  m_runningUrl->GetRerunningUrl(&rerunningUrl);
+  m_runningUrl->GetExternalLinkUrl(&isExternalUrl);
+  m_runningUrl->GetValidUrl(&validUrl);
+  m_runningUrl->GetImapAction(&m_imapAction);
+
+  if (isExternalUrl)
+  {
+    if (m_imapAction == nsIImapUrl::nsImapSelectFolder)
+    {
+      // we need to send a start request so that the doc loader
+      // will call HandleContent on the imap service so we
+      // can abort this url, and run a new url in a new msg window
+      // to run the folder load url and get off this crazy merry-go-round.
+      if (m_channelListener)
+      {
+        nsCOMPtr<nsIRequest> request = do_QueryInterface(m_mockChannel);
+        m_channelListener->OnStartRequest(request, m_channelContext);
+      }
+      return false;
+    }
+  }
+
+  if (!m_imapMailFolderSink && m_imapProtocolSink)
+  {
+    // This occurs when running another URL in the main thread loop
+    rv = m_imapProtocolSink->SetupMainThreadProxies();
+    NS_ENSURE_SUCCESS(rv, false);
+  }
+
+  // Reinitialize the parser
+  GetServerStateParser().InitializeState();
+  GetServerStateParser().SetConnected(true);
+
+  // acknowledge that we are running the url now..
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl = do_QueryInterface(m_runningUrl, &rv);
+  nsAutoCString urlSpec;
+  rv = mailnewsurl->GetSpec(urlSpec);
+  NS_ENSURE_SUCCESS(rv, false);
+  Log("ProcessCurrentURL", urlSpec.get(), (validUrl) ? " = currentUrl\n" : " is not valid\n");
+  if (!validUrl)
+    return false;
+
+  if (NS_SUCCEEDED(rv) && mailnewsurl && m_imapMailFolderSink && !rerunningUrl)
+    m_imapMailFolderSink->SetUrlState(this, mailnewsurl, true, false,
+                                      NS_OK);
+
+  // if we are set up as a channel, we should notify our channel listener that we are starting...
+  // so pass in ourself as the channel and not the underlying socket or file channel the protocol
+  // happens to be using
+  if (m_channelListener) // ### not sure we want to do this if rerunning url...
+  {
+    nsCOMPtr<nsIRequest> request = do_QueryInterface(m_mockChannel);
+    m_channelListener->OnStartRequest(request, m_channelContext);
+  }
+  // If we haven't received the greeting yet, we need to make sure we strip
+  // it out of the input before we start to do useful things...
+  if (!TestFlag(IMAP_RECEIVED_GREETING))
+    EstablishServerConnection();
+
+  // Step 1: If we have not moved into the authenticated state yet then do so
+  // by attempting to logon.
+  if (!DeathSignalReceived() && NS_SUCCEEDED(GetConnectionStatus()) &&
+      (GetServerStateParser().GetIMAPstate() ==
+       nsImapServerResponseParser::kNonAuthenticated))
+  {
+      /* if we got here, the server's greeting should not have been PREAUTH */
+      if (GetServerStateParser().GetCapabilityFlag() == kCapabilityUndefined)
+          Capability();
+
+      if ( !(GetServerStateParser().GetCapabilityFlag() & (kIMAP4Capability | kIMAP4rev1Capability |
+             kIMAP4other) ) )
+      {
+        if (!DeathSignalReceived() && NS_SUCCEEDED(GetConnectionStatus()))
+          AlertUserEventUsingName("imapServerNotImap4");
+
+        SetConnectionStatus(NS_ERROR_FAILURE);        // stop netlib
+      }
+      else
+      {
+        if ((m_connectionType.Equals("starttls")
+             && (m_socketType == nsMsgSocketType::trySTARTTLS
+             && (GetServerStateParser().GetCapabilityFlag() & kHasStartTLSCapability)))
+            || m_socketType == nsMsgSocketType::alwaysSTARTTLS)
+        {
+          StartTLS();
+          if (GetServerStateParser().LastCommandSuccessful())
+          {
+            nsCOMPtr<nsISupports> secInfo;
+            nsCOMPtr<nsISocketTransport> strans = do_QueryInterface(m_transport, &rv);
+            if (NS_FAILED(rv))
+              return false;
+
+            rv = strans->GetSecurityInfo(getter_AddRefs(secInfo));
+
+            if (NS_SUCCEEDED(rv) && secInfo)
+            {
+              nsCOMPtr<nsISSLSocketControl> sslControl = do_QueryInterface(secInfo, &rv);
+
+              if (NS_SUCCEEDED(rv) && sslControl)
+              {
+                rv = sslControl->StartTLS();
+                if (NS_SUCCEEDED(rv))
+                {
+                  if (m_socketType == nsMsgSocketType::trySTARTTLS)
+                    m_imapServerSink->UpdateTrySTARTTLSPref(true);
+                  // force re-issue of "capability", because servers may
+                  // enable other auth features (e.g. remove LOGINDISABLED
+                  // and add AUTH=PLAIN) after we upgraded to SSL.
+                  Capability();
+                  eIMAPCapabilityFlags capabilityFlag = GetServerStateParser().GetCapabilityFlag();
+                  // Courier imap doesn't return STARTTLS capability if we've done
+                  // a STARTTLS! But we need to remember this capability so we'll
+                  // try to use STARTTLS next time.
+                  if (!(capabilityFlag & kHasStartTLSCapability))
+                  {
+                    capabilityFlag |= kHasStartTLSCapability;
+                    GetServerStateParser().SetCapabilityFlag(capabilityFlag);
+                    CommitCapability();
+                  }
+                }
+              }
+            }
+            if (NS_FAILED(rv))
+            {
+              nsAutoCString logLine("STARTTLS negotiation failed. Error 0x");
+              logLine.AppendInt(static_cast<uint32_t>(rv), 16);
+              Log("ProcessCurrentURL", nullptr, logLine.get());
+              if (m_socketType == nsMsgSocketType::alwaysSTARTTLS)
+              {
+                SetConnectionStatus(rv);        // stop netlib
+                m_transport->Close(rv);
+              }
+              else if (m_socketType == nsMsgSocketType::trySTARTTLS)
+                m_imapServerSink->UpdateTrySTARTTLSPref(false);
+            }
+          }
+          else if (m_socketType == nsMsgSocketType::alwaysSTARTTLS)
+          {
+            SetConnectionStatus(NS_ERROR_FAILURE);        // stop netlib
+            if (m_transport)
+              m_transport->Close(rv);
+          }
+          else if (m_socketType == nsMsgSocketType::trySTARTTLS)
+          {
+            // STARTTLS failed, so downgrade socket type
+            m_imapServerSink->UpdateTrySTARTTLSPref(false);
+          }
+        }
+        else if (m_socketType == nsMsgSocketType::trySTARTTLS)
+        {
+          // we didn't know the server supported TLS when we created
+          // the socket, so we're going to retry with a STARTTLS socket
+          if (GetServerStateParser().GetCapabilityFlag() & kHasStartTLSCapability)
+          {
+            ClearFlag(IMAP_CONNECTION_IS_OPEN);
+            TellThreadToDie();
+            SetConnectionStatus(NS_ERROR_FAILURE);
+            return RetryUrl();
+          }
+          else
+          {
+            // trySTARTTLS set, but server doesn't have TLS capability,
+            // so downgrade socket type
+            m_imapServerSink->UpdateTrySTARTTLSPref(false);
+            m_socketType = nsMsgSocketType::plain;
+          }
+        }
+        logonFailed = !TryToLogon();
+        if (m_retryUrlOnError)
+          return RetryUrl();
+      }
+  } // if death signal not received
+
+  if (!DeathSignalReceived() && (NS_SUCCEEDED(GetConnectionStatus())))
+  {
+    // if the server supports a language extension then we should
+    // attempt to issue the language extension.
+    if ( GetServerStateParser().GetCapabilityFlag() & kHasLanguageCapability)
+      Language();
+
+    if (m_runningUrl)
+      FindMailboxesIfNecessary();
+
+    nsImapState imapState = nsIImapUrl::ImapStatusNone;
+    if (m_runningUrl)
+      m_runningUrl->GetRequiredImapState(&imapState);
+
+    if (imapState == nsIImapUrl::nsImapAuthenticatedState)
+      ProcessAuthenticatedStateURL();
+    else   // must be a url that requires us to be in the selected state
+      ProcessSelectedStateURL();
+
+    if (m_retryUrlOnError)
+      return RetryUrl();
+
+  // The URL has now been processed
+    if ((!logonFailed && NS_FAILED(GetConnectionStatus())) ||
+         DeathSignalReceived())
+         HandleCurrentUrlError();
+
+  }
+  else if (!logonFailed)
+      HandleCurrentUrlError();
+
+// if we are set up as a channel, we should notify our channel listener that we are stopping...
+// so pass in ourself as the channel and not the underlying socket or file channel the protocol
+// happens to be using
+  if (m_channelListener)
+  {
+      nsCOMPtr<nsIRequest> request = do_QueryInterface(m_mockChannel);
+      NS_ASSERTION(request, "no request");
+      if (request) {
+        nsresult status;
+        request->GetStatus(&status);
+        if (!GetServerStateParser().LastCommandSuccessful() && NS_SUCCEEDED(status))
+          status = NS_MSG_ERROR_IMAP_COMMAND_FAILED;
+        rv = m_channelListener->OnStopRequest(request, m_channelContext, status);
+      }
+  }
+  bool suspendUrl = false;
+  m_runningUrl->GetMoreHeadersToDownload(&suspendUrl);
+  if (mailnewsurl && m_imapMailFolderSink)
+  {
+    if (logonFailed)
+      rv = NS_ERROR_FAILURE;
+    else if (GetServerStateParser().CommandFailed())
+      rv = NS_MSG_ERROR_IMAP_COMMAND_FAILED;
+    else
+      rv = GetConnectionStatus();
+    // we are done with this url.
+    m_imapMailFolderSink->SetUrlState(this, mailnewsurl, false, suspendUrl,
+                                      rv);
+     // doom the cache entry
+    if (NS_FAILED(rv) && DeathSignalReceived() && m_mockChannel)
+      DoomCacheEntry(mailnewsurl);
+  }
+  else
+  {
+    // That's seen at times in debug sessions.
+    NS_WARNING("missing url or sink");
+  }
+
+  // disable timeouts before caching connection.
+  if (m_transport)
+    m_transport->SetTimeout(nsISocketTransport::TIMEOUT_READ_WRITE, PR_UINT32_MAX);
+
+  SetFlag(IMAP_CLEAN_UP_URL_STATE);
+
+  nsCOMPtr <nsISupports> copyState;
+  if (m_runningUrl)
+    m_runningUrl->GetCopyState(getter_AddRefs(copyState));
+  // this is so hokey...we MUST clear any local references to the url
+  // BEFORE calling ReleaseUrlState
+  mailnewsurl = nullptr;
+
+  if (suspendUrl)
+    m_imapServerSink->SuspendUrl(m_runningUrl);
+  // save the imap folder sink since we need it to do the CopyNextStreamMessage
+  RefPtr<ImapMailFolderSinkProxy> imapMailFolderSink = m_imapMailFolderSink;
+  // release the url as we are done with it...
+  ReleaseUrlState(false);
+  ResetProgressInfo();
+
+  ClearFlag(IMAP_CLEAN_UP_URL_STATE);
+
+  if (imapMailFolderSink)
+  {
+    if (copyState)
+    {
+      rv = imapMailFolderSink->CopyNextStreamMessage(GetServerStateParser().LastCommandSuccessful() &&
+                                                NS_SUCCEEDED(GetConnectionStatus()),
+                                                copyState);
+      if (NS_FAILED(rv))
+        MOZ_LOG(IMAP, LogLevel::Info, ("CopyNextStreamMessage failed:%lx\n", rv));
+
+      NS_ReleaseOnMainThread(copyState.forget());
+    }
+    // we might need this to stick around for IDLE support
+    m_imapMailFolderSink = imapMailFolderSink;
+    imapMailFolderSink = nullptr;
+  }
+  else
+    MOZ_LOG(IMAP, LogLevel::Info, ("null imapMailFolderSink\n"));
+
+  // now try queued urls, now that we've released this connection.
+  if (m_imapServerSink)
+  {
+    if (NS_SUCCEEDED(GetConnectionStatus()))
+      rv = m_imapServerSink->LoadNextQueuedUrl(this, &anotherUrlRun);
+    else // if we don't do this, they'll just sit and spin until
+          // we run some other url on this server.
+    {
+      Log("ProcessCurrentURL", nullptr, "aborting queued urls");
+      rv = m_imapServerSink->AbortQueuedUrls();
+    }
+  }
+
+  // if we didn't run another url, release the server sink to
+  // cut circular refs.
+  if (!anotherUrlRun)
+      m_imapServerSink = nullptr;
+
+  if (NS_FAILED(GetConnectionStatus()) || !GetServerStateParser().Connected()
+    || GetServerStateParser().SyntaxError())
+  {
+    if (m_imapServerSink)
+      m_imapServerSink->RemoveServerConnection(this);
+
+    if (!DeathSignalReceived())
+    {
+        TellThreadToDie();
+    }
+  }
+  else
+  {
+    if (m_imapServerSink)
+    {
+      bool shuttingDown;
+      m_imapServerSink->GetServerShuttingDown(&shuttingDown);
+      if (shuttingDown)
+        m_useIdle = false;
+    }
+  }
+  return anotherUrlRun;
+}
+
+bool nsImapProtocol::RetryUrl()
+{
+  nsCOMPtr <nsIImapUrl> kungFuGripImapUrl = m_runningUrl;
+  nsCOMPtr <nsIImapMockChannel> saveMockChannel;
+
+  // the mock channel might be null - that's OK.
+  if (m_imapServerSink)
+    (void) m_imapServerSink->PrepareToRetryUrl(kungFuGripImapUrl, getter_AddRefs(saveMockChannel));
+
+  ReleaseUrlState(true);
+  if (m_imapServerSink)
+  {
+    m_imapServerSink->RemoveServerConnection(this);
+    m_imapServerSink->RetryUrl(kungFuGripImapUrl, saveMockChannel);
+  }
+  return (m_imapServerSink != nullptr); // we're running a url (the same url)
+}
+
+// ignoreBadAndNOResponses --> don't throw a error dialog if this command results in a NO or Bad response
+// from the server..in other words the command is "exploratory" and we don't really care if it succeeds or fails.
+void nsImapProtocol::ParseIMAPandCheckForNewMail(const char* commandString, bool aIgnoreBadAndNOResponses)
+{
+    if (commandString)
+        GetServerStateParser().ParseIMAPServerResponse(commandString, aIgnoreBadAndNOResponses);
+    else
+        GetServerStateParser().ParseIMAPServerResponse(m_currentCommand.get(), aIgnoreBadAndNOResponses);
+    // **** fix me for new mail biff state *****
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// End of nsIStreamListenerSupport
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP
+nsImapProtocol::GetRunningUrl(nsIURI **result)
+{
+    if (result && m_runningUrl)
+        return m_runningUrl->QueryInterface(NS_GET_IID(nsIURI), (void**)
+                                            result);
+    else
+        return NS_ERROR_NULL_POINTER;
+}
+
+
+NS_IMETHODIMP nsImapProtocol::GetRunningImapURL(nsIImapUrl **aImapUrl)
+{
+  if (aImapUrl && m_runningUrl)
+     return m_runningUrl->QueryInterface(NS_GET_IID(nsIImapUrl), (void**) aImapUrl);
+  else
+    return NS_ERROR_NULL_POINTER;
+
+}
+
+/*
+ * Writes the data contained in dataBuffer into the current output stream. It also informs
+ * the transport layer that this data is now available for transmission.
+ * Returns a positive number for success, 0 for failure (not all the bytes were written to the
+ * stream, etc). We need to make another pass through this file to install an error system (mscott)
+ */
+
+nsresult nsImapProtocol::SendData(const char * dataBuffer, bool aSuppressLogging)
+{
+  nsresult rv = NS_ERROR_NULL_POINTER;
+
+  if (!m_transport)
+  {
+      Log("SendData", nullptr, "clearing IMAP_CONNECTION_IS_OPEN");
+      // the connection died unexpectedly! so clear the open connection flag
+      ClearFlag(IMAP_CONNECTION_IS_OPEN);
+      TellThreadToDie();
+      SetConnectionStatus(NS_ERROR_FAILURE);
+      return NS_ERROR_FAILURE;
+  }
+
+  if (dataBuffer && m_outputStream)
+  {
+    m_currentCommand = dataBuffer;
+    if (!aSuppressLogging)
+      Log("SendData", nullptr, dataBuffer);
+    else
+      Log("SendData", nullptr, "Logging suppressed for this command (it probably contained authentication information)");
+
+    {
+      // don't allow someone to close the stream/transport out from under us
+      // this can happen when the ui thread calls TellThreadToDie.
+      PR_CEnterMonitor(this);
+      uint32_t n;
+      if (m_outputStream)
+        rv = m_outputStream->Write(dataBuffer, PL_strlen(dataBuffer), &n);
+      PR_CExitMonitor(this);
+    }
+    if (NS_FAILED(rv))
+    {
+      Log("SendData", nullptr, "clearing IMAP_CONNECTION_IS_OPEN");
+      // the connection died unexpectedly! so clear the open connection flag
+      ClearFlag(IMAP_CONNECTION_IS_OPEN);
+      TellThreadToDie();
+      SetConnectionStatus(rv);
+      if (m_runningUrl && !m_retryUrlOnError)
+      {
+        bool alreadyRerunningUrl;
+        m_runningUrl->GetRerunningUrl(&alreadyRerunningUrl);
+        if (!alreadyRerunningUrl)
+        {
+          m_runningUrl->SetRerunningUrl(true);
+          m_retryUrlOnError = true;
+        }
+      }
+    }
+  }
+
+  return rv;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Begin protocol state machine functions...
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+  // ProcessProtocolState - we override this only so we'll link - it should never get called.
+
+nsresult nsImapProtocol::ProcessProtocolState(nsIURI * url, nsIInputStream * inputStream,
+                                              uint64_t sourceOffset, uint32_t length)
+{
+  return NS_OK;
+}
+
+class UrlListenerNotifierEvent : public mozilla::Runnable
+{
+public:
+  UrlListenerNotifierEvent(nsIMsgMailNewsUrl *aUrl, nsIImapProtocol *aProtocol)
+    : mUrl(aUrl), mProtocol(aProtocol)
+  {}
+
+  NS_IMETHOD Run()
+  {
+    if (mUrl)
+    {
+      nsCOMPtr<nsIMsgFolder> folder;
+      mUrl->GetFolder(getter_AddRefs(folder));
+      NS_ENSURE_TRUE(folder, NS_OK);
+      nsCOMPtr<nsIImapMailFolderSink> folderSink(do_QueryInterface(folder));
+      // This causes the url listener to get OnStart and Stop notifications.
+      folderSink->SetUrlState(mProtocol, mUrl, true, false, NS_OK);
+      folderSink->SetUrlState(mProtocol, mUrl, false, false, NS_OK);
+    }
+    return NS_OK;
+  }
+
+private:
+  nsCOMPtr<nsIMsgMailNewsUrl> mUrl;
+  nsCOMPtr<nsIImapProtocol> mProtocol;
+};
+
+
+bool nsImapProtocol::TryToRunUrlLocally(nsIURI *aURL, nsISupports *aConsumer)
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(aURL, &rv));
+  NS_ENSURE_SUCCESS(rv, false);
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(aURL);
+  nsCString messageIdString;
+  imapUrl->GetListOfMessageIds(messageIdString);
+  bool useLocalCache = false;
+  if (!messageIdString.IsEmpty() && !HandlingMultipleMessages(messageIdString))
+  {
+    nsImapAction action;
+    imapUrl->GetImapAction(&action);
+    nsCOMPtr <nsIMsgFolder> folder;
+    mailnewsUrl->GetFolder(getter_AddRefs(folder));
+    NS_ENSURE_TRUE(folder, false);
+
+    folder->HasMsgOffline(strtoul(messageIdString.get(), nullptr, 10), &useLocalCache);
+    mailnewsUrl->SetMsgIsInLocalCache(useLocalCache);
+    // We're downloading a single message for offline use, and it's
+    // already offline. So we shouldn't do anything, but we do
+    // need to notify the url listener.
+    if (useLocalCache && action == nsIImapUrl::nsImapMsgDownloadForOffline)
+    {
+      nsCOMPtr<nsIRunnable> event = new UrlListenerNotifierEvent(mailnewsUrl,
+                                                                 this);
+      // Post this as an event because it can lead to re-entrant calls to
+      // LoadNextQueuedUrl if the listener runs a new url.
+      if (event)
+        NS_DispatchToCurrentThread(event);
+      return true;
+    }
+  }
+  if (!useLocalCache)
+    return false;
+
+  nsCOMPtr<nsIImapMockChannel> mockChannel;
+  imapUrl->GetMockChannel(getter_AddRefs(mockChannel));
+  if (!mockChannel)
+    return false;
+
+  nsImapMockChannel *imapChannel = static_cast<nsImapMockChannel *>(mockChannel.get());
+  if (!imapChannel)
+    return false;
+
+  nsCOMPtr <nsILoadGroup> loadGroup;
+  imapChannel->GetLoadGroup(getter_AddRefs(loadGroup));
+  if (!loadGroup) // if we don't have one, the url will snag one from the msg window...
+    mailnewsUrl->GetLoadGroup(getter_AddRefs(loadGroup));
+
+  if (loadGroup)
+    loadGroup->RemoveRequest((nsIRequest *) mockChannel, nullptr /* context isupports */, NS_OK);
+
+  if (imapChannel->ReadFromLocalCache())
+  {
+    (void) imapChannel->NotifyStartEndReadFromCache(true);
+    return true;
+  }
+  return false;
+}
+
+
+// LoadImapUrl takes a url, initializes all of our url specific data by calling SetupUrl.
+// If we don't have a connection yet, we open the connection. Finally, we signal the
+// url to run monitor to let the imap main thread loop process the current url (it is waiting
+// on this monitor). There is a contract that the imap thread has already been started b4 we
+// attempt to load a url....
+NS_IMETHODIMP nsImapProtocol::LoadImapUrl(nsIURI * aURL, nsISupports * aConsumer)
+{
+  nsresult rv;
+  if (aURL)
+  {
+#ifdef DEBUG_bienvenu
+    printf("loading url %s\n", aURL->GetSpecOrDefault().get());
+#endif
+    if (TryToRunUrlLocally(aURL, aConsumer))
+      return NS_OK;
+    m_urlInProgress = true;
+    m_imapMailFolderSink = nullptr;
+    rv = SetupWithUrl(aURL, aConsumer);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "error setting up imap url");
+    if (NS_FAILED(rv))
+      return rv;
+
+    rv = SetupSinkProxy(); // generate proxies for all of the event sinks in the url
+    if (NS_FAILED(rv)) // URL can be invalid.
+      return rv;
+
+    m_lastActiveTime = PR_Now();
+    if (m_transport && m_runningUrl)
+    {
+      nsImapAction imapAction;
+      m_runningUrl->GetImapAction(&imapAction);
+      // if we're shutting down, and not running the kinds of urls we run at
+      // shutdown, then this should fail because running urls during
+      // shutdown will very likely fail and potentially hang.
+      nsCOMPtr<nsIMsgAccountManager> accountMgr = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+      bool shuttingDown = false;
+      (void) accountMgr->GetShutdownInProgress(&shuttingDown);
+      if (shuttingDown && imapAction != nsIImapUrl::nsImapExpungeFolder &&
+          imapAction != nsIImapUrl::nsImapDeleteAllMsgs &&
+          imapAction != nsIImapUrl::nsImapDeleteFolder)
+        return NS_ERROR_FAILURE;
+
+      // if we're running a select or delete all, do a noop first.
+      // this should really be in the connection cache code when we know
+      // we're pulling out a selected state connection, but maybe we
+      // can get away with this.
+      m_needNoop = (imapAction == nsIImapUrl::nsImapSelectFolder || imapAction == nsIImapUrl::nsImapDeleteAllMsgs);
+
+      // We now have a url to run so signal the monitor for url ready to be processed...
+      ReentrantMonitorAutoEnter urlReadyMon(m_urlReadyToRunMonitor);
+      m_nextUrlReadyToRun = true;
+      urlReadyMon.Notify();
+
+    } // if we have an imap url and a transport
+    else
+      NS_ASSERTION(false, "missing channel or running url");
+
+  } // if we received a url!
+  else
+    rv = NS_ERROR_UNEXPECTED;
+
+  return rv;
+}
+
+NS_IMETHODIMP nsImapProtocol::IsBusy(bool *aIsConnectionBusy,
+                                     bool *isInboxConnection)
+{
+  if (!aIsConnectionBusy || !isInboxConnection)
+    return NS_ERROR_NULL_POINTER;
+  nsresult rv = NS_OK;
+  *aIsConnectionBusy = false;
+  *isInboxConnection = false;
+  if (!m_transport)
+  {
+    // this connection might not be fully set up yet.
+    rv = NS_ERROR_FAILURE;
+  }
+  else
+  {
+    if (m_urlInProgress) // do we have a url? That means we're working on it...
+      *aIsConnectionBusy = true;
+
+    if (GetServerStateParser().GetIMAPstate() ==
+        nsImapServerResponseParser::kFolderSelected && GetServerStateParser().GetSelectedMailboxName() &&
+        PL_strcasecmp(GetServerStateParser().GetSelectedMailboxName(),
+                      "Inbox") == 0)
+      *isInboxConnection = true;
+
+  }
+  return rv;
+}
+
+#define IS_SUBSCRIPTION_RELATED_ACTION(action) (action == nsIImapUrl::nsImapSubscribe\
+|| action == nsIImapUrl::nsImapUnsubscribe || action == nsIImapUrl::nsImapDiscoverAllBoxesUrl || action == nsIImapUrl::nsImapListFolder)
+
+
+// canRunUrl means the connection is not busy, and is in the selected state
+// for the desired folder (or authenticated).
+// has to wait means it's in the right selected state, but busy.
+NS_IMETHODIMP nsImapProtocol::CanHandleUrl(nsIImapUrl * aImapUrl,
+                                           bool * aCanRunUrl,
+                                           bool * hasToWait)
+{
+  if (!aCanRunUrl || !hasToWait || !aImapUrl)
+    return NS_ERROR_NULL_POINTER;
+  nsresult rv = NS_OK;
+  MutexAutoLock mon(mLock);
+
+  *aCanRunUrl = false; // assume guilty until proven otherwise...
+  *hasToWait = false;
+
+  if (DeathSignalReceived())
+    return NS_ERROR_FAILURE;
+
+  bool isBusy = false;
+  bool isInboxConnection = false;
+
+  if (!m_transport)
+  {
+    // this connection might not be fully set up yet.
+    return NS_ERROR_FAILURE;
+  }
+  IsBusy(&isBusy, &isInboxConnection);
+  bool inSelectedState = GetServerStateParser().GetIMAPstate() ==
+    nsImapServerResponseParser::kFolderSelected;
+
+  nsAutoCString curSelectedUrlFolderName;
+  nsAutoCString pendingUrlFolderName;
+  if (inSelectedState)
+    curSelectedUrlFolderName = GetServerStateParser().GetSelectedMailboxName();
+
+  if (isBusy)
+  {
+    nsImapState curUrlImapState;
+    NS_ASSERTION(m_runningUrl,"isBusy, but no running url.");
+    if (m_runningUrl)
+    {
+      m_runningUrl->GetRequiredImapState(&curUrlImapState);
+      if (curUrlImapState == nsIImapUrl::nsImapSelectedState)
+      {
+        char *folderName = GetFolderPathString();
+        if (!curSelectedUrlFolderName.Equals(folderName))
+          pendingUrlFolderName.Assign(folderName);
+        inSelectedState = true;
+        PR_Free(folderName);
+      }
+    }
+  }
+
+  nsImapState imapState;
+  nsImapAction actionForProposedUrl;
+  aImapUrl->GetImapAction(&actionForProposedUrl);
+  aImapUrl->GetRequiredImapState(&imapState);
+
+  // OK, this is a bit of a hack - we're going to pretend that
+  // these types of urls requires a selected state connection on
+  // the folder in question. This isn't technically true,
+  // but we would much rather use that connection for several reasons,
+  // one is that some UW servers require us to use that connection
+  // the other is that we don't want to leave a connection dangling in
+  // the selected state for the deleted folder.
+  // If we don't find a connection in that selected state,
+  // we'll fall back to the first free connection.
+  bool isSelectedStateUrl = imapState == nsIImapUrl::nsImapSelectedState
+    || actionForProposedUrl == nsIImapUrl::nsImapDeleteFolder || actionForProposedUrl == nsIImapUrl::nsImapRenameFolder
+    || actionForProposedUrl == nsIImapUrl::nsImapMoveFolderHierarchy
+    || actionForProposedUrl == nsIImapUrl::nsImapAppendDraftFromFile
+    || actionForProposedUrl == nsIImapUrl::nsImapAppendMsgFromFile
+    || actionForProposedUrl == nsIImapUrl::nsImapFolderStatus;
+
+  nsCOMPtr<nsIMsgMailNewsUrl> msgUrl = do_QueryInterface(aImapUrl);
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = msgUrl->GetServer(getter_AddRefs(server));
+  if (NS_SUCCEEDED(rv))
+  {
+    // compare host/user between url and connection.
+    nsCString urlHostName;
+    nsCString urlUserName;
+    rv = server->GetHostName(urlHostName);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = server->GetUsername(urlUserName);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if ((GetImapHostName().IsEmpty() ||
+      urlHostName.Equals(GetImapHostName(), nsCaseInsensitiveCStringComparator())) &&
+      (GetImapUserName().IsEmpty() ||
+      urlUserName.Equals(GetImapUserName(), nsCaseInsensitiveCStringComparator())))
+    {
+      if (isSelectedStateUrl)
+      {
+        if (inSelectedState)
+        {
+          // *** jt - in selected state can only run url with
+          // matching foldername
+          char *folderNameForProposedUrl = nullptr;
+          rv = aImapUrl->CreateServerSourceFolderPathString(
+            &folderNameForProposedUrl);
+          if (NS_SUCCEEDED(rv) && folderNameForProposedUrl)
+          {
+            bool isInbox =
+              PL_strcasecmp("Inbox", folderNameForProposedUrl) == 0;
+            if (!curSelectedUrlFolderName.IsEmpty() || !pendingUrlFolderName.IsEmpty())
+            {
+              bool matched = isInbox ?
+                PL_strcasecmp(curSelectedUrlFolderName.get(),
+                folderNameForProposedUrl) == 0 :
+              PL_strcmp(curSelectedUrlFolderName.get(),
+                folderNameForProposedUrl) == 0;
+              if (!matched && !pendingUrlFolderName.IsEmpty())
+              {
+                matched = isInbox ?
+                  PL_strcasecmp(pendingUrlFolderName.get(),
+                  folderNameForProposedUrl) == 0 :
+                PL_strcmp(pendingUrlFolderName.get(),
+                  folderNameForProposedUrl) == 0;
+              }
+              if (matched)
+              {
+                if (isBusy)
+                  *hasToWait = true;
+                else
+                  *aCanRunUrl = true;
+              }
+            }
+          }
+          MOZ_LOG(IMAP, LogLevel::Debug,
+                 ("proposed url = %s folder for connection %s has To Wait = %s can run = %s",
+                  folderNameForProposedUrl, curSelectedUrlFolderName.get(),
+                  (*hasToWait) ? "TRUE" : "FALSE", (*aCanRunUrl) ? "TRUE" : "FALSE"));
+          PR_FREEIF(folderNameForProposedUrl);
+        }
+      }
+      else // *** jt - an authenticated state url can be run in either
+        // authenticated or selected state
+      {
+        nsImapAction actionForRunningUrl;
+
+        // If proposed url is subscription related, and we are currently running
+        // a subscription url, then we want to queue the proposed url after the current url.
+        // Otherwise, we can run this url if we're not busy.
+        // If we never find a running subscription-related url, the caller will
+        // just use whatever free connection it can find, which is what we want.
+        if (IS_SUBSCRIPTION_RELATED_ACTION(actionForProposedUrl))
+        {
+          if (isBusy && m_runningUrl)
+          {
+            m_runningUrl->GetImapAction(&actionForRunningUrl);
+            if (IS_SUBSCRIPTION_RELATED_ACTION(actionForRunningUrl))
+            {
+              *aCanRunUrl = false;
+              *hasToWait = true;
+            }
+          }
+        }
+        else
+        {
+          if (!isBusy)
+            *aCanRunUrl = true;
+        }
+      }
+    }
+  }
+  return rv;
+}
+
+
+// Command tag handling stuff
+void nsImapProtocol::IncrementCommandTagNumber()
+{
+  sprintf(m_currentServerCommandTag, "%u", ++m_currentServerCommandTagNumber);
+}
+
+const char *nsImapProtocol::GetServerCommandTag()
+{
+    return m_currentServerCommandTag;
+}
+
+void nsImapProtocol::ProcessSelectedStateURL()
+{
+  nsCString mailboxName;
+  bool bMessageIdsAreUids = true;
+  bool moreHeadersToDownload;
+  imapMessageFlagsType  msgFlags = 0;
+  nsCString       urlHost;
+
+  // this can't fail, can it?
+  nsresult res;
+  res = m_runningUrl->GetImapAction(&m_imapAction);
+  m_runningUrl->MessageIdsAreUids(&bMessageIdsAreUids);
+  m_runningUrl->GetMsgFlags(&msgFlags);
+  m_runningUrl->GetMoreHeadersToDownload(&moreHeadersToDownload);
+
+  res = CreateServerSourceFolderPathString(getter_Copies(mailboxName));
+  if (NS_FAILED(res))
+    Log("ProcessSelectedStateURL", nullptr, "error getting source folder path string");
+
+  if (NS_SUCCEEDED(res) && !DeathSignalReceived())
+  {
+    bool selectIssued = false;
+    if (GetServerStateParser().GetIMAPstate() == nsImapServerResponseParser::kFolderSelected)
+    {
+      if (GetServerStateParser().GetSelectedMailboxName() &&
+        PL_strcmp(GetServerStateParser().GetSelectedMailboxName(),
+        mailboxName.get()))
+      {       // we are selected in another folder
+        if (m_closeNeededBeforeSelect)
+          Close();
+        if (GetServerStateParser().LastCommandSuccessful())
+        {
+          selectIssued = true;
+          SelectMailbox(mailboxName.get());
+        }
+      }
+      else if (!GetServerStateParser().GetSelectedMailboxName())
+      {       // why are we in the selected state with no box name?
+        SelectMailbox(mailboxName.get());
+        selectIssued = true;
+      }
+      else if (moreHeadersToDownload && m_imapMailFolderSink) // we need to fetch older headers
+      {
+        nsMsgKey *msgIdList = nullptr;
+        uint32_t msgCount = 0;
+        bool more;
+        m_imapMailFolderSink->GetMsgHdrsToDownload(&more, &m_progressCount,
+                                                   &msgCount, &msgIdList);
+        if (msgIdList)
+        {
+          FolderHeaderDump(msgIdList, msgCount);
+          NS_Free(msgIdList);
+          m_runningUrl->SetMoreHeadersToDownload(more);
+          // We're going to be re-running this url.
+          if (more)
+            m_runningUrl->SetRerunningUrl(true);
+        }
+        HeaderFetchCompleted();
+      }
+      else
+      {
+        // get new message counts, if any, from server
+        if (m_needNoop)
+        {
+          // For some IMAP servers, to detect new email we must send imap
+          // SELECT even if already SELECTed on the same mailbox. For other
+          // servers that simply don't support IDLE, doing select here will
+          // cause emails to be properly marked "read" after they have been
+          // read in another email client.
+          if (m_forceSelect)
+          {
+            SelectMailbox(mailboxName.get());
+            selectIssued = true;
+          }
+
+          m_noopCount++;
+          if ((gPromoteNoopToCheckCount > 0 && (m_noopCount % gPromoteNoopToCheckCount) == 0) ||
+            CheckNeeded())
+            Check();
+          else
+            Noop(); // I think this is needed when we're using a cached connection
+          m_needNoop = false;
+        }
+      }
+    }
+    else
+    {
+      // go to selected state
+      SelectMailbox(mailboxName.get());
+      selectIssued = GetServerStateParser().LastCommandSuccessful();
+    }
+
+    if (selectIssued)
+      RefreshACLForFolderIfNecessary(mailboxName.get());
+
+    bool uidValidityOk = true;
+    if (GetServerStateParser().LastCommandSuccessful() && selectIssued &&
+      (m_imapAction != nsIImapUrl::nsImapSelectFolder) && (m_imapAction != nsIImapUrl::nsImapLiteSelectFolder))
+    {
+
+      // error on the side of caution, if the fe event fails to set uidStruct->returnValidity, then assume that UIDVALIDITY
+      // did not roll.  This is a common case event for attachments that are fetched within a browser context.
+      if (!DeathSignalReceived())
+        uidValidityOk = m_uidValidity == kUidUnknown ||
+                        m_uidValidity == GetServerStateParser().FolderUID();
+    }
+
+    if (!uidValidityOk)
+      Log("ProcessSelectedStateURL", nullptr, "uid validity not ok");
+    if (GetServerStateParser().LastCommandSuccessful() && !DeathSignalReceived() && (uidValidityOk || m_imapAction == nsIImapUrl::nsImapDeleteAllMsgs))
+    {
+      if (GetServerStateParser().CurrentFolderReadOnly())
+      {
+        Log("ProcessSelectedStateURL", nullptr, "current folder read only");
+        if (m_imapAction == nsIImapUrl::nsImapAddMsgFlags ||
+          m_imapAction == nsIImapUrl::nsImapSubtractMsgFlags)
+        {
+          bool canChangeFlag = false;
+          if (GetServerStateParser().ServerHasACLCapability() && m_imapMailFolderSink)
+          {
+            uint32_t aclFlags = 0;
+
+            if (NS_SUCCEEDED(m_imapMailFolderSink->GetAclFlags(&aclFlags))
+                  && aclFlags != 0) // make sure we have some acl flags
+              canChangeFlag = ((msgFlags & kImapMsgSeenFlag) && (aclFlags & IMAP_ACL_STORE_SEEN_FLAG));
+          }
+          else
+            canChangeFlag = (GetServerStateParser().SettablePermanentFlags() & msgFlags) == msgFlags;
+          if (!canChangeFlag)
+            return;
+        }
+        if (m_imapAction == nsIImapUrl::nsImapExpungeFolder || m_imapAction == nsIImapUrl::nsImapDeleteMsg ||
+          m_imapAction == nsIImapUrl::nsImapDeleteAllMsgs)
+          return;
+      }
+      switch (m_imapAction)
+      {
+      case nsIImapUrl::nsImapLiteSelectFolder:
+        if (GetServerStateParser().LastCommandSuccessful() &&
+            m_imapMailFolderSink && !moreHeadersToDownload)
+        {
+          m_imapMailFolderSink->SetUidValidity(GetServerStateParser().FolderUID());
+          ProcessMailboxUpdate(false); // handle uidvalidity change
+        }
+        break;
+      case nsIImapUrl::nsImapSaveMessageToDisk:
+      case nsIImapUrl::nsImapMsgFetch:
+      case nsIImapUrl::nsImapMsgFetchPeek:
+      case nsIImapUrl::nsImapMsgDownloadForOffline:
+      case nsIImapUrl::nsImapMsgPreview:
+        {
+          nsCString messageIdString;
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+          // we don't want to send the flags back in a group
+          if (HandlingMultipleMessages(messageIdString) || m_imapAction == nsIImapUrl::nsImapMsgDownloadForOffline
+             || m_imapAction == nsIImapUrl::nsImapMsgPreview)
+          {
+            // multiple messages, fetch them all
+            SetProgressString("imapFolderReceivingMessageOf2");
+
+            m_progressIndex = 0;
+            m_progressCount = CountMessagesInIdString(messageIdString.get());
+
+            // we need to set this so we'll get the msg from the memory cache.
+            if (m_imapAction == nsIImapUrl::nsImapMsgFetchPeek)
+              SetContentModified(IMAP_CONTENT_NOT_MODIFIED);
+
+            FetchMessage(messageIdString,
+              (m_imapAction == nsIImapUrl::nsImapMsgPreview)
+              ? kBodyStart : kEveryThingRFC822Peek);
+            if (m_imapAction == nsIImapUrl::nsImapMsgPreview)
+              HeaderFetchCompleted();
+            SetProgressString(nullptr);
+          }
+          else
+          {
+            // A single message ID
+            nsIMAPeFetchFields whatToFetch = kEveryThingRFC822;
+            if(m_imapAction == nsIImapUrl::nsImapMsgFetchPeek)
+              whatToFetch = kEveryThingRFC822Peek;
+
+            // First, let's see if we're requesting a specific MIME part
+            char *imappart = nullptr;
+            m_runningUrl->GetImapPartToFetch(&imappart);
+            if (imappart)
+            {
+              if (bMessageIdsAreUids)
+              {
+                // We actually want a specific MIME part of the message.
+                // The Body Shell will generate it, even though we haven't downloaded it yet.
+
+                IMAP_ContentModifiedType modType = GetShowAttachmentsInline() ?
+                  IMAP_CONTENT_MODIFIED_VIEW_INLINE :
+                  IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS ;
+
+                RefPtr<nsIMAPBodyShell> foundShell;
+                res = m_hostSessionList->FindShellInCacheForHost(GetImapServerKey(),
+                  GetServerStateParser().GetSelectedMailboxName(),
+                  messageIdString.get(), modType, getter_AddRefs(foundShell));
+                if (!foundShell)
+                {
+                  // The shell wasn't in the cache.  Deal with this case later.
+                  Log("SHELL",NULL,"Loading part, shell not found in cache!");
+                  //MOZ_LOG(IMAP, out, ("BODYSHELL: Loading part, shell not found in cache!"));
+                  // The parser will extract the part number from the current URL.
+                  SetContentModified(modType);
+                  Bodystructure(messageIdString, bMessageIdsAreUids);
+                }
+                else
+                {
+                  Log("SHELL", NULL, "Loading Part, using cached shell.");
+                  //MOZ_LOG(IMAP, out, ("BODYSHELL: Loading part, using cached shell."));
+                  SetContentModified(modType);
+                  foundShell->SetConnection(this);
+                  GetServerStateParser().UseCachedShell(foundShell);
+                  //Set the current uid in server state parser (in case it was used for new mail msgs earlier).
+                  GetServerStateParser().SetCurrentResponseUID(strtoul(messageIdString.get(), nullptr, 10));
+                  foundShell->Generate(imappart);
+                  GetServerStateParser().UseCachedShell(NULL);
+                }
+              }
+              else
+              {
+                // Message IDs are not UIDs.
+                NS_ASSERTION(false, "message ids aren't uids");
+              }
+              PR_Free(imappart);
+            }
+            else
+            {
+              // downloading a single message: try to do it by bodystructure, and/or do it by chunks
+              uint32_t messageSize = GetMessageSize(messageIdString.get(), bMessageIdsAreUids);
+              // We need to check the format_out bits to see if we are allowed to leave out parts,
+              // or if we are required to get the whole thing.  Some instances where we are allowed
+              // to do it by parts:  when viewing a message, replying to a message, or viewing its source
+              // Some times when we're NOT allowed:  when forwarding a message, saving it, moving it, etc.
+              // need to set a flag in the url, I guess, equiv to allow_content_changed.
+              bool allowedToBreakApart = true; // (ce  && !DeathSignalReceived()) ? ce->URL_s->allow_content_change : false;
+              bool mimePartSelectorDetected;
+              bool urlOKToFetchByParts = false;
+              m_runningUrl->GetMimePartSelectorDetected(&mimePartSelectorDetected);
+              m_runningUrl->GetFetchPartsOnDemand(&urlOKToFetchByParts);
+
+#ifdef PR_LOGGING
+              {
+                nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl = do_QueryInterface(m_runningUrl);
+                nsAutoCString urlSpec;
+                if (mailnewsurl)
+                  urlSpec = mailnewsurl->GetSpecOrDefault();
+                MOZ_LOG(IMAP, LogLevel::Debug,
+                       ("SHELL: URL %s, OKToFetchByParts %d, allowedToBreakApart %d, ShouldFetchAllParts %d",
+                        urlSpec.get(), urlOKToFetchByParts, allowedToBreakApart,
+                        GetShouldFetchAllParts()));
+              }
+#endif
+
+              if (urlOKToFetchByParts &&
+                  allowedToBreakApart &&
+                  !GetShouldFetchAllParts() &&
+                  GetServerStateParser().ServerHasIMAP4Rev1Capability() /* &&
+                !mimePartSelectorDetected */)  // if a ?part=, don't do BS.
+              {
+                // OK, we're doing bodystructure
+
+                // Before fetching the bodystructure, let's check our body shell cache to see if
+                // we already have it around.
+                RefPtr<nsIMAPBodyShell> foundShell;
+                IMAP_ContentModifiedType modType = GetShowAttachmentsInline() ?
+                  IMAP_CONTENT_MODIFIED_VIEW_INLINE :
+                  IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS ;
+
+                bool wasStoringMsgOffline;
+                m_runningUrl->GetStoreResultsOffline(&wasStoringMsgOffline);
+                m_runningUrl->SetStoreOfflineOnFallback(wasStoringMsgOffline);
+                m_runningUrl->SetStoreResultsOffline(false);
+                SetContentModified(modType);  // This will be looked at by the cache
+                if (bMessageIdsAreUids)
+                {
+                  res = m_hostSessionList->FindShellInCacheForHost(GetImapServerKey(),
+                    GetServerStateParser().GetSelectedMailboxName(),
+                    messageIdString.get(), modType, getter_AddRefs(foundShell));
+                  if (foundShell)
+                  {
+                    Log("SHELL",NULL,"Loading message, using cached shell.");
+                    //MOZ_LOG(IMAP, out, ("BODYSHELL: Loading message, using cached shell."));
+                    foundShell->SetConnection(this);
+                    GetServerStateParser().UseCachedShell(foundShell);
+                    //Set the current uid in server state parser (in case it was used for new mail msgs earlier).
+                    GetServerStateParser().SetCurrentResponseUID(strtoul(messageIdString.get(), nullptr, 10));
+                    foundShell->Generate(NULL);
+                    GetServerStateParser().UseCachedShell(NULL);
+                  }
+                }
+
+                if (!foundShell)
+                  Bodystructure(messageIdString, bMessageIdsAreUids);
+              }
+              else
+              {
+                // Not doing bodystructure.  Fetch the whole thing, and try to do
+                // it in chunks.
+                SetContentModified(IMAP_CONTENT_NOT_MODIFIED);
+                FetchTryChunking(messageIdString, whatToFetch,
+                  bMessageIdsAreUids, NULL, messageSize, true);
+              }
+            }
+            if (GetServerStateParser().LastCommandSuccessful()
+                && m_imapAction != nsIImapUrl::nsImapMsgPreview
+                && m_imapAction != nsIImapUrl::nsImapMsgFetchPeek)
+            {
+              uint32_t uid = strtoul(messageIdString.get(), nullptr, 10);
+              int32_t index;
+              bool foundIt;
+              imapMessageFlagsType flags = m_flagState->GetMessageFlagsFromUID(uid, &foundIt, &index);
+              if (foundIt)
+              {
+                flags |= kImapMsgSeenFlag;
+                m_flagState->SetMessageFlags(index, flags);
+              }
+            }
+          }
+        }
+        break;
+      case nsIImapUrl::nsImapExpungeFolder:
+        Expunge();
+        // note fall through to next cases.
+        MOZ_FALLTHROUGH;
+      case nsIImapUrl::nsImapSelectFolder:
+      case nsIImapUrl::nsImapSelectNoopFolder:
+        if (!moreHeadersToDownload)
+          ProcessMailboxUpdate(true);
+        break;
+      case nsIImapUrl::nsImapMsgHeader:
+        {
+          nsCString messageIds;
+          m_runningUrl->GetListOfMessageIds(messageIds);
+
+          FetchMessage(messageIds,
+            kHeadersRFC822andUid);
+          // if we explicitly ask for headers, as opposed to getting them as a result
+          // of selecting the folder, or biff, send the headerFetchCompleted notification
+          // to flush out the header cache.
+          HeaderFetchCompleted();
+        }
+        break;
+      case nsIImapUrl::nsImapSearch:
+        {
+          nsAutoCString searchCriteriaString;
+          m_runningUrl->CreateSearchCriteriaString(getter_Copies(searchCriteriaString));
+          Search(searchCriteriaString.get(), bMessageIdsAreUids);
+          // drop the results on the floor for now
+        }
+        break;
+      case nsIImapUrl::nsImapUserDefinedMsgCommand:
+        {
+          nsCString messageIdString;
+          nsCString command;
+
+          m_runningUrl->GetCommand(command);
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+          IssueUserDefinedMsgCommand(command.get(), messageIdString.get());
+        }
+        break;
+      case nsIImapUrl::nsImapUserDefinedFetchAttribute:
+        {
+          nsCString messageIdString;
+          nsCString attribute;
+
+          m_runningUrl->GetCustomAttributeToFetch(attribute);
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+          FetchMsgAttribute(messageIdString, attribute);
+        }
+        break;
+      case nsIImapUrl::nsImapMsgStoreCustomKeywords:
+        {
+          // if the server doesn't support user defined flags, don't try to set them.
+          uint16_t userFlags;
+          GetSupportedUserFlags(&userFlags);
+          if (! (userFlags & kImapMsgSupportUserFlag))
+            break;
+          nsCString messageIdString;
+          nsCString addFlags;
+          nsCString subtractFlags;
+
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+          m_runningUrl->GetCustomAddFlags(addFlags);
+          m_runningUrl->GetCustomSubtractFlags(subtractFlags);
+          if (!addFlags.IsEmpty())
+          {
+            nsAutoCString storeString("+FLAGS (");
+            storeString.Append(addFlags);
+            storeString.Append(")");
+            Store(messageIdString, storeString.get(), true);
+          }
+          if (!subtractFlags.IsEmpty())
+          {
+            nsAutoCString storeString("-FLAGS (");
+            storeString.Append(subtractFlags);
+            storeString.Append(")");
+            Store(messageIdString, storeString.get(), true);
+          }
+        }
+        break;
+      case nsIImapUrl::nsImapDeleteMsg:
+        {
+          nsCString messageIdString;
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+
+          ProgressEventFunctionUsingName(HandlingMultipleMessages(messageIdString) ?
+                                         "imapDeletingMessages" :
+                                         "imapDeletingMessage");
+
+          Store(messageIdString, "+FLAGS (\\Deleted)",  bMessageIdsAreUids);
+
+          if (GetServerStateParser().LastCommandSuccessful())
+          {
+            //delete_message_struct *deleteMsg = (delete_message_struct *) PR_Malloc (sizeof(delete_message_struct));
+            // convert name back from utf7
+            nsCString canonicalName;
+            const char *selectedMailboxName = GetServerStateParser().GetSelectedMailboxName();
+            if (selectedMailboxName)
+            {
+              m_runningUrl->AllocateCanonicalPath(selectedMailboxName,
+                kOnlineHierarchySeparatorUnknown, getter_Copies(canonicalName));
+            }
+
+            if (m_imapMessageSink)
+              m_imapMessageSink->NotifyMessageDeleted(canonicalName.get(), false, messageIdString.get());
+            // notice we don't wait for this to finish...
+          }
+          else
+            HandleMemoryFailure();
+        }
+        break;
+      case nsIImapUrl::nsImapDeleteFolderAndMsgs:
+        DeleteFolderAndMsgs(mailboxName.get());
+        break;
+      case nsIImapUrl::nsImapDeleteAllMsgs:
+        {
+          uint32_t numberOfMessages = GetServerStateParser().NumberOfMessages();
+          if (numberOfMessages)
+          {
+            Store(NS_LITERAL_CSTRING("1:*"), "+FLAGS.SILENT (\\Deleted)",
+              false);  // use sequence #'s
+
+            if (GetServerStateParser().LastCommandSuccessful())
+              Expunge();      // expunge messages with deleted flag
+            if (GetServerStateParser().LastCommandSuccessful())
+            {
+              // convert name back from utf7
+              nsCString canonicalName;
+              const char *selectedMailboxName = GetServerStateParser().GetSelectedMailboxName();
+              if (selectedMailboxName )
+              {
+                m_runningUrl->AllocateCanonicalPath(selectedMailboxName,
+                  kOnlineHierarchySeparatorUnknown, getter_Copies(canonicalName));
+              }
+
+              if (m_imapMessageSink)
+                m_imapMessageSink->NotifyMessageDeleted(canonicalName.get(), true, nullptr);
+            }
+
+          }
+          bool deleteSelf = false;
+          DeleteSubFolders(mailboxName.get(), deleteSelf);	// don't delete self
+        }
+        break;
+      case nsIImapUrl::nsImapAppendDraftFromFile:
+        {
+          OnAppendMsgFromFile();
+        }
+        break;
+      case nsIImapUrl::nsImapAddMsgFlags:
+        {
+          nsCString messageIdString;
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+
+          ProcessStoreFlags(messageIdString, bMessageIdsAreUids,
+            msgFlags, true);
+        }
+        break;
+      case nsIImapUrl::nsImapSubtractMsgFlags:
+        {
+          nsCString messageIdString;
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+
+          ProcessStoreFlags(messageIdString, bMessageIdsAreUids,
+            msgFlags, false);
+        }
+        break;
+      case nsIImapUrl::nsImapSetMsgFlags:
+        {
+          nsCString messageIdString;
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+
+          ProcessStoreFlags(messageIdString, bMessageIdsAreUids,
+            msgFlags, true);
+          ProcessStoreFlags(messageIdString, bMessageIdsAreUids,
+            ~msgFlags, false);
+        }
+        break;
+      case nsIImapUrl::nsImapBiff:
+        PeriodicBiff();
+        break;
+      case nsIImapUrl::nsImapOnlineCopy:
+      case nsIImapUrl::nsImapOnlineMove:
+        {
+          nsCString messageIdString;
+          m_runningUrl->GetListOfMessageIds(messageIdString);
+          char *destinationMailbox = OnCreateServerDestinationFolderPathString();
+
+          if (destinationMailbox)
+          {
+            if (m_imapAction == nsIImapUrl::nsImapOnlineMove)
+            {
+              if (HandlingMultipleMessages(messageIdString))
+                ProgressEventFunctionUsingNameWithString("imapMovingMessages", destinationMailbox);
+              else
+                ProgressEventFunctionUsingNameWithString("imapMovingMessage", destinationMailbox);
+            }
+            else {
+              if (HandlingMultipleMessages(messageIdString))
+                ProgressEventFunctionUsingNameWithString("imapCopyingMessages", destinationMailbox);
+              else
+                ProgressEventFunctionUsingNameWithString("imapCopyingMessage", destinationMailbox);
+            }
+            Copy(messageIdString.get(), destinationMailbox, bMessageIdsAreUids);
+            PR_FREEIF( destinationMailbox);
+            ImapOnlineCopyState copyState;
+            if (DeathSignalReceived())
+              copyState = ImapOnlineCopyStateType::kInterruptedState;
+            else
+              copyState = GetServerStateParser().LastCommandSuccessful() ?
+              (ImapOnlineCopyState) ImapOnlineCopyStateType::kSuccessfulCopy :
+            (ImapOnlineCopyState) ImapOnlineCopyStateType::kFailedCopy;
+            if (m_imapMailFolderSink)
+              m_imapMailFolderSink->OnlineCopyCompleted(this, copyState);
+            // Don't mark message 'Deleted' for AOL servers or standard imap servers
+            // that support MOVE since we already issued an 'xaol-move' or 'move' command.
+            if (GetServerStateParser().LastCommandSuccessful() &&
+              (m_imapAction == nsIImapUrl::nsImapOnlineMove) &&
+              !(GetServerStateParser().ServerIsAOLServer() ||
+                GetServerStateParser().GetCapabilityFlag() & kHasMoveCapability))
+            {
+              // Simulate MOVE for servers that don't support MOVE: do COPY-DELETE-EXPUNGE.
+              Store(messageIdString, "+FLAGS (\\Deleted \\Seen)",
+                bMessageIdsAreUids);
+              bool storeSuccessful = GetServerStateParser().LastCommandSuccessful();
+              if (storeSuccessful)
+              {
+                if(gExpungeAfterDelete)
+                {
+                  // This will expunge all emails marked as deleted in mailbox,
+                  // not just the ones marked as deleted above.
+                  Expunge();
+                }
+                else
+                {
+                  // Check if UIDPLUS capable so we can just expunge emails we just
+                  // copied and marked as deleted. This prevents expunging emails
+                  // that other clients may have marked as deleted in the mailbox
+                  // and don't want them to disappear.
+                  // Only do UidExpunge() when user selected delete method is "Move
+                  // it to this folder" or "Remove it immediately", not when the
+                  // delete method is "Just mark it as deleted".
+                  if (!GetShowDeletedMessages() &&
+                      (GetServerStateParser().GetCapabilityFlag() & kUidplusCapability))
+                  {
+                    UidExpunge(messageIdString);
+                  }
+                }
+              }
+              if (m_imapMailFolderSink)
+              {
+                copyState = storeSuccessful ? (ImapOnlineCopyState) ImapOnlineCopyStateType::kSuccessfulDelete
+                  : (ImapOnlineCopyState) ImapOnlineCopyStateType::kFailedDelete;
+                m_imapMailFolderSink->OnlineCopyCompleted(this, copyState);
+              }
+            }
+          }
+          else
+            HandleMemoryFailure();
+        }
+        break;
+      case nsIImapUrl::nsImapOnlineToOfflineCopy:
+      case nsIImapUrl::nsImapOnlineToOfflineMove:
+        {
+          nsCString messageIdString;
+          nsresult rv = m_runningUrl->GetListOfMessageIds(messageIdString);
+          if (NS_SUCCEEDED(rv))
+          {
+            SetProgressString("imapFolderReceivingMessageOf2");
+            m_progressIndex = 0;
+            m_progressCount = CountMessagesInIdString(messageIdString.get());
+
+            FetchMessage(messageIdString, kEveryThingRFC822Peek);
+
+            SetProgressString(nullptr);
+            if (m_imapMailFolderSink)
+            {
+              ImapOnlineCopyState copyStatus;
+              copyStatus = GetServerStateParser().LastCommandSuccessful() ?
+                ImapOnlineCopyStateType::kSuccessfulCopy : ImapOnlineCopyStateType::kFailedCopy;
+
+              m_imapMailFolderSink->OnlineCopyCompleted(this, copyStatus);
+              if (GetServerStateParser().LastCommandSuccessful() &&
+                (m_imapAction == nsIImapUrl::nsImapOnlineToOfflineMove))
+              {
+                Store(messageIdString, "+FLAGS (\\Deleted \\Seen)",bMessageIdsAreUids);
+                if (GetServerStateParser().LastCommandSuccessful())
+                {
+                  copyStatus = ImapOnlineCopyStateType::kSuccessfulDelete;
+                  if (gExpungeAfterDelete)
+                    Expunge();
+                }
+                else
+                  copyStatus = ImapOnlineCopyStateType::kFailedDelete;
+
+                m_imapMailFolderSink->OnlineCopyCompleted(this,  copyStatus);
+              }
+            }
+          }
+          else
+            HandleMemoryFailure();
+        }
+        break;
+      default:
+        if (GetServerStateParser().LastCommandSuccessful() && !uidValidityOk)
+          ProcessMailboxUpdate(false); // handle uidvalidity change
+        break;
+    }
+   }
+  }
+  else if (!DeathSignalReceived())
+    HandleMemoryFailure();
+}
+
+nsresult nsImapProtocol::BeginMessageDownLoad(
+                                              uint32_t total_message_size, // for user, headers and body
+                                              const char *content_type)
+{
+  nsresult rv = NS_OK;
+  char *sizeString = PR_smprintf("OPEN Size: %ld", total_message_size);
+  Log("STREAM",sizeString,"Begin Message Download Stream");
+  PR_Free(sizeString);
+  // start counting how many bytes we see in this message after all transformations
+  m_bytesToChannel = 0;
+
+  if (content_type)
+  {
+    m_fromHeaderSeen = false;
+    if (GetServerStateParser().GetDownloadingHeaders())
+    {
+      // if we get multiple calls to BeginMessageDownload w/o intervening
+      // calls to NormalEndMessageDownload or Abort, then we're just
+      // going to fake a NormalMessageEndDownload. This will most likely
+      // cause an empty header to get written to the db, and the user
+      // will have to delete the empty header themselves, which
+      // should remove the message from the server as well.
+      if (m_curHdrInfo)
+        NormalMessageEndDownload();
+      if (!m_curHdrInfo)
+        m_curHdrInfo = m_hdrDownloadCache->StartNewHdr();
+      if (m_curHdrInfo)
+        m_curHdrInfo->SetMsgSize(total_message_size);
+      return NS_OK;
+    }
+    // if we have a mock channel, that means we have a channel listener who wants the
+    // message. So set up a pipe. We'll write the messsage into one end of the pipe
+    // and they will read it out of the other end.
+    else if (m_channelListener)
+    {
+      // create a pipe to pump the message into...the output will go to whoever
+      // is consuming the message display
+      // we create an "infinite" pipe in case we get extremely long lines from the imap server,
+      // and the consumer is waiting for a whole line
+      nsCOMPtr<nsIPipe> pipe = do_CreateInstance("@mozilla.org/pipe;1");
+      rv = pipe->Init(false, false, 4096, PR_UINT32_MAX);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // These always succeed because the pipe is initialized above.
+      MOZ_ALWAYS_SUCCEEDS(pipe->GetInputStream(getter_AddRefs(m_channelInputStream)));
+      MOZ_ALWAYS_SUCCEEDS(pipe->GetOutputStream(getter_AddRefs(m_channelOutputStream)));
+    }
+    // else, if we are saving the message to disk!
+    else if (m_imapMessageSink /* && m_imapAction == nsIImapUrl::nsImapSaveMessageToDisk */)
+    {
+      // we get here when download the inbox for offline use
+      nsCOMPtr<nsIFile> file;
+      bool addDummyEnvelope = true;
+      nsCOMPtr<nsIMsgMessageUrl> msgurl = do_QueryInterface(m_runningUrl);
+      msgurl->GetMessageFile(getter_AddRefs(file));
+      msgurl->GetAddDummyEnvelope(&addDummyEnvelope);
+      if (file)
+        rv = m_imapMessageSink->SetupMsgWriteStream(file, addDummyEnvelope);
+    }
+    if (m_imapMailFolderSink && m_runningUrl)
+    {
+      nsCOMPtr <nsISupports> copyState;
+      if (m_runningUrl)
+      {
+        m_runningUrl->GetCopyState(getter_AddRefs(copyState));
+        if (copyState) // only need this notification during copy
+        {
+          nsCOMPtr<nsIMsgMailNewsUrl> mailurl = do_QueryInterface(m_runningUrl);
+          m_imapMailFolderSink->StartMessage(mailurl);
+        }
+      }
+    }
+
+  }
+  else
+    HandleMemoryFailure();
+  return rv;
+}
+
+void
+nsImapProtocol::GetShouldDownloadAllHeaders(bool *aResult)
+{
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->GetShouldDownloadAllHeaders(aResult);
+}
+
+void
+nsImapProtocol::GetArbitraryHeadersToDownload(nsCString &aResult)
+{
+  if (m_imapServerSink)
+    m_imapServerSink->GetArbitraryHeaders(aResult);
+}
+
+void
+nsImapProtocol::AdjustChunkSize()
+{
+  int32_t deltaInSeconds;
+  PRTime2Seconds(m_endTime - m_startTime, &deltaInSeconds);
+  m_trackingTime = false;
+  if (deltaInSeconds < 0)
+    return;            // bogus for some reason
+
+  if (deltaInSeconds <= m_tooFastTime && m_curFetchSize >= m_chunkSize)
+  {
+    m_chunkSize += m_chunkAddSize;
+    m_chunkThreshold = m_chunkSize + (m_chunkSize / 2);
+    // we used to have a max for the chunk size - I don't think that's needed.
+  }
+  else if (deltaInSeconds <= m_idealTime)
+    return;
+  else
+  {
+    if (m_chunkSize > m_chunkStartSize)
+      m_chunkSize = m_chunkStartSize;
+    else if (m_chunkSize > (m_chunkAddSize * 2))
+      m_chunkSize -= m_chunkAddSize;
+    m_chunkThreshold = m_chunkSize + (m_chunkSize / 2);
+  }
+  // remember these new values globally so new connections
+  // can take advantage of them.
+  if (gChunkSize != m_chunkSize)
+  {
+    // will cause chunk size pref to be written in CloseStream.
+    gChunkSizeDirty = true;
+    gChunkSize = m_chunkSize;
+    gChunkThreshold = m_chunkThreshold;
+  }
+}
+
+// authenticated state commands
+
+// escape any backslashes or quotes.  Backslashes are used a lot with our NT server
+void nsImapProtocol::CreateEscapedMailboxName(const char *rawName, nsCString &escapedName)
+{
+  escapedName.Assign(rawName);
+
+  for (int32_t strIndex = 0; *rawName; strIndex++)
+  {
+    char currentChar = *rawName++;
+    if ((currentChar == '\\') || (currentChar == '\"'))
+      escapedName.Insert('\\', strIndex++);
+  }
+}
+void nsImapProtocol::SelectMailbox(const char *mailboxName)
+{
+  ProgressEventFunctionUsingNameWithString("imapStatusSelectingMailbox", mailboxName);
+  IncrementCommandTagNumber();
+
+  m_closeNeededBeforeSelect = false;   // initial value
+  GetServerStateParser().ResetFlagInfo();
+  nsCString escapedName;
+  CreateEscapedMailboxName(mailboxName, escapedName);
+  nsCString commandBuffer(GetServerCommandTag());
+  commandBuffer.Append(" select \"");
+  commandBuffer.Append(escapedName.get());
+  commandBuffer.Append("\"");
+  if (UseCondStore())
+    commandBuffer.Append(" (CONDSTORE)");
+  commandBuffer.Append(CRLF);
+
+  nsresult res;
+  res = SendData(commandBuffer.get());
+  if (NS_FAILED(res)) return;
+  ParseIMAPandCheckForNewMail();
+
+  int32_t numOfMessagesInFlagState = 0;
+  nsImapAction imapAction;
+  m_flagState->GetNumberOfMessages(&numOfMessagesInFlagState);
+  res = m_runningUrl->GetImapAction(&imapAction);
+  // if we've selected a mailbox, and we're not going to do an update because of the
+  // url type, but don't have the flags, go get them!
+  if (GetServerStateParser().LastCommandSuccessful() && NS_SUCCEEDED(res) &&
+    imapAction != nsIImapUrl::nsImapSelectFolder && imapAction != nsIImapUrl::nsImapExpungeFolder
+    && imapAction != nsIImapUrl::nsImapLiteSelectFolder &&
+    imapAction != nsIImapUrl::nsImapDeleteAllMsgs &&
+    ((GetServerStateParser().NumberOfMessages() != numOfMessagesInFlagState) && (numOfMessagesInFlagState == 0)))
+  {
+      ProcessMailboxUpdate(false);
+  }
+}
+
+// Please call only with a single message ID
+void nsImapProtocol::Bodystructure(const nsCString &messageId, bool idIsUid)
+{
+  IncrementCommandTagNumber();
+
+  nsCString commandString(GetServerCommandTag());
+  if (idIsUid)
+    commandString.Append(" UID");
+  commandString.Append(" fetch ");
+
+  commandString.Append(messageId);
+  commandString.Append(" (BODYSTRUCTURE)" CRLF);
+
+  nsresult rv = SendData(commandString.get());
+  if (NS_SUCCEEDED(rv))
+      ParseIMAPandCheckForNewMail(commandString.get());
+}
+
+void nsImapProtocol::PipelinedFetchMessageParts(const char *uid, nsIMAPMessagePartIDArray *parts)
+{
+  // assumes no chunking
+
+  // build up a string to fetch
+  nsCString stringToFetch, what;
+  uint32_t currentPartNum = 0;
+  while ((parts->GetNumParts() > currentPartNum) && !DeathSignalReceived())
+  {
+    nsIMAPMessagePartID *currentPart = parts->GetPart(currentPartNum);
+    if (currentPart)
+    {
+      // Do things here depending on the type of message part
+      // Append it to the fetch string
+      if (currentPartNum > 0)
+        stringToFetch.Append(" ");
+
+      switch (currentPart->GetFields())
+      {
+      case kMIMEHeader:
+        what = "BODY.PEEK[";
+        what.Append(currentPart->GetPartNumberString());
+        what.Append(".MIME]");
+        stringToFetch.Append(what);
+        break;
+      case kRFC822HeadersOnly:
+        if (currentPart->GetPartNumberString())
+        {
+          what = "BODY.PEEK[";
+          what.Append(currentPart->GetPartNumberString());
+          what.Append(".HEADER]");
+          stringToFetch.Append(what);
+        }
+        else
+        {
+          // headers for the top-level message
+          stringToFetch.Append("BODY.PEEK[HEADER]");
+        }
+        break;
+      default:
+        NS_ASSERTION(false, "we should only be pipelining MIME headers and Message headers");
+        break;
+      }
+
+    }
+    currentPartNum++;
+  }
+
+  // Run the single, pipelined fetch command
+  if ((parts->GetNumParts() > 0) && !DeathSignalReceived() && !GetPseudoInterrupted() && stringToFetch.get())
+  {
+      IncrementCommandTagNumber();
+
+    nsCString commandString(GetServerCommandTag());
+    commandString.Append(" UID fetch ");
+    commandString.Append(uid, 10);
+    commandString.Append(" (");
+    commandString.Append(stringToFetch);
+    commandString.Append(")" CRLF);
+    nsresult rv = SendData(commandString.get());
+        if (NS_SUCCEEDED(rv))
+            ParseIMAPandCheckForNewMail(commandString.get());
+  }
+}
+
+
+void nsImapProtocol::FetchMsgAttribute(const nsCString &messageIds, const nsCString &attribute)
+{
+    IncrementCommandTagNumber();
+
+    nsAutoCString commandString (GetServerCommandTag());
+    commandString.Append(" UID fetch ");
+    commandString.Append(messageIds);
+    commandString.Append(" (");
+    commandString.Append(attribute);
+    commandString.Append(")" CRLF);
+    nsresult rv = SendData(commandString.get());
+
+    if (NS_SUCCEEDED(rv))
+       ParseIMAPandCheckForNewMail(commandString.get());
+    GetServerStateParser().SetFetchingFlags(false);
+    // Always clear this flag after every fetch.
+    m_fetchingWholeMessage = false;
+}
+
+// this routine is used to fetch a message or messages, or headers for a
+// message...
+
+void nsImapProtocol::FallbackToFetchWholeMsg(const nsCString &messageId, uint32_t messageSize)
+{
+  if (m_imapMessageSink && m_runningUrl)
+  {
+    bool shouldStoreMsgOffline;
+    m_runningUrl->GetStoreOfflineOnFallback(&shouldStoreMsgOffline);
+    m_runningUrl->SetStoreResultsOffline(shouldStoreMsgOffline);
+  }
+  FetchTryChunking(messageId,
+                   m_imapAction == nsIImapUrl::nsImapMsgFetchPeek ?
+                     kEveryThingRFC822Peek : kEveryThingRFC822,
+                   true, nullptr, messageSize, true);
+}
+
+void
+nsImapProtocol::FetchMessage(const nsCString &messageIds,
+                             nsIMAPeFetchFields whatToFetch,
+                             const char *fetchModifier,
+                             uint32_t startByte, uint32_t numBytes,
+                             char *part)
+{
+  IncrementCommandTagNumber();
+
+  nsCString commandString;
+  commandString = "%s UID fetch";
+
+  switch (whatToFetch) {
+  case kEveryThingRFC822:
+    m_flagChangeCount++;
+    m_fetchingWholeMessage = true;
+    if (m_trackingTime)
+      AdjustChunkSize();      // we started another segment
+    m_startTime = PR_Now();     // save start of download time
+    m_trackingTime = true;
+    MOZ_LOG(IMAP, LogLevel::Debug, ("FetchMessage everything: curFetchSize %u numBytes %u",
+                                m_curFetchSize, numBytes));
+    if (numBytes > 0)
+      m_curFetchSize = numBytes;
+
+    if (GetServerStateParser().ServerHasIMAP4Rev1Capability())
+    {
+      if (GetServerStateParser().GetCapabilityFlag() & kHasXSenderCapability)
+        commandString.Append(" %s (XSENDER UID RFC822.SIZE BODY[]");
+      else
+        commandString.Append(" %s (UID RFC822.SIZE BODY[]");
+    }
+    else
+    {
+      if (GetServerStateParser().GetCapabilityFlag() & kHasXSenderCapability)
+        commandString.Append(" %s (XSENDER UID RFC822.SIZE RFC822");
+      else
+        commandString.Append(" %s (UID RFC822.SIZE RFC822");
+    }
+    if (numBytes > 0)
+    {
+      // if we are retrieving chunks
+      char *byterangeString = PR_smprintf("<%ld.%ld>",startByte, numBytes);
+      if (byterangeString)
+      {
+        commandString.Append(byterangeString);
+        PR_Free(byterangeString);
+      }
+    }
+    commandString.Append(")");
+
+    break;
+
+  case kEveryThingRFC822Peek:
+    {
+      MOZ_LOG(IMAP, LogLevel::Debug, ("FetchMessage peek: curFetchSize %u numBytes %u",
+                                  m_curFetchSize, numBytes));
+      if (numBytes > 0)
+        m_curFetchSize = numBytes;
+      const char *formatString = "";
+      eIMAPCapabilityFlags server_capabilityFlags = GetServerStateParser().GetCapabilityFlag();
+
+      m_fetchingWholeMessage = true;
+      if (server_capabilityFlags & kIMAP4rev1Capability)
+      {
+        // use body[].peek since rfc822.peek is not in IMAP4rev1
+        if (server_capabilityFlags & kHasXSenderCapability)
+          formatString = " %s (XSENDER UID RFC822.SIZE BODY.PEEK[]";
+        else
+          formatString = " %s (UID RFC822.SIZE BODY.PEEK[]";
+      }
+      else
+      {
+        if (server_capabilityFlags & kHasXSenderCapability)
+          formatString = " %s (XSENDER UID RFC822.SIZE RFC822.peek";
+        else
+          formatString = " %s (UID RFC822.SIZE RFC822.peek";
+      }
+
+      commandString.Append(formatString);
+      if (numBytes > 0)
+      {
+        // if we are retrieving chunks
+        char *byterangeString = PR_smprintf("<%ld.%ld>",startByte, numBytes);
+        if (byterangeString)
+        {
+          commandString.Append(byterangeString);
+          PR_Free(byterangeString);
+        }
+      }
+      commandString.Append(")");
+    }
+    break;
+  case kHeadersRFC822andUid:
+    if (GetServerStateParser().ServerHasIMAP4Rev1Capability())
+    {
+      eIMAPCapabilityFlags server_capabilityFlags = GetServerStateParser().GetCapabilityFlag();
+      bool aolImapServer = ((server_capabilityFlags & kAOLImapCapability) != 0);
+      bool downloadAllHeaders = false;
+      // checks if we're filtering on "any header" or running a spam filter requiring all headers
+      GetShouldDownloadAllHeaders(&downloadAllHeaders);
+
+      if (!downloadAllHeaders)  // if it's ok -- no filters on any header, etc.
+      {
+        char *headersToDL = nullptr;
+        char *what = nullptr;
+        const char *dbHeaders = (gUseEnvelopeCmd) ? IMAP_DB_HEADERS : IMAP_ENV_AND_DB_HEADERS;
+        nsCString arbitraryHeaders;
+        GetArbitraryHeadersToDownload(arbitraryHeaders);
+        for (uint32_t i = 0; i < mCustomDBHeaders.Length(); i++)
+        {
+          if (arbitraryHeaders.Find(mCustomDBHeaders[i], CaseInsensitiveCompare) == kNotFound)
+          {
+            if (!arbitraryHeaders.IsEmpty())
+              arbitraryHeaders.Append(' ');
+            arbitraryHeaders.Append(mCustomDBHeaders[i]);
+          }
+        }
+        for (uint32_t i = 0; i < mCustomHeaders.Length(); i++)
+        {
+           if (arbitraryHeaders.Find(mCustomHeaders[i], CaseInsensitiveCompare) == kNotFound)
+          {
+            if (!arbitraryHeaders.IsEmpty())
+              arbitraryHeaders.Append(' ');
+            arbitraryHeaders.Append(mCustomHeaders[i]);
+          }
+        }
+        if (arbitraryHeaders.IsEmpty())
+          headersToDL = strdup(dbHeaders);
+        else
+          headersToDL = PR_smprintf("%s %s",dbHeaders, arbitraryHeaders.get());
+
+        if (gUseEnvelopeCmd)
+          what = PR_smprintf(" ENVELOPE BODY.PEEK[HEADER.FIELDS (%s)])", headersToDL);
+        else
+          what = PR_smprintf(" BODY.PEEK[HEADER.FIELDS (%s)])",headersToDL);
+        NS_Free(headersToDL);
+        if (what)
+        {
+          commandString.Append(" %s (UID ");
+           if (m_isGmailServer)
+            commandString.Append("X-GM-MSGID X-GM-THRID X-GM-LABELS ");
+          if (aolImapServer)
+            commandString.Append(" XAOL.SIZE") ;
+          else
+            commandString.Append("RFC822.SIZE");
+          commandString.Append(" FLAGS");
+          commandString.Append(what);
+          PR_Free(what);
+        }
+        else
+        {
+          commandString.Append(" %s (UID RFC822.SIZE BODY.PEEK[HEADER] FLAGS)");
+        }
+      }
+      else
+        commandString.Append(" %s (UID RFC822.SIZE BODY.PEEK[HEADER] FLAGS)");
+    }
+    else
+      commandString.Append(" %s (UID RFC822.SIZE RFC822.HEADER FLAGS)");
+    break;
+  case kUid:
+    commandString.Append(" %s (UID)");
+    break;
+  case kFlags:
+    GetServerStateParser().SetFetchingFlags(true);
+    commandString.Append(" %s (FLAGS)");
+    break;
+  case kRFC822Size:
+    commandString.Append(" %s (RFC822.SIZE)");
+    break;
+  case kBodyStart:
+    {
+      int32_t numBytesToFetch;
+      m_runningUrl->GetNumBytesToFetch(&numBytesToFetch);
+
+      commandString.Append(" %s (UID BODY.PEEK[HEADER.FIELDS (Content-Type Content-Transfer-Encoding)] BODY.PEEK[TEXT]<0.");
+      commandString.AppendInt(numBytesToFetch);
+      commandString.Append(">)");
+    }
+    break;
+  case kRFC822HeadersOnly:
+    if (GetServerStateParser().ServerHasIMAP4Rev1Capability())
+    {
+      if (part)
+      {
+        commandString.Append(" %s (BODY[");
+        char *what = PR_smprintf("%s.HEADER])", part);
+        if (what)
+        {
+          commandString.Append(what);
+          PR_Free(what);
+        }
+        else
+          HandleMemoryFailure();
+      }
+      else
+      {
+        // headers for the top-level message
+        commandString.Append(" %s (BODY[HEADER])");
+      }
+    }
+    else
+      commandString.Append(" %s (RFC822.HEADER)");
+    break;
+  case kMIMEPart:
+    commandString.Append(" %s (BODY.PEEK[%s]");
+    if (numBytes > 0)
+    {
+      // if we are retrieving chunks
+      char *byterangeString = PR_smprintf("<%ld.%ld>",startByte, numBytes);
+      if (byterangeString)
+      {
+        commandString.Append(byterangeString);
+        PR_Free(byterangeString);
+      }
+    }
+    commandString.Append(")");
+    break;
+  case kMIMEHeader:
+    commandString.Append(" %s (BODY[%s.MIME])");
+    break;
+  };
+
+  if (fetchModifier)
+    commandString.Append(fetchModifier);
+
+  commandString.Append(CRLF);
+
+  // since messageIds can be infinitely long, use a dynamic buffer rather than the fixed one
+  const char *commandTag = GetServerCommandTag();
+  int protocolStringSize = commandString.Length() + messageIds.Length() + PL_strlen(commandTag) + 1 +
+    (part ? PL_strlen(part) : 0);
+  char *protocolString = (char *) PR_CALLOC( protocolStringSize );
+
+  if (protocolString)
+  {
+    char *cCommandStr = ToNewCString(commandString);
+    if ((whatToFetch == kMIMEPart) ||
+      (whatToFetch == kMIMEHeader))
+    {
+      PR_snprintf(protocolString,                                      // string to create
+        protocolStringSize,                                      // max size
+        cCommandStr,                                   // format string
+        commandTag,                          // command tag
+        messageIds.get(),
+        part);
+    }
+    else
+    {
+      PR_snprintf(protocolString,                                      // string to create
+        protocolStringSize,                                      // max size
+        cCommandStr,                                   // format string
+        commandTag,                          // command tag
+        messageIds.get());
+    }
+
+    nsresult rv = SendData(protocolString);
+
+    free(cCommandStr);
+    if (NS_SUCCEEDED(rv))
+      ParseIMAPandCheckForNewMail(protocolString);
+    PR_Free(protocolString);
+    GetServerStateParser().SetFetchingFlags(false);
+    // Always clear this flag after every fetch.
+    m_fetchingWholeMessage = false;
+    if (GetServerStateParser().LastCommandSuccessful() && CheckNeeded())
+      Check();
+  }
+  else
+    HandleMemoryFailure();
+}
+
+void nsImapProtocol::FetchTryChunking(const nsCString &messageIds,
+                                      nsIMAPeFetchFields whatToFetch,
+                                      bool idIsUid,
+                                      char *part,
+                                      uint32_t downloadSize,
+                                      bool tryChunking)
+{
+  GetServerStateParser().SetTotalDownloadSize(downloadSize);
+  MOZ_LOG(IMAP, LogLevel::Debug, ("FetchTryChunking: curFetchSize %u", downloadSize));
+  m_curFetchSize = downloadSize; // we'll change this if chunking.
+  if (m_fetchByChunks && tryChunking &&
+        GetServerStateParser().ServerHasIMAP4Rev1Capability() &&
+    (downloadSize > (uint32_t) m_chunkThreshold))
+  {
+    uint32_t startByte = 0;
+    m_curFetchSize = m_chunkSize;
+    GetServerStateParser().ClearLastFetchChunkReceived();
+    while (!DeathSignalReceived() && !GetPseudoInterrupted() &&
+      !GetServerStateParser().GetLastFetchChunkReceived() &&
+      GetServerStateParser().ContinueParse())
+    {
+      FetchMessage(messageIds,
+             whatToFetch,
+             nullptr,
+             startByte, m_chunkSize,
+             part);
+      startByte += m_chunkSize;
+    }
+
+    // Only abort the stream if this is a normal message download
+    // Otherwise, let the body shell abort the stream.
+    if ((whatToFetch == kEveryThingRFC822)
+      &&
+      ((startByte > 0 && (startByte < downloadSize) &&
+      (DeathSignalReceived() || GetPseudoInterrupted())) ||
+      !GetServerStateParser().ContinueParse()))
+    {
+      AbortMessageDownLoad();
+      PseudoInterrupt(false);
+    }
+  }
+  else
+  {
+    // small message, or (we're not chunking and not doing bodystructure),
+    // or the server is not rev1.
+    // Just fetch the whole thing.
+    FetchMessage(messageIds, whatToFetch, nullptr, 0, 0, part);
+  }
+}
+
+
+void nsImapProtocol::PipelinedFetchMessageParts(nsCString &uid, nsIMAPMessagePartIDArray *parts)
+{
+  // assumes no chunking
+
+  // build up a string to fetch
+  nsCString stringToFetch;
+  nsCString what;
+
+  uint32_t currentPartNum = 0;
+  while ((parts->GetNumParts() > currentPartNum) && !DeathSignalReceived())
+  {
+    nsIMAPMessagePartID *currentPart = parts->GetPart(currentPartNum);
+    if (currentPart)
+    {
+      // Do things here depending on the type of message part
+      // Append it to the fetch string
+      if (currentPartNum > 0)
+        stringToFetch += " ";
+
+      switch (currentPart->GetFields())
+      {
+      case kMIMEHeader:
+        what = "BODY.PEEK[";
+        what += currentPart->GetPartNumberString();
+        what += ".MIME]";
+        stringToFetch += what;
+        break;
+      case kRFC822HeadersOnly:
+        if (currentPart->GetPartNumberString())
+        {
+          what = "BODY.PEEK[";
+          what += currentPart->GetPartNumberString();
+          what += ".HEADER]";
+          stringToFetch += what;
+        }
+        else
+        {
+          // headers for the top-level message
+          stringToFetch += "BODY.PEEK[HEADER]";
+        }
+        break;
+      default:
+        NS_ASSERTION(false, "we should only be pipelining MIME headers and Message headers");
+        break;
+      }
+
+    }
+    currentPartNum++;
+  }
+
+  // Run the single, pipelined fetch command
+  if ((parts->GetNumParts() > 0) && !DeathSignalReceived() && !GetPseudoInterrupted() && stringToFetch.get())
+  {
+      IncrementCommandTagNumber();
+
+    char *commandString = PR_smprintf("%s UID fetch %s (%s)%s",
+                                          GetServerCommandTag(), uid.get(),
+                                          stringToFetch.get(), CRLF);
+
+    if (commandString)
+    {
+      nsresult rv = SendData(commandString);
+            if (NS_SUCCEEDED(rv))
+                ParseIMAPandCheckForNewMail(commandString);
+      PR_Free(commandString);
+    }
+    else
+      HandleMemoryFailure();
+  }
+}
+
+
+void
+nsImapProtocol::PostLineDownLoadEvent(const char *line, uint32_t uidOfMessage)
+{
+  if (!GetServerStateParser().GetDownloadingHeaders())
+  {
+    uint32_t byteCount = PL_strlen(line);
+    bool echoLineToMessageSink = false;
+    // if we have a channel listener, then just spool the message
+    // directly to the listener
+    if (m_channelListener)
+    {
+      uint32_t count = 0;
+      if (m_channelOutputStream)
+      {
+        nsresult rv = m_channelOutputStream->Write(line, byteCount, &count);
+        NS_ASSERTION(count == byteCount, "IMAP channel pipe couldn't buffer entire write");
+        if (NS_SUCCEEDED(rv))
+        {
+          nsCOMPtr<nsIRequest> request = do_QueryInterface(m_mockChannel);
+          m_channelListener->OnDataAvailable(request, m_channelContext, m_channelInputStream, 0, count);
+        }
+        // else some sort of explosion?
+      }
+    }
+    if (m_runningUrl)
+      m_runningUrl->GetStoreResultsOffline(&echoLineToMessageSink);
+
+    m_bytesToChannel += byteCount;
+    if (m_imapMessageSink && line && echoLineToMessageSink && !GetPseudoInterrupted())
+      m_imapMessageSink->ParseAdoptedMsgLine(line, uidOfMessage, m_runningUrl);
+  }
+  // ***** We need to handle the pseudo interrupt here *****
+}
+
+// Handle a line seen by the parser.
+// * The argument |lineCopy| must be nullptr or should contain the same string as
+//   |line|.  |lineCopy| will be modified.
+// * A line may be passed by parts, e.g., "part1 part2\r\n" may be passed as
+//     HandleMessageDownLoadLine("part 1 ", 1);
+//     HandleMessageDownLoadLine("part 2\r\n", 0);
+//   However, it is assumed that a CRLF or a CRCRLF is never split (i.e., this is
+//   ensured *before* invoking this method).
+void nsImapProtocol::HandleMessageDownLoadLine(const char *line, bool isPartialLine,
+                                               char *lineCopy)
+{
+  NS_PRECONDITION(lineCopy == nullptr || !PL_strcmp(line, lineCopy),
+                  "line and lineCopy must contain the same string");
+  const char *messageLine = line;
+  uint32_t lineLength = strlen(messageLine);
+  const char *cEndOfLine = messageLine + lineLength;
+  char *localMessageLine = nullptr;
+
+  // If we obtain a partial line (due to fetching by chunks), we do not
+  // add/modify the end-of-line terminator.
+  if (!isPartialLine)
+  {
+    // Change this line to native line termination, duplicate if necessary.
+    // Do not assume that the line really ends in CRLF
+    // to start with, even though it is supposed to be RFC822
+
+    // normalize line endings to CRLF unless we are saving the message to disk
+    bool canonicalLineEnding = true;
+    nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(m_runningUrl);
+
+    if (m_imapAction == nsIImapUrl::nsImapSaveMessageToDisk && msgUrl)
+      msgUrl->GetCanonicalLineEnding(&canonicalLineEnding);
+
+    NS_PRECONDITION(MSG_LINEBREAK_LEN == 1 ||
+                    (MSG_LINEBREAK_LEN == 2 && !PL_strcmp(CRLF, MSG_LINEBREAK)),
+                    "violated assumptions on MSG_LINEBREAK");
+    if (MSG_LINEBREAK_LEN == 1 && !canonicalLineEnding)
+    {
+      bool lineEndsWithCRorLF = lineLength >= 1 &&
+        (cEndOfLine[-1] == '\r' || cEndOfLine[-1] == '\n');
+      char *endOfLine;
+      if (lineCopy && lineEndsWithCRorLF)  // true for most lines
+      {
+        endOfLine = lineCopy + lineLength;
+        messageLine = lineCopy;
+      }
+      else
+      {
+        // leave enough room for one more char, MSG_LINEBREAK[0]
+        localMessageLine = (char *) PR_MALLOC(lineLength + 2);
+        if (!localMessageLine) // memory failure
+          return;
+        PL_strcpy(localMessageLine, line);
+        endOfLine = localMessageLine + lineLength;
+        messageLine = localMessageLine;
+      }
+
+      if (lineLength >= 2 &&
+        endOfLine[-2] == '\r' &&
+        endOfLine[-1] == '\n')
+      {
+        if(lineLength>=3 && endOfLine[-3] == '\r') // CRCRLF
+        {
+          endOfLine--;
+          lineLength--;
+        }
+        /* CRLF -> CR or LF */
+        endOfLine[-2] = MSG_LINEBREAK[0];
+        endOfLine[-1] = '\0';
+        lineLength--;
+      }
+      else if (lineLength >= 1 &&
+        ((endOfLine[-1] == '\r') || (endOfLine[-1] == '\n')))
+      {
+        /* CR -> LF or LF -> CR */
+        endOfLine[-1] = MSG_LINEBREAK[0];
+      }
+      else // no eol characters at all
+      {
+        endOfLine[0] = MSG_LINEBREAK[0]; // CR or LF
+        endOfLine[1] = '\0';
+        lineLength++;
+      }
+    }
+    else  // enforce canonical CRLF linebreaks
+    {
+      if (lineLength==0 || (lineLength == 1 && cEndOfLine[-1] == '\n'))
+      {
+        messageLine = CRLF;
+        lineLength = 2;
+      }
+      else if (cEndOfLine[-1] != '\n' || cEndOfLine[-2] != '\r' ||
+               (lineLength >=3 && cEndOfLine[-3] == '\r'))
+      {
+        // The line does not end in CRLF (or it ends in CRCRLF).
+        // Copy line and leave enough room for two more chars (CR and LF).
+        localMessageLine = (char *) PR_MALLOC(lineLength + 3);
+        if (!localMessageLine) // memory failure
+            return;
+        PL_strcpy(localMessageLine, line);
+        char *endOfLine = localMessageLine + lineLength;
+        messageLine = localMessageLine;
+
+        if (lineLength>=3 && endOfLine[-1] == '\n' &&
+            endOfLine[-2] == '\r')
+        {
+          // CRCRLF -> CRLF
+          endOfLine[-2] = '\n';
+          endOfLine[-1] = '\0';
+          lineLength--;
+        }
+        else if ((endOfLine[-1] == '\r') || (endOfLine[-1] == '\n'))
+        {
+          // LF -> CRLF or CR -> CRLF
+          endOfLine[-1] = '\r';
+          endOfLine[0]  = '\n';
+          endOfLine[1]  = '\0';
+          lineLength++;
+        }
+        else // no eol characters at all
+        {
+          endOfLine[0] = '\r';
+          endOfLine[1] = '\n';
+          endOfLine[2] = '\0';
+          lineLength += 2;
+        }
+      }
+    }
+  }
+  NS_ASSERTION(lineLength == PL_strlen(messageLine), "lineLength not accurate");
+
+  // check if sender obtained via XSENDER server extension matches "From:" field
+  const char *xSenderInfo = GetServerStateParser().GetXSenderInfo();
+  if (xSenderInfo && *xSenderInfo && !m_fromHeaderSeen)
+  {
+    if (!PL_strncmp("From: ", messageLine, 6))
+    {
+      m_fromHeaderSeen = true;
+      if (PL_strstr(messageLine, xSenderInfo) != NULL)
+          // Adding a X-Mozilla-Status line here is not very elegant but it
+          // works.  Another X-Mozilla-Status line is added to the message when
+          // downloading to a local folder; this new line will also contain the
+          // 'authed' flag we are adding here.  (If the message is again
+          // uploaded to the server, this flag is lost.)
+          // 0x0200 == nsMsgMessageFlags::SenderAuthed
+          HandleMessageDownLoadLine("X-Mozilla-Status: 0200\r\n", false);
+      GetServerStateParser().FreeXSenderInfo();
+    }
+  }
+
+  if (GetServerStateParser().GetDownloadingHeaders())
+  {
+    if (!m_curHdrInfo)
+      BeginMessageDownLoad(GetServerStateParser().SizeOfMostRecentMessage(), MESSAGE_RFC822);
+    if (m_curHdrInfo)
+      m_curHdrInfo->CacheLine(messageLine, GetServerStateParser().CurrentResponseUID());
+    PR_Free(localMessageLine);
+    return;
+  }
+  // if this line is for a different message, or the incoming line is too big
+  if (((m_downloadLineCache->CurrentUID() != GetServerStateParser().CurrentResponseUID()) && !m_downloadLineCache->CacheEmpty()) ||
+      (m_downloadLineCache->SpaceAvailable() < lineLength + 1) )
+    FlushDownloadCache();
+
+  // so now the cache is flushed, but this string might still be to big
+  if (m_downloadLineCache->SpaceAvailable() < lineLength + 1)
+      PostLineDownLoadEvent(messageLine, GetServerStateParser().CurrentResponseUID());
+  else
+    m_downloadLineCache->CacheLine(messageLine, GetServerStateParser().CurrentResponseUID());
+
+  PR_Free(localMessageLine);
+}
+
+void nsImapProtocol::FlushDownloadCache()
+{
+  if (!m_downloadLineCache->CacheEmpty())
+  {
+    msg_line_info *downloadLine = m_downloadLineCache->GetCurrentLineInfo();
+    PostLineDownLoadEvent(downloadLine->adoptedMessageLine,
+                          downloadLine->uidOfMessage);
+    m_downloadLineCache->ResetCache();
+  }
+}
+
+void nsImapProtocol::NormalMessageEndDownload()
+{
+  Log("STREAM", "CLOSE", "Normal Message End Download Stream");
+
+  if (m_trackingTime)
+    AdjustChunkSize();
+  if (m_imapMailFolderSink && m_curHdrInfo && GetServerStateParser().GetDownloadingHeaders())
+  {
+    m_curHdrInfo->SetMsgSize(GetServerStateParser().SizeOfMostRecentMessage());
+    m_curHdrInfo->SetMsgUid(GetServerStateParser().CurrentResponseUID());
+    m_hdrDownloadCache->FinishCurrentHdr();
+    int32_t numHdrsCached;
+    m_hdrDownloadCache->GetNumHeaders(&numHdrsCached);
+    if (numHdrsCached == kNumHdrsToXfer)
+    {
+      m_imapMailFolderSink->ParseMsgHdrs(this, m_hdrDownloadCache);
+      m_hdrDownloadCache->ResetAll();
+    }
+  }
+  FlushDownloadCache();
+
+  if (!GetServerStateParser().GetDownloadingHeaders())
+  {
+    int32_t updatedMessageSize = -1;
+    if (m_fetchingWholeMessage)
+    {
+      updatedMessageSize = m_bytesToChannel;
+#ifdef PR_LOGGING
+      if (m_bytesToChannel != GetServerStateParser().SizeOfMostRecentMessage()) {
+        MOZ_LOG(IMAP, LogLevel::Debug, ("STREAM:CLOSE Server's RFC822.SIZE %u, actual size %u",
+                                    GetServerStateParser().SizeOfMostRecentMessage(),
+                                    m_bytesToChannel));
+      }
+#endif
+    }
+    // need to know if we're downloading for display or not. We'll use action == nsImapMsgFetch for now
+    nsImapAction imapAction = nsIImapUrl::nsImapSelectFolder; // just set it to some legal value
+    if (m_runningUrl)
+      m_runningUrl->GetImapAction(&imapAction);
+
+    if (m_imapMessageSink)
+      m_imapMessageSink->NormalEndMsgWriteStream(m_downloadLineCache->CurrentUID(), imapAction == nsIImapUrl::nsImapMsgFetch, m_runningUrl, updatedMessageSize);
+
+    if (m_runningUrl && m_imapMailFolderSink)
+    {
+      nsCOMPtr <nsISupports> copyState;
+      m_runningUrl->GetCopyState(getter_AddRefs(copyState));
+      if (copyState) // only need this notification during copy
+      {
+        nsCOMPtr<nsIMsgMailNewsUrl> mailUrl (do_QueryInterface(m_runningUrl));
+        m_imapMailFolderSink->EndMessage(mailUrl, m_downloadLineCache->CurrentUID());
+      }
+    }
+  }
+  m_curHdrInfo = nullptr;
+}
+
+void nsImapProtocol::AbortMessageDownLoad()
+{
+  Log("STREAM", "CLOSE", "Abort Message  Download Stream");
+
+  if (m_trackingTime)
+    AdjustChunkSize();
+  FlushDownloadCache();
+  if (GetServerStateParser().GetDownloadingHeaders())
+  {
+    if (m_imapMailFolderSink)
+      m_imapMailFolderSink->AbortHeaderParseStream(this);
+  }
+  else if (m_imapMessageSink)
+        m_imapMessageSink->AbortMsgWriteStream();
+
+  m_curHdrInfo = nullptr;
+}
+
+
+void nsImapProtocol::ProcessMailboxUpdate(bool handlePossibleUndo)
+{
+  if (DeathSignalReceived())
+    return;
+
+  // Update quota information
+  char *boxName;
+  GetSelectedMailboxName(&boxName);
+  GetQuotaDataIfSupported(boxName);
+  PR_Free(boxName);
+
+  // fetch the flags and uids of all existing messages or new ones
+  if (!DeathSignalReceived() && GetServerStateParser().NumberOfMessages())
+  {
+    if (handlePossibleUndo)
+    {
+      // undo any delete flags we may have asked to
+      nsCString undoIdsStr;
+      nsAutoCString undoIds;
+
+      GetCurrentUrl()->GetListOfMessageIds(undoIdsStr);
+      undoIds.Assign(undoIdsStr);
+      if (!undoIds.IsEmpty())
+      {
+        char firstChar = (char) undoIds.CharAt(0);
+        undoIds.Cut(0, 1);  // remove first character
+        // if this string started with a '-', then this is an undo of a delete
+        // if its a '+' its a redo
+        if (firstChar == '-')
+          Store(undoIds, "-FLAGS (\\Deleted)", true);  // most servers will fail silently on a failure, deal with it?
+        else  if (firstChar == '+')
+          Store(undoIds, "+FLAGS (\\Deleted)", true);  // most servers will fail silently on a failure, deal with it?
+        else
+          NS_ASSERTION(false, "bogus undo Id's");
+      }
+    }
+
+    // make the parser record these flags
+    nsCString fetchStr;
+    int32_t added = 0, deleted = 0;
+
+    m_flagState->GetNumberOfMessages(&added);
+    deleted = m_flagState->NumberOfDeletedMessages();
+    bool flagStateEmpty = !added;
+    // Figure out if we need to do any kind of sync.
+    bool needFolderSync = (flagStateEmpty || added == deleted) && (!UseCondStore() ||
+      (GetServerStateParser().fHighestModSeq != mFolderLastModSeq) ||
+      (GetShowDeletedMessages() &&
+         GetServerStateParser().NumberOfMessages() != mFolderTotalMsgCount));
+
+    // Figure out if we need to do a full sync (UID Fetch Flags 1:*),
+    // a partial sync using CHANGEDSINCE, or a sync from the previous
+    // highwater mark.
+
+    // if the folder doesn't know about the highest uid, or the flag state
+    // is empty, and we're not using CondStore, we need a full sync.
+    bool needFullFolderSync = !mFolderHighestUID || (flagStateEmpty && !UseCondStore());
+
+    if (needFullFolderSync || needFolderSync)
+    {
+      nsCString idsToFetch("1:*");
+      char fetchModifier[40] = "";
+      if (!needFullFolderSync && !GetShowDeletedMessages() && UseCondStore())
+        PR_snprintf(fetchModifier, sizeof(fetchModifier), " (CHANGEDSINCE %llu)",
+                    mFolderLastModSeq);
+      else
+        m_flagState->SetPartialUIDFetch(false);
+
+      FetchMessage(idsToFetch, kFlags, fetchModifier);
+      // lets see if we should expunge during a full sync of flags.
+      if (GetServerStateParser().LastCommandSuccessful())
+      {
+        // if we did a CHANGEDSINCE fetch, do a sanity check on the msg counts
+        // to see if some other client may have done an expunge.
+        if (m_flagState->GetPartialUIDFetch())
+        {
+          if (m_flagState->NumberOfDeletedMessages() +
+              mFolderTotalMsgCount != GetServerStateParser().NumberOfMessages())
+          {
+            // sanity check failed - fall back to full flag sync
+            m_flagState->Reset();
+            m_flagState->SetPartialUIDFetch(false);
+            FetchMessage(NS_LITERAL_CSTRING("1:*"), kFlags);
+          }
+        }
+        int32_t numDeleted = m_flagState->NumberOfDeletedMessages();
+        // Don't do expunge when we are lite selecting folder because we
+        // could be doing undo.
+        // Expunge if we're always expunging, or the number of deleted messages
+        // is over the threshhold, and we're either always respecting the
+        // threshhold, or we're expunging based on the delete model, and
+        // the delete model is not the imap delete model.
+        if (m_imapAction != nsIImapUrl::nsImapLiteSelectFolder &&
+            (gExpungeOption == kAutoExpungeAlways ||
+             (numDeleted >= gExpungeThreshold &&
+              (gExpungeOption == kAutoExpungeOnThreshold ||
+               (gExpungeOption == kAutoExpungeDeleteModel && !GetShowDeletedMessages())))))
+          Expunge();
+      }
+    }
+    else
+    {
+      uint32_t highestRecordedUID = GetServerStateParser().HighestRecordedUID();
+      // if we're using CONDSTORE, and the parser hasn't seen any UIDs, use
+      // the highest UID we've seen from the folder.
+      if (UseCondStore() && !highestRecordedUID)
+        highestRecordedUID = mFolderHighestUID;
+
+      AppendUid(fetchStr, highestRecordedUID + 1);
+      fetchStr.Append(":*");
+      FetchMessage(fetchStr, kFlags);      // only new messages please
+    }
+  }
+  else if (GetServerStateParser().LastCommandSuccessful())
+  {
+    GetServerStateParser().ResetFlagInfo();
+    // the flag state is empty, but not partial.
+    m_flagState->SetPartialUIDFetch(false);
+  }
+
+  if (GetServerStateParser().LastCommandSuccessful())
+  {
+    nsImapAction imapAction;
+    nsresult res = m_runningUrl->GetImapAction(&imapAction);
+    if (NS_SUCCEEDED(res) && imapAction == nsIImapUrl::nsImapLiteSelectFolder)
+      return;
+  }
+
+  bool entered_waitForBodyIdsMonitor = false;
+
+  uint32_t *msgIdList = nullptr;
+  uint32_t msgCount = 0;
+
+  nsImapMailboxSpec *new_spec = GetServerStateParser().CreateCurrentMailboxSpec();
+  if (new_spec && GetServerStateParser().LastCommandSuccessful())
+  {
+    nsImapAction imapAction;
+    nsresult res = m_runningUrl->GetImapAction(&imapAction);
+    if (NS_SUCCEEDED(res) && imapAction == nsIImapUrl::nsImapExpungeFolder)
+      new_spec->mBoxFlags |= kJustExpunged;
+    m_waitForBodyIdsMonitor.Enter();
+    entered_waitForBodyIdsMonitor = true;
+
+    if (m_imapMailFolderSink)
+    {
+      bool more;
+      m_imapMailFolderSink->UpdateImapMailboxInfo(this, new_spec);
+      m_imapMailFolderSink->GetMsgHdrsToDownload(&more, &m_progressCount,
+                                                 &msgCount, &msgIdList);
+      m_progressIndex = 0;
+      m_runningUrl->SetMoreHeadersToDownload(more);
+      // We're going to be re-running this url if there are more headers.
+      if (more)
+        m_runningUrl->SetRerunningUrl(true);
+    }
+  }
+  else if (!new_spec)
+    HandleMemoryFailure();
+
+  if (GetServerStateParser().LastCommandSuccessful())
+  {
+    if (entered_waitForBodyIdsMonitor)
+      m_waitForBodyIdsMonitor.Exit();
+
+    if (msgIdList && !DeathSignalReceived() && GetServerStateParser().LastCommandSuccessful())
+    {
+      FolderHeaderDump(msgIdList, msgCount);
+      NS_Free( msgIdList);
+    }
+    HeaderFetchCompleted();
+      // this might be bogus, how are we going to do pane notification and stuff when we fetch bodies without
+      // headers!
+  }
+  else if (entered_waitForBodyIdsMonitor) // need to exit this monitor if death signal received
+    m_waitForBodyIdsMonitor.Exit();
+
+  // wait for a list of bodies to fetch.
+  if (GetServerStateParser().LastCommandSuccessful())
+  {
+    WaitForPotentialListOfBodysToFetch(&msgIdList, msgCount);
+    if ( msgCount && GetServerStateParser().LastCommandSuccessful())
+    {
+      // Tell the url that it should store the msg fetch results offline,
+      // while we're dumping the messages, and then restore the setting.
+      bool wasStoringOffline;
+      m_runningUrl->GetStoreResultsOffline(&wasStoringOffline);
+      m_runningUrl->SetStoreResultsOffline(true);
+      m_progressIndex = 0;
+      m_progressCount = msgCount;
+      FolderMsgDump(msgIdList, msgCount, kEveryThingRFC822Peek);
+      m_runningUrl->SetStoreResultsOffline(wasStoringOffline);
+    }
+  }
+  if (!GetServerStateParser().LastCommandSuccessful())
+    GetServerStateParser().ResetFlagInfo();
+
+  NS_IF_RELEASE(new_spec);
+}
+
+void nsImapProtocol::FolderHeaderDump(uint32_t *msgUids, uint32_t msgCount)
+{
+  FolderMsgDump(msgUids, msgCount, kHeadersRFC822andUid);
+}
+
+void nsImapProtocol::FolderMsgDump(uint32_t *msgUids, uint32_t msgCount, nsIMAPeFetchFields fields)
+{
+  // lets worry about this progress stuff later.
+  switch (fields) {
+  case kHeadersRFC822andUid:
+    SetProgressString("imapReceivingMessageHeaders2");
+    break;
+  case kFlags:
+    SetProgressString("imapReceivingMessageFlags2");
+    break;
+  default:
+    SetProgressString("imapFolderReceivingMessageOf2");
+    break;
+  }
+
+  FolderMsgDumpLoop(msgUids, msgCount, fields);
+
+  SetProgressString(nullptr);
+}
+
+void nsImapProtocol::WaitForPotentialListOfBodysToFetch(uint32_t **msgIdList, uint32_t &msgCount)
+{
+  PRIntervalTime sleepTime = kImapSleepTime;
+
+  ReentrantMonitorAutoEnter fetchListMon(m_fetchBodyListMonitor);
+  while(!m_fetchBodyListIsNew && !DeathSignalReceived())
+    fetchListMon.Wait(sleepTime);
+  m_fetchBodyListIsNew = false;
+
+  *msgIdList = m_fetchBodyIdList;
+  msgCount   = m_fetchBodyCount;
+}
+
+// libmsg uses this to notify a running imap url about message bodies it should download.
+// why not just have libmsg explicitly download the message bodies?
+NS_IMETHODIMP nsImapProtocol::NotifyBodysToDownload(uint32_t *keys, uint32_t keyCount)
+{
+  ReentrantMonitorAutoEnter fetchListMon(m_fetchBodyListMonitor);
+  PR_FREEIF(m_fetchBodyIdList);
+  m_fetchBodyIdList = (uint32_t *) PR_MALLOC(keyCount * sizeof(uint32_t));
+  if (m_fetchBodyIdList)
+    memcpy(m_fetchBodyIdList, keys, keyCount * sizeof(uint32_t));
+  m_fetchBodyCount    = keyCount;
+  m_fetchBodyListIsNew = true;
+  fetchListMon.Notify();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapProtocol::GetFlagsForUID(uint32_t uid, bool *foundIt, imapMessageFlagsType *resultFlags, char **customFlags)
+{
+  int32_t i;
+
+  imapMessageFlagsType flags = m_flagState->GetMessageFlagsFromUID(uid, foundIt, &i);
+  if (*foundIt)
+  {
+    *resultFlags = flags;
+    if ((flags & kImapMsgCustomKeywordFlag) && customFlags)
+      m_flagState->GetCustomFlags(uid, customFlags);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapProtocol::GetFlagAndUidState(nsIImapFlagAndUidState **aFlagState)
+{
+  NS_ENSURE_ARG_POINTER(aFlagState);
+  NS_IF_ADDREF(*aFlagState = m_flagState);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapProtocol::GetSupportedUserFlags(uint16_t *supportedFlags)
+{
+  if (!supportedFlags)
+    return NS_ERROR_NULL_POINTER;
+
+  *supportedFlags = m_flagState->GetSupportedUserFlags();
+  return NS_OK;
+}
+void nsImapProtocol::FolderMsgDumpLoop(uint32_t *msgUids, uint32_t msgCount, nsIMAPeFetchFields fields)
+{
+  int32_t msgCountLeft = msgCount;
+  uint32_t msgsDownloaded = 0;
+  do
+  {
+    nsCString idString;
+    uint32_t msgsToDownload = msgCountLeft;
+    AllocateImapUidString(msgUids + msgsDownloaded, msgsToDownload, m_flagState, idString);  // 20 * 200
+    FetchMessage(idString, fields);
+    msgsDownloaded += msgsToDownload;
+    msgCountLeft -= msgsToDownload;
+  }
+  while (msgCountLeft > 0 && !DeathSignalReceived());
+}
+
+void nsImapProtocol::HeaderFetchCompleted()
+{
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->ParseMsgHdrs(this, m_hdrDownloadCache);
+  m_hdrDownloadCache->ReleaseAll();
+
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->HeaderFetchCompleted(this);
+}
+
+
+// Use the noop to tell the server we are still here, and therefore we are willing to receive
+// status updates. The recent or exists response from the server could tell us that there is
+// more mail waiting for us, but we need to check the flags of the mail and the high water mark
+// to make sure that we do not tell the user that there is new mail when perhaps they have
+// already read it in another machine.
+
+void nsImapProtocol::PeriodicBiff()
+{
+
+  nsMsgBiffState startingState = m_currentBiffState;
+
+  if (GetServerStateParser().GetIMAPstate() == nsImapServerResponseParser::kFolderSelected)
+  {
+    Noop(); // check the latest number of messages
+    int32_t numMessages = 0;
+    m_flagState->GetNumberOfMessages(&numMessages);
+    if (GetServerStateParser().NumberOfMessages() != numMessages)
+    {
+      uint32_t id = GetServerStateParser().HighestRecordedUID() + 1;
+      nsCString fetchStr;           // only update flags
+      uint32_t added = 0, deleted = 0;
+
+      deleted = m_flagState->NumberOfDeletedMessages();
+      added = numMessages;
+      if (!added || (added == deleted)) // empty keys, get them all
+        id = 1;
+
+      //sprintf(fetchStr, "%ld:%ld", id, id + GetServerStateParser().NumberOfMessages() - fFlagState->GetNumberOfMessages());
+      AppendUid(fetchStr, id);
+      fetchStr.Append(":*");
+      FetchMessage(fetchStr, kFlags);
+      if (((uint32_t) m_flagState->GetHighestNonDeletedUID() >= id) && m_flagState->IsLastMessageUnseen())
+        m_currentBiffState = nsIMsgFolder::nsMsgBiffState_NewMail;
+      else
+        m_currentBiffState = nsIMsgFolder::nsMsgBiffState_NoMail;
+    }
+    else
+      m_currentBiffState = nsIMsgFolder::nsMsgBiffState_NoMail;
+  }
+  else
+    m_currentBiffState = nsIMsgFolder::nsMsgBiffState_Unknown;
+
+  if (startingState != m_currentBiffState)
+    SendSetBiffIndicatorEvent(m_currentBiffState);
+}
+
+void nsImapProtocol::SendSetBiffIndicatorEvent(nsMsgBiffState newState)
+{
+    if (m_imapMailFolderSink)
+      m_imapMailFolderSink->SetBiffStateAndUpdate(newState);
+}
+
+// We get called to see if there is mail waiting for us at the server, even if it may have been
+// read elsewhere. We just want to know if we should download headers or not.
+
+bool nsImapProtocol::CheckNewMail()
+{
+  return m_checkForNewMailDownloadsHeaders;
+}
+
+/* static */ void nsImapProtocol::LogImapUrl(const char *logMsg, nsIImapUrl *imapUrl)
+{
+  // nsImapProtocol is not always constructed before this static method is called
+  if (!IMAP)
+    IMAP = PR_NewLogModule("IMAP");
+
+  if (MOZ_LOG_TEST(IMAP, LogLevel::Info))
+  {
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(imapUrl);
+    if (mailnewsUrl)
+    {
+      nsAutoCString urlSpec, unescapedUrlSpec;
+      nsresult rv = mailnewsUrl->GetSpec(urlSpec);
+      if (NS_FAILED(rv))
+        return;
+      MsgUnescapeString(urlSpec, 0, unescapedUrlSpec);
+      MOZ_LOG(IMAP, LogLevel::Info, ("%s:%s", logMsg, unescapedUrlSpec.get()));
+    }
+  }
+}
+
+// log info including current state...
+void nsImapProtocol::Log(const char *logSubName, const char *extraInfo, const char *logData)
+{
+  if (MOZ_LOG_TEST(IMAP, LogLevel::Info))
+  {
+    static const char nonAuthStateName[] = "NA";
+    static const char authStateName[] = "A";
+    static const char selectedStateName[] = "S";
+    const nsCString& hostName = GetImapHostName();  // initilize to empty string
+
+    int32_t logDataLen = PL_strlen(logData); // PL_strlen checks for null
+    nsCString logDataLines;
+    const char *logDataToLog;
+    int32_t lastLineEnd;
+
+    const int kLogDataChunkSize = 400; // nspr line length is 512, and we
+                                       // allow some space for the log preamble.
+
+    // break up buffers > 400 bytes on line boundaries.
+    if (logDataLen > kLogDataChunkSize)
+    {
+      logDataLines.Assign(logData);
+      lastLineEnd = MsgRFindChar(logDataLines, '\n', kLogDataChunkSize);
+      // null terminate the last line
+      if (lastLineEnd == kNotFound)
+        lastLineEnd = kLogDataChunkSize - 1;
+
+      logDataLines.Insert( '\0', lastLineEnd + 1);
+      logDataToLog = logDataLines.get();
+    }
+    else
+    {
+      logDataToLog = logData;
+      lastLineEnd = logDataLen;
+    }
+    switch (GetServerStateParser().GetIMAPstate())
+    {
+    case nsImapServerResponseParser::kFolderSelected:
+      if (extraInfo)
+        MOZ_LOG(IMAP, LogLevel::Info, ("%x:%s:%s-%s:%s:%s: %.400s", this, hostName.get(),
+               selectedStateName, GetServerStateParser().GetSelectedMailboxName(),
+               logSubName, extraInfo, logDataToLog));
+      else
+        MOZ_LOG(IMAP, LogLevel::Info, ("%x:%s:%s-%s:%s: %.400s", this, hostName.get(),
+               selectedStateName, GetServerStateParser().GetSelectedMailboxName(),
+               logSubName, logDataToLog));
+      break;
+    case nsImapServerResponseParser::kNonAuthenticated:
+    case nsImapServerResponseParser::kAuthenticated:
+    {
+      const char *stateName = (GetServerStateParser().GetIMAPstate() ==
+                               nsImapServerResponseParser::kNonAuthenticated)
+                               ? nonAuthStateName : authStateName;
+      if (extraInfo)
+        MOZ_LOG(IMAP, LogLevel::Info, ("%x:%s:%s:%s:%s: %.400s", this,
+               hostName.get(),stateName,logSubName,extraInfo,logDataToLog));
+      else
+        MOZ_LOG(IMAP, LogLevel::Info, ("%x:%s:%s:%s: %.400s",this,
+               hostName.get(),stateName,logSubName,logDataToLog));
+    }
+    }
+
+    // dump the rest of the string in < 400 byte chunks
+    while (logDataLen > kLogDataChunkSize)
+    {
+      logDataLines.Cut(0, lastLineEnd + 2); // + 2 to account for the LF and the '\0' we added
+      logDataLen = logDataLines.Length();
+      lastLineEnd = (logDataLen > kLogDataChunkSize) ? MsgRFindChar(logDataLines, '\n', kLogDataChunkSize) : kNotFound;
+      // null terminate the last line
+      if (lastLineEnd == kNotFound)
+        lastLineEnd = kLogDataChunkSize - 1;
+      logDataLines.Insert( '\0', lastLineEnd + 1);
+      logDataToLog = logDataLines.get();
+      MOZ_LOG(IMAP, LogLevel::Info, ("%.400s", logDataToLog));
+    }
+  }
+}
+
+// In 4.5, this posted an event back to libmsg and blocked until it got a response.
+// We may still have to do this.It would be nice if we could preflight this value,
+// but we may not always know when we'll need it.
+uint32_t nsImapProtocol::GetMessageSize(const char * messageId,
+                                        bool idsAreUids)
+{
+  const char *folderFromParser = GetServerStateParser().GetSelectedMailboxName();
+  if (folderFromParser && messageId)
+  {
+    char *id = (char *)PR_CALLOC(strlen(messageId) + 1);
+    char *folderName;
+    uint32_t size;
+
+    PL_strcpy(id, messageId);
+
+    nsIMAPNamespace *nsForMailbox = nullptr;
+        m_hostSessionList->GetNamespaceForMailboxForHost(GetImapServerKey(), folderFromParser,
+            nsForMailbox);
+
+
+    if (nsForMailbox)
+          m_runningUrl->AllocateCanonicalPath(
+              folderFromParser, nsForMailbox->GetDelimiter(),
+              &folderName);
+    else
+       m_runningUrl->AllocateCanonicalPath(
+          folderFromParser,kOnlineHierarchySeparatorUnknown,
+          &folderName);
+
+    if (id && folderName)
+    {
+      if (m_imapMessageSink)
+          m_imapMessageSink->GetMessageSizeFromDB(id, &size);
+    }
+    PR_FREEIF(id);
+    PR_FREEIF(folderName);
+
+    uint32_t rv = 0;
+    if (!DeathSignalReceived())
+      rv = size;
+    return rv;
+  }
+  return 0;
+}
+
+// message id string utility functions
+/* static */bool nsImapProtocol::HandlingMultipleMessages(const nsCString & messageIdString)
+{
+  return (MsgFindCharInSet(messageIdString, ",:") != kNotFound);
+}
+
+uint32_t nsImapProtocol::CountMessagesInIdString(const char *idString)
+{
+  uint32_t numberOfMessages = 0;
+  char *uidString = PL_strdup(idString);
+
+  if (uidString)
+  {
+    // This is in the form <id>,<id>, or <id1>:<id2>
+    char curChar = *uidString;
+    bool isRange = false;
+    int32_t curToken;
+    int32_t saveStartToken=0;
+
+    for (char *curCharPtr = uidString; curChar && *curCharPtr;)
+    {
+      char *currentKeyToken = curCharPtr;
+      curChar = *curCharPtr;
+      while (curChar != ':' && curChar != ',' && curChar != '\0')
+        curChar = *curCharPtr++;
+      *(curCharPtr - 1) = '\0';
+      curToken = atol(currentKeyToken);
+      if (isRange)
+      {
+        while (saveStartToken < curToken)
+        {
+          numberOfMessages++;
+          saveStartToken++;
+        }
+      }
+
+      numberOfMessages++;
+      isRange = (curChar == ':');
+      if (isRange)
+        saveStartToken = curToken + 1;
+    }
+    PR_Free(uidString);
+  }
+  return numberOfMessages;
+}
+
+
+// It would be really nice not to have to use this method nearly as much as we did
+// in 4.5 - we need to think about this some. Some of it may just go away in the new world order
+bool nsImapProtocol::DeathSignalReceived()
+{
+  // ignore mock channel status if we've been pseudo interrupted
+  // ### need to make sure we clear pseudo interrupted status appropriately.
+  if (!GetPseudoInterrupted() && m_mockChannel)
+  {
+    nsCOMPtr<nsIRequest> request = do_QueryInterface(m_mockChannel);
+    if (request)
+    {
+      nsresult returnValue;
+      request->GetStatus(&returnValue);
+      if (NS_FAILED(returnValue))
+        return false;
+    }
+  }
+
+  // Check the other way of cancelling.
+  ReentrantMonitorAutoEnter threadDeathMon(m_threadDeathMonitor);
+  return m_threadShouldDie;
+}
+
+NS_IMETHODIMP nsImapProtocol::ResetToAuthenticatedState()
+{
+    GetServerStateParser().PreauthSetAuthenticatedState();
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP nsImapProtocol::GetSelectedMailboxName(char ** folderName)
+{
+    if (!folderName) return NS_ERROR_NULL_POINTER;
+    if (GetServerStateParser().GetSelectedMailboxName())
+        *folderName =
+            PL_strdup((GetServerStateParser().GetSelectedMailboxName()));
+    return NS_OK;
+}
+
+bool nsImapProtocol::GetPseudoInterrupted()
+{
+  ReentrantMonitorAutoEnter pseudoInterruptMon(m_pseudoInterruptMonitor);
+  return m_pseudoInterrupted;
+}
+
+void nsImapProtocol::PseudoInterrupt(bool the_interrupt)
+{
+  ReentrantMonitorAutoEnter pseudoInterruptMon(m_pseudoInterruptMonitor);
+  m_pseudoInterrupted = the_interrupt;
+  if (the_interrupt)
+    Log("CONTROL", NULL, "PSEUDO-Interrupted");
+}
+
+void  nsImapProtocol::SetActive(bool active)
+{
+  ReentrantMonitorAutoEnter dataMemberMon(m_dataMemberMonitor);
+  m_active = active;
+}
+
+bool    nsImapProtocol::GetActive()
+{
+  ReentrantMonitorAutoEnter dataMemberMon(m_dataMemberMonitor);
+  return m_active;
+}
+
+bool nsImapProtocol::GetShowAttachmentsInline()
+{
+  bool showAttachmentsInline = true;
+  if (m_imapServerSink)
+    m_imapServerSink->GetShowAttachmentsInline(&showAttachmentsInline);
+  return showAttachmentsInline;
+
+}
+
+void nsImapProtocol::SetContentModified(IMAP_ContentModifiedType modified)
+{
+  if (m_runningUrl && m_imapMessageSink)
+    m_imapMessageSink->SetContentModified(m_runningUrl, modified);
+}
+
+
+bool	nsImapProtocol::GetShouldFetchAllParts()
+{
+  if (m_runningUrl  && !DeathSignalReceived())
+  {
+    nsImapContentModifiedType contentModified;
+    if (NS_SUCCEEDED(m_runningUrl->GetContentModified(&contentModified)))
+      return (contentModified == IMAP_CONTENT_FORCE_CONTENT_NOT_MODIFIED);
+  }
+  return true;
+}
+
+// Adds a set of rights for a given user on a given mailbox on the current host.
+// if userName is NULL, it means "me," or MYRIGHTS.
+void nsImapProtocol::AddFolderRightsForUser(const char *mailboxName, const char *userName, const char *rights)
+{
+  if (!userName)
+    userName = "";
+  if (m_imapServerSink)
+    m_imapServerSink->AddFolderRights(nsDependentCString(mailboxName), nsDependentCString(userName),
+                                      nsDependentCString(rights));
+}
+
+void nsImapProtocol::SetCopyResponseUid(const char *msgIdString)
+{
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->SetCopyResponseUid(msgIdString, m_runningUrl);
+}
+
+void nsImapProtocol::CommitNamespacesForHostEvent()
+{
+    if (m_imapServerSink)
+        m_imapServerSink->CommitNamespaces();
+}
+
+// notifies libmsg that we have new capability data for the current host
+void nsImapProtocol::CommitCapability()
+{
+    if (m_imapServerSink)
+    {
+        m_imapServerSink->SetCapability(GetServerStateParser().GetCapabilityFlag());
+    }
+}
+
+// rights is a single string of rights, as specified by RFC2086, the IMAP ACL extension.
+// Clears all rights for a given folder, for all users.
+void nsImapProtocol::ClearAllFolderRights()
+{
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->ClearFolderRights();
+}
+
+
+char* nsImapProtocol::CreateNewLineFromSocket()
+{
+  bool needMoreData = false;
+  char * newLine = nullptr;
+  uint32_t numBytesInLine = 0;
+  nsresult rv = NS_OK;
+  // we hold a ref to the input stream in case we get cancelled from the
+  // ui thread, which releases our ref to the input stream, and can
+  // cause the pipe to get deleted before the monitor the read is
+  // blocked on gets notified. When that happens, the imap thread
+  // will stay blocked.
+  nsCOMPtr <nsIInputStream> kungFuGrip = m_inputStream;
+  do
+  {
+    newLine = m_inputStreamBuffer->ReadNextLine(m_inputStream, numBytesInLine, needMoreData, &rv);
+    MOZ_LOG(IMAP, LogLevel::Debug, ("ReadNextLine [stream=%x nb=%u needmore=%u]\n",
+        m_inputStream.get(), numBytesInLine, needMoreData));
+
+  } while (!newLine && NS_SUCCEEDED(rv) && !DeathSignalReceived()); // until we get the next line and haven't been interrupted
+
+  kungFuGrip = nullptr;
+
+  if (NS_FAILED(rv))
+  {
+    switch (rv)
+    {
+        case NS_ERROR_UNKNOWN_HOST:
+        case NS_ERROR_UNKNOWN_PROXY_HOST:
+            AlertUserEventUsingName("imapUnknownHostError");
+            break;
+        case NS_ERROR_CONNECTION_REFUSED:
+        case NS_ERROR_PROXY_CONNECTION_REFUSED:
+            AlertUserEventUsingName("imapConnectionRefusedError");
+            break;
+        case NS_ERROR_NET_TIMEOUT:
+        case NS_ERROR_NET_RESET:
+        case NS_BASE_STREAM_CLOSED:
+        case NS_ERROR_NET_INTERRUPT:
+          // we should retry on RESET, especially for SSL...
+          if ((TestFlag(IMAP_RECEIVED_GREETING) || rv == NS_ERROR_NET_RESET) &&
+              m_runningUrl && !m_retryUrlOnError)
+          {
+            bool rerunningUrl;
+            nsImapAction imapAction;
+            m_runningUrl->GetRerunningUrl(&rerunningUrl);
+            m_runningUrl->GetImapAction(&imapAction);
+            // don't rerun if we already were rerunning. And don't rerun
+            // online move/copies that timeout.
+            if (!rerunningUrl && (rv != NS_ERROR_NET_TIMEOUT ||
+                                 (imapAction != nsIImapUrl::nsImapOnlineCopy &&
+                                  imapAction != nsIImapUrl::nsImapOnlineMove)))
+            {
+              m_runningUrl->SetRerunningUrl(true);
+              m_retryUrlOnError = true;
+              break;
+            }
+          }
+          if (rv == NS_ERROR_NET_TIMEOUT)
+            AlertUserEventUsingName("imapNetTimeoutError");
+          else
+            AlertUserEventUsingName(TestFlag(IMAP_RECEIVED_GREETING) ?
+                                    "imapServerDisconnected" :
+                                    "imapServerDroppedConnection");
+          break;
+        default:
+            break;
+    }
+
+    nsAutoCString logMsg("clearing IMAP_CONNECTION_IS_OPEN - rv = ");
+    logMsg.AppendInt(static_cast<uint32_t>(rv), 16);
+    Log("CreateNewLineFromSocket", nullptr, logMsg.get());
+    ClearFlag(IMAP_CONNECTION_IS_OPEN);
+    TellThreadToDie();
+  }
+  Log("CreateNewLineFromSocket", nullptr, newLine);
+  SetConnectionStatus(newLine && numBytesInLine ? NS_OK : rv); // set > 0 if string is not null or empty
+  return newLine;
+}
+
+nsresult
+nsImapProtocol::GetConnectionStatus()
+{
+  return m_connectionStatus;
+}
+
+void
+nsImapProtocol::SetConnectionStatus(nsresult status)
+{
+  m_connectionStatus = status;
+}
+
+void
+nsImapProtocol::NotifyMessageFlags(imapMessageFlagsType flags,
+                                   const nsACString &keywords,
+                                   nsMsgKey key, uint64_t highestModSeq)
+{
+    if (m_imapMessageSink)
+    {
+      // if we're selecting the folder, don't need to report the flags; we've already fetched them.
+      if (m_imapAction != nsIImapUrl::nsImapSelectFolder &&
+          (m_imapAction != nsIImapUrl::nsImapMsgFetch ||
+          (flags & ~kImapMsgRecentFlag) != kImapMsgSeenFlag))
+        m_imapMessageSink->NotifyMessageFlags(flags, keywords, key, highestModSeq);
+    }
+}
+
+void
+nsImapProtocol::NotifySearchHit(const char * hitLine)
+{
+    nsresult rv;
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl, &rv);
+    if (m_imapMailFolderSink)
+        m_imapMailFolderSink->NotifySearchHit(mailnewsUrl, hitLine);
+}
+
+void nsImapProtocol::SetMailboxDiscoveryStatus(EMailboxDiscoverStatus status)
+{
+  ReentrantMonitorAutoEnter mon(m_dataMemberMonitor);
+  m_discoveryStatus = status;
+}
+
+EMailboxDiscoverStatus nsImapProtocol::GetMailboxDiscoveryStatus( )
+{
+  ReentrantMonitorAutoEnter mon(m_dataMemberMonitor);
+  return m_discoveryStatus;
+}
+
+bool
+nsImapProtocol::GetSubscribingNow()
+{
+    // ***** code me *****
+    return false;// ***** for now
+}
+
+void
+nsImapProtocol::DiscoverMailboxSpec(nsImapMailboxSpec * adoptedBoxSpec)
+{
+  nsIMAPNamespace *ns = nullptr;
+
+  NS_ASSERTION (m_hostSessionList, "fatal null host session list");
+  if (!m_hostSessionList)
+    return;
+
+  m_hostSessionList->GetDefaultNamespaceOfTypeForHost(
+    GetImapServerKey(), kPersonalNamespace, ns);
+  const char *nsPrefix = ns ? ns->GetPrefix() : 0;
+
+  if (m_specialXListMailboxes.Count() > 0)
+  {
+    int32_t hashValue = 0;
+    nsCString strHashKey(adoptedBoxSpec->mAllocatedPathName);
+    m_specialXListMailboxes.Get(strHashKey, &hashValue);
+    adoptedBoxSpec->mBoxFlags |= hashValue;
+  }
+
+  switch (m_hierarchyNameState)
+  {
+  case kXListing:
+    if (adoptedBoxSpec->mBoxFlags &
+        (kImapXListTrash|kImapAllMail|kImapInbox|kImapSent|kImapSpam|kImapDrafts))
+    {
+      nsCString mailboxName(adoptedBoxSpec->mAllocatedPathName);
+      m_specialXListMailboxes.Put(mailboxName, adoptedBoxSpec->mBoxFlags);
+      // Remember hierarchy delimiter in case this is the first time we've
+      // connected to the server and we need it to be correct for the two-level
+      // XLIST we send (INBOX is guaranteed to be in the first response).
+      if (adoptedBoxSpec->mBoxFlags & kImapInbox)
+        m_runningUrl->SetOnlineSubDirSeparator(adoptedBoxSpec->mHierarchySeparator);
+
+    }
+    NS_IF_RELEASE(adoptedBoxSpec);
+    break;
+  case kListingForFolderFlags:
+    {
+      // store mailbox flags from LIST for use by LSUB
+      nsCString mailboxName(adoptedBoxSpec->mAllocatedPathName);
+      m_standardListMailboxes.Put(mailboxName, adoptedBoxSpec->mBoxFlags);
+    }
+    NS_IF_RELEASE(adoptedBoxSpec);
+    break;
+  case kListingForCreate:
+  case kNoOperationInProgress:
+  case kDiscoverTrashFolderInProgress:
+  case kListingForInfoAndDiscovery:
+    {
+      // standard mailbox specs are stored in m_standardListMailboxes
+      // because LSUB does necessarily return all mailbox flags.
+      // count should be > 0 only when we are looking at response of LSUB
+      if (m_standardListMailboxes.Count() > 0)
+      {
+        int32_t hashValue = 0;
+        nsCString strHashKey(adoptedBoxSpec->mAllocatedPathName);
+        if (m_standardListMailboxes.Get(strHashKey, &hashValue))
+          adoptedBoxSpec->mBoxFlags |= hashValue;
+        else
+          // if mailbox is not in hash list, then it is subscribed but does not
+          // exist, so we make sure it can't be selected
+          adoptedBoxSpec->mBoxFlags |= kNoselect;
+      }
+      if (ns && nsPrefix) // if no personal namespace, there can be no Trash folder
+      {
+        bool onlineTrashFolderExists = false;
+        if (m_hostSessionList)
+        {
+          if (adoptedBoxSpec->mBoxFlags & (kImapTrash|kImapXListTrash))
+          {
+             m_hostSessionList->SetOnlineTrashFolderExistsForHost(GetImapServerKey(), true);
+             onlineTrashFolderExists = true;
+          }
+          else
+          {
+            m_hostSessionList->GetOnlineTrashFolderExistsForHost(
+                                  GetImapServerKey(), onlineTrashFolderExists);
+          }
+        }
+
+        // Don't set the Trash flag if not using the Trash model
+        if (GetDeleteIsMoveToTrash() && !onlineTrashFolderExists &&
+            adoptedBoxSpec->mAllocatedPathName.Find(m_trashFolderName, CaseInsensitiveCompare) != -1)
+        {
+          bool trashExists = false;
+          nsCString trashMatch(CreatePossibleTrashName(nsPrefix));
+          nsCString serverTrashName;
+          m_runningUrl->AllocateCanonicalPath(trashMatch.get(),
+                                              ns->GetDelimiter(),
+                                              getter_Copies(serverTrashName));
+          if (StringBeginsWith(serverTrashName,
+                               NS_LITERAL_CSTRING("INBOX/"),
+                               nsCaseInsensitiveCStringComparator()))
+          {
+            nsAutoCString pathName(adoptedBoxSpec->mAllocatedPathName.get() + 6);
+            trashExists =
+              StringBeginsWith(adoptedBoxSpec->mAllocatedPathName,
+                               serverTrashName,
+                               nsCaseInsensitiveCStringComparator()) && /* "INBOX/" */
+              pathName.Equals(Substring(serverTrashName, 6), nsCaseInsensitiveCStringComparator());
+          }
+          else
+            trashExists = adoptedBoxSpec->mAllocatedPathName.Equals(serverTrashName, nsCaseInsensitiveCStringComparator());
+
+          if (m_hostSessionList)
+            m_hostSessionList->SetOnlineTrashFolderExistsForHost(GetImapServerKey(), trashExists);
+
+          if (trashExists)
+            adoptedBoxSpec->mBoxFlags |= kImapTrash;
+        }
+      }
+
+      // Discover the folder (shuttle over to libmsg, yay)
+      // Do this only if the folder name is not empty (i.e. the root)
+      if (!adoptedBoxSpec->mAllocatedPathName.IsEmpty())
+      {
+        if (m_hierarchyNameState == kListingForCreate)
+          adoptedBoxSpec->mBoxFlags |= kNewlyCreatedFolder;
+
+        if (m_imapServerSink)
+        {
+          bool newFolder;
+
+          m_imapServerSink->PossibleImapMailbox(adoptedBoxSpec->mAllocatedPathName,
+                                                adoptedBoxSpec->mHierarchySeparator,
+                                                adoptedBoxSpec->mBoxFlags, &newFolder);
+          // if it's a new folder to the server sink, setting discovery status to
+          // eContinueNew will cause us to get the ACL for the new folder.
+          if (newFolder)
+            SetMailboxDiscoveryStatus(eContinueNew);
+
+          bool useSubscription = false;
+
+          if (m_hostSessionList)
+            m_hostSessionList->GetHostIsUsingSubscription(GetImapServerKey(),
+                                                          useSubscription);
+
+          if ((GetMailboxDiscoveryStatus() != eContinue) &&
+              (GetMailboxDiscoveryStatus() != eContinueNew) &&
+              (GetMailboxDiscoveryStatus() != eListMyChildren))
+          {
+            SetConnectionStatus(NS_ERROR_FAILURE);
+          }
+          else if (!adoptedBoxSpec->mAllocatedPathName.IsEmpty() &&
+                   (GetMailboxDiscoveryStatus() == eListMyChildren) &&
+                   (!useSubscription || GetSubscribingNow()))
+          {
+            NS_ASSERTION (false,
+              "we should never get here anymore");
+            SetMailboxDiscoveryStatus(eContinue);
+          }
+          else if (GetMailboxDiscoveryStatus() == eContinueNew)
+          {
+            if (m_hierarchyNameState == kListingForInfoAndDiscovery &&
+                !adoptedBoxSpec->mAllocatedPathName.IsEmpty() &&
+                !(adoptedBoxSpec->mBoxFlags & kNameSpace))
+            {
+              // remember the info here also
+              nsIMAPMailboxInfo *mb = new nsIMAPMailboxInfo(adoptedBoxSpec->mAllocatedPathName, adoptedBoxSpec->mHierarchySeparator);
+              m_listedMailboxList.AppendElement(mb);
+            }
+            SetMailboxDiscoveryStatus(eContinue);
+          }
+        }
+      }
+      }
+      NS_IF_RELEASE( adoptedBoxSpec);
+      break;
+    case kDiscoverBaseFolderInProgress:
+      break;
+    case kDeleteSubFoldersInProgress:
+      {
+        NS_ASSERTION(m_deletableChildren, "Oops .. null m_deletableChildren\n");
+        m_deletableChildren->AppendElement(ToNewCString(adoptedBoxSpec->mAllocatedPathName));
+        NS_IF_RELEASE(adoptedBoxSpec);
+      }
+      break;
+    case kListingForInfoOnly:
+      {
+        //UpdateProgressWindowForUpgrade(adoptedBoxSpec->allocatedPathName);
+        ProgressEventFunctionUsingNameWithString("imapDiscoveringMailbox",
+          adoptedBoxSpec->mAllocatedPathName.get());
+        nsIMAPMailboxInfo *mb = new nsIMAPMailboxInfo(adoptedBoxSpec->mAllocatedPathName,
+                                                      adoptedBoxSpec->mHierarchySeparator);
+        m_listedMailboxList.AppendElement(mb);
+        NS_IF_RELEASE(adoptedBoxSpec);
+      }
+      break;
+    case kDiscoveringNamespacesOnly:
+      {
+        NS_IF_RELEASE(adoptedBoxSpec);
+      }
+      break;
+    default:
+      NS_ASSERTION (false, "we aren't supposed to be here");
+      break;
+  }
+}
+
+void
+nsImapProtocol::AlertUserEventUsingName(const char* aMessageName)
+{
+  if (m_imapServerSink)
+  {
+    bool suppressErrorMsg = false;
+
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl);
+    if (mailnewsUrl)
+      mailnewsUrl->GetSuppressErrorMsgs(&suppressErrorMsg);
+
+    if (!suppressErrorMsg)
+      m_imapServerSink->FEAlertWithName(aMessageName,
+                                        mailnewsUrl);
+  }
+}
+
+void
+nsImapProtocol::AlertUserEvent(const char * message)
+{
+  if (m_imapServerSink)
+  {
+    bool suppressErrorMsg = false;
+
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl);
+    if (mailnewsUrl)
+      mailnewsUrl->GetSuppressErrorMsgs(&suppressErrorMsg);
+
+    if (!suppressErrorMsg)
+      m_imapServerSink->FEAlert(NS_ConvertASCIItoUTF16(message), mailnewsUrl);
+  }
+}
+
+void
+nsImapProtocol::AlertUserEventFromServer(const char * aServerEvent)
+{
+    if (m_imapServerSink && aServerEvent)
+    {
+      nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl);
+      m_imapServerSink->FEAlertFromServer(nsDependentCString(aServerEvent),
+                                          mailnewsUrl);
+    }
+}
+
+void nsImapProtocol::ResetProgressInfo()
+{
+  m_lastProgressTime = 0;
+  m_lastPercent = -1;
+  m_lastProgressStringName.Truncate();
+}
+
+void nsImapProtocol::SetProgressString(const char * stringName)
+{
+  m_progressStringName.Assign(stringName);
+  if (!m_progressStringName.IsEmpty() && m_imapServerSink)
+    m_imapServerSink->GetImapStringByName(stringName,
+                                          m_progressString);
+}
+
+void
+nsImapProtocol::ShowProgress()
+{
+  if (!m_progressString.IsEmpty() && !m_progressStringName.IsEmpty())
+  {
+    char16_t *progressString = NULL;
+    const char *mailboxName = GetServerStateParser().GetSelectedMailboxName();
+    nsString unicodeMailboxName;
+    nsresult rv = CopyMUTF7toUTF16(nsDependentCString(mailboxName),
+                                   unicodeMailboxName);
+    if (NS_SUCCEEDED(rv))
+    {
+      // ### should convert mailboxName to char16_t and change %s to %S in msg text
+      progressString = nsTextFormatter::smprintf(m_progressString.get(),
+                                unicodeMailboxName.get(), ++m_progressIndex, m_progressCount);
+      if (progressString)
+      {
+        PercentProgressUpdateEvent(progressString, m_progressIndex, m_progressCount);
+        nsTextFormatter::smprintf_free(progressString);
+      }
+    }
+  }
+}
+
+void
+nsImapProtocol::ProgressEventFunctionUsingName(const char* aMsgName)
+{
+  if (m_imapMailFolderSink && !m_lastProgressStringName.Equals(aMsgName))
+  {
+    m_imapMailFolderSink->ProgressStatusString(this, aMsgName, nullptr);
+    m_lastProgressStringName.Assign(aMsgName);
+    // who's going to free this? Does ProgressStatusString complete synchronously?
+  }
+}
+
+void
+nsImapProtocol::ProgressEventFunctionUsingNameWithString(const char* aMsgName,
+                                                         const char * aExtraInfo)
+{
+  if (m_imapMailFolderSink)
+  {
+    nsString unicodeStr;
+    nsresult rv = CopyMUTF7toUTF16(nsDependentCString(aExtraInfo), unicodeStr);
+    if (NS_SUCCEEDED(rv))
+      m_imapMailFolderSink->ProgressStatusString(this, aMsgName, unicodeStr.get());
+  }
+}
+
+void
+nsImapProtocol::PercentProgressUpdateEvent(char16_t *message, int64_t currentProgress, int64_t maxProgress)
+{
+  int64_t nowMS = 0;
+  int32_t percent = (100 * currentProgress) / maxProgress;
+  if (percent == m_lastPercent)
+    return; // hasn't changed, right? So just return. Do we need to clear this anywhere?
+
+  if (percent < 100)  // always need to do 100%
+  {
+    nowMS = PR_IntervalToMilliseconds(PR_IntervalNow());
+    if (nowMS - m_lastProgressTime < 750)
+      return;
+  }
+
+  m_lastPercent = percent;
+  m_lastProgressTime = nowMS;
+
+  // set our max progress on the running URL
+  if (m_runningUrl)
+  {
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(m_runningUrl));
+    mailnewsUrl->SetMaxProgress(maxProgress);
+  }
+
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->PercentProgress(this, message, currentProgress, maxProgress);
+}
+
+  // imap commands issued by the parser
+void
+nsImapProtocol::Store(const nsCString &messageList, const char * messageData,
+                      bool idsAreUid)
+{
+
+  // turn messageList back into key array and then back into a message id list,
+  // but use the flag state to handle ranges correctly.
+  nsCString messageIdList;
+  nsTArray<nsMsgKey> msgKeys;
+  if (idsAreUid)
+    ParseUidString(messageList.get(), msgKeys);
+
+  int32_t msgCountLeft = msgKeys.Length();
+  uint32_t msgsHandled = 0;
+  do
+  {
+    nsCString idString;
+
+    uint32_t msgsToHandle = msgCountLeft;
+    if (idsAreUid)
+      AllocateImapUidString(msgKeys.Elements() + msgsHandled, msgsToHandle, m_flagState, idString);  // 20 * 200
+    else
+      idString.Assign(messageList);
+
+
+    msgsHandled += msgsToHandle;
+    msgCountLeft -= msgsToHandle;
+
+    IncrementCommandTagNumber();
+    const char *formatString;
+    if (idsAreUid)
+        formatString = "%s uid store %s %s\015\012";
+    else
+        formatString = "%s store %s %s\015\012";
+
+    // we might need to close this mailbox after this
+    m_closeNeededBeforeSelect = GetDeleteIsMoveToTrash() &&
+        (PL_strcasestr(messageData, "\\Deleted"));
+
+    const char *commandTag = GetServerCommandTag();
+    int protocolStringSize = PL_strlen(formatString) +
+          messageList.Length() + PL_strlen(messageData) +
+          PL_strlen(commandTag) + 1;
+    char *protocolString = (char *) PR_CALLOC( protocolStringSize );
+
+    if (protocolString)
+    {
+      PR_snprintf(protocolString, // string to create
+                    protocolStringSize, // max size
+                    formatString, // format string
+                    commandTag, // command tag
+                    idString.get(),
+                    messageData);
+
+      nsresult rv = SendData(protocolString);
+      if (NS_SUCCEEDED(rv))
+      {
+        m_flagChangeCount++;
+        ParseIMAPandCheckForNewMail(protocolString);
+        if (GetServerStateParser().LastCommandSuccessful() && CheckNeeded())
+          Check();
+      }
+      PR_Free(protocolString);
+    }
+    else
+      HandleMemoryFailure();
+  }
+  while (msgCountLeft > 0 && !DeathSignalReceived());
+
+}
+
+void
+nsImapProtocol::IssueUserDefinedMsgCommand(const char *command, const char * messageList)
+{
+  IncrementCommandTagNumber();
+
+  const char *formatString;
+  formatString = "%s uid %s %s\015\012";
+
+  const char *commandTag = GetServerCommandTag();
+  int protocolStringSize = PL_strlen(formatString) +
+        PL_strlen(messageList) + PL_strlen(command) +
+        PL_strlen(commandTag) + 1;
+  char *protocolString = (char *) PR_CALLOC( protocolStringSize );
+
+  if (protocolString)
+  {
+    PR_snprintf(protocolString, // string to create
+                  protocolStringSize, // max size
+                  formatString, // format string
+                  commandTag, // command tag
+                  command,
+                  messageList);
+
+    nsresult rv = SendData(protocolString);
+    if (NS_SUCCEEDED(rv))
+      ParseIMAPandCheckForNewMail(protocolString);
+    PR_Free(protocolString);
+  }
+  else
+    HandleMemoryFailure();
+}
+
+void
+nsImapProtocol::UidExpunge(const nsCString &messageSet)
+{
+    IncrementCommandTagNumber();
+    nsCString command(GetServerCommandTag());
+    command.Append(" uid expunge ");
+    command.Append(messageSet);
+    command.Append(CRLF);
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail();
+}
+
+void
+nsImapProtocol::Expunge()
+{
+  uint32_t aclFlags = 0;
+  if (GetServerStateParser().ServerHasACLCapability() && m_imapMailFolderSink)
+    m_imapMailFolderSink->GetAclFlags(&aclFlags);
+
+  if (aclFlags && !(aclFlags & IMAP_ACL_EXPUNGE_FLAG))
+    return;
+  ProgressEventFunctionUsingName("imapStatusExpungingMailbox");
+
+  if(gCheckDeletedBeforeExpunge)
+  {
+    GetServerStateParser().ResetSearchResultSequence();
+    Search("SEARCH DELETED", false, false);
+    if (GetServerStateParser().LastCommandSuccessful())
+    {
+      nsImapSearchResultIterator *search = GetServerStateParser().CreateSearchResultIterator();
+      nsMsgKey key = search->GetNextMessageNumber();
+      delete search;
+      if (key == 0)
+        return;  //no deleted messages to expunge (bug 235004)
+    }
+  }
+
+  IncrementCommandTagNumber();
+  nsAutoCString command(GetServerCommandTag());
+  command.Append(" expunge" CRLF);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail();
+}
+
+void
+nsImapProtocol::HandleMemoryFailure()
+{
+    PR_CEnterMonitor(this);
+    // **** jefft fix me!!!!!! ******
+    // m_imapThreadIsRunning = false;
+    // SetConnectionStatus(-1);
+    PR_CExitMonitor(this);
+}
+
+void nsImapProtocol::HandleCurrentUrlError()
+{
+  // This is to handle a move/copy failing, especially because the user
+  // cancelled the password prompt.
+  (void) m_runningUrl->GetImapAction(&m_imapAction);
+    if (m_imapAction == nsIImapUrl::nsImapOfflineToOnlineMove || m_imapAction == nsIImapUrl::nsImapAppendMsgFromFile
+      || m_imapAction == nsIImapUrl::nsImapAppendDraftFromFile)
+  {
+    if (m_imapMailFolderSink)
+      m_imapMailFolderSink->OnlineCopyCompleted(this, ImapOnlineCopyStateType::kFailedCopy);
+  }
+}
+
+void nsImapProtocol::StartTLS()
+{
+    IncrementCommandTagNumber();
+    nsCString command(GetServerCommandTag());
+
+    command.Append(" STARTTLS" CRLF);
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::Capability()
+{
+
+    ProgressEventFunctionUsingName("imapStatusCheckCompat");
+    IncrementCommandTagNumber();
+    nsCString command(GetServerCommandTag());
+
+    command.Append(" capability" CRLF);
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail();
+    if (!gUseLiteralPlus)
+    {
+      eIMAPCapabilityFlags capabilityFlag = GetServerStateParser().GetCapabilityFlag();
+      if (capabilityFlag & kLiteralPlusCapability)
+      {
+        GetServerStateParser().SetCapabilityFlag(capabilityFlag & ~kLiteralPlusCapability);
+      }
+    }
+}
+
+void nsImapProtocol::ID()
+{
+  if (!gAppName[0])
+    return;
+  IncrementCommandTagNumber();
+  nsCString command(GetServerCommandTag());
+  command.Append(" ID (\"name\" \"");
+  command.Append(gAppName);
+  command.Append("\" \"version\" \"");
+  command.Append(gAppVersion);
+  command.Append("\")" CRLF);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::EnableCondStore()
+{
+  IncrementCommandTagNumber();
+  nsCString command(GetServerCommandTag());
+
+  command.Append(" ENABLE CONDSTORE" CRLF);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::StartCompressDeflate()
+{
+  // only issue a compression request if we haven't already
+  if (!TestFlag(IMAP_ISSUED_COMPRESS_REQUEST))
+  {
+    SetFlag(IMAP_ISSUED_COMPRESS_REQUEST);
+    IncrementCommandTagNumber();
+    nsCString command(GetServerCommandTag());
+
+    command.Append(" COMPRESS DEFLATE" CRLF);
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+    {
+      ParseIMAPandCheckForNewMail();
+      if (GetServerStateParser().LastCommandSuccessful())
+      {
+        rv = BeginCompressing();
+        if (NS_FAILED(rv))
+        {
+          Log("CompressDeflate", nullptr, "failed to enable compression");
+          // we can't use this connection without compression any more, so die
+          ClearFlag(IMAP_CONNECTION_IS_OPEN);
+          TellThreadToDie();
+          SetConnectionStatus(rv);
+          return;
+        }
+      }
+    }
+  }
+}
+
+nsresult nsImapProtocol::BeginCompressing()
+{
+  // wrap the streams in compression layers that compress or decompress
+  // all traffic.
+  RefPtr<nsMsgCompressIStream> new_in = new nsMsgCompressIStream();
+  if (!new_in)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsresult rv = new_in->InitInputStream(m_inputStream);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  m_inputStream = new_in;
+
+  RefPtr<nsMsgCompressOStream> new_out = new nsMsgCompressOStream();
+  if (!new_out)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  rv = new_out->InitOutputStream(m_outputStream);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  m_outputStream = new_out;
+  return rv;
+}
+
+void nsImapProtocol::Language()
+{
+  // only issue the language request if we haven't done so already...
+  if (!TestFlag(IMAP_ISSUED_LANGUAGE_REQUEST))
+  {
+    SetFlag(IMAP_ISSUED_LANGUAGE_REQUEST);
+    ProgressEventFunctionUsingName("imapStatusCheckCompat");
+    IncrementCommandTagNumber();
+    nsCString command(GetServerCommandTag());
+
+    // extract the desired language attribute from prefs
+    nsresult rv = NS_OK;
+
+    // we need to parse out the first language out of this comma separated list....
+    // i.e if we have en,ja we only want to send en to the server.
+    if (mAcceptLanguages.get())
+    {
+      nsAutoCString extractedLanguage;
+      LossyCopyUTF16toASCII(mAcceptLanguages, extractedLanguage);
+      int32_t pos = extractedLanguage.FindChar(',');
+      if (pos > 0) // we have a comma separated list of languages...
+        extractedLanguage.SetLength(pos); // truncate everything after the first comma (including the comma)
+
+      if (extractedLanguage.IsEmpty())
+        return;
+
+      command.Append(" LANGUAGE ");
+      command.Append(extractedLanguage);
+      command.Append(CRLF);
+
+      rv = SendData(command.get());
+      if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail(nullptr, true /* ignore bad or no result from the server for this command */);
+    }
+  }
+}
+
+void nsImapProtocol::EscapeUserNamePasswordString(const char *strToEscape, nsCString *resultStr)
+{
+  if (strToEscape)
+  {
+    uint32_t i = 0;
+    uint32_t escapeStrlen = strlen(strToEscape);
+    for (i=0; i<escapeStrlen; i++)
+    {
+        if (strToEscape[i] == '\\' || strToEscape[i] == '\"')
+        {
+            resultStr->Append('\\');
+        }
+        resultStr->Append(strToEscape[i]);
+    }
+  }
+}
+
+void nsImapProtocol::InitPrefAuthMethods(int32_t authMethodPrefValue,
+                                         nsIMsgIncomingServer *aServer)
+{
+    // for m_prefAuthMethods, using the same flags as server capablities.
+    switch (authMethodPrefValue)
+    {
+      case nsMsgAuthMethod::none:
+        m_prefAuthMethods = kHasAuthNoneCapability;
+        break;
+      case nsMsgAuthMethod::old:
+        m_prefAuthMethods = kHasAuthOldLoginCapability;
+        break;
+      case nsMsgAuthMethod::passwordCleartext:
+        m_prefAuthMethods = kHasAuthOldLoginCapability |
+            kHasAuthLoginCapability | kHasAuthPlainCapability;
+        break;
+      case nsMsgAuthMethod::passwordEncrypted:
+        m_prefAuthMethods = kHasCRAMCapability;
+        break;
+      case nsMsgAuthMethod::NTLM:
+        m_prefAuthMethods = kHasAuthNTLMCapability | kHasAuthMSNCapability;
+        break;
+      case nsMsgAuthMethod::GSSAPI:
+        m_prefAuthMethods = kHasAuthGssApiCapability;
+        break;
+      case nsMsgAuthMethod::External:
+        m_prefAuthMethods = kHasAuthExternalCapability;
+        break;
+      case nsMsgAuthMethod::secure:
+        m_prefAuthMethods = kHasCRAMCapability |
+            kHasAuthGssApiCapability |
+            kHasAuthNTLMCapability | kHasAuthMSNCapability;
+        break;
+      default:
+        NS_ASSERTION(false, "IMAP: authMethod pref invalid");
+        // TODO log to error console
+        MOZ_LOG(IMAP, LogLevel::Error,
+            ("IMAP: bad pref authMethod = %d\n", authMethodPrefValue));
+        // fall to any
+        MOZ_FALLTHROUGH;
+      case nsMsgAuthMethod::anything:
+        m_prefAuthMethods = kHasAuthOldLoginCapability |
+            kHasAuthLoginCapability | kHasAuthPlainCapability |
+            kHasCRAMCapability | kHasAuthGssApiCapability |
+            kHasAuthNTLMCapability | kHasAuthMSNCapability |
+            kHasAuthExternalCapability | kHasXOAuth2Capability;
+        break;
+      case nsMsgAuthMethod::OAuth2:
+        m_prefAuthMethods = kHasXOAuth2Capability;
+        break;
+    }
+
+    if (m_prefAuthMethods & kHasXOAuth2Capability)
+      mOAuth2Support = new mozilla::mailnews::OAuth2ThreadHelper(aServer);
+
+    // Disable OAuth2 support if we don't have the prefs installed.
+    if (m_prefAuthMethods & kHasXOAuth2Capability &&
+        (!mOAuth2Support || !mOAuth2Support->SupportsOAuth2()))
+      m_prefAuthMethods &= ~kHasXOAuth2Capability;
+
+    NS_ASSERTION(m_prefAuthMethods != kCapabilityUndefined,
+         "IMAP: InitPrefAuthMethods() didn't work");
+}
+
+/**
+ * Changes m_currentAuthMethod to pick the best remaining one
+ * which is allowed by server and prefs and not marked failed.
+ * The order of preference and trying of auth methods is encoded here.
+ */
+nsresult nsImapProtocol::ChooseAuthMethod()
+{
+  eIMAPCapabilityFlags serverCaps = GetServerStateParser().GetCapabilityFlag();
+  eIMAPCapabilityFlags availCaps = serverCaps & m_prefAuthMethods & ~m_failedAuthMethods;
+
+  MOZ_LOG(IMAP, LogLevel::Debug, ("IMAP auth: server caps 0x%llx, pref 0x%llx, failed 0x%llx, avail caps 0x%llx",
+        serverCaps, m_prefAuthMethods, m_failedAuthMethods, availCaps));
+  MOZ_LOG(IMAP, LogLevel::Debug, ("(GSSAPI = 0x%llx, CRAM = 0x%llx, NTLM = 0x%llx, "
+        "MSN = 0x%llx, PLAIN = 0x%llx,\n  LOGIN = 0x%llx, old-style IMAP login = 0x%llx"
+        ", auth external IMAP login = 0x%llx, OAUTH2 = 0x%llx)",
+        kHasAuthGssApiCapability, kHasCRAMCapability, kHasAuthNTLMCapability,
+        kHasAuthMSNCapability, kHasAuthPlainCapability, kHasAuthLoginCapability,
+        kHasAuthOldLoginCapability, kHasAuthExternalCapability, kHasXOAuth2Capability));
+
+  if (kHasAuthExternalCapability & availCaps)
+    m_currentAuthMethod = kHasAuthExternalCapability;
+  else if (kHasAuthGssApiCapability & availCaps)
+    m_currentAuthMethod = kHasAuthGssApiCapability;
+  else if (kHasCRAMCapability & availCaps)
+    m_currentAuthMethod = kHasCRAMCapability;
+  else if (kHasAuthNTLMCapability & availCaps)
+    m_currentAuthMethod = kHasAuthNTLMCapability;
+  else if (kHasAuthMSNCapability & availCaps)
+    m_currentAuthMethod = kHasAuthMSNCapability;
+  else if (kHasXOAuth2Capability & availCaps)
+    m_currentAuthMethod = kHasXOAuth2Capability;
+  else if (kHasAuthPlainCapability & availCaps)
+    m_currentAuthMethod = kHasAuthPlainCapability;
+  else if (kHasAuthLoginCapability & availCaps)
+    m_currentAuthMethod = kHasAuthLoginCapability;
+  else if (kHasAuthOldLoginCapability & availCaps)
+    m_currentAuthMethod = kHasAuthOldLoginCapability;
+  else
+  {
+    MOZ_LOG(IMAP, LogLevel::Debug, ("no remaining auth method"));
+    m_currentAuthMethod = kCapabilityUndefined;
+    return NS_ERROR_FAILURE;
+  }
+  MOZ_LOG(IMAP, LogLevel::Debug, ("trying auth method 0x%llx", m_currentAuthMethod));
+  return NS_OK;
+}
+
+void nsImapProtocol::MarkAuthMethodAsFailed(eIMAPCapabilityFlags failedAuthMethod)
+{
+  MOZ_LOG(IMAP, LogLevel::Debug, ("marking auth method 0x%llx failed", failedAuthMethod));
+  m_failedAuthMethods |= failedAuthMethod;
+}
+
+/**
+ * Start over, trying all auth methods again
+ */
+void nsImapProtocol::ResetAuthMethods()
+{
+  MOZ_LOG(IMAP, LogLevel::Debug, ("resetting (failed) auth methods"));
+  m_currentAuthMethod = kCapabilityUndefined;
+  m_failedAuthMethods = 0;
+}
+
+nsresult nsImapProtocol::AuthLogin(const char *userName, const nsCString &password, eIMAPCapabilityFlag flag)
+{
+  ProgressEventFunctionUsingName("imapStatusSendingAuthLogin");
+  IncrementCommandTagNumber();
+
+  char * currentCommand=nullptr;
+  nsresult rv;
+
+  MOZ_LOG(IMAP, LogLevel::Debug, ("IMAP: trying auth method 0x%llx", m_currentAuthMethod));
+
+  if (flag & kHasAuthExternalCapability)
+  {
+      char *base64UserName = PL_Base64Encode(userName, strlen(userName), nullptr);
+      nsAutoCString command (GetServerCommandTag());
+      command.Append(" authenticate EXTERNAL " );
+      command.Append(base64UserName);
+      command.Append(CRLF);
+	  PR_Free(base64UserName);
+      rv = SendData(command.get());
+      ParseIMAPandCheckForNewMail();
+      nsImapServerResponseParser &parser = GetServerStateParser();
+      if (parser.LastCommandSuccessful())
+        return NS_OK;
+      parser.SetCapabilityFlag(parser.GetCapabilityFlag() & ~kHasAuthExternalCapability);
+  }
+  else if (flag & kHasCRAMCapability)
+  {
+    NS_ENSURE_TRUE(m_imapServerSink, NS_ERROR_NULL_POINTER);
+    MOZ_LOG(IMAP, LogLevel::Debug, ("MD5 auth"));
+    // inform the server that we want to begin a CRAM authentication procedure...
+    nsAutoCString command (GetServerCommandTag());
+    command.Append(" authenticate CRAM-MD5" CRLF);
+    rv = SendData(command.get());
+    NS_ENSURE_SUCCESS(rv, rv);
+    ParseIMAPandCheckForNewMail();
+    if (GetServerStateParser().LastCommandSuccessful())
+    {
+      char *digest = nullptr;
+      char *cramDigest = GetServerStateParser().fAuthChallenge;
+      char *decodedChallenge = PL_Base64Decode(cramDigest,
+                                                strlen(cramDigest), nullptr);
+      rv = m_imapServerSink->CramMD5Hash(decodedChallenge, password.get(), &digest);
+      PR_Free(decodedChallenge);
+      NS_ENSURE_SUCCESS(rv, rv);
+      NS_ENSURE_TRUE(digest, NS_ERROR_NULL_POINTER);
+      nsAutoCString encodedDigest;
+      char hexVal[8];
+
+      for (uint32_t j=0; j<16; j++)
+      {
+        PR_snprintf (hexVal,8, "%.2x", 0x0ff & (unsigned short)(digest[j]));
+        encodedDigest.Append(hexVal);
+      }
+
+      PR_snprintf(m_dataOutputBuf, OUTPUT_BUFFER_SIZE, "%s %s", userName, encodedDigest.get());
+      char *base64Str = PL_Base64Encode(m_dataOutputBuf, strlen(m_dataOutputBuf), nullptr);
+      PR_snprintf(m_dataOutputBuf, OUTPUT_BUFFER_SIZE, "%s" CRLF, base64Str);
+      PR_Free(base64Str);
+      PR_Free(digest);
+      rv = SendData(m_dataOutputBuf);
+      NS_ENSURE_SUCCESS(rv, rv);
+      ParseIMAPandCheckForNewMail(command.get());
+    }
+  } // if CRAM response was received
+  else if (flag & kHasAuthGssApiCapability)
+  {
+    MOZ_LOG(IMAP, LogLevel::Debug, ("MD5 auth"));
+
+    // Only try GSSAPI once - if it fails, its going to be because we don't
+    // have valid credentials
+    //MarkAuthMethodAsFailed(kHasAuthGssApiCapability);
+
+    // We do step1 first, so we don't try GSSAPI against a server which
+    // we can't get credentials for.
+    nsAutoCString response;
+
+    nsAutoCString service("imap@");
+    service.Append(m_realHostName);
+    rv = DoGSSAPIStep1(service.get(), userName, response);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoCString command (GetServerCommandTag());
+    command.Append(" authenticate GSSAPI" CRLF);
+    rv = SendData(command.get());
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    ParseIMAPandCheckForNewMail("AUTH GSSAPI");
+    if (GetServerStateParser().LastCommandSuccessful())
+    {
+      response += CRLF;
+      rv = SendData(response.get());
+      NS_ENSURE_SUCCESS(rv, rv);
+      ParseIMAPandCheckForNewMail(command.get());
+      nsresult gssrv = NS_OK;
+
+      while (GetServerStateParser().LastCommandSuccessful() &&
+             NS_SUCCEEDED(gssrv) && gssrv != NS_SUCCESS_AUTH_FINISHED)
+      {
+        nsCString challengeStr(GetServerStateParser().fAuthChallenge);
+        gssrv = DoGSSAPIStep2(challengeStr, response);
+        if (NS_SUCCEEDED(gssrv))
+        {
+          response += CRLF;
+          rv = SendData(response.get());
+        }
+        else
+          rv = SendData("*" CRLF);
+
+        NS_ENSURE_SUCCESS(rv, rv);
+        ParseIMAPandCheckForNewMail(command.get());
+      }
+      // TODO: whether it worked or not is shown by LastCommandSuccessful(), not gssrv, right?
+    }
+  }
+  else if (flag & (kHasAuthNTLMCapability | kHasAuthMSNCapability))
+  {
+    MOZ_LOG(IMAP, LogLevel::Debug, ("NTLM auth"));
+    nsAutoCString command (GetServerCommandTag());
+    command.Append((flag & kHasAuthNTLMCapability) ? " authenticate NTLM" CRLF
+                                                   : " authenticate MSN" CRLF);
+    rv = SendData(command.get());
+    ParseIMAPandCheckForNewMail("AUTH NTLM"); // this just waits for ntlm step 1
+    if (GetServerStateParser().LastCommandSuccessful())
+    {
+      nsAutoCString cmd;
+      rv = DoNtlmStep1(userName, password.get(), cmd);
+      NS_ENSURE_SUCCESS(rv, rv);
+      cmd += CRLF;
+      rv = SendData(cmd.get());
+      NS_ENSURE_SUCCESS(rv, rv);
+      ParseIMAPandCheckForNewMail(command.get());
+      if (GetServerStateParser().LastCommandSuccessful())
+      {
+        nsCString challengeStr(GetServerStateParser().fAuthChallenge);
+        nsCString response;
+        rv = DoNtlmStep2(challengeStr, response);
+        NS_ENSURE_SUCCESS(rv, rv);
+        response += CRLF;
+        rv = SendData(response.get());
+        ParseIMAPandCheckForNewMail(command.get());
+      }
+    }
+  }
+  else if (flag & kHasAuthPlainCapability)
+  {
+    MOZ_LOG(IMAP, LogLevel::Debug, ("PLAIN auth"));
+    PR_snprintf(m_dataOutputBuf, OUTPUT_BUFFER_SIZE, "%s authenticate PLAIN" CRLF, GetServerCommandTag());
+    rv = SendData(m_dataOutputBuf);
+    NS_ENSURE_SUCCESS(rv, rv);
+    currentCommand = PL_strdup(m_dataOutputBuf); /* StrAllocCopy(currentCommand, GetOutputBuffer()); */
+    ParseIMAPandCheckForNewMail();
+    if (GetServerStateParser().LastCommandSuccessful())
+    {
+      // RFC 4616
+      char plainstr[512]; // placeholder for "<NUL>userName<NUL>password" TODO nsAutoCString
+      int len = 1; // count for first <NUL> char
+      memset(plainstr, 0, 512);
+      PR_snprintf(&plainstr[1], 510, "%s", userName);
+      len += PL_strlen(userName);
+      len++;  // count for second <NUL> char
+      PR_snprintf(&plainstr[len], 511-len, "%s", password.get());
+      len += password.Length();
+      char *base64Str = PL_Base64Encode(plainstr, len, nullptr);
+      PR_snprintf(m_dataOutputBuf, OUTPUT_BUFFER_SIZE, "%s" CRLF, base64Str);
+      PR_Free(base64Str);
+
+      bool isResend = false;
+      while (true)
+      {
+        // Send authentication string (true: suppress logging the string).
+        rv = SendData(m_dataOutputBuf, true);
+        if (NS_FAILED(rv))
+          break;
+        ParseIMAPandCheckForNewMail(currentCommand);
+        if (!GetServerStateParser().WaitingForMoreClientInput())
+          break;
+
+        // Server is asking for authentication string again. So we send the
+        // same string again although we already know that it will be
+        // rejected again. We do that to get a firm authentication failure
+        // instead of a resend request. That keeps things in order before
+        // failing "authenticate PLAIN" and trying another method if capable.
+        if (isResend)
+        {
+          rv = NS_ERROR_FAILURE;
+          break;
+        }
+        isResend = true;
+      }
+    } // if the last command succeeded
+  } // if auth plain capability
+  else if (flag & kHasAuthLoginCapability)
+  {
+    MOZ_LOG(IMAP, LogLevel::Debug, ("LOGIN auth"));
+    PR_snprintf(m_dataOutputBuf, OUTPUT_BUFFER_SIZE, "%s authenticate LOGIN" CRLF, GetServerCommandTag());
+    rv = SendData(m_dataOutputBuf);
+    NS_ENSURE_SUCCESS(rv, rv);
+    currentCommand = PL_strdup(m_dataOutputBuf);
+    ParseIMAPandCheckForNewMail();
+
+    if (GetServerStateParser().LastCommandSuccessful())
+    {
+      char *base64Str = PL_Base64Encode(userName, PL_strlen(userName), nullptr);
+      PR_snprintf(m_dataOutputBuf, OUTPUT_BUFFER_SIZE, "%s" CRLF, base64Str);
+      PR_Free(base64Str);
+      rv = SendData(m_dataOutputBuf, true /* suppress logging */);
+      if (NS_SUCCEEDED(rv))
+      {
+        ParseIMAPandCheckForNewMail(currentCommand);
+        if (GetServerStateParser().LastCommandSuccessful())
+        {
+          base64Str = PL_Base64Encode(password.get(), password.Length(), nullptr);
+          PR_snprintf(m_dataOutputBuf, OUTPUT_BUFFER_SIZE, "%s" CRLF, base64Str);
+          PR_Free(base64Str);
+          rv = SendData(m_dataOutputBuf, true /* suppress logging */);
+          if (NS_SUCCEEDED(rv))
+            ParseIMAPandCheckForNewMail(currentCommand);
+        } // if last command successful
+      } // if last command successful
+    } // if last command successful
+  } // if has auth login capability
+  else if (flag & kHasAuthOldLoginCapability)
+  {
+    MOZ_LOG(IMAP, LogLevel::Debug, ("old-style auth"));
+    ProgressEventFunctionUsingName("imapStatusSendingLogin");
+    IncrementCommandTagNumber();
+    nsCString command (GetServerCommandTag());
+    nsAutoCString escapedUserName;
+    command.Append(" login \"");
+    EscapeUserNamePasswordString(userName, &escapedUserName);
+    command.Append(escapedUserName);
+    command.Append("\" \"");
+
+    // if the password contains a \, login will fail
+    // turn foo\bar into foo\\bar
+    nsAutoCString correctedPassword;
+    EscapeUserNamePasswordString(password.get(), &correctedPassword);
+    command.Append(correctedPassword);
+    command.Append("\"" CRLF);
+    rv = SendData(command.get(), true /* suppress logging */);
+    NS_ENSURE_SUCCESS(rv, rv);
+    ParseIMAPandCheckForNewMail();
+  }
+  else if (flag & kHasXOAuth2Capability)
+  {
+    MOZ_LOG(IMAP, LogLevel::Debug, ("XOAUTH2 auth"));
+
+    // Get the XOAuth2 base64 string.
+    NS_ASSERTION(mOAuth2Support,
+      "What are we doing here without OAuth2 helper?");
+    if (!mOAuth2Support)
+      return NS_ERROR_UNEXPECTED;
+    nsAutoCString base64Str;
+    mOAuth2Support->GetXOAuth2String(base64Str);
+    mOAuth2Support = nullptr; // Its purpose has been served.
+    if (base64Str.IsEmpty())
+    {
+      MOZ_LOG(IMAP, LogLevel::Debug, ("OAuth2 failed"));
+      return NS_ERROR_FAILURE;
+    }
+
+    // Send the data on the network.
+    nsAutoCString command (GetServerCommandTag());
+    command += " AUTHENTICATE XOAUTH2 ";
+    command += base64Str;
+    command += CRLF;
+    rv = SendData(command.get(), true /* suppress logging */);
+    NS_ENSURE_SUCCESS(rv, rv);
+    ParseIMAPandCheckForNewMail();
+  }
+  else if (flag & kHasAuthNoneCapability)
+  {
+    // TODO What to do? "login <username>" like POP?
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+  else
+  {
+    MOZ_LOG(IMAP, LogLevel::Error, ("flags param has no auth scheme selected"));
+    return NS_ERROR_ILLEGAL_VALUE;
+  }
+
+  PR_Free(currentCommand);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return GetServerStateParser().LastCommandSuccessful() ?
+        NS_OK : NS_ERROR_FAILURE;
+}
+
+void nsImapProtocol::OnLSubFolders()
+{
+  // **** use to find out whether Drafts, Sent, & Templates folder
+  // exists or not even the user didn't subscribe to it
+  char *mailboxName = OnCreateServerSourceFolderPathString();
+  if (mailboxName)
+  {
+    ProgressEventFunctionUsingName("imapStatusLookingForMailbox");
+    IncrementCommandTagNumber();
+    PR_snprintf(m_dataOutputBuf, OUTPUT_BUFFER_SIZE,"%s list \"\" \"%s\"" CRLF, GetServerCommandTag(), mailboxName);
+    nsresult rv = SendData(m_dataOutputBuf);
+    if (NS_SUCCEEDED(rv))
+      ParseIMAPandCheckForNewMail();
+    PR_Free(mailboxName);
+  }
+  else
+  {
+    HandleMemoryFailure();
+  }
+
+}
+
+void nsImapProtocol::OnAppendMsgFromFile()
+{
+  nsCOMPtr<nsIFile> file;
+  nsresult rv = NS_OK;
+  rv = m_runningUrl->GetMsgFile(getter_AddRefs(file));
+  if (NS_SUCCEEDED(rv) && file)
+  {
+    char *mailboxName =  OnCreateServerSourceFolderPathString();
+    if (mailboxName)
+    {
+      imapMessageFlagsType flagsToSet = 0;
+      uint32_t msgFlags = 0;
+      PRTime date = 0;
+      nsCString keywords;
+      if (m_imapMessageSink)
+        m_imapMessageSink->GetCurMoveCopyMessageInfo(m_runningUrl, &date,
+                                                     keywords, &msgFlags);
+
+      if (msgFlags & nsMsgMessageFlags::Read)
+        flagsToSet |= kImapMsgSeenFlag;
+      if (msgFlags & nsMsgMessageFlags::MDNReportSent)
+        flagsToSet |= kImapMsgMDNSentFlag;
+      // convert msg flag label (0xE000000) to imap flag label (0x0E00)
+      if (msgFlags & nsMsgMessageFlags::Labels)
+        flagsToSet |= (msgFlags & nsMsgMessageFlags::Labels) >> 16;
+      if (msgFlags & nsMsgMessageFlags::Marked)
+        flagsToSet |= kImapMsgFlaggedFlag;
+      if (msgFlags & nsMsgMessageFlags::Replied)
+        flagsToSet |= kImapMsgAnsweredFlag;
+      if (msgFlags & nsMsgMessageFlags::Forwarded)
+        flagsToSet |= kImapMsgForwardedFlag;
+
+      // If the message copied was a draft, flag it as such
+      nsImapAction imapAction;
+      rv = m_runningUrl->GetImapAction(&imapAction);
+      if (NS_SUCCEEDED(rv) && (imapAction == nsIImapUrl::nsImapAppendDraftFromFile))
+        flagsToSet |= kImapMsgDraftFlag;
+      UploadMessageFromFile(file, mailboxName, date, flagsToSet, keywords);
+      PR_Free( mailboxName );
+    }
+    else
+    {
+      HandleMemoryFailure();
+    }
+  }
+}
+
+void nsImapProtocol::UploadMessageFromFile (nsIFile* file,
+                                            const char* mailboxName,
+                                            PRTime date,
+                                            imapMessageFlagsType flags,
+                                            nsCString &keywords)
+{
+  if (!file || !mailboxName) return;
+  IncrementCommandTagNumber();
+
+  int64_t fileSize = 0;
+  int64_t totalSize;
+  uint32_t readCount;
+  char *dataBuffer = nullptr;
+  nsCString command(GetServerCommandTag());
+  nsCString escapedName;
+  CreateEscapedMailboxName(mailboxName, escapedName);
+  nsresult rv;
+  bool eof = false;
+  nsCString flagString;
+  bool hasLiteralPlus = (GetServerStateParser().GetCapabilityFlag() &
+    kLiteralPlusCapability);
+
+  nsCOMPtr <nsIInputStream> fileInputStream;
+
+  if (!escapedName.IsEmpty())
+  {
+    command.Append(" append \"");
+    command.Append(escapedName);
+    command.Append("\"");
+    if (flags || keywords.Length())
+    {
+      command.Append(" (");
+
+      if (flags)
+      {
+        SetupMessageFlagsString(flagString, flags,
+          GetServerStateParser().SupportsUserFlags());
+        command.Append(flagString);
+      }
+      if (keywords.Length())
+      {
+        if (flags)
+          command.Append(' ');
+        command.Append(keywords);
+      }
+      command.Append(")");
+    }
+
+    // date should never be 0, but just in case...
+    if (date)
+    {
+      /* Use PR_FormatTimeUSEnglish() to format the date in US English format,
+        then figure out what our local GMT offset is, and append it (since
+        PR_FormatTimeUSEnglish() can't do that.) Generate four digit years as
+        per RFC 1123 (superceding RFC 822.)
+        */
+      char szDateTime[64];
+      char dateStr[100];
+      PRExplodedTime exploded;
+      PR_ExplodeTime(date, PR_LocalTimeParameters, &exploded);
+      PR_FormatTimeUSEnglish(szDateTime, sizeof(szDateTime), "%d-%b-%Y %H:%M:%S", &exploded);
+      PRExplodedTime now;
+      PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &now);
+      int gmtoffset = (now.tm_params.tp_gmt_offset + now.tm_params.tp_dst_offset) / 60;
+      PR_snprintf(dateStr, sizeof(dateStr),
+                            " \"%s %c%02d%02d\"",
+                            szDateTime,
+                            (gmtoffset >= 0 ? '+' : '-'),
+                            ((gmtoffset >= 0 ? gmtoffset : -gmtoffset) / 60),
+                            ((gmtoffset >= 0 ? gmtoffset : -gmtoffset) % 60));
+
+      command.Append(dateStr);
+    }
+    command.Append(" {");
+
+    dataBuffer = (char*) PR_CALLOC(COPY_BUFFER_SIZE+1);
+    if (!dataBuffer) goto done;
+    rv = file->GetFileSize(&fileSize);
+    NS_ASSERTION(fileSize, "got empty file in UploadMessageFromFile");
+    if (NS_FAILED(rv) || !fileSize) goto done;
+    rv = NS_NewLocalFileInputStream(getter_AddRefs(fileInputStream), file);
+    if (NS_FAILED(rv) || !fileInputStream) goto done;
+    command.AppendInt((int32_t)fileSize);
+    if (hasLiteralPlus)
+      command.Append("+}" CRLF);
+    else
+      command.Append("}" CRLF);
+
+    rv = SendData(command.get());
+    if (NS_FAILED(rv)) goto done;
+
+    if (!hasLiteralPlus)
+      ParseIMAPandCheckForNewMail();
+
+    totalSize = fileSize;
+    readCount = 0;
+    while(NS_SUCCEEDED(rv) && !eof && totalSize > 0)
+    {
+      rv = fileInputStream->Read(dataBuffer, COPY_BUFFER_SIZE, &readCount);
+      if (NS_SUCCEEDED(rv) && !readCount)
+        rv = NS_ERROR_FAILURE;
+
+      if (NS_SUCCEEDED(rv))
+      {
+        NS_ASSERTION(readCount <= (uint32_t) totalSize, "got more bytes than there should be");
+        dataBuffer[readCount] = 0;
+        rv = SendData(dataBuffer);
+        totalSize -= readCount;
+        PercentProgressUpdateEvent(nullptr, fileSize - totalSize, fileSize);
+      }
+    }
+    if (NS_SUCCEEDED(rv))
+    {
+      rv = SendData(CRLF); // complete the append
+      ParseIMAPandCheckForNewMail(command.get());
+
+      nsImapAction imapAction;
+      m_runningUrl->GetImapAction(&imapAction);
+
+      if (GetServerStateParser().LastCommandSuccessful() &&  (
+        imapAction == nsIImapUrl::nsImapAppendDraftFromFile  || imapAction==nsIImapUrl::nsImapAppendMsgFromFile))
+      {
+        if (GetServerStateParser().GetCapabilityFlag() &
+          kUidplusCapability)
+        {
+          nsMsgKey newKey = GetServerStateParser().CurrentResponseUID();
+          if (m_imapMailFolderSink)
+            m_imapMailFolderSink->SetAppendMsgUid(newKey, m_runningUrl);
+
+          // Courier imap server seems to have problems with recently
+          // appended messages. Noop seems to clear its confusion.
+          if (FolderIsSelected(mailboxName))
+              Noop();
+
+          nsCString oldMsgId;
+          rv = m_runningUrl->GetListOfMessageIds(oldMsgId);
+          if (NS_SUCCEEDED(rv) && !oldMsgId.IsEmpty())
+          {
+            bool idsAreUids = true;
+            m_runningUrl->MessageIdsAreUids(&idsAreUids);
+            Store(oldMsgId, "+FLAGS (\\Deleted)", idsAreUids);
+            UidExpunge(oldMsgId);
+          }
+        }
+        // for non UIDPLUS servers,
+        // this code used to check for imapAction==nsIImapUrl::nsImapAppendMsgFromFile, which
+        // meant we'd get into this code whenever sending a message, as well
+        // as when copying messages to an imap folder from local folders or an other imap server.
+        // This made sending a message slow when there was a large sent folder. I don't believe
+        // this code worked anyway.
+        else if (m_imapMailFolderSink && imapAction == nsIImapUrl::nsImapAppendDraftFromFile )
+        {   // *** code me to search for the newly appended message
+          // go to selected state
+          nsCString messageId;
+          rv = m_imapMailFolderSink->GetMessageId(m_runningUrl, messageId);
+          if (NS_SUCCEEDED(rv) && !messageId.IsEmpty() &&
+            GetServerStateParser().LastCommandSuccessful())
+          {
+            // if the appended to folder isn't selected in the connection,
+            // select it.
+            if (!FolderIsSelected(mailboxName))
+              SelectMailbox(mailboxName);
+            else
+              Noop(); // See if this makes SEARCH work on the newly appended msg.
+
+            if (GetServerStateParser().LastCommandSuccessful())
+            {
+              command = "SEARCH UNDELETED HEADER Message-ID ";
+              command.Append(messageId);
+
+              // Clean up result sequence before issuing the cmd.
+              GetServerStateParser().ResetSearchResultSequence();
+
+              Search(command.get(), true, false);
+              if (GetServerStateParser().LastCommandSuccessful())
+              {
+                nsMsgKey newkey = nsMsgKey_None;
+                nsImapSearchResultIterator *searchResult =
+                  GetServerStateParser().CreateSearchResultIterator();
+                newkey = searchResult->GetNextMessageNumber();
+                delete searchResult;
+                if (newkey != nsMsgKey_None)
+                  m_imapMailFolderSink->SetAppendMsgUid(newkey, m_runningUrl);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+done:
+  PR_Free(dataBuffer);
+  if (fileInputStream)
+    fileInputStream->Close();
+}
+
+//caller must free using PR_Free
+char * nsImapProtocol::OnCreateServerSourceFolderPathString()
+{
+  char *sourceMailbox = nullptr;
+  char hierarchyDelimiter = 0;
+  char onlineDelimiter = 0;
+  m_runningUrl->GetOnlineSubDirSeparator(&hierarchyDelimiter);
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->GetOnlineDelimiter(&onlineDelimiter);
+
+  if (onlineDelimiter != kOnlineHierarchySeparatorUnknown &&
+      onlineDelimiter != hierarchyDelimiter)
+    m_runningUrl->SetOnlineSubDirSeparator(onlineDelimiter);
+
+  m_runningUrl->CreateServerSourceFolderPathString(&sourceMailbox);
+
+  return sourceMailbox;
+}
+
+//caller must free using PR_Free, safe to call from ui thread
+char * nsImapProtocol::GetFolderPathString()
+{
+  char *sourceMailbox = nullptr;
+  char onlineSubDirDelimiter = 0;
+  char hierarchyDelimiter = 0;
+  nsCOMPtr <nsIMsgFolder> msgFolder;
+
+  m_runningUrl->GetOnlineSubDirSeparator(&onlineSubDirDelimiter);
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningUrl);
+  mailnewsUrl->GetFolder(getter_AddRefs(msgFolder));
+  if (msgFolder)
+  {
+    nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(msgFolder);
+    if (imapFolder)
+    {
+      imapFolder->GetHierarchyDelimiter(&hierarchyDelimiter);
+      if (hierarchyDelimiter != kOnlineHierarchySeparatorUnknown &&
+          onlineSubDirDelimiter != hierarchyDelimiter)
+        m_runningUrl->SetOnlineSubDirSeparator(hierarchyDelimiter);
+    }
+  }
+  m_runningUrl->CreateServerSourceFolderPathString(&sourceMailbox);
+
+  return sourceMailbox;
+}
+
+nsresult nsImapProtocol::CreateServerSourceFolderPathString(char **result)
+{
+  NS_ENSURE_ARG(result);
+  *result = OnCreateServerSourceFolderPathString();
+  return (*result) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+//caller must free using PR_Free
+char * nsImapProtocol::OnCreateServerDestinationFolderPathString()
+{
+  char *destinationMailbox = nullptr;
+  char hierarchyDelimiter = 0;
+  char onlineDelimiter = 0;
+  m_runningUrl->GetOnlineSubDirSeparator(&hierarchyDelimiter);
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->GetOnlineDelimiter(&onlineDelimiter);
+  if (onlineDelimiter != kOnlineHierarchySeparatorUnknown &&
+      onlineDelimiter != hierarchyDelimiter)
+    m_runningUrl->SetOnlineSubDirSeparator(onlineDelimiter);
+
+  m_runningUrl->CreateServerDestinationFolderPathString(&destinationMailbox);
+
+  return destinationMailbox;
+}
+
+void nsImapProtocol::OnCreateFolder(const char * aSourceMailbox)
+{
+  bool created = CreateMailboxRespectingSubscriptions(aSourceMailbox);
+  if (created)
+  {
+    m_hierarchyNameState = kListingForCreate;
+    nsCString mailboxWODelim(aSourceMailbox);
+    RemoveHierarchyDelimiter(mailboxWODelim);
+    List(mailboxWODelim.get(), false);
+    m_hierarchyNameState = kNoOperationInProgress;
+  }
+  else
+    FolderNotCreated(aSourceMailbox);
+}
+
+void nsImapProtocol::OnEnsureExistsFolder(const char * aSourceMailbox)
+{
+
+  List(aSourceMailbox, false); // how to tell if that succeeded?
+  bool exists = false;
+
+  // try converting aSourceMailbox to canonical format
+
+  nsIMAPNamespace *nsForMailbox = nullptr;
+  m_hostSessionList->GetNamespaceForMailboxForHost(GetImapServerKey(),
+                                                     aSourceMailbox, nsForMailbox);
+  // NS_ASSERTION (nsForMailbox, "Oops .. null nsForMailbox\n");
+
+  nsCString name;
+
+  if (nsForMailbox)
+    m_runningUrl->AllocateCanonicalPath(aSourceMailbox,
+                                            nsForMailbox->GetDelimiter(),
+                                            getter_Copies(name));
+  else
+    m_runningUrl->AllocateCanonicalPath(aSourceMailbox,
+                                            kOnlineHierarchySeparatorUnknown,
+                                            getter_Copies(name));
+
+  if (m_imapServerSink)
+    m_imapServerSink->FolderVerifiedOnline(name, &exists);
+
+  if (exists)
+  {
+    Subscribe(aSourceMailbox);
+  }
+  else
+  {
+    bool created = CreateMailboxRespectingSubscriptions(aSourceMailbox);
+    if (created)
+    {
+        List(aSourceMailbox, false);
+    }
+  }
+  if (!GetServerStateParser().LastCommandSuccessful())
+        FolderNotCreated(aSourceMailbox);
+}
+
+
+void nsImapProtocol::OnSubscribe(const char * sourceMailbox)
+{
+  Subscribe(sourceMailbox);
+}
+
+void nsImapProtocol::OnUnsubscribe(const char * sourceMailbox)
+{
+  // When we try to auto-unsubscribe from \Noselect folders,
+  // some servers report errors if we were already unsubscribed
+  // from them.
+  bool lastReportingErrors = GetServerStateParser().GetReportingErrors();
+  GetServerStateParser().SetReportingErrors(false);
+  Unsubscribe(sourceMailbox);
+  GetServerStateParser().SetReportingErrors(lastReportingErrors);
+}
+
+void nsImapProtocol::RefreshACLForFolderIfNecessary(const char *mailboxName)
+{
+  if (GetServerStateParser().ServerHasACLCapability())
+  {
+    if (!m_folderNeedsACLRefreshed && m_imapMailFolderSink)
+      m_imapMailFolderSink->GetFolderNeedsACLListed(&m_folderNeedsACLRefreshed);
+    if (m_folderNeedsACLRefreshed)
+    {
+      RefreshACLForFolder(mailboxName);
+      m_folderNeedsACLRefreshed = false;
+    }
+  }
+}
+
+void nsImapProtocol::RefreshACLForFolder(const char *mailboxName)
+{
+
+  nsIMAPNamespace *ns = nullptr;
+  m_hostSessionList->GetNamespaceForMailboxForHost(GetImapServerKey(), mailboxName, ns);
+  if (ns)
+  {
+    switch (ns->GetType())
+    {
+    case kPersonalNamespace:
+      // It's a personal folder, most likely.
+      // I find it hard to imagine a server that supports ACL that doesn't support NAMESPACE,
+      // so most likely we KNOW that this is a personal, rather than the default, namespace.
+
+      // First, clear what we have.
+      ClearAllFolderRights();
+      // Now, get the new one.
+      GetMyRightsForFolder(mailboxName);
+      if (m_imapMailFolderSink)
+      {
+        uint32_t aclFlags = 0;
+        if (NS_SUCCEEDED(m_imapMailFolderSink->GetAclFlags(&aclFlags)) && aclFlags & IMAP_ACL_ADMINISTER_FLAG)
+            GetACLForFolder(mailboxName);
+      }
+
+      // We're all done, refresh the icon/flags for this folder
+      RefreshFolderACLView(mailboxName, ns);
+      break;
+    default:
+      // We know it's a public folder or other user's folder.
+      // We only want our own rights
+
+      // First, clear what we have
+      ClearAllFolderRights();
+      // Now, get the new one.
+      GetMyRightsForFolder(mailboxName);
+      // We're all done, refresh the icon/flags for this folder
+      RefreshFolderACLView(mailboxName, ns);
+      break;
+    }
+  }
+  else
+  {
+    // no namespace, not even default... can this happen?
+    NS_ASSERTION(false, "couldn't get namespace");
+  }
+}
+
+void nsImapProtocol::RefreshFolderACLView(const char *mailboxName, nsIMAPNamespace *nsForMailbox)
+{
+  nsCString canonicalMailboxName;
+
+  if (nsForMailbox)
+    m_runningUrl->AllocateCanonicalPath(mailboxName, nsForMailbox->GetDelimiter(), getter_Copies(canonicalMailboxName));
+  else
+    m_runningUrl->AllocateCanonicalPath(mailboxName, kOnlineHierarchySeparatorUnknown, getter_Copies(canonicalMailboxName));
+
+  if (m_imapServerSink)
+    m_imapServerSink->RefreshFolderRights(canonicalMailboxName);
+}
+
+void nsImapProtocol::GetACLForFolder(const char *mailboxName)
+{
+  IncrementCommandTagNumber();
+
+  nsCString command(GetServerCommandTag());
+  nsCString escapedName;
+  CreateEscapedMailboxName(mailboxName, escapedName);
+  command.Append(" getacl \"");
+  command.Append(escapedName);
+  command.Append("\"" CRLF);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::OnRefreshAllACLs()
+{
+  m_hierarchyNameState = kListingForInfoOnly;
+  nsIMAPMailboxInfo *mb = NULL;
+
+  // This will fill in the list
+  List("*", true);
+
+  int32_t total = m_listedMailboxList.Length(), count = 0;
+  GetServerStateParser().SetReportingErrors(false);
+  for (int32_t i = 0; i < total; i++)
+  {
+    mb = m_listedMailboxList.ElementAt(i);
+    if (mb) // paranoia
+    {
+      char *onlineName = nullptr;
+      m_runningUrl->AllocateServerPath(PromiseFlatCString(mb->GetMailboxName()).get(), mb->GetDelimiter(), &onlineName);
+      if (onlineName)
+      {
+        RefreshACLForFolder(onlineName);
+        NS_Free(onlineName);
+      }
+      PercentProgressUpdateEvent(NULL, count, total);
+      delete mb;
+      count++;
+    }
+  }
+  m_listedMailboxList.Clear();
+
+  PercentProgressUpdateEvent(NULL, 100, 100);
+  GetServerStateParser().SetReportingErrors(true);
+  m_hierarchyNameState = kNoOperationInProgress;
+}
+
+// any state commands
+void nsImapProtocol::Logout(bool shuttingDown /* = false */,
+                            bool waitForResponse /* = true */)
+{
+  if (!shuttingDown)
+    ProgressEventFunctionUsingName("imapStatusLoggingOut");
+
+/******************************************************************
+ * due to the undo functionality we cannot issule a close when logout; there
+ * is no way to do an undo if the message has been permanently expunge
+ * jt - 07/12/1999
+
+    bool closeNeeded = GetServerStateParser().GetIMAPstate() ==
+        nsImapServerResponseParser::kFolderSelected;
+
+    if (closeNeeded && GetDeleteIsMoveToTrash())
+        Close();
+********************/
+
+  IncrementCommandTagNumber();
+
+  nsCString command(GetServerCommandTag());
+
+  command.Append(" logout" CRLF);
+
+  nsresult rv = SendData(command.get());
+  if (m_transport && shuttingDown)
+    m_transport->SetTimeout(nsISocketTransport::TIMEOUT_READ_WRITE, 5);
+  // the socket may be dead before we read the response, so drop it.
+  if (NS_SUCCEEDED(rv) && waitForResponse)
+      ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::Noop()
+{
+  //ProgressUpdateEvent("noop...");
+  IncrementCommandTagNumber();
+  nsCString command(GetServerCommandTag());
+
+  command.Append(" noop" CRLF);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+      ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::XServerInfo()
+{
+
+    ProgressEventFunctionUsingName("imapGettingServerInfo");
+    IncrementCommandTagNumber();
+    nsCString command(GetServerCommandTag());
+
+  command.Append(" XSERVERINFO MANAGEACCOUNTURL MANAGELISTSURL MANAGEFILTERSURL" CRLF);
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::Netscape()
+{
+    ProgressEventFunctionUsingName("imapGettingServerInfo");
+    IncrementCommandTagNumber();
+
+    nsCString command(GetServerCommandTag());
+
+  command.Append(" netscape" CRLF);
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail();
+}
+
+
+
+void nsImapProtocol::XMailboxInfo(const char *mailboxName)
+{
+
+    ProgressEventFunctionUsingName("imapGettingMailboxInfo");
+    IncrementCommandTagNumber();
+    nsCString command(GetServerCommandTag());
+
+  command.Append(" XMAILBOXINFO \"");
+  command.Append(mailboxName);
+  command.Append("\" MANAGEURL POSTURL" CRLF);
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::Namespace()
+{
+
+    IncrementCommandTagNumber();
+
+  nsCString command(GetServerCommandTag());
+  command.Append(" namespace" CRLF);
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail();
+}
+
+
+void nsImapProtocol::MailboxData()
+{
+    IncrementCommandTagNumber();
+
+  nsCString command(GetServerCommandTag());
+  command.Append(" mailboxdata" CRLF);
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail();
+}
+
+
+void nsImapProtocol::GetMyRightsForFolder(const char *mailboxName)
+{
+  IncrementCommandTagNumber();
+
+  nsCString command(GetServerCommandTag());
+  nsCString escapedName;
+  CreateEscapedMailboxName(mailboxName, escapedName);
+
+  if (MailboxIsNoSelectMailbox(escapedName.get()))
+    return; // Don't issue myrights on Noselect folder
+
+  command.Append(" myrights \"");
+  command.Append(escapedName);
+  command.Append("\"" CRLF);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail();
+}
+
+bool nsImapProtocol::FolderIsSelected(const char *mailboxName)
+{
+  return (GetServerStateParser().GetIMAPstate() ==
+      nsImapServerResponseParser::kFolderSelected && GetServerStateParser().GetSelectedMailboxName() &&
+      PL_strcmp(GetServerStateParser().GetSelectedMailboxName(),
+                    mailboxName) == 0);
+}
+
+void nsImapProtocol::OnStatusForFolder(const char *mailboxName)
+{
+
+  if (FolderIsSelected(mailboxName))
+  {
+    int32_t prevNumMessages = GetServerStateParser().NumberOfMessages();
+    Noop();
+    // OnNewIdleMessages will cause the ui thread to update the folder
+    if (m_imapMailFolderSink && (GetServerStateParser().NumberOfRecentMessages()
+          || prevNumMessages != GetServerStateParser().NumberOfMessages()))
+      m_imapMailFolderSink->OnNewIdleMessages();
+    return;
+  }
+
+  IncrementCommandTagNumber();
+
+  nsAutoCString command(GetServerCommandTag());
+  nsCString escapedName;
+  CreateEscapedMailboxName(mailboxName, escapedName);
+
+  command.Append(" STATUS \"");
+  command.Append(escapedName);
+  command.Append("\" (UIDNEXT MESSAGES UNSEEN RECENT)" CRLF);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+      ParseIMAPandCheckForNewMail();
+
+  if (GetServerStateParser().LastCommandSuccessful())
+  {
+    nsImapMailboxSpec *new_spec = GetServerStateParser().CreateCurrentMailboxSpec(mailboxName);
+    if (new_spec && m_imapMailFolderSink)
+      m_imapMailFolderSink->UpdateImapMailboxStatus(this, new_spec);
+    NS_IF_RELEASE(new_spec);
+  }
+}
+
+
+void nsImapProtocol::OnListFolder(const char * aSourceMailbox, bool aBool)
+{
+  List(aSourceMailbox, aBool);
+}
+
+
+// Returns true if the mailbox is a NoSelect mailbox.
+// If we don't know about it, returns false.
+bool nsImapProtocol::MailboxIsNoSelectMailbox(const char *mailboxName)
+{
+  bool rv = false;
+
+  nsIMAPNamespace *nsForMailbox = nullptr;
+    m_hostSessionList->GetNamespaceForMailboxForHost(GetImapServerKey(),
+                                                     mailboxName, nsForMailbox);
+  // NS_ASSERTION (nsForMailbox, "Oops .. null nsForMailbox\n");
+
+  nsCString name;
+
+  if (nsForMailbox)
+    m_runningUrl->AllocateCanonicalPath(mailboxName,
+                                            nsForMailbox->GetDelimiter(),
+                                            getter_Copies(name));
+  else
+    m_runningUrl->AllocateCanonicalPath(mailboxName,
+                                            kOnlineHierarchySeparatorUnknown,
+                                            getter_Copies(name));
+
+  if (name.IsEmpty())
+    return false;
+
+  NS_ASSERTION(m_imapServerSink, "unexpected, no imap server sink, see bug #194335");
+  if (m_imapServerSink)
+    m_imapServerSink->FolderIsNoSelect(name, &rv);
+  return rv;
+}
+
+nsresult nsImapProtocol::SetFolderAdminUrl(const char *mailboxName)
+{
+  nsresult rv = NS_ERROR_NULL_POINTER; // if m_imapServerSink is null, rv will be this.
+
+  nsIMAPNamespace *nsForMailbox = nullptr;
+  m_hostSessionList->GetNamespaceForMailboxForHost(GetImapServerKey(),
+                                                     mailboxName, nsForMailbox);
+
+  nsCString name;
+
+  if (nsForMailbox)
+    m_runningUrl->AllocateCanonicalPath(mailboxName,
+                                            nsForMailbox->GetDelimiter(),
+                                            getter_Copies(name));
+  else
+    m_runningUrl->AllocateCanonicalPath(mailboxName,
+                                            kOnlineHierarchySeparatorUnknown,
+                                            getter_Copies(name));
+
+  if (m_imapServerSink)
+    rv = m_imapServerSink->SetFolderAdminURL(name, nsDependentCString(GetServerStateParser().GetManageFolderUrl()));
+  return rv;
+}
+// returns true is the delete succeeded (regardless of subscription changes)
+bool nsImapProtocol::DeleteMailboxRespectingSubscriptions(const char *mailboxName)
+{
+  bool rv = true;
+  if (!MailboxIsNoSelectMailbox(mailboxName))
+  {
+    // Only try to delete it if it really exists
+    DeleteMailbox(mailboxName);
+    rv = GetServerStateParser().LastCommandSuccessful();
+  }
+
+  // We can unsubscribe even if the mailbox doesn't exist.
+  if (rv && m_autoUnsubscribe) // auto-unsubscribe is on
+  {
+    bool reportingErrors = GetServerStateParser().GetReportingErrors();
+    GetServerStateParser().SetReportingErrors(false);
+    Unsubscribe(mailboxName);
+    GetServerStateParser().SetReportingErrors(reportingErrors);
+
+  }
+  return (rv);
+}
+
+// returns true is the rename succeeded (regardless of subscription changes)
+// reallyRename tells us if we should really do the rename (true) or if we should just move subscriptions (false)
+bool nsImapProtocol::RenameMailboxRespectingSubscriptions(const char *existingName, const char *newName, bool reallyRename)
+{
+  bool rv = true;
+  if (reallyRename && !MailboxIsNoSelectMailbox(existingName))
+  {
+    RenameMailbox(existingName, newName);
+    rv = GetServerStateParser().LastCommandSuccessful();
+  }
+
+  if (rv)
+  {
+    if (m_autoSubscribe)  // if auto-subscribe is on
+    {
+      bool reportingErrors = GetServerStateParser().GetReportingErrors();
+      GetServerStateParser().SetReportingErrors(false);
+      Subscribe(newName);
+      GetServerStateParser().SetReportingErrors(reportingErrors);
+    }
+    if (m_autoUnsubscribe) // if auto-unsubscribe is on
+    {
+      bool reportingErrors = GetServerStateParser().GetReportingErrors();
+      GetServerStateParser().SetReportingErrors(false);
+      Unsubscribe(existingName);
+      GetServerStateParser().SetReportingErrors(reportingErrors);
+    }
+  }
+  return (rv);
+}
+
+bool nsImapProtocol::RenameHierarchyByHand(const char *oldParentMailboxName,
+                                             const char *newParentMailboxName)
+{
+  bool renameSucceeded = true;
+    char onlineDirSeparator = kOnlineHierarchySeparatorUnknown;
+  m_deletableChildren = new nsTArray<char*>();
+
+  bool nonHierarchicalRename =
+        ((GetServerStateParser().GetCapabilityFlag() & kNoHierarchyRename)
+         || MailboxIsNoSelectMailbox(oldParentMailboxName));
+
+  if (m_deletableChildren)
+  {
+    m_hierarchyNameState = kDeleteSubFoldersInProgress;
+    nsIMAPNamespace *ns = nullptr;
+        m_hostSessionList->GetNamespaceForMailboxForHost(GetImapServerKey(),
+                                                         oldParentMailboxName,
+                                                         ns); // for delimiter
+    if (!ns)
+    {
+      if (!PL_strcasecmp(oldParentMailboxName, "INBOX"))
+                m_hostSessionList->GetDefaultNamespaceOfTypeForHost(GetImapServerKey(),
+                                                                    kPersonalNamespace,
+                                                                    ns);
+    }
+    if (ns)
+    {
+            nsCString pattern(oldParentMailboxName);
+            pattern += ns->GetDelimiter();
+            pattern += "*";
+            bool isUsingSubscription = false;
+            m_hostSessionList->GetHostIsUsingSubscription(GetImapServerKey(),
+                                                          isUsingSubscription);
+
+            if (isUsingSubscription)
+                Lsub(pattern.get(), false);
+            else
+                List(pattern.get(), false);
+    }
+    m_hierarchyNameState = kNoOperationInProgress;
+
+    if (GetServerStateParser().LastCommandSuccessful())
+      renameSucceeded = // rename this, and move subscriptions
+                RenameMailboxRespectingSubscriptions(oldParentMailboxName,
+                                                     newParentMailboxName, true);
+
+    size_t numberToDelete = m_deletableChildren->Length();
+    size_t childIndex;
+
+    for (childIndex = 0;
+             (childIndex < numberToDelete) && renameSucceeded; childIndex++)
+    {
+      // the imap parser has already converted to a non UTF7 string in the canonical
+      // format so convert it back
+        char *currentName = m_deletableChildren->ElementAt(childIndex);
+        if (currentName)
+        {
+          char *serverName = nullptr;
+          m_runningUrl->AllocateServerPath(currentName,
+                                         onlineDirSeparator,
+                                         &serverName);
+          PR_FREEIF(currentName);
+          currentName = serverName;
+        }
+
+        // calculate the new name and do the rename
+        nsCString newChildName(newParentMailboxName);
+        newChildName += (currentName + PL_strlen(oldParentMailboxName));
+        // Pass in 'nonHierarchicalRename' to determine if we should really
+        // reanme, or just move subscriptions.
+        renameSucceeded =
+          RenameMailboxRespectingSubscriptions(currentName,
+                                               newChildName.get(),
+                                               nonHierarchicalRename);
+        PR_FREEIF(currentName);
+    }
+
+    delete m_deletableChildren;
+    m_deletableChildren = nullptr;
+  }
+
+  return renameSucceeded;
+}
+
+bool nsImapProtocol::DeleteSubFolders(const char* selectedMailbox, bool &aDeleteSelf)
+{
+  bool deleteSucceeded = true;
+  m_deletableChildren = new nsTArray<char*>();
+
+  if (m_deletableChildren)
+  {
+    bool folderDeleted = false;
+
+    m_hierarchyNameState = kDeleteSubFoldersInProgress;
+        nsCString pattern(selectedMailbox);
+        char onlineDirSeparator = kOnlineHierarchySeparatorUnknown;
+        m_runningUrl->GetOnlineSubDirSeparator(&onlineDirSeparator);
+        pattern.Append(onlineDirSeparator);
+        pattern.Append('*');
+
+    if (!pattern.IsEmpty())
+    {
+      List(pattern.get(), false);
+    }
+    m_hierarchyNameState = kNoOperationInProgress;
+
+    // this should be a short list so perform a sequential search for the
+    // longest name mailbox.  Deleting the longest first will hopefully
+        // prevent the server from having problems about deleting parents
+        // ** jt - why? I don't understand this.
+    size_t numberToDelete = m_deletableChildren->Length();
+    size_t outerIndex, innerIndex;
+
+    // intelligently decide if myself(either plain format or following the dir-separator)
+    // is in the sub-folder list
+    bool folderInSubfolderList = false; // For Performance
+    char *selectedMailboxDir = nullptr;
+    {
+        int32_t length = strlen(selectedMailbox);
+        selectedMailboxDir = (char *)PR_MALLOC(length+2);
+        if( selectedMailboxDir )    // only do the intelligent test if there is enough memory
+        {
+            strcpy(selectedMailboxDir, selectedMailbox);
+            selectedMailboxDir[length] = onlineDirSeparator;
+            selectedMailboxDir[length+1] = '\0';
+            size_t i;
+            for( i=0; i<numberToDelete && !folderInSubfolderList; i++ )
+            {
+                char *currentName = m_deletableChildren->ElementAt(i);
+                if( !strcmp(currentName, selectedMailbox) || !strcmp(currentName, selectedMailboxDir) )
+                    folderInSubfolderList = true;
+            }
+        }
+    }
+
+    deleteSucceeded = GetServerStateParser().LastCommandSuccessful();
+    for (outerIndex = 0;
+         (outerIndex < numberToDelete) && deleteSucceeded;
+         outerIndex++)
+    {
+        char* longestName = nullptr;
+        size_t longestIndex = 0; // fix bogus warning by initializing
+        for (innerIndex = 0;
+             innerIndex < m_deletableChildren->Length();
+             innerIndex++)
+        {
+            char *currentName = m_deletableChildren->ElementAt(innerIndex);
+            if (!longestName || strlen(longestName) < strlen(currentName))
+            {
+                longestName = currentName;
+                longestIndex = innerIndex;
+            }
+        }
+        // the imap parser has already converted to a non UTF7 string in
+        // the canonical format so convert it back
+        if (longestName)
+        {
+            char *serverName = nullptr;
+
+            m_deletableChildren->RemoveElementAt(longestIndex);
+            m_runningUrl->AllocateServerPath(longestName,
+                                             onlineDirSeparator,
+                                             &serverName);
+            PR_FREEIF(longestName);
+            longestName = serverName;
+        }
+
+      // some imap servers include the selectedMailbox in the list of
+      // subfolders of the selectedMailbox.  Check for this so we don't
+            // delete the selectedMailbox (usually the trash and doing an
+            // empty trash)
+      // The Cyrus imap server ignores the "INBOX.Trash" constraining
+            // string passed to the list command.  Be defensive and make sure
+            // we only delete children of the trash
+      if (longestName &&
+        strcmp(selectedMailbox, longestName) &&
+        !strncmp(selectedMailbox, longestName, strlen(selectedMailbox)))
+      {
+          if( selectedMailboxDir && !strcmp(selectedMailboxDir, longestName) )	// just myself
+          {
+              if( aDeleteSelf )
+              {
+                  bool deleted = DeleteMailboxRespectingSubscriptions(longestName);
+                  if (deleted)
+                      FolderDeleted(longestName);
+                  folderDeleted = deleted;
+                  deleteSucceeded = deleted;
+              }
+          }
+          else
+          {
+              if (m_imapServerSink)
+                  m_imapServerSink->ResetServerConnection(nsDependentCString(longestName));
+              bool deleted = false;
+              if( folderInSubfolderList )	// for performance
+              {
+                  nsTArray<char*> *pDeletableChildren = m_deletableChildren;
+                  m_deletableChildren = nullptr;
+                  bool folderDeleted = true;
+                  deleted = DeleteSubFolders(longestName, folderDeleted);
+                  // longestName may have subfolder list including itself
+                  if( !folderDeleted )
+                  {
+                      if (deleted)
+                      deleted = DeleteMailboxRespectingSubscriptions(longestName);
+                      if (deleted)
+                          FolderDeleted(longestName);
+                  }
+                  m_deletableChildren = pDeletableChildren;
+              }
+              else
+              {
+                  deleted = DeleteMailboxRespectingSubscriptions(longestName);
+                  if (deleted)
+                      FolderDeleted(longestName);
+              }
+              deleteSucceeded = deleted;
+          }
+      }
+      PR_FREEIF(longestName);
+    }
+
+    aDeleteSelf = folderDeleted;  // feedback if myself is deleted
+    PR_Free(selectedMailboxDir);
+
+    delete m_deletableChildren;
+    m_deletableChildren = nullptr;
+  }
+  return deleteSucceeded;
+}
+
+void nsImapProtocol::FolderDeleted(const char *mailboxName)
+{
+    char onlineDelimiter = kOnlineHierarchySeparatorUnknown;
+    nsCString orphanedMailboxName;
+
+    if (mailboxName)
+    {
+        m_runningUrl->AllocateCanonicalPath(mailboxName, onlineDelimiter,
+                                            getter_Copies(orphanedMailboxName));
+    if (m_imapServerSink)
+      m_imapServerSink->OnlineFolderDelete(orphanedMailboxName);
+    }
+}
+
+void nsImapProtocol::FolderNotCreated(const char *folderName)
+{
+    if (folderName && m_imapServerSink)
+        m_imapServerSink->OnlineFolderCreateFailed(nsDependentCString(folderName));
+}
+
+void nsImapProtocol::FolderRenamed(const char *oldName,
+                                   const char *newName)
+{
+  char onlineDelimiter = kOnlineHierarchySeparatorUnknown;
+
+  if ((m_hierarchyNameState == kNoOperationInProgress) ||
+    (m_hierarchyNameState == kListingForInfoAndDiscovery))
+
+  {
+    nsCString canonicalOldName, canonicalNewName;
+    m_runningUrl->AllocateCanonicalPath(oldName,
+      onlineDelimiter,
+      getter_Copies(canonicalOldName));
+    m_runningUrl->AllocateCanonicalPath(newName,
+      onlineDelimiter,
+      getter_Copies(canonicalNewName));
+    AutoProxyReleaseMsgWindow msgWindow;
+    GetMsgWindow(getter_AddRefs(msgWindow));
+    m_imapServerSink->OnlineFolderRename(msgWindow, canonicalOldName, canonicalNewName);
+  }
+}
+
+void nsImapProtocol::OnDeleteFolder(const char * sourceMailbox)
+{
+  // intelligently delete the folder
+  bool folderDeleted = true;
+  bool deleted = DeleteSubFolders(sourceMailbox, folderDeleted);
+  if( !folderDeleted )
+  {
+    if (deleted)
+      deleted = DeleteMailboxRespectingSubscriptions(sourceMailbox);
+    if (deleted)
+      FolderDeleted(sourceMailbox);
+  }
+}
+
+void nsImapProtocol::RemoveMsgsAndExpunge()
+{
+  uint32_t numberOfMessages = GetServerStateParser().NumberOfMessages();
+  if (numberOfMessages)
+  {
+    // Remove all msgs and expunge the folder (ie, compact it).
+    Store(NS_LITERAL_CSTRING("1:*"), "+FLAGS.SILENT (\\Deleted)", false);  // use sequence #'s
+    if (GetServerStateParser().LastCommandSuccessful())
+      Expunge();
+  }
+}
+
+void nsImapProtocol::DeleteFolderAndMsgs(const char * sourceMailbox)
+{
+  RemoveMsgsAndExpunge();
+  if (GetServerStateParser().LastCommandSuccessful())
+  {
+    // All msgs are deleted successfully - let's remove the folder itself.
+    bool reportingErrors = GetServerStateParser().GetReportingErrors();
+    GetServerStateParser().SetReportingErrors(false);
+    OnDeleteFolder(sourceMailbox);
+    GetServerStateParser().SetReportingErrors(reportingErrors);
+  }
+}
+
+void nsImapProtocol::OnRenameFolder(const char * sourceMailbox)
+{
+  char *destinationMailbox = OnCreateServerDestinationFolderPathString();
+
+  if (destinationMailbox)
+  {
+    bool renamed = RenameHierarchyByHand(sourceMailbox, destinationMailbox);
+    if (renamed)
+      FolderRenamed(sourceMailbox, destinationMailbox);
+
+    PR_Free( destinationMailbox);
+  }
+  else
+    HandleMemoryFailure();
+}
+
+void nsImapProtocol::OnMoveFolderHierarchy(const char * sourceMailbox)
+{
+  char *destinationMailbox = OnCreateServerDestinationFolderPathString();
+
+    if (destinationMailbox)
+    {
+        nsCString newBoxName;
+        newBoxName.Adopt(destinationMailbox);
+
+        char onlineDirSeparator = kOnlineHierarchySeparatorUnknown;
+        m_runningUrl->GetOnlineSubDirSeparator(&onlineDirSeparator);
+
+        nsCString oldBoxName(sourceMailbox);
+        int32_t leafStart = oldBoxName.RFindChar(onlineDirSeparator);
+        nsCString leafName;
+
+        if (-1 == leafStart)
+            leafName = oldBoxName;  // this is a root level box
+        else
+            leafName = Substring(oldBoxName, leafStart+1);
+
+        if ( !newBoxName.IsEmpty() )
+             newBoxName.Append(onlineDirSeparator);
+        newBoxName.Append(leafName);
+        bool    renamed = RenameHierarchyByHand(sourceMailbox,
+                                                newBoxName.get());
+        if (renamed)
+            FolderRenamed(sourceMailbox, newBoxName.get());
+    }
+    else
+      HandleMemoryFailure();
+}
+
+void nsImapProtocol::FindMailboxesIfNecessary()
+{
+  // biff should not discover mailboxes
+  bool foundMailboxesAlready = false;
+  nsImapAction imapAction;
+
+  // need to do this for every connection in order to see folders.
+  (void) m_runningUrl->GetImapAction(&imapAction);
+  nsresult rv = m_hostSessionList->GetHaveWeEverDiscoveredFoldersForHost(GetImapServerKey(), foundMailboxesAlready);
+  if (NS_SUCCEEDED(rv) && !foundMailboxesAlready &&
+      (imapAction != nsIImapUrl::nsImapBiff) &&
+      (imapAction != nsIImapUrl::nsImapVerifylogon) &&
+      (imapAction != nsIImapUrl::nsImapDiscoverAllBoxesUrl) &&
+      (imapAction != nsIImapUrl::nsImapUpgradeToSubscription) &&
+      !GetSubscribingNow())
+    DiscoverMailboxList();
+}
+
+void nsImapProtocol::DiscoverAllAndSubscribedBoxes()
+{
+  // used for subscribe pane
+  // iterate through all namespaces
+  uint32_t count = 0;
+  m_hostSessionList->GetNumberOfNamespacesForHost(GetImapServerKey(), count);
+
+  for (uint32_t i = 0; i < count; i++ )
+  {
+    nsIMAPNamespace *ns = nullptr;
+
+    m_hostSessionList->GetNamespaceNumberForHost(GetImapServerKey(), i,
+      ns);
+    if (ns &&
+      gHideOtherUsersFromList ? (ns->GetType() != kOtherUsersNamespace)
+      : true)
+    {
+      const char *prefix = ns->GetPrefix();
+      if (prefix)
+      {
+        nsAutoCString inboxNameWithDelim("INBOX");
+        inboxNameWithDelim.Append(ns->GetDelimiter());
+
+        if (!gHideUnusedNamespaces && *prefix &&
+        PL_strcasecmp(prefix, inboxNameWithDelim.get())) /* only do it for
+        non-empty namespace prefixes */
+        {
+          // Explicitly discover each Namespace, just so they're
+          // there in the subscribe UI
+          nsImapMailboxSpec *boxSpec = new nsImapMailboxSpec;
+          if (boxSpec)
+          {
+            NS_ADDREF(boxSpec);
+            boxSpec->mFolderSelected = false;
+            boxSpec->mHostName.Assign(GetImapHostName());
+            boxSpec->mConnection = this;
+            boxSpec->mFlagState = nullptr;
+            boxSpec->mDiscoveredFromLsub = true;
+            boxSpec->mOnlineVerified = true;
+            boxSpec->mBoxFlags = kNoselect;
+            boxSpec->mHierarchySeparator = ns->GetDelimiter();
+
+            m_runningUrl->AllocateCanonicalPath(ns->GetPrefix(), ns->GetDelimiter(),
+                                                getter_Copies(boxSpec->mAllocatedPathName));
+            boxSpec->mNamespaceForFolder = ns;
+            boxSpec->mBoxFlags |= kNameSpace;
+
+            switch (ns->GetType())
+            {
+            case kPersonalNamespace:
+              boxSpec->mBoxFlags |= kPersonalMailbox;
+              break;
+            case kPublicNamespace:
+              boxSpec->mBoxFlags |= kPublicMailbox;
+              break;
+            case kOtherUsersNamespace:
+              boxSpec->mBoxFlags |= kOtherUsersMailbox;
+              break;
+            default:	// (kUnknownNamespace)
+              break;
+            }
+
+            DiscoverMailboxSpec(boxSpec);
+          }
+          else
+            HandleMemoryFailure();
+        }
+
+        nsAutoCString allPattern(prefix);
+        allPattern += '*';
+
+        nsAutoCString topLevelPattern(prefix);
+        topLevelPattern += '%';
+
+        nsAutoCString secondLevelPattern;
+
+        char delimiter = ns->GetDelimiter();
+        if (delimiter)
+        {
+          // Hierarchy delimiter might be NIL, in which case there's no hierarchy anyway
+          secondLevelPattern = prefix;
+          secondLevelPattern += '%';
+          secondLevelPattern += delimiter;
+          secondLevelPattern += '%';
+        }
+
+        if (!m_imapServerSink) return;
+
+        if (!allPattern.IsEmpty())
+        {
+          m_imapServerSink->SetServerDoingLsub(true);
+          Lsub(allPattern.get(), true);	// LSUB all the subscribed
+        }
+        if (!topLevelPattern.IsEmpty())
+        {
+          m_imapServerSink->SetServerDoingLsub(false);
+          List(topLevelPattern.get(), true);	// LIST the top level
+        }
+        if (!secondLevelPattern.IsEmpty())
+        {
+          m_imapServerSink->SetServerDoingLsub(false);
+          List(secondLevelPattern.get(), true);	// LIST the second level
+        }
+      }
+    }
+  }
+}
+
+// DiscoverMailboxList() is used to actually do the discovery of folders
+// for a host.  This is used both when we initially start up (and re-sync)
+// and also when the user manually requests a re-sync, by collapsing and
+// expanding a host in the folder pane.  This is not used for the subscribe
+// pane.
+// DiscoverMailboxList() also gets the ACLs for each newly discovered folder
+void nsImapProtocol::DiscoverMailboxList()
+{
+  bool usingSubscription = false;
+
+  m_hostSessionList->GetHostIsUsingSubscription(GetImapServerKey(), usingSubscription);
+  // Pretend that the Trash folder doesn't exist, so we will rediscover it if we need to.
+  m_hostSessionList->SetOnlineTrashFolderExistsForHost(GetImapServerKey(), false);
+
+  // should we check a pref here, to be able to turn off XList?
+  bool hasXLIST = GetServerStateParser().GetCapabilityFlag() & kHasXListCapability;
+  if (hasXLIST && usingSubscription)
+  {
+    m_hierarchyNameState = kXListing;
+    nsAutoCString pattern("%");
+    List("%", true, true);
+    // We list the first and second levels since special folders are unlikely
+    // to be more than 2 levels deep.
+    char separator = 0;
+    m_runningUrl->GetOnlineSubDirSeparator(&separator);
+    pattern.Append(separator);
+    pattern += '%';
+    List(pattern.get(), true, true);
+  }
+
+  SetMailboxDiscoveryStatus(eContinue);
+  if (GetServerStateParser().ServerHasACLCapability())
+    m_hierarchyNameState = kListingForInfoAndDiscovery;
+  else
+    m_hierarchyNameState = kNoOperationInProgress;
+
+  // iterate through all namespaces and LSUB them.
+  uint32_t count = 0;
+  m_hostSessionList->GetNumberOfNamespacesForHost(GetImapServerKey(), count);
+  for (uint32_t i = 0; i < count; i++ )
+  {
+    nsIMAPNamespace * ns = nullptr;
+    m_hostSessionList->GetNamespaceNumberForHost(GetImapServerKey(),i,ns);
+    if (ns)
+    {
+      const char *prefix = ns->GetPrefix();
+      if (prefix)
+      {
+        nsAutoCString inboxNameWithDelim("INBOX");
+        inboxNameWithDelim.Append(ns->GetDelimiter());
+
+        // static bool gHideUnusedNamespaces = true;
+        // mscott -> WARNING!!! i where are we going to get this
+        // global variable for unused name spaces from???
+        // dmb - we should get this from a per-host preference,
+        // I'd say. But for now, just make it true;
+        if (!gHideUnusedNamespaces && *prefix &&
+                    PL_strcasecmp(prefix, inboxNameWithDelim.get()))  // only do it for
+                    // non-empty namespace prefixes, and for non-INBOX prefix
+        {
+          // Explicitly discover each Namespace, so that we can
+                    // create subfolders of them,
+          nsImapMailboxSpec *boxSpec = new nsImapMailboxSpec;
+          if (boxSpec)
+          {
+            NS_ADDREF(boxSpec);
+            boxSpec->mFolderSelected = false;
+            boxSpec->mHostName = GetImapHostName();
+            boxSpec->mConnection = this;
+            boxSpec->mFlagState = nullptr;
+            boxSpec->mDiscoveredFromLsub = true;
+            boxSpec->mOnlineVerified = true;
+            boxSpec->mBoxFlags = kNoselect;
+            boxSpec->mHierarchySeparator = ns->GetDelimiter();
+            // Until |AllocateCanonicalPath()| gets updated:
+            m_runningUrl->AllocateCanonicalPath(
+                            ns->GetPrefix(), ns->GetDelimiter(),
+                            getter_Copies(boxSpec->mAllocatedPathName));
+            boxSpec->mNamespaceForFolder = ns;
+            boxSpec->mBoxFlags |= kNameSpace;
+
+            switch (ns->GetType())
+            {
+            case kPersonalNamespace:
+              boxSpec->mBoxFlags |= kPersonalMailbox;
+              break;
+            case kPublicNamespace:
+              boxSpec->mBoxFlags |= kPublicMailbox;
+              break;
+            case kOtherUsersNamespace:
+              boxSpec->mBoxFlags |= kOtherUsersMailbox;
+              break;
+            default:  // (kUnknownNamespace)
+              break;
+            }
+
+            DiscoverMailboxSpec(boxSpec);
+          }
+          else
+            HandleMemoryFailure();
+        }
+
+        // now do the folders within this namespace
+        nsCString pattern;
+        nsCString pattern2;
+        if (usingSubscription)
+        {
+          pattern.Append(prefix);
+          pattern.Append("*");
+        }
+        else
+        {
+          pattern.Append(prefix);
+          pattern.Append("%"); // mscott just need one percent right?
+          // pattern = PR_smprintf("%s%%", prefix);
+          char delimiter = ns->GetDelimiter();
+          if (delimiter)
+          {
+            // delimiter might be NIL, in which case there's no hierarchy anyway
+            pattern2 = prefix;
+            pattern2 += "%";
+            pattern2 += delimiter;
+            pattern2 += "%";
+            // pattern2 = PR_smprintf("%s%%%c%%", prefix, delimiter);
+          }
+        }
+        // Note: It is important to make sure we are respecting the server_sub_directory
+        //       preference when calling List and Lsub (2nd arg = true), otherwise
+        //       we end up with performance issues or even crashes when connecting to
+        //       servers that expose the users entire home directory (like UW-IMAP).
+        if (usingSubscription) { // && !GetSubscribingNow())  should never get here from subscribe pane
+          if (GetServerStateParser().GetCapabilityFlag() & kHasListExtendedCapability)
+            Lsub(pattern.get(), true); // do LIST (SUBSCRIBED)
+          else {
+            // store mailbox flags from LIST
+            EMailboxHierarchyNameState currentState = m_hierarchyNameState;
+            m_hierarchyNameState = kListingForFolderFlags;
+            List(pattern.get(), true);
+            m_hierarchyNameState = currentState;
+            // then do LSUB using stored flags
+            Lsub(pattern.get(), true);
+            m_standardListMailboxes.Clear();
+          }
+        }
+        else
+        {
+          List(pattern.get(), true, hasXLIST);
+          List(pattern2.get(), true, hasXLIST);
+        }
+      }
+    }
+  }
+
+  // explicitly LIST the INBOX if (a) we're not using subscription, or (b) we are using subscription and
+  // the user wants us to always show the INBOX.
+  bool listInboxForHost = false;
+  m_hostSessionList->GetShouldAlwaysListInboxForHost(GetImapServerKey(), listInboxForHost);
+  if (!usingSubscription || listInboxForHost)
+    List("INBOX", true);
+
+  m_hierarchyNameState = kNoOperationInProgress;
+
+  MailboxDiscoveryFinished();
+
+  // Get the ACLs for newly discovered folders
+  if (GetServerStateParser().ServerHasACLCapability())
+  {
+    int32_t total = m_listedMailboxList.Length(), cnt = 0;
+    // Let's not turn this off here, since we don't turn it on after
+    // GetServerStateParser().SetReportingErrors(false);
+    if (total)
+    {
+      ProgressEventFunctionUsingName("imapGettingACLForFolder");
+      nsIMAPMailboxInfo * mb = nullptr;
+      do
+      {
+        if (m_listedMailboxList.Length() == 0)
+            break;
+
+        mb = m_listedMailboxList[0]; // get top element
+        m_listedMailboxList.RemoveElementAt(0); // XP_ListRemoveTopObject(fListedMailboxList);
+        if (mb)
+        {
+          if (FolderNeedsACLInitialized(PromiseFlatCString(mb->GetMailboxName()).get()))
+          {
+            char *onlineName = nullptr;
+            m_runningUrl->AllocateServerPath(PromiseFlatCString(mb->GetMailboxName()).get(),
+                                             mb->GetDelimiter(), &onlineName);
+            if (onlineName)
+            {
+              RefreshACLForFolder(onlineName);
+              PR_Free(onlineName);
+            }
+          }
+          PercentProgressUpdateEvent(NULL, cnt, total);
+          delete mb;  // this is the last time we're using the list, so delete the entries here
+          cnt++;
+        }
+      } while (mb && !DeathSignalReceived());
+    }
+  }
+}
+
+bool nsImapProtocol::FolderNeedsACLInitialized(const char *folderName)
+{
+  bool rv = false;
+  m_imapServerSink->FolderNeedsACLInitialized(nsDependentCString(folderName), &rv);
+  return rv;
+}
+
+void nsImapProtocol::MailboxDiscoveryFinished()
+{
+  if (!DeathSignalReceived() && !GetSubscribingNow() &&
+    ((m_hierarchyNameState == kNoOperationInProgress) ||
+    (m_hierarchyNameState == kListingForInfoAndDiscovery)))
+  {
+    nsIMAPNamespace *ns = nullptr;
+    m_hostSessionList->GetDefaultNamespaceOfTypeForHost(GetImapServerKey(), kPersonalNamespace, ns);
+    const char *personalDir = ns ? ns->GetPrefix() : 0;
+
+    bool trashFolderExists = false;
+    bool usingSubscription = false;
+    m_hostSessionList->GetOnlineTrashFolderExistsForHost(GetImapServerKey(), trashFolderExists);
+    m_hostSessionList->GetHostIsUsingSubscription(GetImapServerKey(),usingSubscription);
+    if (!trashFolderExists && GetDeleteIsMoveToTrash() && usingSubscription)
+    {
+      // maybe we're not subscribed to the Trash folder
+      if (personalDir)
+      {
+        nsCString originalTrashName(CreatePossibleTrashName(personalDir));
+        m_hierarchyNameState = kDiscoverTrashFolderInProgress;
+        List(originalTrashName.get(), true);
+        m_hierarchyNameState = kNoOperationInProgress;
+      }
+    }
+
+    // There is no Trash folder (either LIST'd or LSUB'd), and we're using the
+    // Delete-is-move-to-Trash model, and there is a personal namespace
+    if (!trashFolderExists && GetDeleteIsMoveToTrash() && ns)
+    {
+      nsCString trashName(CreatePossibleTrashName(ns->GetPrefix()));
+      nsCString onlineTrashName;
+      m_runningUrl->AllocateServerPath(trashName.get(), ns->GetDelimiter(),
+                                       getter_Copies(onlineTrashName));
+
+      GetServerStateParser().SetReportingErrors(false);
+      bool created = CreateMailboxRespectingSubscriptions(onlineTrashName.get());
+      GetServerStateParser().SetReportingErrors(true);
+
+      // force discovery of new trash folder.
+      if (created)
+      {
+        m_hierarchyNameState = kDiscoverTrashFolderInProgress;
+        List(onlineTrashName.get(), false);
+        m_hierarchyNameState = kNoOperationInProgress;
+      }
+      else
+        m_hostSessionList->SetOnlineTrashFolderExistsForHost(GetImapServerKey(), true);
+    } //if trash folder doesn't exist
+    m_hostSessionList->SetHaveWeEverDiscoveredFoldersForHost(GetImapServerKey(), true);
+
+    // notify front end that folder discovery is complete....
+    if (m_imapServerSink)
+      m_imapServerSink->DiscoveryDone();
+  }
+}
+
+// returns the mailboxName with the IMAP delimiter removed from the tail end
+void nsImapProtocol::RemoveHierarchyDelimiter(nsCString &mailboxName)
+{
+  char onlineDelimiter[2] = {0, 0};
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->GetOnlineDelimiter(&onlineDelimiter[0]);
+  // take the hierarchy delimiter off the end, if any.
+  if (onlineDelimiter[0])
+    mailboxName.Trim(onlineDelimiter, false, true);
+}
+
+// returns true is the create succeeded (regardless of subscription changes)
+bool nsImapProtocol::CreateMailboxRespectingSubscriptions(const char *mailboxName)
+{
+  CreateMailbox(mailboxName);
+  bool rv = GetServerStateParser().LastCommandSuccessful();
+  if (rv && m_autoSubscribe) // auto-subscribe is on
+  {
+    // create succeeded - let's subscribe to it
+    bool reportingErrors = GetServerStateParser().GetReportingErrors();
+    GetServerStateParser().SetReportingErrors(false);
+    nsCString mailboxWODelim(mailboxName);
+    RemoveHierarchyDelimiter(mailboxWODelim);
+    OnSubscribe(mailboxWODelim.get());
+    GetServerStateParser().SetReportingErrors(reportingErrors);
+  }
+  return rv;
+}
+
+void nsImapProtocol::CreateMailbox(const char *mailboxName)
+{
+  ProgressEventFunctionUsingName("imapStatusCreatingMailbox");
+
+  IncrementCommandTagNumber();
+
+  nsCString escapedName;
+  CreateEscapedMailboxName(mailboxName, escapedName);
+  nsCString command(GetServerCommandTag());
+  command += " create \"";
+  command += escapedName;
+  command += "\"" CRLF;
+
+  nsresult rv = SendData(command.get());
+  if(NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail();
+  // If that failed, let's list the parent folder to see if
+  // it allows inferiors, so we won't try to create sub-folders
+  // of the parent folder again in the current session.
+  if (GetServerStateParser().CommandFailed())
+  {
+    // Figure out parent folder name.
+    nsCString parentName(mailboxName);
+    char hierarchyDelimiter;
+    m_runningUrl->GetOnlineSubDirSeparator(&hierarchyDelimiter);
+    int32_t leafPos = parentName.RFindChar(hierarchyDelimiter);
+    if (leafPos > 0)
+    {
+      parentName.SetLength(leafPos);
+      List(parentName.get(), false);
+      // We still want the caller to know the create failed, so restore that.
+      GetServerStateParser().SetCommandFailed(true);
+    }
+  }
+}
+
+void nsImapProtocol::DeleteMailbox(const char *mailboxName)
+{
+
+  // check if this connection currently has the folder to be deleted selected.
+  // If so, we should close it because at least some UW servers don't like you deleting
+  // a folder you have open.
+  if (FolderIsSelected(mailboxName))
+    Close();
+
+
+  ProgressEventFunctionUsingNameWithString("imapStatusDeletingMailbox", mailboxName);
+
+    IncrementCommandTagNumber();
+
+    nsCString escapedName;
+    CreateEscapedMailboxName(mailboxName, escapedName);
+    nsCString command(GetServerCommandTag());
+    command += " delete \"";
+    command += escapedName;
+    command += "\"" CRLF;
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+        ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::RenameMailbox(const char *existingName,
+                                   const char *newName)
+{
+  // just like DeleteMailbox; Some UW servers don't like it.
+  if (FolderIsSelected(existingName))
+    Close();
+
+  ProgressEventFunctionUsingNameWithString("imapStatusRenamingMailbox", existingName);
+
+  IncrementCommandTagNumber();
+
+  nsCString escapedExistingName;
+  nsCString escapedNewName;
+  CreateEscapedMailboxName(existingName, escapedExistingName);
+  CreateEscapedMailboxName(newName, escapedNewName);
+  nsCString command(GetServerCommandTag());
+  command += " rename \"";
+  command += escapedExistingName;
+  command += "\" \"";
+  command += escapedNewName;
+  command += "\"" CRLF;
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail();
+}
+
+nsCString nsImapProtocol::CreatePossibleTrashName(const char *prefix)
+{
+  nsCString returnTrash(prefix);
+  returnTrash += m_trashFolderName;
+  return returnTrash;
+}
+
+bool nsImapProtocol::GetListSubscribedIsBrokenOnServer()
+{
+  // This is a workaround for an issue with LIST(SUBSCRIBED) crashing older versions of Zimbra
+  if (GetServerStateParser().GetServerID().Find("\"NAME\" \"Zimbra\"", CaseInsensitiveCompare) != kNotFound) {
+    nsCString serverID(GetServerStateParser().GetServerID());
+    int start = serverID.Find("\"VERSION\" \"", CaseInsensitiveCompare) + 11;
+    int length = serverID.Find("\" ", start, CaseInsensitiveCompare);
+    const nsDependentCSubstring serverVersionSubstring = Substring(serverID, start, length);
+    nsCString serverVersionStr(serverVersionSubstring);
+    Version serverVersion(serverVersionStr.get());
+    Version sevenTwoThree("7.2.3_");
+    Version eightZeroZero("8.0.0_");
+    Version eightZeroThree("8.0.3_");
+    if ((serverVersion < sevenTwoThree) ||
+        ((serverVersion >= eightZeroZero) && (serverVersion < eightZeroThree)))
+      return true;
+  }
+  return false;
+}
+
+// This identifies servers that require an extra imap SELECT to detect new
+// email in a mailbox. Servers requiring this are found by comparing their
+// ID string, returned with imap ID command, to strings entered in
+// mail.imap.force_select_detect. Only openwave servers used by
+// Charter/Spectrum ISP returning an ID containing the strings ""name" "Email Mx""
+// and ""vendor" "Openwave Messaging"" are now known to have this issue. The
+// compared strings can be modified with the config editor if necessary
+// (e.g., a "version" substring could be added). Also, additional servers
+// having a different set of strings can be added if ever needed.
+// The mail.imap.force_select_detect uses semicolon delimiter between
+// servers and within a server substrings to compare are comma delimited.
+// This example force_select_detect value shows how two servers types
+// could be detected:
+// "name" "Email Mx","vendor" "Openwave Messaging";"vendor" "Yahoo! Inc.","name" "Y!IMAP";
+bool nsImapProtocol::IsExtraSelectNeeded()
+{
+  bool retVal;
+  for (uint32_t i = 0; i < gForceSelectServersArray.Length(); i++)
+  {
+    retVal = true;
+    nsTArray<nsCString> forceSelectStringsArray;
+    ParseString(gForceSelectServersArray[i], ',', forceSelectStringsArray);
+    for (uint32_t j = 0; j < forceSelectStringsArray.Length(); j++)
+    {
+      // Each substring within the server string must be contained in ID string.
+      // First un-escape any comma (%2c) or semicolon (%3b) within the substring.
+      nsAutoCString unescapedString;
+      MsgUnescapeString(forceSelectStringsArray[j], 0, unescapedString);
+      if (GetServerStateParser().GetServerID()
+          .Find(unescapedString, CaseInsensitiveCompare) == kNotFound)
+      {
+        retVal = false;
+        break;
+      }
+    }
+    // Matches found for all substrings for the server.
+    if (retVal)
+      return true;
+  }
+
+  // If reached, no substrings match for any server.
+  return false;
+}
+
+void nsImapProtocol::Lsub(const char *mailboxPattern, bool addDirectoryIfNecessary)
+{
+  ProgressEventFunctionUsingName("imapStatusLookingForMailbox");
+
+  IncrementCommandTagNumber();
+
+  char *boxnameWithOnlineDirectory = nullptr;
+  if (addDirectoryIfNecessary)
+    m_runningUrl->AddOnlineDirectoryIfNecessary(mailboxPattern, &boxnameWithOnlineDirectory);
+
+  nsCString escapedPattern;
+  CreateEscapedMailboxName(boxnameWithOnlineDirectory ?
+                        boxnameWithOnlineDirectory :
+                        mailboxPattern, escapedPattern);
+
+  nsCString command (GetServerCommandTag());
+  eIMAPCapabilityFlags flag = GetServerStateParser().GetCapabilityFlag();
+  bool useListSubscribed = (flag & kHasListExtendedCapability) &&
+                           !GetListSubscribedIsBrokenOnServer();
+  if (useListSubscribed)
+    command += " list (subscribed)";
+  else
+    command += " lsub";
+  command += " \"\" \"";
+  command += escapedPattern;
+  if (useListSubscribed && (flag & kHasSpecialUseCapability))
+    command += "\" return (special-use)" CRLF;
+  else
+    command += "\"" CRLF;
+
+  PR_Free(boxnameWithOnlineDirectory);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail(command.get(), true);
+}
+
+void nsImapProtocol::List(const char *mailboxPattern, bool addDirectoryIfNecessary,
+                          bool useXLIST)
+{
+  ProgressEventFunctionUsingName("imapStatusLookingForMailbox");
+
+  IncrementCommandTagNumber();
+
+  char *boxnameWithOnlineDirectory = nullptr;
+  if (addDirectoryIfNecessary)
+    m_runningUrl->AddOnlineDirectoryIfNecessary(mailboxPattern, &boxnameWithOnlineDirectory);
+
+  nsCString escapedPattern;
+  CreateEscapedMailboxName(boxnameWithOnlineDirectory ?
+                        boxnameWithOnlineDirectory :
+                        mailboxPattern, escapedPattern);
+
+  nsCString command (GetServerCommandTag());
+  command += useXLIST ?
+    " xlist \"\" \"" : " list \"\" \"";
+  command += escapedPattern;
+  command += "\"" CRLF;
+
+  PR_Free(boxnameWithOnlineDirectory);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail(command.get(), true);
+}
+
+void nsImapProtocol::Subscribe(const char *mailboxName)
+{
+  ProgressEventFunctionUsingNameWithString("imapStatusSubscribeToMailbox", mailboxName);
+
+  IncrementCommandTagNumber();
+
+  nsCString escapedName;
+  CreateEscapedMailboxName(mailboxName, escapedName);
+
+  nsCString command (GetServerCommandTag());
+  command += " subscribe \"";
+  command += escapedName;
+  command += "\"" CRLF;
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+    ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::Unsubscribe(const char *mailboxName)
+{
+  ProgressEventFunctionUsingNameWithString("imapStatusUnsubscribeMailbox", mailboxName);
+  IncrementCommandTagNumber();
+
+  nsCString escapedName;
+  CreateEscapedMailboxName(mailboxName, escapedName);
+
+  nsCString command (GetServerCommandTag());
+  command += " unsubscribe \"";
+  command += escapedName;
+  command += "\"" CRLF;
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+      ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::Idle()
+{
+  IncrementCommandTagNumber();
+
+  if (m_urlInProgress)
+    return;
+  nsAutoCString command (GetServerCommandTag());
+  command += " IDLE" CRLF;
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+  {
+      m_idle = true;
+      // we'll just get back a continuation char at first.
+      // + idling...
+      ParseIMAPandCheckForNewMail();
+      // this will cause us to get notified of data or the socket getting closed.
+      // That notification will occur on the socket transport thread - we just
+      // need to poke a monitor so the imap thread will do a blocking read
+      // and parse the data.
+      nsCOMPtr <nsIAsyncInputStream> asyncInputStream = do_QueryInterface(m_inputStream);
+      if (asyncInputStream)
+        asyncInputStream->AsyncWait(this, 0, 0, nullptr);
+  }
+}
+
+// until we can fix the hang on shutdown waiting for server
+// responses, we need to not wait for the server response
+// on shutdown.
+void nsImapProtocol::EndIdle(bool waitForResponse /* = true */)
+{
+  // clear the async wait - otherwise, we seem to have trouble doing a blocking read
+  nsCOMPtr <nsIAsyncInputStream> asyncInputStream = do_QueryInterface(m_inputStream);
+  if (asyncInputStream)
+    asyncInputStream->AsyncWait(nullptr, 0, 0, nullptr);
+  nsresult rv = SendData("DONE" CRLF);
+  // set a short timeout if we don't want to wait for a response
+  if (m_transport && !waitForResponse)
+    m_transport->SetTimeout(nsISocketTransport::TIMEOUT_READ_WRITE, 5);
+  if (NS_SUCCEEDED(rv))
+  {
+    m_idle = false;
+    ParseIMAPandCheckForNewMail();
+  }
+  m_imapMailFolderSink = nullptr;
+}
+
+
+void nsImapProtocol::Search(const char * searchCriteria,
+                            bool useUID,
+                            bool notifyHit /* true */)
+{
+  m_notifySearchHit = notifyHit;
+  ProgressEventFunctionUsingName("imapStatusSearchMailbox");
+  IncrementCommandTagNumber();
+
+  nsCString protocolString(GetServerCommandTag());
+  // the searchCriteria string contains the 'search ....' string
+  if (useUID)
+     protocolString.Append(" uid");
+  protocolString.Append(" ");
+  protocolString.Append(searchCriteria);
+  // the search criteria can contain string literals, which means we
+  // need to break up the protocol string by CRLF's, and after sending CRLF,
+  // wait for the server to respond OK before sending more data
+  nsresult rv;
+  int32_t crlfIndex;
+  while (crlfIndex = protocolString.Find(CRLF), crlfIndex != kNotFound && !DeathSignalReceived())
+  {
+    nsAutoCString tempProtocolString;
+    tempProtocolString = StringHead(protocolString, crlfIndex + 2);
+    rv = SendData(tempProtocolString.get());
+    if (NS_FAILED(rv))
+      return;
+    ParseIMAPandCheckForNewMail();
+    protocolString.Cut(0, crlfIndex + 2);
+  }
+  protocolString.Append(CRLF);
+
+  rv = SendData(protocolString.get());
+  if (NS_SUCCEEDED(rv))
+     ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::Copy(const char * messageList,
+                          const char *destinationMailbox,
+                          bool idsAreUid)
+{
+  IncrementCommandTagNumber();
+
+  nsCString escapedDestination;
+  CreateEscapedMailboxName(destinationMailbox, escapedDestination);
+
+  // turn messageList back into key array and then back into a message id list,
+  // but use the flag state to handle ranges correctly.
+  nsCString messageIdList;
+  nsTArray<nsMsgKey> msgKeys;
+  if (idsAreUid)
+    ParseUidString(messageList, msgKeys);
+
+  int32_t msgCountLeft = msgKeys.Length();
+  uint32_t msgsHandled = 0;
+
+  do
+  {
+    nsCString idString;
+
+    uint32_t msgsToHandle = msgCountLeft;
+    if (idsAreUid)
+      AllocateImapUidString(msgKeys.Elements() + msgsHandled, msgsToHandle, m_flagState, idString);
+    else
+      idString.Assign(messageList);
+
+    msgsHandled += msgsToHandle;
+    msgCountLeft -= msgsToHandle;
+
+    IncrementCommandTagNumber();
+    nsAutoCString protocolString(GetServerCommandTag());
+    if (idsAreUid)
+      protocolString.Append(" uid");
+    // If it's a MOVE operation on aol servers then use 'xaol-move' cmd.
+    if ((m_imapAction == nsIImapUrl::nsImapOnlineMove) &&
+        GetServerStateParser().ServerIsAOLServer())
+      protocolString.Append(" xaol-move ");
+    else if ((m_imapAction == nsIImapUrl::nsImapOnlineMove) &&
+             GetServerStateParser().GetCapabilityFlag() & kHasMoveCapability)
+      protocolString.Append(" move ");
+    else
+      protocolString.Append(" copy ");
+
+
+    protocolString.Append(idString);
+    protocolString.Append(" \"");
+    protocolString.Append(escapedDestination);
+    protocolString.Append("\"" CRLF);
+
+    nsresult rv = SendData(protocolString.get());
+    if (NS_SUCCEEDED(rv))
+       ParseIMAPandCheckForNewMail(protocolString.get());
+  }
+  while (msgCountLeft > 0 && !DeathSignalReceived());
+}
+
+void nsImapProtocol::NthLevelChildList(const char* onlineMailboxPrefix,
+                                       int32_t depth)
+{
+  NS_ASSERTION (depth >= 0,
+                  "Oops ... depth must be equal or greater than 0");
+  if (depth < 0) return;
+
+  nsCString truncatedPrefix (onlineMailboxPrefix);
+  char16_t slash = '/';
+  if (truncatedPrefix.Last() == slash)
+        truncatedPrefix.SetLength(truncatedPrefix.Length()-1);
+
+  nsAutoCString pattern(truncatedPrefix);
+  nsAutoCString suffix;
+  int count = 0;
+  char separator = 0;
+  m_runningUrl->GetOnlineSubDirSeparator(&separator);
+  suffix.Assign(separator);
+  suffix += '%';
+
+  while (count < depth)
+  {
+      pattern += suffix;
+      count++;
+      List(pattern.get(), false);
+  }
+}
+
+void nsImapProtocol::ProcessAuthenticatedStateURL()
+{
+  nsImapAction imapAction;
+  char * sourceMailbox = nullptr;
+  m_runningUrl->GetImapAction(&imapAction);
+
+  // switch off of the imap url action and take an appropriate action
+  switch (imapAction)
+  {
+    case nsIImapUrl::nsImapLsubFolders:
+      OnLSubFolders();
+      break;
+    case nsIImapUrl::nsImapAppendMsgFromFile:
+      OnAppendMsgFromFile();
+      break;
+    case nsIImapUrl::nsImapDiscoverAllBoxesUrl:
+      NS_ASSERTION (!GetSubscribingNow(),
+                      "Oops ... should not get here from subscribe UI");
+      DiscoverMailboxList();
+      break;
+    case nsIImapUrl::nsImapDiscoverAllAndSubscribedBoxesUrl:
+      DiscoverAllAndSubscribedBoxes();
+      break;
+    case nsIImapUrl::nsImapCreateFolder:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      OnCreateFolder(sourceMailbox);
+      break;
+    case nsIImapUrl::nsImapEnsureExistsFolder:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      OnEnsureExistsFolder(sourceMailbox);
+      break;
+    case nsIImapUrl::nsImapDiscoverChildrenUrl:
+      {
+        char *canonicalParent = nullptr;
+        m_runningUrl->CreateServerSourceFolderPathString(&canonicalParent);
+        if (canonicalParent)
+        {
+          NthLevelChildList(canonicalParent, 2);
+          PR_Free(canonicalParent);
+        }
+        break;
+      }
+    case nsIImapUrl::nsImapSubscribe:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      OnSubscribe(sourceMailbox); // used to be called subscribe
+
+      if (GetServerStateParser().LastCommandSuccessful())
+      {
+        bool shouldList;
+        // if url is an external click url, then we should list the folder
+        // after subscribing to it, so we can select it.
+        m_runningUrl->GetExternalLinkUrl(&shouldList);
+        if (shouldList)
+          OnListFolder(sourceMailbox, true);
+      }
+      break;
+    case nsIImapUrl::nsImapUnsubscribe:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      OnUnsubscribe(sourceMailbox);
+      break;
+    case nsIImapUrl::nsImapRefreshACL:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      RefreshACLForFolder(sourceMailbox);
+      break;
+    case nsIImapUrl::nsImapRefreshAllACLs:
+      OnRefreshAllACLs();
+      break;
+    case nsIImapUrl::nsImapListFolder:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      OnListFolder(sourceMailbox, false);
+      break;
+    case nsIImapUrl::nsImapFolderStatus:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      OnStatusForFolder(sourceMailbox);
+      break;
+    case nsIImapUrl::nsImapRefreshFolderUrls:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      XMailboxInfo(sourceMailbox);
+      if (GetServerStateParser().LastCommandSuccessful())
+        SetFolderAdminUrl(sourceMailbox);
+      break;
+    case nsIImapUrl::nsImapDeleteFolder:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      OnDeleteFolder(sourceMailbox);
+      break;
+    case nsIImapUrl::nsImapRenameFolder:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      OnRenameFolder(sourceMailbox);
+      break;
+    case nsIImapUrl::nsImapMoveFolderHierarchy:
+      sourceMailbox = OnCreateServerSourceFolderPathString();
+      OnMoveFolderHierarchy(sourceMailbox);
+      break;
+    case nsIImapUrl::nsImapVerifylogon:
+      break;
+    default:
+      break;
+  }
+  PR_Free(sourceMailbox);
+}
+
+void nsImapProtocol::ProcessAfterAuthenticated()
+{
+  // if we're a netscape server, and we haven't got the admin url, get it
+  bool hasAdminUrl = true;
+
+  if (NS_SUCCEEDED(m_hostSessionList->GetHostHasAdminURL(GetImapServerKey(), hasAdminUrl))
+    && !hasAdminUrl)
+  {
+    if (GetServerStateParser().ServerHasServerInfo())
+    {
+      XServerInfo();
+      if (GetServerStateParser().LastCommandSuccessful() && m_imapServerSink)
+      {
+        m_imapServerSink->SetMailServerUrls(GetServerStateParser().GetMailAccountUrl(),
+          GetServerStateParser().GetManageListsUrl(),
+          GetServerStateParser().GetManageFiltersUrl());
+        // we've tried to ask for it, so don't try again this session.
+        m_hostSessionList->SetHostHasAdminURL(GetImapServerKey(), true);
+      }
+    }
+    else if (GetServerStateParser().ServerIsNetscape3xServer())
+    {
+      Netscape();
+      if (GetServerStateParser().LastCommandSuccessful() && m_imapServerSink)
+        m_imapServerSink->SetMailServerUrls(GetServerStateParser().GetMailAccountUrl(),
+                                            EmptyCString(), EmptyCString());
+    }
+  }
+
+  if (GetServerStateParser().ServerHasNamespaceCapability())
+  {
+    bool nameSpacesOverridable = false;
+    bool haveNameSpacesForHost = false;
+    m_hostSessionList->GetNamespacesOverridableForHost(GetImapServerKey(), nameSpacesOverridable);
+    m_hostSessionList->GetGotNamespacesForHost(GetImapServerKey(), haveNameSpacesForHost);
+
+  // mscott: VERIFY THIS CLAUSE!!!!!!!
+    if (nameSpacesOverridable && !haveNameSpacesForHost)
+      Namespace();
+  }
+
+  // If the server supports compression, turn it on now.
+  // Choosing this spot (after login has finished) because
+  // many proxies (e.g. perdition, nginx) talk IMAP to the
+  // client until login is finished, then hand off to the
+  // backend.  If we enable compression early the proxy
+  // will be confused.
+  if (UseCompressDeflate())
+    StartCompressDeflate();
+
+  if ((GetServerStateParser().GetCapabilityFlag() & kHasEnableCapability) &&
+       UseCondStore())
+    EnableCondStore();
+
+  bool haveIdResponse = false;
+  if ((GetServerStateParser().GetCapabilityFlag() & kHasIDCapability) &&
+       m_sendID)
+  {
+    ID();
+    if (m_imapServerSink && !GetServerStateParser().GetServerID().IsEmpty())
+    {
+      haveIdResponse = true;
+      // Determine value for m_forceSelect based on config editor
+      // entries and comparison to imap ID string returned by the server.
+      m_imapServerSink->SetServerID(GetServerStateParser().GetServerID());
+      switch (m_forceSelectValue.get()[0])
+      {
+      // Yes: Set to always force even if imap server doesn't need it.
+      case 'y':
+      case 'Y':
+        m_forceSelect = true;
+        break;
+
+      // No: Set to never force a select for this imap server.
+      case 'n':
+      case 'N':
+        m_forceSelect = false;
+        break;
+
+      // Auto: Set to force only if imap server requires it.
+      default:
+        nsAutoCString statusString;
+        m_forceSelect = IsExtraSelectNeeded();
+        // Setting to "yes-auto" or "no-auto" avoids doing redundant calls to
+        // IsExtraSelectNeeded() on subsequent ID() occurrences. It also
+        // provides feedback to the user regarding the detection status.
+        if (m_forceSelect)
+        {
+          // Set preference value to "yes-auto".
+          statusString.Assign("yes-auto");
+        }
+        else
+        {
+          // Set preference value to "no-auto".
+          statusString.Assign("no-auto");
+        }
+        m_imapServerSink->SetServerForceSelect(statusString);
+        break;
+      }
+    }
+  }
+
+  // If no ID capability or empty ID response, user may still want to
+  // change "force select".
+  if (!haveIdResponse)
+  {
+    switch (m_forceSelectValue.get()[0])
+    {
+    case 'a':
+      {
+        // If default "auto", set to "no-auto" so visible in config editor
+        // and set/keep m_forceSelect false.
+        nsAutoCString statusString;
+        statusString.Assign("no-auto");
+        m_imapServerSink->SetServerForceSelect(statusString);
+        m_forceSelect = false;
+      }
+      break;
+    case 'y':
+    case 'Y':
+      m_forceSelect = true;
+      break;
+    default:
+      m_forceSelect = false;
+    }
+  }
+}
+
+void nsImapProtocol::SetupMessageFlagsString(nsCString& flagString,
+                                             imapMessageFlagsType flags,
+                                             uint16_t userFlags)
+{
+    if (flags & kImapMsgSeenFlag)
+        flagString.Append("\\Seen ");
+    if (flags & kImapMsgAnsweredFlag)
+        flagString.Append("\\Answered ");
+    if (flags & kImapMsgFlaggedFlag)
+        flagString.Append("\\Flagged ");
+    if (flags & kImapMsgDeletedFlag)
+        flagString.Append("\\Deleted ");
+    if (flags & kImapMsgDraftFlag)
+        flagString.Append("\\Draft ");
+    if (flags & kImapMsgRecentFlag)
+        flagString.Append("\\Recent ");
+    if ((flags & kImapMsgForwardedFlag) &&
+        (userFlags & kImapMsgSupportForwardedFlag))
+        flagString.Append("$Forwarded "); // Not always available
+    if ((flags & kImapMsgMDNSentFlag) && (
+        userFlags & kImapMsgSupportMDNSentFlag))
+        flagString.Append("$MDNSent "); // Not always available
+
+    // eat the last space
+    if (!flagString.IsEmpty())
+        flagString.SetLength(flagString.Length()-1);
+}
+
+void nsImapProtocol::ProcessStoreFlags(const nsCString &messageIdsString,
+                                                 bool idsAreUids,
+                                                 imapMessageFlagsType flags,
+                                                 bool addFlags)
+{
+  nsCString flagString;
+
+  uint16_t userFlags = GetServerStateParser().SupportsUserFlags();
+  uint16_t settableFlags = GetServerStateParser().SettablePermanentFlags();
+
+  if (!addFlags && (flags & userFlags) && !(flags & settableFlags))
+  {
+    if (m_runningUrl)
+      m_runningUrl->SetExtraStatus(nsIImapUrl::ImapStatusFlagsNotSettable);
+    return;         // if cannot set any of the flags bail out
+  }
+
+  if (addFlags)
+      flagString = "+Flags (";
+  else
+      flagString = "-Flags (";
+
+  if (flags & kImapMsgSeenFlag && kImapMsgSeenFlag & settableFlags)
+      flagString .Append("\\Seen ");
+  if (flags & kImapMsgAnsweredFlag && kImapMsgAnsweredFlag & settableFlags)
+      flagString .Append("\\Answered ");
+  if (flags & kImapMsgFlaggedFlag && kImapMsgFlaggedFlag & settableFlags)
+      flagString .Append("\\Flagged ");
+  if (flags & kImapMsgDeletedFlag && kImapMsgDeletedFlag & settableFlags)
+      flagString .Append("\\Deleted ");
+  if (flags & kImapMsgDraftFlag && kImapMsgDraftFlag & settableFlags)
+      flagString .Append("\\Draft ");
+  if (flags & kImapMsgForwardedFlag && kImapMsgSupportForwardedFlag & userFlags)
+        flagString .Append("$Forwarded ");  // if supported
+  if (flags & kImapMsgMDNSentFlag && kImapMsgSupportMDNSentFlag & userFlags)
+        flagString .Append("$MDNSent ");  // if supported
+
+  if (flagString.Length() > 8) // if more than "+Flags ("
+  {
+  // replace the final space with ')'
+    flagString.SetCharAt(')',flagString.Length() - 1);
+
+    Store(messageIdsString, flagString.get(), idsAreUids);
+    if (m_runningUrl && idsAreUids)
+    {
+      nsCString messageIdString;
+      m_runningUrl->GetListOfMessageIds(messageIdString);
+      nsTArray<nsMsgKey> msgKeys;
+      ParseUidString(messageIdString.get(), msgKeys);
+
+      int32_t msgCount = msgKeys.Length();
+      for (int32_t i = 0; i < msgCount; i++)
+      {
+        bool found;
+        imapMessageFlagsType resultFlags;
+      // check if the flags were added/removed, and if the uid really exists.
+        nsresult rv = GetFlagsForUID(msgKeys[i], &found, &resultFlags, nullptr);
+        if (NS_FAILED(rv) || !found ||
+           (addFlags && ((flags & resultFlags) != flags)) ||
+           (!addFlags && ((flags & resultFlags) != 0)))
+        {
+          m_runningUrl->SetExtraStatus(nsIImapUrl::ImapStatusFlagChangeFailed);
+          break;
+        }
+      }
+
+    }
+  }
+}
+
+
+void nsImapProtocol::Close(bool shuttingDown /* = false */,
+                           bool waitForResponse /* = true */)
+{
+  IncrementCommandTagNumber();
+
+  nsCString command(GetServerCommandTag());
+  command.Append(" close" CRLF);
+
+  if (!shuttingDown)
+    ProgressEventFunctionUsingName("imapStatusCloseMailbox");
+
+  GetServerStateParser().ResetFlagInfo();
+
+  nsresult rv = SendData(command.get());
+  if (m_transport && shuttingDown)
+    m_transport->SetTimeout(nsISocketTransport::TIMEOUT_READ_WRITE, 5);
+
+  if (NS_SUCCEEDED(rv) && waitForResponse)
+      ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::XAOL_Option(const char *option)
+{
+  IncrementCommandTagNumber();
+
+  nsCString command(GetServerCommandTag());
+  command.Append(" XAOL-OPTION ");
+  command.Append(option);
+  command.Append(CRLF);
+
+  nsresult rv = SendData(command.get());
+  if (NS_SUCCEEDED(rv))
+      ParseIMAPandCheckForNewMail();
+}
+
+void nsImapProtocol::Check()
+{
+    //ProgressUpdateEvent("Checking mailbox...");
+
+    IncrementCommandTagNumber();
+
+  nsCString command(GetServerCommandTag());
+  command.Append(" check" CRLF);
+
+    nsresult rv = SendData(command.get());
+    if (NS_SUCCEEDED(rv))
+    {
+        m_flagChangeCount = 0;
+        m_lastCheckTime = PR_Now();
+        ParseIMAPandCheckForNewMail();
+    }
+}
+
+nsresult nsImapProtocol::GetMsgWindow(nsIMsgWindow **aMsgWindow)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl =
+      do_QueryInterface(m_runningUrl, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!m_imapProtocolSink)
+    return NS_ERROR_FAILURE;
+  return m_imapProtocolSink->GetUrlWindow(mailnewsUrl, aMsgWindow);
+}
+
+/**
+ * Get password from RAM, disk (password manager) or user (dialog)
+ * @return NS_MSG_PASSWORD_PROMPT_CANCELLED
+ *    (which is NS_SUCCEEDED!) when user cancelled
+ *    NS_FAILED(rv) for other errors
+ */
+nsresult nsImapProtocol::GetPassword(nsCString &password,
+                                     bool newPasswordRequested)
+{
+  // we are in the imap thread so *NEVER* try to extract the password with UI
+  // if logon redirection has changed the password, use the cookie as the password
+  if (m_overRideUrlConnectionInfo)
+  {
+    password.Assign(m_logonCookie);
+    return NS_OK;
+  }
+
+  NS_ENSURE_TRUE(m_imapServerSink, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(m_server, NS_ERROR_NULL_POINTER);
+  nsresult rv;
+
+  // Get the password already stored in mem
+  rv = m_imapServerSink->GetServerPassword(password);
+  if (NS_FAILED(rv) || password.IsEmpty())
+  {
+    AutoProxyReleaseMsgWindow msgWindow;
+    GetMsgWindow(getter_AddRefs(msgWindow));
+    NS_ENSURE_TRUE(msgWindow, NS_ERROR_NOT_AVAILABLE); // biff case
+
+    // Get the password from pw manager (harddisk) or user (dialog)
+    nsAutoCString pwd; // GetPasswordWithUI truncates the password on Cancel
+    rv = m_imapServerSink->AsyncGetPassword(this,
+                                                     newPasswordRequested,
+                                                     password);
+    if (password.IsEmpty())
+    {
+      PRIntervalTime sleepTime = kImapSleepTime;
+      m_passwordStatus = NS_OK;
+      ReentrantMonitorAutoEnter mon(m_passwordReadyMonitor);
+      while (m_password.IsEmpty() && !NS_FAILED(m_passwordStatus) &&
+             m_passwordStatus != NS_MSG_PASSWORD_PROMPT_CANCELLED &&
+             !DeathSignalReceived())
+        mon.Wait(sleepTime);
+      rv = m_passwordStatus;
+      password = m_password;
+    }
+  }
+  if (!password.IsEmpty())
+    m_lastPasswordSent = password;
+  return rv;
+}
+
+// This is called from the UI thread.
+NS_IMETHODIMP
+nsImapProtocol::OnPromptStart(bool *aResult)
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryReferent(m_server, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+
+  *aResult = false;
+  GetMsgWindow(getter_AddRefs(msgWindow));
+  nsCString password = m_lastPasswordSent;
+  rv = imapServer->PromptPassword(msgWindow, password);
+  m_password = password;
+  m_passwordStatus = rv;
+  if (!m_password.IsEmpty())
+    *aResult = true;
+
+  // Notify the imap thread that we have a password.
+  ReentrantMonitorAutoEnter passwordMon(m_passwordReadyMonitor);
+  passwordMon.Notify();
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapProtocol::OnPromptAuthAvailable()
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgIncomingServer> imapServer = do_QueryReferent(m_server, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  m_passwordStatus = imapServer->GetPassword(m_password);
+  // Notify the imap thread that we have a password.
+  ReentrantMonitorAutoEnter passwordMon(m_passwordReadyMonitor);
+  passwordMon.Notify();
+  return m_passwordStatus;
+}
+
+NS_IMETHODIMP
+nsImapProtocol::OnPromptCanceled()
+{
+  // A prompt was cancelled, so notify the imap thread.
+  m_passwordStatus = NS_MSG_PASSWORD_PROMPT_CANCELLED;
+  ReentrantMonitorAutoEnter passwordMon(m_passwordReadyMonitor);
+  passwordMon.Notify();
+  return NS_OK;
+}
+
+bool nsImapProtocol::TryToLogon()
+{
+  MOZ_LOG(IMAP, LogLevel::Debug, ("try to log in"));
+  NS_ENSURE_TRUE(m_imapServerSink, false);
+  bool loginSucceeded = false;
+  bool skipLoop = false;
+  nsAutoCString password;
+  nsAutoCString userName;
+
+  nsresult rv = ChooseAuthMethod();
+  if (NS_FAILED(rv)) // all methods failed
+  {
+    // are there any matching login schemes at all?
+    if (!(GetServerStateParser().GetCapabilityFlag() & m_prefAuthMethods))
+    {
+      // Pref doesn't match server. Now, find an appropriate error msg.
+
+      // pref has plaintext pw & server claims to support encrypted pw
+      if (m_prefAuthMethods == (kHasAuthOldLoginCapability |
+              kHasAuthLoginCapability | kHasAuthPlainCapability) &&
+          GetServerStateParser().GetCapabilityFlag() & kHasCRAMCapability)
+        // tell user to change to encrypted pw
+        AlertUserEventUsingName("imapAuthChangePlainToEncrypt");
+      // pref has encrypted pw & server claims to support plaintext pw
+      else if (m_prefAuthMethods == kHasCRAMCapability &&
+               GetServerStateParser().GetCapabilityFlag() &
+                   (kHasAuthOldLoginCapability | kHasAuthLoginCapability |
+                    kHasAuthPlainCapability))
+      {
+        // have SSL
+        if (m_socketType == nsMsgSocketType::SSL ||
+            m_socketType == nsMsgSocketType::alwaysSTARTTLS)
+          // tell user to change to plaintext pw
+          AlertUserEventUsingName("imapAuthChangeEncryptToPlainSSL");
+        else
+          // tell user to change to plaintext pw, with big warning
+          AlertUserEventUsingName("imapAuthChangeEncryptToPlainNoSSL");
+      }
+      else
+        // just "change auth method"
+        AlertUserEventUsingName("imapAuthMechNotSupported");
+
+      skipLoop = true;
+    }
+    else
+    {
+      // try to reset failed methods and try them again
+      ResetAuthMethods();
+      rv = ChooseAuthMethod();
+      if (NS_FAILED(rv)) // all methods failed
+      {
+        MOZ_LOG(IMAP, LogLevel::Error, ("huch? there are auth methods, and we resetted failed ones, but ChooseAuthMethod still fails."));
+        return false;
+      }
+    }
+  }
+
+  // Get username, either the stored one or from user
+  rv = m_imapServerSink->GetLoginUsername(userName);
+  if (NS_FAILED(rv) || userName.IsEmpty())
+  {
+    // The user hit "Cancel" on the dialog box
+    skipLoop = true;
+  }
+
+  /*
+   * Login can fail for various reasons:
+   * 1. Server claims to support GSSAPI, but it really doesn't.
+   *    Or the client doesn't support GSSAPI, or is not logged in yet.
+   *    (GSSAPI is a mechanism without password in apps).
+   * 2. Server claims to support CRAM-MD5, but it's broken and will fail despite correct password.
+   * 2.1. Some servers say they support CRAM but are so badly broken that trying it causes
+   *    all subsequent login attempts to fail during this connection (bug 231303).
+   *    So we use CRAM/NTLM/MSN only if enabled in prefs.
+   *    Update: if it affects only some ISPs, we can maybe use the ISP DB
+   *    and disable CRAM specifically for these.
+   * 3. Prefs are set to require auth methods which the server doesn't support
+   *     (per CAPS or we tried and they failed).
+   * 4. User provided wrong password.
+   * 5. We tried too often and the server shut us down, so even a correct attempt
+   *    will now (currently) fail.
+   * The above problems may overlap, e.g. 3. with 1. and 2., and we can't differentiate
+   * between 2. and 4., which is really unfortunate.
+   */
+
+  bool newPasswordRequested = false;
+  // remember the msgWindow before we start trying to logon, because if the
+  // server drops the connection on errors, TellThreadToDie will null out the
+  // protocolsink and we won't be able to get the msgWindow.
+  AutoProxyReleaseMsgWindow msgWindow;
+  GetMsgWindow(getter_AddRefs(msgWindow));
+
+  // This loops over 1) auth methods (only one per loop) and 2) password tries (with UI)
+  while (!loginSucceeded && !skipLoop && !DeathSignalReceived())
+  {
+      // Get password
+      if (m_currentAuthMethod != kHasAuthGssApiCapability && // GSSAPI uses no pw in apps
+          m_currentAuthMethod != kHasAuthExternalCapability &&
+          m_currentAuthMethod != kHasXOAuth2Capability &&
+          m_currentAuthMethod != kHasAuthNoneCapability)
+      {
+          rv = GetPassword(password, newPasswordRequested);
+          newPasswordRequested = false;
+          if (rv == NS_MSG_PASSWORD_PROMPT_CANCELLED || NS_FAILED(rv))
+          {
+            MOZ_LOG(IMAP, LogLevel::Error, ("IMAP: password prompt failed or user canceled it"));
+            break;
+          }
+          MOZ_LOG(IMAP, LogLevel::Debug, ("got new password"));
+      }
+
+      bool lastReportingErrors = GetServerStateParser().GetReportingErrors();
+      GetServerStateParser().SetReportingErrors(false); // turn off errors - we'll put up our own.
+
+      rv = AuthLogin(userName.get(), password, m_currentAuthMethod);
+
+      GetServerStateParser().SetReportingErrors(lastReportingErrors); // restore error reports
+      loginSucceeded = NS_SUCCEEDED(rv);
+
+      if (!loginSucceeded)
+      {
+        MOZ_LOG(IMAP, LogLevel::Debug, ("authlogin failed"));
+        MarkAuthMethodAsFailed(m_currentAuthMethod);
+        rv = ChooseAuthMethod(); // change m_currentAuthMethod to try other one next round
+
+        if (NS_FAILED(rv)) // all methods failed
+        {
+          if (m_prefAuthMethods == kHasAuthGssApiCapability)
+          {
+            // GSSAPI failed, and it's the only available method,
+            // and it's password-less, so nothing left to do.
+            AlertUserEventUsingName("imapAuthGssapiFailed");
+            break;
+          }
+
+          if (m_prefAuthMethods & kHasXOAuth2Capability)
+          {
+            // OAuth2 failed. We don't have an error message for this, and we
+            // in a string freeze, so use a generic error message. Entering
+            // a password does not help.
+            AlertUserEventUsingName("imapUnknownHostError");
+            break;
+          }
+
+          // The reason that we failed might be a wrong password, so
+          // ask user what to do
+          MOZ_LOG(IMAP, LogLevel::Warning, ("IMAP: ask user what to do (after login failed): new passwort, retry, cancel"));
+          if (!m_imapServerSink)
+            break;
+          // if there's no msg window, don't forget the password
+          if (!msgWindow)
+            break;
+          int32_t buttonPressed = 1;
+          rv = m_imapServerSink->PromptLoginFailed(msgWindow,
+                                                    &buttonPressed);
+          if (NS_FAILED(rv))
+            break;
+          if (buttonPressed == 2) // 'New password' button
+          {
+            MOZ_LOG(IMAP, LogLevel::Warning, ("new password button pressed."));
+            // Forget the current password
+            password.Truncate();
+            m_hostSessionList->SetPasswordForHost(GetImapServerKey(), nullptr);
+            m_imapServerSink->ForgetPassword();
+            m_password.Truncate();
+            MOZ_LOG(IMAP, LogLevel::Warning, ("password resetted (nulled)"));
+            newPasswordRequested = true;
+            // Will call GetPassword() in beginning of next loop
+
+            // Try all possible auth methods again with the new password.
+            ResetAuthMethods();
+          }
+          else if (buttonPressed == 0) // Retry button
+          {
+            MOZ_LOG(IMAP, LogLevel::Warning, ("retry button pressed"));
+            // Try all possible auth methods again
+            ResetAuthMethods();
+          }
+          else if (buttonPressed == 1) // Cancel button
+          {
+            MOZ_LOG(IMAP, LogLevel::Warning, ("cancel button pressed"));
+            break; // Abort quickly
+          }
+
+          // TODO what is this for? When does it get set to != unknown again?
+          m_currentBiffState = nsIMsgFolder::nsMsgBiffState_Unknown;
+          SendSetBiffIndicatorEvent(m_currentBiffState);
+        } // all methods failed
+      } // login failed
+  } // while
+
+  if (loginSucceeded)
+  {
+    MOZ_LOG(IMAP, LogLevel::Debug, ("login succeeded"));
+    bool passwordAlreadyVerified;
+    m_hostSessionList->SetPasswordForHost(GetImapServerKey(), password.get());
+    rv = m_hostSessionList->GetPasswordVerifiedOnline(GetImapServerKey(), passwordAlreadyVerified);
+    if (NS_SUCCEEDED(rv) && !passwordAlreadyVerified)
+      m_hostSessionList->SetPasswordVerifiedOnline(GetImapServerKey());
+    bool imapPasswordIsNew = !passwordAlreadyVerified;
+    if (imapPasswordIsNew)
+    {
+      if (m_currentBiffState == nsIMsgFolder::nsMsgBiffState_Unknown)
+      {
+          m_currentBiffState = nsIMsgFolder::nsMsgBiffState_NoMail;
+          SendSetBiffIndicatorEvent(m_currentBiffState);
+      }
+      m_imapServerSink->SetUserAuthenticated(true);
+    }
+
+    nsImapAction imapAction;
+    m_runningUrl->GetImapAction(&imapAction);
+    // We don't want to do any more processing if we're just
+    // verifying the ability to logon because it can leave us in
+    // a half-constructed state.
+    if (imapAction != nsIImapUrl::nsImapVerifylogon)
+      ProcessAfterAuthenticated();
+  }
+  else // login failed
+  {
+    MOZ_LOG(IMAP, LogLevel::Error, ("login failed entirely"));
+    m_currentBiffState = nsIMsgFolder::nsMsgBiffState_Unknown;
+    SendSetBiffIndicatorEvent(m_currentBiffState);
+    HandleCurrentUrlError();
+    SetConnectionStatus(NS_ERROR_FAILURE); // stop netlib
+  }
+
+  return loginSucceeded;
+}
+
+void nsImapProtocol::UpdateFolderQuotaData(nsCString& aQuotaRoot, uint32_t aUsed, uint32_t aMax)
+{
+  NS_ASSERTION(m_imapMailFolderSink, "m_imapMailFolderSink is null!");
+
+  m_imapMailFolderSink->SetFolderQuotaData(aQuotaRoot, aUsed, aMax);
+}
+
+void nsImapProtocol::GetQuotaDataIfSupported(const char *aBoxName)
+{
+  // If server doesn't have quota support, don't do anything
+  if (! (GetServerStateParser().GetCapabilityFlag() & kQuotaCapability))
+    return;
+
+  nsCString escapedName;
+  CreateEscapedMailboxName(aBoxName, escapedName);
+
+  IncrementCommandTagNumber();
+
+  nsAutoCString quotacommand(GetServerCommandTag());
+  quotacommand.Append(NS_LITERAL_CSTRING(" getquotaroot \""));
+  quotacommand.Append(escapedName);
+  quotacommand.Append(NS_LITERAL_CSTRING("\"" CRLF));
+
+  NS_ASSERTION(m_imapMailFolderSink, "m_imapMailFolderSink is null!");
+  if (m_imapMailFolderSink)
+    m_imapMailFolderSink->SetFolderQuotaCommandIssued(true);
+
+  nsresult quotarv = SendData(quotacommand.get());
+  if (NS_SUCCEEDED(quotarv))
+    ParseIMAPandCheckForNewMail(nullptr, true); // don't display errors.
+}
+
+bool
+nsImapProtocol::GetDeleteIsMoveToTrash()
+{
+    bool rv = false;
+    NS_ASSERTION (m_hostSessionList, "fatal... null host session list");
+    if (m_hostSessionList)
+        m_hostSessionList->GetDeleteIsMoveToTrashForHost(GetImapServerKey(), rv);
+    return rv;
+}
+
+bool
+nsImapProtocol::GetShowDeletedMessages()
+{
+    bool rv = false;
+    if (m_hostSessionList)
+        m_hostSessionList->GetShowDeletedMessagesForHost(GetImapServerKey(), rv);
+    return rv;
+}
+
+NS_IMETHODIMP nsImapProtocol::OverrideConnectionInfo(const char16_t *pHost, uint16_t pPort, const char *pCookieData)
+{
+  m_logonHost = NS_LossyConvertUTF16toASCII(pHost);
+  m_logonPort = pPort;
+  m_logonCookie = pCookieData;
+  m_overRideUrlConnectionInfo = true;
+  return NS_OK;
+}
+
+bool nsImapProtocol::CheckNeeded()
+{
+  if (m_flagChangeCount >= kFlagChangesBeforeCheck)
+    return true;
+
+  int32_t deltaInSeconds;
+
+  PRTime2Seconds(PR_Now() - m_lastCheckTime, &deltaInSeconds);
+
+  return (deltaInSeconds >= kMaxSecondsBeforeCheck);
+}
+
+bool nsImapProtocol::UseCondStore()
+{
+  // Check that the server is capable of cond store, and the user
+  // hasn't disabled the use of constore for this server.
+  return m_useCondStore &&
+         GetServerStateParser().GetCapabilityFlag() & kHasCondStoreCapability &&
+         GetServerStateParser().fUseModSeq;
+}
+
+bool nsImapProtocol::UseCompressDeflate()
+{
+  // Check that the server is capable of compression, and the user
+  // hasn't disabled the use of compression for this server.
+  return m_useCompressDeflate &&
+         GetServerStateParser().GetCapabilityFlag() & kHasCompressDeflateCapability;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// The following is the implementation of nsImapMockChannel and an intermediary
+// imap steam listener. The stream listener is used to make a clean binding between the
+// imap mock channel and the memory cache channel (if we are reading from the cache)
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+// WARNING: the cache stream listener is intended to be accessed from the UI thread!
+// it will NOT create another proxy for the stream listener that gets passed in...
+class nsImapCacheStreamListener : public nsIStreamListener
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSISTREAMLISTENER
+
+  nsImapCacheStreamListener ();
+
+  nsresult Init(nsIStreamListener * aStreamListener, nsIImapMockChannel * aMockChannelToUse);
+protected:
+  virtual ~nsImapCacheStreamListener();
+  nsCOMPtr<nsIImapMockChannel> mChannelToUse;
+  nsCOMPtr<nsIStreamListener> mListener;
+};
+
+NS_IMPL_ADDREF(nsImapCacheStreamListener)
+NS_IMPL_RELEASE(nsImapCacheStreamListener)
+
+NS_INTERFACE_MAP_BEGIN(nsImapCacheStreamListener)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStreamListener)
+  NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
+NS_INTERFACE_MAP_END
+
+nsImapCacheStreamListener::nsImapCacheStreamListener()
+{
+}
+
+nsImapCacheStreamListener::~nsImapCacheStreamListener()
+{}
+
+nsresult nsImapCacheStreamListener::Init(nsIStreamListener * aStreamListener, nsIImapMockChannel * aMockChannelToUse)
+{
+  NS_ENSURE_ARG(aStreamListener);
+  NS_ENSURE_ARG(aMockChannelToUse);
+
+  mChannelToUse = aMockChannelToUse;
+  mListener = aStreamListener;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapCacheStreamListener::OnStartRequest(nsIRequest *request, nsISupports * aCtxt)
+{
+  if (!mChannelToUse)
+  {
+    NS_ERROR("OnStartRequest called after OnStopRequest");
+    return NS_ERROR_NULL_POINTER;
+  }
+  nsCOMPtr<nsILoadGroup> loadGroup;
+  mChannelToUse->GetLoadGroup(getter_AddRefs(loadGroup));
+  nsCOMPtr<nsIRequest> ourRequest = do_QueryInterface(mChannelToUse);
+  if (loadGroup)
+    loadGroup->AddRequest(ourRequest, nullptr /* context isupports */);
+  return mListener->OnStartRequest(ourRequest, aCtxt);
+}
+
+NS_IMETHODIMP
+nsImapCacheStreamListener::OnStopRequest(nsIRequest *request, nsISupports * aCtxt, nsresult aStatus)
+{
+  if (!mListener)
+  {
+    NS_ERROR("OnStopRequest called twice");
+    return NS_ERROR_NULL_POINTER;
+  }
+  nsresult rv = mListener->OnStopRequest(mChannelToUse, aCtxt, aStatus);
+  nsCOMPtr <nsILoadGroup> loadGroup;
+  mChannelToUse->GetLoadGroup(getter_AddRefs(loadGroup));
+  if (loadGroup)
+    loadGroup->RemoveRequest(mChannelToUse, nullptr, aStatus);
+
+  mListener = nullptr;
+  mChannelToUse->Close();
+  mChannelToUse = nullptr;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapCacheStreamListener::OnDataAvailable(nsIRequest *request, nsISupports * aCtxt, nsIInputStream * aInStream, uint64_t aSourceOffset, uint32_t aCount)
+{
+  return mListener->OnDataAvailable(mChannelToUse, aCtxt, aInStream, aSourceOffset, aCount);
+}
+
+NS_IMPL_ISUPPORTS(nsImapMockChannel, nsIImapMockChannel, nsIChannel,
+  nsIRequest, nsICacheEntryOpenCallback, nsITransportEventSink, nsISupportsWeakReference)
+
+
+nsImapMockChannel::nsImapMockChannel()
+{
+  m_channelContext = nullptr;
+  m_cancelStatus = NS_OK;
+  mLoadFlags = 0;
+  mChannelClosed = false;
+  mReadingFromCache = false;
+  mTryingToReadPart = false;
+}
+
+nsImapMockChannel::~nsImapMockChannel()
+{
+  // if we're offline, we may not get to close the channel correctly.
+  // we need to do this to send the url state change notification in
+  // the case of mem and disk cache reads.
+  NS_WARNING_ASSERTION(NS_IsMainThread(), "should only access mock channel on ui thread");
+  if (!mChannelClosed)
+    Close();
+}
+
+nsresult nsImapMockChannel::NotifyStartEndReadFromCache(bool start)
+{
+  nsresult rv = NS_OK;
+  mReadingFromCache = start;
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(m_url, &rv);
+  nsCOMPtr<nsIImapProtocol> imapProtocol = do_QueryReferent(mProtocol);
+  if (imapUrl)
+  {
+    nsCOMPtr<nsIImapMailFolderSink> folderSink;
+    rv = imapUrl->GetImapMailFolderSink(getter_AddRefs(folderSink));
+    if (folderSink)
+    {
+      nsCOMPtr<nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(m_url);
+      rv = folderSink->SetUrlState(nullptr /* we don't know the protocol */,
+                                   mailUrl, start, false, m_cancelStatus);
+
+      // Required for killing ImapProtocol thread
+      if (NS_FAILED(m_cancelStatus) && imapProtocol)
+        imapProtocol->TellThreadToDie(false);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMockChannel::Close()
+{
+  if (mReadingFromCache)
+    NotifyStartEndReadFromCache(false);
+  else
+  {
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_url);
+    if (mailnewsUrl)
+    {
+      nsCOMPtr<nsICacheEntry> cacheEntry;
+      mailnewsUrl->GetMemCacheEntry(getter_AddRefs(cacheEntry));
+      if (cacheEntry)
+        cacheEntry->MarkValid();
+      // remove the channel from the load group
+      nsCOMPtr <nsILoadGroup> loadGroup;
+      GetLoadGroup(getter_AddRefs(loadGroup));
+      // if the mock channel wasn't initialized with a load group then
+      // use our load group (they may differ)
+      if (!loadGroup)
+        mailnewsUrl->GetLoadGroup(getter_AddRefs(loadGroup));
+      if (loadGroup)
+        loadGroup->RemoveRequest((nsIRequest *) this, nullptr, NS_OK);
+    }
+  }
+
+  m_channelListener = nullptr;
+  mCacheRequest = nullptr;
+  if (mTryingToReadPart)
+  {
+    // clear mem cache entry on imap part url in case it's holding
+    // onto last reference in mem cache. Need to do this on ui thread
+    nsresult rv;
+    nsCOMPtr <nsIImapUrl> imapUrl = do_QueryInterface(m_url, &rv);
+    if (imapUrl)
+    {
+      nsCOMPtr <nsIImapMailFolderSink> folderSink;
+      rv = imapUrl->GetImapMailFolderSink(getter_AddRefs(folderSink));
+      if (folderSink)
+      {
+        nsCOMPtr <nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(m_url);
+        rv = folderSink->ReleaseUrlCacheEntry(mailUrl);
+      }
+    }
+  }
+  mChannelClosed = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetProgressEventSink(nsIProgressEventSink ** aProgressEventSink)
+{
+  *aProgressEventSink = mProgressEventSink;
+  NS_IF_ADDREF(*aProgressEventSink);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetProgressEventSink(nsIProgressEventSink * aProgressEventSink)
+{
+  mProgressEventSink = aProgressEventSink;
+  return NS_OK;
+}
+
+NS_IMETHODIMP  nsImapMockChannel::GetChannelListener(nsIStreamListener **aChannelListener)
+{
+  *aChannelListener = m_channelListener;
+  NS_IF_ADDREF(*aChannelListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP  nsImapMockChannel::GetChannelContext(nsISupports **aChannelContext)
+{
+  *aChannelContext = m_channelContext;
+  NS_IF_ADDREF(*aChannelContext);
+  return NS_OK;
+}
+
+// now implement our mock implementation of the channel interface...we forward all calls to the real
+// channel if we have one...otherwise we return something bogus...
+
+NS_IMETHODIMP nsImapMockChannel::SetLoadGroup(nsILoadGroup * aLoadGroup)
+{
+  m_loadGroup = aLoadGroup;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetLoadGroup(nsILoadGroup * *aLoadGroup)
+{
+  *aLoadGroup = m_loadGroup;
+  NS_IF_ADDREF(*aLoadGroup);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetLoadInfo(nsILoadInfo * *aLoadInfo)
+{
+  *aLoadInfo = m_loadInfo;
+  NS_IF_ADDREF(*aLoadInfo);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetLoadInfo(nsILoadInfo * aLoadInfo)
+{
+  m_loadInfo = aLoadInfo;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetOriginalURI(nsIURI* *aURI)
+{
+  // IMap does not seem to have the notion of an original URI :-(
+  //  *aURI = m_originalUrl ? m_originalUrl : m_url;
+  *aURI = m_url;
+  NS_IF_ADDREF(*aURI);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetOriginalURI(nsIURI* aURI)
+{
+  // IMap does not seem to have the notion of an original URI :-(
+  //    NS_NOTREACHED("nsImapMockChannel::SetOriginalURI");
+  //    return NS_ERROR_NOT_IMPLEMENTED;
+  return NS_OK;       // ignore
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetURI(nsIURI* *aURI)
+{
+  *aURI = m_url;
+  NS_IF_ADDREF(*aURI);
+  return NS_OK ;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetURI(nsIURI* aURI)
+{
+  m_url = aURI;
+#ifdef DEBUG_bienvenu
+  if (!aURI)
+    printf("Clearing URI\n");
+#endif
+  if (m_url)
+  {
+    // if we don't have a progress event sink yet, get it from the url for now...
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_url);
+    if (mailnewsUrl && !mProgressEventSink)
+    {
+      nsCOMPtr<nsIMsgStatusFeedback> statusFeedback;
+      mailnewsUrl->GetStatusFeedback(getter_AddRefs(statusFeedback));
+      mProgressEventSink = do_QueryInterface(statusFeedback);
+    }
+    // If this is a fetch URL and we can, get the message size from the message
+    // header and set it to be the content length.
+    // Note that for an attachment URL, this will set the content length to be
+    // equal to the size of the entire message.
+    nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(m_url));
+    nsImapAction imapAction;
+    imapUrl->GetImapAction(&imapAction);
+    if (imapAction == nsIImapUrl::nsImapMsgFetch)
+    {
+      nsCOMPtr<nsIMsgMessageUrl> msgUrl(do_QueryInterface(m_url));
+      if (msgUrl)
+      {
+        nsCOMPtr<nsIMsgDBHdr> msgHdr;
+        // A failure to get a message header isn't an error
+        msgUrl->GetMessageHeader(getter_AddRefs(msgHdr));
+        if (msgHdr)
+        {
+          uint32_t messageSize;
+          if (NS_SUCCEEDED(msgHdr->GetMessageSize(&messageSize)))
+            SetContentLength(messageSize);
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::Open(nsIInputStream **_retval)
+{
+  return NS_ImplementChannelOpen(this, _retval);
+}
+
+NS_IMETHODIMP nsImapMockChannel::Open2(nsIInputStream **_retval)
+{
+  nsCOMPtr<nsIStreamListener> listener;
+  nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return Open(_retval);
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::OnCacheEntryAvailable(nsICacheEntry *entry, bool aNew, nsIApplicationCache* aAppCache, nsresult status)
+{
+  nsresult rv = NS_OK;
+
+  // make sure we didn't close the channel before the async call back came in...
+  // hmmm....if we had write access and we canceled this mock channel then I wonder if we should
+  // be invalidating the cache entry before kicking out...
+  if (mChannelClosed)
+  {
+    entry->AsyncDoom(nullptr);
+    return NS_OK;
+  }
+
+  if (!m_url) {
+    // Something has gone terribly wrong.
+    NS_WARNING("m_url is null in OnCacheEntryAvailable");
+    return Cancel(NS_ERROR_UNEXPECTED);
+  }
+
+  do {
+    // For "normal" read/write access we always receive NS_OK here. aNew
+    // indicates whether the cache entry is new and needs to be written, or not
+    // new and can be read. If AsyncOpenURI() was called with access read-only,
+    // status==NS_ERROR_CACHE_KEY_NOT_FOUND can be received here and we just read
+    // the data directly.
+    if (NS_FAILED(status))
+      break;
+
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_url, &rv);
+    mailnewsUrl->SetMemCacheEntry(entry);
+
+    // For URLs not related to parts, the processing is easy:
+    // aNew==true means that we need to write to the entry,
+    // aNew==false means that we can read it.
+    //
+    // Parts processing is a little complicated, we distinguish two cases:
+    // 1) The caller a) knows that the part is there or
+    //               b) it is not there and can also not be read from the
+    //                  entire message.
+    //    In this case, the URL used as cache key addresses the part and
+    //    mTryingToReadPart==false.
+    //    The caller has already set up part extraction.
+    //    This case is no different to non-part processing.
+    // 2) The caller wants to try to extract the part from the cache entry
+    //    of the entire message.
+    //    In this case, the URL used as cache key addresses the message and
+    //    mTryingToReadPart==true.
+    if (mTryingToReadPart)
+    {
+      // We are here with the URI of the entire message which we know exists.
+      MOZ_ASSERT(!aNew,
+                 "Logic error: Trying to read part from entire message which doesn't exist");
+      if (!aNew)
+      {
+        // Check the meta data.
+        nsCString annotation;
+        rv = entry->GetMetaDataElement("ContentModified", getter_Copies(annotation));
+        if (NS_FAILED(rv) || !annotation.EqualsLiteral("Not Modified"))
+        {
+          // The cache entry is not marked "Not Modified", that means it doesn't
+          // contain the entire message, so we can't use it.
+          // Call OpenCacheEntry() a second time to get the part.
+          rv = OpenCacheEntry();
+          if (NS_SUCCEEDED(rv))
+            return rv;
+
+          // Something has gone wrong, fall back to reading from the imap
+          // connection so the protocol doesn't hang.
+          break;
+        }
+      }
+    }
+
+    if (aNew)
+    {
+      // If we are writing, then insert a "stream listener Tee" into the flow
+      // to force data into the cache and to our current channel listener.
+      nsCOMPtr<nsIStreamListenerTee> tee = do_CreateInstance(NS_STREAMLISTENERTEE_CONTRACTID, &rv);
+      if (NS_SUCCEEDED(rv))
+      {
+        nsCOMPtr<nsIOutputStream> out;
+        // This will fail with the cache turned off, so we need to fall through
+        // to ReadFromImapConnection instead of aborting with NS_ENSURE_SUCCESS(rv,rv).
+        rv = entry->OpenOutputStream(0, getter_AddRefs(out));
+        if (NS_SUCCEEDED(rv))
+        {
+          rv = tee->Init(m_channelListener, out, nullptr);
+          m_channelListener = do_QueryInterface(tee);
+        }
+        else
+          NS_WARNING("IMAP Protocol failed to open output stream to Necko cache");
+      }
+    }
+    else
+    {
+      rv = ReadFromMemCache(entry);
+      if (NS_SUCCEEDED(rv))
+      {
+        NotifyStartEndReadFromCache(true);
+        entry->MarkValid();
+        return NS_OK; // Kick out if reading from the cache succeeded.
+      }
+      entry->AsyncDoom(nullptr); // Doom entry if we failed to read from cache.
+      mailnewsUrl->SetMemCacheEntry(nullptr); // We aren't going to be reading from the cache.
+    }
+  } while (false);
+
+  // If reading from the cache failed or if we are writing into the cache, default to ReadFromImapConnection.
+  return ReadFromImapConnection();
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::OnCacheEntryCheck(nsICacheEntry* entry, nsIApplicationCache* appCache,
+                                     uint32_t* aResult)
+{
+  *aResult = nsICacheEntryOpenCallback::ENTRY_WANTED;
+
+  // Check concurrent read: We can't read concurrently since we don't know
+  // that the entry will ever be written successfully. It may be aborted
+  // due to a size limitation. If reading concurrently, the following function
+  // will return NS_ERROR_IN_PROGRESS. Then we tell the cache to wait until
+  // the write is finished.
+  int64_t size = 0;
+  nsresult rv = entry->GetDataSize(&size);
+  if (rv == NS_ERROR_IN_PROGRESS)
+    *aResult = nsICacheEntryOpenCallback::RECHECK_AFTER_WRITE_FINISHED;
+
+  return NS_OK;
+}
+
+nsresult nsImapMockChannel::OpenCacheEntry()
+{
+  nsresult rv;
+  // get the cache session from our imap service...
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsICacheStorage> cacheStorage;
+  rv = imapService->GetCacheStorage(getter_AddRefs(cacheStorage));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t uidValidity = -1;
+  nsCacheAccessMode cacheAccess = nsICacheStorage::OPEN_NORMALLY;
+
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(m_url, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool storeResultsOffline;
+  nsCOMPtr<nsIImapMailFolderSink> folderSink;
+
+  rv = imapUrl->GetImapMailFolderSink(getter_AddRefs(folderSink));
+  if (folderSink)
+    folderSink->GetUidValidity(&uidValidity);
+  imapUrl->GetStoreResultsOffline(&storeResultsOffline);
+  // If we're storing the message in the offline store, don't
+  // write to the memory cache.
+  if (storeResultsOffline)
+    cacheAccess = nsICacheStorage::OPEN_READONLY;
+
+  // Use the uid validity as part of the cache key, so that if the uid validity
+  // changes, we won't re-use the wrong cache entries.
+  nsAutoCString extension;
+  extension.AppendInt(uidValidity, 16);
+
+  // Open a cache entry where the key is the potentially modified URL.
+  nsCOMPtr<nsIURI> newUri;
+  m_url->Clone(getter_AddRefs(newUri));
+  nsAutoCString path;
+  newUri->GetPath(path);
+
+  // First we need to "normalise" the URL by extracting ?part= and &filename.
+  // The path should only contain: ?part=x.y&filename=file.ext
+  // These are seen in the wild:
+  // /;section=2?part=1.2&filename=A01.JPG
+  // ?section=2?part=1.2&filename=A01.JPG&type=image/jpeg&filename=A01.JPG
+  // ?part=1.2&type=image/jpeg&filename=IMG_C0030.jpg
+  // ?header=quotebody&part=1.2&filename=lijbmghmkilicioj.png
+  nsAutoCString partQuery = MsgExtractQueryPart(path, "?part=");
+  if (partQuery.IsEmpty()) {
+    partQuery = MsgExtractQueryPart(path, "&part=");
+    if (!partQuery.IsEmpty()) {
+      // ? indicates a part query, so set the first character to that.
+      partQuery.SetCharAt('?', 0);
+    }
+  }
+  nsAutoCString filenameQuery = MsgExtractQueryPart(path, "&filename=");
+
+  // Truncate path at either /; or ?
+  int32_t ind = path.FindChar('?');
+  if (ind != kNotFound)
+    path.SetLength(ind);
+  ind = path.Find("/;");
+  if (ind != kNotFound)
+    path.SetLength(ind);
+
+  if (partQuery.IsEmpty())
+  {
+    // Not looking for a part. That's the easy part.
+    newUri->SetPath(path);
+    return cacheStorage->AsyncOpenURI(newUri, extension, cacheAccess, this);
+  }
+
+  /**
+   * Part processing (rest of this function).
+   */
+  if (mTryingToReadPart)
+  {
+    // If mTryingToReadPart is set, we are here for the second time.
+    // We tried to read a part from the entire message but the meta data didn't
+    // allow it. So we come back here.
+    // Now request the part with its full URL.
+    mTryingToReadPart = false;
+
+    // Note that part extraction was already set the first time.
+    newUri->SetPath(path + partQuery + filenameQuery);
+    return cacheStorage->AsyncOpenURI(newUri, extension, cacheAccess, this);
+  }
+
+  // First time processing. Set up part extraction.
+  SetupPartExtractorListener(imapUrl, m_channelListener);
+
+  // Check whether part is in the cache.
+  bool exists = false;
+  newUri->SetPath(path + partQuery + filenameQuery);
+  rv = cacheStorage->Exists(newUri, extension, &exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (exists) {
+    return cacheStorage->AsyncOpenURI(newUri, extension, cacheAccess, this);
+  }
+
+  // Let's see whether we have the entire message instead.
+  newUri->SetPath(path);
+  rv = cacheStorage->Exists(newUri, extension, &exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!exists) {
+    // The entire message is not in the cache. Request the part.
+    newUri->SetPath(path + partQuery + filenameQuery);
+    return cacheStorage->AsyncOpenURI(newUri, extension, cacheAccess, this);
+  }
+
+  // This is where is gets complicated. The entire message is in the cache,
+  // but we don't know whether it's suitable for use. Its meta data
+  // might indicate that the message is incomplete.
+  mTryingToReadPart = true;
+  return cacheStorage->AsyncOpenURI(newUri, extension, cacheAccess, this);
+}
+
+nsresult nsImapMockChannel::ReadFromMemCache(nsICacheEntry *entry)
+{
+  NS_ENSURE_ARG(entry);
+
+  nsCString annotation;
+  nsAutoCString entryKey;
+  nsAutoCString contentType;
+  nsresult rv = NS_OK;
+  bool shouldUseCacheEntry = false;
+
+  entry->GetKey(entryKey);
+  if (entryKey.FindChar('?') != kNotFound)
+  {
+    // Part processing: If we have a part, then we should use the cache entry.
+    entry->GetMetaDataElement("contentType", getter_Copies(contentType));
+    if (!contentType.IsEmpty())
+      SetContentType(contentType);
+    shouldUseCacheEntry = true;
+  }
+  else
+  {
+    // Whole message processing: We should make sure the content isn't modified.
+    rv = entry->GetMetaDataElement("ContentModified", getter_Copies(annotation));
+    if (NS_SUCCEEDED(rv) && !annotation.IsEmpty())
+      shouldUseCacheEntry = annotation.EqualsLiteral("Not Modified");
+
+    // Compare cache entry size with message size.
+    if (shouldUseCacheEntry)
+    {
+      int64_t entrySize;
+
+      rv = entry->GetDataSize(&entrySize);
+      // We don't expect concurrent read here, so this call should always work.
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIMsgMessageUrl> msgUrl(do_QueryInterface(m_url));
+      if (msgUrl)
+      {
+        nsCOMPtr<nsIMsgDBHdr> msgHdr;
+        // A failure to get a message header isn't an error
+        msgUrl->GetMessageHeader(getter_AddRefs(msgHdr));
+        if (msgHdr)
+        {
+          uint32_t messageSize;
+          if (NS_SUCCEEDED(msgHdr->GetMessageSize(&messageSize)) &&
+              messageSize != entrySize)
+          {
+            MOZ_LOG(IMAP, LogLevel::Warning,
+                ("ReadFromMemCache size mismatch for %s: message %d, cache %ld\n",
+                 entryKey.get(), messageSize, entrySize));
+            shouldUseCacheEntry = false;
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Common processing for full messages and message parts.
+   */
+
+  // Check header of full message or part.
+  if (shouldUseCacheEntry)
+  {
+    nsCOMPtr<nsIInputStream> in;
+    uint32_t readCount;
+    rv = entry->OpenInputStream(0, getter_AddRefs(in));
+    NS_ENSURE_SUCCESS(rv, rv);
+    const int kFirstBlockSize = 100;
+    char firstBlock[kFirstBlockSize + 1];
+
+    // Note: This will not work for a cache2 disk cache.
+    // (see bug 1302422 comment #4)
+    rv = in->Read(firstBlock, sizeof(firstBlock), &readCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+    firstBlock[kFirstBlockSize] = '\0';
+    int32_t findPos = MsgFindCharInSet(nsDependentCString(firstBlock),
+                                       ":\n\r", 0);
+    // Check that the first line is a header line, i.e., with a ':' in it
+    // Or that it begins with "From " because some IMAP servers allow that,
+    // even though it's technically invalid.
+    shouldUseCacheEntry = ((findPos != -1 && firstBlock[findPos] == ':') ||
+                           !(strncmp(firstBlock, "From ", 5)));
+    in->Close();
+  }
+
+  if (shouldUseCacheEntry)
+  {
+    nsCOMPtr<nsIInputStream> in;
+    rv = entry->OpenInputStream(0, getter_AddRefs(in));
+    NS_ENSURE_SUCCESS(rv, rv);
+     // if mem cache entry is broken or empty, return error.
+    uint64_t bytesAvailable;
+    rv = in->Available(&bytesAvailable);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (!bytesAvailable)
+      return NS_ERROR_FAILURE;
+
+    nsCOMPtr<nsIInputStreamPump> pump;
+    rv = NS_NewInputStreamPump(getter_AddRefs(pump), in);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // if we are going to read from the cache, then create a mock stream listener class and use it
+    nsImapCacheStreamListener * cacheListener = new nsImapCacheStreamListener();
+    NS_ADDREF(cacheListener);
+    cacheListener->Init(m_channelListener, this);
+    rv = pump->AsyncRead(cacheListener, m_channelContext);
+    NS_RELEASE(cacheListener);
+
+    if (NS_SUCCEEDED(rv)) // ONLY if we succeeded in actually starting the read should we return
+    {
+      mCacheRequest = pump;
+      nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(m_url);
+      // if the msg is unread, we should mark it read on the server. This lets
+      // the code running this url we're loading from the cache, if it cares.
+      imapUrl->SetMsgLoadingFromCache(true);
+
+      // be sure to set the cache entry's security info status as our security info status...
+      nsCOMPtr<nsISupports> securityInfo;
+      entry->GetSecurityInfo(getter_AddRefs(securityInfo));
+      SetSecurityInfo(securityInfo);
+      return NS_OK;
+    } // if AsyncRead succeeded.
+  } // if content is not modified
+  else
+  {
+    // Content is modified so return an error so we try to open it the
+    // old fashioned way.
+    rv = NS_ERROR_FAILURE;
+  }
+
+  return rv;
+}
+
+class nsReadFromImapConnectionFailure : public mozilla::Runnable
+{
+public:
+  nsReadFromImapConnectionFailure(nsImapMockChannel *aChannel)
+    : mImapMockChannel(aChannel)
+  {}
+
+  NS_IMETHOD Run()
+  {
+    if (mImapMockChannel) {
+      mImapMockChannel->RunOnStopRequestFailure();
+    }
+    return NS_OK;
+  }
+private:
+  RefPtr<nsImapMockChannel> mImapMockChannel;
+};
+
+
+nsresult nsImapMockChannel::RunOnStopRequestFailure()
+{
+  if (m_channelListener) {
+    m_channelListener->OnStopRequest(this, m_channelContext,
+                                     NS_MSG_ERROR_MSG_NOT_OFFLINE);
+  }
+  return NS_OK;
+}
+
+// the requested url isn't in any of our caches so create an imap connection
+// to process it.
+nsresult nsImapMockChannel::ReadFromImapConnection()
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(m_url);
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_url);
+
+  bool localOnly = false;
+  imapUrl->GetLocalFetchOnly(&localOnly);
+  if (localOnly)
+  {
+    // This will cause an OnStartRunningUrl, and the subsequent close
+    // will then cause an OnStopRunningUrl with the cancel status.
+    NotifyStartEndReadFromCache(true);
+    Cancel(NS_MSG_ERROR_MSG_NOT_OFFLINE);
+
+    // Dispatch error notification, so ReadFromImapConnection() returns *before*
+    // the error is sent to the listener's OnStopRequest(). This avoids
+    // endless recursion where the caller relies on async execution.
+    nsCOMPtr<nsIRunnable> event = new nsReadFromImapConnectionFailure(this);
+    NS_DispatchToCurrentThread(event);
+    return NS_MSG_ERROR_MSG_NOT_OFFLINE;
+  }
+
+  nsCOMPtr <nsILoadGroup> loadGroup;
+  GetLoadGroup(getter_AddRefs(loadGroup));
+  if (!loadGroup) // if we don't have one, the url will snag one from the msg window...
+    mailnewsUrl->GetLoadGroup(getter_AddRefs(loadGroup));
+
+  // okay, add the mock channel to the load group..
+  if (loadGroup)
+    loadGroup->AddRequest((nsIRequest *) this, nullptr /* context isupports */);
+
+  // loading the url consists of asking the server to add the url to it's imap event queue....
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = mailnewsUrl->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIImapIncomingServer> imapServer (do_QueryInterface(server, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Assume AsyncRead is always called from the UI thread.....
+  return imapServer->GetImapConnectionAndLoadUrl(imapUrl, m_channelListener);
+}
+
+// for messages stored in our offline cache, we have special code to handle that...
+// If it's in the local cache, we return true and we can abort the download because
+// this method does the rest of the work.
+bool nsImapMockChannel::ReadFromLocalCache()
+{
+  nsresult rv = NS_OK;
+
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(m_url);
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_url, &rv);
+
+  bool useLocalCache = false;
+  mailnewsUrl->GetMsgIsInLocalCache(&useLocalCache);
+  if (useLocalCache)
+  {
+    nsAutoCString messageIdString;
+
+    SetupPartExtractorListener(imapUrl, m_channelListener);
+
+    imapUrl->GetListOfMessageIds(messageIdString);
+    nsCOMPtr <nsIMsgFolder> folder;
+    rv = mailnewsUrl->GetFolder(getter_AddRefs(folder));
+    if (folder && NS_SUCCEEDED(rv))
+    {
+      // we want to create a file channel and read the msg from there.
+      nsCOMPtr<nsIInputStream> fileStream;
+      nsMsgKey msgKey = strtoul(messageIdString.get(), nullptr, 10);
+      uint32_t size;
+      int64_t offset;
+      rv = folder->GetOfflineFileStream(msgKey, &offset, &size, getter_AddRefs(fileStream));
+      // get the file channel from the folder, somehow (through the message or
+      // folder sink?) We also need to set the transfer offset to the message offset
+      if (fileStream && NS_SUCCEEDED(rv))
+      {
+        // dougt - This may break the ablity to "cancel" a read from offline mail reading.
+        // fileChannel->SetLoadGroup(m_loadGroup);
+        nsImapCacheStreamListener * cacheListener = new nsImapCacheStreamListener();
+        NS_ADDREF(cacheListener);
+        cacheListener->Init(m_channelListener, this);
+
+        // create a stream pump that will async read the specified amount of data.
+        // XXX make offset/size 64-bit ints
+        nsCOMPtr<nsIInputStreamPump> pump;
+        rv = NS_NewInputStreamPump(getter_AddRefs(pump), fileStream,
+                                   offset, (int64_t) size);
+        if (NS_SUCCEEDED(rv))
+          rv = pump->AsyncRead(cacheListener, m_channelContext);
+
+        NS_RELEASE(cacheListener);
+
+        if (NS_SUCCEEDED(rv)) // ONLY if we succeeded in actually starting the read should we return
+        {
+          // if the msg is unread, we should mark it read on the server. This lets
+          // the code running this url we're loading from the cache, if it cares.
+          imapUrl->SetMsgLoadingFromCache(true);
+          return true;
+        }
+      } // if we got an offline file transport
+    } // if we got the folder for this url
+  } // if use local cache
+
+  return false;
+}
+
+NS_IMETHODIMP nsImapMockChannel::AsyncOpen(nsIStreamListener *listener, nsISupports *ctxt)
+{
+  nsresult rv = NS_OK;
+
+  int32_t port;
+  if (!m_url)
+    return NS_ERROR_NULL_POINTER;
+  rv = m_url->GetPort(&port);
+  if (NS_FAILED(rv))
+      return rv;
+
+  rv = NS_CheckPortSafety(port, "imap");
+  if (NS_FAILED(rv))
+      return rv;
+
+  // set the stream listener and then load the url
+  m_channelContext = ctxt;
+  NS_ASSERTION(!m_channelListener, "shouldn't already have a listener");
+  m_channelListener = listener;
+  nsCOMPtr<nsIImapUrl> imapUrl  (do_QueryInterface(m_url));
+
+  nsImapAction imapAction;
+  imapUrl->GetImapAction(&imapAction);
+
+  bool externalLink = true;
+  imapUrl->GetExternalLinkUrl(&externalLink);
+
+  if (externalLink)
+  {
+    // for security purposes, only allow imap urls originating from external sources
+    // perform a limited set of actions.
+    // Currently the allowed set includes:
+    // 1) folder selection
+    // 2) message fetch
+    // 3) message part fetch
+
+    if (! (imapAction == nsIImapUrl::nsImapSelectFolder || imapAction == nsIImapUrl::nsImapMsgFetch || imapAction == nsIImapUrl::nsImapOpenMimePart
+      || imapAction == nsIImapUrl::nsImapMsgFetchPeek))
+      return NS_ERROR_FAILURE; // abort the running of this url....it failed a security check
+  }
+
+  if (ReadFromLocalCache())
+  {
+    (void) NotifyStartEndReadFromCache(true);
+    return NS_OK;
+  }
+
+  // okay, it's not in the local cache, now check the memory cache...
+  // but we can't download for offline use from the memory cache
+  if (imapAction != nsIImapUrl::nsImapMsgDownloadForOffline)
+  {
+    rv = OpenCacheEntry();
+    if (NS_SUCCEEDED(rv))
+      return rv;
+  }
+
+  SetupPartExtractorListener(imapUrl, m_channelListener);
+  // if for some reason open cache entry failed then just default to opening an imap connection for the url
+  return ReadFromImapConnection();
+}
+
+NS_IMETHODIMP nsImapMockChannel::AsyncOpen2(nsIStreamListener *aListener)
+{
+    nsCOMPtr<nsIStreamListener> listener = aListener;
+    nsresult rv = nsContentSecurityManager::doContentSecurityCheck(this, listener);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return AsyncOpen(listener, nullptr);
+}
+
+nsresult nsImapMockChannel::SetupPartExtractorListener(nsIImapUrl * aUrl, nsIStreamListener * aConsumer)
+{
+  // if the url we are loading refers to a specific part then we need
+  // libmime to extract that part from the message for us.
+  bool refersToPart = false;
+  aUrl->GetMimePartSelectorDetected(&refersToPart);
+  if (refersToPart)
+  {
+    nsCOMPtr<nsIStreamConverterService> converter = do_GetService("@mozilla.org/streamConverters;1");
+    if (converter && aConsumer)
+    {
+      nsCOMPtr<nsIStreamListener> newConsumer;
+      converter->AsyncConvertData("message/rfc822", "*/*",
+           aConsumer, static_cast<nsIChannel *>(this), getter_AddRefs(newConsumer));
+      if (newConsumer)
+        m_channelListener = newConsumer;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetLoadFlags(nsLoadFlags *aLoadFlags)
+{
+  //*aLoadFlags = nsIRequest::LOAD_NORMAL;
+  *aLoadFlags = mLoadFlags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetLoadFlags(nsLoadFlags aLoadFlags)
+{
+  mLoadFlags = aLoadFlags;
+  return NS_OK;       // don't fail when trying to set this
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetContentType(nsACString &aContentType)
+{
+  if (mContentType.IsEmpty())
+  {
+    nsImapAction imapAction = 0;
+    if (m_url)
+    {
+      nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(m_url);
+      if (imapUrl)
+      {
+        imapUrl->GetImapAction(&imapAction);
+      }
+    }
+    if (imapAction == nsIImapUrl::nsImapSelectFolder)
+      aContentType.AssignLiteral("x-application-imapfolder");
+    else
+      aContentType.AssignLiteral("message/rfc822");
+  }
+  else
+    aContentType = mContentType;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetContentType(const nsACString &aContentType)
+{
+  nsAutoCString charset;
+  nsresult rv = NS_ParseResponseContentType(aContentType, mContentType, charset);
+  if (NS_FAILED(rv) || mContentType.IsEmpty())
+    mContentType.AssignLiteral(UNKNOWN_CONTENT_TYPE);
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetContentCharset(nsACString &aContentCharset)
+{
+  aContentCharset.Assign(mCharset);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetContentCharset(const nsACString &aContentCharset)
+{
+  mCharset.Assign(aContentCharset);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::GetContentDisposition(uint32_t *aContentDisposition)
+{
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::SetContentDisposition(uint32_t aContentDisposition)
+{
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::GetContentDispositionFilename(nsAString &aContentDispositionFilename)
+{
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::SetContentDispositionFilename(const nsAString &aContentDispositionFilename)
+{
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::GetContentDispositionHeader(nsACString &aContentDispositionHeader)
+{
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetContentLength(int64_t * aContentLength)
+{
+  *aContentLength = mContentLength;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::SetContentLength(int64_t aContentLength)
+{
+    mContentLength = aContentLength;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetOwner(nsISupports * *aPrincipal)
+{
+  *aPrincipal = mOwner;
+  NS_IF_ADDREF(*aPrincipal);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetOwner(nsISupports * aPrincipal)
+{
+    mOwner = aPrincipal;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetSecurityInfo(nsISupports * *aSecurityInfo)
+{
+    NS_IF_ADDREF(*aSecurityInfo = mSecurityInfo);
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetSecurityInfo(nsISupports *aSecurityInfo)
+{
+    mSecurityInfo = aSecurityInfo;
+    return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// From nsIRequest
+////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP nsImapMockChannel::GetName(nsACString &result)
+{
+  if (m_url)
+    return m_url->GetSpec(result);
+  result.Truncate();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::IsPending(bool *result)
+{
+    *result = m_channelListener != nullptr;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::GetStatus(nsresult *status)
+{
+    *status = m_cancelStatus;
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::SetImapProtocol(nsIImapProtocol *aProtocol)
+{
+  mProtocol = do_GetWeakReference(aProtocol);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::Cancel(nsresult status)
+{
+  NS_WARNING_ASSERTION(NS_IsMainThread(),
+                       "nsImapMockChannel::Cancel should only be called from UI thread");
+  m_cancelStatus = status;
+  nsCOMPtr<nsIImapProtocol> imapProtocol = do_QueryReferent(mProtocol);
+
+  // if we aren't reading from the cache and we get canceled...doom our cache entry...
+  if (m_url)
+  {
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_url);
+    DoomCacheEntry(mailnewsUrl);
+  }
+
+  // Required for killing ImapProtocol thread
+  if (imapProtocol)
+    imapProtocol->TellThreadToDie(false);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMockChannel::Suspend()
+{
+    NS_NOTREACHED("nsImapMockChannel::Suspend");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsImapMockChannel::Resume()
+{
+    NS_NOTREACHED("nsImapMockChannel::Resume");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aNotificationCallbacks)
+{
+  *aNotificationCallbacks = mCallbacks.get();
+  NS_IF_ADDREF(*aNotificationCallbacks);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
+{
+  mCallbacks = aNotificationCallbacks;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapMockChannel::OnTransportStatus(nsITransport *transport, nsresult status,
+                                     int64_t progress, int64_t progressMax)
+{
+  if (NS_FAILED(m_cancelStatus) || (mLoadFlags & LOAD_BACKGROUND) || !m_url)
+    return NS_OK;
+
+  // these transport events should not generate any status messages
+  if (status == NS_NET_STATUS_RECEIVING_FROM ||
+      status == NS_NET_STATUS_SENDING_TO)
+    return NS_OK;
+
+  if (!mProgressEventSink)
+  {
+    NS_QueryNotificationCallbacks(mCallbacks, m_loadGroup, mProgressEventSink);
+    if (!mProgressEventSink)
+      return NS_OK;
+  }
+
+  nsAutoCString host;
+  m_url->GetHost(host);
+
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_url);
+  if (mailnewsUrl)
+  {
+    nsCOMPtr<nsIMsgIncomingServer> server;
+    mailnewsUrl->GetServer(getter_AddRefs(server));
+    if (server)
+      server->GetRealHostName(host);
+  }
+  mProgressEventSink->OnStatus(this, nullptr, status,
+                               NS_ConvertUTF8toUTF16(host).get());
+
+  return NS_OK;
+}
+
+
+nsIMAPMailboxInfo::nsIMAPMailboxInfo(const nsACString &aName, char aDelimiter)
+{
+  mMailboxName.Assign(aName);
+  mDelimiter = aDelimiter;
+  mChildrenListed = false;
+}
+
+nsIMAPMailboxInfo::~nsIMAPMailboxInfo()
+{
+}
+
+void nsIMAPMailboxInfo::SetChildrenListed(bool childrenListed)
+{
+  mChildrenListed = childrenListed;
+}
+
+bool nsIMAPMailboxInfo::GetChildrenListed()
+{
+  return mChildrenListed;
+}
+
+const nsACString& nsIMAPMailboxInfo::GetMailboxName()
+{
+  return mMailboxName;
+}
+
+char nsIMAPMailboxInfo::GetDelimiter()
+{
+  return mDelimiter;
+}
diff --git a/mailnews/imap/src/nsImapProtocol.h b/mailnews/imap/src/nsImapProtocol.h
new file mode 100644
index 0000000000..0341d87bbf
--- /dev/null
+++ b/mailnews/imap/src/nsImapProtocol.h
@@ -0,0 +1,764 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsImapProtocol_h___
+#define nsImapProtocol_h___
+
+#include "mozilla/Attributes.h"
+#include "nsIImapProtocol.h"
+#include "nsIImapUrl.h"
+
+#include "nsMsgProtocol.h"
+#include "nsIStreamListener.h"
+#include "nsIAsyncOutputStream.h"
+#include "nsIAsyncInputStream.h"
+#include "nsImapCore.h"
+#include "nsStringGlue.h"
+#include "nsIProgressEventSink.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsISocketTransport.h"
+#include "nsIInputStreamPump.h"
+
+// imap event sinks
+#include "nsIImapMailFolderSink.h"
+#include "nsIImapServerSink.h"
+#include "nsIImapMessageSink.h"
+
+// UI Thread proxy helper
+#include "nsIImapProtocolSink.h"
+
+#include "nsImapServerResponseParser.h"
+#include "nsImapFlagAndUidState.h"
+#include "nsIMAPNamespace.h"
+#include "nsTArray.h"
+#include "nsWeakPtr.h"
+#include "nsMsgLineBuffer.h" // we need this to use the nsMsgLineStreamBuffer helper class...
+#include "nsIInputStream.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsCOMArray.h"
+#include "nsIThread.h"
+#include "nsIRunnable.h"
+#include "nsIImapMockChannel.h"
+#include "nsILoadGroup.h"
+#include "nsCOMPtr.h"
+#include "nsIImapIncomingServer.h"
+#include "nsIMsgWindow.h"
+#include "nsIImapHeaderXferInfo.h"
+#include "nsMsgLineBuffer.h"
+#include "nsIAsyncInputStream.h"
+#include "nsITimer.h"
+#include "nsAutoPtr.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgAsyncPrompter.h"
+#include "mozilla/ReentrantMonitor.h"
+#include "nsSyncRunnableHelpers.h"
+#include "nsICacheEntryOpenCallback.h"
+
+class nsIMAPMessagePartIDArray;
+class nsIMsgIncomingServer;
+class nsIPrefBranch;
+class nsIMAPMailboxInfo;
+
+#define kDownLoadCacheSize 16000 // was 1536 - try making it bigger
+
+
+typedef struct _msg_line_info {
+    const char   *adoptedMessageLine;
+    uint32_t uidOfMessage;
+} msg_line_info;
+
+
+class nsMsgImapLineDownloadCache : public nsIImapHeaderInfo, public nsByteArray
+{
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIIMAPHEADERINFO
+  nsMsgImapLineDownloadCache();
+    uint32_t  CurrentUID();
+    uint32_t  SpaceAvailable();
+    bool CacheEmpty();
+
+    msg_line_info *GetCurrentLineInfo();
+
+private:
+  virtual ~nsMsgImapLineDownloadCache();
+
+    msg_line_info *fLineInfo;
+    int32_t m_msgSize;
+};
+
+#define kNumHdrsToXfer 10
+
+class nsMsgImapHdrXferInfo : public nsIImapHeaderXferInfo
+{
+public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIIMAPHEADERXFERINFO
+  nsMsgImapHdrXferInfo();
+  void    ResetAll(); // reset HeaderInfos for re-use
+  void    ReleaseAll(); // release HeaderInfos (frees up memory)
+  // this will return null if we're full, in which case the client code
+  // should transfer the headers and retry.
+  nsIImapHeaderInfo *StartNewHdr();
+  // call when we've finished adding lines to current hdr
+  void    FinishCurrentHdr();
+private:
+  virtual ~nsMsgImapHdrXferInfo();
+  nsCOMArray<nsIImapHeaderInfo> m_hdrInfos;
+  int32_t   m_nextFreeHdrInfo;
+};
+
+// State Flags (Note, I use the word state in terms of storing
+// state information about the connection (authentication, have we sent
+// commands, etc. I do not intend it to refer to protocol state)
+// Use these flags in conjunction with SetFlag/TestFlag/ClearFlag instead
+// of creating PRBools for everything....
+
+#define IMAP_RECEIVED_GREETING        0x00000001  /* should we pause for the next read */
+#define  IMAP_CONNECTION_IS_OPEN        0x00000004  /* is the connection currently open? */
+#define IMAP_WAITING_FOR_DATA         0x00000008
+#define IMAP_CLEAN_UP_URL_STATE       0x00000010 // processing clean up url state
+#define IMAP_ISSUED_LANGUAGE_REQUEST  0x00000020 // make sure we only issue the language request once per connection...
+#define IMAP_ISSUED_COMPRESS_REQUEST  0x00000040 // make sure we only request compression once
+
+class nsImapProtocol : public nsIImapProtocol,
+                       public nsIRunnable,
+                       public nsIInputStreamCallback,
+                       public nsSupportsWeakReference,
+                       public nsMsgProtocol,
+                       public nsIImapProtocolSink,
+                       public nsIMsgAsyncPromptListener
+{
+public:
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIINPUTSTREAMCALLBACK
+  nsImapProtocol();
+
+  virtual nsresult ProcessProtocolState(nsIURI * url, nsIInputStream * inputStream,
+                                        uint64_t sourceOffset, uint32_t length) override;
+
+  // nsIRunnable method
+  NS_IMETHOD Run() override;
+
+  //////////////////////////////////////////////////////////////////////////////////
+  // we support the nsIImapProtocol interface
+  //////////////////////////////////////////////////////////////////////////////////
+  NS_DECL_NSIIMAPPROTOCOL
+
+  //////////////////////////////////////////////////////////////////////////////////
+  // we support the nsIImapProtocolSink interface
+  //////////////////////////////////////////////////////////////////////////////////
+  NS_DECL_NSIIMAPPROTOCOLSINK
+
+  NS_DECL_NSIMSGASYNCPROMPTLISTENER
+
+  // message id string utilities.
+  uint32_t    CountMessagesInIdString(const char *idString);
+  static  bool    HandlingMultipleMessages(const nsCString &messageIdString);
+  // escape slashes and double quotes in username/passwords for insecure login.
+  static void EscapeUserNamePasswordString(const char *strToEscape, nsCString *resultStr);
+
+  // used to start fetching a message.
+  void GetShouldDownloadAllHeaders(bool *aResult);
+  void GetArbitraryHeadersToDownload(nsCString &aResult);
+  virtual void AdjustChunkSize();
+  virtual void FetchMessage(const nsCString &messageIds, 
+    nsIMAPeFetchFields whatToFetch,
+    const char *fetchModifier = nullptr,
+    uint32_t startByte = 0, uint32_t numBytes = 0,
+    char *part = 0);
+  void FetchTryChunking(const nsCString &messageIds,
+    nsIMAPeFetchFields whatToFetch,
+    bool idIsUid,
+    char *part,
+    uint32_t downloadSize,
+    bool tryChunking);
+  virtual void PipelinedFetchMessageParts(nsCString &uid, nsIMAPMessagePartIDArray *parts);
+  void FallbackToFetchWholeMsg(const nsCString &messageId, uint32_t messageSize);
+  // used when streaming a message fetch
+  virtual nsresult BeginMessageDownLoad(uint32_t totalSize, // for user, headers and body
+    const char *contentType);     // some downloads are header only
+  virtual void HandleMessageDownLoadLine(const char *line, bool isPartialLine, char *lineCopy=nullptr);
+  virtual void NormalMessageEndDownload();
+  virtual void AbortMessageDownLoad();
+  virtual void PostLineDownLoadEvent(const char *line, uint32_t uid);
+  void FlushDownloadCache();
+
+  virtual void SetMailboxDiscoveryStatus(EMailboxDiscoverStatus status);
+  virtual EMailboxDiscoverStatus GetMailboxDiscoveryStatus();
+
+  virtual void ProcessMailboxUpdate(bool handlePossibleUndo);
+  // Send log output...
+  void  Log(const char *logSubName, const char *extraInfo, const char *logData);
+  static void LogImapUrl(const char *logMsg, nsIImapUrl *imapUrl);
+  // Comment from 4.5: We really need to break out the thread synchronizer from the
+  // connection class...Not sure what this means
+  bool    GetPseudoInterrupted();
+  void  PseudoInterrupt(bool the_interrupt);
+
+  uint32_t GetMessageSize(const char * messageId, bool idsAreUids);
+  bool GetSubscribingNow();
+
+  bool    DeathSignalReceived();
+  void    ResetProgressInfo();
+  void    SetActive(bool active);
+  bool    GetActive();
+
+  bool GetShowAttachmentsInline();
+
+  // Sets whether or not the content referenced by the current ActiveEntry has been modified.
+  // Used for MIME parts on demand.
+  void    SetContentModified(IMAP_ContentModifiedType modified);
+  bool    GetShouldFetchAllParts();
+  bool    GetIgnoreExpunges() {return m_ignoreExpunges;}
+  // Generic accessors required by the imap parser
+  char * CreateNewLineFromSocket();
+  nsresult GetConnectionStatus();
+  void SetConnectionStatus(nsresult status);
+
+  // Cleanup the connection and shutdown the thread.
+  void TellThreadToDie();
+
+  const nsCString& GetImapHostName(); // return the host name from the url for the
+  // current connection
+  const nsCString& GetImapUserName(); // return the user name from the identity
+  const char* GetImapServerKey(); // return the user name from the incoming server;
+
+  // state set by the imap parser...
+  void NotifyMessageFlags(imapMessageFlagsType flags, const nsACString &keywords,
+                          nsMsgKey key, uint64_t highestModSeq);
+  void NotifySearchHit(const char * hitLine);
+
+  // Event handlers for the imap parser.
+  void DiscoverMailboxSpec(nsImapMailboxSpec * adoptedBoxSpec);
+  void AlertUserEventUsingName(const char* aMessageId);
+  void AlertUserEvent(const char * message);
+  void AlertUserEventFromServer(const char * aServerEvent);
+
+  void ProgressEventFunctionUsingName(const char* aMsgId);
+  void ProgressEventFunctionUsingNameWithString(const char* aMsgName, const char *
+    aExtraInfo);
+  void PercentProgressUpdateEvent(char16_t *message, int64_t currentProgress, int64_t maxProgress);
+  void ShowProgress();
+
+  // utility function calls made by the server
+
+  void Copy(const char * messageList, const char *destinationMailbox,
+    bool idsAreUid);
+  void Search(const char * searchCriteria,  bool useUID,
+    bool notifyHit = true);
+  // imap commands issued by the parser
+  void Store(const nsCString &aMessageList, const char * aMessageData, bool
+    aIdsAreUid);
+  void ProcessStoreFlags(const nsCString &messageIds,
+    bool idsAreUids,
+    imapMessageFlagsType flags,
+    bool addFlags);
+  void IssueUserDefinedMsgCommand(const char *command, const char * messageList);
+  void FetchMsgAttribute(const nsCString &messageIds, const nsCString &attribute);
+  void Expunge();
+  void UidExpunge(const nsCString &messageSet);
+  void Close(bool shuttingDown = false, bool waitForResponse = true);
+  void Check();
+  void SelectMailbox(const char *mailboxName);
+  // more imap commands
+  void Logout(bool shuttingDown = false, bool waitForResponse = true);
+  void Noop();
+  void XServerInfo();
+  void Netscape();
+  void XMailboxInfo(const char *mailboxName);
+  void XAOL_Option(const char *option);
+  void MailboxData();
+  void GetMyRightsForFolder(const char *mailboxName);
+  void Bodystructure(const nsCString &messageId, bool idIsUid);
+  void PipelinedFetchMessageParts(const char *uid, nsIMAPMessagePartIDArray *parts);
+
+
+  // this function does not ref count!!! be careful!!!
+  nsIImapUrl  *GetCurrentUrl() {return m_runningUrl;}
+
+  // acl and namespace stuff
+  // notifies libmsg that we have a new personal/default namespace that we're using
+  void CommitNamespacesForHostEvent();
+  // notifies libmsg that we have new capability data for the current host
+  void CommitCapability();
+
+  // Adds a set of rights for a given user on a given mailbox on the current host.
+  // if userName is NULL, it means "me," or MYRIGHTS.
+  // rights is a single string of rights, as specified by RFC2086, the IMAP ACL extension.
+  void AddFolderRightsForUser(const char *mailboxName, const char *userName, const char *rights);
+  // Clears all rights for the current folder, for all users.
+  void ClearAllFolderRights();
+  void RefreshFolderACLView(const char *mailboxName, nsIMAPNamespace *nsForMailbox);
+
+  nsresult SetFolderAdminUrl(const char *mailboxName);
+  void HandleMemoryFailure();
+  void HandleCurrentUrlError();
+
+  // UIDPLUS extension
+  void SetCopyResponseUid(const char* msgIdString);
+
+  // Quota support
+  void UpdateFolderQuotaData(nsCString& aQuotaRoot, uint32_t aUsed, uint32_t aMax);
+
+  bool GetPreferPlainText() { return m_preferPlainText; }
+
+  int32_t GetCurFetchSize() { return m_curFetchSize; }
+
+  const nsString &GetEmptyMimePartString() { return m_emptyMimePartString; }
+private:
+  virtual ~nsImapProtocol();
+  // the following flag is used to determine when a url is currently being run. It is cleared when we
+  // finish processng a url and it is set whenever we call Load on a url
+  bool m_urlInProgress;
+  nsCOMPtr<nsIImapUrl> m_runningUrl; // the nsIImapURL that is currently running
+  nsImapAction m_imapAction;  // current imap action associated with this connnection...
+
+  nsCString             m_hostName;
+  nsCString             m_userName;
+  nsCString             m_serverKey;
+  nsCString             m_realHostName;
+  char                  *m_dataOutputBuf;
+  nsMsgLineStreamBuffer * m_inputStreamBuffer;
+  uint32_t              m_allocatedSize; // allocated size
+  uint32_t        m_totalDataSize; // total data size
+  uint32_t        m_curReadIndex;  // current read index
+  nsCString       m_trashFolderName;
+
+  // Ouput stream for writing commands to the socket
+  nsCOMPtr<nsISocketTransport>  m_transport;
+
+  nsCOMPtr<nsIAsyncInputStream>   m_channelInputStream;
+  nsCOMPtr<nsIAsyncOutputStream>  m_channelOutputStream;
+  nsCOMPtr<nsIImapMockChannel>    m_mockChannel;   // this is the channel we should forward to people
+  uint32_t m_bytesToChannel;
+  bool m_fetchingWholeMessage;
+  //nsCOMPtr<nsIRequest> mAsyncReadRequest; // we're going to cancel this when we're done with the conn.
+
+
+  // ******* Thread support *******
+  nsCOMPtr<nsIThread>      m_iThread;
+  PRThread     *m_thread;
+  mozilla::ReentrantMonitor m_dataAvailableMonitor;   // used to notify the arrival of data from the server
+  mozilla::ReentrantMonitor m_urlReadyToRunMonitor;   // used to notify the arrival of a new url to be processed
+  mozilla::ReentrantMonitor m_pseudoInterruptMonitor;
+  mozilla::ReentrantMonitor m_dataMemberMonitor;
+  mozilla::ReentrantMonitor m_threadDeathMonitor;
+  mozilla::ReentrantMonitor m_waitForBodyIdsMonitor;
+  mozilla::ReentrantMonitor m_fetchBodyListMonitor;
+  mozilla::ReentrantMonitor m_passwordReadyMonitor;
+  mozilla::Mutex mLock;
+  // If we get an async password prompt, this is where the UI thread
+  // stores the password, before notifying the imap thread of the password
+  // via the m_passwordReadyMonitor.
+  nsCString m_password;
+  // Set to the result of nsImapServer::PromptPassword
+  nsresult    m_passwordStatus;
+
+  bool         m_imapThreadIsRunning;
+  void ImapThreadMainLoop(void);
+  nsresult    m_connectionStatus;
+  nsCString   m_connectionType;
+
+  bool        m_nextUrlReadyToRun;
+  nsWeakPtr   m_server;
+
+  RefPtr<ImapMailFolderSinkProxy> m_imapMailFolderSink;
+  RefPtr<ImapMessageSinkProxy>    m_imapMessageSink;
+  RefPtr<ImapServerSinkProxy>     m_imapServerSink;
+  RefPtr<ImapProtocolSinkProxy>   m_imapProtocolSink;
+
+  // helper function to setup imap sink interface proxies
+  nsresult SetupSinkProxy();
+  // End thread support stuff
+
+  bool GetDeleteIsMoveToTrash();
+  bool GetShowDeletedMessages();
+  nsCString m_currentCommand;
+  nsImapServerResponseParser m_parser;
+  nsImapServerResponseParser& GetServerStateParser() { return m_parser; }
+
+  void HandleIdleResponses();
+  virtual bool ProcessCurrentURL();
+  void EstablishServerConnection();
+  virtual void ParseIMAPandCheckForNewMail(const char* commandString =
+    nullptr, bool ignoreBadNOResponses = false);
+  // biff
+  void  PeriodicBiff();
+  void  SendSetBiffIndicatorEvent(nsMsgBiffState newState);
+  bool  CheckNewMail();
+
+  // folder opening and listing header functions
+  void FolderHeaderDump(uint32_t *msgUids, uint32_t msgCount);
+  void FolderMsgDump(uint32_t *msgUids, uint32_t msgCount, nsIMAPeFetchFields fields);
+  void FolderMsgDumpLoop(uint32_t *msgUids, uint32_t msgCount, nsIMAPeFetchFields fields);
+  void WaitForPotentialListOfBodysToFetch(uint32_t **msgIdList, uint32_t &msgCount);
+  void HeaderFetchCompleted();
+  void UploadMessageFromFile(nsIFile* file, const char* mailboxName, PRTime date,
+    imapMessageFlagsType flags, nsCString &keywords);
+
+  // mailbox name utilities.
+  void CreateEscapedMailboxName(const char *rawName, nsCString &escapedName);
+  void SetupMessageFlagsString(nsCString & flagString,
+    imapMessageFlagsType flags,
+    uint16_t userFlags);
+
+  // body fetching listing data
+  bool      m_fetchBodyListIsNew;
+  uint32_t  m_fetchBodyCount;
+  uint32_t  *m_fetchBodyIdList;
+
+  // initialization function given a new url and transport layer
+  nsresult  SetupWithUrl(nsIURI * aURL, nsISupports* aConsumer);
+  void ReleaseUrlState(bool rerunningUrl); // release any state that is stored on a per action basis.
+  /**
+   * Last ditch effort to run the url without using an imap connection.
+   * If it turns out that we don't need to run the url at all (e.g., we're
+   * trying to download a single message for offline use and it has already
+   * been downloaded, this function will send the appropriate notifications.
+   *
+   * @returns true if the url has been run locally, or doesn't need to be run.
+   */
+  bool TryToRunUrlLocally(nsIURI *aURL, nsISupports *aConsumer);
+
+  ////////////////////////////////////////////////////////////////////////////////////////
+  // Communication methods --> Reading and writing protocol
+  ////////////////////////////////////////////////////////////////////////////////////////
+
+  // SendData not only writes the NULL terminated data in dataBuffer to our output stream
+  // but it also informs the consumer that the data has been written to the stream.
+  // aSuppressLogging --> set to true if you wish to suppress logging for this particular command.
+  // this is useful for making sure we don't log authenication information like the user's password (which was
+  // encoded anyway), but still we shouldn't add that information to the log.
+  nsresult SendData(const char * dataBuffer, bool aSuppressLogging = false) override;
+
+  // state ported over from 4.5
+  bool m_pseudoInterrupted;
+  bool m_active;
+  bool m_folderNeedsSubscribing;
+  bool m_folderNeedsACLRefreshed;
+
+  bool m_threadShouldDie;
+
+  // use to prevent re-entering TellThreadToDie.
+  bool m_inThreadShouldDie;
+  // if the UI thread has signalled the IMAP thread to die, and the
+  // connection has timed out, this will be set to FALSE.
+  bool m_safeToCloseConnection;
+
+  nsImapFlagAndUidState  *m_flagState;
+  nsMsgBiffState        m_currentBiffState;
+  // manage the IMAP server command tags
+  // 11 = enough memory for the decimal representation of MAX_UINT + trailing nul
+  char m_currentServerCommandTag[11];
+  uint32_t m_currentServerCommandTagNumber;
+  void IncrementCommandTagNumber();
+  const char *GetServerCommandTag();
+
+  void StartTLS();
+
+  // login related methods.
+  nsresult GetPassword(nsCString &password, bool aNewPasswordRequested);
+  void InitPrefAuthMethods(int32_t authMethodPrefValue,
+                           nsIMsgIncomingServer *aServer);
+  nsresult ChooseAuthMethod();
+  void MarkAuthMethodAsFailed(eIMAPCapabilityFlags failedAuthMethod);
+  void ResetAuthMethods();
+
+  // All of these methods actually issue protocol
+  void Capability(); // query host for capabilities.
+  void ID(); // send RFC 2971 app info to server
+  void EnableCondStore(); 
+  void StartCompressDeflate();
+  nsresult BeginCompressing();
+  void Language(); // set the language on the server if it supports it
+  void Namespace();
+  void InsecureLogin(const char *userName, const nsCString &password);
+  nsresult AuthLogin(const char *userName, const nsCString &password, eIMAPCapabilityFlag flag);
+  void ProcessAuthenticatedStateURL();
+  void ProcessAfterAuthenticated();
+  void ProcessSelectedStateURL();
+  bool TryToLogon();
+
+  // Process Authenticated State Url used to be one giant if statement. I've broken out a set of actions
+  // based on the imap action passed into the url. The following functions are imap protocol handlers for
+  // each action. They are called by ProcessAuthenticatedStateUrl.
+  void OnLSubFolders();
+  void OnAppendMsgFromFile();
+
+  char *GetFolderPathString(); // OK to call from UI thread
+
+  char * OnCreateServerSourceFolderPathString();
+  char * OnCreateServerDestinationFolderPathString();
+  nsresult CreateServerSourceFolderPathString(char **result);
+  void OnCreateFolder(const char * aSourceMailbox);
+  void OnEnsureExistsFolder(const char * aSourceMailbox);
+  void OnSubscribe(const char * aSourceMailbox);
+  void OnUnsubscribe(const char * aSourceMailbox);
+  void RefreshACLForFolderIfNecessary(const char * mailboxName);
+  void RefreshACLForFolder(const char * aSourceMailbox);
+  void GetACLForFolder(const char *aMailboxName);
+  void OnRefreshAllACLs();
+  void OnListFolder(const char * aSourceMailbox, bool aBool);
+  void OnStatusForFolder(const char * sourceMailbox);
+  void OnDeleteFolder(const char * aSourceMailbox);
+  void OnRenameFolder(const char * aSourceMailbox);
+  void OnMoveFolderHierarchy(const char * aSourceMailbox);
+  void DeleteFolderAndMsgs(const char * aSourceMailbox);
+  void RemoveMsgsAndExpunge();
+  void FindMailboxesIfNecessary();
+  void CreateMailbox(const char *mailboxName);
+  void DeleteMailbox(const char *mailboxName);
+  void RenameMailbox(const char *existingName, const char *newName);
+  void RemoveHierarchyDelimiter(nsCString &mailboxName);
+  bool CreateMailboxRespectingSubscriptions(const char *mailboxName);
+  bool DeleteMailboxRespectingSubscriptions(const char *mailboxName);
+  bool    RenameMailboxRespectingSubscriptions(const char *existingName,
+    const char *newName,
+    bool reallyRename);
+  // notify the fe that a folder was deleted
+  void FolderDeleted(const char *mailboxName);
+  // notify the fe that a folder creation failed
+  void FolderNotCreated(const char *mailboxName);
+  // notify the fe that a folder was deleted
+  void FolderRenamed(const char *oldName,
+    const char *newName);
+
+  bool FolderIsSelected(const char *mailboxName);
+
+  bool    MailboxIsNoSelectMailbox(const char *mailboxName);
+  nsCString CreatePossibleTrashName(const char *prefix);
+  bool FolderNeedsACLInitialized(const char *folderName);
+  void DiscoverMailboxList();
+  void DiscoverAllAndSubscribedBoxes();
+  void MailboxDiscoveryFinished();
+  void NthLevelChildList(const char *onlineMailboxPrefix, int32_t depth);
+  // LIST SUBSCRIBED command (from RFC 5258) crashes some servers. so we need to
+  // identify those servers
+  bool GetListSubscribedIsBrokenOnServer();
+  bool IsExtraSelectNeeded();
+  void Lsub(const char *mailboxPattern, bool addDirectoryIfNecessary);
+  void List(const char *mailboxPattern, bool addDirectoryIfNecessary,
+            bool useXLIST = false);
+  void Subscribe(const char *mailboxName);
+  void Unsubscribe(const char *mailboxName);
+  void Idle();
+  void EndIdle(bool waitForResponse = true);
+  // Some imap servers include the mailboxName following the dir-separator in the list of
+  // subfolders of the mailboxName. In fact, they are the same. So we should decide if
+  // we should delete such subfolder and provide feedback if the delete operation succeed.
+  bool DeleteSubFolders(const char* aMailboxName, bool & aDeleteSelf);
+  bool    RenameHierarchyByHand(const char *oldParentMailboxName,
+    const char *newParentMailboxName);
+  bool RetryUrl();
+
+  nsresult GlobalInitialization(nsIPrefBranch *aPrefBranch);
+  nsresult Configure(int32_t TooFastTime, int32_t IdealTime,
+    int32_t ChunkAddSize, int32_t ChunkSize, int32_t ChunkThreshold,
+    bool FetchByChunks);
+  nsresult GetMsgWindow(nsIMsgWindow ** aMsgWindow);
+  // End Process AuthenticatedState Url helper methods
+
+  virtual char const *GetType() override {return "imap";}
+
+  // Quota support
+  void GetQuotaDataIfSupported(const char *aBoxName);
+
+  // CondStore support - true if server supports it, and the user hasn't disabled it.
+  bool UseCondStore();
+  // false if pref "mail.server.serverxxx.use_condstore" is false;
+  bool m_useCondStore; 
+  // COMPRESS=DEFLATE support - true if server supports it, and the user hasn't disabled it.
+  bool UseCompressDeflate();
+  // false if pref "mail.server.serverxxx.use_compress_deflate" is false;
+  bool m_useCompressDeflate; 
+  // these come from the nsIDBFolderInfo in the msgDatabase and
+  // are initialized in nsImapProtocol::SetupWithUrl.
+  uint64_t mFolderLastModSeq;
+  int32_t mFolderTotalMsgCount;
+  uint32_t mFolderHighestUID;
+  uint32_t mFolderNumDeleted;
+
+  bool m_isGmailServer;
+  nsTArray<nsCString> mCustomDBHeaders;
+  nsTArray<nsCString> mCustomHeaders;
+  bool    m_trackingTime;
+  PRTime  m_startTime;
+  PRTime  m_endTime;
+  PRTime  m_lastActiveTime;
+  int32_t m_tooFastTime;
+  int32_t m_idealTime;
+  int32_t m_chunkAddSize;
+  int32_t m_chunkStartSize;
+  bool    m_fetchByChunks;
+  bool    m_sendID;
+  int32_t m_curFetchSize;
+  bool    m_ignoreExpunges;
+  eIMAPCapabilityFlags m_prefAuthMethods; // set of capability flags (in nsImapCore.h) for auth methods
+  eIMAPCapabilityFlags m_failedAuthMethods; // ditto
+  eIMAPCapabilityFlag m_currentAuthMethod; // exactly one capability flag, or 0
+  int32_t m_socketType;
+  int32_t m_chunkSize;
+  int32_t m_chunkThreshold;
+  RefPtr<nsMsgImapLineDownloadCache> m_downloadLineCache;
+  RefPtr<nsMsgImapHdrXferInfo> m_hdrDownloadCache;
+  nsCOMPtr <nsIImapHeaderInfo> m_curHdrInfo;
+  // mapping between mailboxes and the corresponding folder flags
+  nsDataHashtable<nsCStringHashKey, int32_t> m_standardListMailboxes;
+  // mapping between special xlist mailboxes and the corresponding folder flags
+  nsDataHashtable<nsCStringHashKey, int32_t> m_specialXListMailboxes;
+
+
+  nsIImapHostSessionList * m_hostSessionList;
+
+  bool m_fromHeaderSeen;
+
+  // these settings allow clients to override various pieces of the connection info from the url
+  bool m_overRideUrlConnectionInfo;
+
+  nsCString m_logonHost;
+  nsCString m_logonCookie;
+  int16_t m_logonPort;
+  
+  nsString mAcceptLanguages;
+  
+  // progress stuff
+  void SetProgressString(const char* stringName);
+  
+  nsString m_progressString;
+  nsCString     m_progressStringName;
+  int32_t       m_progressIndex;
+  int32_t       m_progressCount;
+  nsCString     m_lastProgressStringName;
+  int32_t       m_lastPercent;
+  int64_t       m_lastProgressTime;
+
+  bool m_notifySearchHit;
+  bool m_checkForNewMailDownloadsHeaders;
+  bool m_needNoop;
+  bool m_idle;
+  bool m_useIdle;
+  int32_t m_noopCount;
+  bool    m_autoSubscribe, m_autoUnsubscribe, m_autoSubscribeOnOpen;
+  bool m_closeNeededBeforeSelect;
+  bool m_retryUrlOnError;
+  bool m_preferPlainText;
+  nsCString m_forceSelectValue;
+  bool m_forceSelect;
+
+  int32_t m_uidValidity; // stored uid validity for the selected folder.
+
+  enum EMailboxHierarchyNameState {
+    kNoOperationInProgress,
+      kDiscoverBaseFolderInProgress,
+      kDiscoverTrashFolderInProgress,
+      kDeleteSubFoldersInProgress,
+      kListingForInfoOnly,
+      kListingForInfoAndDiscovery,
+      kDiscoveringNamespacesOnly,
+      kXListing,
+      kListingForFolderFlags,
+      kListingForCreate
+  };
+  EMailboxHierarchyNameState  m_hierarchyNameState;
+  EMailboxDiscoverStatus      m_discoveryStatus;
+  nsTArray<nsIMAPMailboxInfo*> m_listedMailboxList;
+  nsTArray<char*> *            m_deletableChildren;
+  uint32_t                    m_flagChangeCount;
+  PRTime                      m_lastCheckTime;
+
+  bool CheckNeeded();
+
+  nsString m_emptyMimePartString;
+
+  RefPtr<mozilla::mailnews::OAuth2ThreadHelper> mOAuth2Support;
+};
+
+// This small class is a "mock" channel because it is a mockery of the imap channel's implementation...
+// it's a light weight channel that we can return to necko when they ask for a channel on a url before
+// we actually have an imap protocol instance around which can run the url. Please see my comments in
+// nsIImapMockChannel.idl for more details..
+//
+// Threading concern: This class lives entirely in the UI thread.
+
+class nsICacheEntry;
+
+class nsImapMockChannel : public nsIImapMockChannel
+                        , public nsICacheEntryOpenCallback
+                        , public nsITransportEventSink
+                        , public nsSupportsWeakReference
+{
+public:
+  friend class nsImapProtocol;
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIIMAPMOCKCHANNEL
+  NS_DECL_NSICHANNEL
+  NS_DECL_NSIREQUEST
+  NS_DECL_NSICACHEENTRYOPENCALLBACK
+  NS_DECL_NSITRANSPORTEVENTSINK
+
+  nsImapMockChannel();
+  static nsresult Create (const nsIID& iid, void **result);
+  nsresult RunOnStopRequestFailure();
+
+protected:
+  virtual ~nsImapMockChannel();
+  nsCOMPtr <nsIURI> m_url;
+
+  nsCOMPtr<nsIURI> m_originalUrl;
+  nsCOMPtr<nsILoadGroup> m_loadGroup;
+  nsCOMPtr<nsILoadInfo> m_loadInfo;
+  nsCOMPtr<nsIStreamListener> m_channelListener;
+  nsISupports * m_channelContext; 
+  nsresult m_cancelStatus;
+  nsLoadFlags mLoadFlags;
+  nsCOMPtr<nsIProgressEventSink> mProgressEventSink;
+  nsCOMPtr<nsIInterfaceRequestor> mCallbacks;
+  nsCOMPtr<nsISupports> mOwner;
+  nsCOMPtr<nsISupports> mSecurityInfo;
+  nsCOMPtr<nsIRequest> mCacheRequest; // the request associated with a read from the cache
+  nsCString mContentType;
+  nsCString mCharset;
+  nsWeakPtr mProtocol;
+
+  bool mChannelClosed;
+  bool mReadingFromCache;
+  bool mTryingToReadPart;
+  int64_t mContentLength;
+
+  // cache related helper methods
+  nsresult OpenCacheEntry(); // makes a request to the cache service for a cache entry for a url
+  bool ReadFromLocalCache(); // attempts to read the url out of our local (offline) cache....
+  nsresult ReadFromImapConnection(); // creates a new imap connection to read the url
+  nsresult ReadFromMemCache(nsICacheEntry *entry); // attempts to read the url out of our memory cache
+  nsresult NotifyStartEndReadFromCache(bool start);
+
+  // we end up daisy chaining multiple nsIStreamListeners into the load process.
+  nsresult SetupPartExtractorListener(nsIImapUrl * aUrl, nsIStreamListener * aConsumer);
+};
+
+// This class contains the name of a mailbox and whether or not
+// its children have been listed.
+class nsIMAPMailboxInfo
+{
+public:
+  nsIMAPMailboxInfo(const nsACString &aName, char aDelimiter);
+  virtual ~nsIMAPMailboxInfo();
+
+  void   SetChildrenListed(bool childrenListed);
+  bool GetChildrenListed();
+  const  nsACString& GetMailboxName();
+  char   GetDelimiter();
+
+protected:
+  nsCString mMailboxName;
+  bool     mChildrenListed;
+  char     mDelimiter;
+};
+
+#endif  // nsImapProtocol_h___
diff --git a/mailnews/imap/src/nsImapSearchResults.cpp b/mailnews/imap/src/nsImapSearchResults.cpp
new file mode 100644
index 0000000000..e5e4a76be4
--- /dev/null
+++ b/mailnews/imap/src/nsImapSearchResults.cpp
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"  // for pre-compiled headers
+
+#include "nsImapCore.h"
+#include "nsImapSearchResults.h"
+#include "prmem.h"
+#include "nsCRT.h"
+
+nsImapSearchResultSequence::nsImapSearchResultSequence()
+{
+}
+
+nsImapSearchResultSequence *nsImapSearchResultSequence::CreateSearchResultSequence()
+{
+  return new nsImapSearchResultSequence;
+}
+
+void nsImapSearchResultSequence::Clear(void)
+{
+    int32_t i = Length();
+    while (0 <= --i) 
+    {
+      char* string = ElementAt(i);
+      PR_Free(string);
+    }
+    nsTArray<char*>::Clear();
+}
+
+nsImapSearchResultSequence::~nsImapSearchResultSequence()
+{
+  Clear();
+}
+
+
+void nsImapSearchResultSequence::ResetSequence()
+{
+  Clear();
+}
+
+void nsImapSearchResultSequence::AddSearchResultLine(const char *searchLine)
+{
+  // The first add becomes node 2.  Fix this.
+  char *copiedSequence = PL_strdup(searchLine + 9); // 9 == "* SEARCH "
+  
+  if (copiedSequence)	// if we can't allocate this then the search won't hit
+    AppendElement(copiedSequence);
+}
+
+
+nsImapSearchResultIterator::nsImapSearchResultIterator(nsImapSearchResultSequence &sequence) :
+fSequence(sequence)
+{
+  ResetIterator();
+}
+
+nsImapSearchResultIterator::~nsImapSearchResultIterator()
+{
+}
+
+void  nsImapSearchResultIterator::ResetIterator()
+{
+  fSequenceIndex = 0;
+  fCurrentLine = (char *) fSequence.SafeElementAt(fSequenceIndex);
+  fPositionInCurrentLine = fCurrentLine;
+}
+
+int32_t nsImapSearchResultIterator::GetNextMessageNumber()
+{
+  int32_t returnValue = 0;
+  if (fPositionInCurrentLine)
+  {	
+    returnValue = atoi(fPositionInCurrentLine);
+    
+    // eat the current number
+    while (isdigit(*++fPositionInCurrentLine))
+      ;
+    
+    if (*fPositionInCurrentLine == 0xD)	// found CR, no more digits on line
+    {
+      fCurrentLine = (char *) fSequence.SafeElementAt(++fSequenceIndex);
+      fPositionInCurrentLine = fCurrentLine;
+    }
+    else	// eat the space
+      fPositionInCurrentLine++;
+  }
+  
+  return returnValue;
+}
diff --git a/mailnews/imap/src/nsImapSearchResults.h b/mailnews/imap/src/nsImapSearchResults.h
new file mode 100644
index 0000000000..b4333417b1
--- /dev/null
+++ b/mailnews/imap/src/nsImapSearchResults.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsImapSearchResults_h___
+#define nsImapSearchResults_h___
+
+#include "nsTArray.h"
+
+class nsImapSearchResultSequence : public nsTArray<char*>
+{
+public:
+    virtual ~nsImapSearchResultSequence();
+    static nsImapSearchResultSequence *CreateSearchResultSequence();
+    
+    virtual void AddSearchResultLine(const char *searchLine);
+    virtual void ResetSequence();
+    void  Clear();
+    
+    friend class nsImapSearchResultIterator;
+private:
+    nsImapSearchResultSequence();
+};
+
+class nsImapSearchResultIterator {
+public:
+    nsImapSearchResultIterator(nsImapSearchResultSequence &sequence);
+    virtual ~nsImapSearchResultIterator();
+    
+    void  ResetIterator();
+    int32_t GetNextMessageNumber();   // returns 0 at end of list
+private:
+    nsImapSearchResultSequence &fSequence;
+    int32_t fSequenceIndex;
+    char  *fCurrentLine;
+    char  *fPositionInCurrentLine;
+};
+
+
+
+#endif
diff --git a/mailnews/imap/src/nsImapServerResponseParser.cpp b/mailnews/imap/src/nsImapServerResponseParser.cpp
new file mode 100644
index 0000000000..faa37cc459
--- /dev/null
+++ b/mailnews/imap/src/nsImapServerResponseParser.cpp
@@ -0,0 +1,3360 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"  // for pre-compiled headers
+#include "nsMimeTypes.h"
+#include "nsImapCore.h"
+#include "nsImapProtocol.h"
+#include "nsImapServerResponseParser.h"
+#include "nsIMAPBodyShell.h"
+#include "nsImapFlagAndUidState.h"
+#include "nsIMAPNamespace.h"
+#include "nsImapStringBundle.h"
+#include "nsImapUtils.h"
+#include "nsCRT.h"
+#include "nsMsgUtils.h"
+#include "mozilla/Logging.h"
+
+////////////////// nsImapServerResponseParser /////////////////////////
+
+extern PRLogModuleInfo* IMAP;
+
+nsImapServerResponseParser::nsImapServerResponseParser(nsImapProtocol &imapProtocolConnection)
+                            : nsIMAPGenericParser(),
+    fReportingErrors(true),
+    fCurrentFolderReadOnly(false),
+    fCurrentLineContainedFlagInfo(false),
+    fServerIsNetscape3xServer(false),
+    fNumberOfUnseenMessages(0),
+    fNumberOfExistingMessages(0),
+    fNumberOfRecentMessages(0),
+    fSizeOfMostRecentMessage(0),
+    fTotalDownloadSize(0),
+    fCurrentCommandTag(nullptr),
+    fSelectedMailboxName(nullptr),
+    fIMAPstate(kNonAuthenticated),
+    fLastChunk(false),
+    fServerConnection(imapProtocolConnection),
+    fHostSessionList(nullptr)
+{
+  fSearchResults = nsImapSearchResultSequence::CreateSearchResultSequence();
+  fFolderAdminUrl = nullptr;
+  fNetscapeServerVersionString = nullptr;
+  fXSenderInfo = nullptr;
+  fSupportsUserDefinedFlags = 0;
+  fSettablePermanentFlags = 0;
+  fCapabilityFlag = kCapabilityUndefined;
+  fLastAlert = nullptr;
+  fDownloadingHeaders = false;
+  fGotPermanentFlags = false;
+  fFolderUIDValidity = 0;
+  fHighestModSeq = 0;
+  fAuthChallenge = nullptr;
+  fStatusUnseenMessages = 0;
+  fStatusRecentMessages = 0;
+  fStatusNextUID = nsMsgKey_None;
+  fStatusExistingMessages = 0;
+  fReceivedHeaderOrSizeForUID = nsMsgKey_None;
+  fCondStoreEnabled = false;
+}
+
+nsImapServerResponseParser::~nsImapServerResponseParser()
+{
+  PR_Free( fCurrentCommandTag );
+  delete fSearchResults;
+  PR_Free( fFolderAdminUrl );
+  PR_Free( fNetscapeServerVersionString );
+  PR_Free( fXSenderInfo );
+  PR_Free( fLastAlert );
+  PR_Free( fSelectedMailboxName );
+  PR_Free(fAuthChallenge);
+
+  NS_IF_RELEASE (fHostSessionList);
+}
+
+bool nsImapServerResponseParser::LastCommandSuccessful()
+{
+  return (!CommandFailed() &&
+    !fServerConnection.DeathSignalReceived() &&
+    nsIMAPGenericParser::LastCommandSuccessful());
+}
+
+// returns true if things look ok to continue
+bool nsImapServerResponseParser::GetNextLineForParser(char **nextLine)
+{
+  bool rv = true;
+  *nextLine = fServerConnection.CreateNewLineFromSocket();
+  if (fServerConnection.DeathSignalReceived() ||
+      NS_FAILED(fServerConnection.GetConnectionStatus()))
+    rv = false;
+  // we'd really like to try to silently reconnect, but we shouldn't put this
+  // message up just in the interrupt case
+  if (NS_FAILED(fServerConnection.GetConnectionStatus()) &&
+      !fServerConnection.DeathSignalReceived())
+    fServerConnection.AlertUserEventUsingName("imapServerDisconnected");
+  return rv;
+}
+
+bool nsImapServerResponseParser::CommandFailed()
+{
+  return fCurrentCommandFailed;
+}
+
+void nsImapServerResponseParser::SetCommandFailed(bool failed)
+{
+  fCurrentCommandFailed = failed;
+}
+
+void nsImapServerResponseParser::SetFlagState(nsIImapFlagAndUidState *state)
+{
+  fFlagState = state;
+}
+
+uint32_t nsImapServerResponseParser::SizeOfMostRecentMessage()
+{
+  return fSizeOfMostRecentMessage;
+}
+
+// Call this when adding a pipelined command to the session
+void nsImapServerResponseParser::IncrementNumberOfTaggedResponsesExpected(const char *newExpectedTag)
+{
+  fNumberOfTaggedResponsesExpected++;
+  PR_Free( fCurrentCommandTag );
+  fCurrentCommandTag = PL_strdup(newExpectedTag);
+  if (!fCurrentCommandTag)
+    HandleMemoryFailure();
+}
+
+void nsImapServerResponseParser::InitializeState()
+{
+  fCurrentCommandFailed = false;
+  fNumberOfRecentMessages = 0;
+  fReceivedHeaderOrSizeForUID = nsMsgKey_None;
+}
+
+// RFC3501:  response = *(continue-req / response-data) response-done
+//           response-data = "*" SP (resp-cond-state / resp-cond-bye /
+//                           mailbox-data / message-data / capability-data) CRLF
+//           continue-req    = "+" SP (resp-text / base64) CRLF
+void nsImapServerResponseParser::ParseIMAPServerResponse(const char *aCurrentCommand,
+                                                         bool aIgnoreBadAndNOResponses,
+                                                         char *aGreetingWithCapability)
+{
+
+  NS_ASSERTION(aCurrentCommand && *aCurrentCommand != '\r' &&
+    *aCurrentCommand != '\n' && *aCurrentCommand != ' ', "Invailid command string");
+  bool sendingIdleDone = !strcmp(aCurrentCommand, "DONE" CRLF);
+  if (sendingIdleDone)
+    fWaitingForMoreClientInput = false;
+
+  // Reinitialize the parser
+  SetConnected(true);
+  SetSyntaxError(false);
+
+  // Reinitialize our state
+  InitializeState();
+
+  // the default is to not pipeline
+  fNumberOfTaggedResponsesExpected = 1;
+  int numberOfTaggedResponsesReceived = 0;
+
+  nsCString copyCurrentCommand(aCurrentCommand);
+  if (!fServerConnection.DeathSignalReceived())
+  {
+    char *placeInTokenString = nullptr;
+    char *tagToken = nullptr;
+    const char *commandToken = nullptr;
+    bool inIdle = false;
+    if (!sendingIdleDone)
+    {
+      placeInTokenString = copyCurrentCommand.BeginWriting();
+      tagToken = NS_strtok(WHITESPACE, &placeInTokenString);
+      commandToken = NS_strtok(WHITESPACE, &placeInTokenString);
+    }
+    else
+      commandToken = "DONE";
+    if (tagToken)
+    {
+      PR_Free( fCurrentCommandTag );
+      fCurrentCommandTag = PL_strdup(tagToken);
+      if (!fCurrentCommandTag)
+        HandleMemoryFailure();
+      inIdle = commandToken && !strcmp(commandToken, "IDLE");
+    }
+
+    if (commandToken && ContinueParse())
+      PreProcessCommandToken(commandToken, aCurrentCommand);
+
+    if (ContinueParse())
+    {
+      ResetLexAnalyzer();
+
+      if (aGreetingWithCapability)
+      {
+        PR_FREEIF(fCurrentLine);
+        fCurrentLine = aGreetingWithCapability;
+      }
+
+      do {
+        AdvanceToNextToken();
+
+        // untagged responses [RFC3501, Sec. 2.2.2]
+        while (ContinueParse() && fNextToken && *fNextToken == '*')
+        {
+          response_data();
+          if (ContinueParse())
+          {
+            if (!fAtEndOfLine)
+              SetSyntaxError(true);
+            else if (!inIdle && !fCurrentCommandFailed && !aGreetingWithCapability)
+              AdvanceToNextToken();
+          }
+        }
+
+        // command continuation request [RFC3501, Sec. 7.5]
+        if (ContinueParse() && fNextToken && *fNextToken == '+')	// never pipeline APPEND or AUTHENTICATE
+        {
+          NS_ASSERTION((fNumberOfTaggedResponsesExpected - numberOfTaggedResponsesReceived) == 1,
+            " didn't get the number of tagged responses we expected");
+          numberOfTaggedResponsesReceived = fNumberOfTaggedResponsesExpected;
+          if (commandToken && !PL_strcasecmp(commandToken, "authenticate") && placeInTokenString &&
+            (!PL_strncasecmp(placeInTokenString, "CRAM-MD5", strlen("CRAM-MD5"))
+             || !PL_strncasecmp(placeInTokenString, "NTLM", strlen("NTLM"))
+             || !PL_strncasecmp(placeInTokenString, "GSSAPI", strlen("GSSAPI"))
+             || !PL_strncasecmp(placeInTokenString, "MSN", strlen("MSN"))))
+          {
+            // we need to store the challenge from the server if we are using CRAM-MD5 or NTLM.
+            authChallengeResponse_data();
+          }
+        }
+        else
+          numberOfTaggedResponsesReceived++;
+
+        if (numberOfTaggedResponsesReceived < fNumberOfTaggedResponsesExpected)
+          response_tagged();
+
+      } while (ContinueParse() && !inIdle && (numberOfTaggedResponsesReceived < fNumberOfTaggedResponsesExpected));
+
+      // check and see if the server is waiting for more input
+      // it's possible that we ate this + while parsing certain responses (like cram data),
+      // in these cases, the parsing routine for that specific command will manually set
+      // fWaitingForMoreClientInput so we don't lose that information....
+      if ((fNextToken && *fNextToken == '+') || inIdle)
+      {
+        fWaitingForMoreClientInput = true;
+      }
+      // if we aren't still waiting for more input....
+      else if (!fWaitingForMoreClientInput && !aGreetingWithCapability)
+      {
+        if (ContinueParse())
+          response_done();
+
+        if (ContinueParse() && !CommandFailed())
+        {
+          // a successful command may change the eIMAPstate
+          ProcessOkCommand(commandToken);
+        }
+        else if (CommandFailed())
+        {
+          // a failed command may change the eIMAPstate
+          ProcessBadCommand(commandToken);
+          if (fReportingErrors && !aIgnoreBadAndNOResponses)
+            fServerConnection.AlertUserEventFromServer(fCurrentLine);
+        }
+      }
+    }
+  }
+  else
+    SetConnected(false);
+}
+
+void nsImapServerResponseParser::HandleMemoryFailure()
+{
+  fServerConnection.AlertUserEventUsingName("imapOutOfMemory");
+  nsIMAPGenericParser::HandleMemoryFailure();
+}
+
+
+// SEARCH is the only command that requires pre-processing for now.
+// others will be added here.
+void nsImapServerResponseParser::PreProcessCommandToken(const char *commandToken,
+                                                        const char *currentCommand)
+{
+  fCurrentCommandIsSingleMessageFetch = false;
+  fWaitingForMoreClientInput = false;
+
+  if (!PL_strcasecmp(commandToken, "SEARCH"))
+    fSearchResults->ResetSequence();
+  else if (!PL_strcasecmp(commandToken, "SELECT") && currentCommand)
+  {
+    // the mailbox name must be quoted, so strip the quotes
+    const char *openQuote = PL_strchr(currentCommand, '"');
+    NS_ASSERTION(openQuote, "expected open quote in imap server response");
+    if (!openQuote)
+    { // ill formed select command
+      openQuote = PL_strchr(currentCommand, ' ');
+    }
+    PR_Free( fSelectedMailboxName);
+    fSelectedMailboxName = PL_strdup(openQuote + 1);
+    if (fSelectedMailboxName)
+    {
+      // strip the escape chars and the ending quote
+      char *currentChar = fSelectedMailboxName;
+      while (*currentChar)
+      {
+        if (*currentChar == '\\')
+        {
+          PL_strcpy(currentChar, currentChar+1);
+          currentChar++;	// skip what we are escaping
+        }
+        else if (*currentChar == '\"')
+          *currentChar = 0;	// end quote
+        else
+          currentChar++;
+      }
+    }
+    else
+      HandleMemoryFailure();
+
+    // we don't want bogus info for this new box
+    //delete fFlagState;	// not our object
+    //fFlagState = nullptr;
+  }
+  else if (!PL_strcasecmp(commandToken, "CLOSE"))
+  {
+    return;	// just for debugging
+    // we don't want bogus info outside the selected state
+    //delete fFlagState;	// not our object
+    //fFlagState = nullptr;
+  }
+  else if (!PL_strcasecmp(commandToken, "UID"))
+  {
+    nsCString copyCurrentCommand(currentCommand);
+    if (!fServerConnection.DeathSignalReceived())
+    {
+      char *placeInTokenString = copyCurrentCommand.BeginWriting();
+      (void) NS_strtok(WHITESPACE, &placeInTokenString); // skip tag token
+      (void) NS_strtok(WHITESPACE, &placeInTokenString); // skip uid token
+      char *fetchToken = NS_strtok(WHITESPACE, &placeInTokenString);
+      if (!PL_strcasecmp(fetchToken, "FETCH") )
+      {
+        char *uidStringToken = NS_strtok(WHITESPACE, &placeInTokenString);
+        // , and : are uid delimiters
+        if (!PL_strchr(uidStringToken, ',') && !PL_strchr(uidStringToken, ':'))
+          fCurrentCommandIsSingleMessageFetch = true;
+      }
+    }
+  }
+}
+
+const char *nsImapServerResponseParser::GetSelectedMailboxName()
+{
+  return fSelectedMailboxName;
+}
+
+nsImapSearchResultIterator *nsImapServerResponseParser::CreateSearchResultIterator()
+{
+  return new nsImapSearchResultIterator(*fSearchResults);
+}
+
+nsImapServerResponseParser::eIMAPstate nsImapServerResponseParser::GetIMAPstate()
+{
+  return fIMAPstate;
+}
+
+void nsImapServerResponseParser::PreauthSetAuthenticatedState()
+{
+  fIMAPstate = kAuthenticated;
+}
+
+void nsImapServerResponseParser::ProcessOkCommand(const char *commandToken)
+{
+  if (!PL_strcasecmp(commandToken, "LOGIN") ||
+    !PL_strcasecmp(commandToken, "AUTHENTICATE"))
+    fIMAPstate = kAuthenticated;
+  else if (!PL_strcasecmp(commandToken, "LOGOUT"))
+    fIMAPstate = kNonAuthenticated;
+  else if (!PL_strcasecmp(commandToken, "SELECT") ||
+    !PL_strcasecmp(commandToken, "EXAMINE"))
+    fIMAPstate = kFolderSelected;
+  else if (!PL_strcasecmp(commandToken, "CLOSE"))
+  {
+    fIMAPstate = kAuthenticated;
+    // we no longer have a selected mailbox.
+    PR_FREEIF( fSelectedMailboxName );
+  }
+  else if ((!PL_strcasecmp(commandToken, "LIST")) ||
+          (!PL_strcasecmp(commandToken, "LSUB")) ||
+          (!PL_strcasecmp(commandToken, "XLIST")))
+  {
+    //fServerConnection.MailboxDiscoveryFinished();
+    // This used to be reporting that we were finished
+    // discovering folders for each time we issued a
+    // LIST or LSUB.  So if we explicitly listed the
+    // INBOX, or Trash, or namespaces, we would get multiple
+    // "done" states, even though we hadn't finished.
+    // Move this to be called from the connection object
+    // itself.
+  }
+  else if (!PL_strcasecmp(commandToken, "FETCH"))
+  {
+    if (!fZeroLengthMessageUidString.IsEmpty())
+    {
+      // "Deleting zero length message");
+      fServerConnection.Store(fZeroLengthMessageUidString, "+Flags (\\Deleted)", true);
+      if (LastCommandSuccessful())
+        fServerConnection.Expunge();
+
+      fZeroLengthMessageUidString.Truncate();
+    }
+  }
+  if (GetFillingInShell())
+  {
+    // There is a BODYSTRUCTURE response.  Now let's generate the stream...
+    // that is, if we're not doing it already
+    if (!m_shell->IsBeingGenerated())
+    {
+      nsImapProtocol *navCon = &fServerConnection;
+
+      char *imapPart = nullptr;
+
+      fServerConnection.GetCurrentUrl()->GetImapPartToFetch(&imapPart);
+      m_shell->Generate(imapPart);
+      PR_Free(imapPart);
+
+      if ((navCon && navCon->GetPseudoInterrupted())
+        || fServerConnection.DeathSignalReceived())
+      {
+        // we were pseudointerrupted or interrupted
+        // if it's not in the cache, then we were (pseudo)interrupted while generating
+        // for the first time. Release it.
+        if (!m_shell->IsShellCached())
+          m_shell = nullptr;
+        navCon->PseudoInterrupt(false);
+      }
+      else if (m_shell->GetIsValid())
+      {
+        // If we have a valid shell that has not already been cached, then cache it.
+        if (!m_shell->IsShellCached() && fHostSessionList)	// cache is responsible for destroying it
+        {
+          MOZ_LOG(IMAP, mozilla::LogLevel::Info,
+            ("BODYSHELL:  Adding shell to cache."));
+          const char *serverKey = fServerConnection.GetImapServerKey();
+          fHostSessionList->AddShellToCacheForHost(
+            serverKey, m_shell);
+        }
+      }
+      m_shell = nullptr;
+    }
+  }
+}
+
+void nsImapServerResponseParser::ProcessBadCommand(const char *commandToken)
+{
+  if (!PL_strcasecmp(commandToken, "LOGIN") ||
+    !PL_strcasecmp(commandToken, "AUTHENTICATE"))
+    fIMAPstate = kNonAuthenticated;
+  else if (!PL_strcasecmp(commandToken, "LOGOUT"))
+    fIMAPstate = kNonAuthenticated; // ??
+  else if (!PL_strcasecmp(commandToken, "SELECT") ||
+    !PL_strcasecmp(commandToken, "EXAMINE"))
+    fIMAPstate = kAuthenticated; // nothing selected
+  else if (!PL_strcasecmp(commandToken, "CLOSE"))
+    fIMAPstate = kAuthenticated; // nothing selected
+  if (GetFillingInShell() && !m_shell->IsBeingGenerated())
+    m_shell = nullptr;
+}
+
+
+
+// RFC3501:  response-data = "*" SP (resp-cond-state / resp-cond-bye /
+//                           mailbox-data / message-data / capability-data) CRLF
+// These are ``untagged'' responses [RFC3501, Sec. 2.2.2]
+/*
+ The RFC1730 grammar spec did not allow one symbol look ahead to determine
+ between mailbox_data / message_data so I combined the numeric possibilities
+ of mailbox_data and all of message_data into numeric_mailbox_data.
+
+ It is assumed that the initial "*" is already consumed before calling this
+ method. The production implemented here is
+         response_data   ::= (resp_cond_state / resp_cond_bye /
+                              mailbox_data / numeric_mailbox_data /
+                              capability_data)
+                              CRLF
+*/
+void nsImapServerResponseParser::response_data()
+{
+  AdvanceToNextToken();
+
+  if (ContinueParse())
+  {
+    // Instead of comparing lots of strings and make function calls, try to
+    // pre-flight the possibilities based on the first letter of the token.
+    switch (NS_ToUpper(fNextToken[0]))
+    {
+    case 'O':   // OK
+      if (NS_ToUpper(fNextToken[1]) == 'K')
+        resp_cond_state(false);
+      else SetSyntaxError(true);
+      break;
+    case 'N':   // NO
+      if (NS_ToUpper(fNextToken[1]) == 'O')
+        resp_cond_state(false);
+      else if (!PL_strcasecmp(fNextToken, "NAMESPACE"))
+        namespace_data();
+      else SetSyntaxError(true);
+      break;
+    case 'B':   // BAD
+      if (!PL_strcasecmp(fNextToken, "BAD"))
+        resp_cond_state(false);
+      else if (!PL_strcasecmp(fNextToken, "BYE"))
+        resp_cond_bye();
+      else SetSyntaxError(true);
+      break;
+    case 'F':
+      if (!PL_strcasecmp(fNextToken, "FLAGS"))
+        mailbox_data();
+      else SetSyntaxError(true);
+      break;
+    case 'P':
+      if (PL_strcasecmp(fNextToken, "PERMANENTFLAGS"))
+        mailbox_data();
+      else SetSyntaxError(true);
+      break;
+    case 'L':
+      if (!PL_strcasecmp(fNextToken, "LIST") || !PL_strcasecmp(fNextToken, "LSUB"))
+        mailbox_data();
+      else if (!PL_strcasecmp(fNextToken, "LANGUAGE"))
+        language_data();
+      else
+        SetSyntaxError(true);
+      break;
+    case 'M':
+      if (!PL_strcasecmp(fNextToken, "MAILBOX"))
+        mailbox_data();
+      else if (!PL_strcasecmp(fNextToken, "MYRIGHTS"))
+        myrights_data(false);
+      else SetSyntaxError(true);
+      break;
+    case 'S':
+      if (!PL_strcasecmp(fNextToken, "SEARCH"))
+        mailbox_data();
+      else if (!PL_strcasecmp(fNextToken, "STATUS"))
+      {
+        AdvanceToNextToken();
+        if (fNextToken)
+        {
+          char *mailboxName = CreateAstring();
+          PL_strfree( mailboxName);
+        }
+        while (ContinueParse() && !fAtEndOfLine)
+        {
+          AdvanceToNextToken();
+          if (!fNextToken)
+            break;
+
+          if (*fNextToken == '(') fNextToken++;
+          if (!PL_strcasecmp(fNextToken, "UIDNEXT"))
+          {
+            AdvanceToNextToken();
+            if (fNextToken)
+            {
+              fStatusNextUID = strtoul(fNextToken, nullptr, 10);
+              // if this token ends in ')', then it is the last token
+              // else we advance
+              if ( *(fNextToken + strlen(fNextToken) - 1) == ')')
+                fNextToken += strlen(fNextToken) - 1;
+            }
+          }
+          else if (!PL_strcasecmp(fNextToken, "MESSAGES"))
+          {
+            AdvanceToNextToken();
+            if (fNextToken)
+            {
+              fStatusExistingMessages = strtoul(fNextToken, nullptr, 10);
+              // if this token ends in ')', then it is the last token
+              // else we advance
+              if ( *(fNextToken + strlen(fNextToken) - 1) == ')')
+                fNextToken += strlen(fNextToken) - 1;
+            }
+          }
+          else if (!PL_strcasecmp(fNextToken, "UNSEEN"))
+          {
+            AdvanceToNextToken();
+            if (fNextToken)
+            {
+              fStatusUnseenMessages = strtoul(fNextToken, nullptr, 10);
+              // if this token ends in ')', then it is the last token
+              // else we advance
+              if ( *(fNextToken + strlen(fNextToken) - 1) == ')')
+                fNextToken += strlen(fNextToken) - 1;
+            }
+          }
+          else if (!PL_strcasecmp(fNextToken, "RECENT"))
+          {
+            AdvanceToNextToken();
+            if (fNextToken)
+            {
+              fStatusRecentMessages = strtoul(fNextToken, nullptr, 10);
+              // if this token ends in ')', then it is the last token
+              // else we advance
+              if ( *(fNextToken + strlen(fNextToken) - 1) == ')')
+                fNextToken += strlen(fNextToken) - 1;
+            }
+          }
+          else if (*fNextToken == ')')
+            break;
+          else if (!fAtEndOfLine)
+            SetSyntaxError(true);
+        }
+      } else SetSyntaxError(true);
+      break;
+    case 'C':
+      if (!PL_strcasecmp(fNextToken, "CAPABILITY"))
+        capability_data();
+      else SetSyntaxError(true);
+      break;
+    case 'V':
+      if (!PL_strcasecmp(fNextToken, "VERSION"))
+      {
+        // figure out the version of the Netscape server here
+        PR_FREEIF(fNetscapeServerVersionString);
+        AdvanceToNextToken();
+        if (! fNextToken)
+          SetSyntaxError(true);
+        else
+        {
+          fNetscapeServerVersionString = CreateAstring();
+          AdvanceToNextToken();
+          if (fNetscapeServerVersionString)
+          {
+            fServerIsNetscape3xServer = (*fNetscapeServerVersionString == '3');
+          }
+        }
+        skip_to_CRLF();
+      }
+      else SetSyntaxError(true);
+      break;
+    case 'A':
+      if (!PL_strcasecmp(fNextToken, "ACL"))
+      {
+        acl_data();
+      }
+      else if (!PL_strcasecmp(fNextToken, "ACCOUNT-URL"))
+      {
+        fMailAccountUrl.Truncate();
+        AdvanceToNextToken();
+        if (! fNextToken)
+          SetSyntaxError(true);
+        else
+        {
+          fMailAccountUrl.Adopt(CreateAstring());
+          AdvanceToNextToken();
+        }
+      }
+      else SetSyntaxError(true);
+      break;
+    case 'E':
+      if (!PL_strcasecmp(fNextToken, "ENABLED"))
+        enable_data();
+        break;
+    case 'X':
+      if (!PL_strcasecmp(fNextToken, "XSERVERINFO"))
+        xserverinfo_data();
+      else if (!PL_strcasecmp(fNextToken, "XMAILBOXINFO"))
+        xmailboxinfo_data();
+      else if (!PL_strcasecmp(fNextToken, "XAOL-OPTION"))
+        skip_to_CRLF();
+      else if (!PL_strcasecmp(fNextToken, "XLIST"))
+        mailbox_data();
+      else
+      {
+        // check if custom command
+        nsAutoCString customCommand;
+        fServerConnection.GetCurrentUrl()->GetCommand(customCommand);
+        if (customCommand.Equals(fNextToken))
+        {
+          nsAutoCString customCommandResponse;
+          while (Connected() && !fAtEndOfLine)
+          {
+            AdvanceToNextToken();
+            customCommandResponse.Append(fNextToken);
+            customCommandResponse.Append(" ");
+          }
+          fServerConnection.GetCurrentUrl()->SetCustomCommandResult(customCommandResponse);
+        }
+        else
+          SetSyntaxError(true);
+      }
+      break;
+    case 'Q':
+      if (!PL_strcasecmp(fNextToken, "QUOTAROOT")  || !PL_strcasecmp(fNextToken, "QUOTA"))
+        quota_data();
+      else
+        SetSyntaxError(true);
+      break;
+    case 'I':
+      id_data();
+      break;
+    default:
+      if (IsNumericString(fNextToken))
+        numeric_mailbox_data();
+      else
+        SetSyntaxError(true);
+      break;
+    }
+
+    if (ContinueParse())
+      PostProcessEndOfLine();
+  }
+}
+
+
+void nsImapServerResponseParser::PostProcessEndOfLine()
+{
+  // for now we only have to do one thing here
+  // a fetch response to a 'uid store' command might return the flags
+  // before it returns the uid of the message.  So we need both before
+  // we report the new flag info to the front end
+
+  // also check and be sure that there was a UID in the current response
+  if (fCurrentLineContainedFlagInfo && CurrentResponseUID())
+  {
+    fCurrentLineContainedFlagInfo = false;
+    nsCString customFlags;
+    fFlagState->GetCustomFlags(CurrentResponseUID(), getter_Copies(customFlags));
+    fServerConnection.NotifyMessageFlags(fSavedFlagInfo, customFlags,
+                                         CurrentResponseUID(), fHighestModSeq);
+  }
+}
+
+
+/*
+ mailbox_data    ::=  "FLAGS" SPACE flag_list /
+                               "LIST" SPACE mailbox_list /
+                               "LSUB" SPACE mailbox_list /
+                               "XLIST" SPACE mailbox_list /
+                               "MAILBOX" SPACE text /
+                               "SEARCH" [SPACE 1#nz_number] /
+                               number SPACE "EXISTS" / number SPACE "RECENT"
+
+This production was changed to accomodate predictive parsing
+
+ mailbox_data    ::=  "FLAGS" SPACE flag_list /
+                               "LIST" SPACE mailbox_list /
+                               "LSUB" SPACE mailbox_list /
+                               "XLIST" SPACE mailbox_list /
+                               "MAILBOX" SPACE text /
+                               "SEARCH" [SPACE 1#nz_number]
+*/
+void nsImapServerResponseParser::mailbox_data()
+{
+  if (!PL_strcasecmp(fNextToken, "FLAGS"))
+  {
+    // this handles the case where we got the permanent flags response
+    // before the flags response, in which case, we want to ignore thes flags.
+    if (fGotPermanentFlags)
+      skip_to_CRLF();
+    else
+      parse_folder_flags();
+  }
+  else if (!PL_strcasecmp(fNextToken, "LIST") ||
+           !PL_strcasecmp(fNextToken, "XLIST"))
+  {
+    AdvanceToNextToken();
+    if (ContinueParse())
+      mailbox_list(false);
+  }
+  else if (!PL_strcasecmp(fNextToken, "LSUB"))
+  {
+    AdvanceToNextToken();
+    if (ContinueParse())
+      mailbox_list(true);
+  }
+  else if (!PL_strcasecmp(fNextToken, "MAILBOX"))
+    skip_to_CRLF();
+  else if (!PL_strcasecmp(fNextToken, "SEARCH"))
+  {
+    fSearchResults->AddSearchResultLine(fCurrentLine);
+    fServerConnection.NotifySearchHit(fCurrentLine);
+    skip_to_CRLF();
+  }
+}
+
+/*
+ mailbox_list    ::= "(" #("\Marked" / "\Noinferiors" /
+                              "\Noselect" / "\Unmarked" / flag_extension) ")"
+                              SPACE (<"> QUOTED_CHAR <"> / nil) SPACE mailbox
+*/
+
+void nsImapServerResponseParser::mailbox_list(bool discoveredFromLsub)
+{
+  nsImapMailboxSpec *boxSpec = new nsImapMailboxSpec;
+  NS_ADDREF(boxSpec);
+  bool needsToFreeBoxSpec = true;
+  if (!boxSpec)
+    HandleMemoryFailure();
+  else
+  {
+    boxSpec->mFolderSelected = false;
+    boxSpec->mBoxFlags = kNoFlags;
+    boxSpec->mAllocatedPathName.Truncate();
+    boxSpec->mHostName.Truncate();
+    boxSpec->mConnection = &fServerConnection;
+    boxSpec->mFlagState = nullptr;
+    boxSpec->mDiscoveredFromLsub = discoveredFromLsub;
+    boxSpec->mOnlineVerified = true;
+    boxSpec->mBoxFlags &= ~kNameSpace;
+
+    bool endOfFlags = false;
+    fNextToken++;// eat the first "("
+    do {
+      if (!PL_strncasecmp(fNextToken, "\\Marked", 7))
+        boxSpec->mBoxFlags |= kMarked;
+      else if (!PL_strncasecmp(fNextToken, "\\Unmarked", 9))
+        boxSpec->mBoxFlags |= kUnmarked;
+      else if (!PL_strncasecmp(fNextToken, "\\Noinferiors", 12))
+      {
+        boxSpec->mBoxFlags |= kNoinferiors;
+        // RFC 5258 \Noinferiors implies \HasNoChildren
+        if (fCapabilityFlag & kHasListExtendedCapability)
+          boxSpec->mBoxFlags |= kHasNoChildren;
+      }
+      else if (!PL_strncasecmp(fNextToken, "\\Noselect", 9))
+        boxSpec->mBoxFlags |= kNoselect;
+      else if (!PL_strncasecmp(fNextToken, "\\Drafts", 7))
+        boxSpec->mBoxFlags |= kImapDrafts;
+      else if (!PL_strncasecmp(fNextToken, "\\Trash", 6))
+        boxSpec->mBoxFlags |= kImapXListTrash;
+      else if (!PL_strncasecmp(fNextToken, "\\Sent", 5))
+        boxSpec->mBoxFlags |= kImapSent;
+      else if (!PL_strncasecmp(fNextToken, "\\Spam", 5) ||
+               !PL_strncasecmp(fNextToken, "\\Junk", 5))
+        boxSpec->mBoxFlags |= kImapSpam;
+      else if (!PL_strncasecmp(fNextToken, "\\Archive", 8))
+        boxSpec->mBoxFlags |= kImapArchive;
+      else if (!PL_strncasecmp(fNextToken, "\\All", 4) ||
+               !PL_strncasecmp(fNextToken, "\\AllMail", 8))
+        boxSpec->mBoxFlags |= kImapAllMail;
+      else if (!PL_strncasecmp(fNextToken, "\\Inbox", 6))
+        boxSpec->mBoxFlags |= kImapInbox;
+      else if (!PL_strncasecmp(fNextToken, "\\NonExistent", 11))
+      {
+        boxSpec->mBoxFlags |= kNonExistent;
+        // RFC 5258 \NonExistent implies \Noselect
+        boxSpec->mBoxFlags |= kNoselect;
+      }
+      else if (!PL_strncasecmp(fNextToken, "\\Subscribed", 10))
+        boxSpec->mBoxFlags |= kSubscribed;
+      else if (!PL_strncasecmp(fNextToken, "\\Remote", 6))
+        boxSpec->mBoxFlags |= kRemote;
+      else if (!PL_strncasecmp(fNextToken, "\\HasChildren", 11))
+        boxSpec->mBoxFlags |= kHasChildren;
+      else if (!PL_strncasecmp(fNextToken, "\\HasNoChildren", 13))
+        boxSpec->mBoxFlags |= kHasNoChildren;
+      // we ignore flag other extensions
+
+      endOfFlags = *(fNextToken + strlen(fNextToken) - 1) == ')';
+      AdvanceToNextToken();
+    } while (!endOfFlags && ContinueParse());
+
+    if (ContinueParse())
+    {
+      if (*fNextToken == '"')
+      {
+        fNextToken++;
+        if (*fNextToken == '\\') // handle escaped char
+          boxSpec->mHierarchySeparator = *(fNextToken + 1);
+        else
+          boxSpec->mHierarchySeparator = *fNextToken;
+      }
+      else	// likely NIL.  Discovered late in 4.02 that we do not handle literals here (e.g. {10} <10 chars>), although this is almost impossibly unlikely
+        boxSpec->mHierarchySeparator = kOnlineHierarchySeparatorNil;
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        // nsImapProtocol::DiscoverMailboxSpec() eventually frees the
+        // boxSpec
+        needsToFreeBoxSpec = false;
+        mailbox(boxSpec);
+      }
+    }
+  }
+  if (needsToFreeBoxSpec)
+    NS_RELEASE(boxSpec);
+}
+
+/* mailbox         ::= "INBOX" / astring
+*/
+void nsImapServerResponseParser::mailbox(nsImapMailboxSpec *boxSpec)
+{
+  char *boxname = nullptr;
+  const char *serverKey = fServerConnection.GetImapServerKey();
+  bool xlistInbox = boxSpec->mBoxFlags & kImapInbox;
+
+  if (!PL_strcasecmp(fNextToken, "INBOX") || xlistInbox)
+  {
+    boxname = PL_strdup("INBOX");
+    if (xlistInbox)
+      PR_Free(CreateAstring());
+    AdvanceToNextToken();
+  }
+  else
+  {
+    boxname = CreateAstring();
+    AdvanceToNextToken();
+  }
+
+  if (boxname && fHostSessionList)
+  {
+    // should the namespace check go before or after the Utf7 conversion?
+    fHostSessionList->SetNamespaceHierarchyDelimiterFromMailboxForHost(
+      serverKey, boxname, boxSpec->mHierarchySeparator);
+
+
+    nsIMAPNamespace *ns = nullptr;
+    fHostSessionList->GetNamespaceForMailboxForHost(serverKey, boxname, ns);
+    if (ns)
+    {
+      switch (ns->GetType())
+      {
+      case kPersonalNamespace:
+        boxSpec->mBoxFlags |= kPersonalMailbox;
+        break;
+      case kPublicNamespace:
+        boxSpec->mBoxFlags |= kPublicMailbox;
+        break;
+      case kOtherUsersNamespace:
+        boxSpec->mBoxFlags |= kOtherUsersMailbox;
+        break;
+      default:	// (kUnknownNamespace)
+        break;
+      }
+      boxSpec->mNamespaceForFolder = ns;
+    }
+
+    //    	char *convertedName =
+    //            fServerConnection.CreateUtf7ConvertedString(boxname, false);
+    //		char16_t *unicharName;
+    //        unicharName = fServerConnection.CreatePRUnicharStringFromUTF7(boxname);
+    //    	PL_strfree(boxname);
+    //    	boxname = convertedName;
+  }
+
+  if (!boxname)
+  {
+    if (!fServerConnection.DeathSignalReceived())
+      HandleMemoryFailure();
+  }
+  else if (boxSpec->mConnection && boxSpec->mConnection->GetCurrentUrl())
+  {
+    boxSpec->mConnection->GetCurrentUrl()->AllocateCanonicalPath(boxname, boxSpec->mHierarchySeparator,
+                                                                 getter_Copies(boxSpec->mAllocatedPathName));
+    nsIURI *aURL = nullptr;
+    boxSpec->mConnection->GetCurrentUrl()->QueryInterface(NS_GET_IID(nsIURI), (void **) &aURL);
+    if (aURL)
+      aURL->GetHost(boxSpec->mHostName);
+
+    NS_IF_RELEASE(aURL);
+    if (boxname)
+      PL_strfree( boxname);
+    // storage for the boxSpec is now owned by server connection
+    fServerConnection.DiscoverMailboxSpec(boxSpec);
+
+    // if this was cancelled by the user,then we sure don't want to
+    // send more mailboxes their way
+    if (NS_FAILED(fServerConnection.GetConnectionStatus()))
+      SetConnected(false);
+  }
+}
+
+
+/*
+ message_data    ::= nz_number SPACE ("EXPUNGE" /
+                              ("FETCH" SPACE msg_fetch) / msg_obsolete)
+
+was changed to
+
+numeric_mailbox_data ::=  number SPACE "EXISTS" / number SPACE "RECENT"
+ / nz_number SPACE ("EXPUNGE" /
+                              ("FETCH" SPACE msg_fetch) / msg_obsolete)
+
+*/
+void nsImapServerResponseParser::numeric_mailbox_data()
+{
+  int32_t tokenNumber = atoi(fNextToken);
+  AdvanceToNextToken();
+
+  if (ContinueParse())
+  {
+    if (!PL_strcasecmp(fNextToken, "FETCH"))
+    {
+      fFetchResponseIndex = tokenNumber;
+      AdvanceToNextToken();
+      if (ContinueParse())
+        msg_fetch();
+    }
+    else if (!PL_strcasecmp(fNextToken, "EXISTS"))
+    {
+      fNumberOfExistingMessages = tokenNumber;
+      AdvanceToNextToken();
+    }
+    else if (!PL_strcasecmp(fNextToken, "RECENT"))
+    {
+      fNumberOfRecentMessages = tokenNumber;
+      AdvanceToNextToken();
+    }
+    else if (!PL_strcasecmp(fNextToken, "EXPUNGE"))
+    {
+      if (!fServerConnection.GetIgnoreExpunges())
+        fFlagState->ExpungeByIndex((uint32_t) tokenNumber);
+      skip_to_CRLF();
+    }
+    else
+      msg_obsolete();
+  }
+}
+
+/*
+msg_fetch       ::= "(" 1#("BODY" SPACE body /
+"BODYSTRUCTURE" SPACE body /
+"BODY[" section "]" SPACE nstring /
+"ENVELOPE" SPACE envelope /
+"FLAGS" SPACE "(" #(flag / "\Recent") ")" /
+"INTERNALDATE" SPACE date_time /
+"MODSEQ" SPACE "(" nz_number ")" /
+"RFC822" [".HEADER" / ".TEXT"] SPACE nstring /
+"RFC822.SIZE" SPACE number /
+"UID" SPACE uniqueid) ")"
+
+*/
+
+void nsImapServerResponseParser::msg_fetch()
+{
+  bool bNeedEndMessageDownload = false;
+
+  // we have not seen a uid response or flags for this fetch, yet
+  fCurrentResponseUID = 0;
+  fCurrentLineContainedFlagInfo = false;
+  fSizeOfMostRecentMessage = 0;
+  // show any incremental progress, for instance, for header downloading
+  fServerConnection.ShowProgress();
+
+  fNextToken++; // eat the '(' character
+
+  // some of these productions are ignored for now
+  while (ContinueParse() && (*fNextToken != ')') )
+  {
+    if (!PL_strcasecmp(fNextToken, "FLAGS"))
+    {
+      if (fCurrentResponseUID == 0)
+        fFlagState->GetUidOfMessage(fFetchResponseIndex - 1, &fCurrentResponseUID);
+
+      AdvanceToNextToken();
+      if (ContinueParse())
+        flags();
+
+      if (ContinueParse())
+      { // eat the closing ')'
+        fNextToken++;
+        // there may be another ')' to close out
+        // msg_fetch.  If there is then don't advance
+        if (*fNextToken != ')')
+          AdvanceToNextToken();
+      }
+    }
+    else if (!PL_strcasecmp(fNextToken, "UID"))
+    {
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        fCurrentResponseUID = strtoul(fNextToken, nullptr, 10);
+        if (fCurrentResponseUID > fHighestRecordedUID)
+          fHighestRecordedUID = fCurrentResponseUID;
+        // size came before UID
+        if (fSizeOfMostRecentMessage)
+          fReceivedHeaderOrSizeForUID = CurrentResponseUID();
+        // if this token ends in ')', then it is the last token
+        // else we advance
+        char lastTokenChar = *(fNextToken + strlen(fNextToken) - 1);
+        if (lastTokenChar == ')')
+          fNextToken += strlen(fNextToken) - 1;
+        else if (lastTokenChar < '0' || lastTokenChar > '9')
+        {
+          // GIANT HACK
+          // this is a corrupt uid - see if it's pre 5.08 Zimbra omitting
+          // a space between the UID and MODSEQ
+          if (strlen(fNextToken) > 6 &&
+              !strcmp("MODSEQ", fNextToken + strlen(fNextToken) - 6))
+            fNextToken += strlen(fNextToken) - 6;
+        }
+        else
+          AdvanceToNextToken();
+      }
+    }
+    else if (!PL_strcasecmp(fNextToken, "MODSEQ"))
+    {
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        fNextToken++; // eat '('
+        uint64_t modSeq =  ParseUint64Str(fNextToken);
+        if (modSeq > fHighestModSeq)
+          fHighestModSeq = modSeq;
+
+        if (PL_strcasestr(fNextToken, ")"))
+        {
+          // eat token chars until we get the ')'
+          fNextToken = strchr(fNextToken, ')');
+          if (fNextToken)
+          {
+            fNextToken++;
+            if (*fNextToken != ')')
+              AdvanceToNextToken();
+          }
+          else
+            SetSyntaxError(true);
+        }
+        else
+        {
+          SetSyntaxError(true);
+        }
+      }
+    }
+    else if (!PL_strcasecmp(fNextToken, "RFC822") ||
+      !PL_strcasecmp(fNextToken, "RFC822.HEADER") ||
+      !PL_strncasecmp(fNextToken, "BODY[HEADER",11) ||
+      !PL_strncasecmp(fNextToken, "BODY[]", 6) ||
+      !PL_strcasecmp(fNextToken, "RFC822.TEXT") ||
+      (!PL_strncasecmp(fNextToken, "BODY[", 5) &&
+				  PL_strstr(fNextToken, "HEADER"))
+                                  )
+    {
+      if (fCurrentResponseUID == 0)
+        fFlagState->GetUidOfMessage(fFetchResponseIndex - 1, &fCurrentResponseUID);
+
+      if (!PL_strcasecmp(fNextToken, "RFC822.HEADER") ||
+        !PL_strcasecmp(fNextToken, "BODY[HEADER]"))
+      {
+        // all of this message's headers
+        AdvanceToNextToken();
+        fDownloadingHeaders = true;
+        BeginMessageDownload(MESSAGE_RFC822); // initialize header parser
+        bNeedEndMessageDownload = false;
+        if (ContinueParse())
+          msg_fetch_headers(nullptr);
+      }
+      else if (!PL_strncasecmp(fNextToken, "BODY[HEADER.FIELDS",19))
+      {
+        fDownloadingHeaders = true;
+        BeginMessageDownload(MESSAGE_RFC822); // initialize header parser
+        // specific message header fields
+        while (ContinueParse() && fNextToken[strlen(fNextToken)-1] != ']')
+          AdvanceToNextToken();
+        if (ContinueParse())
+        {
+          bNeedEndMessageDownload = false;
+          AdvanceToNextToken();
+          if (ContinueParse())
+            msg_fetch_headers(nullptr);
+        }
+      }
+      else
+      {
+        char *whereHeader = PL_strstr(fNextToken, "HEADER");
+        if (whereHeader)
+        {
+          const char *startPartNum = fNextToken + 5;
+          if (whereHeader > startPartNum)
+          {
+            int32_t partLength = whereHeader - startPartNum - 1; //-1 for the dot!
+            char *partNum = (char *)PR_CALLOC((partLength + 1) * sizeof (char));
+            if (partNum)
+            {
+              PL_strncpy(partNum, startPartNum, partLength);
+              if (ContinueParse())
+              {
+                if (PL_strstr(fNextToken, "FIELDS"))
+                {
+                  while (ContinueParse() && fNextToken[strlen(fNextToken)-1] != ']')
+                    AdvanceToNextToken();
+                }
+                if (ContinueParse())
+                {
+                  AdvanceToNextToken();
+                  if (ContinueParse())
+                    msg_fetch_headers(partNum);
+                }
+              }
+              PR_Free(partNum);
+            }
+          }
+          else
+            SetSyntaxError(true);
+        }
+        else
+        {
+          fDownloadingHeaders = false;
+
+          bool chunk = false;
+          int32_t origin = 0;
+          if (!PL_strncasecmp(fNextToken, "BODY[]<", 7))
+          {
+            char *tokenCopy = 0;
+            tokenCopy = PL_strdup(fNextToken);
+            if (tokenCopy)
+            {
+              char *originString = tokenCopy + 7;	// where the byte number starts
+              char *closeBracket = PL_strchr(tokenCopy,'>');
+              if (closeBracket && originString && *originString)
+              {
+                *closeBracket = 0;
+                origin = atoi(originString);
+                chunk = true;
+              }
+              PR_Free(tokenCopy);
+            }
+          }
+
+          AdvanceToNextToken();
+          if (ContinueParse())
+          {
+            msg_fetch_content(chunk, origin, MESSAGE_RFC822);
+          }
+        }
+      }
+      }
+      else if (!PL_strcasecmp(fNextToken, "RFC822.SIZE") || !PL_strcasecmp(fNextToken, "XAOL.SIZE"))
+      {
+        AdvanceToNextToken();
+        if (ContinueParse())
+        {
+          bool sendEndMsgDownload = (GetDownloadingHeaders()
+                                        && fReceivedHeaderOrSizeForUID == CurrentResponseUID());
+          fSizeOfMostRecentMessage = strtoul(fNextToken, nullptr, 10);
+          fReceivedHeaderOrSizeForUID = CurrentResponseUID();
+          if (sendEndMsgDownload)
+          {
+            fServerConnection.NormalMessageEndDownload();
+            fReceivedHeaderOrSizeForUID = nsMsgKey_None;
+          }
+
+          if (fSizeOfMostRecentMessage == 0 && CurrentResponseUID())
+          {
+            // on no, bogus Netscape 2.0 mail server bug
+            char uidString[100];
+            sprintf(uidString, "%ld", (long)CurrentResponseUID());
+
+            if (!fZeroLengthMessageUidString.IsEmpty())
+              fZeroLengthMessageUidString += ",";
+
+            fZeroLengthMessageUidString += uidString;
+          }
+
+          // if this token ends in ')', then it is the last token
+          // else we advance
+          if ( *(fNextToken + strlen(fNextToken) - 1) == ')')
+            fNextToken += strlen(fNextToken) - 1;
+          else
+            AdvanceToNextToken();
+        }
+      }
+      else if (!PL_strcasecmp(fNextToken, "XSENDER"))
+      {
+        PR_FREEIF(fXSenderInfo);
+        AdvanceToNextToken();
+        if (! fNextToken)
+          SetSyntaxError(true);
+        else
+        {
+          fXSenderInfo = CreateAstring();
+          AdvanceToNextToken();
+        }
+      }
+      else if (!PL_strcasecmp(fNextToken, "X-GM-MSGID"))
+      {
+        AdvanceToNextToken();
+        if (!fNextToken)
+          SetSyntaxError(true);
+        else
+        {
+          fMsgID = CreateAtom();
+          AdvanceToNextToken();
+          nsCString msgIDValue;
+          msgIDValue.Assign(fMsgID);
+          if (fCurrentResponseUID == 0)
+            fFlagState->GetUidOfMessage(fFetchResponseIndex - 1, &fCurrentResponseUID);
+          fFlagState->SetCustomAttribute(fCurrentResponseUID,
+                                         NS_LITERAL_CSTRING("X-GM-MSGID"), msgIDValue);
+          PR_FREEIF(fMsgID);
+        }
+      }
+      else if (!PL_strcasecmp(fNextToken, "X-GM-THRID"))
+      {
+        AdvanceToNextToken();
+        if (!fNextToken)
+          SetSyntaxError(true);
+        else
+        {
+          fThreadID = CreateAtom();
+          AdvanceToNextToken();
+          nsCString threadIDValue;
+          threadIDValue.Assign(fThreadID);
+          if (fCurrentResponseUID == 0)
+            fFlagState->GetUidOfMessage(fFetchResponseIndex - 1, &fCurrentResponseUID);
+          fFlagState->SetCustomAttribute(fCurrentResponseUID,
+                                         NS_LITERAL_CSTRING("X-GM-THRID"), threadIDValue);
+          PR_FREEIF(fThreadID);
+        }
+      }
+      else if (!PL_strcasecmp(fNextToken, "X-GM-LABELS"))
+      {
+        AdvanceToNextToken();
+        if (!fNextToken)
+          SetSyntaxError(true);
+        else
+        {
+          fLabels = CreateParenGroup();
+          nsCString labelsValue;
+          labelsValue.Assign(fLabels);
+          labelsValue.Cut(0, 1);
+          labelsValue.Cut(labelsValue.Length()-1, 1);
+          if (fCurrentResponseUID == 0)
+            fFlagState->GetUidOfMessage(fFetchResponseIndex - 1, &fCurrentResponseUID);
+          fFlagState->SetCustomAttribute(fCurrentResponseUID,
+                                         NS_LITERAL_CSTRING("X-GM-LABELS"), labelsValue);
+          PR_FREEIF(fLabels);
+        }
+      }
+
+      // I only fetch RFC822 so I should never see these BODY responses
+      else if (!PL_strcasecmp(fNextToken, "BODY"))
+        skip_to_CRLF(); // I never ask for this
+      else if (!PL_strcasecmp(fNextToken, "BODYSTRUCTURE"))
+      {
+        if (fCurrentResponseUID == 0)
+          fFlagState->GetUidOfMessage(fFetchResponseIndex - 1, &fCurrentResponseUID);
+        bodystructure_data();
+      }
+      else if (!PL_strncasecmp(fNextToken, "BODY[TEXT", 9))
+      {
+        mime_data();
+      }
+      else if (!PL_strncasecmp(fNextToken, "BODY[", 5) && PL_strncasecmp(fNextToken, "BODY[]", 6))
+      {
+        fDownloadingHeaders = false;
+        // A specific MIME part, or MIME part header
+        mime_data();
+      }
+      else if (!PL_strcasecmp(fNextToken, "ENVELOPE"))
+      {
+        fDownloadingHeaders = true;
+        bNeedEndMessageDownload = true;
+        BeginMessageDownload(MESSAGE_RFC822);
+        envelope_data();
+      }
+      else if (!PL_strcasecmp(fNextToken, "INTERNALDATE"))
+      {
+        fDownloadingHeaders = true; // we only request internal date while downloading headers
+        if (!bNeedEndMessageDownload)
+          BeginMessageDownload(MESSAGE_RFC822);
+        bNeedEndMessageDownload = true;
+        internal_date();
+      }
+      else if (!PL_strcasecmp(fNextToken, "XAOL-ENVELOPE"))
+      {
+        fDownloadingHeaders = true;
+        if (!bNeedEndMessageDownload)
+          BeginMessageDownload(MESSAGE_RFC822);
+        bNeedEndMessageDownload = true;
+        xaolenvelope_data();
+      }
+      else
+      {
+        nsImapAction imapAction;
+        if (!fServerConnection.GetCurrentUrl())
+          return;
+        fServerConnection.GetCurrentUrl()->GetImapAction(&imapAction);
+        nsAutoCString userDefinedFetchAttribute;
+        fServerConnection.GetCurrentUrl()->GetCustomAttributeToFetch(userDefinedFetchAttribute);
+        if ((imapAction == nsIImapUrl::nsImapUserDefinedFetchAttribute && !strcmp(userDefinedFetchAttribute.get(), fNextToken)) ||
+            imapAction == nsIImapUrl::nsImapUserDefinedMsgCommand)
+        {
+          AdvanceToNextToken();
+          char *fetchResult;
+          if (fNextToken[0] == '(')
+            // look through the tokens until we find the closing ')'
+            // we can have a result like the following:
+            // ((A B) (C D) (E F))
+            fetchResult = CreateParenGroup();
+          else {
+            fetchResult = CreateAstring();
+            AdvanceToNextToken();
+          }
+          if (imapAction == nsIImapUrl::nsImapUserDefinedFetchAttribute)
+            fServerConnection.GetCurrentUrl()->SetCustomAttributeResult(nsDependentCString(fetchResult));
+          if (imapAction == nsIImapUrl::nsImapUserDefinedMsgCommand)
+            fServerConnection.GetCurrentUrl()->SetCustomCommandResult(nsDependentCString(fetchResult));
+          PR_Free(fetchResult);
+        }
+        else
+          SetSyntaxError(true);
+      }
+
+        }
+
+        if (ContinueParse())
+        {
+          if (CurrentResponseUID() && CurrentResponseUID() != nsMsgKey_None
+            && fCurrentLineContainedFlagInfo && fFlagState)
+          {
+            fFlagState->AddUidFlagPair(CurrentResponseUID(), fSavedFlagInfo, fFetchResponseIndex - 1);
+            for (uint32_t i = 0; i < fCustomFlags.Length(); i++)
+              fFlagState->AddUidCustomFlagPair(CurrentResponseUID(), fCustomFlags[i].get());
+            fCustomFlags.Clear();
+          }
+
+          if (fFetchingAllFlags)
+            fCurrentLineContainedFlagInfo = false;  // do not fire if in PostProcessEndOfLine
+
+          AdvanceToNextToken(); // eat the ')' ending token
+          // should be at end of line
+          if (bNeedEndMessageDownload)
+          {
+            if (ContinueParse())
+            {
+              // complete the message download
+              fServerConnection.NormalMessageEndDownload();
+            }
+            else
+              fServerConnection.AbortMessageDownLoad();
+          }
+
+        }
+}
+
+typedef enum _envelopeItemType
+{
+	envelopeString,
+	envelopeAddress
+} envelopeItemType;
+
+typedef struct
+{
+	const char * name;
+	envelopeItemType type;
+} envelopeItem;
+
+// RFC3501:  envelope  = "(" env-date SP env-subject SP env-from SP
+//                       env-sender SP env-reply-to SP env-to SP env-cc SP
+//                       env-bcc SP env-in-reply-to SP env-message-id ")"
+//           env-date    = nstring
+//           env-subject = nstring
+//           env-from    = "(" 1*address ")" / nil
+//           env-sender  = "(" 1*address ")" / nil
+//           env-reply-to= "(" 1*address ")" / nil
+//           env-to      = "(" 1*address ")" / nil
+//           env-cc      = "(" 1*address ")" / nil
+//           env-bcc     = "(" 1*address ")" / nil
+//           env-in-reply-to = nstring
+//           env-message-id  = nstring
+
+static const envelopeItem EnvelopeTable[] =
+{
+  {"Date", envelopeString},
+  {"Subject", envelopeString},
+  {"From", envelopeAddress},
+  {"Sender", envelopeAddress},
+  {"Reply-to", envelopeAddress},
+  {"To", envelopeAddress},
+  {"Cc", envelopeAddress},
+  {"Bcc", envelopeAddress},
+  {"In-reply-to", envelopeString},
+  {"Message-id", envelopeString}
+};
+
+void nsImapServerResponseParser::envelope_data()
+{
+  AdvanceToNextToken();
+  fNextToken++; // eat '('
+  for (int tableIndex = 0; tableIndex < (int)(sizeof(EnvelopeTable) / sizeof(EnvelopeTable[0])); tableIndex++)
+  {
+    if (!ContinueParse())
+      break;
+    else if (*fNextToken == ')')
+    {
+      SetSyntaxError(true); // envelope too short
+      break;
+    }
+    else
+    {
+      nsAutoCString headerLine(EnvelopeTable[tableIndex].name);
+      headerLine += ": ";
+      bool headerNonNil = true;
+      if (EnvelopeTable[tableIndex].type == envelopeString)
+      {
+        nsAutoCString strValue;
+        strValue.Adopt(CreateNilString());
+        if (!strValue.IsEmpty())
+          headerLine.Append(strValue);
+        else
+          headerNonNil = false;
+      }
+      else
+      {
+        nsAutoCString address;
+        parse_address(address);
+        headerLine += address;
+        if (address.IsEmpty())
+          headerNonNil = false;
+      }
+      if (headerNonNil)
+        fServerConnection.HandleMessageDownLoadLine(headerLine.get(), false);
+    }
+    if (ContinueParse())
+      AdvanceToNextToken();
+  }
+  // Now we should be at the end of the envelope and have *fToken == ')'.
+  // Skip this last parenthesis.
+  AdvanceToNextToken();
+}
+
+void nsImapServerResponseParser::xaolenvelope_data()
+{
+  // eat the opening '('
+  fNextToken++;
+
+  if (ContinueParse() && (*fNextToken != ')'))
+  {
+    AdvanceToNextToken();
+    fNextToken++; // eat '('
+    nsAutoCString subject;
+    subject.Adopt(CreateNilString());
+    nsAutoCString subjectLine("Subject: ");
+    subjectLine += subject;
+    fServerConnection.HandleMessageDownLoadLine(subjectLine.get(), false);
+    fNextToken++; // eat the next '('
+    if (ContinueParse())
+    {
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        nsAutoCString fromLine;
+        if (!strcmp(GetSelectedMailboxName(), "Sent Items"))
+        {
+          // xaol envelope switches the From with the To, so we switch them back and
+          // create a fake from line From: user@aol.com
+          fromLine.Append("To: ");
+          nsAutoCString fakeFromLine(NS_LITERAL_CSTRING("From: "));
+          fakeFromLine.Append(fServerConnection.GetImapUserName());
+          fakeFromLine.Append(NS_LITERAL_CSTRING("@aol.com"));
+          fServerConnection.HandleMessageDownLoadLine(fakeFromLine.get(), false);
+        }
+        else
+        {
+          fromLine.Append("From: ");
+        }
+        parse_address(fromLine);
+        fServerConnection.HandleMessageDownLoadLine(fromLine.get(), false);
+        if (ContinueParse())
+        {
+          AdvanceToNextToken();	// ge attachment size
+          int32_t attachmentSize = atoi(fNextToken);
+          if (attachmentSize != 0)
+          {
+            nsAutoCString attachmentLine("X-attachment-size: ");
+            attachmentLine.AppendInt(attachmentSize);
+            fServerConnection.HandleMessageDownLoadLine(attachmentLine.get(), false);
+          }
+        }
+        if (ContinueParse())
+        {
+          AdvanceToNextToken();	// skip image size
+          int32_t imageSize = atoi(fNextToken);
+          if (imageSize != 0)
+          {
+            nsAutoCString imageLine("X-image-size: ");
+            imageLine.AppendInt(imageSize);
+            fServerConnection.HandleMessageDownLoadLine(imageLine.get(), false);
+          }
+        }
+        if (ContinueParse())
+          AdvanceToNextToken();	// skip )
+      }
+    }
+  }
+}
+
+void nsImapServerResponseParser::parse_address(nsAutoCString &addressLine)
+{
+  if (!strcmp(fNextToken, "NIL"))
+    return;
+  bool firstAddress = true;
+  // should really look at chars here
+  NS_ASSERTION(*fNextToken == '(', "address should start with '('");
+  fNextToken++; // eat the next '('
+  while (ContinueParse() && *fNextToken == '(')
+  {
+    NS_ASSERTION(*fNextToken == '(', "address should start with '('");
+    fNextToken++; // eat the next '('
+
+    if (!firstAddress)
+      addressLine += ", ";
+
+    firstAddress = false;
+    char *personalName = CreateNilString();
+    AdvanceToNextToken();
+    char *atDomainList = CreateNilString();
+    if (ContinueParse())
+    {
+      AdvanceToNextToken();
+      char *mailboxName = CreateNilString();
+      if (ContinueParse())
+      {
+        AdvanceToNextToken();
+        char *hostName = CreateNilString();
+        AdvanceToNextToken();
+        addressLine += mailboxName;
+        if (hostName)
+        {
+          addressLine += '@';
+          addressLine += hostName;
+          NS_Free(hostName);
+        }
+        if (personalName)
+        {
+          addressLine += " (";
+          addressLine += personalName;
+          addressLine += ')';
+        }
+      }
+    }
+    PR_Free(personalName);
+    PR_Free(atDomainList);
+
+    if (*fNextToken == ')')
+      fNextToken++;
+    // if the next token isn't a ')' for the address term,
+    // then we must have another address pair left....so get the next
+    // token and continue parsing in this loop...
+    if ( *fNextToken == '\0' )
+      AdvanceToNextToken();
+
+  }
+  if (*fNextToken == ')')
+    fNextToken++;
+  //	AdvanceToNextToken();	// skip "))"
+}
+
+void nsImapServerResponseParser::internal_date()
+{
+  AdvanceToNextToken();
+  if (ContinueParse())
+  {
+    nsAutoCString dateLine("Date: ");
+    char *strValue = CreateNilString();
+    if (strValue)
+    {
+      dateLine += strValue;
+      NS_Free(strValue);
+    }
+    fServerConnection.HandleMessageDownLoadLine(dateLine.get(), false);
+  }
+  // advance the parser.
+  AdvanceToNextToken();
+}
+
+void nsImapServerResponseParser::flags()
+{
+  imapMessageFlagsType messageFlags = kNoImapMsgFlag;
+  fCustomFlags.Clear();
+
+  // clear the custom flags for this message
+  // otherwise the old custom flags will stay around
+  // see bug #191042
+  if (fFlagState && CurrentResponseUID() != nsMsgKey_None)
+    fFlagState->ClearCustomFlags(CurrentResponseUID());
+
+  // eat the opening '('
+  fNextToken++;
+  while (ContinueParse() && (*fNextToken != ')'))
+  {
+    bool knownFlag = false;
+    if (*fNextToken == '\\')
+    {
+      switch (NS_ToUpper(fNextToken[1])) {
+      case 'S':
+        if (!PL_strncasecmp(fNextToken, "\\Seen",5))
+        {
+          messageFlags |= kImapMsgSeenFlag;
+          knownFlag = true;
+        }
+        break;
+      case 'A':
+        if (!PL_strncasecmp(fNextToken, "\\Answered",9))
+        {
+          messageFlags |= kImapMsgAnsweredFlag;
+          knownFlag = true;
+        }
+        break;
+      case 'F':
+        if (!PL_strncasecmp(fNextToken, "\\Flagged",8))
+        {
+          messageFlags |= kImapMsgFlaggedFlag;
+          knownFlag = true;
+        }
+        break;
+      case 'D':
+        if (!PL_strncasecmp(fNextToken, "\\Deleted",8))
+        {
+          messageFlags |= kImapMsgDeletedFlag;
+          knownFlag = true;
+        }
+        else if (!PL_strncasecmp(fNextToken, "\\Draft",6))
+        {
+          messageFlags |= kImapMsgDraftFlag;
+          knownFlag = true;
+        }
+        break;
+      case 'R':
+        if (!PL_strncasecmp(fNextToken, "\\Recent",7))
+        {
+          messageFlags |= kImapMsgRecentFlag;
+          knownFlag = true;
+        }
+        break;
+      default:
+        break;
+      }
+    }
+    else if (*fNextToken == '$')
+    {
+      switch (NS_ToUpper(fNextToken[1])) {
+      case 'M':
+        if ((fSupportsUserDefinedFlags & (kImapMsgSupportUserFlag |
+          kImapMsgSupportMDNSentFlag))
+          && !PL_strncasecmp(fNextToken, "$MDNSent",8))
+        {
+          messageFlags |= kImapMsgMDNSentFlag;
+          knownFlag = true;
+        }
+        break;
+      case 'F':
+        if ((fSupportsUserDefinedFlags & (kImapMsgSupportUserFlag |
+          kImapMsgSupportForwardedFlag))
+          && !PL_strncasecmp(fNextToken, "$Forwarded",10))
+        {
+          messageFlags |= kImapMsgForwardedFlag;
+          knownFlag = true;
+        }
+        break;
+      default:
+        break;
+      }
+    }
+    if (!knownFlag && fFlagState)
+    {
+      nsAutoCString flag(fNextToken);
+      int32_t parenIndex = flag.FindChar(')');
+      if (parenIndex > 0)
+        flag.SetLength(parenIndex);
+      messageFlags |= kImapMsgCustomKeywordFlag;
+      if (CurrentResponseUID() != nsMsgKey_None && CurrentResponseUID() != 0)
+        fFlagState->AddUidCustomFlagPair(CurrentResponseUID(), flag.get());
+      else
+        fCustomFlags.AppendElement(flag);
+    }
+    if (PL_strcasestr(fNextToken, ")"))
+    {
+      // eat token chars until we get the ')'
+      while (*fNextToken != ')')
+        fNextToken++;
+    }
+    else
+      AdvanceToNextToken();
+  }
+
+  if (ContinueParse())
+    while(*fNextToken != ')')
+      fNextToken++;
+
+    fCurrentLineContainedFlagInfo = true;	// handled in PostProcessEndOfLine
+    fSavedFlagInfo = messageFlags;
+}
+
+// RFC3501:  resp-cond-state = ("OK" / "NO" / "BAD") SP resp-text
+//                             ; Status condition
+void nsImapServerResponseParser::resp_cond_state(bool isTagged)
+{
+  // According to RFC3501, Sec. 7.1, the untagged NO response "indicates a
+  // warning; the command can still complete successfully."
+  // However, the untagged BAD response "indicates a protocol-level error for
+  // which the associated command can not be determined; it can also indicate an
+  // internal server failure."
+  // Thus, we flag an error for a tagged NO response and for any BAD response.
+  if ((isTagged && !PL_strcasecmp(fNextToken, "NO")) ||
+      !PL_strcasecmp(fNextToken, "BAD"))
+    fCurrentCommandFailed = true;
+
+  AdvanceToNextToken();
+  if (ContinueParse())
+    resp_text();
+}
+
+/*
+resp_text       ::= ["[" resp_text_code "]" SPACE] (text_mime2 / text)
+
+  was changed to in order to enable a one symbol look ahead predictive
+  parser.
+
+    resp_text       ::= ["[" resp_text_code  SPACE] (text_mime2 / text)
+*/
+void nsImapServerResponseParser::resp_text()
+{
+  if (ContinueParse() && (*fNextToken == '['))
+    resp_text_code();
+
+  if (ContinueParse())
+  {
+    if (!PL_strcmp(fNextToken, "=?"))
+      text_mime2();
+    else
+      text();
+  }
+}
+/*
+ text_mime2       ::= "=?" <charset> "?" <encoding> "?"
+                               <encoded-text> "?="
+                               ;; Syntax defined in [MIME-2]
+*/
+void nsImapServerResponseParser::text_mime2()
+{
+  skip_to_CRLF();
+}
+
+/*
+ text            ::= 1*TEXT_CHAR
+
+*/
+void nsImapServerResponseParser::text()
+{
+  skip_to_CRLF();
+}
+
+void nsImapServerResponseParser::parse_folder_flags()
+{
+  uint16_t labelFlags = 0;
+
+  do
+  {
+    AdvanceToNextToken();
+    if (*fNextToken == '(')
+      fNextToken++;
+    if (!PL_strncasecmp(fNextToken, "$MDNSent", 8))
+      fSupportsUserDefinedFlags |= kImapMsgSupportMDNSentFlag;
+    else if (!PL_strncasecmp(fNextToken, "$Forwarded", 10))
+      fSupportsUserDefinedFlags |= kImapMsgSupportForwardedFlag;
+    else if (!PL_strncasecmp(fNextToken, "\\Seen", 5))
+      fSettablePermanentFlags |= kImapMsgSeenFlag;
+    else if (!PL_strncasecmp(fNextToken, "\\Answered", 9))
+      fSettablePermanentFlags |= kImapMsgAnsweredFlag;
+    else if (!PL_strncasecmp(fNextToken, "\\Flagged", 8))
+      fSettablePermanentFlags |= kImapMsgFlaggedFlag;
+    else if (!PL_strncasecmp(fNextToken, "\\Deleted", 8))
+      fSettablePermanentFlags |= kImapMsgDeletedFlag;
+    else if (!PL_strncasecmp(fNextToken, "\\Draft", 6))
+      fSettablePermanentFlags |= kImapMsgDraftFlag;
+    else if (!PL_strncasecmp(fNextToken, "$Label1", 7))
+      labelFlags |= 1;
+    else if (!PL_strncasecmp(fNextToken, "$Label2", 7))
+      labelFlags |= 2;
+    else if (!PL_strncasecmp(fNextToken, "$Label3", 7))
+      labelFlags |= 4;
+    else if (!PL_strncasecmp(fNextToken, "$Label4", 7))
+      labelFlags |= 8;
+    else if (!PL_strncasecmp(fNextToken, "$Label5", 7))
+      labelFlags |= 16;
+    else if (!PL_strncasecmp(fNextToken, "\\*", 2))
+    {
+      fSupportsUserDefinedFlags |= kImapMsgSupportUserFlag;
+      fSupportsUserDefinedFlags |= kImapMsgSupportForwardedFlag;
+      fSupportsUserDefinedFlags |= kImapMsgSupportMDNSentFlag;
+      fSupportsUserDefinedFlags |= kImapMsgLabelFlags;
+    }
+  } while (!fAtEndOfLine && ContinueParse());
+
+  if (labelFlags == 31)
+    fSupportsUserDefinedFlags |= kImapMsgLabelFlags;
+
+  if (fFlagState)
+    fFlagState->OrSupportedUserFlags(fSupportsUserDefinedFlags);
+}
+/*
+  resp_text_code  ::= ("ALERT" / "PARSE" /
+                              "PERMANENTFLAGS" SPACE "(" #(flag / "\*") ")" /
+                              "READ-ONLY" / "READ-WRITE" / "TRYCREATE" /
+                              "UIDVALIDITY" SPACE nz_number /
+                              "UNSEEN" SPACE nz_number /
+                              "HIGHESTMODSEQ" SPACE nz_number /
+                              "NOMODSEQ" /
+                              atom [SPACE 1*<any TEXT_CHAR except "]">] )
+                      "]"
+
+
+*/
+void nsImapServerResponseParser::resp_text_code()
+{
+  // this is a special case way of advancing the token
+  // strtok won't break up "[ALERT]" into separate tokens
+  if (strlen(fNextToken) > 1)
+    fNextToken++;
+  else
+    AdvanceToNextToken();
+
+  if (ContinueParse())
+  {
+    if (!PL_strcasecmp(fNextToken,"ALERT]"))
+    {
+      char *alertMsg = fCurrentTokenPlaceHolder;	// advance past ALERT]
+      if (alertMsg && *alertMsg && (!fLastAlert || PL_strcmp(fNextToken, fLastAlert)))
+      {
+        fServerConnection.AlertUserEvent(alertMsg);
+        PR_Free(fLastAlert);
+        fLastAlert = PL_strdup(alertMsg);
+      }
+      AdvanceToNextToken();
+    }
+    else if (!PL_strcasecmp(fNextToken,"PARSE]"))
+    {
+      // do nothing for now
+      AdvanceToNextToken();
+    }
+    else if (!PL_strcasecmp(fNextToken,"NETSCAPE]"))
+    {
+      skip_to_CRLF();
+    }
+    else if (!PL_strcasecmp(fNextToken,"PERMANENTFLAGS"))
+    {
+      uint32_t saveSettableFlags = fSettablePermanentFlags;
+      fSupportsUserDefinedFlags = 0;		// assume no unless told
+      fSettablePermanentFlags = 0;            // assume none, unless told otherwise.
+      parse_folder_flags();
+      // if the server tells us there are no permanent flags, we're
+      // just going to pretend that the FLAGS response flags, if any, are
+      // permanent in case the server is broken. This will allow us
+      // to store delete and seen flag changes - if they're not permanent,
+      // they're not permanent, but at least we'll try to set them.
+      if (!fSettablePermanentFlags)
+        fSettablePermanentFlags = saveSettableFlags;
+      fGotPermanentFlags = true;
+    }
+    else if (!PL_strcasecmp(fNextToken,"READ-ONLY]"))
+    {
+      fCurrentFolderReadOnly = true;
+      AdvanceToNextToken();
+    }
+    else if (!PL_strcasecmp(fNextToken,"READ-WRITE]"))
+    {
+      fCurrentFolderReadOnly = false;
+      AdvanceToNextToken();
+    }
+    else if (!PL_strcasecmp(fNextToken,"TRYCREATE]"))
+    {
+      // do nothing for now
+      AdvanceToNextToken();
+    }
+    else if (!PL_strcasecmp(fNextToken,"UIDVALIDITY"))
+    {
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        fFolderUIDValidity = strtoul(fNextToken, nullptr, 10);
+        fHighestRecordedUID = 0;
+        AdvanceToNextToken();
+      }
+    }
+    else if (!PL_strcasecmp(fNextToken,"UNSEEN"))
+    {
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        fNumberOfUnseenMessages = strtoul(fNextToken, nullptr, 10);
+        AdvanceToNextToken();
+      }
+    }
+    else if (!PL_strcasecmp(fNextToken,"UIDNEXT"))
+    {
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        fStatusNextUID = strtoul(fNextToken, nullptr, 10);
+        AdvanceToNextToken();
+      }
+    }
+    else if (!PL_strcasecmp(fNextToken, "APPENDUID"))
+    {
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        // ** jt -- the returned uidvalidity is the destination folder
+        // uidvalidity; don't use it for current folder
+        // fFolderUIDValidity = atoi(fNextToken);
+        // fHighestRecordedUID = 0; ??? this should be wrong
+        AdvanceToNextToken();
+        if (ContinueParse())
+        {
+          fCurrentResponseUID = strtoul(fNextToken, nullptr, 10);
+          AdvanceToNextToken();
+        }
+      }
+    }
+    else if (!PL_strcasecmp(fNextToken, "COPYUID"))
+    {
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        // ** jt -- destination folder uidvalidity
+        // fFolderUIDValidity = atoi(fNextToken);
+        // original message set; ignore it
+        AdvanceToNextToken();
+        if (ContinueParse())
+        {
+          // the resulting message set; should be in the form of
+          // either uid or uid1:uid2
+          AdvanceToNextToken();
+          // clear copy response uid
+          fServerConnection.SetCopyResponseUid(fNextToken);
+        }
+        if (ContinueParse())
+          AdvanceToNextToken();
+      }
+    }
+    else if (!PL_strcasecmp(fNextToken, "HIGHESTMODSEQ"))
+    {
+      AdvanceToNextToken();
+      if (ContinueParse())
+      {
+        fHighestModSeq = ParseUint64Str(fNextToken);
+        fUseModSeq = true;
+        AdvanceToNextToken();
+      }
+    }
+    else if (!PL_strcasecmp(fNextToken, "NOMODSEQ]"))
+    {
+      fHighestModSeq = 0;
+      fUseModSeq = false;
+      skip_to_CRLF();
+    }
+    else if (!PL_strcasecmp(fNextToken, "CAPABILITY"))
+    {
+      capability_data();
+    }
+    else if (!PL_strcasecmp(fNextToken, "MYRIGHTS"))
+    {
+      myrights_data(true);
+    }
+    else // just text
+    {
+      // do nothing but eat tokens until we see the ] or CRLF
+      // we should see the ] but we don't want to go into an
+      // endless loop if the CRLF is not there
+      do
+      {
+        AdvanceToNextToken();
+      } while (!PL_strcasestr(fNextToken, "]") && !fAtEndOfLine
+                && ContinueParse());
+    }
+  }
+}
+
+// RFC3501:  response-done = response-tagged / response-fatal
+ void nsImapServerResponseParser::response_done()
+ {
+   if (ContinueParse())
+   {
+     if (!PL_strcmp(fCurrentCommandTag, fNextToken))
+       response_tagged();
+     else
+       response_fatal();
+   }
+ }
+
+// RFC3501:  response-tagged = tag SP resp-cond-state CRLF
+ void nsImapServerResponseParser::response_tagged()
+ {
+   // eat the tag
+   AdvanceToNextToken();
+   if (ContinueParse())
+   {
+     resp_cond_state(true);
+     if (ContinueParse())
+     {
+       if (!fAtEndOfLine)
+         SetSyntaxError(true);
+       else if (!fCurrentCommandFailed)
+         ResetLexAnalyzer();
+     }
+   }
+ }
+
+// RFC3501:  response-fatal = "*" SP resp-cond-bye CRLF
+//                              ; Server closes connection immediately
+ void nsImapServerResponseParser::response_fatal()
+ {
+   // eat the "*"
+   AdvanceToNextToken();
+   if (ContinueParse())
+     resp_cond_bye();
+ }
+
+// RFC3501:  resp-cond-bye = "BYE" SP resp-text
+void nsImapServerResponseParser::resp_cond_bye()
+{
+  SetConnected(false);
+  fIMAPstate = kNonAuthenticated;
+}
+
+
+void nsImapServerResponseParser::msg_fetch_headers(const char *partNum)
+{
+  if (GetFillingInShell())
+  {
+    char *headerData = CreateAstring();
+    AdvanceToNextToken();
+    m_shell->AdoptMessageHeaders(headerData, partNum);
+  }
+  else
+  {
+    msg_fetch_content(false, 0, MESSAGE_RFC822);
+  }
+}
+
+
+/* nstring         ::= string / nil
+string          ::= quoted / literal
+nil             ::= "NIL"
+
+*/
+void nsImapServerResponseParser::msg_fetch_content(bool chunk, int32_t origin, const char *content_type)
+{
+  // setup the stream for downloading this message.
+  // Don't do it if we are filling in a shell or downloading a part.
+  // DO do it if we are downloading a whole message as a result of
+  // an invalid shell trying to generate.
+  if ((!chunk || (origin == 0)) && !GetDownloadingHeaders() &&
+    (GetFillingInShell() ? m_shell->GetGeneratingWholeMessage() : true))
+  {
+    if (NS_FAILED(BeginMessageDownload(content_type)))
+      return;
+  }
+
+  if (PL_strcasecmp(fNextToken, "NIL"))
+  {
+    if (*fNextToken == '"')
+      fLastChunk = msg_fetch_quoted();
+    else
+      fLastChunk = msg_fetch_literal(chunk, origin);
+  }
+  else
+    AdvanceToNextToken();	// eat "NIL"
+
+  if (fLastChunk && (GetFillingInShell() ? m_shell->GetGeneratingWholeMessage() : true))
+  {
+    // complete the message download
+    if (ContinueParse())
+    {
+      if (fReceivedHeaderOrSizeForUID == CurrentResponseUID())
+      {
+        fServerConnection.NormalMessageEndDownload();
+        fReceivedHeaderOrSizeForUID = nsMsgKey_None;
+      }
+      else
+         fReceivedHeaderOrSizeForUID = CurrentResponseUID();
+    }
+    else
+      fServerConnection.AbortMessageDownLoad();
+  }
+}
+
+
+/*
+quoted          ::= <"> *QUOTED_CHAR <">
+
+  QUOTED_CHAR     ::= <any TEXT_CHAR except quoted_specials> /
+  "\" quoted_specials
+
+    quoted_specials ::= <"> / "\"
+*/
+
+bool nsImapServerResponseParser::msg_fetch_quoted()
+{
+  // *Should* never get a quoted string in response to a chunked download,
+  // but the RFCs don't forbid it
+  char *q = CreateQuoted();
+  if (q)
+  {
+    numberOfCharsInThisChunk = PL_strlen(q);
+    fServerConnection.HandleMessageDownLoadLine(q, false, q);
+    PR_Free(q);
+  }
+  else
+    numberOfCharsInThisChunk = 0;
+
+  AdvanceToNextToken();
+  bool lastChunk = ((fServerConnection.GetCurFetchSize() == 0) ||
+                    (numberOfCharsInThisChunk != fServerConnection.GetCurFetchSize()));
+  return lastChunk;
+}
+
+/* msg_obsolete    ::= "COPY" / ("STORE" SPACE msg_fetch)
+;; OBSOLETE untagged data responses */
+void nsImapServerResponseParser::msg_obsolete()
+{
+  if (!PL_strcasecmp(fNextToken, "COPY"))
+    AdvanceToNextToken();
+  else if (!PL_strcasecmp(fNextToken, "STORE"))
+  {
+    AdvanceToNextToken();
+    if (ContinueParse())
+      msg_fetch();
+  }
+  else
+    SetSyntaxError(true);
+}
+
+void nsImapServerResponseParser::capability_data()
+{
+  int32_t endToken = -1;
+  fCapabilityFlag = kCapabilityDefined | kHasAuthOldLoginCapability;
+  do {
+    AdvanceToNextToken();
+    if (fNextToken) {
+      nsCString token(fNextToken);
+      endToken = token.FindChar(']');
+      if (endToken >= 0)
+        token.SetLength(endToken);
+
+      if(token.Equals("AUTH=LOGIN", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasAuthLoginCapability;
+      else if(token.Equals("AUTH=PLAIN", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasAuthPlainCapability;
+      else if (token.Equals("AUTH=CRAM-MD5", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasCRAMCapability;
+      else if (token.Equals("AUTH=NTLM", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasAuthNTLMCapability;
+      else if (token.Equals("AUTH=GSSAPI", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasAuthGssApiCapability;
+      else if (token.Equals("AUTH=MSN", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasAuthMSNCapability;
+      else if (token.Equals("AUTH=EXTERNAL", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasAuthExternalCapability;
+      else if (token.Equals("AUTH=XOAUTH2", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasXOAuth2Capability;
+      else if (token.Equals("STARTTLS", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasStartTLSCapability;
+      else if (token.Equals("LOGINDISABLED", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag &= ~kHasAuthOldLoginCapability; // remove flag
+      else if (token.Equals("XSENDER", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasXSenderCapability;
+      else if (token.Equals("IMAP4", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kIMAP4Capability;
+      else if (token.Equals("IMAP4rev1", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kIMAP4rev1Capability;
+      else if (Substring(token,0,5).Equals("IMAP4", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kIMAP4other;
+      else if (token.Equals("X-NO-ATOMIC-RENAME", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kNoHierarchyRename;
+      else if (token.Equals("X-NON-HIERARCHICAL-RENAME", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kNoHierarchyRename;
+      else if (token.Equals("NAMESPACE", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kNamespaceCapability;
+      else if (token.Equals("ID", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasIDCapability;
+      else if (token.Equals("ACL", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kACLCapability;
+      else if (token.Equals("XSERVERINFO", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kXServerInfoCapability;
+      else if (token.Equals("UIDPLUS", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kUidplusCapability;
+      else if (token.Equals("LITERAL+", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kLiteralPlusCapability;
+      else if (token.Equals("XAOL-OPTION", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kAOLImapCapability;
+      else if (token.Equals("X-GM-EXT-1", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kGmailImapCapability;
+      else if (token.Equals("QUOTA", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kQuotaCapability;
+      else if (token.Equals("LANGUAGE", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasLanguageCapability;
+      else if (token.Equals("IDLE", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasIdleCapability;
+      else if (token.Equals("CONDSTORE", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasCondStoreCapability;
+      else if (token.Equals("ENABLE", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasEnableCapability;
+      else if (token.Equals("LIST-EXTENDED", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasListExtendedCapability;
+      else if (token.Equals("XLIST", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasXListCapability;
+      else if (token.Equals("SPECIAL-USE", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasSpecialUseCapability;
+      else if (token.Equals("COMPRESS=DEFLATE", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasCompressDeflateCapability;
+      else if (token.Equals("MOVE", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasMoveCapability;
+      else if (token.Equals("HIGHESTMODSEQ", nsCaseInsensitiveCStringComparator()))
+        fCapabilityFlag |= kHasHighestModSeqCapability;
+    }
+  } while (fNextToken && endToken < 0 && !fAtEndOfLine && ContinueParse());
+
+  nsImapProtocol *navCon = &fServerConnection;
+  NS_ASSERTION(navCon, "null imap protocol connection while parsing capability response");	// we should always have this
+  if (navCon)
+    navCon->CommitCapability();
+  skip_to_CRLF();
+}
+
+void nsImapServerResponseParser::xmailboxinfo_data()
+{
+  AdvanceToNextToken();
+  if (!fNextToken)
+    return;
+
+  char *mailboxName = CreateAstring(); // PL_strdup(fNextToken);
+  if (mailboxName)
+  {
+    do
+    {
+      AdvanceToNextToken();
+      if (fNextToken)
+      {
+        if (!PL_strcmp("MANAGEURL", fNextToken))
+        {
+          AdvanceToNextToken();
+          fFolderAdminUrl = CreateAstring();
+        }
+        else if (!PL_strcmp("POSTURL", fNextToken))
+        {
+          AdvanceToNextToken();
+          // ignore this for now...
+        }
+      }
+    } while (fNextToken && !fAtEndOfLine && ContinueParse());
+  }
+}
+
+void nsImapServerResponseParser::xserverinfo_data()
+{
+  do
+  {
+    AdvanceToNextToken();
+    if (!fNextToken)
+      break;
+    if (!PL_strcmp("MANAGEACCOUNTURL", fNextToken))
+    {
+      AdvanceToNextToken();
+      fMailAccountUrl.Adopt(CreateNilString());
+    }
+    else if (!PL_strcmp("MANAGELISTSURL", fNextToken))
+    {
+      AdvanceToNextToken();
+      fManageListsUrl.Adopt(CreateNilString());
+    }
+    else if (!PL_strcmp("MANAGEFILTERSURL", fNextToken))
+    {
+      AdvanceToNextToken();
+      fManageFiltersUrl.Adopt(CreateNilString());
+    }
+  } while (fNextToken && !fAtEndOfLine && ContinueParse());
+}
+
+void nsImapServerResponseParser::enable_data()
+{
+  do
+  {
+    // eat each enable response;
+     AdvanceToNextToken();
+     if (!strcmp("CONDSTORE", fNextToken))
+       fCondStoreEnabled = true;
+  } while (fNextToken && !fAtEndOfLine && ContinueParse());
+
+}
+
+void nsImapServerResponseParser::language_data()
+{
+  // we may want to go out and store the language returned to us
+  // by the language command in the host info session stuff.
+
+  // for now, just eat the language....
+  do
+  {
+    // eat each language returned to us
+    AdvanceToNextToken();
+  } while (fNextToken && !fAtEndOfLine && ContinueParse());
+}
+
+// cram/auth response data ::= "+" SPACE challenge CRLF
+// the server expects more client data after issuing its challenge
+
+void nsImapServerResponseParser::authChallengeResponse_data()
+{
+  AdvanceToNextToken();
+  fAuthChallenge = strdup(fNextToken);
+  fWaitingForMoreClientInput = true;
+
+  skip_to_CRLF();
+}
+
+
+void nsImapServerResponseParser::namespace_data()
+{
+	EIMAPNamespaceType namespaceType = kPersonalNamespace;
+	bool namespacesCommitted = false;
+  const char* serverKey = fServerConnection.GetImapServerKey();
+	while ((namespaceType != kUnknownNamespace) && ContinueParse())
+	{
+		AdvanceToNextToken();
+		while (fAtEndOfLine && ContinueParse())
+			AdvanceToNextToken();
+		if (!PL_strcasecmp(fNextToken,"NIL"))
+		{
+			// No namespace for this type.
+			// Don't add anything to the Namespace object.
+		}
+		else if (fNextToken[0] == '(')
+		{
+			// There may be multiple namespaces of the same type.
+			// Go through each of them and add them to our Namespace object.
+
+			fNextToken++;
+			while (fNextToken[0] == '(' && ContinueParse())
+			{
+				// we have another namespace for this namespace type
+				fNextToken++;
+				if (fNextToken[0] != '"')
+				{
+					SetSyntaxError(true);
+				}
+				else
+				{
+					char *namespacePrefix = CreateQuoted(false);
+
+					AdvanceToNextToken();
+					const char *quotedDelimiter = fNextToken;
+					char namespaceDelimiter = '\0';
+
+					if (quotedDelimiter[0] == '"')
+					{
+						quotedDelimiter++;
+						namespaceDelimiter = quotedDelimiter[0];
+					}
+					else if (!PL_strncasecmp(quotedDelimiter, "NIL", 3))
+					{
+						// NIL hierarchy delimiter.  Leave namespace delimiter nullptr.
+					}
+					else
+					{
+						// not quoted or NIL.
+						SetSyntaxError(true);
+					}
+					if (ContinueParse())
+					{
+            // add code to parse the TRANSLATE attribute if it is present....
+            // we'll also need to expand the name space code to take in the translated prefix name.
+
+						nsIMAPNamespace *newNamespace = new nsIMAPNamespace(namespaceType, namespacePrefix, namespaceDelimiter, false);
+						// add it to a temporary list in the host
+						if (newNamespace && fHostSessionList)
+							fHostSessionList->AddNewNamespaceForHost(
+                                serverKey, newNamespace);
+
+						skip_to_close_paren();	// Ignore any extension data
+
+						bool endOfThisNamespaceType = (fNextToken[0] == ')');
+						if (!endOfThisNamespaceType && fNextToken[0] != '(')	// no space between namespaces of the same type
+						{
+							SetSyntaxError(true);
+						}
+					}
+					PR_Free(namespacePrefix);
+				}
+			}
+		}
+		else
+		{
+			SetSyntaxError(true);
+		}
+		switch (namespaceType)
+		{
+		case kPersonalNamespace:
+			namespaceType = kOtherUsersNamespace;
+			break;
+		case kOtherUsersNamespace:
+			namespaceType = kPublicNamespace;
+			break;
+		default:
+			namespaceType = kUnknownNamespace;
+			break;
+		}
+	}
+	if (ContinueParse())
+	{
+		nsImapProtocol *navCon = &fServerConnection;
+		NS_ASSERTION(navCon, "null protocol connection while parsing namespace");	// we should always have this
+		if (navCon)
+		{
+			navCon->CommitNamespacesForHostEvent();
+			namespacesCommitted = true;
+		}
+	}
+	skip_to_CRLF();
+
+	if (!namespacesCommitted && fHostSessionList)
+	{
+		bool success;
+		fHostSessionList->FlushUncommittedNamespacesForHost(serverKey,
+                                                            success);
+	}
+}
+
+void nsImapServerResponseParser::myrights_data(bool unsolicited)
+{
+  AdvanceToNextToken();
+  if (ContinueParse() && !fAtEndOfLine)
+  {
+    char *mailboxName;
+    // an unsolicited myrights response won't have the mailbox name in
+    // the response, so we use the selected mailbox name.
+    if (unsolicited)
+    {
+      mailboxName = strdup(fSelectedMailboxName);
+    }
+    else
+    {
+      mailboxName = CreateAstring();
+      if (mailboxName)
+        AdvanceToNextToken();
+    }
+    if (mailboxName)
+    {
+      if (ContinueParse())
+      {
+        char *myrights = CreateAstring();
+        if (myrights)
+        {
+          nsImapProtocol *navCon = &fServerConnection;
+          NS_ASSERTION(navCon, "null connection parsing my rights"); // we should always have this
+          if (navCon)
+            navCon->AddFolderRightsForUser(mailboxName, nullptr /* means "me" */, myrights);
+          PR_Free(myrights);
+        }
+        else
+        {
+          HandleMemoryFailure();
+        }
+        if (ContinueParse())
+          AdvanceToNextToken();
+      }
+      PR_Free(mailboxName);
+    }
+    else
+    {
+      HandleMemoryFailure();
+    }
+  }
+  else
+  {
+    SetSyntaxError(true);
+  }
+}
+
+void nsImapServerResponseParser::acl_data()
+{
+  AdvanceToNextToken();
+  if (ContinueParse() && !fAtEndOfLine)
+  {
+    char *mailboxName = CreateAstring();	// PL_strdup(fNextToken);
+    if (mailboxName && ContinueParse())
+    {
+      AdvanceToNextToken();
+      while (ContinueParse() && !fAtEndOfLine)
+      {
+        char *userName = CreateAstring(); // PL_strdup(fNextToken);
+        if (userName && ContinueParse())
+        {
+          AdvanceToNextToken();
+          if (ContinueParse())
+          {
+            char *rights = CreateAstring(); // PL_strdup(fNextToken);
+            if (rights)
+            {
+              fServerConnection.AddFolderRightsForUser(mailboxName, userName, rights);
+              PR_Free(rights);
+            }
+            else
+              HandleMemoryFailure();
+
+            if (ContinueParse())
+              AdvanceToNextToken();
+          }
+          PR_Free(userName);
+        }
+        else
+          HandleMemoryFailure();
+      }
+      PR_Free(mailboxName);
+    }
+    else
+      HandleMemoryFailure();
+  }
+}
+
+
+void nsImapServerResponseParser::mime_data()
+{
+  if (PL_strstr(fNextToken, "MIME"))
+    mime_header_data();
+  else
+    mime_part_data();
+}
+
+// mime_header_data should not be streamed out;  rather, it should be
+// buffered in the nsIMAPBodyShell.
+// This is because we are still in the process of generating enough
+// information from the server (such as the MIME header's size) so that
+// we can construct the final output stream.
+void nsImapServerResponseParser::mime_header_data()
+{
+  char *partNumber = PL_strdup(fNextToken);
+  if (partNumber)
+  {
+    char *start = partNumber + 5, *end = partNumber + 5; // 5 == strlen("BODY[")
+    while (ContinueParse() && end && *end != 'M' && *end != 'm')
+    {
+      end++;
+    }
+    if (end && (*end == 'M' || *end == 'm'))
+    {
+      *(end-1) = 0;
+      AdvanceToNextToken();
+      char *mimeHeaderData = CreateAstring();	// is it really this simple?
+      AdvanceToNextToken();
+      if (m_shell)
+      {
+        m_shell->AdoptMimeHeader(start, mimeHeaderData);
+      }
+    }
+    else
+    {
+      SetSyntaxError(true);
+    }
+    PR_Free(partNumber);	// partNumber is not adopted by the body shell.
+  }
+  else
+  {
+    HandleMemoryFailure();
+  }
+}
+
+// Actual mime parts are filled in on demand (either from shell generation
+// or from explicit user download), so we need to stream these out.
+void nsImapServerResponseParser::mime_part_data()
+{
+  char *checkOriginToken = PL_strdup(fNextToken);
+  if (checkOriginToken)
+  {
+    uint32_t origin = 0;
+    bool originFound = false;
+    char *whereStart = PL_strchr(checkOriginToken, '<');
+    if (whereStart)
+    {
+      char *whereEnd = PL_strchr(whereStart, '>');
+      if (whereEnd)
+      {
+        *whereEnd = 0;
+        whereStart++;
+        origin = atoi(whereStart);
+        originFound = true;
+      }
+    }
+    PR_Free(checkOriginToken);
+    AdvanceToNextToken();
+    msg_fetch_content(originFound, origin, MESSAGE_RFC822);	// keep content type as message/rfc822, even though the
+    // MIME part might not be, because then libmime will
+    // still handle and decode it.
+  }
+  else
+    HandleMemoryFailure();
+}
+
+// parse FETCH BODYSTRUCTURE response, "a parenthesized list that describes
+// the [MIME-IMB] body structure of a message" [RFC 3501].
+void nsImapServerResponseParser::bodystructure_data()
+{
+  AdvanceToNextToken();
+  if (ContinueParse() && fNextToken && *fNextToken == '(')  // It has to start with an open paren.
+  {
+    // Turn the BODYSTRUCTURE response into a form that the nsIMAPBodypartMessage can be constructed from.
+    // FIXME: Follow up on bug 384210 to investigate why the caller has to duplicate the two in-param strings.
+    nsIMAPBodypartMessage *message =
+      new nsIMAPBodypartMessage(NULL, NULL, true, strdup("message"),
+                                strdup("rfc822"),
+                                NULL, NULL, NULL, 0,
+                                fServerConnection.GetPreferPlainText());
+    nsIMAPBodypart *body = bodystructure_part(PL_strdup("1"), message);
+    if (body)
+      message->SetBody(body);
+    else
+    {
+      delete message;
+      message = nullptr;
+    }
+    m_shell = new nsIMAPBodyShell(&fServerConnection, message, CurrentResponseUID(), GetSelectedMailboxName());
+    // ignore syntax errors in parsing the body structure response. If there's an error
+    // we'll just fall back to fetching the whole message.
+    SetSyntaxError(false);
+  }
+  else
+    SetSyntaxError(true);
+}
+
+// RFC3501:  body = "(" (body-type-1part / body-type-mpart) ")"
+nsIMAPBodypart *
+nsImapServerResponseParser::bodystructure_part(char *partNum, nsIMAPBodypart *parentPart)
+{
+  // Check to see if this buffer is a leaf or container
+  // (Look at second character - if an open paren, then it is a container)
+  if (*fNextToken != '(')
+  {
+    NS_ASSERTION(false, "bodystructure_part must begin with '('");
+    return NULL;
+  }
+
+  if (fNextToken[1] == '(')
+    return bodystructure_multipart(partNum, parentPart);
+  else
+    return bodystructure_leaf(partNum, parentPart);
+}
+
+// RFC3501: body-type-1part = (body-type-basic / body-type-msg / body-type-text)
+//                            [SP body-ext-1part]
+nsIMAPBodypart *
+nsImapServerResponseParser::bodystructure_leaf(char *partNum, nsIMAPBodypart *parentPart)
+{
+  // historical note: this code was originally in nsIMAPBodypartLeaf::ParseIntoObjects()
+  char *bodyType = nullptr, *bodySubType = nullptr, *bodyID = nullptr, *bodyDescription = nullptr, *bodyEncoding = nullptr;
+  int32_t partLength = 0;
+  bool isValid = true;
+
+  // body type  ("application", "text", "image", etc.)
+  if (ContinueParse())
+  {
+    fNextToken++; // eat the first '('
+    bodyType = CreateNilString();
+    if (ContinueParse())
+      AdvanceToNextToken();
+  }
+
+  // body subtype  ("gif", "html", etc.)
+  if (isValid && ContinueParse())
+  {
+    bodySubType = CreateNilString();
+    if (ContinueParse())
+      AdvanceToNextToken();
+  }
+
+  // body parameter: parenthesized list
+  if (isValid && ContinueParse())
+  {
+    if (fNextToken[0] == '(')
+    {
+      fNextToken++;
+      skip_to_close_paren();
+    }
+    else if (!PL_strcasecmp(fNextToken, "NIL"))
+      AdvanceToNextToken();
+  }
+
+  // body id
+  if (isValid && ContinueParse())
+  {
+    bodyID = CreateNilString();
+    if (ContinueParse())
+      AdvanceToNextToken();
+  }
+
+  // body description
+  if (isValid && ContinueParse())
+  {
+    bodyDescription = CreateNilString();
+    if (ContinueParse())
+      AdvanceToNextToken();
+  }
+
+  // body encoding
+  if (isValid && ContinueParse())
+  {
+    bodyEncoding = CreateNilString();
+    if (ContinueParse())
+      AdvanceToNextToken();
+  }
+
+  // body size
+  if (isValid && ContinueParse())
+  {
+    char *bodySizeString = CreateAtom();
+    if (!bodySizeString)
+      isValid = false;
+    else
+    {
+      partLength = atoi(bodySizeString);
+      PR_Free(bodySizeString);
+      if (ContinueParse())
+        AdvanceToNextToken();
+    }
+  }
+
+  if (!isValid || !ContinueParse())
+  {
+    PR_FREEIF(partNum);
+    PR_FREEIF(bodyType);
+    PR_FREEIF(bodySubType);
+    PR_FREEIF(bodyID);
+    PR_FREEIF(bodyDescription);
+    PR_FREEIF(bodyEncoding);
+  }
+  else
+  {
+    if (PL_strcasecmp(bodyType, "message") || PL_strcasecmp(bodySubType, "rfc822"))
+    {
+      skip_to_close_paren();
+      return new nsIMAPBodypartLeaf(partNum, parentPart, bodyType, bodySubType,
+                                    bodyID, bodyDescription, bodyEncoding,
+                                    partLength,
+                                    fServerConnection.GetPreferPlainText());
+    }
+
+    // This part is of type "message/rfc822"  (probably a forwarded message)
+    nsIMAPBodypartMessage *message =
+      new nsIMAPBodypartMessage(partNum, parentPart, false,
+                                bodyType, bodySubType, bodyID, bodyDescription,
+                                bodyEncoding, partLength,
+                                fServerConnection.GetPreferPlainText());
+
+    // there are three additional fields: envelope structure, bodystructure, and size in lines
+    // historical note: this code was originally in nsIMAPBodypartMessage::ParseIntoObjects()
+
+    // envelope (ignored)
+    if (*fNextToken == '(')
+    {
+      fNextToken++;
+      skip_to_close_paren();
+    }
+    else
+      isValid = false;
+
+    // bodystructure
+    if (isValid && ContinueParse())
+    {
+      if (*fNextToken != '(')
+        isValid = false;
+      else
+      {
+        char *bodyPartNum = PR_smprintf("%s.1", partNum);
+        if (bodyPartNum)
+        {
+          nsIMAPBodypart *body = bodystructure_part(bodyPartNum, message);
+          if (body)
+            message->SetBody(body);
+          else
+            isValid = false;
+        }
+      }
+    }
+
+    // ignore "size in text lines"
+
+    if (isValid && ContinueParse()) {
+      skip_to_close_paren();
+      return message;
+    }
+    delete message;
+  }
+
+  // parsing failed, just move to the end of the parentheses group
+  if (ContinueParse())
+    skip_to_close_paren();
+  return nullptr;
+}
+
+
+// RFC3501:  body-type-mpart = 1*body SP media-subtype
+//                             [SP body-ext-mpart]
+nsIMAPBodypart *
+nsImapServerResponseParser::bodystructure_multipart(char *partNum, nsIMAPBodypart *parentPart)
+{
+  nsIMAPBodypartMultipart *multipart = new nsIMAPBodypartMultipart(partNum, parentPart);
+  bool isValid = multipart->GetIsValid();
+  // historical note: this code was originally in nsIMAPBodypartMultipart::ParseIntoObjects()
+  if (ContinueParse())
+  {
+    fNextToken++; // eat the first '('
+    // Parse list of children
+    int childCount = 0;
+    while (isValid && fNextToken[0] == '(' && ContinueParse())
+    {
+      childCount++;
+      char *childPartNum = NULL;
+      // note: the multipart constructor does some magic on partNumber
+      if (PL_strcmp(multipart->GetPartNumberString(), "0")) // not top-level
+        childPartNum = PR_smprintf("%s.%d", multipart->GetPartNumberString(), childCount);
+      else // top-level
+        childPartNum = PR_smprintf("%d", childCount);
+      if (!childPartNum)
+        isValid = false;
+      else
+      {
+        nsIMAPBodypart *child = bodystructure_part(childPartNum, multipart);
+        if (child)
+          multipart->AppendPart(child);
+        else
+          isValid = false;
+      }
+    }
+
+    // RFC3501:  media-subtype   = string
+    // (multipart subtype: mixed, alternative, etc.)
+    if (isValid && ContinueParse())
+    {
+      char *bodySubType = CreateNilString();
+      multipart->SetBodySubType(bodySubType);
+      if (ContinueParse())
+        AdvanceToNextToken();
+    }
+
+    // extension data:
+    // RFC3501:  body-ext-mpart = body-fld-param [SP body-fld-dsp [SP body-fld-lang
+    //                            [SP body-fld-loc *(SP body-extension)]]]
+
+    // body parameter parenthesized list (optional data), includes boundary parameter
+    // RFC3501:  body-fld-param  = "(" string SP string *(SP string SP string) ")" / nil
+    char *boundaryData = nullptr;
+    if (isValid && ContinueParse() && *fNextToken == '(')
+    {
+      fNextToken++;
+      while (ContinueParse() && *fNextToken != ')')
+      {
+        char *attribute = CreateNilString();
+        if (ContinueParse())
+          AdvanceToNextToken();
+        if (ContinueParse() && !PL_strcasecmp(attribute, "BOUNDARY"))
+        {
+          char *boundary = CreateNilString();
+          if (boundary)
+            boundaryData = PR_smprintf("--%s", boundary);
+          PR_FREEIF(boundary);
+        }
+        else if (ContinueParse())
+        {
+          char *value = CreateNilString();
+          PR_FREEIF(value);
+        }
+        PR_FREEIF(attribute);
+        if (ContinueParse())
+          AdvanceToNextToken();
+      }
+      if (ContinueParse())
+        fNextToken++;  // skip closing ')'
+    }
+    if (boundaryData)
+      multipart->SetBoundaryData(boundaryData);
+    else
+      isValid = false;   // Actually, we should probably generate a boundary here.
+  }
+
+  // always move to closing ')', even if part was not successfully read
+  if (ContinueParse())
+    skip_to_close_paren();
+
+  if (isValid)
+    return multipart;
+  delete multipart;
+  return nullptr;
+}
+
+
+// RFC2087:  quotaroot_response = "QUOTAROOT" SP astring *(SP astring)
+//           quota_response = "QUOTA" SP astring SP quota_list
+//           quota_list     = "(" [quota_resource *(SP quota_resource)] ")"
+//           quota_resource = atom SP number SP number
+// Only the STORAGE resource is considered.  The current implementation is
+// slightly broken because it assumes that STORAGE is the first resource;
+// a reponse   QUOTA (MESSAGE 5 100 STORAGE 10 512)   would be ignored.
+void nsImapServerResponseParser::quota_data()
+{
+  if (!PL_strcasecmp(fNextToken, "QUOTAROOT"))
+  {
+    // ignore QUOTAROOT response
+    nsCString quotaroot;
+    AdvanceToNextToken();
+    while (ContinueParse() && !fAtEndOfLine)
+    {
+      quotaroot.Adopt(CreateAstring());
+      AdvanceToNextToken();
+    }
+  }
+  else if(!PL_strcasecmp(fNextToken, "QUOTA"))
+  {
+    uint32_t used, max;
+    char *parengroup;
+
+    AdvanceToNextToken();
+    if (ContinueParse())
+    {
+      nsCString quotaroot;
+      quotaroot.Adopt(CreateAstring());
+
+      if(ContinueParse() && !fAtEndOfLine)
+      {
+        AdvanceToNextToken();
+        if(fNextToken)
+        {
+          if(!PL_strcasecmp(fNextToken, "(STORAGE"))
+          {
+            parengroup = CreateParenGroup();
+            if(parengroup && (PR_sscanf(parengroup, "(STORAGE %lu %lu)", &used, &max) == 2) )
+            {
+              fServerConnection.UpdateFolderQuotaData(quotaroot, used, max);
+              skip_to_CRLF();
+            }
+            else
+              SetSyntaxError(true);
+
+            PR_Free(parengroup);
+          }
+          else
+            // Ignore other limits, we just check STORAGE for now
+            skip_to_CRLF();
+        }
+        else
+          SetSyntaxError(true);
+      }
+      else
+        HandleMemoryFailure();
+    }
+  }
+  else
+    SetSyntaxError(true);
+}
+
+void nsImapServerResponseParser::id_data()
+{
+  AdvanceToNextToken();
+  if (!PL_strcasecmp(fNextToken, "NIL"))
+    AdvanceToNextToken();
+  else
+    fServerIdResponse.Adopt(CreateParenGroup());
+  skip_to_CRLF();
+}
+
+bool nsImapServerResponseParser::GetFillingInShell()
+{
+  return (m_shell != nullptr);
+}
+
+bool nsImapServerResponseParser::GetDownloadingHeaders()
+{
+  return fDownloadingHeaders;
+}
+
+// Tells the server state parser to use a previously cached shell.
+void	nsImapServerResponseParser::UseCachedShell(nsIMAPBodyShell *cachedShell)
+{
+  // We shouldn't already have another shell we're dealing with.
+  if (m_shell && cachedShell)
+  {
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("PARSER: Shell Collision"));
+    NS_ASSERTION(false, "shell collision");
+  }
+  m_shell = cachedShell;
+}
+
+
+void nsImapServerResponseParser::ResetCapabilityFlag()
+{
+}
+
+/*
+ literal         ::= "{" number "}" CRLF *CHAR8
+                              ;; Number represents the number of CHAR8 octets
+*/
+// returns true if this is the last chunk and we should close the stream
+bool nsImapServerResponseParser::msg_fetch_literal(bool chunk, int32_t origin)
+{
+  numberOfCharsInThisChunk = atoi(fNextToken + 1);
+  // If we didn't request a specific size, or the server isn't returning exactly
+  // as many octets as we requested, this must be the last or only chunk
+  bool lastChunk = (!chunk ||
+                    (numberOfCharsInThisChunk != fServerConnection.GetCurFetchSize()));
+
+#ifdef DEBUG
+  if (lastChunk)
+    MOZ_LOG(IMAP, mozilla::LogLevel::Debug,
+                  ("PARSER: fetch_literal chunk = %d, requested %d, receiving %d",
+                    chunk, fServerConnection.GetCurFetchSize(),
+                    numberOfCharsInThisChunk));
+#endif
+
+  charsReadSoFar = 0;
+  static bool lastCRLFwasCRCRLF = false;
+
+  while (ContinueParse() && !fServerConnection.DeathSignalReceived() && (charsReadSoFar < numberOfCharsInThisChunk))
+  {
+    AdvanceToNextLine();
+    if (ContinueParse())
+    {
+      // When we split CRLF across two chunks, AdvanceToNextLine() turns the LF at the
+      // beginning of the next chunk into an empty line ending with CRLF, so discard
+      // that leading CR
+      bool specialLineEnding = false;
+      if (lastCRLFwasCRCRLF && (*fCurrentLine == '\r'))
+      {
+        char *usableCurrentLine = PL_strdup(fCurrentLine + 1);
+        PR_Free(fCurrentLine);
+        fCurrentLine = usableCurrentLine;
+        specialLineEnding = true;
+      }
+
+      // This *would* fail on data containing \0, but down below AdvanceToNextLine() in
+      // nsMsgLineStreamBuffer::ReadNextLine() we replace '\0' with ' ' (blank) because
+      // who cares about binary transparency, and anyways \0 in this context violates RFCs.
+      charsReadSoFar += strlen(fCurrentLine);
+      if (!fDownloadingHeaders && fCurrentCommandIsSingleMessageFetch)
+      {
+        fServerConnection.ProgressEventFunctionUsingName("imapDownloadingMessage");
+        if (fTotalDownloadSize > 0)
+          fServerConnection.PercentProgressUpdateEvent(0,charsReadSoFar + origin, fTotalDownloadSize);
+      }
+      if (charsReadSoFar > numberOfCharsInThisChunk)
+      {
+        // The chunk we are receiving doesn't end in CRLF, so the last line includes
+        // the CRLF that comes after the literal
+        char *displayEndOfLine = (fCurrentLine + strlen(fCurrentLine) - (charsReadSoFar - numberOfCharsInThisChunk));
+        char saveit = *displayEndOfLine;
+        *displayEndOfLine = 0;
+        fServerConnection.HandleMessageDownLoadLine(fCurrentLine, specialLineEnding || !lastChunk);
+        *displayEndOfLine = saveit;
+        lastCRLFwasCRCRLF = (*(displayEndOfLine - 1) == '\r');
+      }
+      else
+      {
+        lastCRLFwasCRCRLF = (*(fCurrentLine + strlen(fCurrentLine) - 1) == '\r');
+        fServerConnection.HandleMessageDownLoadLine(fCurrentLine,
+            specialLineEnding || (!lastChunk && (charsReadSoFar == numberOfCharsInThisChunk)),
+            fCurrentLine);
+      }
+    }
+  }
+
+  // This would be a good thing to log.
+  if (lastCRLFwasCRCRLF)
+    MOZ_LOG(IMAP, mozilla::LogLevel::Info, ("PARSER: CR/LF fell on chunk boundary."));
+
+  if (ContinueParse())
+  {
+    if (charsReadSoFar > numberOfCharsInThisChunk)
+    {
+      // move the lexical analyzer state to the end of this message because this message
+      // fetch ends in the middle of this line.
+      AdvanceTokenizerStartingPoint(strlen(fCurrentLine) - (charsReadSoFar - numberOfCharsInThisChunk));
+      AdvanceToNextToken();
+    }
+    else
+    {
+      skip_to_CRLF();
+      AdvanceToNextToken();
+    }
+  }
+  else
+  {
+    lastCRLFwasCRCRLF = false;
+  }
+  return lastChunk;
+}
+
+bool nsImapServerResponseParser::CurrentFolderReadOnly()
+{
+  return fCurrentFolderReadOnly;
+}
+
+int32_t	nsImapServerResponseParser::NumberOfMessages()
+{
+  return fNumberOfExistingMessages;
+}
+
+int32_t nsImapServerResponseParser::NumberOfRecentMessages()
+{
+  return fNumberOfRecentMessages;
+}
+
+int32_t nsImapServerResponseParser::NumberOfUnseenMessages()
+{
+  return fNumberOfUnseenMessages;
+}
+
+int32_t nsImapServerResponseParser::FolderUID()
+{
+  return fFolderUIDValidity;
+}
+
+void nsImapServerResponseParser::SetCurrentResponseUID(uint32_t uid)
+{
+  if (uid > 0)
+    fCurrentResponseUID = uid;
+}
+
+uint32_t nsImapServerResponseParser::CurrentResponseUID()
+{
+  return fCurrentResponseUID;
+}
+
+uint32_t nsImapServerResponseParser::HighestRecordedUID()
+{
+  return fHighestRecordedUID;
+}
+
+bool nsImapServerResponseParser::IsNumericString(const char *string)
+{
+  int i;
+  for(i = 0; i < (int) PL_strlen(string); i++)
+  {
+    if (! isdigit(string[i]))
+    {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
+nsImapMailboxSpec *nsImapServerResponseParser::CreateCurrentMailboxSpec(const char *mailboxName /* = nullptr */)
+{
+  nsImapMailboxSpec *returnSpec = new nsImapMailboxSpec;
+  if (!returnSpec)
+  {
+    HandleMemoryFailure();
+    return  nullptr;
+  }
+  NS_ADDREF(returnSpec);
+  const char *mailboxNameToConvert = (mailboxName) ? mailboxName : fSelectedMailboxName;
+  if (mailboxNameToConvert)
+  {
+    const char *serverKey = fServerConnection.GetImapServerKey();
+    nsIMAPNamespace *ns = nullptr;
+    if (serverKey && fHostSessionList)
+      fHostSessionList->GetNamespaceForMailboxForHost(serverKey, mailboxNameToConvert, ns);	// for
+      // delimiter
+    returnSpec->mHierarchySeparator = (ns) ? ns->GetDelimiter(): '/';
+
+  }
+
+  returnSpec->mFolderSelected = !mailboxName; // if mailboxName is null, we're doing a Status
+  returnSpec->mFolder_UIDVALIDITY = fFolderUIDValidity;
+  returnSpec->mHighestModSeq = fHighestModSeq;
+  returnSpec->mNumOfMessages = (mailboxName) ? fStatusExistingMessages : fNumberOfExistingMessages;
+  returnSpec->mNumOfUnseenMessages = (mailboxName) ? fStatusUnseenMessages : fNumberOfUnseenMessages;
+  returnSpec->mNumOfRecentMessages = (mailboxName) ? fStatusRecentMessages : fNumberOfRecentMessages;
+  returnSpec->mNextUID = fStatusNextUID;
+
+  returnSpec->mSupportedUserFlags = fSupportsUserDefinedFlags;
+
+  returnSpec->mBoxFlags = kNoFlags;	// stub
+  returnSpec->mOnlineVerified = false;	// we're fabricating this.  The flags aren't verified.
+  returnSpec->mAllocatedPathName.Assign(mailboxNameToConvert);
+  returnSpec->mConnection = &fServerConnection;
+  if (returnSpec->mConnection)
+  {
+    nsIURI * aUrl = nullptr;
+    nsresult rv = NS_OK;
+    returnSpec->mConnection->GetCurrentUrl()->QueryInterface(NS_GET_IID(nsIURI), (void **) &aUrl);
+    if (NS_SUCCEEDED(rv) && aUrl)
+      aUrl->GetHost(returnSpec->mHostName);
+
+    NS_IF_RELEASE(aUrl);
+  }
+  else
+    returnSpec->mHostName.Truncate();
+
+  if (fFlagState)
+    returnSpec->mFlagState = fFlagState; //copies flag state
+  else
+    returnSpec->mFlagState = nullptr;
+
+  return returnSpec;
+
+}
+// Reset the flag state.
+void nsImapServerResponseParser::ResetFlagInfo()
+{
+  if (fFlagState)
+    fFlagState->Reset();
+}
+
+
+bool nsImapServerResponseParser::GetLastFetchChunkReceived()
+{
+  return fLastChunk;
+}
+
+void nsImapServerResponseParser::ClearLastFetchChunkReceived()
+{
+  fLastChunk = false;
+}
+
+void nsImapServerResponseParser::SetHostSessionList(nsIImapHostSessionList*
+                                               aHostSessionList)
+{
+    NS_IF_RELEASE (fHostSessionList);
+    fHostSessionList = aHostSessionList;
+    NS_IF_ADDREF (fHostSessionList);
+}
+
+void nsImapServerResponseParser::SetSyntaxError(bool error, const char *msg)
+{
+  nsIMAPGenericParser::SetSyntaxError(error, msg);
+  if (error)
+  {
+    if (!fCurrentLine)
+    {
+      HandleMemoryFailure();
+      fServerConnection.Log("PARSER", ("Internal Syntax Error: %s: <no line>"), msg);
+    }
+    else
+    {
+      if (!strcmp(fCurrentLine, CRLF))
+        fServerConnection.Log("PARSER", "Internal Syntax Error: %s: <CRLF>", msg);
+      else
+      {
+        if (msg)
+          fServerConnection.Log("PARSER", "Internal Syntax Error: %s:", msg);
+        fServerConnection.Log("PARSER", "Internal Syntax Error on line: %s", fCurrentLine);
+      }
+    }
+  }
+}
+
+nsresult nsImapServerResponseParser::BeginMessageDownload(const char *content_type)
+{
+  nsresult rv = fServerConnection.BeginMessageDownLoad(fSizeOfMostRecentMessage,
+    content_type);
+  if (NS_FAILED(rv))
+  {
+    skip_to_CRLF();
+    fServerConnection.PseudoInterrupt(true);
+    fServerConnection.AbortMessageDownLoad();
+  }
+  return rv;
+}
diff --git a/mailnews/imap/src/nsImapServerResponseParser.h b/mailnews/imap/src/nsImapServerResponseParser.h
new file mode 100644
index 0000000000..5b46f8a43e
--- /dev/null
+++ b/mailnews/imap/src/nsImapServerResponseParser.h
@@ -0,0 +1,269 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsIMAPServerResponseParser_H_
+#define _nsIMAPServerResponseParser_H_
+
+#include "mozilla/Attributes.h"
+#include "nsIMAPHostSessionList.h"
+#include "nsImapSearchResults.h"
+#include "nsStringGlue.h"
+#include "MailNewsTypes.h"
+#include "nsTArray.h"
+#include "nsImapUtils.h"
+#include "nsAutoPtr.h"
+
+class nsIMAPNamespace;
+class nsIMAPNamespaceList;
+class nsIMAPBodyShell;
+class nsIMAPBodypart;
+class nsImapSearchResultIterator;
+class nsImapFlagAndUidState;
+class nsCString;
+
+#include "nsIMAPGenericParser.h"
+
+class nsImapServerResponseParser : public nsIMAPGenericParser
+{
+public:
+  nsImapServerResponseParser(nsImapProtocol &imapConnection);
+  virtual ~nsImapServerResponseParser();
+
+  // Overridden from the base parser class
+  virtual bool       LastCommandSuccessful() override;
+  virtual void HandleMemoryFailure() override;
+
+  // aignoreBadAndNOResponses --> don't throw a error dialog if this command results in a NO or Bad response
+  // from the server..in other words the command is "exploratory" and we don't really care if it succeeds or fails.
+  // This value is typically FALSE for almost all cases.
+  virtual void ParseIMAPServerResponse(const char *aCurrentCommand,
+                                       bool aIgnoreBadAndNOResponses,
+                                       char *aGreetingWithCapability = NULL);
+  virtual void InitializeState();
+  bool    CommandFailed();
+  void    SetCommandFailed(bool failed);
+
+    enum eIMAPstate {
+        kNonAuthenticated,
+        kAuthenticated,
+        kFolderSelected
+    } ;
+
+  virtual eIMAPstate GetIMAPstate();
+  virtual bool WaitingForMoreClientInput() { return fWaitingForMoreClientInput; }
+  const char *GetSelectedMailboxName();   // can be NULL
+
+  // if we get a PREAUTH greeting from the server, initialize the parser to begin in
+  // the kAuthenticated state
+  void PreauthSetAuthenticatedState();
+
+  // these functions represent the state of the currently selected
+  // folder
+  bool       CurrentFolderReadOnly();
+  int32_t    NumberOfMessages();
+  int32_t    NumberOfRecentMessages();
+  int32_t    NumberOfUnseenMessages();
+  int32_t    FolderUID();
+  uint32_t   CurrentResponseUID();
+  uint32_t   HighestRecordedUID();
+  void       SetCurrentResponseUID(uint32_t uid);
+  bool       IsNumericString(const char *string);
+  uint32_t   SizeOfMostRecentMessage();
+  void       SetTotalDownloadSize(int32_t newSize) { fTotalDownloadSize = newSize; }
+
+  nsImapSearchResultIterator *CreateSearchResultIterator();
+  void ResetSearchResultSequence() {fSearchResults->ResetSequence();}
+
+  // create a struct mailbox_spec from our info, used in
+  // libmsg c interface
+  nsImapMailboxSpec *CreateCurrentMailboxSpec(const char *mailboxName = nullptr);
+
+  // Resets the flags state.
+  void ResetFlagInfo();
+
+  // set this to false if you don't want to alert the user to server
+  // error messages
+  void SetReportingErrors(bool reportThem) { fReportingErrors=reportThem;}
+  bool GetReportingErrors() { return fReportingErrors; }
+
+  eIMAPCapabilityFlags GetCapabilityFlag() { return fCapabilityFlag; }
+  void   SetCapabilityFlag(eIMAPCapabilityFlags capability) {fCapabilityFlag = capability;}
+  bool ServerHasIMAP4Rev1Capability() { return ((fCapabilityFlag & kIMAP4rev1Capability) != 0); }
+  bool ServerHasACLCapability() { return ((fCapabilityFlag & kACLCapability) != 0); }
+  bool ServerHasNamespaceCapability() { return ((fCapabilityFlag & kNamespaceCapability) != 0); }
+  bool ServerIsNetscape3xServer() { return fServerIsNetscape3xServer; }
+  bool ServerHasServerInfo() {return ((fCapabilityFlag & kXServerInfoCapability) != 0); }
+  bool ServerIsAOLServer() {return ((fCapabilityFlag & kAOLImapCapability) != 0); }
+  void SetFetchingFlags(bool aFetchFlags) { fFetchingAllFlags = aFetchFlags;}
+  void ResetCapabilityFlag() ;
+
+  nsCString& GetMailAccountUrl() { return fMailAccountUrl; }
+  const char *GetXSenderInfo() { return fXSenderInfo; }
+  void FreeXSenderInfo() { PR_FREEIF(fXSenderInfo); }
+  nsCString& GetManageListsUrl() { return fManageListsUrl; }
+  nsCString& GetManageFiltersUrl() {return fManageFiltersUrl;}
+  const char *GetManageFolderUrl() {return fFolderAdminUrl;}
+  nsCString &GetServerID() {return fServerIdResponse;}
+
+  // Call this when adding a pipelined command to the session
+  void IncrementNumberOfTaggedResponsesExpected(const char *newExpectedTag);
+
+  // Interrupt a Fetch, without really Interrupting (through netlib)
+  bool GetLastFetchChunkReceived();
+  void ClearLastFetchChunkReceived();
+  virtual uint16_t	SupportsUserFlags() { return fSupportsUserDefinedFlags; }
+  virtual uint16_t  SettablePermanentFlags() { return fSettablePermanentFlags;}
+  void SetFlagState(nsIImapFlagAndUidState *state);
+  bool GetDownloadingHeaders();
+  bool GetFillingInShell();
+  void UseCachedShell(nsIMAPBodyShell *cachedShell);
+  void SetHostSessionList(nsIImapHostSessionList *aHostSession);
+  char  *fAuthChallenge;    // the challenge returned by the server in
+                            //response to authenticate using CRAM-MD5 or NTLM
+  bool            fCondStoreEnabled;  
+  bool            fUseModSeq;  // can use mod seq for currently selected folder
+  uint64_t        fHighestModSeq;
+
+protected:
+  virtual void    flags();
+  virtual void    envelope_data();
+  virtual void    xaolenvelope_data();
+  virtual void    parse_address(nsAutoCString &addressLine);
+  virtual void    internal_date();
+  virtual nsresult BeginMessageDownload(const char *content_type);
+
+  virtual void    response_data();
+  virtual void    resp_text();
+  virtual void    resp_cond_state(bool isTagged);
+  virtual void    text_mime2();
+  virtual void    text();
+  virtual void    parse_folder_flags();
+  virtual void    enable_data();
+  virtual void    language_data();
+  virtual void    authChallengeResponse_data();
+  virtual void    resp_text_code();
+  virtual void    response_done();
+  virtual void    response_tagged();
+  virtual void    response_fatal();
+  virtual void    resp_cond_bye();
+  virtual void    id_data();
+  virtual void    mailbox_data();
+  virtual void    numeric_mailbox_data();
+  virtual void    capability_data();
+  virtual void    xserverinfo_data();
+  virtual void    xmailboxinfo_data();
+  virtual void    namespace_data();
+  virtual void    myrights_data(bool unsolicited);
+  virtual void    acl_data();
+  virtual void    bodystructure_data();
+  nsIMAPBodypart  *bodystructure_part(char *partNum, nsIMAPBodypart *parentPart);
+  nsIMAPBodypart  *bodystructure_leaf(char *partNum, nsIMAPBodypart *parentPart);
+  nsIMAPBodypart  *bodystructure_multipart(char *partNum, nsIMAPBodypart *parentPart);
+  virtual void    mime_data();
+  virtual void    mime_part_data();
+  virtual void    mime_header_data();
+  virtual void    quota_data();
+  virtual void    msg_fetch();
+  virtual void    msg_obsolete();
+  virtual void    msg_fetch_headers(const char *partNum);
+  virtual void    msg_fetch_content(bool chunk, int32_t origin, const char *content_type);
+  virtual bool    msg_fetch_quoted();
+  virtual bool    msg_fetch_literal(bool chunk, int32_t origin);
+  virtual void    mailbox_list(bool discoveredFromLsub);
+  virtual void    mailbox(nsImapMailboxSpec *boxSpec);
+
+  virtual void    ProcessOkCommand(const char *commandToken);
+  virtual void    ProcessBadCommand(const char *commandToken);
+  virtual void    PreProcessCommandToken(const char *commandToken,
+                                             const char *currentCommand);
+  virtual void    PostProcessEndOfLine();
+
+  // Overridden from the nsIMAPGenericParser, to retrieve the next line
+  // from the open socket.
+  virtual bool    GetNextLineForParser(char **nextLine) override;
+  // overriden to do logging
+  virtual void    SetSyntaxError(bool error, const char *msg = nullptr) override;
+
+private:
+  bool            fCurrentCommandFailed;
+  bool            fReportingErrors;
+
+
+  bool            fCurrentFolderReadOnly;
+  bool            fCurrentLineContainedFlagInfo;
+  bool            fFetchingAllFlags;
+  bool            fWaitingForMoreClientInput;
+  // Is the server a Netscape 3.x Messaging Server?
+  bool            fServerIsNetscape3xServer;
+  bool            fDownloadingHeaders;
+  bool            fCurrentCommandIsSingleMessageFetch;
+  bool            fGotPermanentFlags;
+  imapMessageFlagsType   fSavedFlagInfo;
+  nsTArray<nsCString> fCustomFlags;
+
+  uint16_t  fSupportsUserDefinedFlags;
+  uint16_t  fSettablePermanentFlags;
+
+  int32_t           fFolderUIDValidity;
+  int32_t           fNumberOfUnseenMessages;
+  int32_t           fNumberOfExistingMessages;
+  int32_t           fNumberOfRecentMessages;
+  uint32_t          fCurrentResponseUID;
+  uint32_t          fHighestRecordedUID;
+  // used to handle server that sends msg size after headers
+  uint32_t          fReceivedHeaderOrSizeForUID;
+  int32_t           fSizeOfMostRecentMessage;
+  int32_t           fTotalDownloadSize;
+
+  int32_t           fStatusUnseenMessages;
+  int32_t           fStatusRecentMessages;
+  uint32_t          fStatusNextUID;
+  uint32_t          fStatusExistingMessages;
+
+  int               fNumberOfTaggedResponsesExpected;
+
+  char              *fCurrentCommandTag;
+
+  nsCString         fZeroLengthMessageUidString;
+
+  char              *fSelectedMailboxName;
+
+  nsImapSearchResultSequence    *fSearchResults;
+
+  nsCOMPtr <nsIImapFlagAndUidState> fFlagState;		// NOT owned by us, it's a copy, do not destroy
+
+  eIMAPstate               fIMAPstate;
+
+  eIMAPCapabilityFlags      fCapabilityFlag;
+  nsCString     fMailAccountUrl;
+  char          *fNetscapeServerVersionString;
+  char          *fXSenderInfo; /* changed per message download */
+  char          *fLastAlert; /* used to avoid displaying the same alert over and over */
+  char          *fMsgID; /* MessageID for Gmail only (X-GM-MSGID) */
+  char          *fThreadID; /* ThreadID for Gmail only (X-GM-THRID) */
+  char          *fLabels; /* Labels for Gmail only (X-GM-LABELS) [will include parens, removed while passing to hashTable ]*/
+  nsCString     fManageListsUrl;
+  nsCString    fManageFiltersUrl;
+  char          *fFolderAdminUrl;
+  nsCString    fServerIdResponse; // RFC 
+
+  int32_t fFetchResponseIndex;
+
+  // used for aborting a fetch stream when we're pseudo-Interrupted
+  int32_t numberOfCharsInThisChunk;
+  int32_t charsReadSoFar;
+  bool fLastChunk;
+
+  // points to the current body shell, if any
+  RefPtr<nsIMAPBodyShell> m_shell;
+
+  // The connection object
+  nsImapProtocol &fServerConnection;
+
+  nsIImapHostSessionList *fHostSessionList;
+  nsTArray<nsMsgKey> fCopyResponseKeyArray;
+};
+
+#endif
diff --git a/mailnews/imap/src/nsImapService.cpp b/mailnews/imap/src/nsImapService.cpp
new file mode 100644
index 0000000000..5e097311e1
--- /dev/null
+++ b/mailnews/imap/src/nsImapService.cpp
@@ -0,0 +1,3400 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"    // precompiled header...
+#include "nsMsgImapCID.h"
+
+#include "netCore.h"
+
+#include "nsIServiceManager.h"
+#include "nsIComponentManager.h"
+
+#include "nsIIMAPHostSessionList.h"
+#include "nsImapService.h"
+
+#include "nsImapUrl.h"
+#include "nsCOMPtr.h"
+#include "nsIMsgFolder.h"
+#include "nsIMsgImapMailFolder.h"
+#include "nsIImapIncomingServer.h"
+#include "nsIImapServerSink.h"
+#include "nsIImapMockChannel.h"
+#include "nsImapUtils.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellLoadInfo.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "nsIMsgStatusFeedback.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsILoadGroup.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgFolderFlags.h"
+#include "nsISubscribableServer.h"
+#include "nsIDirectoryService.h"
+#include "nsMailDirServiceDefs.h"
+#include "nsIWebNavigation.h"
+#include "nsImapStringBundle.h"
+#include "plbase64.h"
+#include "nsImapOfflineSync.h"
+#include "nsIMsgHdr.h"
+#include "nsMsgUtils.h"
+#include "nsICacheStorage.h"
+#include "nsICacheStorageService.h"
+#include "nsILoadContextInfo.h"
+#include "nsIStreamListenerTee.h"
+#include "nsNetCID.h"
+#include "nsMsgI18N.h"
+#include "nsIOutputStream.h"
+#include "nsIInputStream.h"
+#include "nsISeekableStream.h"
+#include "nsICopyMsgStreamListener.h"
+#include "nsIMsgParseMailMsgState.h"
+#include "nsMsgLocalCID.h"
+#include "nsIOutputStream.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellLoadInfo.h"
+#include "nsIMessengerWindowService.h"
+#include "nsIWindowMediator.h"
+#include "nsIPrompt.h"
+#include "nsIWindowWatcher.h"
+#include "nsImapProtocol.h"
+#include "nsIMsgMailSession.h"
+#include "nsIStreamConverterService.h"
+#include "nsIAutoSyncManager.h"
+#include "nsThreadUtils.h"
+#include "nsNetUtil.h"
+#include "nsMsgMessageFlags.h"
+#include "nsIMsgPluggableStore.h"
+#include "../../base/src/MailnewsLoadContextInfo.h"
+
+#define PREF_MAIL_ROOT_IMAP "mail.root.imap"            // old - for backward compatibility only
+#define PREF_MAIL_ROOT_IMAP_REL "mail.root.imap-rel"
+
+static NS_DEFINE_CID(kImapUrlCID, NS_IMAPURL_CID);
+static NS_DEFINE_CID(kCImapMockChannel, NS_IMAPMOCKCHANNEL_CID);
+
+static const char sequenceString[] = "SEQUENCE";
+static const char uidString[] = "UID";
+
+static bool gInitialized = false;
+static int32_t gMIMEOnDemandThreshold = 15000;
+static bool gMIMEOnDemand = false;
+
+NS_IMPL_ISUPPORTS(nsImapService,
+                   nsIImapService,
+                   nsIMsgMessageService,
+                   nsIProtocolHandler,
+                   nsIMsgProtocolInfo,
+                   nsIMsgMessageFetchPartService,
+                   nsIContentHandler)
+
+nsImapService::nsImapService()
+{
+  mPrintingOperation = false;
+  if (!gInitialized)
+  {
+    nsresult rv;
+    nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); 
+    if (NS_SUCCEEDED(rv) && prefBranch) 
+    {
+      prefBranch->GetBoolPref("mail.imap.mime_parts_on_demand", &gMIMEOnDemand);
+      prefBranch->GetIntPref("mail.imap.mime_parts_on_demand_threshold", &gMIMEOnDemandThreshold);
+    }
+
+    // initialize auto-sync service
+    nsCOMPtr<nsIAutoSyncManager> autoSyncMgr = do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
+    if (NS_SUCCEEDED(rv) && autoSyncMgr) 
+    {
+      // auto-sync manager initialization goes here
+      // assign new strategy objects here... 
+    }
+    NS_ASSERTION(autoSyncMgr != nullptr, "*** Cannot initialize nsAutoSyncManager service.");
+
+    gInitialized = true;
+  }
+}
+
+nsImapService::~nsImapService()
+{
+}
+
+char nsImapService::GetHierarchyDelimiter(nsIMsgFolder *aMsgFolder)
+{
+  char delimiter = '/';
+  if (aMsgFolder)
+  {
+    nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(aMsgFolder);
+    if (imapFolder)
+      imapFolder->GetHierarchyDelimiter(&delimiter);
+  }
+  return delimiter;
+}
+
+// N.B., this returns an escaped folder name, appropriate for putting in a url.
+nsresult nsImapService::GetFolderName(nsIMsgFolder *aImapFolder, nsACString &aFolderName)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgImapMailFolder> aFolder(do_QueryInterface(aImapFolder, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString onlineName;
+  // online name is in imap utf-7 - leave it that way
+  rv = aFolder->GetOnlineName(onlineName);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (onlineName.IsEmpty())
+  {
+    nsCString uri;
+    rv = aImapFolder->GetURI(uri);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCString hostname;
+    rv = aImapFolder->GetHostname(hostname);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = nsImapURI2FullName(kImapRootURI, hostname.get(), uri.get(), getter_Copies(onlineName));
+  }
+  // if the hierarchy delimiter is not '/', then we want to escape slashes;
+  // otherwise, we do want to escape slashes.
+  // we want to escape slashes and '^' first, otherwise, nsEscape will lose them
+  bool escapeSlashes = (GetHierarchyDelimiter(aImapFolder) != '/');
+  if (escapeSlashes && !onlineName.IsEmpty())
+  {
+    char* escapedOnlineName;
+    rv = nsImapUrl::EscapeSlashes(onlineName.get(), &escapedOnlineName);
+    if (NS_SUCCEEDED(rv))
+      onlineName.Adopt(escapedOnlineName);
+  }
+  // need to escape everything else
+  MsgEscapeString(onlineName, nsINetUtil::ESCAPE_URL_PATH, aFolderName);
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::SelectFolder(nsIMsgFolder *aImapMailFolder,
+                                          nsIUrlListener *aUrlListener,
+                                          nsIMsgWindow *aMsgWindow,
+                                          nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  if (WeAreOffline())
+    return NS_MSG_ERROR_OFFLINE;
+
+  bool canOpenThisFolder = true;
+  nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(aImapMailFolder);
+  if (imapFolder)
+    imapFolder->GetCanOpenFolder(&canOpenThisFolder);
+
+  if (!canOpenThisFolder) 
+    return NS_OK;
+
+  nsresult rv;
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl),
+                            aImapMailFolder, aUrlListener, urlSpec, hierarchyDelimiter);
+
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    // nsImapUrl::SetSpec() will set the imap action properly
+    rv = imapUrl->SetImapAction(nsIImapUrl::nsImapSelectFolder);
+
+    nsCOMPtr<nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(imapUrl);
+    // if no msg window, we won't put up error messages (this is almost certainly a biff-inspired get new msgs)
+    if (!aMsgWindow)
+      mailNewsUrl->SetSuppressErrorMsgs(true);
+    mailNewsUrl->SetMsgWindow(aMsgWindow);
+    mailNewsUrl->SetUpdatingFolder(true);
+    rv = SetImapUrlSink(aImapMailFolder, imapUrl);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      nsAutoCString folderName;
+      GetFolderName(aImapMailFolder, folderName);
+      urlSpec.Append("/select>");
+      urlSpec.Append(hierarchyDelimiter);
+      urlSpec.Append(folderName);
+      rv = mailNewsUrl->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  } // if we have a url to run....
+
+  return rv;
+}
+
+// lite select, used to verify UIDVALIDITY while going on/offline
+NS_IMETHODIMP nsImapService::LiteSelectFolder(nsIMsgFolder *aImapMailFolder,
+                                              nsIUrlListener *aUrlListener,
+                                              nsIMsgWindow *aMsgWindow,
+                                              nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return FolderCommand(aImapMailFolder, aUrlListener,
+                       "/liteselect>", nsIImapUrl::nsImapLiteSelectFolder, aMsgWindow, aURL);
+}
+
+NS_IMETHODIMP nsImapService::GetUrlForUri(const char *aMessageURI, 
+                                          nsIURI **aURL, 
+                                          nsIMsgWindow *aMsgWindow) 
+{
+  nsAutoCString messageURI(aMessageURI);
+
+  if (messageURI.Find(NS_LITERAL_CSTRING("&type=application/x-message-display")) != kNotFound)
+    return NS_NewURI(aURL, aMessageURI);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsAutoCString msgKey;
+  nsresult rv = DecomposeImapURI(messageURI, getter_AddRefs(folder), msgKey);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIImapUrl> imapUrl;
+    nsAutoCString urlSpec;
+    char hierarchyDelimiter = GetHierarchyDelimiter(folder);
+    rv = CreateStartOfImapUrl(messageURI, getter_AddRefs(imapUrl), folder, nullptr, urlSpec, hierarchyDelimiter);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = SetImapUrlSink(folder, imapUrl);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(imapUrl);
+    bool useLocalCache = false;
+    folder->HasMsgOffline(strtoul(msgKey.get(), nullptr, 10), &useLocalCache);
+    mailnewsUrl->SetMsgIsInLocalCache(useLocalCache);
+
+    nsCOMPtr<nsIURI> url = do_QueryInterface(imapUrl);
+    rv = url->GetSpec(urlSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    urlSpec.Append("fetch>UID>");
+    urlSpec.Append(hierarchyDelimiter);
+
+    nsAutoCString folderName;
+    GetFolderName(folder, folderName);
+    urlSpec.Append(folderName);
+    urlSpec.Append(">");
+    urlSpec.Append(msgKey);
+    rv = url->SetSpec(urlSpec);
+    imapUrl->QueryInterface(NS_GET_IID(nsIURI), (void **) aURL);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::OpenAttachment(const char *aContentType, 
+                                            const char *aFileName,
+                                            const char *aUrl, 
+                                            const char *aMessageUri, 
+                                            nsISupports *aDisplayConsumer, 
+                                            nsIMsgWindow *aMsgWindow, 
+                                            nsIUrlListener *aUrlListener)
+{
+  // okay this is a little tricky....we may have to fetch the mime part
+  // or it may already be downloaded for us....the only way i can tell to 
+  // distinguish the two events is to search for ?section or ?part
+  
+  nsAutoCString uri(aMessageUri);
+  nsAutoCString urlString(aUrl);
+  MsgReplaceSubstring(urlString, "/;section", "?section");
+  
+  // more stuff i don't understand
+  int32_t sectionPos = urlString.Find("?section");
+  // if we have a section field then we must be dealing with a mime part we need to fetchf
+  if (sectionPos > 0)
+  {
+    uri.Append(Substring(urlString, sectionPos));
+    uri += "&type=";
+    uri += aContentType;
+    uri += "&filename=";
+    uri += aFileName;
+  }
+  else
+  {
+    // try to extract the specific part number out from the url string
+    const char *partStart = PL_strstr(aUrl, "part=");
+    if (!partStart)
+      return NS_ERROR_FAILURE;
+    nsDependentCString part(partStart);
+    uri += "?";
+    uri += Substring(part, 0, part.FindChar('&'));
+    uri += "&type=";
+    uri += aContentType;
+    uri += "&filename=";
+    uri += aFileName;
+  }
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsAutoCString msgKey;
+  nsAutoCString uriMimePart;
+  nsAutoCString folderURI;
+  nsMsgKey key;
+
+  nsresult rv = DecomposeImapURI(uri, getter_AddRefs(folder), msgKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = nsParseImapMessageURI(uri.get(), folderURI, &key, getter_Copies(uriMimePart));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIImapMessageSink> imapMessageSink(do_QueryInterface(folder, &rv));
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIImapUrl> imapUrl;
+      nsAutoCString urlSpec;
+      char hierarchyDelimiter = GetHierarchyDelimiter(folder);
+      rv = CreateStartOfImapUrl(uri, getter_AddRefs(imapUrl), folder, aUrlListener, urlSpec, hierarchyDelimiter);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      urlSpec.Append("/fetch>UID>");
+      urlSpec.Append(hierarchyDelimiter);
+
+      nsCString folderName;
+      GetFolderName(folder, folderName);
+      urlSpec.Append(folderName);
+      urlSpec.Append(">");
+      urlSpec.Append(msgKey);
+      urlSpec.Append(uriMimePart);
+
+      if (!uriMimePart.IsEmpty())
+      {
+        nsCOMPtr<nsIMsgMailNewsUrl> mailUrl (do_QueryInterface(imapUrl));
+        if (mailUrl)
+        {
+          rv = mailUrl->SetSpec(urlSpec);
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (aFileName)
+            mailUrl->SetFileName(nsDependentCString(aFileName));
+        }
+        rv =  FetchMimePart(imapUrl, nsIImapUrl::nsImapOpenMimePart, folder, imapMessageSink,
+                            nullptr, aDisplayConsumer, msgKey, uriMimePart);
+      }
+    } // if we got a message sink
+  } // if we parsed the message uri
+
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::FetchMimePart(nsIURI *aURI, 
+                                           const char *aMessageURI, 
+                                           nsISupports *aDisplayConsumer, 
+                                           nsIMsgWindow *aMsgWindow, 
+                                           nsIUrlListener *aUrlListener, 
+                                           nsIURI **aURL)
+{
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsAutoCString messageURI(aMessageURI);
+  nsAutoCString msgKey;
+  nsAutoCString mimePart;
+  nsAutoCString folderURI;
+  nsMsgKey key;
+  
+  nsresult rv = DecomposeImapURI(messageURI, getter_AddRefs(folder), msgKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = nsParseImapMessageURI(aMessageURI, folderURI, &key, getter_Copies(mimePart));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIImapMessageSink> imapMessageSink(do_QueryInterface(folder, &rv));
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(aURI);
+      nsCOMPtr<nsIMsgMailNewsUrl> msgurl (do_QueryInterface(aURI));
+      
+      msgurl->SetMsgWindow(aMsgWindow);
+      msgurl->RegisterListener(aUrlListener);
+      
+      if (!mimePart.IsEmpty())
+      {
+        return FetchMimePart(imapUrl, nsIImapUrl::nsImapMsgFetch, folder, imapMessageSink,
+          aURL, aDisplayConsumer, msgKey, mimePart);
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::DisplayMessage(const char *aMessageURI,
+                                            nsISupports *aDisplayConsumer,  
+                                            nsIMsgWindow *aMsgWindow,
+                                            nsIUrlListener *aUrlListener,
+                                            const char *aCharsetOverride,
+                                            nsIURI **aURL)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsAutoCString msgKey;
+  nsAutoCString mimePart;
+  nsAutoCString folderURI;
+  nsMsgKey key;
+  nsAutoCString messageURI(aMessageURI);
+
+  int32_t typeIndex = messageURI.Find("&type=application/x-message-display");
+  if (typeIndex != kNotFound)
+  {
+    // This happens with forward inline of a message/rfc822 attachment opened in
+    // a standalone msg window.
+    // So, just cut to the chase and call AsyncOpen on a channel.
+    nsCOMPtr <nsIURI> uri;
+    messageURI.Cut(typeIndex, sizeof("&type=application/x-message-display") - 1);
+    rv = NS_NewURI(getter_AddRefs(uri), messageURI.get());
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (aURL)
+      NS_IF_ADDREF(*aURL = uri);
+    nsCOMPtr<nsIStreamListener> aStreamListener = do_QueryInterface(aDisplayConsumer, &rv);
+    if (NS_SUCCEEDED(rv) && aStreamListener)
+    {
+      nsCOMPtr<nsIChannel> aChannel;
+      nsCOMPtr<nsILoadGroup> aLoadGroup;
+      nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(uri, &rv);
+      if (NS_SUCCEEDED(rv) && mailnewsUrl)
+        mailnewsUrl->GetLoadGroup(getter_AddRefs(aLoadGroup));
+
+      rv = NewChannel(uri, getter_AddRefs(aChannel));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsISupports> aCtxt = do_QueryInterface(uri);
+      //  now try to open the channel passing in our display consumer as the listener
+      rv = aChannel->AsyncOpen(aStreamListener, aCtxt);
+      return rv;
+    }
+  }
+
+  rv = DecomposeImapURI(messageURI, getter_AddRefs(folder), msgKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (msgKey.IsEmpty())
+    return NS_MSG_MESSAGE_NOT_FOUND;
+
+  rv = nsParseImapMessageURI(aMessageURI, folderURI, &key, getter_Copies(mimePart));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIImapMessageSink> imapMessageSink(do_QueryInterface(folder, &rv));
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIImapUrl> imapUrl;
+      nsAutoCString urlSpec;
+      char hierarchyDelimiter = GetHierarchyDelimiter(folder);
+      rv = CreateStartOfImapUrl(messageURI, getter_AddRefs(imapUrl), folder, aUrlListener, urlSpec, hierarchyDelimiter);
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (!mimePart.IsEmpty())
+      {
+        nsresult rv;
+        nsCOMPtr<nsIURI> url = do_QueryInterface(imapUrl);
+
+        rv = AddImapFetchToUrl(url, folder, msgKey + mimePart, EmptyCString());
+        NS_ENSURE_SUCCESS(rv, rv);
+
+        return FetchMimePart(imapUrl, nsIImapUrl::nsImapMsgFetch, folder, imapMessageSink,
+                             aURL, aDisplayConsumer, msgKey, mimePart);
+      }
+
+      nsCOMPtr<nsIMsgMailNewsUrl> msgurl (do_QueryInterface(imapUrl));
+      nsCOMPtr<nsIMsgI18NUrl> i18nurl (do_QueryInterface(imapUrl));
+      i18nurl->SetCharsetOverRide(aCharsetOverride);
+
+      uint32_t messageSize;
+      bool useMimePartsOnDemand = gMIMEOnDemand;
+      bool shouldStoreMsgOffline = false;
+      bool hasMsgOffline = false;
+
+      nsCOMPtr<nsIMsgIncomingServer> aMsgIncomingServer;
+
+      if (imapMessageSink)
+        imapMessageSink->GetMessageSizeFromDB(msgKey.get(), &messageSize);
+
+      msgurl->SetMsgWindow(aMsgWindow);
+
+      rv = msgurl->GetServer(getter_AddRefs(aMsgIncomingServer));
+
+      if (NS_SUCCEEDED(rv) && aMsgIncomingServer)
+      {
+        nsCOMPtr<nsIImapIncomingServer> aImapServer(do_QueryInterface(aMsgIncomingServer, &rv));
+        if (NS_SUCCEEDED(rv) && aImapServer)
+          aImapServer->GetMimePartsOnDemand(&useMimePartsOnDemand);
+      }
+
+      nsAutoCString uriStr(aMessageURI);
+      int32_t keySeparator = uriStr.RFindChar('#');
+      if(keySeparator != -1)
+      {
+        int32_t keyEndSeparator = MsgFindCharInSet(uriStr, "/?&", keySeparator);
+        int32_t mpodFetchPos = MsgFind(uriStr, "fetchCompleteMessage=true", false, keyEndSeparator);
+        if (mpodFetchPos != -1)
+          useMimePartsOnDemand = false;
+      }
+
+      if (folder)
+      {
+        folder->ShouldStoreMsgOffline(key, &shouldStoreMsgOffline);
+        folder->HasMsgOffline(key, &hasMsgOffline);
+      }
+      imapUrl->SetStoreResultsOffline(shouldStoreMsgOffline);
+      imapUrl->SetFetchPartsOnDemand(
+        useMimePartsOnDemand && messageSize >= (uint32_t) gMIMEOnDemandThreshold);
+
+      if (hasMsgOffline)
+        msgurl->SetMsgIsInLocalCache(true);
+
+      nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+      // Should the message fetch force a peek or a traditional fetch?
+      // Force peek if there is a delay in marking read (or no auto-marking at all).
+      // This is because a FETCH (BODY[]) will implicitly set tha \Seen flag on the msg,
+      // but a FETCH (BODY.PEEK[]) won't.
+      bool forcePeek = false;
+      if (NS_SUCCEEDED(rv) && prefBranch)
+      {
+        int32_t dontMarkAsReadPos = uriStr.Find("&markRead=false");
+        bool markReadAuto = true;
+        prefBranch->GetBoolPref("mailnews.mark_message_read.auto", &markReadAuto);
+        bool markReadDelay = false;
+        prefBranch->GetBoolPref("mailnews.mark_message_read.delay", &markReadDelay);
+        forcePeek = (!markReadAuto || markReadDelay || (dontMarkAsReadPos != kNotFound));
+      }
+
+      rv = FetchMessage(imapUrl, forcePeek ? nsIImapUrl::nsImapMsgFetchPeek : nsIImapUrl::nsImapMsgFetch, 
+                        folder, imapMessageSink, aMsgWindow, aDisplayConsumer, msgKey, false, 
+                        (mPrintingOperation) ? NS_LITERAL_CSTRING("print") : NS_LITERAL_CSTRING(""), aURL);
+    }
+  }
+  return rv;
+}
+
+
+nsresult nsImapService::FetchMimePart(nsIImapUrl *aImapUrl,
+                                      nsImapAction aImapAction,
+                                      nsIMsgFolder *aImapMailFolder, 
+                                      nsIImapMessageSink *aImapMessage,
+                                      nsIURI **aURL,
+                                      nsISupports *aDisplayConsumer, 
+                                      const nsACString &messageIdentifierList,
+                                      const nsACString &mimePart) 
+{
+  NS_ENSURE_ARG_POINTER(aImapUrl);
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+  NS_ENSURE_ARG_POINTER(aImapMessage);
+
+  // create a protocol instance to handle the request.
+  // NOTE: once we start working with multiple connections, this step will be much more complicated...but for now
+  // just create a connection and process the request.
+  nsAutoCString urlSpec;
+  nsresult rv = SetImapUrlSink(aImapMailFolder, aImapUrl);
+  nsImapAction actionToUse = aImapAction;
+  if (actionToUse == nsImapUrl::nsImapOpenMimePart)
+    actionToUse = nsIImapUrl::nsImapMsgFetch;
+
+  nsCOMPtr<nsIMsgMailNewsUrl> msgurl (do_QueryInterface(aImapUrl));
+  if (aImapMailFolder && msgurl && !messageIdentifierList.IsEmpty())
+  {
+    bool useLocalCache = false;
+    aImapMailFolder->HasMsgOffline(strtoul(nsCString(messageIdentifierList).get(), nullptr, 10),
+                                   &useLocalCache);
+    msgurl->SetMsgIsInLocalCache(useLocalCache);
+  }
+  rv = aImapUrl->SetImapMessageSink(aImapMessage);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIURI> url = do_QueryInterface(aImapUrl);
+    if (aURL)
+      NS_IF_ADDREF(*aURL = url);
+
+    rv = url->GetSpec(urlSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // rhp: If we are displaying this message for the purpose of printing, we
+    // need to append the header=print option.
+    //
+    if (mPrintingOperation)
+      urlSpec.Append("?header=print");
+
+    rv = url->SetSpec(urlSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = aImapUrl->SetImapAction(actionToUse /* nsIImapUrl::nsImapMsgFetch */);
+    if (aImapMailFolder && aDisplayConsumer)
+    {
+      nsCOMPtr<nsIMsgIncomingServer> aMsgIncomingServer;
+      rv = aImapMailFolder->GetServer(getter_AddRefs(aMsgIncomingServer));
+      if (NS_SUCCEEDED(rv) && aMsgIncomingServer)
+      {
+        bool interrupted;
+        nsCOMPtr<nsIImapIncomingServer>
+          aImapServer(do_QueryInterface(aMsgIncomingServer, &rv));
+        if (NS_SUCCEEDED(rv) && aImapServer)
+          aImapServer->PseudoInterruptMsgLoad(aImapMailFolder, nullptr, &interrupted);
+      }
+    }
+    // if the display consumer is a docshell, then we should run the url in the docshell.
+    // otherwise, it should be a stream listener....so open a channel using AsyncRead
+    // and the provided stream listener....
+    
+    nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aDisplayConsumer, &rv));
+    if (NS_SUCCEEDED(rv) && docShell)
+    {
+      nsCOMPtr<nsIDocShellLoadInfo> loadInfo;
+      // DIRTY LITTLE HACK --> if we are opening an attachment we want the docshell to
+      // treat this load as if it were a user click event. Then the dispatching stuff will be much
+      // happier.
+      if (aImapAction == nsImapUrl::nsImapOpenMimePart)
+      {
+        docShell->CreateLoadInfo(getter_AddRefs(loadInfo));
+        loadInfo->SetLoadType(nsIDocShellLoadInfo::loadLink);
+      }
+      
+      rv = docShell->LoadURI(url, loadInfo, nsIWebNavigation::LOAD_FLAGS_NONE, false);
+    }
+    else
+    {
+      nsCOMPtr<nsIStreamListener> aStreamListener = do_QueryInterface(aDisplayConsumer, &rv);
+      if (NS_SUCCEEDED(rv) && aStreamListener)
+      {
+        nsCOMPtr<nsIChannel> aChannel;
+        nsCOMPtr<nsILoadGroup> loadGroup;
+        nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(aImapUrl, &rv);
+        if (NS_SUCCEEDED(rv) && mailnewsUrl)
+          mailnewsUrl->GetLoadGroup(getter_AddRefs(loadGroup));
+        
+        rv = NewChannel(url, getter_AddRefs(aChannel));
+        NS_ENSURE_SUCCESS(rv, rv);
+        
+        // we need a load group to hold onto the channel. When the request is finished,
+        // it'll get removed from the load group, and the channel will go away,
+        // which will free the load group.
+        if (!loadGroup)
+          loadGroup = do_CreateInstance(NS_LOADGROUP_CONTRACTID);
+
+        aChannel->SetLoadGroup(loadGroup);
+
+        nsCOMPtr<nsISupports> aCtxt = do_QueryInterface(url);
+        //  now try to open the channel passing in our display consumer as the listener
+        rv = aChannel->AsyncOpen(aStreamListener, aCtxt);
+      }
+      else // do what we used to do before
+      {
+        // I'd like to get rid of this code as I believe that we always get a docshell
+        // or stream listener passed into us in this method but i'm not sure yet...
+        // I'm going to use an assert for now to figure out if this is ever getting called
+#if defined(DEBUG_mscott) || defined(DEBUG_bienvenu)
+        NS_ERROR("oops...someone still is reaching this part of the code");
+#endif
+        rv = GetImapConnectionAndLoadUrl(aImapUrl, aDisplayConsumer, aURL);
+      }
+    }
+  }
+  return rv;
+}
+
+//
+// rhp: Right now, this is the same as simple DisplayMessage, but it will change
+// to support print rendering.
+//
+NS_IMETHODIMP nsImapService::DisplayMessageForPrinting(const char *aMessageURI,
+                                                       nsISupports *aDisplayConsumer,  
+                                                       nsIMsgWindow *aMsgWindow,
+                                                       nsIUrlListener *aUrlListener,
+                                                       nsIURI **aURL) 
+{
+  mPrintingOperation = true;
+  nsresult rv = DisplayMessage(aMessageURI, aDisplayConsumer, aMsgWindow, aUrlListener, nullptr, aURL);
+  mPrintingOperation = false;
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::CopyMessage(const char *aSrcMailboxURI, 
+                                         nsIStreamListener *aMailboxCopy, 
+                                         bool moveMessage,
+                                         nsIUrlListener *aUrlListener, 
+                                         nsIMsgWindow *aMsgWindow, 
+                                         nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aSrcMailboxURI);
+  NS_ENSURE_ARG_POINTER(aMailboxCopy);
+  
+  nsresult rv;
+  nsCOMPtr<nsISupports> streamSupport;
+  streamSupport = do_QueryInterface(aMailboxCopy, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsAutoCString msgKey;
+  rv = DecomposeImapURI(nsDependentCString(aSrcMailboxURI), getter_AddRefs(folder), msgKey);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIImapMessageSink> imapMessageSink(do_QueryInterface(folder, &rv));
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIImapUrl> imapUrl;
+      nsAutoCString urlSpec;
+      char hierarchyDelimiter = GetHierarchyDelimiter(folder);
+      bool hasMsgOffline = false;
+      nsMsgKey key = strtoul(msgKey.get(), nullptr, 10);
+
+      rv = CreateStartOfImapUrl(nsDependentCString(aSrcMailboxURI), getter_AddRefs(imapUrl),
+                                folder, aUrlListener, urlSpec, hierarchyDelimiter);
+      if (folder)
+      {
+        nsCOMPtr<nsIMsgMailNewsUrl> msgurl (do_QueryInterface(imapUrl));
+        folder->HasMsgOffline(key, &hasMsgOffline);
+        if (msgurl)
+          msgurl->SetMsgIsInLocalCache(hasMsgOffline);
+      }
+      // now try to download the message
+      nsImapAction imapAction = nsIImapUrl::nsImapOnlineToOfflineCopy;
+      if (moveMessage)
+        imapAction = nsIImapUrl::nsImapOnlineToOfflineMove; 
+      rv = FetchMessage(imapUrl,imapAction, folder, imapMessageSink,aMsgWindow, 
+                        streamSupport, msgKey, false, EmptyCString(), aURL);
+    } // if we got an imap message sink
+  } // if we decomposed the imap message 
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::CopyMessages(uint32_t aNumKeys,
+                                          nsMsgKey*aKeys,
+                                          nsIMsgFolder *srcFolder,
+                                          nsIStreamListener *aMailboxCopy,
+                                          bool moveMessage,
+                                          nsIUrlListener *aUrlListener,
+                                          nsIMsgWindow *aMsgWindow, 
+                                          nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aMailboxCopy);
+  NS_ENSURE_ARG_POINTER(aKeys);
+
+  nsresult rv;
+  nsCOMPtr<nsISupports> streamSupport = do_QueryInterface(aMailboxCopy, &rv);
+  if (!streamSupport || NS_FAILED(rv)) 
+    return rv;
+  
+  nsCOMPtr<nsIMsgFolder> folder = srcFolder;
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIImapMessageSink> imapMessageSink(do_QueryInterface(folder, &rv));
+    if (NS_SUCCEEDED(rv))
+    {
+      // we generate the uri for the first message so that way on down the line,
+      // GetMessage in nsCopyMessageStreamListener will get an unescaped username
+      // and be able to find the msg hdr. See bug 259656 for details
+      nsCString uri;
+      srcFolder->GenerateMessageURI(aKeys[0], uri);
+
+      nsCString messageIds;
+      AllocateImapUidString(aKeys, aNumKeys, nullptr, messageIds);
+      nsCOMPtr<nsIImapUrl> imapUrl;
+      nsAutoCString urlSpec;
+      char hierarchyDelimiter = GetHierarchyDelimiter(folder);
+      rv = CreateStartOfImapUrl(uri, getter_AddRefs(imapUrl), folder, aUrlListener, urlSpec, hierarchyDelimiter);
+      nsImapAction action;
+      if (moveMessage) // don't use ?: syntax here, it seems to break the Mac.
+        action = nsIImapUrl::nsImapOnlineToOfflineMove;
+      else
+        action = nsIImapUrl::nsImapOnlineToOfflineCopy;
+      imapUrl->SetCopyState(aMailboxCopy);
+      // now try to display the message
+      rv = FetchMessage(imapUrl, action, folder, imapMessageSink, aMsgWindow, 
+                        streamSupport, messageIds, false, EmptyCString(), aURL);
+      // ### end of copy operation should know how to do the delete.if this is a move
+      
+    } // if we got an imap message sink
+  } // if we decomposed the imap message 
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::Search(nsIMsgSearchSession *aSearchSession, 
+                                    nsIMsgWindow *aMsgWindow, 
+                                    nsIMsgFolder *aMsgFolder, 
+                                    const char *aSearchUri)
+{
+  NS_ENSURE_ARG_POINTER(aSearchUri);
+  NS_ENSURE_ARG_POINTER(aMsgFolder);
+  nsresult rv;
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsCOMPtr <nsIUrlListener> urlListener = do_QueryInterface(aSearchSession, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoCString urlSpec;
+  char hierarchyDelimiter = GetHierarchyDelimiter(aMsgFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl),
+                            aMsgFolder, urlListener, urlSpec,
+                            hierarchyDelimiter);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIMsgMailNewsUrl> msgurl (do_QueryInterface(imapUrl));
+
+  msgurl->SetMsgWindow(aMsgWindow);
+  msgurl->SetSearchSession(aSearchSession);
+  rv = SetImapUrlSink(aMsgFolder, imapUrl);
+
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCString folderName;
+    GetFolderName(aMsgFolder, folderName);
+
+    nsCOMPtr <nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(imapUrl);
+    if (!aMsgWindow)
+      mailNewsUrl->SetSuppressErrorMsgs(true);
+
+    urlSpec.Append("/search>UID>");
+    urlSpec.Append(hierarchyDelimiter);
+    urlSpec.Append(folderName);
+    urlSpec.Append('>');
+    // escape aSearchUri so that IMAP special characters (i.e. '\')
+    // won't be replaced with '/' in NECKO.
+    // it will be unescaped in nsImapUrl::ParseUrl().
+    nsCString escapedSearchUri;
+
+    MsgEscapeString(nsDependentCString(aSearchUri), nsINetUtil::ESCAPE_XALPHAS, escapedSearchUri);
+    urlSpec.Append(escapedSearchUri);
+    rv = mailNewsUrl->SetSpec(urlSpec);
+    if (NS_SUCCEEDED(rv))
+      rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, nullptr);
+  }
+  return rv;
+}
+
+// just a helper method to break down imap message URIs....
+nsresult nsImapService::DecomposeImapURI(const nsACString &aMessageURI,
+                                         nsIMsgFolder **aFolder,
+                                         nsACString &aMsgKey)
+{
+  nsMsgKey msgKey;
+  nsresult rv = DecomposeImapURI(aMessageURI, aFolder, &msgKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (msgKey)
+  {
+    nsAutoCString messageIdString;
+    messageIdString.AppendInt(msgKey);
+    aMsgKey = messageIdString;
+  }
+
+  return rv;
+}
+
+// just a helper method to break down imap message URIs....
+nsresult nsImapService::DecomposeImapURI(const nsACString &aMessageURI,
+                                         nsIMsgFolder **aFolder,
+                                         nsMsgKey *aMsgKey)
+{
+  NS_ENSURE_ARG_POINTER(aFolder);
+  NS_ENSURE_ARG_POINTER(aMsgKey);
+
+  nsAutoCString folderURI;
+  nsresult rv = nsParseImapMessageURI(PromiseFlatCString(aMessageURI).get(),
+                                      folderURI, aMsgKey, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr <nsIRDFService> rdf = do_GetService("@mozilla.org/rdf/rdf-service;1",&rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIRDFResource> res;
+  rv = rdf->GetResource(folderURI, getter_AddRefs(res));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgFolder> msgFolder = do_QueryInterface(res);
+  NS_ENSURE_TRUE(msgFolder, NS_ERROR_FAILURE);
+
+  msgFolder.swap(*aFolder);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::SaveMessageToDisk(const char *aMessageURI,
+                                               nsIFile *aFile,
+                                               bool aAddDummyEnvelope,
+                                               nsIUrlListener *aUrlListener,
+                                               nsIURI **aURL,
+                                               bool canonicalLineEnding,
+                                               nsIMsgWindow *aMsgWindow)
+{
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString msgKey;
+
+  nsresult rv = DecomposeImapURI(nsDependentCString(aMessageURI),
+                                 getter_AddRefs(folder), msgKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool hasMsgOffline = false;
+
+  if (folder)
+    folder->HasMsgOffline(strtoul(msgKey.get(), nullptr, 10), &hasMsgOffline);
+
+  nsAutoCString urlSpec;
+  char hierarchyDelimiter = GetHierarchyDelimiter(folder);
+  rv = CreateStartOfImapUrl(nsDependentCString(aMessageURI), getter_AddRefs(imapUrl), 
+                            folder, aUrlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv)) 
+  {
+    nsCOMPtr<nsIImapMessageSink> imapMessageSink(do_QueryInterface(folder, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);  
+    nsCOMPtr<nsIMsgMessageUrl> msgUrl = do_QueryInterface(imapUrl, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    msgUrl->SetMessageFile(aFile);
+    msgUrl->SetAddDummyEnvelope(aAddDummyEnvelope);
+    msgUrl->SetCanonicalLineEnding(canonicalLineEnding);
+
+    nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(msgUrl);
+    if (mailnewsUrl)
+      mailnewsUrl->SetMsgIsInLocalCache(hasMsgOffline);
+
+    nsCOMPtr <nsIStreamListener> saveAsListener;
+    mailnewsUrl->GetSaveAsListener(aAddDummyEnvelope, aFile, getter_AddRefs(saveAsListener));
+
+    return FetchMessage(imapUrl, nsIImapUrl::nsImapSaveMessageToDisk, folder, imapMessageSink, 
+                        aMsgWindow, saveAsListener, msgKey, false, EmptyCString(), aURL);
+  }
+  return rv;
+}
+
+/* fetching RFC822 messages */
+/* imap4://HOST>fetch><UID>>MAILBOXPATH>x */
+/*   'x' is the message UID */
+/* will set the 'SEEN' flag */
+NS_IMETHODIMP nsImapService::AddImapFetchToUrl(nsIURI *aUrl,
+                                               nsIMsgFolder *aImapMailFolder,
+                                               const nsACString &aMessageIdentifierList,
+                                               const nsACString &aAdditionalHeader)
+{
+  NS_ENSURE_ARG_POINTER(aUrl);
+
+  nsAutoCString urlSpec;
+  nsresult rv = aUrl->GetSpec(urlSpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+
+  urlSpec.Append("fetch>UID>");
+  urlSpec.Append(hierarchyDelimiter);
+
+  nsAutoCString folderName;
+  GetFolderName(aImapMailFolder, folderName);
+  urlSpec.Append(folderName);
+
+  urlSpec.Append(">");
+  urlSpec.Append(aMessageIdentifierList);
+
+  if (!aAdditionalHeader.IsEmpty())
+  {
+    urlSpec.Append("?header=");
+    urlSpec.Append(aAdditionalHeader);
+  }
+
+  return aUrl->SetSpec(urlSpec);
+}
+
+NS_IMETHODIMP nsImapService::FetchMessage(nsIImapUrl *aImapUrl,
+                                          nsImapAction aImapAction,
+                                          nsIMsgFolder *aImapMailFolder, 
+                                          nsIImapMessageSink *aImapMessage,
+                                          nsIMsgWindow *aMsgWindow,
+                                          nsISupports *aDisplayConsumer, 
+                                          const nsACString &messageIdentifierList,
+                                          bool aConvertDataToText,
+                                          const nsACString &aAdditionalHeader,
+                                          nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapUrl);
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+  NS_ENSURE_ARG_POINTER(aImapMessage);
+
+  nsresult rv;
+  nsCOMPtr<nsIURI> url = do_QueryInterface(aImapUrl);
+
+  rv = AddImapFetchToUrl(url, aImapMailFolder, messageIdentifierList, aAdditionalHeader);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (WeAreOffline())
+  {
+    bool msgIsInCache = false;
+    nsCOMPtr<nsIMsgMailNewsUrl> msgUrl(do_QueryInterface(aImapUrl));
+    msgUrl->GetMsgIsInLocalCache(&msgIsInCache);
+    if (!msgIsInCache)
+      IsMsgInMemCache(url, aImapMailFolder, &msgIsInCache);
+
+    // Display the "offline" message if we didn't find it in the memory cache either
+    if (!msgIsInCache)
+    {
+      nsCOMPtr<nsIMsgIncomingServer> server;
+      rv = aImapMailFolder->GetServer(getter_AddRefs(server));
+      if (server && aDisplayConsumer)
+        rv = server->DisplayOfflineMsg(aMsgWindow);
+      return rv;
+    }
+  }
+
+  if (aURL)
+    NS_IF_ADDREF(*aURL = url);
+
+  return GetMessageFromUrl(aImapUrl, aImapAction, aImapMailFolder, aImapMessage,
+                           aMsgWindow, aDisplayConsumer, aConvertDataToText, aURL);
+}
+
+nsresult nsImapService::GetMessageFromUrl(nsIImapUrl *aImapUrl,
+                                          nsImapAction aImapAction,
+                                          nsIMsgFolder *aImapMailFolder,
+                                          nsIImapMessageSink *aImapMessage,
+                                          nsIMsgWindow *aMsgWindow,
+                                          nsISupports *aDisplayConsumer,
+                                          bool aConvertDataToText,
+                                          nsIURI **aURL)
+{
+  nsresult rv = SetImapUrlSink(aImapMailFolder, aImapUrl);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = aImapUrl->SetImapMessageSink(aImapMessage);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = aImapUrl->SetImapAction(aImapAction);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIURI> url(do_QueryInterface(aImapUrl));
+
+  // if the display consumer is a docshell, then we should run the url in the docshell.
+  // otherwise, it should be a stream listener....so open a channel using AsyncRead
+  // and the provided stream listener....
+  
+  nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aDisplayConsumer, &rv));
+  if (aImapMailFolder && docShell)
+  {
+    nsCOMPtr<nsIMsgIncomingServer> aMsgIncomingServer;
+    rv = aImapMailFolder->GetServer(getter_AddRefs(aMsgIncomingServer));
+    if (NS_SUCCEEDED(rv) && aMsgIncomingServer)
+    {
+      bool interrupted;
+      nsCOMPtr<nsIImapIncomingServer>
+        aImapServer(do_QueryInterface(aMsgIncomingServer, &rv));
+      if (NS_SUCCEEDED(rv) && aImapServer)
+        aImapServer->PseudoInterruptMsgLoad(aImapMailFolder, aMsgWindow, &interrupted);
+    }
+  }
+  if (NS_SUCCEEDED(rv) && docShell)
+  {
+    NS_ASSERTION(!aConvertDataToText, "can't convert to text when using docshell");
+    rv = docShell->LoadURI(url, nullptr, nsIWebNavigation::LOAD_FLAGS_NONE, false);
+  }
+  else
+  {
+    nsCOMPtr<nsIStreamListener> streamListener = do_QueryInterface(aDisplayConsumer, &rv);
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(aImapUrl, &rv);
+    if (aMsgWindow && mailnewsUrl)
+      mailnewsUrl->SetMsgWindow(aMsgWindow);
+    if (NS_SUCCEEDED(rv) && streamListener)
+    {
+      nsCOMPtr<nsIChannel> channel;
+      nsCOMPtr<nsILoadGroup> loadGroup;
+      if (NS_SUCCEEDED(rv) && mailnewsUrl)
+        mailnewsUrl->GetLoadGroup(getter_AddRefs(loadGroup));
+      
+      rv = NewChannel(url, getter_AddRefs(channel));
+      NS_ENSURE_SUCCESS(rv, rv);
+      
+      // we need a load group to hold onto the channel. When the request is finished,
+      // it'll get removed from the load group, and the channel will go away,
+      // which will free the load group.
+      if (!loadGroup)
+        loadGroup = do_CreateInstance(NS_LOADGROUP_CONTRACTID);
+
+      rv = channel->SetLoadGroup(loadGroup);
+      NS_ENSURE_SUCCESS(rv, rv);
+      
+      if (aConvertDataToText)
+      {
+        nsCOMPtr<nsIStreamListener> conversionListener;
+        nsCOMPtr<nsIStreamConverterService> streamConverter = do_GetService("@mozilla.org/streamConverters;1", &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv = streamConverter->AsyncConvertData("message/rfc822",
+                                               "*/*", streamListener, channel, getter_AddRefs(conversionListener));
+        NS_ENSURE_SUCCESS(rv, rv);
+        streamListener = conversionListener; // this is our new listener.
+      }
+
+      nsCOMPtr<nsISupports> aCtxt = do_QueryInterface(url);
+      //  now try to open the channel passing in our display consumer as the listener 
+      rv = channel->AsyncOpen(streamListener, aCtxt);
+    }
+    else // do what we used to do before
+    {
+      // I'd like to get rid of this code as I believe that we always get a docshell
+      // or stream listener passed into us in this method but i'm not sure yet...
+      // I'm going to use an assert for now to figure out if this is ever getting called
+#if defined(DEBUG_mscott) || defined(DEBUG_bienvenu)
+      NS_ERROR("oops...someone still is reaching this part of the code");
+#endif
+      rv = GetImapConnectionAndLoadUrl(aImapUrl,
+                                       aDisplayConsumer, aURL);
+    }
+  }
+  return rv;
+}
+
+// this method streams a message to the passed in consumer, with an optional stream converter
+// and additional header (e.g., "header=filter")
+NS_IMETHODIMP nsImapService::StreamMessage(const char *aMessageURI, 
+                                           nsISupports *aConsumer, 
+                                           nsIMsgWindow *aMsgWindow,
+                                           nsIUrlListener *aUrlListener, 
+                                           bool aConvertData,
+                                           const nsACString &aAdditionalHeader,
+                                           bool aLocalOnly,
+                                           nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aMessageURI);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsAutoCString msgKey;
+  nsAutoCString mimePart;
+  nsAutoCString folderURI;
+  nsMsgKey key;
+
+  nsresult rv = DecomposeImapURI(nsDependentCString(aMessageURI), getter_AddRefs(folder), msgKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (msgKey.IsEmpty())
+    return NS_MSG_MESSAGE_NOT_FOUND;
+  rv = nsParseImapMessageURI(aMessageURI, folderURI, &key, getter_Copies(mimePart));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIImapMessageSink> imapMessageSink(do_QueryInterface(folder, &rv));
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIImapUrl> imapUrl;
+      nsAutoCString urlSpec;
+      char hierarchyDelimiter = GetHierarchyDelimiter(folder);
+      rv = CreateStartOfImapUrl(nsDependentCString(aMessageURI), getter_AddRefs(imapUrl), 
+                                folder, aUrlListener, urlSpec, hierarchyDelimiter);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCOMPtr<nsIMsgMailNewsUrl> msgurl (do_QueryInterface(imapUrl));
+      nsCOMPtr<nsIURI> url(do_QueryInterface(imapUrl));
+
+      // This option is used by the JS Mime Emitter, in case we want a cheap
+      // streaming, for example, if we just want a quick look at some header,
+      // without having to download all the attachments...
+
+      uint32_t messageSize = 0;
+      imapMessageSink->GetMessageSizeFromDB(msgKey.get(), &messageSize);
+      nsAutoCString additionalHeader(aAdditionalHeader);
+      bool fetchOnDemand =
+        additionalHeader.Find("&fetchCompleteMessage=false") != kNotFound &&
+          messageSize > (uint32_t) gMIMEOnDemandThreshold;
+      imapUrl->SetFetchPartsOnDemand(fetchOnDemand);
+
+      // We need to add the fetch command here for the cache lookup to behave correctly
+      rv = AddImapFetchToUrl(url, folder, msgKey, additionalHeader);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIMsgIncomingServer> aMsgIncomingServer;
+
+      msgurl->SetMsgWindow(aMsgWindow);
+      rv = msgurl->GetServer(getter_AddRefs(aMsgIncomingServer));
+
+      // Try to check if the message is offline
+      bool hasMsgOffline = false;
+      folder->HasMsgOffline(key, &hasMsgOffline);
+      msgurl->SetMsgIsInLocalCache(hasMsgOffline);
+      imapUrl->SetLocalFetchOnly(aLocalOnly);
+
+      // If we don't have the message available locally, and we can't get it over
+      // the network, return with an error
+      if (aLocalOnly || WeAreOffline())
+      {
+        bool isMsgInMemCache = false;
+        if (!hasMsgOffline)
+        {
+          rv = IsMsgInMemCache(url, folder, &isMsgInMemCache);
+          NS_ENSURE_SUCCESS(rv, rv);
+
+          if (!isMsgInMemCache)
+            return NS_ERROR_FAILURE;
+        }
+      }
+
+      bool shouldStoreMsgOffline = false;
+      folder->ShouldStoreMsgOffline(key, &shouldStoreMsgOffline);
+      imapUrl->SetStoreResultsOffline(shouldStoreMsgOffline);
+      rv = GetMessageFromUrl(imapUrl, nsIImapUrl::nsImapMsgFetchPeek, folder,
+                             imapMessageSink, aMsgWindow, aConsumer,
+                             aConvertData, aURL);
+    }
+  }
+  return rv;
+}
+
+// this method streams a message's headers to the passed in consumer.
+NS_IMETHODIMP nsImapService::StreamHeaders(const char *aMessageURI,
+                                           nsIStreamListener *aConsumer,
+                                           nsIUrlListener *aUrlListener,
+                                           bool aLocalOnly,
+                                           nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aMessageURI);
+  NS_ENSURE_ARG_POINTER(aConsumer);
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsAutoCString msgKey;
+  nsAutoCString folderURI;
+  nsCString mimePart;
+  nsMsgKey key;
+
+  nsresult rv = DecomposeImapURI(nsDependentCString(aMessageURI), getter_AddRefs(folder), msgKey);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (msgKey.IsEmpty())
+    return NS_MSG_MESSAGE_NOT_FOUND;
+  rv = nsParseImapMessageURI(aMessageURI, folderURI, &key, getter_Copies(mimePart));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIInputStream> inputStream;
+    bool hasMsgOffline = false;
+    folder->HasMsgOffline(key, &hasMsgOffline);
+    if (hasMsgOffline)
+    {
+      int64_t messageOffset;
+      uint32_t messageSize;
+      folder->GetOfflineFileStream(key, &messageOffset, &messageSize, getter_AddRefs(inputStream));
+      if (inputStream)
+        return MsgStreamMsgHeaders(inputStream, aConsumer);
+    }
+  }
+
+  if (aLocalOnly)
+    return NS_ERROR_FAILURE;
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::IsMsgInMemCache(nsIURI *aUrl,
+                                             nsIMsgFolder *aImapMailFolder,
+                                             bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aUrl);
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+  *aResult = false;
+
+  // Poke around in the memory cache
+  if (mCacheStorage)
+  {
+    nsAutoCString urlSpec;
+    aUrl->GetSpec(urlSpec);
+
+    // Strip any query qualifiers.
+    bool truncated = false;
+    int32_t ind = urlSpec.FindChar('?');
+    if (ind != kNotFound) {
+      urlSpec.SetLength(ind);
+      truncated = true;
+    }
+    ind = urlSpec.Find("/;");
+    if (ind != kNotFound) {
+      urlSpec.SetLength(ind);
+      truncated = true;
+    }
+
+    nsresult rv;
+    nsCOMPtr<nsIImapMailFolderSink> folderSink(do_QueryInterface(aImapMailFolder, &rv));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    int32_t uidValidity = -1;
+    folderSink->GetUidValidity(&uidValidity);
+    // stick the uid validity in front of the url, so that if the uid validity
+    // changes, we won't re-use the wrong cache entries.
+    nsAutoCString extension;
+    extension.AppendInt(uidValidity, 16);
+
+    bool exists;
+    if (truncated) {
+      nsCOMPtr<nsIURI> newUri;
+      aUrl->Clone(getter_AddRefs(newUri));
+      newUri->SetSpec(urlSpec);
+      rv = mCacheStorage->Exists(newUri, extension, &exists);
+    } else {
+      rv = mCacheStorage->Exists(aUrl, extension, &exists);
+    }
+    if (NS_SUCCEEDED(rv) && exists) {
+      *aResult = true;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsImapService::CreateStartOfImapUrl(const nsACString &aImapURI, 
+                                             nsIImapUrl **imapUrl,
+                                             nsIMsgFolder *aImapMailFolder,
+                                             nsIUrlListener *aUrlListener,
+                                             nsACString &urlSpec, 
+                                             char &hierarchyDelimiter)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  nsCString hostname;
+  nsCString username;
+  nsCString escapedUsername;
+
+  nsresult rv = aImapMailFolder->GetHostname(hostname);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = aImapMailFolder->GetUsername(username);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!username.IsEmpty())
+    MsgEscapeString(username, nsINetUtil::ESCAPE_XALPHAS, escapedUsername);
+
+  int32_t port = nsIImapUrl::DEFAULT_IMAP_PORT;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = aImapMailFolder->GetServer(getter_AddRefs(server));
+  if (NS_SUCCEEDED(rv)) 
+  {
+    server->GetPort(&port);
+    if (port == -1 || port == 0) port = nsIImapUrl::DEFAULT_IMAP_PORT;
+  }
+
+  // now we need to create an imap url to load into the connection. The url
+  // needs to represent a select folder action. 
+  rv = CallCreateInstance(kImapUrlCID, imapUrl);
+  if (NS_SUCCEEDED(rv) && *imapUrl)
+  {
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(*imapUrl, &rv);
+    if (NS_SUCCEEDED(rv) && mailnewsUrl && aUrlListener)
+      mailnewsUrl->RegisterListener(aUrlListener);
+    nsCOMPtr<nsIMsgMessageUrl> msgurl(do_QueryInterface(*imapUrl));
+    (*imapUrl)->SetExternalLinkUrl(false);
+    msgurl->SetUri(PromiseFlatCString(aImapURI).get());
+
+    urlSpec = "imap://";
+    urlSpec.Append(escapedUsername);
+    urlSpec.Append('@');
+    urlSpec.Append(hostname);
+    urlSpec.Append(':');
+
+    nsAutoCString portStr;
+    portStr.AppendInt(port);
+    urlSpec.Append(portStr);
+
+    // *** jefft - force to parse the urlSpec in order to search for
+    // the correct incoming server
+    rv = mailnewsUrl->SetSpec(urlSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    hierarchyDelimiter = kOnlineHierarchySeparatorUnknown;
+    nsCOMPtr <nsIMsgImapMailFolder> imapFolder = do_QueryInterface(aImapMailFolder);
+    if (imapFolder)
+      imapFolder->GetHierarchyDelimiter(&hierarchyDelimiter);
+  }
+  return rv;
+}
+
+/* fetching the headers of RFC822 messages */
+/* imap4://HOST>header><UID/SEQUENCE>>MAILBOXPATH>x */
+/*   'x' is the message UID or sequence number list */
+/* will not affect the 'SEEN' flag */
+NS_IMETHODIMP nsImapService::GetHeaders(nsIMsgFolder *aImapMailFolder, 
+                                        nsIUrlListener *aUrlListener, 
+                                        nsIURI **aURL,
+                                        const nsACString &messageIdentifierList,
+                                        bool messageIdsAreUID)
+{
+  // create a protocol instance to handle the request.
+  // NOTE: once we start working with multiple connections, this step will be much more complicated...but for now
+  // just create a connection and process the request.
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+
+  nsresult rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), aImapMailFolder, 
+                                     aUrlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+
+    rv = imapUrl->SetImapAction(nsIImapUrl::nsImapMsgFetch);
+    rv = SetImapUrlSink(aImapMailFolder, imapUrl);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      urlSpec.Append("/header>");
+      urlSpec.Append(messageIdsAreUID ? uidString : sequenceString);
+      urlSpec.Append(">");
+      urlSpec.Append(char (hierarchyDelimiter));
+
+      nsCString folderName;
+
+      GetFolderName(aImapMailFolder, folderName);
+      urlSpec.Append(folderName);
+      urlSpec.Append(">");
+      urlSpec.Append(messageIdentifierList);
+      rv = uri->SetSpec(urlSpec);
+
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  }
+  return rv;
+}
+
+
+/* peeking at the start of msg bodies */
+/* imap4://HOST>header><UID>>MAILBOXPATH>x>n */
+/*   'x' is the message UID */
+/*   'n' is the number of bytes to fetch */
+/* will not affect the 'SEEN' flag */
+NS_IMETHODIMP nsImapService::GetBodyStart(nsIMsgFolder *aImapMailFolder, 
+                                          nsIUrlListener *aUrlListener, 
+                                          const nsACString &messageIdentifierList,
+                                          int32_t numBytes,
+                                          nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  nsresult rv;
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), aImapMailFolder, 
+    aUrlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    rv = imapUrl->SetImapAction(nsIImapUrl::nsImapMsgPreview);
+    rv = SetImapUrlSink(aImapMailFolder, imapUrl);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+
+      urlSpec.Append("/previewBody>");
+      urlSpec.Append(uidString);
+      urlSpec.Append(">");
+      urlSpec.Append(hierarchyDelimiter);
+
+      nsCString folderName;
+      GetFolderName(aImapMailFolder, folderName);
+      urlSpec.Append(folderName);
+      urlSpec.Append(">");
+      urlSpec.Append(messageIdentifierList);
+      urlSpec.Append(">");
+      urlSpec.AppendInt(numBytes);
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  }
+  return rv;
+}
+
+nsresult nsImapService::FolderCommand(nsIMsgFolder *imapMailFolder,
+                                      nsIUrlListener *urlListener,
+                                      const char *aCommand,
+                                      nsImapAction imapAction,
+                                      nsIMsgWindow *msgWindow,
+                                      nsIURI **url)
+{
+  NS_ENSURE_ARG_POINTER(imapMailFolder);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(imapMailFolder);
+  nsresult rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl),
+                                     imapMailFolder, urlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    rv = imapUrl->SetImapAction(imapAction);
+    rv = SetImapUrlSink(imapMailFolder, imapUrl);
+    nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl = do_QueryInterface(imapUrl);
+    if (mailnewsurl)
+      mailnewsurl->SetMsgWindow(msgWindow);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      urlSpec.Append(aCommand);
+      urlSpec.Append(hierarchyDelimiter);
+
+      nsCString folderName;
+      GetFolderName(imapMailFolder, folderName);
+      urlSpec.Append(folderName);
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, url);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapService::VerifyLogon(nsIMsgFolder *aFolder, nsIUrlListener *aUrlListener,
+                           nsIMsgWindow *aMsgWindow, nsIURI **aURL)
+{
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char delimiter = '/'; // shouldn't matter what is is.
+  nsresult rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), aFolder,
+                                     aUrlListener, urlSpec, delimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+
+    nsCOMPtr<nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(imapUrl);
+    mailNewsUrl->SetSuppressErrorMsgs(true);
+    mailNewsUrl->SetMsgWindow(aMsgWindow);
+    rv = SetImapUrlSink(aFolder, imapUrl);
+    urlSpec.Append("/verifyLogon");
+    rv = uri->SetSpec(urlSpec);
+    if (NS_SUCCEEDED(rv))
+      rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, nullptr);
+    if (aURL)
+      uri.forget(aURL);
+  }
+  return rv;
+}
+
+// Noop, used to update a folder (causes server to send changes).
+NS_IMETHODIMP nsImapService::Noop(nsIMsgFolder *aImapMailFolder,
+                                  nsIUrlListener *aUrlListener, 
+                                  nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return FolderCommand(aImapMailFolder, aUrlListener,
+                       "/selectnoop>", nsIImapUrl::nsImapSelectNoopFolder, nullptr, aURL);
+}
+    
+// FolderStatus, used to update message counts
+NS_IMETHODIMP nsImapService::UpdateFolderStatus(nsIMsgFolder *aImapMailFolder,
+                                                nsIUrlListener *aUrlListener, 
+                                                nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return FolderCommand(aImapMailFolder, aUrlListener,
+                       "/folderstatus>", nsIImapUrl::nsImapFolderStatus, nullptr, aURL);
+}
+
+// Expunge, used to "compress" an imap folder,removes deleted messages.
+NS_IMETHODIMP nsImapService::Expunge(nsIMsgFolder *aImapMailFolder,
+                                     nsIUrlListener *aUrlListener,
+                                     nsIMsgWindow *aMsgWindow,
+                                     nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return FolderCommand(aImapMailFolder, aUrlListener,
+                       "/Expunge>", nsIImapUrl::nsImapExpungeFolder, aMsgWindow, aURL);
+}
+
+/* old-stle biff that doesn't download headers */
+NS_IMETHODIMP nsImapService::Biff(nsIMsgFolder *aImapMailFolder,
+                                  nsIUrlListener *aUrlListener, 
+                                  nsIURI **aURL,
+                                  uint32_t uidHighWater)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  // static const char *formatString = "biff>%c%s>%ld";
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+  nsresult rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl),
+    aImapMailFolder, aUrlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    rv = imapUrl->SetImapAction(nsIImapUrl::nsImapExpungeFolder);
+    rv = SetImapUrlSink(aImapMailFolder, imapUrl);
+
+    nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+    if (NS_SUCCEEDED(rv))
+    {
+      urlSpec.Append("/Biff>");
+      urlSpec.Append(hierarchyDelimiter);
+
+      nsCString folderName;
+      GetFolderName(aImapMailFolder, folderName);
+      urlSpec.Append(folderName);
+      urlSpec.Append(">");
+      urlSpec.AppendInt(uidHighWater);
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::DeleteFolder(nsIMsgFolder *aImapMailFolder,
+                                          nsIUrlListener *aUrlListener,
+                                          nsIMsgWindow *aMsgWindow,
+                                          nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  // If it's an aol server then use 'deletefolder' url to 
+  // remove all msgs first and then remove the folder itself.
+  bool removeFolderAndMsgs = false;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  if (NS_SUCCEEDED(aImapMailFolder->GetServer(getter_AddRefs(server))) && server)
+  {
+    nsCOMPtr <nsIImapIncomingServer> imapServer = do_QueryInterface(server);
+    if (imapServer) 
+      imapServer->GetIsAOLServer(&removeFolderAndMsgs);
+  }
+  
+  return FolderCommand(aImapMailFolder, aUrlListener,
+                       removeFolderAndMsgs ? "/deletefolder>" : "/delete>", 
+                       nsIImapUrl::nsImapDeleteFolder, aMsgWindow, aURL);
+}
+
+NS_IMETHODIMP nsImapService::DeleteMessages(nsIMsgFolder *aImapMailFolder, 
+                                            nsIUrlListener *aUrlListener, 
+                                            nsIURI **aURL,
+                                            const nsACString &messageIdentifierList,
+                                            bool messageIdsAreUID)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  // create a protocol instance to handle the request.
+  // NOTE: once we start working with multiple connections, this step will be much more complicated...but for now
+  // just create a connection and process the request.
+  nsresult rv;
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), aImapMailFolder, 
+    aUrlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    rv = imapUrl->SetImapAction(nsIImapUrl::nsImapMsgFetch);
+    rv = SetImapUrlSink(aImapMailFolder, imapUrl);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+
+      urlSpec.Append("/deletemsg>");
+      urlSpec.Append(messageIdsAreUID ? uidString : sequenceString);
+      urlSpec.Append(">");
+      urlSpec.Append(hierarchyDelimiter);
+
+      nsCString folderName;
+      GetFolderName(aImapMailFolder, folderName);
+      urlSpec.Append(folderName);
+      urlSpec.Append(">");
+      urlSpec.Append(messageIdentifierList);
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  }
+  return rv;
+}
+
+// Delete all messages in a folder, used to empty trash
+NS_IMETHODIMP nsImapService::DeleteAllMessages(nsIMsgFolder *aImapMailFolder,
+                                               nsIUrlListener *aUrlListener, 
+                                               nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return FolderCommand(aImapMailFolder, aUrlListener,
+                      "/deleteallmsgs>", nsIImapUrl::nsImapSelectNoopFolder, nullptr, aURL);
+}
+
+NS_IMETHODIMP nsImapService::AddMessageFlags(nsIMsgFolder *aImapMailFolder,
+                                             nsIUrlListener *aUrlListener,
+                                             nsIURI **aURL,
+                                             const nsACString &messageIdentifierList,
+                                             imapMessageFlagsType flags,
+                                             bool messageIdsAreUID)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return DiddleFlags(aImapMailFolder, aUrlListener, aURL, messageIdentifierList,
+                     "addmsgflags", flags, messageIdsAreUID);
+}
+
+NS_IMETHODIMP nsImapService::SubtractMessageFlags(nsIMsgFolder *aImapMailFolder,
+                                                  nsIUrlListener *aUrlListener,
+                                                  nsIURI **aURL,
+                                                  const nsACString &messageIdentifierList,
+                                                  imapMessageFlagsType flags,
+                                                  bool messageIdsAreUID)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return DiddleFlags(aImapMailFolder, aUrlListener, aURL, messageIdentifierList,
+                     "subtractmsgflags", flags, messageIdsAreUID);
+}
+
+NS_IMETHODIMP nsImapService::SetMessageFlags(nsIMsgFolder *aImapMailFolder,
+                                             nsIUrlListener *aUrlListener,
+                                             nsIURI **aURL,
+                                             const nsACString &messageIdentifierList,
+                                             imapMessageFlagsType flags,
+                                             bool messageIdsAreUID)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return DiddleFlags(aImapMailFolder, aUrlListener, aURL, messageIdentifierList,
+                     "setmsgflags", flags, messageIdsAreUID);
+}
+
+nsresult nsImapService::DiddleFlags(nsIMsgFolder *aImapMailFolder,
+                                    nsIUrlListener *aUrlListener,
+                                    nsIURI **aURL,
+                                    const nsACString &messageIdentifierList,
+                                    const char *howToDiddle,
+                                    imapMessageFlagsType flags,
+                                    bool messageIdsAreUID)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  // create a protocol instance to handle the request.
+  // NOTE: once we start working with multiple connections, 
+  //       this step will be much more complicated...but for now
+  // just create a connection and process the request.
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+  nsresult rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl),
+                                     aImapMailFolder, aUrlListener, urlSpec, hierarchyDelimiter); 
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    rv = imapUrl->SetImapAction(nsIImapUrl::nsImapMsgFetch);
+    rv = SetImapUrlSink(aImapMailFolder, imapUrl);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+
+      urlSpec.Append('/');
+      urlSpec.Append(howToDiddle);
+      urlSpec.Append('>');
+      urlSpec.Append(messageIdsAreUID ? uidString : sequenceString);
+      urlSpec.Append(">");
+      urlSpec.Append(hierarchyDelimiter);
+      nsCString folderName;
+      GetFolderName(aImapMailFolder, folderName);
+      urlSpec.Append(folderName);
+      urlSpec.Append(">");
+      urlSpec.Append(messageIdentifierList);
+      urlSpec.Append('>');
+      urlSpec.AppendInt(flags);
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  }
+  return rv;
+}
+
+nsresult nsImapService::SetImapUrlSink(nsIMsgFolder *aMsgFolder, nsIImapUrl *aImapUrl)
+{
+  NS_ENSURE_ARG_POINTER(aMsgFolder);
+  NS_ENSURE_ARG_POINTER(aImapUrl);
+  
+  nsresult rv;
+  nsCOMPtr<nsIMsgIncomingServer> incomingServer;
+  nsCOMPtr<nsIImapServerSink> imapServerSink;
+    
+  rv = aMsgFolder->GetServer(getter_AddRefs(incomingServer));
+  if (NS_SUCCEEDED(rv) && incomingServer)
+  {
+    imapServerSink = do_QueryInterface(incomingServer);
+    if (imapServerSink)
+      aImapUrl->SetImapServerSink(imapServerSink);
+  }
+   
+  nsCOMPtr<nsIImapMailFolderSink> imapMailFolderSink = do_QueryInterface(aMsgFolder);
+  if (NS_SUCCEEDED(rv) && imapMailFolderSink)
+    aImapUrl->SetImapMailFolderSink(imapMailFolderSink);
+  
+  nsCOMPtr<nsIImapMessageSink> imapMessageSink = do_QueryInterface(aMsgFolder);
+  if (NS_SUCCEEDED(rv) && imapMessageSink)
+    aImapUrl->SetImapMessageSink(imapMessageSink);
+  
+  nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(aImapUrl);
+  mailnewsUrl->SetFolder(aMsgFolder);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::DiscoverAllFolders(nsIMsgFolder *aImapMailFolder,
+                                                nsIUrlListener *aUrlListener,
+                                                nsIMsgWindow *aMsgWindow,
+                                                nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+  nsresult rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), aImapMailFolder, 
+                                     aUrlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED (rv))
+  {
+    rv = SetImapUrlSink(aImapMailFolder, imapUrl);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+      nsCOMPtr<nsIMsgMailNewsUrl> mailnewsurl = do_QueryInterface(imapUrl);
+      if (mailnewsurl)
+        mailnewsurl->SetMsgWindow(aMsgWindow);
+      urlSpec.Append("/discoverallboxes");
+      nsCOMPtr <nsIURI> url = do_QueryInterface(imapUrl, &rv);
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::DiscoverAllAndSubscribedFolders(nsIMsgFolder *aImapMailFolder,
+                                                             nsIUrlListener *aUrlListener,
+                                                             nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  nsCOMPtr<nsIImapUrl> aImapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+  nsresult rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(aImapUrl), aImapMailFolder,
+                                     aUrlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && aImapUrl)
+  {
+    rv = SetImapUrlSink(aImapMailFolder, aImapUrl);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(aImapUrl);
+      urlSpec.Append("/discoverallandsubscribedboxes");
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(aImapUrl, nullptr, aURL);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::DiscoverChildren(nsIMsgFolder *aImapMailFolder,
+                                              nsIUrlListener *aUrlListener,
+                                              const nsACString &folderPath,
+                                              nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  nsCOMPtr<nsIImapUrl> aImapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aImapMailFolder);
+  nsresult rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(aImapUrl), aImapMailFolder, 
+                                     aUrlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED (rv))
+  {
+    rv = SetImapUrlSink(aImapMailFolder, aImapUrl);
+    if (NS_SUCCEEDED(rv))
+    {
+      if (!folderPath.IsEmpty())
+      {
+        nsCOMPtr<nsIURI> uri = do_QueryInterface(aImapUrl);
+        urlSpec.Append("/discoverchildren>");
+        urlSpec.Append(hierarchyDelimiter);
+        urlSpec.Append(folderPath);
+        rv = uri->SetSpec(urlSpec);
+
+        // Make sure the uri has the same hierarchy separator as the one in msg folder 
+        // obj if it's not kOnlineHierarchySeparatorUnknown (ie, '^').
+        char uriDelimiter;
+        nsresult rv1 = aImapUrl->GetOnlineSubDirSeparator(&uriDelimiter);
+        if (NS_SUCCEEDED (rv1) && hierarchyDelimiter != kOnlineHierarchySeparatorUnknown &&
+            uriDelimiter != hierarchyDelimiter)
+          aImapUrl->SetOnlineSubDirSeparator(hierarchyDelimiter);
+
+        if (NS_SUCCEEDED(rv))
+          rv = GetImapConnectionAndLoadUrl(aImapUrl, nullptr, aURL);
+      }
+      else
+        rv = NS_ERROR_FAILURE;
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::OnlineMessageCopy(nsIMsgFolder *aSrcFolder,
+                                               const nsACString &messageIds,
+                                               nsIMsgFolder *aDstFolder,
+                                               bool idsAreUids,
+                                               bool isMove,
+                                               nsIUrlListener *aUrlListener,
+                                               nsIURI **aURL,
+                                               nsISupports *copyState,
+                                               nsIMsgWindow *aMsgWindow)
+{
+  NS_ENSURE_ARG_POINTER(aSrcFolder);
+  NS_ENSURE_ARG_POINTER(aDstFolder);
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgIncomingServer> srcServer;
+  nsCOMPtr<nsIMsgIncomingServer> dstServer;
+
+  rv = aSrcFolder->GetServer(getter_AddRefs(srcServer));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = aDstFolder->GetServer(getter_AddRefs(dstServer));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool sameServer;
+  rv = dstServer->Equals(srcServer, &sameServer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!sameServer) 
+  {
+    NS_ASSERTION(false, "can't use this method to copy across servers");
+    // *** can only take message from the same imap host and user accnt
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aSrcFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), aSrcFolder, aUrlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv))
+  {
+    SetImapUrlSink(aSrcFolder, imapUrl);
+    imapUrl->SetCopyState(copyState);
+
+    nsCOMPtr<nsIMsgMailNewsUrl> msgurl (do_QueryInterface(imapUrl));
+
+    msgurl->SetMsgWindow(aMsgWindow);
+    nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+
+    if (isMove)
+      urlSpec.Append("/onlinemove>");
+    else
+      urlSpec.Append("/onlinecopy>");
+    if (idsAreUids)
+      urlSpec.Append(uidString);
+    else
+      urlSpec.Append(sequenceString);
+    urlSpec.Append('>');
+    urlSpec.Append(hierarchyDelimiter);
+
+    nsCString folderName;
+    GetFolderName(aSrcFolder, folderName);
+    urlSpec.Append(folderName);
+    urlSpec.Append('>');
+    urlSpec.Append(messageIds);
+    urlSpec.Append('>');
+    urlSpec.Append(hierarchyDelimiter);
+    folderName.Adopt(strdup(""));
+    GetFolderName(aDstFolder, folderName);
+    urlSpec.Append(folderName);
+
+    rv = uri->SetSpec(urlSpec);
+    if (NS_SUCCEEDED(rv))
+      rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+  }
+  return rv;
+}
+
+nsresult nsImapService::OfflineAppendFromFile(nsIFile *aFile,
+                                              nsIURI *aUrl,
+                                              nsIMsgFolder* aDstFolder,
+                                              const nsACString &messageId,  // to be replaced
+                                              bool inSelectedState, // needs to be in
+                                              nsIUrlListener *aListener,
+                                              nsIURI **aURL,
+                                              nsISupports *aCopyState)
+{
+  nsCOMPtr<nsIMsgDatabase> destDB;
+  nsresult rv = aDstFolder->GetMsgDatabase(getter_AddRefs(destDB));
+  // ### might need to send some notifications instead of just returning
+
+  bool isLocked;
+  aDstFolder->GetLocked(&isLocked);
+  if (isLocked)
+    return NS_MSG_FOLDER_BUSY;
+
+  if (NS_SUCCEEDED(rv) && destDB)
+  {
+    nsMsgKey fakeKey;
+    destDB->GetNextFakeOfflineMsgKey(&fakeKey);
+
+    nsCOMPtr <nsIMsgOfflineImapOperation> op;
+    rv = destDB->GetOfflineOpForKey(fakeKey, true, getter_AddRefs(op));
+    if (NS_SUCCEEDED(rv) && op)
+    {
+      nsCString destFolderUri;
+      aDstFolder->GetURI(destFolderUri);
+      op->SetOperation(nsIMsgOfflineImapOperation::kAppendDraft); // ### do we care if it's a template?
+      op->SetDestinationFolderURI(destFolderUri.get());
+      nsCOMPtr <nsIOutputStream> offlineStore;
+      nsCOMPtr<nsIMsgPluggableStore> msgStore;
+      nsCOMPtr<nsIMsgIncomingServer> dstServer;
+      nsCOMPtr<nsIMsgDBHdr> newMsgHdr;
+
+      aDstFolder->GetServer(getter_AddRefs(dstServer));
+      rv = dstServer->GetMsgStore(getter_AddRefs(msgStore));
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = destDB->CreateNewHdr(fakeKey, getter_AddRefs(newMsgHdr));
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = aDstFolder->GetOfflineStoreOutputStream(newMsgHdr, getter_AddRefs(offlineStore));
+
+      if (NS_SUCCEEDED(rv) && offlineStore)
+      {
+        int64_t curOfflineStorePos = 0;
+        nsCOMPtr <nsISeekableStream> seekable = do_QueryInterface(offlineStore);
+        if (seekable)
+          seekable->Tell(&curOfflineStorePos);
+        else
+        {
+          NS_ERROR("needs to be a random store!");
+          return NS_ERROR_FAILURE;
+        }
+
+        nsCOMPtr <nsIInputStream> inputStream;
+        nsCOMPtr <nsIMsgParseMailMsgState> msgParser = do_CreateInstance(NS_PARSEMAILMSGSTATE_CONTRACTID, &rv);
+        msgParser->SetMailDB(destDB);
+
+        rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), aFile);
+        if (NS_SUCCEEDED(rv) && inputStream)
+        {
+          // now, copy the temp file to the offline store for the dest folder.
+          nsMsgLineStreamBuffer *inputStreamBuffer = new nsMsgLineStreamBuffer(FILE_IO_BUFFER_SIZE,
+                                                                               true,    // allocate new lines
+                                                                               false);  // leave CRLFs on the returned string
+          int64_t fileSize;
+          aFile->GetFileSize(&fileSize);
+          uint32_t bytesWritten;
+          rv = NS_OK;
+//        rv = inputStream->Read(inputBuffer, inputBufferSize, &bytesRead);
+//        if (NS_SUCCEEDED(rv) && bytesRead > 0)
+          msgParser->SetState(nsIMsgParseMailMsgState::ParseHeadersState);
+          msgParser->SetNewMsgHdr(newMsgHdr);
+          // set the new key to fake key so the msg hdr will have that for a key
+          msgParser->SetNewKey(fakeKey);
+          bool needMoreData = false;
+          char * newLine = nullptr;
+          uint32_t numBytesInLine = 0;
+          do
+          {
+            newLine = inputStreamBuffer->ReadNextLine(inputStream, numBytesInLine, needMoreData); 
+            if (newLine)
+            {
+              msgParser->ParseAFolderLine(newLine, numBytesInLine);
+              rv = offlineStore->Write(newLine, numBytesInLine, &bytesWritten);
+              NS_Free(newLine);
+            }
+          } while (newLine);
+          msgParser->FinishHeader();
+
+          nsCOMPtr<nsIMsgDBHdr> fakeHdr;
+          msgParser->GetNewMsgHdr(getter_AddRefs(fakeHdr));
+          if (fakeHdr)
+          {
+            if (NS_SUCCEEDED(rv) && fakeHdr)
+            {
+              uint32_t resultFlags;
+              fakeHdr->SetMessageOffset(curOfflineStorePos);
+              fakeHdr->OrFlags(nsMsgMessageFlags::Offline | nsMsgMessageFlags::Read, &resultFlags);
+              fakeHdr->SetOfflineMessageSize(fileSize);
+              destDB->AddNewHdrToDB(fakeHdr, true /* notify */);
+              aDstFolder->SetFlag(nsMsgFolderFlags::OfflineEvents);
+              if (msgStore)
+                msgStore->FinishNewMessage(offlineStore, fakeHdr);
+            }
+          }
+          // tell the listener we're done.
+          inputStream->Close();
+          inputStream = nullptr;
+          aListener->OnStopRunningUrl(aUrl, NS_OK);
+          delete inputStreamBuffer;
+        }
+        offlineStore->Close();
+      }
+    }
+  }
+          
+  if (destDB)
+    destDB->Close(true);
+  return rv;
+}
+
+/* append message from file url */
+/* imap://HOST>appendmsgfromfile>DESTINATIONMAILBOXPATH */
+/* imap://HOST>appenddraftfromfile>DESTINATIONMAILBOXPATH>UID>messageId */
+NS_IMETHODIMP nsImapService::AppendMessageFromFile(nsIFile *aFile,
+                                                   nsIMsgFolder *aDstFolder,
+                                                   const nsACString &messageId,  // to be replaced
+                                                   bool idsAreUids,
+                                                   bool inSelectedState,       // needs to be in
+                                                   nsIUrlListener *aListener,
+                                                   nsIURI **aURL,
+                                                   nsISupports *aCopyState,
+                                                   nsIMsgWindow *aMsgWindow)
+{
+  NS_ENSURE_ARG_POINTER(aFile);
+  NS_ENSURE_ARG_POINTER(aDstFolder);
+
+  nsresult rv;
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(aDstFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), aDstFolder, aListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIMsgMailNewsUrl> msgUrl = do_QueryInterface(imapUrl);
+    if (msgUrl && aMsgWindow)
+    {
+      // we get the loadGroup from msgWindow
+      msgUrl->SetMsgWindow(aMsgWindow);
+    }
+
+    SetImapUrlSink(aDstFolder, imapUrl);
+    imapUrl->SetMsgFile(aFile);
+    imapUrl->SetCopyState(aCopyState);
+
+    nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+
+    if (inSelectedState)
+      urlSpec.Append("/appenddraftfromfile>");
+    else
+      urlSpec.Append("/appendmsgfromfile>");
+
+    urlSpec.Append(hierarchyDelimiter);
+
+    nsCString folderName;
+    GetFolderName(aDstFolder, folderName);
+    urlSpec.Append(folderName);
+
+    if (inSelectedState)
+    {
+      urlSpec.Append('>');
+      if (idsAreUids)
+        urlSpec.Append(uidString);
+      else
+        urlSpec.Append(sequenceString);
+      urlSpec.Append('>');
+      if (!messageId.IsEmpty())
+        urlSpec.Append(messageId);
+    }
+    
+    rv = uri->SetSpec(urlSpec);
+    if (WeAreOffline())
+    {
+      // handle offline append to drafts or templates folder here.
+      return OfflineAppendFromFile(aFile, uri, aDstFolder, messageId, inSelectedState, aListener, aURL, aCopyState);
+    }
+    if (NS_SUCCEEDED(rv))
+      rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+  }
+  return rv;
+}
+
+nsresult nsImapService::GetImapConnectionAndLoadUrl(nsIImapUrl *aImapUrl,
+                                                    nsISupports *aConsumer,
+                                                    nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapUrl);
+
+  bool isValidUrl;
+  aImapUrl->GetValidUrl(&isValidUrl);
+  if (!isValidUrl)
+    return NS_ERROR_FAILURE;
+
+  if (WeAreOffline())
+  {
+    nsImapAction imapAction;
+
+    // the only thing we can do offline is fetch messages.
+    // ### TODO - need to look at msg copy, save attachment, etc. when we
+    // have offline message bodies.
+    aImapUrl->GetImapAction(&imapAction);
+    if (imapAction != nsIImapUrl::nsImapMsgFetch && imapAction != nsIImapUrl::nsImapSaveMessageToDisk)
+      return NS_MSG_ERROR_OFFLINE;
+  }
+
+  nsCOMPtr<nsIMsgIncomingServer> aMsgIncomingServer;
+  nsCOMPtr<nsIMsgMailNewsUrl> msgUrl = do_QueryInterface(aImapUrl);
+  nsresult rv = msgUrl->GetServer(getter_AddRefs(aMsgIncomingServer));
+    
+  if (aURL)
+  {
+    nsCOMPtr<nsIURI> msgUrlUri = do_QueryInterface(msgUrl);
+    msgUrlUri.swap(*aURL);
+  }
+
+  if (NS_SUCCEEDED(rv) && aMsgIncomingServer)
+  {
+    nsCOMPtr<nsIImapIncomingServer> aImapServer(do_QueryInterface(aMsgIncomingServer, &rv));
+    if (NS_SUCCEEDED(rv) && aImapServer)
+      rv = aImapServer->GetImapConnectionAndLoadUrl(aImapUrl, aConsumer);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::MoveFolder(nsIMsgFolder *srcFolder,
+                                        nsIMsgFolder *dstFolder, 
+                                        nsIUrlListener *urlListener, 
+                                        nsIMsgWindow *msgWindow, 
+                                        nsIURI **url)
+{
+  NS_ENSURE_ARG_POINTER(srcFolder);
+  NS_ENSURE_ARG_POINTER(dstFolder);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  nsresult rv;
+
+  char default_hierarchyDelimiter = GetHierarchyDelimiter(dstFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), dstFolder, 
+                            urlListener, urlSpec, default_hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    rv = SetImapUrlSink(dstFolder, imapUrl);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(imapUrl);
+      if (mailNewsUrl)
+        mailNewsUrl->SetMsgWindow(msgWindow);
+      char hierarchyDelimiter = kOnlineHierarchySeparatorUnknown;
+      nsCString folderName;
+
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+      GetFolderName(srcFolder, folderName);
+      urlSpec.Append("/movefolderhierarchy>");
+      urlSpec.Append(hierarchyDelimiter);
+      urlSpec.Append(folderName);
+      urlSpec.Append('>');
+      GetFolderName(dstFolder, folderName);
+      if (!folderName.IsEmpty())
+      {
+        urlSpec.Append(hierarchyDelimiter);
+        urlSpec.Append(folderName);
+      }
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+      {
+        GetFolderName(srcFolder, folderName);
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, url);
+      }
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::RenameLeaf(nsIMsgFolder *srcFolder,
+                                        const nsAString &newLeafName, 
+                                        nsIUrlListener *urlListener,
+                                        nsIMsgWindow *msgWindow, 
+                                        nsIURI **url)
+{
+  NS_ENSURE_ARG_POINTER(srcFolder);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(srcFolder);
+  nsresult rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), srcFolder, 
+                            urlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv))
+  {
+    rv = SetImapUrlSink(srcFolder, imapUrl);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+      nsCOMPtr<nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(imapUrl);
+      if (mailNewsUrl)
+        mailNewsUrl->SetMsgWindow(msgWindow);
+      nsCString folderName;
+      GetFolderName(srcFolder, folderName);
+      urlSpec.Append("/rename>");
+      urlSpec.Append(hierarchyDelimiter);
+      urlSpec.Append(folderName);
+      urlSpec.Append('>');
+      urlSpec.Append(hierarchyDelimiter);
+      nsAutoCString cStrFolderName;
+      // Unescape the name before looking for parent path
+      MsgUnescapeString(folderName, 0, cStrFolderName);
+      int32_t leafNameStart = cStrFolderName.RFindChar(hierarchyDelimiter);
+      if (leafNameStart != -1)
+      {
+        cStrFolderName.SetLength(leafNameStart+1);
+        urlSpec.Append(cStrFolderName);
+      }
+
+      nsAutoCString utfNewName;
+      CopyUTF16toMUTF7(PromiseFlatString(newLeafName), utfNewName);
+      nsCString escapedNewName;
+      MsgEscapeString(utfNewName, nsINetUtil::ESCAPE_URL_PATH, escapedNewName);
+      nsCString escapedSlashName;
+      rv = nsImapUrl::EscapeSlashes(escapedNewName.get(), getter_Copies(escapedSlashName));
+      NS_ENSURE_SUCCESS(rv, rv);
+      urlSpec.Append(escapedSlashName);
+
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, url);
+    } // if (NS_SUCCEEDED(rv))
+  } // if (NS_SUCCEEDED(rv) && imapUrl)
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::CreateFolder(nsIMsgFolder *parent,
+                                          const nsAString &newFolderName,
+                                          nsIUrlListener *urlListener,
+                                          nsIURI **url)
+{
+  NS_ENSURE_ARG_POINTER(parent);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  nsresult rv;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(parent);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), parent, 
+                            urlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    rv = SetImapUrlSink(parent, imapUrl);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+
+      nsCString folderName;
+      GetFolderName(parent, folderName);
+      urlSpec.Append("/create>");
+      urlSpec.Append(hierarchyDelimiter);
+      if (!folderName.IsEmpty())
+      {
+        nsCString canonicalName;
+        nsImapUrl::ConvertToCanonicalFormat(folderName.get(),
+                                            hierarchyDelimiter,
+                                            getter_Copies(canonicalName));
+        urlSpec.Append(canonicalName);
+        urlSpec.Append(hierarchyDelimiter);
+      }
+
+      nsAutoCString utfNewName;
+      rv = CopyUTF16toMUTF7(PromiseFlatString(newFolderName), utfNewName);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCString escapedFolderName;
+      MsgEscapeString(utfNewName, nsINetUtil::ESCAPE_URL_PATH, escapedFolderName);
+      urlSpec.Append(escapedFolderName);
+
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, url);
+    } // if (NS_SUCCEEDED(rv))
+  } // if (NS_SUCCEEDED(rv) && imapUrl)
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::EnsureFolderExists(nsIMsgFolder *parent,
+                                                const nsAString &newFolderName, 
+                                                nsIUrlListener *urlListener, 
+                                                nsIURI **url)
+{
+  NS_ENSURE_ARG_POINTER(parent);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  nsresult rv;
+
+  char hierarchyDelimiter = GetHierarchyDelimiter(parent);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), parent, urlListener, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    rv = SetImapUrlSink(parent, imapUrl);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+
+      nsCString folderName;
+      GetFolderName(parent, folderName);
+      urlSpec.Append("/ensureExists>");
+      urlSpec.Append(hierarchyDelimiter);
+      if (!folderName.IsEmpty())
+      {
+        urlSpec.Append(folderName);
+        urlSpec.Append(hierarchyDelimiter);
+      }
+      nsAutoCString utfNewName; 
+      CopyUTF16toMUTF7(PromiseFlatString(newFolderName), utfNewName);
+      nsCString escapedFolderName;
+      MsgEscapeString(utfNewName, nsINetUtil::ESCAPE_URL_PATH, escapedFolderName);
+      urlSpec.Append(escapedFolderName);
+
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, url);
+    } // if (NS_SUCCEEDED(rv))
+  } // if (NS_SUCCEEDED(rv) && imapUrl)
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::ListFolder(nsIMsgFolder *aImapMailFolder,
+                                        nsIUrlListener *aUrlListener,
+                                        nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return FolderCommand(aImapMailFolder, aUrlListener,
+                       "/listfolder>", nsIImapUrl::nsImapListFolder, nullptr, aURL);
+}
+
+NS_IMETHODIMP nsImapService::GetScheme(nsACString &aScheme)
+{
+  aScheme.Assign("imap");
+  return NS_OK; 
+}
+
+NS_IMETHODIMP nsImapService::GetDefaultPort(int32_t *aDefaultPort)
+{
+  NS_ENSURE_ARG_POINTER(aDefaultPort);
+  *aDefaultPort = nsIImapUrl::DEFAULT_IMAP_PORT;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetProtocolFlags(uint32_t *result)
+{
+  *result = URI_STD | URI_FORBIDS_AUTOMATIC_DOCUMENT_REPLACEMENT |
+  URI_DANGEROUS_TO_LOAD | ALLOWS_PROXY | URI_FORBIDS_COOKIE_ACCESS
+#ifdef IS_ORIGIN_IS_FULL_SPEC_DEFINED
+  | ORIGIN_IS_FULL_SPEC
+#endif
+  ;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::AllowPort(int32_t port, const char *scheme, bool *aRetVal)
+{
+  // allow imap to run on any port
+  *aRetVal = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetDefaultDoBiff(bool *aDoBiff)
+{
+  NS_ENSURE_ARG_POINTER(aDoBiff);
+  // by default, do biff for IMAP servers
+  *aDoBiff = true;    
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetDefaultServerPort(bool isSecure, int32_t *aDefaultPort)
+{
+  nsresult rv = NS_OK;
+  
+  // Return Secure IMAP Port if secure option chosen i.e., if isSecure is TRUE
+  if (isSecure)
+    *aDefaultPort = nsIImapUrl::DEFAULT_IMAPS_PORT;
+  else    
+    rv = GetDefaultPort(aDefaultPort);
+  
+  return rv;
+}
+
+// this method first tries to find an exact username and hostname match with the given url
+// then, tries to find any account on the passed in imap host in case this is a url to 
+// a shared imap folder.
+nsresult nsImapService::GetServerFromUrl(nsIImapUrl *aImapUrl, nsIMsgIncomingServer **aServer)
+{
+  nsresult rv;
+  nsCString folderName;
+  nsAutoCString userPass;
+  nsAutoCString hostName;
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(aImapUrl);
+  
+  // if we can't get a folder name out of the url then I think this is an error
+  aImapUrl->CreateCanonicalSourceFolderPathString(getter_Copies(folderName));
+  if (folderName.IsEmpty())
+  {
+    rv = mailnewsUrl->GetFileName(folderName);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  
+  nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  rv = accountManager->FindServerByURI(mailnewsUrl, false, aServer);
+  
+  // look for server with any user name, in case we're trying to subscribe
+  // to a folder with some one else's user name like the following
+  // "IMAP://userSharingFolder@server1/SharedFolderName"
+  if (NS_FAILED(rv) || !aServer)
+  {
+    nsAutoCString turl;
+    nsCOMPtr<nsIURL> url = do_CreateInstance(NS_STANDARDURL_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = mailnewsUrl->GetSpec(turl);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = url->SetSpec(turl);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    url->SetUserPass(EmptyCString());
+    rv = accountManager->FindServerByURI(url, false, aServer);
+    if (*aServer)
+      aImapUrl->SetExternalLinkUrl(true);
+  }
+  
+    // if we can't extract the imap server from this url then give up!!!
+  NS_ENSURE_TRUE(*aServer, NS_ERROR_FAILURE);
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::NewURI(const nsACString &aSpec,
+                                    const char *aOriginCharset,  // ignored
+                                    nsIURI *aBaseURI,
+                                    nsIURI **aRetVal)
+{
+  NS_ENSURE_ARG_POINTER(aRetVal);
+
+  nsresult rv;
+  nsCOMPtr<nsIImapUrl> aImapUrl = do_CreateInstance(kImapUrlCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // now extract lots of fun information...
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(aImapUrl);
+  // nsAutoCString unescapedSpec(aSpec);
+  // nsUnescape(unescapedSpec.BeginWriting());
+
+  // set the spec
+  if (aBaseURI)
+  {
+    nsAutoCString newSpec;
+    aBaseURI->Resolve(aSpec, newSpec);
+    rv = mailnewsUrl->SetSpec(newSpec);
+  }
+  else
+  {
+    rv = mailnewsUrl->SetSpec(aSpec);
+  }
+
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCString folderName;
+  // if we can't get a folder name out of the url then I think this is an error
+  aImapUrl->CreateCanonicalSourceFolderPathString(getter_Copies(folderName));
+  if (folderName.IsEmpty())
+  {
+    rv = mailnewsUrl->GetFileName(folderName);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  rv = GetServerFromUrl(aImapUrl, getter_AddRefs(server));
+  // if we can't extract the imap server from this url then give up!!!
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(server, NS_ERROR_FAILURE);
+
+  // now try to get the folder in question...
+  nsCOMPtr<nsIMsgFolder> rootFolder;
+  server->GetRootFolder(getter_AddRefs(rootFolder));
+  if (rootFolder && !folderName.IsEmpty())
+  {
+    nsCOMPtr<nsIMsgFolder> folder;
+    nsCOMPtr<nsIMsgImapMailFolder> imapRoot = do_QueryInterface(rootFolder);
+    nsCOMPtr<nsIMsgImapMailFolder> subFolder;
+    if (imapRoot)
+    {
+      imapRoot->FindOnlineSubFolder(folderName, getter_AddRefs(subFolder));
+      folder = do_QueryInterface(subFolder);
+    }
+
+    // If we can't find the folder, we can still create the URI
+    // in this low-level service. Cloning URIs where the folder
+    // isn't found is common when folders are renamed or moved.
+    // We also ignore return statuses here.
+    if (folder)
+    {
+      nsCOMPtr<nsIImapMessageSink> msgSink = do_QueryInterface(folder);
+      (void) aImapUrl->SetImapMessageSink(msgSink);
+
+      nsCOMPtr<nsIMsgFolder> msgFolder = do_QueryInterface(folder);
+      (void) SetImapUrlSink(msgFolder, aImapUrl);
+
+      nsCString messageIdString;
+      aImapUrl->GetListOfMessageIds(messageIdString);
+      if (!messageIdString.IsEmpty())
+      {
+        bool useLocalCache = false;
+        msgFolder->HasMsgOffline(strtoul(messageIdString.get(), nullptr, 10),
+                                 &useLocalCache);
+        mailnewsUrl->SetMsgIsInLocalCache(useLocalCache);
+      }
+    }
+  }
+
+  // if we are fetching a part, be sure to enable fetch parts on demand
+  bool mimePartSelectorDetected = false;
+  aImapUrl->GetMimePartSelectorDetected(&mimePartSelectorDetected);
+  if (mimePartSelectorDetected)
+    aImapUrl->SetFetchPartsOnDemand(true);
+
+  // we got an imap url, so be sure to return it...
+  nsCOMPtr<nsIURI> imapUri = do_QueryInterface(aImapUrl);
+
+  imapUri.swap(*aRetVal);
+
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::NewChannel(nsIURI *aURI, nsIChannel **aRetVal)
+{
+  return NewChannel2(aURI, nullptr, aRetVal);
+}
+
+NS_IMETHODIMP nsImapService::NewChannel2(nsIURI *aURI,
+                                         nsILoadInfo* aLoadInfo,
+                                         nsIChannel **aRetVal)
+{
+  NS_ENSURE_ARG_POINTER(aURI);
+  NS_ENSURE_ARG_POINTER(aRetVal);
+  *aRetVal = nullptr;
+
+  nsresult rv;
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(aURI, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(imapUrl, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // imap can't open and return a channel right away...the url needs to go in the imap url queue 
+  // until we find a connection which can run the url..in order to satisfy necko, we're going to return
+  // a mock imap channel....
+  nsCOMPtr<nsIImapMockChannel> channel = do_CreateInstance(kCImapMockChannel, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  channel->SetURI(aURI);
+
+  rv = channel->SetLoadInfo(aLoadInfo);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgWindow> msgWindow;
+  mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
+  if (msgWindow)
+  {
+    nsCOMPtr<nsIDocShell> msgDocShell;
+    msgWindow->GetRootDocShell(getter_AddRefs(msgDocShell));
+    if (msgDocShell) 
+    {
+      nsCOMPtr <nsIProgressEventSink> prevEventSink;
+      channel->GetProgressEventSink(getter_AddRefs(prevEventSink));
+      nsCOMPtr<nsIInterfaceRequestor> docIR(do_QueryInterface(msgDocShell));
+      channel->SetNotificationCallbacks(docIR);
+      // we want to use our existing event sink.
+      if (prevEventSink)
+        channel->SetProgressEventSink(prevEventSink);
+    }
+  }
+  imapUrl->SetMockChannel(channel); // the imap url holds a weak reference so we can pass the channel into the imap protocol when we actually run the url
+
+  bool externalLinkUrl;
+  imapUrl->GetExternalLinkUrl(&externalLinkUrl);
+  if (externalLinkUrl)
+  {
+    // everything after here is to handle clicking on an external link. We only want
+    // to do this if we didn't run the url through the various nsImapService methods,
+    // which we can tell by seeing if the sinks have been setup on the url or not.
+    nsCOMPtr <nsIMsgIncomingServer> server;
+    rv = GetServerFromUrl(imapUrl, getter_AddRefs(server));
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCString folderName;
+    imapUrl->CreateCanonicalSourceFolderPathString(getter_Copies(folderName));
+    if (folderName.IsEmpty())
+    {
+      nsCString escapedFolderName;
+      rv = mailnewsUrl->GetFileName(escapedFolderName);
+      if (!escapedFolderName.IsEmpty()) {
+        MsgUnescapeString(escapedFolderName, 0, folderName);
+      }
+    }
+    // if the parent is null, then the folder doesn't really exist, so see if the user
+    // wants to subscribe to it./
+    nsCOMPtr<nsIMsgFolder> aFolder;
+    // now try to get the folder in question...
+    nsCOMPtr<nsIMsgFolder> rootFolder;
+    server->GetRootFolder(getter_AddRefs(rootFolder));
+    nsCOMPtr <nsIMsgImapMailFolder> imapRoot = do_QueryInterface(rootFolder);
+    nsCOMPtr <nsIMsgImapMailFolder> subFolder;
+    if (imapRoot)
+    {
+      imapRoot->FindOnlineSubFolder(folderName, getter_AddRefs(subFolder));
+      aFolder = do_QueryInterface(subFolder);
+    }
+    nsCOMPtr <nsIMsgFolder> parent;
+    if (aFolder)
+      aFolder->GetParent(getter_AddRefs(parent));
+    nsCString serverKey;
+    nsAutoCString userPass;
+    rv = mailnewsUrl->GetUserPass(userPass);
+    server->GetKey(serverKey);
+    nsCString fullFolderName;
+    if (parent)
+      fullFolderName = folderName;
+    if (!parent && !folderName.IsEmpty())  // check if this folder is another user's folder
+    {
+      fullFolderName = nsIMAPNamespaceList::GenerateFullFolderNameWithDefaultNamespace(serverKey.get(), 
+                                                                                       folderName.get(),
+                                                                                       userPass.get(),
+                                                                                       kOtherUsersNamespace,
+                                                                                       nullptr);
+      // if this is another user's folder, let's see if we're already subscribed to it.
+      rv = imapRoot->FindOnlineSubFolder(fullFolderName, getter_AddRefs(subFolder));
+      aFolder = do_QueryInterface(subFolder);
+      if (aFolder)
+        aFolder->GetParent(getter_AddRefs(parent));
+    }
+    // if we couldn't get the fullFolderName, then we probably couldn't find
+    // the other user's namespace, in which case, we shouldn't try to subscribe to it.
+    if (!parent && !folderName.IsEmpty() && !fullFolderName.IsEmpty())
+    {
+      // this folder doesn't exist - check if the user wants to subscribe to this folder.
+      nsCOMPtr<nsIPrompt> dialog;
+      nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
+      NS_ENSURE_SUCCESS(rv, rv);
+      wwatch->GetNewPrompter(nullptr, getter_AddRefs(dialog));
+      
+      nsString statusString, confirmText;
+      nsCOMPtr<nsIStringBundle> bundle;
+      rv = IMAPGetStringBundle(getter_AddRefs(bundle));
+      NS_ENSURE_SUCCESS(rv, rv);
+        // need to convert folder name from mod-utf7 to unicode
+      nsAutoString unescapedName;
+      if (NS_FAILED(CopyMUTF7toUTF16(fullFolderName, unescapedName)))
+        CopyASCIItoUTF16(fullFolderName, unescapedName);
+      const char16_t *formatStrings[1] = { unescapedName.get() };
+
+      rv = bundle->FormatStringFromName(
+        u"imapSubscribePrompt",
+        formatStrings, 1, getter_Copies(confirmText));
+      NS_ENSURE_SUCCESS(rv,rv);
+
+      bool confirmResult = false;
+      rv = dialog->Confirm(nullptr, confirmText.get(), &confirmResult);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (confirmResult)
+      {
+        nsCOMPtr <nsIImapIncomingServer> imapServer = do_QueryInterface(server);
+        if (imapServer)
+        {
+          nsCOMPtr <nsIURI> subscribeURI;
+          // now we have the real folder name to try to subscribe to. Let's try running
+          // a subscribe url and returning that as the uri we've created.
+          // We need to convert this to unicode because that's what subscribe wants :-(
+          // It's already in mod-utf7.
+          nsAutoString unicodeName;
+          CopyASCIItoUTF16(fullFolderName, unicodeName);
+          rv = imapServer->SubscribeToFolder(unicodeName, true, getter_AddRefs(subscribeURI));
+          if (NS_SUCCEEDED(rv) && subscribeURI)
+          {
+            nsCOMPtr <nsIImapUrl> imapSubscribeUrl = do_QueryInterface(subscribeURI);
+            if (imapSubscribeUrl)
+              imapSubscribeUrl->SetExternalLinkUrl(true);
+            nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(subscribeURI);
+            if (mailnewsUrl)
+            {
+              nsCOMPtr<nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+              NS_ENSURE_SUCCESS(rv, rv);
+              nsCOMPtr <nsIMsgWindow> msgWindow;
+              rv = mailSession->GetTopmostMsgWindow(getter_AddRefs(msgWindow));
+              if (NS_SUCCEEDED(rv) && msgWindow)
+              {
+                mailnewsUrl->SetMsgWindow(msgWindow);
+                nsCOMPtr <nsIUrlListener> listener = do_QueryInterface(rootFolder);
+                if (listener)
+                  mailnewsUrl->RegisterListener(listener);
+              }
+            }
+          }
+        }
+      }
+      // error out this channel, so it'll stop trying to run the url.
+      rv = NS_ERROR_FAILURE;
+      *aRetVal = nullptr;
+    }
+    // this folder exists - check if this is a click on a link to the folder
+    // in which case, we'll select it.
+    else if (!fullFolderName.IsEmpty())  
+    {         
+      nsCOMPtr<nsIMsgFolder> imapFolder;
+      nsCOMPtr<nsIImapServerSink> serverSink;
+      
+      mailnewsUrl->GetFolder(getter_AddRefs(imapFolder));
+      imapUrl->GetImapServerSink(getter_AddRefs(serverSink));
+      // need to see if this is a link click - one way is to check if the url is set up correctly
+      // if not, it's probably a url click. We need a better way of doing this. 
+      if (!imapFolder)
+      {
+        nsCOMPtr<nsIMsgMailSession> mailSession = do_GetService(NS_MSGMAILSESSION_CONTRACTID, &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        nsCOMPtr <nsIMsgWindow> msgWindow;
+        rv = mailSession->GetTopmostMsgWindow(getter_AddRefs(msgWindow));
+        if (NS_SUCCEEDED(rv) && msgWindow)
+        {
+          nsCString uri;
+          rootFolder->GetURI(uri);
+          uri.Append('/');
+          uri.Append(fullFolderName);
+          nsCOMPtr<nsIMsgWindowCommands> windowCommands;
+          msgWindow->GetWindowCommands(getter_AddRefs(windowCommands));
+          if (windowCommands)
+            windowCommands->SelectFolder(uri);
+            // error out this channel, so it'll stop trying to run the url.
+          *aRetVal = nullptr;
+          rv = NS_ERROR_FAILURE;
+        }
+        else
+        {
+          // make sure the imap action is selectFolder, so the content type
+          // will be x-application-imapfolder, so ::HandleContent will
+          // know to open a new 3 pane window.
+          imapUrl->SetImapAction(nsIImapUrl::nsImapSelectFolder);
+        }
+      }
+    }
+  }
+  if (NS_SUCCEEDED(rv))
+    NS_IF_ADDREF(*aRetVal = channel);
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::SetDefaultLocalPath(nsIFile *aPath)
+{
+  NS_ENSURE_ARG_POINTER(aPath);
+
+  return NS_SetPersistentFile(PREF_MAIL_ROOT_IMAP_REL, PREF_MAIL_ROOT_IMAP, aPath);
+}
+
+NS_IMETHODIMP nsImapService::GetDefaultLocalPath(nsIFile **aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = nullptr;
+
+  bool havePref;
+  nsCOMPtr<nsIFile> localFile;
+  nsresult rv = NS_GetPersistentFile(PREF_MAIL_ROOT_IMAP_REL,
+                                     PREF_MAIL_ROOT_IMAP,
+                                     NS_APP_IMAP_MAIL_50_DIR,
+                                     havePref,
+                                     getter_AddRefs(localFile));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(localFile, NS_ERROR_FAILURE);
+
+  bool exists;
+  rv = localFile->Exists(&exists);
+  if (NS_SUCCEEDED(rv) && !exists)
+    rv = localFile->Create(nsIFile::DIRECTORY_TYPE, 0775);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!havePref || !exists)
+  {
+    rv = NS_SetPersistentFile(PREF_MAIL_ROOT_IMAP_REL, PREF_MAIL_ROOT_IMAP, localFile);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to set root dir pref.");
+  }
+
+  localFile.swap(*aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetServerIID(nsIID **aServerIID)
+{
+  *aServerIID = new nsIID(NS_GET_IID(nsIImapIncomingServer));
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetRequiresUsername(bool *aRequiresUsername)
+{
+  NS_ENSURE_ARG_POINTER(aRequiresUsername);
+
+  *aRequiresUsername = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetPreflightPrettyNameWithEmailAddress(bool *aPreflightPrettyNameWithEmailAddress)
+{
+  NS_ENSURE_ARG_POINTER(aPreflightPrettyNameWithEmailAddress);
+
+  *aPreflightPrettyNameWithEmailAddress = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetCanLoginAtStartUp(bool *aCanLoginAtStartUp)
+{
+  NS_ENSURE_ARG_POINTER(aCanLoginAtStartUp);
+  *aCanLoginAtStartUp = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetCanDelete(bool *aCanDelete)
+{
+  NS_ENSURE_ARG_POINTER(aCanDelete);
+  *aCanDelete = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetCanDuplicate(bool *aCanDuplicate)
+{
+  NS_ENSURE_ARG_POINTER(aCanDuplicate);
+  *aCanDuplicate = true;
+  return NS_OK;
+}        
+
+NS_IMETHODIMP nsImapService::GetCanGetMessages(bool *aCanGetMessages)
+{
+  NS_ENSURE_ARG_POINTER(aCanGetMessages);
+  *aCanGetMessages = true;
+  return NS_OK;
+}        
+
+NS_IMETHODIMP nsImapService::GetCanGetIncomingMessages(bool *aCanGetIncomingMessages)
+{
+  NS_ENSURE_ARG_POINTER(aCanGetIncomingMessages);
+  *aCanGetIncomingMessages = true;
+  return NS_OK;
+}    
+
+NS_IMETHODIMP nsImapService::GetShowComposeMsgLink(bool *showComposeMsgLink)
+{
+  NS_ENSURE_ARG_POINTER(showComposeMsgLink);
+  *showComposeMsgLink = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetFoldersCreatedAsync(bool *aAsyncCreation)
+{
+  NS_ENSURE_ARG_POINTER(aAsyncCreation);
+  *aAsyncCreation = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::GetListOfFoldersWithPath(nsIImapIncomingServer *aServer, 
+                                                      nsIMsgWindow *aMsgWindow, 
+                                                      const nsACString &folderPath)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgIncomingServer> server = do_QueryInterface(aServer);
+  if (!server) 
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+  rv = server->GetRootMsgFolder(getter_AddRefs(rootMsgFolder));
+
+  NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && rootMsgFolder, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIUrlListener> listener = do_QueryInterface(aServer, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!listener) 
+    return NS_ERROR_FAILURE;
+
+  // Locate the folder so that the correct hierarchical delimiter is used in the folder
+  // pathnames, otherwise root's (ie, '^') is used and this is wrong.
+  nsCOMPtr<nsIMsgFolder> msgFolder;
+  if (rootMsgFolder && !folderPath.IsEmpty())
+  {
+    // If the folder path contains 'INBOX' of any forms, we need to convert it to uppercase
+    // before finding it under the root folder. We do the same in PossibleImapMailbox().
+    nsAutoCString tempFolderName(folderPath);
+    nsAutoCString tokenStr, remStr, changedStr;
+    int32_t slashPos = tempFolderName.FindChar('/');
+    if (slashPos > 0)
+    {
+      tokenStr = StringHead(tempFolderName, slashPos);
+      remStr = Substring(tempFolderName, slashPos);
+    }
+    else
+      tokenStr.Assign(tempFolderName);
+
+    if (tokenStr.LowerCaseEqualsLiteral("inbox") &&
+        !tokenStr.EqualsLiteral("INBOX"))
+      changedStr.Append("INBOX");
+    else
+      changedStr.Append(tokenStr);
+
+    if (slashPos > 0 ) 
+      changedStr.Append(remStr);
+
+    rv = rootMsgFolder->FindSubFolder(changedStr, getter_AddRefs(msgFolder));
+  }
+  return DiscoverChildren(msgFolder, listener, folderPath, nullptr);
+}
+
+NS_IMETHODIMP nsImapService::GetListOfFoldersOnServer(nsIImapIncomingServer *aServer, 
+                                                      nsIMsgWindow *aMsgWindow)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgIncomingServer> server = do_QueryInterface(aServer);
+  if (!server) 
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgFolder> rootMsgFolder;
+  rv = server->GetRootMsgFolder(getter_AddRefs(rootMsgFolder));
+
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!rootMsgFolder) 
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIUrlListener> listener = do_QueryInterface(aServer, &rv);
+  NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && listener, NS_ERROR_FAILURE);
+
+  return DiscoverAllAndSubscribedFolders(rootMsgFolder, listener, nullptr);
+} 
+
+NS_IMETHODIMP nsImapService::SubscribeFolder(nsIMsgFolder *aFolder,
+                                             const nsAString &aFolderName, 
+                                             nsIUrlListener *urlListener, 
+                                             nsIURI **url)
+{
+
+  return ChangeFolderSubscription(aFolder, aFolderName, 
+                                  "/subscribe>", urlListener, url);
+}
+
+nsresult nsImapService::ChangeFolderSubscription(nsIMsgFolder *folder,
+                                                 const nsAString &folderName, 
+                                                 const char *command,
+                                                 nsIUrlListener *urlListener, 
+                                                 nsIURI **url)
+{
+  NS_ENSURE_ARG_POINTER(folder);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  nsresult rv;
+  char hierarchyDelimiter = GetHierarchyDelimiter(folder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), folder, urlListener,
+                            urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    rv = SetImapUrlSink(folder, imapUrl);
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCOMPtr<nsIURI> uri = do_QueryInterface(imapUrl);
+      urlSpec.Append(command);
+      urlSpec.Append(hierarchyDelimiter);
+      nsAutoCString utfFolderName;
+      rv = CopyUTF16toMUTF7(PromiseFlatString(folderName), utfFolderName);
+      NS_ENSURE_SUCCESS(rv, rv);
+      nsCString escapedFolderName;
+      MsgEscapeString(utfFolderName, nsINetUtil::ESCAPE_URL_PATH, escapedFolderName);
+      urlSpec.Append(escapedFolderName);
+      rv = uri->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, url);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::UnsubscribeFolder(nsIMsgFolder *aFolder,
+                                               const nsAString &aFolderName, 
+                                               nsIUrlListener *aUrlListener, 
+                                               nsIURI **aUrl)
+{
+
+  return ChangeFolderSubscription(aFolder, aFolderName,
+                                  "/unsubscribe>", aUrlListener, aUrl);
+}
+
+NS_IMETHODIMP nsImapService::GetFolderAdminUrl(nsIMsgFolder *aImapMailFolder,
+                                               nsIMsgWindow *aMsgWindow,
+                                               nsIUrlListener *aUrlListener,
+                                               nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(aImapMailFolder);
+
+  return FolderCommand(aImapMailFolder, aUrlListener,
+                       "/refreshfolderurls>", nsIImapUrl::nsImapRefreshFolderUrls, aMsgWindow, aURL);
+}
+
+NS_IMETHODIMP nsImapService::IssueCommandOnMsgs(nsIMsgFolder *anImapFolder,
+                                                nsIMsgWindow *aMsgWindow,
+                                                const nsACString &aCommand,
+                                                const nsACString &uids,
+                                                nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(anImapFolder);
+  NS_ENSURE_ARG_POINTER(aMsgWindow);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  nsresult rv;
+  char hierarchyDelimiter = GetHierarchyDelimiter(anImapFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), anImapFolder, nullptr, urlSpec, hierarchyDelimiter);
+
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    // nsImapUrl::SetSpec() will set the imap action properly
+    rv = imapUrl->SetImapAction(nsIImapUrl::nsImapUserDefinedMsgCommand);
+
+    nsCOMPtr <nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(imapUrl);
+    mailNewsUrl->SetMsgWindow(aMsgWindow);
+    mailNewsUrl->SetUpdatingFolder(true);
+    rv = SetImapUrlSink(anImapFolder, imapUrl);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCString folderName;
+      GetFolderName(anImapFolder, folderName);
+      urlSpec.Append("/");
+      urlSpec.Append(aCommand);
+      urlSpec.Append(">");
+      urlSpec.Append(uidString);
+      urlSpec.Append(">");
+      urlSpec.Append(hierarchyDelimiter);
+      urlSpec.Append(folderName);
+      urlSpec.Append(">");
+      urlSpec.Append(uids);
+      rv = mailNewsUrl->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  } // if we have a url to run....
+
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::FetchCustomMsgAttribute(nsIMsgFolder *anImapFolder,
+                                                     nsIMsgWindow *aMsgWindow,
+                                                     const nsACString &aAttribute,
+                                                     const nsACString &uids,
+                                                     nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(anImapFolder);
+  NS_ENSURE_ARG_POINTER(aMsgWindow);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  nsresult rv;
+  char hierarchyDelimiter = GetHierarchyDelimiter(anImapFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), anImapFolder, 
+                            nullptr, urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    // nsImapUrl::SetSpec() will set the imap action properly
+    rv = imapUrl->SetImapAction(nsIImapUrl::nsImapUserDefinedFetchAttribute);
+
+    nsCOMPtr <nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(imapUrl);
+    mailNewsUrl->SetMsgWindow(aMsgWindow);
+    mailNewsUrl->SetUpdatingFolder(true);
+    rv = SetImapUrlSink(anImapFolder, imapUrl);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCString folderName;
+      GetFolderName(anImapFolder, folderName);
+      urlSpec.Append("/customFetch>UID>");
+      urlSpec.Append(hierarchyDelimiter);
+      urlSpec.Append(folderName);
+      urlSpec.Append(">");
+      urlSpec.Append(uids);
+      urlSpec.Append(">");
+      urlSpec.Append(aAttribute);
+      rv = mailNewsUrl->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  } // if we have a url to run....
+
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::StoreCustomKeywords(nsIMsgFolder *anImapFolder,
+                                                 nsIMsgWindow *aMsgWindow,
+                                                 const nsACString &flagsToAdd,
+                                                 const nsACString &flagsToSubtract,
+                                                 const nsACString &uids,
+                                                 nsIURI **aURL)
+{
+  NS_ENSURE_ARG_POINTER(anImapFolder);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  nsresult rv;
+  char hierarchyDelimiter = GetHierarchyDelimiter(anImapFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), anImapFolder, nullptr, urlSpec, hierarchyDelimiter);
+
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    // nsImapUrl::SetSpec() will set the imap action properly
+    rv = imapUrl->SetImapAction(nsIImapUrl::nsImapMsgStoreCustomKeywords);
+
+    nsCOMPtr <nsIMsgMailNewsUrl> mailNewsUrl = do_QueryInterface(imapUrl);
+    mailNewsUrl->SetMsgWindow(aMsgWindow);
+    mailNewsUrl->SetUpdatingFolder(true);
+    rv = SetImapUrlSink(anImapFolder, imapUrl);
+
+    if (NS_SUCCEEDED(rv))
+    {
+      nsCString folderName;
+      GetFolderName(anImapFolder, folderName);
+      urlSpec.Append("/customKeywords>UID>");
+      urlSpec.Append(hierarchyDelimiter);
+      urlSpec.Append(folderName);
+      urlSpec.Append(">");
+      urlSpec.Append(uids);
+      urlSpec.Append(">");
+      urlSpec.Append(flagsToAdd);
+      urlSpec.Append(">");
+      urlSpec.Append(flagsToSubtract);
+      rv = mailNewsUrl->SetSpec(urlSpec);
+      if (NS_SUCCEEDED(rv))
+        rv = GetImapConnectionAndLoadUrl(imapUrl, nullptr, aURL);
+    }
+  } // if we have a url to run....
+
+  return rv;
+}
+
+
+NS_IMETHODIMP nsImapService::DownloadMessagesForOffline(const nsACString &messageIds, 
+                                                        nsIMsgFolder *aFolder, 
+                                                        nsIUrlListener *aUrlListener, 
+                                                        nsIMsgWindow *aMsgWindow)
+{
+  NS_ENSURE_ARG_POINTER(aFolder);
+
+  nsCOMPtr<nsIImapUrl> imapUrl;
+  nsAutoCString urlSpec;
+  nsresult rv;
+  char hierarchyDelimiter = GetHierarchyDelimiter(aFolder);
+  rv = CreateStartOfImapUrl(EmptyCString(), getter_AddRefs(imapUrl), aFolder, nullptr,
+                            urlSpec, hierarchyDelimiter);
+  if (NS_SUCCEEDED(rv) && imapUrl)
+  {
+    nsCOMPtr<nsIURI> runningURI;
+    // need to pass in stream listener in order to get the channel created correctly
+    nsCOMPtr<nsIImapMessageSink> imapMessageSink(do_QueryInterface(aFolder, &rv));
+    rv = FetchMessage(imapUrl, nsImapUrl::nsImapMsgDownloadForOffline,aFolder,
+                      imapMessageSink, aMsgWindow, nullptr, messageIds,
+                      false, EmptyCString(), getter_AddRefs(runningURI));
+    if (runningURI && aUrlListener)
+    {
+      nsCOMPtr<nsIMsgMailNewsUrl> msgurl (do_QueryInterface(runningURI));
+      nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(runningURI));
+      if (msgurl)
+        msgurl->RegisterListener(aUrlListener);
+      if (imapUrl)
+        imapUrl->SetStoreResultsOffline(true);
+    }
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::MessageURIToMsgHdr(const char *uri, nsIMsgDBHdr **aRetVal)
+{
+  NS_ENSURE_ARG_POINTER(uri);
+  NS_ENSURE_ARG_POINTER(aRetVal);
+
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsMsgKey msgKey;
+  nsresult rv = DecomposeImapURI(nsDependentCString(uri),
+                                 getter_AddRefs(folder), &msgKey);
+  NS_ENSURE_SUCCESS(rv,rv);
+  rv = folder->GetMessageHeader(msgKey, aRetVal);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapService::PlaybackAllOfflineOperations(nsIMsgWindow *aMsgWindow, 
+                                                          nsIUrlListener *aListener, 
+                                                          nsISupports **aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  nsresult rv;
+  nsImapOfflineSync *goOnline = new nsImapOfflineSync(aMsgWindow, aListener, nullptr);
+  if (goOnline)
+  {
+    rv = goOnline->QueryInterface(NS_GET_IID(nsISupports), (void **) aResult); 
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (NS_SUCCEEDED(rv) && *aResult)
+      return goOnline->ProcessNextOperation();
+  }
+  return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsImapService::DownloadAllOffineImapFolders(nsIMsgWindow *aMsgWindow, 
+                                                          nsIUrlListener *aListener)
+{
+  nsImapOfflineDownloader *downloadForOffline = new nsImapOfflineDownloader(aMsgWindow, aListener);
+  if (downloadForOffline)
+  {
+    // hold reference to this so it won't get deleted out from under itself.
+    NS_ADDREF(downloadForOffline); 
+    nsresult rv = downloadForOffline->ProcessNextOperation();
+    NS_RELEASE(downloadForOffline);
+    return rv;
+  }
+  return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP nsImapService::GetCacheStorage(nsICacheStorage **result)
+{
+  nsresult rv = NS_OK;
+  if (!mCacheStorage)
+  {
+    nsCOMPtr<nsICacheStorageService> cacheStorageService =
+      do_GetService("@mozilla.org/netwerk/cache-storage-service;1", &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    RefPtr<MailnewsLoadContextInfo> lci =
+      new MailnewsLoadContextInfo(false, false, mozilla::NeckoOriginAttributes());
+
+    rv = cacheStorageService->MemoryCacheStorage(lci, getter_AddRefs(mCacheStorage));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  NS_IF_ADDREF(*result = mCacheStorage);
+  return rv;
+}
+
+NS_IMETHODIMP nsImapService::HandleContent(const char *aContentType, 
+                                           nsIInterfaceRequestor *aWindowContext, 
+                                           nsIRequest *request)
+{
+  NS_ENSURE_ARG_POINTER(request);
+
+  nsresult rv;
+  nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (PL_strcasecmp(aContentType, "x-application-imapfolder") == 0)
+  {
+    nsCOMPtr<nsIURI> uri;
+    rv = aChannel->GetURI(getter_AddRefs(uri));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (uri)
+    {
+      request->Cancel(NS_BINDING_ABORTED);
+      nsCOMPtr<nsIWindowMediator> mediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID, &rv));
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsAutoCString uriStr;
+      rv = uri->GetSpec(uriStr);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // imap uri's are unescaped, so unescape the url.
+      nsCString unescapedUriStr;
+      MsgUnescapeString(uriStr, 0, unescapedUriStr);
+      nsCOMPtr <nsIMessengerWindowService> messengerWindowService = do_GetService(NS_MESSENGERWINDOWSERVICE_CONTRACTID,&rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = messengerWindowService->OpenMessengerWindowWithUri("mail:3pane", unescapedUriStr.get(), nsMsgKey_None);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  } 
+  else 
+  {
+    // The content-type was not x-application-imapfolder
+    return NS_ERROR_WONT_HANDLE_CONTENT;
+  }
+
+  return rv;
+}
diff --git a/mailnews/imap/src/nsImapService.h b/mailnews/imap/src/nsImapService.h
new file mode 100644
index 0000000000..dc6f1921ac
--- /dev/null
+++ b/mailnews/imap/src/nsImapService.h
@@ -0,0 +1,123 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsImapService_h___
+#define nsImapService_h___
+
+#include "nsIImapService.h"
+#include "nsIMsgMessageService.h"
+#include "nsCOMPtr.h"
+#include "nsIFile.h"
+#include "nsIProtocolHandler.h"
+#include "nsIMsgProtocolInfo.h"
+#include "nsIContentHandler.h"
+#include "nsICacheStorage.h"
+
+class nsIImapHostSessionList; 
+class nsCString;
+class nsIImapUrl;
+class nsIMsgFolder;
+class nsIMsgStatusFeedback;
+class nsIMsgIncomingServer;
+
+class nsImapService : public nsIImapService,
+                      public nsIMsgMessageService,
+                      public nsIMsgMessageFetchPartService,
+                      public nsIProtocolHandler,
+                      public nsIMsgProtocolInfo,
+                      public nsIContentHandler
+{
+public:
+  nsImapService();
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIMSGPROTOCOLINFO
+  NS_DECL_NSIIMAPSERVICE
+  NS_DECL_NSIMSGMESSAGESERVICE
+  NS_DECL_NSIPROTOCOLHANDLER
+  NS_DECL_NSIMSGMESSAGEFETCHPARTSERVICE
+  NS_DECL_NSICONTENTHANDLER
+
+protected:
+  virtual ~nsImapService();
+  char GetHierarchyDelimiter(nsIMsgFolder *aMsgFolder);
+
+  nsresult GetFolderName(nsIMsgFolder *aImapFolder, nsACString &aFolderName);
+
+  // This is called by both FetchMessage and StreamMessage
+  nsresult GetMessageFromUrl(nsIImapUrl *aImapUrl,
+                             nsImapAction aImapAction,
+                             nsIMsgFolder *aImapMailFolder, 
+                             nsIImapMessageSink *aImapMessage,
+                             nsIMsgWindow *aMsgWindow,
+                             nsISupports *aDisplayConsumer, 
+                             bool aConvertDataToText,
+                             nsIURI **aURL);
+
+  nsresult CreateStartOfImapUrl(const nsACString &aImapURI,  // a RDF URI for the current message/folder, can be empty
+                                nsIImapUrl  **imapUrl,
+                                nsIMsgFolder *aImapFolder,
+                                nsIUrlListener *aUrlListener,
+                                nsACString &urlSpec,
+                                char &hierarchyDelimiter);
+
+  nsresult GetImapConnectionAndLoadUrl(nsIImapUrl *aImapUrl,
+                                       nsISupports *aConsumer,
+                                       nsIURI **aURL);
+
+  nsresult SetImapUrlSink(nsIMsgFolder *aMsgFolder, nsIImapUrl *aImapUrl);
+
+  nsresult FetchMimePart(nsIImapUrl *aImapUrl,
+                         nsImapAction aImapAction,
+                         nsIMsgFolder *aImapMailFolder, 
+                         nsIImapMessageSink *aImapMessage,
+                         nsIURI **aURL,
+                         nsISupports *aDisplayConsumer, 
+                         const nsACString &messageIdentifierList,
+                         const nsACString &mimePart);
+
+  nsresult FolderCommand(nsIMsgFolder *imapMailFolder,
+                         nsIUrlListener *urlListener,
+                         const char *aCommand,
+                         nsImapAction imapAction,
+                         nsIMsgWindow *msgWindow,
+                         nsIURI **url);
+
+  nsresult ChangeFolderSubscription(nsIMsgFolder *folder,
+                                    const nsAString &folderName,
+                                    const char *aCommand,
+                                    nsIUrlListener *urlListener,
+                                    nsIURI **url);
+
+  nsresult DiddleFlags(nsIMsgFolder *aImapMailFolder,
+                       nsIUrlListener *aUrlListener,
+                       nsIURI **aURL,
+                       const nsACString &messageIdentifierList,
+                       const char *howToDiddle,
+                       imapMessageFlagsType flags,
+                       bool messageIdsAreUID);
+
+  nsresult OfflineAppendFromFile(nsIFile *aFile,
+                                 nsIURI *aUrl,
+                                 nsIMsgFolder *aDstFolder,
+                                 const nsACString &messageId,  // to be replaced
+                                 bool inSelectedState, // needs to be in
+                                 nsIUrlListener *aListener,
+                                 nsIURI **aURL,
+                                 nsISupports *aCopyState);
+
+  nsresult GetServerFromUrl(nsIImapUrl *aImapUrl, nsIMsgIncomingServer **aServer);
+
+  // just a little helper method...maybe it should be a macro? which helps break down a imap message uri
+  // into the folder and message key equivalents
+  nsresult DecomposeImapURI(const nsACString &aMessageURI, nsIMsgFolder **aFolder, nsACString &msgKey);
+  nsresult DecomposeImapURI(const nsACString &aMessageURI, nsIMsgFolder **aFolder, nsMsgKey *msgKey);
+
+
+  nsCOMPtr<nsICacheStorage> mCacheStorage;
+  bool mPrintingOperation;                // Flag for printing operations
+};
+
+#endif /* nsImapService_h___ */
diff --git a/mailnews/imap/src/nsImapStringBundle.cpp b/mailnews/imap/src/nsImapStringBundle.cpp
new file mode 100644
index 0000000000..124b7f0b65
--- /dev/null
+++ b/mailnews/imap/src/nsImapStringBundle.cpp
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "prprf.h"
+#include "prmem.h"
+#include "nsCOMPtr.h"
+#include "nsStringGlue.h"
+#include "nsIStringBundle.h"
+#include "nsImapStringBundle.h"
+#include "nsIServiceManager.h"
+#include "nsIURI.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Services.h"
+
+#define IMAP_MSGS_URL       "chrome://messenger/locale/imapMsgs.properties"
+
+extern "C" 
+nsresult
+IMAPGetStringByName(const char* stringName, char16_t **aString)
+{
+  nsCOMPtr <nsIStringBundle> sBundle;
+  nsresult rv = IMAPGetStringBundle(getter_AddRefs(sBundle));
+  if (NS_SUCCEEDED(rv) && sBundle)
+    rv = sBundle->GetStringFromName(NS_ConvertASCIItoUTF16(stringName).get(),
+                                    aString);
+  return rv;
+}
+
+nsresult
+IMAPGetStringBundle(nsIStringBundle **aBundle)
+{
+  nsresult rv=NS_OK;
+  nsCOMPtr<nsIStringBundleService> stringService =
+    mozilla::services::GetStringBundleService();
+  if (!stringService) return NS_ERROR_NULL_POINTER;
+  nsCOMPtr<nsIStringBundle> stringBundle;
+  rv = stringService->CreateBundle(IMAP_MSGS_URL, getter_AddRefs(stringBundle));
+  *aBundle = stringBundle;
+  NS_IF_ADDREF(*aBundle);
+  return rv;
+}
diff --git a/mailnews/imap/src/nsImapStringBundle.h b/mailnews/imap/src/nsImapStringBundle.h
new file mode 100644
index 0000000000..a5333f185c
--- /dev/null
+++ b/mailnews/imap/src/nsImapStringBundle.h
@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _nsImapStringBundle_H__
+#define _nsImapStringBundle_H__
+
+#include "nsIStringBundle.h"
+
+PR_BEGIN_EXTERN_C
+
+nsresult      IMAPGetStringByName(const char* stringName, char16_t **aString);
+nsresult      IMAPGetStringBundle(nsIStringBundle **aBundle);
+
+PR_END_EXTERN_C
+
+#endif /* _nsImapStringBundle_H__ */
diff --git a/mailnews/imap/src/nsImapUndoTxn.cpp b/mailnews/imap/src/nsImapUndoTxn.cpp
new file mode 100644
index 0000000000..8d51dab359
--- /dev/null
+++ b/mailnews/imap/src/nsImapUndoTxn.cpp
@@ -0,0 +1,751 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h" // for precompiled headers
+#include "nsMsgImapCID.h"
+#include "nsIMsgHdr.h"
+#include "nsImapUndoTxn.h"
+#include "nsIIMAPHostSessionList.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsImapMailFolder.h"
+#include "nsIDBFolderInfo.h"
+#include "nsIMsgDatabase.h"
+#include "nsMsgUtils.h"
+#include "nsThreadUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsComponentManagerUtils.h"
+
+nsImapMoveCopyMsgTxn::nsImapMoveCopyMsgTxn() :
+    m_idsAreUids(false), m_isMove(false), m_srcIsPop3(false)
+{
+}
+
+nsresult
+nsImapMoveCopyMsgTxn::Init(nsIMsgFolder* srcFolder, nsTArray<nsMsgKey>* srcKeyArray,
+                           const char* srcMsgIdString, nsIMsgFolder* dstFolder,
+                           bool idsAreUids, bool isMove)
+{
+  m_srcMsgIdString = srcMsgIdString;
+  m_idsAreUids = idsAreUids;
+  m_isMove = isMove;
+  m_srcFolder = do_GetWeakReference(srcFolder);
+  m_dstFolder = do_GetWeakReference(dstFolder);
+  m_srcKeyArray = *srcKeyArray;
+  m_dupKeyArray = *srcKeyArray;
+  nsCString uri;
+  nsresult rv = srcFolder->GetURI(uri);
+  nsCString protocolType(uri);
+  protocolType.SetLength(protocolType.FindChar(':'));
+  nsCOMPtr<nsIMsgDatabase> srcDB;
+  rv = srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
+  NS_ENSURE_SUCCESS(rv, rv);
+  uint32_t i, count = m_srcKeyArray.Length();
+  nsCOMPtr<nsIMsgDBHdr> srcHdr;
+  nsCOMPtr<nsIMsgDBHdr> copySrcHdr;
+  nsCString messageId;
+
+  for (i = 0; i < count; i++)
+  {
+    rv = srcDB->GetMsgHdrForKey(m_srcKeyArray[i],
+      getter_AddRefs(srcHdr));
+    if (NS_SUCCEEDED(rv))
+    {
+      // ** jt -- only do this for mailbox protocol
+      if (MsgLowerCaseEqualsLiteral(protocolType, "mailbox"))
+      {
+        m_srcIsPop3 = true;
+        uint32_t msgSize;
+        rv = srcHdr->GetMessageSize(&msgSize);
+        if (NS_SUCCEEDED(rv))
+          m_srcSizeArray.AppendElement(msgSize);
+        if (isMove)
+        {
+          rv = srcDB->CopyHdrFromExistingHdr(nsMsgKey_None, srcHdr, false,
+                                             getter_AddRefs(copySrcHdr));
+          nsMsgKey pseudoKey = nsMsgKey_None;
+          if (NS_SUCCEEDED(rv))
+          {
+            copySrcHdr->GetMessageKey(&pseudoKey);
+            m_srcHdrs.AppendObject(copySrcHdr);
+          }
+          m_dupKeyArray[i] = pseudoKey;
+        }
+      }
+      srcHdr->GetMessageId(getter_Copies(messageId));
+      m_srcMessageIds.AppendElement(messageId);
+    }
+  }
+  return nsMsgTxn::Init();
+}
+
+nsImapMoveCopyMsgTxn::~nsImapMoveCopyMsgTxn()
+{
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsImapMoveCopyMsgTxn, nsMsgTxn, nsIUrlListener)
+
+NS_IMETHODIMP
+nsImapMoveCopyMsgTxn::UndoTransaction(void)
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool finishInOnStopRunningUrl = false;
+
+  if (m_isMove || !m_dstFolder)
+  {
+    if (m_srcIsPop3)
+    {
+      rv = UndoMailboxDelete();
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    else
+    {
+      nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryReferent(m_srcFolder, &rv);
+      if (NS_FAILED(rv) || !srcFolder) 
+        return rv;
+      nsCOMPtr<nsIUrlListener> srcListener = do_QueryInterface(srcFolder, &rv);
+      if (NS_FAILED(rv)) 
+        return rv;
+      m_onStopListener =   do_GetWeakReference(srcListener);
+
+      // ** make sure we are in the selected state; use lite select
+      // folder so we won't hit performance hard
+      rv = imapService->LiteSelectFolder(srcFolder, srcListener, nullptr, nullptr);
+      if (NS_FAILED(rv)) 
+        return rv;
+      bool deletedMsgs = true; //default is true unless imapDelete model
+      nsMsgImapDeleteModel deleteModel;
+      rv = GetImapDeleteModel(srcFolder, &deleteModel);
+
+      // protect against a bogus undo txn without any source keys
+      // see bug #179856 for details
+      NS_ASSERTION(!m_srcKeyArray.IsEmpty(), "no source keys");
+      if (m_srcKeyArray.IsEmpty())
+        return NS_ERROR_UNEXPECTED;
+
+      if (!m_srcMsgIdString.IsEmpty())
+      {
+        if (NS_SUCCEEDED(rv) && deleteModel == nsMsgImapDeleteModels::IMAPDelete)
+          CheckForToggleDelete(srcFolder, m_srcKeyArray[0], &deletedMsgs);
+
+        if (deletedMsgs)
+          rv = imapService->SubtractMessageFlags(srcFolder,
+                                                 this, nullptr,
+                                                 m_srcMsgIdString, 
+                                                 kImapMsgDeletedFlag,
+                                                 m_idsAreUids);
+        else
+          rv = imapService->AddMessageFlags(srcFolder,
+                                            srcListener, nullptr,
+                                            m_srcMsgIdString,
+                                            kImapMsgDeletedFlag,
+                                            m_idsAreUids);
+        if (NS_FAILED(rv)) 
+          return rv;
+
+        finishInOnStopRunningUrl = true;
+        if (deleteModel != nsMsgImapDeleteModels::IMAPDelete)
+          rv = imapService->GetHeaders(srcFolder, srcListener, nullptr,
+                                       m_srcMsgIdString, true);
+      }
+    }
+  }
+  if (!finishInOnStopRunningUrl && !m_dstMsgIdString.IsEmpty())
+  {
+    nsCOMPtr<nsIMsgFolder> dstFolder = do_QueryReferent(m_dstFolder, &rv);
+    if (NS_FAILED(rv) || !dstFolder)
+      return rv;
+
+    nsCOMPtr<nsIUrlListener> dstListener;
+
+    dstListener = do_QueryInterface(dstFolder, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    // ** make sure we are in the selected state; use lite select folder
+    // so we won't potentially download a bunch of headers.
+    rv = imapService->LiteSelectFolder(dstFolder,
+      dstListener, nullptr, nullptr);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = imapService->AddMessageFlags(dstFolder, dstListener,
+                                      nullptr, m_dstMsgIdString, 
+                                      kImapMsgDeletedFlag, m_idsAreUids);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapMoveCopyMsgTxn::RedoTransaction(void)
+{
+  nsresult rv;
+  nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (m_isMove || !m_dstFolder)
+  {
+    if (m_srcIsPop3)
+    {
+      rv = RedoMailboxDelete();
+      if (NS_FAILED(rv)) return rv;
+    }
+    else if (!m_srcMsgIdString.IsEmpty())
+    {
+      nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryReferent(m_srcFolder, &rv);
+      if (NS_FAILED(rv) || !srcFolder) 
+        return rv;
+      nsCOMPtr<nsIUrlListener> srcListener = do_QueryInterface(srcFolder, &rv);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      bool deletedMsgs = false;  //default will be false unless imapDeleteModel;
+      nsMsgImapDeleteModel deleteModel;
+      rv = GetImapDeleteModel(srcFolder, &deleteModel);
+      
+      // protect against a bogus undo txn without any source keys
+      // see bug #179856 for details
+      NS_ASSERTION(!m_srcKeyArray.IsEmpty(), "no source keys");
+      if (m_srcKeyArray.IsEmpty())
+        return NS_ERROR_UNEXPECTED;
+      
+      if (NS_SUCCEEDED(rv) && deleteModel == nsMsgImapDeleteModels::IMAPDelete)
+        rv = CheckForToggleDelete(srcFolder, m_srcKeyArray[0], &deletedMsgs);
+      
+      // Make sure we are in the selected state; use lite select
+      // folder so performance won't suffer.
+      rv = imapService->LiteSelectFolder(srcFolder, srcListener, nullptr, nullptr);
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (deletedMsgs)
+      {
+        rv = imapService->SubtractMessageFlags(srcFolder,
+                                               srcListener, nullptr,
+                                               m_srcMsgIdString,
+                                               kImapMsgDeletedFlag,
+                                               m_idsAreUids);
+      }
+      else
+      {
+        rv = imapService->AddMessageFlags(srcFolder,
+                                          srcListener, nullptr, m_srcMsgIdString,
+                                          kImapMsgDeletedFlag, m_idsAreUids);
+      }
+    }
+  }
+  if (!m_dstMsgIdString.IsEmpty())
+  {
+    nsCOMPtr<nsIMsgFolder> dstFolder = do_QueryReferent(m_dstFolder, &rv);
+    if (NS_FAILED(rv) || !dstFolder) return rv;
+
+    nsCOMPtr<nsIUrlListener> dstListener;
+
+    dstListener = do_QueryInterface(dstFolder, &rv); 
+    NS_ENSURE_SUCCESS(rv, rv);
+    // ** make sure we are in the selected state; use lite select
+    // folder so we won't hit performance hard
+    rv = imapService->LiteSelectFolder(dstFolder, dstListener, nullptr, nullptr);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = imapService->SubtractMessageFlags(dstFolder,
+                                           dstListener, nullptr,
+                                           m_dstMsgIdString,
+                                           kImapMsgDeletedFlag,
+                                           m_idsAreUids);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsMsgImapDeleteModel deleteModel;
+    rv = GetImapDeleteModel(dstFolder, &deleteModel);
+    if (NS_FAILED(rv) || deleteModel == nsMsgImapDeleteModels::MoveToTrash)
+    {
+      rv = imapService->GetHeaders(dstFolder, dstListener, 
+                                   nullptr, m_dstMsgIdString, true);
+    }
+  }
+  return rv;
+}
+
+nsresult
+nsImapMoveCopyMsgTxn::SetCopyResponseUid(const char* aMsgIdString)
+{
+  if (!aMsgIdString) return NS_ERROR_NULL_POINTER;
+  m_dstMsgIdString = aMsgIdString;
+  if (m_dstMsgIdString.Last() == ']')
+  {
+    int32_t len = m_dstMsgIdString.Length();
+    m_dstMsgIdString.SetLength(len - 1);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsImapMoveCopyMsgTxn::GetSrcKeyArray(nsTArray<nsMsgKey>& srcKeyArray)
+{
+    srcKeyArray = m_srcKeyArray;
+    return NS_OK;
+}
+
+nsresult
+nsImapMoveCopyMsgTxn::AddDstKey(nsMsgKey aKey)
+{
+    if (!m_dstMsgIdString.IsEmpty())
+        m_dstMsgIdString.Append(",");
+    m_dstMsgIdString.AppendInt((int32_t) aKey);
+    return NS_OK;
+}
+
+nsresult
+nsImapMoveCopyMsgTxn::UndoMailboxDelete()
+{
+    nsresult rv = NS_ERROR_FAILURE;
+    // ** jt -- only do this for mailbox protocol
+    if (m_srcIsPop3)
+    {
+        nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryReferent(m_srcFolder, &rv);
+        if (NS_FAILED(rv) || !srcFolder) return rv;
+
+        nsCOMPtr<nsIMsgFolder> dstFolder = do_QueryReferent(m_dstFolder, &rv);
+        if (NS_FAILED(rv) || !dstFolder) return rv;
+
+        nsCOMPtr<nsIMsgDatabase> srcDB;
+        nsCOMPtr<nsIMsgDatabase> dstDB;
+        rv = srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
+        if (NS_FAILED(rv)) return rv;
+        rv = dstFolder->GetMsgDatabase(getter_AddRefs(dstDB));
+        if (NS_FAILED(rv)) return rv;
+        
+        uint32_t count = m_srcKeyArray.Length();
+        uint32_t i;
+        nsCOMPtr<nsIMsgDBHdr> oldHdr;
+        nsCOMPtr<nsIMsgDBHdr> newHdr;
+        for (i = 0; i < count; i++)
+        {
+            oldHdr = m_srcHdrs[i];
+            NS_ASSERTION(oldHdr, "fatal ... cannot get old msg header\n");
+            rv = srcDB->CopyHdrFromExistingHdr(m_srcKeyArray[i],
+                                               oldHdr,true,
+                                               getter_AddRefs(newHdr));
+            NS_ASSERTION(newHdr, "fatal ... cannot create new header\n");
+
+            if (NS_SUCCEEDED(rv) && newHdr)
+            {
+                if (i < m_srcSizeArray.Length())
+                    newHdr->SetMessageSize(m_srcSizeArray[i]);
+                srcDB->UndoDelete(newHdr);
+            }
+        }
+        srcDB->SetSummaryValid(true);
+        return NS_OK; // always return NS_OK
+    }
+    else
+    {
+        rv = NS_ERROR_FAILURE;
+    }
+    return rv;
+}
+
+
+nsresult
+nsImapMoveCopyMsgTxn::RedoMailboxDelete()
+{
+    nsresult rv = NS_ERROR_FAILURE;
+    if (m_srcIsPop3)
+    {
+        nsCOMPtr<nsIMsgDatabase> srcDB;
+        nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryReferent(m_srcFolder, &rv);
+        if (NS_FAILED(rv) || !srcFolder) return rv;
+        rv = srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
+        if (NS_SUCCEEDED(rv))
+        {
+            srcDB->DeleteMessages(m_srcKeyArray.Length(), m_srcKeyArray.Elements(), nullptr);
+            srcDB->SetSummaryValid(true);
+        }
+        return NS_OK; // always return NS_OK
+    }
+    else
+    {
+        rv = NS_ERROR_FAILURE;
+    }
+    return rv;
+}
+
+nsresult nsImapMoveCopyMsgTxn::GetImapDeleteModel(nsIMsgFolder *aFolder, nsMsgImapDeleteModel *aDeleteModel)
+{
+  nsresult rv;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+  if (!aFolder)
+    return NS_ERROR_NULL_POINTER;
+  rv = aFolder->GetServer(getter_AddRefs(server));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryInterface(server, &rv);
+  if (NS_SUCCEEDED(rv) && imapServer)
+   rv = imapServer->GetDeleteModel(aDeleteModel);
+  return rv;
+}
+
+NS_IMETHODIMP nsImapMoveCopyMsgTxn::OnStartRunningUrl(nsIURI *aUrl)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMoveCopyMsgTxn::OnStopRunningUrl(nsIURI *aUrl, nsresult aExitCode)
+{
+  nsCOMPtr<nsIUrlListener> urlListener = do_QueryReferent(m_onStopListener);
+  if (urlListener)
+    urlListener->OnStopRunningUrl(aUrl, aExitCode);
+
+  nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(aUrl);
+  if (imapUrl)
+  {
+    nsresult rv;
+    nsCOMPtr<nsIImapService> imapService = do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsImapAction imapAction;
+    imapUrl->GetImapAction(&imapAction);
+    nsCOMPtr<nsIMsgFolder> dstFolder = do_QueryReferent(m_dstFolder, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryReferent(m_srcFolder, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (imapAction == nsIImapUrl::nsImapSubtractMsgFlags)
+    {
+      int32_t extraStatus;
+      imapUrl->GetExtraStatus(&extraStatus);
+      if (extraStatus != nsIImapUrl::ImapStatusNone)
+      {
+        // If subtracting the deleted flag didn't work, try
+        // moving the message back from the target folder to the src folder
+        if (!m_dstMsgIdString.IsEmpty())
+          imapService->OnlineMessageCopy(dstFolder,
+                                         m_dstMsgIdString,
+                                         srcFolder,
+                                         true,
+                                         true,
+                                         nullptr, /* listener */
+                                         nullptr,
+                                         nullptr,
+                                         nullptr);
+        else
+        {
+          // server doesn't support COPYUID, so we're going to update the dest
+          // folder, and when that's done, use the db to find the messages
+          // to move back, looking them up by message-id.
+          nsCOMPtr<nsIMsgImapMailFolder> imapDest = do_QueryInterface(dstFolder);
+          if (imapDest)
+            imapDest->UpdateFolderWithListener(nullptr, this);
+        }
+      }
+      else if (!m_dstMsgIdString.IsEmpty())
+      {
+        nsCOMPtr<nsIUrlListener> dstListener;
+
+        dstListener = do_QueryInterface(dstFolder, &rv);
+        NS_ENSURE_SUCCESS(rv, rv);
+        // ** make sure we are in the selected state; use lite select folder
+        // so we won't potentially download a bunch of headers.
+        rv = imapService->LiteSelectFolder(dstFolder, dstListener, nullptr, nullptr);
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv = imapService->AddMessageFlags(dstFolder, dstListener,
+                                          nullptr, m_dstMsgIdString,
+                                          kImapMsgDeletedFlag, m_idsAreUids);
+      }
+    }
+    else if (imapAction == nsIImapUrl::nsImapSelectFolder)
+    {
+      // Now we should have the headers from the dest folder.
+      // Look them up and move them back to the source folder.
+      uint32_t count = m_srcMessageIds.Length();
+      uint32_t i;
+      nsCString messageId;
+      nsTArray<nsMsgKey> dstKeys;
+      nsCOMPtr<nsIMsgDatabase> destDB;
+      nsCOMPtr<nsIMsgDBHdr> dstHdr;
+
+      rv = dstFolder->GetMsgDatabase(getter_AddRefs(destDB));
+      NS_ENSURE_SUCCESS(rv, rv);
+      for (i = 0; i < count; i++)
+      {
+        rv = destDB->GetMsgHdrForMessageID(m_srcMessageIds[i].get(), getter_AddRefs(dstHdr));
+        if (NS_SUCCEEDED(rv) && dstHdr)
+        {
+          nsMsgKey dstKey;
+          dstHdr->GetMessageKey(&dstKey);
+          dstKeys.AppendElement(dstKey);
+        }
+      }
+      if (dstKeys.Length())
+      {
+        nsAutoCString uids;
+        nsImapMailFolder::AllocateUidStringFromKeys(dstKeys.Elements(), dstKeys.Length(), uids);
+        rv = imapService->OnlineMessageCopy(dstFolder, uids, srcFolder,
+                                            true, true, nullptr,
+                                            nullptr, nullptr, nullptr);
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsImapOfflineTxn::nsImapOfflineTxn(nsIMsgFolder* srcFolder, nsTArray<nsMsgKey>* srcKeyArray,
+                                   const char *srcMsgIdString, nsIMsgFolder* dstFolder,
+                                   bool isMove, nsOfflineImapOperationType opType,
+                                   nsCOMArray<nsIMsgDBHdr> &srcHdrs)
+{
+  Init(srcFolder, srcKeyArray, srcMsgIdString, dstFolder, true,
+       isMove);
+
+  m_opType = opType;
+  m_flags = 0;
+  m_addFlags = false;
+  if (opType == nsIMsgOfflineImapOperation::kDeletedMsg)
+  {
+    nsCOMPtr<nsIMsgDatabase> srcDB;
+    nsCOMPtr<nsIDBFolderInfo> folderInfo;
+
+    nsresult rv = srcFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(srcDB));
+    if (NS_SUCCEEDED(rv) && srcDB)
+    {
+      nsMsgKey pseudoKey;
+      nsCOMPtr <nsIMsgDBHdr> copySrcHdr;
+
+      // Imap protocols have conflated key/UUID so we cannot use
+      // auto key with them.
+      nsCString protocolType;
+      srcFolder->GetURI(protocolType);
+      protocolType.SetLength(protocolType.FindChar(':'));
+      for (int32_t i = 0; i < srcHdrs.Count(); i++)
+      {
+        if (protocolType.EqualsLiteral("imap"))
+        {
+          srcDB->GetNextPseudoMsgKey(&pseudoKey);
+          pseudoKey--;
+        }
+        else
+        {
+          pseudoKey = nsMsgKey_None;
+        }
+        rv = srcDB->CopyHdrFromExistingHdr(pseudoKey, srcHdrs[i], false, getter_AddRefs(copySrcHdr));
+        if (NS_SUCCEEDED(rv))
+        {
+          copySrcHdr->GetMessageKey(&pseudoKey);
+          m_srcHdrs.AppendObject(copySrcHdr);
+        }
+        m_dupKeyArray[i] = pseudoKey;
+      }
+    }
+  }
+  else
+    m_srcHdrs.AppendObjects(srcHdrs);
+}
+
+nsImapOfflineTxn::~nsImapOfflineTxn()
+{
+}
+
+// Open the database and find the key for the offline operation that we want to
+// undo, then remove it from the database, we also hold on to this
+// data for a redo operation.
+NS_IMETHODIMP nsImapOfflineTxn::UndoTransaction(void)
+{
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryReferent(m_srcFolder, &rv);
+  if (NS_FAILED(rv) || !srcFolder) 
+    return rv;
+  nsCOMPtr <nsIMsgOfflineImapOperation> op;
+  nsCOMPtr <nsIDBFolderInfo> folderInfo;
+  nsCOMPtr <nsIMsgDatabase> srcDB;
+  nsCOMPtr <nsIMsgDatabase> destDB;
+
+  rv = srcFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(srcDB));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  switch (m_opType)
+  {
+    case nsIMsgOfflineImapOperation::kMsgMoved:
+    case nsIMsgOfflineImapOperation::kMsgCopy:
+    case nsIMsgOfflineImapOperation::kAddedHeader:
+    case nsIMsgOfflineImapOperation::kFlagsChanged:
+    case nsIMsgOfflineImapOperation::kDeletedMsg:
+    {
+      if (m_srcHdrs.IsEmpty())
+      {
+        NS_ASSERTION(false, "No msg header to apply undo.");
+        break;
+      }
+      nsCOMPtr<nsIMsgDBHdr> firstHdr = m_srcHdrs[0];
+      nsMsgKey hdrKey;
+      firstHdr->GetMessageKey(&hdrKey);
+      rv = srcDB->GetOfflineOpForKey(hdrKey, false, getter_AddRefs(op));
+      bool offlineOpPlayedBack = true;
+      if (NS_SUCCEEDED(rv) && op)
+      {
+        op->GetPlayingBack(&offlineOpPlayedBack);
+        srcDB->RemoveOfflineOp(op);
+        op = nullptr;
+      }
+      if (!WeAreOffline() && offlineOpPlayedBack)
+      {
+        // couldn't find offline op - it must have been played back already
+        // so we should undo the transaction online.
+        return nsImapMoveCopyMsgTxn::UndoTransaction();
+      }
+
+      if (!firstHdr)
+        break;
+      nsMsgKey msgKey;
+      if (m_opType == nsIMsgOfflineImapOperation::kAddedHeader)
+      {
+        for (int32_t i = 0; i < m_srcHdrs.Count(); i++)
+        {
+          m_srcHdrs[i]->GetMessageKey(&msgKey);
+          nsCOMPtr<nsIMsgDBHdr> mailHdr;
+          rv = srcDB->GetMsgHdrForKey(msgKey, getter_AddRefs(mailHdr));
+          if (mailHdr)
+            srcDB->DeleteHeader(mailHdr, nullptr, false, false);
+        }
+        srcDB->Commit(true);
+      }
+      else if (m_opType == nsIMsgOfflineImapOperation::kDeletedMsg)
+      {
+        for (int32_t i = 0; i < m_srcHdrs.Count(); i++)
+        {
+          nsCOMPtr<nsIMsgDBHdr> undeletedHdr = m_srcHdrs[i];
+          m_srcHdrs[i]->GetMessageKey(&msgKey);
+          if (undeletedHdr)
+          {
+            nsCOMPtr<nsIMsgDBHdr> newHdr;
+            srcDB->CopyHdrFromExistingHdr (msgKey, undeletedHdr, true, getter_AddRefs(newHdr));
+          }
+        }
+        srcDB->Close(true);
+        srcFolder->SummaryChanged();
+      }
+      break;
+    }
+    case nsIMsgOfflineImapOperation::kMsgMarkedDeleted:
+      {
+        nsMsgKey msgKey;
+        for (int32_t i = 0; i < m_srcHdrs.Count(); i++)
+        {
+          m_srcHdrs[i]->GetMessageKey(&msgKey);
+          srcDB->MarkImapDeleted(msgKey, false, nullptr);
+        }
+      }
+      break;
+    default:
+      break;
+  }
+  srcDB->Close(true);
+  srcFolder->SummaryChanged();
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapOfflineTxn::RedoTransaction(void)
+{
+  nsresult rv;
+  
+  nsCOMPtr<nsIMsgFolder> srcFolder = do_QueryReferent(m_srcFolder, &rv);
+  if (NS_FAILED(rv) || !srcFolder) 
+    return rv;
+  nsCOMPtr <nsIMsgOfflineImapOperation> op;
+  nsCOMPtr <nsIDBFolderInfo> folderInfo;
+  nsCOMPtr <nsIMsgDatabase> srcDB;
+  nsCOMPtr <nsIMsgDatabase> destDB;
+  rv = srcFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(srcDB));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  switch (m_opType)
+  {
+  case nsIMsgOfflineImapOperation::kMsgMoved:
+  case nsIMsgOfflineImapOperation::kMsgCopy:
+    for (int32_t i = 0; i < m_srcHdrs.Count(); i++)
+    {
+      nsMsgKey hdrKey;
+      m_srcHdrs[i]->GetMessageKey(&hdrKey);
+      rv = srcDB->GetOfflineOpForKey(hdrKey, false, getter_AddRefs(op));
+      if (NS_SUCCEEDED(rv) && op)
+      {
+        nsCOMPtr<nsIMsgFolder> dstFolder = do_QueryReferent(m_dstFolder, &rv);
+        if (dstFolder)
+        {
+          nsCString folderURI;
+          dstFolder->GetURI(folderURI);
+
+          if (m_opType == nsIMsgOfflineImapOperation::kMsgMoved)
+            op->SetDestinationFolderURI(folderURI.get()); // offline move
+          if (m_opType == nsIMsgOfflineImapOperation::kMsgCopy)
+          {
+            op->SetOperation(nsIMsgOfflineImapOperation::kMsgMoved);
+            op->AddMessageCopyOperation(folderURI.get()); // offline copy
+          }
+          dstFolder->SummaryChanged();
+        }
+      }
+      else if (!WeAreOffline())
+      {
+        // couldn't find offline op - it must have been played back already
+        // so we should redo the transaction online.
+        return nsImapMoveCopyMsgTxn::RedoTransaction();
+      }
+    }
+    break;
+  case nsIMsgOfflineImapOperation::kAddedHeader:
+    {
+      nsCOMPtr<nsIMsgFolder> dstFolder = do_QueryReferent(m_dstFolder, &rv);
+      rv = srcFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(destDB));
+      NS_ENSURE_SUCCESS(rv, rv);
+      for (int32_t i = 0; i < m_srcHdrs.Count(); i++)
+      {
+        nsCOMPtr<nsIMsgDBHdr> restoreHdr;
+        nsMsgKey msgKey;
+        m_srcHdrs[i]->GetMessageKey(&msgKey);
+        destDB->CopyHdrFromExistingHdr (msgKey, m_srcHdrs[i], true, getter_AddRefs(restoreHdr));
+        rv = destDB->GetOfflineOpForKey(msgKey, true, getter_AddRefs(op));
+        if (NS_SUCCEEDED(rv) && op)
+        {
+          nsCString folderURI;
+          srcFolder->GetURI(folderURI);
+          op->SetSourceFolderURI(folderURI.get());
+        }
+      }
+      dstFolder->SummaryChanged();
+      destDB->Close(true);
+    }
+    break;
+  case nsIMsgOfflineImapOperation::kDeletedMsg:
+    for (int32_t i = 0; i < m_srcHdrs.Count(); i++)
+    {
+      nsMsgKey msgKey;
+      m_srcHdrs[i]->GetMessageKey(&msgKey);
+      srcDB->DeleteMessage(msgKey, nullptr, true);
+    }
+    break;
+  case nsIMsgOfflineImapOperation::kMsgMarkedDeleted:
+    for (int32_t i = 0; i < m_srcHdrs.Count(); i++)
+    {
+      nsMsgKey msgKey;
+      m_srcHdrs[i]->GetMessageKey(&msgKey);
+      srcDB->MarkImapDeleted(msgKey, true, nullptr);
+    }
+    break;
+  case nsIMsgOfflineImapOperation::kFlagsChanged:
+    for (int32_t i = 0; i < m_srcHdrs.Count(); i++)
+    {
+      nsMsgKey msgKey;
+      m_srcHdrs[i]->GetMessageKey(&msgKey);
+      rv = srcDB->GetOfflineOpForKey(msgKey, true, getter_AddRefs(op));
+      if (NS_SUCCEEDED(rv) && op)
+      {
+        imapMessageFlagsType newMsgFlags;
+        op->GetNewFlags(&newMsgFlags);
+        if (m_addFlags)
+          op->SetFlagOperation(newMsgFlags | m_flags);
+        else
+          op->SetFlagOperation(newMsgFlags & ~m_flags);
+      }
+    }
+    break;
+  default:
+    break;
+  }
+  srcDB->Close(true);
+  srcDB = nullptr;
+  srcFolder->SummaryChanged();
+  return NS_OK;
+}
diff --git a/mailnews/imap/src/nsImapUndoTxn.h b/mailnews/imap/src/nsImapUndoTxn.h
new file mode 100644
index 0000000000..cc910d768a
--- /dev/null
+++ b/mailnews/imap/src/nsImapUndoTxn.h
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsImapUndoTxn_h__
+#define nsImapUndoTxn_h__
+
+#include "mozilla/Attributes.h"
+#include "nsIMsgFolder.h"
+#include "nsImapCore.h"
+#include "nsIImapService.h"
+#include "nsIImapIncomingServer.h"
+#include "nsIUrlListener.h"
+#include "nsMsgTxn.h"
+#include "MailNewsTypes.h"
+#include "nsTArray.h"
+#include "nsIMsgOfflineImapOperation.h"
+#include "nsCOMPtr.h"
+#include "nsWeakReference.h"
+#include "nsCOMArray.h"
+
+class nsImapMoveCopyMsgTxn : public nsMsgTxn, nsIUrlListener
+{
+public:
+
+  nsImapMoveCopyMsgTxn();
+  nsImapMoveCopyMsgTxn(nsIMsgFolder* srcFolder, nsTArray<nsMsgKey>* srcKeyArray,
+                       const char* srcMsgIdString, nsIMsgFolder* dstFolder,
+                       bool isMove);
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIURLLISTENER
+
+  NS_IMETHOD UndoTransaction(void) override;
+  NS_IMETHOD RedoTransaction(void) override;
+
+  // helper
+  nsresult SetCopyResponseUid(const char *msgIdString);
+  nsresult GetSrcKeyArray(nsTArray<nsMsgKey>& srcKeyArray);
+  void GetSrcMsgIds(nsCString &srcMsgIds) {srcMsgIds = m_srcMsgIdString;}
+  nsresult AddDstKey(nsMsgKey aKey);
+  nsresult UndoMailboxDelete();
+  nsresult RedoMailboxDelete();
+  nsresult Init(nsIMsgFolder* srcFolder, nsTArray<nsMsgKey>* srcKeyArray,
+                const char* srcMsgIdString, nsIMsgFolder* dstFolder,
+                bool idsAreUids, bool isMove);
+
+protected:
+  virtual ~nsImapMoveCopyMsgTxn();
+
+  nsWeakPtr m_srcFolder;
+  nsCOMArray<nsIMsgDBHdr> m_srcHdrs;
+  nsTArray<nsMsgKey> m_dupKeyArray;
+  nsTArray<nsMsgKey> m_srcKeyArray;
+  nsTArray<nsCString> m_srcMessageIds;
+  nsCString m_srcMsgIdString;
+  nsWeakPtr m_dstFolder;
+  nsCString m_dstMsgIdString;
+  bool m_idsAreUids;
+  bool m_isMove;
+  bool m_srcIsPop3;
+  nsTArray<uint32_t> m_srcSizeArray;
+  // this is used when we chain urls for imap undo, since "this" needs
+  // to be the listener, but the folder may need to also be notified.
+  nsWeakPtr m_onStopListener;
+
+  nsresult GetImapDeleteModel(nsIMsgFolder* aFolder, nsMsgImapDeleteModel *aDeleteModel);
+};
+
+class nsImapOfflineTxn : public nsImapMoveCopyMsgTxn
+{
+public:
+  nsImapOfflineTxn(nsIMsgFolder* srcFolder, nsTArray<nsMsgKey>* srcKeyArray,
+                   const char* srcMsgIdString,
+                   nsIMsgFolder* dstFolder,
+                   bool isMove,
+                   nsOfflineImapOperationType opType,
+                   nsCOMArray<nsIMsgDBHdr> &srcHdrs);
+
+  NS_IMETHOD UndoTransaction(void) override;
+  NS_IMETHOD RedoTransaction(void) override;
+  void SetAddFlags(bool addFlags) {m_addFlags = addFlags;}
+  void SetFlags(uint32_t flags) {m_flags = flags;}
+protected:
+  virtual ~nsImapOfflineTxn();
+  nsOfflineImapOperationType m_opType;
+  // these two are used to undo flag changes, which we don't currently do.
+  bool m_addFlags;
+  uint32_t m_flags;
+};
+#endif
diff --git a/mailnews/imap/src/nsImapUrl.cpp b/mailnews/imap/src/nsImapUrl.cpp
new file mode 100644
index 0000000000..d764379052
--- /dev/null
+++ b/mailnews/imap/src/nsImapUrl.cpp
@@ -0,0 +1,1563 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"    // precompiled header...
+#include "nsMsgImapCID.h"
+
+#include "nsIURL.h"
+#include "nsImapUrl.h"
+#include "nsIIMAPHostSessionList.h"
+#include "nsThreadUtils.h"
+#include "nsStringGlue.h"
+#include "prmem.h"
+#include "plstr.h"
+#include "prprf.h"
+#include "nsMemory.h"
+#include "nsCOMPtr.h"
+#include "nsIImapIncomingServer.h"
+#include "nsMsgBaseCID.h"
+#include "nsImapUtils.h"
+#include "nsIMAPNamespace.h"
+#include "nsICacheEntry.h"
+#include "nsIMsgFolder.h"
+#include "nsIDocShell.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsMsgUtils.h"
+#include "nsIMsgHdr.h"
+#include "nsIProgressEventSink.h"
+#include "nsAlgorithm.h"
+#include "nsServiceManagerUtils.h"
+#include <algorithm>
+
+using namespace mozilla;
+
+static NS_DEFINE_CID(kCImapHostSessionListCID, NS_IIMAPHOSTSESSIONLIST_CID);
+
+nsImapUrl::nsImapUrl() : mLock("nsImapUrl.mLock")
+{
+  m_listOfMessageIds = nullptr;
+  m_sourceCanonicalFolderPathSubString = nullptr;
+  m_destinationCanonicalFolderPathSubString = nullptr;
+  m_listOfMessageIds = nullptr;
+  m_tokenPlaceHolder = nullptr;
+  m_searchCriteriaString = nullptr;
+  m_idsAreUids = false;
+  m_mimePartSelectorDetected = false;
+  m_allowContentChange = true;  // assume we can do MPOD.
+  m_fetchPartsOnDemand = false; // but assume we're not doing it :-)
+  m_msgLoadingFromCache = false;
+  m_storeResultsOffline = false;
+  m_storeOfflineOnFallback = false;
+  m_localFetchOnly = false;
+  m_rerunningUrl = false;
+  m_moreHeadersToDownload = false;
+  m_externalLinkUrl = true; // we'll start this at true, and set it false in nsImapService::CreateStartOfImapUrl
+  m_contentModified = IMAP_CONTENT_NOT_MODIFIED;
+  m_validUrl = true;  // assume the best.
+  m_flags = 0;
+  m_extraStatus = ImapStatusNone;
+  m_onlineSubDirSeparator = '/';
+
+  // ** jt - the following are not ref counted
+  m_copyState = nullptr;
+  m_file = nullptr;
+  m_imapMailFolderSink = nullptr;
+  m_imapMessageSink = nullptr;
+  m_addDummyEnvelope = false;
+  m_canonicalLineEnding = false;
+}
+
+nsImapUrl::~nsImapUrl()
+{
+  PR_FREEIF(m_listOfMessageIds);
+  PR_FREEIF(m_destinationCanonicalFolderPathSubString);
+  PR_FREEIF(m_sourceCanonicalFolderPathSubString);
+  PR_FREEIF(m_searchCriteriaString);
+}
+
+NS_IMPL_ADDREF_INHERITED(nsImapUrl, nsMsgMailNewsUrl)
+
+NS_IMPL_RELEASE_INHERITED(nsImapUrl, nsMsgMailNewsUrl)
+
+NS_INTERFACE_MAP_BEGIN(nsImapUrl)
+  NS_INTERFACE_MAP_ENTRY(nsIImapUrl)
+  NS_INTERFACE_MAP_ENTRY(nsIMsgMessageUrl)
+  NS_INTERFACE_MAP_ENTRY(nsIMsgI18NUrl)
+NS_INTERFACE_MAP_END_INHERITING(nsMsgMailNewsUrl)
+
+////////////////////////////////////////////////////////////////////////////////////
+// Begin nsIImapUrl specific support
+////////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP nsImapUrl::GetRequiredImapState(nsImapState * aImapUrlState)
+{
+  if (aImapUrlState)
+  {
+    // the imap action determines the state we must be in...check the
+    // the imap action.
+
+    if (m_imapAction & 0x10000000)
+      *aImapUrlState = nsImapSelectedState;
+    else
+      *aImapUrlState = nsImapAuthenticatedState;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetImapAction(nsImapAction * aImapAction)
+{
+  *aImapAction = m_imapAction;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetImapAction(nsImapAction aImapAction)
+{
+  m_imapAction = aImapAction;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetFolder(nsIMsgFolder **aMsgFolder)
+{
+  NS_ENSURE_ARG_POINTER(aMsgFolder);
+  NS_ENSURE_ARG_POINTER(m_imapFolder);
+
+  nsCOMPtr<nsIMsgFolder> folder = do_QueryReferent(m_imapFolder);
+  NS_IF_ADDREF(*aMsgFolder = folder);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetFolder(nsIMsgFolder  * aMsgFolder)
+{
+  nsresult rv;
+  m_imapFolder = do_GetWeakReference(aMsgFolder, &rv);
+  if (aMsgFolder)
+  {
+    nsCOMPtr <nsIMsgIncomingServer> incomingServer;
+    aMsgFolder->GetServer(getter_AddRefs(incomingServer));
+    if (incomingServer)
+      incomingServer->GetKey(m_serverKey);
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapUrl::GetImapMailFolderSink(nsIImapMailFolderSink **
+                                           aImapMailFolderSink)
+{
+    NS_ENSURE_ARG_POINTER(aImapMailFolderSink);
+    if (!m_imapMailFolderSink)
+      return NS_ERROR_NULL_POINTER; // no assert, so don't use NS_ENSURE_POINTER.
+
+    nsCOMPtr<nsIImapMailFolderSink> folderSink = do_QueryReferent(m_imapMailFolderSink);
+    *aImapMailFolderSink = folderSink;
+    NS_IF_ADDREF(*aImapMailFolderSink);
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetImapMailFolderSink(nsIImapMailFolderSink  * aImapMailFolderSink)
+{
+    nsresult rv;
+    m_imapMailFolderSink = do_GetWeakReference(aImapMailFolderSink, &rv);
+    return rv;
+}
+
+NS_IMETHODIMP nsImapUrl::GetImapMessageSink(nsIImapMessageSink ** aImapMessageSink)
+{
+    NS_ENSURE_ARG_POINTER(aImapMessageSink);
+    NS_ENSURE_ARG_POINTER(m_imapMessageSink);
+
+    nsCOMPtr<nsIImapMessageSink> messageSink = do_QueryReferent(m_imapMessageSink);
+    *aImapMessageSink = messageSink;
+    NS_IF_ADDREF(*aImapMessageSink);
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetImapMessageSink(nsIImapMessageSink  * aImapMessageSink)
+{
+  nsresult rv;
+  m_imapMessageSink = do_GetWeakReference(aImapMessageSink, &rv);
+  return rv;
+}
+
+NS_IMETHODIMP nsImapUrl::GetImapServerSink(nsIImapServerSink ** aImapServerSink)
+{
+    NS_ENSURE_ARG_POINTER(aImapServerSink);
+    NS_ENSURE_ARG_POINTER(m_imapServerSink);
+
+    nsCOMPtr<nsIImapServerSink> serverSink = do_QueryReferent(m_imapServerSink);
+    *aImapServerSink = serverSink;
+    NS_IF_ADDREF(*aImapServerSink);
+    return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetImapServerSink(nsIImapServerSink  * aImapServerSink)
+{
+  nsresult rv;
+  m_imapServerSink = do_GetWeakReference(aImapServerSink, &rv);
+  return rv;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// End nsIImapUrl specific support
+////////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP nsImapUrl::SetSpec(const nsACString &aSpec)
+{
+  nsresult rv = nsMsgMailNewsUrl::SetSpec(aSpec);
+  if (NS_SUCCEEDED(rv))
+  {
+    m_validUrl = true;  // assume the best.
+    rv = ParseUrl();
+  }
+  return rv;
+}
+
+NS_IMETHODIMP nsImapUrl::SetQuery(const nsACString &aQuery)
+{
+  nsresult rv = nsMsgMailNewsUrl::SetQuery(aQuery);
+  if (NS_SUCCEEDED(rv))
+    rv = ParseUrl();
+  return rv;
+}
+
+nsresult nsImapUrl::ParseUrl()
+{
+  nsresult rv = NS_OK;
+  // extract the user name
+  GetUserPass(m_userName);
+
+  nsAutoCString imapPartOfUrl;
+  rv = GetPath(imapPartOfUrl);
+  nsAutoCString unescapedImapPartOfUrl;
+  MsgUnescapeString(imapPartOfUrl, 0, unescapedImapPartOfUrl);
+  if (NS_SUCCEEDED(rv) && !unescapedImapPartOfUrl.IsEmpty())
+  {
+    ParseImapPart(unescapedImapPartOfUrl.BeginWriting()+1);  // GetPath leaves leading '/' in the path!!!
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::CreateSearchCriteriaString(char ** aResult)
+{
+  // this method should only be called from the imap thread...
+  // o.t. add lock protection..
+  if (nullptr == aResult || !m_searchCriteriaString)
+    return  NS_ERROR_NULL_POINTER;
+  *aResult = strdup(m_searchCriteriaString);
+  return NS_OK;
+}
+
+// this method gets called from the UI thread and the imap thread
+NS_IMETHODIMP nsImapUrl::GetListOfMessageIds(nsACString &aResult)
+{
+  MutexAutoLock mon(mLock);
+  if (!m_listOfMessageIds)
+    return  NS_ERROR_NULL_POINTER;
+
+  int32_t bytesToCopy = strlen(m_listOfMessageIds);
+
+  // mime may have glommed a "&part=" for a part download
+  // we return the entire message and let mime extract
+  // the part. Pop and news work this way also.
+  // this algorithm truncates the "&part" string.
+  char *currentChar = m_listOfMessageIds;
+  while (*currentChar && (*currentChar != '?'))
+    currentChar++;
+  if (*currentChar == '?')
+    bytesToCopy = currentChar - m_listOfMessageIds;
+
+  // we should also strip off anything after "/;section="
+  // since that can specify an IMAP MIME part
+  char *wherePart = PL_strstr(m_listOfMessageIds, "/;section=");
+  if (wherePart)
+    bytesToCopy = std::min(bytesToCopy, int32_t(wherePart - m_listOfMessageIds));
+
+  aResult.Assign(m_listOfMessageIds, bytesToCopy);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetCommand(nsACString &result)
+{
+  result = m_command;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsImapUrl::GetCustomAttributeToFetch(nsACString &result)
+{
+  result = m_msgFetchAttribute;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetCustomAttributeResult(nsACString &result)
+{
+  result = m_customAttributeResult;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetCustomAttributeResult(const nsACString &result)
+{
+  m_customAttributeResult = result;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetCustomCommandResult(nsACString &result)
+{
+  result = m_customCommandResult;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetCustomCommandResult(const nsACString &result)
+{
+  m_customCommandResult = result;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetCustomAddFlags(nsACString &aResult)
+{
+  aResult = m_customAddFlags;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetCustomSubtractFlags(nsACString &aResult)
+{
+  aResult = m_customSubtractFlags;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsImapUrl::GetImapPartToFetch(char **result)
+{
+  //  here's the old code....
+
+  // unforunately an imap part can have the form: /;section= OR
+  // it can have the form ?section=. We need to look for both.
+  if (m_listOfMessageIds)
+  {
+    char *wherepart = PL_strstr(m_listOfMessageIds, ";section=");
+    if (!wherepart) // look for ?section too....
+      wherepart = PL_strstr(m_listOfMessageIds, "?section=");
+    if (wherepart)
+    {
+      wherepart += 9;  // strlen("/;section=")
+      char *wherelibmimepart = PL_strstr(wherepart, "&part=");
+      if (!wherelibmimepart)
+        wherelibmimepart = PL_strstr(wherepart, "?part=");
+      int numCharsToCopy = (wherelibmimepart) ? wherelibmimepart - wherepart :
+                   PL_strlen(m_listOfMessageIds) - (wherepart - m_listOfMessageIds);
+      if (numCharsToCopy)
+      {
+        *result = (char *) PR_Malloc(sizeof(char) * (numCharsToCopy + 1));
+        if (*result)
+        {
+          PL_strncpy(*result, wherepart, numCharsToCopy + 1);  // appends a \0
+          (*result)[numCharsToCopy] = '\0';
+        }
+      }
+    } // if we got a wherepart
+  } // if we got a m_listOfMessageIds
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetOnlineSubDirSeparator(char* separator)
+{
+  if (separator)
+  {
+      *separator = m_onlineSubDirSeparator;
+      return NS_OK;
+  }
+  else
+  {
+      return NS_ERROR_NULL_POINTER;
+  }
+}
+
+NS_IMETHODIMP nsImapUrl::GetNumBytesToFetch(int32_t *aNumBytesToFetch)
+{
+  NS_ENSURE_ARG_POINTER(aNumBytesToFetch);
+  *aNumBytesToFetch = m_numBytesToFetch;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapUrl::SetOnlineSubDirSeparator(char onlineDirSeparator)
+{
+  m_onlineSubDirSeparator = onlineDirSeparator;
+  return NS_OK;
+}
+
+// this method is only called from the imap thread
+NS_IMETHODIMP nsImapUrl::MessageIdsAreUids(bool *result)
+{
+  *result = m_idsAreUids;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapUrl::SetExtraStatus(int32_t aExtraStatus)
+{
+  m_extraStatus = aExtraStatus;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetExtraStatus(int32_t *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = m_extraStatus;
+  return NS_OK;
+}
+
+// this method is only called from the imap thread
+NS_IMETHODIMP nsImapUrl::GetMsgFlags(imapMessageFlagsType *result)  // kAddMsgFlags or kSubtractMsgFlags only
+{
+  *result = m_flags;
+  return NS_OK;
+}
+
+void nsImapUrl::ParseImapPart(char *imapPartOfUrl)
+{
+  m_tokenPlaceHolder = imapPartOfUrl;
+  m_urlidSubString = m_tokenPlaceHolder ? NS_strtok(IMAP_URL_TOKEN_SEPARATOR, &m_tokenPlaceHolder) : (char *)NULL;
+
+  if (!m_urlidSubString)
+  {
+    m_validUrl = false;
+    return;
+  }
+
+  if (!PL_strcasecmp(m_urlidSubString, "fetch"))
+  {
+    m_imapAction  = nsImapMsgFetch;
+    ParseUidChoice();
+    PR_FREEIF(m_sourceCanonicalFolderPathSubString);
+    ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    ParseListOfMessageIds();
+    // if fetched by spam filter, the action will be changed to nsImapMsgFetchPeek
+  }
+  else
+  {
+    if (!PL_strcasecmp(m_urlidSubString, "header"))
+    {
+      m_imapAction = nsImapMsgHeader;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "customFetch"))
+    {
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      ParseCustomMsgFetchAttribute();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "previewBody"))
+    {
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      ParseNumBytes();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "deletemsg"))
+    {
+      m_imapAction = nsImapDeleteMsg;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "uidexpunge"))
+    {
+      m_imapAction = nsImapUidExpunge;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "deleteallmsgs"))
+    {
+      m_imapAction = nsImapDeleteAllMsgs;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "addmsgflags"))
+    {
+      m_imapAction = nsImapAddMsgFlags;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      ParseMsgFlags();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "subtractmsgflags"))
+    {
+      m_imapAction = nsImapSubtractMsgFlags;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      ParseMsgFlags();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "setmsgflags"))
+    {
+      m_imapAction = nsImapSetMsgFlags;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      ParseMsgFlags();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "onlinecopy"))
+    {
+      m_imapAction = nsImapOnlineCopy;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      ParseFolderPath(&m_destinationCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "onlinemove"))
+    {
+      m_imapAction = nsImapOnlineMove;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      ParseFolderPath(&m_destinationCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "onlinetoofflinecopy"))
+    {
+      m_imapAction = nsImapOnlineToOfflineCopy;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      ParseFolderPath(&m_destinationCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "onlinetoofflinemove"))
+    {
+      m_imapAction = nsImapOnlineToOfflineMove;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      ParseFolderPath(&m_destinationCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "offlinetoonlinecopy"))
+    {
+      m_imapAction = nsImapOfflineToOnlineMove;
+      ParseFolderPath(&m_destinationCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "search"))
+    {
+      m_imapAction = nsImapSearch;
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseSearchCriteriaString();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "test"))
+    {
+      m_imapAction = nsImapTest;
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "select"))
+    {
+      m_imapAction = nsImapSelectFolder;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      if (m_tokenPlaceHolder && *m_tokenPlaceHolder)
+        ParseListOfMessageIds();
+      else
+        m_listOfMessageIds = PL_strdup("");
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "liteselect"))
+    {
+      m_imapAction = nsImapLiteSelectFolder;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "selectnoop"))
+    {
+      m_imapAction = nsImapSelectNoopFolder;
+      m_listOfMessageIds = PL_strdup("");
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "expunge"))
+    {
+      m_imapAction = nsImapExpungeFolder;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      m_listOfMessageIds = PL_strdup("");    // no ids to UNDO
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "create"))
+    {
+      m_imapAction = nsImapCreateFolder;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "ensureExists"))
+    {
+      m_imapAction = nsImapEnsureExistsFolder;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "discoverchildren"))
+    {
+      m_imapAction = nsImapDiscoverChildrenUrl;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "discoverallboxes"))
+    {
+      m_imapAction = nsImapDiscoverAllBoxesUrl;
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "discoverallandsubscribedboxes"))
+    {
+      m_imapAction = nsImapDiscoverAllAndSubscribedBoxesUrl;
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "delete"))
+    {
+      m_imapAction = nsImapDeleteFolder;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "deletefolder"))
+    {
+      m_imapAction = nsImapDeleteFolderAndMsgs;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "rename"))
+    {
+      m_imapAction = nsImapRenameFolder;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseFolderPath(&m_destinationCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "movefolderhierarchy"))
+    {
+      m_imapAction = nsImapMoveFolderHierarchy;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      if (m_tokenPlaceHolder && *m_tokenPlaceHolder)  // handle promote to root
+        ParseFolderPath(&m_destinationCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "list"))
+    {
+      m_imapAction = nsImapLsubFolders;
+      ParseFolderPath(&m_destinationCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "biff"))
+    {
+      m_imapAction = nsImapBiff;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "netscape"))
+    {
+      m_imapAction = nsImapGetMailAccountUrl;
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "appendmsgfromfile"))
+    {
+      m_imapAction = nsImapAppendMsgFromFile;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "appenddraftfromfile"))
+    {
+      m_imapAction = nsImapAppendDraftFromFile;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseUidChoice();
+      if (m_tokenPlaceHolder && *m_tokenPlaceHolder)
+        ParseListOfMessageIds();
+      else
+        m_listOfMessageIds = strdup("");
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "subscribe"))
+    {
+      m_imapAction = nsImapSubscribe;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "unsubscribe"))
+    {
+      m_imapAction = nsImapUnsubscribe;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "refreshacl"))
+    {
+      m_imapAction = nsImapRefreshACL;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "refreshfolderurls"))
+    {
+      m_imapAction = nsImapRefreshFolderUrls;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "refreshallacls"))
+    {
+      m_imapAction = nsImapRefreshAllACLs;
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "listfolder"))
+    {
+      m_imapAction = nsImapListFolder;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "upgradetosubscription"))
+    {
+      m_imapAction = nsImapUpgradeToSubscription;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "folderstatus"))
+    {
+      m_imapAction = nsImapFolderStatus;
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+    }
+    else if (!PL_strcasecmp(m_urlidSubString, "verifyLogon"))
+    {
+      m_imapAction = nsImapVerifylogon;
+    }
+    else if (m_imapAction == nsIImapUrl::nsImapUserDefinedMsgCommand)
+    {
+      m_command = m_urlidSubString; // save this
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+    }
+    else if (m_imapAction == nsIImapUrl::nsImapMsgStoreCustomKeywords)
+    {
+      ParseUidChoice();
+      ParseFolderPath(&m_sourceCanonicalFolderPathSubString);
+      ParseListOfMessageIds();
+      bool addKeyword = (m_tokenPlaceHolder && *m_tokenPlaceHolder != '>');
+      // if we're not adding a keyword, m_tokenPlaceHolder will now look like >keywordToSubtract>
+      // and strtok will leave flagsPtr pointing to keywordToSubtract. So detect this
+      // case and only set the customSubtractFlags.
+      char *flagsPtr = m_tokenPlaceHolder ? NS_strtok(IMAP_URL_TOKEN_SEPARATOR, &m_tokenPlaceHolder) : (char *)nullptr;
+      if (addKeyword)
+      {
+        m_customAddFlags.Assign(flagsPtr);
+        flagsPtr = m_tokenPlaceHolder ? NS_strtok(IMAP_URL_TOKEN_SEPARATOR, &m_tokenPlaceHolder) : (char *)nullptr;
+      }
+      m_customSubtractFlags.Assign(flagsPtr);
+    }
+    else
+    {
+      m_validUrl = false;
+    }
+  }
+}
+
+
+// Returns NULL if nothing was done.
+// Otherwise, returns a newly allocated name.
+NS_IMETHODIMP nsImapUrl::AddOnlineDirectoryIfNecessary(const char *onlineMailboxName, char ** directory)
+{
+  nsresult rv;
+  nsString onlineDirString;
+  char *newOnlineName = nullptr;
+
+  nsCOMPtr<nsIImapHostSessionList> hostSessionList =
+    do_GetService(kCImapHostSessionListCID, &rv);
+  if (NS_FAILED(rv)) return rv;
+  rv = hostSessionList->GetOnlineDirForHost(m_serverKey.get(), onlineDirString);
+  nsAutoCString onlineDir;
+  LossyCopyUTF16toASCII(onlineDirString, onlineDir);
+
+  nsIMAPNamespace *ns = nullptr;
+  rv = hostSessionList->GetNamespaceForMailboxForHost(m_serverKey.get(),
+                                                      onlineMailboxName, ns);
+  if (!ns)
+    hostSessionList->GetDefaultNamespaceOfTypeForHost(m_serverKey.get(),
+                                                      kPersonalNamespace, ns);
+
+  if (onlineDir.IsEmpty() && ns)
+    onlineDir = ns->GetPrefix();
+
+  // If this host has an online server directory configured
+  if (onlineMailboxName && !onlineDir.IsEmpty())
+  {
+    if (PL_strcasecmp(onlineMailboxName, "INBOX"))
+    {
+      NS_ASSERTION(ns, "couldn't find namespace for host");
+      nsAutoCString onlineDirWithDelimiter(onlineDir);
+      // make sure the onlineDir ends with the hierarchy delimiter
+      if (ns)
+      {
+        char delimiter = ns->GetDelimiter();
+        if ( delimiter && delimiter != kOnlineHierarchySeparatorUnknown )
+        {
+          // try to change the canonical online dir name to real dir name first
+          MsgReplaceChar(onlineDirWithDelimiter, '/', delimiter);
+          // make sure the last character is the delimiter
+          if ( onlineDirWithDelimiter.Last() != delimiter )
+            onlineDirWithDelimiter += delimiter;
+          if ( !*onlineMailboxName )
+            onlineDirWithDelimiter.SetLength(onlineDirWithDelimiter.Length()-1);
+        }
+      }
+      if (ns && (PL_strlen(ns->GetPrefix()) != 0) && !onlineDirWithDelimiter.Equals(ns->GetPrefix()))
+      {
+        // check that onlineMailboxName doesn't start with the namespace. If that's the case,
+        // we don't want to prepend the online dir.
+        if (PL_strncmp(onlineMailboxName, ns->GetPrefix(), PL_strlen(ns->GetPrefix())))
+        {
+          // The namespace for this mailbox is the root ("").
+          // Prepend the online server directory
+          int finalLen = onlineDirWithDelimiter.Length() +
+            strlen(onlineMailboxName) + 1;
+          newOnlineName = (char *)PR_Malloc(finalLen);
+          if (newOnlineName)
+          {
+            PL_strcpy(newOnlineName, onlineDirWithDelimiter.get());
+            PL_strcat(newOnlineName, onlineMailboxName);
+          }
+        }
+     }
+      // just prepend the online server directory if it doesn't start with it already
+      else if (strncmp(onlineMailboxName, onlineDirWithDelimiter.get(), onlineDirWithDelimiter.Length()))
+      {
+        newOnlineName = (char *)PR_Malloc(strlen(onlineMailboxName) + onlineDirWithDelimiter.Length() + 1);
+        if (newOnlineName)
+        {
+          PL_strcpy(newOnlineName, onlineDirWithDelimiter.get());
+          PL_strcat(newOnlineName, onlineMailboxName);
+        }
+      }
+    }
+  }
+  if (directory)
+    *directory = newOnlineName;
+  else if (newOnlineName)
+    NS_Free(newOnlineName);
+  return rv;
+}
+
+// Converts from canonical format (hierarchy is indicated by '/' and all real slashes ('/') are escaped)
+// to the real online name on the server.
+NS_IMETHODIMP nsImapUrl::AllocateServerPath(const char * canonicalPath, char onlineDelimiter, char ** aAllocatedPath)
+{
+  nsresult retVal = NS_OK;
+  char *rv = NULL;
+  char delimiterToUse = onlineDelimiter;
+  if (onlineDelimiter == kOnlineHierarchySeparatorUnknown)
+    GetOnlineSubDirSeparator(&delimiterToUse);
+  NS_ASSERTION(delimiterToUse != kOnlineHierarchySeparatorUnknown, "hierarchy separator unknown");
+  if (canonicalPath)
+    rv = ReplaceCharsInCopiedString(canonicalPath, '/', delimiterToUse);
+  else
+    rv = strdup("");
+
+  if (delimiterToUse != '/')
+    UnescapeSlashes(rv);
+  char *onlineNameAdded = nullptr;
+  AddOnlineDirectoryIfNecessary(rv, &onlineNameAdded);
+  if (onlineNameAdded)
+  {
+    NS_Free(rv);
+    rv = onlineNameAdded;
+  }
+
+  if (aAllocatedPath)
+    *aAllocatedPath = rv;
+  else
+    NS_Free(rv);
+
+  return retVal;
+}
+
+// escape '/' as ^, ^ -> ^^ - use UnescapeSlashes to revert
+/* static */ nsresult nsImapUrl::EscapeSlashes(const char *sourcePath, char **resultPath)
+{
+  NS_ENSURE_ARG(sourcePath);
+  NS_ENSURE_ARG(resultPath);
+  int32_t extra = 0;
+  int32_t len = strlen(sourcePath);
+  const char *src = sourcePath;
+  int32_t i;
+  for ( i = 0; i < len; i++)
+  {
+    if (*src == '^')
+      extra += 1; /* ^ -> ^^ */
+    src++;
+  }
+  char* result = (char *)moz_xmalloc(len + extra + 1);
+  if (!result)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  unsigned char* dst = (unsigned char *) result;
+  src = sourcePath;
+  for (i = 0; i < len; i++)
+  {
+    unsigned char c = *src++;
+    if (c == '/')
+      *dst++ = '^';
+    else if (c == '^')
+    {
+      *dst++ = '^';
+      *dst++ = '^';
+    }
+    else
+      *dst++ = c;
+  }
+  *dst = '\0';     /* tack on eos */
+  *resultPath = result;
+  return NS_OK;
+}
+
+/* static */ nsresult nsImapUrl::UnescapeSlashes(char *sourcePath)
+{
+    char *src = sourcePath;
+    char *dst = sourcePath;
+
+    while (*src)
+    {
+      if (*src == '^')
+      {
+        if (*(src + 1) == '^')
+        {
+          *dst++ = '^';
+          src++;   // skip over second '^'
+        }
+        else
+          *dst++ = '/';
+        src++;
+      }
+      else
+        *dst++ = *src++;
+    }
+
+    *dst = 0;
+    return NS_OK;
+}
+
+/*  static */ nsresult nsImapUrl::ConvertToCanonicalFormat(const char *folderName, char onlineDelimiter, char **resultingCanonicalPath)
+{
+  // Now, start the conversion to canonical form.
+
+  char *canonicalPath;
+  if (onlineDelimiter != '/')
+  {
+    nsCString escapedPath;
+
+    EscapeSlashes(folderName, getter_Copies(escapedPath));
+    canonicalPath = ReplaceCharsInCopiedString(escapedPath.get(), onlineDelimiter , '/');
+  }
+  else
+  {
+    canonicalPath = strdup(folderName);
+  }
+  if (canonicalPath)
+    *resultingCanonicalPath = canonicalPath;
+
+  return (canonicalPath) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+// Converts the real online name on the server to canonical format:
+// result is hierarchy is indicated by '/' and all real slashes ('/') are escaped.
+// The caller has already converted m-utf-7 to 8 bit ascii, which is a problem.
+// this method is only called from the imap thread
+NS_IMETHODIMP nsImapUrl::AllocateCanonicalPath(const char *serverPath, char onlineDelimiter, char **allocatedPath )
+{
+  nsresult rv = NS_ERROR_NULL_POINTER;
+  char delimiterToUse = onlineDelimiter;
+  char *serverKey = nullptr;
+  nsString aString;
+  char *currentPath = (char *) serverPath;
+  nsAutoCString onlineDir;
+  nsCOMPtr<nsIMsgIncomingServer> server;
+
+  nsCOMPtr<nsIImapHostSessionList> hostSessionList =
+    do_GetService(kCImapHostSessionListCID, &rv);
+
+  *allocatedPath = nullptr;
+
+  if (onlineDelimiter == kOnlineHierarchySeparatorUnknown ||
+    onlineDelimiter == 0)
+    GetOnlineSubDirSeparator(&delimiterToUse);
+
+  NS_ASSERTION (serverPath, "Oops... null serverPath");
+
+  if (!serverPath || NS_FAILED(rv))
+    goto done;
+
+  hostSessionList->GetOnlineDirForHost(m_serverKey.get(), aString);
+  // First we have to check to see if we should strip off an online server
+  // subdirectory
+  // If this host has an online server directory configured
+  LossyCopyUTF16toASCII(aString, onlineDir);
+
+  if (currentPath && !onlineDir.IsEmpty())
+  {
+    // By definition, the online dir must be at the root.
+    if (delimiterToUse && delimiterToUse != kOnlineHierarchySeparatorUnknown)
+    {
+      // try to change the canonical online dir name to real dir name first
+      MsgReplaceChar(onlineDir, '/', delimiterToUse);
+      // Add the delimiter
+      if (onlineDir.Last() != delimiterToUse)
+        onlineDir += delimiterToUse;
+    }
+    int len = onlineDir.Length();
+    if (!PL_strncmp(onlineDir.get(), currentPath, len))
+    {
+      // This online path begins with the server sub directory
+      currentPath += len;
+
+      // This might occur, but it's most likely something not good.
+      // Basically, it means we're doing something on the online sub directory itself.
+      NS_ASSERTION (*currentPath, "Oops ... null currentPath");
+      // Also make sure that the first character in the mailbox name is not '/'.
+      NS_ASSERTION (*currentPath != '/',
+        "Oops ... currentPath starts with a slash");
+    }
+  }
+
+
+  if (!currentPath)
+    goto done;
+
+  rv = ConvertToCanonicalFormat(currentPath, delimiterToUse, allocatedPath);
+
+done:
+  PR_Free(serverKey);
+  return rv;
+}
+
+// this method is only called from the imap thread
+NS_IMETHODIMP  nsImapUrl::CreateServerSourceFolderPathString(char **result)
+{
+  NS_ENSURE_ARG_POINTER(result);
+  AllocateServerPath(m_sourceCanonicalFolderPathSubString, kOnlineHierarchySeparatorUnknown, result);
+  return NS_OK;
+}
+
+// this method is called from the imap thread AND the UI thread...
+NS_IMETHODIMP nsImapUrl::CreateCanonicalSourceFolderPathString(char **result)
+{
+  NS_ENSURE_ARG_POINTER(result);
+  MutexAutoLock  mon(mLock);
+  *result = strdup(m_sourceCanonicalFolderPathSubString ? m_sourceCanonicalFolderPathSubString : "");
+  return (*result) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+// this method is called from the imap thread AND the UI thread...
+NS_IMETHODIMP nsImapUrl::CreateServerDestinationFolderPathString(char **result)
+{
+  NS_ENSURE_ARG_POINTER(result);
+  MutexAutoLock mon(mLock);
+  nsresult rv = AllocateServerPath(m_destinationCanonicalFolderPathSubString,
+                                   kOnlineHierarchySeparatorUnknown,
+                                   result);
+  return (*result) ? rv : NS_ERROR_OUT_OF_MEMORY;
+}
+
+// for enabling or disabling mime parts on demand. Setting this to true says we
+// can use mime parts on demand, if we chose.
+NS_IMETHODIMP nsImapUrl::SetAllowContentChange(bool allowContentChange)
+{
+  m_allowContentChange = allowContentChange;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetContentModified(nsImapContentModifiedType contentModified)
+{
+  m_contentModified = contentModified;
+  nsCOMPtr<nsICacheEntry> cacheEntry;
+  nsresult res = GetMemCacheEntry(getter_AddRefs(cacheEntry));
+  if (NS_SUCCEEDED(res) && cacheEntry)
+  {
+    const char *contentModifiedAnnotation = "";
+    switch (m_contentModified)
+    {
+    case IMAP_CONTENT_NOT_MODIFIED:
+      contentModifiedAnnotation = "Not Modified";
+      break;
+    case IMAP_CONTENT_MODIFIED_VIEW_INLINE:
+      contentModifiedAnnotation = "Modified View Inline";
+      break;
+    case IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS:
+      contentModifiedAnnotation = "Modified View As Link";
+      break;
+    case IMAP_CONTENT_FORCE_CONTENT_NOT_MODIFIED:
+      contentModifiedAnnotation = "Force Content Not Modified";
+      break;
+    }
+    cacheEntry->SetMetaDataElement("ContentModified", contentModifiedAnnotation);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetContentModified(nsImapContentModifiedType *contentModified)
+{
+  if (!contentModified) return NS_ERROR_NULL_POINTER;
+
+  *contentModified = m_contentModified;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetFetchPartsOnDemand(bool fetchPartsOnDemand)
+{
+  m_fetchPartsOnDemand = fetchPartsOnDemand;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetFetchPartsOnDemand(bool *fetchPartsOnDemand)
+{
+  if (!fetchPartsOnDemand) return NS_ERROR_NULL_POINTER;
+
+  *fetchPartsOnDemand = m_fetchPartsOnDemand;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP nsImapUrl::SetMimePartSelectorDetected(bool mimePartSelectorDetected)
+{
+  m_mimePartSelectorDetected = mimePartSelectorDetected;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetMimePartSelectorDetected(bool *mimePartSelectorDetected)
+{
+  if (!mimePartSelectorDetected) return NS_ERROR_NULL_POINTER;
+
+  *mimePartSelectorDetected = m_mimePartSelectorDetected;
+  return NS_OK;
+}
+
+
+// this method is only called from the UI thread.
+NS_IMETHODIMP nsImapUrl::SetCopyState(nsISupports* copyState)
+{
+  MutexAutoLock  mon(mLock);
+  m_copyState = copyState;
+  return NS_OK;
+}
+
+//this method is only called from the imap thread..but we still
+// need a monitor 'cause the setter is called from the UI thread.
+NS_IMETHODIMP nsImapUrl::GetCopyState(nsISupports** copyState)
+{
+  NS_ENSURE_ARG_POINTER(copyState);
+  MutexAutoLock mon(mLock);
+  *copyState = m_copyState;
+  NS_IF_ADDREF(*copyState);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsImapUrl::SetMsgFile(nsIFile* aFile)
+{
+  nsresult rv = NS_OK;
+  MutexAutoLock mon(mLock);
+  m_file = aFile;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsImapUrl::GetMsgFile(nsIFile** aFile)
+{
+  NS_ENSURE_ARG_POINTER(aFile);
+
+  MutexAutoLock mon(mLock);
+  NS_IF_ADDREF(*aFile = m_file);
+  return NS_OK;
+}
+
+// this method is called from the UI thread..
+NS_IMETHODIMP nsImapUrl::GetMockChannel(nsIImapMockChannel ** aChannel)
+{
+  NS_ENSURE_ARG_POINTER(aChannel);
+  NS_WARNING_ASSERTION(NS_IsMainThread(), "should only access mock channel on ui thread");
+  *aChannel = nullptr;
+  nsCOMPtr<nsIImapMockChannel> channel(do_QueryReferent(m_channelWeakPtr));
+  channel.swap(*aChannel);
+  return *aChannel ? NS_OK : NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP nsImapUrl::SetMockChannel(nsIImapMockChannel * aChannel)
+{
+  NS_WARNING_ASSERTION(NS_IsMainThread(), "should only access mock channel on ui thread");
+  m_channelWeakPtr = do_GetWeakReference(aChannel);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetAllowContentChange(bool *result)
+{
+  NS_ENSURE_ARG_POINTER(result);
+  *result = m_allowContentChange;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::CloneInternal(uint32_t aRefHandlingMode,
+                                       const nsACString& newRef,
+                                       nsIURI** _retval)
+{
+  nsresult rv =
+    nsMsgMailNewsUrl::CloneInternal(aRefHandlingMode, newRef, _retval);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // also clone the mURI member, because GetUri below won't work if
+  // mURI isn't set due to escaping issues.
+  nsCOMPtr <nsIMsgMessageUrl> clonedUrl = do_QueryInterface(*_retval);
+  if (clonedUrl)
+    clonedUrl->SetUri(mURI.get());
+  return rv;
+}
+
+NS_IMETHODIMP nsImapUrl::GetPrincipalSpec(nsACString& aPrincipalSpec)
+{
+  // URLs look like this:
+  // imap://user@domain@server:port/fetch>UID>folder>nn
+  // We simply strip any query part beginning with ? & or /;
+  // Normalised spec: imap://user@domain@server:port/fetch>UID>folder>nn
+  nsCOMPtr<nsIMsgMailNewsUrl> mailnewsURL;
+  QueryInterface(NS_GET_IID(nsIMsgMailNewsUrl), getter_AddRefs(mailnewsURL));
+
+  nsAutoCString spec;
+  mailnewsURL->GetSpecIgnoringRef(spec);
+
+  // Strip any query part beginning with ? or /;
+  int32_t ind = spec.Find("/;");
+  if (ind != kNotFound)
+    spec.SetLength(ind);
+
+  ind = spec.FindChar('?');
+  if (ind != kNotFound)
+    spec.SetLength(ind);
+
+  aPrincipalSpec.Assign(spec);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetUri(const char * aURI)
+{
+  mURI= aURI;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetUri(char** aURI)
+{
+  nsresult rv = NS_OK;
+  if (!mURI.IsEmpty())
+    *aURI = ToNewCString(mURI);
+  else
+  {
+    *aURI = nullptr;
+    uint32_t key = m_listOfMessageIds ? strtoul(m_listOfMessageIds, nullptr, 10) : 0;
+    nsCString canonicalPath;
+    AllocateCanonicalPath(m_sourceCanonicalFolderPathSubString, m_onlineSubDirSeparator, (getter_Copies(canonicalPath)));
+    nsCString fullFolderPath("/");
+    fullFolderPath.Append(m_userName);
+    nsAutoCString hostName;
+    rv = GetHost(hostName);
+    fullFolderPath.Append('@');
+    fullFolderPath.Append(hostName);
+    fullFolderPath.Append('/');
+    fullFolderPath.Append(canonicalPath);
+
+    nsCString baseMessageURI;
+    nsCreateImapBaseMessageURI(fullFolderPath, baseMessageURI);
+    nsAutoCString uriStr;
+    rv = nsBuildImapMessageURI(baseMessageURI.get(), key, uriStr);
+    *aURI = ToNewCString(uriStr);
+  }
+  return rv;
+}
+
+NS_IMPL_GETSET(nsImapUrl, AddDummyEnvelope, bool, m_addDummyEnvelope)
+NS_IMPL_GETSET(nsImapUrl, CanonicalLineEnding, bool, m_canonicalLineEnding)
+NS_IMETHODIMP nsImapUrl::GetMsgLoadingFromCache(bool *result)
+{
+  NS_ENSURE_ARG_POINTER(result);
+  *result = m_msgLoadingFromCache;
+  return NS_OK;
+}
+NS_IMPL_GETSET(nsImapUrl, LocalFetchOnly, bool, m_localFetchOnly)
+NS_IMPL_GETSET(nsImapUrl, ExternalLinkUrl, bool, m_externalLinkUrl)
+NS_IMPL_GETSET(nsImapUrl, RerunningUrl, bool, m_rerunningUrl)
+NS_IMPL_GETSET(nsImapUrl, ValidUrl, bool, m_validUrl)
+NS_IMPL_GETSET(nsImapUrl, MoreHeadersToDownload, bool, m_moreHeadersToDownload)
+
+NS_IMETHODIMP nsImapUrl::SetMsgLoadingFromCache(bool loadingFromCache)
+{
+  nsresult rv = NS_OK;
+  m_msgLoadingFromCache = loadingFromCache;
+  return rv;
+}
+
+NS_IMETHODIMP nsImapUrl::SetMessageFile(nsIFile * aFile)
+{
+  m_messageFile = aFile;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetMessageFile(nsIFile ** aFile)
+{
+  if (aFile)
+    NS_IF_ADDREF(*aFile = m_messageFile);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::IsUrlType(uint32_t type, bool *isType)
+{
+  NS_ENSURE_ARG(isType);
+
+  switch(type)
+  {
+    case nsIMsgMailNewsUrl::eCopy:
+      *isType = ((m_imapAction == nsIImapUrl::nsImapOnlineCopy) ||
+        (m_imapAction == nsIImapUrl::nsImapOnlineToOfflineCopy) ||
+        (m_imapAction == nsIImapUrl::nsImapOfflineToOnlineCopy));
+      break;
+    case nsIMsgMailNewsUrl::eMove:
+      *isType = ((m_imapAction == nsIImapUrl::nsImapOnlineMove) ||
+        (m_imapAction == nsIImapUrl::nsImapOnlineToOfflineMove) ||
+        (m_imapAction == nsIImapUrl::nsImapOfflineToOnlineMove));
+      break;
+    case nsIMsgMailNewsUrl::eDisplay:
+      *isType = (m_imapAction == nsIImapUrl::nsImapMsgFetch ||
+        m_imapAction == nsIImapUrl::nsImapMsgFetchPeek);
+      break;
+    default:
+      *isType = false;
+  };
+
+  return NS_OK;
+
+}
+
+NS_IMETHODIMP
+nsImapUrl::GetOriginalSpec(char ** aSpec)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsImapUrl::SetOriginalSpec(const char *aSpec)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+char *nsImapUrl::ReplaceCharsInCopiedString(const char *stringToCopy, char oldChar, char newChar)
+{
+  char oldCharString[2];
+  *oldCharString = oldChar;
+  *(oldCharString+1) = 0;
+
+  char *translatedString = PL_strdup(stringToCopy);
+  char *currentSeparator = PL_strstr(translatedString, oldCharString);
+
+  while(currentSeparator)
+  {
+    *currentSeparator = newChar;
+    currentSeparator = PL_strstr(currentSeparator+1, oldCharString);
+  }
+
+  return translatedString;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// End of functions which should be made obsolete after modifying nsIURI
+////////////////////////////////////////////////////////////////////////////////////
+
+void nsImapUrl::ParseFolderPath(char **resultingCanonicalPath)
+{
+  char *resultPath = m_tokenPlaceHolder ? NS_strtok(IMAP_URL_TOKEN_SEPARATOR, &m_tokenPlaceHolder) : (char *)NULL;
+
+  if (!resultPath)
+  {
+    m_validUrl = false;
+    return;
+  }
+  NS_ASSERTION(*resultingCanonicalPath == nullptr, "whoops, mem leak");
+
+  char dirSeparator = *resultPath;
+
+  nsCString unescapedResultingCanonicalPath;
+  MsgUnescapeString(nsDependentCString(resultPath + 1), 0, unescapedResultingCanonicalPath);
+  *resultingCanonicalPath = ToNewCString(unescapedResultingCanonicalPath);
+  // The delimiter will be set for a given URL, but will not be statically available
+  // from an arbitrary URL.  It is the creator's responsibility to fill in the correct
+  // delimiter from the folder's namespace when creating the URL.
+  if (dirSeparator != kOnlineHierarchySeparatorUnknown)
+    SetOnlineSubDirSeparator( dirSeparator);
+
+  // if dirSeparator == kOnlineHierarchySeparatorUnknown, then this must be a create
+  // of a top level imap box.  If there is an online subdir, we will automatically
+  // use its separator.  If there is not an online subdir, we don't need a separator.
+}
+
+void nsImapUrl::ParseSearchCriteriaString()
+{
+  if (m_tokenPlaceHolder)
+  {
+    int quotedFlag = false;
+
+    //skip initial separator
+    while (*m_tokenPlaceHolder == *IMAP_URL_TOKEN_SEPARATOR)
+      m_tokenPlaceHolder++;
+
+     char *saveTokenPlaceHolder = m_tokenPlaceHolder;
+
+//    m_searchCriteriaString = m_tokenPlaceHolder;
+
+    //looking for another separator outside quoted string
+    while (*m_tokenPlaceHolder)
+    {
+      if (*m_tokenPlaceHolder == '\\' && *(m_tokenPlaceHolder+1) == '"')
+        m_tokenPlaceHolder++;
+      else if (*m_tokenPlaceHolder == '"')
+        quotedFlag = !quotedFlag;
+      else if (!quotedFlag && *m_tokenPlaceHolder == *IMAP_URL_TOKEN_SEPARATOR)
+      {
+        *m_tokenPlaceHolder = '\0';
+        m_tokenPlaceHolder++;
+        break;
+      }
+      m_tokenPlaceHolder++;
+    }
+    m_searchCriteriaString = PL_strdup(saveTokenPlaceHolder);
+    if (*m_tokenPlaceHolder == '\0')
+      m_tokenPlaceHolder = NULL;
+
+    if (*m_searchCriteriaString == '\0')
+      m_searchCriteriaString = (char *)NULL;
+  }
+  else
+    m_searchCriteriaString = (char *)NULL;
+  if (!m_searchCriteriaString)
+    m_validUrl = false;
+}
+
+
+void nsImapUrl::ParseUidChoice()
+{
+  char *uidChoiceString = m_tokenPlaceHolder ? NS_strtok(IMAP_URL_TOKEN_SEPARATOR, &m_tokenPlaceHolder) : (char *)NULL;
+  if (!uidChoiceString)
+    m_validUrl = false;
+  else
+    m_idsAreUids = strcmp(uidChoiceString, "UID") == 0;
+}
+
+void nsImapUrl::ParseMsgFlags()
+{
+  char *flagsPtr = m_tokenPlaceHolder ? NS_strtok(IMAP_URL_TOKEN_SEPARATOR, &m_tokenPlaceHolder) : (char *)NULL;
+  if (flagsPtr)
+  {
+    // the url is encodes the flags byte as ascii
+    int intFlags = atoi(flagsPtr);
+    m_flags = (imapMessageFlagsType) intFlags;  // cast here
+  }
+  else
+    m_flags = 0;
+}
+
+void nsImapUrl::ParseListOfMessageIds()
+{
+  m_listOfMessageIds = m_tokenPlaceHolder ? NS_strtok(IMAP_URL_TOKEN_SEPARATOR, &m_tokenPlaceHolder) : (char *)NULL;
+  if (!m_listOfMessageIds)
+    m_validUrl = false;
+  else
+  {
+    m_listOfMessageIds = strdup(m_listOfMessageIds);
+    m_mimePartSelectorDetected = PL_strstr(m_listOfMessageIds, "&part=") != 0 || PL_strstr(m_listOfMessageIds, "?part=") != 0;
+
+    // if we're asking for just the body, don't download the whole message. see
+    // nsMsgQuote::QuoteMessage() for the "header=" settings when replying to msgs.
+    if (!m_fetchPartsOnDemand)
+      m_fetchPartsOnDemand = (PL_strstr(m_listOfMessageIds, "?header=quotebody") != 0 ||
+      PL_strstr(m_listOfMessageIds, "?header=only") != 0);
+    // if it's a spam filter trying to fetch the msg, don't let it get marked read.
+    if (PL_strstr(m_listOfMessageIds,"?header=filter") != 0)
+      m_imapAction = nsImapMsgFetchPeek;
+  }
+}
+
+void nsImapUrl::ParseCustomMsgFetchAttribute()
+{
+  m_msgFetchAttribute = m_tokenPlaceHolder ? NS_strtok(IMAP_URL_TOKEN_SEPARATOR, &m_tokenPlaceHolder) : (char *)nullptr;
+}
+
+void nsImapUrl::ParseNumBytes()
+{
+  const char *numBytes = (m_tokenPlaceHolder) ? NS_strtok(IMAP_URL_TOKEN_SEPARATOR, &m_tokenPlaceHolder) : 0;
+  m_numBytesToFetch = numBytes ? atoi(numBytes) : 0;
+}
+
+// nsIMsgI18NUrl support
+
+nsresult nsImapUrl::GetMsgFolder(nsIMsgFolder **msgFolder)
+{
+  // if we have a RDF URI, then try to get the folder for that URI and then ask the folder
+  // for it's charset....
+
+  nsCString uri;
+  GetUri(getter_Copies(uri));
+  NS_ENSURE_TRUE(!uri.IsEmpty(), NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIMsgDBHdr> msg;
+  GetMsgDBHdrFromURI(uri.get(), getter_AddRefs(msg));
+  NS_ENSURE_TRUE(msg, NS_ERROR_FAILURE);
+  nsresult rv = msg->GetFolder(msgFolder);
+  NS_ENSURE_SUCCESS(rv,rv);
+  NS_ENSURE_TRUE(msgFolder, NS_ERROR_FAILURE);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetFolderCharset(char ** aCharacterSet)
+{
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = GetMsgFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv,rv);
+  nsCString tmpStr;
+  folder->GetCharset(tmpStr);
+  *aCharacterSet = ToNewCString(tmpStr);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetFolderCharsetOverride(bool * aCharacterSetOverride)
+{
+  nsCOMPtr<nsIMsgFolder> folder;
+  nsresult rv = GetMsgFolder(getter_AddRefs(folder));
+  NS_ENSURE_SUCCESS(rv,rv);
+  NS_ENSURE_TRUE(folder, NS_ERROR_FAILURE);
+  folder->GetCharsetOverride(aCharacterSetOverride);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetCharsetOverRide(char ** aCharacterSet)
+{
+  if (!mCharsetOverride.IsEmpty())
+    *aCharacterSet = ToNewCString(mCharsetOverride);
+  else
+    *aCharacterSet = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetCharsetOverRide(const char * aCharacterSet)
+{
+  mCharsetOverride = aCharacterSet;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetStoreResultsOffline(bool *aStoreResultsOffline)
+{
+  NS_ENSURE_ARG_POINTER(aStoreResultsOffline);
+  *aStoreResultsOffline = m_storeResultsOffline;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetStoreResultsOffline(bool aStoreResultsOffline)
+{
+  m_storeResultsOffline = aStoreResultsOffline;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetStoreOfflineOnFallback(bool *aStoreOfflineOnFallback)
+{
+  NS_ENSURE_ARG_POINTER(aStoreOfflineOnFallback);
+  *aStoreOfflineOnFallback = m_storeOfflineOnFallback;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::SetStoreOfflineOnFallback(bool aStoreOfflineOnFallback)
+{
+  m_storeOfflineOnFallback = aStoreOfflineOnFallback;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapUrl::GetMessageHeader(nsIMsgDBHdr ** aMsgHdr)
+{
+  nsCString uri;
+  nsresult rv = GetUri(getter_Copies(uri));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return GetMsgDBHdrFromURI(uri.get(), aMsgHdr);
+}
+
+NS_IMETHODIMP nsImapUrl::SetMessageHeader(nsIMsgDBHdr *aMsgHdr)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
diff --git a/mailnews/imap/src/nsImapUrl.h b/mailnews/imap/src/nsImapUrl.h
new file mode 100644
index 0000000000..d1925d87a6
--- /dev/null
+++ b/mailnews/imap/src/nsImapUrl.h
@@ -0,0 +1,133 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsImapUrl_h___
+#define nsImapUrl_h___
+
+#include "mozilla/Attributes.h"
+#include "nsIImapUrl.h"
+#include "nsIImapMockChannel.h"
+#include "nsCOMPtr.h"
+#include "nsMsgMailNewsUrl.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIImapMailFolderSink.h"
+#include "nsIImapServerSink.h"
+#include "nsIImapMessageSink.h"
+
+#include "nsWeakPtr.h"
+#include "nsIFile.h"
+#include "mozilla/Mutex.h"
+
+class nsImapUrl : public nsIImapUrl, public nsMsgMailNewsUrl, public nsIMsgMessageUrl, public nsIMsgI18NUrl
+{
+public:
+
+  NS_DECL_ISUPPORTS_INHERITED
+
+  // nsIURI override
+  NS_IMETHOD SetSpec(const nsACString &aSpec) override;
+  NS_IMETHOD SetQuery(const nsACString &aQuery) override;
+  NS_IMETHOD CloneInternal(uint32_t aRefHandlingMode,
+                           const nsACString& newRef, nsIURI **_retval) override;
+
+  //////////////////////////////////////////////////////////////////////////////
+  // we support the nsIImapUrl interface
+  //////////////////////////////////////////////////////////////////////////////
+  NS_DECL_NSIIMAPURL
+
+  // nsIMsgMailNewsUrl overrides
+  NS_IMETHOD IsUrlType(uint32_t type, bool *isType) override;
+  NS_IMETHOD GetFolder(nsIMsgFolder **aFolder) override;
+  NS_IMETHOD SetFolder(nsIMsgFolder *aFolder) override;
+  // nsIMsgMessageUrl
+  NS_DECL_NSIMSGMESSAGEURL
+  NS_DECL_NSIMSGI18NURL
+
+  // nsImapUrl
+  nsImapUrl();
+
+  static nsresult ConvertToCanonicalFormat(const char *folderName, char onlineDelimiter, char **resultingCanonicalPath);
+  static nsresult EscapeSlashes(const char *sourcePath, char **resultPath);
+  static nsresult UnescapeSlashes(char *path);
+  static char *  ReplaceCharsInCopiedString(const char *stringToCopy, char oldChar, char newChar);
+
+protected:
+  virtual ~nsImapUrl();
+  virtual nsresult ParseUrl();
+
+  char *m_listOfMessageIds;
+
+  // handle the imap specific parsing
+  void ParseImapPart(char *imapPartOfUrl);
+
+  void ParseFolderPath(char **resultingCanonicalPath);
+  void ParseSearchCriteriaString();
+  void ParseUidChoice();
+  void ParseMsgFlags();
+  void ParseListOfMessageIds();
+  void ParseCustomMsgFetchAttribute();
+  void ParseNumBytes();
+
+  nsresult GetMsgFolder(nsIMsgFolder **msgFolder);
+
+  char        *m_sourceCanonicalFolderPathSubString;
+  char        *m_destinationCanonicalFolderPathSubString;
+  char        *m_tokenPlaceHolder;
+  char        *m_urlidSubString;
+  char        m_onlineSubDirSeparator;
+  char        *m_searchCriteriaString;  // should we use m_search, or is this special?
+  nsCString     m_command;       // for custom commands
+  nsCString     m_msgFetchAttribute; // for fetching custom msg attributes
+  nsCString     m_customAttributeResult; // for fetching custom msg attributes
+  nsCString     m_customCommandResult; // custom command response
+  nsCString     m_customAddFlags;       // these two are for setting and clearing custom flags
+  nsCString     m_customSubtractFlags;
+  int32_t       m_numBytesToFetch; // when doing a msg body preview, how many bytes to read
+  bool m_validUrl;
+  bool m_runningUrl;
+  bool m_idsAreUids;
+  bool m_mimePartSelectorDetected;
+  bool m_allowContentChange;  // if false, we can't use Mime parts on demand
+  bool m_fetchPartsOnDemand; // if true, we should fetch leave parts on server.
+  bool m_msgLoadingFromCache; // if true, we might need to mark read on server
+  bool m_externalLinkUrl; // if true, we're running this url because the user
+  // True if the fetch results should be put in the offline store.
+  bool m_storeResultsOffline;
+  bool m_storeOfflineOnFallback;
+  bool m_localFetchOnly;
+  bool m_rerunningUrl; // first attempt running this failed with connection error; retrying
+  bool m_moreHeadersToDownload;
+  nsImapContentModifiedType  m_contentModified;
+
+  int32_t    m_extraStatus;
+
+  nsCString  m_userName;
+  nsCString  m_serverKey;
+  // event sinks
+  imapMessageFlagsType  m_flags;
+  nsImapAction  m_imapAction;
+
+  nsWeakPtr m_imapFolder;
+  nsWeakPtr m_imapMailFolderSink;
+  nsWeakPtr m_imapMessageSink;
+
+  nsWeakPtr m_imapServerSink;
+
+  // online message copy support; i don't have a better solution yet
+  nsCOMPtr <nsISupports> m_copyState;   // now, refcounted.
+  nsCOMPtr<nsIFile> m_file;
+  nsWeakPtr m_channelWeakPtr;
+
+  // used by save message to disk
+  nsCOMPtr<nsIFile> m_messageFile;
+  bool                  m_addDummyEnvelope;
+  bool                  m_canonicalLineEnding; // CRLF
+
+  nsCString mURI; // the RDF URI associated with this url.
+  nsCString mCharsetOverride; // used by nsIMsgI18NUrl...
+  mozilla::Mutex mLock;
+};
+
+#endif /* nsImapUrl_h___ */
diff --git a/mailnews/imap/src/nsImapUtils.cpp b/mailnews/imap/src/nsImapUtils.cpp
new file mode 100644
index 0000000000..b213d33f81
--- /dev/null
+++ b/mailnews/imap/src/nsImapUtils.cpp
@@ -0,0 +1,373 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "msgCore.h"
+#include "nsImapUtils.h"
+#include "nsCOMPtr.h"
+#include "nsIServiceManager.h"
+#include "prsystem.h"
+#include "prprf.h"
+#include "nsNetCID.h"
+
+// stuff for temporary root folder hack
+#include "nsIMsgAccountManager.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIImapIncomingServer.h"
+#include "nsMsgBaseCID.h"
+#include "nsImapCore.h"
+#include "nsMsgUtils.h"
+#include "nsImapFlagAndUidState.h"
+#include "nsIMAPNamespace.h"
+#include "nsIImapFlagAndUidState.h"
+
+nsresult
+nsImapURI2FullName(const char* rootURI, const char* hostName, const char* uriStr,
+                   char **name)
+{
+    nsAutoCString uri(uriStr);
+    nsAutoCString fullName;
+    if (uri.Find(rootURI) != 0)
+      return NS_ERROR_FAILURE;
+    fullName = Substring(uri, strlen(rootURI));
+    uri = fullName;
+    int32_t hostStart = uri.Find(hostName);
+    if (hostStart <= 0)
+      return NS_ERROR_FAILURE;
+    fullName = Substring(uri, hostStart);
+    uri = fullName;
+    int32_t hostEnd = uri.FindChar('/');
+    if (hostEnd <= 0)
+      return NS_ERROR_FAILURE;
+    fullName = Substring(uri, hostEnd + 1);
+    if (fullName.IsEmpty())
+      return NS_ERROR_FAILURE;
+    *name = ToNewCString(fullName);
+    return NS_OK;
+}
+
+/* parses ImapMessageURI */
+nsresult nsParseImapMessageURI(const char* uri, nsCString& folderURI, uint32_t *key, char **part)
+{
+  if(!key)
+    return NS_ERROR_NULL_POINTER;
+
+  nsAutoCString uriStr(uri);
+  int32_t folderEnd = -1;
+  // imap-message uri's can have imap:// url strings tacked on the end,
+  // e.g., when opening/saving attachments. We don't want to look for '#'
+  // in that part of the uri, if the attachment name contains '#',
+  // so check for that here.
+  if (StringBeginsWith(uriStr, NS_LITERAL_CSTRING("imap-message")))
+    folderEnd = uriStr.Find("imap://");
+
+  int32_t keySeparator = MsgRFindChar(uriStr, '#', folderEnd);
+  if(keySeparator != -1)
+  {
+    int32_t keyEndSeparator = MsgFindCharInSet(uriStr, "/?&", keySeparator);
+    nsAutoString folderPath;
+    folderURI = StringHead(uriStr, keySeparator);
+    folderURI.Cut(4, 8); // cut out the _message part of imap-message:
+    // folder uri's don't have fully escaped usernames.
+    int32_t atPos = folderURI.FindChar('@');
+    if (atPos != -1)
+    {
+      nsCString unescapedName, escapedName;
+      int32_t userNamePos = folderURI.Find("//") + 2;
+      uint32_t origUserNameLen = atPos - userNamePos;
+      if (NS_SUCCEEDED(MsgUnescapeString(Substring(folderURI, userNamePos,
+                                                   origUserNameLen),
+                                         0, unescapedName)))
+      {
+        // Re-escape the username, matching the way we do it in uris, not the
+        // way necko escapes urls. See nsMsgIncomingServer::GetServerURI.
+        MsgEscapeString(unescapedName, nsINetUtil::ESCAPE_XALPHAS, escapedName);
+        folderURI.Replace(userNamePos, origUserNameLen, escapedName);
+      }
+    }
+    nsAutoCString keyStr;
+    if (keyEndSeparator != -1)
+      keyStr = Substring(uriStr, keySeparator + 1, keyEndSeparator - (keySeparator + 1));
+    else
+      keyStr = Substring(uriStr, keySeparator + 1);
+
+    *key = strtoul(keyStr.get(), nullptr, 10);
+
+    if (part && keyEndSeparator != -1)
+    {
+      int32_t partPos = MsgFind(uriStr, "part=", false, keyEndSeparator);
+      if (partPos != -1)
+      {
+        *part = ToNewCString(Substring(uriStr, keyEndSeparator));
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult nsBuildImapMessageURI(const char *baseURI, uint32_t key, nsCString& uri)
+{
+  uri.Append(baseURI);
+  uri.Append('#');
+  uri.AppendInt(key);
+  return NS_OK;
+}
+
+nsresult nsCreateImapBaseMessageURI(const nsACString& baseURI, nsCString &baseMessageURI)
+{
+  nsAutoCString tailURI(baseURI);
+  // chop off imap:/
+  if (tailURI.Find(kImapRootURI) == 0)
+    tailURI.Cut(0, PL_strlen(kImapRootURI));
+  baseMessageURI = kImapMessageRootURI;
+  baseMessageURI += tailURI;
+  return NS_OK;
+}
+
+// nsImapMailboxSpec definition
+NS_IMPL_ISUPPORTS(nsImapMailboxSpec, nsIMailboxSpec)
+
+nsImapMailboxSpec::nsImapMailboxSpec()
+{
+  mFolder_UIDVALIDITY = 0;
+  mHighestModSeq = 0;
+  mNumOfMessages = 0;
+  mNumOfUnseenMessages = 0;
+  mNumOfRecentMessages = 0;
+  mNextUID = 0;
+
+  mBoxFlags = 0;
+  mSupportedUserFlags = 0;
+
+  mHierarchySeparator = '\0';
+
+  mFolderSelected = false;
+  mDiscoveredFromLsub = false;
+
+  mOnlineVerified = false;
+  mNamespaceForFolder = nullptr;
+}
+
+nsImapMailboxSpec::~nsImapMailboxSpec()
+{
+}
+
+NS_IMPL_GETSET(nsImapMailboxSpec, Folder_UIDVALIDITY, int32_t, mFolder_UIDVALIDITY)
+NS_IMPL_GETSET(nsImapMailboxSpec, HighestModSeq, uint64_t, mHighestModSeq)
+NS_IMPL_GETSET(nsImapMailboxSpec, NumMessages, int32_t, mNumOfMessages)
+NS_IMPL_GETSET(nsImapMailboxSpec, NumUnseenMessages, int32_t, mNumOfUnseenMessages)
+NS_IMPL_GETSET(nsImapMailboxSpec, NumRecentMessages, int32_t, mNumOfRecentMessages)
+NS_IMPL_GETSET(nsImapMailboxSpec, NextUID, int32_t, mNextUID)
+NS_IMPL_GETSET(nsImapMailboxSpec, HierarchyDelimiter, char, mHierarchySeparator)
+NS_IMPL_GETSET(nsImapMailboxSpec, FolderSelected, bool, mFolderSelected)
+NS_IMPL_GETSET(nsImapMailboxSpec, DiscoveredFromLsub, bool, mDiscoveredFromLsub)
+NS_IMPL_GETSET(nsImapMailboxSpec, OnlineVerified, bool, mOnlineVerified)
+NS_IMPL_GETSET(nsImapMailboxSpec, SupportedUserFlags, uint32_t, mSupportedUserFlags)
+NS_IMPL_GETSET(nsImapMailboxSpec, Box_flags, uint32_t, mBoxFlags)
+NS_IMPL_GETSET(nsImapMailboxSpec, NamespaceForFolder, nsIMAPNamespace *, mNamespaceForFolder)
+
+NS_IMETHODIMP nsImapMailboxSpec::GetAllocatedPathName(nsACString &aAllocatedPathName)
+{
+  aAllocatedPathName = mAllocatedPathName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailboxSpec::SetAllocatedPathName(const nsACString &aAllocatedPathName)
+{
+  mAllocatedPathName = aAllocatedPathName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailboxSpec::GetUnicharPathName(nsAString &aUnicharPathName)
+{
+  aUnicharPathName = aUnicharPathName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailboxSpec::SetUnicharPathName(const nsAString &aUnicharPathName)
+{
+  mUnicharPathName = aUnicharPathName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailboxSpec::GetHostName(nsACString &aHostName)
+{
+  aHostName = mHostName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailboxSpec::SetHostName(const nsACString &aHostName)
+{
+  mHostName = aHostName;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailboxSpec::GetFlagState(nsIImapFlagAndUidState ** aFlagState)
+{
+  NS_ENSURE_ARG_POINTER(aFlagState);
+  NS_IF_ADDREF(*aFlagState = mFlagState);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsImapMailboxSpec::SetFlagState(nsIImapFlagAndUidState * aFlagState)
+{
+  NS_ENSURE_ARG_POINTER(aFlagState);
+  mFlagState = aFlagState;
+  return NS_OK;
+}
+
+nsImapMailboxSpec& nsImapMailboxSpec::operator= (const nsImapMailboxSpec& aCopy)
+{
+  mFolder_UIDVALIDITY = aCopy.mFolder_UIDVALIDITY;
+  mHighestModSeq = aCopy.mHighestModSeq;
+  mNumOfMessages = aCopy.mNumOfMessages;
+  mNumOfUnseenMessages = aCopy.mNumOfUnseenMessages;
+  mNumOfRecentMessages = aCopy.mNumOfRecentMessages;
+
+  mBoxFlags = aCopy.mBoxFlags;
+  mSupportedUserFlags = aCopy.mSupportedUserFlags;
+
+  mAllocatedPathName.Assign(aCopy.mAllocatedPathName);
+  mUnicharPathName.Assign(aCopy.mUnicharPathName);
+  mHostName.Assign(aCopy.mHostName);
+
+  mFlagState = aCopy.mFlagState;
+  mNamespaceForFolder = aCopy.mNamespaceForFolder;
+
+  mFolderSelected = aCopy.mFolderSelected;
+  mDiscoveredFromLsub = aCopy.mDiscoveredFromLsub;
+
+  mOnlineVerified = aCopy.mOnlineVerified;
+
+  return *this;
+}
+
+// use the flagState to determine if the gaps in the msgUids correspond to gaps in the mailbox,
+// in which case we can still use ranges. If flagState is null, we won't do this.
+void AllocateImapUidString(uint32_t *msgUids, uint32_t &msgCount,
+                           nsImapFlagAndUidState *flagState, nsCString &returnString)
+{
+  uint32_t startSequence = (msgCount > 0) ? msgUids[0] : 0xFFFFFFFF;
+  uint32_t curSequenceEnd = startSequence;
+  uint32_t total = msgCount;
+  int32_t  curFlagStateIndex = -1;
+
+  // a partial fetch flag state doesn't help us, so don't use it.
+  if (flagState && flagState->GetPartialUIDFetch())
+    flagState = nullptr;
+
+
+  for (uint32_t keyIndex = 0; keyIndex < total; keyIndex++)
+  {
+    uint32_t curKey = msgUids[keyIndex];
+    uint32_t nextKey = (keyIndex + 1 < total) ? msgUids[keyIndex + 1] : 0xFFFFFFFF;
+    bool lastKey = (nextKey == 0xFFFFFFFF);
+
+    if (lastKey)
+      curSequenceEnd = curKey;
+
+    if (!lastKey)
+    {
+      if (nextKey == curSequenceEnd + 1)
+      {
+        curSequenceEnd = nextKey;
+        curFlagStateIndex++;
+        continue;
+      }
+      if (flagState)
+      {
+        if (curFlagStateIndex == -1)
+        {
+          bool foundIt;
+          flagState->GetMessageFlagsFromUID(curSequenceEnd, &foundIt, &curFlagStateIndex);
+          if (!foundIt)
+          {
+            NS_WARNING("flag state missing key");
+            // The start of this sequence is missing from flag state, so move
+            // on to the next key.
+            curFlagStateIndex = -1;
+            curSequenceEnd = startSequence = nextKey;
+            continue;
+          }
+        }
+        curFlagStateIndex++;
+        uint32_t nextUidInFlagState;
+        nsresult rv = flagState->GetUidOfMessage(curFlagStateIndex, &nextUidInFlagState);
+        if (NS_SUCCEEDED(rv) && nextUidInFlagState == nextKey)
+        {
+          curSequenceEnd = nextKey;
+          continue;
+        }
+      }
+    }
+    if (curSequenceEnd > startSequence)
+    {
+      returnString.AppendInt((int64_t) startSequence);
+      returnString += ':';
+      returnString.AppendInt((int64_t) curSequenceEnd);
+      startSequence = nextKey;
+      curSequenceEnd = startSequence;
+      curFlagStateIndex = -1;
+    }
+    else
+    {
+      startSequence = nextKey;
+      curSequenceEnd = startSequence;
+      returnString.AppendInt((int64_t) msgUids[keyIndex]);
+      curFlagStateIndex = -1;
+    }
+    // check if we've generated too long a string - if there's no flag state,
+    // it means we just need to go ahead and generate a too long string
+    // because the calling code won't handle breaking up the strings.
+    if (flagState && returnString.Length() > 950)
+    {
+      msgCount = keyIndex;
+      break;
+    }
+    // If we are not the last item then we need to add the comma
+    // but it's important we do it here, after the length check
+    if (!lastKey)
+      returnString += ',';
+  }
+}
+
+void ParseUidString(const char *uidString, nsTArray<nsMsgKey> &keys)
+{
+  // This is in the form <id>,<id>, or <id1>:<id2>
+  if (!uidString)
+    return;
+
+  char curChar = *uidString;
+  bool isRange = false;
+  uint32_t curToken;
+  uint32_t saveStartToken = 0;
+
+  for (const char *curCharPtr = uidString; curChar && *curCharPtr;)
+  {
+    const char *currentKeyToken = curCharPtr;
+    curChar = *curCharPtr;
+    while (curChar != ':' && curChar != ',' && curChar != '\0')
+      curChar = *curCharPtr++;
+
+    // we don't need to null terminate currentKeyToken because strtoul
+    // stops at non-numeric chars.
+    curToken = strtoul(currentKeyToken, nullptr, 10);
+    if (isRange)
+    {
+      while (saveStartToken < curToken)
+        keys.AppendElement(saveStartToken++);
+    }
+    keys.AppendElement(curToken);
+    isRange = (curChar == ':');
+    if (isRange)
+      saveStartToken = curToken + 1;
+  }
+}
+
+void AppendUid(nsCString &msgIds, uint32_t uid)
+{
+  char buf[20];
+  PR_snprintf(buf, sizeof(buf), "%u", uid);
+  msgIds.Append(buf);
+}
diff --git a/mailnews/imap/src/nsImapUtils.h b/mailnews/imap/src/nsImapUtils.h
new file mode 100644
index 0000000000..b24a38a005
--- /dev/null
+++ b/mailnews/imap/src/nsImapUtils.h
@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef NS_IMAPUTILS_H
+#define NS_IMAPUTILS_H
+
+#include "nsStringGlue.h"
+#include "nsIMsgIncomingServer.h"
+#include "MailNewsTypes.h"
+#include "nsTArray.h"
+#include "nsIMailboxSpec.h"
+#include "nsCOMPtr.h"
+
+class nsImapFlagAndUidState;
+class nsImapProtocol;
+
+static const char kImapRootURI[] = "imap:/";
+static const char kImapMessageRootURI[] = "imap-message:/";
+static const char kModSeqPropertyName[] = "highestModSeq";
+static const char kHighestRecordedUIDPropertyName[] = "highestRecordedUID";
+static const char kDeletedHdrCountPropertyName[] = "numDeletedHeaders";
+
+extern nsresult
+nsImapURI2FullName(const char* rootURI, const char* hostname, const char* uriStr,
+                   char **name);
+
+extern nsresult
+nsParseImapMessageURI(const char* uri, nsCString& folderURI, uint32_t *key, char **part);
+
+extern nsresult 
+nsBuildImapMessageURI(const char *baseURI, uint32_t key, nsCString& uri);
+
+extern nsresult
+nsCreateImapBaseMessageURI(const nsACString& baseURI, nsCString& baseMessageURI);
+
+void AllocateImapUidString(uint32_t *msgUids, uint32_t &msgCount, nsImapFlagAndUidState *flagState, nsCString &returnString);
+void ParseUidString(const char *uidString, nsTArray<nsMsgKey> &keys);
+void AppendUid(nsCString &msgIds, uint32_t uid);
+
+class nsImapMailboxSpec : public nsIMailboxSpec
+{
+public:
+  nsImapMailboxSpec();
+  
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIMAILBOXSPEC
+    
+  nsImapMailboxSpec& operator= (const nsImapMailboxSpec& aCopy);
+  
+  nsCOMPtr<nsIImapFlagAndUidState> mFlagState;
+  nsIMAPNamespace                  *mNamespaceForFolder;  
+  
+  uint32_t  mBoxFlags;
+  uint32_t  mSupportedUserFlags;
+  int32_t   mFolder_UIDVALIDITY;
+  uint64_t  mHighestModSeq;
+  int32_t   mNumOfMessages;
+  int32_t   mNumOfUnseenMessages;
+  int32_t   mNumOfRecentMessages;
+  int32_t   mNextUID;
+  nsCString mAllocatedPathName;
+  nsCString mHostName;
+  nsString  mUnicharPathName;
+  char      mHierarchySeparator;
+  bool      mFolderSelected;
+  bool      mDiscoveredFromLsub;
+  bool      mOnlineVerified;
+  
+  nsImapProtocol *mConnection;	// do we need this? It seems evil
+
+private:
+  virtual ~nsImapMailboxSpec();
+};
+
+#endif //NS_IMAPUTILS_H
diff --git a/mailnews/imap/src/nsSyncRunnableHelpers.cpp b/mailnews/imap/src/nsSyncRunnableHelpers.cpp
new file mode 100644
index 0000000000..ec547eb911
--- /dev/null
+++ b/mailnews/imap/src/nsSyncRunnableHelpers.cpp
@@ -0,0 +1,600 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.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 "nsSyncRunnableHelpers.h"
+#include "nsIMsgMailNewsUrl.h"
+#include "nsIMsgWindow.h"
+#include "nsImapMailFolder.h"
+
+#include "mozilla/Monitor.h"
+
+NS_IMPL_ISUPPORTS(StreamListenerProxy, nsIStreamListener)
+NS_IMPL_ISUPPORTS(ImapMailFolderSinkProxy, nsIImapMailFolderSink)
+NS_IMPL_ISUPPORTS(ImapServerSinkProxy, nsIImapServerSink)
+NS_IMPL_ISUPPORTS(ImapMessageSinkProxy,
+                              nsIImapMessageSink)
+NS_IMPL_ISUPPORTS(ImapProtocolSinkProxy,
+                              nsIImapProtocolSink)
+namespace {
+
+// Traits class for a reference type, specialized for parameters which are
+// already references.
+template<typename T>
+struct RefType
+{
+  typedef T& type;
+};
+
+template<>
+struct RefType<nsAString&>
+{
+  typedef nsAString& type;
+};
+
+template<>
+struct RefType<const nsAString&>
+{
+  typedef const nsAString& type;
+};
+
+template<>
+struct RefType<nsACString&>
+{
+  typedef nsACString& type;
+};
+
+template<>
+struct RefType<const nsACString&>
+{
+  typedef const nsACString& type;
+};
+
+template<>
+struct RefType<const nsIID&>
+{
+  typedef const nsIID& type;
+};
+
+class SyncRunnableBase : public mozilla::Runnable
+{
+public:
+  nsresult Result() {
+    return mResult;
+  }
+
+  mozilla::Monitor& Monitor() {
+    return mMonitor;
+  }
+
+protected:
+  SyncRunnableBase()
+    : mResult(NS_ERROR_UNEXPECTED)
+    , mMonitor("SyncRunnableBase")
+  { }
+
+  nsresult mResult;
+  mozilla::Monitor mMonitor;
+};
+
+template<typename Receiver>
+class SyncRunnable0 : public SyncRunnableBase
+{
+public:
+  typedef nsresult (NS_STDCALL Receiver::*ReceiverMethod)();
+
+  SyncRunnable0(Receiver* receiver, ReceiverMethod method)
+    : mReceiver(receiver)
+    , mMethod(method)
+  { }
+
+  NS_IMETHOD Run() {
+    mResult = (mReceiver->*mMethod)();
+    mozilla::MonitorAutoLock(mMonitor).Notify();
+    return NS_OK;
+  }
+
+private:
+  Receiver* mReceiver;
+  ReceiverMethod mMethod;
+};
+
+
+template<typename Receiver, typename Arg1>
+class SyncRunnable1 : public SyncRunnableBase
+{
+public:
+  typedef nsresult (NS_STDCALL Receiver::*ReceiverMethod)(Arg1);
+  typedef typename RefType<Arg1>::type Arg1Ref;
+
+  SyncRunnable1(Receiver* receiver, ReceiverMethod method,
+                Arg1Ref arg1)
+    : mReceiver(receiver)
+    , mMethod(method)
+    , mArg1(arg1)
+  { }
+
+  NS_IMETHOD Run() {
+    mResult = (mReceiver->*mMethod)(mArg1);
+    mozilla::MonitorAutoLock(mMonitor).Notify();
+    return NS_OK;
+  }
+
+private:
+  Receiver* mReceiver;
+  ReceiverMethod mMethod;
+  Arg1Ref mArg1;
+};
+
+template<typename Receiver, typename Arg1, typename Arg2>
+class SyncRunnable2 : public SyncRunnableBase
+{
+public:
+  typedef nsresult (NS_STDCALL Receiver::*ReceiverMethod)(Arg1, Arg2);
+  typedef typename RefType<Arg1>::type Arg1Ref;
+  typedef typename RefType<Arg2>::type Arg2Ref;
+
+  SyncRunnable2(Receiver* receiver, ReceiverMethod method,
+                Arg1Ref arg1, Arg2Ref arg2)
+    : mReceiver(receiver)
+    , mMethod(method)
+    , mArg1(arg1)
+    , mArg2(arg2)
+  { }
+
+  NS_IMETHOD Run() {
+    mResult = (mReceiver->*mMethod)(mArg1, mArg2);
+    mozilla::MonitorAutoLock(mMonitor).Notify();
+    return NS_OK;
+  }
+
+private:
+  Receiver* mReceiver;
+  ReceiverMethod mMethod;
+  Arg1Ref mArg1;
+  Arg2Ref mArg2;
+};
+
+template<typename Receiver, typename Arg1, typename Arg2, typename Arg3>
+class SyncRunnable3 : public SyncRunnableBase
+{
+public:
+  typedef nsresult (NS_STDCALL Receiver::*ReceiverMethod)(Arg1, Arg2, Arg3);
+  typedef typename RefType<Arg1>::type Arg1Ref;
+  typedef typename RefType<Arg2>::type Arg2Ref;
+  typedef typename RefType<Arg3>::type Arg3Ref;
+
+  SyncRunnable3(Receiver* receiver, ReceiverMethod method,
+                Arg1Ref arg1, Arg2Ref arg2, Arg3Ref arg3)
+    : mReceiver(receiver)
+    , mMethod(method)
+    , mArg1(arg1)
+    , mArg2(arg2)
+    , mArg3(arg3)
+  { }
+
+  NS_IMETHOD Run() {
+    mResult = (mReceiver->*mMethod)(mArg1, mArg2, mArg3);
+    mozilla::MonitorAutoLock(mMonitor).Notify();
+    return NS_OK;
+  }
+
+private:
+  Receiver* mReceiver;
+  ReceiverMethod mMethod;
+  Arg1Ref mArg1;
+  Arg2Ref mArg2;
+  Arg3Ref mArg3;
+};
+
+template<typename Receiver, typename Arg1, typename Arg2, typename Arg3,
+         typename Arg4>
+class SyncRunnable4 : public SyncRunnableBase
+{
+public:
+  typedef nsresult (NS_STDCALL Receiver::*ReceiverMethod)(Arg1, Arg2, Arg3, Arg4);
+  typedef typename RefType<Arg1>::type Arg1Ref;
+  typedef typename RefType<Arg2>::type Arg2Ref;
+  typedef typename RefType<Arg3>::type Arg3Ref;
+  typedef typename RefType<Arg4>::type Arg4Ref;
+
+  SyncRunnable4(Receiver* receiver, ReceiverMethod method,
+                Arg1Ref arg1, Arg2Ref arg2, Arg3Ref arg3, Arg4Ref arg4)
+    : mReceiver(receiver)
+    , mMethod(method)
+    , mArg1(arg1)
+    , mArg2(arg2)
+    , mArg3(arg3)
+    , mArg4(arg4)
+  { }
+
+  NS_IMETHOD Run() {
+    mResult = (mReceiver->*mMethod)(mArg1, mArg2, mArg3, mArg4);
+    mozilla::MonitorAutoLock(mMonitor).Notify();
+    return NS_OK;
+  }
+
+private:
+  Receiver* mReceiver;
+  ReceiverMethod mMethod;
+  Arg1Ref mArg1;
+  Arg2Ref mArg2;
+  Arg3Ref mArg3;
+  Arg4Ref mArg4;
+};
+
+template<typename Receiver, typename Arg1, typename Arg2, typename Arg3,
+         typename Arg4, typename Arg5>
+class SyncRunnable5 : public SyncRunnableBase
+{
+public:
+  typedef nsresult (NS_STDCALL Receiver::*ReceiverMethod)(Arg1, Arg2, Arg3, Arg4, Arg5);
+  typedef typename RefType<Arg1>::type Arg1Ref;
+  typedef typename RefType<Arg2>::type Arg2Ref;
+  typedef typename RefType<Arg3>::type Arg3Ref;
+  typedef typename RefType<Arg4>::type Arg4Ref;
+  typedef typename RefType<Arg5>::type Arg5Ref;
+
+  SyncRunnable5(Receiver* receiver, ReceiverMethod method,
+                Arg1Ref arg1, Arg2Ref arg2, Arg3Ref arg3, Arg4Ref arg4, Arg5Ref arg5)
+    : mReceiver(receiver)
+    , mMethod(method)
+    , mArg1(arg1)
+    , mArg2(arg2)
+    , mArg3(arg3)
+    , mArg4(arg4)
+    , mArg5(arg5)
+  { }
+
+  NS_IMETHOD Run() {
+    mResult = (mReceiver->*mMethod)(mArg1, mArg2, mArg3, mArg4, mArg5);
+    mozilla::MonitorAutoLock(mMonitor).Notify();
+    return NS_OK;
+  }
+
+private:
+  Receiver* mReceiver;
+  ReceiverMethod mMethod;
+  Arg1Ref mArg1;
+  Arg2Ref mArg2;
+  Arg3Ref mArg3;
+  Arg4Ref mArg4;
+  Arg5Ref mArg5;
+};
+
+nsresult
+DispatchSyncRunnable(SyncRunnableBase* r)
+{
+  if (NS_IsMainThread()) {
+    r->Run();
+  }
+  else {
+    mozilla::MonitorAutoLock lock(r->Monitor());
+    nsresult rv = NS_DispatchToMainThread(r);
+    if (NS_FAILED(rv))
+      return rv;
+    lock.Wait();
+  }
+  return r->Result();
+}
+
+} // anonymous namespace
+
+#define NS_SYNCRUNNABLEMETHOD0(iface, method)                       \
+  NS_IMETHODIMP iface##Proxy::method() {                     \
+    RefPtr<SyncRunnableBase> r =                                  \
+      new SyncRunnable0<nsI##iface>                           \
+      (mReceiver, &nsI##iface::method);                         \
+    return DispatchSyncRunnable(r);                                 \
+  }
+
+
+#define NS_SYNCRUNNABLEMETHOD1(iface, method,                       \
+                               arg1)                                \
+  NS_IMETHODIMP iface##Proxy::method(arg1 a1) {                     \
+    RefPtr<SyncRunnableBase> r =                                  \
+      new SyncRunnable1<nsI##iface, arg1>                           \
+      (mReceiver, &nsI##iface::method, a1);                         \
+    return DispatchSyncRunnable(r);                                 \
+  }
+
+#define NS_SYNCRUNNABLEMETHOD2(iface, method,                       \
+                               arg1, arg2)                          \
+  NS_IMETHODIMP iface##Proxy::method(arg1 a1, arg2 a2) {            \
+    RefPtr<SyncRunnableBase> r =                                  \
+      new SyncRunnable2<nsI##iface, arg1, arg2>                     \
+      (mReceiver, &nsI##iface::method, a1, a2);                     \
+    return DispatchSyncRunnable(r);                                 \
+  }
+
+#define NS_SYNCRUNNABLEMETHOD3(iface, method,                       \
+                               arg1, arg2, arg3)                    \
+  NS_IMETHODIMP iface##Proxy::method(arg1 a1, arg2 a2, arg3 a3) {   \
+    RefPtr<SyncRunnableBase> r =                                  \
+      new SyncRunnable3<nsI##iface, arg1, arg2, arg3>               \
+      (mReceiver, &nsI##iface::method,                              \
+       a1, a2, a3);                                                 \
+    return DispatchSyncRunnable(r);                                 \
+  }
+
+#define NS_SYNCRUNNABLEMETHOD4(iface, method,                       \
+                               arg1, arg2, arg3, arg4)              \
+  NS_IMETHODIMP iface##Proxy::method(arg1 a1, arg2 a2, arg3 a3, arg4 a4) { \
+    RefPtr<SyncRunnableBase> r =                                  \
+      new SyncRunnable4<nsI##iface, arg1, arg2, arg3, arg4>         \
+      (mReceiver, &nsI##iface::method,                              \
+       a1, a2, a3, a4);                                             \
+    return DispatchSyncRunnable(r);                                 \
+  }
+
+#define NS_SYNCRUNNABLEMETHOD5(iface, method,                       \
+                               arg1, arg2, arg3, arg4, arg5)        \
+  NS_IMETHODIMP iface##Proxy::method(arg1 a1, arg2 a2, arg3 a3, arg4 a4, arg5 a5) {   \
+    RefPtr<SyncRunnableBase> r =                                  \
+      new SyncRunnable5<nsI##iface, arg1, arg2, arg3, arg4, arg5>   \
+      (mReceiver, &nsI##iface::method,                              \
+       a1, a2, a3, a4, a5);                                         \
+    return DispatchSyncRunnable(r);                                 \
+  }
+
+#define NS_SYNCRUNNABLEATTRIBUTE(iface, attribute,                       \
+                                 type)                                \
+NS_IMETHODIMP iface##Proxy::Get##attribute(type *a1) {                     \
+    RefPtr<SyncRunnableBase> r =                                  \
+      new SyncRunnable1<nsI##iface, type *>                           \
+      (mReceiver, &nsI##iface::Get##attribute, a1);                         \
+    return DispatchSyncRunnable(r);                                 \
+  } \
+NS_IMETHODIMP iface##Proxy::Set##attribute(type a1) {                     \
+    RefPtr<SyncRunnableBase> r =                                  \
+      new SyncRunnable1<nsI##iface, type>                           \
+      (mReceiver, &nsI##iface::Set##attribute, a1);                         \
+    return DispatchSyncRunnable(r);                                 \
+  }
+
+
+#define NS_NOTIMPLEMENTED \
+  { NS_RUNTIMEABORT("Not implemented"); return NS_ERROR_UNEXPECTED; }
+
+NS_SYNCRUNNABLEMETHOD5(StreamListener, OnDataAvailable,
+                       nsIRequest *, nsISupports *, nsIInputStream *, uint64_t, uint32_t)
+
+NS_SYNCRUNNABLEMETHOD2(StreamListener, OnStartRequest,
+                       nsIRequest *, nsISupports *)
+
+NS_SYNCRUNNABLEMETHOD3(StreamListener, OnStopRequest,
+                       nsIRequest *, nsISupports *, nsresult)
+
+NS_SYNCRUNNABLEMETHOD2(ImapProtocolSink, GetUrlWindow, nsIMsgMailNewsUrl *,
+                       nsIMsgWindow **)
+
+NS_SYNCRUNNABLEMETHOD0(ImapProtocolSink, CloseStreams)
+NS_SYNCRUNNABLEMETHOD0(ImapProtocolSink, SetupMainThreadProxies)
+
+NS_SYNCRUNNABLEATTRIBUTE(ImapMailFolderSink, FolderNeedsACLListed, bool)
+NS_SYNCRUNNABLEATTRIBUTE(ImapMailFolderSink, FolderNeedsSubscribing, bool)
+NS_SYNCRUNNABLEATTRIBUTE(ImapMailFolderSink, FolderNeedsAdded, bool)
+NS_SYNCRUNNABLEATTRIBUTE(ImapMailFolderSink, AclFlags, uint32_t)
+NS_SYNCRUNNABLEATTRIBUTE(ImapMailFolderSink, UidValidity, int32_t)
+NS_SYNCRUNNABLEATTRIBUTE(ImapMailFolderSink, FolderQuotaCommandIssued, bool)
+NS_SYNCRUNNABLEMETHOD3(ImapMailFolderSink, SetFolderQuotaData, const nsACString &, uint32_t, uint32_t)
+NS_SYNCRUNNABLEMETHOD1(ImapMailFolderSink, GetShouldDownloadAllHeaders, bool *)
+NS_SYNCRUNNABLEMETHOD1(ImapMailFolderSink, GetOnlineDelimiter, char *)
+NS_SYNCRUNNABLEMETHOD0(ImapMailFolderSink, OnNewIdleMessages)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, UpdateImapMailboxStatus, nsIImapProtocol *, nsIMailboxSpec *)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, UpdateImapMailboxInfo, nsIImapProtocol *, nsIMailboxSpec *)
+NS_SYNCRUNNABLEMETHOD4(ImapMailFolderSink, GetMsgHdrsToDownload, bool *, int32_t *, uint32_t *, nsMsgKey **)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, ParseMsgHdrs, nsIImapProtocol *, nsIImapHeaderXferInfo *)
+NS_SYNCRUNNABLEMETHOD1(ImapMailFolderSink, AbortHeaderParseStream, nsIImapProtocol *)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, OnlineCopyCompleted, nsIImapProtocol *, ImapOnlineCopyState)
+NS_SYNCRUNNABLEMETHOD1(ImapMailFolderSink, StartMessage, nsIMsgMailNewsUrl *)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, EndMessage, nsIMsgMailNewsUrl *, nsMsgKey)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, NotifySearchHit, nsIMsgMailNewsUrl *, const char *)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, CopyNextStreamMessage, bool, nsISupports *)
+NS_SYNCRUNNABLEMETHOD1(ImapMailFolderSink, CloseMockChannel, nsIImapMockChannel *)
+NS_SYNCRUNNABLEMETHOD5(ImapMailFolderSink, SetUrlState, nsIImapProtocol *, nsIMsgMailNewsUrl *,
+                       bool, bool, nsresult)
+NS_SYNCRUNNABLEMETHOD1(ImapMailFolderSink, ReleaseUrlCacheEntry, nsIMsgMailNewsUrl *)
+NS_SYNCRUNNABLEMETHOD1(ImapMailFolderSink, HeaderFetchCompleted, nsIImapProtocol *)
+NS_SYNCRUNNABLEMETHOD1(ImapMailFolderSink, SetBiffStateAndUpdate, int32_t)
+NS_SYNCRUNNABLEMETHOD3(ImapMailFolderSink, ProgressStatusString, nsIImapProtocol*, const char*, const char16_t *)
+NS_SYNCRUNNABLEMETHOD4(ImapMailFolderSink, PercentProgress, nsIImapProtocol*, const char16_t *, int64_t, int64_t)
+NS_SYNCRUNNABLEMETHOD0(ImapMailFolderSink, ClearFolderRights)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, SetCopyResponseUid, const char *, nsIImapUrl *)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, SetAppendMsgUid, nsMsgKey, nsIImapUrl *)
+NS_SYNCRUNNABLEMETHOD2(ImapMailFolderSink, GetMessageId, nsIImapUrl *, nsACString &)
+
+NS_SYNCRUNNABLEMETHOD2(ImapMessageSink, SetupMsgWriteStream, nsIFile *, bool)
+NS_SYNCRUNNABLEMETHOD3(ImapMessageSink, ParseAdoptedMsgLine, const char *, nsMsgKey, nsIImapUrl *)
+NS_SYNCRUNNABLEMETHOD4(ImapMessageSink, NormalEndMsgWriteStream, nsMsgKey, bool, nsIImapUrl *, int32_t)
+NS_SYNCRUNNABLEMETHOD0(ImapMessageSink, AbortMsgWriteStream)
+NS_SYNCRUNNABLEMETHOD0(ImapMessageSink, BeginMessageUpload)
+NS_SYNCRUNNABLEMETHOD4(ImapMessageSink, NotifyMessageFlags, uint32_t, const nsACString &, nsMsgKey, uint64_t)
+NS_SYNCRUNNABLEMETHOD3(ImapMessageSink, NotifyMessageDeleted, const char *, bool, const char *)
+NS_SYNCRUNNABLEMETHOD2(ImapMessageSink, GetMessageSizeFromDB, const char *, uint32_t *)
+NS_SYNCRUNNABLEMETHOD2(ImapMessageSink, SetContentModified, nsIImapUrl *, nsImapContentModifiedType)
+NS_SYNCRUNNABLEMETHOD4(ImapMessageSink, GetCurMoveCopyMessageInfo, nsIImapUrl *, PRTime *, nsACString &, uint32_t *)
+
+NS_SYNCRUNNABLEMETHOD4(ImapServerSink, PossibleImapMailbox, const nsACString &, char, int32_t, bool *)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, FolderNeedsACLInitialized, const nsACString &, bool *)
+NS_SYNCRUNNABLEMETHOD3(ImapServerSink, AddFolderRights, const nsACString &, const nsACString &, const nsACString &)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, RefreshFolderRights, const nsACString &)
+NS_SYNCRUNNABLEMETHOD0(ImapServerSink, DiscoveryDone)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, OnlineFolderDelete, const nsACString &)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, OnlineFolderCreateFailed, const nsACString &)
+NS_SYNCRUNNABLEMETHOD3(ImapServerSink, OnlineFolderRename, nsIMsgWindow *, const nsACString &, const nsACString &)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, FolderIsNoSelect, const nsACString &, bool *)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, SetFolderAdminURL, const nsACString &, const nsACString &)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, FolderVerifiedOnline, const nsACString &, bool *)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, SetCapability, eIMAPCapabilityFlags)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, SetServerID, const nsACString &)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, LoadNextQueuedUrl, nsIImapProtocol *, bool *)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, PrepareToRetryUrl, nsIImapUrl *, nsIImapMockChannel **)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, SuspendUrl, nsIImapUrl *)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, RetryUrl, nsIImapUrl *, nsIImapMockChannel *)
+NS_SYNCRUNNABLEMETHOD0(ImapServerSink, AbortQueuedUrls)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, GetImapStringByName, const char*, nsAString &)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, PromptLoginFailed, nsIMsgWindow *, int32_t *)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, FEAlert, const nsAString &, nsIMsgMailNewsUrl *)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, FEAlertWithName, const char*, nsIMsgMailNewsUrl *)
+NS_SYNCRUNNABLEMETHOD2(ImapServerSink, FEAlertFromServer, const nsACString &, nsIMsgMailNewsUrl *)
+NS_SYNCRUNNABLEMETHOD0(ImapServerSink, CommitNamespaces)
+NS_SYNCRUNNABLEMETHOD3(ImapServerSink, AsyncGetPassword, nsIImapProtocol *, bool, nsACString &)
+NS_SYNCRUNNABLEATTRIBUTE(ImapServerSink, UserAuthenticated, bool)
+NS_SYNCRUNNABLEMETHOD3(ImapServerSink, SetMailServerUrls, const nsACString &, const nsACString &, const nsACString &)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, GetArbitraryHeaders, nsACString &)
+NS_SYNCRUNNABLEMETHOD0(ImapServerSink, ForgetPassword)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, GetShowAttachmentsInline, bool *)
+NS_SYNCRUNNABLEMETHOD3(ImapServerSink, CramMD5Hash, const char *, const char *, char **)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, GetLoginUsername, nsACString &)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, UpdateTrySTARTTLSPref, bool)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, GetOriginalUsername, nsACString &)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, GetServerKey, nsACString &)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, GetServerPassword, nsACString &)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, RemoveServerConnection, nsIImapProtocol *)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, GetServerShuttingDown, bool *)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, ResetServerConnection, const nsACString &)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, SetServerDoingLsub, bool)
+NS_SYNCRUNNABLEMETHOD1(ImapServerSink, SetServerForceSelect, const nsACString &)
+
+
+namespace mozilla {
+namespace mailnews {
+
+NS_IMPL_ISUPPORTS(OAuth2ThreadHelper, msgIOAuth2ModuleListener)
+
+OAuth2ThreadHelper::OAuth2ThreadHelper(nsIMsgIncomingServer *aServer)
+: mMonitor("OAuth thread lock"),
+  mServer(aServer)
+{
+}
+
+OAuth2ThreadHelper::~OAuth2ThreadHelper()
+{
+  if (mOAuth2Support)
+  {
+    NS_ReleaseOnMainThread(mOAuth2Support.forget());
+  }
+}
+
+bool OAuth2ThreadHelper::SupportsOAuth2()
+{
+  // Acquire a lock early, before reading anything. Guarantees memory visibility
+  // issues.
+  MonitorAutoLock lockGuard(mMonitor);
+
+  // If we don't have a server, we can't init, and therefore, we don't support
+  // OAuth2.
+  if (!mServer)
+    return false;
+
+  // If we have this, then we support OAuth2.
+  if (mOAuth2Support)
+    return true;
+
+  // Initialize. This needs to be done on-main-thread: if we're off that thread,
+  // synchronously dispatch to the main thread.
+  if (NS_IsMainThread())
+  {
+    MonitorAutoUnlock lockGuard(mMonitor);
+    Init();
+  }
+  else
+  {
+    nsCOMPtr<nsIRunnable> runInit =
+      NewRunnableMethod(this, &OAuth2ThreadHelper::Init);
+    NS_DispatchToMainThread(runInit);
+    mMonitor.Wait();
+  }
+
+  // After synchronously initializing, if we didn't get an object, then we don't
+  // support XOAuth2.
+  return mOAuth2Support != nullptr;
+}
+
+void OAuth2ThreadHelper::GetXOAuth2String(nsACString &base64Str)
+{
+  MOZ_ASSERT(!NS_IsMainThread(), "This method cannot run on the main thread");
+
+  // Acquire a lock early, before reading anything. Guarantees memory visibility
+  // issues.
+  MonitorAutoLock lockGuard(mMonitor);
+
+  // Umm... what are you trying to do?
+  if (!mOAuth2Support)
+    return;
+
+  nsCOMPtr<nsIRunnable> runInit =
+    NewRunnableMethod(this, &OAuth2ThreadHelper::Connect);
+  NS_DispatchToMainThread(runInit);
+  mMonitor.Wait();
+
+  // Now we either have the string, or we failed (in which case the string is
+  // empty).
+  base64Str = mOAuth2String;
+}
+
+void OAuth2ThreadHelper::Init()
+{
+  MOZ_ASSERT(NS_IsMainThread(), "Can't touch JS off-main-thread");
+  MonitorAutoLock lockGuard(mMonitor);
+
+  // Create the OAuth2 helper module and initialize it. If the preferences are
+  // not set up on this server, we don't support OAuth2, and we nullify our
+  // members to indicate this.
+  mOAuth2Support = do_CreateInstance(MSGIOAUTH2MODULE_CONTRACTID);
+  if (mOAuth2Support)
+  {
+    bool supportsOAuth = false;
+    mOAuth2Support->InitFromMail(mServer, &supportsOAuth);
+    if (!supportsOAuth)
+      mOAuth2Support = nullptr;
+  }
+
+  // There is now no longer any need for the server. Kill it now--this helps
+  // prevent us from maintaining a refcount cycle.
+  mServer = nullptr;
+
+  // Notify anyone waiting that we're done.
+  mMonitor.Notify();
+}
+
+void OAuth2ThreadHelper::Connect()
+{
+  MOZ_ASSERT(NS_IsMainThread(), "Can't touch JS off-main-thread");
+  MOZ_ASSERT(mOAuth2Support, "Should not be here if no OAuth2 support");
+
+  // OK to delay lock since mOAuth2Support is only written on main thread.
+  nsresult rv = mOAuth2Support->Connect(true, this);
+  // If the method failed, we'll never get a callback, so notify the monitor
+  // immediately so that IMAP can react.
+  if (NS_FAILED(rv))
+  {
+    MonitorAutoLock lockGuard(mMonitor);
+    mMonitor.Notify();
+  }
+}
+
+nsresult OAuth2ThreadHelper::OnSuccess(const nsACString &aAccessToken)
+{
+  MOZ_ASSERT(NS_IsMainThread(), "Can't touch JS off-main-thread");
+  MonitorAutoLock lockGuard(mMonitor);
+
+  MOZ_ASSERT(mOAuth2Support, "Should not be here if no OAuth2 support");
+  mOAuth2Support->BuildXOAuth2String(mOAuth2String);
+  mMonitor.Notify();
+  return NS_OK;
+}
+
+nsresult OAuth2ThreadHelper::OnFailure(nsresult aError)
+{
+  MOZ_ASSERT(NS_IsMainThread(), "Can't touch JS off-main-thread");
+  MonitorAutoLock lockGuard(mMonitor);
+
+  mOAuth2String.Truncate();
+  mMonitor.Notify();
+  return NS_OK;
+}
+
+} // namespace mailnews
+} // namespace mozilla
diff --git a/mailnews/imap/src/nsSyncRunnableHelpers.h b/mailnews/imap/src/nsSyncRunnableHelpers.h
new file mode 100644
index 0000000000..4fcadf4655
--- /dev/null
+++ b/mailnews/imap/src/nsSyncRunnableHelpers.h
@@ -0,0 +1,146 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsSyncRunnableHelpers_h
+#define nsSyncRunnableHelpers_h
+
+#include "nsThreadUtils.h"
+#include "nsProxyRelease.h"
+
+#include "mozilla/Monitor.h"
+#include "msgIOAuth2Module.h"
+#include "nsIStreamListener.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIImapMailFolderSink.h"
+#include "nsIImapServerSink.h"
+#include "nsIImapProtocolSink.h"
+#include "nsIImapMessageSink.h"
+
+// The classes in this file proxy method calls to the main thread
+// synchronously. The main thread must not block on this thread, or a
+// deadlock condition can occur.
+
+class StreamListenerProxy final : public nsIStreamListener
+{
+public:
+  StreamListenerProxy(nsIStreamListener* receiver)
+    : mReceiver(receiver)
+  { }
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSISTREAMLISTENER
+
+private:
+  ~StreamListenerProxy() {
+    NS_ReleaseOnMainThread(mReceiver.forget());
+  }
+  nsCOMPtr<nsIStreamListener> mReceiver;
+};
+
+class ImapMailFolderSinkProxy final : public nsIImapMailFolderSink
+{
+public:
+  ImapMailFolderSinkProxy(nsIImapMailFolderSink* receiver)
+    : mReceiver(receiver)
+  {
+    NS_ASSERTION(receiver, "Don't allow receiver is nullptr");
+  }
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIIMAPMAILFOLDERSINK
+
+private:
+  ~ImapMailFolderSinkProxy() {
+    NS_ReleaseOnMainThread(mReceiver.forget());
+  }
+  nsCOMPtr<nsIImapMailFolderSink> mReceiver;
+};
+
+class ImapServerSinkProxy final : public nsIImapServerSink
+{
+public:
+  ImapServerSinkProxy(nsIImapServerSink* receiver)
+    : mReceiver(receiver)
+  { }
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIIMAPSERVERSINK
+
+private:
+  ~ImapServerSinkProxy() {
+    NS_ReleaseOnMainThread(mReceiver.forget());
+  }
+  nsCOMPtr<nsIImapServerSink> mReceiver;
+};
+
+
+class ImapMessageSinkProxy final : public nsIImapMessageSink
+{
+public:
+  ImapMessageSinkProxy(nsIImapMessageSink* receiver)
+    : mReceiver(receiver)
+  { }
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIIMAPMESSAGESINK
+
+private:
+  ~ImapMessageSinkProxy() {
+    NS_ReleaseOnMainThread(mReceiver.forget());
+  }
+  nsCOMPtr<nsIImapMessageSink> mReceiver;
+};
+
+class ImapProtocolSinkProxy final : public nsIImapProtocolSink
+{
+public:
+  ImapProtocolSinkProxy(nsIImapProtocolSink* receiver)
+    : mReceiver(receiver)
+  { }
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIIMAPPROTOCOLSINK
+
+private:
+  ~ImapProtocolSinkProxy() {
+    NS_ReleaseOnMainThread(mReceiver.forget());
+  }
+  nsCOMPtr<nsIImapProtocolSink> mReceiver;
+};
+
+class msgIOAuth2Module;
+class nsIMsgIncomingServer;
+class nsIVariant;
+class nsIWritableVariant;
+
+namespace mozilla {
+namespace mailnews {
+
+class OAuth2ThreadHelper final : public msgIOAuth2ModuleListener
+{
+public:
+  OAuth2ThreadHelper(nsIMsgIncomingServer *aServer);
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_MSGIOAUTH2MODULELISTENER
+
+  bool SupportsOAuth2();
+  void GetXOAuth2String(nsACString &base64Str);
+
+private:
+  ~OAuth2ThreadHelper();
+  void Init();
+  void Connect();
+
+  Monitor mMonitor;
+  nsCOMPtr<msgIOAuth2Module> mOAuth2Support;
+  nsCOMPtr<nsIMsgIncomingServer> mServer;
+  nsCString mOAuth2String;
+};
+
+} // namespace mailnews
+} // namespace mozilla
+
+#endif // nsSyncRunnableHelpers_h