imap/src/nsImapMailFolder.cpp

/* -*- 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 "nsIImapService.h"
#include "nsIFile.h"
#include "nsIUrlListener.h"
#include "nsCOMPtr.h"
#include "nsMsgDBCID.h"
#include "nsMsgFolderFlags.h"
#include "nsISeekableStream.h"
#include "nsThreadUtils.h"
#include "nsIImapUrl.h"
#include "nsImapUtils.h"
#include "nsMsgUtils.h"
#include "nsIMsgMailSession.h"
#include "nsMsgBaseCID.h"
#include "nsMsgLocalCID.h"
#include "nsITransactionManager.h"
#include "nsImapUndoTxn.h"
#include "nsIImapHostSessionList.h"
#include "nsIMsgCopyService.h"
#include "nsICopyMessageStreamListener.h"
#include "nsImapStringBundle.h"
#include "nsIMsgFolderCacheElement.h"
#include "nsTextFormatter.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
#include "nsMsgI18N.h"
#include "nsIMsgFilter.h"
#include "nsIMsgFilterService.h"
#include "nsIMsgSearchCustomTerm.h"
#include "nsIMsgSearchTerm.h"
#include "nsImapMoveCoalescer.h"
#include "nsIPrompt.h"
#include "nsIDocShell.h"
#include "nsUnicharUtils.h"
#include "nsIImapFlagAndUidState.h"
#include "nsIImapHeaderXferInfo.h"
#include "nsIMessenger.h"
#include "nsIMsgSearchAdapter.h"
#include "nsIImapMockChannel.h"
#include "nsIProgressEventSink.h"
#include "nsIMsgWindow.h"
#include "nsIMsgFolder.h"  // TO include biffState enum. Change to bool later...
#include "nsIMsgLocalMailFolder.h"
#include "nsIMsgOfflineImapOperation.h"
#include "nsImapOfflineSync.h"
#include "nsIImapMailFolderSink.h"
#include "nsIImapServerSink.h"
#include "nsIMsgAccountManager.h"
#include "nsQuickSort.h"
#include "nsIImapMockChannel.h"
#include "nsNetUtil.h"
#include "nsImapNamespace.h"
#include "nsIMsgFolderCompactor.h"
#include "nsMsgMessageFlags.h"
#include "nsISpamSettings.h"
#include <time.h>
#include "nsIMsgMailNewsUrl.h"
#include "nsEmbedCID.h"
#include "nsIMsgComposeService.h"
#include "nsMsgCompCID.h"
#include "nsDirectoryServiceDefs.h"
#include "nsIDirectoryEnumerator.h"
#include "nsIMsgIdentity.h"
#include "nsIMsgFolderNotificationService.h"
#include "nsNativeCharsetUtils.h"
#include "nsIExternalProtocolService.h"
#include "nsCExternalHandlerService.h"
#include "prprf.h"
#include "nsAutoSyncManager.h"
#include "nsIMsgFilterCustomAction.h"
#include "nsMsgReadStateTxn.h"
#include "nsStringEnumerator.h"
#include "nsIMsgStatusFeedback.h"
#include "nsMsgLineBuffer.h"
#include "mozilla/Logging.h"
#include "mozilla/Attributes.h"
#include "nsStringStream.h"
#include "nsIStreamListener.h"

static NS_DEFINE_CID(kParseMailMsgStateCID, NS_PARSEMAILMSGSTATE_CID);
static NS_DEFINE_CID(kCImapHostSessionList, NS_IIMAPHOSTSESSIONLIST_CID);

#define MAILNEWS_CUSTOM_HEADERS "mailnews.customHeaders"

using namespace mozilla;

extern LazyLogModule gAutoSyncLog;  // defined in nsAutoSyncManager.cpp
extern LazyLogModule IMAP;          // defined in nsImapProtocol.cpp
extern LazyLogModule IMAP_CS;  // For CONDSTORE, defined in nsImapProtocol.cpp
extern LazyLogModule FILTERLOGMODULE;  // defined in nsMsgFilterService.cpp
LazyLogModule IMAP_KW("IMAP_KW");      // for logging keyword (tag) processing

/*
    Copies the contents of srcDir into destDir.
    destDir will be created if it doesn't exist.
*/

static nsresult RecursiveCopy(nsIFile* srcDir, nsIFile* destDir) {
  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;

  nsCOMPtr<nsIDirectoryEnumerator> dirIterator;
  rv = srcDir->GetDirectoryEntries(getter_AddRefs(dirIterator));
  if (NS_FAILED(rv)) return rv;

  bool hasMore = false;
  while (NS_SUCCEEDED(dirIterator->HasMoreElements(&hasMore)) && hasMore) {
    nsCOMPtr<nsIFile> dirEntry;
    rv = dirIterator->GetNextFile(getter_AddRefs(dirEntry));
    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());
      }
    }
  }

  return rv;
}

//
//  nsMsgQuota
//
NS_IMPL_ISUPPORTS(nsMsgQuota, nsIMsgQuota)

nsMsgQuota::nsMsgQuota(const nsACString& aName, const uint64_t& aUsage,
                       const uint64_t& aLimit)
    : mName(aName), mUsage(aUsage), mLimit(aLimit) {}

nsMsgQuota::~nsMsgQuota() {}

/**
 * Note: These quota access function are not called but still must be defined
 * for the linker.
 */
NS_IMETHODIMP nsMsgQuota::GetName(nsACString& aName) {
  aName = mName;
  return NS_OK;
}

NS_IMETHODIMP nsMsgQuota::SetName(const nsACString& aName) {
  mName = aName;
  return NS_OK;
}

NS_IMETHODIMP nsMsgQuota::GetUsage(uint64_t* aUsage) {
  *aUsage = mUsage;
  return NS_OK;
}

NS_IMETHODIMP nsMsgQuota::SetUsage(uint64_t aUsage) {
  mUsage = aUsage;
  return NS_OK;
}

NS_IMETHODIMP nsMsgQuota::GetLimit(uint64_t* aLimit) {
  *aLimit = mLimit;
  return NS_OK;
}

NS_IMETHODIMP nsMsgQuota::SetLimit(uint64_t aLimit) {
  mLimit = aLimit;
  return NS_OK;
}

//
//  nsImapMailFolder
//
nsImapMailFolder::nsImapMailFolder()
    : m_initialized(false),
      m_haveDiscoveredAllFolders(false),
      m_curMsgUid(0),
      m_nextMessageByteLength(0),
      m_urlRunning(false),
      m_verifiedAsOnlineFolder(false),
      m_explicitlyVerify(false),
      m_folderIsNamespace(false),
      m_folderNeedsSubscribing(false),
      m_folderNeedsAdded(false),
      m_folderNeedsACLListed(true),
      m_performingBiff(false),
      m_updatingFolder(false),
      m_compactingOfflineStore(false),
      m_expunging(false),
      m_applyIncomingFilters(false),
      m_downloadingFolderForOfflineUse(false),
      m_filterListRequiresBody(false),
      m_folderQuotaCommandIssued(false),
      m_folderQuotaDataIsValid(false) {
  m_boxFlags = 0;
  m_uidValidity = kUidUnknown;
  m_numServerRecentMessages = 0;
  m_numServerUnseenMessages = 0;
  m_numServerTotalMessages = 0;
  m_nextUID = nsMsgKey_None;
  m_hierarchyDelimiter = kOnlineHierarchySeparatorUnknown;
  m_folderACL = nullptr;
  m_aclFlags = 0;
  m_supportedUserFlags = 0;
  m_namespace = nullptr;
  m_pendingPlaybackReq = nullptr;
}

nsImapMailFolder::~nsImapMailFolder() {
  delete m_folderACL;

  // cleanup any pending request
  delete m_pendingPlaybackReq;
}

NS_IMPL_ADDREF_INHERITED(nsImapMailFolder, nsMsgDBFolder)
NS_IMPL_RELEASE_INHERITED(nsImapMailFolder, nsMsgDBFolder)
NS_IMPL_QUERY_HEAD(nsImapMailFolder)
NS_IMPL_QUERY_BODY(nsIMsgImapMailFolder)
NS_IMPL_QUERY_BODY(nsICopyMessageListener)
NS_IMPL_QUERY_BODY(nsIImapMailFolderSink)
NS_IMPL_QUERY_BODY(nsIImapMessageSink)
NS_IMPL_QUERY_BODY(nsIUrlListener)
NS_IMPL_QUERY_BODY(nsIMsgFilterHitNotify)
NS_IMPL_QUERY_TAIL_INHERITING(nsMsgDBFolder)

nsresult nsImapMailFolder::AddDirectorySeparator(nsIFile* path) {
  if (mURI.Equals(kImapRootURI)) {
    // don't concat the full separator with .sbd
  } else {
    // see if there's a dir with the same name ending with .sbd
    nsAutoString leafName;
    path->GetLeafName(leafName);
    leafName.AppendLiteral(FOLDER_SUFFIX);
    path->SetLeafName(leafName);
  }

  return NS_OK;
}

static bool nsShouldIgnoreFile(nsString& name) {
  if (StringEndsWith(name, NS_LITERAL_STRING_FROM_CSTRING(SUMMARY_SUFFIX),
                     nsCaseInsensitiveStringComparator)) {
    name.SetLength(name.Length() -
                   SUMMARY_SUFFIX_LENGTH);  // truncate the string
    return false;
  }
  return true;
}

nsresult nsImapMailFolder::CreateChildFromURI(const nsACString& uri,
                                              nsIMsgFolder** folder) {
  nsImapMailFolder* newFolder = new nsImapMailFolder;
  newFolder->Init(uri);
  NS_ADDREF(*folder = newFolder);
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::AddSubfolder(const nsAString& aName,
                                             nsIMsgFolder** aChild) {
  NS_ENSURE_ARG_POINTER(aChild);

  int32_t flags = 0;
  nsresult rv;

  nsAutoCString uri(mURI);
  uri.Append('/');

  nsAutoCString escapedName;
  rv = NS_MsgEscapeEncodeURLPath(aName, escapedName);
  NS_ENSURE_SUCCESS(rv, rv);

  uri += escapedName.get();

  nsCOMPtr<nsIMsgFolder> msgFolder;
  rv = GetChildWithURI(uri, false /*deep*/, true /*case Insensitive*/,
                       getter_AddRefs(msgFolder));
  if (NS_SUCCEEDED(rv) && msgFolder) return NS_MSG_FOLDER_EXISTS;

  nsCOMPtr<nsIMsgFolder> folder;
  rv = GetOrCreateFolder(uri, getter_AddRefs(folder));
  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);

  nsCOMPtr<nsIFile> path;
  rv = CreateDirectoryForFolder(getter_AddRefs(path));
  NS_ENSURE_SUCCESS(rv, rv);

  folder->GetFlags((uint32_t*)&flags);

  flags |= nsMsgFolderFlags::Mail;

  nsCOMPtr<nsIImapIncomingServer> imapServer;
  GetImapIncomingServer(getter_AddRefs(imapServer));
  if (imapServer) {
    bool setNewFoldersForOffline = false;
    rv = imapServer->GetOfflineDownload(&setNewFoldersForOffline);
    if (NS_SUCCEEDED(rv) && setNewFoldersForOffline)
      flags |= nsMsgFolderFlags::Offline;
  }

  folder->SetParent(this);

  folder->SetFlags(flags);

  mSubFolders.AppendObject(folder);
  folder.forget(aChild);

  nsCOMPtr<nsIMsgImapMailFolder> imapChild = do_QueryInterface(*aChild);
  if (imapChild) {
    imapChild->SetOnlineName(NS_ConvertUTF16toUTF8(aName));
    imapChild->SetHierarchyDelimiter(m_hierarchyDelimiter);
  }
  NotifyItemAdded(*aChild);
  return rv;
}

// Creates a new child nsIMsgFolder locally, with no IMAP traffic.
nsresult nsImapMailFolder::AddSubfolderWithPath(nsAString& name,
                                                nsIFile* dbPath,
                                                nsIMsgFolder** child,
                                                bool brandNew) {
  NS_ENSURE_ARG_POINTER(child);
  nsresult rv;

  nsAutoCString uri(mURI);
  uri.Append('/');
  AppendUTF16toUTF8(name, uri);

  bool isServer;
  rv = GetIsServer(&isServer);
  NS_ENSURE_SUCCESS(rv, rv);

  bool isInbox = isServer && name.LowerCaseEqualsLiteral("inbox");

  // will make sure mSubFolders does not have duplicates because of bogus msf
  // files.
  nsCOMPtr<nsIMsgFolder> msgFolder;
  rv = GetChildWithURI(uri, false /*deep*/, isInbox /*case Insensitive*/,
                       getter_AddRefs(msgFolder));
  if (NS_SUCCEEDED(rv) && msgFolder) return NS_MSG_FOLDER_EXISTS;

  nsCOMPtr<nsIMsgFolder> folder;
  rv = GetOrCreateFolder(uri, getter_AddRefs(folder));
  NS_ENSURE_SUCCESS(rv, rv);

  folder->SetFilePath(dbPath);
  nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(folder, &rv);
  mozilla::Unused << imapFolder;
  NS_ENSURE_SUCCESS(rv, rv);

  uint32_t flags = 0;
  folder->GetFlags(&flags);

  folder->SetParent(this);
  flags |= nsMsgFolderFlags::Mail;

  uint32_t pFlags;
  GetFlags(&pFlags);
  bool isParentInbox = pFlags & nsMsgFolderFlags::Inbox;

  nsCOMPtr<nsIImapIncomingServer> imapServer;
  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
  NS_ENSURE_SUCCESS(rv, rv);

  // Only set these if these are top level children or parent is inbox
  if (isInbox)
    flags |= nsMsgFolderFlags::Inbox;
  else if (isServer || isParentInbox) {
    nsMsgImapDeleteModel deleteModel;
    imapServer->GetDeleteModel(&deleteModel);
    if (deleteModel == nsMsgImapDeleteModels::MoveToTrash) {
      nsAutoString trashName;
      GetTrashFolderName(trashName);
      if (name.Equals(trashName)) flags |= nsMsgFolderFlags::Trash;
    }
  }

  // Make the folder offline if it is newly created and the offline_download
  // pref is true, unless it's the Trash or Junk folder.
  if (brandNew &&
      !(flags & (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Junk))) {
    bool setNewFoldersForOffline = false;
    rv = imapServer->GetOfflineDownload(&setNewFoldersForOffline);
    if (NS_SUCCEEDED(rv) && setNewFoldersForOffline)
      flags |= nsMsgFolderFlags::Offline;
  }

  folder->SetFlags(flags);

  if (folder) mSubFolders.AppendObject(folder);
  folder.forget(child);
  return NS_OK;
}

