Bug 1326433 - Port bug 1323683 to mailnews: Whitespace fixes for modified files. r=jorgk CLOSED TREE
authorFrank-Rainer Grahl <frgrahl@gmx.net>
Fri, 30 Dec 2016 22:53:15 +0100
changeset 20944 e84176264e2b82b8eb362ff63e879537be53e4b7
parent 20943 f7bc43a2fcccb6c5c4e8cd74221ee79c82c71664
child 20945 3c3539b7c5d8f3b35b699166a12064c467a3fe2b
push id12695
push userfrgrahl@gmx.net
push dateFri, 30 Dec 2016 21:53:43 +0000
treeherdercomm-central@e84176264e2b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjorgk
bugs1326433, 1323683
Bug 1326433 - Port bug 1323683 to mailnews: Whitespace fixes for modified files. r=jorgk CLOSED TREE
ldap/xpcom/src/nsLDAPURL.cpp
mailnews/addrbook/src/nsAddbookUrl.cpp
mailnews/base/util/nsMsgMailNewsUrl.cpp
mailnews/base/util/nsMsgMailNewsUrl.h
mailnews/compose/src/nsSmtpUrl.cpp
--- a/ldap/xpcom/src/nsLDAPURL.cpp
+++ b/ldap/xpcom/src/nsLDAPURL.cpp
@@ -1,10 +1,10 @@
 /* -*- 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 "nsLDAPURL.h"
 #include "netCore.h"
 #include "plstr.h"
 #include "nsCOMPtr.h"
@@ -121,39 +121,39 @@ nsLDAPURL::SetPathInternal(const nsCStri
   case LDAP_URL_ERR_NODN:
   case LDAP_URL_ERR_BADSCOPE:
     return NS_ERROR_MALFORMED_URI;
 
   case LDAP_URL_ERR_MEM:
     NS_ERROR("nsLDAPURL::SetSpec: out of memory ");
     return NS_ERROR_OUT_OF_MEMORY;
 
-  case LDAP_URL_ERR_PARAM: 
+  case LDAP_URL_ERR_PARAM:
     return NS_ERROR_INVALID_POINTER;
   }
 
   // This shouldn't happen...
   return NS_ERROR_UNEXPECTED;
 }
 
-// A string representation of the URI. Setting the spec 
+// A string representation of the URI. Setting the spec
 // causes the new spec to be parsed, initializing the URI. Setting
 // the spec (or any of the accessors) causes also any currently
 // open streams on the URI's channel to be closed.
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::GetSpec(nsACString &_retval)
 {
   if (!mBaseURL)
     return NS_ERROR_NOT_INITIALIZED;
 
   return mBaseURL->GetSpec(_retval);
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::SetSpec(const nsACString &aSpec)
 {
   if (!mBaseURL)
     return NS_ERROR_NOT_INITIALIZED;
 
   // Cache the original spec in case we don't like what we've been passed and
   // need to reset ourselves.
   nsCString originalSpec;
@@ -197,17 +197,17 @@ NS_IMETHODIMP nsLDAPURL::SetScheme(const
                           nsCaseInsensitiveCStringComparator()))
     mOptions |= OPT_SECURE;
   else
     return NS_ERROR_MALFORMED_URI;
 
   return mBaseURL->SetScheme(aScheme);
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::GetUserPass(nsACString &_retval)
 {
   _retval.Truncate();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsLDAPURL::SetUserPass(const nsACString &aUserPass)
@@ -223,39 +223,39 @@ nsLDAPURL::GetUsername(nsACString &_retv
 }
 
 NS_IMETHODIMP
 nsLDAPURL::SetUsername(const nsACString &aUsername)
 {
   return NS_OK;
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::GetPassword(nsACString &_retval)
 {
   _retval.Truncate();
   return NS_OK;
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::SetPassword(const nsACString &aPassword)
 {
   return NS_OK;
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::GetHostPort(nsACString &_retval)
 {
   if (!mBaseURL)
     return NS_ERROR_NOT_INITIALIZED;
 
   return mBaseURL->GetHostPort(_retval);
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::SetHostPort(const nsACString &aHostPort)
 {
   if (!mBaseURL)
     return NS_ERROR_NOT_INITIALIZED;
 
   return mBaseURL->SetHostPort(aHostPort);
 }
 
@@ -263,44 +263,44 @@ NS_IMETHODIMP
 nsLDAPURL::SetHostAndPort(const nsACString &aHostPort)
 {
   if (!mBaseURL)
     return NS_ERROR_NOT_INITIALIZED;
 
   return mBaseURL->SetHostAndPort(aHostPort);
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::GetHost(nsACString &_retval)
 {
   if (!mBaseURL)
     return NS_ERROR_NOT_INITIALIZED;
 
   return mBaseURL->GetHost(_retval);
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::SetHost(const nsACString &aHost)
 {
   if (!mBaseURL)
     return NS_ERROR_NOT_INITIALIZED;
 
   return mBaseURL->SetHost(aHost);
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::GetPort(int32_t *_retval)
 {
   if (!mBaseURL)
     return NS_ERROR_NOT_INITIALIZED;
 
   return mBaseURL->GetPort(_retval);
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsLDAPURL::SetPort(int32_t aPort)
 {
   if (!mBaseURL)
     return NS_ERROR_NOT_INITIALIZED;
 
   return mBaseURL->SetPort(aPort);
 }
 
--- a/mailnews/addrbook/src/nsAddbookUrl.cpp
+++ b/mailnews/addrbook/src/nsAddbookUrl.cpp
@@ -13,26 +13,26 @@
 
 /////////////////////////////////////////////////////////////////////////////////////
 // addbook url definition
 /////////////////////////////////////////////////////////////////////////////////////
 nsAddbookUrl::nsAddbookUrl()
 {
   m_baseURL = do_CreateInstance(NS_SIMPLEURI_CONTRACTID);
 
-  mOperationType = nsIAddbookUrlOperation::InvalidUrl; 
+  mOperationType = nsIAddbookUrlOperation::InvalidUrl;
 }
 
 nsAddbookUrl::~nsAddbookUrl()
 {
 }
 
 NS_IMPL_ISUPPORTS(nsAddbookUrl, nsIAddbookUrl, nsIURI)
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsAddbookUrl::SetSpec(const nsACString &aSpec)
 {
   nsresult rv = m_baseURL->SetSpec(aSpec);
   NS_ENSURE_SUCCESS(rv, rv);
   return ParseUrl();
 }
 
 nsresult nsAddbookUrl::ParseUrl()
@@ -53,133 +53,133 @@ nsresult nsAddbookUrl::ParseUrl()
 
 ////////////////////////////////////////////////////////////////////////////////////
 // Begin nsIURI support
 ////////////////////////////////////////////////////////////////////////////////////
 
 
 NS_IMETHODIMP nsAddbookUrl::GetSpec(nsACString &aSpec)
 {
-	return m_baseURL->GetSpec(aSpec);
+  return m_baseURL->GetSpec(aSpec);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetPrePath(nsACString &aPrePath)
 {
-	return m_baseURL->GetPrePath(aPrePath);
+  return m_baseURL->GetPrePath(aPrePath);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetScheme(nsACString &aScheme)
 {
-	return m_baseURL->GetScheme(aScheme);
+  return m_baseURL->GetScheme(aScheme);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SetScheme(const nsACString &aScheme)
 {
-	return m_baseURL->SetScheme(aScheme);
+  return m_baseURL->SetScheme(aScheme);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetUserPass(nsACString &aUserPass)
 {
-	return m_baseURL->GetUserPass(aUserPass);
+  return m_baseURL->GetUserPass(aUserPass);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SetUserPass(const nsACString &aUserPass)
 {
-	return m_baseURL->SetUserPass(aUserPass);
+  return m_baseURL->SetUserPass(aUserPass);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetUsername(nsACString &aUsername)
 {
-	return m_baseURL->GetUsername(aUsername);
+  return m_baseURL->GetUsername(aUsername);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SetUsername(const nsACString &aUsername)
 {
-	return m_baseURL->SetUsername(aUsername);
+  return m_baseURL->SetUsername(aUsername);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetPassword(nsACString &aPassword)
 {
-	return m_baseURL->GetPassword(aPassword);
+  return m_baseURL->GetPassword(aPassword);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SetPassword(const nsACString &aPassword)
 {
-	return m_baseURL->SetPassword(aPassword);
+  return m_baseURL->SetPassword(aPassword);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetHostPort(nsACString &aHostPort)
 {
-	return m_baseURL->GetHostPort(aHostPort);
+  return m_baseURL->GetHostPort(aHostPort);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SetHostPort(const nsACString &aHostPort)
 {
-	return m_baseURL->SetHostPort(aHostPort);
+  return m_baseURL->SetHostPort(aHostPort);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SetHostAndPort(const nsACString &aHostPort)
 {
-	return m_baseURL->SetHostAndPort(aHostPort);
+  return m_baseURL->SetHostAndPort(aHostPort);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetHost(nsACString &aHost)
 {
-	return m_baseURL->GetHost(aHost);
+  return m_baseURL->GetHost(aHost);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SetHost(const nsACString &aHost)
 {
-	return m_baseURL->SetHost(aHost);
+  return m_baseURL->SetHost(aHost);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetPort(int32_t *aPort)
 {
-	return m_baseURL->GetPort(aPort);
+  return m_baseURL->GetPort(aPort);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SetPort(int32_t aPort)
 {
-	return m_baseURL->SetPort(aPort);
+  return m_baseURL->SetPort(aPort);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetPath(nsACString &aPath)
 {
-	return m_baseURL->GetPath(aPath);
+  return m_baseURL->GetPath(aPath);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SetPath(const nsACString &aPath)
 {
   m_baseURL->SetPath(aPath);
   return ParseUrl();
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetAsciiHost(nsACString &aHostA)
 {
-	return m_baseURL->GetAsciiHost(aHostA);
+  return m_baseURL->GetAsciiHost(aHostA);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetAsciiHostPort(nsACString &aHostPortA)
 {
-	return m_baseURL->GetAsciiHostPort(aHostPortA);
+  return m_baseURL->GetAsciiHostPort(aHostPortA);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetAsciiSpec(nsACString &aSpecA)
 {
-	return m_baseURL->GetAsciiSpec(aSpecA);
+  return m_baseURL->GetAsciiSpec(aSpecA);
 }
 
 NS_IMETHODIMP nsAddbookUrl::GetOriginCharset(nsACString &aOriginCharset)
 {
     return m_baseURL->GetOriginCharset(aOriginCharset);
 }
 
 NS_IMETHODIMP nsAddbookUrl::SchemeIs(const char *aScheme, bool *_retval)
 {
-	return m_baseURL->SchemeIs(aScheme, _retval);
+  return m_baseURL->SchemeIs(aScheme, _retval);
 }
 
 NS_IMETHODIMP nsAddbookUrl::Equals(nsIURI *other, bool *_retval)
 {
   // The passed-in URI might be an nsMailtoUrl. Pass our inner URL to its
   // Equals method. The other nsMailtoUrl will then pass its inner URL to
   // to the Equals method of our inner URL. Other URIs will return false.
   if (other)
@@ -225,17 +225,17 @@ nsAddbookUrl::CloneIgnoringRef(nsIURI** 
 }
 
 NS_IMETHODIMP
 nsAddbookUrl::CloneWithNewRef(const nsACString& newRef, nsIURI** _retval)
 {
   return CloneInternal(eReplaceRef, newRef, _retval);
 }
 
-NS_IMETHODIMP nsAddbookUrl::Resolve(const nsACString &relativePath, nsACString &result) 
+NS_IMETHODIMP nsAddbookUrl::Resolve(const nsACString &relativePath, nsACString &result)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsAddbookUrl::GetRef(nsACString &result)
 {
   return m_baseURL->GetRef(result);
@@ -293,14 +293,14 @@ NS_IMETHODIMP
 nsAddbookUrl::GetHasRef(bool *result)
 {
   return m_baseURL->GetHasRef(result);
 }
 
 //
 // Specific nsAddbookUrl operations
 //
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsAddbookUrl::GetAddbookOperation(int32_t *_retval)
 {
   *_retval = mOperationType;
   return NS_OK;
 }
--- a/mailnews/base/util/nsMsgMailNewsUrl.cpp
+++ b/mailnews/base/util/nsMsgMailNewsUrl.cpp
@@ -47,17 +47,17 @@ nsMsgMailNewsUrl::nsMsgMailNewsUrl()
     listener->propertyfunc_ params_;                                   \
   }                                                                    \
   PR_END_MACRO
 
 nsMsgMailNewsUrl::~nsMsgMailNewsUrl()
 {
   PR_FREEIF(m_errorMessage);
 }
-  
+
 NS_IMPL_ISUPPORTS(nsMsgMailNewsUrl, nsIMsgMailNewsUrl, nsIURL, nsIURI)
 
 ////////////////////////////////////////////////////////////////////////////////////
 // Begin nsIMsgMailNewsUrl specific support
 ////////////////////////////////////////////////////////////////////////////////////
 
 nsresult nsMsgMailNewsUrl::GetUrlState(bool * aRunningUrl)
 {
@@ -69,39 +69,39 @@ nsresult nsMsgMailNewsUrl::GetUrlState(b
 
 nsresult nsMsgMailNewsUrl::SetUrlState(bool aRunningUrl, nsresult aExitCode)
 {
   // if we already knew this running state, return, unless the url was aborted
   if (m_runningUrl == aRunningUrl && aExitCode != NS_MSG_ERROR_URL_ABORTED)
     return NS_OK;
   m_runningUrl = aRunningUrl;
   nsCOMPtr <nsIMsgStatusFeedback> statusFeedback;
-  
+
   // put this back - we need it for urls that don't run through the doc loader
   if (NS_SUCCEEDED(GetStatusFeedback(getter_AddRefs(statusFeedback))) && statusFeedback)
   {
     if (m_runningUrl)
       statusFeedback->StartMeteors();
     else
     {
       statusFeedback->ShowProgress(0);
       statusFeedback->StopMeteors();
     }
   }
-  
+
   if (m_runningUrl)
   {
     NOTIFY_URL_LISTENERS(OnStartRunningUrl, (this));
   }
   else
   {
     NOTIFY_URL_LISTENERS(OnStopRunningUrl, (this, aExitCode));
     mUrlListeners.Clear();
   }
-  
+
   return NS_OK;
 }
 
 NS_IMETHODIMP nsMsgMailNewsUrl::RegisterListener(nsIUrlListener *aUrlListener)
 {
   NS_ENSURE_ARG_POINTER(aUrlListener);
   mUrlListeners.AppendElement(aUrlListener);
   return NS_OK;
@@ -142,43 +142,43 @@ NS_IMETHODIMP nsMsgMailNewsUrl::GetServe
     if (NS_SUCCEEDED(rv))
     {
         if (scheme.EqualsLiteral("pop"))
           scheme.Assign("pop3");
         // we use "nntp" in the server list so translate it here.
         if (scheme.EqualsLiteral("news"))
           scheme.Assign("nntp");
         url->SetScheme(scheme);
-        nsCOMPtr<nsIMsgAccountManager> accountManager = 
+        nsCOMPtr<nsIMsgAccountManager> accountManager =
                  do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
         if (NS_FAILED(rv)) return rv;
-        
+
         nsCOMPtr<nsIMsgIncomingServer> server;
         rv = accountManager->FindServerByURI(url, false,
                                         aIncomingServer);
         if (!*aIncomingServer && scheme.EqualsLiteral("imap"))
         {
-          // look for any imap server with this host name so clicking on 
+          // look for any imap server with this host name so clicking on
           // other users folder urls will work. We could override this method
           // for imap urls, or we could make caching of servers work and
           // just set the server in the imap code for this case.
           url->SetUserPass(EmptyCString());
           rv = accountManager->FindServerByURI(url, false,
                                           aIncomingServer);
         }
     }
 
     return rv;
 }
 
 NS_IMETHODIMP nsMsgMailNewsUrl::GetMsgWindow(nsIMsgWindow **aMsgWindow)
 {
   NS_ENSURE_ARG_POINTER(aMsgWindow);
   *aMsgWindow = nullptr;
-  
+
   nsCOMPtr<nsIMsgWindow> msgWindow(do_QueryReferent(m_msgWindowWeak));
   msgWindow.swap(*aMsgWindow);
   return *aMsgWindow ? NS_OK : NS_ERROR_NULL_POINTER;
 }
 
 NS_IMETHODIMP nsMsgMailNewsUrl::SetMsgWindow(nsIMsgWindow *aMsgWindow)
 {
 #ifdef DEBUG_David_Bienvenu
@@ -259,30 +259,30 @@ NS_IMETHODIMP nsMsgMailNewsUrl::GetUpdat
 NS_IMETHODIMP nsMsgMailNewsUrl::SetUpdatingFolder(bool updatingFolder)
 {
   m_updatingFolder = updatingFolder;
   return NS_OK;
 }
 
 NS_IMETHODIMP nsMsgMailNewsUrl::GetMsgIsInLocalCache(bool *aMsgIsInLocalCache)
 {
-  NS_ENSURE_ARG(aMsgIsInLocalCache); 
+  NS_ENSURE_ARG(aMsgIsInLocalCache);
   *aMsgIsInLocalCache = m_msgIsInLocalCache;
   return NS_OK;
 }
 
 NS_IMETHODIMP nsMsgMailNewsUrl::SetMsgIsInLocalCache(bool aMsgIsInLocalCache)
 {
   m_msgIsInLocalCache = aMsgIsInLocalCache;
   return NS_OK;
 }
 
 NS_IMETHODIMP nsMsgMailNewsUrl::GetSuppressErrorMsgs(bool *aSuppressErrorMsgs)
 {
-  NS_ENSURE_ARG(aSuppressErrorMsgs); 
+  NS_ENSURE_ARG(aSuppressErrorMsgs);
   *aSuppressErrorMsgs = m_suppressErrorMsgs;
   return NS_OK;
 }
 
 NS_IMETHODIMP nsMsgMailNewsUrl::SetSuppressErrorMsgs(bool aSuppressErrorMsgs)
 {
   m_suppressErrorMsgs = aSuppressErrorMsgs;
   return NS_OK;
@@ -555,17 +555,17 @@ nsMsgMailNewsUrl::CloneIgnoringRef(nsIUR
 }
 
 NS_IMETHODIMP
 nsMsgMailNewsUrl::CloneWithNewRef(const nsACString& newRef, nsIURI** _retval)
 {
   return CloneInternal(nsIMsgMailNewsUrl::REPLACE_REF, newRef, _retval);
 }
 
-NS_IMETHODIMP nsMsgMailNewsUrl::Resolve(const nsACString &relativePath, nsACString &result) 
+NS_IMETHODIMP nsMsgMailNewsUrl::Resolve(const nsACString &relativePath, nsACString &result)
 {
   // only resolve anchor urls....i.e. urls which start with '#' against the mailnews url...
   // everything else shouldn't be resolved against mailnews urls.
   nsresult rv = NS_OK;
 
   if (!relativePath.IsEmpty() && relativePath.First() == '#') // an anchor
     return m_baseURL->Resolve(relativePath, result);
   else
@@ -779,21 +779,21 @@ NS_IMETHODIMP
 nsMsgSaveAsListener::OnStopRequest(nsIRequest *request, nsISupports * aCtxt, nsresult aStatus)
 {
   if (m_outputStream)
   {
     m_outputStream->Flush();
     m_outputStream->Close();
   }
   return NS_OK;
-} 
+}
 
-NS_IMETHODIMP nsMsgSaveAsListener::OnDataAvailable(nsIRequest* request, 
+NS_IMETHODIMP nsMsgSaveAsListener::OnDataAvailable(nsIRequest* request,
                                   nsISupports* aSupport,
-                                  nsIInputStream* inStream, 
+                                  nsIInputStream* inStream,
                                   uint64_t srcOffset,
                                   uint32_t count)
 {
   nsresult rv;
   uint64_t available;
   rv = inStream->Available(&available);
   if (!m_writtenData)
   {
@@ -801,20 +801,20 @@ NS_IMETHODIMP nsMsgSaveAsListener::OnDat
     rv = SetupMsgWriteStream(m_outputFile, m_addDummyEnvelope);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   bool useCanonicalEnding = false;
   nsCOMPtr <nsIMsgMessageUrl> msgUrl = do_QueryInterface(aSupport);
   if (msgUrl)
     msgUrl->GetCanonicalLineEnding(&useCanonicalEnding);
-  
+
   const char *lineEnding = (useCanonicalEnding) ? CRLF : MSG_LINEBREAK;
   uint32_t lineEndingLength = (useCanonicalEnding) ? 2 : MSG_LINEBREAK_LEN;
-  
+
   uint32_t readCount, maxReadCount = SAVE_BUF_SIZE - m_leftOver;
   uint32_t writeCount;
   char *start, *end, lastCharInPrevBuf = '\0';
   uint32_t linebreak_len = 0;
 
   while (count > 0)
   {
       if (count < maxReadCount)
@@ -880,17 +880,17 @@ NS_IMETHODIMP nsMsgSaveAsListener::OnDat
               maxReadCount = SAVE_BUF_SIZE - m_leftOver;
           }
       }
       if (NS_FAILED(rv)) return rv;
       if (end)
           lastCharInPrevBuf = *end;
   }
   return rv;
-  
+
   //  rv = m_outputStream->WriteFrom(inStream, std::min(available, count), &bytesWritten);
 }
 
 nsresult nsMsgSaveAsListener::SetupMsgWriteStream(nsIFile *aFile, bool addDummyEnvelope)
 {
   // If the file already exists, delete it, but do this before
   // getting the outputstream.
   // Due to bug 328027, the nsSaveMsgListener created in
@@ -926,17 +926,17 @@ nsresult nsMsgSaveAsListener::SetupMsgWr
     result += MSG_LINEBREAK;
     m_outputStream->Write(result.get(), result.Length(), &writeCount);
   }
 
   return rv;
 }
 
 
-NS_IMETHODIMP nsMsgMailNewsUrl::GetSaveAsListener(bool addDummyEnvelope, 
+NS_IMETHODIMP nsMsgMailNewsUrl::GetSaveAsListener(bool addDummyEnvelope,
                                                   nsIFile *aFile, nsIStreamListener **aSaveListener)
 {
   NS_ENSURE_ARG_POINTER(aSaveListener);
   nsMsgSaveAsListener *saveAsListener = new nsMsgSaveAsListener(aFile, addDummyEnvelope);
   return saveAsListener->QueryInterface(NS_GET_IID(nsIStreamListener), (void **) aSaveListener);
 }
 
 
--- a/mailnews/base/util/nsMsgMailNewsUrl.h
+++ b/mailnews/base/util/nsMsgMailNewsUrl.h
@@ -22,17 +22,17 @@
 #include "nsICacheEntry.h"
 #include "nsICacheSession.h"
 #include "nsIMimeMiscStatus.h"
 #include "nsWeakReference.h"
 #include "nsStringGlue.h"
 
 ///////////////////////////////////////////////////////////////////////////////////
 // Okay, I found that all of the mail and news url interfaces needed to support
-// several common interfaces (in addition to those provided through nsIURI). 
+// several common interfaces (in addition to those provided through nsIURI).
 // So I decided to group them all in this implementation so we don't have to
 // duplicate the code.
 //
 //////////////////////////////////////////////////////////////////////////////////
 
 #undef  IMETHOD_VISIBILITY
 #define IMETHOD_VISIBILITY NS_VISIBILITY_DEFAULT
 
@@ -59,20 +59,20 @@ protected:
   nsCOMPtr<nsIMsgHeaderSink> mMsgHeaderSink;
   char *m_errorMessage;
   int64_t mMaxProgress;
   bool m_runningUrl;
   bool m_updatingFolder;
   bool m_msgIsInLocalCache;
   bool m_suppressErrorMsgs;
 
-  // the following field is really a bit of a hack to make 
+  // the following field is really a bit of a hack to make
   // open attachments work. The external applications code sometimes tries to figure out the right
   // handler to use by looking at the file extension of the url we are trying to load. Unfortunately,
-  // the attachment file name really isn't part of the url string....so we'll store it here...and if 
+  // the attachment file name really isn't part of the url string....so we'll store it here...and if
   // the url we are running is an attachment url, we'll set it here. Then when the helper apps code
   // asks us for it, we'll return the right value.
   nsCString mAttachmentFileName;
 
   nsTObserverArray<nsCOMPtr<nsIUrlListener> > mUrlListeners;
 };
 
 #undef  IMETHOD_VISIBILITY
--- a/mailnews/compose/src/nsSmtpUrl.cpp
+++ b/mailnews/compose/src/nsSmtpUrl.cpp
@@ -92,57 +92,57 @@ nsresult nsMailtoUrl::ParseMailtoUrl(cha
         *eq = 0;
       }
 
       nsCString decodedName;
       MsgUnescapeString(nsDependentCString(token), 0, decodedName);
 
       switch (NS_ToUpper(decodedName.First()))
       {
-        /* DO NOT support attachment= in mailto urls. This poses a security fire hole!!! 
+        /* DO NOT support attachment= in mailto urls. This poses a security fire hole!!!
                           case 'A':
                           if (!PL_strcasecmp (token, "attachment"))
                           m_attachmentPart = value;
                           break;
                      */
       case 'B':
         if (decodedName.LowerCaseEqualsLiteral("bcc"))
         {
           if (!escapedBccPart.IsEmpty())
           {
             escapedBccPart += ", ";
             escapedBccPart += value;
           }
           else
-            escapedBccPart = value; 
+            escapedBccPart = value;
         }
         else if (decodedName.LowerCaseEqualsLiteral("body"))
         {
           if (!escapedBodyPart.IsEmpty())
           {
             escapedBodyPart +="\n";
             escapedBodyPart += value;
           }
           else
             escapedBodyPart = value;
         }
         break;
