summaryrefslogtreecommitdiffstats
path: root/browser/components/downloads/DownloadsViewUI.sys.mjs
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--browser/components/downloads/DownloadsViewUI.sys.mjs1201
1 files changed, 1201 insertions, 0 deletions
diff --git a/browser/components/downloads/DownloadsViewUI.sys.mjs b/browser/components/downloads/DownloadsViewUI.sys.mjs
new file mode 100644
index 0000000000..0e0f5a7af3
--- /dev/null
+++ b/browser/components/downloads/DownloadsViewUI.sys.mjs
@@ -0,0 +1,1201 @@
+/* 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/. */
+
+/*
+ * This module is imported by code that uses the "download.xml" binding, and
+ * provides prototypes for objects that handle input and display information.
+ */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ DownloadUtils: "resource://gre/modules/DownloadUtils.sys.mjs",
+ Downloads: "resource://gre/modules/Downloads.sys.mjs",
+ DownloadsCommon: "resource:///modules/DownloadsCommon.sys.mjs",
+ FileUtils: "resource://gre/modules/FileUtils.sys.mjs",
+ UrlbarUtils: "resource:///modules/UrlbarUtils.sys.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+ BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.jsm",
+});
+
+XPCOMUtils.defineLazyServiceGetter(
+ lazy,
+ "handlerSvc",
+ "@mozilla.org/uriloader/handler-service;1",
+ "nsIHandlerService"
+);
+
+XPCOMUtils.defineLazyServiceGetter(
+ lazy,
+ "gReputationService",
+ "@mozilla.org/reputationservice/application-reputation-service;1",
+ Ci.nsIApplicationReputationService
+);
+
+import { Integration } from "resource://gre/modules/Integration.sys.mjs";
+
+Integration.downloads.defineESModuleGetter(
+ lazy,
+ "DownloadIntegration",
+ "resource://gre/modules/DownloadIntegration.sys.mjs"
+);
+
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+
+var gDownloadElementButtons = {
+ cancel: {
+ commandName: "downloadsCmd_cancel",
+ l10nId: "downloads-cmd-cancel",
+ descriptionL10nId: "downloads-cancel-download",
+ panelL10nId: "downloads-cmd-cancel-panel",
+ iconClass: "downloadIconCancel",
+ },
+ retry: {
+ commandName: "downloadsCmd_retry",
+ l10nId: "downloads-cmd-retry",
+ descriptionL10nId: "downloads-retry-download",
+ panelL10nId: "downloads-cmd-retry-panel",
+ iconClass: "downloadIconRetry",
+ },
+ show: {
+ commandName: "downloadsCmd_show",
+ l10nId: "downloads-cmd-show-button-2",
+ descriptionL10nId: "downloads-cmd-show-description-2",
+ panelL10nId: "downloads-cmd-show-panel-2",
+ iconClass: "downloadIconShow",
+ },
+ subviewOpenOrRemoveFile: {
+ commandName: "downloadsCmd_showBlockedInfo",
+ l10nId: "downloads-cmd-choose-open",
+ descriptionL10nId: "downloads-show-more-information",
+ panelL10nId: "downloads-cmd-choose-open-panel",
+ iconClass: "downloadIconSubviewArrow",
+ },
+ askOpenOrRemoveFile: {
+ commandName: "downloadsCmd_chooseOpen",
+ l10nId: "downloads-cmd-choose-open",
+ panelL10nId: "downloads-cmd-choose-open-panel",
+ iconClass: "downloadIconShow",
+ },
+ askRemoveFileOrAllow: {
+ commandName: "downloadsCmd_chooseUnblock",
+ l10nId: "downloads-cmd-choose-unblock",
+ panelL10nId: "downloads-cmd-choose-unblock-panel",
+ iconClass: "downloadIconShow",
+ },
+ removeFile: {
+ commandName: "downloadsCmd_confirmBlock",
+ l10nId: "downloads-cmd-remove-file",
+ panelL10nId: "downloads-cmd-remove-file-panel",
+ iconClass: "downloadIconCancel",
+ },
+};
+
+/**
+ * Associates each document with a pre-built DOM fragment representing the
+ * download list item. This is then cloned to create each individual list item.
+ * This is stored on the document to prevent leaks that would occur if a single
+ * instance created by one document's DOMParser was stored globally.
+ */
+var gDownloadListItemFragments = new WeakMap();
+
+export var DownloadsViewUI = {
+ /**
+ * Returns true if the given string is the name of a command that can be
+ * handled by the Downloads user interface, including standard commands.
+ */
+ isCommandName(name) {
+ return name.startsWith("cmd_") || name.startsWith("downloadsCmd_");
+ },
+
+ /**
+ * Get source url of the download without'http' or'https' prefix.
+ */
+ getStrippedUrl(download) {
+ return lazy.UrlbarUtils.stripPrefixAndTrim(download?.source?.url, {
+ stripHttp: true,
+ stripHttps: true,
+ })[0];
+ },
+
+ /**
+ * Returns the user-facing label for the given Download object. This is
+ * normally the leaf name of the download target file. In case this is a very
+ * old history download for which the target file is unknown, the download
+ * source URI is displayed.
+ */
+ getDisplayName(download) {
+ if (
+ download.error?.reputationCheckVerdict ==
+ lazy.Downloads.Error.BLOCK_VERDICT_DOWNLOAD_SPAM
+ ) {
+ let l10n = {
+ id: "downloads-blocked-from-url",
+ args: { url: DownloadsViewUI.getStrippedUrl(download) },
+ };
+ return { l10n };
+ }
+ return download.target.path
+ ? PathUtils.filename(download.target.path)
+ : download.source.url;
+ },
+
+ /**
+ * Given a Download object, returns a string representing its file size with
+ * an appropriate measurement unit, for example "1.5 MB", or an empty string
+ * if the size is unknown.
+ */
+ getSizeWithUnits(download) {
+ if (download.target.size === undefined) {
+ return "";
+ }
+
+ let [size, unit] = lazy.DownloadUtils.convertByteUnits(
+ download.target.size
+ );
+ return lazy.DownloadsCommon.strings.sizeWithUnits(size, unit);
+ },
+
+ /**
+ * Given a context menu and a download element on which it is invoked,
+ * update items in the context menu to reflect available options for
+ * that download element.
+ */
+ updateContextMenuForElement(contextMenu, element) {
+ // Get the state and ensure only the appropriate items are displayed.
+ let state = parseInt(element.getAttribute("state"), 10);
+
+ const document = contextMenu.ownerDocument;
+
+ const {
+ DOWNLOAD_NOTSTARTED,
+ DOWNLOAD_DOWNLOADING,
+ DOWNLOAD_FINISHED,
+ DOWNLOAD_FAILED,
+ DOWNLOAD_CANCELED,
+ DOWNLOAD_PAUSED,
+ DOWNLOAD_BLOCKED_PARENTAL,
+ DOWNLOAD_DIRTY,
+ DOWNLOAD_BLOCKED_POLICY,
+ } = lazy.DownloadsCommon;
+
+ contextMenu.querySelector(".downloadPauseMenuItem").hidden =
+ state != DOWNLOAD_DOWNLOADING;
+
+ contextMenu.querySelector(".downloadResumeMenuItem").hidden =
+ state != DOWNLOAD_PAUSED;
+
+ // Only show "unblock" for blocked (dirty) items that have not been
+ // confirmed and have temporary data:
+ contextMenu.querySelector(".downloadUnblockMenuItem").hidden =
+ state != DOWNLOAD_DIRTY || !element.classList.contains("temporary-block");
+
+ // Can only remove finished/failed/canceled/blocked downloads.
+ contextMenu.querySelector(".downloadRemoveFromHistoryMenuItem").hidden = ![
+ DOWNLOAD_FINISHED,
+ DOWNLOAD_FAILED,
+ DOWNLOAD_CANCELED,
+ DOWNLOAD_BLOCKED_PARENTAL,
+ DOWNLOAD_DIRTY,
+ DOWNLOAD_BLOCKED_POLICY,
+ ].includes(state);
+
+ // Can reveal downloads with data on the file system using the relevant OS
+ // tool (Explorer, Finder, appropriate Linux file system viewer):
+ contextMenu.querySelector(".downloadShowMenuItem").hidden =
+ ![
+ DOWNLOAD_NOTSTARTED,
+ DOWNLOAD_DOWNLOADING,
+ DOWNLOAD_FINISHED,
+ DOWNLOAD_PAUSED,
+ ].includes(state) ||
+ (state == DOWNLOAD_FINISHED && !element.hasAttribute("exists"));
+
+ // Show the separator if we're showing either unblock or reveal menu items.
+ contextMenu.querySelector(".downloadCommandsSeparator").hidden =
+ contextMenu.querySelector(".downloadUnblockMenuItem").hidden &&
+ contextMenu.querySelector(".downloadShowMenuItem").hidden;
+
+ let download = element._shell.download;
+ let mimeInfo = lazy.DownloadsCommon.getMimeInfo(download);
+ let { preferredAction, useSystemDefault, defaultDescription } = mimeInfo
+ ? mimeInfo
+ : {};
+
+ // Hide the "Delete" item if there's no file data to delete.
+ contextMenu.querySelector(".downloadDeleteFileMenuItem").hidden =
+ download.deleted ||
+ !(download.target?.exists || download.target?.partFileExists);
+
+ // Hide the "Go To Download Page" item if there's no referrer. Ideally the
+ // Downloads API will require a referrer (see bug 1723712) to create a
+ // download, but this fallback will ensure any failures aren't user facing.
+ contextMenu.querySelector(".downloadOpenReferrerMenuItem").hidden =
+ !download.source.referrerInfo?.originalReferrer;
+
+ // Hide the "use system viewer" and "always use system viewer" items
+ // if the feature is disabled or this download doesn't support it:
+ let useSystemViewerItem = contextMenu.querySelector(
+ ".downloadUseSystemDefaultMenuItem"
+ );
+ let alwaysUseSystemViewerItem = contextMenu.querySelector(
+ ".downloadAlwaysUseSystemDefaultMenuItem"
+ );
+ let canViewInternally = element.hasAttribute("viewable-internally");
+ useSystemViewerItem.hidden =
+ !lazy.DownloadsCommon.openInSystemViewerItemEnabled ||
+ !canViewInternally ||
+ !download.target?.exists;
+
+ alwaysUseSystemViewerItem.hidden =
+ !lazy.DownloadsCommon.alwaysOpenInSystemViewerItemEnabled ||
+ !canViewInternally;
+
+ // Set menuitem labels to display the system viewer's name. Stop the l10n
+ // mutation observer temporarily since we're going to synchronously
+ // translate the elements to avoid translation delay. See bug 1737951 & bug
+ // 1746748. This can be simplified when they're resolved.
+ try {
+ document.l10n.pauseObserving();
+ // Handler descriptions longer than 40 characters will be skipped to avoid
+ // unreasonably stretching the context menu.
+ if (defaultDescription && defaultDescription.length < 40) {
+ document.l10n.setAttributes(
+ useSystemViewerItem,
+ "downloads-cmd-use-system-default-named",
+ { handler: defaultDescription }
+ );
+ document.l10n.setAttributes(
+ alwaysUseSystemViewerItem,
+ "downloads-cmd-always-use-system-default-named",
+ { handler: defaultDescription }
+ );
+ } else {
+ // In the unlikely event that defaultDescription is somehow missing/invalid,
+ // fall back to the static "Open In System Viewer" label.
+ document.l10n.setAttributes(
+ useSystemViewerItem,
+ "downloads-cmd-use-system-default"
+ );
+ document.l10n.setAttributes(
+ alwaysUseSystemViewerItem,
+ "downloads-cmd-always-use-system-default"
+ );
+ }
+ } finally {
+ document.l10n.resumeObserving();
+ }
+ document.l10n.translateElements([
+ useSystemViewerItem,
+ alwaysUseSystemViewerItem,
+ ]);
+
+ // If non default mime-type or cannot be opened internally, display
+ // "always open similar files" item instead so that users can add a new
+ // mimetype to about:preferences table and set to open with system default.
+ let alwaysOpenSimilarFilesItem = contextMenu.querySelector(
+ ".downloadAlwaysOpenSimilarFilesMenuItem"
+ );
+
+ /**
+ * In HelperAppDlg.sys.mjs, we determine whether or not an "always open..." checkbox
+ * should appear in the unknownContentType window. Here, we use similar checks to
+ * determine if we should show the "always open similar files" context menu item.
+ *
+ * Note that we also read the content type using mimeInfo to detect better and available
+ * mime types, given a file extension. Some sites default to "application/octet-stream",
+ * further limiting what file types can be added to about:preferences, even for file types
+ * that are in fact capable of being handled with a default application.
+ *
+ * There are also cases where download.contentType is undefined (ex. when opening
+ * the context menu on a previously downloaded item via download history).
+ * Using mimeInfo ensures that content type exists and prevents intermittence.
+ */
+ //
+ let filename = PathUtils.filename(download.target.path);
+
+ let isExemptExecutableExtension =
+ Services.policies.isExemptExecutableExtension(
+ download.source.originalUrl || download.source.url,
+ filename?.split(".").at(-1)
+ );
+
+ let shouldNotRememberChoice =
+ !mimeInfo?.type ||
+ mimeInfo.type === "application/octet-stream" ||
+ mimeInfo.type === "application/x-msdownload" ||
+ mimeInfo.type === "application/x-msdos-program" ||
+ (lazy.gReputationService.isExecutable(filename) &&
+ !isExemptExecutableExtension) ||
+ (mimeInfo.type === "text/plain" &&
+ lazy.gReputationService.isBinary(download.target.path));
+
+ alwaysOpenSimilarFilesItem.hidden =
+ canViewInternally ||
+ state !== DOWNLOAD_FINISHED ||
+ shouldNotRememberChoice;
+
+ // Update checkbox for "always open..." options.
+ if (preferredAction === useSystemDefault) {
+ alwaysUseSystemViewerItem.setAttribute("checked", "true");
+ alwaysOpenSimilarFilesItem.setAttribute("checked", "true");
+ } else {
+ alwaysUseSystemViewerItem.removeAttribute("checked");
+ alwaysOpenSimilarFilesItem.removeAttribute("checked");
+ }
+ },
+};
+
+XPCOMUtils.defineLazyPreferenceGetter(
+ DownloadsViewUI,
+ "clearHistoryOnDelete",
+ "browser.download.clearHistoryOnDelete",
+ 0
+);
+
+DownloadsViewUI.BaseView = class {
+ canClearDownloads(nodeContainer) {
+ // Downloads can be cleared if there's at least one removable download in
+ // the list (either a history download or a completed session download).
+ // Because history downloads are always removable and are listed after the
+ // session downloads, check from bottom to top.
+ for (let elt = nodeContainer.lastChild; elt; elt = elt.previousSibling) {
+ // Stopped, paused, and failed downloads with partial data are removed.
+ let download = elt._shell.download;
+ if (download.stopped && !(download.canceled && download.hasPartialData)) {
+ return true;
+ }
+ }
+ return false;
+ }
+};
+
+/**
+ * A download element shell is responsible for handling the commands and the
+ * displayed data for a single element that uses the "download.xml" binding.
+ *
+ * The information to display is obtained through the associated Download object
+ * from the JavaScript API for downloads, and commands are executed using a
+ * combination of Download methods and DownloadsCommon.sys.mjs helper functions.
+ *
+ * Specialized versions of this shell must be defined, and they are required to
+ * implement the "download" property or getter. Currently these objects are the
+ * HistoryDownloadElementShell and the DownloadsViewItem for the panel. The
+ * history view may use a HistoryDownload object in place of a Download object.
+ */
+DownloadsViewUI.DownloadElementShell = function () {};
+
+DownloadsViewUI.DownloadElementShell.prototype = {
+ /**
+ * The richlistitem for the download, initialized by the derived object.
+ */
+ element: null,
+
+ /**
+ * Manages the "active" state of the shell. By default all the shells are
+ * inactive, thus their UI is not updated. They must be activated when
+ * entering the visible area.
+ */
+ ensureActive() {
+ if (!this._active) {
+ this._active = true;
+ this.connect();
+ this.onChanged();
+ }
+ },
+ get active() {
+ return !!this._active;
+ },
+
+ connect() {
+ let document = this.element.ownerDocument;
+ let downloadListItemFragment = gDownloadListItemFragments.get(document);
+ // When changing the markup within the fragment, please ensure that
+ // the functions within DownloadsView still operate correctly.
+ if (!downloadListItemFragment) {
+ let MozXULElement = document.defaultView.MozXULElement;
+ downloadListItemFragment = MozXULElement.parseXULToFragment(`
+ <hbox class="downloadMainArea" flex="1" align="center">
+ <image class="downloadTypeIcon"/>
+ <vbox class="downloadContainer" flex="1" pack="center">
+ <description class="downloadTarget" crop="center"/>
+ <description class="downloadDetails downloadDetailsNormal"
+ crop="end"/>
+ <description class="downloadDetails downloadDetailsHover"
+ crop="end"/>
+ <description class="downloadDetails downloadDetailsButtonHover"
+ crop="end"/>
+ </vbox>
+ <image class="downloadBlockedBadge" />
+ </hbox>
+ <button class="downloadButton"/>
+ `);
+ gDownloadListItemFragments.set(document, downloadListItemFragment);
+ }
+ this.element.setAttribute("active", true);
+ this.element.setAttribute("orient", "horizontal");
+ this.element.addEventListener("click", ev => {
+ ev.target.ownerGlobal.DownloadsView.onDownloadClick(ev);
+ });
+ this.element.appendChild(
+ document.importNode(downloadListItemFragment, true)
+ );
+ let downloadButton = this.element.querySelector(".downloadButton");
+ downloadButton.addEventListener("command", function (event) {
+ event.target.ownerGlobal.DownloadsView.onDownloadButton(event);
+ });
+ for (let [propertyName, selector] of [
+ ["_downloadTypeIcon", ".downloadTypeIcon"],
+ ["_downloadTarget", ".downloadTarget"],
+ ["_downloadDetailsNormal", ".downloadDetailsNormal"],
+ ["_downloadDetailsHover", ".downloadDetailsHover"],
+ ["_downloadDetailsButtonHover", ".downloadDetailsButtonHover"],
+ ["_downloadButton", ".downloadButton"],
+ ]) {
+ this[propertyName] = this.element.querySelector(selector);
+ }
+
+ // HTML elements can be created directly without using parseXULToFragment.
+ let progress = (this._downloadProgress = document.createElementNS(
+ HTML_NS,
+ "progress"
+ ));
+ progress.className = "downloadProgress";
+ progress.setAttribute("max", "100");
+ this._downloadTarget.insertAdjacentElement("afterend", progress);
+ },
+
+ /**
+ * URI string for the file type icon displayed in the download element.
+ */
+ get image() {
+ if (!this.download.target.path) {
+ // Old history downloads may not have a target path.
+ return "moz-icon://.unknown?size=32";
+ }
+
+ // When a download that was previously in progress finishes successfully, it
+ // means that the target file now exists and we can extract its specific
+ // icon, for example from a Windows executable. To ensure that the icon is
+ // reloaded, however, we must change the URI used by the XUL image element,
+ // for example by adding a query parameter. This only works if we add one of
+ // the parameters explicitly supported by the nsIMozIconURI interface.
+ return (
+ "moz-icon://" +
+ this.download.target.path +
+ "?size=32" +
+ (this.download.succeeded ? "&state=normal" : "")
+ );
+ },
+
+ get browserWindow() {
+ return lazy.BrowserWindowTracker.getTopWindow();
+ },
+
+ /**
+ * Updates the display name and icon.
+ *
+ * @param displayName
+ * This is usually the full file name of the download without the path.
+ * @param icon
+ * URL of the icon to load, generally from the "image" property.
+ */
+ showDisplayNameAndIcon(displayName, icon) {
+ if (displayName.l10n) {
+ let document = this.element.ownerDocument;
+ document.l10n.setAttributes(
+ this._downloadTarget,
+ displayName.l10n.id,
+ displayName.l10n.args
+ );
+ } else {
+ this._downloadTarget.setAttribute("value", displayName);
+ this._downloadTarget.setAttribute("tooltiptext", displayName);
+ }
+ this._downloadTypeIcon.setAttribute("src", icon);
+ },
+
+ /**
+ * Updates the displayed progress bar.
+ *
+ * @param mode
+ * Either "normal" or "undetermined".
+ * @param value
+ * Percentage of the progress bar to display, from 0 to 100.
+ * @param paused
+ * True to display the progress bar style for paused downloads.
+ */
+ showProgress(mode, value, paused) {
+ if (mode == "undetermined") {
+ this._downloadProgress.removeAttribute("value");
+ } else {
+ this._downloadProgress.setAttribute("value", value);
+ }
+ this._downloadProgress.toggleAttribute("paused", !!paused);
+ },
+
+ /**
+ * Updates the full status line.
+ *
+ * @param status
+ * Status line of the Downloads Panel or the Downloads View.
+ * @param hoverStatus
+ * Label to show in the Downloads Panel when the mouse pointer is over
+ * the main area of the item. If not specified, this will be the same
+ * as the status line. This is ignored in the Downloads View. Type is
+ * either l10n object or string literal.
+ */
+ showStatus(status, hoverStatus = status) {
+ let document = this.element.ownerDocument;
+ if (status?.l10n) {
+ document.l10n.setAttributes(
+ this._downloadDetailsNormal,
+ status.l10n.id,
+ status.l10n.args
+ );
+ } else {
+ this._downloadDetailsNormal.removeAttribute("data-l10n-id");
+ this._downloadDetailsNormal.setAttribute("value", status);
+ this._downloadDetailsNormal.setAttribute("tooltiptext", status);
+ }
+ if (hoverStatus?.l10n) {
+ document.l10n.setAttributes(
+ this._downloadDetailsHover,
+ hoverStatus.l10n.id,
+ hoverStatus.l10n.args
+ );
+ } else {
+ this._downloadDetailsHover.removeAttribute("data-l10n-id");
+ this._downloadDetailsHover.setAttribute("value", hoverStatus);
+ }
+ },
+
+ /**
+ * Updates the status line combining the given state label with other labels.
+ *
+ * @param stateLabel
+ * Label representing the state of the download, for example "Failed".
+ * In the Downloads Panel, this is the only text displayed when the
+ * the mouse pointer is not over the main area of the item. In the
+ * Downloads View, this label is combined with the host and date, for
+ * example "Failed - example.com - 1:45 PM".
+ * @param hoverStatus
+ * Label to show in the Downloads Panel when the mouse pointer is over
+ * the main area of the item. If not specified, this will be the
+ * state label combined with the host and date. This is ignored in the
+ * Downloads View. Type is either l10n object or string literal.
+ */
+ showStatusWithDetails(stateLabel, hoverStatus) {
+ if (stateLabel.l10n) {
+ this.showStatus(stateLabel, hoverStatus);
+ return;
+ }
+ let [displayHost] = lazy.DownloadUtils.getURIHost(this.download.source.url);
+ let [displayDate] = lazy.DownloadUtils.getReadableDates(
+ new Date(this.download.endTime)
+ );
+
+ let firstPart = lazy.DownloadsCommon.strings.statusSeparator(
+ stateLabel,
+ displayHost
+ );
+ let fullStatus = lazy.DownloadsCommon.strings.statusSeparator(
+ firstPart,
+ displayDate
+ );
+
+ if (!this.isPanel) {
+ this.showStatus(fullStatus);
+ } else {
+ this.showStatus(stateLabel, hoverStatus || fullStatus);
+ }
+ },
+
+ /**
+ * Updates the main action button and makes it visible.
+ *
+ * @param type
+ * One of the presets defined in gDownloadElementButtons.
+ */
+ showButton(type) {
+ let { commandName, l10nId, descriptionL10nId, panelL10nId, iconClass } =
+ gDownloadElementButtons[type];
+
+ this.buttonCommandName = commandName;
+ let stringId = this.isPanel ? panelL10nId : l10nId;
+ let document = this.element.ownerDocument;
+ document.l10n.setAttributes(this._downloadButton, stringId);
+ if (this.isPanel && descriptionL10nId) {
+ document.l10n.setAttributes(
+ this._downloadDetailsButtonHover,
+ descriptionL10nId
+ );
+ }
+ this._downloadButton.setAttribute("class", "downloadButton " + iconClass);
+ this._downloadButton.removeAttribute("hidden");
+ },
+
+ hideButton() {
+ this._downloadButton.hidden = true;
+ },
+
+ lastEstimatedSecondsLeft: Infinity,
+
+ /**
+ * This is called when a major state change occurs in the download, but is not
+ * called for every progress update in order to improve performance.
+ */
+ _updateState() {
+ this.showDisplayNameAndIcon(
+ DownloadsViewUI.getDisplayName(this.download),
+ this.image
+ );
+ this.element.setAttribute(
+ "state",
+ lazy.DownloadsCommon.stateOfDownload(this.download)
+ );
+
+ if (!this.download.stopped) {
+ // When the download becomes in progress, we make all the major changes to
+ // the user interface here. The _updateStateInner function takes care of
+ // displaying the right button type for all other state changes.
+ this.showButton("cancel");
+
+ // If there was a verdict set but the download is running we can assume
+ // that the verdict has been overruled and can be removed.
+ this.element.removeAttribute("verdict");
+ }
+
+ // Since state changed, reset the time left estimation.
+ this.lastEstimatedSecondsLeft = Infinity;
+
+ this._updateStateInner();
+ },
+
+ /**
+ * This is called for all changes in the download, including progress updates.
+ * For major state changes, _updateState is called first, but several elements
+ * are still updated here. When the download is in progress, this function
+ * takes a faster path with less element updates to improve performance.
+ */
+ _updateStateInner() {
+ let progressPaused = false;
+
+ this.element.classList.toggle("openWhenFinished", !this.download.stopped);
+
+ if (!this.download.stopped) {
+ // The download is in progress, so we don't change the button state
+ // because the _updateState function already did it. We still need to
+ // update all elements that may change during the download.
+ let totalBytes = this.download.hasProgress
+ ? this.download.totalBytes
+ : -1;
+ let [status, newEstimatedSecondsLeft] =
+ lazy.DownloadUtils.getDownloadStatus(
+ this.download.currentBytes,
+ totalBytes,
+ this.download.speed,
+ this.lastEstimatedSecondsLeft
+ );
+ this.lastEstimatedSecondsLeft = newEstimatedSecondsLeft;
+
+ if (this.download.launchWhenSucceeded) {
+ status = lazy.DownloadUtils.getFormattedTimeStatus(
+ newEstimatedSecondsLeft
+ );
+ }
+ let hoverStatus = {
+ l10n: { id: "downloading-file-click-to-open" },
+ };
+ this.showStatus(status, hoverStatus);
+ } else {
+ let verdict = "";
+
+ // The download is not in progress, so we update the user interface based
+ // on other properties. The order in which we check the properties of the
+ // Download object is the same used by stateOfDownload.
+ if (this.download.deleted) {
+ this.showDeletedOrMissing();
+ } else if (this.download.succeeded) {
+ lazy.DownloadsCommon.log(
+ "_updateStateInner, target exists? ",
+ this.download.target.path,
+ this.download.target.exists
+ );
+ if (this.download.target.exists) {
+ // This is a completed download, and the target file still exists.
+ this.element.setAttribute("exists", "true");
+
+ this.element.toggleAttribute(
+ "viewable-internally",
+ lazy.DownloadIntegration.shouldViewDownloadInternally(
+ lazy.DownloadsCommon.getMimeInfo(this.download)?.type
+ )
+ );
+
+ let sizeWithUnits = DownloadsViewUI.getSizeWithUnits(this.download);
+ if (this.isPanel) {
+ // In the Downloads Panel, we show the file size after the state
+ // label, for example "Completed - 1.5 MB". When the pointer is over
+ // the main area of the item, this label is replaced with a
+ // description of the default action, which opens the file.
+ let status = lazy.DownloadsCommon.strings.stateCompleted;
+ if (sizeWithUnits) {
+ status = lazy.DownloadsCommon.strings.statusSeparator(
+ status,
+ sizeWithUnits
+ );
+ }
+ this.showStatus(status, { l10n: { id: "downloads-open-file" } });
+ } else {
+ // In the Downloads View, we show the file size in place of the
+ // state label, for example "1.5 MB - example.com - 1:45 PM".
+ this.showStatusWithDetails(
+ sizeWithUnits || lazy.DownloadsCommon.strings.sizeUnknown
+ );
+ }
+ this.showButton("show");
+ } else {
+ // This is a completed download, but the target file does not exist
+ // anymore, so the main action of opening the file is unavailable.
+ this.showDeletedOrMissing();
+ }
+ } else if (this.download.error) {
+ if (this.download.error.becauseBlockedByParentalControls) {
+ // This download was blocked permanently by parental controls.
+ this.showStatusWithDetails(
+ lazy.DownloadsCommon.strings.stateBlockedParentalControls
+ );
+ this.hideButton();
+ } else if (this.download.error.becauseBlockedByReputationCheck) {
+ verdict = this.download.error.reputationCheckVerdict;
+ let hover = "";
+ if (!this.download.hasBlockedData) {
+ // This download was blocked permanently by reputation check.
+ this.hideButton();
+ } else if (this.isPanel) {
+ // This download was blocked temporarily by reputation check. In the
+ // Downloads Panel, a subview can be used to remove the file or open
+ // the download anyways.
+ this.showButton("subviewOpenOrRemoveFile");
+ hover = { l10n: { id: "downloads-show-more-information" } };
+ } else {
+ // This download was blocked temporarily by reputation check. In the
+ // Downloads View, the interface depends on the threat severity.
+ switch (verdict) {
+ case lazy.Downloads.Error.BLOCK_VERDICT_UNCOMMON:
+ case lazy.Downloads.Error.BLOCK_VERDICT_INSECURE:
+ case lazy.Downloads.Error.BLOCK_VERDICT_POTENTIALLY_UNWANTED:
+ // Keep the option the user chose on the save dialogue
+ if (this.download.launchWhenSucceeded) {
+ this.showButton("askOpenOrRemoveFile");
+ } else {
+ this.showButton("askRemoveFileOrAllow");
+ }
+ break;
+ case lazy.Downloads.Error.BLOCK_VERDICT_DOWNLOAD_SPAM:
+ this.showButton("askRemoveFileOrAllow");
+ break;
+ default:
+ // Assume Downloads.Error.BLOCK_VERDICT_MALWARE
+ this.showButton("removeFile");
+ break;
+ }
+ }
+ this.showStatusWithDetails(this.rawBlockedTitleAndDetails[0], hover);
+ } else {
+ // This download failed without being blocked, and can be restarted.
+ this.showStatusWithDetails(lazy.DownloadsCommon.strings.stateFailed);
+ this.showButton("retry");
+ }
+ } else if (this.download.canceled) {
+ if (this.download.hasPartialData) {
+ // This download was paused. The main action button will cancel the
+ // download, and in both the Downloads Panel and the Downlods View the
+ // status includes the size, for example "Paused - 1.1 MB".
+ let totalBytes = this.download.hasProgress
+ ? this.download.totalBytes
+ : -1;
+ let transfer = lazy.DownloadUtils.getTransferTotal(
+ this.download.currentBytes,
+ totalBytes
+ );
+ this.showStatus(
+ lazy.DownloadsCommon.strings.statusSeparatorBeforeNumber(
+ lazy.DownloadsCommon.strings.statePaused,
+ transfer
+ )
+ );
+ this.showButton("cancel");
+ progressPaused = true;
+ } else {
+ // This download was canceled.
+ this.showStatusWithDetails(
+ lazy.DownloadsCommon.strings.stateCanceled
+ );
+ this.showButton("retry");
+ }
+ } else {
+ // This download was added to the global list before it started. While
+ // we still support this case, at the moment it can only be triggered by
+ // internally developed add-ons and regression tests, and should not
+ // happen unless there is a bug. This means the stateStarting string can
+ // probably be removed when converting the localization to Fluent.
+ this.showStatus(lazy.DownloadsCommon.strings.stateStarting);
+ this.showButton("cancel");
+ }
+
+ // These attributes are only set in this slower code path, because they
+ // are irrelevant for downloads that are in progress.
+ if (verdict) {
+ this.element.setAttribute("verdict", verdict);
+ } else {
+ this.element.removeAttribute("verdict");
+ }
+
+ this.element.classList.toggle(
+ "temporary-block",
+ !!this.download.hasBlockedData
+ );
+ }
+
+ // These attributes are set in all code paths, because they are relevant for
+ // downloads that are in progress and for other states.
+ if (this.download.hasProgress) {
+ this.showProgress("normal", this.download.progress, progressPaused);
+ } else {
+ this.showProgress("undetermined", 100, progressPaused);
+ }
+ },
+
+ /**
+ * Returns [title, [details1, details2]] for blocked downloads.
+ * The title or details could be raw strings or l10n objects.
+ */
+ get rawBlockedTitleAndDetails() {
+ let s = lazy.DownloadsCommon.strings;
+ if (
+ !this.download.error ||
+ !this.download.error.becauseBlockedByReputationCheck
+ ) {
+ return [null, null];
+ }
+ switch (this.download.error.reputationCheckVerdict) {
+ case lazy.Downloads.Error.BLOCK_VERDICT_UNCOMMON:
+ return [s.blockedUncommon2, [s.unblockTypeUncommon2, s.unblockTip2]];
+ case lazy.Downloads.Error.BLOCK_VERDICT_INSECURE:
+ return [
+ s.blockedPotentiallyInsecure,
+ [s.unblockInsecure2, s.unblockTip2],
+ ];
+ case lazy.Downloads.Error.BLOCK_VERDICT_POTENTIALLY_UNWANTED:
+ return [
+ s.blockedPotentiallyUnwanted,
+ [s.unblockTypePotentiallyUnwanted2, s.unblockTip2],
+ ];
+ case lazy.Downloads.Error.BLOCK_VERDICT_MALWARE:
+ return [s.blockedMalware, [s.unblockTypeMalware, s.unblockTip2]];
+
+ case lazy.Downloads.Error.BLOCK_VERDICT_DOWNLOAD_SPAM:
+ let title = {
+ id: "downloads-files-not-downloaded",
+ args: {
+ num: this.download.blockedDownloadsCount,
+ },
+ };
+ let details = {
+ id: "downloads-blocked-download-detailed-info",
+ args: { url: DownloadsViewUI.getStrippedUrl(this.download) },
+ };
+ return [{ l10n: title }, [{ l10n: details }, null]];
+ }
+ throw new Error(
+ "Unexpected reputationCheckVerdict: " +
+ this.download.error.reputationCheckVerdict
+ );
+ },
+
+ showDeletedOrMissing() {
+ this.element.removeAttribute("exists");
+ let label =
+ lazy.DownloadsCommon.strings[
+ this.download.deleted ? "fileDeleted" : "fileMovedOrMissing"
+ ];
+ this.showStatusWithDetails(label, label);
+ this.hideButton();
+ },
+
+ /**
+ * Shows the appropriate unblock dialog based on the verdict, and executes the
+ * action selected by the user in the dialog, which may involve unblocking,
+ * opening or removing the file.
+ *
+ * @param window
+ * The window to which the dialog should be anchored.
+ * @param dialogType
+ * Can be "unblock", "chooseUnblock", or "chooseOpen".
+ */
+ confirmUnblock(window, dialogType) {
+ lazy.DownloadsCommon.confirmUnblockDownload({
+ verdict: this.download.error.reputationCheckVerdict,
+ window,
+ dialogType,
+ })
+ .then(action => {
+ if (action == "open") {
+ return this.unblockAndOpenDownload();
+ } else if (action == "unblock") {
+ return this.download.unblock();
+ } else if (action == "confirmBlock") {
+ return this.download.confirmBlock();
+ }
+ return Promise.resolve();
+ })
+ .catch(console.error);
+ },
+
+ /**
+ * Unblocks the downloaded file and opens it.
+ *
+ * @return A promise that's resolved after the file has been opened.
+ */
+ unblockAndOpenDownload() {
+ return this.download.unblock().then(() => this.downloadsCmd_open());
+ },
+
+ unblockAndSave() {
+ return this.download.unblock();
+ },
+ /**
+ * Returns the name of the default command to use for the current state of the
+ * download, when there is a double click or another default interaction. If
+ * there is no default command for the current state, returns an empty string.
+ * The commands are implemented as functions on this object or derived ones.
+ */
+ get currentDefaultCommandName() {
+ switch (lazy.DownloadsCommon.stateOfDownload(this.download)) {
+ case lazy.DownloadsCommon.DOWNLOAD_NOTSTARTED:
+ return "downloadsCmd_cancel";
+ case lazy.DownloadsCommon.DOWNLOAD_FAILED:
+ case lazy.DownloadsCommon.DOWNLOAD_CANCELED:
+ return "downloadsCmd_retry";
+ case lazy.DownloadsCommon.DOWNLOAD_PAUSED:
+ return "downloadsCmd_pauseResume";
+ case lazy.DownloadsCommon.DOWNLOAD_FINISHED:
+ return "downloadsCmd_open";
+ case lazy.DownloadsCommon.DOWNLOAD_BLOCKED_PARENTAL:
+ return "downloadsCmd_openReferrer";
+ case lazy.DownloadsCommon.DOWNLOAD_DIRTY:
+ return "downloadsCmd_showBlockedInfo";
+ }
+ return "";
+ },
+
+ /**
+ * Returns true if the specified command can be invoked on the current item.
+ * The commands are implemented as functions on this object or derived ones.
+ *
+ * @param aCommand
+ * Name of the command to check, for example "downloadsCmd_retry".
+ */
+ isCommandEnabled(aCommand) {
+ switch (aCommand) {
+ case "downloadsCmd_retry":
+ return this.download.canceled || !!this.download.error;
+ case "downloadsCmd_pauseResume":
+ return this.download.hasPartialData && !this.download.error;
+ case "downloadsCmd_openReferrer":
+ return (
+ !!this.download.source.referrerInfo &&
+ !!this.download.source.referrerInfo.originalReferrer
+ );
+ case "downloadsCmd_confirmBlock":
+ case "downloadsCmd_chooseUnblock":
+ case "downloadsCmd_chooseOpen":
+ case "downloadsCmd_unblock":
+ case "downloadsCmd_unblockAndSave":
+ case "downloadsCmd_unblockAndOpen":
+ return this.download.hasBlockedData;
+ case "downloadsCmd_cancel":
+ return this.download.hasPartialData || !this.download.stopped;
+ case "downloadsCmd_open":
+ case "downloadsCmd_open:current":
+ case "downloadsCmd_open:tab":
+ case "downloadsCmd_open:tabshifted":
+ case "downloadsCmd_open:window":
+ case "downloadsCmd_alwaysOpenSimilarFiles":
+ // This property is false if the download did not succeed.
+ return this.download.target.exists;
+
+ case "downloadsCmd_show":
+ case "downloadsCmd_deleteFile":
+ let { target } = this.download;
+ return (
+ !this.download.deleted && (target.exists || target.partFileExists)
+ );
+
+ case "downloadsCmd_delete":
+ case "cmd_delete":
+ // We don't want in-progress downloads to be removed accidentally.
+ return this.download.stopped;
+ case "downloadsCmd_openInSystemViewer":
+ case "downloadsCmd_alwaysOpenInSystemViewer":
+ return lazy.DownloadIntegration.shouldViewDownloadInternally(
+ lazy.DownloadsCommon.getMimeInfo(this.download)?.type
+ );
+ }
+ return DownloadsViewUI.isCommandName(aCommand) && !!this[aCommand];
+ },
+
+ doCommand(aCommand) {
+ // split off an optional command "modifier" into an argument,
+ // e.g. "downloadsCmd_open:window"
+ let [command, modifier] = aCommand.split(":");
+ if (DownloadsViewUI.isCommandName(command)) {
+ this[command](modifier);
+ }
+ },
+
+ onButton() {
+ this.doCommand(this.buttonCommandName);
+ },
+
+ downloadsCmd_cancel() {
+ // This is the correct way to avoid race conditions when cancelling.
+ this.download.cancel().catch(() => {});
+ this.download
+ .removePartialData()
+ .catch(console.error)
+ .finally(() => this.download.target.refresh());
+ },
+
+ downloadsCmd_confirmBlock() {
+ this.download.confirmBlock().catch(console.error);
+ },
+
+ downloadsCmd_open(openWhere = "tab") {
+ lazy.DownloadsCommon.openDownload(this.download, {
+ openWhere,
+ });
+ },
+
+ downloadsCmd_openReferrer() {
+ this.element.ownerGlobal.openURL(
+ this.download.source.referrerInfo.originalReferrer
+ );
+ },
+
+ downloadsCmd_pauseResume() {
+ if (this.download.stopped) {
+ this.download.start();
+ } else {
+ this.download.cancel();
+ }
+ },
+
+ downloadsCmd_show() {
+ let file = new lazy.FileUtils.File(this.download.target.path);
+ lazy.DownloadsCommon.showDownloadedFile(file);
+ },
+
+ downloadsCmd_retry() {
+ if (this.download.start) {
+ // Errors when retrying are already reported as download failures.
+ this.download.start().catch(() => {});
+ return;
+ }
+
+ let window = this.browserWindow || this.element.ownerGlobal;
+ let document = window.document;
+
+ // Do not suggest a file name if we don't know the original target.
+ let targetPath = this.download.target.path
+ ? PathUtils.filename(this.download.target.path)
+ : null;
+ window.DownloadURL(this.download.source.url, targetPath, document);
+ },
+
+ downloadsCmd_delete() {
+ // Alias for the 'cmd_delete' command, because it may clash with another
+ // controller which causes unexpected behavior as different codepaths claim
+ // ownership.
+ this.cmd_delete();
+ },
+
+ cmd_delete() {
+ lazy.DownloadsCommon.deleteDownload(this.download).catch(console.error);
+ },
+
+ async downloadsCmd_deleteFile() {
+ // Remove the download from the session and history downloads, delete part files.
+ await lazy.DownloadsCommon.deleteDownloadFiles(
+ this.download,
+ DownloadsViewUI.clearHistoryOnDelete
+ );
+ },
+
+ downloadsCmd_openInSystemViewer() {
+ // For this interaction only, pass a flag to override the preferredAction for this
+ // mime-type and open using the system viewer
+ lazy.DownloadsCommon.openDownload(this.download, {
+ useSystemDefault: true,
+ }).catch(console.error);
+ },
+
+ downloadsCmd_alwaysOpenInSystemViewer() {
+ // this command toggles between setting preferredAction for this mime-type to open
+ // using the system viewer, or to open the file in browser.
+ const mimeInfo = lazy.DownloadsCommon.getMimeInfo(this.download);
+ if (!mimeInfo) {
+ throw new Error(
+ "Can't open download with unknown mime-type in system viewer"
+ );
+ }
+ if (mimeInfo.preferredAction !== mimeInfo.useSystemDefault) {
+ // User has selected to open this mime-type with the system viewer from now on
+ lazy.DownloadsCommon.log(
+ "downloadsCmd_alwaysOpenInSystemViewer command for download: ",
+ this.download,
+ "switching to use system default for " + mimeInfo.type
+ );
+ mimeInfo.preferredAction = mimeInfo.useSystemDefault;
+ mimeInfo.alwaysAskBeforeHandling = false;
+ } else {
+ lazy.DownloadsCommon.log(
+ "downloadsCmd_alwaysOpenInSystemViewer command for download: ",
+ this.download,
+ "currently uses system default, switching to handleInternally"
+ );
+ // User has selected to not open this mime-type with the system viewer
+ mimeInfo.preferredAction = mimeInfo.handleInternally;
+ }
+ lazy.handlerSvc.store(mimeInfo);
+ lazy.DownloadsCommon.openDownload(this.download).catch(console.error);
+ },
+
+ downloadsCmd_alwaysOpenSimilarFiles() {
+ const mimeInfo = lazy.DownloadsCommon.getMimeInfo(this.download);
+ if (!mimeInfo) {
+ throw new Error("Can't open download with unknown mime-type");
+ }
+
+ // User has selected to always open this mime-type from now on and will add this
+ // mime-type to our preferences table with the system default option. Open the
+ // file immediately after selecting the menu item like alwaysOpenInSystemViewer.
+ if (mimeInfo.preferredAction !== mimeInfo.useSystemDefault) {
+ mimeInfo.preferredAction = mimeInfo.useSystemDefault;
+ lazy.handlerSvc.store(mimeInfo);
+ lazy.DownloadsCommon.openDownload(this.download).catch(console.error);
+ } else {
+ // Otherwise, if user unchecks this option after already enabling it from the
+ // context menu, resort to saveToDisk.
+ mimeInfo.preferredAction = mimeInfo.saveToDisk;
+ lazy.handlerSvc.store(mimeInfo);
+ }
+ },
+};