path: root/comm/mailnews/base/src/nsMessenger.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 "prsystem.h"

#include "nsMessenger.h"

// xpcom
#include "nsIComponentManager.h"
#include "nsIServiceManager.h"
#include "nsIStringStream.h"
#include "nsLocalFile.h"
#include "nsDirectoryServiceDefs.h"
#include "nsQuickSort.h"
#include "nsNativeCharsetUtils.h"
#include "mozilla/Path.h"
#include "mozilla/Components.h"
#include "mozilla/dom/LoadURIOptionsBinding.h"

// necko
#include "nsMimeTypes.h"
#include "nsIURL.h"
#include "nsIPrompt.h"
#include "nsIStreamListener.h"
#include "nsIStreamConverterService.h"
#include "nsNetUtil.h"
#include "nsIFileURL.h"
#include "nsIMIMEInfo.h"

// gecko
#include "nsLayoutCID.h"
#include "nsIContentViewer.h"

/* for access to docshell */
#include "nsPIDOMWindow.h"
#include "nsIDocShell.h"
#include "nsIDocShellTreeItem.h"
#include "nsIWebNavigation.h"
#include "nsContentUtils.h"
#include "nsDocShellLoadState.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/XULFrameElement.h"
#include "nsFrameLoader.h"
#include "mozilla/dom/Document.h"

// mail
#include "nsIMsgMailNewsUrl.h"
#include "nsIMsgAccountManager.h"
#include "nsIMsgMailSession.h"
#include "nsIMailboxUrl.h"
#include "nsIMsgFolder.h"
#include "nsMsgMessageFlags.h"
#include "nsIMsgIncomingServer.h"

#include "nsIMsgMessageService.h"

#include "nsIMsgHdr.h"
// compose
#include "nsNativeCharsetUtils.h"

// draft/folders/sendlater/etc
#include "nsIMsgCopyService.h"
#include "nsIMsgCopyServiceListener.h"
#include "nsIUrlListener.h"
#include "UrlListener.h"

// undo
#include "nsITransaction.h"
#include "nsMsgTxn.h"

// charset conversions
#include "nsIMimeConverter.h"

// Save As
#include "nsIStringBundle.h"
#include "nsIPrefService.h"
#include "nsIPrefBranch.h"
#include "nsCExternalHandlerService.h"
#include "nsIExternalProtocolService.h"
#include "nsIMIMEService.h"
#include "nsITransfer.h"

#define MESSENGER_SAVE_DIR_PREF_NAME "messenger.save.dir"
#define MIMETYPE_DELETED "text/x-moz-deleted"
#define ATTACHMENT_PERMISSION 00664

//
// Convert an nsString buffer to plain text...
//
#include "nsMsgUtils.h"
#include "nsCharsetSource.h"
#include "nsIChannel.h"
#include "nsIOutputStream.h"
#include "nsIPrincipal.h"

#include "mozilla/dom/BrowserParent.h"
#include "mozilla/dom/CanonicalBrowsingContext.h"

#include "mozilla/NullPrincipal.h"
#include "mozilla/dom/RemoteType.h"
#include "nsQueryObject.h"
#include "mozilla/JSONStringWriteFuncs.h"

using namespace mozilla;
using namespace mozilla::dom;

static void ConvertAndSanitizeFileName(const nsACString& displayName,
                                       nsString& aResult) {
  nsCString unescapedName;

  /* we need to convert the UTF-8 fileName to platform specific character set.
     The display name is in UTF-8 because it has been escaped from JS
  */
  MsgUnescapeString(displayName, 0, unescapedName);
  CopyUTF8toUTF16(unescapedName, aResult);

  // replace platform specific path separator and illegale characters to avoid
  // any confusion
  aResult.ReplaceChar(u"" FILE_PATH_SEPARATOR FILE_ILLEGAL_CHARACTERS, u'-');
}

// ***************************************************
// jefft - this is a rather obscured class serves for Save Message As File,
// Save Message As Template, and Save Attachment to a file
// It's used to save out a single item. If multiple items are to be saved,
// a nsSaveAllAttachmentsState should be set, which holds a list of items.
//
class nsSaveAllAttachmentsState;

class nsSaveMsgListener : public nsIUrlListener,
                          public nsIMsgCopyServiceListener,
                          public nsIStreamListener,
                          public nsICancelable {
  using PathChar = mozilla::filesystem::Path::value_type;

 public:
  nsSaveMsgListener(nsIFile* file, nsMessenger* aMessenger,
                    nsIUrlListener* aListener);

  NS_DECL_ISUPPORTS

  NS_DECL_NSIURLLISTENER
  NS_DECL_NSIMSGCOPYSERVICELISTENER
  NS_DECL_NSISTREAMLISTENER
  NS_DECL_NSIREQUESTOBSERVER
  NS_DECL_NSICANCELABLE

  nsCOMPtr<nsIFile> m_file;
  nsCOMPtr<nsIOutputStream> m_outputStream;
  char m_dataBuffer[FILE_IO_BUFFER_SIZE];
  nsCOMPtr<nsIChannel> m_channel;
  nsCString m_templateUri;
  RefPtr<nsMessenger> m_messenger;
  nsSaveAllAttachmentsState* m_saveAllAttachmentsState;

  // rhp: For character set handling
  bool m_doCharsetConversion;
  nsString m_charset;
  enum { eUnknown, ePlainText, eHTML } m_outputFormat;
  nsCString m_msgBuffer;

  nsCString m_contentType;  // used only when saving attachment

  nsCOMPtr<nsITransfer> mTransfer;
  nsCOMPtr<nsIUrlListener> mListener;
  nsCOMPtr<nsIURI> mListenerUri;
  int64_t mProgress;
  int64_t mMaxProgress;
  bool mCanceled;
  bool mInitialized;
  bool mUrlHasStopped;
  bool mRequestHasStopped;
  nsresult InitializeDownload(nsIRequest* aRequest);

 private:
  virtual ~nsSaveMsgListener();
};

// This helper class holds a list of attachments to be saved and (optionally)
// detached. It's used by nsSaveMsgListener (which only sticks around for a
// single item, then passes the nsSaveAllAttachmentsState along to the next
// SaveAttachment() call).
class nsSaveAllAttachmentsState {
  using PathChar = mozilla::filesystem::Path::value_type;

 public:
  nsSaveAllAttachmentsState(const nsTArray<nsCString>& contentTypeArray,
                            const nsTArray<nsCString>& urlArray,
                            const nsTArray<nsCString>& displayNameArray,
                            const nsTArray<nsCString>& messageUriArray,
                            const PathChar* directoryName,
                            bool detachingAttachments,
                            nsIUrlListener* overallListener);
  virtual ~nsSaveAllAttachmentsState();

  uint32_t m_count;
  uint32_t m_curIndex;
  PathChar* m_directoryName;
  nsTArray<nsCString> m_contentTypeArray;
  nsTArray<nsCString> m_urlArray;
  nsTArray<nsCString> m_displayNameArray;
  nsTArray<nsCString> m_messageUriArray;
  bool m_detachingAttachments;
  // The listener to invoke when all the items have been saved.
  nsCOMPtr<nsIUrlListener> m_overallListener;
  // if detaching, do without warning? Will create unique files instead of
  // prompting if duplicate files exist.
  bool m_withoutWarning;
  // if detaching first, remember where we saved to.
  nsTArray<nsCString> m_savedFiles;
};

//
// nsMessenger
//
nsMessenger::nsMessenger() {}

nsMessenger::~nsMessenger() {}

NS_IMPL_ISUPPORTS(nsMessenger, nsIMessenger, nsISupportsWeakReference)

NS_IMETHODIMP nsMessenger::SetWindow(mozIDOMWindowProxy* aWin,
                                     nsIMsgWindow* aMsgWindow) {
  nsresult rv;

  nsCOMPtr<nsIMsgMailSession> mailSession =
      do_GetService("@mozilla.org/messenger/services/session;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  if (aWin) {
    aMsgWindow->GetTransactionManager(getter_AddRefs(mTxnMgr));
    mMsgWindow = aMsgWindow;
    mWindow = aWin;

    NS_ENSURE_TRUE(aWin, NS_ERROR_FAILURE);
    nsCOMPtr<nsPIDOMWindowOuter> win = nsPIDOMWindowOuter::From(aWin);
    mDocShell = win->GetDocShell();
  } else {
    mWindow = nullptr;
    mDocShell = nullptr;
  }

  return NS_OK;
}

NS_IMPL_ISUPPORTS(nsMessenger::nsFilePickerShownCallback,
                  nsIFilePickerShownCallback)
nsMessenger::nsFilePickerShownCallback::nsFilePickerShownCallback() {
  mResult = nsIFilePicker::returnOK;
  mPickerDone = false;
}

NS_IMETHODIMP
nsMessenger::nsFilePickerShownCallback::Done(
    nsIFilePicker::ResultCode aResult) {
  mResult = aResult;
  mPickerDone = true;
  return NS_OK;
}

nsresult nsMessenger::ShowPicker(nsIFilePicker* aPicker,
                                 nsIFilePicker::ResultCode* aResult) {
  nsCOMPtr<nsIFilePickerShownCallback> callback =
      new nsMessenger::nsFilePickerShownCallback();
  nsFilePickerShownCallback* cb =
      static_cast<nsFilePickerShownCallback*>(callback.get());

  nsresult rv;
  rv = aPicker->Open(callback);
  NS_ENSURE_SUCCESS(rv, rv);

  // Spin the event loop until the callback was called.
  nsCOMPtr<nsIThread> thread(do_GetCurrentThread());
  while (!cb->mPickerDone) {
    NS_ProcessNextEvent(thread, true);
  }

  *aResult = cb->mResult;
  return NS_OK;
}