-      case 'C': 
+      case 'C':
         if (decodedName.LowerCaseEqualsLiteral("cc"))
         {
           if (!escapedCcPart.IsEmpty())
           {
             escapedCcPart += ", ";
             escapedCcPart += value;
           }
           else
             escapedCcPart = value;
         }
         break;
-      case 'F': 
+      case 'F':
         if (decodedName.LowerCaseEqualsLiteral("followup-to"))
           escapedFollowUpToPart = value;
         else if (decodedName.LowerCaseEqualsLiteral("from"))
           escapedFromPart = value;
         break;
       case 'H':
         if (decodedName.LowerCaseEqualsLiteral("html-part") ||
             decodedName.LowerCaseEqualsLiteral("html-body"))
@@ -266,17 +266,17 @@ NS_IMETHODIMP nsMailtoUrl::SetSpec(const
   return ParseUrl();
 }
 
 nsresult nsMailtoUrl::CleanupMailtoState()
 {
     m_ccPart = "";
     m_subjectPart = "";
     m_newsgroupPart = "";
-    m_newsHostPart = ""; 
+    m_newsHostPart = "";
     m_referencePart = "";
     m_bodyPart = "";
     m_bccPart = "";
     m_followUpToPart = "";
     m_fromPart = "";
     m_htmlPart = "";
     m_organizationPart = "";
     m_replyToPart = "";
@@ -633,22 +633,22 @@ nsMailtoUrl::SetQuery(const nsACString &
 nsSmtpUrl::nsSmtpUrl() : nsMsgMailNewsUrl()
 {
   // nsISmtpUrl specific state...
 
   m_isPostMessage = true;
   m_requestDSN = false;
   m_verifyLogon = false;
 }
- 
+
 nsSmtpUrl::~nsSmtpUrl()
 {
 }
-  
-NS_IMPL_ISUPPORTS_INHERITED(nsSmtpUrl, nsMsgMailNewsUrl, nsISmtpUrl)  
+
+NS_IMPL_ISUPPORTS_INHERITED(nsSmtpUrl, nsMsgMailNewsUrl, nsISmtpUrl)
 
 ////////////////////////////////////////////////////////////////////////////////////
 // Begin nsISmtpUrl specific support
 
 ////////////////////////////////////////////////////////////////////////////////////
 
 NS_IMETHODIMP
 nsSmtpUrl::SetRecipients(const char * aRecipientsList)
@@ -690,17 +690,17 @@ NS_IMETHODIMP nsSmtpUrl::GetPostMessageF
     m_fileName->Clone(aFile);
     return *aFile ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
   }
   return NS_ERROR_NULL_POINTER;
 }
 
 NS_IMPL_GETSET(nsSmtpUrl, RequestDSN, bool, m_requestDSN)
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsSmtpUrl::SetDsnEnvid(const nsACString &aDsnEnvid)
 {
     m_dsnEnvid = aDsnEnvid;
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSmtpUrl::GetDsnEnvid(nsACString &aDsnEnvid)