The Tor Browser: embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp@6474c204b198 (annotated)

embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp@6474c204b198 (annotated)

embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "mozilla/ArrayUtils.h"
 #include "nspr.h"
 #include "nsIFileStreams.h"       // New Necko file streams
 #include <algorithm>
 #include "nsNetUtil.h"
 #include "nsComponentManagerUtils.h"
 #include "nsIComponentRegistrar.h"
 #include "nsIStorageStream.h"
 #include "nsISeekableStream.h"
 #include "nsIHttpChannel.h"
 #include "nsIHttpChannelInternal.h"
 #include "nsIEncodedChannel.h"
 #include "nsIUploadChannel.h"
 #include "nsICachingChannel.h"
 #include "nsIFileChannel.h"
 #include "nsEscape.h"
 #include "nsUnicharUtils.h"
 #include "nsIStringEnumerator.h"
 #include "nsCRT.h"
 #include "nsSupportsArray.h"
 #include "nsContentCID.h"
 #include "nsStreamUtils.h"
 #include "nsCExternalHandlerService.h"
 #include "nsIURL.h"
 #include "nsIFileURL.h"
 #include "nsIDocument.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMXMLDocument.h"
 #include "nsIDOMTreeWalker.h"
 #include "nsIDOMNode.h"
 #include "nsIDOMComment.h"
 #include "nsIDOMMozNamedAttrMap.h"
 #include "nsIDOMAttr.h"
 #include "nsIDOMNodeList.h"
 #include "nsIWebProgressListener.h"
 #include "nsIAuthPrompt.h"
 #include "nsIPrompt.h"
 #include "nsISHEntry.h"
 #include "nsIWebPageDescriptor.h"
 #include "nsIFormControl.h"
 #include "nsContentUtils.h"
 #include "nsIDOMNodeFilter.h"
 #include "nsIDOMProcessingInstruction.h"
 #include "nsIDOMHTMLAnchorElement.h"
 #include "nsIDOMHTMLAreaElement.h"
 #include "nsIDOMHTMLCollection.h"
 #include "nsIDOMHTMLImageElement.h"
 #include "nsIDOMHTMLScriptElement.h"
 #include "nsIDOMHTMLLinkElement.h"
 #include "nsIDOMHTMLBaseElement.h"
 #include "nsIDOMHTMLFrameElement.h"
 #include "nsIDOMHTMLIFrameElement.h"
 #include "nsIDOMHTMLInputElement.h"
 #include "nsIDOMHTMLEmbedElement.h"
 #include "nsIDOMHTMLObjectElement.h"
 #include "nsIDOMHTMLAppletElement.h"
 #include "nsIDOMHTMLOptionElement.h"
 #include "nsIDOMHTMLTextAreaElement.h"
 #include "nsIDOMHTMLDocument.h"
 #include "nsIDOMHTMLSourceElement.h"
 #include "nsIDOMHTMLMediaElement.h"
 #include "nsIImageLoadingContent.h"
 #include "ftpCore.h"
 #include "nsITransport.h"
 #include "nsISocketTransport.h"
 #include "nsIStringBundle.h"
 #include "nsIProtocolHandler.h"
 #include "nsWebBrowserPersist.h"
 #include "nsIContent.h"
 #include "nsIMIMEInfo.h"
 #include "mozilla/dom/HTMLInputElement.h"
 #include "mozilla/dom/HTMLSharedElement.h"
 #include "mozilla/dom/HTMLSharedObjectElement.h"
 using namespace mozilla;
 using namespace mozilla::dom;
 // Buffer file writes in 32kb chunks
 #define BUFFERED_OUTPUT_SIZE (1024 * 32)
 // Information about a DOM document
 struct DocData
 {
     nsCOMPtr<nsIURI> mBaseURI;
     nsCOMPtr<nsIDOMDocument> mDocument;
     nsCOMPtr<nsIURI> mFile;
     nsCOMPtr<nsIURI> mDataPath;
     bool mDataPathIsRelative;
     nsCString mRelativePathToData;
     nsCString mCharset;
 };
 // Information about a URI
 struct URIData
 {
     bool mNeedsPersisting;
     bool mSaved;
     bool mIsSubFrame;
     bool mDataPathIsRelative;
     bool mNeedsFixup;
     nsString mFilename;
     nsString mSubFrameExt;
     nsCOMPtr<nsIURI> mFile;
     nsCOMPtr<nsIURI> mDataPath;
     nsCString mRelativePathToData;
     nsCString mCharset;
 };
 // Information about the output stream
 struct OutputData
 {
     nsCOMPtr<nsIURI> mFile;
     nsCOMPtr<nsIURI> mOriginalLocation;
     nsCOMPtr<nsIOutputStream> mStream;
     int64_t mSelfProgress;
     int64_t mSelfProgressMax;
     bool mCalcFileExt;
     OutputData(nsIURI *aFile, nsIURI *aOriginalLocation, bool aCalcFileExt) :
         mFile(aFile),
         mOriginalLocation(aOriginalLocation),
         mSelfProgress(0),
         mSelfProgressMax(10000),
         mCalcFileExt(aCalcFileExt)
     {
     }
     ~OutputData()
     {
         if (mStream)
         {
             mStream->Close();
         }
     }
 };
 struct UploadData
 {
     nsCOMPtr<nsIURI> mFile;
     int64_t mSelfProgress;
     int64_t mSelfProgressMax;
     UploadData(nsIURI *aFile) :
         mFile(aFile),
         mSelfProgress(0),
         mSelfProgressMax(10000)
     {
     }
 };
 struct CleanupData
 {
     nsCOMPtr<nsIFile> mFile;
     // Snapshot of what the file actually is at the time of creation so that if
     // it transmutes into something else later on it can be ignored. For example,
     // catch files that turn into dirs or vice versa.
     bool mIsDirectory;
 };
 // Maximum file length constant. The max file name length is
 // volume / server dependent but it is difficult to obtain
 // that information. Instead this constant is a reasonable value that
 // modern systems should able to cope with.
 const uint32_t kDefaultMaxFilenameLength = 64;
 // Default flags for persistence
 const uint32_t kDefaultPersistFlags =
     nsIWebBrowserPersist::PERSIST_FLAGS_NO_CONVERSION |
     nsIWebBrowserPersist::PERSIST_FLAGS_REPLACE_EXISTING_FILES;
 // String bundle where error messages come from
 const char *kWebBrowserPersistStringBundle =
     "chrome://global/locale/nsWebBrowserPersist.properties";
 nsWebBrowserPersist::nsWebBrowserPersist() :
     mCurrentThingsToPersist(0),
     mFirstAndOnlyUse(true),
     mCancel(false),
     mJustStartedLoading(true),
     mCompleted(false),
     mStartSaving(false),
     mReplaceExisting(true),
     mSerializingOutput(false),
     mIsPrivate(false),
     mPersistFlags(kDefaultPersistFlags),
     mPersistResult(NS_OK),
     mTotalCurrentProgress(0),
     mTotalMaxProgress(0),
     mWrapColumn(72),
     mEncodingFlags(0)
 {
 }
 nsWebBrowserPersist::~nsWebBrowserPersist()
 {
     Cleanup();
 }
 //*****************************************************************************
 // nsWebBrowserPersist::nsISupports
 //*****************************************************************************
 NS_IMPL_ADDREF(nsWebBrowserPersist)
 NS_IMPL_RELEASE(nsWebBrowserPersist)
 NS_INTERFACE_MAP_BEGIN(nsWebBrowserPersist)
     NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebBrowserPersist)
     NS_INTERFACE_MAP_ENTRY(nsIWebBrowserPersist)
     NS_INTERFACE_MAP_ENTRY(nsICancelable)
     NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
     NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
     NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
     NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
     NS_INTERFACE_MAP_ENTRY(nsIProgressEventSink)
 NS_INTERFACE_MAP_END
 //*****************************************************************************
 // nsWebBrowserPersist::nsIInterfaceRequestor
 //*****************************************************************************
 NS_IMETHODIMP nsWebBrowserPersist::GetInterface(const nsIID & aIID, void **aIFace)
 {
     NS_ENSURE_ARG_POINTER(aIFace);
     *aIFace = nullptr;
     nsresult rv = QueryInterface(aIID, aIFace);
     if (NS_SUCCEEDED(rv))
     {
         return rv;
     }
     if (mProgressListener && (aIID.Equals(NS_GET_IID(nsIAuthPrompt))
                              || aIID.Equals(NS_GET_IID(nsIPrompt))))
     {
         mProgressListener->QueryInterface(aIID, aIFace);
         if (*aIFace)
             return NS_OK;
     }
     nsCOMPtr<nsIInterfaceRequestor> req = do_QueryInterface(mProgressListener);
     if (req)
     {
         return req->GetInterface(aIID, aIFace);
     }
     return NS_ERROR_NO_INTERFACE;
 }
 //*****************************************************************************
 // nsWebBrowserPersist::nsIWebBrowserPersist
 //*****************************************************************************
 /* attribute unsigned long persistFlags; */
 NS_IMETHODIMP nsWebBrowserPersist::GetPersistFlags(uint32_t *aPersistFlags)
 {
     NS_ENSURE_ARG_POINTER(aPersistFlags);
     *aPersistFlags = mPersistFlags;
     return NS_OK;
 }
 NS_IMETHODIMP nsWebBrowserPersist::SetPersistFlags(uint32_t aPersistFlags)
 {
     mPersistFlags = aPersistFlags;
     mReplaceExisting = (mPersistFlags & PERSIST_FLAGS_REPLACE_EXISTING_FILES) ? true : false;
     mSerializingOutput = (mPersistFlags & PERSIST_FLAGS_SERIALIZE_OUTPUT) ? true : false;
     return NS_OK;
 }
 /* readonly attribute unsigned long currentState; */
 NS_IMETHODIMP nsWebBrowserPersist::GetCurrentState(uint32_t *aCurrentState)
 {
     NS_ENSURE_ARG_POINTER(aCurrentState);
     if (mCompleted)
     {
         *aCurrentState = PERSIST_STATE_FINISHED;
     }
     else if (mFirstAndOnlyUse)
     {
         *aCurrentState = PERSIST_STATE_SAVING;
     }
     else
     {
         *aCurrentState = PERSIST_STATE_READY;
     }
     return NS_OK;
 }
 /* readonly attribute unsigned long result; */
 NS_IMETHODIMP nsWebBrowserPersist::GetResult(nsresult *aResult)
 {
     NS_ENSURE_ARG_POINTER(aResult);
     *aResult = mPersistResult;
     return NS_OK;
 }
 /* attribute nsIWebBrowserPersistProgress progressListener; */
 NS_IMETHODIMP nsWebBrowserPersist::GetProgressListener(
     nsIWebProgressListener * *aProgressListener)
 {
     NS_ENSURE_ARG_POINTER(aProgressListener);
     *aProgressListener = mProgressListener;
     NS_IF_ADDREF(*aProgressListener);
     return NS_OK;
 }
 NS_IMETHODIMP nsWebBrowserPersist::SetProgressListener(
     nsIWebProgressListener * aProgressListener)
 {
     mProgressListener = aProgressListener;
     mProgressListener2 = do_QueryInterface(aProgressListener);
     mEventSink = do_GetInterface(aProgressListener);
     return NS_OK;
 }
 /* void saveURI (in nsIURI aURI, in nsISupports aCacheKey, in nsIURI aReferrer,
    in nsIInputStream aPostData, in wstring aExtraHeaders,
    in nsISupports aFile, in nsILoadContext aPrivayContext); */
 NS_IMETHODIMP nsWebBrowserPersist::SaveURI(
     nsIURI *aURI, nsISupports *aCacheKey, nsIURI *aReferrer, nsIInputStream *aPostData, const char *aExtraHeaders, nsISupports *aFile, nsILoadContext* aPrivacyContext)
 {
     return SavePrivacyAwareURI(aURI, aCacheKey, aReferrer, aPostData, aExtraHeaders, aFile,
                                aPrivacyContext && aPrivacyContext->UsePrivateBrowsing());
 }
 NS_IMETHODIMP nsWebBrowserPersist::SavePrivacyAwareURI(
     nsIURI *aURI, nsISupports *aCacheKey, nsIURI *aReferrer, nsIInputStream *aPostData, const char *aExtraHeaders, nsISupports *aFile, bool aIsPrivate)
 {
     NS_ENSURE_TRUE(mFirstAndOnlyUse, NS_ERROR_FAILURE);
     mFirstAndOnlyUse = false; // Stop people from reusing this object!
     nsCOMPtr<nsIURI> fileAsURI;
     nsresult rv;
     rv = GetValidURIFromObject(aFile, getter_AddRefs(fileAsURI));
     NS_ENSURE_SUCCESS(rv, NS_ERROR_INVALID_ARG);
     // SaveURI doesn't like broken uris.
     mPersistFlags |= PERSIST_FLAGS_FAIL_ON_BROKEN_LINKS;
     rv = SaveURIInternal(aURI, aCacheKey, aReferrer, aPostData, aExtraHeaders, fileAsURI, false, aIsPrivate);
     return NS_FAILED(rv) ? rv : NS_OK;
 }
 /* void saveChannel (in nsIChannel aChannel, in nsISupports aFile); */
 NS_IMETHODIMP nsWebBrowserPersist::SaveChannel(
     nsIChannel *aChannel, nsISupports *aFile)
 {
     NS_ENSURE_TRUE(mFirstAndOnlyUse, NS_ERROR_FAILURE);
     mFirstAndOnlyUse = false; // Stop people from reusing this object!
     nsCOMPtr<nsIURI> fileAsURI;
     nsresult rv;
     rv = GetValidURIFromObject(aFile, getter_AddRefs(fileAsURI));
     NS_ENSURE_SUCCESS(rv, NS_ERROR_INVALID_ARG);
     rv = aChannel->GetURI(getter_AddRefs(mURI));
     NS_ENSURE_SUCCESS(rv, rv);
     // SaveURI doesn't like broken uris.
     mPersistFlags |= PERSIST_FLAGS_FAIL_ON_BROKEN_LINKS;
     rv = SaveChannelInternal(aChannel, fileAsURI, false);
     return NS_FAILED(rv) ? rv : NS_OK;
 }
 /* void saveDocument (in nsIDOMDocument aDocument, in nsIURI aFileURI,
    in nsIURI aDataPathURI, in string aOutputContentType,
    in unsigned long aEncodingFlags, in unsigned long aWrapColumn); */
 NS_IMETHODIMP nsWebBrowserPersist::SaveDocument(
     nsIDOMDocument *aDocument, nsISupports *aFile, nsISupports *aDataPath,
     const char *aOutputContentType, uint32_t aEncodingFlags, uint32_t aWrapColumn)
 {
     NS_ENSURE_TRUE(mFirstAndOnlyUse, NS_ERROR_FAILURE);
     mFirstAndOnlyUse = false; // Stop people from reusing this object!
     nsCOMPtr<nsIURI> fileAsURI;
     nsCOMPtr<nsIURI> datapathAsURI;
     nsresult rv;
     nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDocument);
     nsCOMPtr<nsILoadContext> privacyContext = doc ? doc->GetLoadContext() : nullptr;
     mIsPrivate = privacyContext && privacyContext->UsePrivateBrowsing();
     rv = GetValidURIFromObject(aFile, getter_AddRefs(fileAsURI));
     NS_ENSURE_SUCCESS(rv, NS_ERROR_INVALID_ARG);
     if (aDataPath)
     {
         rv = GetValidURIFromObject(aDataPath, getter_AddRefs(datapathAsURI));
         NS_ENSURE_SUCCESS(rv, NS_ERROR_INVALID_ARG);
     }
     mWrapColumn = aWrapColumn;
     // Produce nsIDocumentEncoder encoding flags
     mEncodingFlags = 0;
     if (aEncodingFlags & ENCODE_FLAGS_SELECTION_ONLY)
         mEncodingFlags |= nsIDocumentEncoder::OutputSelectionOnly;
     if (aEncodingFlags & ENCODE_FLAGS_FORMATTED)
         mEncodingFlags |= nsIDocumentEncoder::OutputFormatted;
     if (aEncodingFlags & ENCODE_FLAGS_RAW)
         mEncodingFlags |= nsIDocumentEncoder::OutputRaw;
     if (aEncodingFlags & ENCODE_FLAGS_BODY_ONLY)
         mEncodingFlags |= nsIDocumentEncoder::OutputBodyOnly;
     if (aEncodingFlags & ENCODE_FLAGS_PREFORMATTED)
         mEncodingFlags |= nsIDocumentEncoder::OutputPreformatted;
     if (aEncodingFlags & ENCODE_FLAGS_WRAP)
         mEncodingFlags |= nsIDocumentEncoder::OutputWrap;
     if (aEncodingFlags & ENCODE_FLAGS_FORMAT_FLOWED)
         mEncodingFlags |= nsIDocumentEncoder::OutputFormatFlowed;
     if (aEncodingFlags & ENCODE_FLAGS_ABSOLUTE_LINKS)
         mEncodingFlags |= nsIDocumentEncoder::OutputAbsoluteLinks;
     if (aEncodingFlags & ENCODE_FLAGS_ENCODE_BASIC_ENTITIES)
         mEncodingFlags |= nsIDocumentEncoder::OutputEncodeBasicEntities;
     if (aEncodingFlags & ENCODE_FLAGS_ENCODE_LATIN1_ENTITIES)
         mEncodingFlags |= nsIDocumentEncoder::OutputEncodeLatin1Entities;
     if (aEncodingFlags & ENCODE_FLAGS_ENCODE_HTML_ENTITIES)
         mEncodingFlags |= nsIDocumentEncoder::OutputEncodeHTMLEntities;
     if (aEncodingFlags & ENCODE_FLAGS_ENCODE_W3C_ENTITIES)
         mEncodingFlags |= nsIDocumentEncoder::OutputEncodeW3CEntities;
     if (aEncodingFlags & ENCODE_FLAGS_CR_LINEBREAKS)
         mEncodingFlags |= nsIDocumentEncoder::OutputCRLineBreak;
     if (aEncodingFlags & ENCODE_FLAGS_LF_LINEBREAKS)
         mEncodingFlags |= nsIDocumentEncoder::OutputLFLineBreak;
     if (aEncodingFlags & ENCODE_FLAGS_NOSCRIPT_CONTENT)
         mEncodingFlags |= nsIDocumentEncoder::OutputNoScriptContent;
     if (aEncodingFlags & ENCODE_FLAGS_NOFRAMES_CONTENT)
         mEncodingFlags |= nsIDocumentEncoder::OutputNoFramesContent;
     if (aOutputContentType)
     {
         mContentType.AssignASCII(aOutputContentType);
     }
     rv = SaveDocumentInternal(aDocument, fileAsURI, datapathAsURI);
     // Now save the URIs that have been gathered
     if (NS_SUCCEEDED(rv) && datapathAsURI)
     {
         rv = SaveGatheredURIs(fileAsURI);
     }
     else if (mProgressListener)
     {
         // tell the listener we're done
         mProgressListener->OnStateChange(nullptr, nullptr,
                                          nsIWebProgressListener::STATE_START |
                                          nsIWebProgressListener::STATE_IS_NETWORK,
                                          NS_OK);
         mProgressListener->OnStateChange(nullptr, nullptr,
                                          nsIWebProgressListener::STATE_STOP |
                                          nsIWebProgressListener::STATE_IS_NETWORK,
                                          rv);
     }
     return rv;
 }
 /* void cancel(nsresult aReason); */
 NS_IMETHODIMP nsWebBrowserPersist::Cancel(nsresult aReason)
 {
     mCancel = true;
     EndDownload(aReason);
     return NS_OK;
 }
 /* void cancelSave(); */
 NS_IMETHODIMP nsWebBrowserPersist::CancelSave()
 {
     return Cancel(NS_BINDING_ABORTED);
 }
 nsresult
 nsWebBrowserPersist::StartUpload(nsIStorageStream *storStream,
     nsIURI *aDestinationURI, const nsACString &aContentType)
 {
      // setup the upload channel if the destination is not local
     nsCOMPtr<nsIInputStream> inputstream;
     nsresult rv = storStream->NewInputStream(0, getter_AddRefs(inputstream));
     NS_ENSURE_TRUE(inputstream, NS_ERROR_FAILURE);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     return StartUpload(inputstream, aDestinationURI, aContentType);
 }
 nsresult
 nsWebBrowserPersist::StartUpload(nsIInputStream *aInputStream,
     nsIURI *aDestinationURI, const nsACString &aContentType)
 {
     nsCOMPtr<nsIChannel> destChannel;
     CreateChannelFromURI(aDestinationURI, getter_AddRefs(destChannel));
     nsCOMPtr<nsIUploadChannel> uploadChannel(do_QueryInterface(destChannel));
     NS_ENSURE_TRUE(uploadChannel, NS_ERROR_FAILURE);
     // Set the upload stream
     // NOTE: ALL data must be available in "inputstream"
     nsresult rv = uploadChannel->SetUploadStream(aInputStream, aContentType, -1);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     rv = destChannel->AsyncOpen(this, nullptr);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     // add this to the upload list
     nsCOMPtr<nsISupports> keyPtr = do_QueryInterface(destChannel);
     mUploadList.Put(keyPtr, new UploadData(aDestinationURI));
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::SaveGatheredURIs(nsIURI *aFileAsURI)
 {
     nsresult rv = NS_OK;
     // Count how many URIs in the URI map require persisting
     uint32_t urisToPersist = 0;
     if (mURIMap.Count() > 0)
     {
         mURIMap.EnumerateRead(EnumCountURIsToPersist, &urisToPersist);
     }
     if (urisToPersist > 0)
     {
         // Persist each file in the uri map. The document(s)
         // will be saved after the last one of these is saved.
         mURIMap.EnumerateRead(EnumPersistURIs, this);
     }
     // if we don't have anything in mOutputMap (added from above enumeration)
     // then we build the doc list (SaveDocuments)
     if (mOutputMap.Count() == 0)
     {
         // There are no URIs to save, so just save the document(s)
         // State start notification
         uint32_t addToStateFlags = 0;
         if (mProgressListener)
         {
             if (mJustStartedLoading)
             {
                 addToStateFlags |= nsIWebProgressListener::STATE_IS_NETWORK;
             }
             mProgressListener->OnStateChange(nullptr, nullptr,
                 nsIWebProgressListener::STATE_START | addToStateFlags, NS_OK);
         }
         rv = SaveDocuments();
         if (NS_FAILED(rv))
             EndDownload(rv);
         else if (aFileAsURI)
         {
             // local files won't trigger OnStopRequest so we call EndDownload here
             bool isFile = false;
             aFileAsURI->SchemeIs("file", &isFile);
             if (isFile)
                 EndDownload(NS_OK);
         }
         // State stop notification
         if (mProgressListener)
         {
             mProgressListener->OnStateChange(nullptr, nullptr,
                 nsIWebProgressListener::STATE_STOP | addToStateFlags, rv);
         }
     }
     return rv;
 }
 // this method returns true if there is another file to persist and false if not
 bool
 nsWebBrowserPersist::SerializeNextFile()
 {
     if (!mSerializingOutput)
     {
         return false;
     }
     nsresult rv = SaveGatheredURIs(nullptr);
     if (NS_FAILED(rv))
     {
         return false;
     }
     return (mURIMap.Count()
         || mUploadList.Count()
         || mDocList.Length()
         || mOutputMap.Count());
 }
 //*****************************************************************************
 // nsWebBrowserPersist::nsIRequestObserver
 //*****************************************************************************
 NS_IMETHODIMP nsWebBrowserPersist::OnStartRequest(
     nsIRequest* request, nsISupports *ctxt)
 {
     if (mProgressListener)
     {
         uint32_t stateFlags = nsIWebProgressListener::STATE_START |
                               nsIWebProgressListener::STATE_IS_REQUEST;
         if (mJustStartedLoading)
         {
             stateFlags |= nsIWebProgressListener::STATE_IS_NETWORK;
         }
         mProgressListener->OnStateChange(nullptr, request, stateFlags, NS_OK);
     }
     mJustStartedLoading = false;
     nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
     NS_ENSURE_TRUE(channel, NS_ERROR_FAILURE);
     nsCOMPtr<nsISupports> keyPtr = do_QueryInterface(request);
     OutputData *data = mOutputMap.Get(keyPtr);
     // NOTE: This code uses the channel as a hash key so it will not
     //       recognize redirected channels because the key is not the same.
     //       When that happens we remove and add the data entry to use the
     //       new channel as the hash key.
     if (!data)
     {
         UploadData *upData = mUploadList.Get(keyPtr);
         if (!upData)
         {
             // Redirect? Try and fixup the output table
             nsresult rv = FixRedirectedChannelEntry(channel);
             NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
             // Should be able to find the data after fixup unless redirects
             // are disabled.
             data = mOutputMap.Get(keyPtr);
             if (!data)
             {
                 return NS_ERROR_FAILURE;
             }
         }
     }
     if (data && data->mFile)
     {
         // If PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION is set in mPersistFlags,
         // try to determine whether this channel needs to apply Content-Encoding
         // conversions.
         NS_ASSERTION(!((mPersistFlags & PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION) &&
                       (mPersistFlags & PERSIST_FLAGS_NO_CONVERSION)),
                      "Conflict in persist flags: both AUTODETECT and NO_CONVERSION set");
         if (mPersistFlags & PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION)
             SetApplyConversionIfNeeded(channel);
         if (data->mCalcFileExt && !(mPersistFlags & PERSIST_FLAGS_DONT_CHANGE_FILENAMES))
         {
             // this is the first point at which the server can tell us the mimetype
             CalculateAndAppendFileExt(data->mFile, channel, data->mOriginalLocation);
             // now make filename conformant and unique
             CalculateUniqueFilename(data->mFile);
         }
         // compare uris and bail before we add to output map if they are equal
         bool isEqual = false;
         if (NS_SUCCEEDED(data->mFile->Equals(data->mOriginalLocation, &isEqual))
             && isEqual)
         {
             // remove from output map
             mOutputMap.Remove(keyPtr);
             // cancel; we don't need to know any more
             // stop request will get called
             request->Cancel(NS_BINDING_ABORTED);
         }
     }
     return NS_OK;
 }
 NS_IMETHODIMP nsWebBrowserPersist::OnStopRequest(
     nsIRequest* request, nsISupports *ctxt, nsresult status)
 {
     nsCOMPtr<nsISupports> keyPtr = do_QueryInterface(request);
     OutputData *data = mOutputMap.Get(keyPtr);
     if (data)
     {
         if (NS_SUCCEEDED(mPersistResult) && NS_FAILED(status))
             SendErrorStatusChange(true, status, request, data->mFile);
         // This will automatically close the output stream
         mOutputMap.Remove(keyPtr);
     }
     else
     {
         // if we didn't find the data in mOutputMap, try mUploadList
         UploadData *upData = mUploadList.Get(keyPtr);
         if (upData)
         {
             mUploadList.Remove(keyPtr);
         }
     }
     // ensure we call SaveDocuments if we:
     // 1) aren't canceling
     // 2) we haven't triggered the save (which we only want to trigger once)
     // 3) we aren't serializing (which will call it inside SerializeNextFile)
     if (mOutputMap.Count() == 0 && !mCancel && !mStartSaving && !mSerializingOutput)
     {
         nsresult rv = SaveDocuments();
         NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     }
     bool completed = false;
     if (mOutputMap.Count() == 0 && mUploadList.Count() == 0 && !mCancel)
     {
         // if no documents left in mDocList, --> done
         // if we have no files left to serialize and no error result, --> done
         if (mDocList.Length() == 0
             || (!SerializeNextFile() && NS_SUCCEEDED(mPersistResult)))
         {
             completed = true;
         }
     }
     if (completed)
     {
         // we're all done, do our cleanup
         EndDownload(status);
     }
     if (mProgressListener)
     {
         uint32_t stateFlags = nsIWebProgressListener::STATE_STOP |
                               nsIWebProgressListener::STATE_IS_REQUEST;
         if (completed)
         {
             stateFlags |= nsIWebProgressListener::STATE_IS_NETWORK;
         }
         mProgressListener->OnStateChange(nullptr, request, stateFlags, status);
     }
     if (completed)
     {
         mProgressListener = nullptr;
         mProgressListener2 = nullptr;
         mEventSink = nullptr;
     }
     return NS_OK;
 }
 //*****************************************************************************
 // nsWebBrowserPersist::nsIStreamListener
 //*****************************************************************************
 NS_IMETHODIMP
 nsWebBrowserPersist::OnDataAvailable(
     nsIRequest* request, nsISupports *aContext, nsIInputStream *aIStream,
     uint64_t aOffset, uint32_t aLength)
 {
     bool cancel = mCancel;
     if (!cancel)
     {
         nsresult rv = NS_OK;
         uint32_t bytesRemaining = aLength;
         nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
         NS_ENSURE_TRUE(channel, NS_ERROR_FAILURE);
         nsCOMPtr<nsISupports> keyPtr = do_QueryInterface(request);
         OutputData *data = mOutputMap.Get(keyPtr);
         if (!data) {
             // might be uploadData; consume necko's buffer and bail...
             uint32_t n;
             return aIStream->ReadSegments(NS_DiscardSegment, nullptr, aLength, &n);
         }
         bool readError = true;
         // Make the output stream
         if (!data->mStream)
         {
             rv = MakeOutputStream(data->mFile, getter_AddRefs(data->mStream));
             if (NS_FAILED(rv))
             {
                 readError = false;
                 cancel = true;
             }
         }
         // Read data from the input and write to the output
         char buffer[8192];
         uint32_t bytesRead;
         while (!cancel && bytesRemaining)
         {
             readError = true;
             rv = aIStream->Read(buffer,
                                 std::min(uint32_t(sizeof(buffer)), bytesRemaining),
                                 &bytesRead);
             if (NS_SUCCEEDED(rv))
             {
                 readError = false;
                 // Write out the data until something goes wrong, or, it is
                 // all written.  We loop because for some errors (e.g., disk
                 // full), we get NS_OK with some bytes written, then an error.
                 // So, we want to write again in that case to get the actual
                 // error code.
                 const char *bufPtr = buffer; // Where to write from.
                 while (NS_SUCCEEDED(rv) && bytesRead)
                 {
                     uint32_t bytesWritten = 0;
                     rv = data->mStream->Write(bufPtr, bytesRead, &bytesWritten);
                     if (NS_SUCCEEDED(rv))
                     {
                         bytesRead -= bytesWritten;
                         bufPtr += bytesWritten;
                         bytesRemaining -= bytesWritten;
                         // Force an error if (for some reason) we get NS_OK but
                         // no bytes written.
                         if (!bytesWritten)
                         {
                             rv = NS_ERROR_FAILURE;
                             cancel = true;
                         }
                     }
                     else
                     {
                         // Disaster - can't write out the bytes - disk full / permission?
                         cancel = true;
                     }
                 }
             }
             else
             {
                 // Disaster - can't read the bytes - broken link / file error?
                 cancel = true;
             }
         }
         int64_t channelContentLength = -1;
         if (!cancel &&
             NS_SUCCEEDED(channel->GetContentLength(&channelContentLength)))
         {
             // if we get -1 at this point, we didn't get content-length header
             // assume that we got all of the data and push what we have;
             // that's the best we can do now
             if ((-1 == channelContentLength) ||
                 ((channelContentLength - (aOffset + aLength)) == 0))
             {
                 NS_WARN_IF_FALSE(channelContentLength != -1,
                     "nsWebBrowserPersist::OnDataAvailable() no content length "
                     "header, pushing what we have");
                 // we're done with this pass; see if we need to do upload
                 nsAutoCString contentType;
                 channel->GetContentType(contentType);
                 // if we don't have the right type of output stream then it's a local file
                 nsCOMPtr<nsIStorageStream> storStream(do_QueryInterface(data->mStream));
                 if (storStream)
                 {
                     data->mStream->Close();
                     data->mStream = nullptr; // null out stream so we don't close it later
                     rv = StartUpload(storStream, data->mFile, contentType);
                     if (NS_FAILED(rv))
                     {
                         readError = false;
                         cancel = true;
                     }
                 }
             }
         }
         // Notify listener if an error occurred.
         if (cancel)
         {
             SendErrorStatusChange(readError, rv,
                 readError ? request : nullptr, data->mFile);
         }
     }
     // Cancel reading?
     if (cancel)
     {
         EndDownload(NS_BINDING_ABORTED);
     }
     return NS_OK;
 }
 //*****************************************************************************
 // nsWebBrowserPersist::nsIProgressEventSink
 //*****************************************************************************
 /* void onProgress (in nsIRequest request, in nsISupports ctxt,
     in unsigned long long aProgress, in unsigned long long aProgressMax); */
 NS_IMETHODIMP nsWebBrowserPersist::OnProgress(
     nsIRequest *request, nsISupports *ctxt, uint64_t aProgress,
     uint64_t aProgressMax)
 {
     if (!mProgressListener)
     {
         return NS_OK;
     }
     // Store the progress of this request
     nsCOMPtr<nsISupports> keyPtr = do_QueryInterface(request);
     OutputData *data = mOutputMap.Get(keyPtr);
     if (data)
     {
         data->mSelfProgress = int64_t(aProgress);
         data->mSelfProgressMax = int64_t(aProgressMax);
     }
     else
     {
         UploadData *upData = mUploadList.Get(keyPtr);
         if (upData)
         {
             upData->mSelfProgress = int64_t(aProgress);
             upData->mSelfProgressMax = int64_t(aProgressMax);
         }
     }
     // Notify listener of total progress
     CalcTotalProgress();
     if (mProgressListener2)
     {
       mProgressListener2->OnProgressChange64(nullptr, request, aProgress,
             aProgressMax, mTotalCurrentProgress, mTotalMaxProgress);
     }
     else
     {
       // have to truncate 64-bit to 32bit
       mProgressListener->OnProgressChange(nullptr, request, uint64_t(aProgress),
               uint64_t(aProgressMax), mTotalCurrentProgress, mTotalMaxProgress);
     }
     // If our progress listener implements nsIProgressEventSink,
     // forward the notification
     if (mEventSink)
     {
         mEventSink->OnProgress(request, ctxt, aProgress, aProgressMax);
     }
     return NS_OK;
 }
 /* void onStatus (in nsIRequest request, in nsISupports ctxt,
     in nsresult status, in wstring statusArg); */
 NS_IMETHODIMP nsWebBrowserPersist::OnStatus(
     nsIRequest *request, nsISupports *ctxt, nsresult status,
     const char16_t *statusArg)
 {
     if (mProgressListener)
     {
         // We need to filter out non-error error codes.
         // Is the only NS_SUCCEEDED value NS_OK?
         switch ( status )
         {
         case NS_NET_STATUS_RESOLVING_HOST:
         case NS_NET_STATUS_RESOLVED_HOST:
         case NS_NET_STATUS_BEGIN_FTP_TRANSACTION:
         case NS_NET_STATUS_END_FTP_TRANSACTION:
         case NS_NET_STATUS_CONNECTING_TO:
         case NS_NET_STATUS_CONNECTED_TO:
         case NS_NET_STATUS_SENDING_TO:
         case NS_NET_STATUS_RECEIVING_FROM:
         case NS_NET_STATUS_WAITING_FOR:
         case NS_NET_STATUS_READING:
         case NS_NET_STATUS_WRITING:
             break;
         default:
             // Pass other notifications (for legitimate errors) along.
             mProgressListener->OnStatusChange(nullptr, request, status, statusArg);
             break;
         }
     }
     // If our progress listener implements nsIProgressEventSink,
     // forward the notification
     if (mEventSink)
     {
         mEventSink->OnStatus(request, ctxt, status, statusArg);
     }
     return NS_OK;
 }
 //*****************************************************************************
 // nsWebBrowserPersist private methods
 //*****************************************************************************
 // Convert error info into proper message text and send OnStatusChange notification
 // to the web progress listener.
 nsresult nsWebBrowserPersist::SendErrorStatusChange(
     bool aIsReadError, nsresult aResult, nsIRequest *aRequest, nsIURI *aURI)
 {
     NS_ENSURE_ARG_POINTER(aURI);
     if (!mProgressListener)
     {
         // Do nothing
         return NS_OK;
     }
     // Get the file path or spec from the supplied URI
     nsCOMPtr<nsIFile> file;
     GetLocalFileFromURI(aURI, getter_AddRefs(file));
     nsAutoString path;
     if (file)
     {
         file->GetPath(path);
     }
     else
     {
         nsAutoCString fileurl;
         aURI->GetSpec(fileurl);
         AppendUTF8toUTF16(fileurl, path);
     }
     nsAutoString msgId;
     switch(aResult)
     {
     case NS_ERROR_FILE_NAME_TOO_LONG:
         // File name too long.
         msgId.AssignLiteral("fileNameTooLongError");
         break;
     case NS_ERROR_FILE_ALREADY_EXISTS:
         // File exists with same name as directory.
         msgId.AssignLiteral("fileAlreadyExistsError");
         break;
     case NS_ERROR_FILE_DISK_FULL:
     case NS_ERROR_FILE_NO_DEVICE_SPACE:
         // Out of space on target volume.
         msgId.AssignLiteral("diskFull");
         break;
     case NS_ERROR_FILE_READ_ONLY:
         // Attempt to write to read/only file.
         msgId.AssignLiteral("readOnly");
         break;
     case NS_ERROR_FILE_ACCESS_DENIED:
         // Attempt to write without sufficient permissions.
         msgId.AssignLiteral("accessError");
         break;
     default:
         // Generic read/write error message.
         if (aIsReadError)
             msgId.AssignLiteral("readError");
         else
             msgId.AssignLiteral("writeError");
         break;
     }
     // Get properties file bundle and extract status string.
     nsresult rv;
     nsCOMPtr<nsIStringBundleService> s = do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
     NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && s, NS_ERROR_FAILURE);
     nsCOMPtr<nsIStringBundle> bundle;
     rv = s->CreateBundle(kWebBrowserPersistStringBundle, getter_AddRefs(bundle));
     NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && bundle, NS_ERROR_FAILURE);
     nsXPIDLString msgText;
     const char16_t *strings[1];
     strings[0] = path.get();
     rv = bundle->FormatStringFromName(msgId.get(), strings, 1, getter_Copies(msgText));
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     mProgressListener->OnStatusChange(nullptr, aRequest, aResult, msgText);
     return NS_OK;
 }
 nsresult nsWebBrowserPersist::GetValidURIFromObject(nsISupports *aObject, nsIURI **aURI) const
 {
     NS_ENSURE_ARG_POINTER(aObject);
     NS_ENSURE_ARG_POINTER(aURI);
     nsCOMPtr<nsIFile> objAsFile = do_QueryInterface(aObject);
     if (objAsFile)
     {
         return NS_NewFileURI(aURI, objAsFile);
     }
     nsCOMPtr<nsIURI> objAsURI = do_QueryInterface(aObject);
     if (objAsURI)
     {
         *aURI = objAsURI;
         NS_ADDREF(*aURI);
         return NS_OK;
     }
     return NS_ERROR_FAILURE;
 }
 nsresult nsWebBrowserPersist::GetLocalFileFromURI(nsIURI *aURI, nsIFile **aLocalFile) const
 {
     nsresult rv;
     nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aURI, &rv);
     if (NS_FAILED(rv))
         return rv;
     nsCOMPtr<nsIFile> file;
     rv = fileURL->GetFile(getter_AddRefs(file));
     if (NS_FAILED(rv)) {
         return rv;
     }
     file.forget(aLocalFile);
     return NS_OK;
 }
 nsresult nsWebBrowserPersist::AppendPathToURI(nsIURI *aURI, const nsAString & aPath) const
 {
     NS_ENSURE_ARG_POINTER(aURI);
     nsAutoCString newPath;
     nsresult rv = aURI->GetPath(newPath);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     // Append a forward slash if necessary
     int32_t len = newPath.Length();
     if (len > 0 && newPath.CharAt(len - 1) != '/')
     {
         newPath.Append('/');
     }
     // Store the path back on the URI
     AppendUTF16toUTF8(aPath, newPath);
     aURI->SetPath(newPath);
     return NS_OK;
 }
 nsresult nsWebBrowserPersist::SaveURIInternal(
     nsIURI *aURI, nsISupports *aCacheKey, nsIURI *aReferrer,
     nsIInputStream *aPostData, const char *aExtraHeaders,
     nsIURI *aFile, bool aCalcFileExt, bool aIsPrivate)
 {
     NS_ENSURE_ARG_POINTER(aURI);
     NS_ENSURE_ARG_POINTER(aFile);
     nsresult rv = NS_OK;
     mURI = aURI;
     nsLoadFlags loadFlags = nsIRequest::LOAD_NORMAL;
     if (mPersistFlags & PERSIST_FLAGS_BYPASS_CACHE)
     {
         loadFlags |= nsIRequest::LOAD_BYPASS_CACHE;
     }
     else if (mPersistFlags & PERSIST_FLAGS_FROM_CACHE)
     {
         loadFlags |= nsIRequest::LOAD_FROM_CACHE;
     }
     // Extract the cache key
     nsCOMPtr<nsISupports> cacheKey;
     if (aCacheKey)
     {
         // Test if the cache key is actually a web page descriptor (docshell)
         // or session history entry.
         nsCOMPtr<nsISHEntry> shEntry = do_QueryInterface(aCacheKey);
         if (!shEntry)
         {
             nsCOMPtr<nsIWebPageDescriptor> webPageDescriptor =
                 do_QueryInterface(aCacheKey);
             if (webPageDescriptor)
             {
                 nsCOMPtr<nsISupports> currentDescriptor;
                 webPageDescriptor->GetCurrentDescriptor(getter_AddRefs(currentDescriptor));
                 shEntry = do_QueryInterface(currentDescriptor);
             }
         }
         if (shEntry)
         {
             shEntry->GetCacheKey(getter_AddRefs(cacheKey));
         }
         else
         {
             // Assume a plain cache key
             cacheKey = aCacheKey;
         }
     }
     // Open a channel to the URI
     nsCOMPtr<nsIChannel> inputChannel;
     rv = NS_NewChannel(getter_AddRefs(inputChannel), aURI,
             nullptr, nullptr, static_cast<nsIInterfaceRequestor*>(this),
             loadFlags);
     nsCOMPtr<nsIPrivateBrowsingChannel> pbChannel = do_QueryInterface(inputChannel);
     if (pbChannel)
     {
         pbChannel->SetPrivate(aIsPrivate);
     }
     if (NS_FAILED(rv) || inputChannel == nullptr)
     {
         EndDownload(NS_ERROR_FAILURE);
         return NS_ERROR_FAILURE;
     }
     // Disable content conversion
     if (mPersistFlags & PERSIST_FLAGS_NO_CONVERSION)
     {
         nsCOMPtr<nsIEncodedChannel> encodedChannel(do_QueryInterface(inputChannel));
         if (encodedChannel)
         {
             encodedChannel->SetApplyConversion(false);
         }
     }
     if (mPersistFlags & PERSIST_FLAGS_FORCE_ALLOW_COOKIES)
     {
         nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal =
                 do_QueryInterface(inputChannel);
         if (httpChannelInternal)
             httpChannelInternal->SetForceAllowThirdPartyCookie(true);
     }
     // Set the referrer, post data and headers if any
     nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(inputChannel));
     if (httpChannel)
     {
         // Referrer
         if (aReferrer)
         {
             httpChannel->SetReferrer(aReferrer);
         }
         // Post data
         if (aPostData)
         {
             nsCOMPtr<nsISeekableStream> stream(do_QueryInterface(aPostData));
             if (stream)
             {
                 // Rewind the postdata stream
                 stream->Seek(nsISeekableStream::NS_SEEK_SET, 0);
                 nsCOMPtr<nsIUploadChannel> uploadChannel(do_QueryInterface(httpChannel));
                 NS_ASSERTION(uploadChannel, "http must support nsIUploadChannel");
                 // Attach the postdata to the http channel
                 uploadChannel->SetUploadStream(aPostData, EmptyCString(), -1);
             }
         }
         // Cache key
         nsCOMPtr<nsICachingChannel> cacheChannel(do_QueryInterface(httpChannel));
         if (cacheChannel && cacheKey)
         {
             cacheChannel->SetCacheKey(cacheKey);
         }
         // Headers
         if (aExtraHeaders)
         {
             nsAutoCString oneHeader;
             nsAutoCString headerName;
             nsAutoCString headerValue;
             int32_t crlf = 0;
             int32_t colon = 0;
             const char *kWhitespace = "\b\t\r\n ";
             nsAutoCString extraHeaders(aExtraHeaders);
             while (true)
             {
                 crlf = extraHeaders.Find("\r\n", true);
                 if (crlf == -1)
                     break;
                 extraHeaders.Mid(oneHeader, 0, crlf);
                 extraHeaders.Cut(0, crlf + 2);
                 colon = oneHeader.Find(":");
                 if (colon == -1)
                     break; // Should have a colon
                 oneHeader.Left(headerName, colon);
                 colon++;
                 oneHeader.Mid(headerValue, colon, oneHeader.Length() - colon);
                 headerName.Trim(kWhitespace);
                 headerValue.Trim(kWhitespace);
                 // Add the header (merging if required)
                 rv = httpChannel->SetRequestHeader(headerName, headerValue, true);
                 if (NS_FAILED(rv))
                 {
                     EndDownload(NS_ERROR_FAILURE);
                     return NS_ERROR_FAILURE;
                 }
             }
         }
     }
     return SaveChannelInternal(inputChannel, aFile, aCalcFileExt);
 }
 nsresult nsWebBrowserPersist::SaveChannelInternal(
     nsIChannel *aChannel, nsIURI *aFile, bool aCalcFileExt)
 {
     NS_ENSURE_ARG_POINTER(aChannel);
     NS_ENSURE_ARG_POINTER(aFile);
     // The default behaviour of SaveChannelInternal is to download the source
     // into a storage stream and upload that to the target. MakeOutputStream
     // special-cases a file target and creates a file output stream directly.
     // We want to special-case a file source and create a file input stream,
     // but we don't need to do this in the case of a file target.
     nsCOMPtr<nsIFileChannel> fc(do_QueryInterface(aChannel));
     nsCOMPtr<nsIFileURL> fu(do_QueryInterface(aFile));
     if (fc && !fu) {
         nsCOMPtr<nsIInputStream> fileInputStream, bufferedInputStream;
         nsresult rv = aChannel->Open(getter_AddRefs(fileInputStream));
         NS_ENSURE_SUCCESS(rv, rv);
         rv = NS_NewBufferedInputStream(getter_AddRefs(bufferedInputStream),
                                        fileInputStream, BUFFERED_OUTPUT_SIZE);
         NS_ENSURE_SUCCESS(rv, rv);
         nsAutoCString contentType;
         aChannel->GetContentType(contentType);
         return StartUpload(bufferedInputStream, aFile, contentType);
     }
     // Read from the input channel
     nsresult rv = aChannel->AsyncOpen(this, nullptr);
     if (rv == NS_ERROR_NO_CONTENT)
     {
         // Assume this is a protocol such as mailto: which does not feed out
         // data and just ignore it.
         return NS_SUCCESS_DONT_FIXUP;
     }
     if (NS_FAILED(rv))
     {
         // Opening failed, but do we care?
         if (mPersistFlags & PERSIST_FLAGS_FAIL_ON_BROKEN_LINKS)
         {
             SendErrorStatusChange(true, rv, aChannel, aFile);
             EndDownload(NS_ERROR_FAILURE);
             return NS_ERROR_FAILURE;
         }
         return NS_SUCCESS_DONT_FIXUP;
     }
     // Add the output transport to the output map with the channel as the key
     nsCOMPtr<nsISupports> keyPtr = do_QueryInterface(aChannel);
     mOutputMap.Put(keyPtr, new OutputData(aFile, mURI, aCalcFileExt));
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::GetExtensionForContentType(const char16_t *aContentType, char16_t **aExt)
 {
     NS_ENSURE_ARG_POINTER(aContentType);
     NS_ENSURE_ARG_POINTER(aExt);
     *aExt = nullptr;
     nsresult rv;
     if (!mMIMEService)
     {
         mMIMEService = do_GetService(NS_MIMESERVICE_CONTRACTID, &rv);
         NS_ENSURE_TRUE(mMIMEService, NS_ERROR_FAILURE);
     }
     nsCOMPtr<nsIMIMEInfo> mimeInfo;
     nsAutoCString contentType;
     contentType.AssignWithConversion(aContentType);
     nsAutoCString ext;
     rv = mMIMEService->GetPrimaryExtension(contentType, EmptyCString(), ext);
     if (NS_SUCCEEDED(rv))
     {
         *aExt = UTF8ToNewUnicode(ext);
         NS_ENSURE_TRUE(*aExt, NS_ERROR_OUT_OF_MEMORY);
         return NS_OK;
     }
     return NS_ERROR_FAILURE;
 }
 nsresult
 nsWebBrowserPersist::GetDocumentExtension(nsIDOMDocument *aDocument, char16_t **aExt)
 {
     NS_ENSURE_ARG_POINTER(aDocument);
     NS_ENSURE_ARG_POINTER(aExt);
     nsXPIDLString contentType;
     nsresult rv = GetDocEncoderContentType(aDocument, nullptr, getter_Copies(contentType));
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     return GetExtensionForContentType(contentType.get(), aExt);
 }
 nsresult
 nsWebBrowserPersist::GetDocEncoderContentType(nsIDOMDocument *aDocument, const char16_t *aContentType, char16_t **aRealContentType)
 {
     NS_ENSURE_ARG_POINTER(aDocument);
     NS_ENSURE_ARG_POINTER(aRealContentType);
     *aRealContentType = nullptr;
     nsAutoString defaultContentType(NS_LITERAL_STRING("text/html"));
     // Get the desired content type for the document, either by using the one
     // supplied or from the document itself.
     nsAutoString contentType;
     if (aContentType)
     {
         contentType.Assign(aContentType);
     }
     else
     {
         // Get the content type from the document
         nsAutoString type;
         if (NS_SUCCEEDED(aDocument->GetContentType(type)) && !type.IsEmpty())
             contentType.Assign(type);
     }
     // Check that an encoder actually exists for the desired output type. The
     // following content types will usually yield an encoder.
     //
     //   text/xml
     //   application/xml
     //   application/xhtml+xml
     //   image/svg+xml
     //   text/html
     //   text/plain
     if (!contentType.IsEmpty() &&
         !contentType.Equals(defaultContentType, nsCaseInsensitiveStringComparator()))
     {
         // Check if there is an encoder for the desired content type
         nsAutoCString contractID(NS_DOC_ENCODER_CONTRACTID_BASE);
         AppendUTF16toUTF8(contentType, contractID);
         nsCOMPtr<nsIComponentRegistrar> registrar;
         NS_GetComponentRegistrar(getter_AddRefs(registrar));
         if (registrar)
         {
             bool result;
             nsresult rv = registrar->IsContractIDRegistered(contractID.get(), &result);
             if (NS_SUCCEEDED(rv) && result)
             {
                 *aRealContentType = ToNewUnicode(contentType);
             }
         }
     }
     // Use the default if no encoder exists for the desired one
     if (!*aRealContentType)
     {
         *aRealContentType = ToNewUnicode(defaultContentType);
     }
     NS_ENSURE_TRUE(*aRealContentType, NS_ERROR_OUT_OF_MEMORY);
     return NS_OK;
 }
 nsresult nsWebBrowserPersist::SaveDocumentInternal(
     nsIDOMDocument *aDocument, nsIURI *aFile, nsIURI *aDataPath)
 {
     NS_ENSURE_ARG_POINTER(aDocument);
     NS_ENSURE_ARG_POINTER(aFile);
     // See if we can get the local file representation of this URI
     nsCOMPtr<nsIFile> localFile;
     nsresult rv = GetLocalFileFromURI(aFile, getter_AddRefs(localFile));
     nsCOMPtr<nsIFile> localDataPath;
     if (NS_SUCCEEDED(rv) && aDataPath)
     {
         // See if we can get the local file representation of this URI
         rv = GetLocalFileFromURI(aDataPath, getter_AddRefs(localDataPath));
         NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     }
     nsCOMPtr<nsIDOMNode> docAsNode = do_QueryInterface(aDocument);
     // Persist the main document
     nsCOMPtr<nsIDocument> doc(do_QueryInterface(aDocument));
     if (!doc) {
         return NS_ERROR_UNEXPECTED;
     }
     mURI = doc->GetDocumentURI();
     nsCOMPtr<nsIURI> oldBaseURI = mCurrentBaseURI;
     nsAutoCString oldCharset(mCurrentCharset);
     // Store the base URI and the charset
     mCurrentBaseURI = doc->GetBaseURI();
     mCurrentCharset = doc->GetDocumentCharacterSet();
     // Does the caller want to fixup the referenced URIs and save those too?
     if (aDataPath)
     {
         // Basic steps are these.
         //
         // 1. Iterate through the document (and subdocuments) building a list
         //    of unique URIs.
         // 2. For each URI create an OutputData entry and open a channel to save
         //    it. As each URI is saved, discover the mime type and fix up the
         //    local filename with the correct extension.
         // 3. Store the document in a list and wait for URI persistence to finish
         // 4. After URI persistence completes save the list of documents,
         //    fixing it up as it goes out to file.
         nsCOMPtr<nsIURI> oldDataPath = mCurrentDataPath;
         bool oldDataPathIsRelative = mCurrentDataPathIsRelative;
         nsCString oldCurrentRelativePathToData = mCurrentRelativePathToData;
         uint32_t oldThingsToPersist = mCurrentThingsToPersist;
         mCurrentDataPathIsRelative = false;
         mCurrentDataPath = aDataPath;
         mCurrentRelativePathToData = "";
         mCurrentThingsToPersist = 0;
         // Determine if the specified data path is relative to the
         // specified file, (e.g. c:\docs\htmldata is relative to
         // c:\docs\myfile.htm, but not to d:\foo\data.
         // Starting with the data dir work back through its parents
         // checking if one of them matches the base directory.
         if (localDataPath && localFile)
         {
             nsCOMPtr<nsIFile> baseDir;
             localFile->GetParent(getter_AddRefs(baseDir));
             nsAutoCString relativePathToData;
             nsCOMPtr<nsIFile> dataDirParent;
             dataDirParent = localDataPath;
             while (dataDirParent)
             {
                 bool sameDir = false;
                 dataDirParent->Equals(baseDir, &sameDir);
                 if (sameDir)
                 {
                     mCurrentRelativePathToData = relativePathToData;
                     mCurrentDataPathIsRelative = true;
                     break;
                 }
                 nsAutoString dirName;
                 dataDirParent->GetLeafName(dirName);
                 nsAutoCString newRelativePathToData;
                 newRelativePathToData = NS_ConvertUTF16toUTF8(dirName)
                                       + NS_LITERAL_CSTRING("/")
                                       + relativePathToData;
                 relativePathToData = newRelativePathToData;
                 nsCOMPtr<nsIFile> newDataDirParent;
                 rv = dataDirParent->GetParent(getter_AddRefs(newDataDirParent));
                 dataDirParent = newDataDirParent;
             }
         }
         else
         {
             // generate a relative path if possible
             nsCOMPtr<nsIURL> pathToBaseURL(do_QueryInterface(aFile));
             if (pathToBaseURL)
             {
                 nsAutoCString relativePath;  // nsACString
                 if (NS_SUCCEEDED(pathToBaseURL->GetRelativeSpec(aDataPath, relativePath)))
                 {
                     mCurrentDataPathIsRelative = true;
                     mCurrentRelativePathToData = relativePath;
                 }
             }
         }
         // Store the document in a list so when URI persistence is done and the
         // filenames of saved URIs are known, the documents can be fixed up and
         // saved
         DocData *docData = new DocData;
         docData->mBaseURI = mCurrentBaseURI;
         docData->mCharset = mCurrentCharset;
         docData->mDocument = aDocument;
         docData->mFile = aFile;
         docData->mRelativePathToData = mCurrentRelativePathToData;
         docData->mDataPath = mCurrentDataPath;
         docData->mDataPathIsRelative = mCurrentDataPathIsRelative;
         mDocList.AppendElement(docData);
         // Walk the DOM gathering a list of externally referenced URIs in the uri map
         nsCOMPtr<nsIDOMTreeWalker> walker;
         rv = aDocument->CreateTreeWalker(docAsNode,
             nsIDOMNodeFilter::SHOW_ELEMENT |
                 nsIDOMNodeFilter::SHOW_DOCUMENT |
                 nsIDOMNodeFilter::SHOW_PROCESSING_INSTRUCTION,
             nullptr, 1, getter_AddRefs(walker));
         NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
         nsCOMPtr<nsIDOMNode> currentNode;
         walker->GetCurrentNode(getter_AddRefs(currentNode));
         while (currentNode)
         {
             OnWalkDOMNode(currentNode);
             walker->NextNode(getter_AddRefs(currentNode));
         }
         // If there are things to persist, create a directory to hold them
         if (mCurrentThingsToPersist > 0)
         {
             if (localDataPath)
             {
                 bool exists = false;
                 bool haveDir = false;
                 localDataPath->Exists(&exists);
                 if (exists)
                 {
                     localDataPath->IsDirectory(&haveDir);
                 }
                 if (!haveDir)
                 {
                     rv = localDataPath->Create(nsIFile::DIRECTORY_TYPE, 0755);
                     if (NS_SUCCEEDED(rv))
                         haveDir = true;
                     else
                         SendErrorStatusChange(false, rv, nullptr, aFile);
                 }
                 if (!haveDir)
                 {
                     EndDownload(NS_ERROR_FAILURE);
                     mCurrentBaseURI = oldBaseURI;
                     mCurrentCharset = oldCharset;
                     return NS_ERROR_FAILURE;
                 }
                 if (mPersistFlags & PERSIST_FLAGS_CLEANUP_ON_FAILURE)
                 {
                     // Add to list of things to delete later if all goes wrong
                     CleanupData *cleanupData = new CleanupData;
                     NS_ENSURE_TRUE(cleanupData, NS_ERROR_OUT_OF_MEMORY);
                     cleanupData->mFile = localDataPath;
                     cleanupData->mIsDirectory = true;
                     mCleanupList.AppendElement(cleanupData);
                 }
             }
         }
         mCurrentThingsToPersist = oldThingsToPersist;
         mCurrentDataPath = oldDataPath;
         mCurrentDataPathIsRelative = oldDataPathIsRelative;
         mCurrentRelativePathToData = oldCurrentRelativePathToData;
     }
     else
     {
         // Set the document base to ensure relative links still work
         SetDocumentBase(aDocument, mCurrentBaseURI);
         // Get the content type to save with
         nsXPIDLString realContentType;
         GetDocEncoderContentType(aDocument,
             !mContentType.IsEmpty() ? mContentType.get() : nullptr,
             getter_Copies(realContentType));
         nsAutoCString contentType; contentType.AssignWithConversion(realContentType);
         nsAutoCString charType; // Empty
         // Save the document
         rv = SaveDocumentWithFixup(
             aDocument,
             nullptr,  // no dom fixup
             aFile,
             mReplaceExisting,
             contentType,
             charType,
             mEncodingFlags);
         NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     }
     mCurrentBaseURI = oldBaseURI;
     mCurrentCharset = oldCharset;
     return NS_OK;
 }
 nsresult nsWebBrowserPersist::SaveDocuments()
 {
     nsresult rv = NS_OK;
     mStartSaving = true;
     // Iterate through all queued documents, saving them to file and fixing
     // them up on the way.
     uint32_t i;
     for (i = 0; i < mDocList.Length(); i++)
     {
         DocData *docData = mDocList.ElementAt(i);
         if (!docData)
         {
             rv = NS_ERROR_FAILURE;
             break;
         }
         mCurrentBaseURI = docData->mBaseURI;
         mCurrentCharset = docData->mCharset;
         // Save the document, fixing it up with the new URIs as we do
         nsEncoderNodeFixup *nodeFixup;
         nodeFixup = new nsEncoderNodeFixup;
         if (nodeFixup)
             nodeFixup->mWebBrowserPersist = this;
         // Get the content type
         nsXPIDLString realContentType;
         GetDocEncoderContentType(docData->mDocument,
             !mContentType.IsEmpty() ? mContentType.get() : nullptr,
             getter_Copies(realContentType));
         nsAutoCString contentType; contentType.AssignWithConversion(realContentType.get());
         nsAutoCString charType; // Empty
         // Save the document, fixing up the links as it goes out
         rv = SaveDocumentWithFixup(
             docData->mDocument,
             nodeFixup,
             docData->mFile,
             mReplaceExisting,
             contentType,
             charType,
             mEncodingFlags);
         if (NS_FAILED(rv))
             break;
         // if we're serializing, bail after first iteration of loop
         if (mSerializingOutput)
             break;
     }
     // delete, cleanup regardless of errors (bug 132417)
     for (i = 0; i < mDocList.Length(); i++)
     {
         DocData *docData = mDocList.ElementAt(i);
         delete docData;
         if (mSerializingOutput)
         {
             mDocList.RemoveElementAt(i);
             break;
         }
     }
     if (!mSerializingOutput)
     {
         mDocList.Clear();
     }
     return rv;
 }
 void nsWebBrowserPersist::Cleanup()
 {
     mURIMap.Clear();
     mOutputMap.EnumerateRead(EnumCleanupOutputMap, this);
     mOutputMap.Clear();
     mUploadList.EnumerateRead(EnumCleanupUploadList, this);
     mUploadList.Clear();
     uint32_t i;
     for (i = 0; i < mDocList.Length(); i++)
     {
         DocData *docData = mDocList.ElementAt(i);
         delete docData;
     }
     mDocList.Clear();
     for (i = 0; i < mCleanupList.Length(); i++)
     {
         CleanupData *cleanupData = mCleanupList.ElementAt(i);
         delete cleanupData;
     }
     mCleanupList.Clear();
     mFilenameList.Clear();
 }
 void nsWebBrowserPersist::CleanupLocalFiles()
 {
     // Two passes, the first pass cleans up files, the second pass tests
     // for and then deletes empty directories. Directories that are not
     // empty after the first pass must contain files from something else
     // and are not deleted.
     int pass;
     for (pass = 0; pass < 2; pass++)
     {
         uint32_t i;
         for (i = 0; i < mCleanupList.Length(); i++)
         {
             CleanupData *cleanupData = mCleanupList.ElementAt(i);
             nsCOMPtr<nsIFile> file = cleanupData->mFile;
             // Test if the dir / file exists (something in an earlier loop
             // may have already removed it)
             bool exists = false;
             file->Exists(&exists);
             if (!exists)
                 continue;
             // Test if the file has changed in between creation and deletion
             // in some way that means it should be ignored
             bool isDirectory = false;
             file->IsDirectory(&isDirectory);
             if (isDirectory != cleanupData->mIsDirectory)
                 continue; // A file has become a dir or vice versa !
             if (pass == 0 && !isDirectory)
             {
                 file->Remove(false);
             }
             else if (pass == 1 && isDirectory) // Directory
             {
                 // Directories are more complicated. Enumerate through
                 // children looking for files. Any files created by the
                 // persist object would have been deleted by the first
                 // pass so if there are any there at this stage, the dir
                 // cannot be deleted because it has someone else's files
                 // in it. Empty child dirs are deleted but they must be
                 // recursed through to ensure they are actually empty.
                 bool isEmptyDirectory = true;
                 nsCOMArray<nsISimpleEnumerator> dirStack;
                 int32_t stackSize = 0;
                 // Push the top level enum onto the stack
                 nsCOMPtr<nsISimpleEnumerator> pos;
                 if (NS_SUCCEEDED(file->GetDirectoryEntries(getter_AddRefs(pos))))
                     dirStack.AppendObject(pos);
                 while (isEmptyDirectory && (stackSize = dirStack.Count()))
                 {
                     // Pop the last element
                     nsCOMPtr<nsISimpleEnumerator> curPos;
                     curPos = dirStack[stackSize-1];
                     dirStack.RemoveObjectAt(stackSize - 1);
                     // Test if the enumerator has any more files in it
                     bool hasMoreElements = false;
                     curPos->HasMoreElements(&hasMoreElements);
                     if (!hasMoreElements)
                     {
                         continue;
                     }
                     // Child files automatically make this code drop out,
                     // while child dirs keep the loop going.
                     nsCOMPtr<nsISupports> child;
                     curPos->GetNext(getter_AddRefs(child));
                     NS_ASSERTION(child, "No child element, but hasMoreElements says otherwise");
                     if (!child)
                         continue;
                     nsCOMPtr<nsIFile> childAsFile = do_QueryInterface(child);
                     NS_ASSERTION(childAsFile, "This should be a file but isn't");
                     bool childIsSymlink = false;
                     childAsFile->IsSymlink(&childIsSymlink);
                     bool childIsDir = false;
                     childAsFile->IsDirectory(&childIsDir);
                     if (!childIsDir || childIsSymlink)
                     {
                         // Some kind of file or symlink which means dir
                         // is not empty so just drop out.
                         isEmptyDirectory = false;
                         break;
                     }
                     // Push parent enumerator followed by child enumerator
                     nsCOMPtr<nsISimpleEnumerator> childPos;
                     childAsFile->GetDirectoryEntries(getter_AddRefs(childPos));
                     dirStack.AppendObject(curPos);
                     if (childPos)
                         dirStack.AppendObject(childPos);
                 }
                 dirStack.Clear();
                 // If after all that walking the dir is deemed empty, delete it
                 if (isEmptyDirectory)
                 {
                     file->Remove(true);
                 }
             }
         }
     }
 }
 nsresult
 nsWebBrowserPersist::CalculateUniqueFilename(nsIURI *aURI)
 {
     nsCOMPtr<nsIURL> url(do_QueryInterface(aURI));
     NS_ENSURE_TRUE(url, NS_ERROR_FAILURE);
     bool nameHasChanged = false;
     nsresult rv;
     // Get the old filename
     nsAutoCString filename;
     rv = url->GetFileName(filename);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     nsAutoCString directory;
     rv = url->GetDirectory(directory);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     // Split the filename into a base and an extension.
     // e.g. "foo.html" becomes "foo" & ".html"
     //
     // The nsIURL methods GetFileBaseName & GetFileExtension don't
     // preserve the dot whereas this code does to save some effort
     // later when everything is put back together.
     int32_t lastDot = filename.RFind(".");
     nsAutoCString base;
     nsAutoCString ext;
     if (lastDot >= 0)
     {
         filename.Mid(base, 0, lastDot);
         filename.Mid(ext, lastDot, filename.Length() - lastDot); // includes dot
     }
     else
     {
         // filename contains no dot
         base = filename;
     }
     // Test if the filename is longer than allowed by the OS
     int32_t needToChop = filename.Length() - kDefaultMaxFilenameLength;
     if (needToChop > 0)
     {
         // Truncate the base first and then the ext if necessary
         if (base.Length() > (uint32_t) needToChop)
         {
             base.Truncate(base.Length() - needToChop);
         }
         else
         {
             needToChop -= base.Length() - 1;
             base.Truncate(1);
             if (ext.Length() > (uint32_t) needToChop)
             {
                 ext.Truncate(ext.Length() - needToChop);
             }
             else
             {
                 ext.Truncate(0);
             }
             // If kDefaultMaxFilenameLength were 1 we'd be in trouble here,
             // but that won't happen because it will be set to a sensible
             // value.
         }
         filename.Assign(base);
         filename.Append(ext);
         nameHasChanged = true;
     }
     // Ensure the filename is unique
     // Create a filename if it's empty, or if the filename / datapath is
     // already taken by another URI and create an alternate name.
     if (base.IsEmpty() || !mFilenameList.IsEmpty())
     {
         nsAutoCString tmpPath;
         nsAutoCString tmpBase;
         uint32_t duplicateCounter = 1;
         while (1)
         {
             // Make a file name,
             // Foo become foo_001, foo_002, etc.
             // Empty files become _001, _002 etc.
             if (base.IsEmpty() || duplicateCounter > 1)
             {
                 char * tmp = PR_smprintf("_%03d", duplicateCounter);
                 NS_ENSURE_TRUE(tmp, NS_ERROR_OUT_OF_MEMORY);
                 if (filename.Length() < kDefaultMaxFilenameLength - 4)
                 {
                     tmpBase = base;
                 }
                 else
                 {
                     base.Mid(tmpBase, 0, base.Length() - 4);
                 }
                 tmpBase.Append(tmp);
                 PR_smprintf_free(tmp);
             }
             else
             {
                 tmpBase = base;
             }
             tmpPath.Assign(directory);
             tmpPath.Append(tmpBase);
             tmpPath.Append(ext);
             // Test if the name is a duplicate
             if (!mFilenameList.Contains(tmpPath))
             {
                 if (!base.Equals(tmpBase))
                 {
                     filename.Assign(tmpBase);
                     filename.Append(ext);
                     nameHasChanged = true;
                 }
                 break;
             }
             duplicateCounter++;
         }
     }
     // Add name to list of those already used
     nsAutoCString newFilepath(directory);
     newFilepath.Append(filename);
     mFilenameList.AppendElement(newFilepath);
     // Update the uri accordingly if the filename actually changed
     if (nameHasChanged)
     {
         // Final sanity test
         if (filename.Length() > kDefaultMaxFilenameLength)
         {
             NS_WARNING("Filename wasn't truncated less than the max file length - how can that be?");
             return NS_ERROR_FAILURE;
         }
         nsCOMPtr<nsIFile> localFile;
         GetLocalFileFromURI(aURI, getter_AddRefs(localFile));
         if (localFile)
         {
             nsAutoString filenameAsUnichar;
             filenameAsUnichar.AssignWithConversion(filename.get());
             localFile->SetLeafName(filenameAsUnichar);
             // Resync the URI with the file after the extension has been appended
             nsresult rv;
             nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aURI, &rv);
             NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
             fileURL->SetFile(localFile);  // this should recalculate uri
         }
         else
         {
             url->SetFileName(filename);
         }
     }
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::MakeFilenameFromURI(nsIURI *aURI, nsString &aFilename)
 {
     // Try to get filename from the URI.
     nsAutoString fileName;
     // Get a suggested file name from the URL but strip it of characters
     // likely to cause the name to be illegal.
     nsCOMPtr<nsIURL> url(do_QueryInterface(aURI));
     if (url)
     {
         nsAutoCString nameFromURL;
         url->GetFileName(nameFromURL);
         if (mPersistFlags & PERSIST_FLAGS_DONT_CHANGE_FILENAMES)
         {
             fileName.AssignWithConversion(NS_UnescapeURL(nameFromURL).get());
             goto end;
         }
         if (!nameFromURL.IsEmpty())
         {
             // Unescape the file name (GetFileName escapes it)
             NS_UnescapeURL(nameFromURL);
             uint32_t nameLength = 0;
             const char *p = nameFromURL.get();
             for (;*p && *p != ';' && *p != '?' && *p != '#' && *p != '.'
                  ;p++)
             {
                 if (nsCRT::IsAsciiAlpha(*p) || nsCRT::IsAsciiDigit(*p)
                     || *p == '.' || *p == '-' ||  *p == '_' || (*p == ' '))
                 {
                     fileName.Append(char16_t(*p));
                     if (++nameLength == kDefaultMaxFilenameLength)
                     {
                         // Note:
                         // There is no point going any further since it will be
                         // truncated in CalculateUniqueFilename anyway.
                         // More importantly, certain implementations of
                         // nsIFile (e.g. the Mac impl) might truncate
                         // names in undesirable ways, such as truncating from
                         // the middle, inserting ellipsis and so on.
                         break;
                     }
                 }
             }
         }
     }
     // Empty filenames can confuse the local file object later
     // when it attempts to set the leaf name in CalculateUniqueFilename
     // for duplicates and ends up replacing the parent dir. To avoid
     // the problem, all filenames are made at least one character long.
     if (fileName.IsEmpty())
     {
         fileName.Append(char16_t('a')); // 'a' is for arbitrary
     }
 end:
     aFilename = fileName;
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::CalculateAndAppendFileExt(nsIURI *aURI, nsIChannel *aChannel, nsIURI *aOriginalURIWithExtension)
 {
     nsresult rv;
     if (!mMIMEService)
     {
         mMIMEService = do_GetService(NS_MIMESERVICE_CONTRACTID, &rv);
         NS_ENSURE_TRUE(mMIMEService, NS_ERROR_FAILURE);
     }
     nsAutoCString contentType;
     // Get the content type from the channel
     aChannel->GetContentType(contentType);
     // Get the content type from the MIME service
     if (contentType.IsEmpty())
     {
         nsCOMPtr<nsIURI> uri;
         aChannel->GetOriginalURI(getter_AddRefs(uri));
         mMIMEService->GetTypeFromURI(uri, contentType);
     }
     // Append the extension onto the file
     if (!contentType.IsEmpty())
     {
         nsCOMPtr<nsIMIMEInfo> mimeInfo;
         mMIMEService->GetFromTypeAndExtension(
             contentType, EmptyCString(), getter_AddRefs(mimeInfo));
         nsCOMPtr<nsIFile> localFile;
         GetLocalFileFromURI(aURI, getter_AddRefs(localFile));
         if (mimeInfo)
         {
             nsCOMPtr<nsIURL> url(do_QueryInterface(aURI));
             NS_ENSURE_TRUE(url, NS_ERROR_FAILURE);
             nsAutoCString newFileName;
             url->GetFileName(newFileName);
             // Test if the current extension is current for the mime type
             bool hasExtension = false;
             int32_t ext = newFileName.RFind(".");
             if (ext != -1)
             {
                 mimeInfo->ExtensionExists(Substring(newFileName, ext + 1), &hasExtension);
             }
             // Append the mime file extension
             nsAutoCString fileExt;
             if (!hasExtension)
             {
                 // Test if previous extension is acceptable
                 nsCOMPtr<nsIURL> oldurl(do_QueryInterface(aOriginalURIWithExtension));
                 NS_ENSURE_TRUE(oldurl, NS_ERROR_FAILURE);
                 oldurl->GetFileExtension(fileExt);
                 bool useOldExt = false;
                 if (!fileExt.IsEmpty())
                 {
                     mimeInfo->ExtensionExists(fileExt, &useOldExt);
                 }
                 // can't use old extension so use primary extension
                 if (!useOldExt)
                 {
                     mimeInfo->GetPrimaryExtension(fileExt);
                 }
                 if (!fileExt.IsEmpty())
                 {
                     uint32_t newLength = newFileName.Length() + fileExt.Length() + 1;
                     if (newLength > kDefaultMaxFilenameLength)
                     {
                         if (fileExt.Length() > kDefaultMaxFilenameLength/2)
                             fileExt.Truncate(kDefaultMaxFilenameLength/2);
                         uint32_t diff = kDefaultMaxFilenameLength - 1 -
                                         fileExt.Length();
                         if (newFileName.Length() > diff)
                             newFileName.Truncate(diff);
                     }
                     newFileName.Append(".");
                     newFileName.Append(fileExt);
                 }
                 if (localFile)
                 {
                     localFile->SetLeafName(NS_ConvertUTF8toUTF16(newFileName));
                     // Resync the URI with the file after the extension has been appended
                     nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aURI, &rv);
                     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
                     fileURL->SetFile(localFile);  // this should recalculate uri
                 }
                 else
                 {
                     url->SetFileName(newFileName);
                 }
             }
         }
     }
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::MakeOutputStream(
     nsIURI *aURI, nsIOutputStream **aOutputStream)
 {
     nsresult rv;
     nsCOMPtr<nsIFile> localFile;
     GetLocalFileFromURI(aURI, getter_AddRefs(localFile));
     if (localFile)
         rv = MakeOutputStreamFromFile(localFile, aOutputStream);
     else
         rv = MakeOutputStreamFromURI(aURI, aOutputStream);
     return rv;
 }
 nsresult
 nsWebBrowserPersist::MakeOutputStreamFromFile(
     nsIFile *aFile, nsIOutputStream **aOutputStream)
 {
     nsresult rv = NS_OK;
     nsCOMPtr<nsIFileOutputStream> fileOutputStream =
         do_CreateInstance(NS_LOCALFILEOUTPUTSTREAM_CONTRACTID, &rv);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     // XXX brade:  get the right flags here!
     int32_t ioFlags = -1;
     if (mPersistFlags & nsIWebBrowserPersist::PERSIST_FLAGS_APPEND_TO_FILE)
       ioFlags = PR_APPEND | PR_CREATE_FILE | PR_WRONLY;
     rv = fileOutputStream->Init(aFile, ioFlags, -1, 0);
     NS_ENSURE_SUCCESS(rv, rv);
     *aOutputStream = NS_BufferOutputStream(fileOutputStream,
                                            BUFFERED_OUTPUT_SIZE).take();
     if (mPersistFlags & PERSIST_FLAGS_CLEANUP_ON_FAILURE)
     {
         // Add to cleanup list in event of failure
         CleanupData *cleanupData = new CleanupData;
         if (!cleanupData) {
           NS_RELEASE(*aOutputStream);
           return NS_ERROR_OUT_OF_MEMORY;
         }
         cleanupData->mFile = aFile;
         cleanupData->mIsDirectory = false;
         mCleanupList.AppendElement(cleanupData);
     }
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::MakeOutputStreamFromURI(
     nsIURI *aURI, nsIOutputStream  **aOutputStream)
 {
     uint32_t segsize = 8192;
     uint32_t maxsize = uint32_t(-1);
     nsCOMPtr<nsIStorageStream> storStream;
     nsresult rv = NS_NewStorageStream(segsize, maxsize, getter_AddRefs(storStream));
     NS_ENSURE_SUCCESS(rv, rv);
     NS_ENSURE_SUCCESS(CallQueryInterface(storStream, aOutputStream), NS_ERROR_FAILURE);
     return NS_OK;
 }
 void
 nsWebBrowserPersist::EndDownload(nsresult aResult)
 {
     // Store the error code in the result if it is an error
     if (NS_SUCCEEDED(mPersistResult) && NS_FAILED(aResult))
     {
         mPersistResult = aResult;
     }
     // Do file cleanup if required
     if (NS_FAILED(aResult) && (mPersistFlags & PERSIST_FLAGS_CLEANUP_ON_FAILURE))
     {
         CleanupLocalFiles();
     }
     // Cleanup the channels
     mCompleted = true;
     Cleanup();
 }
 struct MOZ_STACK_CLASS FixRedirectData
 {
     nsCOMPtr<nsIChannel> mNewChannel;
     nsCOMPtr<nsIURI> mOriginalURI;
     nsCOMPtr<nsISupports> mMatchingKey;
 };
 nsresult
 nsWebBrowserPersist::FixRedirectedChannelEntry(nsIChannel *aNewChannel)
 {
     NS_ENSURE_ARG_POINTER(aNewChannel);
     nsCOMPtr<nsIURI> originalURI;
     // Enumerate through existing open channels looking for one with
     // a URI matching the one specified.
     FixRedirectData data;
     data.mNewChannel = aNewChannel;
     data.mNewChannel->GetOriginalURI(getter_AddRefs(data.mOriginalURI));
     mOutputMap.EnumerateRead(EnumFixRedirect, &data);
     // If a match is found, remove the data entry with the old channel key
     // and re-add it with the new channel key.
     if (data.mMatchingKey)
     {
         nsAutoPtr<OutputData> outputData;
         mOutputMap.RemoveAndForget(data.mMatchingKey, outputData);
         NS_ENSURE_TRUE(outputData, NS_ERROR_FAILURE);
         // Store data again with new channel unless told to ignore redirects
         if (!(mPersistFlags & PERSIST_FLAGS_IGNORE_REDIRECTED_DATA))
         {
             nsCOMPtr<nsISupports> keyPtr = do_QueryInterface(aNewChannel);
             mOutputMap.Put(keyPtr, outputData.forget());
         }
     }
     return NS_OK;
 }
 PLDHashOperator
 nsWebBrowserPersist::EnumFixRedirect(nsISupports *aKey, OutputData *aData, void* aClosure)
 {
     FixRedirectData *data = static_cast<FixRedirectData*>(aClosure);
     nsCOMPtr<nsIChannel> thisChannel = do_QueryInterface(aKey);
     nsCOMPtr<nsIURI> thisURI;
     thisChannel->GetOriginalURI(getter_AddRefs(thisURI));
     // Compare this channel's URI to the one passed in.
     bool matchingURI = false;
     thisURI->Equals(data->mOriginalURI, &matchingURI);
     if (matchingURI)
     {
         data->mMatchingKey = aKey;
         return PL_DHASH_STOP;
     }
     return PL_DHASH_NEXT;
 }
 void
 nsWebBrowserPersist::CalcTotalProgress()
 {
     mTotalCurrentProgress = 0;
     mTotalMaxProgress = 0;
     if (mOutputMap.Count() > 0)
     {
         // Total up the progress of each output stream
         mOutputMap.EnumerateRead(EnumCalcProgress, this);
     }
     if (mUploadList.Count() > 0)
     {
         // Total up the progress of each upload
         mUploadList.EnumerateRead(EnumCalcUploadProgress, this);
     }
     // XXX this code seems pretty bogus and pointless
     if (mTotalCurrentProgress == 0 && mTotalMaxProgress == 0)
     {
         // No output streams so we must be complete
         mTotalCurrentProgress = 10000;
         mTotalMaxProgress = 10000;
     }
 }
 PLDHashOperator
 nsWebBrowserPersist::EnumCalcProgress(nsISupports *aKey, OutputData *aData, void* aClosure)
 {
     nsWebBrowserPersist *pthis = static_cast<nsWebBrowserPersist*>(aClosure);
     // only count toward total progress if destination file is local
     nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aData->mFile);
     if (fileURL)
     {
         pthis->mTotalCurrentProgress += aData->mSelfProgress;
         pthis->mTotalMaxProgress += aData->mSelfProgressMax;
     }
     return PL_DHASH_NEXT;
 }
 PLDHashOperator
 nsWebBrowserPersist::EnumCalcUploadProgress(nsISupports *aKey, UploadData *aData, void* aClosure)
 {
     if (aData && aClosure)
     {
         nsWebBrowserPersist *pthis = static_cast<nsWebBrowserPersist*>(aClosure);
         pthis->mTotalCurrentProgress += aData->mSelfProgress;
         pthis->mTotalMaxProgress += aData->mSelfProgressMax;
     }
     return PL_DHASH_NEXT;
 }
 PLDHashOperator
 nsWebBrowserPersist::EnumCountURIsToPersist(const nsACString &aKey, URIData *aData, void* aClosure)
 {
     uint32_t *count = static_cast<uint32_t*>(aClosure);
     if (aData->mNeedsPersisting && !aData->mSaved)
     {
         (*count)++;
     }
     return PL_DHASH_NEXT;
 }
 PLDHashOperator
 nsWebBrowserPersist::EnumPersistURIs(const nsACString &aKey, URIData *aData, void* aClosure)
 {
     if (!aData->mNeedsPersisting || aData->mSaved)
     {
         return PL_DHASH_NEXT;
     }
     nsWebBrowserPersist *pthis = static_cast<nsWebBrowserPersist*>(aClosure);
     nsresult rv;
     // Create a URI from the key
     nsAutoCString key = nsAutoCString(aKey);
     nsCOMPtr<nsIURI> uri;
     rv = NS_NewURI(getter_AddRefs(uri),
                    nsDependentCString(key.get(), key.Length()),
                    aData->mCharset.get());
     NS_ENSURE_SUCCESS(rv, PL_DHASH_STOP);
     // Make a URI to save the data to
     nsCOMPtr<nsIURI> fileAsURI;
     rv = aData->mDataPath->Clone(getter_AddRefs(fileAsURI));
     NS_ENSURE_SUCCESS(rv, PL_DHASH_STOP);
     rv = pthis->AppendPathToURI(fileAsURI, aData->mFilename);
     NS_ENSURE_SUCCESS(rv, PL_DHASH_STOP);
     rv = pthis->SaveURIInternal(uri, nullptr, nullptr, nullptr, nullptr, fileAsURI, true,
                                 pthis->mIsPrivate);
     // if SaveURIInternal fails, then it will have called EndDownload,
     // which means that |aData| is no longer valid memory.  we MUST bail.
     NS_ENSURE_SUCCESS(rv, PL_DHASH_STOP);
     if (rv == NS_OK)
     {
         // Store the actual object because once it's persisted this
         // will be fixed up with the right file extension.
         aData->mFile = fileAsURI;
         aData->mSaved = true;
     }
     else
     {
         aData->mNeedsFixup = false;
     }
     if (pthis->mSerializingOutput)
         return PL_DHASH_STOP;
     return PL_DHASH_NEXT;
 }
 PLDHashOperator
 nsWebBrowserPersist::EnumCleanupOutputMap(nsISupports *aKey, OutputData *aData, void* aClosure)
 {
     nsCOMPtr<nsIChannel> channel = do_QueryInterface(aKey);
     if (channel)
     {
         channel->Cancel(NS_BINDING_ABORTED);
     }
     return PL_DHASH_NEXT;
 }
 PLDHashOperator
 nsWebBrowserPersist::EnumCleanupUploadList(nsISupports *aKey, UploadData *aData, void* aClosure)
 {
     nsCOMPtr<nsIChannel> channel = do_QueryInterface(aKey);
     if (channel)
     {
         channel->Cancel(NS_BINDING_ABORTED);
     }
     return PL_DHASH_NEXT;
 }
 nsresult nsWebBrowserPersist::FixupXMLStyleSheetLink(nsIDOMProcessingInstruction *aPI, const nsAString &aHref)
 {
     NS_ENSURE_ARG_POINTER(aPI);
     nsresult rv = NS_OK;
     nsAutoString data;
     rv = aPI->GetData(data);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     nsAutoString href;
     nsContentUtils::GetPseudoAttributeValue(data,
                                             nsGkAtoms::href,
                                             href);
     // Construct and set a new data value for the xml-stylesheet
     if (!aHref.IsEmpty() && !href.IsEmpty())
     {
         nsAutoString alternate;
         nsAutoString charset;
         nsAutoString title;
         nsAutoString type;
         nsAutoString media;
         nsContentUtils::GetPseudoAttributeValue(data,
                                                 nsGkAtoms::alternate,
                                                 alternate);
         nsContentUtils::GetPseudoAttributeValue(data,
                                                 nsGkAtoms::charset,
                                                 charset);
         nsContentUtils::GetPseudoAttributeValue(data,
                                                 nsGkAtoms::title,
                                                 title);
         nsContentUtils::GetPseudoAttributeValue(data,
                                                 nsGkAtoms::type,
                                                 type);
         nsContentUtils::GetPseudoAttributeValue(data,
                                                 nsGkAtoms::media,
                                                 media);
         NS_NAMED_LITERAL_STRING(kCloseAttr, "\" ");
         nsAutoString newData;
         newData += NS_LITERAL_STRING("href=\"") + aHref + kCloseAttr;
         if (!title.IsEmpty())
         {
             newData += NS_LITERAL_STRING("title=\"") + title + kCloseAttr;
         }
         if (!media.IsEmpty())
         {
             newData += NS_LITERAL_STRING("media=\"") + media + kCloseAttr;
         }
         if (!type.IsEmpty())
         {
             newData += NS_LITERAL_STRING("type=\"") + type + kCloseAttr;
         }
         if (!charset.IsEmpty())
         {
             newData += NS_LITERAL_STRING("charset=\"") + charset + kCloseAttr;
         }
         if (!alternate.IsEmpty())
         {
             newData += NS_LITERAL_STRING("alternate=\"") + alternate + kCloseAttr;
         }
         newData.Truncate(newData.Length() - 1);  // Remove the extra space on the end.
         aPI->SetData(newData);
     }
     return rv;
 }
 nsresult nsWebBrowserPersist::GetXMLStyleSheetLink(nsIDOMProcessingInstruction *aPI, nsAString &aHref)
 {
     NS_ENSURE_ARG_POINTER(aPI);
     nsresult rv = NS_OK;
     nsAutoString data;
     rv = aPI->GetData(data);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::href, aHref);
     return NS_OK;
 }
 nsresult nsWebBrowserPersist::OnWalkDOMNode(nsIDOMNode *aNode)
 {
     // Fixup xml-stylesheet processing instructions
     nsCOMPtr<nsIDOMProcessingInstruction> nodeAsPI = do_QueryInterface(aNode);
     if (nodeAsPI)
     {
         nsAutoString target;
         nodeAsPI->GetTarget(target);
         if (target.EqualsLiteral("xml-stylesheet"))
         {
             nsAutoString href;
             GetXMLStyleSheetLink(nodeAsPI, href);
             if (!href.IsEmpty())
             {
                 StoreURI(NS_ConvertUTF16toUTF8(href).get());
             }
         }
         return NS_OK;
     }
     nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
     if (!content)
     {
         return NS_OK;
     }
     // Test the node to see if it's an image, frame, iframe, css, js
     nsCOMPtr<nsIDOMHTMLImageElement> nodeAsImage = do_QueryInterface(aNode);
     if (nodeAsImage)
     {
         StoreURIAttribute(aNode, "src");
         return NS_OK;
     }
     if (content->IsSVG(nsGkAtoms::img))
     {
         StoreURIAttributeNS(aNode, "http://www.w3.org/1999/xlink", "href");
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLMediaElement> nodeAsMedia = do_QueryInterface(aNode);
     if (nodeAsMedia)
     {
         StoreURIAttribute(aNode, "src");
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLSourceElement> nodeAsSource = do_QueryInterface(aNode);
     if (nodeAsSource)
     {
         StoreURIAttribute(aNode, "src");
         return NS_OK;
     }
     if (content->IsHTML(nsGkAtoms::body)) {
         StoreURIAttribute(aNode, "background");
         return NS_OK;
     }
     if (content->IsHTML(nsGkAtoms::table)) {
         StoreURIAttribute(aNode, "background");
         return NS_OK;
     }
     if (content->IsHTML(nsGkAtoms::tr)) {
         StoreURIAttribute(aNode, "background");
         return NS_OK;
     }
     if (content->IsHTML(nsGkAtoms::td) || content->IsHTML(nsGkAtoms::th)) {
         StoreURIAttribute(aNode, "background");
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLScriptElement> nodeAsScript = do_QueryInterface(aNode);
     if (nodeAsScript)
     {
         StoreURIAttribute(aNode, "src");
         return NS_OK;
     }
     if (content->IsSVG(nsGkAtoms::script))
     {
         StoreURIAttributeNS(aNode, "http://www.w3.org/1999/xlink", "href");
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLEmbedElement> nodeAsEmbed = do_QueryInterface(aNode);
     if (nodeAsEmbed)
     {
         StoreURIAttribute(aNode, "src");
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLObjectElement> nodeAsObject = do_QueryInterface(aNode);
     if (nodeAsObject)
     {
         StoreURIAttribute(aNode, "data");
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLAppletElement> nodeAsApplet = do_QueryInterface(aNode);
     if (nodeAsApplet)
     {
         // For an applet, relative URIs are resolved relative to the
         // codebase (which is resolved relative to the base URI).
         nsCOMPtr<nsIURI> oldBase = mCurrentBaseURI;
         nsAutoString codebase;
         nodeAsApplet->GetCodeBase(codebase);
         if (!codebase.IsEmpty()) {
             nsCOMPtr<nsIURI> baseURI;
             NS_NewURI(getter_AddRefs(baseURI), codebase,
                       mCurrentCharset.get(), mCurrentBaseURI);
             if (baseURI) {
                 mCurrentBaseURI = baseURI;
             }
         }
         URIData *archiveURIData = nullptr;
         StoreURIAttribute(aNode, "archive", true, &archiveURIData);
         // We only store 'code' locally if there is no 'archive',
         // otherwise we assume the archive file(s) contains it (bug 430283).
         if (!archiveURIData)
             StoreURIAttribute(aNode, "code");
         // restore the base URI we really want to have
         mCurrentBaseURI = oldBase;
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLLinkElement> nodeAsLink = do_QueryInterface(aNode);
     if (nodeAsLink)
     {
         // Test if the link has a rel value indicating it to be a stylesheet
         nsAutoString linkRel;
         if (NS_SUCCEEDED(nodeAsLink->GetRel(linkRel)) && !linkRel.IsEmpty())
         {
             nsReadingIterator<char16_t> start;
             nsReadingIterator<char16_t> end;
             nsReadingIterator<char16_t> current;
             linkRel.BeginReading(start);
             linkRel.EndReading(end);
             // Walk through space delimited string looking for "stylesheet"
             for (current = start; current != end; ++current)
             {
                 // Ignore whitespace
                 if (nsCRT::IsAsciiSpace(*current))
                     continue;
                 // Grab the next space delimited word
                 nsReadingIterator<char16_t> startWord = current;
                 do {
                     ++current;
                 } while (current != end && !nsCRT::IsAsciiSpace(*current));
                 // Store the link for fix up if it says "stylesheet"
                 if (Substring(startWord, current)
                         .LowerCaseEqualsLiteral("stylesheet"))
                 {
                     StoreURIAttribute(aNode, "href");
                     return NS_OK;
                 }
                 if (current == end)
                     break;
             }
         }
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLFrameElement> nodeAsFrame = do_QueryInterface(aNode);
     if (nodeAsFrame)
     {
         URIData *data = nullptr;
         StoreURIAttribute(aNode, "src", false, &data);
         if (data)
         {
             data->mIsSubFrame = true;
             // Save the frame content
             nsCOMPtr<nsIDOMDocument> content;
             nodeAsFrame->GetContentDocument(getter_AddRefs(content));
             if (content)
             {
                 SaveSubframeContent(content, data);
             }
         }
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLIFrameElement> nodeAsIFrame = do_QueryInterface(aNode);
     if (nodeAsIFrame && !(mPersistFlags & PERSIST_FLAGS_IGNORE_IFRAMES))
     {
         URIData *data = nullptr;
         StoreURIAttribute(aNode, "src", false, &data);
         if (data)
         {
             data->mIsSubFrame = true;
             // Save the frame content
             nsCOMPtr<nsIDOMDocument> content;
             nodeAsIFrame->GetContentDocument(getter_AddRefs(content));
             if (content)
             {
                 SaveSubframeContent(content, data);
             }
         }
         return NS_OK;
     }
     nsCOMPtr<nsIDOMHTMLInputElement> nodeAsInput = do_QueryInterface(aNode);
     if (nodeAsInput)
     {
         StoreURIAttribute(aNode, "src");
         return NS_OK;
     }
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::GetNodeToFixup(nsIDOMNode *aNodeIn, nsIDOMNode **aNodeOut)
 {
     if (!(mPersistFlags & PERSIST_FLAGS_FIXUP_ORIGINAL_DOM))
     {
         nsresult rv = aNodeIn->CloneNode(false, 1, aNodeOut);
         NS_ENSURE_SUCCESS(rv, rv);
     }
     else
     {
         NS_ADDREF(*aNodeOut = aNodeIn);
     }
     nsCOMPtr<nsIDOMHTMLElement> element(do_QueryInterface(*aNodeOut));
     if (element) {
         // Make sure this is not XHTML
         nsAutoString namespaceURI;
         element->GetNamespaceURI(namespaceURI);
         if (namespaceURI.IsEmpty()) {
             // This is a tag-soup node.  It may have a _base_href attribute
             // stuck on it by the parser, but since we're fixing up all URIs
             // relative to the overall document base that will screw us up.
             // Just remove the _base_href.
             element->RemoveAttribute(NS_LITERAL_STRING("_base_href"));
         }
     }
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::CloneNodeWithFixedUpAttributes(
     nsIDOMNode *aNodeIn, bool *aSerializeCloneKids, nsIDOMNode **aNodeOut)
 {
     nsresult rv;
     *aNodeOut = nullptr;
     *aSerializeCloneKids = false;
     // Fixup xml-stylesheet processing instructions
     nsCOMPtr<nsIDOMProcessingInstruction> nodeAsPI = do_QueryInterface(aNodeIn);
     if (nodeAsPI)
     {
         nsAutoString target;
         nodeAsPI->GetTarget(target);
         if (target.EqualsLiteral("xml-stylesheet"))
         {
             rv = GetNodeToFixup(aNodeIn, aNodeOut);
             if (NS_SUCCEEDED(rv) && *aNodeOut)
             {
                 nsCOMPtr<nsIDOMProcessingInstruction> outNode = do_QueryInterface(*aNodeOut);
                 nsAutoString href;
                 GetXMLStyleSheetLink(nodeAsPI, href);
                 if (!href.IsEmpty())
                 {
                     FixupURI(href);
                     FixupXMLStyleSheetLink(outNode, href);
                 }
             }
         }
     }
     // BASE elements are replaced by a comment so relative links are not hosed.
     if (!(mPersistFlags & PERSIST_FLAGS_NO_BASE_TAG_MODIFICATIONS))
     {
         nsCOMPtr<nsIDOMHTMLBaseElement> nodeAsBase = do_QueryInterface(aNodeIn);
         if (nodeAsBase)
         {
             nsCOMPtr<nsIDOMDocument> ownerDocument;
             HTMLSharedElement* base = static_cast<HTMLSharedElement*>(nodeAsBase.get());
             base->GetOwnerDocument(getter_AddRefs(ownerDocument));
             if (ownerDocument)
             {
                 nsAutoString href;
                 base->GetHref(href); // Doesn't matter if this fails
                 nsCOMPtr<nsIDOMComment> comment;
                 nsAutoString commentText; commentText.AssignLiteral(" base ");
                 if (!href.IsEmpty())
                 {
                     commentText += NS_LITERAL_STRING("href=\"") + href + NS_LITERAL_STRING("\" ");
                 }
                 rv = ownerDocument->CreateComment(commentText, getter_AddRefs(comment));
                 if (comment)
                 {
                     return CallQueryInterface(comment, aNodeOut);
                 }
             }
         }
     }
     nsCOMPtr<nsIContent> content = do_QueryInterface(aNodeIn);
     if (!content)
     {
         return NS_OK;
     }
     // Fix up href and file links in the elements
     nsCOMPtr<nsIDOMHTMLAnchorElement> nodeAsAnchor = do_QueryInterface(aNodeIn);
     if (nodeAsAnchor)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupAnchor(*aNodeOut);
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLAreaElement> nodeAsArea = do_QueryInterface(aNodeIn);
     if (nodeAsArea)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupAnchor(*aNodeOut);
         }
         return rv;
     }
     if (content->IsHTML(nsGkAtoms::body)) {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "background");
         }
         return rv;
     }
     if (content->IsHTML(nsGkAtoms::table)) {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "background");
         }
         return rv;
     }
     if (content->IsHTML(nsGkAtoms::tr)) {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "background");
         }
         return rv;
     }
     if (content->IsHTML(nsGkAtoms::td) || content->IsHTML(nsGkAtoms::th)) {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "background");
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLImageElement> nodeAsImage = do_QueryInterface(aNodeIn);
     if (nodeAsImage)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             // Disable image loads
             nsCOMPtr<nsIImageLoadingContent> imgCon =
                 do_QueryInterface(*aNodeOut);
             if (imgCon)
                 imgCon->SetLoadingEnabled(false);
             FixupAnchor(*aNodeOut);
             FixupNodeAttribute(*aNodeOut, "src");
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLMediaElement> nodeAsMedia = do_QueryInterface(aNodeIn);
     if (nodeAsMedia)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "src");
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLSourceElement> nodeAsSource = do_QueryInterface(aNodeIn);
     if (nodeAsSource)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "src");
         }
         return rv;
     }
     if (content->IsSVG(nsGkAtoms::img))
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             // Disable image loads
             nsCOMPtr<nsIImageLoadingContent> imgCon =
                 do_QueryInterface(*aNodeOut);
             if (imgCon)
                 imgCon->SetLoadingEnabled(false);
             // FixupAnchor(*aNodeOut);  // XXXjwatt: is this line needed?
             FixupNodeAttributeNS(*aNodeOut, "http://www.w3.org/1999/xlink", "href");
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLScriptElement> nodeAsScript = do_QueryInterface(aNodeIn);
     if (nodeAsScript)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "src");
         }
         return rv;
     }
     if (content->IsSVG(nsGkAtoms::script))
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttributeNS(*aNodeOut, "http://www.w3.org/1999/xlink", "href");
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLEmbedElement> nodeAsEmbed = do_QueryInterface(aNodeIn);
     if (nodeAsEmbed)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "src");
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLObjectElement> nodeAsObject = do_QueryInterface(aNodeIn);
     if (nodeAsObject)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "data");
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLAppletElement> nodeAsApplet = do_QueryInterface(aNodeIn);
     if (nodeAsApplet)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             nsCOMPtr<nsIDOMHTMLAppletElement> newApplet =
                 do_QueryInterface(*aNodeOut);
             // For an applet, relative URIs are resolved relative to the
             // codebase (which is resolved relative to the base URI).
             nsCOMPtr<nsIURI> oldBase = mCurrentBaseURI;
             nsAutoString codebase;
             nodeAsApplet->GetCodeBase(codebase);
             if (!codebase.IsEmpty()) {
                 nsCOMPtr<nsIURI> baseURI;
                 NS_NewURI(getter_AddRefs(baseURI), codebase,
                           mCurrentCharset.get(), mCurrentBaseURI);
                 if (baseURI) {
                     mCurrentBaseURI = baseURI;
                 }
             }
             // Unset the codebase too, since we'll correctly relativize the
             // code and archive paths.
             static_cast<HTMLSharedObjectElement*>(newApplet.get())->
               RemoveAttribute(NS_LITERAL_STRING("codebase"));
             FixupNodeAttribute(*aNodeOut, "code");
             FixupNodeAttribute(*aNodeOut, "archive");
             // restore the base URI we really want to have
             mCurrentBaseURI = oldBase;
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLLinkElement> nodeAsLink = do_QueryInterface(aNodeIn);
     if (nodeAsLink)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             // First see if the link represents linked content
             rv = FixupNodeAttribute(*aNodeOut, "href");
             if (NS_FAILED(rv))
             {
                 // Perhaps this link is actually an anchor to related content
                 FixupAnchor(*aNodeOut);
             }
             // TODO if "type" attribute == "text/css"
             //        fixup stylesheet
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLFrameElement> nodeAsFrame = do_QueryInterface(aNodeIn);
     if (nodeAsFrame)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "src");
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLIFrameElement> nodeAsIFrame = do_QueryInterface(aNodeIn);
     if (nodeAsIFrame)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             FixupNodeAttribute(*aNodeOut, "src");
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLInputElement> nodeAsInput = do_QueryInterface(aNodeIn);
     if (nodeAsInput)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             // Disable image loads
             nsCOMPtr<nsIImageLoadingContent> imgCon =
                 do_QueryInterface(*aNodeOut);
             if (imgCon)
                 imgCon->SetLoadingEnabled(false);
             FixupNodeAttribute(*aNodeOut, "src");
             nsAutoString valueStr;
             NS_NAMED_LITERAL_STRING(valueAttr, "value");
             // Update element node attributes with user-entered form state
             nsCOMPtr<nsIContent> content = do_QueryInterface(*aNodeOut);
             nsRefPtr<HTMLInputElement> outElt =
               HTMLInputElement::FromContentOrNull(content);
             nsCOMPtr<nsIFormControl> formControl = do_QueryInterface(*aNodeOut);
             switch (formControl->GetType()) {
                 case NS_FORM_INPUT_EMAIL:
                 case NS_FORM_INPUT_SEARCH:
                 case NS_FORM_INPUT_TEXT:
                 case NS_FORM_INPUT_TEL:
                 case NS_FORM_INPUT_URL:
                 case NS_FORM_INPUT_NUMBER:
                 case NS_FORM_INPUT_RANGE:
                 case NS_FORM_INPUT_DATE:
                 case NS_FORM_INPUT_TIME:
                 case NS_FORM_INPUT_COLOR:
                     nodeAsInput->GetValue(valueStr);
                     // Avoid superfluous value="" serialization
                     if (valueStr.IsEmpty())
                       outElt->RemoveAttribute(valueAttr);
                     else
                       outElt->SetAttribute(valueAttr, valueStr);
                     break;
                 case NS_FORM_INPUT_CHECKBOX:
                 case NS_FORM_INPUT_RADIO:
                     bool checked;
                     nodeAsInput->GetChecked(&checked);
                     outElt->SetDefaultChecked(checked);
                     break;
                 default:
                     break;
             }
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLTextAreaElement> nodeAsTextArea = do_QueryInterface(aNodeIn);
     if (nodeAsTextArea)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             // Tell the document encoder to serialize the text child we create below
             *aSerializeCloneKids = true;
             nsAutoString valueStr;
             nodeAsTextArea->GetValue(valueStr);
             (*aNodeOut)->SetTextContent(valueStr);
         }
         return rv;
     }
     nsCOMPtr<nsIDOMHTMLOptionElement> nodeAsOption = do_QueryInterface(aNodeIn);
     if (nodeAsOption)
     {
         rv = GetNodeToFixup(aNodeIn, aNodeOut);
         if (NS_SUCCEEDED(rv) && *aNodeOut)
         {
             nsCOMPtr<nsIDOMHTMLOptionElement> outElt = do_QueryInterface(*aNodeOut);
             bool selected;
             nodeAsOption->GetSelected(&selected);
             outElt->SetDefaultSelected(selected);
         }
         return rv;
     }
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::StoreURI(
     const char *aURI, bool aNeedsPersisting, URIData **aData)
 {
     NS_ENSURE_ARG_POINTER(aURI);
     nsCOMPtr<nsIURI> uri;
     nsresult rv = NS_NewURI(getter_AddRefs(uri),
                             nsDependentCString(aURI),
                             mCurrentCharset.get(),
                             mCurrentBaseURI);
     NS_ENSURE_SUCCESS(rv, rv);
     return StoreURI(uri, aNeedsPersisting, aData);
 }
 nsresult
 nsWebBrowserPersist::StoreURI(
     nsIURI *aURI, bool aNeedsPersisting, URIData **aData)
 {
     NS_ENSURE_ARG_POINTER(aURI);
     if (aData)
     {
         *aData = nullptr;
     }
     // Test if this URI should be persisted. By default
     // we should assume the URI  is persistable.
     bool doNotPersistURI;
     nsresult rv = NS_URIChainHasFlags(aURI,
                                       nsIProtocolHandler::URI_NON_PERSISTABLE,
                                       &doNotPersistURI);
     if (NS_FAILED(rv))
     {
         doNotPersistURI = false;
     }
     if (doNotPersistURI)
     {
         return NS_OK;
     }
     URIData *data = nullptr;
     MakeAndStoreLocalFilenameInURIMap(aURI, aNeedsPersisting, &data);
     if (aData)
     {
         *aData = data;
     }
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::StoreURIAttributeNS(
     nsIDOMNode *aNode, const char *aNamespaceURI, const char *aAttribute,
     bool aNeedsPersisting, URIData **aData)
 {
     NS_ENSURE_ARG_POINTER(aNode);
     NS_ENSURE_ARG_POINTER(aNamespaceURI);
     NS_ENSURE_ARG_POINTER(aAttribute);
     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
     MOZ_ASSERT(element);
     // Find the named URI attribute on the (element) node and store
     // a reference to the URI that maps onto a local file name
     nsCOMPtr<nsIDOMMozNamedAttrMap> attrMap;
     nsresult rv = element->GetAttributes(getter_AddRefs(attrMap));
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     NS_ConvertASCIItoUTF16 namespaceURI(aNamespaceURI);
     NS_ConvertASCIItoUTF16 attribute(aAttribute);
     nsCOMPtr<nsIDOMAttr> attr;
     rv = attrMap->GetNamedItemNS(namespaceURI, attribute, getter_AddRefs(attr));
     if (attr)
     {
         nsAutoString oldValue;
         attr->GetValue(oldValue);
         if (!oldValue.IsEmpty())
         {
             NS_ConvertUTF16toUTF8 oldCValue(oldValue);
             return StoreURI(oldCValue.get(), aNeedsPersisting, aData);
         }
     }
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::FixupURI(nsAString &aURI)
 {
     // get the current location of the file (absolutized)
     nsCOMPtr<nsIURI> uri;
     nsresult rv = NS_NewURI(getter_AddRefs(uri), aURI,
                             mCurrentCharset.get(), mCurrentBaseURI);
     NS_ENSURE_SUCCESS(rv, rv);
     nsAutoCString spec;
     rv = uri->GetSpec(spec);
     NS_ENSURE_SUCCESS(rv, rv);
     // Search for the URI in the map and replace it with the local file
     if (!mURIMap.Contains(spec))
     {
         return NS_ERROR_FAILURE;
     }
     URIData *data = mURIMap.Get(spec);
     if (!data->mNeedsFixup)
     {
         return NS_OK;
     }
     nsCOMPtr<nsIURI> fileAsURI;
     if (data->mFile)
     {
         rv = data->mFile->Clone(getter_AddRefs(fileAsURI));
         NS_ENSURE_SUCCESS(rv, rv);
     }
     else
     {
         rv = data->mDataPath->Clone(getter_AddRefs(fileAsURI));
         NS_ENSURE_SUCCESS(rv, rv);
         rv = AppendPathToURI(fileAsURI, data->mFilename);
         NS_ENSURE_SUCCESS(rv, rv);
     }
     nsAutoString newValue;
     // remove username/password if present
     fileAsURI->SetUserPass(EmptyCString());
     // reset node attribute
     // Use relative or absolute links
     if (data->mDataPathIsRelative)
     {
         nsCOMPtr<nsIURL> url(do_QueryInterface(fileAsURI));
         if (!url)
           return NS_ERROR_FAILURE;
         nsAutoCString filename;
         url->GetFileName(filename);
         nsAutoCString rawPathURL(data->mRelativePathToData);
         rawPathURL.Append(filename);
         nsAutoCString buf;
         AppendUTF8toUTF16(NS_EscapeURL(rawPathURL, esc_FilePath, buf),
                           newValue);
     }
     else
     {
         nsAutoCString fileurl;
         fileAsURI->GetSpec(fileurl);
         AppendUTF8toUTF16(fileurl, newValue);
     }
     if (data->mIsSubFrame)
     {
         newValue.Append(data->mSubFrameExt);
     }
     aURI = newValue;
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::FixupNodeAttributeNS(nsIDOMNode *aNode,
                                           const char *aNamespaceURI,
                                           const char *aAttribute)
 {
     NS_ENSURE_ARG_POINTER(aNode);
     NS_ENSURE_ARG_POINTER(aNamespaceURI);
     NS_ENSURE_ARG_POINTER(aAttribute);
     // Find the named URI attribute on the (element) node and change it to reference
     // a local file.
     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
     MOZ_ASSERT(element);
     nsCOMPtr<nsIDOMMozNamedAttrMap> attrMap;
     nsresult rv = element->GetAttributes(getter_AddRefs(attrMap));
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     NS_ConvertASCIItoUTF16 attribute(aAttribute);
     NS_ConvertASCIItoUTF16 namespaceURI(aNamespaceURI);
     nsCOMPtr<nsIDOMAttr> attr;
     rv = attrMap->GetNamedItemNS(namespaceURI, attribute, getter_AddRefs(attr));
     if (attr) {
         nsString uri;
         attr->GetValue(uri);
         rv = FixupURI(uri);
         if (NS_SUCCEEDED(rv))
         {
             attr->SetValue(uri);
         }
     }
     return rv;
 }
 nsresult
 nsWebBrowserPersist::FixupAnchor(nsIDOMNode *aNode)
 {
     NS_ENSURE_ARG_POINTER(aNode);
     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
     MOZ_ASSERT(element);
     nsCOMPtr<nsIDOMMozNamedAttrMap> attrMap;
     nsresult rv = element->GetAttributes(getter_AddRefs(attrMap));
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     if (mPersistFlags & PERSIST_FLAGS_DONT_FIXUP_LINKS)
     {
         return NS_OK;
     }
     // Make all anchor links absolute so they point off onto the Internet
     nsString attribute(NS_LITERAL_STRING("href"));
     nsCOMPtr<nsIDOMAttr> attr;
     rv = attrMap->GetNamedItem(attribute, getter_AddRefs(attr));
     if (attr)
     {
         nsString oldValue;
         attr->GetValue(oldValue);
         NS_ConvertUTF16toUTF8 oldCValue(oldValue);
         // Skip empty values and self-referencing bookmarks
         if (oldCValue.IsEmpty() || oldCValue.CharAt(0) == '#')
         {
             return NS_OK;
         }
         // if saving file to same location, we don't need to do any fixup
         bool isEqual = false;
         if (NS_SUCCEEDED(mCurrentBaseURI->Equals(mTargetBaseURI, &isEqual))
             && isEqual)
         {
             return NS_OK;
         }
         nsCOMPtr<nsIURI> relativeURI;
         relativeURI = (mPersistFlags & PERSIST_FLAGS_FIXUP_LINKS_TO_DESTINATION)
                       ? mTargetBaseURI : mCurrentBaseURI;
         // Make a new URI to replace the current one
         nsCOMPtr<nsIURI> newURI;
         rv = NS_NewURI(getter_AddRefs(newURI), oldCValue,
                        mCurrentCharset.get(), relativeURI);
         if (NS_SUCCEEDED(rv) && newURI)
         {
             newURI->SetUserPass(EmptyCString());
             nsAutoCString uriSpec;
             newURI->GetSpec(uriSpec);
             attr->SetValue(NS_ConvertUTF8toUTF16(uriSpec));
         }
     }
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::StoreAndFixupStyleSheet(nsIStyleSheet *aStyleSheet)
 {
     // TODO go through the style sheet fixing up all links
     return NS_OK;
 }
 bool
 nsWebBrowserPersist::DocumentEncoderExists(const char16_t *aContentType)
 {
     // Check if there is an encoder for the desired content type.
     nsAutoCString contractID(NS_DOC_ENCODER_CONTRACTID_BASE);
     AppendUTF16toUTF8(aContentType, contractID);
     nsCOMPtr<nsIComponentRegistrar> registrar;
     NS_GetComponentRegistrar(getter_AddRefs(registrar));
     if (registrar)
     {
         bool result;
         nsresult rv = registrar->IsContractIDRegistered(contractID.get(),
                                                         &result);
         if (NS_SUCCEEDED(rv) && result)
         {
             return true;
         }
     }
     return false;
 }
 nsresult
 nsWebBrowserPersist::SaveSubframeContent(
     nsIDOMDocument *aFrameContent, URIData *aData)
 {
     NS_ENSURE_ARG_POINTER(aData);
     // Extract the content type for the frame's contents.
     nsCOMPtr<nsIDocument> frameDoc(do_QueryInterface(aFrameContent));
     NS_ENSURE_STATE(frameDoc);
     nsAutoString contentType;
     nsresult rv = frameDoc->GetContentType(contentType);
     NS_ENSURE_SUCCESS(rv, rv);
     nsXPIDLString ext;
     GetExtensionForContentType(contentType.get(), getter_Copies(ext));
     // We must always have an extension so we will try to re-assign
     // the original extension if GetExtensionForContentType fails.
     if (ext.IsEmpty())
     {
         nsCOMPtr<nsIURL> url(do_QueryInterface(frameDoc->GetDocumentURI(),
                                                &rv));
         nsAutoCString extension;
         if (NS_SUCCEEDED(rv))
         {
             url->GetFileExtension(extension);
         }
         else
         {
             extension.AssignLiteral("htm");
         }
         aData->mSubFrameExt.Assign(char16_t('.'));
         AppendUTF8toUTF16(extension, aData->mSubFrameExt);
     }
     else
     {
         aData->mSubFrameExt.Assign(char16_t('.'));
         aData->mSubFrameExt.Append(ext);
     }
     nsString filenameWithExt = aData->mFilename;
     filenameWithExt.Append(aData->mSubFrameExt);
     // Work out the path for the subframe
     nsCOMPtr<nsIURI> frameURI;
     rv = mCurrentDataPath->Clone(getter_AddRefs(frameURI));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = AppendPathToURI(frameURI, filenameWithExt);
     NS_ENSURE_SUCCESS(rv, rv);
     // Work out the path for the subframe data
     nsCOMPtr<nsIURI> frameDataURI;
     rv = mCurrentDataPath->Clone(getter_AddRefs(frameDataURI));
     NS_ENSURE_SUCCESS(rv, rv);
     nsAutoString newFrameDataPath(aData->mFilename);
     // Append _data
     newFrameDataPath.AppendLiteral("_data");
     rv = AppendPathToURI(frameDataURI, newFrameDataPath);
     NS_ENSURE_SUCCESS(rv, rv);
     // Make frame document & data path conformant and unique
     rv = CalculateUniqueFilename(frameURI);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = CalculateUniqueFilename(frameDataURI);
     NS_ENSURE_SUCCESS(rv, rv);
     mCurrentThingsToPersist++;
     // We shouldn't use SaveDocumentInternal for the contents
     // of frames that are not documents, e.g. images.
     if (DocumentEncoderExists(contentType.get()))
     {
         rv = SaveDocumentInternal(aFrameContent, frameURI, frameDataURI);
     }
     else
     {
         rv = StoreURI(frameDoc->GetDocumentURI());
     }
     NS_ENSURE_SUCCESS(rv, rv);
     // Store the updated uri to the frame
     aData->mFile = frameURI;
     aData->mSubFrameExt.Truncate(); // we already put this in frameURI
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::CreateChannelFromURI(nsIURI *aURI, nsIChannel **aChannel)
 {
     nsresult rv = NS_OK;
     *aChannel = nullptr;
     nsCOMPtr<nsIIOService> ioserv;
     ioserv = do_GetIOService(&rv);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = ioserv->NewChannelFromURI(aURI, aChannel);
     NS_ENSURE_SUCCESS(rv, rv);
     NS_ENSURE_ARG_POINTER(*aChannel);
     rv = (*aChannel)->SetNotificationCallbacks(static_cast<nsIInterfaceRequestor*>(this));
     NS_ENSURE_SUCCESS(rv, rv);
     return NS_OK;
 }
 nsresult
 nsWebBrowserPersist::SaveDocumentWithFixup(
     nsIDOMDocument *aDocument, nsIDocumentEncoderNodeFixup *aNodeFixup,
     nsIURI *aFile, bool aReplaceExisting, const nsACString &aFormatType,
     const nsCString &aSaveCharset, uint32_t aFlags)
 {
     NS_ENSURE_ARG_POINTER(aFile);
     nsresult  rv = NS_OK;
     nsCOMPtr<nsIFile> localFile;
     GetLocalFileFromURI(aFile, getter_AddRefs(localFile));
     if (localFile)
     {
         // if we're not replacing an existing file but the file
         // exists, something is wrong
         bool fileExists = false;
         rv = localFile->Exists(&fileExists);
         NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
         if (!aReplaceExisting && fileExists)
             return NS_ERROR_FAILURE;                // where are the file I/O errors?
     }
     nsCOMPtr<nsIOutputStream> outputStream;
     rv = MakeOutputStream(aFile, getter_AddRefs(outputStream));
     if (NS_FAILED(rv))
     {
         SendErrorStatusChange(false, rv, nullptr, aFile);
         return NS_ERROR_FAILURE;
     }
     NS_ENSURE_TRUE(outputStream, NS_ERROR_FAILURE);
     // Get a document encoder instance
     nsAutoCString contractID(NS_DOC_ENCODER_CONTRACTID_BASE);
     contractID.Append(aFormatType);
     nsCOMPtr<nsIDocumentEncoder> encoder = do_CreateInstance(contractID.get(), &rv);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     NS_ConvertASCIItoUTF16 newContentType(aFormatType);
     rv = encoder->Init(aDocument, newContentType, aFlags);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     mTargetBaseURI = aFile;
     // Set the node fixup callback
     encoder->SetNodeFixup(aNodeFixup);
     if (mWrapColumn && (aFlags & ENCODE_FLAGS_WRAP))
         encoder->SetWrapColumn(mWrapColumn);
     nsAutoCString charsetStr(aSaveCharset);
     if (charsetStr.IsEmpty())
     {
         nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDocument);
         NS_ASSERTION(doc, "Need a document");
         charsetStr = doc->GetDocumentCharacterSet();
     }
     rv = encoder->SetCharset(charsetStr);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     rv = encoder->EncodeToStream(outputStream);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     if (!localFile)
     {
         nsCOMPtr<nsIStorageStream> storStream(do_QueryInterface(outputStream));
         if (storStream)
         {
             outputStream->Close();
             rv = StartUpload(storStream, aFile, aFormatType);
             NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
         }
     }
     return rv;
 }
 // we store the current location as the key (absolutized version of domnode's attribute's value)
 nsresult
 nsWebBrowserPersist::MakeAndStoreLocalFilenameInURIMap(
     nsIURI *aURI, bool aNeedsPersisting, URIData **aData)
 {
     NS_ENSURE_ARG_POINTER(aURI);
     nsAutoCString spec;
     nsresult rv = aURI->GetSpec(spec);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     // Create a sensibly named filename for the URI and store in the URI map
     URIData *data;
     if (mURIMap.Contains(spec))
     {
         data = mURIMap.Get(spec);
         if (aNeedsPersisting)
         {
           data->mNeedsPersisting = true;
         }
         if (aData)
         {
             *aData = data;
         }
         return NS_OK;
     }
     // Create a unique file name for the uri
     nsString filename;
     rv = MakeFilenameFromURI(aURI, filename);
     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
     // Store the file name
     data = new URIData;
     NS_ENSURE_TRUE(data, NS_ERROR_OUT_OF_MEMORY);
     data->mNeedsPersisting = aNeedsPersisting;
     data->mNeedsFixup = true;
     data->mFilename = filename;
     data->mSaved = false;
     data->mIsSubFrame = false;
     data->mDataPath = mCurrentDataPath;
     data->mDataPathIsRelative = mCurrentDataPathIsRelative;
     data->mRelativePathToData = mCurrentRelativePathToData;
     data->mCharset = mCurrentCharset;
     if (aNeedsPersisting)
         mCurrentThingsToPersist++;
     mURIMap.Put(spec, data);
     if (aData)
     {
         *aData = data;
     }
     return NS_OK;
 }
 // Ordered so that typical documents work fastest.
 //                                    strlen("blockquote")==10
 static const char kSpecialXHTMLTags[][11] = {
     "body",
     "head",
     "img",
     "script",
     "a",
     "area",
     "link",
     "input",
     "frame",
     "iframe",
     "object",
     "applet",
     "form",
     "blockquote",
     "q",
     "del",
     "ins"
 };
 static bool IsSpecialXHTMLTag(nsIDOMNode *aNode)
 {
     nsAutoString tmp;
     aNode->GetNamespaceURI(tmp);
     if (!tmp.EqualsLiteral("http://www.w3.org/1999/xhtml"))
         return false;
     aNode->GetLocalName(tmp);
     for (uint32_t i = 0; i < ArrayLength(kSpecialXHTMLTags); i++) {
         if (tmp.EqualsASCII(kSpecialXHTMLTags[i]))
         {
             // XXX This element MAY have URI attributes, but
             //     we are not actually checking if they are present.
             //     That would slow us down further, and I am not so sure
             //     how important that would be.
             return true;
         }
     }
     return false;
 }
 static bool HasSpecialXHTMLTags(nsIDOMNode *aParent)
 {
     if (IsSpecialXHTMLTag(aParent))
         return true;
     nsCOMPtr<nsIDOMNodeList> list;
     aParent->GetChildNodes(getter_AddRefs(list));
     if (list)
     {
         uint32_t count;
         list->GetLength(&count);
         uint32_t i;
         for (i = 0; i < count; i++) {
             nsCOMPtr<nsIDOMNode> node;
             list->Item(i, getter_AddRefs(node));
             if (!node)
                 break;
             uint16_t nodeType;
             node->GetNodeType(&nodeType);
             if (nodeType == nsIDOMNode::ELEMENT_NODE) {
                 return HasSpecialXHTMLTags(node);
             }
         }
     }
     return false;
 }
 static bool NeedXHTMLBaseTag(nsIDOMDocument *aDocument)
 {
     nsCOMPtr<nsIDOMElement> docElement;
     aDocument->GetDocumentElement(getter_AddRefs(docElement));
     nsCOMPtr<nsIDOMNode> node(do_QueryInterface(docElement));
     if (node)
     {
         return HasSpecialXHTMLTags(node);
     }
     return false;
 }
 // Set document base. This could create an invalid XML document (still well-formed).
 nsresult
 nsWebBrowserPersist::SetDocumentBase(
     nsIDOMDocument *aDocument, nsIURI *aBaseURI)
 {
     if (mPersistFlags & PERSIST_FLAGS_NO_BASE_TAG_MODIFICATIONS)
     {
         return NS_OK;
     }
     NS_ENSURE_ARG_POINTER(aBaseURI);
     nsCOMPtr<nsIDOMXMLDocument> xmlDoc;
     nsCOMPtr<nsIDOMHTMLDocument> htmlDoc = do_QueryInterface(aDocument);
     if (!htmlDoc)
     {
         xmlDoc = do_QueryInterface(aDocument);
         if (!xmlDoc)
         {
             return NS_ERROR_FAILURE;
         }
     }
     NS_NAMED_LITERAL_STRING(kXHTMLNS, "http://www.w3.org/1999/xhtml");
     NS_NAMED_LITERAL_STRING(kHead, "head");
     // Find the head element
     nsCOMPtr<nsIDOMElement> headElement;
     nsCOMPtr<nsIDOMNodeList> headList;
     if (xmlDoc)
     {
         // First see if there is XHTML content that needs base
         // tags.
         if (!NeedXHTMLBaseTag(aDocument))
             return NS_OK;
         aDocument->GetElementsByTagNameNS(
             kXHTMLNS,
             kHead, getter_AddRefs(headList));
     }
     else
     {
         aDocument->GetElementsByTagName(
             kHead, getter_AddRefs(headList));
     }
     if (headList)
     {
         nsCOMPtr<nsIDOMNode> headNode;
         headList->Item(0, getter_AddRefs(headNode));
         headElement = do_QueryInterface(headNode);
     }
     if (!headElement)
     {
         // Create head and insert as first element
         nsCOMPtr<nsIDOMNode> firstChildNode;
         nsCOMPtr<nsIDOMNode> newNode;
         if (xmlDoc)
         {
             aDocument->CreateElementNS(
                 kXHTMLNS,
                 kHead, getter_AddRefs(headElement));
         }
         else
         {
             aDocument->CreateElement(
                 kHead, getter_AddRefs(headElement));
         }
         nsCOMPtr<nsIDOMElement> documentElement;
         aDocument->GetDocumentElement(getter_AddRefs(documentElement));
         if (documentElement)
         {
             documentElement->GetFirstChild(getter_AddRefs(firstChildNode));
             documentElement->InsertBefore(headElement, firstChildNode, getter_AddRefs(newNode));
         }
     }
     if (!headElement)
     {
         return NS_ERROR_FAILURE;
     }
     // Find or create the BASE element
     NS_NAMED_LITERAL_STRING(kBase, "base");
     nsCOMPtr<nsIDOMElement> baseElement;
     nsCOMPtr<nsIDOMHTMLCollection> baseList;
     if (xmlDoc)
     {
         headElement->GetElementsByTagNameNS(
             kXHTMLNS,
             kBase, getter_AddRefs(baseList));
     }
     else
     {
         headElement->GetElementsByTagName(
             kBase, getter_AddRefs(baseList));
     }
     if (baseList)
     {
         nsCOMPtr<nsIDOMNode> baseNode;
         baseList->Item(0, getter_AddRefs(baseNode));
         baseElement = do_QueryInterface(baseNode);
     }
     // Add the BASE element
     if (!baseElement)
     {
       nsCOMPtr<nsIDOMNode> newNode;
       if (xmlDoc)
       {
           aDocument->CreateElementNS(
               kXHTMLNS,
               kBase, getter_AddRefs(baseElement));
       }
       else
       {
           aDocument->CreateElement(
               kBase, getter_AddRefs(baseElement));
       }
       headElement->AppendChild(baseElement, getter_AddRefs(newNode));
     }
     if (!baseElement)
     {
         return NS_ERROR_FAILURE;
     }
     nsAutoCString uriSpec;
     aBaseURI->GetSpec(uriSpec);
     NS_ConvertUTF8toUTF16 href(uriSpec);
     baseElement->SetAttribute(NS_LITERAL_STRING("href"), href);
     return NS_OK;
 }
 // Decide if we need to apply conversion to the passed channel.
 void nsWebBrowserPersist::SetApplyConversionIfNeeded(nsIChannel *aChannel)
 {
     nsresult rv = NS_OK;
     nsCOMPtr<nsIEncodedChannel> encChannel = do_QueryInterface(aChannel, &rv);
     if (NS_FAILED(rv))
         return;
     // Set the default conversion preference:
     encChannel->SetApplyConversion(false);
     nsCOMPtr<nsIURI> thisURI;
     aChannel->GetURI(getter_AddRefs(thisURI));
     nsCOMPtr<nsIURL> sourceURL(do_QueryInterface(thisURI));
     if (!sourceURL)
         return;
     nsAutoCString extension;
     sourceURL->GetFileExtension(extension);
     nsCOMPtr<nsIUTF8StringEnumerator> encEnum;
     encChannel->GetContentEncodings(getter_AddRefs(encEnum));
     if (!encEnum)
         return;
     nsCOMPtr<nsIExternalHelperAppService> helperAppService =
         do_GetService(NS_EXTERNALHELPERAPPSERVICE_CONTRACTID, &rv);
     if (NS_FAILED(rv))
         return;
     bool hasMore;
     rv = encEnum->HasMore(&hasMore);
     if (NS_SUCCEEDED(rv) && hasMore)
     {
         nsAutoCString encType;
         rv = encEnum->GetNext(encType);
         if (NS_SUCCEEDED(rv))
         {
             bool applyConversion = false;
             rv = helperAppService->ApplyDecodingForExtension(extension, encType,
                                                              &applyConversion);
             if (NS_SUCCEEDED(rv))
                 encChannel->SetApplyConversion(applyConversion);
         }
     }
 }
 ///////////////////////////////////////////////////////////////////////////////
 nsEncoderNodeFixup::nsEncoderNodeFixup() : mWebBrowserPersist(nullptr)
 {
 }
 nsEncoderNodeFixup::~nsEncoderNodeFixup()
 {
 }
 NS_IMPL_ADDREF(nsEncoderNodeFixup)
 NS_IMPL_RELEASE(nsEncoderNodeFixup)
 NS_INTERFACE_MAP_BEGIN(nsEncoderNodeFixup)
     NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDocumentEncoderNodeFixup)
     NS_INTERFACE_MAP_ENTRY(nsIDocumentEncoderNodeFixup)
 NS_INTERFACE_MAP_END
 NS_IMETHODIMP nsEncoderNodeFixup::FixupNode(
     nsIDOMNode *aNode, bool *aSerializeCloneKids, nsIDOMNode **aOutNode)
 {
     NS_ENSURE_ARG_POINTER(aNode);
     NS_ENSURE_ARG_POINTER(aOutNode);
     NS_ENSURE_TRUE(mWebBrowserPersist, NS_ERROR_FAILURE);
     *aOutNode = nullptr;
     // Test whether we need to fixup the node
     uint16_t type = 0;
     aNode->GetNodeType(&type);
     if (type == nsIDOMNode::ELEMENT_NODE ||
         type == nsIDOMNode::PROCESSING_INSTRUCTION_NODE)
     {
         return mWebBrowserPersist->CloneNodeWithFixedUpAttributes(aNode, aSerializeCloneKids, aOutNode);
     }
     return NS_OK;
 }

The Tor Browser / annotate

embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp@6474c204b198 (annotated)

embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp