The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 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/. */

 "use strict";

 this.EXPORTED_SYMBOLS = [

   "DownloadsCommon",

 ];

 /**

  * 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

  * Download Manager data, and provides asynchronous notifications allowing

  * to build a consistent view of the available data.

  *

  * DownloadsDataItem

  * Represents a single item in the list of downloads.  This object either wraps

  * an existing nsIDownload from the Download Manager, or provides the same

  * information read directly from the downloads database, with the possibility

  * of querying the nsIDownload lazily, for performance reasons.

  *

  * 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

 const Cc = Components.classes;

 const Ci = Components.interfaces;

 const Cu = Components.utils;

 const Cr = Components.results;

 Cu.import("resource://gre/modules/XPCOMUtils.jsm");

 Cu.import("resource://gre/modules/Services.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",

                                   "resource://gre/modules/NetUtil.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "PluralForm",

                                   "resource://gre/modules/PluralForm.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "Downloads",

                                   "resource://gre/modules/Downloads.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "DownloadUIHelper",

                                   "resource://gre/modules/DownloadUIHelper.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "DownloadUtils",

                                   "resource://gre/modules/DownloadUtils.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "OS",

                                   "resource://gre/modules/osfile.jsm")

 XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils",

                                   "resource://gre/modules/PlacesUtils.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "PrivateBrowsingUtils",

                                   "resource://gre/modules/PrivateBrowsingUtils.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "RecentWindow",

                                   "resource:///modules/RecentWindow.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "Promise",

                                   "resource://gre/modules/Promise.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "DownloadsLogger",

                                   "resource:///modules/DownloadsLogger.jsm");

 const nsIDM = Ci.nsIDownloadManager;

 const kDownloadsStringBundleUrl =

   "chrome://browser/locale/downloads/downloads.properties";

 const kDownloadsStringsRequiringFormatting = {

   sizeWithUnits: true,

   shortTimeLeftSeconds: true,

   shortTimeLeftMinutes: true,

   shortTimeLeftHours: true,

   shortTimeLeftDays: true,

   statusSeparator: true,

   statusSeparatorBeforeNumber: true,

   fileExecutableSecurityWarning: true

 };

 const kDownloadsStringsRequiringPluralForm = {

   otherDownloads2: true

 };

 XPCOMUtils.defineLazyGetter(this, "DownloadsLocalFileCtor", function () {

   return Components.Constructor("@mozilla.org/file/local;1",

                                 "nsILocalFile", "initWithPath");

 });

 const kPartialDownloadSuffix = ".part";

 const kPrefBranch = Services.prefs.getBranch("browser.download.");

 let PrefObserver = {

   QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver,

                                          Ci.nsISupportsWeakReference]),

   getPref: function PO_getPref(name) {

     try {

       switch (typeof this.prefs[name]) {

         case "boolean":

           return kPrefBranch.getBoolPref(name);

       }

     } catch (ex) { }

     return this.prefs[name];

   },

   observe: function PO_observe(aSubject, aTopic, aData) {

     if (this.prefs.hasOwnProperty(aData)) {

       return this[aData] = this.getPref(aData);

     }

   },

   register: function PO_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

   debug: false,

   animateNotifications: 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.

  */

 this.DownloadsCommon = {

   log: function DC_log(...aMessageArgs) {

     delete this.log;

     this.log = function DC_log(...aMessageArgs) {

       if (!PrefObserver.debug) {

         return;

       }

       DownloadsLogger.log.apply(DownloadsLogger, aMessageArgs);

     }

     this.log.apply(this, aMessageArgs);

   },

   error: function DC_error(...aMessageArgs) {

     delete this.error;

     this.error = function DC_error(...aMessageArgs) {

       if (!PrefObserver.debug) {

         return;

       }

       DownloadsLogger.reportError.apply(DownloadsLogger, aMessageArgs);

     }

     this.error.apply(this, aMessageArgs);

   },

   /**

    * 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);

     let enumerator = sb.getSimpleEnumeration();

     while (enumerator.hasMoreElements()) {

       let string = enumerator.getNext().QueryInterface(Ci.nsIPropertyElement);

       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.slice(arguments, 0),

                                          arguments.length);

         };

       } else if (stringName in kDownloadsStringsRequiringPluralForm) {

         strings[stringName] = function (aCount) {

           // Convert "arguments" to a real array before calling into XPCOM.

           let formattedString = sb.formatStringFromName(stringName,

                                          Array.slice(arguments, 0),

                                          arguments.length);

           return PluralForm.get(aCount, formattedString);

         };

       } else {

         strings[stringName] = string.value;

       }

     }

     delete this.strings;

     return this.strings = strings;

   },

   /**

    * Generates a very short string representing the given time left.

    *

    * @param aSeconds

    *        Value to be formatted.  It represents the number of seconds, it must

    *        be positive but does not need to be an integer.

    *

    * @return Formatted string, for example "30s" or "2h".  The returned value is

    *         maximum three characters long, at least in English.

    */

   formatTimeLeft: function DC_formatTimeLeft(aSeconds)

   {

     // Decide what text to show for the time

     let seconds = Math.round(aSeconds);

     if (!seconds) {

       return "";

     } else if (seconds <= 30) {

       return DownloadsCommon.strings["shortTimeLeftSeconds"](seconds);

     }

     let minutes = Math.round(aSeconds / 60);

     if (minutes < 60) {

       return DownloadsCommon.strings["shortTimeLeftMinutes"](minutes);

     }

     let hours = Math.round(minutes / 60);

     if (hours < 48) { // two days

       return DownloadsCommon.strings["shortTimeLeftHours"](hours);

     }

     let days = Math.round(hours / 24);

     return DownloadsCommon.strings["shortTimeLeftDays"](Math.min(days, 99));

   },

   /**

    * Indicates whether we should show visual notification on the indicator

    * when a download event is triggered.

    */

   get animateNotifications()

   {

     return PrefObserver.animateNotifications;

   },

   /**

    * Get access to one of the DownloadsData or PrivateDownloadsData objects,

    * depending on the privacy status of the window in question.

    *

    * @param aWindow

    *        The browser window which owns the download button.

    */

   getData: function DC_getData(aWindow) {

     if (PrivateBrowsingUtils.isWindowPrivate(aWindow)) {

       return PrivateDownloadsData;

     } else {

       return DownloadsData;

     }

   },

   /**

    * Initializes the Downloads back-end and starts receiving events for both the

    * private and non-private downloads data objects.

    */

   initializeAllDataLinks: function () {

     DownloadsData.initializeDataLink();

     PrivateDownloadsData.initializeDataLink();

   },

   /**

    * Get access to one of the DownloadsIndicatorData or

    * PrivateDownloadsIndicatorData objects, depending on the privacy status of

    * the window in question.

    */

   getIndicatorData: function DC_getIndicatorData(aWindow) {

     if (PrivateBrowsingUtils.isWindowPrivate(aWindow)) {

       return PrivateDownloadsIndicatorData;

     } else {

       return 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: function DC_getSummary(aWindow, aNumToExclude)

   {

     if (PrivateBrowsingUtils.isWindowPrivate(aWindow)) {

       if (this._privateSummary) {

         return this._privateSummary;

       }

       return this._privateSummary = new DownloadsSummaryData(true, aNumToExclude);

     } else {

       if (this._summary) {

         return this._summary;

       }

       return this._summary = new DownloadsSummaryData(false, aNumToExclude);

     }

   },

   _summary: null,

   _privateSummary: null,

   /**

    * Given an iterable collection of DownloadDataItems, generates and returns

    * statistics about that collection.

    *

    * @param aDataItems An iterable collection of DownloadDataItems.

    *

    * @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.

    *         numScanning     : The total number of downloads being scanned.

    *         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: function DC_summarizeDownloads(aDataItems)

   {

     let summary = {

       numActive: 0,

       numPaused: 0,

       numScanning: 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

       // dataItems.

       slowestSpeed: Infinity,

       rawTimeLeft: -1,

       percentComplete: -1

     }

     for (let dataItem of aDataItems) {

       summary.numActive++;

       switch (dataItem.state) {

         case nsIDM.DOWNLOAD_PAUSED:

           summary.numPaused++;

           break;

         case nsIDM.DOWNLOAD_SCANNING:

           summary.numScanning++;

           break;

         case nsIDM.DOWNLOAD_DOWNLOADING:

           summary.numDownloading++;

           if (dataItem.maxBytes > 0 && dataItem.speed > 0) {

             let sizeLeft = dataItem.maxBytes - dataItem.currBytes;

             summary.rawTimeLeft = Math.max(summary.rawTimeLeft,

                                            sizeLeft / dataItem.speed);

             summary.slowestSpeed = Math.min(summary.slowestSpeed,

                                             dataItem.speed);

           }

           break;

       }

       // Only add to total values if we actually know the download size.

       if (dataItem.maxBytes > 0 &&

           dataItem.state != nsIDM.DOWNLOAD_CANCELED &&

           dataItem.state != nsIDM.DOWNLOAD_FAILED) {

         summary.totalSize += dataItem.maxBytes;

         summary.totalTransferred += dataItem.currBytes;

       }

     }

     if (summary.numActive != 0 && summary.totalSize != 0 &&

         summary.numActive != summary.numScanning) {

       summary.percentComplete = (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: function DC_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 sommothing 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 ? .3 : .1) * diff;

       }

       // If the new time is similar, reuse something close to the last time

       // left, but subtract a little to provide forward progress.

       let diff = aSeconds - aLastSeconds;

       let diffPercent = diff / aLastSeconds * 100;

       if (Math.abs(diff) < 5 || Math.abs(diffPercent) < 5) {

         aSeconds = aLastSeconds - (diff < 0 ? .4 : .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.

    * If you've a dataItem, you should call dataItem.openLocalFile.

    * @param aFile

    *        the downloaded file to be opened.

    * @param aMimeInfo

    *        the mime type info object.  May be null.

    * @param aOwnerWindow

    *        the window with which this action is associated.

    */

   openDownloadedFile: function DC_openDownloadedFile(aFile, aMimeInfo, aOwnerWindow) {

     if (!(aFile instanceof Ci.nsIFile))

       throw new Error("aFile must be a nsIFile object");

     if (aMimeInfo && !(aMimeInfo instanceof Ci.nsIMIMEInfo))

       throw new Error("Invalid value passed for aMimeInfo");

     if (!(aOwnerWindow instanceof Ci.nsIDOMWindow))

       throw new Error("aOwnerWindow must be a dom-window object");

     let promiseShouldLaunch;

     if (aFile.isExecutable()) {

       // We get a prompter for the provided window here, even though anchoring

       // to the most recently active window should work as well.

       promiseShouldLaunch =

         DownloadUIHelper.getPrompter(aOwnerWindow)

                         .confirmLaunchExecutable(aFile.path);

     } else {

       promiseShouldLaunch = Promise.resolve(true);

     }

     promiseShouldLaunch.then(shouldLaunch => {

       if (!shouldLaunch) {

         return;

       }

       // Actually open the file.

       try {

         if (aMimeInfo && aMimeInfo.preferredAction == aMimeInfo.useHelperApp) {

           aMimeInfo.launchWithFile(aFile);

           return;

         }

       }

       catch(ex) { }

       // If either we don't have the mime info, or the preferred action failed,

       // attempt to launch the file directly.

       try {

         aFile.launch();

       }

       catch(ex) {

         // If launch fails, try sending it through the system's external "file:"

         // URL handler.

         Cc["@mozilla.org/uriloader/external-protocol-service;1"]

           .getService(Ci.nsIExternalProtocolService)

           .loadUrl(NetUtil.newURI(aFile));

       }

     }).then(null, Cu.reportError);

   },

   /**

    * Show a donwloaded file in the system file manager.

    * If you have a dataItem, use dataItem.showLocalFile.

    *

    * @param aFile

    *        a downloaded file.

    */

   showDownloadedFile: function DC_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) {

         try {

           // Open the parent directory to show where the file should be.

           parent.launch();

         } catch (ex) {

           // If launch also fails (probably because it's not implemented), let

           // the OS handler try to open the parent.

           Cc["@mozilla.org/uriloader/external-protocol-service;1"]

             .getService(Ci.nsIExternalProtocolService)

             .loadUrl(NetUtil.newURI(parent));

         }

       }

     }

   }

 };

 /**

  * Returns true if we are executing on Windows Vista or a later version.

  */

 XPCOMUtils.defineLazyGetter(DownloadsCommon, "isWinVistaOrHigher", function () {

   let os = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime).OS;

   if (os != "WINNT") {

     return false;

   }

   let sysInfo = Cc["@mozilla.org/system-info;1"].getService(Ci.nsIPropertyBag2);

   return parseFloat(sysInfo.getProperty("version")) >= 6;

 });

 ////////////////////////////////////////////////////////////////////////////////

 //// DownloadsData

 /**

  * Retrieves the list of past and completed downloads from the underlying

  * Download Manager data, and provides asynchronous notifications allowing to

  * build a consistent view of the available data.

  *

  * This object responds to real-time changes in the underlying Download Manager

  * data.  For example, the deletion of one or more downloads is notified through

  * the nsIObserver interface, while any state or progress change is notified

  * through the nsIDownloadProgressListener interface.

  *

  * 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.

  *

  * Note that DownloadsData and PrivateDownloadsData are two equivalent singleton

  * objects, one accessing non-private downloads, and the other accessing private

  * ones.

  */

 function DownloadsDataCtor(aPrivate) {

   this._isPrivate = aPrivate;

   // This Object contains all the available DownloadsDataItem objects, indexed by

   // their globally unique identifier.  The identifiers of downloads that have

   // been removed from the Download Manager data are still present, however the

   // associated objects are replaced with the value "null".  This is required to

   // prevent race conditions when populating the list asynchronously.

   this.dataItems = {};

   // Array of view objects that should be notified when the available download

   // data changes.

   this._views = [];

   // Maps Download objects to DownloadDataItem objects.

   this._downloadToDataItemMap = new Map();

 }

 DownloadsDataCtor.prototype = {

   /**

    * Starts receiving events for current downloads.

    */

   initializeDataLink: function ()

   {

     if (!this._dataLinkInitialized) {

       let promiseList = Downloads.getList(this._isPrivate ? Downloads.PRIVATE

                                                           : Downloads.PUBLIC);

       promiseList.then(list => list.addView(this)).then(null, Cu.reportError);

       this._dataLinkInitialized = true;

     }

   },

   _dataLinkInitialized: false,

   /**

    * True if there are finished downloads that can be removed from the list.

    */

   get canRemoveFinished()

   {

     for (let [, dataItem] of Iterator(this.dataItems)) {

       if (dataItem && !dataItem.inProgress) {

         return true;

       }

     }

     return false;

   },

   /**

    * Asks the back-end to remove finished downloads from the list.

    */

   removeFinished: function DD_removeFinished()

   {

     let promiseList = Downloads.getList(this._isPrivate ? Downloads.PRIVATE

                                                         : Downloads.PUBLIC);

     promiseList.then(list => list.removeFinished())

                .then(null, Cu.reportError);

   },

   //////////////////////////////////////////////////////////////////////////////

   //// Integration with the asynchronous Downloads back-end

   onDownloadAdded: function (aDownload)

   {

     let dataItem = new DownloadsDataItem(aDownload);

     this._downloadToDataItemMap.set(aDownload, dataItem);

     this.dataItems[dataItem.downloadGuid] = dataItem;

     for (let view of this._views) {

       view.onDataItemAdded(dataItem, true);

     }

     this._updateDataItemState(dataItem);

   },

   onDownloadChanged: function (aDownload)

   {

     let dataItem = this._downloadToDataItemMap.get(aDownload);

     if (!dataItem) {

       Cu.reportError("Download doesn't exist.");

       return;

     }

     this._updateDataItemState(dataItem);

   },

   onDownloadRemoved: function (aDownload)

   {

     let dataItem = this._downloadToDataItemMap.get(aDownload);

     if (!dataItem) {

       Cu.reportError("Download doesn't exist.");

       return;

     }

     this._downloadToDataItemMap.delete(aDownload);

     this.dataItems[dataItem.downloadGuid] = null;

     for (let view of this._views) {

       view.onDataItemRemoved(dataItem);

     }

   },

   /**

    * Updates the given data item and sends related notifications.

    */

   _updateDataItemState: function (aDataItem)

   {

     let oldState = aDataItem.state;

     let wasInProgress = aDataItem.inProgress;

     let wasDone = aDataItem.done;

     aDataItem.updateFromDownload();

     if (wasInProgress && !aDataItem.inProgress) {

       aDataItem.endTime = Date.now();

     }

     if (oldState != aDataItem.state) {

       for (let view of this._views) {

         try {

           view.getViewItem(aDataItem).onStateChange(oldState);

         } catch (ex) {

           Cu.reportError(ex);

         }

       }

       // This state transition code should actually be located in a Downloads

       // API module (bug 941009).  Moreover, the fact that state is stored as

       // annotations should be ideally hidden behind methods of

       // nsIDownloadHistory (bug 830415).

       if (!this._isPrivate && !aDataItem.inProgress) {

         try {

           let downloadMetaData = { state: aDataItem.state,

                                    endTime: aDataItem.endTime };

           if (aDataItem.done) {

             downloadMetaData.fileSize = aDataItem.maxBytes;

           }

           PlacesUtils.annotations.setPageAnnotation(

                         NetUtil.newURI(aDataItem.uri), "downloads/metaData",

                         JSON.stringify(downloadMetaData), 0,

                         PlacesUtils.annotations.EXPIRE_WITH_HISTORY);

         } catch (ex) {

           Cu.reportError(ex);

         }

       }

     }

     if (!aDataItem.newDownloadNotified) {

       aDataItem.newDownloadNotified = true;

       this._notifyDownloadEvent("start");

     }

     if (!wasDone && aDataItem.done) {

       this._notifyDownloadEvent("finish");

     }

     for (let view of this._views) {

       view.getViewItem(aDataItem).onProgressChange();

     }

   },

   //////////////////////////////////////////////////////////////////////////////

   //// 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: function DD_addView(aView)

   {

     this._views.push(aView);

     this._updateView(aView);

   },

   /**

    * Removes an object previously added using addView.

    *

    * @param aView

    *        DownloadsView object to be removed.

    */

   removeView: function DD_removeView(aView)

   {

     let index = this._views.indexOf(aView);

     if (index != -1) {

       this._views.splice(index, 1);

     }

   },

   /**

    * Ensures that the currently loaded data is added to the specified view.

    *

    * @param aView

    *        DownloadsView object to be initialized.

    */

   _updateView: function DD_updateView(aView)

   {

     // Indicate to the view that a batch loading operation is in progress.

     aView.onDataLoadStarting();

     // Sort backwards by start time, ensuring that the most recent

     // downloads are added first regardless of their state.

     let loadedItemsArray = [dataItem

                             for each (dataItem in this.dataItems)

                             if (dataItem)];

     loadedItemsArray.sort(function(a, b) b.startTime - a.startTime);

     loadedItemsArray.forEach(

       function (dataItem) aView.onDataItemAdded(dataItem, false)

     );

     // Notify the view that all data is available.

     aView.onDataLoadCompleted();

   },

   //////////////////////////////////////////////////////////////////////////////

   //// 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);

     return 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 aType

    *        Set to "start" for new downloads, "finish" for completed downloads.

    */

   _notifyDownloadEvent: function DD_notifyDownloadEvent(aType)

   {

     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 = RecentWindow.getMostRecentBrowserWindow({ private: this._isPrivate });

     if (!browserWin) {

       return;

     }

     if (this.panelHasShownBefore) {

       // 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.

       DownloadsCommon.log("Showing new download notification.");

       browserWin.DownloadsIndicatorView.showEventNotification(aType);

       return;

     }

     this.panelHasShownBefore = true;

     browserWin.DownloadsPanel.showPanel();

   }

 };

 XPCOMUtils.defineLazyGetter(this, "PrivateDownloadsData", function() {

   return new DownloadsDataCtor(true);

 });

 XPCOMUtils.defineLazyGetter(this, "DownloadsData", function() {

   return new DownloadsDataCtor(false);

 });

 ////////////////////////////////////////////////////////////////////////////////

 //// DownloadsDataItem

 /**

  * Represents a single item in the list of downloads.

  *

  * The endTime property is initialized to the current date and time.

  *

  * @param aDownload

  *        The Download object with the current state.

  */

 function DownloadsDataItem(aDownload)

 {

   this._download = aDownload;

   this.downloadGuid = "id:" + this._autoIncrementId;

   this.file = aDownload.target.path;

   this.target = OS.Path.basename(aDownload.target.path);

   this.uri = aDownload.source.url;

   this.endTime = Date.now();

   this.updateFromDownload();

 }

 DownloadsDataItem.prototype = {

   /**

    * The JavaScript API does not need identifiers for Download objects, so they

    * are generated sequentially for the corresponding DownloadDataItem.

    */

   get _autoIncrementId() ++DownloadsDataItem.prototype.__lastId,

   __lastId: 0,

   /**

    * Updates this object from the underlying Download object.

    */

   updateFromDownload: function ()

   {

     // Collapse state using the correct priority.

     if (this._download.succeeded) {

       this.state = nsIDM.DOWNLOAD_FINISHED;

     } else if (this._download.error &&

                this._download.error.becauseBlockedByParentalControls) {

       this.state = nsIDM.DOWNLOAD_BLOCKED_PARENTAL;

     } else if (this._download.error &&

                this._download.error.becauseBlockedByReputationCheck) {

       this.state = nsIDM.DOWNLOAD_DIRTY;

     } else if (this._download.error) {

       this.state = nsIDM.DOWNLOAD_FAILED;

     } else if (this._download.canceled && this._download.hasPartialData) {

       this.state = nsIDM.DOWNLOAD_PAUSED;

     } else if (this._download.canceled) {

       this.state = nsIDM.DOWNLOAD_CANCELED;

     } else if (this._download.stopped) {

       this.state = nsIDM.DOWNLOAD_NOTSTARTED;

     } else {

       this.state = nsIDM.DOWNLOAD_DOWNLOADING;

     }

     this.referrer = this._download.source.referrer;

     this.startTime = this._download.startTime;

     this.currBytes = this._download.currentBytes;

     this.resumable = this._download.hasPartialData;

     this.speed = this._download.speed;

     if (this._download.succeeded) {

       // If the download succeeded, show the final size if available, otherwise

       // use the last known number of bytes transferred.  The final size on disk

       // will be available when bug 941063 is resolved.

       this.maxBytes = this._download.hasProgress ?

                              this._download.totalBytes :

                              this._download.currentBytes;

       this.percentComplete = 100;

     } else if (this._download.hasProgress) {

       // If the final size and progress are known, use them.

       this.maxBytes = this._download.totalBytes;

       this.percentComplete = this._download.progress;

     } else {

       // The download final size and progress percentage is unknown.

       this.maxBytes = -1;

       this.percentComplete = -1;

     }

   },

   /**

    * Indicates whether the download is proceeding normally, and not finished

    * yet.  This includes paused downloads.  When this property is true, the

    * "progress" property represents the current progress of the download.

    */

   get inProgress()

   {

     return [

       nsIDM.DOWNLOAD_NOTSTARTED,

       nsIDM.DOWNLOAD_QUEUED,

       nsIDM.DOWNLOAD_DOWNLOADING,

       nsIDM.DOWNLOAD_PAUSED,

       nsIDM.DOWNLOAD_SCANNING,

     ].indexOf(this.state) != -1;

   },

   /**

    * This is true during the initial phases of a download, before the actual

    * download of data bytes starts.

    */

   get starting()

   {

     return this.state == nsIDM.DOWNLOAD_NOTSTARTED ||

            this.state == nsIDM.DOWNLOAD_QUEUED;

   },

   /**

    * Indicates whether the download is paused.

    */

   get paused()

   {

     return this.state == nsIDM.DOWNLOAD_PAUSED;

   },

   /**

    * Indicates whether the download is in a final state, either because it

    * completed successfully or because it was blocked.

    */

   get done()

   {

     return [

       nsIDM.DOWNLOAD_FINISHED,

       nsIDM.DOWNLOAD_BLOCKED_PARENTAL,

       nsIDM.DOWNLOAD_BLOCKED_POLICY,

       nsIDM.DOWNLOAD_DIRTY,

     ].indexOf(this.state) != -1;

   },

   /**

    * Indicates whether the download is finished and can be opened.

    */

   get openable()

   {

     return this.state == nsIDM.DOWNLOAD_FINISHED;

   },

   /**

    * Indicates whether the download stopped because of an error, and can be

    * resumed manually.

    */

   get canRetry()

   {

     return this.state == nsIDM.DOWNLOAD_CANCELED ||

            this.state == nsIDM.DOWNLOAD_FAILED;

   },

   /**

    * Returns the nsILocalFile for the download target.

    *

    * @throws if the native path is not valid.  This can happen if the same

    *         profile is used on different platforms, for example if a native

    *         Windows path is stored and then the item is accessed on a Mac.

    */

   get localFile()

   {

     return this._getFile(this.file);

   },

   /**

    * Returns the nsILocalFile for the partially downloaded target.

    *

    * @throws if the native path is not valid.  This can happen if the same

    *         profile is used on different platforms, for example if a native

    *         Windows path is stored and then the item is accessed on a Mac.

    */

   get partFile()

   {

     return this._getFile(this.file + kPartialDownloadSuffix);

   },

   /**

    * Returns an nsILocalFile for aFilename. aFilename might be a file URL or

    * a native path.

    *

    * @param aFilename the filename of the file to retrieve.

    * @return an nsILocalFile for the file.

    * @throws if the native path is not valid.  This can happen if the same

    *         profile is used on different platforms, for example if a native

    *         Windows path is stored and then the item is accessed on a Mac.

    * @note This function makes no guarantees about the file's existence -

    *       callers should check that the returned file exists.

    */

   _getFile: function DDI__getFile(aFilename)

   {

     // The download database may contain targets stored as file URLs or native

     // paths.  This can still be true for previously stored items, even if new

     // items are stored using their file URL.  See also bug 239948 comment 12.

     if (aFilename.startsWith("file:")) {

       // Assume the file URL we obtained from the downloads database or from the

       // "spec" property of the target has the UTF-8 charset.

       let fileUrl = NetUtil.newURI(aFilename).QueryInterface(Ci.nsIFileURL);

       return fileUrl.file.clone().QueryInterface(Ci.nsILocalFile);

     } else {

       // The downloads database contains a native path.  Try to create a local

       // file, though this may throw an exception if the path is invalid.

       return new DownloadsLocalFileCtor(aFilename);

     }

   },

   /**

    * Open the target file for this download.

    */

   openLocalFile: function () {

     this._download.launch().then(null, Cu.reportError);

   },

   /**

    * Show the downloaded file in the system file manager.

    */

   showLocalFile: function DDI_showLocalFile() {

     DownloadsCommon.showDownloadedFile(this.localFile);

   },

   /**

    * Resumes the download if paused, pauses it if active.

    * @throws if the download is not resumable or if has already done.

    */

   togglePauseResume: function DDI_togglePauseResume() {

     if (this._download.stopped) {

       this._download.start();

     } else {

       this._download.cancel();

     }

   },

   /**

    * Attempts to retry the download.

    * @throws if we cannot.

    */

   retry: function DDI_retry() {

     this._download.start();

   },

   /**

    * Cancels the download.

    */

   cancel: function() {

     this._download.cancel();

     this._download.removePartialData().then(null, Cu.reportError);

   },

   /**

    * Remove the download.

    */

   remove: function DDI_remove() {

     Downloads.getList(Downloads.ALL)

              .then(list => list.remove(this._download))

              .then(() => this._download.finalize(true))

              .then(null, Cu.reportError);

   }

 };

 ////////////////////////////////////////////////////////////////////////////////

 //// DownloadsViewPrototype

 /**

  * A prototype for an object that registers itself with DownloadsData as soon

  * as a view is registered with it.

  */

 const DownloadsViewPrototype = {

   //////////////////////////////////////////////////////////////////////////////

   //// 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: function DVP_addView(aView)

   {

     // Start receiving events when the first of our views is registered.

     if (this._views.length == 0) {

       if (this._isPrivate) {

         PrivateDownloadsData.addView(this);

       } else {

         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: function DVP_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: function DVP_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 == 0) {

       if (this._isPrivate) {

         PrivateDownloadsData.removeView(this);

       } else {

         DownloadsData.removeView(this);

       }

     }

   },

   //////////////////////////////////////////////////////////////////////////////

   //// Callback functions from DownloadsData

   /**

    * Indicates whether we are still loading downloads data asynchronously.

    */

   _loading: false,

   /**

    * Called before multiple downloads are about to be loaded.

    */

   onDataLoadStarting: function DVP_onDataLoadStarting()

   {

     this._loading = true;

   },

   /**

    * Called after data loading finished.

    */

   onDataLoadCompleted: function DVP_onDataLoadCompleted()

   {

     this._loading = false;

   },

   /**

    * Called when a new download data item is available, either during the

    * asynchronous data load or when a new download is started.

    *

    * @param aDataItem

    *        DownloadsDataItem object that was just added.

    * @param aNewest

    *        When true, indicates that this item is the most recent and should be

    *        added in the topmost position.  This happens when a new download is

    *        started.  When false, indicates that the item is the least recent

    *        with regard to the items that have been already added. The latter

    *        generally happens during the asynchronous data load.

    *

    * @note Subclasses should override this.

    */

   onDataItemAdded: function DVP_onDataItemAdded(aDataItem, aNewest)

   {

     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;

   },

   /**

    * Called when a data item is removed, ensures that the widget associated with

    * the view item is removed from the user interface.

    *

    * @param aDataItem

    *        DownloadsDataItem object that is being removed.

    *

    * @note Subclasses should override this.

    */

   onDataItemRemoved: function DVP_onDataItemRemoved(aDataItem)

   {

     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;

   },

   /**

    * Returns the view item associated with the provided data item for this view.

    *

    * @param aDataItem

    *        DownloadsDataItem object for which the view item is requested.

    *

    * @return Object that can be used to notify item status events.

    *

    * @note Subclasses should override this.

    */

   getViewItem: function DID_getViewItem(aDataItem)

   {

     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;

   },

   /**

    * Private function used to refresh the internal properties being sent to

    * each registered view.

    *

    * @note Subclasses should override this.

    */

   _refreshProperties: function DID_refreshProperties()

   {

     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;

   },

   /**

    * Private function used to refresh an individual view.

    *

    * @note Subclasses should override this.

    */

   _updateView: function DID_updateView()

   {

     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;

   }

 };

 ////////////////////////////////////////////////////////////////////////////////

 //// 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._isPrivate = aPrivate;

   this._views = [];

 }

 DownloadsIndicatorDataCtor.prototype = {

   __proto__: DownloadsViewPrototype,

   /**

    * Removes an object previously added using addView.

    *

    * @param aView

    *        DownloadsIndicatorView object to be removed.

    */

   removeView: function DID_removeView(aView)

   {

     DownloadsViewPrototype.removeView.call(this, aView);

     if (this._views.length == 0) {

       this._itemCount = 0;

     }

   },

   //////////////////////////////////////////////////////////////////////////////

   //// Callback functions from DownloadsData

   /**

    * Called after data loading finished.

    */

   onDataLoadCompleted: function DID_onDataLoadCompleted()

   {

     DownloadsViewPrototype.onDataLoadCompleted.call(this);

     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 aDataItem

    *        DownloadsDataItem object that was just added.

    * @param aNewest

    *        When true, indicates that this item is the most recent and should be

    *        added in the topmost position.  This happens when a new download is

    *        started.  When false, indicates that the item is the least recent

    *        with regard to the items that have been already added. The latter

    *        generally happens during the asynchronous data load.

    */

   onDataItemAdded: function DID_onDataItemAdded(aDataItem, aNewest)

   {

     this._itemCount++;

     this._updateViews();

   },

   /**

    * Called when a data item is removed, ensures that the widget associated with

    * the view item is removed from the user interface.

    *

    * @param aDataItem

    *        DownloadsDataItem object that is being removed.

    */

   onDataItemRemoved: function DID_onDataItemRemoved(aDataItem)

   {

     this._itemCount--;

     this._updateViews();

   },

   /**

    * Returns the view item associated with the provided data item for this view.

    *

    * @param aDataItem

    *        DownloadsDataItem object for which the view item is requested.

    *

    * @return Object that can be used to notify item status events.

    */

   getViewItem: function DID_getViewItem(aDataItem)

   {

     let data = this._isPrivate ? PrivateDownloadsIndicatorData

                                : DownloadsIndicatorData;

     return Object.freeze({

       onStateChange: function DIVI_onStateChange(aOldState)

       {

         if (aDataItem.state == nsIDM.DOWNLOAD_FINISHED ||

             aDataItem.state == nsIDM.DOWNLOAD_FAILED) {

           data.attention = true;

         }

         // Since the state of a download changed, reset the estimated time left.

         data._lastRawTimeLeft = -1;

         data._lastTimeLeft = -1;

         data._updateViews();

       },

       onProgressChange: function DIVI_onProgressChange()

       {

         data._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,

   _counter: "",

   _percentComplete: -1,

   _paused: false,

   /**

    * Indicates whether the download indicators should be highlighted.

    */

   set attention(aValue)

   {

     this._attention = aValue;

     this._updateViews();

     return aValue;

   },

   _attention: false,

   /**

    * Indicates whether the user is interacting with downloads, thus the

    * attention indication should not be shown even if requested.

    */

   set attentionSuppressed(aValue)

   {

     this._attentionSuppressed = aValue;

     this._attention = false;

     this._updateViews();

     return aValue;

   },

   _attentionSuppressed: false,

   /**

    * Computes aggregate values and propagates the changes to our views.

    */

   _updateViews: function DID_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);

   },

   /**

    * Updates the specified view with the current aggregate values.

    *

    * @param aView

    *        DownloadsIndicatorView object to be updated.

    */

   _updateView: function DID_updateView(aView)

   {

     aView.hasDownloads = this._hasDownloads;

     aView.counter = this._counter;

     aView.percentComplete = this._percentComplete;

     aView.paused = this._paused;

     aView.attention = this._attention && !this._attentionSuppressed;

   },

   //////////////////////////////////////////////////////////////////////////////

   //// Property updating based on current download status

   /**

    * Number of download items that are available to be displayed.

    */

   _itemCount: 0,

   /**

    * 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.

    */

   _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.

    */

   _lastTimeLeft: -1,

   /**

    * A generator function for the dataItems that this summary is currently

    * interested in. This generator is passed off to summarizeDownloads in order

    * to generate statistics about the dataItems we care about - in this case,

    * it's all dataItems for active downloads.

    */

   _activeDataItems: function DID_activeDataItems()

   {

     let dataItems = this._isPrivate ? PrivateDownloadsData.dataItems

                                     : DownloadsData.dataItems;

     for each (let dataItem in dataItems) {

       if (dataItem && dataItem.inProgress) {

         yield dataItem;

       }

     }

   },

   /**

    * Computes aggregate values based on the current state of downloads.

    */

   _refreshProperties: function DID_refreshProperties()

   {

     let summary =

       DownloadsCommon.summarizeDownloads(this._activeDataItems());

     // Determine if the indicator should be shown or get attention.

     this._hasDownloads = (this._itemCount > 0);

     // If all downloads are paused, show the progress indicator as paused.

     this._paused = summary.numActive > 0 &&

                    summary.numActive == summary.numPaused;

     this._percentComplete = summary.percentComplete;

     // 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._counter = "";

     } 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._counter = DownloadsCommon.formatTimeLeft(this._lastTimeLeft);

     }

   }

 };

 XPCOMUtils.defineLazyGetter(this, "PrivateDownloadsIndicatorData", function() {

   return new DownloadsIndicatorDataCtor(true);

 });

 XPCOMUtils.defineLazyGetter(this, "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._dataItems = [];

   // 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._isPrivate = aIsPrivate;

   this._views = [];

 }

 DownloadsSummaryData.prototype = {

   __proto__: DownloadsViewPrototype,

   /**

    * Removes an object previously added using addView.

    *

    * @param aView

    *        DownloadsSummary view to be removed.

    */

   removeView: function DSD_removeView(aView)

   {

     DownloadsViewPrototype.removeView.call(this, aView);

     if (this._views.length == 0) {

       // Clear out our collection of DownloadDataItems. If we ever have

       // another view registered with us, this will get re-populated.

       this._dataItems = [];

     }

   },

   //////////////////////////////////////////////////////////////////////////////

   //// Callback functions from DownloadsData - see the documentation in

   //// DownloadsViewPrototype for more information on what these functions

   //// are used for.

   onDataLoadCompleted: function DSD_onDataLoadCompleted()

   {

     DownloadsViewPrototype.onDataLoadCompleted.call(this);

     this._updateViews();

   },

   onDataItemAdded: function DSD_onDataItemAdded(aDataItem, aNewest)

   {

     if (aNewest) {

       this._dataItems.unshift(aDataItem);

     } else {

       this._dataItems.push(aDataItem);

     }

     this._updateViews();

   },

   onDataItemRemoved: function DSD_onDataItemRemoved(aDataItem)

   {

     let itemIndex = this._dataItems.indexOf(aDataItem);

     this._dataItems.splice(itemIndex, 1);

     this._updateViews();

   },

   getViewItem: function DSD_getViewItem(aDataItem)

   {

     let self = this;

     return Object.freeze({

       onStateChange: function DIVI_onStateChange(aOldState)

       {

         // Since the state of a download changed, reset the estimated time left.

         self._lastRawTimeLeft = -1;

         self._lastTimeLeft = -1;

         self._updateViews();

       },

       onProgressChange: function DIVI_onProgressChange()

       {

         self._updateViews();

       }

     });

   },

   //////////////////////////////////////////////////////////////////////////////

   //// Propagation of properties to our views

   /**

    * Computes aggregate values and propagates the changes to our views.

    */

   _updateViews: function DSD_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);

   },

   /**

    * Updates the specified view with the current aggregate values.

    *

    * @param aView

    *        DownloadsIndicatorView object to be updated.

    */

   _updateView: function DSD_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 dataItems that this summary is currently

    * interested in. This generator is passed off to summarizeDownloads in order

    * to generate statistics about the dataItems we care about - in this case,

    * it's the dataItems in this._dataItems after the first few to exclude,

    * which was set when constructing this DownloadsSummaryData instance.

    */

   _dataItemsForSummary: function DSD_dataItemsForSummary()

   {

     if (this._dataItems.length > 0) {

       for (let i = this._numToExclude; i < this._dataItems.length; ++i) {

         yield this._dataItems[i];

       }

     }

   },

   /**

    * Computes aggregate values based on the current state of downloads.

    */

   _refreshProperties: function DSD_refreshProperties()

   {

     // Pre-load summary with default values.

     let summary =

       DownloadsCommon.summarizeDownloads(this._dataItemsForSummary());

     this._description = DownloadsCommon.strings

                                        .otherDownloads2(summary.numActive);

     this._percentComplete = summary.percentComplete;

     // If all downloads are paused, show the progress indicator as paused.

     this._showingProgress = summary.numDownloading > 0 ||

                             summary.numPaused > 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] = DownloadUtils.getDownloadStatusNoRate(

         summary.totalTransferred, summary.totalSize, summary.slowestSpeed,

         this._lastTimeLeft);

     }

   }

 }