summaryrefslogtreecommitdiffstats
path: root/browser/components/downloads/DownloadsCommon.sys.mjs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /browser/components/downloads/DownloadsCommon.sys.mjs
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'browser/components/downloads/DownloadsCommon.sys.mjs')
-rw-r--r--browser/components/downloads/DownloadsCommon.sys.mjs1642
1 files changed, 1642 insertions, 0 deletions
diff --git a/browser/components/downloads/DownloadsCommon.sys.mjs b/browser/components/downloads/DownloadsCommon.sys.mjs
new file mode 100644
index 0000000000..c797be3ce7
--- /dev/null
+++ b/browser/components/downloads/DownloadsCommon.sys.mjs
@@ -0,0 +1,1642 @@
+/* -*- 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/. */
+
+/**
+ * Handles the Downloads panel shared methods and data access.
+ *
+ * This file includes the following constructors and global objects:
+ *
+ * DownloadsCommon
+ * This object is exposed directly to the consumers of this JavaScript module,
+ * and provides shared methods for all the instances of the user interface.
+ *
+ * DownloadsData
+ * Retrieves the list of past and completed downloads from the underlying
+ * Downloads API data, and provides asynchronous notifications allowing
+ * to build a consistent view of the available data.
+ *
+ * DownloadsIndicatorData
+ * This object registers itself with DownloadsData as a view, and transforms the
+ * notifications it receives into overall status data, that is then broadcast to
+ * the registered download status indicators.
+ */
+
+// Globals
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ DownloadHistory: "resource://gre/modules/DownloadHistory.sys.mjs",
+ DownloadUtils: "resource://gre/modules/DownloadUtils.sys.mjs",
+ Downloads: "resource://gre/modules/Downloads.sys.mjs",
+ PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
+ PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+ NetUtil: "resource://gre/modules/NetUtil.jsm",
+ BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.jsm",
+});
+
+XPCOMUtils.defineLazyServiceGetters(lazy, {
+ gClipboardHelper: [
+ "@mozilla.org/widget/clipboardhelper;1",
+ "nsIClipboardHelper",
+ ],
+ gMIMEService: ["@mozilla.org/mime;1", "nsIMIMEService"],
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "DownloadsLogger", () => {
+ let { ConsoleAPI } = ChromeUtils.importESModule(
+ "resource://gre/modules/Console.sys.mjs"
+ );
+ let consoleOptions = {
+ maxLogLevelPref: "browser.download.loglevel",
+ prefix: "Downloads",
+ };
+ return new ConsoleAPI(consoleOptions);
+});
+
+XPCOMUtils.defineLazyPreferenceGetter(
+ lazy,
+ "gAlwaysOpenPanel",
+ "browser.download.alwaysOpenPanel",
+ true
+);
+
+const kDownloadsStringBundleUrl =
+ "chrome://browser/locale/downloads/downloads.properties";
+
+const kDownloadsFluentStrings = new Localization(
+ ["browser/downloads.ftl"],
+ true
+);
+
+const kDownloadsStringsRequiringFormatting = {
+ sizeWithUnits: true,
+ statusSeparator: true,
+ statusSeparatorBeforeNumber: true,
+};
+
+const kMaxHistoryResultsForLimitedView = 42;
+
+const kPrefBranch = Services.prefs.getBranch("browser.download.");
+
+const kGenericContentTypes = [
+ "application/octet-stream",
+ "binary/octet-stream",
+ "application/unknown",
+];
+
+var PrefObserver = {
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIObserver",
+ "nsISupportsWeakReference",
+ ]),
+ getPref(name) {
+ try {
+ switch (typeof this.prefs[name]) {
+ case "boolean":
+ return kPrefBranch.getBoolPref(name);
+ }
+ } catch (ex) {}
+ return this.prefs[name];
+ },
+ observe(aSubject, aTopic, aData) {
+ if (this.prefs.hasOwnProperty(aData)) {
+ delete this[aData];
+ this[aData] = this.getPref(aData);
+ }
+ },
+ register(prefs) {
+ this.prefs = prefs;
+ kPrefBranch.addObserver("", this, true);
+ for (let key in prefs) {
+ let name = key;
+ XPCOMUtils.defineLazyGetter(this, name, function () {
+ return PrefObserver.getPref(name);
+ });
+ }
+ },
+};
+
+PrefObserver.register({
+ // prefName: defaultValue
+ openInSystemViewerContextMenuItem: true,
+ alwaysOpenInSystemViewerContextMenuItem: true,
+});
+
+// DownloadsCommon
+
+/**
+ * This object is exposed directly to the consumers of this JavaScript module,
+ * and provides shared methods for all the instances of the user interface.
+ */
+export var DownloadsCommon = {
+ // The following legacy constants are still returned by stateOfDownload, but
+ // individual properties of the Download object should normally be used.
+ DOWNLOAD_NOTSTARTED: -1,
+ DOWNLOAD_DOWNLOADING: 0,
+ DOWNLOAD_FINISHED: 1,
+ DOWNLOAD_FAILED: 2,
+ DOWNLOAD_CANCELED: 3,
+ DOWNLOAD_PAUSED: 4,
+ DOWNLOAD_BLOCKED_PARENTAL: 6,
+ DOWNLOAD_DIRTY: 8,
+ DOWNLOAD_BLOCKED_POLICY: 9,
+
+ // The following are the possible values of the "attention" property.
+ ATTENTION_NONE: "",
+ ATTENTION_SUCCESS: "success",
+ ATTENTION_INFO: "info",
+ ATTENTION_WARNING: "warning",
+ ATTENTION_SEVERE: "severe",
+
+ // Bit flags for the attentionSuppressed property.
+ SUPPRESS_NONE: 0,
+ SUPPRESS_PANEL_OPEN: 1,
+ SUPPRESS_ALL_DOWNLOADS_OPEN: 2,
+ SUPPRESS_CONTENT_AREA_DOWNLOADS_OPEN: 4,
+
+ /**
+ * Returns an object whose keys are the string names from the downloads string
+ * bundle, and whose values are either the translated strings or functions
+ * returning formatted strings.
+ */
+ get strings() {
+ let strings = {};
+ let sb = Services.strings.createBundle(kDownloadsStringBundleUrl);
+ for (let string of sb.getSimpleEnumeration()) {
+ let stringName = string.key;
+ if (stringName in kDownloadsStringsRequiringFormatting) {
+ strings[stringName] = function () {
+ // Convert "arguments" to a real array before calling into XPCOM.
+ return sb.formatStringFromName(stringName, Array.from(arguments));
+ };
+ } else {
+ strings[stringName] = string.value;
+ }
+ }
+ delete this.strings;
+ return (this.strings = strings);
+ },
+
+ /**
+ * Indicates whether or not to show the 'Open in system viewer' context menu item when appropriate
+ */
+ get openInSystemViewerItemEnabled() {
+ return PrefObserver.openInSystemViewerContextMenuItem;
+ },
+
+ /**
+ * Indicates whether or not to show the 'Always open...' context menu item when appropriate
+ */
+ get alwaysOpenInSystemViewerItemEnabled() {
+ return PrefObserver.alwaysOpenInSystemViewerContextMenuItem;
+ },
+
+ /**
+ * Get access to one of the DownloadsData, PrivateDownloadsData, or
+ * HistoryDownloadsData objects, depending on the privacy status of the
+ * specified window and on whether history downloads should be included.
+ *
+ * @param [optional] window
+ * The browser window which owns the download button.
+ * If not given, the privacy status will be assumed as non-private.
+ * @param [optional] history
+ * True to include history downloads when the window is public.
+ * @param [optional] privateAll
+ * Whether to force the public downloads data to be returned together
+ * with the private downloads data for a private window.
+ * @param [optional] limited
+ * True to limit the amount of downloads returned to
+ * `kMaxHistoryResultsForLimitedView`.
+ */
+ getData(window, history = false, privateAll = false, limited = false) {
+ let isPrivate =
+ window && lazy.PrivateBrowsingUtils.isContentWindowPrivate(window);
+ if (isPrivate && !privateAll) {
+ return lazy.PrivateDownloadsData;
+ }
+ if (history) {
+ if (isPrivate && privateAll) {
+ return lazy.LimitedPrivateHistoryDownloadData;
+ }
+ return limited
+ ? lazy.LimitedHistoryDownloadsData
+ : lazy.HistoryDownloadsData;
+ }
+ return lazy.DownloadsData;
+ },
+
+ /**
+ * Initializes the Downloads back-end and starts receiving events for both the
+ * private and non-private downloads data objects.
+ */
+ initializeAllDataLinks() {
+ lazy.DownloadsData.initializeDataLink();
+ lazy.PrivateDownloadsData.initializeDataLink();
+ },
+
+ /**
+ * Get access to one of the DownloadsIndicatorData or
+ * PrivateDownloadsIndicatorData objects, depending on the privacy status of
+ * the window in question.
+ */
+ getIndicatorData(aWindow) {
+ if (lazy.PrivateBrowsingUtils.isContentWindowPrivate(aWindow)) {
+ return lazy.PrivateDownloadsIndicatorData;
+ }
+ return lazy.DownloadsIndicatorData;
+ },
+
+ /**
+ * Returns a reference to the DownloadsSummaryData singleton - creating one
+ * in the process if one hasn't been instantiated yet.
+ *
+ * @param aWindow
+ * The browser window which owns the download button.
+ * @param aNumToExclude
+ * The number of items on the top of the downloads list to exclude
+ * from the summary.
+ */
+ getSummary(aWindow, aNumToExclude) {
+ if (lazy.PrivateBrowsingUtils.isContentWindowPrivate(aWindow)) {
+ if (this._privateSummary) {
+ return this._privateSummary;
+ }
+ return (this._privateSummary = new DownloadsSummaryData(
+ true,
+ aNumToExclude
+ ));
+ }
+ if (this._summary) {
+ return this._summary;
+ }
+ return (this._summary = new DownloadsSummaryData(false, aNumToExclude));
+ },
+ _summary: null,
+ _privateSummary: null,
+
+ /**
+ * Returns the legacy state integer value for the provided Download object.
+ */
+ stateOfDownload(download) {
+ // Collapse state using the correct priority.
+ if (!download.stopped) {
+ return DownloadsCommon.DOWNLOAD_DOWNLOADING;
+ }
+ if (download.succeeded) {
+ return DownloadsCommon.DOWNLOAD_FINISHED;
+ }
+ if (download.error) {
+ if (download.error.becauseBlockedByParentalControls) {
+ return DownloadsCommon.DOWNLOAD_BLOCKED_PARENTAL;
+ }
+ if (download.error.becauseBlockedByReputationCheck) {
+ return DownloadsCommon.DOWNLOAD_DIRTY;
+ }
+ return DownloadsCommon.DOWNLOAD_FAILED;
+ }
+ if (download.canceled) {
+ if (download.hasPartialData) {
+ return DownloadsCommon.DOWNLOAD_PAUSED;
+ }
+ return DownloadsCommon.DOWNLOAD_CANCELED;
+ }
+ return DownloadsCommon.DOWNLOAD_NOTSTARTED;
+ },
+
+ /**
+ * Removes a Download object from both session and history downloads.
+ */
+ async deleteDownload(download) {
+ // Check hasBlockedData to avoid double counting if you click the X button
+ // in the Libarary view and then delete the download from the history.
+ if (
+ download.error?.becauseBlockedByReputationCheck &&
+ download.hasBlockedData
+ ) {
+ Services.telemetry
+ .getKeyedHistogramById("DOWNLOADS_USER_ACTION_ON_BLOCKED_DOWNLOAD")
+ .add(download.error.reputationCheckVerdict, 1); // confirm block
+ }
+
+ // Remove the associated history element first, if any, so that the views
+ // that combine history and session downloads won't resurrect the history
+ // download into the view just before it is deleted permanently.
+ try {
+ await lazy.PlacesUtils.history.remove(download.source.url);
+ } catch (ex) {
+ console.error(ex);
+ }
+ let list = await lazy.Downloads.getList(lazy.Downloads.ALL);
+ await list.remove(download);
+ await download.finalize(true);
+ },
+
+ /**
+ * Deletes all files associated with a download, with or without removing it
+ * from the session downloads list and/or download history.
+ *
+ * @param download
+ * The download to delete and/or forget.
+ * @param clearHistory
+ * Optional. Removes history from session downloads list or history.
+ * 0 - Don't remove the download from session list or history.
+ * 1 - Remove the download from session list, but not history.
+ * 2 - Remove the download from both session list and history.
+ */
+ async deleteDownloadFiles(download, clearHistory = 0) {
+ if (clearHistory > 1) {
+ try {
+ await lazy.PlacesUtils.history.remove(download.source.url);
+ } catch (ex) {
+ console.error(ex);
+ }
+ }
+ if (clearHistory > 0) {
+ let list = await lazy.Downloads.getList(lazy.Downloads.ALL);
+ await list.remove(download);
+ }
+ await download.manuallyRemoveData();
+ if (clearHistory < 2) {
+ lazy.DownloadHistory.updateMetaData(download).catch(console.error);
+ }
+ },
+
+ /**
+ * Get a nsIMIMEInfo object for a download
+ */
+ getMimeInfo(download) {
+ if (!download.succeeded) {
+ return null;
+ }
+ let contentType = download.contentType;
+ let url = Cc["@mozilla.org/network/standard-url-mutator;1"]
+ .createInstance(Ci.nsIURIMutator)
+ .setSpec("http://example.com") // construct the URL
+ .setFilePath(download.target.path)
+ .finalize()
+ .QueryInterface(Ci.nsIURL);
+ let fileExtension = url.fileExtension;
+
+ // look at file extension if there's no contentType or it is generic
+ if (!contentType || kGenericContentTypes.includes(contentType)) {
+ try {
+ contentType = lazy.gMIMEService.getTypeFromExtension(fileExtension);
+ } catch (ex) {
+ DownloadsCommon.log(
+ "Cant get mimeType from file extension: ",
+ fileExtension
+ );
+ }
+ }
+ if (!(contentType || fileExtension)) {
+ return null;
+ }
+ let mimeInfo = null;
+ try {
+ mimeInfo = lazy.gMIMEService.getFromTypeAndExtension(
+ contentType || "",
+ fileExtension || ""
+ );
+ } catch (ex) {
+ DownloadsCommon.log(
+ "Can't get nsIMIMEInfo for contentType: ",
+ contentType,
+ "and fileExtension:",
+ fileExtension
+ );
+ }
+ return mimeInfo;
+ },
+
+ /**
+ * Confirm if the download exists on the filesystem and is a given mime-type
+ */
+ isFileOfType(download, mimeType) {
+ if (!(download.succeeded && download.target?.exists)) {
+ DownloadsCommon.log(
+ `isFileOfType returning false for mimeType: ${mimeType}, succeeded: ${download.succeeded}, exists: ${download.target?.exists}`
+ );
+ return false;
+ }
+ let mimeInfo = DownloadsCommon.getMimeInfo(download);
+ return mimeInfo?.type === mimeType.toLowerCase();
+ },
+
+ /**
+ * Copies the source URI of the given Download object to the clipboard.
+ */
+ copyDownloadLink(download) {
+ lazy.gClipboardHelper.copyString(
+ download.source.originalUrl || download.source.url
+ );
+ },
+
+ /**
+ * Given an iterable collection of Download objects, generates and returns
+ * statistics about that collection.
+ *
+ * @param downloads An iterable collection of Download objects.
+ *
+ * @return Object whose properties are the generated statistics. Currently,
+ * we return the following properties:
+ *
+ * numActive : The total number of downloads.
+ * numPaused : The total number of paused downloads.
+ * numDownloading : The total number of downloads being downloaded.
+ * totalSize : The total size of all downloads once completed.
+ * totalTransferred: The total amount of transferred data for these
+ * downloads.
+ * slowestSpeed : The slowest download rate.
+ * rawTimeLeft : The estimated time left for the downloads to
+ * complete.
+ * percentComplete : The percentage of bytes successfully downloaded.
+ */
+ summarizeDownloads(downloads) {
+ let summary = {
+ numActive: 0,
+ numPaused: 0,
+ numDownloading: 0,
+ totalSize: 0,
+ totalTransferred: 0,
+ // slowestSpeed is Infinity so that we can use Math.min to
+ // find the slowest speed. We'll set this to 0 afterwards if
+ // it's still at Infinity by the time we're done iterating all
+ // download.
+ slowestSpeed: Infinity,
+ rawTimeLeft: -1,
+ percentComplete: -1,
+ };
+
+ for (let download of downloads) {
+ summary.numActive++;
+
+ if (!download.stopped) {
+ summary.numDownloading++;
+ if (download.hasProgress && download.speed > 0) {
+ let sizeLeft = download.totalBytes - download.currentBytes;
+ summary.rawTimeLeft = Math.max(
+ summary.rawTimeLeft,
+ sizeLeft / download.speed
+ );
+ summary.slowestSpeed = Math.min(summary.slowestSpeed, download.speed);
+ }
+ } else if (download.canceled && download.hasPartialData) {
+ summary.numPaused++;
+ }
+
+ // Only add to total values if we actually know the download size.
+ if (download.succeeded) {
+ summary.totalSize += download.target.size;
+ summary.totalTransferred += download.target.size;
+ } else if (download.hasProgress) {
+ summary.totalSize += download.totalBytes;
+ summary.totalTransferred += download.currentBytes;
+ }
+ }
+
+ if (summary.totalSize != 0) {
+ summary.percentComplete = Math.floor(
+ (summary.totalTransferred / summary.totalSize) * 100
+ );
+ }
+
+ if (summary.slowestSpeed == Infinity) {
+ summary.slowestSpeed = 0;
+ }
+
+ return summary;
+ },
+
+ /**
+ * If necessary, smooths the estimated number of seconds remaining for one
+ * or more downloads to complete.
+ *
+ * @param aSeconds
+ * Current raw estimate on number of seconds left for one or more
+ * downloads. This is a floating point value to help get sub-second
+ * accuracy for current and future estimates.
+ */
+ smoothSeconds(aSeconds, aLastSeconds) {
+ // We apply an algorithm similar to the DownloadUtils.getTimeLeft function,
+ // though tailored to a single time estimation for all downloads. We never
+ // apply something if the new value is less than half the previous value.
+ let shouldApplySmoothing = aLastSeconds >= 0 && aSeconds > aLastSeconds / 2;
+ if (shouldApplySmoothing) {
+ // Apply hysteresis to favor downward over upward swings. Trust only 30%
+ // of the new value if lower, and 10% if higher (exponential smoothing).
+ let diff = aSeconds - aLastSeconds;
+ aSeconds = aLastSeconds + (diff < 0 ? 0.3 : 0.1) * diff;
+
+ // If the new time is similar, reuse something close to the last time
+ // left, but subtract a little to provide forward progress.
+ diff = aSeconds - aLastSeconds;
+ let diffPercent = (diff / aLastSeconds) * 100;
+ if (Math.abs(diff) < 5 || Math.abs(diffPercent) < 5) {
+ aSeconds = aLastSeconds - (diff < 0 ? 0.4 : 0.2);
+ }
+ }
+
+ // In the last few seconds of downloading, we are always subtracting and
+ // never adding to the time left. Ensure that we never fall below one
+ // second left until all downloads are actually finished.
+ return (aLastSeconds = Math.max(aSeconds, 1));
+ },
+
+ /**
+ * Opens a downloaded file.
+ *
+ * @param downloadProperties
+ * A Download object or the initial properties of a serialized download
+ * @param options.openWhere
+ * Optional string indicating how to handle opening a download target file URI.
+ * One of "window", "tab", "tabshifted".
+ * @param options.useSystemDefault
+ * Optional value indicating how to handle launching this download,
+ * this call only. Will override the associated mimeInfo.preferredAction
+ * @return {Promise}
+ * @resolves When the instruction to launch the file has been
+ * successfully given to the operating system or handled internally
+ * @rejects JavaScript exception if there was an error trying to launch
+ * the file.
+ */
+ async openDownload(download, options) {
+ // some download objects got serialized and need reconstituting
+ if (typeof download.launch !== "function") {
+ download = await lazy.Downloads.createDownload(download);
+ }
+ return download.launch(options).catch(ex => console.error(ex));
+ },
+
+ /**
+ * Show a downloaded file in the system file manager.
+ *
+ * @param aFile
+ * a downloaded file.
+ */
+ showDownloadedFile(aFile) {
+ if (!(aFile instanceof Ci.nsIFile)) {
+ throw new Error("aFile must be a nsIFile object");
+ }
+ try {
+ // Show the directory containing the file and select the file.
+ aFile.reveal();
+ } 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 = aFile.parent;
+ if (parent) {
+ this.showDirectory(parent);
+ }
+ }
+ },
+
+ /**
+ * Show the specified folder in the system file manager.
+ *
+ * @param aDirectory
+ * a directory to be opened with system file manager.
+ */
+ showDirectory(aDirectory) {
+ if (!(aDirectory instanceof Ci.nsIFile)) {
+ throw new Error("aDirectory must be a nsIFile object");
+ }
+ try {
+ aDirectory.launch();
+ } catch (ex) {
+ // If launch fails (probably because it's not implemented), let
+ // the OS handler try to open the directory.
+ Cc["@mozilla.org/uriloader/external-protocol-service;1"]
+ .getService(Ci.nsIExternalProtocolService)
+ .loadURI(
+ lazy.NetUtil.newURI(aDirectory),
+ Services.scriptSecurityManager.getSystemPrincipal()
+ );
+ }
+ },
+
+ /**
+ * Displays an alert message box which asks the user if they want to
+ * unblock the downloaded file or not.
+ *
+ * @param options
+ * An object with the following properties:
+ * {
+ * verdict:
+ * The detailed reason why the download was blocked, according to
+ * the "Downloads.Error.BLOCK_VERDICT_" constants. If an unknown
+ * reason is specified, "Downloads.Error.BLOCK_VERDICT_MALWARE" is
+ * assumed.
+ * window:
+ * The window with which this action is associated.
+ * dialogType:
+ * String that determines which actions are available:
+ * - "unblock" to offer just "unblock".
+ * - "chooseUnblock" to offer "unblock" and "confirmBlock".
+ * - "chooseOpen" to offer "open" and "confirmBlock".
+ * }
+ *
+ * @return {Promise}
+ * @resolves String representing the action that should be executed:
+ * - "open" to allow the download and open the file.
+ * - "unblock" to allow the download without opening the file.
+ * - "confirmBlock" to delete the blocked data permanently.
+ * - "cancel" to do nothing and cancel the operation.
+ */
+ async confirmUnblockDownload({ verdict, window, dialogType }) {
+ let s = DownloadsCommon.strings;
+
+ // All the dialogs have an action button and a cancel button, while only
+ // some of them have an additonal button to remove the file. The cancel
+ // button must always be the one at BUTTON_POS_1 because this is the value
+ // returned by confirmEx when using ESC or closing the dialog (bug 345067).
+ let title = s.unblockHeaderUnblock;
+ let firstButtonText = s.unblockButtonUnblock;
+ let firstButtonAction = "unblock";
+ let buttonFlags =
+ Ci.nsIPrompt.BUTTON_TITLE_IS_STRING * Ci.nsIPrompt.BUTTON_POS_0 +
+ Ci.nsIPrompt.BUTTON_TITLE_CANCEL * Ci.nsIPrompt.BUTTON_POS_1;
+
+ switch (dialogType) {
+ case "unblock":
+ // Use only the unblock action. The default is to cancel.
+ buttonFlags += Ci.nsIPrompt.BUTTON_POS_1_DEFAULT;
+ break;
+ case "chooseUnblock":
+ // Use the unblock and remove file actions. The default is remove file.
+ buttonFlags +=
+ Ci.nsIPrompt.BUTTON_TITLE_IS_STRING * Ci.nsIPrompt.BUTTON_POS_2 +
+ Ci.nsIPrompt.BUTTON_POS_2_DEFAULT;
+ break;
+ case "chooseOpen":
+ // Use the unblock and open file actions. The default is open file.
+ title = s.unblockHeaderOpen;
+ firstButtonText = s.unblockButtonOpen;
+ firstButtonAction = "open";
+ buttonFlags +=
+ Ci.nsIPrompt.BUTTON_TITLE_IS_STRING * Ci.nsIPrompt.BUTTON_POS_2 +
+ Ci.nsIPrompt.BUTTON_POS_0_DEFAULT;
+ break;
+ default:
+ console.error("Unexpected dialog type: " + dialogType);
+ return "cancel";
+ }
+
+ let message;
+ switch (verdict) {
+ case lazy.Downloads.Error.BLOCK_VERDICT_UNCOMMON:
+ message = s.unblockTypeUncommon2;
+ break;
+ case lazy.Downloads.Error.BLOCK_VERDICT_POTENTIALLY_UNWANTED:
+ message = s.unblockTypePotentiallyUnwanted2;
+ break;
+ case lazy.Downloads.Error.BLOCK_VERDICT_INSECURE:
+ message = s.unblockInsecure2;
+ break;
+ default:
+ // Assume Downloads.Error.BLOCK_VERDICT_MALWARE
+ message = s.unblockTypeMalware;
+ break;
+ }
+ message += "\n\n" + s.unblockTip2;
+
+ Services.ww.registerNotification(function onOpen(subj, topic) {
+ if (topic == "domwindowopened" && subj instanceof Ci.nsIDOMWindow) {
+ // Make sure to listen for "DOMContentLoaded" because it is fired
+ // before the "load" event.
+ subj.addEventListener(
+ "DOMContentLoaded",
+ function () {
+ if (
+ subj.document.documentURI ==
+ "chrome://global/content/commonDialog.xhtml"
+ ) {
+ Services.ww.unregisterNotification(onOpen);
+ let dialog = subj.document.getElementById("commonDialog");
+ if (dialog) {
+ // Change the dialog to use a warning icon.
+ dialog.classList.add("alert-dialog");
+ }
+ }
+ },
+ { once: true }
+ );
+ }
+ });
+
+ let rv = Services.prompt.confirmEx(
+ window,
+ title,
+ message,
+ buttonFlags,
+ firstButtonText,
+ null,
+ s.unblockButtonConfirmBlock,
+ null,
+ {}
+ );
+ return [firstButtonAction, "cancel", "confirmBlock"][rv];
+ },
+};
+
+XPCOMUtils.defineLazyGetter(DownloadsCommon, "log", () => {
+ return lazy.DownloadsLogger.log.bind(lazy.DownloadsLogger);
+});
+XPCOMUtils.defineLazyGetter(DownloadsCommon, "error", () => {
+ return lazy.DownloadsLogger.error.bind(lazy.DownloadsLogger);
+});
+
+// DownloadsData
+
+/**
+ * Retrieves the list of past and completed downloads from the underlying
+ * Downloads API data, and provides asynchronous notifications allowing to
+ * build a consistent view of the available data.
+ *
+ * Note that using this object does not automatically initialize the list of
+ * downloads. This is useful to display a neutral progress indicator in
+ * the main browser window until the autostart timeout elapses.
+ *
+ * This powers the DownloadsData, PrivateDownloadsData, and HistoryDownloadsData
+ * singleton objects.
+ */
+function DownloadsDataCtor({ isPrivate, isHistory, maxHistoryResults } = {}) {
+ this._isPrivate = !!isPrivate;
+
+ // Contains all the available Download objects and their integer state.
+ this._oldDownloadStates = new WeakMap();
+
+ // For the history downloads list we don't need to register this as a view,
+ // but we have to ensure that the DownloadsData object is initialized before
+ // we register more views. This ensures that the view methods of DownloadsData
+ // are invoked before those of views registered on HistoryDownloadsData,
+ // allowing the endTime property to be set correctly.
+ if (isHistory) {
+ if (isPrivate) {
+ lazy.PrivateDownloadsData.initializeDataLink();
+ }
+ lazy.DownloadsData.initializeDataLink();
+ this._promiseList = lazy.DownloadsData._promiseList.then(() => {
+ // For history downloads in Private Browsing mode, we'll fetch the combined
+ // list of public and private downloads.
+ return lazy.DownloadHistory.getList({
+ type: isPrivate ? lazy.Downloads.ALL : lazy.Downloads.PUBLIC,
+ maxHistoryResults,
+ });
+ });
+ return;
+ }
+
+ // This defines "initializeDataLink" and "_promiseList" synchronously, then
+ // continues execution only when "initializeDataLink" is called, allowing the
+ // underlying data to be loaded only when actually needed.
+ this._promiseList = (async () => {
+ await new Promise(resolve => (this.initializeDataLink = resolve));
+ let list = await lazy.Downloads.getList(
+ isPrivate ? lazy.Downloads.PRIVATE : lazy.Downloads.PUBLIC
+ );
+ await list.addView(this);
+ return list;
+ })();
+}
+
+DownloadsDataCtor.prototype = {
+ /**
+ * Starts receiving events for current downloads.
+ */
+ initializeDataLink() {},
+
+ /**
+ * Promise resolved with the underlying DownloadList object once we started
+ * receiving events for current downloads.
+ */
+ _promiseList: null,
+
+ /**
+ * Iterator for all the available Download objects. This is empty until the
+ * data has been loaded using the JavaScript API for downloads.
+ */
+ get _downloads() {
+ return ChromeUtils.nondeterministicGetWeakMapKeys(this._oldDownloadStates);
+ },
+
+ /**
+ * True if there are finished downloads that can be removed from the list.
+ */
+ get canRemoveFinished() {
+ for (let download of this._downloads) {
+ // Stopped, paused, and failed downloads with partial data are removed.
+ if (download.stopped && !(download.canceled && download.hasPartialData)) {
+ return true;
+ }
+ }
+ return false;
+ },
+
+ /**
+ * Asks the back-end to remove finished downloads from the list. This method
+ * is only called after the data link has been initialized.
+ */
+ removeFinished() {
+ lazy.Downloads.getList(
+ this._isPrivate ? lazy.Downloads.PRIVATE : lazy.Downloads.PUBLIC
+ )
+ .then(list => list.removeFinished())
+ .catch(console.error);
+ },
+
+ // Integration with the asynchronous Downloads back-end
+
+ onDownloadAdded(download) {
+ // Download objects do not store the end time of downloads, as the Downloads
+ // API does not need to persist this information for all platforms. Once a
+ // download terminates on a Desktop browser, it becomes a history download,
+ // for which the end time is stored differently, as a Places annotation.
+ download.endTime = Date.now();
+
+ this._oldDownloadStates.set(
+ download,
+ DownloadsCommon.stateOfDownload(download)
+ );
+ if (download.error?.becauseBlockedByReputationCheck) {
+ this._notifyDownloadEvent("error");
+ }
+ },
+
+ onDownloadChanged(download) {
+ let oldState = this._oldDownloadStates.get(download);
+ let newState = DownloadsCommon.stateOfDownload(download);
+ this._oldDownloadStates.set(download, newState);
+
+ if (oldState != newState) {
+ if (
+ download.succeeded ||
+ (download.canceled && !download.hasPartialData) ||
+ download.error
+ ) {
+ // Store the end time that may be displayed by the views.
+ download.endTime = Date.now();
+
+ // This state transition code should actually be located in a Downloads
+ // API module (bug 941009).
+ lazy.DownloadHistory.updateMetaData(download).catch(console.error);
+ }
+
+ if (
+ download.succeeded ||
+ (download.error && download.error.becauseBlocked)
+ ) {
+ this._notifyDownloadEvent("finish");
+ }
+ }
+
+ if (!download.newDownloadNotified) {
+ download.newDownloadNotified = true;
+ this._notifyDownloadEvent("start", {
+ openDownloadsListOnStart: download.openDownloadsListOnStart,
+ });
+ }
+ },
+
+ onDownloadRemoved(download) {
+ this._oldDownloadStates.delete(download);
+ },
+
+ // Registration of views
+
+ /**
+ * Adds an object to be notified when the available download data changes.
+ * The specified object is initialized with the currently available downloads.
+ *
+ * @param aView
+ * DownloadsView object to be added. This reference must be passed to
+ * removeView before termination.
+ */
+ addView(aView) {
+ this._promiseList.then(list => list.addView(aView)).catch(console.error);
+ },
+
+ /**
+ * Removes an object previously added using addView.
+ *
+ * @param aView
+ * DownloadsView object to be removed.
+ */
+ removeView(aView) {
+ this._promiseList.then(list => list.removeView(aView)).catch(console.error);
+ },
+
+ // Notifications sent to the most recent browser window only
+
+ /**
+ * Set to true after the first download causes the downloads panel to be
+ * displayed.
+ */
+ get panelHasShownBefore() {
+ try {
+ return Services.prefs.getBoolPref("browser.download.panel.shown");
+ } catch (ex) {}
+ return false;
+ },
+
+ set panelHasShownBefore(aValue) {
+ Services.prefs.setBoolPref("browser.download.panel.shown", aValue);
+ },
+
+ /**
+ * Displays a new or finished download notification in the most recent browser
+ * window, if one is currently available with the required privacy type.
+ * @param {string} aType
+ * Set to "start" for new downloads, "finish" for completed downloads,
+ * "error" for downloads that failed and need attention
+ * @param {boolean} [openDownloadsListOnStart]
+ * (Only relevant when aType = "start")
+ * true (default) - open the downloads panel.
+ * false - only show an indicator notification.
+ */
+ _notifyDownloadEvent(aType, { openDownloadsListOnStart = true } = {}) {
+ DownloadsCommon.log(
+ "Attempting to notify that a new download has started or finished."
+ );
+
+ // Show the panel in the most recent browser window, if present.
+ let browserWin = lazy.BrowserWindowTracker.getTopWindow({
+ private: this._isPrivate,
+ });
+ if (!browserWin) {
+ return;
+ }
+
+ let shouldOpenDownloadsPanel =
+ aType == "start" &&
+ DownloadsCommon.summarizeDownloads(this._downloads).numDownloading <= 1 &&
+ lazy.gAlwaysOpenPanel;
+
+ // For new downloads after the first one, don't show the panel
+ // automatically, but provide a visible notification in the topmost browser
+ // window, if the status indicator is already visible. Also ensure that if
+ // openDownloadsListOnStart = false is passed, we always skip opening the
+ // panel. That's because this will only be passed if the download is started
+ // without user interaction or if a dialog was previously opened in the
+ // process of the download (e.g. unknown content type dialog).
+ if (
+ aType != "error" &&
+ ((this.panelHasShownBefore && !shouldOpenDownloadsPanel) ||
+ !openDownloadsListOnStart ||
+ browserWin != Services.focus.activeWindow)
+ ) {
+ DownloadsCommon.log("Showing new download notification.");
+ browserWin.DownloadsIndicatorView.showEventNotification(aType);
+ return;
+ }
+ this.panelHasShownBefore = true;
+ browserWin.DownloadsPanel.showPanel();
+ },
+};
+
+XPCOMUtils.defineLazyGetter(lazy, "HistoryDownloadsData", function () {
+ return new DownloadsDataCtor({ isHistory: true });
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "LimitedHistoryDownloadsData", function () {
+ return new DownloadsDataCtor({
+ isHistory: true,
+ maxHistoryResults: kMaxHistoryResultsForLimitedView,
+ });
+});
+
+XPCOMUtils.defineLazyGetter(
+ lazy,
+ "LimitedPrivateHistoryDownloadData",
+ function () {
+ return new DownloadsDataCtor({
+ isPrivate: true,
+ isHistory: true,
+ maxHistoryResults: kMaxHistoryResultsForLimitedView,
+ });
+ }
+);
+
+XPCOMUtils.defineLazyGetter(lazy, "PrivateDownloadsData", function () {
+ return new DownloadsDataCtor({ isPrivate: true });
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "DownloadsData", function () {
+ return new DownloadsDataCtor();
+});
+
+// DownloadsViewPrototype
+
+/**
+ * A prototype for an object that registers itself with DownloadsData as soon
+ * as a view is registered with it.
+ */
+const DownloadsViewPrototype = {
+ /**
+ * Contains all the available Download objects and their current state value.
+ *
+ * SUBCLASSES MUST OVERRIDE THIS PROPERTY.
+ */
+ _oldDownloadStates: null,
+
+ // Registration of views
+
+ /**
+ * Array of view objects that should be notified when the available status
+ * data changes.
+ *
+ * SUBCLASSES MUST OVERRIDE THIS PROPERTY.
+ */
+ _views: null,
+
+ /**
+ * Determines whether this view object is over the private or non-private
+ * downloads.
+ *
+ * SUBCLASSES MUST OVERRIDE THIS PROPERTY.
+ */
+ _isPrivate: false,
+
+ /**
+ * Adds an object to be notified when the available status data changes.
+ * The specified object is initialized with the currently available status.
+ *
+ * @param aView
+ * View object to be added. This reference must be
+ * passed to removeView before termination.
+ */
+ addView(aView) {
+ // Start receiving events when the first of our views is registered.
+ if (!this._views.length) {
+ if (this._isPrivate) {
+ lazy.PrivateDownloadsData.addView(this);
+ } else {
+ lazy.DownloadsData.addView(this);
+ }
+ }
+
+ this._views.push(aView);
+ this.refreshView(aView);
+ },
+
+ /**
+ * Updates the properties of an object previously added using addView.
+ *
+ * @param aView
+ * View object to be updated.
+ */
+ refreshView(aView) {
+ // Update immediately even if we are still loading data asynchronously.
+ // Subclasses must provide these two functions!
+ this._refreshProperties();
+ this._updateView(aView);
+ },
+
+ /**
+ * Removes an object previously added using addView.
+ *
+ * @param aView
+ * View object to be removed.
+ */
+ removeView(aView) {
+ let index = this._views.indexOf(aView);
+ if (index != -1) {
+ this._views.splice(index, 1);
+ }
+
+ // Stop receiving events when the last of our views is unregistered.
+ if (!this._views.length) {
+ if (this._isPrivate) {
+ lazy.PrivateDownloadsData.removeView(this);
+ } else {
+ lazy.DownloadsData.removeView(this);
+ }
+ }
+ },
+
+ // Callback functions from DownloadList
+
+ /**
+ * Indicates whether we are still loading downloads data asynchronously.
+ */
+ _loading: false,
+
+ /**
+ * Called before multiple downloads are about to be loaded.
+ */
+ onDownloadBatchStarting() {
+ this._loading = true;
+ },
+
+ /**
+ * Called after data loading finished.
+ */
+ onDownloadBatchEnded() {
+ this._loading = false;
+ this._updateViews();
+ },
+
+ /**
+ * Called when a new download data item is available, either during the
+ * asynchronous data load or when a new download is started.
+ *
+ * @param download
+ * Download object that was just added.
+ *
+ * @note Subclasses should override this and still call the base method.
+ */
+ onDownloadAdded(download) {
+ this._oldDownloadStates.set(
+ download,
+ DownloadsCommon.stateOfDownload(download)
+ );
+ },
+
+ /**
+ * Called when the overall state of a Download has changed. In particular,
+ * this is called only once when the download succeeds or is blocked
+ * permanently, and is never called if only the current progress changed.
+ *
+ * The onDownloadChanged notification will always be sent afterwards.
+ *
+ * @note Subclasses should override this.
+ */
+ onDownloadStateChanged(download) {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+ },
+
+ /**
+ * Called every time any state property of a Download may have changed,
+ * including progress properties.
+ *
+ * Note that progress notification changes are throttled at the Downloads.sys.mjs
+ * API level, and there is no throttling mechanism in the front-end.
+ *
+ * @note Subclasses should override this and still call the base method.
+ */
+ onDownloadChanged(download) {
+ let oldState = this._oldDownloadStates.get(download);
+ let newState = DownloadsCommon.stateOfDownload(download);
+ this._oldDownloadStates.set(download, newState);
+
+ if (oldState != newState) {
+ this.onDownloadStateChanged(download);
+ }
+ },
+
+ /**
+ * Called when a data item is removed, ensures that the widget associated with
+ * the view item is removed from the user interface.
+ *
+ * @param download
+ * Download object that is being removed.
+ *
+ * @note Subclasses should override this.
+ */
+ onDownloadRemoved(download) {
+ this._oldDownloadStates.delete(download);
+ },
+
+ /**
+ * Private function used to refresh the internal properties being sent to
+ * each registered view.
+ *
+ * @note Subclasses should override this.
+ */
+ _refreshProperties() {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+ },
+
+ /**
+ * Private function used to refresh an individual view.
+ *
+ * @note Subclasses should override this.
+ */
+ _updateView() {
+ throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+ },
+
+ /**
+ * Computes aggregate values and propagates the changes to our views.
+ */
+ _updateViews() {
+ // Do not update the status indicators during batch loads of download items.
+ if (this._loading) {
+ return;
+ }
+
+ this._refreshProperties();
+ this._views.forEach(this._updateView, this);
+ },
+};
+
+// DownloadsIndicatorData
+
+/**
+ * This object registers itself with DownloadsData as a view, and transforms the
+ * notifications it receives into overall status data, that is then broadcast to
+ * the registered download status indicators.
+ *
+ * Note that using this object does not automatically start the Download Manager
+ * service. Consumers will see an empty list of downloads until the service is
+ * actually started. This is useful to display a neutral progress indicator in
+ * the main browser window until the autostart timeout elapses.
+ */
+function DownloadsIndicatorDataCtor(aPrivate) {
+ this._oldDownloadStates = new WeakMap();
+ this._isPrivate = aPrivate;
+ this._views = [];
+}
+DownloadsIndicatorDataCtor.prototype = {
+ /**
+ * Map of the relative severities of different attention states.
+ * Used in sorting the map of active downloads' attention states
+ * to determine the attention state to be displayed.
+ */
+ _attentionPriority: new Map([
+ [DownloadsCommon.ATTENTION_NONE, 0],
+ [DownloadsCommon.ATTENTION_SUCCESS, 1],
+ [DownloadsCommon.ATTENTION_INFO, 2],
+ [DownloadsCommon.ATTENTION_WARNING, 3],
+ [DownloadsCommon.ATTENTION_SEVERE, 4],
+ ]),
+
+ /**
+ * Iterator for all the available Download objects. This is empty until the
+ * data has been loaded using the JavaScript API for downloads.
+ */
+ get _downloads() {
+ return ChromeUtils.nondeterministicGetWeakMapKeys(this._oldDownloadStates);
+ },
+
+ /**
+ * Removes an object previously added using addView.
+ *
+ * @param aView
+ * DownloadsIndicatorView object to be removed.
+ */
+ removeView(aView) {
+ DownloadsViewPrototype.removeView.call(this, aView);
+
+ if (!this._views.length) {
+ this._itemCount = 0;
+ }
+ },
+
+ onDownloadAdded(download) {
+ DownloadsViewPrototype.onDownloadAdded.call(this, download);
+ this._itemCount++;
+ this._updateViews();
+ },
+
+ onDownloadStateChanged(download) {
+ if (this._attentionSuppressed !== DownloadsCommon.SUPPRESS_NONE) {
+ return;
+ }
+ let attention;
+ if (
+ !download.succeeded &&
+ download.error &&
+ download.error.reputationCheckVerdict
+ ) {
+ switch (download.error.reputationCheckVerdict) {
+ case lazy.Downloads.Error.BLOCK_VERDICT_UNCOMMON:
+ attention = DownloadsCommon.ATTENTION_INFO;
+ break;
+ case lazy.Downloads.Error.BLOCK_VERDICT_POTENTIALLY_UNWANTED: // fall-through
+ case lazy.Downloads.Error.BLOCK_VERDICT_INSECURE:
+ case lazy.Downloads.Error.BLOCK_VERDICT_DOWNLOAD_SPAM:
+ attention = DownloadsCommon.ATTENTION_WARNING;
+ break;
+ case lazy.Downloads.Error.BLOCK_VERDICT_MALWARE:
+ attention = DownloadsCommon.ATTENTION_SEVERE;
+ break;
+ default:
+ attention = DownloadsCommon.ATTENTION_SEVERE;
+ console.error(
+ "Unknown reputation verdict: " +
+ download.error.reputationCheckVerdict
+ );
+ }
+ } else if (download.succeeded) {
+ attention = DownloadsCommon.ATTENTION_SUCCESS;
+ } else if (download.error) {
+ attention = DownloadsCommon.ATTENTION_WARNING;
+ }
+ download.attention = attention;
+ this.updateAttention();
+ },
+
+ onDownloadChanged(download) {
+ DownloadsViewPrototype.onDownloadChanged.call(this, download);
+ this._updateViews();
+ },
+
+ onDownloadRemoved(download) {
+ DownloadsViewPrototype.onDownloadRemoved.call(this, download);
+ this._itemCount--;
+ this.updateAttention();
+ this._updateViews();
+ },
+
+ // Propagation of properties to our views
+
+ // The following properties are updated by _refreshProperties and are then
+ // propagated to the views. See _refreshProperties for details.
+ _hasDownloads: false,
+ _percentComplete: -1,
+
+ /**
+ * Indicates whether the download indicators should be highlighted.
+ */
+ set attention(aValue) {
+ this._attention = aValue;
+ this._updateViews();
+ },
+ _attention: DownloadsCommon.ATTENTION_NONE,
+
+ /**
+ * Indicates whether the user is interacting with downloads, thus the
+ * attention indication should not be shown even if requested.
+ */
+ set attentionSuppressed(aFlags) {
+ this._attentionSuppressed = aFlags;
+ if (aFlags !== DownloadsCommon.SUPPRESS_NONE) {
+ for (let download of this._downloads) {
+ download.attention = DownloadsCommon.ATTENTION_NONE;
+ }
+ this.attention = DownloadsCommon.ATTENTION_NONE;
+ }
+ },
+ get attentionSuppressed() {
+ return this._attentionSuppressed;
+ },
+ _attentionSuppressed: DownloadsCommon.SUPPRESS_NONE,
+
+ /**
+ * Set the indicator's attention to the most severe attention state among the
+ * unseen displayed downloads, or DownloadsCommon.ATTENTION_NONE if empty.
+ */
+ updateAttention() {
+ let currentAttention = DownloadsCommon.ATTENTION_NONE;
+ let currentPriority = 0;
+ for (let download of this._downloads) {
+ let { attention } = download;
+ let priority = this._attentionPriority.get(attention);
+ if (priority > currentPriority) {
+ currentPriority = priority;
+ currentAttention = attention;
+ }
+ }
+ this.attention = currentAttention;
+ },
+
+ /**
+ * Updates the specified view with the current aggregate values.
+ *
+ * @param aView
+ * DownloadsIndicatorView object to be updated.
+ */
+ _updateView(aView) {
+ aView.hasDownloads = this._hasDownloads;
+ aView.percentComplete = this._percentComplete;
+ aView.attention =
+ this.attentionSuppressed !== DownloadsCommon.SUPPRESS_NONE
+ ? DownloadsCommon.ATTENTION_NONE
+ : this._attention;
+ },
+
+ // Property updating based on current download status
+
+ /**
+ * Number of download items that are available to be displayed.
+ */
+ _itemCount: 0,
+
+ /**
+ * A generator function for the Download objects this summary is currently
+ * interested in. This generator is passed off to summarizeDownloads in order
+ * to generate statistics about the downloads we care about - in this case,
+ * it's all active downloads.
+ */
+ *_activeDownloads() {
+ let downloads = this._isPrivate
+ ? lazy.PrivateDownloadsData._downloads
+ : lazy.DownloadsData._downloads;
+ for (let download of downloads) {
+ if (!download.stopped || (download.canceled && download.hasPartialData)) {
+ yield download;
+ }
+ }
+ },
+
+ /**
+ * Computes aggregate values based on the current state of downloads.
+ */
+ _refreshProperties() {
+ let summary = DownloadsCommon.summarizeDownloads(this._activeDownloads());
+
+ // Determine if the indicator should be shown or get attention.
+ this._hasDownloads = this._itemCount > 0;
+
+ // Always show a progress bar if there are downloads in progress.
+ if (summary.percentComplete >= 0) {
+ this._percentComplete = summary.percentComplete;
+ } else if (summary.numDownloading > 0) {
+ this._percentComplete = 0;
+ } else {
+ this._percentComplete = -1;
+ }
+ },
+};
+Object.setPrototypeOf(
+ DownloadsIndicatorDataCtor.prototype,
+ DownloadsViewPrototype
+);
+
+XPCOMUtils.defineLazyGetter(lazy, "PrivateDownloadsIndicatorData", function () {
+ return new DownloadsIndicatorDataCtor(true);
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "DownloadsIndicatorData", function () {
+ return new DownloadsIndicatorDataCtor(false);
+});
+
+// DownloadsSummaryData
+
+/**
+ * DownloadsSummaryData is a view for DownloadsData that produces a summary
+ * of all downloads after a certain exclusion point aNumToExclude. For example,
+ * if there were 5 downloads in progress, and a DownloadsSummaryData was
+ * constructed with aNumToExclude equal to 3, then that DownloadsSummaryData
+ * would produce a summary of the last 2 downloads.
+ *
+ * @param aIsPrivate
+ * True if the browser window which owns the download button is a private
+ * window.
+ * @param aNumToExclude
+ * The number of items to exclude from the summary, starting from the
+ * top of the list.
+ */
+function DownloadsSummaryData(aIsPrivate, aNumToExclude) {
+ this._numToExclude = aNumToExclude;
+ // Since we can have multiple instances of DownloadsSummaryData, we
+ // override these values from the prototype so that each instance can be
+ // completely separated from one another.
+ this._loading = false;
+
+ this._downloads = [];
+
+ // Floating point value indicating the last number of seconds estimated until
+ // the longest download will finish. We need to store this value so that we
+ // don't continuously apply smoothing if the actual download state has not
+ // changed. This is set to -1 if the previous value is unknown.
+ this._lastRawTimeLeft = -1;
+
+ // Last number of seconds estimated until all in-progress downloads with a
+ // known size and speed will finish. This value is stored to allow smoothing
+ // in case of small variations. This is set to -1 if the previous value is
+ // unknown.
+ this._lastTimeLeft = -1;
+
+ // The following properties are updated by _refreshProperties and are then
+ // propagated to the views.
+ this._showingProgress = false;
+ this._details = "";
+ this._description = "";
+ this._numActive = 0;
+ this._percentComplete = -1;
+
+ this._oldDownloadStates = new WeakMap();
+ this._isPrivate = aIsPrivate;
+ this._views = [];
+}
+
+DownloadsSummaryData.prototype = {
+ /**
+ * Removes an object previously added using addView.
+ *
+ * @param aView
+ * DownloadsSummary view to be removed.
+ */
+ removeView(aView) {
+ DownloadsViewPrototype.removeView.call(this, aView);
+
+ if (!this._views.length) {
+ // Clear out our collection of Download objects. If we ever have
+ // another view registered with us, this will get re-populated.
+ this._downloads = [];
+ }
+ },
+
+ onDownloadAdded(download) {
+ DownloadsViewPrototype.onDownloadAdded.call(this, download);
+ this._downloads.unshift(download);
+ this._updateViews();
+ },
+
+ onDownloadStateChanged() {
+ // Since the state of a download changed, reset the estimated time left.
+ this._lastRawTimeLeft = -1;
+ this._lastTimeLeft = -1;
+ },
+
+ onDownloadChanged(download) {
+ DownloadsViewPrototype.onDownloadChanged.call(this, download);
+ this._updateViews();
+ },
+
+ onDownloadRemoved(download) {
+ DownloadsViewPrototype.onDownloadRemoved.call(this, download);
+ let itemIndex = this._downloads.indexOf(download);
+ this._downloads.splice(itemIndex, 1);
+ this._updateViews();
+ },
+
+ // Propagation of properties to our views
+
+ /**
+ * Updates the specified view with the current aggregate values.
+ *
+ * @param aView
+ * DownloadsIndicatorView object to be updated.
+ */
+ _updateView(aView) {
+ aView.showingProgress = this._showingProgress;
+ aView.percentComplete = this._percentComplete;
+ aView.description = this._description;
+ aView.details = this._details;
+ },
+
+ // Property updating based on current download status
+
+ /**
+ * A generator function for the Download objects this summary is currently
+ * interested in. This generator is passed off to summarizeDownloads in order
+ * to generate statistics about the downloads we care about - in this case,
+ * it's the downloads in this._downloads after the first few to exclude,
+ * which was set when constructing this DownloadsSummaryData instance.
+ */
+ *_downloadsForSummary() {
+ if (this._downloads.length) {
+ for (let i = this._numToExclude; i < this._downloads.length; ++i) {
+ yield this._downloads[i];
+ }
+ }
+ },
+
+ /**
+ * Computes aggregate values based on the current state of downloads.
+ */
+ _refreshProperties() {
+ // Pre-load summary with default values.
+ let summary = DownloadsCommon.summarizeDownloads(
+ this._downloadsForSummary()
+ );
+
+ // Run sync to update view right away and get correct description.
+ // See refreshView for more details.
+ this._description = kDownloadsFluentStrings.formatValueSync(
+ "downloads-more-downloading",
+ {
+ count: summary.numDownloading,
+ }
+ );
+ this._percentComplete = summary.percentComplete;
+
+ // Only show the downloading items.
+ this._showingProgress = summary.numDownloading > 0;
+
+ // Display the estimated time left, if present.
+ if (summary.rawTimeLeft == -1) {
+ // There are no downloads with a known time left.
+ this._lastRawTimeLeft = -1;
+ this._lastTimeLeft = -1;
+ this._details = "";
+ } else {
+ // Compute the new time left only if state actually changed.
+ if (this._lastRawTimeLeft != summary.rawTimeLeft) {
+ this._lastRawTimeLeft = summary.rawTimeLeft;
+ this._lastTimeLeft = DownloadsCommon.smoothSeconds(
+ summary.rawTimeLeft,
+ this._lastTimeLeft
+ );
+ }
+ [this._details] = lazy.DownloadUtils.getDownloadStatusNoRate(
+ summary.totalTransferred,
+ summary.totalSize,
+ summary.slowestSpeed,
+ this._lastTimeLeft
+ );
+ }
+ },
+};
+Object.setPrototypeOf(DownloadsSummaryData.prototype, DownloadsViewPrototype);