Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1246 insertions, 0 deletions

diff --git a/toolkit/content/contentAreaUtils.js b/toolkit/content/contentAreaUtils.js
new file mode 100644
index 0000000000..5371b1a45b
--- /dev/null
+++ b/toolkit/content/contentAreaUtils.js
@@ -0,0 +1,1246 @@
+/* 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/. */
+
+var { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+var { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+ChromeUtils.defineESModuleGetters(this, {
+  BrowserUtils: "resource://gre/modules/BrowserUtils.sys.mjs",
+  Deprecated: "resource://gre/modules/Deprecated.sys.mjs",
+  DownloadPaths: "resource://gre/modules/DownloadPaths.sys.mjs",
+  Downloads: "resource://gre/modules/Downloads.sys.mjs",
+  FileUtils: "resource://gre/modules/FileUtils.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  DownloadLastDir: "resource://gre/modules/DownloadLastDir.jsm",
+  NetUtil: "resource://gre/modules/NetUtil.jsm",
+});
+
+var ContentAreaUtils = {
+  get stringBundle() {
+    delete this.stringBundle;
+    return (this.stringBundle = Services.strings.createBundle(
+      "chrome://global/locale/contentAreaCommands.properties"
+    ));
+  },
+};
+
+function urlSecurityCheck(
+  aURL,
+  aPrincipal,
+  aFlags = Services.scriptSecurityManager
+) {
+  if (aURL instanceof Ci.nsIURI) {
+    Services.scriptSecurityManager.checkLoadURIWithPrincipal(
+      aPrincipal,
+      aURL,
+      aFlags
+    );
+  } else {
+    Services.scriptSecurityManager.checkLoadURIStrWithPrincipal(
+      aPrincipal,
+      aURL,
+      aFlags
+    );
+  }
+}
+
+// Clientele: (Make sure you don't break any of these)
+//  - File    ->  Save Page/Frame As...
+//  - Context ->  Save Page/Frame As...
+//  - Context ->  Save Link As...
+//  - Alt-Click links in web pages
+//  - Alt-Click links in the UI
+//
+// Try saving each of these types:
+// - A complete webpage using File->Save Page As, and Context->Save Page As
+// - A webpage as HTML only using the above methods
+// - A webpage as Text only using the above methods
+// - An image with an extension (e.g. .jpg) in its file name, using
+//   Context->Save Image As...
+// - An image without an extension (e.g. a banner ad on cnn.com) using
+//   the above method.
+// - A linked document using Save Link As...
+// - A linked document using Alt-click Save Link As...
+//
+function saveURL(
+  aURL,
+  aOriginalURL,
+  aFileName,
+  aFilePickerTitleKey,
+  aShouldBypassCache,
+  aSkipPrompt,
+  aReferrerInfo,
+  aCookieJarSettings,
+  aSourceDocument,
+  aIsContentWindowPrivate,
+  aPrincipal
+) {
+  internalSave(
+    aURL,
+    aOriginalURL,
+    null,
+    aFileName,
+    null,
+    null,
+    aShouldBypassCache,
+    aFilePickerTitleKey,
+    null,
+    aReferrerInfo,
+    aCookieJarSettings,
+    aSourceDocument,
+    aSkipPrompt,
+    null,
+    aIsContentWindowPrivate,
+    aPrincipal
+  );
+}
+
+// Save the current document inside any browser/frame-like element,
+// whether in-process or out-of-process.
+function saveBrowser(aBrowser, aSkipPrompt, aBrowsingContext = null) {
+  if (!aBrowser) {
+    throw new Error("Must have a browser when calling saveBrowser");
+  }
+  let persistable = aBrowser.frameLoader;
+  // PDF.js has its own way to handle saving PDFs since it may need to
+  // generate a new PDF to save modified form data.
+  if (aBrowser.contentPrincipal.spec == "resource://pdf.js/web/viewer.html") {
+    aBrowser.sendMessageToActor("PDFJS:Save", {}, "Pdfjs");
+    return;
+  }
+  let stack = Components.stack.caller;
+  persistable.startPersistence(aBrowsingContext, {
+    onDocumentReady(document) {
+      if (!document || !(document instanceof Ci.nsIWebBrowserPersistDocument)) {
+        throw new Error("Must have an nsIWebBrowserPersistDocument!");
+      }
+
+      internalSave(
+        document.documentURI,
+        null, // originalURL
+        document,
+        null, // file name
+        document.contentDisposition,
+        document.contentType,
+        false, // bypass cache
+        null, // file picker title key
+        null, // chosen file data
+        document.referrerInfo,
+        document.cookieJarSettings,
+        document,
+        aSkipPrompt,
+        document.cacheKey
+      );
+    },
+    onError(status) {
+      throw new Components.Exception(
+        "saveBrowser failed asynchronously in startPersistence",
+        status,
+        stack
+      );
+    },
+  });
+}
+
+function DownloadListener(win, transfer) {
+  function makeClosure(name) {
+    return function() {
+      transfer[name].apply(transfer, arguments);
+    };
+  }
+
+  this.window = win;
+
+  // Now... we need to forward all calls to our transfer
+  for (var i in transfer) {
+    if (i != "QueryInterface") {
+      this[i] = makeClosure(i);
+    }
+  }
+}
+
+DownloadListener.prototype = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIInterfaceRequestor",
+    "nsIWebProgressListener",
+    "nsIWebProgressListener2",
+  ]),
+
+  getInterface: function dl_gi(aIID) {
+    if (aIID.equals(Ci.nsIAuthPrompt) || aIID.equals(Ci.nsIAuthPrompt2)) {
+      var ww = Cc["@mozilla.org/embedcomp/window-watcher;1"].getService(
+        Ci.nsIPromptFactory
+      );
+      return ww.getPrompt(this.window, aIID);
+    }
+
+    throw Components.Exception("", Cr.NS_ERROR_NO_INTERFACE);
+  },
+};
+
+const kSaveAsType_Complete = 0; // Save document with attached objects.
+XPCOMUtils.defineConstant(this, "kSaveAsType_Complete", 0);
+// const kSaveAsType_URL      = 1; // Save document or URL by itself.
+const kSaveAsType_Text = 2; // Save document, converting to plain text.
+XPCOMUtils.defineConstant(this, "kSaveAsType_Text", kSaveAsType_Text);
+
+/**
+ * internalSave: Used when saving a document or URL.
+ *
+ * If aChosenData is null, this method:
+ *  - Determines a local target filename to use
+ *  - Prompts the user to confirm the destination filename and save mode
+ *    (aContentType affects this)
+ *  - [Note] This process involves the parameters aURL, aReferrerInfo,
+ *    aDocument, aDefaultFileName, aFilePickerTitleKey, and aSkipPrompt.
+ *
+ * If aChosenData is non-null, this method:
+ *  - Uses the provided source URI and save file name
+ *  - Saves the document as complete DOM if possible (aDocument present and
+ *    right aContentType)
+ *  - [Note] The parameters aURL, aDefaultFileName, aFilePickerTitleKey, and
+ *    aSkipPrompt are ignored.
+ *
+ * In any case, this method:
+ *  - Creates a 'Persist' object (which will perform the saving in the
+ *    background) and then starts it.
+ *  - [Note] This part of the process only involves the parameters aDocument,
+ *    aShouldBypassCache and aReferrerInfo. The source, the save name and the
+ *    save mode are the ones determined previously.
+ *
+ * @param aURL
+ *        The String representation of the URL of the document being saved
+ * @param aOriginalURL
+ *        The String representation of the original URL of the document being
+ *        saved. It can useful in case aURL is a blob.
+ * @param aDocument
+ *        The document to be saved
+ * @param aDefaultFileName
+ *        The caller-provided suggested filename if we don't
+ *        find a better one
+ * @param aContentDisposition
+ *        The caller-provided content-disposition header to use.
+ * @param aContentType
+ *        The caller-provided content-type to use
+ * @param aShouldBypassCache
+ *        If true, the document will always be refetched from the server
+ * @param aFilePickerTitleKey
+ *        Alternate title for the file picker
+ * @param aChosenData
+ *        If non-null this contains an instance of object AutoChosen (see below)
+ *        which holds pre-determined data so that the user does not need to be
+ *        prompted for a target filename.
+ * @param aReferrerInfo
+ *        the referrerInfo object to use, or null if no referrer should be sent.
+ * @param aCookieJarSettings
+ *        the cookieJarSettings object to use. This will be used for the channel
+ *        used to save.
+ * @param aInitiatingDocument [optional]
+ *        The document from which the save was initiated.
+ *        If this is omitted then aIsContentWindowPrivate has to be provided.
+ * @param aSkipPrompt [optional]
+ *        If set to true, we will attempt to save the file to the
+ *        default downloads folder without prompting.
+ * @param aCacheKey [optional]
+ *        If set will be passed to saveURI.  See nsIWebBrowserPersist for
+ *        allowed values.
+ * @param aIsContentWindowPrivate [optional]
+ *        This parameter is provided when the aInitiatingDocument is not a
+ *        real document object. Stores whether aInitiatingDocument.defaultView
+ *        was private or not.
+ * @param aPrincipal [optional]
+ *        This parameter is provided when neither aDocument nor
+ *        aInitiatingDocument is provided. Used to determine what level of
+ *        privilege to load the URI with.
+ */
+function internalSave(
+  aURL,
+  aOriginalURL,
+  aDocument,
+  aDefaultFileName,
+  aContentDisposition,
+  aContentType,
+  aShouldBypassCache,
+  aFilePickerTitleKey,
+  aChosenData,
+  aReferrerInfo,
+  aCookieJarSettings,
+  aInitiatingDocument,
+  aSkipPrompt,
+  aCacheKey,
+  aIsContentWindowPrivate,
+  aPrincipal
+) {
+  if (aSkipPrompt == undefined) {
+    aSkipPrompt = false;
+  }
+
+  if (aCacheKey == undefined) {
+    aCacheKey = 0;
+  }
+
+  // Note: aDocument == null when this code is used by save-link-as...
+  var saveMode = GetSaveModeForContentType(aContentType, aDocument);
+
+  var file, sourceURI, saveAsType;
+  let contentPolicyType = Ci.nsIContentPolicy.TYPE_SAVEAS_DOWNLOAD;
+  // Find the URI object for aURL and the FileName/Extension to use when saving.
+  // FileName/Extension will be ignored if aChosenData supplied.
+  if (aChosenData) {
+    file = aChosenData.file;
+    sourceURI = aChosenData.uri;
+    saveAsType = kSaveAsType_Complete;
+
+    continueSave();
+  } else {
+    var charset = null;
+    if (aDocument) {
+      charset = aDocument.characterSet;
+    }
+    var fileInfo = new FileInfo(aDefaultFileName);
+    initFileInfo(
+      fileInfo,
+      aURL,
+      charset,
+      aDocument,
+      aContentType,
+      aContentDisposition
+    );
+    sourceURI = fileInfo.uri;
+
+    if (aContentType && aContentType.startsWith("image/")) {
+      contentPolicyType = Ci.nsIContentPolicy.TYPE_IMAGE;
+    }
+    var fpParams = {
+      fpTitleKey: aFilePickerTitleKey,
+      fileInfo,
+      contentType: aContentType,
+      saveMode,
+      saveAsType: kSaveAsType_Complete,
+      file,
+    };
+
+    // Find a URI to use for determining last-downloaded-to directory
+    let relatedURI = aReferrerInfo?.originalReferrer || sourceURI;
+
+    promiseTargetFile(fpParams, aSkipPrompt, relatedURI)
+      .then(aDialogAccepted => {
+        if (!aDialogAccepted) {
+          return;
+        }
+
+        saveAsType = fpParams.saveAsType;
+        file = fpParams.file;
+
+        continueSave();
+      })
+      .catch(Cu.reportError);
+  }
+
+  function continueSave() {
+    // XXX We depend on the following holding true in appendFiltersForContentType():
+    // If we should save as a complete page, the saveAsType is kSaveAsType_Complete.
+    // If we should save as text, the saveAsType is kSaveAsType_Text.
+    var useSaveDocument =
+      aDocument &&
+      ((saveMode & SAVEMODE_COMPLETE_DOM &&
+        saveAsType == kSaveAsType_Complete) ||
+        (saveMode & SAVEMODE_COMPLETE_TEXT && saveAsType == kSaveAsType_Text));
+    // If we're saving a document, and are saving either in complete mode or
+    // as converted text, pass the document to the web browser persist component.
+    // If we're just saving the HTML (second option in the list), send only the URI.
+
+    let isPrivate = aIsContentWindowPrivate;
+    if (isPrivate === undefined) {
+      isPrivate =
+        aInitiatingDocument.nodeType == 9 /* DOCUMENT_NODE */
+          ? PrivateBrowsingUtils.isContentWindowPrivate(
+              aInitiatingDocument.defaultView
+            )
+          : aInitiatingDocument.isPrivate;
+    }
+
+    // We have to cover the cases here where we were either passed an explicit
+    // principal, or a 'real' document (with a nodePrincipal property), or an
+    // nsIWebBrowserPersistDocument which has a principal property.
+    let sourcePrincipal =
+      aPrincipal ||
+      (aDocument && (aDocument.nodePrincipal || aDocument.principal)) ||
+      (aInitiatingDocument && aInitiatingDocument.nodePrincipal);
+
+    let sourceOriginalURI = aOriginalURL ? makeURI(aOriginalURL) : null;
+
+    var persistArgs = {
+      sourceURI,
+      sourceOriginalURI,
+      sourcePrincipal,
+      sourceReferrerInfo: aReferrerInfo,
+      sourceDocument: useSaveDocument ? aDocument : null,
+      targetContentType: saveAsType == kSaveAsType_Text ? "text/plain" : null,
+      targetFile: file,
+      sourceCacheKey: aCacheKey,
+      sourcePostData: aDocument ? getPostData(aDocument) : null,
+      bypassCache: aShouldBypassCache,
+      contentPolicyType,
+      cookieJarSettings: aCookieJarSettings,
+      isPrivate,
+    };
+
+    // Start the actual save process
+    internalPersist(persistArgs);
+  }
+}
+
+/**
+ * internalPersist: Creates a 'Persist' object (which will perform the saving
+ *  in the background) and then starts it.
+ *
+ * @param persistArgs.sourceURI
+ *        The nsIURI of the document being saved
+ * @param persistArgs.sourceCacheKey [optional]
+ *        If set will be passed to savePrivacyAwareURI
+ * @param persistArgs.sourceDocument [optional]
+ *        The document to be saved, or null if not saving a complete document
+ * @param persistArgs.sourceReferrerInfo
+ *        Required and used only when persistArgs.sourceDocument is NOT present,
+ *        the nsIReferrerInfo of the referrer info to use, or null if no
+ *        referrer should be sent.
+ * @param persistArgs.sourcePostData
+ *        Required and used only when persistArgs.sourceDocument is NOT present,
+ *        represents the POST data to be sent along with the HTTP request, and
+ *        must be null if no POST data should be sent.
+ * @param persistArgs.targetFile
+ *        The nsIFile of the file to create
+ * @param persistArgs.contentPolicyType
+ *        The type of content we're saving. Will be used to determine what
+ *        content is accepted, enforce sniffing restrictions, etc.
+ * @param persistArgs.cookieJarSettings [optional]
+ *        The nsICookieJarSettings that will be used for the saving channel, or
+ *        null that savePrivacyAwareURI will create one based on the current
+ *        state of the prefs/permissions
+ * @param persistArgs.targetContentType
+ *        Required and used only when persistArgs.sourceDocument is present,
+ *        determines the final content type of the saved file, or null to use
+ *        the same content type as the source document. Currently only
+ *        "text/plain" is meaningful.
+ * @param persistArgs.bypassCache
+ *        If true, the document will always be refetched from the server
+ * @param persistArgs.isPrivate
+ *        Indicates whether this is taking place in a private browsing context.
+ */
+function internalPersist(persistArgs) {
+  var persist = makeWebBrowserPersist();
+
+  // Calculate persist flags.
+  const nsIWBP = Ci.nsIWebBrowserPersist;
+  const flags = nsIWBP.PERSIST_FLAGS_REPLACE_EXISTING_FILES;
+  if (persistArgs.bypassCache) {
+    persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_BYPASS_CACHE;
+  } else {
+    persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_FROM_CACHE;
+  }
+
+  // Leave it to WebBrowserPersist to discover the encoding type (or lack thereof):
+  persist.persistFlags |= nsIWBP.PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION;
+
+  // Find the URI associated with the target file
+  var targetFileURL = makeFileURI(persistArgs.targetFile);
+
+  // Create download and initiate it (below)
+  var tr = Cc["@mozilla.org/transfer;1"].createInstance(Ci.nsITransfer);
+  tr.init(
+    persistArgs.sourceURI,
+    persistArgs.sourceOriginalURI,
+    targetFileURL,
+    "",
+    null,
+    null,
+    null,
+    persist,
+    persistArgs.isPrivate,
+    Ci.nsITransfer.DOWNLOAD_ACCEPTABLE,
+    persistArgs.sourceReferrerInfo
+  );
+  persist.progressListener = new DownloadListener(window, tr);
+
+  if (persistArgs.sourceDocument) {
+    // Saving a Document, not a URI:
+    var filesFolder = null;
+    if (persistArgs.targetContentType != "text/plain") {
+      // Create the local directory into which to save associated files.
+      filesFolder = persistArgs.targetFile.clone();
+
+      var nameWithoutExtension = getFileBaseName(filesFolder.leafName);
+      var filesFolderLeafName = ContentAreaUtils.stringBundle.formatStringFromName(
+        "filesFolder",
+        [nameWithoutExtension]
+      );
+
+      filesFolder.leafName = filesFolderLeafName;
+    }
+
+    var encodingFlags = 0;
+    if (persistArgs.targetContentType == "text/plain") {
+      encodingFlags |= nsIWBP.ENCODE_FLAGS_FORMATTED;
+      encodingFlags |= nsIWBP.ENCODE_FLAGS_ABSOLUTE_LINKS;
+      encodingFlags |= nsIWBP.ENCODE_FLAGS_NOFRAMES_CONTENT;
+    } else {
+      encodingFlags |= nsIWBP.ENCODE_FLAGS_ENCODE_BASIC_ENTITIES;
+    }
+
+    const kWrapColumn = 80;
+    persist.saveDocument(
+      persistArgs.sourceDocument,
+      targetFileURL,
+      filesFolder,
+      persistArgs.targetContentType,
+      encodingFlags,
+      kWrapColumn
+    );
+  } else {
+    persist.savePrivacyAwareURI(
+      persistArgs.sourceURI,
+      persistArgs.sourcePrincipal,
+      persistArgs.sourceCacheKey,
+      persistArgs.sourceReferrerInfo,
+      persistArgs.cookieJarSettings,
+      persistArgs.sourcePostData,
+      null,
+      targetFileURL,
+      persistArgs.contentPolicyType || Ci.nsIContentPolicy.TYPE_SAVEAS_DOWNLOAD,
+      persistArgs.isPrivate
+    );
+  }
+}
+
+/**
+ * Structure for holding info about automatically supplied parameters for
+ * internalSave(...). This allows parameters to be supplied so the user does not
+ * need to be prompted for file info.
+ * @param aFileAutoChosen This is an nsIFile object that has been
+ *        pre-determined as the filename for the target to save to
+ * @param aUriAutoChosen  This is the nsIURI object for the target
+ */
+function AutoChosen(aFileAutoChosen, aUriAutoChosen) {
+  this.file = aFileAutoChosen;
+  this.uri = aUriAutoChosen;
+}
+
+/**
+ * Structure for holding info about a URL and the target filename it should be
+ * saved to. This structure is populated by initFileInfo(...).
+ * @param aSuggestedFileName This is used by initFileInfo(...) when it
+ *        cannot 'discover' the filename from the url
+ * @param aFileName The target filename
+ * @param aFileBaseName The filename without the file extension
+ * @param aFileExt The extension of the filename
+ * @param aUri An nsIURI object for the url that is being saved
+ */
+function FileInfo(
+  aSuggestedFileName,
+  aFileName,
+  aFileBaseName,
+  aFileExt,
+  aUri
+) {
+  this.suggestedFileName = aSuggestedFileName;
+  this.fileName = aFileName;
+  this.fileBaseName = aFileBaseName;
+  this.fileExt = aFileExt;
+  this.uri = aUri;
+}
+
+/**
+ * Determine what the 'default' filename string is, its file extension and the
+ * filename without the extension. This filename is used when prompting the user
+ * for confirmation in the file picker dialog.
+ * @param aFI A FileInfo structure into which we'll put the results of this method.
+ * @param aURL The String representation of the URL of the document being saved
+ * @param aURLCharset The charset of aURL.
+ * @param aDocument The document to be saved
+ * @param aContentType The content type we're saving, if it could be
+ *        determined by the caller.
+ * @param aContentDisposition The content-disposition header for the object
+ *        we're saving, if it could be determined by the caller.
+ */
+function initFileInfo(
+  aFI,
+  aURL,
+  aURLCharset,
+  aDocument,
+  aContentType,
+  aContentDisposition
+) {
+  try {
+    let uriExt = null;
+    // Get an nsIURI object from aURL if possible:
+    try {
+      aFI.uri = makeURI(aURL, aURLCharset);
+      // Assuming nsiUri is valid, calling QueryInterface(...) on it will
+      // populate extra object fields (eg filename and file extension).
+      uriExt = aFI.uri.QueryInterface(Ci.nsIURL).fileExtension;
+    } catch (e) {}
+
+    // Get the default filename:
+    let fileName = getDefaultFileName(
+      aFI.suggestedFileName || aFI.fileName,
+      aFI.uri,
+      aDocument,
+      aContentDisposition
+    );
+
+    let mimeService = this.getMIMEService();
+    aFI.fileName = mimeService.validateFileNameForSaving(
+      fileName,
+      aContentType,
+      mimeService.VALIDATE_FORCE_APPEND_EXTENSION
+    );
+
+    // If uriExt is blank, consider: aFI.suggestedFileName is supplied if
+    // saveURL(...) was the original caller (hence both aContentType and
+    // aDocument are blank). If they were saving a link to a website then make
+    // the extension .htm .
+    if (
+      !uriExt &&
+      !aDocument &&
+      !aContentType &&
+      /^http(s?):\/\//i.test(aURL)
+    ) {
+      aFI.fileExt = "htm";
+      aFI.fileBaseName = aFI.fileName;
+    } else {
+      let idx = aFI.fileName.lastIndexOf(".");
+      aFI.fileBaseName =
+        idx >= 0 ? aFI.fileName.substring(0, idx) : aFI.fileName;
+      aFI.fileExt = idx >= 0 ? aFI.fileName.substring(idx + 1) : null;
+    }
+  } catch (e) {}
+}
+
+/**
+ * Given the Filepicker Parameters (aFpP), show the file picker dialog,
+ * prompting the user to confirm (or change) the fileName.
+ * @param aFpP
+ *        A structure (see definition in internalSave(...) method)
+ *        containing all the data used within this method.
+ * @param aSkipPrompt
+ *        If true, attempt to save the file automatically to the user's default
+ *        download directory, thus skipping the explicit prompt for a file name,
+ *        but only if the associated preference is set.
+ *        If false, don't save the file automatically to the user's
+ *        default download directory, even if the associated preference
+ *        is set, but ask for the target explicitly.
+ * @param aRelatedURI
+ *        An nsIURI associated with the download. The last used
+ *        directory of the picker is retrieved from/stored in the
+ *        Content Pref Service using this URI.
+ * @return Promise
+ * @resolve a boolean. When true, it indicates that the file picker dialog
+ *          is accepted.
+ */
+function promiseTargetFile(
+  aFpP,
+  /* optional */ aSkipPrompt,
+  /* optional */ aRelatedURI
+) {
+  return (async function() {
+    let downloadLastDir = new DownloadLastDir(window);
+    let prefBranch = Services.prefs.getBranch("browser.download.");
+    let useDownloadDir = prefBranch.getBoolPref("useDownloadDir");
+
+    if (!aSkipPrompt) {
+      useDownloadDir = false;
+    }
+
+    // Default to the user's default downloads directory configured
+    // through download prefs.
+    let dirPath = await Downloads.getPreferredDownloadsDirectory();
+    let dirExists = await IOUtils.exists(dirPath);
+    let dir = new FileUtils.File(dirPath);
+
+    if (useDownloadDir && dirExists) {
+      dir.append(aFpP.fileInfo.fileName);
+      aFpP.file = uniqueFile(dir);
+      return true;
+    }
+
+    // We must prompt for the file name explicitly.
+    // If we must prompt because we were asked to...
+    let file = await new Promise(resolve => {
+      if (useDownloadDir) {
+        // Keep async behavior in both branches
+        Services.tm.dispatchToMainThread(function() {
+          resolve(null);
+        });
+      } else {
+        downloadLastDir.getFileAsync(aRelatedURI, function getFileAsyncCB(
+          aFile
+        ) {
+          resolve(aFile);
+        });
+      }
+    });
+    if (file && (await IOUtils.exists(file.path))) {
+      dir = file;
+      dirExists = true;
+    }
+
+    if (!dirExists) {
+      // Default to desktop.
+      dir = Services.dirsvc.get("Desk", Ci.nsIFile);
+    }
+
+    let fp = makeFilePicker();
+    let titleKey = aFpP.fpTitleKey || "SaveLinkTitle";
+    fp.init(
+      window,
+      ContentAreaUtils.stringBundle.GetStringFromName(titleKey),
+      Ci.nsIFilePicker.modeSave
+    );
+
+    fp.displayDirectory = dir;
+    fp.defaultExtension = aFpP.fileInfo.fileExt;
+    fp.defaultString = aFpP.fileInfo.fileName;
+    appendFiltersForContentType(
+      fp,
+      aFpP.contentType,
+      aFpP.fileInfo.fileExt,
+      aFpP.saveMode
+    );
+
+    // The index of the selected filter is only preserved and restored if there's
+    // more than one filter in addition to "All Files".
+    if (aFpP.saveMode != SAVEMODE_FILEONLY) {
+      // eslint-disable-next-line mozilla/use-default-preference-values
+      try {
+        fp.filterIndex = prefBranch.getIntPref("save_converter_index");
+      } catch (e) {}
+    }
+
+    let result = await new Promise(resolve => {
+      fp.open(function(aResult) {
+        resolve(aResult);
+      });
+    });
+    if (result == Ci.nsIFilePicker.returnCancel || !fp.file) {
+      return false;
+    }
+
+    if (aFpP.saveMode != SAVEMODE_FILEONLY) {
+      prefBranch.setIntPref("save_converter_index", fp.filterIndex);
+    }
+
+    // Do not store the last save directory as a pref inside the private browsing mode
+    downloadLastDir.setFile(aRelatedURI, fp.file.parent);
+
+    fp.file.leafName = validateFileName(fp.file.leafName);
+
+    aFpP.saveAsType = fp.filterIndex;
+    aFpP.file = fp.file;
+    aFpP.fileURL = fp.fileURL;
+
+    return true;
+  })();
+}
+
+// Since we're automatically downloading, we don't get the file picker's
+// logic to check for existing files, so we need to do that here.
+//
+// Note - this code is identical to that in
+//   mozilla/toolkit/mozapps/downloads/src/nsHelperAppDlg.js.in
+// If you are updating this code, update that code too! We can't share code
+// here since that code is called in a js component.
+function uniqueFile(aLocalFile) {
+  var collisionCount = 0;
+  while (aLocalFile.exists()) {
+    collisionCount++;
+    if (collisionCount == 1) {
+      // Append "(2)" before the last dot in (or at the end of) the filename
+      // special case .ext.gz etc files so we don't wind up with .tar(2).gz
+      if (aLocalFile.leafName.match(/\.[^\.]{1,3}\.(gz|bz2|Z)$/i)) {
+        aLocalFile.leafName = aLocalFile.leafName.replace(
+          /\.[^\.]{1,3}\.(gz|bz2|Z)$/i,
+          "(2)$&"
+        );
+      } else {
+        aLocalFile.leafName = aLocalFile.leafName.replace(
+          /(\.[^\.]*)?$/,
+          "(2)$&"
+        );
+      }
+    } else {
+      // replace the last (n) in the filename with (n+1)
+      aLocalFile.leafName = aLocalFile.leafName.replace(
+        /^(.*\()\d+\)/,
+        "$1" + (collisionCount + 1) + ")"
+      );
+    }
+  }
+  return aLocalFile;
+}
+
+/**
+ * Download a URL using the Downloads API.
+ *
+ * @param aURL
+ *        the url to download
+ * @param [optional] aFileName
+ *        the destination file name, if omitted will be obtained from the url.
+ * @param aInitiatingDocument
+ *        The document from which the download was initiated.
+ */
+function DownloadURL(aURL, aFileName, aInitiatingDocument) {
+  // For private browsing, try to get document out of the most recent browser
+  // window, or provide our own if there's no browser window.
+  let isPrivate = aInitiatingDocument.defaultView.docShell.QueryInterface(
+    Ci.nsILoadContext
+  ).usePrivateBrowsing;
+
+  let fileInfo = new FileInfo(aFileName);
+  initFileInfo(fileInfo, aURL, null, null, null, null);
+
+  let filepickerParams = {
+    fileInfo,
+    saveMode: SAVEMODE_FILEONLY,
+  };
+
+  (async function() {
+    let accepted = await promiseTargetFile(
+      filepickerParams,
+      true,
+      fileInfo.uri
+    );
+    if (!accepted) {
+      return;
+    }
+
+    let file = filepickerParams.file;
+    let download = await Downloads.createDownload({
+      source: { url: aURL, isPrivate },
+      target: { path: file.path, partFilePath: file.path + ".part" },
+    });
+    download.tryToKeepPartialData = true;
+
+    // Ignore errors because failures are reported through the download list.
+    download.start().catch(() => {});
+
+    // Add the download to the list, allowing it to be managed.
+    let list = await Downloads.getList(Downloads.ALL);
+    list.add(download);
+  })().catch(Cu.reportError);
+}
+
+// We have no DOM, and can only save the URL as is.
+const SAVEMODE_FILEONLY = 0x00;
+XPCOMUtils.defineConstant(this, "SAVEMODE_FILEONLY", SAVEMODE_FILEONLY);
+// We have a DOM and can save as complete.
+const SAVEMODE_COMPLETE_DOM = 0x01;
+XPCOMUtils.defineConstant(this, "SAVEMODE_COMPLETE_DOM", SAVEMODE_COMPLETE_DOM);
+// We have a DOM which we can serialize as text.
+const SAVEMODE_COMPLETE_TEXT = 0x02;
+XPCOMUtils.defineConstant(
+  this,
+  "SAVEMODE_COMPLETE_TEXT",
+  SAVEMODE_COMPLETE_TEXT
+);
+
+// If we are able to save a complete DOM, the 'save as complete' filter
+// must be the first filter appended.  The 'save page only' counterpart
+// must be the second filter appended.  And the 'save as complete text'
+// filter must be the third filter appended.
+function appendFiltersForContentType(
+  aFilePicker,
+  aContentType,
+  aFileExtension,
+  aSaveMode
+) {
+  // The bundle name for saving only a specific content type.
+  var bundleName;
+  // The corresponding filter string for a specific content type.
+  var filterString;
+
+  // Every case where GetSaveModeForContentType can return non-FILEONLY
+  // modes must be handled here.
+  if (aSaveMode != SAVEMODE_FILEONLY) {
+    switch (aContentType) {
+      case "text/html":
+        bundleName = "WebPageHTMLOnlyFilter";
+        filterString = "*.htm; *.html";
+        break;
+
+      case "application/xhtml+xml":
+        bundleName = "WebPageXHTMLOnlyFilter";
+        filterString = "*.xht; *.xhtml";
+        break;
+
+      case "image/svg+xml":
+        bundleName = "WebPageSVGOnlyFilter";
+        filterString = "*.svg; *.svgz";
+        break;
+
+      case "text/xml":
+      case "application/xml":
+        bundleName = "WebPageXMLOnlyFilter";
+        filterString = "*.xml";
+        break;
+    }
+  }
+
+  if (!bundleName) {
+    if (aSaveMode != SAVEMODE_FILEONLY) {
+      throw new Error(`Invalid save mode for type '${aContentType}'`);
+    }
+
+    var mimeInfo = getMIMEInfoForType(aContentType, aFileExtension);
+    if (mimeInfo) {
+      var extString = "";
+      for (var extension of mimeInfo.getFileExtensions()) {
+        if (extString) {
+          extString += "; ";
+        } // If adding more than one extension,
+        // separate by semi-colon
+        extString += "*." + extension;
+      }
+
+      if (extString) {
+        aFilePicker.appendFilter(mimeInfo.description, extString);
+      }
+    }
+  }
+
+  if (aSaveMode & SAVEMODE_COMPLETE_DOM) {
+    aFilePicker.appendFilter(
+      ContentAreaUtils.stringBundle.GetStringFromName("WebPageCompleteFilter"),
+      filterString
+    );
+    // We should always offer a choice to save document only if
+    // we allow saving as complete.
+    aFilePicker.appendFilter(
+      ContentAreaUtils.stringBundle.GetStringFromName(bundleName),
+      filterString
+    );
+  }
+
+  if (aSaveMode & SAVEMODE_COMPLETE_TEXT) {
+    aFilePicker.appendFilters(Ci.nsIFilePicker.filterText);
+  }
+
+  // Always append the all files (*) filter
+  aFilePicker.appendFilters(Ci.nsIFilePicker.filterAll);
+}
+
+function getPostData(aDocument) {
+  if (aDocument instanceof Ci.nsIWebBrowserPersistDocument) {
+    return aDocument.postData;
+  }
+  try {
+    // Find the session history entry corresponding to the given document. In
+    // the current implementation, nsIWebPageDescriptor.currentDescriptor always
+    // returns a session history entry.
+    let sessionHistoryEntry = aDocument.defaultView.docShell
+      .QueryInterface(Ci.nsIWebPageDescriptor)
+      .currentDescriptor.QueryInterface(Ci.nsISHEntry);
+    return sessionHistoryEntry.postData;
+  } catch (e) {}
+  return null;
+}
+
+function makeWebBrowserPersist() {
+  const persistContractID =
+    "@mozilla.org/embedding/browser/nsWebBrowserPersist;1";
+  const persistIID = Ci.nsIWebBrowserPersist;
+  return Cc[persistContractID].createInstance(persistIID);
+}
+
+function makeURI(aURL, aOriginCharset, aBaseURI) {
+  return Services.io.newURI(aURL, aOriginCharset, aBaseURI);
+}
+
+function makeFileURI(aFile) {
+  return Services.io.newFileURI(aFile);
+}
+
+function makeFilePicker() {
+  const fpContractID = "@mozilla.org/filepicker;1";
+  const fpIID = Ci.nsIFilePicker;
+  return Cc[fpContractID].createInstance(fpIID);
+}
+
+function getMIMEService() {
+  const mimeSvcContractID = "@mozilla.org/mime;1";
+  const mimeSvcIID = Ci.nsIMIMEService;
+  const mimeSvc = Cc[mimeSvcContractID].getService(mimeSvcIID);
+  return mimeSvc;
+}
+
+// Given aFileName, find the fileName without the extension on the end.
+function getFileBaseName(aFileName) {
+  // Remove the file extension from aFileName:
+  return aFileName.replace(/\.[^.]*$/, "");
+}
+
+function getMIMETypeForURI(aURI) {
+  try {
+    return getMIMEService().getTypeFromURI(aURI);
+  } catch (e) {}
+  return null;
+}
+
+function getMIMEInfoForType(aMIMEType, aExtension) {
+  if (aMIMEType || aExtension) {
+    try {
+      return getMIMEService().getFromTypeAndExtension(aMIMEType, aExtension);
+    } catch (e) {}
+  }
+  return null;
+}
+
+function getDefaultFileName(
+  aDefaultFileName,
+  aURI,
+  aDocument,
+  aContentDisposition
+) {
+  // 1) look for a filename in the content-disposition header, if any
+  if (aContentDisposition) {
+    const mhpContractID = "@mozilla.org/network/mime-hdrparam;1";
+    const mhpIID = Ci.nsIMIMEHeaderParam;
+    const mhp = Cc[mhpContractID].getService(mhpIID);
+    var dummy = { value: null }; // Need an out param...
+    var charset = getCharsetforSave(aDocument);
+
+    var fileName = null;
+    try {
+      fileName = mhp.getParameter(
+        aContentDisposition,
+        "filename",
+        charset,
+        true,
+        dummy
+      );
+    } catch (e) {
+      try {
+        fileName = mhp.getParameter(
+          aContentDisposition,
+          "name",
+          charset,
+          true,
+          dummy
+        );
+      } catch (e) {}
+    }
+    if (fileName) {
+      return Services.textToSubURI.unEscapeURIForUI(
+        fileName,
+        /* dontEscape = */ true
+      );
+    }
+  }
+
+  let docTitle;
+  if (aDocument && aDocument.title && aDocument.title.trim()) {
+    // If the document looks like HTML or XML, try to use its original title.
+    let contentType = aDocument.contentType;
+    if (
+      contentType == "application/xhtml+xml" ||
+      contentType == "application/xml" ||
+      contentType == "image/svg+xml" ||
+      contentType == "text/html" ||
+      contentType == "text/xml"
+    ) {
+      // 2) Use the document title
+      return aDocument.title;
+    }
+  }
+
+  try {
+    var url = aURI.QueryInterface(Ci.nsIURL);
+    if (url.fileName != "") {
+      // 3) Use the actual file name, if present
+      return Services.textToSubURI.unEscapeURIForUI(
+        url.fileName,
+        /* dontEscape = */ true
+      );
+    }
+  } catch (e) {
+    // This is something like a data: and so forth URI... no filename here.
+  }
+
+  // Don't use the title if it's from a data URI
+  if (docTitle && aURI?.scheme != "data") {
+    // 4) Use the document title
+    return docTitle;
+  }
+
+  if (aDefaultFileName) {
+    // 5) Use the caller-provided name, if any
+    return aDefaultFileName;
+  }
+
+  try {
+    if (aURI.host) {
+      // 6) Use the host.
+      return aURI.host;
+    }
+  } catch (e) {
+    // Some files have no information at all, like Javascript generated pages
+  }
+
+  return "";
+}
+
+// This is only used after the user has entered a filename.
+function validateFileName(aFileName) {
+  let processed = DownloadPaths.sanitize(aFileName) || "_";
+  if (AppConstants.platform == "android") {
+    // If a large part of the filename has been sanitized, then we
+    // will use a default filename instead
+    if (processed.replace(/_/g, "").length <= processed.length / 2) {
+      // We purposefully do not use a localized default filename,
+      // which we could have done using
+      // ContentAreaUtils.stringBundle.GetStringFromName("DefaultSaveFileName")
+      // since it may contain invalid characters.
+      var original = processed;
+      processed = "download";
+
+      // Preserve a suffix, if there is one
+      if (original.includes(".")) {
+        var suffix = original.split(".").slice(-1)[0];
+        if (suffix && !suffix.includes("_")) {
+          processed += "." + suffix;
+        }
+      }
+    }
+  }
+  return processed;
+}
+
+function GetSaveModeForContentType(aContentType, aDocument) {
+  // We can only save a complete page if we have a loaded document,
+  if (!aDocument) {
+    return SAVEMODE_FILEONLY;
+  }
+
+  // Find the possible save modes using the provided content type
+  var saveMode = SAVEMODE_FILEONLY;
+  switch (aContentType) {
+    case "text/html":
+    case "application/xhtml+xml":
+    case "image/svg+xml":
+      saveMode |= SAVEMODE_COMPLETE_TEXT;
+    // Fall through
+    case "text/xml":
+    case "application/xml":
+      saveMode |= SAVEMODE_COMPLETE_DOM;
+      break;
+  }
+
+  return saveMode;
+}
+
+function getCharsetforSave(aDocument) {
+  if (aDocument) {
+    return aDocument.characterSet;
+  }
+
+  if (document.commandDispatcher.focusedWindow) {
+    return document.commandDispatcher.focusedWindow.document.characterSet;
+  }
+
+  return window.content.document.characterSet;
+}
+
+/**
+ * Open a URL from chrome, determining if we can handle it internally or need to
+ *  launch an external application to handle it.
+ * @param aURL The URL to be opened
+ *
+ * WARNING: Please note that openURL() does not perform any content security checks!!!
+ */
+function openURL(aURL) {
+  var uri = aURL instanceof Ci.nsIURI ? aURL : makeURI(aURL);
+
+  var protocolSvc = Cc[
+    "@mozilla.org/uriloader/external-protocol-service;1"
+  ].getService(Ci.nsIExternalProtocolService);
+
+  let recentWindow = Services.wm.getMostRecentWindow("navigator:browser");
+
+  if (!protocolSvc.isExposedProtocol(uri.scheme)) {
+    // If we're not a browser, use the external protocol service to load the URI.
+    protocolSvc.loadURI(uri, recentWindow?.document.contentPrincipal);
+  } else {
+    if (recentWindow) {
+      recentWindow.openWebLinkIn(uri.spec, "tab", {
+        triggeringPrincipal: recentWindow.document.contentPrincipal,
+      });
+      return;
+    }
+
+    var loadgroup = Cc["@mozilla.org/network/load-group;1"].createInstance(
+      Ci.nsILoadGroup
+    );
+    var appstartup = Services.startup;
+
+    var loadListener = {
+      onStartRequest: function ll_start(aRequest) {
+        appstartup.enterLastWindowClosingSurvivalArea();
+      },
+      onStopRequest: function ll_stop(aRequest, aStatusCode) {
+        appstartup.exitLastWindowClosingSurvivalArea();
+      },
+      QueryInterface: ChromeUtils.generateQI([
+        "nsIRequestObserver",
+        "nsISupportsWeakReference",
+      ]),
+    };
+    loadgroup.groupObserver = loadListener;
+
+    var uriListener = {
+      doContent(ctype, preferred, request, handler) {
+        return false;
+      },
+      isPreferred(ctype, desired) {
+        return false;
+      },
+      canHandleContent(ctype, preferred, desired) {
+        return false;
+      },
+      loadCookie: null,
+      parentContentListener: null,
+      getInterface(iid) {
+        if (iid.equals(Ci.nsIURIContentListener)) {
+          return this;
+        }
+        if (iid.equals(Ci.nsILoadGroup)) {
+          return loadgroup;
+        }
+        throw Components.Exception("", Cr.NS_ERROR_NO_INTERFACE);
+      },
+    };
+
+    var channel = NetUtil.newChannel({
+      uri,
+      loadUsingSystemPrincipal: true,
+    });
+
+    if (channel) {
+      channel.channelIsForDownload = true;
+    }
+
+    var uriLoader = Cc["@mozilla.org/uriloader;1"].getService(Ci.nsIURILoader);
+    uriLoader.openURI(
+      channel,
+      Ci.nsIURILoader.IS_CONTENT_PREFERRED,
+      uriListener
+    );
+  }
+}