// Create child nsIMsgFolders by scanning the filesystem to find .msf files.
// No IMAP traffic.
nsresult nsImapMailFolder::CreateSubFolders(nsIFile* path) {
  nsresult rv = NS_OK;
  nsCOMPtr<nsIMsgIncomingServer> server;
  rv = GetServer(getter_AddRefs(server));
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIDirectoryEnumerator> directoryEnumerator;
  rv = path->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
  NS_ENSURE_SUCCESS(rv, rv);

  // For each .msf file in the directory...
  bool hasMore = false;
  while (NS_SUCCEEDED(directoryEnumerator->HasMoreElements(&hasMore)) &&
         hasMore) {
    nsCOMPtr<nsIFile> currentFolderPath;
    rv = directoryEnumerator->GetNextFile(getter_AddRefs(currentFolderPath));
    if (NS_FAILED(rv) || !currentFolderPath) continue;

    nsAutoString currentFolderNameStr;    // online name
    nsAutoString currentFolderDBNameStr;  // possibly munged name
    currentFolderPath->GetLeafName(currentFolderNameStr);
    // Skip if not an .msf file.
    // (NOTE: nsShouldIgnoreFile() strips the trailing ".msf" here)
    if (nsShouldIgnoreFile(currentFolderNameStr)) continue;

    // OK, here we need to get the online name from the folder cache if we can.
    // If we can, use that to create the sub-folder
    nsCOMPtr<nsIFile> curFolder =
        do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    nsCOMPtr<nsIFile> dbFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    dbFile->InitWithFile(currentFolderPath);
    curFolder->InitWithFile(currentFolderPath);
    // don't strip off the .msf in currentFolderPath.
    currentFolderPath->SetLeafName(currentFolderNameStr);
    currentFolderDBNameStr = currentFolderNameStr;
    nsAutoString utfLeafName = currentFolderNameStr;

    if (curFolder) {
      nsCOMPtr<nsIMsgFolderCacheElement> cacheElement;
      rv = GetFolderCacheElemFromFile(dbFile, getter_AddRefs(cacheElement));
      if (NS_SUCCEEDED(rv) && cacheElement) {
        nsCString onlineFullUtfName;

        uint32_t folderFlags;
        rv = cacheElement->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", onlineFullUtfName);
        if (NS_SUCCEEDED(rv) && !onlineFullUtfName.IsEmpty()) {
          CopyFolderNameToUTF16(onlineFullUtfName, currentFolderNameStr);
          char delimiter = 0;
          GetHierarchyDelimiter(&delimiter);
          int32_t leafPos = currentFolderNameStr.RFindChar(delimiter);
          if (leafPos > 0) currentFolderNameStr.Cut(0, leafPos + 1);

          // Take the full online name, and determine the leaf name.
          CopyUTF8toUTF16(onlineFullUtfName, utfLeafName);
          leafPos = utfLeafName.RFindChar(delimiter);
          if (leafPos > 0) utfLeafName.Cut(0, leafPos + 1);
        }
      }
    }
    // make the imap folder remember the file spec it was created with.
    nsCOMPtr<nsIFile> msfFilePath =
        do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    msfFilePath->InitWithFile(currentFolderPath);
    if (NS_SUCCEEDED(rv) && msfFilePath) {
      // leaf name is the db name w/o .msf (nsShouldIgnoreFile strips it off)
      // so this trims the .msf off the file spec.
      msfFilePath->SetLeafName(currentFolderDBNameStr);
    }
    // Use the name as the uri for the folder.
    nsCOMPtr<nsIMsgFolder> child;
    AddSubfolderWithPath(utfLeafName, msfFilePath, getter_AddRefs(child));
    if (child) {
      // use the unicode name as the "pretty" name. Set it so it won't be
      // automatically computed from the URI.
      if (!currentFolderNameStr.IsEmpty())
        child->SetPrettyName(currentFolderNameStr);
      child->SetMsgDatabase(nullptr);
    }
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::GetSubFolders(
    nsTArray<RefPtr<nsIMsgFolder>>& folders) {
  bool isServer;
  nsresult rv = GetIsServer(&isServer);
  NS_ENSURE_SUCCESS(rv, rv);

  if (!m_initialized) {
    nsCOMPtr<nsIFile> pathFile;
    rv = GetFilePath(getter_AddRefs(pathFile));
    if (NS_FAILED(rv)) return rv;

    // host directory does not need .sbd tacked on
    if (!isServer) {
      rv = AddDirectorySeparator(pathFile);
      if (NS_FAILED(rv)) return rv;
    }

    m_initialized = true;  // need to set this here to avoid infinite recursion
                           // from CreateSubfolders.
    // we have to treat the root folder specially, because it's name
    // doesn't end with .sbd

    int32_t newFlags = nsMsgFolderFlags::Mail;
    bool isDirectory = false;
    pathFile->IsDirectory(&isDirectory);
    if (isDirectory) {
      newFlags |= (nsMsgFolderFlags::Directory | nsMsgFolderFlags::Elided);
      if (!mIsServer) SetFlag(newFlags);
      rv = CreateSubFolders(pathFile);
    }
    if (isServer) {
      nsCOMPtr<nsIMsgFolder> inboxFolder;

      GetFolderWithFlags(nsMsgFolderFlags::Inbox, getter_AddRefs(inboxFolder));
      if (!inboxFolder) {
        // create an inbox if we don't have one.
        CreateClientSubfolderInfo("INBOX"_ns, kOnlineHierarchySeparatorUnknown,
                                  0, true);
      }
    }

    // Force initialisation recursively.
    for (nsIMsgFolder* f : mSubFolders) {
      nsTArray<RefPtr<nsIMsgFolder>> dummy;
      rv = f->GetSubFolders(dummy);
      if (NS_FAILED(rv)) {
        break;
      }
    }

    UpdateSummaryTotals(false);
    if (NS_FAILED(rv)) return rv;
  }

  return nsMsgDBFolder::GetSubFolders(folders);
}

// Makes sure the database is open and exists.  If the database is valid then
// returns NS_OK.  Otherwise returns a failure error value.
nsresult nsImapMailFolder::GetDatabase() {
  nsresult rv = NS_OK;
  if (!mDatabase) {
    nsCOMPtr<nsIMsgDBService> msgDBService =
        do_GetService(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");

  nsString folderName;
  GetPrettyName(folderName);
  MOZ_LOG(FILTERLOGMODULE, LogLevel::Debug,
          ("(Imap) nsImapMailFolder::UpdateFolderWithListener() on folder '%s'",
           NS_ConvertUTF16toUTF8(folderName).get()));
  if (mFlags & nsMsgFolderFlags::Inbox || m_applyIncomingFilters) {
    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
            ("(Imap) Preparing filter run on folder '%s'",
             NS_ConvertUTF16toUTF8(folderName).get()));

    if (!m_filterList) {
      rv = GetFilterList(aMsgWindow, getter_AddRefs(m_filterList));
      if (NS_FAILED(rv)) {
        MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
                ("(Imap) Loading of filter list failed"));
      }
    }

    // if there's no msg window, but someone is updating the inbox, we're
    // doing something biff-like, and may download headers, so make biff notify.
    if (!aMsgWindow && mFlags & nsMsgFolderFlags::Inbox)
      SetPerformingBiff(true);
  }

  if (m_filterList) {
    nsCString listId;
    m_filterList->GetListId(listId);
    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
            ("(Imap) Preparing filter list %s", listId.get()));
    nsCOMPtr<nsIMsgIncomingServer> server;
    rv = GetServer(getter_AddRefs(server));
    NS_ENSURE_SUCCESS(rv, rv);

    bool canFileMessagesOnServer = true;
    rv = server->GetCanFileMessagesOnServer(&canFileMessagesOnServer);
    // the mdn filter is for filing return receipts into the sent folder
    // some servers (like AOL mail servers)
    // can't file to the sent folder, so we don't add the filter for those
    // servers
    if (canFileMessagesOnServer) {
      rv = server->ConfigureTemporaryFilters(m_filterList);
      NS_ENSURE_SUCCESS(rv, rv);
    }

    // If a body filter is enabled for an offline folder, delay the filter
    // application until after message has been downloaded.
    m_filterListRequiresBody = false;

    if (mFlags & nsMsgFolderFlags::Offline) {
      nsCOMPtr<nsIMsgFilterService> filterService =
          do_GetService(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;
        nsTArray<RefPtr<nsIMsgSearchTerm>> searchTerms;
        filter->GetSearchTerms(searchTerms);
        for (nsIMsgSearchTerm* term : searchTerms) {
          nsMsgSearchAttribValue attrib;
          rv = term->GetAttrib(&attrib);
          NS_ENSURE_SUCCESS(rv, rv);
          if (attrib == nsMsgSearchAttrib::Body)
            m_filterListRequiresBody = true;
          else if (attrib == nsMsgSearchAttrib::Custom) {
            nsAutoCString customId;
            rv = term->GetCustomId(customId);
            nsCOMPtr<nsIMsgSearchCustomTerm> customTerm;
            if (NS_SUCCEEDED(rv) && filterService)
              rv = filterService->GetCustomTerm(customId,
                                                getter_AddRefs(customTerm));
            bool needsBody = false;
            if (NS_SUCCEEDED(rv) && customTerm)
              rv = customTerm->GetNeedsBody(&needsBody);
            if (NS_SUCCEEDED(rv) && needsBody) m_filterListRequiresBody = true;
          }
          if (m_filterListRequiresBody) {
            break;
          }
        }

        // Also check if filter actions need the body, as this
        // is supported in custom actions.
        uint32_t numActions = 0;
        filter->GetActionCount(&numActions);
        for (uint32_t actionIndex = 0;
             actionIndex < numActions && !m_filterListRequiresBody;
             actionIndex++) {
          nsCOMPtr<nsIMsgRuleAction> action;
          rv = filter->GetActionAt(actionIndex, getter_AddRefs(action));
          if (NS_FAILED(rv) || !action) continue;

          nsCOMPtr<nsIMsgFilterCustomAction> customAction;
          rv = action->GetCustomAction(getter_AddRefs(customAction));
          if (NS_FAILED(rv) || !customAction) continue;

          bool needsBody = false;
          customAction->GetNeedsBody(&needsBody);
          if (needsBody) m_filterListRequiresBody = true;
        }
      }
    }
    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
            ("(Imap) Filters require the message body: %s",
             (m_filterListRequiresBody ? "true" : "false")));
  }

  selectFolder = true;

  bool isServer;
  rv = GetIsServer(&isServer);
  if (NS_SUCCEEDED(rv) && isServer) {
    if (!m_haveDiscoveredAllFolders) {
      bool hasSubFolders = false;
      GetHasSubFolders(&hasSubFolders);
      if (!hasSubFolders) {
        rv = CreateClientSubfolderInfo(
            "Inbox"_ns, kOnlineHierarchySeparatorUnknown, 0, false);
        NS_ENSURE_SUCCESS(rv, rv);
      }
      m_haveDiscoveredAllFolders = true;
    }
    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);

    /* Do a discovery in its own url if needed. Do before SELECT url. */
    nsCOMPtr<nsIImapHostSessionList> hostSession =
        do_GetService(kCImapHostSessionList, &rv);
    if (NS_SUCCEEDED(rv) && hostSession) {
      bool foundMailboxesAlready = false;
      nsCString serverKey;
      GetServerKey(serverKey);
      hostSession->GetHaveWeEverDiscoveredFoldersForHost(serverKey.get(),
                                                         foundMailboxesAlready);
      if (!foundMailboxesAlready) {
        bool discoveryInProgress = false;
        // See if discovery in progress and not yet finished.
        hostSession->GetDiscoveryForHostInProgress(serverKey.get(),
                                                   discoveryInProgress);
        if (!discoveryInProgress) {
          nsCOMPtr<nsIMsgFolder> rootFolder;
          rv = GetRootFolder(getter_AddRefs(rootFolder));
          if (NS_SUCCEEDED(rv) && rootFolder) {
            rv = imapService->DiscoverAllFolders(rootFolder, this, aMsgWindow,
                                                 nullptr);
            if (NS_SUCCEEDED(rv))
              hostSession->SetDiscoveryForHostInProgress(serverKey.get(), true);
          }
        }
      }
    }

    nsCOMPtr<nsIURI> url;
    rv = imapService->SelectFolder(this, m_urlListener, aMsgWindow,
                                   getter_AddRefs(url));
    if (NS_SUCCEEDED(rv)) {
      m_urlRunning = true;
      m_updatingFolder = true;
    }
    if (url) {
      nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(url, &rv);
      NS_ENSURE_SUCCESS(rv, rv);
      mailnewsUrl->RegisterListener(this);
      m_urlListener = aUrlListener;
    }

    // Allow IMAP folder auto-compact to occur when online or offline.
    if (aMsgWindow) AutoCompact(aMsgWindow);

    if (rv == NS_MSG_ERROR_OFFLINE || rv == NS_BINDING_ABORTED) {
      rv = NS_OK;
      NotifyFolderEvent(kFolderLoaded);
    }
  } else 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(kFolderLoaded);
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::CreateSubfolder(const nsAString& folderName,
                                                nsIMsgWindow* msgWindow) {
  if (folderName.IsEmpty()) return NS_MSG_ERROR_INVALID_FOLDER_NAME;

  nsresult rv;
  nsAutoString trashName;
  GetTrashFolderName(trashName);
  if (folderName.Equals(trashName))  // Trash , a special folder
  {
    ThrowAlertMsg("folderExists", msgWindow);
    return NS_MSG_FOLDER_EXISTS;
  }
  if (mIsServer &&
      folderName.LowerCaseEqualsLiteral("inbox"))  // Inbox, a special folder
  {
    ThrowAlertMsg("folderExists", msgWindow);
    return NS_MSG_FOLDER_EXISTS;
  }

  nsCOMPtr<nsIImapService> imapService =
      do_GetService(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_ConvertUTF8toUTF16 leafName(folderName);
  nsAutoString folderNameStr;
  nsAutoString parentName = leafName;
  // use RFind, because folder can start with a delimiter and
  // not be a leaf folder.
  int32_t folderStart = leafName.RFindChar('/');
  if (folderStart > 0) {
    nsCOMPtr<nsIMsgImapMailFolder> imapFolder;
    nsAutoCString uri(mURI);
    leafName.Assign(Substring(parentName, folderStart + 1));
    parentName.SetLength(folderStart);

    rv = CreateDirectoryForFolder(getter_AddRefs(path));
    NS_ENSURE_SUCCESS(rv, rv);
    uri.Append('/');
    uri.Append(NS_ConvertUTF16toUTF8(parentName));
    nsCOMPtr<nsIMsgFolder> folder;
    rv = GetOrCreateFolder(uri, getter_AddRefs(folder));
    NS_ENSURE_SUCCESS(rv, rv);
    imapFolder = do_QueryInterface(folder, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    nsAutoCString leafnameC;
    CopyUTF16toUTF8(leafName, leafnameC);
    return imapFolder->CreateClientSubfolderInfo(leafnameC, hierarchyDelimiter,
                                                 flags, suppressNotification);
  }

  // if we get here, it's really a leaf, and "this" is the parent.
  folderNameStr = leafName;

  // Create an empty database for this mail folder, set its name from the user
  nsCOMPtr<nsIMsgDatabase> mailDBFactory;
  nsCOMPtr<nsIMsgFolder> child;

  nsCOMPtr<nsIMsgDBService> msgDBService =
      do_GetService(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_ConvertUTF16toUTF8(folderNameStr));
      imapFolder->SetVerifiedAsOnlineFolder(true);
      imapFolder->SetOnlineName(onlineName);
      imapFolder->SetHierarchyDelimiter(hierarchyDelimiter);
      imapFolder->SetBoxFlags(flags);

      // Now that the child is created and the boxflags are set we can be sure
      // all special folder flags are known. The child may get its flags already
      // in AddSubfolderWithPath if they were in FolderCache, but that's
      // not always the case.
      uint32_t flags = 0;
      child->GetFlags(&flags);

      // Set the offline use flag for the newly created folder if the
      // offline_download preference is true, unless it's the Trash or Junk
      // folder.
      if (!(flags & (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Junk))) {
        nsCOMPtr<nsIImapIncomingServer> imapServer;
        rv = GetImapIncomingServer(getter_AddRefs(imapServer));
        NS_ENSURE_SUCCESS(rv, rv);
        bool setNewFoldersForOffline = false;
        rv = imapServer->GetOfflineDownload(&setNewFoldersForOffline);
        if (NS_SUCCEEDED(rv) && setNewFoldersForOffline)
          flags |= nsMsgFolderFlags::Offline;
      } else {
        flags &= ~nsMsgFolderFlags::Offline;  // clear offline flag if set
      }

      flags |= nsMsgFolderFlags::Elided;
      child->SetFlags(flags);

      nsString unicodeName;
      rv = CopyFolderNameToUTF16(nsCString(folderName), unicodeName);
      if (NS_SUCCEEDED(rv)) child->SetPrettyName(unicodeName);

      // store the online name as the mailbox name in the db folder info
      // I don't think anyone uses the mailbox name, so we'll use it
      // to restore the online name when blowing away an imap db.
      if (folderInfo)
        folderInfo->SetMailboxName(NS_ConvertUTF8toUTF16(onlineName));
    }

    unusedDB->SetSummaryValid(true);
    unusedDB->Commit(nsMsgDBCommitType::kLargeCommit);
    unusedDB->Close(true);
    // don't want to hold onto this newly created db.
    child->SetMsgDatabase(nullptr);
  }

  if (!suppressNotification) {
    if (NS_SUCCEEDED(rv) && child) {
      NotifyItemAdded(child);
      child->NotifyFolderEvent(kFolderCreateCompleted);
      nsCOMPtr<nsIMsgFolderNotificationService> notifier(
          do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
      if (notifier) notifier->NotifyFolderAdded(child);
    } else {
      NotifyFolderEvent(kFolderCreateFailed);
    }
  }
  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::RemoveLocalSelf() {
  // Kill the local folder and its storage.
  return nsMsgDBFolder::DeleteSelf(nullptr);
}

NS_IMETHODIMP nsImapMailFolder::CreateStorageIfMissing(
    nsIUrlListener* urlListener) {
  nsresult rv = NS_OK;
  nsCOMPtr<nsIMsgFolder> msgParent;
  GetParent(getter_AddRefs(msgParent));

  // parent is probably not set because *this* was probably created by rdf
  // and not by folder discovery. So, we have to compute the parent.
  if (!msgParent) {
    nsAutoCString folderName(mURI);

    int32_t leafPos = folderName.RFindChar('/');
    nsAutoCString parentName(folderName);

    if (leafPos > 0) {
      // If there is a hierarchy, there is a parent.
      // Don't strip off slash if it's the first character
      parentName.SetLength(leafPos);
      rv = GetOrCreateFolder(parentName, getter_AddRefs(msgParent));
      NS_ENSURE_SUCCESS(rv, rv);
    }
  }
  if (msgParent) {
    nsString folderName;
    GetName(folderName);
    nsresult rv;
    nsCOMPtr<nsIImapService> imapService =
        do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    nsCOMPtr<nsIURI> uri;
    imapService->EnsureFolderExists(msgParent, folderName, nullptr, 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<nsIMsgEnumerator> hdrs;
    rv = mDatabase->EnumerateMessages(getter_AddRefs(hdrs));
    NS_ENSURE_SUCCESS(rv, rv);
    bool hasMore = false;

    PRTime cutOffDay =
        MsgConvertAgeInDaysToCutoffDate(numDaysToKeepOfflineMsgs);

    // so now cutOffDay is the PRTime cut-off point. Any offline msg with
    // a date less than that will get marked for pending removal.
    while (NS_SUCCEEDED(rv = hdrs->HasMoreElements(&hasMore)) && hasMore) {
      nsCOMPtr<nsIMsgDBHdr> header;
      rv = hdrs->GetNext(getter_AddRefs(header));
      NS_ENSURE_SUCCESS(rv, rv);

      uint32_t msgFlags;
      PRTime msgDate;
      header->GetFlags(&msgFlags);
      if (msgFlags & nsMsgMessageFlags::Offline) {
        header->GetDate(&msgDate);
        MarkPendingRemoval(header, msgDate < cutOffDay);
        // I'm horribly tempted to break out of the loop if we've found
        // a message after the cut-off date, because messages will most likely
        // be in date order in the db, but there are always edge cases.
      }
    }
    if (!dbWasCached) {
      holdDBOpen = mDatabase;
      mDatabase = nullptr;
    }
  }
  return nsMsgDBFolder::ApplyRetentionSettings();
}

/**
 * The listener will get called when both the online expunge and the offline
 * store compaction are finished (if the latter is needed).
 */
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;
  nsTArray<RefPtr<nsIMsgFolder>> folderArray;
  nsTArray<RefPtr<nsIMsgFolder>> offlineFolderArray;

  nsCOMPtr<nsIMsgFolder> rootFolder;
  rv = GetRootFolder(getter_AddRefs(rootFolder));
  if (NS_SUCCEEDED(rv) && rootFolder) {
    nsTArray<RefPtr<nsIMsgFolder>> allDescendants;
    rootFolder->GetDescendants(allDescendants);
    for (auto folder : allDescendants) {
      uint32_t folderFlags;
      folder->GetFlags(&folderFlags);
      if (!(folderFlags &
            (nsMsgFolderFlags::Virtual | nsMsgFolderFlags::ImapNoselect))) {
        folderArray.AppendElement(folder);
        if (aCompactOfflineAlso) offlineFolderArray.AppendElement(folder);
      }
    }
    if (folderArray.IsEmpty()) 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.

    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<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);

    // Delete any subfolders under Trash.
    nsTArray<RefPtr<nsIMsgFolder>> subFolders;
    rv = trashFolder->GetSubFolders(subFolders);
    NS_ENSURE_SUCCESS(rv, rv);
    while (!subFolders.IsEmpty()) {
      RefPtr<nsIMsgFolder> f = subFolders.PopLastElement();
      rv = trashFolder->PropagateDelete(f, true, aMsgWindow);
      NS_ENSURE_SUCCESS(rv, rv);
    }

    nsCOMPtr<nsIDBFolderInfo> transferInfo;
    rv = trashFolder->GetDBTransferInfo(getter_AddRefs(transferInfo));
    NS_ENSURE_SUCCESS(rv, rv);
    // Bulk-delete all the messages by deleting the msf file and storage.
    // This is a little kludgy.
    rv = trashFolder->DeleteStorage();
    NS_ENSURE_SUCCESS(rv, rv);
    trashFolder->SetDBTransferInfo(transferInfo);
    trashFolder->SetSizeOnDisk(0);

    // 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::DeleteStorage() {
  nsresult rv = nsMsgDBFolder::DeleteStorage();

  // Should notify nsIMsgFolderListeners about the folder getting deleted?
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::Rename(const nsAString& newName,
                                       nsIMsgWindow* msgWindow) {
  if (mFlags & nsMsgFolderFlags::Virtual)
    return nsMsgDBFolder::Rename(newName, msgWindow);
  nsresult rv;
  nsAutoString newNameStr(newName);
  if (newNameStr.FindChar(m_hierarchyDelimiter, 0) != kNotFound) {
    nsCOMPtr<nsIDocShell> docShell;
    if (msgWindow) msgWindow->GetRootDocShell(getter_AddRefs(docShell));
    if (docShell) {
      nsCOMPtr<nsIStringBundle> bundle;
      rv = IMAPGetStringBundle(getter_AddRefs(bundle));
      if (NS_SUCCEEDED(rv) && bundle) {
        AutoTArray<nsString, 1> formatStrings;
        formatStrings.AppendElement()->Append(m_hierarchyDelimiter);
        nsString alertString;
        rv = bundle->FormatStringFromName("imapSpecialChar2", formatStrings,
                                          alertString);
        nsCOMPtr<nsIPrompt> dialog(do_GetInterface(docShell));
        // setting up the dialog title
        nsCOMPtr<nsIMsgIncomingServer> server;
        rv = GetServer(getter_AddRefs(server));
        NS_ENSURE_SUCCESS(rv, rv);
        nsString dialogTitle;
        nsString accountName;
        rv = server->GetPrettyName(accountName);
        NS_ENSURE_SUCCESS(rv, rv);
        AutoTArray<nsString, 1> titleParams = {accountName};
        rv = bundle->FormatStringFromName("imapAlertDialogTitle", titleParams,
                                          dialogTitle);

        if (dialog && !alertString.IsEmpty())
          dialog->Alert(dialogTitle.get(), alertString.get());
      }
    }
    return NS_ERROR_FAILURE;
  }
  nsCOMPtr<nsIImapIncomingServer> incomingImapServer;
  GetImapIncomingServer(getter_AddRefs(incomingImapServer));
  if (incomingImapServer) RecursiveCloseActiveConnections(incomingImapServer);

  nsCOMPtr<nsIImapService> imapService =
      do_GetService(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) {
  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.AppendLiteral(FOLDER_SUFFIX8);
    nsAutoCString leafName;
    dirFile->GetNativeLeafName(leafName);
    if (!leafName.Equals(newNameStr))
      return dirFile->MoveToNative(
          nullptr,
          newNameStr);  // in case of rename operation leaf names will differ

    parentPathFile->AppendNative(
        newNameStr);  // only for move we need to progress further in case the
                      // parent differs
    bool isDirectory = false;
    parentPathFile->IsDirectory(&isDirectory);
    if (!isDirectory) {
      rv = parentPathFile->Create(nsIFile::DIRECTORY_TYPE, 0700);
      NS_ENSURE_SUCCESS(rv, rv);
    } else {
      NS_ERROR("Directory already exists.");
    }
    rv = RecursiveCopy(dirFile, parentPathFile);
    NS_ENSURE_SUCCESS(rv, rv);
    dirFile->Remove(true);  // moving folders
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::GetPrettyName(nsAString& prettyName) {
  return GetName(prettyName);
}

NS_IMETHODIMP nsImapMailFolder::UpdateSummaryTotals(bool force) {
  // bug 72871 inserted the mIsServer check for IMAP
  return mIsServer ? NS_OK : nsMsgDBFolder::UpdateSummaryTotals(force);
}

NS_IMETHODIMP nsImapMailFolder::GetDeletable(bool* deletable) {
  NS_ENSURE_ARG_POINTER(deletable);

  bool isServer;
  GetIsServer(&isServer);

  *deletable = !(isServer || (mFlags & nsMsgFolderFlags::SpecialUse));
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::GetSizeOnDisk(int64_t* size) {
  NS_ENSURE_ARG_POINTER(size);

  bool isServer = false;
  nsresult rv = GetIsServer(&isServer);
  // If this is the rootFolder, return 0 as a safe value.
  if (NS_FAILED(rv) || isServer) mFolderSize = 0;

  *size = mFolderSize;
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::GetCanCreateSubfolders(bool* aResult) {
  NS_ENSURE_ARG_POINTER(aResult);
  *aResult = !(mFlags &
               (nsMsgFolderFlags::ImapNoinferiors | nsMsgFolderFlags::Virtual));

  bool isServer = false;
  GetIsServer(&isServer);
  if (!isServer) {
    nsCOMPtr<nsIImapIncomingServer> imapServer;
    nsresult rv = GetImapIncomingServer(getter_AddRefs(imapServer));
    bool dualUseFolders = true;
    if (NS_SUCCEEDED(rv) && imapServer)
      imapServer->GetDualUseFolders(&dualUseFolders);
    if (!dualUseFolders && *aResult)
      *aResult = (mFlags & nsMsgFolderFlags::ImapNoselect);
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::GetCanSubscribe(bool* aResult) {
  NS_ENSURE_ARG_POINTER(aResult);
  *aResult = false;

  bool isImapServer = false;
  nsresult rv = GetIsServer(&isImapServer);
  if (NS_FAILED(rv)) return rv;
  // you can only subscribe to imap servers, not imap folders
  *aResult = isImapServer;
  return NS_OK;
}

nsresult nsImapMailFolder::GetServerKey(nsACString& serverKey) {
  // look for matching imap folders, then pop folders
  nsCOMPtr<nsIMsgIncomingServer> server;
  nsresult rv = GetServer(getter_AddRefs(server));
  if (NS_SUCCEEDED(rv)) rv = server->GetKey(serverKey);
  return rv;
}

NS_IMETHODIMP
nsImapMailFolder::GetImapIncomingServer(
    nsIImapIncomingServer** aImapIncomingServer) {
  NS_ENSURE_ARG(aImapIncomingServer);
  nsCOMPtr<nsIMsgIncomingServer> server;
  if (NS_SUCCEEDED(GetServer(getter_AddRefs(server))) && server) {
    nsCOMPtr<nsIImapIncomingServer> incomingServer = do_QueryInterface(server);
    NS_ENSURE_TRUE(incomingServer, NS_ERROR_NO_INTERFACE);
    incomingServer.forget(aImapIncomingServer);
    return NS_OK;
  }
  return NS_ERROR_NULL_POINTER;
}

NS_IMETHODIMP
nsImapMailFolder::AddMessageDispositionState(
    nsIMsgDBHdr* aMessage, nsMsgDispositionState aDispositionFlag) {
  nsMsgDBFolder::AddMessageDispositionState(aMessage, aDispositionFlag);

  // set the mark message answered flag on the server for this message...
  if (aMessage) {
    nsMsgKey msgKey;
    aMessage->GetMessageKey(&msgKey);

    if (aDispositionFlag == nsIMsgFolder::nsMsgDispositionState_Replied)
      StoreImapFlags(kImapMsgAnsweredFlag, true, {msgKey}, nullptr);
    else if (aDispositionFlag == nsIMsgFolder::nsMsgDispositionState_Forwarded)
      StoreImapFlags(kImapMsgForwardedFlag, true, {msgKey}, nullptr);
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::MarkMessagesRead(
    const nsTArray<RefPtr<nsIMsgDBHdr>>& messages, bool markRead) {
  // tell the folder to do it, which will mark them read in the db.
  nsresult rv = nsMsgDBFolder::MarkMessagesRead(messages, markRead);
  if (NS_SUCCEEDED(rv)) {
    nsAutoCString messageIds;
    nsTArray<nsMsgKey> keysToMarkRead;
    rv = BuildIdsAndKeyArray(messages, messageIds, keysToMarkRead);
    NS_ENSURE_SUCCESS(rv, rv);

    StoreImapFlags(kImapMsgSeenFlag, markRead, keysToMarkRead, nullptr);
    rv = GetDatabase();
    if (NS_SUCCEEDED(rv)) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
  }
  return rv;
}

NS_IMETHODIMP
nsImapMailFolder::SetLabelForMessages(
    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages, nsMsgLabelValue aLabel) {
  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, nullptr);
    rv = GetDatabase();
    if (NS_SUCCEEDED(rv)) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
  }
  return rv;
}

NS_IMETHODIMP
nsImapMailFolder::MarkAllMessagesRead(nsIMsgWindow* aMsgWindow) {
  nsresult rv = GetDatabase();
  if (NS_SUCCEEDED(rv)) {
    nsTArray<nsMsgKey> thoseMarked;
    EnableNotifications(allMessageCountNotifications, false);
    rv = mDatabase->MarkAllRead(thoseMarked);
    EnableNotifications(allMessageCountNotifications, true);
    if (NS_SUCCEEDED(rv) && thoseMarked.Length() > 0) {
      rv = StoreImapFlags(kImapMsgSeenFlag, true, thoseMarked, nullptr);
      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);

      // Setup a undo-state
      if (aMsgWindow)
        rv = AddMarkAllReadUndoAction(aMsgWindow, thoseMarked.Elements(),
                                      thoseMarked.Length());
    }
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::MarkThreadRead(nsIMsgThread* thread) {
  nsresult rv = GetDatabase();
  if (NS_SUCCEEDED(rv)) {
    nsTArray<nsMsgKey> keys;
    rv = mDatabase->MarkThreadRead(thread, nullptr, keys);
    if (NS_SUCCEEDED(rv) && keys.Length() > 0) {
      rv = StoreImapFlags(kImapMsgSeenFlag, true, keys, nullptr);
      mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
    }
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::ReadFromFolderCacheElem(
    nsIMsgFolderCacheElement* element) {
  nsresult rv = nsMsgDBFolder::ReadFromFolderCacheElem(element);
  int32_t hierarchyDelimiter = kOnlineHierarchySeparatorUnknown;
  nsCString onlineName;

  element->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(
    const nsTArray<RefPtr<nsIMsgDBHdr>>& messages, bool markFlagged) {
  nsresult rv;
  // tell the folder to do it, which will mark them read in the db.
  rv = nsMsgDBFolder::MarkMessagesFlagged(messages, markFlagged);
  if (NS_SUCCEEDED(rv)) {
    nsAutoCString messageIds;
    nsTArray<nsMsgKey> keysToMarkFlagged;
    rv = BuildIdsAndKeyArray(messages, messageIds, keysToMarkFlagged);
    if (NS_FAILED(rv)) return rv;
    rv = StoreImapFlags(kImapMsgFlaggedFlag, markFlagged, keysToMarkFlagged,
                        nullptr);
    NS_ENSURE_SUCCESS(rv, rv);
    rv = GetDatabase();
    NS_ENSURE_SUCCESS(rv, rv);
    mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::SetOnlineName(
    const nsACString& aOnlineFolderName) {
  nsresult rv;
  nsCOMPtr<nsIMsgDatabase> db;
  nsCOMPtr<nsIDBFolderInfo> folderInfo;
  rv = GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), getter_AddRefs(db));
  // do this after GetDBFolderInfoAndDB, because it crunches m_onlineFolderName
  // (not sure why)
  m_onlineFolderName = aOnlineFolderName;
  if (NS_SUCCEEDED(rv) && folderInfo) {
    nsAutoString onlineName;
    CopyUTF8toUTF16(aOnlineFolderName, onlineName);
    rv = folderInfo->SetProperty("onlineName", onlineName);
    rv = folderInfo->SetMailboxName(onlineName);
    // so, when are we going to commit this? Definitely not every time!
    // We could check if the online name has changed.
    db->Commit(nsMsgDBCommitType::kLargeCommit);
  }
  folderInfo = nullptr;
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::GetOnlineName(nsACString& aOnlineFolderName) {
  ReadDBFolderInfo(false);  // update cache first.
  aOnlineFolderName = m_onlineFolderName;
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::GetDBFolderInfoAndDB(nsIDBFolderInfo** folderInfo,
                                       nsIMsgDatabase** db) {
  NS_ENSURE_ARG_POINTER(folderInfo);
  NS_ENSURE_ARG_POINTER(db);

  nsresult rv = GetDatabase();
  if (NS_FAILED(rv)) return rv;

  NS_ADDREF(*db = mDatabase);

  rv = (*db)->GetDBFolderInfo(folderInfo);
  if (NS_FAILED(rv))
    return rv;  // GetDBFolderInfo can't return NS_OK if !folderInfo

  nsCString onlineName;
  rv = (*folderInfo)->GetCharProperty("onlineName", onlineName);
  if (NS_FAILED(rv)) return rv;

  if (!onlineName.IsEmpty())
    m_onlineFolderName.Assign(onlineName);
  else {
    nsAutoString autoOnlineName;
    (*folderInfo)->GetMailboxName(autoOnlineName);
    if (autoOnlineName.IsEmpty()) {
      nsCString uri;
      rv = GetURI(uri);
      NS_ENSURE_SUCCESS(rv, rv);

      nsCString hostname;
      rv = GetHostname(hostname);
      NS_ENSURE_SUCCESS(rv, rv);

      nsCString onlineCName;
      rv = nsImapURI2FullName(kImapRootURI, hostname.get(), uri.get(),
                              getter_Copies(onlineCName));
      // Note: check for unknown separator '^' only became needed
      // with UTF8=ACCEPT modification and haven't found why. Online name
      // contained the '^' delimiter and gmail said "NO" when folder under
      // [Gmail] is created and selected.
      if ((m_hierarchyDelimiter != '/') &&
          (m_hierarchyDelimiter != kOnlineHierarchySeparatorUnknown))
        onlineCName.ReplaceChar('/', m_hierarchyDelimiter);
      // XXX: What if online name contains slashes? Breaks?
      m_onlineFolderName.Assign(onlineCName);
      CopyUTF8toUTF16(onlineCName, autoOnlineName);
    }
    (*folderInfo)->SetProperty("onlineName", autoOnlineName);
  }
  return rv;
}

/* static */
nsresult nsImapMailFolder::BuildIdsAndKeyArray(
    const nsTArray<RefPtr<nsIMsgDBHdr>>& messages, nsCString& msgIds,
    nsTArray<nsMsgKey>& keyArray) {
  keyArray.Clear();
  keyArray.SetCapacity(messages.Length());
  // build up message keys.
  for (auto msgDBHdr : messages) {
    nsMsgKey key;
    nsresult rv = msgDBHdr->GetMessageKey(&key);
    if (NS_SUCCEEDED(rv)) keyArray.AppendElement(key);
  }
  return AllocateUidStringFromKeys(keyArray, msgIds);
}

/* static */
nsresult nsImapMailFolder::AllocateUidStringFromKeys(
    const nsTArray<nsMsgKey>& keys, nsCString& msgIds) {
  if (keys.IsEmpty()) return NS_ERROR_INVALID_ARG;
  nsresult rv = NS_OK;
  uint32_t startSequence;
  startSequence = keys[0];
  uint32_t curSequenceEnd = startSequence;
  uint32_t total = keys.Length();
  // sort keys and then generate ranges instead of singletons!
  nsTArray<nsMsgKey> sorted(keys.Clone());
  sorted.Sort();
  for (uint32_t keyIndex = 0; keyIndex < total; keyIndex++) {
    uint32_t curKey = sorted[keyIndex];
    uint32_t nextKey =
        (keyIndex + 1 < total) ? sorted[keyIndex + 1] : 0xFFFFFFFF;
    bool lastKey = (nextKey == 0xFFFFFFFF);

    if (lastKey) curSequenceEnd = curKey;
    if (nextKey == (uint32_t)curSequenceEnd + 1 && !lastKey) {
      curSequenceEnd = nextKey;
      continue;
    }
    if (curSequenceEnd > startSequence) {
      AppendUid(msgIds, startSequence);
      msgIds += ':';
      AppendUid(msgIds, curSequenceEnd);
      if (!lastKey) msgIds += ',';
      startSequence = nextKey;
      curSequenceEnd = startSequence;
    } else {
      startSequence = nextKey;
      curSequenceEnd = startSequence;
      AppendUid(msgIds, sorted[keyIndex]);
      if (!lastKey) msgIds += ',';
    }
  }
  return rv;
}

nsresult nsImapMailFolder::MarkMessagesImapDeleted(nsTArray<nsMsgKey>* keyArray,
                                                   bool deleted,
                                                   nsIMsgDatabase* db) {
  for (uint32_t kindex = 0; kindex < keyArray->Length(); kindex++) {
    nsMsgKey key = keyArray->ElementAt(kindex);
    db->MarkImapDeleted(key, deleted, nullptr);
  }
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::DeleteMessages(
    nsTArray<RefPtr<nsIMsgDBHdr>> const& msgHeaders, nsIMsgWindow* msgWindow,
    bool deleteStorage, bool isMove, nsIMsgCopyServiceListener* listener,
    bool allowUndo) {
  // *** jt - assuming delete is move to the trash folder for now
  nsAutoCString uri;
  bool deleteImmediatelyNoTrash = false;
  nsAutoCString messageIds;
  nsTArray<nsMsgKey> srcKeyArray;
  bool deleteMsgs = true;  // used for toggling delete status - default is true
  nsMsgImapDeleteModel deleteModel = nsMsgImapDeleteModels::MoveToTrash;
  imapMessageFlagsType messageFlags = kImapMsgDeletedFlag;

  nsCOMPtr<nsIImapIncomingServer> imapServer;
  nsresult rv = GetFlag(nsMsgFolderFlags::Trash, &deleteImmediatelyNoTrash);
  rv = GetImapIncomingServer(getter_AddRefs(imapServer));

  if (NS_SUCCEEDED(rv) && imapServer) {
    imapServer->GetDeleteModel(&deleteModel);
    if (deleteModel != nsMsgImapDeleteModels::MoveToTrash || deleteStorage)
      deleteImmediatelyNoTrash = true;
    // if we're deleting a message, we should pseudo-interrupt the msg
    // load of the current message.
    bool interrupted = false;
    imapServer->PseudoInterruptMsgLoad(this, msgWindow, &interrupted);
  }

  rv = BuildIdsAndKeyArray(msgHeaders, messageIds, srcKeyArray);
  if (NS_FAILED(rv)) return rv;

  nsCOMPtr<nsIMsgFolder> rootFolder;
  nsCOMPtr<nsIMsgFolder> trashFolder;

  if (!deleteImmediatelyNoTrash) {
    rv = GetRootFolder(getter_AddRefs(rootFolder));
    if (NS_SUCCEEDED(rv) && rootFolder) {
      rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Trash,
                                     getter_AddRefs(trashFolder));
      NS_ASSERTION(trashFolder, "couldn't find trash");
      // if we can't find the trash, we'll just have to do an imap delete and
      // pretend this is the trash
      if (!trashFolder) deleteImmediatelyNoTrash = true;
    }
  }

  if ((NS_SUCCEEDED(rv) && deleteImmediatelyNoTrash) ||
      deleteModel == nsMsgImapDeleteModels::IMAPDelete) {
    if (allowUndo) {
      // need to take care of these two delete models
      RefPtr<nsImapMoveCopyMsgTxn> undoMsgTxn = new nsImapMoveCopyMsgTxn;
      if (!undoMsgTxn ||
          NS_FAILED(undoMsgTxn->Init(this, &srcKeyArray, messageIds.get(),
                                     nullptr, true, isMove)))
        return NS_ERROR_OUT_OF_MEMORY;

      undoMsgTxn->SetTransactionType(nsIMessenger::eDeleteMsg);
      // we're adding this undo action before the delete is successful. This is
      // evil, but 4.5 did it as well.
      nsCOMPtr<nsITransactionManager> txnMgr;
      if (msgWindow) msgWindow->GetTransactionManager(getter_AddRefs(txnMgr));
      if (txnMgr) txnMgr->DoTransaction(undoMsgTxn);
    }

    if (deleteModel == nsMsgImapDeleteModels::IMAPDelete && !deleteStorage) {
      deleteMsgs = false;
      for (nsIMsgDBHdr* msgHdr : msgHeaders) {
        if (!msgHdr) {
          continue;
        }
        uint32_t flags;
        msgHdr->GetFlags(&flags);
        if (!(flags & nsMsgMessageFlags::IMAPDeleted)) {
          deleteMsgs = true;
          break;
        }
      }
    }
    // if copy service listener is also a url listener, pass that
    // url listener into StoreImapFlags.
    nsCOMPtr<nsIUrlListener> urlListener = do_QueryInterface(listener);
    if (deleteMsgs) messageFlags |= kImapMsgSeenFlag;
    rv = StoreImapFlags(messageFlags, deleteMsgs, srcKeyArray, urlListener);

    if (NS_SUCCEEDED(rv)) {
      if (mDatabase) {
        nsCOMPtr<nsIMsgDatabase> database(mDatabase);
        if (deleteModel == nsMsgImapDeleteModels::IMAPDelete)
          MarkMessagesImapDeleted(&srcKeyArray, deleteMsgs, database);
        else {
          EnableNotifications(allMessageCountNotifications,
                              false);  //"remove it immediately" model
          // Notify if this is an actual delete.
          if (!isMove) {
            nsCOMPtr<nsIMsgFolderNotificationService> notifier(
                do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
            if (notifier) notifier->NotifyMsgsDeleted(msgHeaders);
          }
          DeleteStoreMessages(msgHeaders);
          database->DeleteMessages(srcKeyArray, nullptr);
          EnableNotifications(allMessageCountNotifications, true);
        }
        if (listener) {
          listener->OnStartCopy();
          listener->OnStopCopy(NS_OK);
        }
        NotifyFolderEvent(kDeleteOrMoveMsgCompleted);
      }
    }
    return rv;
  }

  // have to move the messages to the trash
  if (trashFolder) {
    nsCOMPtr<nsIMsgFolder> srcFolder;
    nsCOMPtr<nsISupports> srcSupport;

    rv = QueryInterface(NS_GET_IID(nsIMsgFolder), getter_AddRefs(srcFolder));
    nsCOMPtr<nsIMsgCopyService> copyService =
        do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    rv = copyService->CopyMessages(srcFolder, msgHeaders, trashFolder, true,
                                   listener, msgWindow, allowUndo);
  }

  return rv;
}

// check if folder is the trash, or a descendent of the trash
// so we can tell if the folders we're deleting from it should
// be *really* deleted.
bool nsImapMailFolder::TrashOrDescendentOfTrash(nsIMsgFolder* folder) {
  NS_ENSURE_TRUE(folder, false);
  nsCOMPtr<nsIMsgFolder> parent;
  nsCOMPtr<nsIMsgFolder> curFolder = folder;
  nsresult rv;
  uint32_t flags = 0;
  do {
    rv = curFolder->GetFlags(&flags);
    if (NS_FAILED(rv)) return false;
    if (flags & nsMsgFolderFlags::Trash) return true;
    curFolder->GetParent(getter_AddRefs(parent));
    if (!parent) return false;
    curFolder = parent;
  } while (NS_SUCCEEDED(rv) && curFolder);
  return false;
}
NS_IMETHODIMP
nsImapMailFolder::DeleteSelf(nsIMsgWindow* msgWindow) {
  nsCOMPtr<nsIMsgFolder> trashFolder;
  nsresult rv;
  uint32_t folderFlags;

  // No IMAP shenanigans required for virtual folders.
  GetFlags(&folderFlags);
  if (folderFlags & nsMsgFolderFlags::Virtual) {
    return nsMsgDBFolder::DeleteSelf(nullptr);
  }

  // "this" is the folder we're deleting from
  bool deleteNoTrash = TrashOrDescendentOfTrash(this) || !DeleteIsMoveToTrash();
  bool confirmDeletion = true;

  nsCOMPtr<nsIImapService> imapService =
      do_GetService(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 we are deleting folder immediately, ask user for confirmation.
  bool confirmed = false;
  if (confirmDeletion || deleteNoTrash) {
    nsCOMPtr<nsIStringBundle> bundle;
    rv = IMAPGetStringBundle(getter_AddRefs(bundle));
    NS_ENSURE_SUCCESS(rv, rv);

    nsAutoString folderName;
    rv = GetName(folderName);
    NS_ENSURE_SUCCESS(rv, rv);
    AutoTArray<nsString, 1> formatStrings = {folderName};

    nsAutoString deleteFolderDialogTitle;
    rv = bundle->GetStringFromName("imapDeleteFolderDialogTitle",
                                   deleteFolderDialogTitle);
    NS_ENSURE_SUCCESS(rv, rv);

    nsAutoString deleteFolderButtonLabel;
    rv = bundle->GetStringFromName("imapDeleteFolderButtonLabel",
                                   deleteFolderButtonLabel);
    NS_ENSURE_SUCCESS(rv, rv);

    nsAutoString confirmationStr;
    rv = bundle->FormatStringFromName(
        (deleteNoTrash) ? "imapDeleteNoTrash" : "imapMoveFolderToTrash",
        formatStrings, confirmationStr);
    NS_ENSURE_SUCCESS(rv, rv);
    if (!msgWindow) return NS_ERROR_NULL_POINTER;
    nsCOMPtr<nsIDocShell> docShell;
    msgWindow->GetRootDocShell(getter_AddRefs(docShell));
    nsCOMPtr<nsIPrompt> dialog;
    if (docShell) dialog = do_GetInterface(docShell);
    if (dialog) {
      int32_t buttonPressed = 0;
      // Default the dialog to "cancel".
      const uint32_t buttonFlags =
          (nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_0) +
          (nsIPrompt::BUTTON_TITLE_CANCEL * nsIPrompt::BUTTON_POS_1);

      bool dummyValue = false;
      rv = dialog->ConfirmEx(deleteFolderDialogTitle.get(),
                             confirmationStr.get(), buttonFlags,
                             deleteFolderButtonLabel.get(), nullptr, nullptr,
                             nullptr, &dummyValue, &buttonPressed);
      NS_ENSURE_SUCCESS(rv, rv);
      confirmed = !buttonPressed;  // "ok" is in position 0
    }
  } else {
    confirmed = true;
  }

  if (confirmed) {
    if (deleteNoTrash) {
      rv = imapService->DeleteFolder(this, this, msgWindow, nullptr);
      nsMsgDBFolder::DeleteSelf(msgWindow);
    } else {
      bool match = false;
      rv = MatchOrChangeFilterDestination(nullptr, false, &match);
      if (match) {
        bool confirm = false;
        ConfirmFolderDeletionForFilter(msgWindow, &confirm);
        if (!confirm) return NS_OK;
      }
      rv = imapService->MoveFolder(this, trashFolder, this, msgWindow, nullptr);
    }
  }
  return rv;
}

// FIXME: helper function to know whether we should check all IMAP folders
// for new mail; this is necessary because of a legacy hidden preference
// mail.check_all_imap_folders_for_new (now replaced by per-server preference
// mail.server.%serverkey%.check_all_folders_for_new), still present in some
// profiles.
/*static*/
bool nsImapMailFolder::ShouldCheckAllFolders(
    nsIImapIncomingServer* imapServer) {
  // Check legacy global preference to see if we should check all folders for
  // new messages, or just the inbox and marked ones.
  bool checkAllFolders = false;
  nsresult rv;
  nsCOMPtr<nsIPrefBranch> prefBranch =
      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, false);
  // This pref might not exist, which is OK.
  (void)prefBranch->GetBoolPref("mail.check_all_imap_folders_for_new",
                                &checkAllFolders);

  if (checkAllFolders) return true;

  // If the legacy preference doesn't exist or has its default value (False),
  // the true preference is read.
  imapServer->GetCheckAllFoldersForNew(&checkAllFolders);
  return checkAllFolders;
}

// Called by Biff, or when user presses GetMsg button.
NS_IMETHODIMP nsImapMailFolder::GetNewMessages(nsIMsgWindow* aWindow,
                                               nsIUrlListener* aListener) {
  nsCOMPtr<nsIMsgFolder> rootFolder;
  nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
  if (NS_SUCCEEDED(rv) && rootFolder) {
    nsCOMPtr<nsIImapIncomingServer> imapServer;
    rv = GetImapIncomingServer(getter_AddRefs(imapServer));
    NS_ENSURE_SUCCESS(rv, rv);
    bool performingBiff = false;
    nsCOMPtr<nsIMsgIncomingServer> incomingServer =
        do_QueryInterface(imapServer, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    incomingServer->GetPerformingBiff(&performingBiff);
    m_urlListener = aListener;

    // See if we should check all folders for new messages, or just the inbox
    // and marked ones
    bool checkAllFolders = ShouldCheckAllFolders(imapServer);

    // Get new messages for inbox
    nsCOMPtr<nsIMsgFolder> inbox;
    rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox,
                                        getter_AddRefs(inbox));
    if (inbox) {
      nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(inbox, &rv);
      NS_ENSURE_SUCCESS(rv, rv);
      imapFolder->SetPerformingBiff(performingBiff);
      inbox->SetGettingNewMessages(true);
      rv = inbox->UpdateFolder(aWindow);
    }
    // Get new messages for other folders if marked, or all of them if the pref
    // is set
    rv = imapServer->GetNewMessagesForNonInboxFolders(
        rootFolder, aWindow, checkAllFolders, performingBiff);
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::Shutdown(bool shutdownChildren) {
  m_filterList = nullptr;
  m_initialized = false;
  // mPath is used to decide if folder pathname needs to be reconstructed in
  // GetPath().
  mPath = nullptr;
  m_moveCoalescer = nullptr;
  m_msgParser = nullptr;
  if (m_playbackTimer) {
    m_playbackTimer->Cancel();
    m_playbackTimer = nullptr;
  }
  m_pendingOfflineMoves.Clear();
  return nsMsgDBFolder::Shutdown(shutdownChildren);
}

nsresult nsImapMailFolder::GetBodysToDownload(
    nsTArray<nsMsgKey>* keysOfMessagesToDownload) {
  NS_ENSURE_ARG(keysOfMessagesToDownload);
  NS_ENSURE_TRUE(mDatabase, NS_ERROR_FAILURE);

  nsCOMPtr<nsIMsgEnumerator> enumerator;
  nsresult rv = mDatabase->EnumerateMessages(getter_AddRefs(enumerator));
  if (NS_SUCCEEDED(rv) && enumerator) {
    bool hasMore;
    while (NS_SUCCEEDED(rv = enumerator->HasMoreElements(&hasMore)) &&
           hasMore) {
      nsCOMPtr<nsIMsgDBHdr> header;
      rv = enumerator->GetNext(getter_AddRefs(header));
      NS_ENSURE_SUCCESS(rv, rv);
      bool shouldStoreMsgOffline = false;
      nsMsgKey msgKey;
      header->GetMessageKey(&msgKey);
      // MsgFitsDownloadCriteria ignores nsMsgFolderFlags::Offline, which we
      // want
      if (m_downloadingFolderForOfflineUse)
        MsgFitsDownloadCriteria(msgKey, &shouldStoreMsgOffline);
      else
        ShouldStoreMsgOffline(msgKey, &shouldStoreMsgOffline);
      if (shouldStoreMsgOffline)
        keysOfMessagesToDownload->AppendElement(msgKey);
    }
  }
  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);
      MOZ_LOG(IMAP_CS, mozilla::LogLevel::Debug,
              ("UpdateImapMailboxInfo(): Store highest MODSEQ=%" PRIu64
               " for folder=%s",
               mailboxHighestModSeq, m_onlineFolderName.get()));
      char intStrBuf[40];
      PR_snprintf(intStrBuf, sizeof(intStrBuf), "%llu", mailboxHighestModSeq);
      dbFolderInfo->SetCharProperty(kModSeqPropertyName,
                                    nsDependentCString(intStrBuf));
    }
    nsTArray<nsMsgKey> keys;
    rv = mDatabase->ListAllKeys(keys);
    NS_ENSURE_SUCCESS(rv, rv);
    existingKeys.AppendElements(keys);
    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.
      MOZ_LOG(IMAP_CS, mozilla::LogLevel::Debug,
              ("UpdateImapMailboxInfo(): UIDVALIDITY changed, reset highest "
               "MODSEQ and UID for folder=%s",
               m_onlineFolderName.get()));
      dbFolderInfo->SetCharProperty(kModSeqPropertyName, EmptyCString());
      dbFolderInfo->SetUint32Property(kHighestRecordedUIDPropertyName, 0);
    }
    // delete all my msgs, the keys are bogus now
    // add every message in this folder
    existingKeys.Clear();
    //      keysToDelete.CopyArray(&existingKeys);

    if (flagState) {
      nsTArray<nsMsgKey> no_existingKeys;
      FindKeysToAdd(no_existingKeys, m_keysToFetch, numNewUnread, flagState);
    }
    if (NS_FAILED(rv)) pathFile->Remove(false);

  } else if (!flagState /*&& !NET_IsOffline() */)  // if there are no messages
                                                   // on the server
    keysToDelete = existingKeys.Clone();
  else /* if ( !NET_IsOffline()) */
  {
    uint32_t boxFlags;
    aSpec->GetBox_flags(&boxFlags);
    // FindKeysToDelete and FindKeysToAdd require sorted lists
    existingKeys.Sort();
    FindKeysToDelete(existingKeys, keysToDelete, flagState, boxFlags);
    // if this is the result of an expunge then don't grab headers
    if (!(boxFlags & kJustExpunged))
      FindKeysToAdd(existingKeys, m_keysToFetch, numNewUnread, flagState);
  }
  m_totalKeysToFetch = m_keysToFetch.Length();
  if (!keysToDelete.IsEmpty() && mDatabase) {
    nsTArray<RefPtr<nsIMsgDBHdr>> hdrsToDelete;
    MsgGetHeadersFromKeys(mDatabase, keysToDelete, hdrsToDelete);
    // Notify nsIMsgFolderListeners of a mass delete, but only if we actually
    // have headers
    if (!hdrsToDelete.IsEmpty()) {
      nsCOMPtr<nsIMsgFolderNotificationService> notifier(
          do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
      if (notifier) notifier->NotifyMsgsDeleted(hdrsToDelete);
    }
    DeleteStoreMessages(hdrsToDelete);
    EnableNotifications(nsIMsgFolder::allMessageCountNotifications, false);
    mDatabase->DeleteMessages(keysToDelete, nullptr);
    EnableNotifications(nsIMsgFolder::allMessageCountNotifications, true);
  }
  int32_t numUnreadFromServer;
  aSpec->GetNumUnseenMessages(&numUnreadFromServer);

  bool partialUIDFetch;
  flagState->GetPartialUIDFetch(&partialUIDFetch);

  // For partial UID fetches, 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);

    // clang-format off
    bool doFilter = filterOnHighwater
      // Filter on largest UUID and not deleted.
      ? m_curMsgUid > highestUID && !(msgFlags & nsMsgMessageFlags::IMAPDeleted)
      // Filter on unread and not deleted.
      : !(msgFlags & (nsMsgMessageFlags::Read | nsMsgMessageFlags::IMAPDeleted));
    // clang-format on

    if (doFilter)
      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
              ("(Imap) New message parsed, and filters will be run on it"));
    else
      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
              ("(Imap) New message parsed, but filters will not be run on it"));

    if (doFilter) {
      int32_t duplicateAction = nsIMsgIncomingServer::keepDups;
      if (server) server->GetIncomingDuplicateAction(&duplicateAction);
      if ((duplicateAction != nsIMsgIncomingServer::keepDups) &&
          mFlags & nsMsgFolderFlags::Inbox) {
        bool isDup;
        server->IsNewHdrDuplicate(newMsgHdr, &isDup);
        if (isDup) {
          // we want to do something similar to applying filter hits.
          // if a dup is marked read, it shouldn't trigger biff.
          // Same for deleting it or moving it to trash.
          switch (duplicateAction) {
            case nsIMsgIncomingServer::deleteDups: {
              uint32_t newFlags;
              newMsgHdr->OrFlags(
                  nsMsgMessageFlags::Read | nsMsgMessageFlags::IMAPDeleted,
                  &newFlags);
              StoreImapFlags(kImapMsgSeenFlag | kImapMsgDeletedFlag, true,
                             {m_curMsgUid}, nullptr);
              m_msgMovedByFilter = true;
            } break;
            case nsIMsgIncomingServer::moveDupsToTrash: {
              nsCOMPtr<nsIMsgFolder> trash;
              GetTrashFolder(getter_AddRefs(trash));
              if (trash) {
                nsCString trashUri;
                trash->GetURI(trashUri);
                nsresult err = MoveIncorporatedMessage(
                    newMsgHdr, mDatabase, trashUri, nullptr, msgWindow);
                if (NS_SUCCEEDED(err)) m_msgMovedByFilter = true;
              }
            } break;
            case nsIMsgIncomingServer::markDupsRead: {
              uint32_t newFlags;
              newMsgHdr->OrFlags(nsMsgMessageFlags::Read, &newFlags);
              StoreImapFlags(kImapMsgSeenFlag, true, {m_curMsgUid}, nullptr);
            } break;
          }
          int32_t numNewMessages;
          GetNumNewMessages(false, &numNewMessages);
          SetNumNewMessages(numNewMessages - 1);
        }
      }
      rv = m_msgParser->GetAllHeaders(&headers, &headersSize);

      if (NS_SUCCEEDED(rv) && headers && !m_msgMovedByFilter &&
          !m_filterListRequiresBody) {
        if (m_filterList) {
          GetMoveCoalescer();  // not sure why we're doing this here.
          MOZ_LOG(FILTERLOGMODULE, LogLevel::Debug,
                  ("(Imap) ApplyFilterToHdr from "
                   "nsImapMailFolder::NormalEndHeaderParseStream()"));
          m_filterList->ApplyFiltersToHdr(
              nsMsgFilterType::InboxRule, newMsgHdr, this, mDatabase,
              nsDependentCSubstring(headers, headersSize), this, msgWindow);
          NotifyFolderEvent(kFiltersApplied);
        }
      }
    }
  }
  // here we need to tweak flags from uid state..
  if (mDatabase && (!m_msgMovedByFilter || ShowDeletedMessages())) {
    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
        do_GetService(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;
    newMsgHdr->GetMessageId(getter_Copies(newMessageId));
    nsMsgKey pseudoKey =
        m_pseudoHdrs.MaybeGet(newMessageId).valueOr(nsMsgKey_None);
    if (notifier && pseudoKey != nsMsgKey_None) {
      notifier->NotifyMsgKeyChanged(pseudoKey, newMsgHdr);
      m_pseudoHdrs.Remove(newMessageId);
    }
    mDatabase->AddNewHdrToDB(newMsgHdr, true);
    if (notifier) notifier->NotifyMsgAdded(newMsgHdr);
    // mark the header as not yet reported classified
    OrProcessingFlags(m_curMsgUid, nsMsgProcessingFlags::NotReportedClassified);
  }
  // adjust highestRecordedUID
  if (dbFolderInfo) {
    if (m_curMsgUid > highestUID) {
      MOZ_LOG(IMAP_CS, mozilla::LogLevel::Debug,
              ("NormalEndHeaderParseStream(): Store new highest UID=%" PRIu32
               " for folder=%s",
               m_curMsgUid, m_onlineFolderName.get()));
      dbFolderInfo->SetUint32Property(kHighestRecordedUIDPropertyName,
                                      m_curMsgUid);
    }
  }

  if (m_isGmailServer) {
    nsCOMPtr<nsIImapFlagAndUidState> flagState;
    aProtocol->GetFlagAndUidState(getter_AddRefs(flagState));
    nsCString msgIDValue;
    nsCString threadIDValue;
    nsCString labelsValue;
    flagState->GetCustomAttribute(m_curMsgUid, "X-GM-MSGID"_ns, msgIDValue);
    flagState->GetCustomAttribute(m_curMsgUid, "X-GM-THRID"_ns, threadIDValue);
    flagState->GetCustomAttribute(m_curMsgUid, "X-GM-LABELS"_ns, labelsValue);
    newMsgHdr->SetStringProperty("X-GM-MSGID", msgIDValue.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->HumanReadablePath();
      MOZ_LOG(IMAP, mozilla::LogLevel::Info,
              ("couldn't remove prev temp file %s: %" PRIx32, nativePath.get(),
               static_cast<uint32_t>(rv)));
    }
    m_copyState->m_tmpFile = nullptr;
  }

  rv = 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:%" PRIx32, static_cast<uint32_t>(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:%" PRIx32,
             static_cast<uint32_t>(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.AppendLiteral(".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: %" PRIx32,
                 static_cast<uint32_t>(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: %" PRIx32,
             static_cast<uint32_t>(rv)));

  if (!m_copyState->m_dataBuffer)
    m_copyState->m_dataBuffer = (char*)PR_CALLOC(COPY_BUFFER_SIZE + 1);
  NS_ENSURE_TRUE(m_copyState->m_dataBuffer, NS_ERROR_OUT_OF_MEMORY);
  m_copyState->m_dataBufferSize = COPY_BUFFER_SIZE;
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::CopyDataToOutputStreamForAppend(
    nsIInputStream* aIStream, int32_t aLength, nsIOutputStream* outputStream) {
  uint32_t readCount;
  uint32_t writeCount;
  if (!m_copyState) m_copyState = new nsImapMailCopyState();

  if (aLength + m_copyState->m_leftOver > m_copyState->m_dataBufferSize) {
    char* newBuffer = (char*)PR_REALLOC(m_copyState->m_dataBuffer,
                                        aLength + m_copyState->m_leftOver + 1);
    NS_ENSURE_TRUE(newBuffer, NS_ERROR_OUT_OF_MEMORY);
    m_copyState->m_dataBuffer = newBuffer;
    m_copyState->m_dataBufferSize = aLength + m_copyState->m_leftOver;
  }

  char *start, *end;
  uint32_t linebreak_len = 1;

  nsresult rv = aIStream->Read(
      m_copyState->m_dataBuffer + m_copyState->m_leftOver, aLength, &readCount);
  if (NS_FAILED(rv)) return rv;

  m_copyState->m_leftOver += readCount;
  m_copyState->m_dataBuffer[m_copyState->m_leftOver] = '\0';

  start = m_copyState->m_dataBuffer;
  if (m_copyState->m_eatLF) {
    if (*start == '\n') start++;
    m_copyState->m_eatLF = false;
  }
  end = PL_strpbrk(start, "\r\n");
  if (end && *end == '\r' && *(end + 1) == '\n') linebreak_len = 2;

  while (start && end) {
    if (PL_strncasecmp(start, "X-Mozilla-Status:", 17) &&
        PL_strncasecmp(start, "X-Mozilla-Status2:", 18) &&
        PL_strncmp(start, "From - ", 7)) {
      rv = outputStream->Write(start, end - start, &writeCount);
      rv = outputStream->Write(CRLF, 2, &writeCount);
    }
    start = end + linebreak_len;
    if (start >= m_copyState->m_dataBuffer + m_copyState->m_leftOver) {
      m_copyState->m_leftOver = 0;
      break;
    }
    linebreak_len = 1;

    end = PL_strpbrk(start, "\r\n");
    if (end && *end == '\r') {
      if (*(end + 1) == '\n')
        linebreak_len = 2;
      else if (!*(end + 1))  // block might have split CRLF so remember if
        m_copyState->m_eatLF = true;  // we should eat LF
    }

    if (start && !end) {
      m_copyState->m_leftOver -= (start - m_copyState->m_dataBuffer);
      memcpy(m_copyState->m_dataBuffer, start,
             m_copyState->m_leftOver + 1);  // including null
    }
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::CopyDataDone() {
  m_copyState = nullptr;
  return NS_OK;
}

// sICopyMessageListener methods, BeginCopy, CopyData, EndCopy, EndMove,
// StartMessage, EndMessage
NS_IMETHODIMP nsImapMailFolder::CopyData(nsIInputStream* aIStream,
                                         int32_t aLength) {
  NS_ENSURE_TRUE(
      m_copyState && m_copyState->m_msgFileStream && m_copyState->m_dataBuffer,
      NS_ERROR_NULL_POINTER);
  nsresult rv = CopyDataToOutputStreamForAppend(aIStream, aLength,
                                                m_copyState->m_msgFileStream);
  if (NS_FAILED(rv)) {
    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
            ("CopyData failed: %" PRIx32, static_cast<uint32_t>(rv)));
    OnCopyCompleted(m_copyState->m_srcSupport, rv);
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::EndCopy(bool copySucceeded) {
  nsresult rv = copySucceeded ? NS_OK : NS_ERROR_FAILURE;
  if (copySucceeded && m_copyState && m_copyState->m_msgFileStream) {
    nsCOMPtr<nsIUrlListener> urlListener;
    m_copyState->m_msgFileStream->Close();
    // m_tmpFile can be stale because we wrote to it
    nsCOMPtr<nsIFile> tmpFile;
    m_copyState->m_tmpFile->Clone(getter_AddRefs(tmpFile));
    m_copyState->m_tmpFile = tmpFile;
    nsCOMPtr<nsIImapService> imapService =
        do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);

    rv =
        QueryInterface(NS_GET_IID(nsIUrlListener), getter_AddRefs(urlListener));
    rv = imapService->AppendMessageFromFile(
        m_copyState->m_tmpFile, this, EmptyCString(), true,
        m_copyState->m_selectedState, urlListener, nullptr, m_copyState,
        m_copyState->m_msgWindow);
  }
  if (NS_FAILED(rv) || !copySucceeded)
    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
            ("EndCopy failed: %" PRIx32, static_cast<uint32_t>(rv)));
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::EndMove(bool moveSucceeded) { return NS_OK; }
// this is the beginning of the next message copied
NS_IMETHODIMP nsImapMailFolder::StartMessage() { return NS_OK; }

// just finished the current message.
NS_IMETHODIMP nsImapMailFolder::EndMessage(nsMsgKey key) { return NS_OK; }

NS_IMETHODIMP nsImapMailFolder::ApplyFilterHit(nsIMsgFilter* filter,
                                               nsIMsgWindow* msgWindow,
                                               bool* applyMore) {
  //
  //  This routine is called indirectly from ApplyFiltersToHdr in two
  //  circumstances, controlled by m_filterListRequiresBody:
  //
  //  If false, after headers are parsed in NormalEndHeaderParseStream.
  //  If true, after the message body is downloaded in NormalEndMsgWriteStream.
  //
  //  In NormalEndHeaderParseStream, the message has not been added to the
  //  database, and it is important that database notifications and count
  //  updates do not occur. In NormalEndMsgWriteStream, the message has been
  //  added to the database, and database notifications and count updates
  //  should be performed.
  //

  NS_ENSURE_ARG_POINTER(filter);
  NS_ENSURE_ARG_POINTER(applyMore);

  nsresult rv = NS_OK;

  nsCOMPtr<nsIMsgDBHdr> msgHdr;
  if (m_filterListRequiresBody)
    GetMessageHeader(m_curMsgUid, getter_AddRefs(msgHdr));
  else if (m_msgParser)
    m_msgParser->GetNewMsgHdr(getter_AddRefs(msgHdr));
  NS_ENSURE_TRUE(msgHdr,
                 NS_ERROR_NULL_POINTER);  // fatal error, cannot apply filters

  bool deleteToTrash = DeleteIsMoveToTrash();

  nsTArray<RefPtr<nsIMsgRuleAction>> filterActionList;
  rv = filter->GetSortedActionList(filterActionList);
  NS_ENSURE_SUCCESS(rv, rv);

  uint32_t numActions = filterActionList.Length();

  nsCString msgId;
  msgHdr->GetMessageId(getter_Copies(msgId));
  nsMsgKey msgKey;
  msgHdr->GetMessageKey(&msgKey);
  MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
          ("(Imap) Applying %" PRIu32
           " filter actions on message with key %" PRIu32,
           numActions, msgKeyToInt(msgKey)));
  MOZ_LOG(FILTERLOGMODULE, LogLevel::Debug,
          ("(Imap) Message ID: %s", msgId.get()));

  bool loggingEnabled = false;
  if (m_filterList && numActions)
    (void)m_filterList->GetLoggingEnabled(&loggingEnabled);

  bool msgIsNew = true;

  rv = GetDatabase();
  NS_ENSURE_SUCCESS(rv, rv);

  nsresult finalResult = NS_OK;  // result of all actions
  for (uint32_t actionIndex = 0; actionIndex < numActions; actionIndex++) {
    nsCOMPtr<nsIMsgRuleAction> filterAction(filterActionList[actionIndex]);
    if (!filterAction) {
      MOZ_LOG(FILTERLOGMODULE, LogLevel::Warning,
              ("(Imap) Filter action at index %" PRIu32 " invalid, skipping",
               actionIndex));
      continue;
    }

    rv = NS_OK;  // result of the current action
    nsMsgRuleActionType actionType;
    if (NS_SUCCEEDED(filterAction->GetType(&actionType))) {
      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
              ("(Imap) Running filter action at index %" PRIu32
               ", action type = %i",
               actionIndex, actionType));
      if (loggingEnabled) (void)filter->LogRuleHit(filterAction, msgHdr);

      nsCString actionTargetFolderUri;
      if (actionType == nsMsgFilterAction::MoveToFolder ||
          actionType == nsMsgFilterAction::CopyToFolder) {
        rv = filterAction->GetTargetFolderUri(actionTargetFolderUri);
        if (NS_FAILED(rv) || actionTargetFolderUri.IsEmpty()) {
          // clang-format off
          MOZ_LOG(FILTERLOGMODULE, LogLevel::Warning,
                  ("(Imap) Target URI for Copy/Move action is empty, skipping"));
          // clang-format on
          NS_ASSERTION(false, "actionTargetFolderUri is empty");
          continue;
        }
      }

      uint32_t msgFlags;
      msgHdr->GetFlags(&msgFlags);
      bool isRead = (msgFlags & nsMsgMessageFlags::Read);

      switch (actionType) {
        case nsMsgFilterAction::Delete: {
          if (deleteToTrash) {
            // set value to trash folder
            nsCOMPtr<nsIMsgFolder> mailTrash;
            rv = GetTrashFolder(getter_AddRefs(mailTrash));
            if (NS_SUCCEEDED(rv) && mailTrash) {
              rv = mailTrash->GetURI(actionTargetFolderUri);
              if (NS_FAILED(rv)) break;
            }
            // msgHdr->OrFlags(nsMsgMessageFlags::Read, &newFlags);  // mark
            // read in trash.
          } else {
            mDatabase->MarkHdrRead(msgHdr, true, nullptr);
            mDatabase->MarkImapDeleted(msgKey, true, nullptr);
            rv = StoreImapFlags(kImapMsgSeenFlag | kImapMsgDeletedFlag, true,
                                {msgKey}, nullptr);
            if (NS_FAILED(rv)) break;
            // this will prevent us from adding the header to the db.
            m_msgMovedByFilter = true;
          }
          msgIsNew = false;
        }
          // note that delete falls through to move.
          [[fallthrough]];
        case nsMsgFilterAction::MoveToFolder: {
          // if moving to a different file, do it.
          nsCString uri;
          rv = GetURI(uri);
          if (NS_FAILED(rv)) break;

          if (!actionTargetFolderUri.Equals(uri)) {
            msgHdr->GetFlags(&msgFlags);
            if (msgFlags & nsMsgMessageFlags::MDNReportNeeded && !isRead) {
              mDatabase->MarkMDNNeeded(msgKey, false, nullptr);
              mDatabase->MarkMDNSent(msgKey, true, nullptr);
            }
            nsresult rv = MoveIncorporatedMessage(
                msgHdr, mDatabase, actionTargetFolderUri, filter, msgWindow);
            if (NS_SUCCEEDED(rv)) {
              m_msgMovedByFilter = true;
            } else {
              if (loggingEnabled) {
                (void)filter->LogRuleHitFail(filterAction, msgHdr, rv,
                                             "filterFailureMoveFailed"_ns);
              }
            }
          }
          // don't apply any more filters, even if it was a move to the same
          // folder
          *applyMore = false;
        } break;
        case nsMsgFilterAction::CopyToFolder: {
          nsCString uri;
          rv = GetURI(uri);
          if (NS_FAILED(rv)) break;

          if (!actionTargetFolderUri.Equals(uri)) {
            // XXXshaver I'm not actually 100% what the right semantics are for
            // MDNs and copied messages, but I suspect deep down inside that
            // we probably want to suppress them only on the copies.
            msgHdr->GetFlags(&msgFlags);
            if (msgFlags & nsMsgMessageFlags::MDNReportNeeded && !isRead) {
              mDatabase->MarkMDNNeeded(msgKey, false, nullptr);
              mDatabase->MarkMDNSent(msgKey, true, nullptr);
            }

            nsCOMPtr<nsIMsgFolder> dstFolder;
            rv = GetExistingFolder(actionTargetFolderUri,
                                   getter_AddRefs(dstFolder));
            if (NS_FAILED(rv)) break;

            nsCOMPtr<nsIMsgCopyService> copyService =
                do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
            if (NS_FAILED(rv)) break;
            rv = copyService->CopyMessages(this, {&*msgHdr}, dstFolder, false,
                                           nullptr, msgWindow, false);
            if (NS_FAILED(rv)) {
              if (loggingEnabled) {
                (void)filter->LogRuleHitFail(filterAction, msgHdr, rv,
                                             "filterFailureCopyFailed"_ns);
              }
            }
          }
        } break;
        case nsMsgFilterAction::MarkRead: {
          mDatabase->MarkHdrRead(msgHdr, true, nullptr);
          rv = StoreImapFlags(kImapMsgSeenFlag, true, {msgKey}, nullptr);
          msgIsNew = false;
        } break;
        case nsMsgFilterAction::MarkUnread: {
          mDatabase->MarkHdrRead(msgHdr, false, nullptr);
          rv = StoreImapFlags(kImapMsgSeenFlag, false, {msgKey}, nullptr);
          msgIsNew = true;
        } break;
        case nsMsgFilterAction::MarkFlagged: {
          mDatabase->MarkHdrMarked(msgHdr, true, nullptr);
          rv = StoreImapFlags(kImapMsgFlaggedFlag, true, {msgKey}, nullptr);
        } break;
        case nsMsgFilterAction::KillThread:
        case nsMsgFilterAction::WatchThread: {
          nsCOMPtr<nsIMsgThread> msgThread;
          nsMsgKey threadKey;
          mDatabase->GetThreadContainingMsgHdr(msgHdr,
                                               getter_AddRefs(msgThread));
          if (msgThread) {
            msgThread->GetThreadKey(&threadKey);
            if (actionType == nsMsgFilterAction::KillThread)
              rv = mDatabase->MarkThreadIgnored(msgThread, threadKey, true,
                                                nullptr);
            else
              rv = mDatabase->MarkThreadWatched(msgThread, threadKey, true,
                                                nullptr);
          } else {
            if (actionType == nsMsgFilterAction::KillThread)
              rv = msgHdr->SetUint32Property("ProtoThreadFlags",
                                             nsMsgMessageFlags::Ignored);
            else
              rv = msgHdr->SetUint32Property("ProtoThreadFlags",
                                             nsMsgMessageFlags::Watched);
          }
          if (actionType == nsMsgFilterAction::KillThread) {
            mDatabase->MarkHdrRead(msgHdr, true, nullptr);
            rv = StoreImapFlags(kImapMsgSeenFlag, true, {msgKey}, nullptr);
            msgIsNew = false;
          }
        } break;
        case nsMsgFilterAction::KillSubthread: {
          mDatabase->MarkHeaderKilled(msgHdr, true, nullptr);
          mDatabase->MarkHdrRead(msgHdr, true, nullptr);
          rv = StoreImapFlags(kImapMsgSeenFlag, true, {msgKey}, nullptr);
          msgIsNew = false;
        } break;
        case nsMsgFilterAction::ChangePriority: {
          nsMsgPriorityValue filterPriority;  // a int32_t
          filterAction->GetPriority(&filterPriority);
          rv = mDatabase->SetUint32PropertyByHdr(
              msgHdr, "priority", static_cast<uint32_t>(filterPriority));
        } break;
        case nsMsgFilterAction::Label: {
          nsMsgLabelValue filterLabel;
          filterAction->GetLabel(&filterLabel);
          mDatabase->SetUint32PropertyByHdr(msgHdr, "label",
                                            static_cast<uint32_t>(filterLabel));
          rv = StoreImapFlags((filterLabel << 9), true, {msgKey}, nullptr);
        } break;
        case nsMsgFilterAction::AddTag: {
          nsCString keyword;
          filterAction->GetStrValue(keyword);
          rv = AddKeywordsToMessages({&*msgHdr}, keyword);
        } break;
        case nsMsgFilterAction::JunkScore: {
          nsAutoCString junkScoreStr;
          int32_t junkScore;
          filterAction->GetJunkScore(&junkScore);
          junkScoreStr.AppendInt(junkScore);
          rv = mDatabase->SetStringProperty(msgKey, "junkscore",
                                            junkScoreStr.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));
          if (NS_FAILED(rv)) break;
          if (!forwardTo.IsEmpty()) {
            nsCOMPtr<nsIMsgComposeService> compService =
                do_GetService(NS_MSGCOMPOSESERVICE_CONTRACTID, &rv);
            if (NS_FAILED(rv)) break;
            rv = compService->ForwardMessage(
                NS_ConvertUTF8toUTF16(forwardTo), msgHdr, msgWindow, server,
                nsIMsgComposeService::kForwardAsDefault);
          }
        } break;

        case nsMsgFilterAction::Reply: {
          nsCString replyTemplateUri;
          filterAction->GetStrValue(replyTemplateUri);
          nsCOMPtr<nsIMsgIncomingServer> server;
          rv = GetServer(getter_AddRefs(server));
          if (NS_FAILED(rv)) break;
          if (!replyTemplateUri.IsEmpty()) {
            nsCOMPtr<nsIMsgComposeService> compService =
                do_GetService(NS_MSGCOMPOSESERVICE_CONTRACTID, &rv);
            if (NS_SUCCEEDED(rv) && compService) {
              rv = compService->ReplyWithTemplate(msgHdr, replyTemplateUri,
                                                  msgWindow, server);
              if (NS_FAILED(rv)) {
                NS_WARNING("ReplyWithTemplate failed");
                if (rv == NS_ERROR_ABORT) {
                  (void)filter->LogRuleHitFail(
                      filterAction, msgHdr, rv,
                      "filterFailureSendingReplyAborted"_ns);
                } else {
                  (void)filter->LogRuleHitFail(
                      filterAction, msgHdr, rv,
                      "filterFailureSendingReplyError"_ns);
                }
              }
            }
          }
        } break;

        case nsMsgFilterAction::StopExecution: {
          // don't apply any more filters
          *applyMore = false;
          rv = NS_OK;
        } break;

        case nsMsgFilterAction::Custom: {
          nsCOMPtr<nsIMsgFilterCustomAction> customAction;
          rv = filterAction->GetCustomAction(getter_AddRefs(customAction));
          if (NS_FAILED(rv)) break;

          nsAutoCString value;
          rv = filterAction->GetStrValue(value);
          if (NS_FAILED(rv)) break;

          rv = customAction->ApplyAction({&*msgHdr}, value, nullptr,
                                         nsMsgFilterType::InboxRule, msgWindow);
          // allow custom action to affect new
          msgHdr->GetFlags(&msgFlags);
          if (!(msgFlags & nsMsgMessageFlags::New)) msgIsNew = false;
        } break;

        default:
          NS_ERROR("unexpected filter action");
          rv = NS_ERROR_UNEXPECTED;
          break;
      }
    }
    if (NS_FAILED(rv)) {
      finalResult = rv;
      MOZ_LOG(FILTERLOGMODULE, LogLevel::Error,
              ("(Imap) Action execution failed with error: %" PRIx32,
               static_cast<uint32_t>(rv)));
      if (loggingEnabled) {
        (void)filter->LogRuleHitFail(filterAction, msgHdr, rv,
                                     "filterFailureAction"_ns);
      }
    } else {
      MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
              ("(Imap) Action execution succeeded"));
    }
  }
  if (!msgIsNew) {
    int32_t numNewMessages;
    GetNumNewMessages(false, &numNewMessages);
    // When database notifications are active, new counts will be reset
    // to zero in nsMsgDBFolder::SendFlagNotifications by the call to
    // SetBiffState(nsMsgBiffState_NoMail), so don't repeat them here.
    if (!m_filterListRequiresBody) SetNumNewMessages(--numNewMessages);
    if (mDatabase) mDatabase->MarkHdrNotNew(msgHdr, nullptr);
    MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
            ("(Imap) Message will not be marked new"));
  }
  MOZ_LOG(FILTERLOGMODULE, LogLevel::Info,
          ("(Imap) Finished executing actions"));
  return finalResult;
}

NS_IMETHODIMP nsImapMailFolder::SetImapFlags(const char* uids, int32_t flags,
                                             nsIURI** url) {
  nsresult rv;
  nsCOMPtr<nsIImapService> imapService =
      do_GetService(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(const nsTArray<nsMsgKey>& aMsgKeys,
                                        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<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))) {
        nsTArray<RefPtr<nsIMsgDBHdr>> messages;
        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(opSrcUri);
            if (opSrcUri.Equals(srcFolderUri)) {
              nsMsgKey srcMessageKey;
              currentOp->GetSrcMessageKey(&srcMessageKey);
              for (auto key : aMsgKeys) {
                if (srcMessageKey == key) {
                  nsCOMPtr<nsIMsgDBHdr> fakeDestHdr;
                  dstFolderDB->GetMsgHdrForKey(offlineOps[opIndex],
                                               getter_AddRefs(fakeDestHdr));
                  if (fakeDestHdr) messages.AppendElement(fakeDestHdr);
                  break;
                }
              }
            }
          }
        }
        // 3rd parameter: Set offline flag.
        destImapFolder->SetPendingAttributes(messages, isMove, true);
      }
    }
    // 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, uids);
  rv = imapService->OnlineMessageCopy(this, uids, aDstFolder, true, isMove,
                                      aUrlListener, getter_AddRefs(resultUrl),
                                      nullptr, aWindow);
  if (resultUrl) {
    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(resultUrl, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    nsCOMPtr<nsIUrlListener> folderListener = do_QueryInterface(aDstFolder);
    if (folderListener) mailnewsUrl->RegisterListener(folderListener);
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::AddMoveResultPseudoKey(nsMsgKey aMsgKey) {
  nsresult rv = GetDatabase();
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIMsgDBHdr> pseudoHdr;
  rv = mDatabase->GetMsgHdrForKey(aMsgKey, getter_AddRefs(pseudoHdr));
  NS_ENSURE_SUCCESS(rv, rv);
  nsCString messageId;
  pseudoHdr->GetMessageId(getter_Copies(messageId));
  // err on the side of caution and ignore messages w/o messageid.
  if (messageId.IsEmpty()) return NS_OK;
  m_pseudoHdrs.InsertOrUpdate(messageId, aMsgKey);
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::StoreImapFlags(int32_t flags, bool addFlags,
                                               const nsTArray<nsMsgKey>& keys,
                                               nsIUrlListener* aUrlListener) {
  nsresult rv;
  if (!WeAreOffline()) {
    nsCOMPtr<nsIImapService> imapService =
        do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    nsAutoCString msgIds;
    AllocateUidStringFromKeys(keys, 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) {
      for (auto key : keys) {
        nsCOMPtr<nsIMsgOfflineImapOperation> op;
        rv = mDatabase->GetOfflineOpForKey(key, true, getter_AddRefs(op));
        SetFlag(nsMsgFolderFlags::OfflineEvents);
        if (NS_SUCCEEDED(rv) && op) {
          imapMessageFlagsType newFlags;
          op->GetNewFlags(&newFlags);
          op->SetFlagOperation(addFlags ? newFlags | flags : newFlags & ~flags);
        }
      }
      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->LoadURI(uri, nullptr, nullptr, nullptr, false);
      }
    }
  } 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<nsIMsgFolder> destIFolder;
    rv = GetOrCreateFolder(destFolderUri, getter_AddRefs(destIFolder));
    NS_ENSURE_SUCCESS(rv, rv);

    if (destIFolder) {
      // check if the destination is a real folder (by checking for null parent)
      // and if it can file messages (e.g., servers or news folders can't file
      // messages). Or read only imap folders...
      bool canFileMessages = true;
      nsCOMPtr<nsIMsgFolder> parentFolder;
      destIFolder->GetParent(getter_AddRefs(parentFolder));
      if (parentFolder) destIFolder->GetCanFileMessages(&canFileMessages);
      if (filter && (!parentFolder || !canFileMessages)) {
        filter->SetEnabled(false);
        m_filterList->SaveToDefaultFile();
        destIFolder->ThrowAlertMsg("filterDisabled", msgWindow);
        return NS_MSG_NOT_A_MAIL_FOLDER;
      }
      // put the header into the source db, since it needs to be there when we
      // copy it and we need a valid header to pass to
      // StartAsyncCopyMessagesInto
      nsMsgKey keyToFilter;
      mailHdr->GetMessageKey(&keyToFilter);

      if (sourceDB && destIFolder) {
        bool imapDeleteIsMoveToTrash = DeleteIsMoveToTrash();
        m_moveCoalescer->AddMove(destIFolder, keyToFilter);
        // For each folder, we need to keep track of the ids we want to move to
        // that folder - we used to store them in the MSG_FolderInfo and then
        // when we'd finished downloading headers, we'd iterate through all the
        // folders looking for the ones that needed messages moved into them -
        // perhaps instead we could keep track of nsIMsgFolder,
        // nsTArray<nsMsgKey> pairs here in the imap code. nsTArray<nsMsgKey>
        // *idsToMoveFromInbox = msgFolder->GetImapIdsToMoveFromInbox();
        // idsToMoveFromInbox->AppendElement(keyToFilter);
        if (imapDeleteIsMoveToTrash) {
        }
        bool isRead = false;
        mailHdr->GetIsRead(&isRead);
        if (imapDeleteIsMoveToTrash) rv = NS_OK;
      }
    }
  } else
    rv = NS_ERROR_UNEXPECTED;

  // we have to return an error because we do not actually move the message
  // it is done async and that can fail
  return rv;
}

/**
 * This method assumes that key arrays and flag states are sorted by increasing
 * key.
 */
void nsImapMailFolder::FindKeysToDelete(const nsTArray<nsMsgKey>& existingKeys,
                                        nsTArray<nsMsgKey>& keysToDelete,
                                        nsIImapFlagAndUidState* flagState,
                                        uint32_t boxFlags) {
  bool showDeletedMessages = ShowDeletedMessages();
  int32_t numMessageInFlagState;
  bool partialUIDFetch;
  uint32_t uidOfMessage;
  imapMessageFlagsType flags;

  flagState->GetNumberOfMessages(&numMessageInFlagState);
  flagState->GetPartialUIDFetch(&partialUIDFetch);

  // if we're doing a partialUIDFetch, just delete the keys from the db
  // that have the deleted flag set (if not using imap delete model)
  // and return.
  if (partialUIDFetch) {
    if (!showDeletedMessages) {
      for (uint32_t i = 0; (int32_t)i < numMessageInFlagState; i++) {
        flagState->GetUidOfMessage(i, &uidOfMessage);
        // flag state will be zero filled up to first real uid, so ignore those.
        if (uidOfMessage) {
          flagState->GetMessageFlags(i, &flags);
          if (flags & kImapMsgDeletedFlag)
            keysToDelete.AppendElement(uidOfMessage);
        }
      }
    } else if (boxFlags & kJustExpunged) {
      // we've just issued an expunge with a partial flag state. We should
      // delete headers with the imap deleted flag set, because we can't
      // tell from the expunge response which messages were deleted.
      nsCOMPtr<nsIMsgEnumerator> hdrs;
      nsresult rv = GetMessages(getter_AddRefs(hdrs));
      NS_ENSURE_SUCCESS_VOID(rv);
      bool hasMore = false;
      while (NS_SUCCEEDED(rv = hdrs->HasMoreElements(&hasMore)) && hasMore) {
        nsCOMPtr<nsIMsgDBHdr> header;
        rv = hdrs->GetNext(getter_AddRefs(header));
        NS_ENSURE_SUCCESS_VOID(rv);
        uint32_t msgFlags;
        header->GetFlags(&msgFlags);
        if (msgFlags & nsMsgMessageFlags::IMAPDeleted) {
          nsMsgKey msgKey;
          header->GetMessageKey(&msgKey);
          keysToDelete.AppendElement(msgKey);
        }
      }
    }
    return;
  }
  // otherwise, we have a complete set of uid's and flags, so we delete
  // anything that's in existingKeys but not in the flag state, as well
  // as messages with the deleted flag set.
  uint32_t total = existingKeys.Length();
  int onlineIndex = 0;  // current index into flagState
  for (uint32_t keyIndex = 0; keyIndex < total; keyIndex++) {
    while (
        (onlineIndex < numMessageInFlagState) &&
        NS_SUCCEEDED(flagState->GetUidOfMessage(onlineIndex, &uidOfMessage)) &&
        (existingKeys[keyIndex] > uidOfMessage))
      onlineIndex++;

    flagState->GetUidOfMessage(onlineIndex, &uidOfMessage);
    flagState->GetMessageFlags(onlineIndex, &flags);
    // delete this key if it is not there or marked deleted
    if ((onlineIndex >= numMessageInFlagState) ||
        (existingKeys[keyIndex] != uidOfMessage) ||
        ((flags & kImapMsgDeletedFlag) && !showDeletedMessages)) {
      nsMsgKey doomedKey = existingKeys[keyIndex];
      if ((int32_t)doomedKey <= 0 && doomedKey != nsMsgKey_None) continue;

      keysToDelete.AppendElement(existingKeys[keyIndex]);
    }

    flagState->GetUidOfMessage(onlineIndex, &uidOfMessage);
    if (existingKeys[keyIndex] == uidOfMessage) onlineIndex++;
  }
}

void nsImapMailFolder::FindKeysToAdd(const nsTArray<nsMsgKey>& existingKeys,
                                     nsTArray<nsMsgKey>& keysToFetch,
                                     uint32_t& numNewUnread,
                                     nsIImapFlagAndUidState* flagState) {
  bool showDeletedMessages = ShowDeletedMessages();
  int dbIndex = 0;  // current index into existingKeys
  int32_t existTotal, numberOfKnownKeys;
  int32_t messageIndex;

  numNewUnread = 0;
  existTotal = numberOfKnownKeys = existingKeys.Length();
  flagState->GetNumberOfMessages(&messageIndex);
  bool partialUIDFetch;
  flagState->GetPartialUIDFetch(&partialUIDFetch);

  for (int32_t flagIndex = 0; flagIndex < messageIndex; flagIndex++) {
    uint32_t uidOfMessage;
    flagState->GetUidOfMessage(flagIndex, &uidOfMessage);
    while ((flagIndex < numberOfKnownKeys) && (dbIndex < existTotal) &&
           existingKeys[dbIndex] < uidOfMessage)
      dbIndex++;

    if ((flagIndex >= numberOfKnownKeys) || (dbIndex >= existTotal) ||
        (existingKeys[dbIndex] != uidOfMessage)) {
      numberOfKnownKeys++;

      imapMessageFlagsType flags;
      flagState->GetMessageFlags(flagIndex, &flags);
      NS_ASSERTION(uidOfMessage != nsMsgKey_None, "got invalid msg key");
      if (uidOfMessage && uidOfMessage != nsMsgKey_None &&
          (showDeletedMessages || !(flags & kImapMsgDeletedFlag))) {
        if (mDatabase) {
          bool dbContainsKey;
          if (NS_SUCCEEDED(
                  mDatabase->ContainsKey(uidOfMessage, &dbContainsKey)) &&
              dbContainsKey) {
            // this is expected in the partial uid fetch case because the
            // flag state does not contain all messages, so the db has
            // messages the flag state doesn't know about.
            if (!partialUIDFetch) NS_ERROR("db has key - flagState messed up?");
            continue;
          }
        }
        keysToFetch.AppendElement(uidOfMessage);
        if (!(flags & kImapMsgSeenFlag)) numNewUnread++;
      }
    }
  }
}

NS_IMETHODIMP nsImapMailFolder::GetMsgHdrsToDownload(
    bool* aMoreToDownload, int32_t* aTotalCount, nsTArray<nsMsgKey>& aKeys) {
  NS_ENSURE_ARG_POINTER(aMoreToDownload);
  NS_ENSURE_ARG_POINTER(aTotalCount);
  aKeys.Clear();

  *aMoreToDownload = false;
  *aTotalCount = m_totalKeysToFetch;
  if (m_keysToFetch.IsEmpty()) {
    return NS_OK;
  }

  // if folder isn't open in a window, no reason to limit the number of headers
  // we download.
  nsCOMPtr<nsIMsgMailSession> session =
      do_GetService(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.AppendElements(&m_keysToFetch[startIndex], numKeysToFetch);
  // Remove these for the incremental header download case, so that
  // we know we don't have to download them again.
  m_keysToFetch.RemoveElementsAt(startIndex, numKeysToFetch);

  return NS_OK;
}

void nsImapMailFolder::PrepareToAddHeadersToMailDB(nsIImapProtocol* aProtocol) {
  // now, tell it we don't need any bodies.
  nsTArray<nsMsgKey> noBodies;
  aProtocol->NotifyBodysToDownload(noBodies);
}

void nsImapMailFolder::TweakHeaderFlags(nsIImapProtocol* aProtocol,
                                        nsIMsgDBHdr* tweakMe) {
  if (mDatabase && aProtocol && tweakMe) {
    tweakMe->SetMessageKey(m_curMsgUid);
    tweakMe->SetMessageSize(m_nextMessageByteLength);

    bool foundIt = false;
    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:
         XXX TODO: Fix badly formatted comment which doesn't reflect the code.
                    MDNSent flag set => clear kMDNNeeded flag
                    MDNSent flag not set => do nothing, leave kMDNNeeded on
                    else if
                    not nsMsgMessageFlags::New => clear kMDNNeeded flag
                   nsMsgMessageFlags::New => do nothing, leave kMDNNeeded on
               */
      uint16_t userFlags;
      rv = aProtocol->GetSupportedUserFlags(&userFlags);
      if (NS_SUCCEEDED(rv) && (userFlags & (kImapMsgSupportUserFlag |
                                            kImapMsgSupportMDNSentFlag))) {
        if (imap_flags & kImapMsgMDNSentFlag) {
          newFlags |= nsMsgMessageFlags::MDNReportSent;
          if (dbHdrFlags & nsMsgMessageFlags::MDNReportNeeded)
            tweakMe->AndFlags(~nsMsgMessageFlags::MDNReportNeeded, &dbHdrFlags);
        }
      }

      if (imap_flags & kImapMsgAnsweredFlag)
        newFlags |= nsMsgMessageFlags::Replied;
      if (imap_flags & kImapMsgFlaggedFlag)
        newFlags |= nsMsgMessageFlags::Marked;
      if (imap_flags & kImapMsgDeletedFlag)
        newFlags |= nsMsgMessageFlags::IMAPDeleted;
      if (imap_flags & kImapMsgForwardedFlag)
        newFlags |= nsMsgMessageFlags::Forwarded;

      // 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(
    nsTArray<RefPtr<nsIMsgDBHdr>> const& messages, nsIMsgWindow* window) {
  nsAutoCString messageIds;
  nsTArray<nsMsgKey> srcKeyArray;
  nsresult rv = BuildIdsAndKeyArray(messages, messageIds, srcKeyArray);
  if (NS_FAILED(rv) || messageIds.IsEmpty()) return rv;

  nsCOMPtr<nsIImapService> imapService =
      do_GetService(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, EmptyCString(), this,
                                      msgWindow);
      NotifyFolderEvent(kFiltersApplied);
    }
    // Process filter plugins and other items normally done at the end of
    // HeaderFetchCompleted.
    bool pendingMoves = m_moveCoalescer && m_moveCoalescer->HasPendingMoves();
    PlaybackCoalescedOperations();

    bool filtersRun;
    CallFilterPlugins(nullptr, &filtersRun);
    int32_t numNewBiffMsgs = 0;
    if (m_performingBiff) GetNumNewMessages(false, &numNewBiffMsgs);

    if (!filtersRun && m_performingBiff && mDatabase && numNewBiffMsgs > 0 &&
        (!pendingMoves || !ShowPreviewText())) {
      // If we are performing biff for this folder, tell the
      // stand-alone biff about the new high water mark
      // We must ensure that the server knows that we are performing biff.
      // Otherwise the stand-alone biff won't fire.
      nsCOMPtr<nsIMsgIncomingServer> server;
      if (NS_SUCCEEDED(GetServer(getter_AddRefs(server))) && server)
        server->SetPerformingBiff(true);

      SetBiffState(nsIMsgFolder::nsMsgBiffState_NewMail);
      if (server) server->SetPerformingBiff(false);
      m_performingBiff = false;
    }

    if (m_filterList) (void)m_filterList->FlushLogIfNecessary();
  }

  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::AbortMsgWriteStream() {
  m_offlineHeader = nullptr;
  return NS_ERROR_FAILURE;
}

// message move/copy related methods
NS_IMETHODIMP
nsImapMailFolder::OnlineCopyCompleted(nsIImapProtocol* aProtocol,
                                      ImapOnlineCopyState aCopyState) {
  NS_ENSURE_ARG_POINTER(aProtocol);

  nsresult rv;
  if (aCopyState == ImapOnlineCopyStateType::kSuccessfulCopy) {
    nsCOMPtr<nsIImapUrl> imapUrl;
    rv = aProtocol->GetRunningImapURL(getter_AddRefs(imapUrl));
    if (NS_FAILED(rv) || !imapUrl) return NS_ERROR_FAILURE;
    nsImapAction action;
    rv = imapUrl->GetImapAction(&action);
    if (NS_FAILED(rv)) return rv;
    if (action != nsIImapUrl::nsImapOnlineToOfflineMove)
      return NS_ERROR_FAILURE;  // don't assert here...
    nsCString messageIds;
    rv = imapUrl->GetListOfMessageIds(messageIds);
    if (NS_FAILED(rv)) return rv;
    nsCOMPtr<nsIImapService> imapService =
        do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    return imapService->AddMessageFlags(this, nullptr, nullptr, messageIds,
                                        kImapMsgDeletedFlag, true);
  }
  /* unhandled copystate */
  if (m_copyState)  // whoops, this is the wrong folder - should use the source
                    // folder
  {
    nsCOMPtr<nsIMsgFolder> srcFolder;
    srcFolder = do_QueryInterface(m_copyState->m_srcSupport, &rv);
    if (srcFolder) srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgCompleted);
  } else
    rv = NS_ERROR_FAILURE;

  return rv;
}

NS_IMETHODIMP
nsImapMailFolder::CloseMockChannel(nsIImapMockChannel* aChannel) {
  aChannel->Close();
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::ReleaseUrlCacheEntry(nsIMsgMailNewsUrl* aUrl) {
  NS_ENSURE_ARG_POINTER(aUrl);
  return aUrl->SetMemCacheEntry(nullptr);
}

NS_IMETHODIMP
nsImapMailFolder::BeginMessageUpload() { return NS_ERROR_FAILURE; }

nsresult nsImapMailFolder::HandleCustomFlags(nsMsgKey uidOfMessage,
                                             nsIMsgDBHdr* dbHdr,
                                             uint16_t userFlags,
                                             nsCString& keywords) {
  nsresult rv = GetDatabase();
  NS_ENSURE_SUCCESS(rv, rv);

  ToLowerCase(keywords);
  bool messageClassified = true;
  // Mac Mail uses "NotJunk"
  if (keywords.Find("NonJunk", /* ignoreCase = */ true) != kNotFound ||
      keywords.Find("NotJunk", /* ignoreCase = */ true) != 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", /* ignoreCase = */ true) != 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");
  }

  if (!(userFlags & kImapMsgSupportUserFlag)) {
    nsCString localKeywords;
    nsCString prevKeywords;
    dbHdr->GetStringProperty("keywords", getter_Copies(localKeywords));
    dbHdr->GetStringProperty("prevkeywords", getter_Copies(prevKeywords));
    // localKeywords: tags currently stored in database for the message.
    // keywords: tags stored in server and obtained when flags for the message
    //           were last fetched. (Parameter of this function.)
    // prevKeywords: saved keywords from previous call of this function.
    // clang-format off
    MOZ_LOG(IMAP_KW, mozilla::LogLevel::Debug,
            ("UID=%" PRIu32 ", localKeywords=|%s| keywords=|%s|, prevKeywords=|%s|",
             uidOfMessage, localKeywords.get(), keywords.get(), prevKeywords.get()));
    // clang-format on

    // Store keywords to detect changes on next call of this function.
    dbHdr->SetStringProperty("prevkeywords", keywords.get());

    // Parse the space separated strings into arrays.
    nsTArray<nsCString> localKeywordArray;
    nsTArray<nsCString> keywordArray;
    nsTArray<nsCString> prevKeywordArray;
    ParseString(localKeywords, ' ', localKeywordArray);
    ParseString(keywords, ' ', keywordArray);
    ParseString(prevKeywords, ' ', prevKeywordArray);

    // If keyword not received now but was the last time, remove it from
    // the localKeywords. This means the keyword was removed by another user
    // sharing the folder.
    for (uint32_t i = 0; i < prevKeywordArray.Length(); i++) {
      bool inRcvd = keywordArray.Contains(prevKeywordArray[i]);
      bool inLocal = localKeywordArray.Contains(prevKeywordArray[i]);
      if (!inRcvd && inLocal)
        localKeywordArray.RemoveElement(prevKeywordArray[i]);
    }

    // Combine local and rcvd keyword arrays into a single string
    // so it can be passed to SetStringProperty(). If element of
    // local already in rcvd, avoid duplicates in combined string.
    nsAutoCString combinedKeywords;
    for (uint32_t i = 0; i < localKeywordArray.Length(); i++) {
      if (!keywordArray.Contains(localKeywordArray[i])) {
        combinedKeywords.Append(localKeywordArray[i]);
        combinedKeywords.Append(' ');
      }
    }
    for (uint32_t i = 0; i < keywordArray.Length(); i++) {
      combinedKeywords.Append(keywordArray[i]);
      combinedKeywords.Append(' ');
    }
    MOZ_LOG(IMAP_KW, mozilla::LogLevel::Debug,
            ("combinedKeywords stored = |%s|", combinedKeywords.get()));
    // combinedKeywords are tags being stored in database for the message.
    return dbHdr->SetStringProperty("keywords", combinedKeywords.get());
  }
  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(kFolderSize, oldFolderSize, mFolderSize);
  }

  return NS_OK;
}

// helper routine to sync the flags on a given header
nsresult nsImapMailFolder::NotifyMessageFlagsFromHdr(nsIMsgDBHdr* dbHdr,
                                                     nsMsgKey msgKey,
                                                     uint32_t flags) {
  nsresult rv = GetDatabase();
  NS_ENSURE_SUCCESS(rv, rv);

  // Although it may seem strange to keep a local reference of mDatabase here,
  // the current lifetime management of databases requires that methods
  // sometimes null the database when they think they opened it. Unfortunately
  // experience shows this happens when we don't expect, so for crash protection
  // best practice with the current flawed database management is to keep a
  // local reference when there will be complex calls in a method. See bug
  // 1312254.
  nsCOMPtr<nsIMsgDatabase> database(mDatabase);
  NS_ENSURE_STATE(database);

  database->MarkHdrRead(dbHdr, (flags & kImapMsgSeenFlag) != 0, nullptr);
  database->MarkHdrReplied(dbHdr, (flags & kImapMsgAnsweredFlag) != 0, nullptr);
  database->MarkHdrMarked(dbHdr, (flags & kImapMsgFlaggedFlag) != 0, nullptr);
  database->MarkImapDeleted(msgKey, (flags & kImapMsgDeletedFlag) != 0,
                            nullptr);

  uint32_t supportedFlags;
  GetSupportedUserFlags(&supportedFlags);
  if (supportedFlags & kImapMsgSupportForwardedFlag)
    database->MarkForwarded(msgKey, (flags & kImapMsgForwardedFlag) != 0,
                            nullptr);
  // 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);
          MOZ_LOG(IMAP_CS, mozilla::LogLevel::Debug,
                  ("NotifyMessageFlags(): Store highest MODSEQ=%" PRIu64
                   " for folder=%s",
                   aHighestModSeq, m_onlineFolderName.get()));
          dbFolderInfo->SetCharProperty(kModSeqPropertyName,
                                        nsDependentCString(intStrBuf));
        }
        if (msgDeleted) {
          uint32_t oldDeletedCount;
          dbFolderInfo->GetUint32Property(kDeletedHdrCountPropertyName, 0,
                                          &oldDeletedCount);
          dbFolderInfo->SetUint32Property(kDeletedHdrCountPropertyName,
                                          oldDeletedCount + 1);
        }
      }
    }
    nsCOMPtr<nsIMsgDBHdr> dbHdr;
    bool containsKey;
    nsresult rv = mDatabase->ContainsKey(aMsgKey, &containsKey);
    // if we don't have the header, don't diddle the flags.
    // GetMsgHdrForKey will create the header if it doesn't exist.
    if (NS_FAILED(rv) || !containsKey) return rv;
    rv = mDatabase->GetMsgHdrForKey(aMsgKey, getter_AddRefs(dbHdr));
    if (NS_SUCCEEDED(rv) && dbHdr) {
      uint32_t supportedUserFlags;
      GetSupportedUserFlags(&supportedUserFlags);
      NotifyMessageFlagsFromHdr(dbHdr, aMsgKey, aFlags);
      nsCString keywords(aKeywords);
      HandleCustomFlags(aMsgKey, dbHdr, supportedUserFlags, keywords);
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::NotifyMessageDeleted(const char* onlineFolderName,
                                       bool deleteAllMsgs,
                                       const char* msgIdString) {
  if (deleteAllMsgs) return NS_OK;

  if (!msgIdString) return NS_OK;

  nsTArray<nsMsgKey> affectedMessages;
  ParseUidString(msgIdString, affectedMessages);

  if (!ShowDeletedMessages()) {
    GetDatabase();
    NS_ENSURE_TRUE(mDatabase, NS_OK);
    if (!ShowDeletedMessages()) {
      if (!affectedMessages.IsEmpty())  // perhaps Search deleted these messages
      {
        DeleteStoreMessages(affectedMessages);
        mDatabase->DeleteMessages(affectedMessages, nullptr);
      }
    } else  // && !imapDeleteIsMoveToTrash // TODO: can this ever be executed?
      SetIMAPDeletedFlag(mDatabase, affectedMessages, false);
  }
  return NS_OK;
}

bool nsImapMailFolder::ShowDeletedMessages() {
  nsresult rv;
  nsCOMPtr<nsIImapHostSessionList> hostSession =
      do_GetService(kCImapHostSessionList, &rv);
  NS_ENSURE_SUCCESS(rv, false);

  bool showDeleted = false;
  nsCString serverKey;
  GetServerKey(serverKey);
  hostSession->GetShowDeletedMessagesForHost(serverKey.get(), showDeleted);

  return showDeleted;
}

bool nsImapMailFolder::DeleteIsMoveToTrash() {
  nsresult err;
  nsCOMPtr<nsIImapHostSessionList> hostSession =
      do_GetService(kCImapHostSessionList, &err);
  NS_ENSURE_SUCCESS(err, true);
  bool rv = true;

  nsCString serverKey;
  GetServerKey(serverKey);
  hostSession->GetDeleteIsMoveToTrashForHost(serverKey.get(), rv);
  return rv;
}

nsresult nsImapMailFolder::GetTrashFolder(nsIMsgFolder** pTrashFolder) {
  NS_ENSURE_ARG_POINTER(pTrashFolder);
  nsCOMPtr<nsIMsgFolder> rootFolder;
  nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
  if (NS_SUCCEEDED(rv) && rootFolder) {
    rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Trash, pTrashFolder);
    if (!*pTrashFolder) rv = NS_ERROR_FAILURE;
  }
  return rv;
}

// store nsMsgMessageFlags::IMAPDeleted in the specified mailhdr records
void nsImapMailFolder::SetIMAPDeletedFlag(nsIMsgDatabase* mailDB,
                                          const nsTArray<nsMsgKey>& msgids,
                                          bool markDeleted) {
  nsresult markStatus = NS_OK;
  uint32_t total = msgids.Length();

  for (uint32_t msgIndex = 0; NS_SUCCEEDED(markStatus) && (msgIndex < total);
       msgIndex++)
    markStatus =
        mailDB->MarkImapDeleted(msgids[msgIndex], markDeleted, nullptr);
}

NS_IMETHODIMP
nsImapMailFolder::GetMessageSizeFromDB(const char* id, uint32_t* size) {
  NS_ENSURE_ARG_POINTER(size);

  *size = 0;
  nsresult rv = GetDatabase();
  NS_ENSURE_SUCCESS(rv, rv);
  if (id) {
    nsMsgKey key = msgKeyFromInt(ParseUint64Str(id));
    nsCOMPtr<nsIMsgDBHdr> mailHdr;
    rv = mDatabase->GetMsgHdrForKey(key, getter_AddRefs(mailHdr));
    if (NS_SUCCEEDED(rv) && mailHdr) rv = mailHdr->GetMessageSize(size);
  }
  return rv;
}

NS_IMETHODIMP
nsImapMailFolder::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_curIndex < mailCopyState->m_messages.Length()) {
      nsIMsgDBHdr* message =
          mailCopyState->m_messages[mailCopyState->m_curIndex];
      nsMsgLabelValue label;
      message->GetFlags(aResult);
      if (supportedFlags & (kImapMsgSupportUserFlag | kImapMsgLabelFlags)) {
        message->GetLabel(&label);
        if (label != 0) *aResult |= label << 25;
      }
      if (aDate) message->GetDate(aDate);
      if (supportedFlags & kImapMsgSupportUserFlag) {
        // setup the custom imap keywords, which includes the message keywords
        // plus any junk status
        nsCString junkscore;
        message->GetStringProperty("junkscore", 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
        message->GetStringProperty("keywords", getter_Copies(keywords));
        int32_t start;
        int32_t length;
        bool hasJunk = MsgFindKeyword("junk"_ns, keywords, &start, &length);
        if (hasJunk && !isJunk)
          keywords.Cut(start, length);
        else if (!hasJunk && isJunk)
          keywords.AppendLiteral(" Junk");
        bool hasNonJunk =
            MsgFindKeyword("nonjunk"_ns, keywords, &start, &length);
        if (!hasNonJunk)
          hasNonJunk = MsgFindKeyword("notjunk"_ns, keywords, &start, &length);
        if (hasNonJunk && !isNotJunk)
          keywords.Cut(start, length);
        else if (!hasNonJunk && isNotJunk)
          keywords.AppendLiteral(" NonJunk");

        // Cleanup extra spaces
        while (!keywords.IsEmpty() && keywords.First() == ' ')
          keywords.Cut(0, 1);
        while (!keywords.IsEmpty() && keywords.Last() == ' ')
          keywords.Cut(keywords.Length() - 1, 1);
        while (!keywords.IsEmpty() && (start = keywords.Find("  "_ns)) >= 0)
          keywords.Cut(start, 1);
        aKeywords.Assign(keywords);
      }
    }
    // if we don't have a source header, and it's not the drafts folder,
    // then mark the message read, since it must be an append to the
    // fcc or templates folder.
    else if (mailCopyState) {
      *aResult = mailCopyState->m_newMsgFlags;
      if (supportedFlags & kImapMsgSupportUserFlag)
        aKeywords.Assign(mailCopyState->m_newMsgKeywords);
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::OnStartRunningUrl(nsIURI* aUrl) {
  NS_ASSERTION(aUrl, "sanity check - need to be be running non-null url");
  nsCOMPtr<nsIMsgMailNewsUrl> mailUrl = do_QueryInterface(aUrl);
  if (mailUrl) {
    bool updatingFolder;
    mailUrl->GetUpdatingFolder(&updatingFolder);
    m_updatingFolder = updatingFolder;
  }
  m_urlRunning = true;
  return NS_OK;
}

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, {});
        } else if (imapAction == nsIImapUrl::nsImapOnlineCopy) {
          notifier->NotifyMsgsMoveCopyCompleted(false, m_copyState->m_messages,
                                                this, {});
        } else if (imapAction == nsIImapUrl::nsImapDeleteMsg) {
          notifier->NotifyMsgsDeleted(m_copyState->m_messages);
        }
      }

      switch (imapAction) {
        case nsIImapUrl::nsImapDeleteMsg:
        case nsIImapUrl::nsImapOnlineMove:
        case nsIImapUrl::nsImapOnlineCopy:
          if (NS_SUCCEEDED(aExitCode)) {
            if (folderOpen)
              UpdateFolder(msgWindow);
            else
              UpdatePendingCounts();
          }

          if (m_copyState) {
            nsCOMPtr<nsIMsgFolder> srcFolder =
                do_QueryInterface(m_copyState->m_srcSupport, &rv);
            if (m_copyState->m_isMove && !m_copyState->m_isCrossServerOp) {
              if (NS_SUCCEEDED(aExitCode)) {
                nsCOMPtr<nsIMsgDatabase> srcDB;
                if (srcFolder)
                  rv = srcFolder->GetMsgDatabase(getter_AddRefs(srcDB));
                if (NS_SUCCEEDED(rv) && srcDB) {
                  RefPtr<nsImapMoveCopyMsgTxn> msgTxn;
                  nsTArray<nsMsgKey> srcKeyArray;
                  if (m_copyState->m_allowUndo) {
                    msgTxn = m_copyState->m_undoMsgTxn;
                    if (msgTxn) msgTxn->GetSrcKeyArray(srcKeyArray);
                  } else {
                    nsAutoCString messageIds;
                    rv = BuildIdsAndKeyArray(m_copyState->m_messages,
                                             messageIds, srcKeyArray);
                    NS_ENSURE_SUCCESS(rv, rv);
                  }

                  if (!ShowDeletedMessages()) {
                    // We only reach here for same-server operations
                    // (!m_copyState->m_isCrossServerOp in if above), so we can
                    // assume that the src is also imap that uses offline
                    // storage.
                    DeleteStoreMessages(srcKeyArray, srcFolder);
                    srcDB->DeleteMessages(srcKeyArray, nullptr);
                  } else
                    MarkMessagesImapDeleted(&srcKeyArray, true, srcDB);
                }
                srcFolder->EnableNotifications(allMessageCountNotifications,
                                               true);
                // even if we're showing deleted messages,
                // we still need to notify FE so it will show the imap deleted
                // flag
                srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgCompleted);
                // is there a way to see that we think we have new msgs?
                nsCOMPtr<nsIPrefBranch> prefBranch(
                    do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
                if (NS_SUCCEEDED(rv)) {
                  bool showPreviewText;
                  prefBranch->GetBoolPref("mail.biff.alert.show_preview",
                                          &showPreviewText);
                  // if we're showing preview text, update ourselves if we got a
                  // new unread message copied so that we can download the new
                  // headers and have a chance to preview the msg bodies.
                  if (!folderOpen && showPreviewText &&
                      m_copyState->m_unreadCount > 0 &&
                      !(mFlags &
                        (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Junk)))
                    UpdateFolder(msgWindow);
                }
              } else {
                srcFolder->EnableNotifications(allMessageCountNotifications,
                                               true);
                srcFolder->NotifyFolderEvent(kDeleteOrMoveMsgFailed);
              }
            }
            if (m_copyState->m_msgWindow &&
                m_copyState->m_undoMsgTxn &&  // may be null from filters
                NS_SUCCEEDED(
                    aExitCode))  // we should do this only if move/copy succeeds
            {
              nsCOMPtr<nsITransactionManager> txnMgr;
              m_copyState->m_msgWindow->GetTransactionManager(
                  getter_AddRefs(txnMgr));
              if (txnMgr) {
                RefPtr<nsImapMoveCopyMsgTxn> txn = m_copyState->m_undoMsgTxn;
                mozilla::DebugOnly<nsresult> rv2 = txnMgr->DoTransaction(txn);
                NS_ASSERTION(NS_SUCCEEDED(rv2), "doing transaction failed");
              }
            }
            // nsImapUrl can hold a pointer to our m_copyState, so force a
            // release here (see Bug 1586494).
            imapUrl->SetCopyState(nullptr);
            (void)OnCopyCompleted(m_copyState->m_srcSupport, aExitCode);
          }

          // we're the dest folder of a move/copy - if we're not open in the ui,
          // then we should clear our nsMsgDatabase pointer. Otherwise, the db
          // would be open until the user selected it and then selected another
          // folder. but don't do this for the trash or inbox - we'll leave them
          // open
          if (!folderOpen &&
              !(mFlags & (nsMsgFolderFlags::Trash | nsMsgFolderFlags::Inbox)))
            SetMsgDatabase(nullptr);
          break;
        case nsIImapUrl::nsImapSubtractMsgFlags: {
          // this isn't really right - we'd like to know we were
          // deleting a message to start with, but it probably
          // won't do any harm.
          imapMessageFlagsType flags = 0;
          imapUrl->GetMsgFlags(&flags);
          // we need to subtract the delete flag in db only in case when we show
          // deleted msgs
          if (flags & kImapMsgDeletedFlag && ShowDeletedMessages()) {
            nsCOMPtr<nsIMsgDatabase> db;
            rv = GetMsgDatabase(getter_AddRefs(db));
            if (NS_SUCCEEDED(rv) && db) {
              nsTArray<nsMsgKey> keyArray;
              nsCString keyString;
              imapUrl->GetListOfMessageIds(keyString);
              ParseUidString(keyString.get(), keyArray);
              MarkMessagesImapDeleted(&keyArray, false, db);
              db->Commit(nsMsgDBCommitType::kLargeCommit);
            }
          }
        } break;
        case nsIImapUrl::nsImapAddMsgFlags: {
          imapMessageFlagsType flags = 0;
          imapUrl->GetMsgFlags(&flags);
          if (flags & kImapMsgDeletedFlag) {
            // we need to delete headers from db only when we don't show deleted
            // msgs
            if (!ShowDeletedMessages()) {
              nsCOMPtr<nsIMsgDatabase> db;
              rv = GetMsgDatabase(getter_AddRefs(db));
              if (NS_SUCCEEDED(rv) && db) {
                nsTArray<nsMsgKey> keyArray;
                nsCString keyString;
                imapUrl->GetListOfMessageIds(keyString);
                ParseUidString(keyString.get(), keyArray);

                // For pluggable stores that do not support compaction, we need
                // to delete the messages now.
                bool supportsCompaction = false;
                nsCOMPtr<nsIMsgPluggableStore> offlineStore;
                (void)GetMsgStore(getter_AddRefs(offlineStore));
                if (offlineStore)
                  offlineStore->GetSupportsCompaction(&supportsCompaction);

                nsTArray<RefPtr<nsIMsgDBHdr>> msgHdrs;
                if (notifier || !supportsCompaction) {
                  MsgGetHeadersFromKeys(db, keyArray, msgHdrs);
                }

                // Notify listeners of delete.
                if (notifier && !msgHdrs.IsEmpty()) {
                  // XXX Currently, the DeleteMessages below gets executed twice
                  // on deletes. Once in DeleteMessages, once here. The second
                  // time, it silently fails to delete. This is why we're also
                  // checking whether the array is empty.
                  notifier->NotifyMsgsDeleted(msgHdrs);
                }

                if (!supportsCompaction && !msgHdrs.IsEmpty())
                  DeleteStoreMessages(msgHdrs);

                db->DeleteMessages(keyArray, nullptr);
                db->SetSummaryValid(true);
                db->Commit(nsMsgDBCommitType::kLargeCommit);
              }
            }
          }
        } break;
        case nsIImapUrl::nsImapAppendMsgFromFile:
        case nsIImapUrl::nsImapAppendDraftFromFile:
          if (m_copyState) {
            if (NS_SUCCEEDED(aExitCode)) {
              UpdatePendingCounts();

              m_copyState->m_curIndex++;
              if (m_copyState->m_curIndex >= m_copyState->m_messages.Length()) {
                nsCOMPtr<nsIUrlListener> saveUrlListener = m_urlListener;
                if (folderOpen) {
                  // This gives a way for the caller to get notified
                  // when the UpdateFolder url is done.
                  // (if the nsIMsgCopyServiceListener also implements
                  // nsIUrlListener)
                  if (m_copyState->m_listener)
                    m_urlListener = do_QueryInterface(m_copyState->m_listener);
                }
                if (m_copyState->m_msgWindow && m_copyState->m_undoMsgTxn) {
                  nsCOMPtr<nsITransactionManager> txnMgr;
                  m_copyState->m_msgWindow->GetTransactionManager(
                      getter_AddRefs(txnMgr));
                  if (txnMgr) {
                    RefPtr<nsImapMoveCopyMsgTxn> txn =
                        m_copyState->m_undoMsgTxn;
                    txnMgr->DoTransaction(txn);
                  }
                }
                (void)OnCopyCompleted(m_copyState->m_srcSupport, aExitCode);
                if (folderOpen ||
                    imapAction == nsIImapUrl::nsImapAppendDraftFromFile) {
                  UpdateFolderWithListener(msgWindow, m_urlListener);
                  m_urlListener = saveUrlListener;
                }
              }
            } else {
              // clear the copyState if copy has failed
              (void)OnCopyCompleted(m_copyState->m_srcSupport, aExitCode);
            }
          }
          break;
        case nsIImapUrl::nsImapMoveFolderHierarchy:
          if (m_copyState)  // delete folder gets here, but w/o an m_copyState
          {
            nsCOMPtr<nsIMsgCopyService> copyService =
                do_GetService(NS_MSGCOPYSERVICE_CONTRACTID, &rv);
            NS_ENSURE_SUCCESS(rv, rv);
            nsCOMPtr<nsIMsgFolder> srcFolder =
                do_QueryInterface(m_copyState->m_srcSupport);
            if (srcFolder) {
              copyService->NotifyCompletion(m_copyState->m_srcSupport, this,
                                            aExitCode);
            }
            m_copyState = nullptr;
          }
          break;
        case nsIImapUrl::nsImapRenameFolder:
          if (NS_FAILED(aExitCode)) {
            NotifyFolderEvent(kRenameCompleted);
          }
          break;
        case nsIImapUrl::nsImapDeleteAllMsgs:
          if (NS_SUCCEEDED(aExitCode)) {
            if (folderOpen)
              UpdateFolder(msgWindow);
            else {
              ChangeNumPendingTotalMessages(-mNumPendingTotalMessages);
              ChangeNumPendingUnread(-mNumPendingUnreadMessages);
              m_numServerUnseenMessages = 0;
            }
          }
          break;
        case nsIImapUrl::nsImapListFolder:
          if (NS_SUCCEEDED(aExitCode)) {
            // listing folder will open db; don't leave the db open.
            SetMsgDatabase(nullptr);
            if (!m_verifiedAsOnlineFolder) {
              // If folder is not verified, we remove it.
              nsCOMPtr<nsIMsgFolder> parent;
              rv = GetParent(getter_AddRefs(parent));
              if (NS_SUCCEEDED(rv) && parent) {
                nsCOMPtr<nsIMsgImapMailFolder> imapParent =
                    do_QueryInterface(parent);
                if (imapParent) this->RemoveLocalSelf();
              }
            }
          }
          break;
        case nsIImapUrl::nsImapRefreshFolderUrls:
          // we finished getting an admin url for the folder.
          if (!m_adminUrl.IsEmpty()) FolderPrivileges(msgWindow);
          break;
        case nsIImapUrl::nsImapCreateFolder:
          if (NS_FAILED(aExitCode))  // if success notification already done
          {
            NotifyFolderEvent(kFolderCreateFailed);
          }
          break;
        case nsIImapUrl::nsImapSubscribe:
          if (NS_SUCCEEDED(aExitCode) && msgWindow) {
            nsCString canonicalFolderName;
            imapUrl->CreateCanonicalSourceFolderPathString(
                getter_Copies(canonicalFolderName));
            nsCOMPtr<nsIMsgFolder> rootFolder;
            nsresult rv = GetRootFolder(getter_AddRefs(rootFolder));
            if (NS_SUCCEEDED(rv) && rootFolder) {
              nsCOMPtr<nsIMsgImapMailFolder> imapRoot =
                  do_QueryInterface(rootFolder);
              if (imapRoot) {
                nsCOMPtr<nsIMsgImapMailFolder> foundFolder;
                rv = imapRoot->FindOnlineSubFolder(canonicalFolderName,
                                                   getter_AddRefs(foundFolder));
                if (NS_SUCCEEDED(rv) && foundFolder) {
                  nsCString uri;
                  nsCOMPtr<nsIMsgFolder> msgFolder =
                      do_QueryInterface(foundFolder);
                  if (msgFolder) {
                    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) {
    int32_t delta =
        m_copyState->m_isCrossServerOp ? 1 : m_copyState->m_messages.Length();
    if (!m_copyState->m_selectedState && m_copyState->m_messages.IsEmpty()) {
      // special case from CopyFileMessage():
      // - copied a single message in from a file
      // - no previously-existing messages are involved
      delta = 1;
    }
    ChangePendingTotal(delta);

    // count the moves that were unread
    int numUnread = m_copyState->m_unreadCount;
    if (numUnread) {
      m_numServerUnseenMessages +=
          numUnread;  // adjust last status count by this delta.
      ChangeNumPendingUnread(numUnread);
    }
    SummaryChanged();
  }
}

NS_IMETHODIMP
nsImapMailFolder::ClearFolderRights() {
  SetFolderNeedsACLListed(false);
  delete m_folderACL;
  m_folderACL = new nsMsgIMAPFolderACL(this);
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::AddFolderRights(const nsACString& userName,
                                  const nsACString& rights) {
  SetFolderNeedsACLListed(false);
  GetFolderACL()->SetFolderRightsForUser(userName, rights);
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::RefreshFolderRights() {
  if (GetFolderACL()->GetIsFolderShared())
    SetFlag(nsMsgFolderFlags::PersonalShared);
  else
    ClearFlag(nsMsgFolderFlags::PersonalShared);
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::SetCopyResponseUid(const char* msgIdString,
                                     nsIImapUrl* aUrl) {  // CopyMessages() only
  nsresult rv = NS_OK;
  RefPtr<nsImapMoveCopyMsgTxn> msgTxn;
  nsCOMPtr<nsISupports> copyState;

  if (aUrl) aUrl->GetCopyState(getter_AddRefs(copyState));

  if (copyState) {
    nsCOMPtr<nsImapMailCopyState> mailCopyState =
        do_QueryInterface(copyState, &rv);
    if (NS_FAILED(rv)) return rv;
    if (mailCopyState->m_undoMsgTxn) msgTxn = mailCopyState->m_undoMsgTxn;
  } else if (aUrl && m_pendingOfflineMoves.Length()) {
    nsCString urlSourceMsgIds, undoTxnSourceMsgIds;
    aUrl->GetListOfMessageIds(urlSourceMsgIds);
    RefPtr<nsImapMoveCopyMsgTxn> imapUndo = m_pendingOfflineMoves[0];
    if (imapUndo) {
      imapUndo->GetSrcMsgIds(undoTxnSourceMsgIds);
      if (undoTxnSourceMsgIds.Equals(urlSourceMsgIds)) msgTxn = imapUndo;
      // ### we should handle batched moves, but lets keep it simple for a2.
      m_pendingOfflineMoves.Clear();
    }
  }
  if (msgTxn) msgTxn->SetCopyResponseUid(msgIdString);
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::StartMessage(nsIMsgMailNewsUrl* aUrl) {
  nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(aUrl));
  nsCOMPtr<nsISupports> copyState;
  NS_ENSURE_TRUE(imapUrl, NS_ERROR_FAILURE);

  imapUrl->GetCopyState(getter_AddRefs(copyState));
  if (copyState) {
    nsCOMPtr<nsICopyMessageStreamListener> listener =
        do_QueryInterface(copyState);
    if (listener) listener->StartMessage();
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::EndMessage(nsIMsgMailNewsUrl* aUrl, nsMsgKey uidOfMessage) {
  nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(aUrl));
  nsCOMPtr<nsISupports> copyState;
  NS_ENSURE_TRUE(imapUrl, NS_ERROR_FAILURE);
  imapUrl->GetCopyState(getter_AddRefs(copyState));
  if (copyState) {
    nsCOMPtr<nsICopyMessageStreamListener> listener =
        do_QueryInterface(copyState);
    if (listener) listener->EndMessage(uidOfMessage);
  }
  return NS_OK;
}

#define WHITESPACE " \015\012"  // token delimiter

NS_IMETHODIMP
nsImapMailFolder::NotifySearchHit(nsIMsgMailNewsUrl* aUrl,
                                  const char* searchHitLine) {
  NS_ENSURE_ARG_POINTER(aUrl);
  nsresult rv = GetDatabase();
  NS_ENSURE_SUCCESS(rv, rv);

  // expect search results in the form of "* SEARCH <hit> <hit> ..."
  // expect search results in the form of "* SEARCH <hit> <hit> ..."
  nsCString tokenString(searchHitLine);
  char* currentPosition = PL_strcasestr(tokenString.get(), "SEARCH");
  if (currentPosition) {
    currentPosition += strlen("SEARCH");
    bool shownUpdateAlert = false;
    char* hitUidToken = NS_strtok(WHITESPACE, &currentPosition);
    while (hitUidToken) {
      long naturalLong;  // %l is 64 bits on OSF1
      sscanf(hitUidToken, "%ld", &naturalLong);
      nsMsgKey hitUid = (nsMsgKey)naturalLong;

      nsCOMPtr<nsIMsgDBHdr> hitHeader;
      rv = mDatabase->GetMsgHdrForKey(hitUid, getter_AddRefs(hitHeader));
      if (NS_SUCCEEDED(rv) && hitHeader) {
        nsCOMPtr<nsIMsgSearchSession> searchSession;
        nsCOMPtr<nsIMsgSearchAdapter> searchAdapter;
        aUrl->GetSearchSession(getter_AddRefs(searchSession));
        if (searchSession) {
          searchSession->GetRunningAdapter(getter_AddRefs(searchAdapter));
          if (searchAdapter) searchAdapter->AddResultElement(hitHeader);
        }
      } else if (!shownUpdateAlert) {
      }

      hitUidToken = NS_strtok(WHITESPACE, &currentPosition);
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::SetAppendMsgUid(nsMsgKey aKey, nsIImapUrl* aUrl) {
  nsresult rv;
  nsCOMPtr<nsISupports> copyState;
  if (aUrl) aUrl->GetCopyState(getter_AddRefs(copyState));
  if (copyState) {
    nsCOMPtr<nsImapMailCopyState> mailCopyState =
        do_QueryInterface(copyState, &rv);
    if (NS_FAILED(rv)) return rv;

    if (mailCopyState->m_undoMsgTxn)  // CopyMessages()
    {
      RefPtr<nsImapMoveCopyMsgTxn> msgTxn;
      msgTxn = mailCopyState->m_undoMsgTxn;
      msgTxn->AddDstKey(aKey);
    } else if (mailCopyState->m_listener)  // CopyFileMessage();
                                           // Draft/Template goes here
    {
      mailCopyState->m_appendUID = aKey;
      mailCopyState->m_listener->SetMessageKey(aKey);
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::GetMessageId(nsIImapUrl* aUrl, nsACString& messageId) {
  nsresult rv = NS_OK;
  nsCOMPtr<nsISupports> copyState;

  if (aUrl) aUrl->GetCopyState(getter_AddRefs(copyState));
  if (copyState) {
    nsCOMPtr<nsImapMailCopyState> mailCopyState =
        do_QueryInterface(copyState, &rv);
    if (NS_FAILED(rv)) return rv;
    if (mailCopyState->m_listener)
      rv = mailCopyState->m_listener->GetMessageId(messageId);
  }
  if (NS_SUCCEEDED(rv) && messageId.Length() > 0) {
    if (messageId.First() == '<') messageId.Cut(0, 1);
    if (messageId.Last() == '>') messageId.SetLength(messageId.Length() - 1);
  }
  return rv;
}

NS_IMETHODIMP
nsImapMailFolder::HeaderFetchCompleted(nsIImapProtocol* aProtocol) {
  nsCOMPtr<nsIMsgWindow>
      msgWindow;  // we might need this for the filter plugins.
  if (mBackupDatabase) RemoveBackupMsgDatabase();

  SetSizeOnDisk(mFolderSize);
  int32_t numNewBiffMsgs = 0;
  if (m_performingBiff) GetNumNewMessages(false, &numNewBiffMsgs);

  bool pendingMoves = m_moveCoalescer && m_moveCoalescer->HasPendingMoves();
  PlaybackCoalescedOperations();
  if (aProtocol) {
    // check if we should download message bodies because it's the inbox and
    // the server is specified as one where where we download msg bodies
    // automatically. Or if we autosyncing all offline folders.
    nsCOMPtr<nsIImapIncomingServer> imapServer;
    GetImapIncomingServer(getter_AddRefs(imapServer));

    bool autoDownloadNewHeaders = false;
    bool autoSyncOfflineStores = false;

    if (imapServer) {
      imapServer->GetAutoSyncOfflineStores(&autoSyncOfflineStores);
      imapServer->GetDownloadBodiesOnGetNewMail(&autoDownloadNewHeaders);
      if (m_filterListRequiresBody) autoDownloadNewHeaders = true;
    }
    bool notifiedBodies = false;
    if (m_downloadingFolderForOfflineUse || autoSyncOfflineStores ||
        autoDownloadNewHeaders) {
      nsTArray<nsMsgKey> keysToDownload;
      GetBodysToDownload(&keysToDownload);
      // this is the case when DownloadAllForOffline is called.
      if (!keysToDownload.IsEmpty() &&
          (m_downloadingFolderForOfflineUse || autoDownloadNewHeaders)) {
        notifiedBodies = true;
        aProtocol->NotifyBodysToDownload(keysToDownload);
      } 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) {
      nsTArray<nsMsgKey> noBodies;
      aProtocol->NotifyBodysToDownload(noBodies);
    }

    nsCOMPtr<nsIURI> runningUri;
    aProtocol->GetRunningUrl(getter_AddRefs(runningUri));
    if (runningUri) {
      nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(runningUri);
      if (mailnewsUrl) mailnewsUrl->GetMsgWindow(getter_AddRefs(msgWindow));
    }
  }

  // delay calling plugins if filter application is also delayed
  if (!m_filterListRequiresBody) {
    bool filtersRun;
    CallFilterPlugins(msgWindow, &filtersRun);
    if (!filtersRun && m_performingBiff && mDatabase && numNewBiffMsgs > 0 &&
        (!pendingMoves || !ShowPreviewText())) {
      // If we are performing biff for this folder, tell the
      // stand-alone biff about the new high water mark
      // We must ensure that the server knows that we are performing biff.
      // Otherwise the stand-alone biff won't fire.
      nsCOMPtr<nsIMsgIncomingServer> server;
      if (NS_SUCCEEDED(GetServer(getter_AddRefs(server))) && server)
        server->SetPerformingBiff(true);

      SetBiffState(nsIMsgFolder::nsMsgBiffState_NewMail);
      if (server) server->SetPerformingBiff(false);
      m_performingBiff = false;
    }

    if (m_filterList) (void)m_filterList->FlushLogIfNecessary();
  }

  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::SetBiffStateAndUpdate(nsMsgBiffState biffState) {
  SetBiffState(biffState);
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::GetUidValidity(int32_t* uidValidity) {
  NS_ENSURE_ARG(uidValidity);
  if ((int32_t)m_uidValidity == kUidUnknown) {
    nsCOMPtr<nsIMsgDatabase> db;
    nsCOMPtr<nsIDBFolderInfo> dbFolderInfo;
    (void)GetDBFolderInfoAndDB(getter_AddRefs(dbFolderInfo),
                               getter_AddRefs(db));
    if (db) db->GetDBFolderInfo(getter_AddRefs(dbFolderInfo));

    if (dbFolderInfo)
      dbFolderInfo->GetImapUidValidity((int32_t*)&m_uidValidity);
  }
  *uidValidity = m_uidValidity;
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::SetUidValidity(int32_t uidValidity) {
  m_uidValidity = uidValidity;
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::FillInFolderProps(nsIMsgImapFolderProps* aFolderProps) {
  NS_ENSURE_ARG(aFolderProps);
  const char* folderTypeStringID;
  const char* folderTypeDescStringID = nullptr;
  const char* folderQuotaStatusStringID;
  nsString folderType;
  nsString folderTypeDesc;
  nsString folderQuotaStatusDesc;
  nsCOMPtr<nsIStringBundle> bundle;
  nsresult rv = IMAPGetStringBundle(getter_AddRefs(bundle));
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIImapIncomingServer> imapServer;
  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
  // if for some bizarre reason this fails, we'll still fall through to the
  // normal sharing code
  if (NS_SUCCEEDED(rv)) {
    // get the latest committed imap capabilities bit mask.
    eIMAPCapabilityFlags capability = kCapabilityUndefined;
    imapServer->GetCapability(&capability);
    bool haveACL = capability & kACLCapability;
    bool haveQuota = capability & kQuotaCapability;

    // Figure out what to display in the Quota tab of the folder properties.
    // Does the server support quotas? This depends on the latest imap
    // CAPABILITY response.
    if (haveQuota) {
      // Have quota capability. Have we asked the server for quota information?
      if (m_folderQuotaCommandIssued) {
        // Has the server replied with all the quota info?
        if (m_folderQuotaDataIsValid) {
          if (!m_folderQuota.IsEmpty()) {
            // If so, set quota data to show in the quota tab
            folderQuotaStatusStringID = nullptr;
            aFolderProps->SetQuotaData(m_folderQuota);
          } else {
            // The server reported no quota limits on this folder.
            folderQuotaStatusStringID = "imapQuotaStatusNoQuota2";
          }
        } else {
          // The getquotaroot command was sent to the server but the complete
          // response was not yet received when the folder properties were
          // requested. This is rare. Request the folder properties again to
          // obtain the quota data.
          folderQuotaStatusStringID = "imapQuotaStatusInProgress";
        }
      } else {
        // The folder is not open, so no quota information is available
        folderQuotaStatusStringID = "imapQuotaStatusFolderNotOpen";
      }
    } else {
      // Either the server doesn't support quotas, or we don't know if it does
      // (e.g., because we don't have a connection yet). If the latter, we fall
      // back to saying that no information is available because the folder is
      // not yet open.
      folderQuotaStatusStringID = (capability == kCapabilityUndefined)
                                      ? "imapQuotaStatusFolderNotOpen"
                                      : "imapQuotaStatusNotSupported";
    }

    if (!folderQuotaStatusStringID) {
      // Display quota data
      aFolderProps->ShowQuotaData(true);
    } else {
      // Hide quota data and show reason why it is not available
      aFolderProps->ShowQuotaData(false);

      rv = IMAPGetStringByName(folderQuotaStatusStringID,
                               getter_Copies(folderQuotaStatusDesc));
      if (NS_SUCCEEDED(rv)) aFolderProps->SetQuotaStatus(folderQuotaStatusDesc);
    }

    // See if the server supports ACL.
    // If not, just set the folder description to a string that says
    // the server doesn't support sharing, and return.
    if (!haveACL) {
      rv = IMAPGetStringByName("imapServerDoesntSupportAcl",
                               getter_Copies(folderTypeDesc));
      if (NS_SUCCEEDED(rv))
        aFolderProps->SetFolderTypeDescription(folderTypeDesc);
      aFolderProps->ServerDoesntSupportACL();
      return NS_OK;
    }
  }
  if (mFlags & nsMsgFolderFlags::ImapPublic) {
    folderTypeStringID = "imapPublicFolderTypeName";
    folderTypeDescStringID = "imapPublicFolderTypeDescription";
  } else if (mFlags & nsMsgFolderFlags::ImapOtherUser) {
    folderTypeStringID = "imapOtherUsersFolderTypeName";
    nsCString owner;
    nsString uniOwner;
    GetFolderOwnerUserName(owner);
    if (owner.IsEmpty()) {
      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?
      CopyUTF8toUTF16(owner, uniOwner);
    }
    AutoTArray<nsString, 1> params = {uniOwner};
    rv = bundle->FormatStringFromName("imapOtherUsersFolderTypeDescription",
                                      params, folderTypeDesc);
  } else if (GetFolderACL()->GetIsFolderShared()) {
    folderTypeStringID = "imapPersonalSharedFolderTypeName";
    folderTypeDescStringID = "imapPersonalSharedFolderTypeDescription";
  } else {
    folderTypeStringID = "imapPersonalSharedFolderTypeName";
    folderTypeDescStringID = "imapPersonalFolderTypeDescription";
  }

  rv = IMAPGetStringByName(folderTypeStringID, getter_Copies(folderType));
  if (NS_SUCCEEDED(rv)) aFolderProps->SetFolderType(folderType);

  if (folderTypeDesc.IsEmpty() && folderTypeDescStringID)
    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);
  if (!oldValue.IsEmpty()) {
    m_rightsHash.Remove(ourUserName);
    m_aclCount--;
    NS_ASSERTION(m_aclCount >= 0, "acl count can't go negative");
  }
  m_aclCount++;
  m_rightsHash.InsertOrUpdate(ourUserName, PromiseFlatCString(rights));

  if (myUserName.Equals(ourUserName) ||
      ourUserName.EqualsLiteral(IMAP_ACL_ANYONE_STRING))
    // if this is setting an ACL for me, cache it in the folder pref flags
    UpdateACLCache();

  return true;
}

NS_IMETHODIMP nsImapMailFolder::GetOtherUsersWithAccess(
    nsIUTF8StringEnumerator** aResult) {
  return GetFolderACL()->GetOtherUsers(aResult);
}

nsresult nsMsgIMAPFolderACL::GetOtherUsers(nsIUTF8StringEnumerator** aResult) {
  nsCString myUserName;
  nsCOMPtr<nsIMsgIncomingServer> server;
  nsresult rv = m_folder->GetServer(getter_AddRefs(server));
  NS_ENSURE_SUCCESS(rv, rv);
  server->GetRealUsername(myUserName);

  // We need to filter out myUserName from m_rightsHash.
  nsTArray<nsCString>* resultArray = new nsTArray<nsCString>;
  for (auto iter = m_rightsHash.Iter(); !iter.Done(); iter.Next()) {
    if (!iter.Key().Equals(myUserName)) resultArray->AppendElement(iter.Key());
  }

  // enumerator will free resultArray
  return NS_NewAdoptingUTF8StringEnumerator(aResult, resultArray);
}

nsresult nsImapMailFolder::GetPermissionsForUser(const nsACString& otherUser,
                                                 nsACString& aResult) {
  nsCString str;
  nsresult rv = GetFolderACL()->GetRightsStringForUser(otherUser, str);
  NS_ENSURE_SUCCESS(rv, rv);
  aResult = str;
  return NS_OK;
}

nsresult nsMsgIMAPFolderACL::GetRightsStringForUser(
    const nsACString& inUserName, nsCString& rights) {
  nsCString userName;
  userName.Assign(inUserName);
  if (userName.IsEmpty()) {
    nsCOMPtr<nsIMsgIncomingServer> server;

    nsresult rv = m_folder->GetServer(getter_AddRefs(server));
    NS_ENSURE_SUCCESS(rv, rv);
    // we need the real user name to match with what the imap server returns
    // in the acl response.
    server->GetRealUsername(userName);
  }
  ToLowerCase(userName);
  rights = m_rightsHash.Get(userName);
  return NS_OK;
}

// First looks for individual user;  then looks for 'anyone' if the user isn't
// found. Returns defaultIfNotFound, if neither are found.
bool nsMsgIMAPFolderACL::GetFlagSetInRightsForUser(const nsACString& userName,
                                                   char flag,
                                                   bool defaultIfNotFound) {
  nsCString flags;
  nsresult rv = GetRightsStringForUser(userName, flags);
  NS_ENSURE_SUCCESS(rv, defaultIfNotFound);
  if (flags.IsEmpty()) {
    nsCString anyoneFlags;
    GetRightsStringForUser(nsLiteralCString(IMAP_ACL_ANYONE_STRING),
                           anyoneFlags);
    if (anyoneFlags.IsEmpty()) return defaultIfNotFound;
    return (anyoneFlags.FindChar(flag) != kNotFound);
  }
  return (flags.FindChar(flag) != kNotFound);
}

bool nsMsgIMAPFolderACL::GetCanUserLookupFolder(const nsACString& userName) {
  return GetFlagSetInRightsForUser(userName, 'l', false);
}

bool nsMsgIMAPFolderACL::GetCanUserReadFolder(const nsACString& userName) {
  return GetFlagSetInRightsForUser(userName, 'r', false);
}

bool nsMsgIMAPFolderACL::GetCanUserStoreSeenInFolder(
    const nsACString& userName) {
  return GetFlagSetInRightsForUser(userName, 's', false);
}

bool nsMsgIMAPFolderACL::GetCanUserWriteFolder(const nsACString& userName) {
  return GetFlagSetInRightsForUser(userName, 'w', false);
}

bool nsMsgIMAPFolderACL::GetCanUserInsertInFolder(const nsACString& userName) {
  return GetFlagSetInRightsForUser(userName, 'i', false);
}

bool nsMsgIMAPFolderACL::GetCanUserPostToFolder(const nsACString& userName) {
  return GetFlagSetInRightsForUser(userName, 'p', false);
}

bool nsMsgIMAPFolderACL::GetCanUserCreateSubfolder(const nsACString& userName) {
  return GetFlagSetInRightsForUser(userName, 'c', false);
}

bool nsMsgIMAPFolderACL::GetCanUserDeleteInFolder(const nsACString& userName) {
  return GetFlagSetInRightsForUser(userName, 'd', false) ||
         GetFlagSetInRightsForUser(userName, 't', false);
}

bool nsMsgIMAPFolderACL::GetCanUserAdministerFolder(
    const nsACString& userName) {
  return GetFlagSetInRightsForUser(userName, 'a', false);
}

bool nsMsgIMAPFolderACL::GetCanILookupFolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 'l', true);
}

bool nsMsgIMAPFolderACL::GetCanIReadFolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 'r', true);
}

bool nsMsgIMAPFolderACL::GetCanIStoreSeenInFolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 's', true);
}

bool nsMsgIMAPFolderACL::GetCanIWriteFolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 'w', true);
}

bool nsMsgIMAPFolderACL::GetCanIInsertInFolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 'i', true);
}

bool nsMsgIMAPFolderACL::GetCanIPostToFolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 'p', true);
}

bool nsMsgIMAPFolderACL::GetCanICreateSubfolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 'c', true);
}

bool nsMsgIMAPFolderACL::GetCanIDeleteInFolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 'd', true) ||
         GetFlagSetInRightsForUser(EmptyCString(), 't', true);
}

bool nsMsgIMAPFolderACL::GetCanIAdministerFolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 'a', true);
}

bool nsMsgIMAPFolderACL::GetCanIExpungeFolder() {
  return GetFlagSetInRightsForUser(EmptyCString(), 'e', true) ||
         GetFlagSetInRightsForUser(EmptyCString(), 'd', true);
}

// We use this to see if the ACLs think a folder is shared or not.
// We will define "Shared" in 5.0 to mean:
// At least one user other than the currently authenticated user has at least
// one explicitly-listed ACL right on that folder.
bool nsMsgIMAPFolderACL::GetIsFolderShared() {
  // If we have more than one ACL count for this folder, which means that
  // someone other than ourself has rights on it, then it is "shared."
  if (m_aclCount > 1) return true;

  // Or, if "anyone" has rights to it, it is shared.
  nsCString anyonesRights =
      m_rightsHash.Get(nsLiteralCString(IMAP_ACL_ANYONE_STRING));
  return (!anyonesRights.IsEmpty());
}

bool nsMsgIMAPFolderACL::GetDoIHaveFullRightsForFolder() {
  return (GetCanIReadFolder() && GetCanIWriteFolder() &&
          GetCanIInsertInFolder() && GetCanIAdministerFolder() &&
          GetCanICreateSubfolder() && GetCanIDeleteInFolder() &&
          GetCanILookupFolder() && GetCanIStoreSeenInFolder() &&
          GetCanIExpungeFolder() && GetCanIPostToFolder());
}

// Returns a newly allocated string describing these rights
nsresult nsMsgIMAPFolderACL::CreateACLRightsString(nsAString& aRightsString) {
  nsString curRight;
  nsCOMPtr<nsIStringBundle> bundle;
  nsresult rv = IMAPGetStringBundle(getter_AddRefs(bundle));
  NS_ENSURE_SUCCESS(rv, rv);

  if (GetDoIHaveFullRightsForFolder()) {
    nsAutoString result;
    rv = bundle->GetStringFromName("imapAclFullRights", result);
    aRightsString.Assign(result);
    return rv;
  }

  if (GetCanIReadFolder()) {
    bundle->GetStringFromName("imapAclReadRight", curRight);
    aRightsString.Append(curRight);
  }
  if (GetCanIWriteFolder()) {
    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
    bundle->GetStringFromName("imapAclWriteRight", curRight);
    aRightsString.Append(curRight);
  }
  if (GetCanIInsertInFolder()) {
    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
    bundle->GetStringFromName("imapAclInsertRight", curRight);
    aRightsString.Append(curRight);
  }
  if (GetCanILookupFolder()) {
    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
    bundle->GetStringFromName("imapAclLookupRight", curRight);
    aRightsString.Append(curRight);
  }
  if (GetCanIStoreSeenInFolder()) {
    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
    bundle->GetStringFromName("imapAclSeenRight", curRight);
    aRightsString.Append(curRight);
  }
  if (GetCanIDeleteInFolder()) {
    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
    bundle->GetStringFromName("imapAclDeleteRight", curRight);
    aRightsString.Append(curRight);
  }
  if (GetCanIExpungeFolder()) {
    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
    bundle->GetStringFromName("imapAclExpungeRight", curRight);
    aRightsString.Append(curRight);
  }
  if (GetCanICreateSubfolder()) {
    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
    bundle->GetStringFromName("imapAclCreateRight", curRight);
    aRightsString.Append(curRight);
  }
  if (GetCanIPostToFolder()) {
    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
    bundle->GetStringFromName("imapAclPostRight", curRight);
    aRightsString.Append(curRight);
  }
  if (GetCanIAdministerFolder()) {
    if (!aRightsString.IsEmpty()) aRightsString.AppendLiteral(", ");
    bundle->GetStringFromName("imapAclAdministerRight", curRight);
    aRightsString.Append(curRight);
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::GetFilePath(nsIFile** aPathName) {
  // this will return a copy of mPath, which is what we want.
  // this will also initialize mPath using parseURI if it isn't already done
  return nsMsgDBFolder::GetFilePath(aPathName);
}

NS_IMETHODIMP nsImapMailFolder::SetFilePath(nsIFile* aPathName) {
  return nsMsgDBFolder::SetFilePath(
      aPathName);  // call base class so mPath will get set
}

nsresult nsImapMailFolder::DisplayStatusMsg(nsIImapUrl* aImapUrl,
                                            const nsAString& msg) {
  nsCOMPtr<nsIImapMockChannel> mockChannel;
  aImapUrl->GetMockChannel(getter_AddRefs(mockChannel));
  if (mockChannel) {
    nsCOMPtr<nsIProgressEventSink> progressSink;
    mockChannel->GetProgressEventSink(getter_AddRefs(progressSink));
    if (progressSink) {
      progressSink->OnStatus(mockChannel, NS_OK,
                             PromiseFlatString(msg).get());  // XXX i18n message
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::ProgressStatusString(nsIImapProtocol* aProtocol,
                                       const char* aMsgName,
                                       const char16_t* extraInfo) {
  nsString progressMsg;

  nsCOMPtr<nsIMsgIncomingServer> server;
  nsresult rv = GetServer(getter_AddRefs(server));
  if (NS_SUCCEEDED(rv) && server) {
    nsCOMPtr<nsIImapServerSink> serverSink = do_QueryInterface(server);
    if (serverSink) serverSink->GetImapStringByName(aMsgName, progressMsg);
  }
  if (progressMsg.IsEmpty())
    IMAPGetStringByName(aMsgName, getter_Copies(progressMsg));

  if (aProtocol && !progressMsg.IsEmpty()) {
    nsCOMPtr<nsIImapUrl> imapUrl;
    aProtocol->GetRunningImapURL(getter_AddRefs(imapUrl));
    if (imapUrl) {
      if (extraInfo) {
        nsString printfString;
        nsTextFormatter::ssprintf(printfString, progressMsg.get(), extraInfo);
        progressMsg = printfString;
      }

      DisplayStatusMsg(imapUrl, progressMsg);
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::PercentProgress(nsIImapProtocol* aProtocol,
                                  nsACString const& aFmtStringName,
                                  nsAString const& aMailboxName,
                                  int64_t aCurrentProgress,
                                  int64_t aMaxProgress) {
  if (aProtocol) {
    nsCOMPtr<nsIImapUrl> imapUrl;
    aProtocol->GetRunningImapURL(getter_AddRefs(imapUrl));
    if (imapUrl) {
      nsCOMPtr<nsIImapMockChannel> mockChannel;
      imapUrl->GetMockChannel(getter_AddRefs(mockChannel));
      if (mockChannel) {
        nsCOMPtr<nsIProgressEventSink> progressSink;
        mockChannel->GetProgressEventSink(getter_AddRefs(progressSink));
        if (progressSink) {
          progressSink->OnProgress(mockChannel, aCurrentProgress, aMaxProgress);

          if (!aFmtStringName.IsEmpty()) {
            // There's a progress message to format (the progress messages are
            // all localized and expect three params).
            nsAutoString current;
            current.AppendInt(aCurrentProgress);
            nsAutoString expected;
            expected.AppendInt(aMaxProgress);
            nsAutoString mailbox(aMailboxName);
            AutoTArray<nsString, 3> params = {current, expected, mailbox};

            nsCOMPtr<nsIStringBundle> bundle;
            nsresult rv = IMAPGetStringBundle(getter_AddRefs(bundle));
            NS_ENSURE_SUCCESS(rv, rv);

            nsString progressText;
            rv = bundle->FormatStringFromName(
                PromiseFlatCString(aFmtStringName).get(), params, progressText);
            NS_ENSURE_SUCCESS(rv, rv);
            if (!progressText.IsEmpty()) {
              progressSink->OnStatus(mockChannel, NS_OK, progressText.get());
            }
          }
        }
      }
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::CopyNextStreamMessage(bool copySucceeded,
                                        nsISupports* copyState) {
  // if copy has failed it could be either user interrupted it or for some other
  // reason don't do any subsequent copies or delete src messages if it is move
  if (!copySucceeded) return NS_OK;
  nsresult rv;
  nsCOMPtr<nsImapMailCopyState> mailCopyState =
      do_QueryInterface(copyState, &rv);
  if (NS_FAILED(rv)) {
    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
            ("QI copyState failed: %" PRIx32, static_cast<uint32_t>(rv)));
    return rv;  // this can fail...
  }

  if (!mailCopyState->m_streamCopy) return NS_OK;

  if (mailCopyState->m_curIndex < mailCopyState->m_messages.Length()) {
    MOZ_LOG(
        IMAP, mozilla::LogLevel::Info,
        ("CopyNextStreamMessage: Copying %u of %u", mailCopyState->m_curIndex,
         (uint32_t)mailCopyState->m_messages.Length()));
    nsIMsgDBHdr* message = mailCopyState->m_messages[mailCopyState->m_curIndex];
    bool isRead;
    message->GetIsRead(&isRead);
    mailCopyState->m_unreadCount = (isRead) ? 0 : 1;
    rv = CopyStreamMessage(message, this, mailCopyState->m_msgWindow,
                           mailCopyState->m_isMove);
  } else {
    // Notify of move/copy completion in case we have some source headers
    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
        do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
    if (notifier && !mailCopyState->m_messages.IsEmpty()) {
      notifier->NotifyMsgsMoveCopyCompleted(
          mailCopyState->m_isMove, mailCopyState->m_messages, this, {});
    }
    if (mailCopyState->m_isMove) {
      nsCOMPtr<nsIMsgFolder> srcFolder(
          do_QueryInterface(mailCopyState->m_srcSupport, &rv));
      if (NS_SUCCEEDED(rv) && srcFolder) {
        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(kDeleteOrMoveMsgCompleted);
      }
    }
  }
  if (NS_FAILED(rv)) (void)OnCopyCompleted(mailCopyState->m_srcSupport, rv);

  return rv;
}

NS_IMETHODIMP
nsImapMailFolder::SetUrlState(nsIImapProtocol* aProtocol,
                              nsIMsgMailNewsUrl* aUrl, bool isRunning,
                              bool aSuspend, nsresult statusCode) {
  // If we have no path, then the folder has been shutdown, and there's
  // no point in doing anything...
  if (!mPath) return NS_OK;
  if (!isRunning) {
    ProgressStatusString(aProtocol, "imapDone", nullptr);
    m_urlRunning = false;
    // if no protocol, then we're reading from the mem or disk cache
    // and we don't want to end the offline download just yet.
    if (aProtocol) {
      EndOfflineDownload();
      m_downloadingFolderForOfflineUse = false;
    }
    nsCOMPtr<nsIImapUrl> imapUrl(do_QueryInterface(aUrl));
    if (imapUrl) {
      nsImapAction imapAction;
      imapUrl->GetImapAction(&imapAction);
      // if the server doesn't support copyUID, then SetCopyResponseUid won't
      // get called, so we need to clear m_pendingOfflineMoves when the online
      // move operation has finished.
      if (imapAction == nsIImapUrl::nsImapOnlineMove)
        m_pendingOfflineMoves.Clear();
    }
  }
  if (aUrl && !aSuspend) return aUrl->SetUrlState(isRunning, statusCode);
  return statusCode;
}

// used when copying from local mail folder, or other imap server)
nsresult nsImapMailFolder::CopyMessagesWithStream(
    nsIMsgFolder* srcFolder, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
    bool isMove, bool isCrossServerOp, nsIMsgWindow* msgWindow,
    nsIMsgCopyServiceListener* listener, bool allowUndo) {
  NS_ENSURE_ARG_POINTER(srcFolder);
  nsresult rv;
  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;
  }
  if (NS_SUCCEEDED(rv)) CopyStreamMessage(messages[0], this, msgWindow, isMove);
  return rv;  // we are clearing copy state in CopyMessages on failure
}

nsresult nsImapMailFolder::GetClearedOriginalOp(
    nsIMsgOfflineImapOperation* op, nsIMsgOfflineImapOperation** originalOp,
    nsIMsgDatabase** originalDB) {
  nsCOMPtr<nsIMsgOfflineImapOperation> returnOp;
  nsOfflineImapOperationType opType;
  op->GetOperation(&opType);
  NS_ASSERTION(opType & nsIMsgOfflineImapOperation::kMoveResult,
               "not an offline move op");

  nsCString sourceFolderURI;
  op->GetSourceFolderURI(sourceFolderURI);

  nsresult rv;
  nsCOMPtr<nsIMsgFolder> sourceFolder;
  rv = GetOrCreateFolder(sourceFolderURI, getter_AddRefs(sourceFolder));
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIDBFolderInfo> folderInfo;
  sourceFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), originalDB);
  if (*originalDB) {
    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(moveDestination);
      if (moveDestination.Equals(thisFolderURI))
        returnOp->ClearOperation(nsIMsgOfflineImapOperation::kMoveResult);
    }
  }
  returnOp.forget(originalOp);
  return rv;
}

nsresult nsImapMailFolder::GetOriginalOp(
    nsIMsgOfflineImapOperation* op, nsIMsgOfflineImapOperation** originalOp,
    nsIMsgDatabase** originalDB) {
  nsCOMPtr<nsIMsgOfflineImapOperation> returnOp;
  nsCString sourceFolderURI;
  op->GetSourceFolderURI(sourceFolderURI);

  nsresult rv;
  nsCOMPtr<nsIMsgFolder> sourceFolder;
  rv = GetOrCreateFolder(sourceFolderURI, getter_AddRefs(sourceFolder));
  NS_ENSURE_SUCCESS(rv, rv);
  nsCOMPtr<nsIDBFolderInfo> folderInfo;
  sourceFolder->GetDBFolderInfoAndDB(getter_AddRefs(folderInfo), originalDB);
  if (*originalDB) {
    nsMsgKey originalKey;
    op->GetMessageKey(&originalKey);
    rv = (*originalDB)
             ->GetOfflineOpForKey(originalKey, false, getter_AddRefs(returnOp));
  }
  returnOp.forget(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, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
    bool isMove, nsIMsgWindow* msgWindow, nsIMsgCopyServiceListener* listener) {
  nsresult rv;
  nsresult stopit = NS_OK;
  nsCOMPtr<nsIMsgDatabase> sourceMailDB;
  nsCOMPtr<nsIDBFolderInfo> srcDbFolderInfo;
  srcFolder->GetDBFolderInfoAndDB(getter_AddRefs(srcDbFolderInfo),
                                  getter_AddRefs(sourceMailDB));
  bool deleteToTrash = false;
  bool deleteImmediately = false;
  uint32_t srcCount = messages.Length();
  nsCOMPtr<nsIImapIncomingServer> imapServer;
  rv = GetImapIncomingServer(getter_AddRefs(imapServer));

  nsTArray<RefPtr<nsIMsgDBHdr>> msgHdrsCopied;
  nsTArray<RefPtr<nsIMsgDBHdr>> destMsgHdrs;

  if (NS_SUCCEEDED(rv) && imapServer) {
    nsMsgImapDeleteModel deleteModel;
    imapServer->GetDeleteModel(&deleteModel);
    deleteToTrash = (deleteModel == nsMsgImapDeleteModels::MoveToTrash);
    deleteImmediately = (deleteModel == nsMsgImapDeleteModels::DeleteNoTrash);
  }

  // This array is used only when we are actually removing the messages from the
  // source database.
  nsTArray<nsMsgKey> keysToDelete(
      (isMove && (deleteToTrash || deleteImmediately)) ? srcCount : 0);

  if (sourceMailDB) {
    // save the future ops in the source DB, if this is not a imap->local
    // copy/move
    nsCOMPtr<nsITransactionManager> txnMgr;
    if (msgWindow) msgWindow->GetTransactionManager(getter_AddRefs(txnMgr));
    if (txnMgr) txnMgr->BeginBatch(nullptr);
    nsCOMPtr<nsIMsgDatabase> database;
    GetMsgDatabase(getter_AddRefs(database));
    if (database) {
      // get the highest key in the dest db, so we can make up our fake keys
      nsMsgKey fakeBase = 1;
      nsCOMPtr<nsIDBFolderInfo> folderInfo;
      rv = database->GetDBFolderInfo(getter_AddRefs(folderInfo));
      NS_ENSURE_SUCCESS(rv, rv);
      nsMsgKey highWaterMark = nsMsgKey_None;
      folderInfo->GetHighWater(&highWaterMark);
      fakeBase += highWaterMark;
      nsMsgKey fakeTop = fakeBase + srcCount;
      // Check that we have enough room for the fake headers. If fakeTop
      // is <= highWaterMark, we've overflowed.
      if (fakeTop <= highWaterMark || fakeTop == nsMsgKey_None) {
        rv = FindOpenRange(fakeBase, srcCount);
        NS_ENSURE_SUCCESS(rv, rv);
      }
      // N.B. We must not return out of the for loop - we need the matching
      // end notifications to be sent.
      // We don't need to acquire the semaphor since this is synchronous
      // on the UI thread but we should check if the offline store is locked.
      bool isLocked;
      GetLocked(&isLocked);
      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);
      for (uint32_t sourceKeyIndex = 0;
           NS_SUCCEEDED(stopit) && (sourceKeyIndex < srcCount);
           sourceKeyIndex++) {
        bool messageReturningHome = false;
        nsCString originalSrcFolderURI;
        srcFolder->GetURI(originalSrcFolderURI);
        RefPtr<nsIMsgDBHdr> message = messages[sourceKeyIndex];
        nsMsgKey originalKey;
        if (message)
          rv = message->GetMessageKey(&originalKey);
        else {
          NS_ERROR("bad msg in src array");
          continue;
        }
        nsCOMPtr<nsIMsgOfflineImapOperation> sourceOp;
        rv = 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(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);  // offline move
              sourceOp->SetOperation(nsIMsgOfflineImapOperation::kMsgMoved);
              sourceOp->SetMsgSize(msgSize);
              newImapFlags = msgFlags & 0x7;
              if (msgFlags & nsMsgMessageFlags::Forwarded)
                newImapFlags |= kImapMsgForwardedFlag;
              sourceOp->SetNewFlags(newImapFlags);
            } else
              sourceOp->AddMessageCopyOperation(folderURI);  // offline copy

            sourceOp->GetOperation(&moveCopyOpType);
            srcMsgs.AppendObject(message);
          }
          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);
            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);
                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);
        }
      }
      EnableNotifications(nsIMsgFolder::allMessageCountNotifications, true);
      RefPtr<nsImapOfflineTxn> addHdrMsgTxn = new nsImapOfflineTxn(
          this, &addedKeys, nullptr, this, isMove,
          nsIMsgOfflineImapOperation::kAddedHeader, addedHdrs);
      if (addHdrMsgTxn && txnMgr) txnMgr->DoTransaction(addHdrMsgTxn);
      RefPtr<nsImapOfflineTxn> undoMsgTxn =
          new nsImapOfflineTxn(srcFolder, &srcKeyArray, messageIds.get(), this,
                               isMove, moveCopyOpType, srcMsgs);
      if (undoMsgTxn) {
        if (isMove) {
          undoMsgTxn->SetTransactionType(nsIMessenger::eMoveMsg);
          nsCOMPtr<nsIMsgImapMailFolder> srcIsImap(
              do_QueryInterface(srcFolder));
          // remember this undo transaction so we can hook up the result
          // msg ids in the undo transaction.
          if (srcIsImap) {
            nsImapMailFolder* srcImapFolder =
                static_cast<nsImapMailFolder*>(srcFolder);
            srcImapFolder->m_pendingOfflineMoves.AppendElement(undoMsgTxn);
          }
        } else
          undoMsgTxn->SetTransactionType(nsIMessenger::eCopyMsg);
        // we're adding this undo action before the delete is successful. This
        // is evil, but 4.5 did it as well.
        if (txnMgr) txnMgr->DoTransaction(undoMsgTxn);
      }
      undoMsgTxn =
          new nsImapOfflineTxn(srcFolder, &srcKeyArray, messageIds.get(), this,
                               isMove, deleteOpType, srcMsgs);
      if (undoMsgTxn) {
        if (isMove) {
          if (mFlags & nsMsgFolderFlags::Trash)
            undoMsgTxn->SetTransactionType(nsIMessenger::eDeleteMsg);
          else
            undoMsgTxn->SetTransactionType(nsIMessenger::eMoveMsg);
        } else
          undoMsgTxn->SetTransactionType(nsIMessenger::eCopyMsg);
        if (txnMgr) txnMgr->DoTransaction(undoMsgTxn);
      }
      if (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
  if (!msgHdrsCopied.IsEmpty()) {
    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);
    sourceMailDB->DeleteMessages(keysToDelete, nullptr);
    srcFolder->EnableNotifications(nsIMsgFolder::allMessageCountNotifications,
                                   true);
  }

  nsCOMPtr<nsISupports> srcSupport = do_QueryInterface(srcFolder);
  OnCopyCompleted(srcSupport, rv);

  if (isMove)
    srcFolder->NotifyFolderEvent(NS_SUCCEEDED(rv) ? kDeleteOrMoveMsgCompleted
                                                  : kDeleteOrMoveMsgFailed);
  return rv;
}

void nsImapMailFolder::SetPendingAttributes(
    const nsTArray<RefPtr<nsIMsgDBHdr>>& messages, bool aIsMove,
    bool aSetOffline) {
  GetDatabase();
  if (!mDatabase) return;

  uint32_t supportedUserFlags;
  GetSupportedUserFlags(&supportedUserFlags);

  nsresult rv;
  nsCOMPtr<nsIPrefBranch> prefBranch(
      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
  NS_ENSURE_SUCCESS_VOID(rv);

  nsCString dontPreserve;

  // These preferences exist so that extensions can control which properties
  // are preserved in the database when a message is moved or copied. All
  // properties are preserved except those listed in these preferences
  if (aIsMove)
    prefBranch->GetCharPref("mailnews.database.summary.dontPreserveOnMove",
                            dontPreserve);
  else
    prefBranch->GetCharPref("mailnews.database.summary.dontPreserveOnCopy",
                            dontPreserve);

  // We'll add spaces at beginning and end so we can search for space-name-space
  nsCString dontPreserveEx(" "_ns);
  dontPreserveEx.Append(dontPreserve);
  dontPreserveEx.Append(' ');

  // these properties are set as integers below, so don't set them again
  // in the iteration through the properties
  dontPreserveEx.AppendLiteral(
      "offlineMsgSize msgOffset flags priority pseudoHdr ");

  // these fields are either copied separately when the server does not support
  // custom IMAP flags, or managed directly through the flags
  dontPreserveEx.AppendLiteral("keywords label ");

  // check if any msg hdr has special flags or properties set
  // that we need to set on the dest hdr
  for (auto msgDBHdr : messages) {
    if (!(supportedUserFlags & kImapMsgSupportUserFlag)) {
      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);
      propertyEx.Append(property);
      propertyEx.Append(' ');
      if (dontPreserveEx.Find(propertyEx) != kNotFound) continue;

      nsCString sourceString;
      msgDBHdr->GetStringProperty(property.get(), getter_Copies(sourceString));
      mDatabase->SetAttributeOnPendingHdr(msgDBHdr, property.get(),
                                          sourceString.get());
    }

    // Carry over HasRe flag.
    uint32_t flags;
    uint32_t storeFlags = 0;
    msgDBHdr->GetFlags(&flags);
    if (flags & nsMsgMessageFlags::HasRe) {
      storeFlags = nsMsgMessageFlags::HasRe;
      mDatabase->SetUint32AttributeOnPendingHdr(msgDBHdr, "flags", storeFlags);
    }

    uint32_t messageSize;
    uint64_t messageOffset;
    nsCString storeToken;
    msgDBHdr->GetMessageOffset(&messageOffset);
    msgDBHdr->GetOfflineMessageSize(&messageSize);
    msgDBHdr->GetStringProperty("storeToken", getter_Copies(storeToken));
    if (messageSize) {
      mDatabase->SetUint32AttributeOnPendingHdr(msgDBHdr, "offlineMsgSize",
                                                messageSize);
      mDatabase->SetUint64AttributeOnPendingHdr(msgDBHdr, "msgOffset",
                                                messageOffset);
      // Not always setting "flags" attribute to nsMsgMessageFlags::Offline
      // here because it can cause missing parts (inline or attachments)
      // when messages are moved or copied manually or by filter action.
      if (aSetOffline)
        mDatabase->SetUint32AttributeOnPendingHdr(
            msgDBHdr, "flags", storeFlags | nsMsgMessageFlags::Offline);
      mDatabase->SetAttributeOnPendingHdr(msgDBHdr, "storeToken",
                                          storeToken.get());
    }
    nsMsgPriorityValue priority;
    msgDBHdr->GetPriority(&priority);
    if (priority != 0) {
      nsAutoCString priorityStr;
      priorityStr.AppendInt(priority);
      mDatabase->SetAttributeOnPendingHdr(msgDBHdr, "priority",
                                          priorityStr.get());
    }
  }
}

NS_IMETHODIMP
nsImapMailFolder::CopyMessages(
    nsIMsgFolder* srcFolder, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
    bool isMove, nsIMsgWindow* msgWindow, nsIMsgCopyServiceListener* listener,
    bool isFolder,  // isFolder for future use when we do cross-server folder
                    // move/copy
    bool allowUndo) {
  UpdateTimestamps(allowUndo);

  nsresult rv;
  nsCOMPtr<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->InitWithNamedFuncCallback(
          PlaybackTimerCallback, (void*)srcImapFolder->m_pendingPlaybackReq,
          PLAYBACK_TIMER_INTERVAL_IN_MS, nsITimer::TYPE_ONE_SHOT,
          "nsImapMailFolder::PlaybackTimerCallback");
    }
    return rv;
  } else {
    // sort the message array by key

    nsTArray<nsMsgKey> keyArray(messages.Length());
    for (nsIMsgDBHdr* aMessage : messages) {
      if (!aMessage) {
        continue;
      }
      nsMsgKey key;
      aMessage->GetMessageKey(&key);
      keyArray.AppendElement(key);
    }
    keyArray.Sort();

    nsTArray<RefPtr<nsIMsgDBHdr>> sortedMsgs;
    rv = MessagesInKeyOrder(keyArray, srcFolder, sortedMsgs);
    NS_ENSURE_SUCCESS(rv, rv);

    if (WeAreOffline())
      return CopyMessagesOffline(srcFolder, sortedMsgs, isMove, msgWindow,
                                 listener);

    nsCOMPtr<nsIImapService> imapService =
        do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);

    // 3rd parameter: Do not set offline flag.
    SetPendingAttributes(sortedMsgs, isMove, false);

    // if the folders aren't on the same server, do a stream base copy
    if (!sameServer) {
      rv = CopyMessagesWithStream(srcFolder, sortedMsgs, isMove, true,
                                  msgWindow, listener, allowUndo);
      goto done;
    }

    nsAutoCString messageIds;
    rv = AllocateUidStringFromKeys(keyArray, messageIds);
    if (NS_FAILED(rv)) goto done;

    nsCOMPtr<nsIUrlListener> urlListener;
    rv =
        QueryInterface(NS_GET_IID(nsIUrlListener), getter_AddRefs(urlListener));
    rv = InitCopyState(srcSupport, sortedMsgs, isMove, true, false, 0,
                       EmptyCString(), listener, msgWindow, allowUndo);
    if (NS_FAILED(rv)) goto done;

    m_copyState->m_curIndex = m_copyState->m_messages.Length();

    if (isMove)
      srcFolder->EnableNotifications(
          allMessageCountNotifications,
          false);  // disable message count notification

    nsCOMPtr<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);  // enable message count notification
      NotifyFolderEvent(kDeleteOrMoveMsgFailed);
    }
  }
  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;
  // NOTE: The nsImapMailFolder doesn't keep a reference to us, so we're
  // relying on our use as a listener by nsImapService and nsMsgCopyService
  // to keep our refcount from zeroing!
  // Might be safer to add a kungfudeathgrip on ourselves for the duration
  // of the operation? Would need to make sure we catch all error conditions.
}

nsImapFolderCopyState::~nsImapFolderCopyState() {}

nsresult nsImapFolderCopyState::StartNextCopy() {
  nsresult rv;
  // Create the destination folder (our OnStopRunningUrl() will be called
  // when done).
  nsCOMPtr<nsIImapService> imapService =
      do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  nsString folderName;
  m_curSrcFolder->GetName(folderName);
  return imapService->EnsureFolderExists(m_curDestParent, folderName,
                                         m_msgWindow, 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);
  } else {
    m_curDestParent = m_destParents[m_childIndex];
    m_curSrcFolder = m_srcChildFolders[m_childIndex];
    rv = StartNextCopy();
  }
  return rv;
}

