The Tor Browser: uriloader/exthandler/nsExternalHelperAppService.cpp@97036ab72558 (annotated)

uriloader/exthandler/nsExternalHelperAppService.cpp@97036ab72558 (annotated)

uriloader/exthandler/nsExternalHelperAppService.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  * vim:expandtab:shiftwidth=2:tabstop=2:cin:
  * 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/. */
 #ifdef MOZ_LOGGING
 #define FORCE_PR_LOG
 #endif
 #include "base/basictypes.h"
 /* This must occur *after* base/basictypes.h to avoid typedefs conflicts. */
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/Base64.h"
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/dom/TabChild.h"
 #include "nsXULAppAPI.h"
 #include "nsExternalHelperAppService.h"
 #include "nsCExternalHandlerService.h"
 #include "nsIURI.h"
 #include "nsIURL.h"
 #include "nsIFile.h"
 #include "nsIFileURL.h"
 #include "nsIChannel.h"
 #include "nsIDirectoryService.h"
 #include "nsAppDirectoryServiceDefs.h"
 #include "nsICategoryManager.h"
 #include "nsDependentSubstring.h"
 #include "nsXPIDLString.h"
 #include "nsUnicharUtils.h"
 #include "nsIStringEnumerator.h"
 #include "nsMemory.h"
 #include "nsIStreamListener.h"
 #include "nsIMIMEService.h"
 #include "nsILoadGroup.h"
 #include "nsIWebProgressListener.h"
 #include "nsITransfer.h"
 #include "nsReadableUtils.h"
 #include "nsIRequest.h"
 #include "nsDirectoryServiceDefs.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsThreadUtils.h"
 #include "nsAutoPtr.h"
 #include "nsIMutableArray.h"
 // used to access our datastore of user-configured helper applications
 #include "nsIHandlerService.h"
 #include "nsIMIMEInfo.h"
 #include "nsIRefreshURI.h" // XXX needed to redirect according to Refresh: URI
 #include "nsIDocumentLoader.h" // XXX needed to get orig. channel and assoc. refresh uri
 #include "nsIHelperAppLauncherDialog.h"
 #include "nsIContentDispatchChooser.h"
 #include "nsNetUtil.h"
 #include "nsIIOService.h"
 #include "nsNetCID.h"
 #include "nsChannelProperties.h"
 #include "nsMimeTypes.h"
 // used for header disposition information.
 #include "nsIHttpChannel.h"
 #include "nsIHttpChannelInternal.h"
 #include "nsIEncodedChannel.h"
 #include "nsIMultiPartChannel.h"
 #include "nsIFileChannel.h"
 #include "nsIObserverService.h" // so we can be a profile change observer
 #include "nsIPropertyBag2.h" // for the 64-bit content length
 #ifdef XP_MACOSX
 #include "nsILocalFileMac.h"
 #endif
 #include "nsIPluginHost.h" // XXX needed for ext->type mapping (bug 233289)
 #include "nsPluginHost.h"
 #include "nsEscape.h"
 #include "nsIStringBundle.h" // XXX needed to localize error msgs
 #include "nsIPrompt.h"
 #include "nsITextToSubURI.h" // to unescape the filename
 #include "nsIMIMEHeaderParam.h"
 #include "nsIWindowWatcher.h"
 #include "nsIDownloadHistory.h" // to mark downloads as visited
 #include "nsDocShellCID.h"
 #include "nsCRT.h"
 #include "nsLocalHandlerApp.h"
 #include "nsIRandomGenerator.h"
 #include "ContentChild.h"
 #include "nsXULAppAPI.h"
 #include "nsPIDOMWindow.h"
 #include "nsIDocShellTreeOwner.h"
 #include "nsIDocShellTreeItem.h"
 #include "ExternalHelperAppChild.h"
 #ifdef XP_WIN
 #include "nsWindowsHelpers.h"
 #endif
 #ifdef MOZ_WIDGET_ANDROID
 #include "AndroidBridge.h"
 #endif
 #include "mozilla/Preferences.h"
 #include "mozilla/ipc/URIUtils.h"
 #ifdef MOZ_WIDGET_GONK
 #include "nsDeviceStorage.h"
 #endif
 #ifdef NECKO_PROTOCOL_rtsp
 #include "nsIScriptSecurityManager.h"
 #include "nsIMessageManager.h"
 #endif
 using namespace mozilla;
 using namespace mozilla::ipc;
 // Download Folder location constants
 #define NS_PREF_DOWNLOAD_DIR        "browser.download.dir"
 #define NS_PREF_DOWNLOAD_FOLDERLIST "browser.download.folderList"
 enum {
   NS_FOLDER_VALUE_DESKTOP = 0
 , NS_FOLDER_VALUE_DOWNLOADS = 1
 , NS_FOLDER_VALUE_CUSTOM = 2
 };
 #ifdef PR_LOGGING
 PRLogModuleInfo* nsExternalHelperAppService::mLog = nullptr;
 #endif
 // Using level 3 here because the OSHelperAppServices use a log level
 // of PR_LOG_DEBUG (4), and we want less detailed output here
 // Using 3 instead of PR_LOG_WARN because we don't output warnings
 #undef LOG
 #define LOG(args) PR_LOG(nsExternalHelperAppService::mLog, 3, args)
 #define LOG_ENABLED() PR_LOG_TEST(nsExternalHelperAppService::mLog, 3)
 static const char NEVER_ASK_FOR_SAVE_TO_DISK_PREF[] =
   "browser.helperApps.neverAsk.saveToDisk";
 static const char NEVER_ASK_FOR_OPEN_FILE_PREF[] =
   "browser.helperApps.neverAsk.openFile";
 // Helper functions for Content-Disposition headers
 /**
  * Given a URI fragment, unescape it
  * @param aFragment The string to unescape
  * @param aURI The URI from which this fragment is taken. Only its character set
  *             will be used.
  * @param aResult [out] Unescaped string.
  */
 static nsresult UnescapeFragment(const nsACString& aFragment, nsIURI* aURI,
                                  nsAString& aResult)
 {
   // First, we need a charset
   nsAutoCString originCharset;
   nsresult rv = aURI->GetOriginCharset(originCharset);
   NS_ENSURE_SUCCESS(rv, rv);
   // Now, we need the unescaper
   nsCOMPtr<nsITextToSubURI> textToSubURI = do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   return textToSubURI->UnEscapeURIForUI(originCharset, aFragment, aResult);
 }
 /**
  * UTF-8 version of UnescapeFragment.
  * @param aFragment The string to unescape
  * @param aURI The URI from which this fragment is taken. Only its character set
  *             will be used.
  * @param aResult [out] Unescaped string, UTF-8 encoded.
  * @note It is safe to pass the same string for aFragment and aResult.
  * @note When this function fails, aResult will not be modified.
  */
 static nsresult UnescapeFragment(const nsACString& aFragment, nsIURI* aURI,
                                  nsACString& aResult)
 {
   nsAutoString result;
   nsresult rv = UnescapeFragment(aFragment, aURI, result);
   if (NS_SUCCEEDED(rv))
     CopyUTF16toUTF8(result, aResult);
   return rv;
 }
 /**
  * Given a channel, returns the filename and extension the channel has.
  * This uses the URL and other sources (nsIMultiPartChannel).
  * Also gives back whether the channel requested external handling (i.e.
  * whether Content-Disposition: attachment was sent)
  * @param aChannel The channel to extract the filename/extension from
  * @param aFileName [out] Reference to the string where the filename should be
  *        stored. Empty if it could not be retrieved.
  *        WARNING - this filename may contain characters which the OS does not
  *        allow as part of filenames!
  * @param aExtension [out] Reference to the string where the extension should
  *        be stored. Empty if it could not be retrieved. Stored in UTF-8.
  * @param aAllowURLExtension (optional) Get the extension from the URL if no
  *        Content-Disposition header is present. Default is true.
  * @retval true The server sent Content-Disposition:attachment or equivalent
  * @retval false Content-Disposition: inline or no content-disposition header
  *         was sent.
  */
 static bool GetFilenameAndExtensionFromChannel(nsIChannel* aChannel,
                                                  nsString& aFileName,
                                                  nsCString& aExtension,
                                                  bool aAllowURLExtension = true)
 {
   aExtension.Truncate();
   /*
    * If the channel is an http or part of a multipart channel and we
    * have a content disposition header set, then use the file name
    * suggested there as the preferred file name to SUGGEST to the
    * user.  we shouldn't actually use that without their
    * permission... otherwise just use our temp file
    */
   bool handleExternally = false;
   uint32_t disp;
   nsresult rv = aChannel->GetContentDisposition(&disp);
   if (NS_SUCCEEDED(rv))
   {
     aChannel->GetContentDispositionFilename(aFileName);
     if (disp == nsIChannel::DISPOSITION_ATTACHMENT)
       handleExternally = true;
   }
   // If the disposition header didn't work, try the filename from nsIURL
   nsCOMPtr<nsIURI> uri;
   aChannel->GetURI(getter_AddRefs(uri));
   nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
   if (url && aFileName.IsEmpty())
   {
     if (aAllowURLExtension) {
       url->GetFileExtension(aExtension);
       UnescapeFragment(aExtension, url, aExtension);
       // Windows ignores terminating dots. So we have to as well, so
       // that our security checks do "the right thing"
       // In case the aExtension consisted only of the dot, the code below will
       // extract an aExtension from the filename
       aExtension.Trim(".", false);
     }
     // try to extract the file name from the url and use that as a first pass as the
     // leaf name of our temp file...
     nsAutoCString leafName;
     url->GetFileName(leafName);
     if (!leafName.IsEmpty())
     {
       rv = UnescapeFragment(leafName, url, aFileName);
       if (NS_FAILED(rv))
       {
         CopyUTF8toUTF16(leafName, aFileName); // use escaped name
       }
     }
   }
   // Extract Extension, if we have a filename; otherwise,
   // truncate the string
   if (aExtension.IsEmpty()) {
     if (!aFileName.IsEmpty())
     {
       // Windows ignores terminating dots. So we have to as well, so
       // that our security checks do "the right thing"
       aFileName.Trim(".", false);
       // XXX RFindCharInReadable!!
       nsAutoString fileNameStr(aFileName);
       int32_t idx = fileNameStr.RFindChar(char16_t('.'));
       if (idx != kNotFound)
         CopyUTF16toUTF8(StringTail(fileNameStr, fileNameStr.Length() - idx - 1), aExtension);
     }
   }
   return handleExternally;
 }
 /**
  * Obtains the directory to use.  This tends to vary per platform, and
  * needs to be consistent throughout our codepaths. For platforms where
  * helper apps use the downloads directory, this should be kept in
  * sync with nsDownloadManager.cpp
  *
  * Optionally skip availability of the directory and storage.
  */
 static nsresult GetDownloadDirectory(nsIFile **_directory,
                                      bool aSkipChecks = false)
 {
   nsCOMPtr<nsIFile> dir;
 #ifdef XP_MACOSX
   // On OS X, we first try to get the users download location, if it's set.
   switch (Preferences::GetInt(NS_PREF_DOWNLOAD_FOLDERLIST, -1)) {
     case NS_FOLDER_VALUE_DESKTOP:
       (void) NS_GetSpecialDirectory(NS_OS_DESKTOP_DIR, getter_AddRefs(dir));
       break;
     case NS_FOLDER_VALUE_CUSTOM:
       {
         Preferences::GetComplex(NS_PREF_DOWNLOAD_DIR,
                                 NS_GET_IID(nsIFile),
                                 getter_AddRefs(dir));
         if (!dir) break;
         // If we're not checking for availability we're done.
         if (aSkipChecks) {
           dir.forget(_directory);
           return NS_OK;
         }
         // We have the directory, and now we need to make sure it exists
         bool dirExists = false;
         (void) dir->Exists(&dirExists);
         if (dirExists) break;
         nsresult rv = dir->Create(nsIFile::DIRECTORY_TYPE, 0755);
         if (NS_FAILED(rv)) {
           dir = nullptr;
           break;
         }
       }
       break;
     case NS_FOLDER_VALUE_DOWNLOADS:
       // This is just the OS default location, so fall out
       break;
   }
   if (!dir) {
     // If not, we default to the OS X default download location.
     nsresult rv = NS_GetSpecialDirectory(NS_OSX_DEFAULT_DOWNLOAD_DIR,
                                          getter_AddRefs(dir));
     NS_ENSURE_SUCCESS(rv, rv);
   }
 #elif defined(MOZ_WIDGET_GONK)
   // On Gonk, store the files on the sdcard in the downloads directory.
   // We need to check with the volume manager which storage point is
   // available.
   // Pick the default storage in case multiple (internal and external) ones
   // are available.
   nsString storageName;
   nsDOMDeviceStorage::GetDefaultStorageName(NS_LITERAL_STRING("sdcard"),
                                             storageName);
   DeviceStorageFile dsf(NS_LITERAL_STRING("sdcard"),
                         storageName,
                         NS_LITERAL_STRING("downloads"));
   NS_ENSURE_TRUE(dsf.mFile, NS_ERROR_FILE_ACCESS_DENIED);
   // If we're not checking for availability we're done.
   if (aSkipChecks) {
     dsf.mFile.forget(_directory);
     return NS_OK;
   }
   // Check device storage status before continuing.
   nsString storageStatus;
   dsf.GetStatus(storageStatus);
   // If we get an "unavailable" status, it means the sd card is not present.
   // We'll also catch internal errors by looking for an empty string and assume
   // the SD card isn't present when this occurs.
   if (storageStatus.EqualsLiteral("unavailable") ||
       storageStatus.IsEmpty()) {
     return NS_ERROR_FILE_NOT_FOUND;
   }
   // If we get a status other than 'available' here it means the card is busy
   // because it's mounted via USB or it is being formatted.
   if (!storageStatus.EqualsLiteral("available")) {
     return NS_ERROR_FILE_ACCESS_DENIED;
   }
   bool alreadyThere;
   nsresult rv = dsf.mFile->Exists(&alreadyThere);
   NS_ENSURE_SUCCESS(rv, rv);
   if (!alreadyThere) {
     rv = dsf.mFile->Create(nsIFile::DIRECTORY_TYPE, 0770);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   dir = dsf.mFile;
 #elif defined(ANDROID)
   // On mobile devices, we are avoiding exposing users to the file
   // system, and don't save downloads to temp directories
   // On Android we only return something if we have and SD-card
   char* downloadDir = getenv("DOWNLOADS_DIRECTORY");
   nsresult rv;
   if (downloadDir) {
     nsCOMPtr<nsIFile> ldir;
     rv = NS_NewNativeLocalFile(nsDependentCString(downloadDir),
                                true, getter_AddRefs(ldir));
     NS_ENSURE_SUCCESS(rv, rv);
     dir = do_QueryInterface(ldir);
     // If we're not checking for availability we're done.
     if (aSkipChecks) {
       dir.forget(_directory);
       return NS_OK;
     }
   }
   else {
     return NS_ERROR_FAILURE;
   }
 #elif defined(XP_WIN)
   // On metro we want to be able to search opened files and the temp directory
   // is exlcuded in searches.
   nsresult rv;
   if (IsRunningInWindowsMetro()) {
     rv = NS_GetSpecialDirectory(NS_WIN_DEFAULT_DOWNLOAD_DIR, getter_AddRefs(dir));
   } else {
     rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(dir));
   }
   NS_ENSURE_SUCCESS(rv, rv);
 #else
   // On all other platforms, we default to the systems temporary directory.
   nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(dir));
   NS_ENSURE_SUCCESS(rv, rv);
 #endif
   NS_ASSERTION(dir, "Somehow we didn't get a download directory!");
   dir.forget(_directory);
   return NS_OK;
 }
 /**
  * Structure for storing extension->type mappings.
  * @see defaultMimeEntries
  */
 struct nsDefaultMimeTypeEntry {
   const char* mMimeType;
   const char* mFileExtension;
 };
 /**
  * Default extension->mimetype mappings. These are not overridable.
  * If you add types here, make sure they are lowercase, or you'll regret it.
  */
 static nsDefaultMimeTypeEntry defaultMimeEntries [] =
 {
   // The following are those extensions that we're asked about during startup,
   // sorted by order used
   { IMAGE_GIF, "gif" },
   { TEXT_XML, "xml" },
   { APPLICATION_RDF, "rdf" },
   { TEXT_XUL, "xul" },
   { IMAGE_PNG, "png" },
   // -- end extensions used during startup
   { TEXT_CSS, "css" },
   { IMAGE_JPEG, "jpeg" },
   { IMAGE_JPEG, "jpg" },
   { IMAGE_SVG_XML, "svg" },
   { TEXT_HTML, "html" },
   { TEXT_HTML, "htm" },
   { APPLICATION_XPINSTALL, "xpi" },
   { "application/xhtml+xml", "xhtml" },
   { "application/xhtml+xml", "xht" },
   { TEXT_PLAIN, "txt" },
   { VIDEO_OGG, "ogv" },
   { VIDEO_OGG, "ogg" },
   { APPLICATION_OGG, "ogg" },
   { AUDIO_OGG, "oga" },
 #ifdef MOZ_OPUS
   { AUDIO_OGG, "opus" },
 #endif
 #ifdef MOZ_WEBM
   { VIDEO_WEBM, "webm" },
   { AUDIO_WEBM, "webm" },
 #endif
 #if defined(MOZ_GSTREAMER) || defined(MOZ_WMF)
   { VIDEO_MP4, "mp4" },
   { AUDIO_MP4, "m4a" },
   { AUDIO_MP3, "mp3" },
 #endif
 #ifdef MOZ_RAW
   { VIDEO_RAW, "yuv" }
 #endif
 };
 /**
  * This is a small private struct used to help us initialize some
  * default mime types.
  */
 struct nsExtraMimeTypeEntry {
   const char* mMimeType;
   const char* mFileExtensions;
   const char* mDescription;
 };
 #ifdef XP_MACOSX
 #define MAC_TYPE(x) x
 #else
 #define MAC_TYPE(x) 0
 #endif
 /**
  * This table lists all of the 'extra' content types that we can deduce from particular
  * file extensions.  These entries also ensure that we provide a good descriptive name
  * when we encounter files with these content types and/or extensions.  These can be
  * overridden by user helper app prefs.
  * If you add types here, make sure they are lowercase, or you'll regret it.
  */
 static nsExtraMimeTypeEntry extraMimeEntries [] =
 {
 #if defined(VMS)
   { APPLICATION_OCTET_STREAM, "exe,com,bin,sav,bck,pcsi,dcx_axpexe,dcx_vaxexe,sfx_axpexe,sfx_vaxexe", "Binary File" },
 #elif defined(XP_MACOSX) // don't define .bin on the mac...use internet config to look that up...
   { APPLICATION_OCTET_STREAM, "exe,com", "Binary File" },
 #else
   { APPLICATION_OCTET_STREAM, "exe,com,bin", "Binary File" },
 #endif
   { APPLICATION_GZIP2, "gz", "gzip" },
   { "application/x-arj", "arj", "ARJ file" },
   { "application/rtf", "rtf", "Rich Text Format File" },
   { APPLICATION_XPINSTALL, "xpi", "XPInstall Install" },
   { APPLICATION_PDF, "pdf", "Portable Document Format" },
   { APPLICATION_POSTSCRIPT, "ps,eps,ai", "Postscript File" },
   { APPLICATION_XJAVASCRIPT, "js", "Javascript Source File" },
   { APPLICATION_XJAVASCRIPT, "jsm", "Javascript Module Source File" },
 #ifdef MOZ_WIDGET_ANDROID
   { "application/vnd.android.package-archive", "apk", "Android Package" },
 #endif
   { IMAGE_ART, "art", "ART Image" },
   { IMAGE_BMP, "bmp", "BMP Image" },
   { IMAGE_GIF, "gif", "GIF Image" },
   { IMAGE_ICO, "ico,cur", "ICO Image" },
   { IMAGE_JPEG, "jpeg,jpg,jfif,pjpeg,pjp", "JPEG Image" },
   { IMAGE_PNG, "png", "PNG Image" },
   { IMAGE_TIFF, "tiff,tif", "TIFF Image" },
   { IMAGE_XBM, "xbm", "XBM Image" },
   { IMAGE_SVG_XML, "svg", "Scalable Vector Graphics" },
   { MESSAGE_RFC822, "eml", "RFC-822 data" },
   { TEXT_PLAIN, "txt,text", "Text File" },
   { TEXT_HTML, "html,htm,shtml,ehtml", "HyperText Markup Language" },
   { "application/xhtml+xml", "xhtml,xht", "Extensible HyperText Markup Language" },
   { APPLICATION_MATHML_XML, "mml", "Mathematical Markup Language" },
   { APPLICATION_RDF, "rdf", "Resource Description Framework" },
   { TEXT_XUL, "xul", "XML-Based User Interface Language" },
   { TEXT_XML, "xml,xsl,xbl", "Extensible Markup Language" },
   { TEXT_CSS, "css", "Style Sheet" },
   { TEXT_VCARD, "vcf,vcard", "Contact Information" },
   { VIDEO_OGG, "ogv", "Ogg Video" },
   { VIDEO_OGG, "ogg", "Ogg Video" },
   { APPLICATION_OGG, "ogg", "Ogg Video"},
   { AUDIO_OGG, "oga", "Ogg Audio" },
   { AUDIO_OGG, "opus", "Opus Audio" },
 #ifdef MOZ_WIDGET_GONK
   { AUDIO_AMR, "amr", "Adaptive Multi-Rate Audio" },
 #endif
   { VIDEO_WEBM, "webm", "Web Media Video" },
   { AUDIO_WEBM, "webm", "Web Media Audio" },
   { AUDIO_MP3, "mp3", "MPEG Audio" },
   { VIDEO_MP4, "mp4", "MPEG-4 Video" },
   { AUDIO_MP4, "m4a", "MPEG-4 Audio" },
   { VIDEO_RAW, "yuv", "Raw YUV Video" },
   { AUDIO_WAV, "wav", "Waveform Audio" },
   { VIDEO_3GPP, "3gpp,3gp", "3GPP Video" },
   { AUDIO_MIDI, "mid", "Standard MIDI Audio" }
 };
 #undef MAC_TYPE
 /**
  * File extensions for which decoding should be disabled.
  * NOTE: These MUST be lower-case and ASCII.
  */
 static nsDefaultMimeTypeEntry nonDecodableExtensions [] = {
   { APPLICATION_GZIP, "gz" },
   { APPLICATION_GZIP, "tgz" },
   { APPLICATION_ZIP, "zip" },
   { APPLICATION_COMPRESS, "z" },
   { APPLICATION_GZIP, "svgz" }
 };
 NS_IMPL_ISUPPORTS(
   nsExternalHelperAppService,
   nsIExternalHelperAppService,
   nsPIExternalAppLauncher,
   nsIExternalProtocolService,
   nsIMIMEService,
   nsIObserver,
   nsISupportsWeakReference)
 nsExternalHelperAppService::nsExternalHelperAppService()
 {
 }
 nsresult nsExternalHelperAppService::Init()
 {
   // Add an observer for profile change
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   if (!obs)
     return NS_ERROR_FAILURE;
 #ifdef PR_LOGGING
   if (!mLog) {
     mLog = PR_NewLogModule("HelperAppService");
     if (!mLog)
       return NS_ERROR_OUT_OF_MEMORY;
   }
 #endif
   nsresult rv = obs->AddObserver(this, "profile-before-change", true);
   NS_ENSURE_SUCCESS(rv, rv);
   return obs->AddObserver(this, "last-pb-context-exited", true);
 }
 nsExternalHelperAppService::~nsExternalHelperAppService()
 {
 }
 #ifdef NECKO_PROTOCOL_rtsp
 namespace {
 /**
  * A stack helper to clear the currently pending exception in a JS context.
  */
 class AutoClearPendingException {
 public:
   AutoClearPendingException(JSContext* aCx) :
     mCx(aCx) {
   }
   ~AutoClearPendingException() {
     JS_ClearPendingException(mCx);
   }
 private:
   JSContext *mCx;
 };
 } // anonymous namespace
 /**
  * This function sends a message. This 'content-handler' message is handled in
  * b2g/chrome/content/shell.js where it starts an activity request that will
  * open the video app.
  */
 void nsExternalHelperAppService::LaunchVideoAppForRtsp(nsIURI* aURI)
 {
   bool rv;
   // Get a system principal.
   nsCOMPtr<nsIScriptSecurityManager> securityManager =
     do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID);
   NS_ENSURE_TRUE_VOID(securityManager);
   nsCOMPtr<nsIPrincipal> principal;
   securityManager->GetSystemPrincipal(getter_AddRefs(principal));
   NS_ENSURE_TRUE_VOID(principal);
   // Construct the message in jsVal format.
   AutoSafeJSContext cx;
   AutoClearPendingException helper(cx);
   JS::Rooted<JSObject*> msgObj(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   NS_ENSURE_TRUE_VOID(msgObj);
   JS::Rooted<JS::Value> jsVal(cx);
   // Set the "type" property of the message. This is a fake MIME type.
   {
     NS_NAMED_LITERAL_CSTRING(mimeType, "video/rtsp");
     JSString *typeStr = JS_NewStringCopyN(cx, mimeType.get(), mimeType.Length());
     NS_ENSURE_TRUE_VOID(typeStr);
     jsVal.setString(typeStr);
     rv = JS_SetProperty(cx, msgObj, "type", jsVal);
     NS_ENSURE_TRUE_VOID(rv);
   }
   // Set the "url" and "title" properties of the message.
   // They are the same in the case of RTSP streaming.
   {
     nsAutoCString spec;
     aURI->GetSpec(spec);
     JSString *urlStr = JS_NewStringCopyN(cx, spec.get(), spec.Length());
     NS_ENSURE_TRUE_VOID(urlStr);
     jsVal.setString(urlStr);
     rv = JS_SetProperty(cx, msgObj, "url", jsVal);
     NS_ENSURE_TRUE_VOID(rv);
     rv = JS_SetProperty(cx, msgObj, "title", jsVal);
   }
   jsVal.setObject(*msgObj);
   // Send the message.
   nsCOMPtr<nsIMessageSender> cpmm =
     do_GetService("@mozilla.org/childprocessmessagemanager;1");
   NS_ENSURE_TRUE_VOID(cpmm);
   cpmm->SendAsyncMessage(NS_LITERAL_STRING("content-handler"),
                          jsVal, JS::NullHandleValue, principal, cx, 2);
 }
 #endif
 NS_IMETHODIMP nsExternalHelperAppService::DoContent(const nsACString& aMimeContentType,
                                                     nsIRequest *aRequest,
                                                     nsIInterfaceRequestor *aWindowContext,
                                                     bool aForceSave,
                                                     nsIStreamListener ** aStreamListener)
 {
   nsAutoString fileName;
   nsAutoCString fileExtension;
   uint32_t reason = nsIHelperAppLauncherDialog::REASON_CANTHANDLE;
   uint32_t contentDisposition = -1;
   nsresult rv;
   // Get the file extension and name that we will need later
   nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
   nsCOMPtr<nsIURI> uri;
   int64_t contentLength = -1;
   if (channel) {
     channel->GetURI(getter_AddRefs(uri));
     channel->GetContentLength(&contentLength);
     channel->GetContentDisposition(&contentDisposition);
     channel->GetContentDispositionFilename(fileName);
   }
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
     nsCOMPtr<nsIDOMWindow> window = do_GetInterface(aWindowContext);
     NS_ENSURE_STATE(window);
     // We need to get a hold of a ContentChild so that we can begin forwarding
     // this data to the parent.  In the HTTP case, this is unfortunate, since
     // we're actually passing data from parent->child->parent wastefully, but
     // the Right Fix will eventually be to short-circuit those channels on the
     // parent side based on some sort of subscription concept.
     using mozilla::dom::ContentChild;
     using mozilla::dom::ExternalHelperAppChild;
     ContentChild *child = ContentChild::GetSingleton();
     if (!child)
       return NS_ERROR_FAILURE;
     nsCString disp;
     if (channel) {
       channel->GetContentDispositionHeader(disp);
     }
     nsCOMPtr<nsIURI> referrer;
     rv = NS_GetReferrerFromChannel(channel, getter_AddRefs(referrer));
     OptionalURIParams uriParams, referrerParams;
     SerializeURI(uri, uriParams);
     SerializeURI(referrer, referrerParams);
     // Now we build a protocol for forwarding our data to the parent.  The
     // protocol will act as a listener on the child-side and create a "real"
     // helperAppService listener on the parent-side, via another call to
     // DoContent.
     mozilla::dom::PExternalHelperAppChild *pc =
       child->SendPExternalHelperAppConstructor(uriParams,
                                                nsCString(aMimeContentType),
                                                disp, contentDisposition,
                                                fileName, aForceSave,
                                                contentLength, referrerParams,
                                                mozilla::dom::TabChild::GetFrom(window));
     ExternalHelperAppChild *childListener = static_cast<ExternalHelperAppChild *>(pc);
     NS_ADDREF(*aStreamListener = childListener);
     nsRefPtr<nsExternalAppHandler> handler =
       new nsExternalAppHandler(nullptr, EmptyCString(), aWindowContext, this,
                                fileName,
                                reason, aForceSave);
     if (!handler)
       return NS_ERROR_OUT_OF_MEMORY;
     childListener->SetHandler(handler);
     return NS_OK;
   }
   if (channel) {
     // Check if we have a POST request, in which case we don't want to use
     // the url's extension
     bool allowURLExt = true;
     nsCOMPtr<nsIHttpChannel> httpChan = do_QueryInterface(channel);
     if (httpChan) {
       nsAutoCString requestMethod;
       httpChan->GetRequestMethod(requestMethod);
       allowURLExt = !requestMethod.Equals("POST");
     }
     // Check if we had a query string - we don't want to check the URL
     // extension if a query is present in the URI
     // If we already know we don't want to check the URL extension, don't
     // bother checking the query
     if (uri && allowURLExt) {
       nsCOMPtr<nsIURL> url = do_QueryInterface(uri);
       if (url) {
         nsAutoCString query;
         // We only care about the query for HTTP and HTTPS URLs
         bool isHTTP, isHTTPS;
         rv = uri->SchemeIs("http", &isHTTP);
         if (NS_FAILED(rv))
           isHTTP = false;
         rv = uri->SchemeIs("https", &isHTTPS);
         if (NS_FAILED(rv))
           isHTTPS = false;
         if (isHTTP || isHTTPS)
           url->GetQuery(query);
         // Only get the extension if the query is empty; if it isn't, then the
         // extension likely belongs to a cgi script and isn't helpful
         allowURLExt = query.IsEmpty();
       }
     }
     // Extract name & extension
     bool isAttachment = GetFilenameAndExtensionFromChannel(channel, fileName,
                                                              fileExtension,
                                                              allowURLExt);
     LOG(("Found extension '%s' (filename is '%s', handling attachment: %i)",
          fileExtension.get(), NS_ConvertUTF16toUTF8(fileName).get(),
          isAttachment));
     if (isAttachment)
       reason = nsIHelperAppLauncherDialog::REASON_SERVERREQUEST;
   }
   LOG(("HelperAppService::DoContent: mime '%s', extension '%s'\n",
        PromiseFlatCString(aMimeContentType).get(), fileExtension.get()));
   // we get the mime service here even though we're the default implementation of it,
   // so it's possible to override only the mime service and not need to reimplement the
   // whole external helper app service itself
   nsCOMPtr<nsIMIMEService> mimeSvc(do_GetService(NS_MIMESERVICE_CONTRACTID));
   NS_ENSURE_TRUE(mimeSvc, NS_ERROR_FAILURE);
   // Try to find a mime object by looking at the mime type/extension
   nsCOMPtr<nsIMIMEInfo> mimeInfo;
   if (aMimeContentType.Equals(APPLICATION_GUESS_FROM_EXT, nsCaseInsensitiveCStringComparator())) {
     nsAutoCString mimeType;
     if (!fileExtension.IsEmpty()) {
       mimeSvc->GetFromTypeAndExtension(EmptyCString(), fileExtension, getter_AddRefs(mimeInfo));
       if (mimeInfo) {
         mimeInfo->GetMIMEType(mimeType);
         LOG(("OS-Provided mime type '%s' for extension '%s'\n",
              mimeType.get(), fileExtension.get()));
       }
     }
     if (fileExtension.IsEmpty() || mimeType.IsEmpty()) {
       // Extension lookup gave us no useful match
       mimeSvc->GetFromTypeAndExtension(NS_LITERAL_CSTRING(APPLICATION_OCTET_STREAM), fileExtension,
                                        getter_AddRefs(mimeInfo));
       mimeType.AssignLiteral(APPLICATION_OCTET_STREAM);
     }
     if (channel)
       channel->SetContentType(mimeType);
     // Don't overwrite SERVERREQUEST
     if (reason == nsIHelperAppLauncherDialog::REASON_CANTHANDLE)
       reason = nsIHelperAppLauncherDialog::REASON_TYPESNIFFED;
   }
   else {
     mimeSvc->GetFromTypeAndExtension(aMimeContentType, fileExtension,
                                      getter_AddRefs(mimeInfo));
   }
   LOG(("Type/Ext lookup found 0x%p\n", mimeInfo.get()));
   // No mimeinfo -> we can't continue. probably OOM.
   if (!mimeInfo)
     return NS_ERROR_OUT_OF_MEMORY;
   *aStreamListener = nullptr;
   // We want the mimeInfo's primary extension to pass it to
   // nsExternalAppHandler
   nsAutoCString buf;
   mimeInfo->GetPrimaryExtension(buf);
   nsExternalAppHandler * handler = new nsExternalAppHandler(mimeInfo,
                                                             buf,
                                                             aWindowContext,
                                                             this,
                                                             fileName,
                                                             reason,
                                                             aForceSave);
   if (!handler)
     return NS_ERROR_OUT_OF_MEMORY;
   NS_ADDREF(*aStreamListener = handler);
   return NS_OK;
 }
 NS_IMETHODIMP nsExternalHelperAppService::ApplyDecodingForExtension(const nsACString& aExtension,
                                                                     const nsACString& aEncodingType,
                                                                     bool *aApplyDecoding)
 {
   *aApplyDecoding = true;
   uint32_t i;
   for(i = 0; i < ArrayLength(nonDecodableExtensions); ++i) {
     if (aExtension.LowerCaseEqualsASCII(nonDecodableExtensions[i].mFileExtension) &&
         aEncodingType.LowerCaseEqualsASCII(nonDecodableExtensions[i].mMimeType)) {
       *aApplyDecoding = false;
       break;
     }
   }
   return NS_OK;
 }
 nsresult nsExternalHelperAppService::GetFileTokenForPath(const char16_t * aPlatformAppPath,
                                                          nsIFile ** aFile)
 {
   nsDependentString platformAppPath(aPlatformAppPath);
   // First, check if we have an absolute path
   nsIFile* localFile = nullptr;
   nsresult rv = NS_NewLocalFile(platformAppPath, true, &localFile);
   if (NS_SUCCEEDED(rv)) {
     *aFile = localFile;
     bool exists;
     if (NS_FAILED((*aFile)->Exists(&exists)) || !exists) {
       NS_RELEASE(*aFile);
       return NS_ERROR_FILE_NOT_FOUND;
     }
     return NS_OK;
   }
   // Second, check if file exists in mozilla program directory
   rv = NS_GetSpecialDirectory(NS_XPCOM_CURRENT_PROCESS_DIR, aFile);
   if (NS_SUCCEEDED(rv)) {
     rv = (*aFile)->Append(platformAppPath);
     if (NS_SUCCEEDED(rv)) {
       bool exists = false;
       rv = (*aFile)->Exists(&exists);
       if (NS_SUCCEEDED(rv) && exists)
         return NS_OK;
     }
     NS_RELEASE(*aFile);
   }
   return NS_ERROR_NOT_AVAILABLE;
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 // begin external protocol service default implementation...
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 NS_IMETHODIMP nsExternalHelperAppService::ExternalProtocolHandlerExists(const char * aProtocolScheme,
                                                                         bool * aHandlerExists)
 {
   nsCOMPtr<nsIHandlerInfo> handlerInfo;
   nsresult rv = GetProtocolHandlerInfo(nsDependentCString(aProtocolScheme),
                                        getter_AddRefs(handlerInfo));
   NS_ENSURE_SUCCESS(rv, rv);
   // See if we have any known possible handler apps for this
   nsCOMPtr<nsIMutableArray> possibleHandlers;
   handlerInfo->GetPossibleApplicationHandlers(getter_AddRefs(possibleHandlers));
   uint32_t length;
   possibleHandlers->GetLength(&length);
   if (length) {
     *aHandlerExists = true;
     return NS_OK;
   }
   // if not, fall back on an os-based handler
   return OSProtocolHandlerExists(aProtocolScheme, aHandlerExists);
 }
 NS_IMETHODIMP nsExternalHelperAppService::IsExposedProtocol(const char * aProtocolScheme, bool * aResult)
 {
   // check the per protocol setting first.  it always takes precedence.
   // if not set, then use the global setting.
   nsAutoCString prefName("network.protocol-handler.expose.");
   prefName += aProtocolScheme;
   bool val;
   if (NS_SUCCEEDED(Preferences::GetBool(prefName.get(), &val))) {
     *aResult = val;
     return NS_OK;
   }
   // by default, no protocol is exposed.  i.e., by default all link clicks must
   // go through the external protocol service.  most applications override this
   // default behavior.
   *aResult =
     Preferences::GetBool("network.protocol-handler.expose-all", false);
   return NS_OK;
 }
 NS_IMETHODIMP nsExternalHelperAppService::LoadUrl(nsIURI * aURL)
 {
   return LoadURI(aURL, nullptr);
 }
 static const char kExternalProtocolPrefPrefix[]  = "network.protocol-handler.external.";
 static const char kExternalProtocolDefaultPref[] = "network.protocol-handler.external-default";
 NS_IMETHODIMP
 nsExternalHelperAppService::LoadURI(nsIURI *aURI,
                                     nsIInterfaceRequestor *aWindowContext)
 {
   NS_ENSURE_ARG_POINTER(aURI);
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
     URIParams uri;
     SerializeURI(aURI, uri);
     mozilla::dom::ContentChild::GetSingleton()->SendLoadURIExternal(uri);
     return NS_OK;
   }
   nsAutoCString spec;
   aURI->GetSpec(spec);
   if (spec.Find("%00") != -1)
     return NS_ERROR_MALFORMED_URI;
   spec.ReplaceSubstring("\"", "%22");
   spec.ReplaceSubstring("`", "%60");
   nsCOMPtr<nsIIOService> ios(do_GetIOService());
   nsCOMPtr<nsIURI> uri;
   nsresult rv = ios->NewURI(spec, nullptr, nullptr, getter_AddRefs(uri));
   NS_ENSURE_SUCCESS(rv, rv);
   nsAutoCString scheme;
   uri->GetScheme(scheme);
   if (scheme.IsEmpty())
     return NS_OK; // must have a scheme
   // Deny load if the prefs say to do so
   nsAutoCString externalPref(kExternalProtocolPrefPrefix);
   externalPref += scheme;
   bool allowLoad  = false;
   if (NS_FAILED(Preferences::GetBool(externalPref.get(), &allowLoad))) {
     // no scheme-specific value, check the default
     if (NS_FAILED(Preferences::GetBool(kExternalProtocolDefaultPref,
                                        &allowLoad))) {
       return NS_OK; // missing default pref
     }
   }
   if (!allowLoad) {
     return NS_OK; // explicitly denied
   }
 #ifdef NECKO_PROTOCOL_rtsp
   // Handle rtsp protocol.
   {
     bool isRTSP = false;
     rv = aURI->SchemeIs("rtsp", &isRTSP);
     if (NS_SUCCEEDED(rv) && isRTSP) {
       LaunchVideoAppForRtsp(aURI);
       return NS_OK;
     }
   }
 #endif
   nsCOMPtr<nsIHandlerInfo> handler;
   rv = GetProtocolHandlerInfo(scheme, getter_AddRefs(handler));
   NS_ENSURE_SUCCESS(rv, rv);
   nsHandlerInfoAction preferredAction;
   handler->GetPreferredAction(&preferredAction);
   bool alwaysAsk = true;
   handler->GetAlwaysAskBeforeHandling(&alwaysAsk);
   // if we are not supposed to ask, and the preferred action is to use
   // a helper app or the system default, we just launch the URI.
   if (!alwaysAsk && (preferredAction == nsIHandlerInfo::useHelperApp ||
                      preferredAction == nsIHandlerInfo::useSystemDefault))
     return handler->LaunchWithURI(uri, aWindowContext);
   nsCOMPtr<nsIContentDispatchChooser> chooser =
     do_CreateInstance("@mozilla.org/content-dispatch-chooser;1", &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   return chooser->Ask(handler, aWindowContext, uri,
                       nsIContentDispatchChooser::REASON_CANNOT_HANDLE);
 }
 NS_IMETHODIMP nsExternalHelperAppService::GetApplicationDescription(const nsACString& aScheme, nsAString& _retval)
 {
   // this method should only be implemented by each OS specific implementation of this service.
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 // Methods related to deleting temporary files on exit
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 /* static */
 nsresult
 nsExternalHelperAppService::DeleteTemporaryFileHelper(nsIFile * aTemporaryFile,
                                                       nsCOMArray<nsIFile> &aFileList)
 {
   bool isFile = false;
   // as a safety measure, make sure the nsIFile is really a file and not a directory object.
   aTemporaryFile->IsFile(&isFile);
   if (!isFile) return NS_OK;
   aFileList.AppendObject(aTemporaryFile);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsExternalHelperAppService::DeleteTemporaryFileOnExit(nsIFile* aTemporaryFile)
 {
   return DeleteTemporaryFileHelper(aTemporaryFile, mTemporaryFilesList);
 }
 NS_IMETHODIMP
 nsExternalHelperAppService::DeleteTemporaryPrivateFileWhenPossible(nsIFile* aTemporaryFile)
 {
   return DeleteTemporaryFileHelper(aTemporaryFile, mTemporaryPrivateFilesList);
 }
 void nsExternalHelperAppService::ExpungeTemporaryFilesHelper(nsCOMArray<nsIFile> &fileList)
 {
   int32_t numEntries = fileList.Count();
   nsIFile* localFile;
   for (int32_t index = 0; index < numEntries; index++)
   {
     localFile = fileList[index];
     if (localFile) {
       // First make the file writable, since the temp file is probably readonly.
       localFile->SetPermissions(0600);
       localFile->Remove(false);
     }
   }
   fileList.Clear();
 }
 void nsExternalHelperAppService::ExpungeTemporaryFiles()
 {
   ExpungeTemporaryFilesHelper(mTemporaryFilesList);
 }
 void nsExternalHelperAppService::ExpungeTemporaryPrivateFiles()
 {
   ExpungeTemporaryFilesHelper(mTemporaryPrivateFilesList);
 }
 static const char kExternalWarningPrefPrefix[] =
   "network.protocol-handler.warn-external.";
 static const char kExternalWarningDefaultPref[] =
   "network.protocol-handler.warn-external-default";
 NS_IMETHODIMP
 nsExternalHelperAppService::GetProtocolHandlerInfo(const nsACString &aScheme,
                                                    nsIHandlerInfo **aHandlerInfo)
 {
   // XXX enterprise customers should be able to turn this support off with a
   // single master pref (maybe use one of the "exposed" prefs here?)
   bool exists;
   nsresult rv = GetProtocolHandlerInfoFromOS(aScheme, &exists, aHandlerInfo);
   if (NS_FAILED(rv)) {
     // Either it knows nothing, or we ran out of memory
     return NS_ERROR_FAILURE;
   }
   nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);
   if (handlerSvc) {
     bool hasHandler = false;
     (void) handlerSvc->Exists(*aHandlerInfo, &hasHandler);
     if (hasHandler) {
       rv = handlerSvc->FillHandlerInfo(*aHandlerInfo, EmptyCString());
       if (NS_SUCCEEDED(rv))
         return NS_OK;
     }
   }
   return SetProtocolHandlerDefaults(*aHandlerInfo, exists);
 }
 NS_IMETHODIMP
 nsExternalHelperAppService::GetProtocolHandlerInfoFromOS(const nsACString &aScheme,
                                                          bool *found,
                                                          nsIHandlerInfo **aHandlerInfo)
 {
   // intended to be implemented by the subclass
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsExternalHelperAppService::SetProtocolHandlerDefaults(nsIHandlerInfo *aHandlerInfo,
                                                        bool aOSHandlerExists)
 {
   // this type isn't in our database, so we've only got an OS default handler,
   // if one exists
   if (aOSHandlerExists) {
     // we've got a default, so use it
     aHandlerInfo->SetPreferredAction(nsIHandlerInfo::useSystemDefault);
     // whether or not to ask the user depends on the warning preference
     nsAutoCString scheme;
     aHandlerInfo->GetType(scheme);
     nsAutoCString warningPref(kExternalWarningPrefPrefix);
     warningPref += scheme;
     bool warn;
     if (NS_FAILED(Preferences::GetBool(warningPref.get(), &warn))) {
       // no scheme-specific value, check the default
       warn = Preferences::GetBool(kExternalWarningDefaultPref, true);
     }
     aHandlerInfo->SetAlwaysAskBeforeHandling(warn);
   } else {
     // If no OS default existed, we set the preferred action to alwaysAsk.
     // This really means not initialized (i.e. there's no available handler)
     // to all the code...
     aHandlerInfo->SetPreferredAction(nsIHandlerInfo::alwaysAsk);
   }
   return NS_OK;
 }
 // XPCOM profile change observer
 NS_IMETHODIMP
 nsExternalHelperAppService::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *someData )
 {
   if (!strcmp(aTopic, "profile-before-change")) {
     ExpungeTemporaryFiles();
   } else if (!strcmp(aTopic, "last-pb-context-exited")) {
     ExpungeTemporaryPrivateFiles();
   }
   return NS_OK;
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 // begin external app handler implementation
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 NS_IMPL_ADDREF(nsExternalAppHandler)
 NS_IMPL_RELEASE(nsExternalAppHandler)
 NS_INTERFACE_MAP_BEGIN(nsExternalAppHandler)
    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStreamListener)
    NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
    NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
    NS_INTERFACE_MAP_ENTRY(nsIHelperAppLauncher)
    NS_INTERFACE_MAP_ENTRY(nsICancelable)
    NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
    NS_INTERFACE_MAP_ENTRY(nsIBackgroundFileSaverObserver)
 NS_INTERFACE_MAP_END_THREADSAFE
 nsExternalAppHandler::nsExternalAppHandler(nsIMIMEInfo * aMIMEInfo,
                                            const nsCSubstring& aTempFileExtension,
                                            nsIInterfaceRequestor* aWindowContext,
                                            nsExternalHelperAppService *aExtProtSvc,
                                            const nsAString& aSuggestedFilename,
                                            uint32_t aReason, bool aForceSave)
 : mMimeInfo(aMIMEInfo)
 , mWindowContext(aWindowContext)
 , mWindowToClose(nullptr)
 , mSuggestedFileName(aSuggestedFilename)
 , mForceSave(aForceSave)
 , mCanceled(false)
 , mShouldCloseWindow(false)
 , mStopRequestIssued(false)
 , mReason(aReason)
 , mContentLength(-1)
 , mProgress(0)
 , mSaver(nullptr)
 , mDialogProgressListener(nullptr)
 , mTransfer(nullptr)
 , mRequest(nullptr)
 , mExtProtSvc(aExtProtSvc)
 {
   // make sure the extention includes the '.'
   if (!aTempFileExtension.IsEmpty() && aTempFileExtension.First() != '.')
     mTempFileExtension = char16_t('.');
   AppendUTF8toUTF16(aTempFileExtension, mTempFileExtension);
   // replace platform specific path separator and illegal characters to avoid any confusion
   mSuggestedFileName.ReplaceChar(KNOWN_PATH_SEPARATORS FILE_ILLEGAL_CHARACTERS, '_');
   mTempFileExtension.ReplaceChar(KNOWN_PATH_SEPARATORS FILE_ILLEGAL_CHARACTERS, '_');
   // Remove unsafe bidi characters which might have spoofing implications (bug 511521).
   const char16_t unsafeBidiCharacters[] = {
     char16_t(0x061c), // Arabic Letter Mark
     char16_t(0x200e), // Left-to-Right Mark
     char16_t(0x200f), // Right-to-Left Mark
     char16_t(0x202a), // Left-to-Right Embedding
     char16_t(0x202b), // Right-to-Left Embedding
     char16_t(0x202c), // Pop Directional Formatting
     char16_t(0x202d), // Left-to-Right Override
     char16_t(0x202e), // Right-to-Left Override
     char16_t(0x2066), // Left-to-Right Isolate
     char16_t(0x2067), // Right-to-Left Isolate
     char16_t(0x2068), // First Strong Isolate
     char16_t(0x2069), // Pop Directional Isolate
     char16_t(0)
   };
   mSuggestedFileName.ReplaceChar(unsafeBidiCharacters, '_');
   mTempFileExtension.ReplaceChar(unsafeBidiCharacters, '_');
   // Make sure extension is correct.
   EnsureSuggestedFileName();
   mBufferSize = Preferences::GetUint("network.buffer.cache.size", 4096);
 }
 nsExternalAppHandler::~nsExternalAppHandler()
 {
   MOZ_ASSERT(!mSaver, "Saver should hold a reference to us until deleted");
 }
 void
 nsExternalAppHandler::DidDivertRequest(nsIRequest *request)
 {
   MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Content, "in child process");
   // Remove our request from the child loadGroup
   RetargetLoadNotifications(request);
   MaybeCloseWindow();
 }
 NS_IMETHODIMP nsExternalAppHandler::SetWebProgressListener(nsIWebProgressListener2 * aWebProgressListener)
 {
   // This is always called by nsHelperDlg.js. Go ahead and register the
   // progress listener. At this point, we don't have mTransfer.
   mDialogProgressListener = aWebProgressListener;
   return NS_OK;
 }
 NS_IMETHODIMP nsExternalAppHandler::GetTargetFile(nsIFile** aTarget)
 {
   if (mFinalFileDestination)
     *aTarget = mFinalFileDestination;
   else
     *aTarget = mTempFile;
   NS_IF_ADDREF(*aTarget);
   return NS_OK;
 }
 NS_IMETHODIMP nsExternalAppHandler::GetTargetFileIsExecutable(bool *aExec)
 {
   // Use the real target if it's been set
   if (mFinalFileDestination)
     return mFinalFileDestination->IsExecutable(aExec);
   // Otherwise, use the stored executable-ness of the temporary
   *aExec = mTempFileIsExecutable;
   return NS_OK;
 }
 NS_IMETHODIMP nsExternalAppHandler::GetTimeDownloadStarted(PRTime* aTime)
 {
   *aTime = mTimeDownloadStarted;
   return NS_OK;
 }
 NS_IMETHODIMP nsExternalAppHandler::GetContentLength(int64_t *aContentLength)
 {
   *aContentLength = mContentLength;
   return NS_OK;
 }
 void nsExternalAppHandler::RetargetLoadNotifications(nsIRequest *request)
 {
   // we are going to run the downloading of the helper app in our own little docloader / load group context.
   // so go ahead and force the creation of a load group and doc loader for us to use...
   nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
   if (!aChannel)
     return;
   // we need to store off the original (pre redirect!) channel that initiated the load. We do
   // this so later on, we can pass any refresh urls associated with the original channel back to the
   // window context which started the whole process. More comments about that are listed below....
   // HACK ALERT: it's pretty bogus that we are getting the document channel from the doc loader.
   // ideally we should be able to just use mChannel (the channel we are extracting content from) or
   // the default load channel associated with the original load group. Unfortunately because
   // a redirect may have occurred, the doc loader is the only one with a ptr to the original channel
   // which is what we really want....
   // Note that we need to do this before removing aChannel from the loadgroup,
   // since that would mess with the original channel on the loader.
   nsCOMPtr<nsIDocumentLoader> origContextLoader =
     do_GetInterface(mWindowContext);
   if (origContextLoader)
     origContextLoader->GetDocumentChannel(getter_AddRefs(mOriginalChannel));
   bool isPrivate = NS_UsePrivateBrowsing(aChannel);
   nsCOMPtr<nsILoadGroup> oldLoadGroup;
   aChannel->GetLoadGroup(getter_AddRefs(oldLoadGroup));
   if(oldLoadGroup)
      oldLoadGroup->RemoveRequest(request, nullptr, NS_BINDING_RETARGETED);
   aChannel->SetLoadGroup(nullptr);
   aChannel->SetNotificationCallbacks(nullptr);
   nsCOMPtr<nsIPrivateBrowsingChannel> pbChannel = do_QueryInterface(aChannel);
   if (pbChannel) {
     pbChannel->SetPrivate(isPrivate);
   }
 }
 /**
  * Make mTempFileExtension contain an extension exactly when its previous value
  * is different from mSuggestedFileName's extension, so that it can be appended
  * to mSuggestedFileName and form a valid, useful leaf name.
  * This is required so that the (renamed) temporary file has the correct extension
  * after downloading to make sure the OS will launch the application corresponding
  * to the MIME type (which was used to calculate mTempFileExtension).  This prevents
  * a cgi-script named foobar.exe that returns application/zip from being named
  * foobar.exe and executed as an executable file. It also blocks content that
  * a web site might provide with a content-disposition header indicating
  * filename="foobar.exe" from being downloaded to a file with extension .exe
  * and executed.
  */
 void nsExternalAppHandler::EnsureSuggestedFileName()
 {
   // Make sure there is a mTempFileExtension (not "" or ".").
   // Remember that mTempFileExtension will always have the leading "."
   // (the check for empty is just to be safe).
   if (mTempFileExtension.Length() > 1)
   {
     // Get mSuggestedFileName's current extension.
     nsAutoString fileExt;
     int32_t pos = mSuggestedFileName.RFindChar('.');
     if (pos != kNotFound)
       mSuggestedFileName.Right(fileExt, mSuggestedFileName.Length() - pos);
     // Now, compare fileExt to mTempFileExtension.
     if (fileExt.Equals(mTempFileExtension, nsCaseInsensitiveStringComparator()))
     {
       // Matches -> mTempFileExtension can be empty
       mTempFileExtension.Truncate();
     }
   }
 }
 nsresult nsExternalAppHandler::SetUpTempFile(nsIChannel * aChannel)
 {
   // First we need to try to get the destination directory for the temporary
   // file.
   nsresult rv = GetDownloadDirectory(getter_AddRefs(mTempFile));
   NS_ENSURE_SUCCESS(rv, rv);
   // At this point, we do not have a filename for the temp file.  For security
   // purposes, this cannot be predictable, so we must use a cryptographic
   // quality PRNG to generate one.
   // We will request raw random bytes, and transform that to a base64 string,
   // as all characters from the base64 set are acceptable for filenames.  For
   // each three bytes of random data, we will get four bytes of ASCII.  Request
   // a bit more, to be safe, and truncate to the length we want in the end.
   const uint32_t wantedFileNameLength = 8;
   const uint32_t requiredBytesLength =
     static_cast<uint32_t>((wantedFileNameLength + 1) / 4 * 3);
   nsCOMPtr<nsIRandomGenerator> rg =
     do_GetService("@mozilla.org/security/random-generator;1", &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   uint8_t *buffer;
   rv = rg->GenerateRandomBytes(requiredBytesLength, &buffer);
   NS_ENSURE_SUCCESS(rv, rv);
   nsAutoCString tempLeafName;
   nsDependentCSubstring randomData(reinterpret_cast<const char*>(buffer), requiredBytesLength);
   rv = Base64Encode(randomData, tempLeafName);
   NS_Free(buffer);
   buffer = nullptr;
   NS_ENSURE_SUCCESS(rv, rv);
   tempLeafName.Truncate(wantedFileNameLength);
   // Base64 characters are alphanumeric (a-zA-Z0-9) and '+' and '/', so we need
   // to replace illegal characters -- notably '/'
   tempLeafName.ReplaceChar(KNOWN_PATH_SEPARATORS FILE_ILLEGAL_CHARACTERS, '_');
   // now append our extension.
   nsAutoCString ext;
   mMimeInfo->GetPrimaryExtension(ext);
   if (!ext.IsEmpty()) {
     ext.ReplaceChar(KNOWN_PATH_SEPARATORS FILE_ILLEGAL_CHARACTERS, '_');
     if (ext.First() != '.')
       tempLeafName.Append('.');
     tempLeafName.Append(ext);
   }
   // We need to temporarily create a dummy file with the correct
   // file extension to determine the executable-ness, so do this before adding
   // the extra .part extension.
   nsCOMPtr<nsIFile> dummyFile;
   rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(dummyFile));
   NS_ENSURE_SUCCESS(rv, rv);
   // Set the file name without .part
   rv = dummyFile->Append(NS_ConvertUTF8toUTF16(tempLeafName));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = dummyFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
   NS_ENSURE_SUCCESS(rv, rv);
   // Store executable-ness then delete
   dummyFile->IsExecutable(&mTempFileIsExecutable);
   dummyFile->Remove(false);
   // Add an additional .part to prevent the OS from running this file in the
   // default application.
   tempLeafName.Append(NS_LITERAL_CSTRING(".part"));
   rv = mTempFile->Append(NS_ConvertUTF8toUTF16(tempLeafName));
   // make this file unique!!!
   NS_ENSURE_SUCCESS(rv, rv);
   rv = mTempFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0644);
   NS_ENSURE_SUCCESS(rv, rv);
   // Now save the temp leaf name, minus the ".part" bit, so we can use it later.
   // This is a bit broken in the case when createUnique actually had to append
   // some numbers, because then we now have a filename like foo.bar-1.part and
   // we'll end up with foo.bar-1.bar as our final filename if we end up using
   // this.  But the other options are all bad too....  Ideally we'd have a way
   // to tell createUnique to put its unique marker before the extension that
   // comes before ".part" or something.
   rv = mTempFile->GetLeafName(mTempLeafName);
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_TRUE(StringEndsWith(mTempLeafName, NS_LITERAL_STRING(".part")),
                  NS_ERROR_UNEXPECTED);
   // Strip off the ".part" from mTempLeafName
   mTempLeafName.Truncate(mTempLeafName.Length() - ArrayLength(".part") + 1);
   MOZ_ASSERT(!mSaver, "Output file initialization called more than once!");
   mSaver = do_CreateInstance(NS_BACKGROUNDFILESAVERSTREAMLISTENER_CONTRACTID,
                              &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = mSaver->SetObserver(this);
   if (NS_FAILED(rv)) {
     mSaver = nullptr;
     return rv;
   }
   rv = mSaver->EnableSha256();
   NS_ENSURE_SUCCESS(rv, rv);
   rv = mSaver->EnableSignatureInfo();
   NS_ENSURE_SUCCESS(rv, rv);
   LOG(("Enabled hashing and signature verification"));
   rv = mSaver->SetTarget(mTempFile, false);
   NS_ENSURE_SUCCESS(rv, rv);
   return rv;
 }
 NS_IMETHODIMP nsExternalAppHandler::OnStartRequest(nsIRequest *request, nsISupports * aCtxt)
 {
   NS_PRECONDITION(request, "OnStartRequest without request?");
   // Set mTimeDownloadStarted here as the download has already started and
   // we want to record the start time before showing the filepicker.
   mTimeDownloadStarted = PR_Now();
   mRequest = request;
   nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
   nsresult rv;
   nsCOMPtr<nsIFileChannel> fileChan(do_QueryInterface(request));
   mIsFileChannel = fileChan != nullptr;
   // Get content length
   if (aChannel) {
     aChannel->GetContentLength(&mContentLength);
   }
   nsCOMPtr<nsIPropertyBag2> props(do_QueryInterface(request, &rv));
   // Determine whether a new window was opened specifically for this request
   if (props) {
     bool tmp = false;
     props->GetPropertyAsBool(NS_LITERAL_STRING("docshell.newWindowTarget"),
                              &tmp);
     mShouldCloseWindow = tmp;
   }
   // Now get the URI
   if (aChannel)
   {
     aChannel->GetURI(getter_AddRefs(mSourceUrl));
   }
   // retarget all load notifications to our docloader instead of the original window's docloader...
   RetargetLoadNotifications(request);
   // Check to see if there is a refresh header on the original channel.
   if (mOriginalChannel) {
     nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(mOriginalChannel));
     if (httpChannel) {
       nsAutoCString refreshHeader;
       httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("refresh"),
                                      refreshHeader);
       if (!refreshHeader.IsEmpty()) {
         mShouldCloseWindow = false;
       }
     }
   }
   // Close the underlying DOMWindow if there is no refresh header
   // and it was opened specifically for the download
   MaybeCloseWindow();
   // In an IPC setting, we're allowing the child process, here, to make
   // decisions about decoding the channel (e.g. decompression).  It will
   // still forward the decoded (uncompressed) data back to the parent.
   // Con: Uncompressed data means more IPC overhead.
   // Pros: ExternalHelperAppParent doesn't need to implement nsIEncodedChannel.
   //       Parent process doesn't need to expect CPU time on decompression.
   nsCOMPtr<nsIEncodedChannel> encChannel = do_QueryInterface( aChannel );
   if (encChannel)
   {
     // Turn off content encoding conversions if needed
     bool applyConversion = true;
     nsCOMPtr<nsIURL> sourceURL(do_QueryInterface(mSourceUrl));
     if (sourceURL)
     {
       nsAutoCString extension;
       sourceURL->GetFileExtension(extension);
       if (!extension.IsEmpty())
       {
         nsCOMPtr<nsIUTF8StringEnumerator> encEnum;
         encChannel->GetContentEncodings(getter_AddRefs(encEnum));
         if (encEnum)
         {
           bool hasMore;
           rv = encEnum->HasMore(&hasMore);
           if (NS_SUCCEEDED(rv) && hasMore)
           {
             nsAutoCString encType;
             rv = encEnum->GetNext(encType);
             if (NS_SUCCEEDED(rv) && !encType.IsEmpty())
             {
               mExtProtSvc->ApplyDecodingForExtension(extension, encType,
                                                      &applyConversion);
             }
           }
         }
       }
     }
     encChannel->SetApplyConversion( applyConversion );
   }
   // At this point, the child process has done everything it can usefully do
   // for OnStartRequest.
   if (XRE_GetProcessType() == GeckoProcessType_Content)
      return NS_OK;
   rv = SetUpTempFile(aChannel);
   if (NS_FAILED(rv)) {
     nsresult transferError = rv;
     rv = CreateFailedTransfer(aChannel && NS_UsePrivateBrowsing(aChannel));
 #ifdef PR_LOGGING
     if (NS_FAILED(rv)) {
       LOG(("Failed to create transfer to report failure."
            "Will fallback to prompter!"));
     }
 #endif
     mCanceled = true;
     request->Cancel(transferError);
     nsAutoString path;
     if (mTempFile)
       mTempFile->GetPath(path);
     SendStatusChange(kWriteError, transferError, request, path);
     return NS_OK;
   }
   // Inform channel it is open on behalf of a download to prevent caching.
   nsCOMPtr<nsIHttpChannelInternal> httpInternal = do_QueryInterface(aChannel);
   if (httpInternal) {
     httpInternal->SetChannelIsForDownload(true);
   }
   // now that the temp file is set up, find out if we need to invoke a dialog
   // asking the user what they want us to do with this content...
   // We can get here for three reasons: "can't handle", "sniffed type", or
   // "server sent content-disposition:attachment".  In the first case we want
   // to honor the user's "always ask" pref; in the other two cases we want to
   // honor it only if the default action is "save".  Opening attachments in
   // helper apps by default breaks some websites (especially if the attachment
   // is one part of a multipart document).  Opening sniffed content in helper
   // apps by default introduces security holes that we'd rather not have.
   // So let's find out whether the user wants to be prompted.  If he does not,
   // check mReason and the preferred action to see what we should do.
   bool alwaysAsk = true;
   mMimeInfo->GetAlwaysAskBeforeHandling(&alwaysAsk);
   if (alwaysAsk)
   {
     // But we *don't* ask if this mimeInfo didn't come from
     // our user configuration datastore and the user has said
     // at some point in the distant past that they don't
     // want to be asked.  The latter fact would have been
     // stored in pref strings back in the old days.
     bool mimeTypeIsInDatastore = false;
     nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);
     if (handlerSvc)
       handlerSvc->Exists(mMimeInfo, &mimeTypeIsInDatastore);
     if (!handlerSvc || !mimeTypeIsInDatastore)
     {
       nsAutoCString MIMEType;
       mMimeInfo->GetMIMEType(MIMEType);
       if (!GetNeverAskFlagFromPref(NEVER_ASK_FOR_SAVE_TO_DISK_PREF, MIMEType.get()))
       {
         // Don't need to ask after all.
         alwaysAsk = false;
         // Make sure action matches pref (save to disk).
         mMimeInfo->SetPreferredAction(nsIMIMEInfo::saveToDisk);
       }
       else if (!GetNeverAskFlagFromPref(NEVER_ASK_FOR_OPEN_FILE_PREF, MIMEType.get()))
       {
         // Don't need to ask after all.
         alwaysAsk = false;
       }
     }
   }
   int32_t action = nsIMIMEInfo::saveToDisk;
   mMimeInfo->GetPreferredAction( &action );
   // OK, now check why we're here
   if (!alwaysAsk && mReason != nsIHelperAppLauncherDialog::REASON_CANTHANDLE) {
     // Force asking if we're not saving.  See comment back when we fetched the
     // alwaysAsk boolean for details.
     alwaysAsk = (action != nsIMIMEInfo::saveToDisk);
   }
   // if we were told that we _must_ save to disk without asking, all the stuff
   // before this is irrelevant; override it
   if (mForceSave) {
     alwaysAsk = false;
     action = nsIMIMEInfo::saveToDisk;
   }
   if (alwaysAsk)
   {
     // invoke the dialog!!!!! use mWindowContext as the window context parameter for the dialog request
     mDialog = do_CreateInstance( NS_HELPERAPPLAUNCHERDLG_CONTRACTID, &rv );
     NS_ENSURE_SUCCESS(rv, rv);
     // this will create a reference cycle (the dialog holds a reference to us as
     // nsIHelperAppLauncher), which will be broken in Cancel or CreateTransfer.
     rv = mDialog->Show( this, mWindowContext, mReason );
     // what do we do if the dialog failed? I guess we should call Cancel and abort the load....
   }
   else
   {
     // We need to do the save/open immediately, then.
 #ifdef XP_WIN
     /* We need to see whether the file we've got here could be
      * executable.  If it could, we had better not try to open it!
      * We can skip this check, though, if we have a setting to open in a
      * helper app.
      * This code mirrors the code in
      * nsExternalAppHandler::LaunchWithApplication so that what we
      * test here is as close as possible to what will really be
      * happening if we decide to execute
      */
     nsCOMPtr<nsIHandlerApp> prefApp;
     mMimeInfo->GetPreferredApplicationHandler(getter_AddRefs(prefApp));
     if (action != nsIMIMEInfo::useHelperApp || !prefApp) {
       nsCOMPtr<nsIFile> fileToTest;
       GetTargetFile(getter_AddRefs(fileToTest));
       if (fileToTest) {
         bool isExecutable;
         rv = fileToTest->IsExecutable(&isExecutable);
         if (NS_FAILED(rv) || isExecutable) {  // checking NS_FAILED, because paranoia is good
           action = nsIMIMEInfo::saveToDisk;
         }
       } else {   // Paranoia is good here too, though this really should not happen
         NS_WARNING("GetDownloadInfo returned a null file after the temp file has been set up! ");
         action = nsIMIMEInfo::saveToDisk;
       }
     }
 #endif
     if (action == nsIMIMEInfo::useHelperApp ||
         action == nsIMIMEInfo::useSystemDefault)
     {
         rv = LaunchWithApplication(nullptr, false);
     }
     else // Various unknown actions go here too
     {
         rv = SaveToDisk(nullptr, false);
     }
   }
   return NS_OK;
 }
 // Convert error info into proper message text and send OnStatusChange
 // notification to the dialog progress listener or nsITransfer implementation.
 void nsExternalAppHandler::SendStatusChange(ErrorType type, nsresult rv, nsIRequest *aRequest, const nsAFlatString &path)
 {
     nsAutoString msgId;
     switch(rv)
     {
     case NS_ERROR_OUT_OF_MEMORY:
         // No memory
         msgId.AssignLiteral("noMemory");
         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:
         if (type == kWriteError) {
           // Attempt to write without sufficient permissions.
 #if defined(ANDROID)
           // On Android (and Gonk), this means the SD card is present but
           // unavailable (read-only).
           msgId.AssignLiteral("SDAccessErrorCardReadOnly");
 #else
           msgId.AssignLiteral("accessError");
 #endif
         }
         else
         {
           msgId.AssignLiteral("launchError");
         }
         break;
     case NS_ERROR_FILE_NOT_FOUND:
     case NS_ERROR_FILE_TARGET_DOES_NOT_EXIST:
     case NS_ERROR_FILE_UNRECOGNIZED_PATH:
         // Helper app not found, let's verify this happened on launch
         if (type == kLaunchError) {
           msgId.AssignLiteral("helperAppNotFound");
           break;
         }
 #if defined(ANDROID)
         else if (type == kWriteError) {
           // On Android (and Gonk), this means the SD card is missing (not in
           // SD slot).
           msgId.AssignLiteral("SDAccessErrorCardMissing");
           break;
         }
 #endif
         // fall through
     default:
         // Generic read/write/launch error message.
         switch(type)
         {
         case kReadError:
           msgId.AssignLiteral("readError");
           break;
         case kWriteError:
           msgId.AssignLiteral("writeError");
           break;
         case kLaunchError:
           msgId.AssignLiteral("launchError");
           break;
         }
         break;
     }
     PR_LOG(nsExternalHelperAppService::mLog, PR_LOG_ERROR,
         ("Error: %s, type=%i, listener=0x%p, transfer=0x%p, rv=0x%08X\n",
          NS_LossyConvertUTF16toASCII(msgId).get(), type, mDialogProgressListener.get(), mTransfer.get(), rv));
     PR_LOG(nsExternalHelperAppService::mLog, PR_LOG_ERROR,
         ("       path='%s'\n", NS_ConvertUTF16toUTF8(path).get()));
     // Get properties file bundle and extract status string.
     nsCOMPtr<nsIStringBundleService> stringService =
         mozilla::services::GetStringBundleService();
     if (stringService)
     {
         nsCOMPtr<nsIStringBundle> bundle;
         if (NS_SUCCEEDED(stringService->CreateBundle("chrome://global/locale/nsWebBrowserPersist.properties", getter_AddRefs(bundle))))
         {
             nsXPIDLString msgText;
             const char16_t *strings[] = { path.get() };
             if(NS_SUCCEEDED(bundle->FormatStringFromName(msgId.get(), strings, 1, getter_Copies(msgText))))
             {
               if (mDialogProgressListener)
               {
                 // We have a listener, let it handle the error.
                 mDialogProgressListener->OnStatusChange(nullptr, (type == kReadError) ? aRequest : nullptr, rv, msgText);
               } else if (mTransfer) {
                 mTransfer->OnStatusChange(nullptr, (type == kReadError) ? aRequest : nullptr, rv, msgText);
               }
               else
               if (XRE_GetProcessType() == GeckoProcessType_Default) {
                 // We don't have a listener.  Simply show the alert ourselves.
                 nsresult qiRv;
                 nsCOMPtr<nsIPrompt> prompter(do_GetInterface(mWindowContext, &qiRv));
                 nsXPIDLString title;
                 bundle->FormatStringFromName(MOZ_UTF16("title"),
                                              strings,
 ,
                                              getter_Copies(title));
                 PR_LOG(nsExternalHelperAppService::mLog, PR_LOG_DEBUG,
                        ("mWindowContext=0x%p, prompter=0x%p, qi rv=0x%08X, title='%s', msg='%s'",
                        mWindowContext.get(),
                        prompter.get(),
                        qiRv,
                        NS_ConvertUTF16toUTF8(title).get(),
                        NS_ConvertUTF16toUTF8(msgText).get()));
                 // If we didn't have a prompter we will try and get a window
                 // instead, get it's docshell and use it to alert the user.
                 if (!prompter)
                 {
                   nsCOMPtr<nsPIDOMWindow> window(do_GetInterface(mWindowContext));
                   if (!window || !window->GetDocShell())
                   {
                     return;
                   }
                   prompter = do_GetInterface(window->GetDocShell(), &qiRv);
                   PR_LOG(nsExternalHelperAppService::mLog, PR_LOG_DEBUG,
                          ("No prompter from mWindowContext, using DocShell, " \
                           "window=0x%p, docShell=0x%p, " \
                           "prompter=0x%p, qi rv=0x%08X",
                           window.get(),
                           window->GetDocShell(),
                           prompter.get(),
                           qiRv));
                   // If we still don't have a prompter, there's nothing else we
                   // can do so just return.
                   if (!prompter)
                   {
                     PR_LOG(nsExternalHelperAppService::mLog, PR_LOG_ERROR,
                            ("No prompter from DocShell, no way to alert user"));
                     return;
                   }
                 }
                 // We should always have a prompter at this point.
                 prompter->Alert(title, msgText);
               }
             }
         }
     }
 }
 NS_IMETHODIMP
 nsExternalAppHandler::OnDataAvailable(nsIRequest *request, nsISupports * aCtxt,
                                       nsIInputStream * inStr,
                                       uint64_t sourceOffset, uint32_t count)
 {
   nsresult rv = NS_OK;
   // first, check to see if we've been canceled....
   if (mCanceled || !mSaver) // then go cancel our underlying channel too
     return request->Cancel(NS_BINDING_ABORTED);
   // read the data out of the stream and write it to the temp file.
   if (count > 0)
   {
     mProgress += count;
     nsCOMPtr<nsIStreamListener> saver = do_QueryInterface(mSaver);
     rv = saver->OnDataAvailable(request, aCtxt, inStr, sourceOffset, count);
     if (NS_SUCCEEDED(rv))
     {
       // Send progress notification.
       if (mTransfer) {
         mTransfer->OnProgressChange64(nullptr, request, mProgress,
                                       mContentLength, mProgress,
                                       mContentLength);
       }
     }
     else
     {
       // An error occurred, notify listener.
       nsAutoString tempFilePath;
       if (mTempFile)
         mTempFile->GetPath(tempFilePath);
       SendStatusChange(kReadError, rv, request, tempFilePath);
       // Cancel the download.
       Cancel(rv);
     }
   }
   return rv;
 }
 NS_IMETHODIMP nsExternalAppHandler::OnStopRequest(nsIRequest *request, nsISupports *aCtxt,
                                                   nsresult aStatus)
 {
   LOG(("nsExternalAppHandler::OnStopRequest\n"
        "  mCanceled=%d, mTransfer=0x%p, aStatus=0x%08X\n",
        mCanceled, mTransfer.get(), aStatus));
   mStopRequestIssued = true;
   // Cancel if the request did not complete successfully.
   if (!mCanceled && NS_FAILED(aStatus))
   {
     // Send error notification.
     nsAutoString tempFilePath;
     if (mTempFile)
       mTempFile->GetPath(tempFilePath);
     SendStatusChange( kReadError, aStatus, request, tempFilePath );
     Cancel(aStatus);
   }
   // first, check to see if we've been canceled....
   if (mCanceled || !mSaver)
     return NS_OK;
   return mSaver->Finish(NS_OK);
 }
 NS_IMETHODIMP
 nsExternalAppHandler::OnTargetChange(nsIBackgroundFileSaver *aSaver,
                                      nsIFile *aTarget)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsExternalAppHandler::OnSaveComplete(nsIBackgroundFileSaver *aSaver,
                                      nsresult aStatus)
 {
   LOG(("nsExternalAppHandler::OnSaveComplete\n"
        "  aSaver=0x%p, aStatus=0x%08X, mCanceled=%d, mTransfer=0x%p\n",
        aSaver, aStatus, mCanceled, mTransfer.get()));
   if (!mCanceled) {
     // Save the hash
     (void)mSaver->GetSha256Hash(mHash);
     (void)mSaver->GetSignatureInfo(getter_AddRefs(mSignatureInfo));
     // Free the reference that the saver keeps on us, even if we couldn't get
     // the hash.
     mSaver = nullptr;
     if (NS_FAILED(aStatus)) {
       nsAutoString path;
       mTempFile->GetPath(path);
       // It may happen when e10s is enabled that there will be no transfer
       // object available to communicate status as expected by the system.
       // Let's try and create a temporary transfer object to take care of this
       // for us, we'll fall back to using the prompt service if we absolutely
       // have to.
       if (!mTransfer) {
         nsCOMPtr<nsIChannel> channel = do_QueryInterface(mRequest);
         // We don't care if this fails.
         CreateFailedTransfer(channel && NS_UsePrivateBrowsing(channel));
       }
       SendStatusChange(kWriteError, aStatus, nullptr, path);
       if (!mCanceled)
         Cancel(aStatus);
       return NS_OK;
     }
   }
   // Notify the transfer object that we are done if the user has chosen an
   // action. If the user hasn't chosen an action, the progress listener
   // (nsITransfer) will be notified in CreateTransfer.
   if (mTransfer) {
     NotifyTransfer(aStatus);
   }
   return NS_OK;
 }
 void nsExternalAppHandler::NotifyTransfer(nsresult aStatus)
 {
   MOZ_ASSERT(NS_IsMainThread(), "Must notify on main thread");
   MOZ_ASSERT(mTransfer, "We must have an nsITransfer");
   LOG(("Notifying progress listener"));
   if (NS_SUCCEEDED(aStatus)) {
     (void)mTransfer->SetSha256Hash(mHash);
     (void)mTransfer->SetSignatureInfo(mSignatureInfo);
     (void)mTransfer->OnProgressChange64(nullptr, nullptr, mProgress,
       mContentLength, mProgress, mContentLength);
   }
   (void)mTransfer->OnStateChange(nullptr, nullptr,
     nsIWebProgressListener::STATE_STOP |
     nsIWebProgressListener::STATE_IS_REQUEST |
     nsIWebProgressListener::STATE_IS_NETWORK, aStatus);
   // This nsITransfer object holds a reference to us (we are its observer), so
   // we need to release the reference to break a reference cycle (and therefore
   // to prevent leaking).  We do this even if the previous calls failed.
   mTransfer = nullptr;
 }
 NS_IMETHODIMP nsExternalAppHandler::GetMIMEInfo(nsIMIMEInfo ** aMIMEInfo)
 {
   *aMIMEInfo = mMimeInfo;
   NS_ADDREF(*aMIMEInfo);
   return NS_OK;
 }
 NS_IMETHODIMP nsExternalAppHandler::GetSource(nsIURI ** aSourceURI)
 {
   NS_ENSURE_ARG(aSourceURI);
   *aSourceURI = mSourceUrl;
   NS_IF_ADDREF(*aSourceURI);
   return NS_OK;
 }
 NS_IMETHODIMP nsExternalAppHandler::GetSuggestedFileName(nsAString& aSuggestedFileName)
 {
   aSuggestedFileName = mSuggestedFileName;
   return NS_OK;
 }
 nsresult nsExternalAppHandler::CreateTransfer()
 {
   LOG(("nsExternalAppHandler::CreateTransfer"));
   MOZ_ASSERT(NS_IsMainThread(), "Must create transfer on main thread");
   // We are back from the helper app dialog (where the user chooses to save or
   // open), but we aren't done processing the load. in this case, throw up a
   // progress dialog so the user can see what's going on.
   // Also, release our reference to mDialog. We don't need it anymore, and we
   // need to break the reference cycle.
   mDialog = nullptr;
   if (!mDialogProgressListener) {
     NS_WARNING("The dialog should nullify the dialog progress listener");
   }
   nsresult rv;
   // We must be able to create an nsITransfer object. If not, it doesn't matter
   // much that we can't launch the helper application or save to disk. Work on
   // a local copy rather than mTransfer until we know we succeeded, to make it
   // clearer that this function is re-entrant.
   nsCOMPtr<nsITransfer> transfer = do_CreateInstance(
     NS_TRANSFER_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   // Initialize the download
   nsCOMPtr<nsIURI> target;
   rv = NS_NewFileURI(getter_AddRefs(target), mFinalFileDestination);
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIChannel> channel = do_QueryInterface(mRequest);
   rv = transfer->Init(mSourceUrl, target, EmptyString(),
                        mMimeInfo, mTimeDownloadStarted, mTempFile, this,
                        channel && NS_UsePrivateBrowsing(channel));
   NS_ENSURE_SUCCESS(rv, rv);
   // Now let's add the download to history
   nsCOMPtr<nsIDownloadHistory> dh(do_GetService(NS_DOWNLOADHISTORY_CONTRACTID));
   if (dh) {
     nsCOMPtr<nsIURI> referrer;
     nsCOMPtr<nsIChannel> channel = do_QueryInterface(mRequest);
     if (channel) {
       NS_GetReferrerFromChannel(channel, getter_AddRefs(referrer));
     }
     if (channel && !NS_UsePrivateBrowsing(channel)) {
       dh->AddDownload(mSourceUrl, referrer, mTimeDownloadStarted, target);
     }
   }
   // If we were cancelled since creating the transfer, just return. It is
   // always ok to return NS_OK if we are cancelled. Callers of this function
   // must call Cancel if CreateTransfer fails, but there's no need to cancel
   // twice.
   if (mCanceled) {
     return NS_OK;
   }
   rv = transfer->OnStateChange(nullptr, mRequest,
     nsIWebProgressListener::STATE_START |
     nsIWebProgressListener::STATE_IS_REQUEST |
     nsIWebProgressListener::STATE_IS_NETWORK, NS_OK);
   NS_ENSURE_SUCCESS(rv, rv);
   if (mCanceled) {
     return NS_OK;
   }
   mRequest = nullptr;
   // Finally, save the transfer to mTransfer.
   mTransfer = transfer;
   transfer = nullptr;
   // While we were bringing up the progress dialog, we actually finished
   // processing the url. If that's the case then mStopRequestIssued will be
   // true and OnSaveComplete has been called.
   if (mStopRequestIssued && !mSaver && mTransfer) {
     NotifyTransfer(NS_OK);
   }
   return rv;
 }
 nsresult nsExternalAppHandler::CreateFailedTransfer(bool aIsPrivateBrowsing)
 {
   nsresult rv;
   nsCOMPtr<nsITransfer> transfer =
     do_CreateInstance(NS_TRANSFER_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   // If we don't have a download directory we're kinda screwed but it's OK
   // we'll still report the error via the prompter.
   nsCOMPtr<nsIFile> pseudoFile;
   rv = GetDownloadDirectory(getter_AddRefs(pseudoFile), true);
   NS_ENSURE_SUCCESS(rv, rv);
   // Append the default suggested filename. If the user restarts the transfer
   // we will re-trigger a filename check anyway to ensure that it is unique.
   rv = pseudoFile->Append(mSuggestedFileName);
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIURI> pseudoTarget;
   rv = NS_NewFileURI(getter_AddRefs(pseudoTarget), pseudoFile);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = transfer->Init(mSourceUrl, pseudoTarget, EmptyString(),
                       mMimeInfo, mTimeDownloadStarted, nullptr, this,
                       aIsPrivateBrowsing);
   NS_ENSURE_SUCCESS(rv, rv);
   // Our failed transfer is ready.
   mTransfer = transfer.forget();
   return NS_OK;
 }
 nsresult nsExternalAppHandler::SaveDestinationAvailable(nsIFile * aFile)
 {
   if (aFile)
     ContinueSave(aFile);
   else
     Cancel(NS_BINDING_ABORTED);
   return NS_OK;
 }
 void nsExternalAppHandler::RequestSaveDestination(const nsAFlatString &aDefaultFile, const nsAFlatString &aFileExtension)
 {
   // invoke the dialog!!!!! use mWindowContext as the window context parameter for the dialog request
   // Convert to use file picker? No, then embeddors could not do any sort of
   // "AutoDownload" w/o showing a prompt
   nsresult rv = NS_OK;
   if (!mDialog)
   {
     // Get helper app launcher dialog.
     mDialog = do_CreateInstance( NS_HELPERAPPLAUNCHERDLG_CONTRACTID, &rv );
     if (rv != NS_OK) {
       Cancel(NS_BINDING_ABORTED);
       return;
     }
   }
   // we want to explicitly unescape aDefaultFile b4 passing into the dialog. we can't unescape
   // it because the dialog is implemented by a JS component which doesn't have a window so no unescape routine is defined...
   // Now, be sure to keep |this| alive, and the dialog
   // If we don't do this, users that close the helper app dialog while the file
   // picker is up would cause Cancel() to be called, and the dialog would be
   // released, which would release this object too, which would crash.
   // See Bug 249143
   nsIFile* fileToUse;
   nsRefPtr<nsExternalAppHandler> kungFuDeathGrip(this);
   nsCOMPtr<nsIHelperAppLauncherDialog> dlg(mDialog);
   rv = mDialog->PromptForSaveToFile(this,
                                     mWindowContext,
                                     aDefaultFile.get(),
                                     aFileExtension.get(),
                                     mForceSave, &fileToUse);
   if (rv == NS_ERROR_NOT_AVAILABLE) {
     // we need to use the async version -> nsIHelperAppLauncherDialog.promptForSaveToFileAsync.
     rv = mDialog->PromptForSaveToFileAsync(this,
                                            mWindowContext,
                                            aDefaultFile.get(),
                                            aFileExtension.get(),
                                            mForceSave);
   } else {
     SaveDestinationAvailable(rv == NS_OK ? fileToUse : nullptr);
   }
 }
 // SaveToDisk should only be called by the helper app dialog which allows
 // the user to say launch with application or save to disk. It doesn't actually
 // perform the save, it just prompts for the destination file name.
 NS_IMETHODIMP nsExternalAppHandler::SaveToDisk(nsIFile * aNewFileLocation, bool aRememberThisPreference)
 {
   if (mCanceled)
     return NS_OK;
   mMimeInfo->SetPreferredAction(nsIMIMEInfo::saveToDisk);
   if (!aNewFileLocation) {
     if (mSuggestedFileName.IsEmpty())
       RequestSaveDestination(mTempLeafName, mTempFileExtension);
     else
     {
       nsAutoString fileExt;
       int32_t pos = mSuggestedFileName.RFindChar('.');
       if (pos >= 0)
         mSuggestedFileName.Right(fileExt, mSuggestedFileName.Length() - pos);
       if (fileExt.IsEmpty())
         fileExt = mTempFileExtension;
       RequestSaveDestination(mSuggestedFileName, fileExt);
     }
   } else {
     ContinueSave(aNewFileLocation);
   }
   return NS_OK;
 }
 nsresult nsExternalAppHandler::ContinueSave(nsIFile * aNewFileLocation)
 {
   if (mCanceled)
     return NS_OK;
   NS_PRECONDITION(aNewFileLocation, "Must be called with a non-null file");
   nsresult rv = NS_OK;
   nsCOMPtr<nsIFile> fileToUse = do_QueryInterface(aNewFileLocation);
   mFinalFileDestination = do_QueryInterface(fileToUse);
   // Move what we have in the final directory, but append .part
   // to it, to indicate that it's unfinished.  Do not call SetTarget on the
   // saver if we are done (Finish has been called) but OnSaverComplete has not
   // been called.
   if (mFinalFileDestination && mSaver && !mStopRequestIssued)
   {
     nsCOMPtr<nsIFile> movedFile;
     mFinalFileDestination->Clone(getter_AddRefs(movedFile));
     if (movedFile) {
       // Get the old leaf name and append .part to it
       nsAutoString name;
       mFinalFileDestination->GetLeafName(name);
       name.AppendLiteral(".part");
       movedFile->SetLeafName(name);
       rv = mSaver->SetTarget(movedFile, true);
       if (NS_FAILED(rv)) {
         nsAutoString path;
         mTempFile->GetPath(path);
         SendStatusChange(kWriteError, rv, nullptr, path);
         Cancel(rv);
         return NS_OK;
       }
       mTempFile = movedFile;
     }
   }
   // The helper app dialog has told us what to do and we have a final file
   // destination.
   rv = CreateTransfer();
   // If we fail to create the transfer, Cancel.
   if (NS_FAILED(rv)) {
     Cancel(rv);
     return rv;
   }
   // now that the user has chosen the file location to save to, it's okay to fire the refresh tag
   // if there is one. We don't want to do this before the save as dialog goes away because this dialog
   // is modal and we do bad things if you try to load a web page in the underlying window while a modal
   // dialog is still up.
   ProcessAnyRefreshTags();
   return NS_OK;
 }
 // LaunchWithApplication should only be called by the helper app dialog which
 // allows the user to say launch with application or save to disk. It doesn't
 // actually perform launch with application.
 NS_IMETHODIMP nsExternalAppHandler::LaunchWithApplication(nsIFile * aApplication, bool aRememberThisPreference)
 {
   if (mCanceled)
     return NS_OK;
   // user has chosen to launch using an application, fire any refresh tags now...
   ProcessAnyRefreshTags();
   if (mMimeInfo && aApplication) {
     PlatformLocalHandlerApp_t *handlerApp =
       new PlatformLocalHandlerApp_t(EmptyString(), aApplication);
     mMimeInfo->SetPreferredApplicationHandler(handlerApp);
   }
   // Now check if the file is local, in which case we won't bother with saving
   // it to a temporary directory and just launch it from where it is
   nsCOMPtr<nsIFileURL> fileUrl(do_QueryInterface(mSourceUrl));
   if (fileUrl && mIsFileChannel)
   {
     Cancel(NS_BINDING_ABORTED);
     nsCOMPtr<nsIFile> file;
     nsresult rv = fileUrl->GetFile(getter_AddRefs(file));
     if (NS_SUCCEEDED(rv))
     {
       rv = mMimeInfo->LaunchWithFile(file);
       if (NS_SUCCEEDED(rv))
         return NS_OK;
     }
     nsAutoString path;
     if (file)
       file->GetPath(path);
     // If we get here, an error happened
     SendStatusChange(kLaunchError, rv, nullptr, path);
     return rv;
   }
   // Now that the user has elected to launch the downloaded file with a helper
   // app, we're justified in removing the 'salted' name.  We'll rename to what
   // was specified in mSuggestedFileName after the download is done prior to
   // launching the helper app.  So that any existing file of that name won't be
   // overwritten we call CreateUnique().  Also note that we use the same
   // directory as originally downloaded so nsDownload can rename in place
   // later.
   nsCOMPtr<nsIFile> fileToUse;
   (void) GetDownloadDirectory(getter_AddRefs(fileToUse));
   if (mSuggestedFileName.IsEmpty())
   {
     // Keep using the leafname of the temp file, since we're just starting a helper
     mSuggestedFileName = mTempLeafName;
   }
 #ifdef XP_WIN
   fileToUse->Append(mSuggestedFileName + mTempFileExtension);
 #else
   fileToUse->Append(mSuggestedFileName);
 #endif
   nsresult rv = fileToUse->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0644);
   if(NS_SUCCEEDED(rv))
   {
     mFinalFileDestination = do_QueryInterface(fileToUse);
     // launch the progress window now that the user has picked the desired action.
     rv = CreateTransfer();
     if (NS_FAILED(rv)) {
       Cancel(rv);
     }
   }
   else
   {
     // Cancel the download and report an error.  We do not want to end up in
     // a state where it appears that we have a normal download that is
     // pointing to a file that we did not actually create.
     nsAutoString path;
     mTempFile->GetPath(path);
     SendStatusChange(kWriteError, rv, nullptr, path);
     Cancel(rv);
   }
   return rv;
 }
 NS_IMETHODIMP nsExternalAppHandler::Cancel(nsresult aReason)
 {
   NS_ENSURE_ARG(NS_FAILED(aReason));
   if (mCanceled) {
     return NS_OK;
   }
   mCanceled = true;
   if (mSaver) {
     // We are still writing to the target file.  Give the saver a chance to
     // close the target file, then notify the transfer object if necessary in
     // the OnSaveComplete callback.
     mSaver->Finish(aReason);
     mSaver = nullptr;
   } else {
     if (mStopRequestIssued && mTempFile) {
       // This branch can only happen when the user cancels the helper app dialog
       // when the request has completed. The temp file has to be removed here,
       // because mSaver has been released at that time with the temp file left.
       (void)mTempFile->Remove(false);
     }
     // Notify the transfer object that the download has been canceled, if the
     // user has already chosen an action and we didn't notify already.
     if (mTransfer) {
       NotifyTransfer(aReason);
     }
   }
   // Break our reference cycle with the helper app dialog (set up in
   // OnStartRequest)
   mDialog = nullptr;
   mRequest = nullptr;
   // Release the listener, to break the reference cycle with it (we are the
   // observer of the listener).
   mDialogProgressListener = nullptr;
   return NS_OK;
 }
 void nsExternalAppHandler::ProcessAnyRefreshTags()
 {
    // one last thing, try to see if the original window context supports a refresh interface...
    // Sometimes, when you download content that requires an external handler, there is
    // a refresh header associated with the download. This refresh header points to a page
    // the content provider wants the user to see after they download the content. How do we
    // pass this refresh information back to the caller? For now, try to get the refresh URI
    // interface. If the window context where the request originated came from supports this
    // then we can force it to process the refresh information (if there is any) from this channel.
    if (mWindowContext && mOriginalChannel)
    {
      nsCOMPtr<nsIRefreshURI> refreshHandler (do_GetInterface(mWindowContext));
      if (refreshHandler) {
         refreshHandler->SetupRefreshURI(mOriginalChannel);
      }
      mOriginalChannel = nullptr;
    }
 }
 bool nsExternalAppHandler::GetNeverAskFlagFromPref(const char * prefName, const char * aContentType)
 {
   // Search the obsolete pref strings.
   nsAdoptingCString prefCString = Preferences::GetCString(prefName);
   if (prefCString.IsEmpty()) {
     // Default is true, if not found in the pref string.
     return true;
   }
   NS_UnescapeURL(prefCString);
   nsACString::const_iterator start, end;
   prefCString.BeginReading(start);
   prefCString.EndReading(end);
   return !CaseInsensitiveFindInReadable(nsDependentCString(aContentType),
                                         start, end);
 }
 nsresult nsExternalAppHandler::MaybeCloseWindow()
 {
   nsCOMPtr<nsIDOMWindow> window = do_GetInterface(mWindowContext);
   NS_ENSURE_STATE(window);
   if (mShouldCloseWindow) {
     // Reset the window context to the opener window so that the dependent
     // dialogs have a parent
     nsCOMPtr<nsIDOMWindow> opener;
     window->GetOpener(getter_AddRefs(opener));
     bool isClosed;
     if (opener && NS_SUCCEEDED(opener->GetClosed(&isClosed)) && !isClosed) {
       mWindowContext = do_GetInterface(opener);
       // Now close the old window.  Do it on a timer so that we don't run
       // into issues trying to close the window before it has fully opened.
       NS_ASSERTION(!mTimer, "mTimer was already initialized once!");
       mTimer = do_CreateInstance("@mozilla.org/timer;1");
       if (!mTimer) {
         return NS_ERROR_FAILURE;
       }
       mTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT);
       mWindowToClose = window;
     }
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsExternalAppHandler::Notify(nsITimer* timer)
 {
   NS_ASSERTION(mWindowToClose, "No window to close after timer fired");
   mWindowToClose->Close();
   mWindowToClose = nullptr;
   mTimer = nullptr;
   return NS_OK;
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // The following section contains our nsIMIMEService implementation and related methods.
 //
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // nsIMIMEService methods
 NS_IMETHODIMP nsExternalHelperAppService::GetFromTypeAndExtension(const nsACString& aMIMEType, const nsACString& aFileExt, nsIMIMEInfo **_retval)
 {
   NS_PRECONDITION(!aMIMEType.IsEmpty() ||
                   !aFileExt.IsEmpty(),
                   "Give me something to work with");
   LOG(("Getting mimeinfo from type '%s' ext '%s'\n",
         PromiseFlatCString(aMIMEType).get(), PromiseFlatCString(aFileExt).get()));
   *_retval = nullptr;
   // OK... we need a type. Get one.
   nsAutoCString typeToUse(aMIMEType);
   if (typeToUse.IsEmpty()) {
     nsresult rv = GetTypeFromExtension(aFileExt, typeToUse);
     if (NS_FAILED(rv))
       return NS_ERROR_NOT_AVAILABLE;
   }
   // We promise to only send lower case mime types to the OS
   ToLowerCase(typeToUse);
   // (1) Ask the OS for a mime info
   bool found;
   *_retval = GetMIMEInfoFromOS(typeToUse, aFileExt, &found).take();
   LOG(("OS gave back 0x%p - found: %i\n", *_retval, found));
   // If we got no mimeinfo, something went wrong. Probably lack of memory.
   if (!*_retval)
     return NS_ERROR_OUT_OF_MEMORY;
   // (2) Now, let's see if we can find something in our datastore
   // This will not overwrite the OS information that interests us
   // (i.e. default application, default app. description)
   nsresult rv;
   nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);
   if (handlerSvc) {
     bool hasHandler = false;
     (void) handlerSvc->Exists(*_retval, &hasHandler);
     if (hasHandler) {
       rv = handlerSvc->FillHandlerInfo(*_retval, EmptyCString());
       LOG(("Data source: Via type: retval 0x%08x\n", rv));
     } else {
       rv = NS_ERROR_NOT_AVAILABLE;
     }
     found = found || NS_SUCCEEDED(rv);
     if (!found || NS_FAILED(rv)) {
       // No type match, try extension match
       if (!aFileExt.IsEmpty()) {
         nsAutoCString overrideType;
         rv = handlerSvc->GetTypeFromExtension(aFileExt, overrideType);
         if (NS_SUCCEEDED(rv) && !overrideType.IsEmpty()) {
           // We can't check handlerSvc->Exists() here, because we have a
           // overideType. That's ok, it just results in some console noise.
           // (If there's no handler for the override type, it throws)
           rv = handlerSvc->FillHandlerInfo(*_retval, overrideType);
           LOG(("Data source: Via ext: retval 0x%08x\n", rv));
           found = found || NS_SUCCEEDED(rv);
         }
       }
     }
   }
   // (3) No match yet. Ask extras.
   if (!found) {
     rv = NS_ERROR_FAILURE;
 #ifdef XP_WIN
     /* XXX Gross hack to wallpaper over the most common Win32
      * extension issues caused by the fix for bug 116938.  See bug
      * 120327, comment 271 for why this is needed.  Not even sure we
      * want to remove this once we have fixed all this stuff to work
      * right; any info we get from extras on this type is pretty much
      * useless....
      */
     if (!typeToUse.Equals(APPLICATION_OCTET_STREAM, nsCaseInsensitiveCStringComparator()))
 #endif
       rv = FillMIMEInfoForMimeTypeFromExtras(typeToUse, *_retval);
     LOG(("Searched extras (by type), rv 0x%08X\n", rv));
     // If that didn't work out, try file extension from extras
     if (NS_FAILED(rv) && !aFileExt.IsEmpty()) {
       rv = FillMIMEInfoForExtensionFromExtras(aFileExt, *_retval);
       LOG(("Searched extras (by ext), rv 0x%08X\n", rv));
     }
     // If that still didn't work, set the file description to "ext File"
     if (NS_FAILED(rv) && !aFileExt.IsEmpty()) {
       // XXXzpao This should probably be localized
       nsAutoCString desc(aFileExt);
       desc.Append(" File");
       (*_retval)->SetDescription(NS_ConvertASCIItoUTF16(desc));
       LOG(("Falling back to 'File' file description\n"));
     }
   }
   // Finally, check if we got a file extension and if yes, if it is an
   // extension on the mimeinfo, in which case we want it to be the primary one
   if (!aFileExt.IsEmpty()) {
     bool matches = false;
     (*_retval)->ExtensionExists(aFileExt, &matches);
     LOG(("Extension '%s' matches mime info: %i\n", PromiseFlatCString(aFileExt).get(), matches));
     if (matches)
       (*_retval)->SetPrimaryExtension(aFileExt);
   }
 #ifdef PR_LOGGING
   if (LOG_ENABLED()) {
     nsAutoCString type;
     (*_retval)->GetMIMEType(type);
     nsAutoCString ext;
     (*_retval)->GetPrimaryExtension(ext);
     LOG(("MIME Info Summary: Type '%s', Primary Ext '%s'\n", type.get(), ext.get()));
   }
 #endif
   return NS_OK;
 }
 NS_IMETHODIMP nsExternalHelperAppService::GetTypeFromExtension(const nsACString& aFileExt, nsACString& aContentType)
 {
   // OK. We want to try the following sources of mimetype information, in this order:
   // 1. defaultMimeEntries array
   // 2. User-set preferences (managed by the handler service)
   // 3. OS-provided information
   // 4. our "extras" array
   // 5. Information from plugins
   // 6. The "ext-to-type-mapping" category
   // Early return if called with an empty extension parameter
   if (aFileExt.IsEmpty())
     return NS_ERROR_NOT_AVAILABLE;
   nsresult rv = NS_OK;
   // First of all, check our default entries
   for (size_t i = 0; i < ArrayLength(defaultMimeEntries); i++)
   {
     if (aFileExt.LowerCaseEqualsASCII(defaultMimeEntries[i].mFileExtension)) {
       aContentType = defaultMimeEntries[i].mMimeType;
       return rv;
     }
   }
   // Check user-set prefs
   nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);
   if (handlerSvc)
     rv = handlerSvc->GetTypeFromExtension(aFileExt, aContentType);
   if (NS_SUCCEEDED(rv) && !aContentType.IsEmpty())
     return NS_OK;
   // Ask OS.
   bool found = false;
   nsCOMPtr<nsIMIMEInfo> mi = GetMIMEInfoFromOS(EmptyCString(), aFileExt, &found);
   if (mi && found)
     return mi->GetMIMEType(aContentType);
   // Check extras array.
   found = GetTypeFromExtras(aFileExt, aContentType);
   if (found)
     return NS_OK;
   const nsCString& flatExt = PromiseFlatCString(aFileExt);
   // Try the plugins
   const char* mimeType;
   nsCOMPtr<nsIPluginHost> pluginHostCOM(do_GetService(MOZ_PLUGIN_HOST_CONTRACTID, &rv));
   nsPluginHost* pluginHost = static_cast<nsPluginHost*>(pluginHostCOM.get());
   if (NS_SUCCEEDED(rv)) {
     if (NS_SUCCEEDED(pluginHost->IsPluginEnabledForExtension(flatExt.get(), mimeType))) {
       aContentType = mimeType;
       return NS_OK;
     }
   }
   rv = NS_OK;
   // Let's see if an extension added something
   nsCOMPtr<nsICategoryManager> catMan(do_GetService("@mozilla.org/categorymanager;1"));
   if (catMan) {
     // The extension in the category entry is always stored as lowercase
     nsAutoCString lowercaseFileExt(aFileExt);
     ToLowerCase(lowercaseFileExt);
     // Read the MIME type from the category entry, if available
     nsXPIDLCString type;
     rv = catMan->GetCategoryEntry("ext-to-type-mapping", lowercaseFileExt.get(),
                                   getter_Copies(type));
     aContentType = type;
   }
   else {
     rv = NS_ERROR_NOT_AVAILABLE;
   }
   return rv;
 }
 NS_IMETHODIMP nsExternalHelperAppService::GetPrimaryExtension(const nsACString& aMIMEType, const nsACString& aFileExt, nsACString& _retval)
 {
   NS_ENSURE_ARG(!aMIMEType.IsEmpty());
   nsCOMPtr<nsIMIMEInfo> mi;
   nsresult rv = GetFromTypeAndExtension(aMIMEType, aFileExt, getter_AddRefs(mi));
   if (NS_FAILED(rv))
     return rv;
   return mi->GetPrimaryExtension(_retval);
 }
 NS_IMETHODIMP nsExternalHelperAppService::GetTypeFromURI(nsIURI *aURI, nsACString& aContentType)
 {
   NS_ENSURE_ARG_POINTER(aURI);
   nsresult rv = NS_ERROR_NOT_AVAILABLE;
   aContentType.Truncate();
   // First look for a file to use.  If we have one, we just use that.
   nsCOMPtr<nsIFileURL> fileUrl = do_QueryInterface(aURI);
   if (fileUrl) {
     nsCOMPtr<nsIFile> file;
     rv = fileUrl->GetFile(getter_AddRefs(file));
     if (NS_SUCCEEDED(rv)) {
       rv = GetTypeFromFile(file, aContentType);
       if (NS_SUCCEEDED(rv)) {
         // we got something!
         return rv;
       }
     }
   }
   // Now try to get an nsIURL so we don't have to do our own parsing
   nsCOMPtr<nsIURL> url = do_QueryInterface(aURI);
   if (url) {
     nsAutoCString ext;
     rv = url->GetFileExtension(ext);
     if (NS_FAILED(rv))
       return rv;
     if (ext.IsEmpty())
       return NS_ERROR_NOT_AVAILABLE;
     UnescapeFragment(ext, url, ext);
     return GetTypeFromExtension(ext, aContentType);
   }
   // no url, let's give the raw spec a shot
   nsAutoCString specStr;
   rv = aURI->GetSpec(specStr);
   if (NS_FAILED(rv))
     return rv;
   UnescapeFragment(specStr, aURI, specStr);
   // find the file extension (if any)
   int32_t extLoc = specStr.RFindChar('.');
   int32_t specLength = specStr.Length();
   if (-1 != extLoc &&
       extLoc != specLength - 1 &&
       // nothing over 20 chars long can be sanely considered an
       // extension.... Dat dere would be just data.
       specLength - extLoc < 20)
   {
     return GetTypeFromExtension(Substring(specStr, extLoc + 1), aContentType);
   }
   // We found no information; say so.
   return NS_ERROR_NOT_AVAILABLE;
 }
 NS_IMETHODIMP nsExternalHelperAppService::GetTypeFromFile(nsIFile* aFile, nsACString& aContentType)
 {
   NS_ENSURE_ARG_POINTER(aFile);
   nsresult rv;
   nsCOMPtr<nsIMIMEInfo> info;
   // Get the Extension
   nsAutoString fileName;
   rv = aFile->GetLeafName(fileName);
   if (NS_FAILED(rv)) return rv;
   nsAutoCString fileExt;
   if (!fileName.IsEmpty())
   {
     int32_t len = fileName.Length();
     for (int32_t i = len; i >= 0; i--)
     {
       if (fileName[i] == char16_t('.'))
       {
         CopyUTF16toUTF8(fileName.get() + i + 1, fileExt);
         break;
       }
     }
   }
   if (fileExt.IsEmpty())
     return NS_ERROR_FAILURE;
   return GetTypeFromExtension(fileExt, aContentType);
 }
 nsresult nsExternalHelperAppService::FillMIMEInfoForMimeTypeFromExtras(
   const nsACString& aContentType, nsIMIMEInfo * aMIMEInfo)
 {
   NS_ENSURE_ARG( aMIMEInfo );
   NS_ENSURE_ARG( !aContentType.IsEmpty() );
   // Look for default entry with matching mime type.
   nsAutoCString MIMEType(aContentType);
   ToLowerCase(MIMEType);
   int32_t numEntries = ArrayLength(extraMimeEntries);
   for (int32_t index = 0; index < numEntries; index++)
   {
       if ( MIMEType.Equals(extraMimeEntries[index].mMimeType) )
       {
           // This is the one. Set attributes appropriately.
           aMIMEInfo->SetFileExtensions(nsDependentCString(extraMimeEntries[index].mFileExtensions));
           aMIMEInfo->SetDescription(NS_ConvertASCIItoUTF16(extraMimeEntries[index].mDescription));
           return NS_OK;
       }
   }
   return NS_ERROR_NOT_AVAILABLE;
 }
 nsresult nsExternalHelperAppService::FillMIMEInfoForExtensionFromExtras(
   const nsACString& aExtension, nsIMIMEInfo * aMIMEInfo)
 {
   nsAutoCString type;
   bool found = GetTypeFromExtras(aExtension, type);
   if (!found)
     return NS_ERROR_NOT_AVAILABLE;
   return FillMIMEInfoForMimeTypeFromExtras(type, aMIMEInfo);
 }
 bool nsExternalHelperAppService::GetTypeFromExtras(const nsACString& aExtension, nsACString& aMIMEType)
 {
   NS_ASSERTION(!aExtension.IsEmpty(), "Empty aExtension parameter!");
   // Look for default entry with matching extension.
   nsDependentCString::const_iterator start, end, iter;
   int32_t numEntries = ArrayLength(extraMimeEntries);
   for (int32_t index = 0; index < numEntries; index++)
   {
       nsDependentCString extList(extraMimeEntries[index].mFileExtensions);
       extList.BeginReading(start);
       extList.EndReading(end);
       iter = start;
       while (start != end)
       {
           FindCharInReadable(',', iter, end);
           if (Substring(start, iter).Equals(aExtension,
                                             nsCaseInsensitiveCStringComparator()))
           {
               aMIMEType = extraMimeEntries[index].mMimeType;
               return true;
           }
           if (iter != end) {
             ++iter;
           }
           start = iter;
       }
   }
   return false;
 }

The Tor Browser / annotate

uriloader/exthandler/nsExternalHelperAppService.cpp@97036ab72558 (annotated)

uriloader/exthandler/nsExternalHelperAppService.cpp