Add m-esr52 at 52.6.0

1 files changed, 1273 insertions, 0 deletions

diff --git a/toolkit/components/jsdownloads/src/DownloadIntegration.jsm b/toolkit/components/jsdownloads/src/DownloadIntegration.jsm
new file mode 100644
index 000000000..5fed9212a
--- /dev/null
+++ b/toolkit/components/jsdownloads/src/DownloadIntegration.jsm
@@ -0,0 +1,1273 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80 filetype=javascript: */
+/* 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/. */
+
+/**
+ * Provides functions to integrate with the host application, handling for
+ * example the global prompts on shutdown.
+ */
+
+"use strict";
+
+this.EXPORTED_SYMBOLS = [
+  "DownloadIntegration",
+];
+
+////////////////////////////////////////////////////////////////////////////////
+//// Globals
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+const Cr = Components.results;
+
+Cu.import("resource://gre/modules/Integration.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "AsyncShutdown",
+                                  "resource://gre/modules/AsyncShutdown.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "DeferredTask",
+                                  "resource://gre/modules/DeferredTask.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Downloads",
+                                  "resource://gre/modules/Downloads.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "DownloadStore",
+                                  "resource://gre/modules/DownloadStore.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "DownloadImport",
+                                  "resource://gre/modules/DownloadImport.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "DownloadUIHelper",
+                                  "resource://gre/modules/DownloadUIHelper.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
+                                  "resource://gre/modules/FileUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+                                  "resource://gre/modules/NetUtil.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "OS",
+                                  "resource://gre/modules/osfile.jsm");
+#ifdef MOZ_PLACES
+XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils",
+                                  "resource://gre/modules/PlacesUtils.jsm");
+#endif
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+                                  "resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Services",
+                                  "resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+                                  "resource://gre/modules/Task.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+                                  "resource://gre/modules/NetUtil.jsm");
+
+XPCOMUtils.defineLazyServiceGetter(this, "gDownloadPlatform",
+                                   "@mozilla.org/toolkit/download-platform;1",
+                                   "mozIDownloadPlatform");
+XPCOMUtils.defineLazyServiceGetter(this, "gEnvironment",
+                                   "@mozilla.org/process/environment;1",
+                                   "nsIEnvironment");
+XPCOMUtils.defineLazyServiceGetter(this, "gMIMEService",
+                                   "@mozilla.org/mime;1",
+                                   "nsIMIMEService");
+XPCOMUtils.defineLazyServiceGetter(this, "gExternalProtocolService",
+                                   "@mozilla.org/uriloader/external-protocol-service;1",
+                                   "nsIExternalProtocolService");
+#ifdef MOZ_WIDGET_ANDROID
+XPCOMUtils.defineLazyModuleGetter(this, "RuntimePermissions",
+                                  "resource://gre/modules/RuntimePermissions.jsm");
+#endif
+
+XPCOMUtils.defineLazyGetter(this, "gParentalControlsService", function() {
+  if ("@mozilla.org/parental-controls-service;1" in Cc) {
+    return Cc["@mozilla.org/parental-controls-service;1"]
+      .createInstance(Ci.nsIParentalControlsService);
+  }
+  return null;
+});
+
+XPCOMUtils.defineLazyServiceGetter(this, "gApplicationReputationService",
+           "@mozilla.org/downloads/application-reputation-service;1",
+           Ci.nsIApplicationReputationService);
+
+XPCOMUtils.defineLazyServiceGetter(this, "volumeService",
+                                   "@mozilla.org/telephony/volume-service;1",
+                                   "nsIVolumeService");
+
+// We have to use the gCombinedDownloadIntegration identifier because, in this
+// module only, the DownloadIntegration identifier refers to the base version.
+Integration.downloads.defineModuleGetter(this, "gCombinedDownloadIntegration",
+            "resource://gre/modules/DownloadIntegration.jsm",
+            "DownloadIntegration");
+
+const Timer = Components.Constructor("@mozilla.org/timer;1", "nsITimer",
+                                     "initWithCallback");
+
+/**
+ * Indicates the delay between a change to the downloads data and the related
+ * save operation.
+ *
+ * For best efficiency, this value should be high enough that the input/output
+ * for opening or closing the target file does not overlap with the one for
+ * saving the list of downloads.
+ */
+const kSaveDelayMs = 1500;
+
+/**
+ * This pref indicates if we have already imported (or attempted to import)
+ * the downloads database from the previous SQLite storage.
+ */
+const kPrefImportedFromSqlite = "browser.download.importedFromSqlite";
+
+/**
+ * List of observers to listen against
+ */
+const kObserverTopics = [
+  "quit-application-requested",
+  "offline-requested",
+  "last-pb-context-exiting",
+  "last-pb-context-exited",
+  "sleep_notification",
+  "suspend_process_notification",
+  "wake_notification",
+  "resume_process_notification",
+  "network:offline-about-to-go-offline",
+  "network:offline-status-changed",
+  "xpcom-will-shutdown",
+];
+
+/**
+ * Maps nsIApplicationReputationService verdicts with the DownloadError ones.
+ */
+const kVerdictMap = {
+  [Ci.nsIApplicationReputationService.VERDICT_DANGEROUS]:
+                Downloads.Error.BLOCK_VERDICT_MALWARE,
+  [Ci.nsIApplicationReputationService.VERDICT_UNCOMMON]:
+                Downloads.Error.BLOCK_VERDICT_UNCOMMON,
+  [Ci.nsIApplicationReputationService.VERDICT_POTENTIALLY_UNWANTED]:
+                Downloads.Error.BLOCK_VERDICT_POTENTIALLY_UNWANTED,
+  [Ci.nsIApplicationReputationService.VERDICT_DANGEROUS_HOST]:
+                Downloads.Error.BLOCK_VERDICT_MALWARE,
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//// DownloadIntegration
+
+/**
+ * Provides functions to integrate with the host application, handling for
+ * example the global prompts on shutdown.
+ */
+this.DownloadIntegration = {
+  /**
+   * Main DownloadStore object for loading and saving the list of persistent
+   * downloads, or null if the download list was never requested and thus it
+   * doesn't need to be persisted.
+   */
+  _store: null,
+
+  /**
+   * Returns whether data for blocked downloads should be kept on disk.
+   * Implementations which support unblocking downloads may return true to
+   * keep the blocked download on disk until its fate is decided.
+   *
+   * If a download is blocked and the partial data is kept the Download's
+   * 'hasBlockedData' property will be true. In this state Download.unblock()
+   * or Download.confirmBlock() may be used to either unblock the download or
+   * remove the downloaded data respectively.
+   *
+   * Even if shouldKeepBlockedData returns true, if the download did not use a
+   * partFile the blocked data will be removed - preventing the complete
+   * download from existing on disk with its final filename.
+   *
+   * @return boolean True if data should be kept.
+   */
+  shouldKeepBlockedData() {
+    const FIREFOX_ID = "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}";
+    return Services.appinfo.ID == FIREFOX_ID;
+  },
+
+  /**
+   * Performs initialization of the list of persistent downloads, before its
+   * first use by the host application.  This function may be called only once
+   * during the entire lifetime of the application.
+   *
+   * @param list
+   *        DownloadList object to be initialized.
+   *
+   * @return {Promise}
+   * @resolves When the list has been initialized.
+   * @rejects JavaScript exception.
+   */
+  initializePublicDownloadList: Task.async(function* (list) {
+    try {
+      yield this.loadPublicDownloadListFromStore(list);
+    } catch (ex) {
+      Cu.reportError(ex);
+    }
+
+    // After the list of persistent downloads has been loaded, we can add the
+    // history observers, even if the load operation failed. This object is kept
+    // alive by the history service.
+    new DownloadHistoryObserver(list);
+  }),
+
+  /**
+   * Called by initializePublicDownloadList to load the list of persistent
+   * downloads, before its first use by the host application.  This function may
+   * be called only once during the entire lifetime of the application.
+   *
+   * @param list
+   *        DownloadList object to be populated with the download objects
+   *        serialized from the previous session.  This list will be persisted
+   *        to disk during the session lifetime.
+   *
+   * @return {Promise}
+   * @resolves When the list has been populated.
+   * @rejects JavaScript exception.
+   */
+  loadPublicDownloadListFromStore: Task.async(function* (list) {
+    if (this._store) {
+      throw new Error("Initialization may be performed only once.");
+    }
+
+    this._store = new DownloadStore(list, OS.Path.join(
+                                             OS.Constants.Path.profileDir,
+                                             "downloads.json"));
+    this._store.onsaveitem = this.shouldPersistDownload.bind(this);
+
+    try {
+      if (this._importedFromSqlite) {
+        yield this._store.load();
+      } else {
+        let sqliteDBpath = OS.Path.join(OS.Constants.Path.profileDir,
+                                        "downloads.sqlite");
+
+        if (yield OS.File.exists(sqliteDBpath)) {
+          let sqliteImport = new DownloadImport(list, sqliteDBpath);
+          yield sqliteImport.import();
+
+          let importCount = (yield list.getAll()).length;
+          if (importCount > 0) {
+            try {
+              yield this._store.save();
+            } catch (ex) { }
+          }
+
+          // No need to wait for the file removal.
+          OS.File.remove(sqliteDBpath).then(null, Cu.reportError);
+        }
+
+        Services.prefs.setBoolPref(kPrefImportedFromSqlite, true);
+
+        // Don't even report error here because this file is pre Firefox 3
+        // and most likely doesn't exist.
+        OS.File.remove(OS.Path.join(OS.Constants.Path.profileDir,
+                                    "downloads.rdf")).catch(() => {});
+
+      }
+    } catch (ex) {
+      Cu.reportError(ex);
+    }
+
+    // Add the view used for detecting changes to downloads to be persisted.
+    // We must do this after the list of persistent downloads has been loaded,
+    // even if the load operation failed. We wait for a complete initialization
+    // so other callers cannot modify the list without being detected. The
+    // DownloadAutoSaveView is kept alive by the underlying DownloadList.
+    yield new DownloadAutoSaveView(list, this._store).initialize();
+  }),
+
+  /**
+   * Determines if a Download object from the list of persistent downloads
+   * should be saved into a file, so that it can be restored across sessions.
+   *
+   * This function allows filtering out downloads that the host application is
+   * not interested in persisting across sessions, for example downloads that
+   * finished successfully.
+   *
+   * @param aDownload
+   *        The Download object to be inspected.  This is originally taken from
+   *        the global DownloadList object for downloads that were not started
+   *        from a private browsing window.  The item may have been removed
+   *        from the list since the save operation started, though in this case
+   *        the save operation will be repeated later.
+   *
+   * @return True to save the download, false otherwise.
+   */
+  shouldPersistDownload(aDownload) {
+    // On all platforms, we save all the downloads currently in progress, as
+    // well as stopped downloads for which we retained partially downloaded
+    // data or we have blocked data.
+    if (!aDownload.stopped || aDownload.hasPartialData ||
+        aDownload.hasBlockedData) {
+      return true;
+    }
+#ifdef MOZ_B2G
+    // On B2G we keep a few days of history.
+    let maxTime = Date.now() -
+      Services.prefs.getIntPref("dom.downloads.max_retention_days") * 24 * 60 * 60 * 1000;
+    return aDownload.startTime > maxTime;
+#elif defined(MOZ_WIDGET_ANDROID)
+    // On Android we store all history.
+    return true;
+#else
+    // On Desktop, stopped downloads for which we don't need to track the
+    // presence of a ".part" file are only retained in the browser history.
+    return false;
+#endif
+  },
+
+  /**
+   * Returns the system downloads directory asynchronously.
+   *
+   * @return {Promise}
+   * @resolves The downloads directory string path.
+   */
+  getSystemDownloadsDirectory: Task.async(function* () {
+    if (this._downloadsDirectory) {
+      return this._downloadsDirectory;
+    }
+
+    let directoryPath = null;
+#ifdef XP_MACOSX
+    directoryPath = this._getDirectory("DfltDwnld");
+#elifdef XP_WIN
+    // For XP/2K, use My Documents/Downloads. Other version uses
+    // the default Downloads directory.
+    let version = parseFloat(Services.sysinfo.getProperty("version"));
+    if (version < 6) {
+      directoryPath = yield this._createDownloadsDirectory("Pers");
+    } else {
+      directoryPath = this._getDirectory("DfltDwnld");
+    }
+#elifdef XP_UNIX
+#ifdef MOZ_WIDGET_ANDROID
+    // Android doesn't have a $HOME directory, and by default we only have
+    // write access to /data/data/org.mozilla.{$APP} and /sdcard
+    directoryPath = gEnvironment.get("DOWNLOADS_DIRECTORY");
+    if (!directoryPath) {
+      throw new Components.Exception("DOWNLOADS_DIRECTORY is not set.",
+                                     Cr.NS_ERROR_FILE_UNRECOGNIZED_PATH);
+    }
+#else
+    // For Linux, use XDG download dir, with a fallback to Home/Downloads
+    // if the XDG user dirs are disabled.
+    try {
+      directoryPath = this._getDirectory("DfltDwnld");
+    } catch(e) {
+      directoryPath = yield this._createDownloadsDirectory("Home");
+    }
+#endif
+#else
+    directoryPath = yield this._createDownloadsDirectory("Home");
+#endif
+
+    this._downloadsDirectory = directoryPath;
+    return this._downloadsDirectory;
+  }),
+  _downloadsDirectory: null,
+
+  /**
+   * Returns the user downloads directory asynchronously.
+   *
+   * @return {Promise}
+   * @resolves The downloads directory string path.
+   */
+  getPreferredDownloadsDirectory: Task.async(function* () {
+    let directoryPath = null;
+    let prefValue = 1;
+
+    try {
+      prefValue = Services.prefs.getIntPref("browser.download.folderList");
+    } catch(e) {}
+
+    switch(prefValue) {
+      case 0: // Desktop
+        directoryPath = this._getDirectory("Desk");
+        break;
+      case 1: // Downloads
+        directoryPath = yield this.getSystemDownloadsDirectory();
+        break;
+      case 2: // Custom
+        try {
+          let directory = Services.prefs.getComplexValue("browser.download.dir",
+                                                         Ci.nsIFile);
+          directoryPath = directory.path;
+          yield OS.File.makeDir(directoryPath, { ignoreExisting: true });
+        } catch(ex) {
+          // Either the preference isn't set or the directory cannot be created.
+          directoryPath = yield this.getSystemDownloadsDirectory();
+        }
+        break;
+      default:
+        directoryPath = yield this.getSystemDownloadsDirectory();
+    }
+    return directoryPath;
+  }),
+
+  /**
+   * Returns the temporary downloads directory asynchronously.
+   *
+   * @return {Promise}
+   * @resolves The downloads directory string path.
+   */
+  getTemporaryDownloadsDirectory: Task.async(function* () {
+    let directoryPath = null;
+#ifdef XP_MACOSX
+    directoryPath = yield this.getPreferredDownloadsDirectory();
+#elifdef MOZ_WIDGET_ANDROID
+    directoryPath = yield this.getSystemDownloadsDirectory();
+#elifdef MOZ_WIDGET_GONK
+    directoryPath = yield this.getSystemDownloadsDirectory();
+#else
+    directoryPath = this._getDirectory("TmpD");
+#endif
+    return directoryPath;
+  }),
+
+  /**
+   * Checks to determine whether to block downloads for parental controls.
+   *
+   * aParam aDownload
+   *        The download object.
+   *
+   * @return {Promise}
+   * @resolves The boolean indicates to block downloads or not.
+   */
+  shouldBlockForParentalControls(aDownload) {
+    let isEnabled = gParentalControlsService &&
+                    gParentalControlsService.parentalControlsEnabled;
+    let shouldBlock = isEnabled &&
+                      gParentalControlsService.blockFileDownloadsEnabled;
+
+    // Log the event if required by parental controls settings.
+    if (isEnabled && gParentalControlsService.loggingEnabled) {
+      gParentalControlsService.log(gParentalControlsService.ePCLog_FileDownload,
+                                   shouldBlock,
+                                   NetUtil.newURI(aDownload.source.url), null);
+    }
+
+    return Promise.resolve(shouldBlock);
+  },
+
+  /**
+   * Checks to determine whether to block downloads for not granted runtime permissions.
+   *
+   * @return {Promise}
+   * @resolves The boolean indicates to block downloads or not.
+   */
+  shouldBlockForRuntimePermissions() {
+#ifdef MOZ_WIDGET_ANDROID
+    return RuntimePermissions.waitForPermissions(RuntimePermissions.WRITE_EXTERNAL_STORAGE)
+                             .then(permissionGranted => !permissionGranted);
+#else
+    return Promise.resolve(false);
+#endif
+  },
+
+  /**
+   * Checks to determine whether to block downloads because they might be
+   * malware, based on application reputation checks.
+   *
+   * aParam aDownload
+   *        The download object.
+   *
+   * @return {Promise}
+   * @resolves Object with the following properties:
+   *           {
+   *             shouldBlock: Whether the download should be blocked.
+   *             verdict: Detailed reason for the block, according to the
+   *                      "Downloads.Error.BLOCK_VERDICT_" constants, or empty
+   *                      string if the reason is unknown.
+   *           }
+   */
+  shouldBlockForReputationCheck(aDownload) {
+    let hash;
+    let sigInfo;
+    let channelRedirects;
+    try {
+      hash = aDownload.saver.getSha256Hash();
+      sigInfo = aDownload.saver.getSignatureInfo();
+      channelRedirects = aDownload.saver.getRedirects();
+    } catch (ex) {
+      // Bail if DownloadSaver doesn't have a hash or signature info.
+      return Promise.resolve({
+        shouldBlock: false,
+        verdict: "",
+      });
+    }
+    if (!hash || !sigInfo) {
+      return Promise.resolve({
+        shouldBlock: false,
+        verdict: "",
+      });
+    }
+    let deferred = Promise.defer();
+    let aReferrer = null;
+    if (aDownload.source.referrer) {
+      aReferrer = NetUtil.newURI(aDownload.source.referrer);
+    }
+    gApplicationReputationService.queryReputation({
+      sourceURI: NetUtil.newURI(aDownload.source.url),
+      referrerURI: aReferrer,
+      fileSize: aDownload.currentBytes,
+      sha256Hash: hash,
+      suggestedFileName: OS.Path.basename(aDownload.target.path),
+      signatureInfo: sigInfo,
+      redirects: channelRedirects },
+      function onComplete(aShouldBlock, aRv, aVerdict) {
+        deferred.resolve({
+          shouldBlock: aShouldBlock,
+          verdict: (aShouldBlock && kVerdictMap[aVerdict]) || "",
+        });
+      });
+    return deferred.promise;
+  },
+
+#ifdef XP_WIN
+  /**
+   * Checks whether downloaded files should be marked as coming from
+   * Internet Zone.
+   *
+   * @return true if files should be marked
+   */
+  _shouldSaveZoneInformation() {
+    let key = Cc["@mozilla.org/windows-registry-key;1"]
+                .createInstance(Ci.nsIWindowsRegKey);
+    try {
+      key.open(Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
+               "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Attachments",
+               Ci.nsIWindowsRegKey.ACCESS_QUERY_VALUE);
+      try {
+        return key.readIntValue("SaveZoneInformation") != 1;
+      } finally {
+        key.close();
+      }
+    } catch (ex) {
+      // If the key is not present, files should be marked by default.
+      return true;
+    }
+  },
+#endif
+
+  /**
+   * Performs platform-specific operations when a download is done.
+   *
+   * aParam aDownload
+   *        The Download object.
+   *
+   * @return {Promise}
+   * @resolves When all the operations completed successfully.
+   * @rejects JavaScript exception if any of the operations failed.
+   */
+  downloadDone: Task.async(function* (aDownload) {
+#ifdef XP_WIN
+    // On Windows, we mark any file saved to the NTFS file system as coming
+    // from the Internet security zone unless Group Policy disables the
+    // feature.  We do this by writing to the "Zone.Identifier" Alternate
+    // Data Stream directly, because the Save method of the
+    // IAttachmentExecute interface would trigger operations that may cause
+    // the application to hang, or other performance issues.
+    // The stream created in this way is forward-compatible with all the
+    // current and future versions of Windows.
+    if (this._shouldSaveZoneInformation()) {
+      let zone;
+      try {
+        zone = gDownloadPlatform.mapUrlToZone(aDownload.source.url);
+      } catch (e) {
+        // Default to Internet Zone if mapUrlToZone failed for
+        // whatever reason.
+        zone = Ci.mozIDownloadPlatform.ZONE_INTERNET;
+      }
+      try {
+        // Don't write zone IDs for Local, Intranet, or Trusted sites
+        // to match Windows behavior.
+        if (zone >= Ci.mozIDownloadPlatform.ZONE_INTERNET) {
+          let streamPath = aDownload.target.path + ":Zone.Identifier";
+          let stream = yield OS.File.open(
+            streamPath,
+            { create: true },
+            { winAllowLengthBeyondMaxPathWithCaveats: true }
+          );
+          try {
+            yield stream.write(new TextEncoder().encode("[ZoneTransfer]\r\nZoneId=" + zone + "\r\n"));
+          } finally {
+            yield stream.close();
+          }
+        }
+      } catch (ex) {
+        // If writing to the stream fails, we ignore the error and continue.
+        // The Windows API error 123 (ERROR_INVALID_NAME) is expected to
+        // occur when working on a file system that does not support
+        // Alternate Data Streams, like FAT32, thus we don't report this
+        // specific error.
+        if (!(ex instanceof OS.File.Error) || ex.winLastError != 123) {
+          Cu.reportError(ex);
+        }
+      }
+    }
+#endif
+
+    // The file with the partially downloaded data has restrictive permissions
+    // that don't allow other users on the system to access it.  Now that the
+    // download is completed, we need to adjust permissions based on whether
+    // this is a permanently downloaded file or a temporary download to be
+    // opened read-only with an external application.
+    try {
+      // The following logic to determine whether this is a temporary download
+      // is due to the fact that "deleteTempFileOnExit" is false on Mac, where
+      // downloads to be opened with external applications are preserved in
+      // the "Downloads" folder like normal downloads.
+      let isTemporaryDownload =
+        aDownload.launchWhenSucceeded && (aDownload.source.isPrivate ||
+        Services.prefs.getBoolPref("browser.helperApps.deleteTempFileOnExit"));
+      // Permanently downloaded files are made accessible by other users on
+      // this system, while temporary downloads are marked as read-only.
+      let options = {};
+      if (isTemporaryDownload) {
+        options.unixMode = 0o400;
+        options.winAttributes = {readOnly: true};
+      } else {
+        options.unixMode = 0o666;
+      }
+      // On Unix, the umask of the process is respected.
+      yield OS.File.setPermissions(aDownload.target.path, options);
+    } catch (ex) {
+      // We should report errors with making the permissions less restrictive
+      // or marking the file as read-only on Unix and Mac, but this should not
+      // prevent the download from completing.
+      // The setPermissions API error EPERM is expected to occur when working
+      // on a file system that does not support file permissions, like FAT32,
+      // thus we don't report this error.
+      if (!(ex instanceof OS.File.Error) || ex.unixErrno != OS.Constants.libc.EPERM) {
+        Cu.reportError(ex);
+      }
+    }
+
+    let aReferrer = null;
+    if (aDownload.source.referrer) {
+      aReferrer = NetUtil.newURI(aDownload.source.referrer);
+    }
+
+    gDownloadPlatform.downloadDone(NetUtil.newURI(aDownload.source.url),
+                                   aReferrer,
+                                   new FileUtils.File(aDownload.target.path),
+                                   aDownload.contentType,
+                                   aDownload.source.isPrivate);
+  }),
+
+  /**
+   * Launches a file represented by the target of a download. This can
+   * open the file with the default application for the target MIME type
+   * or file extension, or with a custom application if
+   * aDownload.launcherPath is set.
+   *
+   * @param    aDownload
+   *           A Download object that contains the necessary information
+   *           to launch the file. The relevant properties are: the target
+   *           file, the contentType and the custom application chosen
+   *           to launch it.
+   *
+   * @return {Promise}
+   * @resolves When the instruction to launch the file has been
+   *           successfully given to the operating system. Note that
+   *           the OS might still take a while until the file is actually
+   *           launched.
+   * @rejects  JavaScript exception if there was an error trying to launch
+   *           the file.
+   */
+  launchDownload: Task.async(function* (aDownload) {
+    let file = new FileUtils.File(aDownload.target.path);
+
+#ifndef XP_WIN
+    // Ask for confirmation if the file is executable, except on Windows where
+    // the operating system will show the prompt based on the security zone.
+    // We do this here, instead of letting the caller handle the prompt
+    // separately in the user interface layer, for two reasons.  The first is
+    // because of its security nature, so that add-ons cannot forget to do
+    // this check.  The second is that the system-level security prompt would
+    // be displayed at launch time in any case.
+    if (file.isExecutable() &&
+        !(yield this.confirmLaunchExecutable(file.path))) {
+      return;
+    }
+#endif
+
+    // In case of a double extension, like ".tar.gz", we only
+    // consider the last one, because the MIME service cannot
+    // handle multiple extensions.
+    let fileExtension = null, mimeInfo = null;
+    let match = file.leafName.match(/\.([^.]+)$/);
+    if (match) {
+      fileExtension = match[1];
+    }
+
+    try {
+      // The MIME service might throw if contentType == "" and it can't find
+      // a MIME type for the given extension, so we'll treat this case as
+      // an unknown mimetype.
+      mimeInfo = gMIMEService.getFromTypeAndExtension(aDownload.contentType,
+                                                      fileExtension);
+    } catch (e) { }
+
+    if (aDownload.launcherPath) {
+      if (!mimeInfo) {
+        // This should not happen on normal circumstances because launcherPath
+        // is only set when we had an instance of nsIMIMEInfo to retrieve
+        // the custom application chosen by the user.
+        throw new Error(
+          "Unable to create nsIMIMEInfo to launch a custom application");
+      }
+
+      // Custom application chosen
+      let localHandlerApp = Cc["@mozilla.org/uriloader/local-handler-app;1"]
+                              .createInstance(Ci.nsILocalHandlerApp);
+      localHandlerApp.executable = new FileUtils.File(aDownload.launcherPath);
+
+      mimeInfo.preferredApplicationHandler = localHandlerApp;
+      mimeInfo.preferredAction = Ci.nsIMIMEInfo.useHelperApp;
+
+      this.launchFile(file, mimeInfo);
+      return;
+    }
+
+    // No custom application chosen, let's launch the file with the default
+    // handler. First, let's try to launch it through the MIME service.
+    if (mimeInfo) {
+      mimeInfo.preferredAction = Ci.nsIMIMEInfo.useSystemDefault;
+
+      try {
+        this.launchFile(file, mimeInfo);
+        return;
+      } catch (ex) { }
+    }
+
+    // If it didn't work or if there was no MIME info available,
+    // let's try to directly launch the file.
+    try {
+      this.launchFile(file);
+      return;
+    } catch (ex) { }
+
+    // If our previous attempts failed, try sending it through
+    // the system's external "file:" URL handler.
+    gExternalProtocolService.loadUrl(NetUtil.newURI(file));
+  }),
+
+  /**
+   * Asks for confirmation for launching the specified executable file. This
+   * can be overridden by regression tests to avoid the interactive prompt.
+   */
+  confirmLaunchExecutable: Task.async(function* (path) {
+    // We don't anchor the prompt to a specific window intentionally, not
+    // only because this is the same behavior as the system-level prompt,
+    // but also because the most recently active window is the right choice
+    // in basically all cases.
+    return yield DownloadUIHelper.getPrompter().confirmLaunchExecutable(path);
+  }),
+
+  /**
+   * Launches the specified file, unless overridden by regression tests.
+   */
+  launchFile(file, mimeInfo) {
+    if (mimeInfo) {
+      mimeInfo.launchWithFile(file);
+    } else {
+      file.launch();
+    }
+  },
+
+  /**
+   * Shows the containing folder of a file.
+   *
+   * @param aFilePath
+   *        The path to the file.
+   *
+   * @return {Promise}
+   * @resolves When the instruction to open the containing folder has been
+   *           successfully given to the operating system. Note that
+   *           the OS might still take a while until the folder is actually
+   *           opened.
+   * @rejects  JavaScript exception if there was an error trying to open
+   *           the containing folder.
+   */
+  showContainingDirectory: Task.async(function* (aFilePath) {
+    let file = new FileUtils.File(aFilePath);
+
+    try {
+      // Show the directory containing the file and select the file.
+      file.reveal();
+      return;
+    } catch (ex) { }
+
+    // If reveal fails for some reason (e.g., it's not implemented on unix
+    // or the file doesn't exist), try using the parent if we have it.
+    let parent = file.parent;
+    if (!parent) {
+      throw new Error(
+        "Unexpected reference to a top-level directory instead of a file");
+    }
+
+    try {
+      // Open the parent directory to show where the file should be.
+      parent.launch();
+      return;
+    } catch (ex) { }
+
+    // If launch also fails (probably because it's not implemented), let
+    // the OS handler try to open the parent.
+    gExternalProtocolService.loadUrl(NetUtil.newURI(parent));
+  }),
+
+  /**
+   * Calls the directory service, create a downloads directory and returns an
+   * nsIFile for the downloads directory.
+   *
+   * @return {Promise}
+   * @resolves The directory string path.
+   */
+  _createDownloadsDirectory(aName) {
+    // We read the name of the directory from the list of translated strings
+    // that is kept by the UI helper module, even if this string is not strictly
+    // displayed in the user interface.
+    let directoryPath = OS.Path.join(this._getDirectory(aName),
+                                     DownloadUIHelper.strings.downloadsFolder);
+
+    // Create the Downloads folder and ignore if it already exists.
+    return OS.File.makeDir(directoryPath, { ignoreExisting: true })
+                  .then(() => directoryPath);
+  },
+
+  /**
+   * Returns the string path for the given directory service location name. This
+   * can be overridden by regression tests to return the path of the system
+   * temporary directory in all cases.
+   */
+  _getDirectory(name) {
+    return Services.dirsvc.get(name, Ci.nsIFile).path;
+  },
+
+  /**
+   * Register the downloads interruption observers.
+   *
+   * @param aList
+   *        The public or private downloads list.
+   * @param aIsPrivate
+   *        True if the list is private, false otherwise.
+   *
+   * @return {Promise}
+   * @resolves When the views and observers are added.
+   */
+  addListObservers(aList, aIsPrivate) {
+    DownloadObserver.registerView(aList, aIsPrivate);
+    if (!DownloadObserver.observersAdded) {
+      DownloadObserver.observersAdded = true;
+      for (let topic of kObserverTopics) {
+        Services.obs.addObserver(DownloadObserver, topic, false);
+      }
+    }
+    return Promise.resolve();
+  },
+
+  /**
+   * Force a save on _store if it exists. Used to ensure downloads do not
+   * persist after being sanitized on Android.
+   *
+   * @return {Promise}
+   * @resolves When _store.save() completes.
+   */
+  forceSave() {
+    if (this._store) {
+      return this._store.save();
+    }
+    return Promise.resolve();
+  },
+
+  /**
+   * Checks if we have already imported (or attempted to import)
+   * the downloads database from the previous SQLite storage.
+   *
+   * @return boolean True if we the previous DB was imported.
+   */
+  get _importedFromSqlite() {
+    try {
+      return Services.prefs.getBoolPref(kPrefImportedFromSqlite);
+    } catch (ex) {
+      return false;
+    }
+  },
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//// DownloadObserver
+
+this.DownloadObserver = {
+  /**
+   * Flag to determine if the observers have been added previously.
+   */
+  observersAdded: false,
+
+  /**
+   * Timer used to delay restarting canceled downloads upon waking and returning
+   * online.
+   */
+  _wakeTimer: null,
+
+  /**
+   * Set that contains the in progress publics downloads.
+   * It's kept updated when a public download is added, removed or changes its
+   * properties.
+   */
+  _publicInProgressDownloads: new Set(),
+
+  /**
+   * Set that contains the in progress private downloads.
+   * It's kept updated when a private download is added, removed or changes its
+   * properties.
+   */
+  _privateInProgressDownloads: new Set(),
+
+  /**
+   * Set that contains the downloads that have been canceled when going offline
+   * or to sleep. These are started again when returning online or waking. This
+   * list is not persisted so when exiting and restarting, the downloads will not
+   * be started again.
+   */
+  _canceledOfflineDownloads: new Set(),
+
+  /**
+   * Registers a view that updates the corresponding downloads state set, based
+   * on the aIsPrivate argument. The set is updated when a download is added,
+   * removed or changes its properties.
+   *
+   * @param aList
+   *        The public or private downloads list.
+   * @param aIsPrivate
+   *        True if the list is private, false otherwise.
+   */
+  registerView: function DO_registerView(aList, aIsPrivate) {
+    let downloadsSet = aIsPrivate ? this._privateInProgressDownloads
+                                  : this._publicInProgressDownloads;
+    let downloadsView = {
+      onDownloadAdded: aDownload => {
+        if (!aDownload.stopped) {
+          downloadsSet.add(aDownload);
+        }
+      },
+      onDownloadChanged: aDownload => {
+        if (aDownload.stopped) {
+          downloadsSet.delete(aDownload);
+        } else {
+          downloadsSet.add(aDownload);
+        }
+      },
+      onDownloadRemoved: aDownload => {
+        downloadsSet.delete(aDownload);
+        // The download must also be removed from the canceled when offline set.
+        this._canceledOfflineDownloads.delete(aDownload);
+      }
+    };
+
+    // We register the view asynchronously.
+    aList.addView(downloadsView).then(null, Cu.reportError);
+  },
+
+  /**
+   * Wrapper that handles the test mode before calling the prompt that display
+   * a warning message box that informs that there are active downloads,
+   * and asks whether the user wants to cancel them or not.
+   *
+   * @param aCancel
+   *        The observer notification subject.
+   * @param aDownloadsCount
+   *        The current downloads count.
+   * @param aPrompter
+   *        The prompter object that shows the confirm dialog.
+   * @param aPromptType
+   *        The type of prompt notification depending on the observer.
+   */
+  _confirmCancelDownloads: function DO_confirmCancelDownload(
+    aCancel, aDownloadsCount, aPrompter, aPromptType) {
+    // If user has already dismissed the request, then do nothing.
+    if ((aCancel instanceof Ci.nsISupportsPRBool) && aCancel.data) {
+      return;
+    }
+    // Handle test mode
+    if (gCombinedDownloadIntegration._testPromptDownloads) {
+      gCombinedDownloadIntegration._testPromptDownloads = aDownloadsCount;
+      return;
+    }
+
+    aCancel.data = aPrompter.confirmCancelDownloads(aDownloadsCount, aPromptType);
+  },
+
+  /**
+   * Resume all downloads that were paused when going offline, used when waking
+   * from sleep or returning from being offline.
+   */
+  _resumeOfflineDownloads: function DO_resumeOfflineDownloads() {
+    this._wakeTimer = null;
+
+    for (let download of this._canceledOfflineDownloads) {
+      download.start().catch(() => {});
+    }
+  },
+
+  ////////////////////////////////////////////////////////////////////////////
+  //// nsIObserver
+
+  observe: function DO_observe(aSubject, aTopic, aData) {
+    let downloadsCount;
+    let p = DownloadUIHelper.getPrompter();
+    switch (aTopic) {
+      case "quit-application-requested":
+        downloadsCount = this._publicInProgressDownloads.size +
+                         this._privateInProgressDownloads.size;
+        this._confirmCancelDownloads(aSubject, downloadsCount, p, p.ON_QUIT);
+        break;
+      case "offline-requested":
+        downloadsCount = this._publicInProgressDownloads.size +
+                         this._privateInProgressDownloads.size;
+        this._confirmCancelDownloads(aSubject, downloadsCount, p, p.ON_OFFLINE);
+        break;
+      case "last-pb-context-exiting":
+        downloadsCount = this._privateInProgressDownloads.size;
+        this._confirmCancelDownloads(aSubject, downloadsCount, p,
+                                     p.ON_LEAVE_PRIVATE_BROWSING);
+        break;
+      case "last-pb-context-exited":
+        let promise = Task.spawn(function() {
+          let list = yield Downloads.getList(Downloads.PRIVATE);
+          let downloads = yield list.getAll();
+
+          // We can remove the downloads and finalize them in parallel.
+          for (let download of downloads) {
+            list.remove(download).then(null, Cu.reportError);
+            download.finalize(true).then(null, Cu.reportError);
+          }
+        });
+        // Handle test mode
+        if (gCombinedDownloadIntegration._testResolveClearPrivateList) {
+          gCombinedDownloadIntegration._testResolveClearPrivateList(promise);
+        } else {
+          promise.catch(ex => Cu.reportError(ex));
+        }
+        break;
+      case "sleep_notification":
+      case "suspend_process_notification":
+      case "network:offline-about-to-go-offline":
+        for (let download of this._publicInProgressDownloads) {
+          download.cancel();
+          this._canceledOfflineDownloads.add(download);
+        }
+        for (let download of this._privateInProgressDownloads) {
+          download.cancel();
+          this._canceledOfflineDownloads.add(download);
+        }
+        break;
+      case "wake_notification":
+      case "resume_process_notification":
+        let wakeDelay = 10000;
+        try {
+          wakeDelay = Services.prefs.getIntPref("browser.download.manager.resumeOnWakeDelay");
+        } catch(e) {}
+
+        if (wakeDelay >= 0) {
+          this._wakeTimer = new Timer(this._resumeOfflineDownloads.bind(this), wakeDelay,
+                                      Ci.nsITimer.TYPE_ONE_SHOT);
+        }
+        break;
+      case "network:offline-status-changed":
+        if (aData == "online") {
+          this._resumeOfflineDownloads();
+        }
+        break;
+      // We need to unregister observers explicitly before we reach the
+      // "xpcom-shutdown" phase, otherwise observers may be notified when some
+      // required services are not available anymore. We can't unregister
+      // observers on "quit-application", because this module is also loaded
+      // during "make package" automation, and the quit notification is not sent
+      // in that execution environment (bug 973637).
+      case "xpcom-will-shutdown":
+        for (let topic of kObserverTopics) {
+          Services.obs.removeObserver(this, topic);
+        }
+        break;
+    }
+  },
+
+  ////////////////////////////////////////////////////////////////////////////
+  //// nsISupports
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver])
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//// DownloadHistoryObserver
+
+#ifdef MOZ_PLACES
+/**
+ * Registers a Places observer so that operations on download history are
+ * reflected on the provided list of downloads.
+ *
+ * You do not need to keep a reference to this object in order to keep it alive,
+ * because the history service already keeps a strong reference to it.
+ *
+ * @param aList
+ *        DownloadList object linked to this observer.
+ */
+this.DownloadHistoryObserver = function (aList)
+{
+  this._list = aList;
+  PlacesUtils.history.addObserver(this, false);
+}
+
+this.DownloadHistoryObserver.prototype = {
+  /**
+   * DownloadList object linked to this observer.
+   */
+  _list: null,
+
+  ////////////////////////////////////////////////////////////////////////////
+  //// nsISupports
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryObserver]),
+
+  ////////////////////////////////////////////////////////////////////////////
+  //// nsINavHistoryObserver
+
+  onDeleteURI: function DL_onDeleteURI(aURI, aGUID) {
+    this._list.removeFinished(download => aURI.equals(NetUtil.newURI(
+                                                      download.source.url)));
+  },
+
+  onClearHistory: function DL_onClearHistory() {
+    this._list.removeFinished();
+  },
+
+  onTitleChanged: function () {},
+  onBeginUpdateBatch: function () {},
+  onEndUpdateBatch: function () {},
+  onVisit: function () {},
+  onPageChanged: function () {},
+  onDeleteVisits: function () {},
+};
+#else
+/**
+ * Empty implementation when we have no Places support, for example on B2G.
+ */
+this.DownloadHistoryObserver = function (aList) {}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+//// DownloadAutoSaveView
+
+/**
+ * This view can be added to a DownloadList object to trigger a save operation
+ * in the given DownloadStore object when a relevant change occurs.  You should
+ * call the "initialize" method in order to register the view and load the
+ * current state from disk.
+ *
+ * You do not need to keep a reference to this object in order to keep it alive,
+ * because the DownloadList object already keeps a strong reference to it.
+ *
+ * @param aList
+ *        The DownloadList object on which the view should be registered.
+ * @param aStore
+ *        The DownloadStore object used for saving.
+ */
+this.DownloadAutoSaveView = function (aList, aStore)
+{
+  this._list = aList;
+  this._store = aStore;
+  this._downloadsMap = new Map();
+  this._writer = new DeferredTask(() => this._store.save(), kSaveDelayMs);
+  AsyncShutdown.profileBeforeChange.addBlocker("DownloadAutoSaveView: writing data",
+                                               () => this._writer.finalize());
+}
+
+this.DownloadAutoSaveView.prototype = {
+  /**
+   * DownloadList object linked to this view.
+   */
+  _list: null,
+
+  /**
+   * The DownloadStore object used for saving.
+   */
+  _store: null,
+
+  /**
+   * True when the initial state of the downloads has been loaded.
+   */
+  _initialized: false,
+
+  /**
+   * Registers the view and loads the current state from disk.
+   *
+   * @return {Promise}
+   * @resolves When the view has been registered.
+   * @rejects JavaScript exception.
+   */
+  initialize: function ()
+  {
+    // We set _initialized to true after adding the view, so that
+    // onDownloadAdded doesn't cause a save to occur.
+    return this._list.addView(this).then(() => this._initialized = true);
+  },
+
+  /**
+   * This map contains only Download objects that should be saved to disk, and
+   * associates them with the result of their getSerializationHash function, for
+   * the purpose of detecting changes to the relevant properties.
+   */
+  _downloadsMap: null,
+
+  /**
+   * DeferredTask for the save operation.
+   */
+  _writer: null,
+
+  /**
+   * Called when the list of downloads changed, this triggers the asynchronous
+   * serialization of the list of downloads.
+   */
+  saveSoon: function ()
+  {
+    this._writer.arm();
+  },
+
+  //////////////////////////////////////////////////////////////////////////////
+  //// DownloadList view
+
+  onDownloadAdded: function (aDownload)
+  {
+    if (gCombinedDownloadIntegration.shouldPersistDownload(aDownload)) {
+      this._downloadsMap.set(aDownload, aDownload.getSerializationHash());
+      if (this._initialized) {
+        this.saveSoon();
+      }
+    }
+  },
+
+  onDownloadChanged: function (aDownload)
+  {
+    if (!gCombinedDownloadIntegration.shouldPersistDownload(aDownload)) {
+      if (this._downloadsMap.has(aDownload)) {
+        this._downloadsMap.delete(aDownload);
+        this.saveSoon();
+      }
+      return;
+    }
+
+    let hash = aDownload.getSerializationHash();
+    if (this._downloadsMap.get(aDownload) != hash) {
+      this._downloadsMap.set(aDownload, hash);
+      this.saveSoon();
+    }
+  },
+
+  onDownloadRemoved: function (aDownload)
+  {
+    if (this._downloadsMap.has(aDownload)) {
+      this._downloadsMap.delete(aDownload);
+      this.saveSoon();
+    }
+  },
+};