NS_IMETHODIMP
nsImapFolderCopyState::OnStartRunningUrl(nsIURI* aUrl) {
  NS_ASSERTION(aUrl, "sanity check - need to be be running non-null url");
  return NS_OK;
}

NS_IMETHODIMP
nsImapFolderCopyState::OnStopRunningUrl(nsIURI* aUrl, nsresult aExitCode) {
  if (NS_FAILED(aExitCode)) {
    if (m_copySrvcListener) m_copySrvcListener->OnStopCopy(aExitCode);
    return aExitCode;  // or NS_OK???
  }
  nsresult rv = NS_OK;
  if (aUrl) {
    nsCOMPtr<nsIImapUrl> imapUrl = do_QueryInterface(aUrl);
    if (imapUrl) {
      nsImapAction imapAction = nsIImapUrl::nsImapTest;
      imapUrl->GetImapAction(&imapAction);

      switch (imapAction) {
        case nsIImapUrl::nsImapEnsureExistsFolder: {
          // Our EnsureFolderExists() call has completed successfully,
          // so our dest folder is ready.
          nsCOMPtr<nsIMsgFolder> newMsgFolder;
          nsString folderName;
          nsCString utfLeafName;
          m_curSrcFolder->GetName(folderName);
          bool utf8AcceptEnabled;
          nsCOMPtr<nsIMsgImapMailFolder> imapFolder =
              do_QueryInterface(m_curDestParent);
          rv = imapFolder->GetShouldUseUtf8FolderName(&utf8AcceptEnabled);
          NS_ENSURE_SUCCESS(rv, rv);
          if (utf8AcceptEnabled) {
            CopyUTF16toUTF8(folderName, utfLeafName);
          } else {
            CopyUTF16toMUTF7(folderName, utfLeafName);
          }
          // Create the nsIMsgFolder object which represents the folder on
          // the IMAP server.
          rv = m_curDestParent->FindSubFolder(utfLeafName,
                                              getter_AddRefs(newMsgFolder));
          NS_ENSURE_SUCCESS(rv, rv);
          // Save the first new folder so we can send a notification to the
          // copy service when this whole process is done.
          if (!m_newDestFolder)
            m_newDestFolder =
                static_cast<nsImapMailFolder*>(newMsgFolder.get());

          // Check if the source folder has children. If it does, list them
          // into m_srcChildFolders, and set m_destParents for the
          // corresponding indexes to the newly created folder.
          nsTArray<RefPtr<nsIMsgFolder>> subFolders;
          rv = m_curSrcFolder->GetSubFolders(subFolders);
          NS_ENSURE_SUCCESS(rv, rv);
          uint32_t childIndex = 0;
          for (nsIMsgFolder* folder : subFolders) {
            m_srcChildFolders.InsertElementAt(m_childIndex + childIndex + 1,
                                              folder);
            m_destParents.InsertElementAt(m_childIndex + childIndex + 1,
                                          newMsgFolder);
            ++childIndex;
          }

          // Now kick off a copy (or move) of messages to the new folder.
          nsCOMPtr<nsIMsgEnumerator> enumerator;
          rv = m_curSrcFolder->GetMessages(getter_AddRefs(enumerator));
          nsTArray<RefPtr<nsIMsgDBHdr>> msgArray;
          bool hasMore = false;

          if (enumerator) rv = enumerator->HasMoreElements(&hasMore);

          // Early-out for empty folder.
          if (!hasMore) return AdvanceToNextFolder(NS_OK);

          while (NS_SUCCEEDED(rv) && hasMore) {
            nsCOMPtr<nsIMsgDBHdr> hdr;
            rv = enumerator->GetNext(getter_AddRefs(hdr));
            NS_ENSURE_SUCCESS(rv, rv);
            msgArray.AppendElement(hdr);
            rv = enumerator->HasMoreElements(&hasMore);
          }

          nsCOMPtr<nsIMsgCopyService> copyService =
              do_GetService(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;
  }

  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
        srcFolder->DeleteStorage();

        nsCOMPtr<nsIFile> parentPathFile;
        rv = msgParent->GetFilePath(getter_AddRefs(parentPathFile));
        NS_ENSURE_SUCCESS(rv, rv);

        AddDirectorySeparator(parentPathFile);
        nsCOMPtr<nsIDirectoryEnumerator> children;
        parentPathFile->GetDirectoryEntries(getter_AddRefs(children));
        bool more;
        // checks if the directory is empty or not
        if (children && NS_SUCCEEDED(children->HasMoreElements(&more)) && !more)
          parentPathFile->Remove(true);
      }
    } else  // non-virtual folder
    {
      nsCOMPtr<nsIImapService> imapService =
          do_GetService(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, {}, 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?)
  {
    // NOTE: the copystate object must hold itself in existence until complete,
    // as we're not keeping hold of it here.
    RefPtr<nsImapFolderCopyState> folderCopier = new nsImapFolderCopyState(
        this, srcFolder, isMoveFolder, msgWindow, listener);
    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;
  nsTArray<RefPtr<nsIMsgDBHdr>> messages;

  nsCOMPtr<nsIImapService> imapService =
      do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv);
  if (NS_FAILED(rv)) return OnCopyCompleted(file, rv);

  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);
      SetPendingAttributes({msgToReplace}, false, false);
    }
  }

  bool isMove = (msgToReplace ? true : false);
  rv = InitCopyState(file, messages, isMove, isDraftOrTemplate, false,
                     aNewMsgFlags, aNewMsgKeywords, listener, msgWindow, false);
  if (NS_FAILED(rv)) return OnCopyCompleted(file, rv);

  m_copyState->m_streamCopy = true;
  rv = imapService->AppendMessageFromFile(file, this, messageId, true,
                                          isDraftOrTemplate, this, nullptr,
                                          m_copyState, msgWindow);
  if (NS_FAILED(rv)) return OnCopyCompleted(file, rv);

  return rv;
}