nsresult nsMessenger::PromptIfFileExists(nsIFile* file) {
  nsresult rv = NS_ERROR_FAILURE;
  bool exists;
  file->Exists(&exists);
  if (!exists) return NS_OK;

  nsCOMPtr<nsIPrompt> dialog(do_GetInterface(mDocShell));
  if (!dialog) return rv;
  nsAutoString path;
  bool dialogResult = false;
  nsString errorMessage;

  file->GetPath(path);
  AutoTArray<nsString, 1> pathFormatStrings = {path};

  if (!mStringBundle) {
    rv = InitStringBundle();
    NS_ENSURE_SUCCESS(rv, rv);
  }
  rv = mStringBundle->FormatStringFromName("fileExists", pathFormatStrings,
                                           errorMessage);
  NS_ENSURE_SUCCESS(rv, rv);
  rv = dialog->Confirm(nullptr, errorMessage.get(), &dialogResult);
  NS_ENSURE_SUCCESS(rv, rv);

  if (dialogResult) return NS_OK;  // user says okay to replace

  // if we don't re-init the path for redisplay the picker will
  // show the full path, not just the file name
  nsCOMPtr<nsIFile> currentFile =
      do_CreateInstance("@mozilla.org/file/local;1");
  if (!currentFile) return NS_ERROR_FAILURE;

  rv = currentFile->InitWithPath(path);
  NS_ENSURE_SUCCESS(rv, rv);

  nsAutoString leafName;
  currentFile->GetLeafName(leafName);
  if (!leafName.IsEmpty())
    path.Assign(leafName);  // path should be a copy of leafName

  nsCOMPtr<nsIFilePicker> filePicker =
      do_CreateInstance("@mozilla.org/filepicker;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  nsString saveAttachmentStr;
  GetString(u"SaveAttachment"_ns, saveAttachmentStr);
  filePicker->Init(mWindow, saveAttachmentStr, nsIFilePicker::modeSave);
  filePicker->SetDefaultString(path);
  filePicker->AppendFilters(nsIFilePicker::filterAll);

  nsCOMPtr<nsIFile> lastSaveDir;
  rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
  if (NS_SUCCEEDED(rv) && lastSaveDir) {
    filePicker->SetDisplayDirectory(lastSaveDir);
  }

  nsIFilePicker::ResultCode dialogReturn;
  rv = ShowPicker(filePicker, &dialogReturn);
  if (NS_FAILED(rv) || dialogReturn == nsIFilePicker::returnCancel) {
    // XXX todo
    // don't overload the return value like this
    // change this function to have an out boolean
    // that we check to see if the user cancelled
    return NS_ERROR_FAILURE;
  }

  nsCOMPtr<nsIFile> localFile;

  rv = filePicker->GetFile(getter_AddRefs(localFile));
  NS_ENSURE_SUCCESS(rv, rv);

  rv = SetLastSaveDirectory(localFile);
  NS_ENSURE_SUCCESS(rv, rv);

  // reset the file to point to the new path
  return file->InitWithFile(localFile);
}

NS_IMETHODIMP nsMessenger::SaveAttachmentToFile(nsIFile* aFile,
                                                const nsACString& aURL,
                                                const nsACString& aMessageUri,
                                                const nsACString& aContentType,
                                                nsIUrlListener* aListener) {
  return SaveAttachment(aFile, aURL, aMessageUri, aContentType, nullptr,
                        aListener);
}

NS_IMETHODIMP
nsMessenger::DetachAttachmentsWOPrompts(
    nsIFile* aDestFolder, const nsTArray<nsCString>& aContentTypeArray,
    const nsTArray<nsCString>& aUrlArray,
    const nsTArray<nsCString>& aDisplayNameArray,
    const nsTArray<nsCString>& aMessageUriArray, nsIUrlListener* aListener) {
  NS_ENSURE_ARG_POINTER(aDestFolder);
  MOZ_ASSERT(aContentTypeArray.Length() == aUrlArray.Length() &&
             aUrlArray.Length() == aDisplayNameArray.Length() &&
             aDisplayNameArray.Length() == aMessageUriArray.Length());

  if (!aContentTypeArray.Length()) return NS_OK;
  nsCOMPtr<nsIFile> attachmentDestination;
  nsresult rv = aDestFolder->Clone(getter_AddRefs(attachmentDestination));
  NS_ENSURE_SUCCESS(rv, rv);

  PathString path = attachmentDestination->NativePath();

  nsAutoString unescapedFileName;
  ConvertAndSanitizeFileName(aDisplayNameArray[0], unescapedFileName);
  rv = attachmentDestination->Append(unescapedFileName);
  NS_ENSURE_SUCCESS(rv, rv);
  rv = attachmentDestination->CreateUnique(nsIFile::NORMAL_FILE_TYPE,
                                           ATTACHMENT_PERMISSION);
  NS_ENSURE_SUCCESS(rv, rv);

  // Set up to detach the attachments once they've been saved out.
  // NOTE: nsSaveAllAttachmentsState has a detach option, but I'd like to
  // phase it out, so we set up a listener to call DetachAttachments()
  // instead.
  UrlListener* listener = new UrlListener;
  nsSaveAllAttachmentsState* saveState = new nsSaveAllAttachmentsState(
      aContentTypeArray, aUrlArray, aDisplayNameArray, aMessageUriArray,
      path.get(),
      false,  // detach = false
      listener);

  // Note: saveState is kept in existence by SaveAttachment() until after
  // the last item is saved.
  listener->mStopFn = [saveState, self = RefPtr<nsMessenger>(this),
                       originalListener = nsCOMPtr<nsIUrlListener>(aListener)](
                          nsIURI* url, nsresult status) -> nsresult {
    if (NS_SUCCEEDED(status)) {
      status = self->DetachAttachments(
          saveState->m_contentTypeArray, saveState->m_urlArray,
          saveState->m_displayNameArray, saveState->m_messageUriArray,
          &saveState->m_savedFiles, originalListener,
          saveState->m_withoutWarning);
    }
    if (NS_FAILED(status) && originalListener) {
      return originalListener->OnStopRunningUrl(nullptr, status);
    }
    return NS_OK;
  };

  // This method is used in filters, where we don't want to warn
  saveState->m_withoutWarning = true;

  rv = SaveAttachment(attachmentDestination, aUrlArray[0], aMessageUriArray[0],
                      aContentTypeArray[0], saveState, nullptr);
  return rv;
}

// Internal helper for Saving attachments.
// It handles a single attachment, but multiple attachments can be saved
// by passing in an nsSaveAllAttachmentsState. In this case, SaveAttachment()
// will be called for each attachment, and the saveState keeps track of which
// one we're up to.
//
// aListener is invoked to cover this single attachment save.
// If a saveState is used, it can also contain a nsIUrlListener which
// will be invoked when _all_ the saves are complete.
//
// SaveAttachment() takes ownership of the saveState passed in.
// If SaveAttachment() fails, then
// saveState->m_overallListener->OnStopRunningUrl()
// will be invoked and saveState itself will be deleted.
//
// Even though SaveAttachment() takes ownership of saveState,
// nsSaveMsgListener is responsible for finally deleting it when the
// last save operation successfully completes.
//
// Yes, this is convoluted. Bug 1788159 covers simplifying all this stuff.
nsresult nsMessenger::SaveAttachment(nsIFile* aFile, const nsACString& aURL,
                                     const nsACString& aMessageUri,
                                     const nsACString& aContentType,
                                     nsSaveAllAttachmentsState* saveState,
                                     nsIUrlListener* aListener) {
  nsCOMPtr<nsIMsgMessageService> messageService;
  nsCOMPtr<nsIMsgMessageFetchPartService> fetchService;
  nsAutoCString urlString;
  nsAutoCString fullMessageUri(aMessageUri);

  nsresult rv = NS_OK;

  // This instance will be held onto by the listeners, and will be released once
  // the transfer has been completed.
  RefPtr<nsSaveMsgListener> saveListener(
      new nsSaveMsgListener(aFile, this, aListener));

  saveListener->m_contentType = aContentType;
  if (saveState) {
    if (saveState->m_overallListener && saveState->m_curIndex == 0) {
      // This is the first item, so tell the caller we're starting.
      saveState->m_overallListener->OnStartRunningUrl(nullptr);
    }
    saveListener->m_saveAllAttachmentsState = saveState;
    // Record the resultant file:// URL for each saved attachment as we go
    // along. It'll be used later if we want to also detach them from the email.
    // Placeholder text will be inserted into the email to replace the
    // removed attachment pointing at it's final resting place.
    nsCOMPtr<nsIURI> outputURI;
    rv = NS_NewFileURI(getter_AddRefs(outputURI), aFile);
    if (NS_SUCCEEDED(rv)) {
      nsAutoCString fileUriSpec;
      rv = outputURI->GetSpec(fileUriSpec);
      if NS_SUCCEEDED (rv) {
        saveState->m_savedFiles.AppendElement(fileUriSpec);
      }
    }
  }

  nsCOMPtr<nsIURI> URL;
  if (NS_SUCCEEDED(rv)) {
    urlString = aURL;
    // strip out ?type=application/x-message-display because it confuses libmime

    int32_t typeIndex = urlString.Find("?type=application/x-message-display");
    if (typeIndex != kNotFound) {
      urlString.Cut(typeIndex,
                    sizeof("?type=application/x-message-display") - 1);
      // we also need to replace the next '&' with '?'
      int32_t firstPartIndex = urlString.FindChar('&');
      if (firstPartIndex != kNotFound) urlString.SetCharAt('?', firstPartIndex);
    }

    urlString.ReplaceSubstring("/;section", "?section");
    rv = NS_NewURI(getter_AddRefs(URL), urlString);
  }

  if (NS_SUCCEEDED(rv)) {
    rv = GetMessageServiceFromURI(aMessageUri, getter_AddRefs(messageService));
    if (NS_SUCCEEDED(rv)) {
      fetchService = do_QueryInterface(messageService);
      // if the message service has a fetch part service then we know we can
      // fetch mime parts...
      if (fetchService) {
        int32_t partPos = urlString.FindChar('?');
        if (partPos == kNotFound) return NS_ERROR_FAILURE;
        fullMessageUri.Append(Substring(urlString, partPos));
      }

      nsCOMPtr<nsIStreamListener> convertedListener;
      saveListener->QueryInterface(NS_GET_IID(nsIStreamListener),
                                   getter_AddRefs(convertedListener));

      nsCOMPtr<nsIURI> dummyNull;
      if (fetchService)
        rv = fetchService->FetchMimePart(URL, fullMessageUri, convertedListener,
                                         mMsgWindow, saveListener,
                                         getter_AddRefs(dummyNull));
      else
        rv = messageService->LoadMessage(fullMessageUri, convertedListener,
                                         mMsgWindow, nullptr, false);
    }  // if we got a message service
  }    // if we created a url

  if (NS_FAILED(rv)) {
    if (saveState) {
      // If we had a listener, make sure it sees the failure!
      if (saveState->m_overallListener) {
        saveState->m_overallListener->OnStopRunningUrl(nullptr, rv);
      }
      // Ugh. Ownership is all over the place here!
      // Usually nsSaveMsgListener is responsible for cleaning up
      // nsSaveAllAttachmentsState... but we're not getting
      // that far, so have to clean it up here!
      delete saveState;
      saveListener->m_saveAllAttachmentsState = nullptr;
    }
    Alert("saveAttachmentFailed");
  }
  return rv;
}

NS_IMETHODIMP
nsMessenger::SaveAttachmentToFolder(const nsACString& contentType,
                                    const nsACString& url,
                                    const nsACString& displayName,
                                    const nsACString& messageUri,
                                    nsIFile* aDestFolder, nsIFile** aOutFile) {
  NS_ENSURE_ARG_POINTER(aDestFolder);
  nsresult rv;

  nsCOMPtr<nsIFile> attachmentDestination;
  rv = aDestFolder->Clone(getter_AddRefs(attachmentDestination));
  NS_ENSURE_SUCCESS(rv, rv);

  nsString unescapedFileName;
  ConvertAndSanitizeFileName(displayName, unescapedFileName);
  rv = attachmentDestination->Append(unescapedFileName);
  NS_ENSURE_SUCCESS(rv, rv);
#ifdef XP_MACOSX
  rv = attachmentDestination->CreateUnique(nsIFile::NORMAL_FILE_TYPE,
                                           ATTACHMENT_PERMISSION);
  NS_ENSURE_SUCCESS(rv, rv);
#endif

  rv = SaveAttachment(attachmentDestination, url, messageUri, contentType,
                      nullptr, nullptr);
  attachmentDestination.forget(aOutFile);
  return rv;
}

NS_IMETHODIMP
nsMessenger::SaveAttachment(const nsACString& aContentType,
                            const nsACString& aURL,
                            const nsACString& aDisplayName,
                            const nsACString& aMessageUri,
                            bool aIsExternalAttachment) {
  return SaveOneAttachment(aContentType, aURL, aDisplayName, aMessageUri,
                           false);
}

nsresult nsMessenger::SaveOneAttachment(const nsACString& aContentType,
                                        const nsACString& aURL,
                                        const nsACString& aDisplayName,
                                        const nsACString& aMessageUri,
                                        bool detaching) {
  nsresult rv = NS_ERROR_OUT_OF_MEMORY;
  nsCOMPtr<nsIFilePicker> filePicker =
      do_CreateInstance("@mozilla.org/filepicker;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsIFilePicker::ResultCode dialogResult;
  nsCOMPtr<nsIFile> localFile;
  nsCOMPtr<nsIFile> lastSaveDir;
  nsCString filePath;
  nsString saveAttachmentStr;
  nsString defaultDisplayString;
  ConvertAndSanitizeFileName(aDisplayName, defaultDisplayString);

  if (detaching) {
    GetString(u"DetachAttachment"_ns, saveAttachmentStr);
  } else {
    GetString(u"SaveAttachment"_ns, saveAttachmentStr);
  }
  filePicker->Init(mWindow, saveAttachmentStr, nsIFilePicker::modeSave);
  filePicker->SetDefaultString(defaultDisplayString);

  // Check if the attachment file name has an extension (which must not
  // contain spaces) and set it as the default extension for the attachment.
  int32_t extensionIndex = defaultDisplayString.RFindChar('.');
  if (extensionIndex > 0 &&
      defaultDisplayString.FindChar(' ', extensionIndex) == kNotFound) {
    nsString extension;
    extension = Substring(defaultDisplayString, extensionIndex + 1);
    filePicker->SetDefaultExtension(extension);
    if (!mStringBundle) {
      rv = InitStringBundle();
      NS_ENSURE_SUCCESS(rv, rv);
    }

    nsString filterName;
    AutoTArray<nsString, 1> extensionParam = {extension};
    rv = mStringBundle->FormatStringFromName("saveAsType", extensionParam,
                                             filterName);
    NS_ENSURE_SUCCESS(rv, rv);

    extension.InsertLiteral(u"*.", 0);
    filePicker->AppendFilter(filterName, extension);
  }

  filePicker->AppendFilters(nsIFilePicker::filterAll);

  rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
  if (NS_SUCCEEDED(rv) && lastSaveDir)
    filePicker->SetDisplayDirectory(lastSaveDir);

  rv = ShowPicker(filePicker, &dialogResult);
  if (NS_FAILED(rv) || dialogResult == nsIFilePicker::returnCancel) return rv;

  rv = filePicker->GetFile(getter_AddRefs(localFile));
  NS_ENSURE_SUCCESS(rv, rv);

  SetLastSaveDirectory(localFile);

  PathString dirName = localFile->NativePath();

  AutoTArray<nsCString, 1> contentTypeArray = {
      PromiseFlatCString(aContentType)};
  AutoTArray<nsCString, 1> urlArray = {PromiseFlatCString(aURL)};
  AutoTArray<nsCString, 1> displayNameArray = {
      PromiseFlatCString(aDisplayName)};
  AutoTArray<nsCString, 1> messageUriArray = {PromiseFlatCString(aMessageUri)};
  nsSaveAllAttachmentsState* saveState = new nsSaveAllAttachmentsState(
      contentTypeArray, urlArray, displayNameArray, messageUriArray,
      dirName.get(), detaching, nullptr);

  // SaveAttachment takes ownership of saveState.
  return SaveAttachment(localFile, aURL, aMessageUri, aContentType, saveState,
                        nullptr);
}

NS_IMETHODIMP
nsMessenger::SaveAllAttachments(const nsTArray<nsCString>& contentTypeArray,
                                const nsTArray<nsCString>& urlArray,
                                const nsTArray<nsCString>& displayNameArray,
                                const nsTArray<nsCString>& messageUriArray) {
  uint32_t len = contentTypeArray.Length();
  NS_ENSURE_TRUE(urlArray.Length() == len, NS_ERROR_INVALID_ARG);
  NS_ENSURE_TRUE(displayNameArray.Length() == len, NS_ERROR_INVALID_ARG);
  NS_ENSURE_TRUE(messageUriArray.Length() == len, NS_ERROR_INVALID_ARG);
  if (len == 0) {
    return NS_OK;
  }
  return SaveAllAttachments(contentTypeArray, urlArray, displayNameArray,
                            messageUriArray, false);
}

nsresult nsMessenger::SaveAllAttachments(
    const nsTArray<nsCString>& contentTypeArray,
    const nsTArray<nsCString>& urlArray,
    const nsTArray<nsCString>& displayNameArray,
    const nsTArray<nsCString>& messageUriArray, bool detaching) {
  nsresult rv = NS_ERROR_OUT_OF_MEMORY;
  nsCOMPtr<nsIFilePicker> filePicker =
      do_CreateInstance("@mozilla.org/filepicker;1", &rv);
  nsCOMPtr<nsIFile> localFile;
  nsCOMPtr<nsIFile> lastSaveDir;
  nsIFilePicker::ResultCode dialogResult;
  nsString saveAttachmentStr;

  NS_ENSURE_SUCCESS(rv, rv);
  if (detaching) {
    GetString(u"DetachAllAttachments"_ns, saveAttachmentStr);
  } else {
    GetString(u"SaveAllAttachments"_ns, saveAttachmentStr);
  }
  filePicker->Init(mWindow, saveAttachmentStr, nsIFilePicker::modeGetFolder);

  rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
  if (NS_SUCCEEDED(rv) && lastSaveDir)
    filePicker->SetDisplayDirectory(lastSaveDir);

  rv = ShowPicker(filePicker, &dialogResult);
  if (NS_FAILED(rv) || dialogResult == nsIFilePicker::returnCancel) return rv;

  rv = filePicker->GetFile(getter_AddRefs(localFile));
  NS_ENSURE_SUCCESS(rv, rv);

  rv = SetLastSaveDirectory(localFile);
  NS_ENSURE_SUCCESS(rv, rv);

  PathString dirName = localFile->NativePath();

  nsString unescapedName;
  ConvertAndSanitizeFileName(displayNameArray[0], unescapedName);
  rv = localFile->Append(unescapedName);
  NS_ENSURE_SUCCESS(rv, rv);

  rv = PromptIfFileExists(localFile);
  NS_ENSURE_SUCCESS(rv, rv);

  nsSaveAllAttachmentsState* saveState = new nsSaveAllAttachmentsState(
      contentTypeArray, urlArray, displayNameArray, messageUriArray,
      dirName.get(), detaching, nullptr);
  // SaveAttachment takes ownership of saveState.
  rv = SaveAttachment(localFile, urlArray[0], messageUriArray[0],
                      contentTypeArray[0], saveState, nullptr);
  return rv;
}

enum MESSENGER_SAVEAS_FILE_TYPE {
  EML_FILE_TYPE = 0,
  HTML_FILE_TYPE = 1,
  TEXT_FILE_TYPE = 2,
  ANY_FILE_TYPE = 3
};
#define HTML_FILE_EXTENSION ".htm"
#define HTML_FILE_EXTENSION2 ".html"
#define TEXT_FILE_EXTENSION ".txt"

/**
 * Adjust the file name, removing characters from the middle of the name if
 * the name would otherwise be too long - too long for what file systems
 * usually support.
 */
nsresult nsMessenger::AdjustFileIfNameTooLong(nsIFile* aFile) {
  NS_ENSURE_ARG_POINTER(aFile);
  nsAutoString path;
  nsresult rv = aFile->GetPath(path);
  NS_ENSURE_SUCCESS(rv, rv);
  // Most common file systems have a max filename length of 255. On windows, the
  // total path length is (at least for all practical purposees) limited to 255.
  // Let's just don't allow paths longer than that elsewhere either for
  // simplicity.
  uint32_t MAX = 255;
  if (path.Length() > MAX) {
    nsAutoString leafName;
    rv = aFile->GetLeafName(leafName);
    NS_ENSURE_SUCCESS(rv, rv);

    uint32_t pathLengthUpToLeaf = path.Length() - leafName.Length();
    if (pathLengthUpToLeaf >= MAX - 8) {  // want at least 8 chars for name
      return NS_ERROR_FILE_NAME_TOO_LONG;
    }
    uint32_t x = MAX - pathLengthUpToLeaf;  // x = max leaf size
    nsAutoString truncatedLeaf;
    truncatedLeaf.Append(Substring(leafName, 0, x / 2));
    truncatedLeaf.AppendLiteral("...");
    truncatedLeaf.Append(
        Substring(leafName, leafName.Length() - x / 2 + 3, leafName.Length()));
    rv = aFile->SetLeafName(truncatedLeaf);
  }
  return rv;
}

NS_IMETHODIMP
nsMessenger::SaveAs(const nsACString& aURI, bool aAsFile,
                    nsIMsgIdentity* aIdentity, const nsAString& aMsgFilename,
                    bool aBypassFilePicker) {
  nsCOMPtr<nsIMsgMessageService> messageService;
  nsCOMPtr<nsIUrlListener> urlListener;
  RefPtr<nsSaveMsgListener> saveListener;
  nsCOMPtr<nsIStreamListener> convertedListener;
  int32_t saveAsFileType = EML_FILE_TYPE;

  nsresult rv = GetMessageServiceFromURI(aURI, getter_AddRefs(messageService));
  if (NS_FAILED(rv)) goto done;

  if (aAsFile) {
    nsCOMPtr<nsIFile> saveAsFile;
    // show the file picker if BypassFilePicker is not specified (null) or false
    if (!aBypassFilePicker) {
      rv = GetSaveAsFile(aMsgFilename, &saveAsFileType,
                         getter_AddRefs(saveAsFile));
      // A null saveAsFile means that the user canceled the save as
      if (NS_FAILED(rv) || !saveAsFile) goto done;
    } else {
      saveAsFile = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
      rv = saveAsFile->InitWithPath(aMsgFilename);
      if (NS_FAILED(rv)) goto done;
      if (StringEndsWith(aMsgFilename,
                         NS_LITERAL_STRING_FROM_CSTRING(TEXT_FILE_EXTENSION),
                         nsCaseInsensitiveStringComparator))
        saveAsFileType = TEXT_FILE_TYPE;
      else if ((StringEndsWith(
                   aMsgFilename,
                   NS_LITERAL_STRING_FROM_CSTRING(HTML_FILE_EXTENSION),
                   nsCaseInsensitiveStringComparator)) ||
               (StringEndsWith(
                   aMsgFilename,
                   NS_LITERAL_STRING_FROM_CSTRING(HTML_FILE_EXTENSION2),
                   nsCaseInsensitiveStringComparator)))
        saveAsFileType = HTML_FILE_TYPE;
      else
        saveAsFileType = EML_FILE_TYPE;
    }

    rv = AdjustFileIfNameTooLong(saveAsFile);
    NS_ENSURE_SUCCESS(rv, rv);

    rv = PromptIfFileExists(saveAsFile);
    if (NS_FAILED(rv)) {
      goto done;
    }

    // After saveListener goes out of scope, the listener will be owned by
    // whoever the listener is registered with, usually a URL.
    saveListener = new nsSaveMsgListener(saveAsFile, this, nullptr);
    rv = saveListener->QueryInterface(NS_GET_IID(nsIUrlListener),
                                      getter_AddRefs(urlListener));
    if (NS_FAILED(rv)) goto done;

    if (saveAsFileType == EML_FILE_TYPE) {
      nsCOMPtr<nsIURI> dummyNull;
      rv = messageService->SaveMessageToDisk(
          aURI, saveAsFile, false, urlListener, getter_AddRefs(dummyNull), true,
          mMsgWindow);
    } else {
      nsAutoCString urlString(aURI);

      // we can't go RFC822 to TXT until bug #1775 is fixed
      // so until then, do the HTML to TXT conversion in
      // nsSaveMsgListener::OnStopRequest(), see ConvertBufToPlainText()
      //
      // Setup the URL for a "Save As..." Operation...
      // For now, if this is a save as TEXT operation, then do
      // a "printing" operation
      if (saveAsFileType == TEXT_FILE_TYPE) {
        saveListener->m_outputFormat = nsSaveMsgListener::ePlainText;
        saveListener->m_doCharsetConversion = true;
        urlString.AppendLiteral("?header=print");
      } else {
        saveListener->m_outputFormat = nsSaveMsgListener::eHTML;
        saveListener->m_doCharsetConversion = false;
        urlString.AppendLiteral("?header=saveas");
      }

      nsCOMPtr<nsIURI> url;
      rv = NS_NewURI(getter_AddRefs(url), urlString);
      NS_ASSERTION(NS_SUCCEEDED(rv), "NS_NewURI failed");
      if (NS_FAILED(rv)) goto done;

      nsCOMPtr<nsIPrincipal> nullPrincipal =
          NullPrincipal::CreateWithoutOriginAttributes();

      saveListener->m_channel = nullptr;
      rv = NS_NewInputStreamChannel(
          getter_AddRefs(saveListener->m_channel), url, nullptr, nullPrincipal,
          nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
          nsIContentPolicy::TYPE_OTHER);
      NS_ASSERTION(NS_SUCCEEDED(rv), "NS_NewChannel failed");
      if (NS_FAILED(rv)) goto done;

      nsCOMPtr<nsIStreamConverterService> streamConverterService =
          do_GetService("@mozilla.org/streamConverters;1");
      nsCOMPtr<nsISupports> channelSupport =
          do_QueryInterface(saveListener->m_channel);

      // we can't go RFC822 to TXT until bug #1775 is fixed
      // so until then, do the HTML to TXT conversion in
      // nsSaveMsgListener::OnStopRequest(), see ConvertBufToPlainText()
      rv = streamConverterService->AsyncConvertData(
          MESSAGE_RFC822, TEXT_HTML, saveListener, channelSupport,
          getter_AddRefs(convertedListener));
      NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncConvertData failed");
      if (NS_FAILED(rv)) goto done;

      rv = messageService->LoadMessage(urlString, convertedListener, mMsgWindow,
                                       nullptr, false);
    }
  } else {
    // ** save as Template
    nsCOMPtr<nsIFile> tmpFile;
    nsresult rv = GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR, "nsmail.tmp",
                                                  getter_AddRefs(tmpFile));

    NS_ENSURE_SUCCESS(rv, rv);

    // For temp file, we should use restrictive 00600 instead of
    // ATTACHMENT_PERMISSION
    rv = tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
    if (NS_FAILED(rv)) goto done;

    // The saveListener is owned by whoever we ultimately register the
    // listener with, generally a URL.
    saveListener = new nsSaveMsgListener(tmpFile, this, nullptr);

    if (aIdentity)
      rv = aIdentity->GetStationeryFolder(saveListener->m_templateUri);
    if (NS_FAILED(rv)) goto done;

    bool needDummyHeader =
        StringBeginsWith(saveListener->m_templateUri, "mailbox://"_ns);
    bool canonicalLineEnding =
        StringBeginsWith(saveListener->m_templateUri, "imap://"_ns);

    rv = saveListener->QueryInterface(NS_GET_IID(nsIUrlListener),
                                      getter_AddRefs(urlListener));
    if (NS_FAILED(rv)) goto done;

    nsCOMPtr<nsIURI> dummyNull;
    rv = messageService->SaveMessageToDisk(
        aURI, tmpFile, needDummyHeader, urlListener, getter_AddRefs(dummyNull),
        canonicalLineEnding, mMsgWindow);
  }

done:
  if (NS_FAILED(rv)) {
    Alert("saveMessageFailed");
  }
  return rv;
}

nsresult nsMessenger::GetSaveAsFile(const nsAString& aMsgFilename,
                                    int32_t* aSaveAsFileType,
                                    nsIFile** aSaveAsFile) {
  nsresult rv;
  nsCOMPtr<nsIFilePicker> filePicker =
      do_CreateInstance("@mozilla.org/filepicker;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  nsString saveMailAsStr;
  GetString(u"SaveMailAs"_ns, saveMailAsStr);
  filePicker->Init(mWindow, saveMailAsStr, nsIFilePicker::modeSave);

  // if we have a non-null filename use it, otherwise use default save message
  // one
  if (aMsgFilename.IsEmpty()) {
    nsString saveMsgStr;
    GetString(u"defaultSaveMessageAsFileName"_ns, saveMsgStr);
    filePicker->SetDefaultString(saveMsgStr);
  } else {
    filePicker->SetDefaultString(aMsgFilename);
  }

  // because we will be using GetFilterIndex()
  // we must call AppendFilters() one at a time,
  // in MESSENGER_SAVEAS_FILE_TYPE order
  nsString emlFilesStr;
  GetString(u"EMLFiles"_ns, emlFilesStr);
  filePicker->AppendFilter(emlFilesStr, u"*.eml"_ns);
  filePicker->AppendFilters(nsIFilePicker::filterHTML);
  filePicker->AppendFilters(nsIFilePicker::filterText);
  filePicker->AppendFilters(nsIFilePicker::filterAll);

  // Save as the "All Files" file type by default. We want to save as .eml by
  // default, but the filepickers on some platforms don't switch extensions
  // based on the file type selected (bug 508597).
  filePicker->SetFilterIndex(ANY_FILE_TYPE);
  // Yes, this is fine even if we ultimately save as HTML or text. On Windows,
  // this actually is a boolean telling the file picker to automatically add
  // the correct extension depending on the filter. On Mac or Linux this is a
  // no-op.
  filePicker->SetDefaultExtension(u"eml"_ns);

  nsIFilePicker::ResultCode dialogResult;

  nsCOMPtr<nsIFile> lastSaveDir;
  rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
  if (NS_SUCCEEDED(rv) && lastSaveDir)
    filePicker->SetDisplayDirectory(lastSaveDir);

  nsCOMPtr<nsIFile> localFile;
  rv = ShowPicker(filePicker, &dialogResult);
  NS_ENSURE_SUCCESS(rv, rv);
  if (dialogResult == nsIFilePicker::returnCancel) {
    // We'll indicate this by setting the outparam to null.
    *aSaveAsFile = nullptr;
    return NS_OK;
  }

  rv = filePicker->GetFile(getter_AddRefs(localFile));
  NS_ENSURE_SUCCESS(rv, rv);

  rv = SetLastSaveDirectory(localFile);
  NS_ENSURE_SUCCESS(rv, rv);

  int32_t selectedSaveAsFileType;
  rv = filePicker->GetFilterIndex(&selectedSaveAsFileType);
  NS_ENSURE_SUCCESS(rv, rv);

  // If All Files was selected, look at the extension
  if (selectedSaveAsFileType == ANY_FILE_TYPE) {
    nsAutoString fileName;
    rv = localFile->GetLeafName(fileName);
    NS_ENSURE_SUCCESS(rv, rv);

    if (StringEndsWith(fileName,
                       NS_LITERAL_STRING_FROM_CSTRING(HTML_FILE_EXTENSION),
                       nsCaseInsensitiveStringComparator) ||
        StringEndsWith(fileName,
                       NS_LITERAL_STRING_FROM_CSTRING(HTML_FILE_EXTENSION2),
                       nsCaseInsensitiveStringComparator))
      *aSaveAsFileType = HTML_FILE_TYPE;
    else if (StringEndsWith(fileName,
                            NS_LITERAL_STRING_FROM_CSTRING(TEXT_FILE_EXTENSION),
                            nsCaseInsensitiveStringComparator))
      *aSaveAsFileType = TEXT_FILE_TYPE;
    else
      // The default is .eml
      *aSaveAsFileType = EML_FILE_TYPE;
  } else {
    *aSaveAsFileType = selectedSaveAsFileType;
  }

  if (dialogResult == nsIFilePicker::returnReplace) {
    // be extra safe and only delete when the file is really a file
    bool isFile;
    rv = localFile->IsFile(&isFile);
    if (NS_SUCCEEDED(rv) && isFile) {
      rv = localFile->Remove(false /* recursive delete */);
      NS_ENSURE_SUCCESS(rv, rv);
    } else {
      // We failed, or this isn't a file. We can't do anything about it.
      return NS_ERROR_FAILURE;
    }
  }

  *aSaveAsFile = nullptr;
  localFile.forget(aSaveAsFile);
  return NS_OK;
}

/**
 * Show a Save All dialog allowing the user to pick which folder to save
 * messages to.
 * @param [out] aSaveDir directory to save to. Will be null on cancel.
 */
nsresult nsMessenger::GetSaveToDir(nsIFile** aSaveDir) {
  nsresult rv;
  nsCOMPtr<nsIFilePicker> filePicker =
      do_CreateInstance("@mozilla.org/filepicker;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsString chooseFolderStr;
  GetString(u"ChooseFolder"_ns, chooseFolderStr);
  filePicker->Init(mWindow, chooseFolderStr, nsIFilePicker::modeGetFolder);

  nsCOMPtr<nsIFile> lastSaveDir;
  rv = GetLastSaveDirectory(getter_AddRefs(lastSaveDir));
  if (NS_SUCCEEDED(rv) && lastSaveDir)
    filePicker->SetDisplayDirectory(lastSaveDir);

  nsIFilePicker::ResultCode dialogResult;
  rv = ShowPicker(filePicker, &dialogResult);
  if (NS_FAILED(rv) || dialogResult == nsIFilePicker::returnCancel) {
    // We'll indicate this by setting the outparam to null.
    *aSaveDir = nullptr;
    return NS_OK;
  }

  nsCOMPtr<nsIFile> dir;
  rv = filePicker->GetFile(getter_AddRefs(dir));
  NS_ENSURE_SUCCESS(rv, rv);

  rv = SetLastSaveDirectory(dir);
  NS_ENSURE_SUCCESS(rv, rv);

  *aSaveDir = nullptr;
  dir.forget(aSaveDir);
  return NS_OK;
}

NS_IMETHODIMP
nsMessenger::SaveMessages(const nsTArray<nsString>& aFilenameArray,
                          const nsTArray<nsCString>& aMessageUriArray) {
  MOZ_ASSERT(aFilenameArray.Length() == aMessageUriArray.Length());

  nsresult rv;

  nsCOMPtr<nsIFile> saveDir;
  rv = GetSaveToDir(getter_AddRefs(saveDir));
  NS_ENSURE_SUCCESS(rv, rv);
  if (!saveDir)  // A null saveDir means that the user canceled the save.
    return NS_OK;

  for (uint32_t i = 0; i < aFilenameArray.Length(); i++) {
    nsCOMPtr<nsIFile> saveToFile =
        do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    rv = saveToFile->InitWithFile(saveDir);
    NS_ENSURE_SUCCESS(rv, rv);

    rv = saveToFile->Append(aFilenameArray[i]);
    NS_ENSURE_SUCCESS(rv, rv);

    rv = AdjustFileIfNameTooLong(saveToFile);
    NS_ENSURE_SUCCESS(rv, rv);

    rv = PromptIfFileExists(saveToFile);
    if (NS_FAILED(rv)) continue;

    nsCOMPtr<nsIMsgMessageService> messageService;
    nsCOMPtr<nsIUrlListener> urlListener;

    rv = GetMessageServiceFromURI(aMessageUriArray[i],
                                  getter_AddRefs(messageService));
    if (NS_FAILED(rv)) {
      Alert("saveMessageFailed");
      return rv;
    }

    RefPtr<nsSaveMsgListener> saveListener =
        new nsSaveMsgListener(saveToFile, this, nullptr);

    rv = saveListener->QueryInterface(NS_GET_IID(nsIUrlListener),
                                      getter_AddRefs(urlListener));
    if (NS_FAILED(rv)) {
      Alert("saveMessageFailed");
      return rv;
    }

    // Ok, now save the message.
    nsCOMPtr<nsIURI> dummyNull;
    rv = messageService->SaveMessageToDisk(
        aMessageUriArray[i], saveToFile, false, urlListener,
        getter_AddRefs(dummyNull), true, mMsgWindow);
    if (NS_FAILED(rv)) {
      Alert("saveMessageFailed");
      return rv;
    }
  }
  return rv;
}

nsresult nsMessenger::Alert(const char* stringName) {
  nsresult rv = NS_OK;

  if (mDocShell) {
    nsCOMPtr<nsIPrompt> dialog(do_GetInterface(mDocShell));

    if (dialog) {
      nsString alertStr;
      GetString(NS_ConvertASCIItoUTF16(stringName), alertStr);
      rv = dialog->Alert(nullptr, alertStr.get());
    }
  }
  return rv;
}

NS_IMETHODIMP
nsMessenger::MsgHdrFromURI(const nsACString& aUri, nsIMsgDBHdr** aMsgHdr) {
  NS_ENSURE_ARG_POINTER(aMsgHdr);
  nsCOMPtr<nsIMsgMessageService> msgService;
  nsresult rv;

  rv = GetMessageServiceFromURI(aUri, getter_AddRefs(msgService));
  NS_ENSURE_SUCCESS(rv, rv);
  return msgService->MessageURIToMsgHdr(aUri, aMsgHdr);
}

NS_IMETHODIMP nsMessenger::GetUndoTransactionType(uint32_t* txnType) {
  NS_ENSURE_TRUE(txnType && mTxnMgr, NS_ERROR_NULL_POINTER);

  nsresult rv;
  *txnType = nsMessenger::eUnknown;
  nsCOMPtr<nsITransaction> txn;
  rv = mTxnMgr->PeekUndoStack(getter_AddRefs(txn));
  if (NS_SUCCEEDED(rv) && txn) {
    nsCOMPtr<nsIPropertyBag2> propertyBag = do_QueryInterface(txn, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    return propertyBag->GetPropertyAsUint32(u"type"_ns, txnType);
  }
  return rv;
}

NS_IMETHODIMP nsMessenger::CanUndo(bool* bValue) {
  NS_ENSURE_TRUE(bValue && mTxnMgr, NS_ERROR_NULL_POINTER);

  nsresult rv;
  *bValue = false;
  int32_t count = 0;
  rv = mTxnMgr->GetNumberOfUndoItems(&count);
  if (NS_SUCCEEDED(rv) && count > 0) *bValue = true;
  return rv;
}

NS_IMETHODIMP nsMessenger::GetRedoTransactionType(uint32_t* txnType) {
  NS_ENSURE_TRUE(txnType && mTxnMgr, NS_ERROR_NULL_POINTER);

  nsresult rv;
  *txnType = nsMessenger::eUnknown;
  nsCOMPtr<nsITransaction> txn;
  rv = mTxnMgr->PeekRedoStack(getter_AddRefs(txn));
  if (NS_SUCCEEDED(rv) && txn) {
    nsCOMPtr<nsIPropertyBag2> propertyBag = do_QueryInterface(txn, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    return propertyBag->GetPropertyAsUint32(u"type"_ns, txnType);
  }
  return rv;
}

NS_IMETHODIMP nsMessenger::CanRedo(bool* bValue) {
  NS_ENSURE_TRUE(bValue && mTxnMgr, NS_ERROR_NULL_POINTER);

  nsresult rv;
  *bValue = false;
  int32_t count = 0;
  rv = mTxnMgr->GetNumberOfRedoItems(&count);
  if (NS_SUCCEEDED(rv) && count > 0) *bValue = true;
  return rv;
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
nsMessenger::Undo(nsIMsgWindow* msgWindow) {
  nsresult rv = NS_OK;
  if (mTxnMgr) {
    int32_t numTxn = 0;
    rv = mTxnMgr->GetNumberOfUndoItems(&numTxn);
    if (NS_SUCCEEDED(rv) && numTxn > 0) {
      nsCOMPtr<nsITransaction> txn;
      rv = mTxnMgr->PeekUndoStack(getter_AddRefs(txn));
      if (NS_SUCCEEDED(rv) && txn) {
        static_cast<nsMsgTxn*>(static_cast<nsITransaction*>(txn.get()))
            ->SetMsgWindow(msgWindow);
      }
      nsCOMPtr<nsITransactionManager> txnMgr = mTxnMgr;
      txnMgr->UndoTransaction();
    }
  }
  return rv;
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
nsMessenger::Redo(nsIMsgWindow* msgWindow) {
  nsresult rv = NS_OK;
  if (mTxnMgr) {
    int32_t numTxn = 0;
    rv = mTxnMgr->GetNumberOfRedoItems(&numTxn);
    if (NS_SUCCEEDED(rv) && numTxn > 0) {
      nsCOMPtr<nsITransaction> txn;
      rv = mTxnMgr->PeekRedoStack(getter_AddRefs(txn));
      if (NS_SUCCEEDED(rv) && txn) {
        static_cast<nsMsgTxn*>(static_cast<nsITransaction*>(txn.get()))
            ->SetMsgWindow(msgWindow);
      }
      nsCOMPtr<nsITransactionManager> txnMgr = mTxnMgr;
      txnMgr->RedoTransaction();
    }
  }
  return rv;
}

NS_IMETHODIMP
nsMessenger::GetTransactionManager(nsITransactionManager** aTxnMgr) {
  NS_ENSURE_TRUE(mTxnMgr && aTxnMgr, NS_ERROR_NULL_POINTER);
  NS_ADDREF(*aTxnMgr = mTxnMgr);
  return NS_OK;
}

nsSaveMsgListener::nsSaveMsgListener(nsIFile* aFile, nsMessenger* aMessenger,
                                     nsIUrlListener* aListener) {
  m_file = aFile;
  m_messenger = aMessenger;
  mListener = aListener;
  mUrlHasStopped = false;
  mRequestHasStopped = false;

  // rhp: for charset handling
  m_doCharsetConversion = false;
  m_saveAllAttachmentsState = nullptr;
  mProgress = 0;
  mMaxProgress = -1;
  mCanceled = false;
  m_outputFormat = eUnknown;
  mInitialized = false;
}

nsSaveMsgListener::~nsSaveMsgListener() {}

//
// nsISupports
//
NS_IMPL_ISUPPORTS(nsSaveMsgListener, nsIUrlListener, nsIMsgCopyServiceListener,
                  nsIStreamListener, nsIRequestObserver, nsICancelable)

NS_IMETHODIMP
nsSaveMsgListener::Cancel(nsresult status) {
  mCanceled = true;
  return NS_OK;
}

//
// nsIUrlListener
//
NS_IMETHODIMP
nsSaveMsgListener::OnStartRunningUrl(nsIURI* url) {
  if (mListener) mListener->OnStartRunningUrl(url);
  return NS_OK;
}

NS_IMETHODIMP
nsSaveMsgListener::OnStopRunningUrl(nsIURI* url, nsresult exitCode) {
  nsresult rv = exitCode;
  mUrlHasStopped = true;

  // ** save as template goes here
  if (!m_templateUri.IsEmpty()) {
    nsCOMPtr<nsIMsgFolder> templateFolder;
    rv = GetOrCreateFolder(m_templateUri, getter_AddRefs(templateFolder));
    if (NS_FAILED(rv)) goto done;
    nsCOMPtr<nsIMsgCopyService> copyService =
        do_GetService("@mozilla.org/messenger/messagecopyservice;1");
    if (copyService) {
      nsCOMPtr<nsIFile> clone;
      m_file->Clone(getter_AddRefs(clone));
      rv = copyService->CopyFileMessage(clone, templateFolder, nullptr, true,
                                        nsMsgMessageFlags::Read, EmptyCString(),
                                        this, nullptr);
      // Clear this so we don't end up in a loop if OnStopRunningUrl gets
      // called again.
      m_templateUri.Truncate();
    }
  } else if (m_outputStream && mRequestHasStopped) {
    m_outputStream->Close();
    m_outputStream = nullptr;
  }

done:
  if (NS_FAILED(rv)) {
    if (m_file) m_file->Remove(false);
    if (m_messenger) m_messenger->Alert("saveMessageFailed");
  }

  if (mRequestHasStopped && mListener)
    mListener->OnStopRunningUrl(url, exitCode);
  else
    mListenerUri = url;

  return rv;
}

NS_IMETHODIMP
nsSaveMsgListener::OnStartCopy(void) { return NS_OK; }

NS_IMETHODIMP
nsSaveMsgListener::OnProgress(uint32_t aProgress, uint32_t aProgressMax) {
  return NS_OK;
}

NS_IMETHODIMP
nsSaveMsgListener::SetMessageKey(nsMsgKey aKey) {
  return NS_ERROR_NOT_IMPLEMENTED;
}

NS_IMETHODIMP
nsSaveMsgListener::GetMessageId(nsACString& aMessageId) {
  return NS_ERROR_NOT_IMPLEMENTED;
}

NS_IMETHODIMP
nsSaveMsgListener::OnStopCopy(nsresult aStatus) {
  if (m_file) m_file->Remove(false);
  return aStatus;
}

// initializes the progress window if we are going to show one
// and for OSX, sets creator flags on the output file
nsresult nsSaveMsgListener::InitializeDownload(nsIRequest* aRequest) {
  nsresult rv = NS_OK;

  mInitialized = true;
  nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));

  if (!channel) return rv;

  // Get the max progress from the URL if we haven't already got it.
  if (mMaxProgress == -1) {
    nsCOMPtr<nsIURI> uri;
    channel->GetURI(getter_AddRefs(uri));
    nsCOMPtr<nsIMsgMailNewsUrl> mailnewsUrl(do_QueryInterface(uri));
    if (mailnewsUrl) mailnewsUrl->GetMaxProgress(&mMaxProgress);
  }

  if (!m_contentType.IsEmpty()) {
    nsCOMPtr<nsIMIMEService> mimeService(
        do_GetService(NS_MIMESERVICE_CONTRACTID));
    nsCOMPtr<nsIMIMEInfo> mimeinfo;

    mimeService->GetFromTypeAndExtension(m_contentType, EmptyCString(),
                                         getter_AddRefs(mimeinfo));

    // create a download progress window

    // Set saveToDisk explicitly to avoid launching the saved file.
    // See
    // https://hg.mozilla.org/mozilla-central/file/814a6f071472/toolkit/components/jsdownloads/src/DownloadLegacy.js#l164
    mimeinfo->SetPreferredAction(nsIHandlerInfo::saveToDisk);

    // When we don't allow warnings, also don't show progress, as this
    //  is an environment (typically filters) where we don't want
    //  interruption.
    bool allowProgress = true;
    if (m_saveAllAttachmentsState)
      allowProgress = !m_saveAllAttachmentsState->m_withoutWarning;
    if (allowProgress) {
      nsCOMPtr<nsITransfer> tr = do_CreateInstance(NS_TRANSFER_CONTRACTID, &rv);
      if (tr && m_file) {
        PRTime timeDownloadStarted = PR_Now();

        nsCOMPtr<nsIURI> outputURI;
        NS_NewFileURI(getter_AddRefs(outputURI), m_file);

        nsCOMPtr<nsIURI> url;
        channel->GetURI(getter_AddRefs(url));
        rv = tr->Init(url, nullptr, outputURI, EmptyString(), mimeinfo,
                      timeDownloadStarted, nullptr, this, false,
                      nsITransfer::DOWNLOAD_ACCEPTABLE, nullptr, false);

        // now store the web progresslistener
        mTransfer = tr;
      }
    }
  }
  return rv;
}

NS_IMETHODIMP
nsSaveMsgListener::OnStartRequest(nsIRequest* request) {
  if (m_file)
    MsgNewBufferedFileOutputStream(getter_AddRefs(m_outputStream), m_file, -1,
                                   ATTACHMENT_PERMISSION);
  if (!m_outputStream) {
    mCanceled = true;
    if (m_messenger) m_messenger->Alert("saveAttachmentFailed");
  }
  return NS_OK;
}

NS_IMETHODIMP
nsSaveMsgListener::OnStopRequest(nsIRequest* request, nsresult status) {
  nsresult rv = NS_OK;
  mRequestHasStopped = true;

  // rhp: If we are doing the charset conversion magic, this is different
  // processing, otherwise, its just business as usual.
  // If we need text/plain, then we need to convert the HTML and then convert
  // to the systems charset.
  if (m_doCharsetConversion && m_outputStream) {
    // For HTML, code is emitted immediately in OnDataAvailable.
    MOZ_ASSERT(m_outputFormat == ePlainText,
               "For HTML, m_doCharsetConversion shouldn't be set");
    NS_ConvertUTF8toUTF16 utf16Buffer(m_msgBuffer);
    ConvertBufToPlainText(utf16Buffer, false, false, false);

    nsCString outCString;
    // NS_CopyUnicodeToNative() doesn't return an error, so we have no choice
    // but to always use UTF-8.
    CopyUTF16toUTF8(utf16Buffer, outCString);
    uint32_t writeCount;
    rv = m_outputStream->Write(outCString.get(), outCString.Length(),
                               &writeCount);
    if (outCString.Length() != writeCount) rv = NS_ERROR_FAILURE;
  }

  if (m_outputStream) {
    m_outputStream->Close();
    m_outputStream = nullptr;
  }

  // Are there more attachments to deal with?
  nsSaveAllAttachmentsState* state = m_saveAllAttachmentsState;
  if (state) {
    state->m_curIndex++;
    if (!mCanceled && state->m_curIndex < state->m_count) {
      // Yes, start on the next attachment.
      uint32_t i = state->m_curIndex;
      nsString unescapedName;
      RefPtr<nsLocalFile> localFile =
          new nsLocalFile(nsTDependentString<PathChar>(state->m_directoryName));
      if (localFile->NativePath().IsEmpty()) {
        rv = NS_ERROR_FAILURE;
        goto done;
      }

      ConvertAndSanitizeFileName(state->m_displayNameArray[i], unescapedName);
      rv = localFile->Append(unescapedName);
      if (NS_FAILED(rv)) goto done;

      // When we are running with no warnings (typically filters and other
      // automatic uses), then don't prompt for duplicates, but create a unique
      // file instead.
      if (!state->m_withoutWarning) {
        rv = m_messenger->PromptIfFileExists(localFile);
        if (NS_FAILED(rv)) goto done;
      } else {
        rv = localFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE,
                                     ATTACHMENT_PERMISSION);
        if (NS_FAILED(rv)) goto done;
      }
      // Start the next attachment saving.
      // NOTE: null listener passed in on subsequent saves! The original
      // listener will already have been invoked.
      // See Bug 1789565
      rv = m_messenger->SaveAttachment(
          localFile, state->m_urlArray[i], state->m_messageUriArray[i],
          state->m_contentTypeArray[i], state, nullptr);
      if (NS_FAILED(rv)) {
        // If SaveAttachment() fails, state will have been deleted, and
        // m_overallListener->OnStopRunningUrl() will have been called.
        state = nullptr;
        m_saveAllAttachmentsState = nullptr;
      }
    done:
      if (NS_FAILED(rv) && state) {
        if (state->m_overallListener) {
          state->m_overallListener->OnStopRunningUrl(nullptr, rv);
        }
        delete state;
        m_saveAllAttachmentsState = nullptr;
      }
    } else {
      // All attachments have been saved.
      if (state->m_overallListener) {
        state->m_overallListener->OnStopRunningUrl(
            nullptr, mCanceled ? NS_ERROR_FAILURE : NS_OK);
      }
      // Check if we're supposed to be detaching attachments after saving them.
      if (state->m_detachingAttachments && !mCanceled) {
        m_messenger->DetachAttachments(
            state->m_contentTypeArray, state->m_urlArray,
            state->m_displayNameArray, state->m_messageUriArray,
            &state->m_savedFiles, nullptr, state->m_withoutWarning);
      }
      delete m_saveAllAttachmentsState;
      m_saveAllAttachmentsState = nullptr;
    }
  }

  if (mTransfer) {
    mTransfer->OnProgressChange64(nullptr, nullptr, mMaxProgress, mMaxProgress,
                                  mMaxProgress, mMaxProgress);
    mTransfer->OnStateChange(nullptr, nullptr,
                             nsIWebProgressListener::STATE_STOP |
                                 nsIWebProgressListener::STATE_IS_NETWORK,
                             NS_OK);
    mTransfer = nullptr;  // break any circular dependencies between the
                          // progress dialog and use
  }

  if (mUrlHasStopped && mListener)
    mListener->OnStopRunningUrl(mListenerUri, rv);

  return NS_OK;
}

NS_IMETHODIMP
nsSaveMsgListener::OnDataAvailable(nsIRequest* request,
                                   nsIInputStream* inStream, uint64_t srcOffset,
                                   uint32_t count) {
  nsresult rv = NS_ERROR_FAILURE;
  // first, check to see if we've been canceled....
  if (mCanceled)  // then go cancel our underlying channel too
    return request->Cancel(NS_BINDING_ABORTED);

  if (!mInitialized) InitializeDownload(request);

  if (m_outputStream) {
    mProgress += count;
    uint64_t available;
    uint32_t readCount, maxReadCount = sizeof(m_dataBuffer);
    uint32_t writeCount;
    rv = inStream->Available(&available);
    while (NS_SUCCEEDED(rv) && available) {
      if (maxReadCount > available) maxReadCount = (uint32_t)available;
      rv = inStream->Read(m_dataBuffer, maxReadCount, &readCount);

      // rhp:
      // Ok, now we do one of two things. If we are sending out HTML, then
      // just write it to the HTML stream as it comes along...but if this is
      // a save as TEXT operation, we need to buffer this up for conversion
      // when we are done. When the stream converter for HTML-TEXT gets in
      // place, this magic can go away.
      //
      if (NS_SUCCEEDED(rv)) {
        if ((m_doCharsetConversion) && (m_outputFormat == ePlainText))
          m_msgBuffer.Append(Substring(m_dataBuffer, m_dataBuffer + readCount));
        else
          rv = m_outputStream->Write(m_dataBuffer, readCount, &writeCount);

        available -= readCount;
      }
    }

    if (NS_SUCCEEDED(rv) && mTransfer)  // Send progress notification.
      mTransfer->OnProgressChange64(nullptr, request, mProgress, mMaxProgress,
                                    mProgress, mMaxProgress);
  }
  return rv;
}

#define MESSENGER_STRING_URL "chrome://messenger/locale/messenger.properties"

nsresult nsMessenger::InitStringBundle() {
  if (mStringBundle) return NS_OK;

  const char propertyURL[] = MESSENGER_STRING_URL;
  nsCOMPtr<nsIStringBundleService> sBundleService =
      mozilla::components::StringBundle::Service();
  NS_ENSURE_TRUE(sBundleService, NS_ERROR_UNEXPECTED);
  return sBundleService->CreateBundle(propertyURL,
                                      getter_AddRefs(mStringBundle));
}

void nsMessenger::GetString(const nsString& aStringName, nsString& aValue) {
  nsresult rv;
  aValue.Truncate();

  if (!mStringBundle) InitStringBundle();

  if (mStringBundle)
    rv = mStringBundle->GetStringFromName(
        NS_ConvertUTF16toUTF8(aStringName).get(), aValue);
  else
    rv = NS_ERROR_FAILURE;

  if (NS_FAILED(rv) || aValue.IsEmpty()) aValue = aStringName;
  return;
}

nsSaveAllAttachmentsState::nsSaveAllAttachmentsState(
    const nsTArray<nsCString>& contentTypeArray,
    const nsTArray<nsCString>& urlArray,
    const nsTArray<nsCString>& displayNameArray,
    const nsTArray<nsCString>& messageUriArray, const PathChar* dirName,
    bool detachingAttachments, nsIUrlListener* overallListener)
    : m_contentTypeArray(contentTypeArray.Clone()),
      m_urlArray(urlArray.Clone()),
      m_displayNameArray(displayNameArray.Clone()),
      m_messageUriArray(messageUriArray.Clone()),
      m_detachingAttachments(detachingAttachments),
      m_overallListener(overallListener),
      m_withoutWarning(false) {
  m_count = contentTypeArray.Length();
  m_curIndex = 0;
  m_directoryName = NS_xstrdup(dirName);
}

nsSaveAllAttachmentsState::~nsSaveAllAttachmentsState() {
  free(m_directoryName);
}

nsresult nsMessenger::GetLastSaveDirectory(nsIFile** aLastSaveDir) {
  nsresult rv;
  nsCOMPtr<nsIPrefBranch> prefBranch =
      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // this can fail, and it will, on the first time we call it, as there is no
  // default for this pref.
  nsCOMPtr<nsIFile> localFile;
  rv = prefBranch->GetComplexValue(MESSENGER_SAVE_DIR_PREF_NAME,
                                   NS_GET_IID(nsIFile),
                                   getter_AddRefs(localFile));
  if (NS_SUCCEEDED(rv)) localFile.forget(aLastSaveDir);
  return rv;
}

nsresult nsMessenger::SetLastSaveDirectory(nsIFile* aLocalFile) {
  NS_ENSURE_ARG_POINTER(aLocalFile);
  nsresult rv;
  nsCOMPtr<nsIPrefBranch> prefBranch =
      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // if the file is a directory, just use it for the last dir chosen
  // otherwise, use the parent of the file as the last dir chosen.
  // IsDirectory() will return error on saving a file, as the
  // file doesn't exist yet.
  bool isDirectory;
  rv = aLocalFile->IsDirectory(&isDirectory);
  if (NS_SUCCEEDED(rv) && isDirectory) {
    rv = prefBranch->SetComplexValue(MESSENGER_SAVE_DIR_PREF_NAME,
                                     NS_GET_IID(nsIFile), aLocalFile);
    NS_ENSURE_SUCCESS(rv, rv);
  } else {
    nsCOMPtr<nsIFile> parent;
    rv = aLocalFile->GetParent(getter_AddRefs(parent));
    NS_ENSURE_SUCCESS(rv, rv);

    rv = prefBranch->SetComplexValue(MESSENGER_SAVE_DIR_PREF_NAME,
                                     NS_GET_IID(nsIFile), parent);
    NS_ENSURE_SUCCESS(rv, rv);
  }
  return NS_OK;
}

NS_IMETHODIMP
nsMessenger::FormatFileSize(uint64_t aSize, bool aUseKB,
                            nsAString& aFormattedSize) {
  return ::FormatFileSize(aSize, aUseKB, aFormattedSize);
}

///////////////////////////////////////////////////////////////////////////////
// Detach/Delete Attachments
///////////////////////////////////////////////////////////////////////////////

static const char* GetAttachmentPartId(const char* aAttachmentUrl) {
  static const char partIdPrefix[] = "part=";
  const char* partId = PL_strstr(aAttachmentUrl, partIdPrefix);
  return partId ? (partId + sizeof(partIdPrefix) - 1) : nullptr;
}

static int CompareAttachmentPartId(const char* aAttachUrlLeft,
                                   const char* aAttachUrlRight) {
  // part ids are numbers separated by periods, like "1.2.3.4".
  // we sort by doing a numerical comparison on each item in turn. e.g. "1.4" <
  // "1.25" shorter entries come before longer entries. e.g. "1.4" < "1.4.1.2"
  // return values:
  //  -2  left is a parent of right
  //  -1  left is less than right
  //   0  left == right
  //   1  right is greater than left
  //   2  right is a parent of left

  const char* partIdLeft = GetAttachmentPartId(aAttachUrlLeft);
  const char* partIdRight = GetAttachmentPartId(aAttachUrlRight);

  // for detached attachments the URL does not contain any "part=xx"
  if (!partIdLeft) partIdLeft = "0";

  if (!partIdRight) partIdRight = "0";

  long idLeft, idRight;
  do {
    MOZ_ASSERT(partIdLeft && IS_DIGIT(*partIdLeft),
               "Invalid character in part id string");
    MOZ_ASSERT(partIdRight && IS_DIGIT(*partIdRight),
               "Invalid character in part id string");

    // if the part numbers are different then the numerically smaller one is
    // first
    char* fixConstLoss;
    idLeft = strtol(partIdLeft, &fixConstLoss, 10);
    partIdLeft = fixConstLoss;
    idRight = strtol(partIdRight, &fixConstLoss, 10);
    partIdRight = fixConstLoss;
    if (idLeft != idRight) return idLeft < idRight ? -1 : 1;

    // if one part id is complete but the other isn't, then the shortest one
    // is first (parents before children)
    if (*partIdLeft != *partIdRight) return *partIdRight ? -2 : 2;

    // if both part ids are complete (*partIdLeft == *partIdRight now) then
    // they are equal
    if (!*partIdLeft) return 0;

    MOZ_ASSERT(*partIdLeft == '.', "Invalid character in part id string");
    MOZ_ASSERT(*partIdRight == '.', "Invalid character in part id string");

    ++partIdLeft;
    ++partIdRight;
  } while (true);
}

// ------------------------------------

// struct on purpose -> show that we don't ever want a vtable
struct msgAttachment {
  msgAttachment(const nsACString& aContentType, const nsACString& aUrl,
                const nsACString& aDisplayName, const nsACString& aMessageUri)
      : mContentType(aContentType),
        mUrl(aUrl),
        mDisplayName(aDisplayName),
        mMessageUri(aMessageUri) {}

  nsCString mContentType;
  nsCString mUrl;
  nsCString mDisplayName;
  nsCString mMessageUri;
};

// ------------------------------------

class nsAttachmentState {
 public:
  nsAttachmentState();
  nsresult Init(const nsTArray<nsCString>& aContentTypeArray,
                const nsTArray<nsCString>& aUrlArray,
                const nsTArray<nsCString>& aDisplayNameArray,
                const nsTArray<nsCString>& aMessageUriArray);
  nsresult PrepareForAttachmentDelete();

 private:
  static int CompareAttachmentsByPartId(const void* aLeft, const void* aRight);

 public:
  uint32_t mCurIndex;
  nsTArray<msgAttachment> mAttachmentArray;
};

nsAttachmentState::nsAttachmentState() : mCurIndex(0) {}

nsresult nsAttachmentState::Init(const nsTArray<nsCString>& aContentTypeArray,
                                 const nsTArray<nsCString>& aUrlArray,
                                 const nsTArray<nsCString>& aDisplayNameArray,
                                 const nsTArray<nsCString>& aMessageUriArray) {
  MOZ_ASSERT(aContentTypeArray.Length() > 0);
  MOZ_ASSERT(aContentTypeArray.Length() == aUrlArray.Length() &&
             aUrlArray.Length() == aDisplayNameArray.Length() &&
             aDisplayNameArray.Length() == aMessageUriArray.Length());

  uint32_t count = aContentTypeArray.Length();
  mCurIndex = 0;
  mAttachmentArray.Clear();
  mAttachmentArray.SetCapacity(count);

  for (uint32_t u = 0; u < count; ++u) {
    mAttachmentArray.AppendElement(
        msgAttachment(aContentTypeArray[u], aUrlArray[u], aDisplayNameArray[u],
                      aMessageUriArray[u]));
  }

  return NS_OK;
}

nsresult nsAttachmentState::PrepareForAttachmentDelete() {
  // this must be called before any processing
  if (mCurIndex != 0) return NS_ERROR_FAILURE;

  // this prepares the attachment list for use in deletion. In order to prepare,
  // we sort the attachments in numerical ascending order on their part id,
  // remove all duplicates and remove any subparts which will be removed
  // automatically by the removal of the parent.
  //
  // e.g. the attachment list processing (showing only part ids)
  // before: 1.11, 1.3, 1.2, 1.2.1.3, 1.4.1.2
  // sorted: 1.2, 1.2.1.3, 1.3, 1.4.1.2, 1.11
  // after:  1.2, 1.3, 1.4.1.2, 1.11

  // sort
  qsort(mAttachmentArray.Elements(), mAttachmentArray.Length(),
        sizeof(msgAttachment), CompareAttachmentsByPartId);

  // remove duplicates and sub-items
  int nCompare;
  for (uint32_t u = 1; u < mAttachmentArray.Length();) {
    nCompare = ::CompareAttachmentPartId(mAttachmentArray[u - 1].mUrl.get(),
                                         mAttachmentArray[u].mUrl.get());
    if (nCompare == 0 ||
        nCompare == -2)  // [u-1] is the same as or a parent of [u]
    {
      // shuffle the array down (and thus keeping the sorted order)
      mAttachmentArray.RemoveElementAt(u);
    } else {
      ++u;
    }
  }

  return NS_OK;
}

// Static compare callback for sorting.
int nsAttachmentState::CompareAttachmentsByPartId(const void* aLeft,
                                                  const void* aRight) {
  msgAttachment& attachLeft = *((msgAttachment*)aLeft);
  msgAttachment& attachRight = *((msgAttachment*)aRight);
  return ::CompareAttachmentPartId(attachLeft.mUrl.get(),
                                   attachRight.mUrl.get());
}

// ------------------------------------
// Helper class to coordinate deleting attachments from a message.
//
// Implementation notes:
// The basic technique is to use nsIMsgMessageService.streamMessage() to
// stream the message through a streamconverter which is set up to strip
// out the attachments. The result is written out to a temporary file,
// which is then copied over the old message using
// nsIMsgCopyService.copyFileMessage() and the old message deleted with
// nsIMsgFolder.deleteMessages(). Phew.
//
// The nsIStreamListener, nsIUrlListener and nsIMsgCopyServiceListener
// inheritances here are just unfortunately-exposed implementation details.
// And they are a bit of a mess. Some are used multiple times, for different
// phases of the operation. So we use m_state to keep track.
class AttachmentDeleter : public nsIStreamListener,
                          public nsIUrlListener,
                          public nsIMsgCopyServiceListener {
 public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSISTREAMLISTENER
  NS_DECL_NSIREQUESTOBSERVER
  NS_DECL_NSIURLLISTENER
  NS_DECL_NSIMSGCOPYSERVICELISTENER

 public:
  AttachmentDeleter();
  nsresult StartProcessing(nsMessenger* aMessenger, nsIMsgWindow* aMsgWindow,
                           nsAttachmentState* aAttach, bool aSaveFirst);

 public:
  nsAttachmentState* mAttach;                // list of attachments to process
  bool mSaveFirst;                           // detach (true) or delete (false)
  nsCOMPtr<nsIFile> mMsgFile;                // temporary file (processed mail)
  nsCOMPtr<nsIOutputStream> mMsgFileStream;  // temporary file (processed mail)
  nsCOMPtr<nsIMsgMessageService> mMessageService;  // original message service
  nsCOMPtr<nsIMsgDBHdr> mOriginalMessage;          // original message header
  nsCOMPtr<nsIMsgFolder> mMessageFolder;           // original message folder
  nsCOMPtr<nsIMessenger> mMessenger;               // our messenger instance
  nsCOMPtr<nsIMsgWindow> mMsgWindow;               // our UI window
  nsMsgKey mOriginalMessageKey;                    // old message key
  nsMsgKey mNewMessageKey;                         // new message key
  uint32_t mOrigMsgFlags;

  enum {
    eStarting,
    eCopyingNewMsg,
    eUpdatingFolder,  // for IMAP
    eDeletingOldMessage,
    eSelectingNewMessage
  } m_state;
  // temp
  nsTArray<nsCString> mDetachedFileUris;

  // The listener to invoke when the full operation is complete.
  nsCOMPtr<nsIUrlListener> mListener;

 private:
  nsresult InternalStartProcessing(nsMessenger* aMessenger,
                                   nsIMsgWindow* aMsgWindow,
                                   nsAttachmentState* aAttach, bool aSaveFirst);
  nsresult DeleteOriginalMessage();
  virtual ~AttachmentDeleter();
};

//
// nsISupports
//
NS_IMPL_ISUPPORTS(AttachmentDeleter, nsIStreamListener, nsIRequestObserver,
                  nsIUrlListener, nsIMsgCopyServiceListener)

//
// nsIRequestObserver
//
NS_IMETHODIMP
AttachmentDeleter::OnStartRequest(nsIRequest* aRequest) {
  // called when we start processing the StreamMessage request.
  // This is called after OnStartRunningUrl().
  return NS_OK;
}

NS_IMETHODIMP
AttachmentDeleter::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
  // called when we have completed processing the StreamMessage request.
  // This is called before OnStopRunningUrl(). This means that we have now
  // received all data of the message and we have completed processing.
  // We now start to copy the processed message from the temporary file
  // back into the message store, replacing the original message.

  mMessageFolder->CopyDataDone();
  if (NS_FAILED(aStatusCode)) return aStatusCode;

  // copy the file back into the folder. Note: setting msgToReplace only copies
  // metadata, so we do the delete ourselves
  nsCOMPtr<nsIMsgCopyServiceListener> listenerCopyService;
  nsresult rv = this->QueryInterface(NS_GET_IID(nsIMsgCopyServiceListener),
                                     getter_AddRefs(listenerCopyService));
  NS_ENSURE_SUCCESS(rv, rv);

  mMsgFileStream->Close();
  mMsgFileStream = nullptr;
  mNewMessageKey = nsMsgKey_None;
  nsCOMPtr<nsIMsgCopyService> copyService =
      do_GetService("@mozilla.org/messenger/messagecopyservice;1");
  m_state = eCopyingNewMsg;
  // clone file because nsIFile on Windows caches the wrong file size.
  nsCOMPtr<nsIFile> clone;
  mMsgFile->Clone(getter_AddRefs(clone));
  if (copyService) {
    nsCString originalKeys;
    mOriginalMessage->GetStringProperty("keywords", originalKeys);
    rv = copyService->CopyFileMessage(clone, mMessageFolder, mOriginalMessage,
                                      false, mOrigMsgFlags, originalKeys,
                                      listenerCopyService, mMsgWindow);
  }
  return rv;
}

//
// nsIStreamListener
//

NS_IMETHODIMP
AttachmentDeleter::OnDataAvailable(nsIRequest* aRequest,
                                   nsIInputStream* aInStream,
                                   uint64_t aSrcOffset, uint32_t aCount) {
  if (!mMsgFileStream) return NS_ERROR_NULL_POINTER;
  return mMessageFolder->CopyDataToOutputStreamForAppend(aInStream, aCount,
                                                         mMsgFileStream);
}

//
// nsIUrlListener
//

NS_IMETHODIMP
AttachmentDeleter::OnStartRunningUrl(nsIURI* aUrl) {
  // called when we start processing the StreamMessage request. This is
  // called before OnStartRequest().
  return NS_OK;
}

nsresult AttachmentDeleter::DeleteOriginalMessage() {
  nsCOMPtr<nsIMsgCopyServiceListener> listenerCopyService;
  QueryInterface(NS_GET_IID(nsIMsgCopyServiceListener),
                 getter_AddRefs(listenerCopyService));

  mOriginalMessage->SetUint32Property("attachmentDetached", 1);
  RefPtr<nsIMsgDBHdr> doomed(mOriginalMessage);
  mOriginalMessage = nullptr;
  m_state = eDeletingOldMessage;
  return mMessageFolder->DeleteMessages({doomed},             // messages
                                        mMsgWindow,           // msgWindow
                                        true,                 // deleteStorage
                                        false,                // isMove
                                        listenerCopyService,  // listener
                                        false);               // allowUndo
}

// This is called (potentially) multiple times.
// Firstly, as a result of StreamMessage() (when the message is being passed
// through a streamconverter to strip the attachments).
// Secondly, after the DeleteMessages() call. But maybe not for IMAP?
// Maybe also after CopyFileMessage()? Gah.
NS_IMETHODIMP
AttachmentDeleter::OnStopRunningUrl(nsIURI* aUrl, nsresult aExitCode) {
  nsresult rv = NS_OK;
  if (mOriginalMessage && m_state == eUpdatingFolder)
    rv = DeleteOriginalMessage();

  return rv;
}

//
// nsIMsgCopyServiceListener
//

NS_IMETHODIMP
AttachmentDeleter::OnStartCopy(void) {
  // never called?
  return NS_OK;
}

NS_IMETHODIMP
AttachmentDeleter::OnProgress(uint32_t aProgress, uint32_t aProgressMax) {
  // never called?
  return NS_OK;
}

NS_IMETHODIMP
AttachmentDeleter::SetMessageKey(nsMsgKey aKey) {
  // called during the copy of the modified message back into the message
  // store to notify us of the message key of the newly created message.
  mNewMessageKey = aKey;

  nsCString folderURI;
  nsresult rv = mMessageFolder->GetURI(folderURI);
  NS_ENSURE_SUCCESS(rv, rv);

  mozilla::JSONStringWriteFunc<nsCString> jsonString;
  mozilla::JSONWriter data(jsonString);
  data.Start();
  data.IntProperty("oldMessageKey", mOriginalMessageKey);
  data.IntProperty("newMessageKey", aKey);
  data.StringProperty("folderURI", folderURI);
  data.End();

  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
  if (obs) {
    obs->NotifyObservers(nullptr, "attachment-delete-msgkey-changed",
                         NS_ConvertUTF8toUTF16(jsonString.StringCRef()).get());
  }
  return NS_OK;
}

NS_IMETHODIMP
AttachmentDeleter::GetMessageId(nsACString& aMessageId) {
  // never called?
  return NS_ERROR_NOT_IMPLEMENTED;
}

NS_IMETHODIMP
AttachmentDeleter::OnStopCopy(nsresult aStatus) {
  // This is called via `CopyFileMessage()` and `DeleteMessages()`.
  // `m_state` tells us which callback it is.
  if (m_state == eDeletingOldMessage) {
    m_state = eSelectingNewMessage;

    // OK... that's it. The entire operation is now done.
    // (there may still be another call to OnStopRunningUrl(), but that'll be
    // a no-op in this state).
    if (mListener) {
      mListener->OnStopRunningUrl(nullptr, aStatus);
    }
    return NS_OK;
  }

  // For non-IMAP messages, the original is deleted here, for IMAP messages
  // that happens in `OnStopRunningUrl()` which isn't called for non-IMAP
  // messages.
  const nsACString& messageUri = mAttach->mAttachmentArray[0].mMessageUri;
  if (mOriginalMessage &&
      !Substring(messageUri, 0, 13).EqualsLiteral("imap-message:")) {
    return DeleteOriginalMessage();
  } else {
    // Arrange for the message to be deleted in the next `OnStopRunningUrl()`
    // call.
    m_state = eUpdatingFolder;
  }

  return NS_OK;
}

//
// local methods
//

AttachmentDeleter::AttachmentDeleter()
    : mAttach(nullptr),
      mSaveFirst(false),
      mOriginalMessageKey(nsMsgKey_None),
      mNewMessageKey(nsMsgKey_None),
      mOrigMsgFlags(0),
      m_state(eStarting) {}

AttachmentDeleter::~AttachmentDeleter() {
  if (mAttach) {
    delete mAttach;
  }
  if (mMsgFileStream) {
    mMsgFileStream->Close();
    mMsgFileStream = nullptr;
  }
  if (mMsgFile) {
    mMsgFile->Remove(false);
  }
}

nsresult AttachmentDeleter::StartProcessing(nsMessenger* aMessenger,
                                            nsIMsgWindow* aMsgWindow,
                                            nsAttachmentState* aAttach,
                                            bool detaching) {
  if (mListener) {
    mListener->OnStartRunningUrl(nullptr);
  }

  nsresult rv =
      InternalStartProcessing(aMessenger, aMsgWindow, aAttach, detaching);
  if (NS_FAILED(rv)) {
    if (mListener) {
      mListener->OnStopRunningUrl(nullptr, rv);
    }
  }
  return rv;
}

nsresult AttachmentDeleter::InternalStartProcessing(nsMessenger* aMessenger,
                                                    nsIMsgWindow* aMsgWindow,
                                                    nsAttachmentState* aAttach,
                                                    bool detaching) {
  aMessenger->QueryInterface(NS_GET_IID(nsIMessenger),
                             getter_AddRefs(mMessenger));
  mMsgWindow = aMsgWindow;
  mAttach = aAttach;

  nsresult rv;

  // all attachments refer to the same message
  const nsCString& messageUri = mAttach->mAttachmentArray[0].mMessageUri;

  // get the message service, original message and folder for this message
  rv = GetMessageServiceFromURI(messageUri, getter_AddRefs(mMessageService));
  NS_ENSURE_SUCCESS(rv, rv);
  rv = mMessageService->MessageURIToMsgHdr(messageUri,
                                           getter_AddRefs(mOriginalMessage));
  NS_ENSURE_SUCCESS(rv, rv);
  rv = mOriginalMessage->GetMessageKey(&mOriginalMessageKey);
  NS_ENSURE_SUCCESS(rv, rv);
  rv = mOriginalMessage->GetFolder(getter_AddRefs(mMessageFolder));
  NS_ENSURE_SUCCESS(rv, rv);
  mOriginalMessage->GetFlags(&mOrigMsgFlags);

  // ensure that we can store and delete messages in this folder, if we
  // can't then we can't do attachment deleting
  bool canDelete = false;
  mMessageFolder->GetCanDeleteMessages(&canDelete);
  bool canFile = false;
  mMessageFolder->GetCanFileMessages(&canFile);
  if (!canDelete || !canFile) return NS_ERROR_FAILURE;

  // create an output stream on a temporary file. This stream will save the
  // modified message data to a file which we will later use to replace the
  // existing message. The file is removed in the destructor.
  rv = GetSpecialDirectoryWithFileName(NS_OS_TEMP_DIR, "nsmail.tmp",
                                       getter_AddRefs(mMsgFile));
  NS_ENSURE_SUCCESS(rv, rv);

  // For temp file, we should use restrictive 00600 instead of
  // ATTACHMENT_PERMISSION
  rv = mMsgFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
  NS_ENSURE_SUCCESS(rv, rv);

  rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mMsgFileStream), mMsgFile,
                                      -1, ATTACHMENT_PERMISSION);

  // Create the additional header for data conversion. This will tell the stream
  // converter which MIME emitter we want to use, and it will tell the MIME
  // emitter which attachments should be deleted.
  // It also supplies the path of the already-saved attachments, so that
  // path can be noted in the message, where those attachements are removed.
  // The X-Mozilla-External-Attachment-URL header will be added, with the
  // location of the saved attachment.
  const char* partId;
  const char* nextField;
  nsAutoCString sHeader("attach&del=");
  nsAutoCString detachToHeader("&detachTo=");
  for (uint32_t u = 0; u < mAttach->mAttachmentArray.Length(); ++u) {
    if (u > 0) {
      sHeader.Append(',');
      if (detaching) detachToHeader.Append(',');
    }
    partId = GetAttachmentPartId(mAttach->mAttachmentArray[u].mUrl.get());
    if (partId) {
      nextField = PL_strchr(partId, '&');
      sHeader.Append(partId, nextField ? nextField - partId : -1);
    }
    if (detaching) {
      // The URI can contain commas, so percent-encode those first.
      nsAutoCString uri(mDetachedFileUris[u]);
      int ind = uri.FindChar(',');
      while (ind != kNotFound) {
        uri.Replace(ind, 1, "%2C");
        ind = uri.FindChar(',');
      }
      detachToHeader.Append(uri);
    }
  }

  if (detaching) sHeader.Append(detachToHeader);
  // stream this message to our listener converting it via the attachment mime
  // converter. The listener will just write the converted message straight to
  // disk.
  nsCOMPtr<nsISupports> listenerSupports;
  rv = this->QueryInterface(NS_GET_IID(nsISupports),
                            getter_AddRefs(listenerSupports));
  NS_ENSURE_SUCCESS(rv, rv);
  nsCOMPtr<nsIUrlListener> listenerUrlListener =
      do_QueryInterface(listenerSupports, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<nsIURI> dummyNull;
  rv = mMessageService->StreamMessage(messageUri, listenerSupports, mMsgWindow,
                                      listenerUrlListener, true, sHeader, false,
                                      getter_AddRefs(dummyNull));
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}

// ------------------------------------

NS_IMETHODIMP
nsMessenger::DetachAttachment(const nsACString& aContentType,
                              const nsACString& aURL,
                              const nsACString& aDisplayName,
                              const nsACString& aMessageUri, bool aSaveFirst,
                              bool withoutWarning = false) {
  if (aSaveFirst)
    return SaveOneAttachment(aContentType, aURL, aDisplayName, aMessageUri,
                             true);
  AutoTArray<nsCString, 1> contentTypeArray = {
      PromiseFlatCString(aContentType)};
  AutoTArray<nsCString, 1> urlArray = {PromiseFlatCString(aURL)};
  AutoTArray<nsCString, 1> displayNameArray = {
      PromiseFlatCString(aDisplayName)};
  AutoTArray<nsCString, 1> messageUriArray = {PromiseFlatCString(aMessageUri)};
  return DetachAttachments(contentTypeArray, urlArray, displayNameArray,
                           messageUriArray, nullptr, nullptr, withoutWarning);
}

NS_IMETHODIMP
nsMessenger::DetachAllAttachments(const nsTArray<nsCString>& aContentTypeArray,
                                  const nsTArray<nsCString>& aUrlArray,
                                  const nsTArray<nsCString>& aDisplayNameArray,
                                  const nsTArray<nsCString>& aMessageUriArray,
                                  bool aSaveFirst,
                                  bool withoutWarning = false) {
  NS_ENSURE_ARG_MIN(aContentTypeArray.Length(), 1);
  MOZ_ASSERT(aContentTypeArray.Length() == aUrlArray.Length() &&
             aUrlArray.Length() == aDisplayNameArray.Length() &&
             aDisplayNameArray.Length() == aMessageUriArray.Length());

  if (aSaveFirst)
    return SaveAllAttachments(aContentTypeArray, aUrlArray, aDisplayNameArray,
                              aMessageUriArray, true);
  else
    return DetachAttachments(aContentTypeArray, aUrlArray, aDisplayNameArray,
                             aMessageUriArray, nullptr, nullptr,
                             withoutWarning);
}

nsresult nsMessenger::DetachAttachments(
    const nsTArray<nsCString>& aContentTypeArray,
    const nsTArray<nsCString>& aUrlArray,
    const nsTArray<nsCString>& aDisplayNameArray,
    const nsTArray<nsCString>& aMessageUriArray,
    nsTArray<nsCString>* saveFileUris, nsIUrlListener* aListener,
    bool withoutWarning) {
  // if withoutWarning no dialog for user
  if (!withoutWarning && NS_FAILED(PromptIfDeleteAttachments(
                             saveFileUris != nullptr, aDisplayNameArray)))
    return NS_OK;

  nsresult rv = NS_OK;

  // ensure that our arguments are valid
  //  char * partId;
  for (uint32_t u = 0; u < aContentTypeArray.Length(); ++u) {
    // ensure all of the message URI are the same, we cannot process
    // attachments from different messages
    if (u > 0 && aMessageUriArray[0] != aMessageUriArray[u]) {
      rv = NS_ERROR_INVALID_ARG;
      break;
    }

    // ensure that we don't have deleted messages in this list
    if (aContentTypeArray[u].EqualsLiteral(MIMETYPE_DELETED)) {
      rv = NS_ERROR_INVALID_ARG;
      break;
    }

    // for the moment we prevent any attachments other than root level
    // attachments being deleted (i.e. you can't delete attachments from a
    // email forwarded as an attachment). We do this by ensuring that the
    // part id only has a single period in it (e.g. "1.2").
    // TODO: support non-root level attachment delete
    //    partId = ::GetAttachmentPartId(aUrlArray[u]);
    //    if (!partId || PL_strchr(partId, '.') != PL_strrchr(partId, '.'))
    //    {
    //      rv = NS_ERROR_INVALID_ARG;
    //      break;
    //    }
  }
  if (NS_FAILED(rv)) {
    Alert("deleteAttachmentFailure");
    return rv;
  }

  // TODO: ensure that nothing else is processing this message uri at the same
  // time

  // TODO: if any of the selected attachments are messages that contain other
  // attachments we need to warn the user that all sub-attachments of those
  // messages will also be deleted. Best to display a list of them.

  RefPtr<AttachmentDeleter> deleter = new AttachmentDeleter;
  deleter->mListener = aListener;
  if (saveFileUris) {
    deleter->mDetachedFileUris = saveFileUris->Clone();
  }
  // create the attachments for use by the deleter
  nsAttachmentState* attach = new nsAttachmentState;
  rv = attach->Init(aContentTypeArray, aUrlArray, aDisplayNameArray,
                    aMessageUriArray);
  if (NS_SUCCEEDED(rv)) rv = attach->PrepareForAttachmentDelete();
  if (NS_FAILED(rv)) {
    delete attach;
    return rv;
  }

  // initialize our deleter with the attachments and details. The deleter
  // takes ownership of 'attach' immediately irrespective of the return value
  // (error or not).
  return deleter->StartProcessing(this, mMsgWindow, attach,
                                  saveFileUris != nullptr);
}

nsresult nsMessenger::PromptIfDeleteAttachments(
    bool aSaveFirst, const nsTArray<nsCString>& aDisplayNameArray) {
  nsresult rv = NS_ERROR_FAILURE;

  nsCOMPtr<nsIPrompt> dialog(do_GetInterface(mDocShell));
  if (!dialog) return rv;

  if (!mStringBundle) {
    rv = InitStringBundle();
    NS_ENSURE_SUCCESS(rv, rv);
  }

  // create the list of attachments we are removing
  nsString displayString;
  nsString attachmentList;
  for (uint32_t u = 0; u < aDisplayNameArray.Length(); ++u) {
    ConvertAndSanitizeFileName(aDisplayNameArray[u], displayString);
    attachmentList.Append(displayString);
    attachmentList.Append(char16_t('\n'));
  }
  AutoTArray<nsString, 1> formatStrings = {attachmentList};

  // format the message and display
  nsString promptMessage;
  const char* propertyName =
      aSaveFirst ? "detachAttachments" : "deleteAttachments";
  rv = mStringBundle->FormatStringFromName(propertyName, formatStrings,
                                           promptMessage);
  NS_ENSURE_SUCCESS(rv, rv);

  bool dialogResult = false;
  rv = dialog->Confirm(nullptr, promptMessage.get(), &dialogResult);
  NS_ENSURE_SUCCESS(rv, rv);

  return dialogResult ? NS_OK : NS_ERROR_FAILURE;
}