The Tor Browser: mobile/android/chrome/content/aboutDownloads.js@6474c204b198 (annotated)

mobile/android/chrome/content/aboutDownloads.js@6474c204b198 (annotated)

mobile/android/chrome/content/aboutDownloads.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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/. */
 let Ci = Components.interfaces, Cc = Components.classes, Cu = Components.utils;
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/DownloadUtils.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/PluralForm.jsm");
 Cu.import("resource://gre/modules/PrivateBrowsingUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "OS", "resource://gre/modules/osfile.jsm");
 let gStrings = Services.strings.createBundle("chrome://browser/locale/aboutDownloads.properties");
 let downloadTemplate =
 "<li downloadGUID='{guid}' class='list-item' role='button' state='{state}' contextmenu='downloadmenu'>" +
   "<img class='icon' src='{icon}'/>" +
   "<div class='details'>" +
      "<div class='row'>" +
        // This is a hack so that we can crop this label in its center
        "<xul:label class='title' crop='center' value='{target}'/>" +
        "<div class='date'>{date}</div>" +
      "</div>" +
      "<div class='size'>{size}</div>" +
      "<div class='domain'>{domain}</div>" +
      "<div class='displayState'>{displayState}</div>" +
   "</div>" +
 "</li>";
 XPCOMUtils.defineLazyGetter(window, "gChromeWin", function ()
   window.QueryInterface(Ci.nsIInterfaceRequestor)
     .getInterface(Ci.nsIWebNavigation)
     .QueryInterface(Ci.nsIDocShellTreeItem)
     .rootTreeItem
     .QueryInterface(Ci.nsIInterfaceRequestor)
     .getInterface(Ci.nsIDOMWindow)
     .QueryInterface(Ci.nsIDOMChromeWindow));
 var ContextMenus = {
   target: null,
   init: function() {
     document.addEventListener("contextmenu", this, false);
     document.getElementById("contextmenu-open").addEventListener("click", this.open.bind(this), false);
     document.getElementById("contextmenu-retry").addEventListener("click", this.retry.bind(this), false);
     document.getElementById("contextmenu-remove").addEventListener("click", this.remove.bind(this), false);
     document.getElementById("contextmenu-pause").addEventListener("click", this.pause.bind(this), false);
     document.getElementById("contextmenu-resume").addEventListener("click", this.resume.bind(this), false);
     document.getElementById("contextmenu-cancel").addEventListener("click", this.cancel.bind(this), false);
     document.getElementById("contextmenu-removeall").addEventListener("click", this.removeAll.bind(this), false);
     this.items = [
       { name: "open", states: [Downloads._dlmgr.DOWNLOAD_FINISHED] },
       { name: "retry", states: [Downloads._dlmgr.DOWNLOAD_FAILED, Downloads._dlmgr.DOWNLOAD_CANCELED] },
       { name: "remove", states: [Downloads._dlmgr.DOWNLOAD_FINISHED,Downloads._dlmgr.DOWNLOAD_FAILED, Downloads._dlmgr.DOWNLOAD_CANCELED] },
       { name: "removeall", states: [Downloads._dlmgr.DOWNLOAD_FINISHED,Downloads._dlmgr.DOWNLOAD_FAILED, Downloads._dlmgr.DOWNLOAD_CANCELED] },
       { name: "pause", states: [Downloads._dlmgr.DOWNLOAD_DOWNLOADING] },
       { name: "resume", states: [Downloads._dlmgr.DOWNLOAD_PAUSED] },
       { name: "cancel", states: [Downloads._dlmgr.DOWNLOAD_DOWNLOADING, Downloads._dlmgr.DOWNLOAD_NOTSTARTED, Downloads._dlmgr.DOWNLOAD_QUEUED, Downloads._dlmgr.DOWNLOAD_PAUSED] },
     ];
   },
   handleEvent: function(event) {
     // store the target of context menu events so that we know which app to act on
     this.target = event.target;
     while (!this.target.hasAttribute("contextmenu")) {
       this.target = this.target.parentNode;
     }
     if (!this.target)
       return;
     let state = parseInt(this.target.getAttribute("state"));
     for (let i = 0; i < this.items.length; i++) {
       var item = this.items[i];
       let enabled = (item.states.indexOf(state) > -1);
       if (enabled)
         document.getElementById("contextmenu-" + item.name).removeAttribute("hidden");
       else
         document.getElementById("contextmenu-" + item.name).setAttribute("hidden", "true");
     }
   },
   // Open shown only for downloads that completed successfully
   open: function(event) {
     Downloads.openDownload(this.target);
     this.target = null;
   },
   // Retry shown when its failed, canceled, blocked(covered in failed, see _getState())
   retry: function (event) {
     Downloads.retryDownload(this.target);
     this.target = null;
   },
   // Remove shown when its canceled, finished, failed(failed includes blocked and dirty, see _getState())
   remove: function (event) {
     Downloads.removeDownload(this.target);
     this.target = null;
   },
   // Pause shown when item is currently downloading
   pause: function (event) {
     Downloads.pauseDownload(this.target);
     this.target = null;
   },
   // Resume shown for paused items only
   resume: function (event) {
     Downloads.resumeDownload(this.target);
     this.target = null;
   },
   // Cancel shown when its downloading, notstarted, queued or paused
   cancel: function (event) {
     Downloads.cancelDownload(this.target);
     this.target = null;
   },
   removeAll: function(event) {
     Downloads.removeAll();
     this.target = null;
   }
 }
 let Downloads = {
   init: function dl_init() {
     function onClick(evt) {
       let target = evt.target;
       while (target.nodeName != "li") {
         target = target.parentNode;
         if (!target)
           return;
       }
       Downloads.openDownload(target);
     }
     this._normalList = document.getElementById("normal-downloads-list");
     this._privateList = document.getElementById("private-downloads-list");
     this._normalList.addEventListener("click", onClick, false);
     this._privateList.addEventListener("click", onClick, false);
     this._dlmgr = Cc["@mozilla.org/download-manager;1"].getService(Ci.nsIDownloadManager);
     this._dlmgr.addPrivacyAwareListener(this);
     Services.obs.addObserver(this, "last-pb-context-exited", false);
     Services.obs.addObserver(this, "download-manager-remove-download-guid", false);
     // If we have private downloads, show them all immediately. If we were to
     // add them asynchronously, there's a small chance we could get a
     // "last-pb-context-exited" notification before downloads are added to the
     // list, meaning we'd show private downloads without any private tabs open.
     let privateEntries = this.getDownloads({ isPrivate: true });
     this._stepAddEntries(privateEntries, this._privateList, privateEntries.length);
     // Add non-private downloads
     let normalEntries = this.getDownloads({ isPrivate: false });
     this._stepAddEntries(normalEntries, this._normalList, 1, this._scrollToSelectedDownload.bind(this));
     ContextMenus.init();
   },
   uninit: function dl_uninit() {
     let contextmenus = gChromeWin.NativeWindow.contextmenus;
     contextmenus.remove(this.openMenuItem);
     contextmenus.remove(this.removeMenuItem);
     contextmenus.remove(this.pauseMenuItem);
     contextmenus.remove(this.resumeMenuItem);
     contextmenus.remove(this.retryMenuItem);
     contextmenus.remove(this.cancelMenuItem);
     contextmenus.remove(this.deleteAllMenuItem);
     this._dlmgr.removeListener(this);
     Services.obs.removeObserver(this, "last-pb-context-exited");
     Services.obs.removeObserver(this, "download-manager-remove-download-guid");
   },
   onProgressChange: function(aWebProgress, aRequest, aCurSelfProgress, aMaxSelfProgress,
                              aCurTotalProgress, aMaxTotalProgress, aDownload) { },
   onDownloadStateChange: function(aState, aDownload) {
     switch (aDownload.state) {
       case Ci.nsIDownloadManager.DOWNLOAD_FAILED:
       case Ci.nsIDownloadManager.DOWNLOAD_CANCELED:
       case Ci.nsIDownloadManager.DOWNLOAD_BLOCKED_PARENTAL:
       case Ci.nsIDownloadManager.DOWNLOAD_DIRTY:
       case Ci.nsIDownloadManager.DOWNLOAD_FINISHED:
         // For all "completed" states, move them after active downloads
         this._moveDownloadAfterActive(this._getElementForDownload(aDownload.guid));
       // Fall-through the rest
       case Ci.nsIDownloadManager.DOWNLOAD_SCANNING:
       case Ci.nsIDownloadManager.DOWNLOAD_QUEUED:
       case Ci.nsIDownloadManager.DOWNLOAD_DOWNLOADING:
         let item = this._getElementForDownload(aDownload.guid);
         if (item)
           this._updateDownloadRow(item, aDownload);
         else
           this._insertDownloadRow(aDownload);
         break;
     }
   },
   onStateChange: function(aWebProgress, aRequest, aState, aStatus, aDownload) { },
   onSecurityChange: function(aWebProgress, aRequest, aState, aDownload) { },
   observe: function (aSubject, aTopic, aData) {
     switch (aTopic) {
       case "last-pb-context-exited":
         this._privateList.innerHTML = "";
         break;
       case "download-manager-remove-download-guid": {
         let guid = aSubject.QueryInterface(Ci.nsISupportsCString).data;
         this._removeItem(this._getElementForDownload(guid));
         break;
       }
     }
   },
   _moveDownloadAfterActive: function dl_moveDownloadAfterActive(aItem) {
     // Move downloads that just reached a "completed" state below any active
     try {
       // Iterate down until we find a non-active download
       let next = aItem.nextElementSibling;
       while (next && this._inProgress(next.getAttribute("state")))
         next = next.nextElementSibling;
       // Move the item
       aItem.parentNode.insertBefore(aItem, next);
     } catch (ex) {
       this.logError("_moveDownloadAfterActive() " + ex);
     }
   },
   _inProgress: function dl_inProgress(aState) {
     return [
       this._dlmgr.DOWNLOAD_NOTSTARTED,
       this._dlmgr.DOWNLOAD_QUEUED,
       this._dlmgr.DOWNLOAD_DOWNLOADING,
       this._dlmgr.DOWNLOAD_PAUSED,
       this._dlmgr.DOWNLOAD_SCANNING,
     ].indexOf(parseInt(aState)) != -1;
   },
   _insertDownloadRow: function dl_insertDownloadRow(aDownload) {
     let updatedState = this._getState(aDownload.state);
     let item = this._createItem(downloadTemplate, {
       guid: aDownload.guid,
       target: aDownload.displayName,
       icon: "moz-icon://" + aDownload.displayName + "?size=64",
       date: DownloadUtils.getReadableDates(new Date())[0],
       domain: DownloadUtils.getURIHost(aDownload.source.spec)[0],
       size: this._getDownloadSize(aDownload.size),
       displayState: this._getStateString(updatedState),
       state: updatedState
     });
     list = aDownload.isPrivate ? this._privateList : this._normalList;
     list.insertAdjacentHTML("afterbegin", item);
   },
   _getDownloadSize: function dl_getDownloadSize(aSize) {
     if (aSize > 0) {
       let displaySize = DownloadUtils.convertByteUnits(aSize);
       return displaySize.join(""); // [0] is size, [1] is units
     }
     return gStrings.GetStringFromName("downloadState.unknownSize");
   },
   // Not all states are displayed as-is on mobile, some are translated to a generic state
   _getState: function dl_getState(aState) {
     let str;
     switch (aState) {
       // Downloading and Scanning states show up as "Downloading"
       case this._dlmgr.DOWNLOAD_DOWNLOADING:
       case this._dlmgr.DOWNLOAD_SCANNING:
         str = this._dlmgr.DOWNLOAD_DOWNLOADING;
         break;
       // Failed, Dirty and Blocked states show up as "Failed"
       case this._dlmgr.DOWNLOAD_FAILED:
       case this._dlmgr.DOWNLOAD_DIRTY:
       case this._dlmgr.DOWNLOAD_BLOCKED_POLICY:
       case this._dlmgr.DOWNLOAD_BLOCKED_PARENTAL:
         str = this._dlmgr.DOWNLOAD_FAILED;
         break;
       /* QUEUED and NOTSTARTED are not translated as they
          dont fall under a common state but we still need
          to display a common "status" on the UI */
       default:
         str = aState;
     }
     return str;
   },
   // Note: This doesn't cover all states as some of the states are translated in _getState()
   _getStateString: function dl_getStateString(aState) {
     let str;
     switch (aState) {
       case this._dlmgr.DOWNLOAD_DOWNLOADING:
         str = "downloadState.downloading";
         break;
       case this._dlmgr.DOWNLOAD_CANCELED:
         str = "downloadState.canceled";
         break;
       case this._dlmgr.DOWNLOAD_FAILED:
         str = "downloadState.failed";
         break;
       case this._dlmgr.DOWNLOAD_PAUSED:
         str = "downloadState.paused";
         break;
       // Queued and Notstarted show up as "Starting..."
       case this._dlmgr.DOWNLOAD_QUEUED:
       case this._dlmgr.DOWNLOAD_NOTSTARTED:
         str = "downloadState.starting";
         break;
       default:
         return "";
     }
     return gStrings.GetStringFromName(str);
   },
   _updateItem: function dl_updateItem(aItem, aValues) {
     for (let i in aValues) {
       aItem.querySelector("." + i).textContent = aValues[i];
     }
   },
   _initStatement: function dv__initStatement(aIsPrivate) {
     let dbConn = aIsPrivate ? this._dlmgr.privateDBConnection : this._dlmgr.DBConnection;
     return dbConn.createStatement(
       "SELECT guid, name, source, state, startTime, endTime, referrer, " +
              "currBytes, maxBytes, state IN (?1, ?2, ?3, ?4, ?5) isActive " +
       "FROM moz_downloads " +
       "ORDER BY isActive DESC, endTime DESC, startTime DESC");
   },
   _createItem: function _createItem(aTemplate, aValues) {
     function htmlEscape(s) {
       s = s.replace(/&/g, "&amp;");
       s = s.replace(/>/g, "&gt;");
       s = s.replace(/</g, "&lt;");
       s = s.replace(/"/g, "&quot;");
       s = s.replace(/'/g, "&apos;");
       return s;
     }
     let t = aTemplate;
     for (let key in aValues) {
       if (aValues.hasOwnProperty(key)) {
         let regEx = new RegExp("{" + key + "}", "g");
         let value = htmlEscape(aValues[key].toString());
         t = t.replace(regEx, value);
       }
     }
     return t;
   },
   _getEntry: function dv__getEntry(aStmt) {
     try {
       if (!aStmt.executeStep()) {
         return null;
       }
       let updatedState = this._getState(aStmt.row.state);
       // Try to get the attribute values from the statement
       return {
         guid: aStmt.row.guid,
         target: aStmt.row.name,
         icon: "moz-icon://" + aStmt.row.name + "?size=64",
         date: DownloadUtils.getReadableDates(new Date(aStmt.row.endTime / 1000))[0],
         domain: DownloadUtils.getURIHost(aStmt.row.source)[0],
         size: this._getDownloadSize(aStmt.row.maxBytes),
         displayState: this._getStateString(updatedState),
         state: updatedState
       };
     } catch (e) {
       // Something went wrong when stepping or getting values, so clear and quit
       this.logError("_getEntry() " + e);
       aStmt.reset();
       return null;
     }
   },
   _stepAddEntries: function dv__stepAddEntries(aEntries, aList, aNumItems, aCallback) {
     if (aEntries.length == 0){
       if (aCallback)
         aCallback();
       return;
     }
     let attrs = aEntries.shift();
     let item = this._createItem(downloadTemplate, attrs);
     aList.insertAdjacentHTML("beforeend", item);
     // Add another item to the list if we should; otherwise, let the UI update
     // and continue later
     if (aNumItems > 1) {
       this._stepAddEntries(aEntries, aList, aNumItems - 1, aCallback);
     } else {
       // Use a shorter delay for earlier downloads to display them faster
       let delay = Math.min(aList.itemCount * 10, 300);
       setTimeout(function () {
         this._stepAddEntries(aEntries, aList, 5, aCallback);
       }.bind(this), delay);
     }
   },
   getDownloads: function dl_getDownloads(aParams) {
     aParams = aParams || {};
     let stmt = this._initStatement(aParams.isPrivate);
     stmt.reset();
     stmt.bindInt32Parameter(0, Ci.nsIDownloadManager.DOWNLOAD_NOTSTARTED);
     stmt.bindInt32Parameter(1, Ci.nsIDownloadManager.DOWNLOAD_DOWNLOADING);
     stmt.bindInt32Parameter(2, Ci.nsIDownloadManager.DOWNLOAD_PAUSED);
     stmt.bindInt32Parameter(3, Ci.nsIDownloadManager.DOWNLOAD_QUEUED);
     stmt.bindInt32Parameter(4, Ci.nsIDownloadManager.DOWNLOAD_SCANNING);
     let entries = [];
     while (entry = this._getEntry(stmt)) {
       entries.push(entry);
     }
     stmt.finalize();
     return entries;
   },
   _getElementForDownload: function dl_getElementForDownload(aKey) {
     return document.body.querySelector("li[downloadGUID='" + aKey + "']");
   },
   _getDownloadForElement: function dl_getDownloadForElement(aElement, aCallback) {
     let guid = aElement.getAttribute("downloadGUID");
     this._dlmgr.getDownloadByGUID(guid, function(status, download) {
       if (!Components.isSuccessCode(status)) {
         return;
       }
       aCallback(download);
     });
   },
   _removeItem: function dl_removeItem(aItem) {
     // Make sure we have an item to remove
     if (!aItem)
       return;
     aItem.parentNode.removeChild(aItem);
   },
   openDownload: function dl_openDownload(aItem) {
     this._getDownloadForElement(aItem, function(aDownload) {
       if (aDownload.state !== Ci.nsIDownloadManager.DOWNLOAD_FINISHED) {
         // Do not open unfinished downloads.
         return;
       }
       try {
         let f = aDownload.targetFile;
         if (f) f.launch();
       } catch (ex) {
         this.logError("openDownload() " + ex, aDownload);
       }
     }.bind(this));
   },
   removeDownload: function dl_removeDownload(aItem) {
     this._getDownloadForElement(aItem, function(aDownload) {
       if (aDownload.targetFile) {
         OS.File.remove(aDownload.targetFile.path).then(null, function onError(reason) {
           if (!(reason instanceof OS.File.Error && reason.becauseNoSuchFile)) {
             this.logError("removeDownload() " + reason, aDownload);
           }
         }.bind(this));
       }
       aDownload.remove();
     }.bind(this));
   },
   removeAll: function dl_removeAll() {
     let title = gStrings.GetStringFromName("downloadAction.deleteAll");
     let messageForm = gStrings.GetStringFromName("downloadMessage.deleteAll");
     let elements = document.body.querySelectorAll("li[state='" + this._dlmgr.DOWNLOAD_FINISHED + "']," +
                                                "li[state='" + this._dlmgr.DOWNLOAD_CANCELED + "']," +
                                                "li[state='" + this._dlmgr.DOWNLOAD_FAILED + "']");
     let message = PluralForm.get(elements.length, messageForm)
                             .replace("#1", elements.length);
     let flags = Services.prompt.BUTTON_POS_0 * Services.prompt.BUTTON_TITLE_OK +
                 Services.prompt.BUTTON_POS_1 * Services.prompt.BUTTON_TITLE_CANCEL;
     let choice = Services.prompt.confirmEx(null, title, message, flags,
                                            null, null, null, null, {});
     if (choice == 0) {
       for (let i = 0; i < elements.length; i++) {
         this.removeDownload(elements[i]);
       }
     }
   },
   pauseDownload: function dl_pauseDownload(aItem) {
     this._getDownloadForElement(aItem, function(aDownload) {
       try {
         aDownload.pause();
         this._updateDownloadRow(aItem, aDownload);
       } catch (ex) {
         this.logError("Error: pauseDownload() " + ex, aDownload);
       }
     }.bind(this));
   },
   resumeDownload: function dl_resumeDownload(aItem) {
     this._getDownloadForElement(aItem, function(aDownload) {
       try {
         aDownload.resume();
         this._updateDownloadRow(aItem, aDownload);
       } catch (ex) {
         this.logError("resumeDownload() " + ex, aDownload);
       }
     }.bind(this));
   },
   retryDownload: function dl_retryDownload(aItem) {
     this._getDownloadForElement(aItem, function(aDownload) {
       try {
         this._removeItem(aItem);
         aDownload.retry();
       } catch (ex) {
         this.logError("retryDownload() " + ex, aDownload);
       }
     }.bind(this));
   },
   cancelDownload: function dl_cancelDownload(aItem) {
     this._getDownloadForElement(aItem, function(aDownload) {
       OS.File.remove(aDownload.targetFile.path).then(null, function onError(reason) {
         if (!(reason instanceof OS.File.Error && reason.becauseNoSuchFile)) {
           this.logError("cancelDownload() " + reason, aDownload);
         }
       }.bind(this));
       aDownload.cancel();
       this._updateDownloadRow(aItem, aDownload);
     }.bind(this));
   },
   _updateDownloadRow: function dl_updateDownloadRow(aItem, aDownload) {
     try {
       let updatedState = this._getState(aDownload.state);
       aItem.setAttribute("state", updatedState);
       this._updateItem(aItem, {
         size: this._getDownloadSize(aDownload.size),
         displayState: this._getStateString(updatedState),
         date: DownloadUtils.getReadableDates(new Date())[0]
       });
     } catch (ex) {
       this.logError("_updateDownloadRow() " + ex, aDownload);
     }
   },
   /**
    * In case a specific downloadId was passed while opening, scrolls the list to
    * the given elemenet
    */
   _scrollToSelectedDownload : function dl_scrollToSelected() {
     let spec = document.location.href;
     let pos = spec.indexOf("?");
     let query = "";
     if (pos >= 0)
       query = spec.substring(pos + 1);
     // Just assume the query is "id=<id>"
     let id = query.substring(3);
     if (!id) {
       return;
     }
     downloadElement = this._getElementForDownload(id);
     if (!downloadElement) {
       return;
     }
     downloadElement.scrollIntoView();
   },
   /**
    * Logs the error to the console.
    *
    * @param aMessage  error message to log
    * @param aDownload (optional) if given, and if the download is private, the
    *                  log message is suppressed
    */
   logError: function dl_logError(aMessage, aDownload) {
     if (!aDownload || !aDownload.isPrivate) {
       console.log("Error: " + aMessage);
     }
   },
   QueryInterface: function (aIID) {
     if (!aIID.equals(Ci.nsIDownloadProgressListener) &&
         !aIID.equals(Ci.nsISupports))
       throw Components.results.NS_ERROR_NO_INTERFACE;
     return this;
   }
 }
 document.addEventListener("DOMContentLoaded", Downloads.init.bind(Downloads), true);
 window.addEventListener("unload", Downloads.uninit.bind(Downloads), false);