nsresult nsImapMailFolder::CopyStreamMessage(
    nsIMsgDBHdr* message,
    nsIMsgFolder* dstFolder,  // should be this
    nsIMsgWindow* aMsgWindow, bool isMove) {
  NS_ENSURE_ARG_POINTER(message);
  if (!m_copyState)
    MOZ_LOG(IMAP, mozilla::LogLevel::Info,
            ("CopyStreamMessage failed with null m_copyState"));
  NS_ENSURE_TRUE(m_copyState, NS_ERROR_NULL_POINTER);
  nsresult rv;
  nsCOMPtr<nsICopyMessageStreamListener> copyStreamListener =
      do_CreateInstance(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;

  nsCString uri;
  srcFolder->GetUriForMsg(message, uri);

  if (!m_copyState->m_msgService)
    rv = GetMessageServiceFromURI(uri,
                                  getter_AddRefs(m_copyState->m_msgService));

  if (NS_SUCCEEDED(rv) && m_copyState->m_msgService) {
    nsCOMPtr<nsIStreamListener> streamListener(
        do_QueryInterface(copyStreamListener, &rv));
    NS_ENSURE_SUCCESS(rv, rv);

    // put up status message here, if copying more than one message.
    if (m_copyState->m_messages.Length() > 1) {
      nsString dstFolderName, progressText;
      GetName(dstFolderName);
      nsAutoString curMsgString;
      nsAutoString totalMsgString;
      totalMsgString.AppendInt((int32_t)m_copyState->m_messages.Length());
      curMsgString.AppendInt(m_copyState->m_curIndex + 1);

      AutoTArray<nsString, 3> formatStrings = {curMsgString, totalMsgString,
                                               dstFolderName};

      nsCOMPtr<nsIStringBundle> bundle;
      rv = IMAPGetStringBundle(getter_AddRefs(bundle));
      NS_ENSURE_SUCCESS(rv, rv);
      rv = bundle->FormatStringFromName("imapCopyingMessageOf2", formatStrings,
                                        progressText);
      nsCOMPtr<nsIMsgStatusFeedback> statusFeedback;
      if (m_copyState->m_msgWindow)
        m_copyState->m_msgWindow->GetStatusFeedback(
            getter_AddRefs(statusFeedback));
      if (statusFeedback) {
        statusFeedback->ShowStatusString(progressText);
        int32_t percent;
        percent = (100 * m_copyState->m_curIndex) /
                  (int32_t)m_copyState->m_messages.Length();
        statusFeedback->ShowProgress(percent);
      }
    }
    nsCOMPtr<nsIURI> dummyNull;
    rv = m_copyState->m_msgService->CopyMessage(
        uri, 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", uri.get()));
  }
  return rv;
}

nsImapMailCopyState::nsImapMailCopyState()
    : m_isMove(false),
      m_selectedState(false),
      m_isCrossServerOp(false),
      m_curIndex(0),
      m_streamCopy(false),
      m_dataBuffer(nullptr),
      m_dataBufferSize(0),
      m_leftOver(0),
      m_allowUndo(false),
      m_eatLF(false),
      m_newMsgFlags(0),
      m_appendUID(nsMsgKey_None) {}

nsImapMailCopyState::~nsImapMailCopyState() {
  PR_Free(m_dataBuffer);
  if (m_tmpFile) m_tmpFile->Remove(false);
}

NS_IMPL_ISUPPORTS(nsImapMailCopyState, nsImapMailCopyState)

nsresult nsImapMailFolder::InitCopyState(
    nsISupports* srcSupport, nsTArray<RefPtr<nsIMsgDBHdr>> const& messages,
    bool isMove, bool selectedState, bool acrossServers, uint32_t newMsgFlags,
    const nsACString& newMsgKeywords, nsIMsgCopyServiceListener* listener,
    nsIMsgWindow* msgWindow, bool allowUndo) {
  NS_ENSURE_ARG_POINTER(srcSupport);

  NS_ENSURE_TRUE(!m_copyState, NS_ERROR_FAILURE);

  m_copyState = new nsImapMailCopyState();

  m_copyState->m_isCrossServerOp = acrossServers;
  m_copyState->m_srcSupport = srcSupport;

  m_copyState->m_messages = messages.Clone();
  if (!m_copyState->m_isCrossServerOp) {
    uint32_t numUnread = 0;
    for (nsIMsgDBHdr* message : m_copyState->m_messages) {
      // if the message is not there, then assume what the caller tells us to.
      bool isRead = false;
      uint32_t flags;
      if (message) {
        message->GetFlags(&flags);
        isRead = flags & nsMsgMessageFlags::Read;
      }
      if (!isRead) numUnread++;
    }
    m_copyState->m_unreadCount = numUnread;
  } else {
    nsIMsgDBHdr* message = m_copyState->m_messages[m_copyState->m_curIndex];
    // if the key is not there, then assume what the caller tells us to.
    bool isRead = false;
    uint32_t flags;
    if (message) {
      message->GetFlags(&flags);
      isRead = flags & nsMsgMessageFlags::Read;
    }
    m_copyState->m_unreadCount = (isRead) ? 0 : 1;
  }

  m_copyState->m_isMove = isMove;
  m_copyState->m_newMsgFlags = newMsgFlags;
  m_copyState->m_newMsgKeywords = newMsgKeywords;
  m_copyState->m_allowUndo = allowUndo;
  m_copyState->m_selectedState = selectedState;
  m_copyState->m_msgWindow = msgWindow;
  if (listener) m_copyState->m_listener = listener;
  return NS_OK;
}

nsresult nsImapMailFolder::CopyFileToOfflineStore(nsIFile* srcFile,
                                                  nsMsgKey msgKey) {
  nsresult rv = GetDatabase();
  NS_ENSURE_SUCCESS(rv, rv);

  bool storeOffline = (mFlags & nsMsgFolderFlags::Offline) && !WeAreOffline();

  if (msgKey == nsMsgKey_None) {
    // To support send filters, we need to store the message in the database
    // when it is copied to the FCC folder. In that case, we know the UID of the
    // message and therefore have the correct msgKey. In other cases, where
    // we don't need the offline message copied, don't add to db.
    if (!storeOffline) return NS_OK;

    mDatabase->GetNextFakeOfflineMsgKey(&msgKey);
  }

  nsCOMPtr<nsIMsgDBHdr> fakeHdr;
  rv = mDatabase->CreateNewHdr(msgKey, getter_AddRefs(fakeHdr));
  NS_ENSURE_SUCCESS(rv, rv);
  fakeHdr->SetUint32Property("pseudoHdr", 1);

  // Should we add this to the offline store?
  nsCOMPtr<nsIOutputStream> offlineStore;
  if (storeOffline) {
    rv = GetOfflineStoreOutputStream(fakeHdr, getter_AddRefs(offlineStore));
    NS_ENSURE_SUCCESS(rv, rv);
  }

  // We set an offline kMoveResult because in any case we want to update this
  // msgHdr with one downloaded from the server, with possible additional
  // headers added.
  nsCOMPtr<nsIMsgOfflineImapOperation> op;
  rv = mDatabase->GetOfflineOpForKey(msgKey, true, getter_AddRefs(op));
  if (NS_SUCCEEDED(rv) && op) {
    nsCString destFolderUri;
    GetURI(destFolderUri);
    op->SetOperation(nsIMsgOfflineImapOperation::kMoveResult);
    op->SetDestinationFolderURI(destFolderUri);
    SetFlag(nsMsgFolderFlags::OfflineEvents);
  }

  nsCOMPtr<nsIInputStream> inputStream;
  nsCOMPtr<nsIMsgParseMailMsgState> msgParser =
      do_CreateInstance(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.
    RefPtr<nsMsgLineStreamBuffer> inputStreamBuffer =
        new nsMsgLineStreamBuffer(FILE_IO_BUFFER_SIZE, true, false);
    int64_t fileSize;
    srcFile->GetFileSize(&fileSize);
    uint32_t bytesWritten;
    rv = NS_OK;
    msgParser->SetState(nsIMsgParseMailMsgState::ParseHeadersState);
    msgParser->SetNewMsgHdr(fakeHdr);
    bool needMoreData = false;
    char* newLine = nullptr;
    uint32_t numBytesInLine = 0;
    if (offlineStore) {
      const char* envelope = "From " CRLF;
      offlineStore->Write(envelope, strlen(envelope), &bytesWritten);
      fileSize += bytesWritten;
    }
    do {
      newLine = inputStreamBuffer->ReadNextLine(inputStream, numBytesInLine,
                                                needMoreData);
      if (newLine) {
        msgParser->ParseAFolderLine(newLine, numBytesInLine);
        if (offlineStore)
          rv = offlineStore->Write(newLine, numBytesInLine, &bytesWritten);

        free(newLine);
        NS_ENSURE_SUCCESS(rv, rv);
      }
    } while (newLine);

    msgParser->FinishHeader();
    uint32_t resultFlags;
    if (offlineStore)
      fakeHdr->OrFlags(nsMsgMessageFlags::Offline | nsMsgMessageFlags::Read,
                       &resultFlags);
    else
      fakeHdr->OrFlags(nsMsgMessageFlags::Read, &resultFlags);
    if (offlineStore) fakeHdr->SetOfflineMessageSize(fileSize);
    mDatabase->AddNewHdrToDB(fakeHdr, true /* notify */);

    // Call FinishNewMessage before setting pending attributes, as in
    //   maildir it copies from tmp to cur and may change the storeToken
    //   to get a unique filename.
    if (offlineStore) {
      nsCOMPtr<nsIMsgPluggableStore> msgStore;
      GetMsgStore(getter_AddRefs(msgStore));
      if (msgStore) msgStore->FinishNewMessage(offlineStore, fakeHdr);
    }

    // We are copying from a file to offline store so set offline flag.
    SetPendingAttributes({&*fakeHdr}, false, true);

    // Gloda needs this notification to index the fake message.
    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
        do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID));
    if (notifier) notifier->NotifyMsgsClassified({&*fakeHdr}, false, false);
    inputStream->Close();
    inputStream = nullptr;
  }
  if (offlineStore) offlineStore->Close();
  return rv;
}

