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

1 files changed, 1552 insertions, 0 deletions

diff --git a/mailnews/compose/src/nsMsgSendLater.cpp b/mailnews/compose/src/nsMsgSendLater.cpp
new file mode 100644
index 000000000..97206f12b
--- /dev/null
+++ b/mailnews/compose/src/nsMsgSendLater.cpp
@@ -0,0 +1,1552 @@
+/* -*- 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 "nsMsgSendLater.h"
+#include "nsMsgCopy.h"
+#include "nsIMsgSend.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsIMsgMessageService.h"
+#include "nsIMsgAccountManager.h"
+#include "nsMsgBaseCID.h"
+#include "nsMsgCompCID.h"
+#include "nsMsgCompUtils.h"
+#include "nsMsgUtils.h"
+#include "nsMailHeaders.h"
+#include "nsMsgPrompts.h"
+#include "nsISmtpUrl.h"
+#include "nsIChannel.h"
+#include "nsNetUtil.h"
+#include "prlog.h"
+#include "prmem.h"
+#include "nsIMimeConverter.h"
+#include "nsMsgMimeCID.h"
+#include "nsComposeStrings.h"
+#include "nsIMutableArray.h"
+#include "nsArrayEnumerator.h"
+#include "nsIObserverService.h"
+#include "nsIMsgLocalMailFolder.h"
+#include "nsIMsgDatabase.h"
+#include "mozilla/Services.h"
+#include "nsArrayUtils.h"
+
+// Consts for checking and sending mail in milliseconds
+
+// 1 second from mail into the unsent messages folder to initially trying to
+// send it.
+const uint32_t kInitialMessageSendTime = 1000;
+
+NS_IMPL_ISUPPORTS(nsMsgSendLater,
+                   nsIMsgSendLater,
+                   nsIFolderListener,
+                   nsIRequestObserver,
+                   nsIStreamListener,
+                   nsIObserver,
+                   nsIUrlListener,
+                   nsIMsgShutdownTask)
+
+nsMsgSendLater::nsMsgSendLater()
+{
+  mSendingMessages = false;
+  mTimerSet = false;
+  mTotalSentSuccessfully = 0;
+  mTotalSendCount = 0;
+  mLeftoverBuffer = nullptr;
+
+  m_to = nullptr;
+  m_bcc = nullptr;
+  m_fcc = nullptr;
+  m_newsgroups = nullptr;
+  m_newshost = nullptr;
+  m_headers = nullptr;
+  m_flags = 0;
+  m_headersFP = 0;
+  m_inhead = true;
+  m_headersPosition = 0;
+
+  m_bytesRead = 0;
+  m_position = 0;
+  m_flagsPosition = 0;
+  m_headersSize = 0;
+
+  mIdentityKey = nullptr;
+  mAccountKey = nullptr;
+}
+
+nsMsgSendLater::~nsMsgSendLater()
+{
+  PR_Free(m_to);
+  PR_Free(m_fcc);
+  PR_Free(m_bcc);
+  PR_Free(m_newsgroups);
+  PR_Free(m_newshost);
+  PR_Free(m_headers);
+  PR_Free(mLeftoverBuffer);
+  PR_Free(mIdentityKey);
+  PR_Free(mAccountKey);
+}
+
+nsresult
+nsMsgSendLater::Init()
+{
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool sendInBackground;
+  rv = prefs->GetBoolPref("mailnews.sendInBackground", &sendInBackground);
+  // If we're not sending in the background, don't do anything else
+  if (NS_FAILED(rv) || !sendInBackground)
+    return NS_OK;
+
+  // We need to know when we're shutting down.
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  NS_ENSURE_TRUE(observerService, NS_ERROR_UNEXPECTED);
+
+  rv = observerService->AddObserver(this, "xpcom-shutdown", false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = observerService->AddObserver(this, "quit-application", false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = observerService->AddObserver(this, "msg-shutdown", false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Subscribe to the unsent messages folder
+  // XXX This code should be set up for multiple unsent folders, however we
+  // don't support that at the moment, so for now just assume one folder.
+  rv = GetUnsentMessagesFolder(nullptr, getter_AddRefs(mMessageFolder));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mMessageFolder->AddFolderListener(this);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // XXX may want to send messages X seconds after startup if there are any.
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::Observe(nsISupports *aSubject, const char* aTopic,
+                        const char16_t *aData)
+{
+  if (aSubject == mTimer && !strcmp(aTopic, "timer-callback"))
+  {
+    if (mTimer)
+      mTimer->Cancel();
+    else
+      NS_ERROR("mTimer was null in nsMsgSendLater::Observe");
+
+    mTimerSet = false;
+    // If we've already started a send since the timer fired, don't start
+    // another
+    if (!mSendingMessages)
+      InternalSendMessages(false, nullptr);
+  }
+  else if (!strcmp(aTopic, "quit-application"))
+  {
+    // If the timer is set, cancel it - we're quitting, the shutdown service
+    // interfaces will sort out sending etc.
+    if (mTimer)
+      mTimer->Cancel();
+
+    mTimerSet = false;
+  }
+  else if (!strcmp(aTopic, "xpcom-shutdown"))
+  {
+    // We're shutting down. Unsubscribe from the unsentFolder notifications
+    // they aren't any use to us now, we don't want to start sending more
+    // messages.
+    nsresult rv;
+    if (mMessageFolder)
+    {
+      rv = mMessageFolder->RemoveFolderListener(this);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    // Now remove ourselves from the observer service as well.
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+    NS_ENSURE_TRUE(observerService, NS_ERROR_UNEXPECTED);
+
+    rv = observerService->RemoveObserver(this, "xpcom-shutdown");
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = observerService->RemoveObserver(this, "quit-application");
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = observerService->RemoveObserver(this, "msg-shutdown");
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::SetStatusFeedback(nsIMsgStatusFeedback *aFeedback)
+{
+  mFeedback = aFeedback;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::GetStatusFeedback(nsIMsgStatusFeedback **aFeedback)
+{
+  NS_ENSURE_ARG_POINTER(aFeedback);
+  NS_IF_ADDREF(*aFeedback = mFeedback);
+  return NS_OK;
+}
+
+// Stream is done...drive on!
+NS_IMETHODIMP
+nsMsgSendLater::OnStopRequest(nsIRequest *request, nsISupports *ctxt, nsresult status)
+{
+  nsresult    rv;
+
+  // First, this shouldn't happen, but if
+  // it does, flush the buffer and move on.
+  if (mLeftoverBuffer)
+  {
+    DeliverQueuedLine(mLeftoverBuffer, PL_strlen(mLeftoverBuffer));
+  }
+
+  if (mOutFile)
+    mOutFile->Close();
+
+  // See if we succeeded on reading the message from the message store?
+  //
+  if (NS_SUCCEEDED(status))
+  {
+    // Message is done...send it!
+    rv = CompleteMailFileSend();
+
+#ifdef NS_DEBUG
+    printf("nsMsgSendLater: Success on getting message...\n");
+#endif
+    
+    // If the send operation failed..try the next one...
+    if (NS_FAILED(rv))
+    {
+      rv = StartNextMailFileSend(rv);
+      if (NS_FAILED(rv))
+        EndSendMessages(rv, nullptr, mTotalSendCount, mTotalSentSuccessfully);
+    }
+  }
+  else
+  {
+    nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
+    if(!channel) return NS_ERROR_FAILURE;
+
+    // extract the prompt object to use for the alert from the url....
+    nsCOMPtr<nsIURI> uri; 
+    nsCOMPtr<nsIPrompt> promptObject;
+    if (channel)
+    {
+      channel->GetURI(getter_AddRefs(uri));
+      nsCOMPtr<nsISmtpUrl> smtpUrl (do_QueryInterface(uri));
+      if (smtpUrl)
+        smtpUrl->GetPrompt(getter_AddRefs(promptObject));
+    }
+    nsMsgDisplayMessageByName(promptObject, u"errorQueuedDeliveryFailed");
+
+    // Getting the data failed, but we will still keep trying to send the rest...
+    rv = StartNextMailFileSend(status);
+    if (NS_FAILED(rv))
+      EndSendMessages(rv, nullptr, mTotalSendCount, mTotalSentSuccessfully);
+  }
+
+  return rv;
+}
+
+char *
+FindEOL(char *inBuf, char *buf_end)
+{
+  char *buf = inBuf;
+  char *findLoc = nullptr;
+
+  while (buf <= buf_end)
+    if (*buf == 0) 
+      return buf;
+    else if ( (*buf == '\n') || (*buf == '\r') )
+    {
+      findLoc = buf;
+      break;
+    }
+    else
+      ++buf;
+
+  if (!findLoc)
+    return nullptr;
+  else if ((findLoc + 1) > buf_end)
+    return buf;
+
+  if ( (*findLoc == '\n' && *(findLoc+1) == '\r') || 
+       (*findLoc == '\r' && *(findLoc+1) == '\n'))
+    findLoc++; // possibly a pair.       
+  return findLoc;
+}
+
+nsresult
+nsMsgSendLater::RebufferLeftovers(char *startBuf, uint32_t aLen)
+{
+  PR_FREEIF(mLeftoverBuffer);
+  mLeftoverBuffer = (char *)PR_Malloc(aLen + 1);
+  if (!mLeftoverBuffer)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  memcpy(mLeftoverBuffer, startBuf, aLen);
+  mLeftoverBuffer[aLen] = '\0';
+  return NS_OK;
+}
+
+nsresult
+nsMsgSendLater::BuildNewBuffer(const char* aBuf, uint32_t aCount, uint32_t *totalBufSize)
+{
+  // Only build a buffer when there are leftovers...
+  NS_ENSURE_TRUE(mLeftoverBuffer, NS_ERROR_FAILURE);
+
+  int32_t leftoverSize = PL_strlen(mLeftoverBuffer);
+  char* newBuffer = (char *) PR_Realloc(mLeftoverBuffer, aCount + leftoverSize);
+  NS_ENSURE_TRUE(newBuffer, NS_ERROR_OUT_OF_MEMORY);
+  mLeftoverBuffer = newBuffer;
+
+  memcpy(mLeftoverBuffer + leftoverSize, aBuf, aCount);
+  *totalBufSize = aCount + leftoverSize;
+  return NS_OK;
+}
+
+// Got data?
+NS_IMETHODIMP
+nsMsgSendLater::OnDataAvailable(nsIRequest *request, nsISupports *ctxt, nsIInputStream *inStr, uint64_t sourceOffset, uint32_t count)
+{
+  NS_ENSURE_ARG_POINTER(inStr);
+
+  // This is a little bit tricky since we have to chop random 
+  // buffers into lines and deliver the lines...plus keeping the
+  // leftovers for next time...some fun, eh?
+  //
+  nsresult    rv = NS_OK;
+  char        *startBuf;
+  char        *endBuf;
+  char        *lineEnd;
+  char        *newbuf = nullptr;
+  uint32_t    size;
+
+  uint32_t    aCount = count;
+  char        *aBuf = (char *)PR_Malloc(aCount + 1);
+
+  inStr->Read(aBuf, count, &aCount);
+
+  // First, create a new work buffer that will
+  if (NS_FAILED(BuildNewBuffer(aBuf, aCount, &size))) // no leftovers...
+  {
+    startBuf = (char *)aBuf;
+    endBuf = (char *)(aBuf + aCount - 1);
+  }
+  else  // yum, leftovers...new buffer created...sitting in mLeftoverBuffer
+  {
+    newbuf = mLeftoverBuffer;
+    startBuf = newbuf;
+    endBuf = startBuf + size - 1;
+    mLeftoverBuffer = nullptr; // null out this
+  }
+
+  while (startBuf <= endBuf)
+  {
+    lineEnd = FindEOL(startBuf, endBuf);
+    if (!lineEnd)
+    {
+      rv = RebufferLeftovers(startBuf, (endBuf - startBuf) + 1);
+      break;
+    }
+
+    rv = DeliverQueuedLine(startBuf, (lineEnd - startBuf) + 1);
+    if (NS_FAILED(rv))
+      break;
+
+    startBuf = lineEnd+1;
+  }
+
+  PR_Free(newbuf);
+  PR_Free(aBuf);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnStartRunningUrl(nsIURI *url)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnStopRunningUrl(nsIURI *url, nsresult aExitCode)
+{
+  if (NS_SUCCEEDED(aExitCode))
+    InternalSendMessages(mUserInitiated, mIdentity);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
+{
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// This is the listener class for the send operation. We have to create this class 
+// to listen for message send completion and eventually notify the caller
+////////////////////////////////////////////////////////////////////////////////////
+NS_IMPL_ISUPPORTS(SendOperationListener, nsIMsgSendListener,
+                   nsIMsgCopyServiceListener)
+
+SendOperationListener::SendOperationListener(nsMsgSendLater *aSendLater)
+: mSendLater(aSendLater)
+{
+}
+
+SendOperationListener::~SendOperationListener(void) 
+{
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnGetDraftFolderURI(const char *aFolderURI)
+{
+  return NS_OK;
+}
+  
+NS_IMETHODIMP
+SendOperationListener::OnStartSending(const char *aMsgID, uint32_t aMsgSize)
+{
+#ifdef NS_DEBUG
+  printf("SendOperationListener::OnStartSending()\n");
+#endif
+  return NS_OK;
+}
+  
+NS_IMETHODIMP
+SendOperationListener::OnProgress(const char *aMsgID, uint32_t aProgress, uint32_t aProgressMax)
+{
+#ifdef NS_DEBUG
+  printf("SendOperationListener::OnProgress()\n");
+#endif
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnStatus(const char *aMsgID, const char16_t *aMsg)
+{
+#ifdef NS_DEBUG
+  printf("SendOperationListener::OnStatus()\n");
+#endif
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnSendNotPerformed(const char *aMsgID, nsresult aStatus)
+{
+  return NS_OK;
+}
+  
+NS_IMETHODIMP
+SendOperationListener::OnStopSending(const char *aMsgID, nsresult aStatus, const char16_t *aMsg, 
+                                     nsIFile *returnFile)
+{
+  if (mSendLater && !mSendLater->OnSendStepFinished(aStatus))
+      NS_RELEASE(mSendLater);
+
+  return NS_OK;
+}
+
+// nsIMsgCopyServiceListener
+
+NS_IMETHODIMP
+SendOperationListener::OnStartCopy(void)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnProgress(uint32_t aProgress, uint32_t aProgressMax)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+SendOperationListener::SetMessageKey(nsMsgKey aKey)
+{
+  NS_NOTREACHED("SendOperationListener::SetMessageKey()");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+SendOperationListener::GetMessageId(nsACString& messageId)
+{
+  NS_NOTREACHED("SendOperationListener::GetMessageId()\n");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+SendOperationListener::OnStopCopy(nsresult aStatus)
+{
+  if (mSendLater)
+  {
+    mSendLater->OnCopyStepFinished(aStatus);
+    NS_RELEASE(mSendLater);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsMsgSendLater::CompleteMailFileSend()
+{
+  // get the identity from the key
+  // if no key, or we fail to find the identity
+  // use the default identity on the default account
+  nsCOMPtr<nsIMsgIdentity> identity;
+  nsresult rv = GetIdentityFromKey(mIdentityKey, getter_AddRefs(identity));
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // If for some reason the tmp file didn't get created, we've failed here
+  bool created;
+  mTempFile->Exists(&created);
+  if (!created)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMsgCompFields> compFields = do_CreateInstance(NS_MSGCOMPFIELDS_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  nsCOMPtr<nsIMsgSend> pMsgSend = do_CreateInstance(NS_MSGSEND_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  // Since we have already parsed all of the headers, we are simply going to
+  // set the composition fields and move on.
+  nsCString author;
+  mMessage->GetAuthor(getter_Copies(author));
+
+  nsMsgCompFields * fields = (nsMsgCompFields *)compFields.get();
+
+  fields->SetFrom(author.get());
+
+  if (m_to)
+  {
+    fields->SetTo(m_to);
+  }
+
+  if (m_bcc)
+  {
+    fields->SetBcc(m_bcc);
+  }
+
+  if (m_fcc)
+  {
+    fields->SetFcc(m_fcc);
+  }
+
+  if (m_newsgroups)
+    fields->SetNewsgroups(m_newsgroups);
+
+#if 0
+  // needs cleanup. Is this needed?
+  if (m_newshost)
+    fields->SetNewspostUrl(m_newshost);
+#endif
+
+  // Create the listener for the send operation...
+  SendOperationListener *sendListener = new SendOperationListener(this);
+  if (!sendListener)
+    return NS_ERROR_OUT_OF_MEMORY;
+  
+  NS_ADDREF(sendListener);
+
+  NS_ADDREF(this);  //TODO: We should remove this!!!
+  rv = pMsgSend->SendMessageFile(identity,
+                                 mAccountKey,
+                                 compFields, // nsIMsgCompFields *fields,
+                                 mTempFile, // nsIFile *sendFile,
+                                 true, // bool deleteSendFileOnCompletion,
+                                 false, // bool digest_p,
+                                 nsIMsgSend::nsMsgSendUnsent, // nsMsgDeliverMode mode,
+                                 nullptr, // nsIMsgDBHdr *msgToReplace, 
+                                 sendListener,
+                                 mFeedback,
+                                 nullptr); 
+  NS_RELEASE(sendListener);
+  return rv;
+}
+
+nsresult
+nsMsgSendLater::StartNextMailFileSend(nsresult prevStatus)
+{
+  bool hasMoreElements = false;
+  if ((!mEnumerator) ||
+      NS_FAILED(mEnumerator->HasMoreElements(&hasMoreElements)) ||
+      !hasMoreElements)
+  {
+    // Notify that this message has finished being sent.
+    NotifyListenersOnProgress(mTotalSendCount, mMessagesToSend.Count(), 100, 100);
+
+    // EndSendMessages resets everything for us
+    EndSendMessages(prevStatus, nullptr, mTotalSendCount, mTotalSentSuccessfully);
+
+    // XXX Should we be releasing references so that we don't hold onto items
+    // unnecessarily.
+    return NS_OK;
+  }
+
+  // If we've already sent a message, and are sending more, send out a progress
+  // update with 100% for both send and copy as we must have finished by now.
+  if (mTotalSendCount)
+    NotifyListenersOnProgress(mTotalSendCount, mMessagesToSend.Count(), 100, 100);
+
+  nsCOMPtr<nsISupports> currentItem;
+  nsresult rv = mEnumerator->GetNext(getter_AddRefs(currentItem));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mMessage = do_QueryInterface(currentItem); 
+  if (!mMessage)
+    return NS_ERROR_NOT_AVAILABLE;
+
+  if (!mMessageFolder)
+    return NS_ERROR_UNEXPECTED;
+
+  nsCString messageURI;
+  mMessageFolder->GetUriForMsg(mMessage, messageURI);
+
+  rv = nsMsgCreateTempFile("nsqmail.tmp", getter_AddRefs(mTempFile)); 
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgMessageService> messageService;
+  rv = GetMessageServiceFromURI(messageURI, getter_AddRefs(messageService));
+  if (NS_FAILED(rv) && !messageService)
+    return NS_ERROR_FACTORY_NOT_LOADED;
+
+  ++mTotalSendCount;
+
+  nsCString identityKey;
+  rv = mMessage->GetStringProperty(HEADER_X_MOZILLA_IDENTITY_KEY,
+                                   getter_Copies(identityKey));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIMsgIdentity> identity;
+  rv = GetIdentityFromKey(identityKey.get(), getter_AddRefs(identity));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Notify that we're just about to start sending this message
+  NotifyListenersOnMessageStartSending(mTotalSendCount, mMessagesToSend.Count(),
+                                       identity);
+
+  // Setup what we need to parse the data stream correctly
+  m_inhead = true;
+  m_headersFP = 0;
+  m_headersPosition = 0;
+  m_bytesRead = 0;
+  m_position = 0;
+  m_flagsPosition = 0;
+  m_headersSize = 0;
+  PR_FREEIF(mLeftoverBuffer);
+
+  // Now, get our stream listener interface and plug it into the DisplayMessage
+  // operation
+  AddRef();
+
+  nsCOMPtr<nsIURI> dummyNull;
+  rv = messageService->DisplayMessage(messageURI.get(),
+                                      static_cast<nsIStreamListener*>(this),
+                                      nullptr, nullptr, nullptr,
+                                      getter_AddRefs(dummyNull));
+
+  Release();
+
+  return rv;
+}
+
+NS_IMETHODIMP 
+nsMsgSendLater::GetUnsentMessagesFolder(nsIMsgIdentity *aIdentity, nsIMsgFolder **folder)
+{
+  nsCString uri;
+  GetFolderURIFromUserPrefs(nsIMsgSend::nsMsgQueueForLater, aIdentity, uri);
+  return LocateMessageFolder(aIdentity, nsIMsgSend::nsMsgQueueForLater,
+                             uri.get(), folder);
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::HasUnsentMessages(nsIMsgIdentity *aIdentity, bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  nsresult rv;
+
+  nsCOMPtr<nsIMsgAccountManager> accountManager =
+    do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIArray> accounts;
+  accountManager->GetAccounts(getter_AddRefs(accounts));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t cnt = 0;
+  rv = accounts->GetLength(&cnt);
+  if (cnt == 0) {
+    *aResult = false;
+    return NS_OK; // no account set up -> no unsent messages
+  }
+
+  // XXX This code should be set up for multiple unsent folders, however we
+  // don't support that at the moment, so for now just assume one folder.
+  if (!mMessageFolder)
+  {
+    rv = GetUnsentMessagesFolder(nullptr,
+                                 getter_AddRefs(mMessageFolder));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  rv = ReparseDBIfNeeded(nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t totalMessages;
+  rv = mMessageFolder->GetTotalMessages(false, &totalMessages);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  *aResult = totalMessages > 0;
+  return NS_OK;
+}
+
+//
+// To really finalize this capability, we need to have the ability to get
+// the message from the mail store in a stream for processing. The flow 
+// would be something like this:
+//
+//      foreach (message in Outbox folder)
+//         get stream of Nth message
+//         if (not done with headers)
+//            Tack on to current buffer of headers
+//         when done with headers
+//            BuildHeaders()
+//            Write Headers to Temp File
+//         after done with headers
+//            write rest of message body to temp file
+//
+//          when done with the message
+//            do send operation
+//
+//          when send is complete
+//            Copy from Outbox to FCC folder
+//            Delete from Outbox folder
+//
+//
+NS_IMETHODIMP 
+nsMsgSendLater::SendUnsentMessages(nsIMsgIdentity *aIdentity)
+{
+  return InternalSendMessages(true, aIdentity);
+}
+
+// Returns NS_OK if the db is OK, an error otherwise, e.g., we had to reparse.
+nsresult nsMsgSendLater::ReparseDBIfNeeded(nsIUrlListener *aListener)
+{
+  // This will kick off a reparse, if needed. So the next time we check if
+  // there are unsent messages, the db will be up to date.
+  nsCOMPtr<nsIMsgDatabase> unsentDB;
+  nsresult rv;
+  nsCOMPtr<nsIMsgLocalMailFolder> locFolder(do_QueryInterface(mMessageFolder, &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+  return locFolder->GetDatabaseWithReparse(aListener, nullptr,
+                                           getter_AddRefs(unsentDB));
+}
+
+nsresult
+nsMsgSendLater::InternalSendMessages(bool aUserInitiated,
+                                     nsIMsgIdentity *aIdentity)
+{
+  if (WeAreOffline())
+    return NS_MSG_ERROR_OFFLINE;
+
+  // Protect against being called whilst we're already sending.
+  if (mSendingMessages)
+  {
+    NS_ERROR("nsMsgSendLater is already sending messages\n");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv;
+
+  // XXX This code should be set up for multiple unsent folders, however we
+  // don't support that at the moment, so for now just assume one folder.
+  if (!mMessageFolder)
+  {
+    rv = GetUnsentMessagesFolder(nullptr,
+                                 getter_AddRefs(mMessageFolder));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  nsCOMPtr<nsIMsgDatabase> unsentDB;
+  // Remember these in case we need to reparse the db.
+  mUserInitiated = aUserInitiated;
+  mIdentity = aIdentity;
+  rv = ReparseDBIfNeeded(this);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mIdentity = nullptr; // don't hold onto the identity since we're a service.
+
+  nsCOMPtr<nsISimpleEnumerator> enumerator;
+  rv = mMessageFolder->GetMessages(getter_AddRefs(enumerator));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // copy all the elements in the enumerator into our isupports array....
+
+  nsCOMPtr<nsISupports> currentItem;
+  nsCOMPtr<nsIMsgDBHdr> messageHeader;
+  bool hasMoreElements = false;
+  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMoreElements)) && hasMoreElements)
+  {
+    rv = enumerator->GetNext(getter_AddRefs(currentItem));
+    if (NS_SUCCEEDED(rv))
+    {
+      messageHeader = do_QueryInterface(currentItem, &rv);
+      if (NS_SUCCEEDED(rv))
+      {
+        if (aUserInitiated)
+          // If the user initiated the send, add all messages
+          mMessagesToSend.AppendObject(messageHeader);
+        else
+        {
+          // Else just send those that are NOT marked as Queued.
+          uint32_t flags;
+          rv = messageHeader->GetFlags(&flags);
+          if (NS_SUCCEEDED(rv) && !(flags & nsMsgMessageFlags::Queued))
+            mMessagesToSend.AppendObject(messageHeader);
+        }  
+      }
+    }
+  }
+
+  // Now get an enumerator for our array.
+  rv = NS_NewArrayEnumerator(getter_AddRefs(mEnumerator), mMessagesToSend);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // We're now sending messages so its time to signal that and reset our counts.
+  mSendingMessages = true;
+  mTotalSentSuccessfully = 0;
+  mTotalSendCount = 0;
+
+  // Notify the listeners that we are starting a send.
+  NotifyListenersOnStartSending(mMessagesToSend.Count());
+
+  return StartNextMailFileSend(NS_OK);
+}
+
+nsresult nsMsgSendLater::SetOrigMsgDisposition()
+{
+  if (!mMessage)
+    return NS_ERROR_NULL_POINTER;
+
+  // We're finished sending a queued message. We need to look at mMessage 
+  // and see if we need to set replied/forwarded
+  // flags for the original message that this message might be a reply to
+  // or forward of.
+  nsCString originalMsgURIs;
+  nsCString queuedDisposition;
+  mMessage->GetStringProperty(ORIG_URI_PROPERTY, getter_Copies(originalMsgURIs));
+  mMessage->GetStringProperty(QUEUED_DISPOSITION_PROPERTY, getter_Copies(queuedDisposition));
+  if (!queuedDisposition.IsEmpty())
+  {
+    nsTArray<nsCString> uriArray;
+    ParseString(originalMsgURIs, ',', uriArray);
+    for (uint32_t i = 0; i < uriArray.Length(); i++)
+    {
+      nsCOMPtr <nsIMsgDBHdr> msgHdr;
+      nsresult rv = GetMsgDBHdrFromURI(uriArray[i].get(), getter_AddRefs(msgHdr));
+      NS_ENSURE_SUCCESS(rv,rv);
+      if (msgHdr)
+      {
+        // get the folder for the message resource
+        nsCOMPtr<nsIMsgFolder> msgFolder;
+        msgHdr->GetFolder(getter_AddRefs(msgFolder));
+        if (msgFolder)
+        {
+          nsMsgDispositionState dispositionSetting = nsIMsgFolder::nsMsgDispositionState_Replied;
+          if (queuedDisposition.Equals("forwarded"))
+            dispositionSetting = nsIMsgFolder::nsMsgDispositionState_Forwarded;
+          
+          msgFolder->AddMessageDispositionState(msgHdr, dispositionSetting);
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsMsgSendLater::DeleteCurrentMessage()
+{
+  if (!mMessage)
+  {
+    NS_ERROR("nsMsgSendLater: Attempt to delete an already deleted message");
+    return NS_OK;
+  }
+
+  // Get the composition fields interface
+  nsCOMPtr<nsIMutableArray> msgArray(do_CreateInstance(NS_ARRAY_CONTRACTID));
+  if (!msgArray)
+    return NS_ERROR_FACTORY_NOT_LOADED;
+
+  if (!mMessageFolder)
+    return NS_ERROR_UNEXPECTED;
+
+  msgArray->InsertElementAt(mMessage, 0, false);
+
+  nsresult res = mMessageFolder->DeleteMessages(msgArray, nullptr, true, false, nullptr, false /*allowUndo*/);
+  if (NS_FAILED(res))
+    return NS_ERROR_FAILURE;
+
+  // Null out the message so we don't try and delete it again.
+  mMessage = nullptr;
+
+  return NS_OK;
+}
+
+//
+// This function parses the headers, and also deletes from the header block
+// any headers which should not be delivered in mail, regardless of whether
+// they were present in the queue file.  Such headers include: BCC, FCC,
+// Sender, X-Mozilla-Status, X-Mozilla-News-Host, and Content-Length.
+// (Content-Length is for the disk file only, and must not be allowed to
+// escape onto the network, since it depends on the local linebreak
+// representation.  Arguably, we could allow Lines to escape, but it's not
+// required by NNTP.)
+//
+nsresult
+nsMsgSendLater::BuildHeaders()
+{
+  char *buf = m_headers;
+  char *buf_end = buf + m_headersFP;
+
+  PR_FREEIF(m_to);
+  PR_FREEIF(m_bcc);
+  PR_FREEIF(m_newsgroups);
+  PR_FREEIF(m_newshost);
+  PR_FREEIF(m_fcc);
+  PR_FREEIF(mIdentityKey);
+  PR_FREEIF(mAccountKey);
+  m_flags = 0;
+
+  while (buf < buf_end)
+  {
+    bool prune_p = false;
+    bool do_flags_p = false;
+    char *colon = PL_strchr(buf, ':');
+    char *end;
+    char *value = 0;
+    char **header = 0;
+    char *header_start = buf;
+
+    if (! colon)
+      break;
+
+    end = colon;
+    while (end > buf && (*end == ' ' || *end == '\t'))
+      end--;
+
+    switch (buf [0])
+    {
+    case 'B': case 'b':
+      if (!PL_strncasecmp ("BCC", buf, end - buf))
+      {
+        header = &m_bcc;
+        prune_p = true;
+      }
+      break;
+    case 'C': case 'c':
+      if (!PL_strncasecmp ("CC", buf, end - buf))
+      header = &m_to;
+      else if (!PL_strncasecmp (HEADER_CONTENT_LENGTH, buf, end - buf))
+      prune_p = true;
+      break;
+    case 'F': case 'f':
+      if (!PL_strncasecmp ("FCC", buf, end - buf))
+      {
+        header = &m_fcc;
+        prune_p = true;
+      }
+      break;
+    case 'L': case 'l':
+      if (!PL_strncasecmp ("Lines", buf, end - buf))
+      prune_p = true;
+      break;
+    case 'N': case 'n':
+      if (!PL_strncasecmp ("Newsgroups", buf, end - buf))
+        header = &m_newsgroups;
+      break;
+    case 'S': case 's':
+      if (!PL_strncasecmp ("Sender", buf, end - buf))
+      prune_p = true;
+      break;
+    case 'T': case 't':
+      if (!PL_strncasecmp ("To", buf, end - buf))
+      header = &m_to;
+      break;
+    case 'X': case 'x':
+      {
+        if (buf + strlen(HEADER_X_MOZILLA_STATUS2) == end &&
+          !PL_strncasecmp(HEADER_X_MOZILLA_STATUS2, buf, end - buf))
+          prune_p = true;
+        else if (buf + strlen(HEADER_X_MOZILLA_STATUS) == end &&
+          !PL_strncasecmp(HEADER_X_MOZILLA_STATUS, buf, end - buf))
+          prune_p = do_flags_p = true;
+        else if (!PL_strncasecmp(HEADER_X_MOZILLA_DRAFT_INFO, buf, end - buf))
+          prune_p = true;
+        else if (!PL_strncasecmp(HEADER_X_MOZILLA_KEYWORDS, buf, end - buf))
+          prune_p = true;
+        else if (!PL_strncasecmp(HEADER_X_MOZILLA_NEWSHOST, buf, end - buf))
+        {
+          prune_p = true;
+          header = &m_newshost;
+        }
+        else if (!PL_strncasecmp(HEADER_X_MOZILLA_IDENTITY_KEY, buf, end - buf))
+        {
+          prune_p = true;
+          header = &mIdentityKey;
+        }
+        else if (!PL_strncasecmp(HEADER_X_MOZILLA_ACCOUNT_KEY, buf, end - buf))
+        {
+          prune_p = true;
+          header = &mAccountKey;
+        }
+        break;
+      }
+    }
+
+    buf = colon + 1;
+    while (*buf == ' ' || *buf == '\t')
+    buf++;
+
+    value = buf;
+
+SEARCH_NEWLINE:
+    while (*buf != 0 && *buf != '\r' && *buf != '\n')
+      buf++;
+
+    if (buf+1 >= buf_end)
+      ;
+    // If "\r\n " or "\r\n\t" is next, that doesn't terminate the header.
+    else if (buf+2 < buf_end &&
+         (buf[0] == '\r'  && buf[1] == '\n') &&
+         (buf[2] == ' ' || buf[2] == '\t'))
+    {
+      buf += 3;
+      goto SEARCH_NEWLINE;
+    }
+    // If "\r " or "\r\t" or "\n " or "\n\t" is next, that doesn't terminate
+    // the header either. 
+    else if ((buf[0] == '\r'  || buf[0] == '\n') &&
+         (buf[1] == ' ' || buf[1] == '\t'))
+    {
+      buf += 2;
+      goto SEARCH_NEWLINE;
+    }
+
+    if (header)
+    {
+      int L = buf - value;
+      if (*header)
+      {
+        char *newh = (char*) PR_Realloc ((*header),
+                         PL_strlen(*header) + L + 10);
+        if (!newh) return NS_ERROR_OUT_OF_MEMORY;
+        *header = newh;
+        newh = (*header) + PL_strlen (*header);
+        *newh++ = ',';
+        *newh++ = ' ';
+        memcpy(newh, value, L);
+        newh [L] = 0;
+      }
+      else
+      {
+        *header = (char *) PR_Malloc(L+1);
+        if (!*header) return NS_ERROR_OUT_OF_MEMORY;
+        memcpy((*header), value, L);
+        (*header)[L] = 0;
+      }
+    }
+    else if (do_flags_p)
+    {
+      char *s = value;
+      PR_ASSERT(*s != ' ' && *s != '\t');
+      NS_ASSERTION(MsgIsHex(s, 4), "Expected 4 hex digits for flags.");
+      m_flags = MsgUnhex(s, 4);
+    }
+
+    if (*buf == '\r' || *buf == '\n')
+    {
+      if (*buf == '\r' && buf[1] == '\n')
+      buf++;
+      buf++;
+    }
+
+    if (prune_p)
+    {
+      char *to = header_start;
+      char *from = buf;
+      while (from < buf_end)
+      *to++ = *from++;
+      buf = header_start;
+      buf_end = to;
+      m_headersFP = buf_end - m_headers;
+    }
+  }
+
+  m_headers[m_headersFP++] = '\r';
+  m_headers[m_headersFP++] = '\n';
+
+  // Now we have parsed out all of the headers we need and we 
+  // can proceed.
+  return NS_OK;
+}
+
+nsresult
+DoGrowBuffer(int32_t desired_size, int32_t element_size, int32_t quantum,
+            char **buffer, int32_t *size)
+{
+  if (*size <= desired_size)
+  {
+    char *new_buf;
+    int32_t increment = desired_size - *size;
+    if (increment < quantum) // always grow by a minimum of N bytes 
+      increment = quantum;
+    
+    new_buf = (*buffer
+                ? (char *) PR_Realloc (*buffer, (*size + increment)
+                * (element_size / sizeof(char)))
+                : (char *) PR_Malloc ((*size + increment)
+                * (element_size / sizeof(char))));
+    if (! new_buf)
+      return NS_ERROR_OUT_OF_MEMORY;
+    *buffer = new_buf;
+    *size += increment;
+  }
+  return NS_OK;
+}
+
+#define do_grow_headers(desired_size) \
+  (((desired_size) >= m_headersSize) ? \
+   DoGrowBuffer ((desired_size), sizeof(char), 1024, \
+           &m_headers, &m_headersSize) \
+   : NS_OK)
+
+nsresult
+nsMsgSendLater::DeliverQueuedLine(char *line, int32_t length)
+{
+  int32_t flength = length;
+  
+  m_bytesRead += length;
+  
+// convert existing newline to CRLF 
+// Don't need this because the calling routine is taking care of it.
+//  if (length > 0 && (line[length-1] == '\r' || 
+//     (line[length-1] == '\n' && (length < 2 || line[length-2] != '\r'))))
+//  {
+//    line[length-1] = '\r';
+//    line[length++] = '\n';
+//  }
+//
+  //
+  // We are going to check if we are looking at a "From - " line. If so, 
+  // then just eat it and return NS_OK
+  //
+  if (!PL_strncasecmp(line, "From - ", 7))
+    return NS_OK;
+
+  if (m_inhead)
+  {
+    if (m_headersPosition == 0)
+    {
+      // This line is the first line in a header block.
+      // Remember its position.
+      m_headersPosition = m_position;
+      
+      // Also, since we're now processing the headers, clear out the
+      // slots which we will parse data into, so that the values that
+      // were used the last time around do not persist.
+      
+      // We must do that here, and not in the previous clause of this
+      // `else' (the "I've just seen a `From ' line clause") because
+      // that clause happens before delivery of the previous message is
+      // complete, whereas this clause happens after the previous msg
+      // has been delivered.  If we did this up there, then only the
+      // last message in the folder would ever be able to be both
+      // mailed and posted (or fcc'ed.)
+      PR_FREEIF(m_to);
+      PR_FREEIF(m_bcc);
+      PR_FREEIF(m_newsgroups);
+      PR_FREEIF(m_newshost);
+      PR_FREEIF(m_fcc);
+      PR_FREEIF(mIdentityKey);
+    }
+    
+    if (line[0] == '\r' || line[0] == '\n' || line[0] == 0)
+    {
+      // End of headers.  Now parse them; open the temp file;
+      // and write the appropriate subset of the headers out. 
+      m_inhead = false;
+
+      nsresult rv = MsgNewBufferedFileOutputStream(getter_AddRefs(mOutFile), mTempFile, -1, 00600);
+      if (NS_FAILED(rv))
+        return NS_MSG_ERROR_WRITING_FILE;
+
+      nsresult status = BuildHeaders();
+      if (NS_FAILED(status))
+        return status;
+
+      uint32_t n;
+      rv = mOutFile->Write(m_headers, m_headersFP, &n);
+      if (NS_FAILED(rv) || n != (uint32_t)m_headersFP)
+        return NS_MSG_ERROR_WRITING_FILE;
+    }
+    else
+    {
+      // Otherwise, this line belongs to a header.  So append it to the
+      // header data.
+      
+      if (!PL_strncasecmp (line, HEADER_X_MOZILLA_STATUS, PL_strlen(HEADER_X_MOZILLA_STATUS)))
+        // Notice the position of the flags.
+        m_flagsPosition = m_position;
+      else if (m_headersFP == 0)
+        m_flagsPosition = 0;
+      
+      nsresult status = do_grow_headers (length + m_headersFP + 10);
+      if (NS_FAILED(status)) 
+        return status;
+      
+      memcpy(m_headers + m_headersFP, line, length);
+      m_headersFP += length;
+    }
+  }
+  else
+  {
+    // This is a body line.  Write it to the file.
+    PR_ASSERT(mOutFile);
+    if (mOutFile)
+    {
+      uint32_t wrote;
+      nsresult rv = mOutFile->Write(line, length, &wrote);
+      if (NS_FAILED(rv) || wrote < (uint32_t) length) 
+        return NS_MSG_ERROR_WRITING_FILE;
+    }
+  }
+  
+  m_position += flength;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::AddListener(nsIMsgSendLaterListener *aListener)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+  mListenerArray.AppendElement(aListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::RemoveListener(nsIMsgSendLaterListener *aListener)
+{
+  NS_ENSURE_ARG_POINTER(aListener);
+  return mListenerArray.RemoveElement(aListener) ? NS_OK : NS_ERROR_INVALID_ARG;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::GetSendingMessages(bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = mSendingMessages;
+  return NS_OK;
+}
+
+#define NOTIFY_LISTENERS(propertyfunc_, params_) \
+  PR_BEGIN_MACRO                                 \
+  nsTObserverArray<nsCOMPtr<nsIMsgSendLaterListener> >::ForwardIterator iter(mListenerArray); \
+  nsCOMPtr<nsIMsgSendLaterListener> listener;    \
+  while (iter.HasMore()) {                       \
+    listener = iter.GetNext();                   \
+    listener->propertyfunc_ params_;             \
+  }                                              \
+  PR_END_MACRO
+
+void
+nsMsgSendLater::NotifyListenersOnStartSending(uint32_t aTotalMessageCount)
+{
+  NOTIFY_LISTENERS(OnStartSending, (aTotalMessageCount));
+}
+
+void
+nsMsgSendLater::NotifyListenersOnMessageStartSending(uint32_t aCurrentMessage,
+                                                     uint32_t aTotalMessage,
+                                                     nsIMsgIdentity *aIdentity)
+{
+  NOTIFY_LISTENERS(OnMessageStartSending, (aCurrentMessage, aTotalMessage,
+                                           mMessage, aIdentity));
+}
+
+void
+nsMsgSendLater::NotifyListenersOnProgress(uint32_t aCurrentMessage,
+                                          uint32_t aTotalMessage,
+                                          uint32_t aSendPercent,
+                                          uint32_t aCopyPercent)
+{
+  NOTIFY_LISTENERS(OnMessageSendProgress, (aCurrentMessage, aTotalMessage,
+                                           aSendPercent, aCopyPercent));
+}
+
+void
+nsMsgSendLater::NotifyListenersOnMessageSendError(uint32_t aCurrentMessage,
+                                                  nsresult aStatus,
+                                                  const char16_t *aMsg)
+{
+  NOTIFY_LISTENERS(OnMessageSendError, (aCurrentMessage, mMessage,
+                                        aStatus, aMsg));
+}
+
+/**
+ * This function is called to end sending of messages, it resets the send later
+ * system and notifies the relevant parties that we have finished.
+ */
+void
+nsMsgSendLater::EndSendMessages(nsresult aStatus, const char16_t *aMsg,
+                                uint32_t aTotalTried, uint32_t aSuccessful)
+{
+  // Catch-all, we may have had an issue sending, so we may not be calling
+  // StartNextMailFileSend to fully finish the sending. Therefore set
+  // mSendingMessages to false here so that we don't think we're still trying
+  // to send messages
+  mSendingMessages = false;
+
+  // Clear out our array of messages.
+  mMessagesToSend.Clear();
+
+  // We don't need to keep hold of the database now we've finished sending.
+  (void)mMessageFolder->SetMsgDatabase(nullptr);
+
+  // or the enumerator, temp file or output stream
+  mEnumerator = nullptr;
+  mTempFile = nullptr;
+  mOutFile = nullptr;  
+
+  NOTIFY_LISTENERS(OnStopSending, (aStatus, aMsg, aTotalTried, aSuccessful));
+
+  // If we've got a shutdown listener, notify it that we've finished.
+  if (mShutdownListener)
+  {
+    mShutdownListener->OnStopRunningUrl(nullptr, NS_OK);
+    mShutdownListener = nullptr;
+  }
+}
+
+/**
+ * Called when the send part of sending a message is finished. This will set up
+ * for the next step or "end" depending on the status.
+ *
+ * @param aStatus  The success or fail result of the send step.
+ * @return         True if the copy process will continue, false otherwise.
+ */
+bool
+nsMsgSendLater::OnSendStepFinished(nsresult aStatus)
+{
+  if (NS_SUCCEEDED(aStatus))
+  {
+    SetOrigMsgDisposition();
+    DeleteCurrentMessage();
+
+    // Send finished, so that is now 100%, copy to proceed...
+    NotifyListenersOnProgress(mTotalSendCount, mMessagesToSend.Count(), 100, 0);
+
+    ++mTotalSentSuccessfully;
+    return true;
+  }
+  else
+  {
+    // XXX we don't currently get a message string from the send service.
+    NotifyListenersOnMessageSendError(mTotalSendCount, aStatus, nullptr);
+    nsresult rv = StartNextMailFileSend(aStatus);
+    // if this is the last message we're sending, we should report
+    // the status failure.
+    if (NS_FAILED(rv))
+      EndSendMessages(rv, nullptr, mTotalSendCount, mTotalSentSuccessfully);
+  }
+  return false;
+}
+
+/**
+ * Called when the copy part of sending a message is finished. This will send
+ * the next message or handle failure as appropriate.
+ *
+ * @param aStatus  The success or fail result of the copy step.
+ */
+void
+nsMsgSendLater::OnCopyStepFinished(nsresult aStatus)
+{
+  // Regardless of the success of the copy we will still keep trying
+  // to send the rest...
+  nsresult rv = StartNextMailFileSend(aStatus);
+  if (NS_FAILED(rv))
+    EndSendMessages(rv, nullptr, mTotalSendCount, mTotalSentSuccessfully);
+}
+
+// XXX todo
+// maybe this should just live in the account manager?
+nsresult
+nsMsgSendLater::GetIdentityFromKey(const char *aKey, nsIMsgIdentity  **aIdentity)
+{
+  NS_ENSURE_ARG_POINTER(aIdentity);
+
+  nsresult rv;
+  nsCOMPtr<nsIMsgAccountManager> accountManager = 
+    do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv,rv);
+
+  if (aKey)
+  {
+    nsCOMPtr<nsIArray> identities;
+    if (NS_SUCCEEDED(accountManager->GetAllIdentities(getter_AddRefs(identities))))
+    {
+      nsCOMPtr<nsIMsgIdentity> lookupIdentity;
+      uint32_t count = 0;
+
+      identities->GetLength(&count);
+      for (uint32_t i = 0; i < count; i++)
+      {
+        lookupIdentity = do_QueryElementAt(identities, i, &rv);
+        if (NS_FAILED(rv))
+          continue;
+
+        nsCString key;
+        lookupIdentity->GetKey(key);
+        if (key.Equals(aKey))
+        {
+          NS_IF_ADDREF(*aIdentity = lookupIdentity);
+          return NS_OK;
+        }
+      }
+    }
+  }
+
+  // if no aKey, or we failed to find the identity from the key
+  // use the identity from the default account.
+  nsCOMPtr<nsIMsgAccount> defaultAccount;
+  rv = accountManager->GetDefaultAccount(getter_AddRefs(defaultAccount));
+  NS_ENSURE_SUCCESS(rv,rv);
+  
+  rv = defaultAccount->GetDefaultIdentity(aIdentity);
+  NS_ENSURE_SUCCESS(rv,rv);
+  return rv;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemAdded(nsIMsgFolder *aParentItem, nsISupports *aItem)
+{
+  // No need to trigger if timer is already set
+  if (mTimerSet)
+    return NS_OK;
+
+  // XXX only trigger for non-queued headers
+
+  // Items from this function return NS_OK because the callee won't care about
+  // the result anyway.
+  nsresult rv;
+  if (!mTimer)
+  {
+    mTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
+    NS_ENSURE_SUCCESS(rv, NS_OK);
+  }
+
+  rv = mTimer->Init(static_cast<nsIObserver*>(this), kInitialMessageSendTime,
+                    nsITimer::TYPE_ONE_SHOT);
+  NS_ENSURE_SUCCESS(rv, NS_OK);
+
+  mTimerSet = true;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemRemoved(nsIMsgFolder *aParentItem, nsISupports *aItem)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemPropertyChanged(nsIMsgFolder *aItem, nsIAtom *aProperty,
+                                      const char* aOldValue,
+                                      const char* aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemIntPropertyChanged(nsIMsgFolder *aItem, nsIAtom *aProperty,
+                                         int64_t aOldValue, int64_t aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemBoolPropertyChanged(nsIMsgFolder *aItem, nsIAtom *aProperty,
+                                          bool aOldValue, bool aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemUnicharPropertyChanged(nsIMsgFolder *aItem,
+                                             nsIAtom *aProperty,
+                                             const char16_t* aOldValue,
+                                             const char16_t* aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemPropertyFlagChanged(nsIMsgDBHdr *aItem, nsIAtom *aProperty,
+                                          uint32_t aOldValue, uint32_t aNewValue)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::OnItemEvent(nsIMsgFolder* aItem, nsIAtom *aEvent)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::GetNeedsToRunTask(bool *aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+  *aResult = mSendingMessages;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::DoShutdownTask(nsIUrlListener *aListener, nsIMsgWindow *aWindow,
+                               bool *aResult)
+{
+  if (mTimer)
+    mTimer->Cancel();
+  // If we're already sending messages, nothing to do, but save the shutdown
+  // listener until we've finished.
+  if (mSendingMessages)
+  {
+    mShutdownListener = aListener;
+    return NS_OK;
+  }
+  // Else we have pending messages, we need to throw up a dialog to find out
+  // if to send them or not.
+
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMsgSendLater::GetCurrentTaskName(nsAString &aResult)
+{
+  // XXX Bug 440794 will localize this, left as non-localized whilst we decide
+  // on the actual strings and try out the UI.
+  aResult = NS_LITERAL_STRING("Sending Messages");
+  return NS_OK;
+}