nsresult nsImapMailFolder::OnCopyCompleted(nsISupports* srcSupport,
                                           nsresult rv) {
  // if it's a file, and the copy succeeded, then fcc the offline
  // store, and add a kMoveResult offline op.
  if (NS_SUCCEEDED(rv) && m_copyState) {
    nsCOMPtr<nsIFile> srcFile(do_QueryInterface(srcSupport));
    if (srcFile)
      (void)CopyFileToOfflineStore(srcFile, m_copyState->m_appendUID);
  }
  m_copyState = nullptr;
  nsresult result;
  nsCOMPtr<nsIMsgCopyService> copyService =
      do_GetService(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;

  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
  nsresult rv = GetSubFolders(subFolders);
  NS_ENSURE_SUCCESS(rv, rv);

  for (nsIMsgFolder* f : subFolders) {
    nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(f, &rv));
    NS_ENSURE_SUCCESS(rv, rv);
    rv = imapFolder->ResetNamespaceReferences();
    NS_ENSURE_SUCCESS(rv, rv);
  }
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::FindOnlineSubFolder(
    const nsACString& targetOnlineName, nsIMsgImapMailFolder** aResultFolder) {
  *aResultFolder = nullptr;
  nsresult rv = NS_OK;

  nsCString onlineName;
  GetOnlineName(onlineName);

  if (onlineName.Equals(targetOnlineName)) {
    return QueryInterface(NS_GET_IID(nsIMsgImapMailFolder),
                          (void**)aResultFolder);
  }

  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
  rv = GetSubFolders(subFolders);
  NS_ENSURE_SUCCESS(rv, rv);
  for (nsIMsgFolder* f : subFolders) {
    nsCOMPtr<nsIMsgImapMailFolder> imapFolder(do_QueryInterface(f, &rv));
    NS_ENSURE_SUCCESS(rv, rv);
    rv = imapFolder->FindOnlineSubFolder(targetOnlineName, aResultFolder);
    NS_ENSURE_SUCCESS(rv, rv);
    if (*aResultFolder) {
      return NS_OK;  // Found it!
    }
  }
  return NS_OK;  // Not found.
}

NS_IMETHODIMP nsImapMailFolder::GetFolderNeedsAdded(bool* bVal) {
  NS_ENSURE_ARG_POINTER(bVal);
  *bVal = m_folderNeedsAdded;
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::SetFolderNeedsAdded(bool bVal) {
  m_folderNeedsAdded = bVal;
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::GetFolderQuotaCommandIssued(bool* aCmdIssued) {
  NS_ENSURE_ARG_POINTER(aCmdIssued);
  *aCmdIssued = m_folderQuotaCommandIssued;
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::SetFolderQuotaCommandIssued(bool aCmdIssued) {
  m_folderQuotaCommandIssued = aCmdIssued;
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::SetFolderQuotaData(
    uint32_t aAction, const nsACString& aFolderQuotaRoot,
    uint64_t aFolderQuotaUsage, uint64_t aFolderQuotaLimit) {
  switch (aAction) {
    case kInvalidateQuota:
      // Reset to initialize evaluation of a new quotaroot imap response. This
      // clears any previous array data and marks the quota data for this folder
      // invalid.
      m_folderQuotaDataIsValid = false;
      m_folderQuota.Clear();
      break;
    case kStoreQuota:
      // Store folder's quota data to an array. This will occur zero or more
      // times for a folder.
      m_folderQuota.AppendElement(new nsMsgQuota(
          aFolderQuotaRoot, aFolderQuotaUsage, aFolderQuotaLimit));
      break;
    case kValidateQuota:
      // GETQUOTAROOT command was successful and OK response has occurred. This
      // indicates that all the untagged QUOTA responses have occurred so mark
      // as valid.
      m_folderQuotaDataIsValid = true;
      break;
    default:
      // Called with undefined aAction parameter.
      NS_ASSERTION(false, "undefined action");
  }
  return NS_OK;
}

// Provide the quota array for status bar notification.
NS_IMETHODIMP nsImapMailFolder::GetQuota(
    nsTArray<RefPtr<nsIMsgQuota>>& aArray) {
  if (m_folderQuotaDataIsValid) {
    aArray = m_folderQuota.Clone();
  }
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::PerformExpand(nsIMsgWindow* aMsgWindow) {
  nsresult rv;
  bool usingSubscription = false;
  nsCOMPtr<nsIImapIncomingServer> imapServer;
  rv = GetImapIncomingServer(getter_AddRefs(imapServer));
  NS_ENSURE_SUCCESS(rv, rv);
  rv = imapServer->GetUsingSubscription(&usingSubscription);
  if (NS_SUCCEEDED(rv) && !usingSubscription) {
    nsCOMPtr<nsIImapService> imapService =
        do_GetService(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_ConvertUTF8toUTF16 newNameString(newName);
  NS_ENSURE_SUCCESS(rv, rv);
  newLeafName = newNameString;
  nsAutoString folderNameStr;
  int32_t folderStart = newLeafName.RFindChar(
      '/');  // internal use of hierarchyDelimiter is always '/'
  if (folderStart > 0) {
    newLeafName = Substring(newNameString, folderStart + 1);
    CreateDirectoryForFolder(
        getter_AddRefs(pathFile));  // needed when we move a folder to a folder
                                    // with no subfolders.
  }

  // if we get here, it's really a leaf, and "this" is the parent.
  folderNameStr = newLeafName;

  // Create an empty database for this mail folder, set its name from the user
  nsCOMPtr<nsIMsgDatabase> mailDBFactory;
  nsCOMPtr<nsIMsgFolder> child;
  nsCOMPtr<nsIMsgImapMailFolder> imapFolder;

  nsCOMPtr<nsIMsgDBService> msgDBService =
      do_GetService(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 = CopyFolderNameToUTF16(NS_ConvertUTF16toUTF8(folderNameStr),
                               unicodeName);
    if (NS_SUCCEEDED(rv)) child->SetPrettyName(unicodeName);
    imapFolder = do_QueryInterface(child);
    if (imapFolder) {
      nsAutoCString onlineName(m_onlineFolderName);

      if (!onlineName.IsEmpty()) onlineName.Append(hierarchyDelimiter);
      onlineName.Append(NS_ConvertUTF16toUTF8(folderNameStr));
      imapFolder->SetVerifiedAsOnlineFolder(true);
      imapFolder->SetOnlineName(onlineName);
      imapFolder->SetHierarchyDelimiter(hierarchyDelimiter);
      imapFolder->SetBoxFlags(boxflags);
      // store the online name as the mailbox name in the db folder info
      // I don't think anyone uses the mailbox name, so we'll use it
      // to restore the online name when blowing away an imap db.
      if (folderInfo) {
        nsAutoString unicodeOnlineName;
        CopyUTF8toUTF16(onlineName, unicodeOnlineName);
        folderInfo->SetMailboxName(unicodeOnlineName);
      }
      bool changed = false;
      msgFolder->MatchOrChangeFilterDestination(
          child, false /*caseInsensitive*/, &changed);
      if (changed) msgFolder->AlertFilterChanged(msgWindow);
    }
    unusedDB->SetSummaryValid(true);
    unusedDB->Commit(nsMsgDBCommitType::kLargeCommit);
    unusedDB->Close(true);
    child->RenameSubFolders(msgWindow, msgFolder);
    nsCOMPtr<nsIMsgFolder> msgParent;
    msgFolder->GetParent(getter_AddRefs(msgParent));
    msgFolder->SetParent(nullptr);
    // Reset online status now that the folder is renamed.
    nsCOMPtr<nsIMsgImapMailFolder> oldImapFolder = do_QueryInterface(msgFolder);
    if (oldImapFolder) oldImapFolder->SetVerifiedAsOnlineFolder(false);
    nsCOMPtr<nsIMsgFolderNotificationService> notifier(
        do_GetService(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;
  nsTArray<RefPtr<nsIMsgFolder>> subFolders;
  nsresult rv = oldFolder->GetSubFolders(subFolders);
  NS_ENSURE_SUCCESS(rv, rv);

  for (nsIMsgFolder* msgFolder : subFolders) {
    nsCOMPtr<nsIMsgImapMailFolder> folder(do_QueryInterface(msgFolder, &rv));
    NS_ENSURE_SUCCESS(rv, rv);

    char hierarchyDelimiter = '/';
    folder->GetHierarchyDelimiter(&hierarchyDelimiter);

    int32_t boxflags;
    folder->GetBoxFlags(&boxflags);

    bool verified;
    folder->GetVerifiedAsOnlineFolder(&verified);

    nsCOMPtr<nsIFile> oldPathFile;
    rv = msgFolder->GetFilePath(getter_AddRefs(oldPathFile));
    if (NS_FAILED(rv)) return rv;

    nsCOMPtr<nsIFile> newParentPathFile;
    rv = GetFilePath(getter_AddRefs(newParentPathFile));
    if (NS_FAILED(rv)) return rv;

    rv = AddDirectorySeparator(newParentPathFile);
    nsAutoCString oldLeafName;
    oldPathFile->GetNativeLeafName(oldLeafName);
    newParentPathFile->AppendNative(oldLeafName);

    nsCOMPtr<nsIFile> newPathFile =
        do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    newPathFile->InitWithFile(newParentPathFile);

    nsCOMPtr<nsIFile> dbFilePath = newPathFile;

    nsCOMPtr<nsIMsgFolder> child;

    nsString folderName;
    rv = msgFolder->GetName(folderName);
    if (folderName.IsEmpty() || NS_FAILED(rv)) return rv;

    nsCString utfLeafName;
    bool utf8AcceptEnabled;
    nsCOMPtr<nsIMsgImapMailFolder> imapFolder = do_QueryInterface(msgFolder);
    rv = imapFolder->GetShouldUseUtf8FolderName(&utf8AcceptEnabled);
    NS_ENSURE_SUCCESS(rv, rv);
    if (utf8AcceptEnabled) {
      CopyUTF16toUTF8(folderName, utfLeafName);
    } else {
      CopyUTF16toMUTF7(folderName, utfLeafName);
    }

    // XXX : Fix this non-sense by fixing AddSubfolderWithPath
    nsAutoString unicodeLeafName;
    CopyUTF8toUTF16(utfLeafName, unicodeLeafName);

    rv = AddSubfolderWithPath(unicodeLeafName, dbFilePath,
                              getter_AddRefs(child));
    if (!child || NS_FAILED(rv)) return rv;

    child->SetName(folderName);
    imapFolder = do_QueryInterface(child);
    nsCString onlineName;
    GetOnlineName(onlineName);
    nsAutoCString onlineCName(onlineName);
    onlineCName.Append(hierarchyDelimiter);
    onlineCName.Append(utfLeafName);
    if (imapFolder) {
      imapFolder->SetVerifiedAsOnlineFolder(verified);
      imapFolder->SetOnlineName(onlineCName);
      imapFolder->SetHierarchyDelimiter(hierarchyDelimiter);
      imapFolder->SetBoxFlags(boxflags);

      bool changed = false;
      msgFolder->MatchOrChangeFilterDestination(
          child, false /*caseInsensitive*/, &changed);
      if (changed) msgFolder->AlertFilterChanged(msgWindow);
      child->RenameSubFolders(msgWindow, msgFolder);
    }
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::IsCommandEnabled(const nsACString& command,
                                                 bool* result) {
  NS_ENSURE_ARG_POINTER(result);
  *result = !(WeAreOffline() && (command.EqualsLiteral("cmd_renameFolder") ||
                                 command.EqualsLiteral("cmd_compactFolder") ||
                                 command.EqualsLiteral("button_compact") ||
                                 command.EqualsLiteral("cmd_delete") ||
                                 command.EqualsLiteral("button_delete")));
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::GetCanFileMessages(bool* aCanFileMessages) {
  nsresult rv;
  *aCanFileMessages = true;

  nsCOMPtr<nsIMsgIncomingServer> server;
  rv = GetServer(getter_AddRefs(server));
  if (NS_SUCCEEDED(rv) && server)
    rv = server->GetCanFileMessagesOnServer(aCanFileMessages);

  if (*aCanFileMessages)
    rv = nsMsgDBFolder::GetCanFileMessages(aCanFileMessages);

  if (*aCanFileMessages) {
    bool noSelect;
    GetFlag(nsMsgFolderFlags::ImapNoselect, &noSelect);
    *aCanFileMessages =
        (noSelect) ? false : GetFolderACL()->GetCanIInsertInFolder();
    return NS_OK;
  }
  return rv;
}

NS_IMETHODIMP
nsImapMailFolder::GetCanDeleteMessages(bool* aCanDeleteMessages) {
  NS_ENSURE_ARG_POINTER(aCanDeleteMessages);
  *aCanDeleteMessages = GetFolderACL()->GetCanIDeleteInFolder();
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::GetPerformingBiff(bool* aPerformingBiff) {
  NS_ENSURE_ARG_POINTER(aPerformingBiff);
  *aPerformingBiff = m_performingBiff;
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::SetPerformingBiff(bool aPerformingBiff) {
  m_performingBiff = aPerformingBiff;
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::SetFilterList(nsIMsgFilterList* aMsgFilterList) {
  m_filterList = aMsgFilterList;
  return nsMsgDBFolder::SetFilterList(aMsgFilterList);
}

nsresult nsImapMailFolder::GetMoveCoalescer() {
  if (!m_moveCoalescer)
    m_moveCoalescer = new nsImapMoveCoalescer(this, nullptr /* msgWindow */);
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::StoreCustomKeywords(nsIMsgWindow* aMsgWindow,
                                      const nsACString& aFlagsToAdd,
                                      const nsACString& aFlagsToSubtract,
                                      const nsTArray<nsMsgKey>& aKeysToStore,
                                      nsIURI** _retval) {
  if (aKeysToStore.IsEmpty()) return NS_OK;
  nsresult rv = NS_OK;
  if (WeAreOffline()) {
    GetDatabase();
    if (!mDatabase) return NS_ERROR_UNEXPECTED;
    for (auto key : aKeysToStore) {
      nsCOMPtr<nsIMsgOfflineImapOperation> op;
      nsresult rv2 =
          mDatabase->GetOfflineOpForKey(key, true, getter_AddRefs(op));
      if (NS_FAILED(rv2)) rv = rv2;
      SetFlag(nsMsgFolderFlags::OfflineEvents);
      if (NS_SUCCEEDED(rv2) && op) {
        if (!aFlagsToAdd.IsEmpty())
          op->AddKeywordToAdd(PromiseFlatCString(aFlagsToAdd).get());
        if (!aFlagsToSubtract.IsEmpty())
          op->AddKeywordToRemove(PromiseFlatCString(aFlagsToSubtract).get());
      }
    }
    mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);  // flush offline ops
    return rv;
  }

  nsCOMPtr<nsIImapService> imapService(
      do_GetService(NS_IMAPSERVICE_CONTRACTID, &rv));
  NS_ENSURE_SUCCESS(rv, rv);
  nsAutoCString msgIds;
  AllocateUidStringFromKeys(aKeysToStore, 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(), "Junk"_ns,
                          EmptyCString(), *junkKeysToClassify, nullptr);
    junkKeysToClassify->Clear();
    nsTArray<nsMsgKey>* nonJunkKeysToClassify =
        m_moveCoalescer->GetKeyBucket(1);
    if (nonJunkKeysToClassify && !nonJunkKeysToClassify->IsEmpty())
      StoreCustomKeywords(m_moveCoalescer->GetMsgWindow(), "NonJunk"_ns,
                          EmptyCString(), *nonJunkKeysToClassify, nullptr);
    nonJunkKeysToClassify->Clear();
    return m_moveCoalescer->PlaybackMoves(ShowPreviewText());
  }
  return NS_OK;  // must not be any coalesced operations
}

NS_IMETHODIMP
nsImapMailFolder::SetJunkScoreForMessages(
    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
    const nsACString& aJunkScore) {
  nsresult rv = nsMsgDBFolder::SetJunkScoreForMessages(aMessages, aJunkScore);
  if (NS_SUCCEEDED(rv)) {
    nsAutoCString messageIds;
    nsTArray<nsMsgKey> keys;
    nsresult rv = BuildIdsAndKeyArray(aMessages, messageIds, keys);
    NS_ENSURE_SUCCESS(rv, rv);
    StoreCustomKeywords(
        nullptr, aJunkScore.EqualsLiteral("0") ? "NonJunk"_ns : "Junk"_ns,
        aJunkScore.EqualsLiteral("0") ? "Junk"_ns : "NonJunk"_ns, keys,
        nullptr);
    if (mDatabase) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
  }
  return rv;
}

NS_IMETHODIMP
nsImapMailFolder::OnMessageClassified(const nsACString& aMsgURI,
                                      nsMsgJunkStatus aClassification,
                                      uint32_t aJunkPercent) {
  nsCOMPtr<nsIMsgIncomingServer> server;
  nsresult rv = GetServer(getter_AddRefs(server));
  NS_ENSURE_SUCCESS(rv, rv);

  if (!aMsgURI.IsEmpty())  // not end of batch
  {
    nsCOMPtr<nsIMsgDBHdr> msgHdr;
    rv = GetMsgDBHdrFromURI(aMsgURI, getter_AddRefs(msgHdr));
    NS_ENSURE_SUCCESS(rv, rv);

    nsMsgKey msgKey;
    rv = msgHdr->GetMessageKey(&msgKey);
    NS_ENSURE_SUCCESS(rv, rv);

    // check if this message needs junk classification

    uint32_t processingFlags;
    GetProcessingFlags(msgKey, &processingFlags);

    if (processingFlags & nsMsgProcessingFlags::ClassifyJunk) {
      nsMsgDBFolder::OnMessageClassified(aMsgURI, aClassification,
                                         aJunkPercent);

      GetMoveCoalescer();
      if (m_moveCoalescer) {
        nsTArray<nsMsgKey>* keysToClassify = m_moveCoalescer->GetKeyBucket(
            (aClassification == nsIJunkMailPlugin::JUNK) ? 0 : 1);
        NS_ASSERTION(keysToClassify, "error getting key bucket");
        if (keysToClassify) keysToClassify->AppendElement(msgKey);
      }
      if (aClassification == nsIJunkMailPlugin::JUNK) {
        nsCOMPtr<nsISpamSettings> spamSettings;
        rv = server->GetSpamSettings(getter_AddRefs(spamSettings));
        NS_ENSURE_SUCCESS(rv, rv);

        bool markAsReadOnSpam;
        (void)spamSettings->GetMarkAsReadOnSpam(&markAsReadOnSpam);
        if (markAsReadOnSpam) {
          m_junkMessagesToMarkAsRead.AppendElement(msgHdr);
        }

        bool willMoveMessage = false;

        // don't do the move when we are opening up
        // the junk mail folder or the trash folder
        // or when manually classifying messages in those folders
        if (!(mFlags & nsMsgFolderFlags::Junk ||
              mFlags & nsMsgFolderFlags::Trash)) {
          bool moveOnSpam;
          (void)spamSettings->GetMoveOnSpam(&moveOnSpam);
          if (moveOnSpam) {
            nsCString spamFolderURI;
            rv = spamSettings->GetSpamFolderURI(spamFolderURI);
            NS_ENSURE_SUCCESS(rv, rv);

            if (!spamFolderURI.IsEmpty()) {
              rv = FindFolder(spamFolderURI, getter_AddRefs(mSpamFolder));
              NS_ENSURE_SUCCESS(rv, rv);
              if (mSpamFolder) {
                rv = mSpamFolder->SetFlag(nsMsgFolderFlags::Junk);
                NS_ENSURE_SUCCESS(rv, rv);
                mSpamKeysToMove.AppendElement(msgKey);
                willMoveMessage = true;
              } else {
                // XXX TODO
                // JUNK MAIL RELATED
                // the listener should do
                // rv = folder->SetFlag(nsMsgFolderFlags::Junk);
                // NS_ENSURE_SUCCESS(rv,rv);
                // if (NS_SUCCEEDED(GetMoveCoalescer())) {
                //   m_moveCoalescer->AddMove(folder, msgKey);
                //   willMoveMessage = true;
                // }
                rv = GetOrCreateJunkFolder(spamFolderURI,
                                           nullptr /* aListener */);
                NS_ASSERTION(NS_SUCCEEDED(rv), "GetOrCreateJunkFolder failed");
              }
            }
          }
        }
        rv = spamSettings->LogJunkHit(msgHdr, willMoveMessage);
        NS_ENSURE_SUCCESS(rv, rv);
      }
    }
  }

  else  // end of batch
  {
    // Parent will apply post bayes filters.
    nsMsgDBFolder::OnMessageClassified(EmptyCString(),
                                       nsIJunkMailPlugin::UNCLASSIFIED, 0);

    if (!m_junkMessagesToMarkAsRead.IsEmpty()) {
      rv = MarkMessagesRead(m_junkMessagesToMarkAsRead, true);
      NS_ENSURE_SUCCESS(rv, rv);
      m_junkMessagesToMarkAsRead.Clear();
    }
    if (!mSpamKeysToMove.IsEmpty()) {
      GetMoveCoalescer();
      for (uint32_t keyIndex = 0; keyIndex < mSpamKeysToMove.Length();
           keyIndex++) {
        // If an upstream filter moved this message, don't move it here.
        nsMsgKey msgKey = mSpamKeysToMove.ElementAt(keyIndex);
        nsMsgProcessingFlagType processingFlags;
        GetProcessingFlags(msgKey, &processingFlags);
        if (!(processingFlags & nsMsgProcessingFlags::FilterToMove)) {
          if (m_moveCoalescer && mSpamFolder)
            m_moveCoalescer->AddMove(mSpamFolder, msgKey);
        } else {
          // We don't need the FilterToMove flag anymore.
          AndProcessingFlags(msgKey, ~nsMsgProcessingFlags::FilterToMove);
        }
      }
      mSpamKeysToMove.Clear();
    }

    // Let's not hold onto the spam folder reference longer than necessary.
    mSpamFolder = nullptr;

    bool pendingMoves = m_moveCoalescer && m_moveCoalescer->HasPendingMoves();
    PlaybackCoalescedOperations();
    // If we are performing biff for this folder, tell the server object
    if ((!pendingMoves || !ShowPreviewText()) && m_performingBiff) {
      // we don't need to adjust the num new messages in this folder because
      // the playback moves code already did that.
      (void)PerformBiffNotifications();
      server->SetPerformingBiff(false);
      m_performingBiff = false;
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
nsImapMailFolder::GetShouldDownloadAllHeaders(bool* aResult) {
  NS_ENSURE_ARG_POINTER(aResult);
  *aResult = false;
  // for just the inbox, we check if the filter list has arbitrary headers.
  // for all folders, check if we have a spam plugin that requires all headers
  if (mFlags & nsMsgFolderFlags::Inbox) {
    nsCOMPtr<nsIMsgFilterList> filterList;
    nsresult rv = GetFilterList(nullptr, getter_AddRefs(filterList));
    NS_ENSURE_SUCCESS(rv, rv);

    rv = filterList->GetShouldDownloadAllHeaders(aResult);
    if (*aResult) return rv;
  }
  nsCOMPtr<nsIMsgFilterPlugin> filterPlugin;
  nsCOMPtr<nsIMsgIncomingServer> server;

  if (NS_SUCCEEDED(GetServer(getter_AddRefs(server))))
    server->GetSpamFilterPlugin(getter_AddRefs(filterPlugin));

  return (filterPlugin) ? filterPlugin->GetShouldDownloadAllHeaders(aResult)
                        : NS_OK;
}

void nsImapMailFolder::GetTrashFolderName(nsAString& aFolderName) {
  nsCOMPtr<nsIMsgIncomingServer> server;
  nsCOMPtr<nsIImapIncomingServer> imapServer;
  nsresult rv;
  rv = GetServer(getter_AddRefs(server));
  if (NS_FAILED(rv)) return;
  imapServer = do_QueryInterface(server, &rv);
  if (NS_FAILED(rv)) return;
  imapServer->GetTrashFolderName(aFolderName);
  return;
}
NS_IMETHODIMP nsImapMailFolder::FetchMsgPreviewText(
    nsTArray<nsMsgKey> const& aKeysToFetch, bool aLocalOnly,
    nsIUrlListener* aUrlListener, bool* aAsyncResults) {
  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 < aKeysToFetch.Length(); i++) {
    nsCOMPtr<nsIMsgDBHdr> msgHdr;
    nsCString prevBody;
    rv = GetMessageHeader(aKeysToFetch[i], getter_AddRefs(msgHdr));
    NS_ENSURE_SUCCESS(rv, rv);
    // ignore messages that already have a preview body.
    msgHdr->GetStringProperty("preview", 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, nullptr, getter_AddRefs(url));
    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;
      rv = GetOfflineFileStream(msgKey, &messageOffset, &messageSize,
                                getter_AddRefs(inputStream));
      NS_ENSURE_SUCCESS(rv, rv);
      rv = GetMsgPreviewTextFromStream(msgHdr, inputStream);
      NS_ENSURE_SUCCESS(rv, rv);
    } 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(
    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
    const nsACString& aKeywords) {
  nsresult rv = nsMsgDBFolder::AddKeywordsToMessages(aMessages, aKeywords);
  if (NS_SUCCEEDED(rv)) {
    nsAutoCString messageIds;
    nsTArray<nsMsgKey> keys;
    rv = BuildIdsAndKeyArray(aMessages, messageIds, keys);
    NS_ENSURE_SUCCESS(rv, rv);
    rv = StoreCustomKeywords(nullptr, aKeywords, EmptyCString(), keys, nullptr);
    if (mDatabase) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::RemoveKeywordsFromMessages(
    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages,
    const nsACString& aKeywords) {
  nsresult rv = nsMsgDBFolder::RemoveKeywordsFromMessages(aMessages, aKeywords);
  if (NS_SUCCEEDED(rv)) {
    nsAutoCString messageIds;
    nsTArray<nsMsgKey> keys;
    nsresult rv = BuildIdsAndKeyArray(aMessages, messageIds, keys);
    NS_ENSURE_SUCCESS(rv, rv);
    rv = StoreCustomKeywords(nullptr, EmptyCString(), aKeywords, keys, nullptr);
    if (mDatabase) mDatabase->Commit(nsMsgDBCommitType::kLargeCommit);
  }
  return rv;
}

NS_IMETHODIMP nsImapMailFolder::GetCustomIdentity(nsIMsgIdentity** aIdentity) {
  NS_ENSURE_ARG_POINTER(aIdentity);
  if (mFlags & nsMsgFolderFlags::ImapOtherUser) {
    nsresult rv;
    bool delegateOtherUsersFolders = false;
    nsCOMPtr<nsIPrefBranch> prefBranch(
        do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
    NS_ENSURE_SUCCESS(rv, rv);
    prefBranch->GetBoolPref("mail.imap.delegateOtherUsersFolders",
                            &delegateOtherUsersFolders);
    // if we're automatically delegating other user's folders, we need to
    // cons up an e-mail address for the other user. We do that by
    // taking the other user's name and the current user's domain name,
    // assuming they'll be the same. So, <otherUsersName>@<ourDomain>
    if (delegateOtherUsersFolders) {
      nsCOMPtr<nsIMsgIncomingServer> server = do_QueryReferent(mServer, &rv);
      NS_ENSURE_SUCCESS(rv, rv);
      nsCOMPtr<nsIMsgAccountManager> accountManager =
          do_GetService(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()));
        nsTArray<RefPtr<nsIMsgIdentity>> identities;
        rv = accountManager->GetIdentitiesForServer(server, identities);
        NS_ENSURE_SUCCESS(rv, rv);

        for (auto identity : identities) {
          if (!identity) continue;
          nsCString identityEmail;
          identity->GetEmail(identityEmail);
          if (identityEmail.Equals(otherUsersEmailAddress)) {
            retIdentity = identity;
            break;
          }
        }
        if (!retIdentity) {
          // create the identity
          rv = accountManager->CreateIdentity(getter_AddRefs(retIdentity));
          NS_ENSURE_SUCCESS(rv, rv);
          retIdentity->SetEmail(otherUsersEmailAddress);
          nsCOMPtr<nsIMsgAccount> account;
          accountManager->FindAccountForServer(server, getter_AddRefs(account));
          NS_ENSURE_SUCCESS(rv, rv);
          account->AddIdentity(retIdentity);
        }
      }
      if (retIdentity) {
        retIdentity.forget(aIdentity);
        return NS_OK;
      }
    }
  }
  return nsMsgDBFolder::GetCustomIdentity(aIdentity);
}

NS_IMETHODIMP nsImapMailFolder::ChangePendingTotal(int32_t aDelta) {
  ChangeNumPendingTotalMessages(aDelta);
  if (aDelta > 0) NotifyHasPendingMsgs();
  return NS_OK;
}

void nsImapMailFolder::NotifyHasPendingMsgs() {
  InitAutoSyncState();
  nsresult rv;
  nsCOMPtr<nsIAutoSyncManager> autoSyncMgr =
      do_GetService(NS_AUTOSYNCMANAGER_CONTRACTID, &rv);
  if (NS_SUCCEEDED(rv)) autoSyncMgr->OnFolderHasPendingMsgs(m_autoSyncStateObj);
}

/* void changePendingUnread (in long aDelta); */
NS_IMETHODIMP nsImapMailFolder::ChangePendingUnread(int32_t aDelta) {
  ChangeNumPendingUnread(aDelta);
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::GetServerRecent(int32_t* aServerRecent) {
  NS_ENSURE_ARG_POINTER(aServerRecent);
  *aServerRecent = m_numServerRecentMessages;
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::GetServerTotal(int32_t* aServerTotal) {
  NS_ENSURE_ARG_POINTER(aServerTotal);
  *aServerTotal = m_numServerTotalMessages;
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::GetServerUnseen(int32_t* aServerUnseen) {
  NS_ENSURE_ARG_POINTER(aServerUnseen);
  *aServerUnseen = m_numServerUnseenMessages;
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::GetServerNextUID(int32_t* aNextUID) {
  NS_ENSURE_ARG_POINTER(aNextUID);
  *aNextUID = m_nextUID;
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::GetAutoSyncStateObj(
    nsIAutoSyncState** autoSyncStateObj) {
  NS_ENSURE_ARG_POINTER(autoSyncStateObj);

  // create auto-sync state object lazily
  InitAutoSyncState();

  NS_IF_ADDREF(*autoSyncStateObj = m_autoSyncStateObj);
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::InitiateAutoSync(nsIUrlListener* aUrlListener) {
  nsCString folderName;
  GetURI(folderName);
  MOZ_LOG(gAutoSyncLog, mozilla::LogLevel::Debug,
          ("Updating folder: %s", 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", 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].EqualsLiteral("\"\\\\Draft\""))
            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Drafts,
                                                getter_AddRefs(subMsgFolder));
          if (labelNames[i].EqualsLiteral("\"\\\\Inbox\""))
            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox,
                                                getter_AddRefs(subMsgFolder));
          if (labelNames[i].EqualsLiteral("\"\\\\All Mail\""))
            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Archive,
                                                getter_AddRefs(subMsgFolder));
          if (labelNames[i].EqualsLiteral("\"\\\\Trash\""))
            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Trash,
                                                getter_AddRefs(subMsgFolder));
          if (labelNames[i].EqualsLiteral("\"\\\\Spam\""))
            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Junk,
                                                getter_AddRefs(subMsgFolder));
          if (labelNames[i].EqualsLiteral("\"\\\\Sent\""))
            rv = rootFolder->GetFolderWithFlags(nsMsgFolderFlags::SentMail,
                                                getter_AddRefs(subMsgFolder));
          if (labelNames[i].Find("[Imap]/", /* ignoreCase = */ true) !=
              kNotFound) {
            labelNames[i].ReplaceSubstring("[Imap]/", "");
            imapRootFolder->FindOnlineSubFolder(labelNames[i],
                                                getter_AddRefs(subFolder));
            subMsgFolder = do_QueryInterface(subFolder);
          }
          if (!subMsgFolder) {
            imapRootFolder->FindOnlineSubFolder(labelNames[i],
                                                getter_AddRefs(subFolder));
            subMsgFolder = do_QueryInterface(subFolder);
          }
          if (subMsgFolder) {
            nsCOMPtr<nsIMsgDatabase> db;
            subMsgFolder->GetMsgDatabase(getter_AddRefs(db));
            if (db) {
              nsCOMPtr<nsIMsgDBHdr> retHdr;
              nsCString gmMsgID;
              hdr->GetStringProperty("X-GM-MSGID", 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));
  NS_ENSURE_SUCCESS(rv, rv);

  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));
  NS_ENSURE_SUCCESS(rv, rv);
  if (!hdr) {
    return NS_ERROR_FAILURE;
  }

  nsMsgKey newMsgKey;
  hdr->GetMessageKey(&newMsgKey);
  return offlineFolder->GetOfflineFileStream(newMsgKey, offset, size,
                                             aFileStream);
}

NS_IMETHODIMP nsImapMailFolder::GetIncomingServerType(nsACString& serverType) {
  serverType.AssignLiteral("imap");
  return NS_OK;
}

NS_IMETHODIMP nsImapMailFolder::GetShouldUseUtf8FolderName(bool* aUseUTF8) {
  *aUseUTF8 = false;
  nsCOMPtr<nsIMsgIncomingServer> server;
  nsresult rv = GetServer(getter_AddRefs(server));
  NS_ENSURE_SUCCESS(rv, rv);
  nsCOMPtr<nsIImapIncomingServer> imapServer = do_QueryInterface(server, &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  imapServer->GetUtf8AcceptEnabled(aUseUTF8);
  return NS_OK;
}

void nsImapMailFolder::DeleteStoreMessages(
    const nsTArray<RefPtr<nsIMsgDBHdr>>& aMessages) {
  // Delete messages for pluggable stores that do not support compaction.
  nsCOMPtr<nsIMsgPluggableStore> offlineStore;
  (void)GetMsgStore(getter_AddRefs(offlineStore));

  if (offlineStore) {
    bool supportsCompaction;
    offlineStore->GetSupportsCompaction(&supportsCompaction);
    if (!supportsCompaction) offlineStore->DeleteMessages(aMessages);
  }
}

void nsImapMailFolder::DeleteStoreMessages(
    const nsTArray<nsMsgKey>& aMessages) {
  DeleteStoreMessages(aMessages, this);
}

void nsImapMailFolder::DeleteStoreMessages(const nsTArray<nsMsgKey>& aMessages,
                                           nsIMsgFolder* aFolder) {
  // Delete messages for pluggable stores that do not support compaction.
  NS_ASSERTION(aFolder, "Missing Source Folder");
  nsCOMPtr<nsIMsgPluggableStore> offlineStore;
  (void)aFolder->GetMsgStore(getter_AddRefs(offlineStore));
  if (offlineStore) {
    bool supportsCompaction;
    offlineStore->GetSupportsCompaction(&supportsCompaction);
    if (!supportsCompaction) {
      nsCOMPtr<nsIMsgDatabase> db;
      aFolder->GetMsgDatabase(getter_AddRefs(db));
      nsresult rv = NS_ERROR_FAILURE;
      nsTArray<RefPtr<nsIMsgDBHdr>> messages;
      if (db) rv = MsgGetHeadersFromKeys(db, aMessages, messages);
      if (NS_SUCCEEDED(rv))
        offlineStore->DeleteMessages(messages);
      else
        NS_WARNING("Failed to get database");
    }
  }
}