The Tor Browser: toolkit/mozapps/downloads/content/downloads.js@129ffea94266 (annotated)

toolkit/mozapps/downloads/content/downloads.js@129ffea94266 (annotated)

toolkit/mozapps/downloads/content/downloads.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 # -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 # 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/.
 ////////////////////////////////////////////////////////////////////////////////
 //// Globals
 const PREF_BDM_CLOSEWHENDONE = "browser.download.manager.closeWhenDone";
 const PREF_BDM_ALERTONEXEOPEN = "browser.download.manager.alertOnEXEOpen";
 const PREF_BDM_SCANWHENDONE = "browser.download.manager.scanWhenDone";
 const nsLocalFile = Components.Constructor("@mozilla.org/file/local;1",
                                            "nsILocalFile", "initWithPath");
 var Cc = Components.classes;
 var Ci = Components.interfaces;
 let Cu = Components.utils;
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/DownloadUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "PluralForm",
                                   "resource://gre/modules/PluralForm.jsm");
 const nsIDM = Ci.nsIDownloadManager;
 let gDownloadManager = Cc["@mozilla.org/download-manager;1"].getService(nsIDM);
 let gDownloadManagerUI = Cc["@mozilla.org/download-manager-ui;1"].
                          getService(Ci.nsIDownloadManagerUI);
 let gDownloadListener = null;
 let gDownloadsView = null;
 let gSearchBox = null;
 let gSearchTerms = [];
 let gBuilder = 0;
 // This variable is used when performing commands on download items and gives
 // the command the ability to do something after all items have been operated
 // on. The following convention is used to handle the value of the variable:
 // whenever we aren't performing a command, the value is |undefined|; just
 // before executing commands, the value will be set to |null|; and when
 // commands want to create a callback, they set the value to be a callback
 // function to be executed after all download items have been visited.
 let gPerformAllCallback;
 // Control the performance of the incremental list building by setting how many
 // milliseconds to wait before building more of the list and how many items to
 // add between each delay.
 const gListBuildDelay = 300;
 const gListBuildChunk = 3;
 // Array of download richlistitem attributes to check when searching
 const gSearchAttributes = [
   "target",
   "status",
   "dateTime",
 ];
 // If the user has interacted with the window in a significant way, we should
 // not auto-close the window. Tough UI decisions about what is "significant."
 var gUserInteracted = false;
 // These strings will be converted to the corresponding ones from the string
 // bundle on startup.
 let gStr = {
   paused: "paused",
   cannotPause: "cannotPause",
   doneStatus: "doneStatus",
   doneSize: "doneSize",
   doneSizeUnknown: "doneSizeUnknown",
   stateFailed: "stateFailed",
   stateCanceled: "stateCanceled",
   stateBlockedParentalControls: "stateBlocked",
   stateBlockedPolicy: "stateBlockedPolicy",
   stateDirty: "stateDirty",
   downloadsTitleFiles: "downloadsTitleFiles",
   downloadsTitlePercent: "downloadsTitlePercent",
   fileExecutableSecurityWarningTitle: "fileExecutableSecurityWarningTitle",
   fileExecutableSecurityWarningDontAsk: "fileExecutableSecurityWarningDontAsk"
 };
 // The statement to query for downloads that are active or match the search
 let gStmt = null;
 ////////////////////////////////////////////////////////////////////////////////
 //// Start/Stop Observers
 function downloadCompleted(aDownload)
 {
   // The download is changing state, so update the clear list button
   updateClearListButton();
   // Wrap this in try...catch since this can be called while shutting down...
   // it doesn't really matter if it fails then since well.. we're shutting down
   // and there's no UI to update!
   try {
     let dl = getDownload(aDownload.id);
     // Update attributes now that we've finished
     dl.setAttribute("startTime", Math.round(aDownload.startTime / 1000));
     dl.setAttribute("endTime", Date.now());
     dl.setAttribute("currBytes", aDownload.amountTransferred);
     dl.setAttribute("maxBytes", aDownload.size);
     // Move the download below active if it should stay in the list
     if (downloadMatchesSearch(dl)) {
       // Iterate down until we find a non-active download
       let next = dl.nextSibling;
       while (next && next.inProgress)
         next = next.nextSibling;
       // Move the item
       gDownloadsView.insertBefore(dl, next);
     } else {
       removeFromView(dl);
     }
     // getTypeFromFile fails if it can't find a type for this file.
     try {
       // Refresh the icon, so that executable icons are shown.
       var mimeService = Cc["@mozilla.org/mime;1"].
                         getService(Ci.nsIMIMEService);
       var contentType = mimeService.getTypeFromFile(aDownload.targetFile);
       var listItem = getDownload(aDownload.id)
       var oldImage = listItem.getAttribute("image");
       // Tacking on contentType bypasses cache
       listItem.setAttribute("image", oldImage + "&contentType=" + contentType);
     } catch (e) { }
     if (gDownloadManager.activeDownloadCount == 0)
       document.title = document.documentElement.getAttribute("statictitle");
     gDownloadManagerUI.getAttention();
   }
   catch (e) { }
 }
 function autoRemoveAndClose(aDownload)
 {
   var pref = Cc["@mozilla.org/preferences-service;1"].
              getService(Ci.nsIPrefBranch);
   if (gDownloadManager.activeDownloadCount == 0) {
     // For the moment, just use the simple heuristic that if this window was
     // opened by the download process, rather than by the user, it should
     // auto-close if the pref is set that way. If the user opened it themselves,
     // it should not close until they explicitly close it.  Additionally, the
     // preference to control the feature may not be set, so defaulting to
     // keeping the window open.
     let autoClose = false;
     try {
       autoClose = pref.getBoolPref(PREF_BDM_CLOSEWHENDONE);
     } catch (e) { }
     var autoOpened =
       !window.opener || window.opener.location.href == window.location.href;
     if (autoClose && autoOpened && !gUserInteracted) {
       gCloseDownloadManager();
       return true;
     }
   }
   return false;
 }
 // This function can be overwritten by extensions that wish to place the
 // Download Window in another part of the UI.
 function gCloseDownloadManager()
 {
   window.close();
 }
 ////////////////////////////////////////////////////////////////////////////////
 //// Download Event Handlers
 function cancelDownload(aDownload)
 {
   gDownloadManager.cancelDownload(aDownload.getAttribute("dlid"));
   // XXXben -
   // If we got here because we resumed the download, we weren't using a temp file
   // because we used saveURL instead. (this is because the proper download mechanism
   // employed by the helper app service isn't fully accessible yet... should be fixed...
   // talk to bz...)
   // the upshot is we have to delete the file if it exists.
   var f = getLocalFileFromNativePathOrUrl(aDownload.getAttribute("file"));
   if (f.exists())
     f.remove(false);
 }
 function pauseDownload(aDownload)
 {
   var id = aDownload.getAttribute("dlid");
   gDownloadManager.pauseDownload(id);
 }
 function resumeDownload(aDownload)
 {
   gDownloadManager.resumeDownload(aDownload.getAttribute("dlid"));
 }
 function removeDownload(aDownload)
 {
   gDownloadManager.removeDownload(aDownload.getAttribute("dlid"));
 }
 function retryDownload(aDownload)
 {
   removeFromView(aDownload);
   gDownloadManager.retryDownload(aDownload.getAttribute("dlid"));
 }
 function showDownload(aDownload)
 {
   var f = getLocalFileFromNativePathOrUrl(aDownload.getAttribute("file"));
   try {
     // Show the directory containing the file and select the file
     f.reveal();
   } catch (e) {
     // 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 = f.parent.QueryInterface(Ci.nsILocalFile);
     if (!parent)
       return;
     try {
       // "Double click" the parent directory to show where the file should be
       parent.launch();
     } catch (e) {
       // If launch also fails (probably because it's not implemented), let the
       // OS handler try to open the parent
       openExternal(parent);
     }
   }
 }
 function onDownloadDblClick(aEvent)
 {
   // Only do the default action for double primary clicks
   if (aEvent.button == 0 && aEvent.target.selected)
     doDefaultForSelected();
 }
 function openDownload(aDownload)
 {
   var f = getLocalFileFromNativePathOrUrl(aDownload.getAttribute("file"));
   if (f.isExecutable()) {
     var dontAsk = false;
     var pref = Cc["@mozilla.org/preferences-service;1"].
                getService(Ci.nsIPrefBranch);
     try {
       dontAsk = !pref.getBoolPref(PREF_BDM_ALERTONEXEOPEN);
     } catch (e) { }
 #ifdef XP_WIN
     // On Vista and above, we rely on native security prompting for
     // downloaded content unless it's disabled.
     try {
       var sysInfo = Cc["@mozilla.org/system-info;1"].
                     getService(Ci.nsIPropertyBag2);
       if (parseFloat(sysInfo.getProperty("version")) >= 6 &&
           pref.getBoolPref(PREF_BDM_SCANWHENDONE)) {
         dontAsk = true;
       }
     } catch (ex) { }
 #endif
     if (!dontAsk) {
       var strings = document.getElementById("downloadStrings");
       var name = aDownload.getAttribute("target");
       var message = strings.getFormattedString("fileExecutableSecurityWarning", [name, name]);
       let title = gStr.fileExecutableSecurityWarningTitle;
       let dontAsk = gStr.fileExecutableSecurityWarningDontAsk;
       var promptSvc = Cc["@mozilla.org/embedcomp/prompt-service;1"].
                       getService(Ci.nsIPromptService);
       var checkbox = { value: false };
       var open = promptSvc.confirmCheck(window, title, message, dontAsk, checkbox);
       if (!open)
         return;
       pref.setBoolPref(PREF_BDM_ALERTONEXEOPEN, !checkbox.value);
     }
   }
   try {
     try {
       let download = gDownloadManager.getDownload(aDownload.getAttribute("dlid"));
       let mimeInfo = download.MIMEInfo;
       if (mimeInfo.preferredAction == mimeInfo.useHelperApp) {
         mimeInfo.launchWithFile(f);
         return;
       }
     } catch (ex) {
     }
     f.launch();
   } catch (ex) {
     // if launch fails, try sending it through the system's external
     // file: URL handler
     openExternal(f);
   }
 }
 function openReferrer(aDownload)
 {
   openURL(getReferrerOrSource(aDownload));
 }
 function copySourceLocation(aDownload)
 {
   var uri = aDownload.getAttribute("uri");
   var clipboard = Cc["@mozilla.org/widget/clipboardhelper;1"].
                   getService(Ci.nsIClipboardHelper);
   // Check if we should initialize a callback
   if (gPerformAllCallback === null) {
     let uris = [];
     gPerformAllCallback = function(aURI) aURI ? uris.push(aURI) :
       clipboard.copyString(uris.join("\n"), document);
   }
   // We have a callback to use, so use it to add a uri
   if (typeof gPerformAllCallback == "function")
     gPerformAllCallback(uri);
   else {
     // It's a plain copy source, so copy it
     clipboard.copyString(uri, document);
   }
 }
 /**
  * Remove the currently shown downloads from the download list.
  */
 function clearDownloadList() {
   // Clear the whole list if there's no search
   if (gSearchTerms == "") {
     gDownloadManager.cleanUp();
     return;
   }
   // Remove each download starting from the end until we hit a download
   // that is in progress
   let item;
   while ((item = gDownloadsView.lastChild) && !item.inProgress)
     removeDownload(item);
   // Clear the input as if the user did it and move focus to the list
   gSearchBox.value = "";
   gSearchBox.doCommand();
   gDownloadsView.focus();
 }
 // This is called by the progress listener.
 var gLastComputedMean = -1;
 var gLastActiveDownloads = 0;
 function onUpdateProgress()
 {
   let numActiveDownloads = gDownloadManager.activeDownloadCount;
   // Use the default title and reset "last" values if there's no downloads
   if (numActiveDownloads == 0) {
     document.title = document.documentElement.getAttribute("statictitle");
     gLastComputedMean = -1;
     gLastActiveDownloads = 0;
     return;
   }
   // Establish the mean transfer speed and amount downloaded.
   var mean = 0;
   var base = 0;
   var dls = gDownloadManager.activeDownloads;
   while (dls.hasMoreElements()) {
     let dl = dls.getNext();
     if (dl.percentComplete < 100 && dl.size > 0) {
       mean += dl.amountTransferred;
       base += dl.size;
     }
   }
   // Calculate the percent transferred, unless we don't have a total file size
   let title = gStr.downloadsTitlePercent;
   if (base == 0)
     title = gStr.downloadsTitleFiles;
   else
     mean = Math.floor((mean / base) * 100);
   // Update title of window
   if (mean != gLastComputedMean || gLastActiveDownloads != numActiveDownloads) {
     gLastComputedMean = mean;
     gLastActiveDownloads = numActiveDownloads;
     // Get the correct plural form and insert number of downloads and percent
     title = PluralForm.get(numActiveDownloads, title);
     title = replaceInsert(title, 1, numActiveDownloads);
     title = replaceInsert(title, 2, mean);
     document.title = title;
   }
 }
 ////////////////////////////////////////////////////////////////////////////////
 //// Startup, Shutdown
 function Startup()
 {
   gDownloadsView = document.getElementById("downloadView");
   gSearchBox = document.getElementById("searchbox");
   // convert strings to those in the string bundle
   let (sb = document.getElementById("downloadStrings")) {
     let getStr = function(string) sb.getString(string);
     for (let [name, value] in Iterator(gStr))
       gStr[name] = typeof value == "string" ? getStr(value) : value.map(getStr);
   }
   initStatement();
   buildDownloadList(true);
   // The DownloadProgressListener (DownloadProgressListener.js) handles progress
   // notifications.
   gDownloadListener = new DownloadProgressListener();
   gDownloadManager.addListener(gDownloadListener);
   // If the UI was displayed because the user interacted, we need to make sure
   // we update gUserInteracted accordingly.
   if (window.arguments[1] == Ci.nsIDownloadManagerUI.REASON_USER_INTERACTED)
     gUserInteracted = true;
   // downloads can finish before Startup() does, so check if the window should
   // close and act accordingly
   if (!autoRemoveAndClose())
     gDownloadsView.focus();
   let obs = Cc["@mozilla.org/observer-service;1"].
             getService(Ci.nsIObserverService);
   obs.addObserver(gDownloadObserver, "download-manager-remove-download", false);
   obs.addObserver(gDownloadObserver, "browser-lastwindow-close-granted", false);
   // Clear the search box and move focus to the list on escape from the box
   gSearchBox.addEventListener("keypress", function(e) {
     if (e.keyCode == e.DOM_VK_ESCAPE) {
       // Move focus to the list instead of closing the window
       gDownloadsView.focus();
       e.preventDefault();
     }
   }, false);
   let DownloadTaskbarProgress =
     Cu.import("resource://gre/modules/DownloadTaskbarProgress.jsm", {}).DownloadTaskbarProgress;
   DownloadTaskbarProgress.onDownloadWindowLoad(window);
 }
 function Shutdown()
 {
   gDownloadManager.removeListener(gDownloadListener);
   let obs = Cc["@mozilla.org/observer-service;1"].
             getService(Ci.nsIObserverService);
   obs.removeObserver(gDownloadObserver, "download-manager-remove-download");
   obs.removeObserver(gDownloadObserver, "browser-lastwindow-close-granted");
   clearTimeout(gBuilder);
   gStmt.reset();
   gStmt.finalize();
 }
 let gDownloadObserver = {
   observe: function gdo_observe(aSubject, aTopic, aData) {
     switch (aTopic) {
       case "download-manager-remove-download":
         // A null subject here indicates "remove multiple", so we just rebuild.
         if (!aSubject) {
           // Rebuild the default view
           buildDownloadList(true);
           break;
         }
         // Otherwise, remove a single download
         let id = aSubject.QueryInterface(Ci.nsISupportsPRUint32);
         let dl = getDownload(id.data);
         removeFromView(dl);
         break;
       case "browser-lastwindow-close-granted":
 #ifndef XP_MACOSX
         if (gDownloadManager.activeDownloadCount == 0) {
           setTimeout(gCloseDownloadManager, 0);
         }
 #endif
         break;
     }
   }
 };
 ////////////////////////////////////////////////////////////////////////////////
 //// View Context Menus
 var gContextMenus = [
   // DOWNLOAD_DOWNLOADING
   [
     "menuitem_pause"
     , "menuitem_cancel"
     , "menuseparator"
     , "menuitem_show"
     , "menuseparator"
     , "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
   ],
   // DOWNLOAD_FINISHED
   [
     "menuitem_open"
     , "menuitem_show"
     , "menuseparator"
     , "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
     , "menuseparator"
     , "menuitem_removeFromList"
   ],
   // DOWNLOAD_FAILED
   [
     "menuitem_retry"
     , "menuseparator"
     , "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
     , "menuseparator"
     , "menuitem_removeFromList"
   ],
   // DOWNLOAD_CANCELED
   [
     "menuitem_retry"
     , "menuseparator"
     , "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
     , "menuseparator"
     , "menuitem_removeFromList"
   ],
   // DOWNLOAD_PAUSED
   [
     "menuitem_resume"
     , "menuitem_cancel"
     , "menuseparator"
     , "menuitem_show"
     , "menuseparator"
     , "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
   ],
   // DOWNLOAD_QUEUED
   [
     "menuitem_cancel"
     , "menuseparator"
     , "menuitem_show"
     , "menuseparator"
     , "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
   ],
   // DOWNLOAD_BLOCKED_PARENTAL
   [
     "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
     , "menuseparator"
     , "menuitem_removeFromList"
   ],
   // DOWNLOAD_SCANNING
   [
     "menuitem_show"
     , "menuseparator"
     , "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
   ],
   // DOWNLOAD_DIRTY
   [
     "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
     , "menuseparator"
     , "menuitem_removeFromList"
   ],
   // DOWNLOAD_BLOCKED_POLICY
   [
     "menuitem_openReferrer"
     , "menuitem_copyLocation"
     , "menuseparator"
     , "menuitem_selectAll"
     , "menuseparator"
     , "menuitem_removeFromList"
   ]
 ];
 function buildContextMenu(aEvent)
 {
   if (aEvent.target.id != "downloadContextMenu")
     return false;
   var popup = document.getElementById("downloadContextMenu");
   while (popup.hasChildNodes())
     popup.removeChild(popup.firstChild);
   if (gDownloadsView.selectedItem) {
     let dl = gDownloadsView.selectedItem;
     let idx = parseInt(dl.getAttribute("state"));
     if (idx < 0)
       idx = 0;
     var menus = gContextMenus[idx];
     for (let i = 0; i < menus.length; ++i) {
       let menuitem = document.getElementById(menus[i]).cloneNode(true);
       let cmd = menuitem.getAttribute("cmd");
       if (cmd)
         menuitem.disabled = !gDownloadViewController.isCommandEnabled(cmd, dl);
       popup.appendChild(menuitem);
     }
     return true;
   }
   return false;
 }
 ////////////////////////////////////////////////////////////////////////////////
 //// Drag and Drop
 var gDownloadDNDObserver =
 {
   onDragStart: function (aEvent)
   {
     if (!gDownloadsView.selectedItem)
       return;
     var dl = gDownloadsView.selectedItem;
     var f = getLocalFileFromNativePathOrUrl(dl.getAttribute("file"));
     if (!f.exists())
       return;
     var dt = aEvent.dataTransfer;
     dt.mozSetDataAt("application/x-moz-file", f, 0);
     var url = Services.io.newFileURI(f).spec;
     dt.setData("text/uri-list", url);
     dt.setData("text/plain", url);
     dt.effectAllowed = "copyMove";
     dt.addElement(dl);
   },
   onDragOver: function (aEvent)
   {
     var types = aEvent.dataTransfer.types;
     if (types.contains("text/uri-list") ||
         types.contains("text/x-moz-url") ||
         types.contains("text/plain"))
       aEvent.preventDefault();
   },
   onDrop: function(aEvent)
   {
     var dt = aEvent.dataTransfer;
     // If dragged item is from our source, do not try to
     // redownload already downloaded file.
     if (dt.mozGetDataAt("application/x-moz-file", 0))
       return;
     var url = dt.getData("URL");
     var name;
     if (!url) {
       url = dt.getData("text/x-moz-url") || dt.getData("text/plain");
       [url, name] = url.split("\n");
     }
     if (url) {
       let sourceDoc = dt.mozSourceNode ? dt.mozSourceNode.ownerDocument : document;
       saveURL(url, name ? name : url, null, true, true, null, sourceDoc);
     }
   }
 }
 function pasteHandler() {
   let trans = Cc["@mozilla.org/widget/transferable;1"].
               createInstance(Ci.nsITransferable);
   trans.init(null);
   let flavors = ["text/x-moz-url", "text/unicode"];
   flavors.forEach(trans.addDataFlavor);
   Services.clipboard.getData(trans, Services.clipboard.kGlobalClipboard);
   // Getting the data or creating the nsIURI might fail
   try {
     let data = {};
     trans.getAnyTransferData({}, data, {});
     let [url, name] = data.value.QueryInterface(Ci.nsISupportsString).data.split("\n");
     if (!url)
       return;
     let uri = Services.io.newURI(url, null, null);
     saveURL(uri.spec, name || uri.spec, null, true, true, null, document);
   } catch (ex) {}
 }
 ////////////////////////////////////////////////////////////////////////////////
 //// Command Updating and Command Handlers
 var gDownloadViewController = {
   isCommandEnabled: function(aCommand, aItem)
   {
     let dl = aItem;
     let download = null; // used for getting an nsIDownload object
     switch (aCommand) {
       case "cmd_cancel":
         return dl.inProgress;
       case "cmd_open": {
         let file = getLocalFileFromNativePathOrUrl(dl.getAttribute("file"));
         return dl.openable && file.exists();
       }
       case "cmd_show": {
         let file = getLocalFileFromNativePathOrUrl(dl.getAttribute("file"));
         return file.exists();
       }
       case "cmd_pause":
         download = gDownloadManager.getDownload(dl.getAttribute("dlid"));
         return dl.inProgress && !dl.paused && download.resumable;
       case "cmd_pauseResume":
         download = gDownloadManager.getDownload(dl.getAttribute("dlid"));
         return (dl.inProgress || dl.paused) && download.resumable;
       case "cmd_resume":
         download = gDownloadManager.getDownload(dl.getAttribute("dlid"));
         return dl.paused && download.resumable;
       case "cmd_openReferrer":
         return dl.hasAttribute("referrer");
       case "cmd_removeFromList":
       case "cmd_retry":
         return dl.removable;
       case "cmd_copyLocation":
         return true;
     }
     return false;
   },
   doCommand: function(aCommand, aItem)
   {
     if (this.isCommandEnabled(aCommand, aItem))
       this.commands[aCommand](aItem);
   },
   commands: {
     cmd_cancel: function(aSelectedItem) {
       cancelDownload(aSelectedItem);
     },
     cmd_open: function(aSelectedItem) {
       openDownload(aSelectedItem);
     },
     cmd_openReferrer: function(aSelectedItem) {
       openReferrer(aSelectedItem);
     },
     cmd_pause: function(aSelectedItem) {
       pauseDownload(aSelectedItem);
     },
     cmd_pauseResume: function(aSelectedItem) {
       if (aSelectedItem.paused)
         this.cmd_resume(aSelectedItem);
       else
         this.cmd_pause(aSelectedItem);
     },
     cmd_removeFromList: function(aSelectedItem) {
       removeDownload(aSelectedItem);
     },
     cmd_resume: function(aSelectedItem) {
       resumeDownload(aSelectedItem);
     },
     cmd_retry: function(aSelectedItem) {
       retryDownload(aSelectedItem);
     },
     cmd_show: function(aSelectedItem) {
       showDownload(aSelectedItem);
     },
     cmd_copyLocation: function(aSelectedItem) {
       copySourceLocation(aSelectedItem);
     },
   }
 };
 /**
  * Helper function to do commands.
  *
  * @param aCmd
  *        The command to be performed.
  * @param aItem
  *        The richlistitem that represents the download that will have the
  *        command performed on it. If this is null, the command is performed on
  *        all downloads. If the item passed in is not a richlistitem that
  *        represents a download, it will walk up the parent nodes until it finds
  *        a DOM node that is.
  */
 function performCommand(aCmd, aItem)
 {
   let elm = aItem;
   if (!elm) {
     // If we don't have a desired download item, do the command for all
     // selected items. Initialize the callback to null so commands know to add
     // a callback if they want. We will call the callback with empty arguments
     // after performing the command on each selected download item.
     gPerformAllCallback = null;
     // Convert the nodelist into an array to keep a copy of the download items
     let items = [];
     for (let i = gDownloadsView.selectedItems.length; --i >= 0; )
       items.unshift(gDownloadsView.selectedItems[i]);
     // Do the command for each download item
     for each (let item in items)
       performCommand(aCmd, item);
     // Call the callback with no arguments and reset because we're done
     if (typeof gPerformAllCallback == "function")
       gPerformAllCallback();
     gPerformAllCallback = undefined;
     return;
   } else {
     while (elm.nodeName != "richlistitem" ||
            elm.getAttribute("type") != "download")
       elm = elm.parentNode;
   }
   gDownloadViewController.doCommand(aCmd, elm);
 }
 function setSearchboxFocus()
 {
   gSearchBox.focus();
   gSearchBox.select();
 }
 function openExternal(aFile)
 {
   var uri = Cc["@mozilla.org/network/io-service;1"].
             getService(Ci.nsIIOService).newFileURI(aFile);
   var protocolSvc = Cc["@mozilla.org/uriloader/external-protocol-service;1"].
                     getService(Ci.nsIExternalProtocolService);
   protocolSvc.loadUrl(uri);
   return;
 }
 ////////////////////////////////////////////////////////////////////////////////
 //// Utility Functions
 /**
  * Create a download richlistitem with the provided attributes. Some attributes
  * are *required* while optional ones will only be set on the item if provided.
  *
  * @param aAttrs
  *        An object that must have the following properties: dlid, file,
  *        target, uri, state, progress, startTime, endTime, currBytes,
  *        maxBytes; optional properties: referrer
  * @return An initialized download richlistitem
  */
 function createDownloadItem(aAttrs)
 {
   let dl = document.createElement("richlistitem");
   // Copy the attributes from the argument into the item
   for (let attr in aAttrs)
     dl.setAttribute(attr, aAttrs[attr]);
   // Initialize other attributes
   dl.setAttribute("type", "download");
   dl.setAttribute("id", "dl" + aAttrs.dlid);
   dl.setAttribute("image", "moz-icon://" + aAttrs.file + "?size=32");
   dl.setAttribute("lastSeconds", Infinity);
   // Initialize more complex attributes
   updateTime(dl);
   updateStatus(dl);
   try {
     let file = getLocalFileFromNativePathOrUrl(aAttrs.file);
     dl.setAttribute("path", file.nativePath || file.path);
     return dl;
   } catch (e) {
     // aFile might not be a file: url or a valid native path
     // see bug #392386 for details
   }
   return null;
 }
 /**
  * Updates the disabled state of the buttons of a downlaod.
  *
  * @param aItem
  *        The richlistitem representing the download.
  */
 function updateButtons(aItem)
 {
   let buttons = aItem.buttons;
   for (let i = 0; i < buttons.length; ++i) {
     let cmd = buttons[i].getAttribute("cmd");
     let enabled = gDownloadViewController.isCommandEnabled(cmd, aItem);
     buttons[i].disabled = !enabled;
     if ("cmd_pause" == cmd && !enabled) {
       // We need to add the tooltip indicating that the download cannot be
       // paused now.
       buttons[i].setAttribute("tooltiptext", gStr.cannotPause);
     }
   }
 }
 /**
  * Updates the status for a download item depending on its state
  *
  * @param aItem
  *        The richlistitem that has various download attributes.
  * @param aDownload
  *        The nsDownload from the backend. This is an optional parameter, but
  *        is useful for certain states such as DOWNLOADING.
  */
 function updateStatus(aItem, aDownload) {
   let status = "";
   let statusTip = "";
   let state = Number(aItem.getAttribute("state"));
   switch (state) {
     case nsIDM.DOWNLOAD_PAUSED:
     {
       let currBytes = Number(aItem.getAttribute("currBytes"));
       let maxBytes = Number(aItem.getAttribute("maxBytes"));
       let transfer = DownloadUtils.getTransferTotal(currBytes, maxBytes);
       status = replaceInsert(gStr.paused, 1, transfer);
       break;
     }
     case nsIDM.DOWNLOAD_DOWNLOADING:
     {
       let currBytes = Number(aItem.getAttribute("currBytes"));
       let maxBytes = Number(aItem.getAttribute("maxBytes"));
       // If we don't have an active download, assume 0 bytes/sec
       let speed = aDownload ? aDownload.speed : 0;
       let lastSec = Number(aItem.getAttribute("lastSeconds"));
       let newLast;
       [status, newLast] =
         DownloadUtils.getDownloadStatus(currBytes, maxBytes, speed, lastSec);
       // Update lastSeconds to be the new value
       aItem.setAttribute("lastSeconds", newLast);
       break;
     }
     case nsIDM.DOWNLOAD_FINISHED:
     case nsIDM.DOWNLOAD_FAILED:
     case nsIDM.DOWNLOAD_CANCELED:
     case nsIDM.DOWNLOAD_BLOCKED_PARENTAL:
     case nsIDM.DOWNLOAD_BLOCKED_POLICY:
     case nsIDM.DOWNLOAD_DIRTY:
     {
       let (stateSize = {}) {
         stateSize[nsIDM.DOWNLOAD_FINISHED] = function() {
           // Display the file size, but show "Unknown" for negative sizes
           let fileSize = Number(aItem.getAttribute("maxBytes"));
           let sizeText = gStr.doneSizeUnknown;
           if (fileSize >= 0) {
             let [size, unit] = DownloadUtils.convertByteUnits(fileSize);
             sizeText = replaceInsert(gStr.doneSize, 1, size);
             sizeText = replaceInsert(sizeText, 2, unit);
           }
           return sizeText;
         };
         stateSize[nsIDM.DOWNLOAD_FAILED] = function() gStr.stateFailed;
         stateSize[nsIDM.DOWNLOAD_CANCELED] = function() gStr.stateCanceled;
         stateSize[nsIDM.DOWNLOAD_BLOCKED_PARENTAL] = function() gStr.stateBlockedParentalControls;
         stateSize[nsIDM.DOWNLOAD_BLOCKED_POLICY] = function() gStr.stateBlockedPolicy;
         stateSize[nsIDM.DOWNLOAD_DIRTY] = function() gStr.stateDirty;
         // Insert 1 is the download size or download state
         status = replaceInsert(gStr.doneStatus, 1, stateSize[state]());
       }
       let [displayHost, fullHost] =
         DownloadUtils.getURIHost(getReferrerOrSource(aItem));
       // Insert 2 is the eTLD + 1 or other variations of the host
       status = replaceInsert(status, 2, displayHost);
       // Set the tooltip to be the full host
       statusTip = fullHost;
       break;
     }
   }
   aItem.setAttribute("status", status);
   aItem.setAttribute("statusTip", statusTip != "" ? statusTip : status);
 }
 /**
  * Updates the time that gets shown for completed download items
  *
  * @param aItem
  *        The richlistitem representing a download in the UI
  */
 function updateTime(aItem)
 {
   // Don't bother updating for things that aren't finished
   if (aItem.inProgress)
     return;
   let end = new Date(parseInt(aItem.getAttribute("endTime")));
   let [dateCompact, dateComplete] = DownloadUtils.getReadableDates(end);
   aItem.setAttribute("dateTime", dateCompact);
   aItem.setAttribute("dateTimeTip", dateComplete);
 }
 /**
  * Helper function to replace a placeholder string with a real string
  *
  * @param aText
  *        Source text containing placeholder (e.g., #1)
  * @param aIndex
  *        Index number of placeholder to replace
  * @param aValue
  *        New string to put in place of placeholder
  * @return The string with placeholder replaced with the new string
  */
 function replaceInsert(aText, aIndex, aValue)
 {
   return aText.replace("#" + aIndex, aValue);
 }
 /**
  * Perform the default action for the currently selected download item
  */
 function doDefaultForSelected()
 {
   // Make sure we have something selected
   let item = gDownloadsView.selectedItem;
   if (!item)
     return;
   // Get the default action (first item in the menu)
   let state = Number(item.getAttribute("state"));
   let menuitem = document.getElementById(gContextMenus[state][0]);
   // Try to do the action if the command is enabled
   gDownloadViewController.doCommand(menuitem.getAttribute("cmd"), item);
 }
 function removeFromView(aDownload)
 {
   // Make sure we have an item to remove
   if (!aDownload) return;
   let index = gDownloadsView.selectedIndex;
   gDownloadsView.removeChild(aDownload);
   gDownloadsView.selectedIndex = Math.min(index, gDownloadsView.itemCount - 1);
   // We might have removed the last item, so update the clear list button
   updateClearListButton();
 }
 function getReferrerOrSource(aDownload)
 {
   // Give the referrer if we have it set
   if (aDownload.hasAttribute("referrer"))
     return aDownload.getAttribute("referrer");
   // Otherwise, provide the source
   return aDownload.getAttribute("uri");
 }
 /**
  * Initiate building the download list to have the active downloads followed by
  * completed ones filtered by the search term if necessary.
  *
  * @param aForceBuild
  *        Force the list to be built even if the search terms don't change
  */
 function buildDownloadList(aForceBuild)
 {
   // Stringify the previous search
   let prevSearch = gSearchTerms.join(" ");
   // Array of space-separated lower-case search terms
   gSearchTerms = gSearchBox.value.replace(/^\s+|\s+$/g, "").
                  toLowerCase().split(/\s+/);
   // Unless forced, don't rebuild the download list if the search didn't change
   if (!aForceBuild && gSearchTerms.join(" ") == prevSearch)
     return;
   // Clear out values before using them
   clearTimeout(gBuilder);
   gStmt.reset();
   // Clear the list before adding items by replacing with a shallow copy
   let (empty = gDownloadsView.cloneNode(false)) {
     gDownloadsView.parentNode.replaceChild(empty, gDownloadsView);
     gDownloadsView = empty;
   }
   try {
     gStmt.bindByIndex(0, nsIDM.DOWNLOAD_NOTSTARTED);
     gStmt.bindByIndex(1, nsIDM.DOWNLOAD_DOWNLOADING);
     gStmt.bindByIndex(2, nsIDM.DOWNLOAD_PAUSED);
     gStmt.bindByIndex(3, nsIDM.DOWNLOAD_QUEUED);
     gStmt.bindByIndex(4, nsIDM.DOWNLOAD_SCANNING);
   } catch (e) {
     // Something must have gone wrong when binding, so clear and quit
     gStmt.reset();
     return;
   }
   // Take a quick break before we actually start building the list
   gBuilder = setTimeout(function() {
     // Start building the list
     stepListBuilder(1);
     // We just tried to add a single item, so we probably need to enable
     updateClearListButton();
   }, 0);
 }
 /**
  * Incrementally build the download list by adding at most the requested number
  * of items if there are items to add. After doing that, it will schedule
  * another chunk of items specified by gListBuildDelay and gListBuildChunk.
  *
  * @param aNumItems
  *        Number of items to add to the list before taking a break
  */
 function stepListBuilder(aNumItems) {
   try {
     // If we're done adding all items, we can quit
     if (!gStmt.executeStep()) {
       // Send a notification that we finished, but wait for clear list to update
       updateClearListButton();
       setTimeout(function() Cc["@mozilla.org/observer-service;1"].
         getService(Ci.nsIObserverService).
         notifyObservers(window, "download-manager-ui-done", null), 0);
       return;
     }
     // Try to get the attribute values from the statement
     let attrs = {
       dlid: gStmt.getInt64(0),
       file: gStmt.getString(1),
       target: gStmt.getString(2),
       uri: gStmt.getString(3),
       state: gStmt.getInt32(4),
       startTime: Math.round(gStmt.getInt64(5) / 1000),
       endTime: Math.round(gStmt.getInt64(6) / 1000),
       currBytes: gStmt.getInt64(8),
       maxBytes: gStmt.getInt64(9)
     };
     // Only add the referrer if it's not null
     let (referrer = gStmt.getString(7)) {
       if (referrer)
         attrs.referrer = referrer;
     }
     // If the download is active, grab the real progress, otherwise default 100
     let isActive = gStmt.getInt32(10);
     attrs.progress = isActive ? gDownloadManager.getDownload(attrs.dlid).
       percentComplete : 100;
     // Make the item and add it to the end if it's active or matches the search
     let item = createDownloadItem(attrs);
     if (item && (isActive || downloadMatchesSearch(item))) {
       // Add item to the end
       gDownloadsView.appendChild(item);
       // Because of the joys of XBL, we can't update the buttons until the
       // download object is in the document.
       updateButtons(item);
     } else {
       // We didn't add an item, so bump up the number of items to process, but
       // not a whole number so that we eventually do pause for a chunk break
       aNumItems += .9;
     }
   } catch (e) {
     // Something went wrong when stepping or getting values, so clear and quit
     gStmt.reset();
     return;
   }
   // Add another item to the list if we should; otherwise, let the UI update
   // and continue later
   if (aNumItems > 1) {
     stepListBuilder(aNumItems - 1);
   } else {
     // Use a shorter delay for earlier downloads to display them faster
     let delay = Math.min(gDownloadsView.itemCount * 10, gListBuildDelay);
     gBuilder = setTimeout(stepListBuilder, delay, gListBuildChunk);
   }
 }
 /**
  * Add a download to the front of the download list
  *
  * @param aDownload
  *        The nsIDownload to make into a richlistitem
  */
 function prependList(aDownload)
 {
   let attrs = {
     dlid: aDownload.id,
     file: aDownload.target.spec,
     target: aDownload.displayName,
     uri: aDownload.source.spec,
     state: aDownload.state,
     progress: aDownload.percentComplete,
     startTime: Math.round(aDownload.startTime / 1000),
     endTime: Date.now(),
     currBytes: aDownload.amountTransferred,
     maxBytes: aDownload.size
   };
   // Make the item and add it to the beginning
   let item = createDownloadItem(attrs);
   if (item) {
     // Add item to the beginning
     gDownloadsView.insertBefore(item, gDownloadsView.firstChild);
     // Because of the joys of XBL, we can't update the buttons until the
     // download object is in the document.
     updateButtons(item);
     // We might have added an item to an empty list, so update button
     updateClearListButton();
   }
 }
 /**
  * Check if the download matches the current search term based on the texts
  * shown to the user. All search terms are checked to see if each matches any
  * of the displayed texts.
  *
  * @param aItem
  *        Download richlistitem to check if it matches the current search
  * @return Boolean true if it matches the search; false otherwise
  */
 function downloadMatchesSearch(aItem)
 {
   // Search through the download attributes that are shown to the user and
   // make it into one big string for easy combined searching
   let combinedSearch = "";
   for each (let attr in gSearchAttributes)
     combinedSearch += aItem.getAttribute(attr).toLowerCase() + " ";
   // Make sure each of the terms are found
   for each (let term in gSearchTerms)
     if (combinedSearch.indexOf(term) == -1)
       return false;
   return true;
 }
 // we should be using real URLs all the time, but until
 // bug 239948 is fully fixed, this will do...
 //
 // note, this will thrown an exception if the native path
 // is not valid (for example a native Windows path on a Mac)
 // see bug #392386 for details
 function getLocalFileFromNativePathOrUrl(aPathOrUrl)
 {
   if (aPathOrUrl.substring(0,7) == "file://") {
     // if this is a URL, get the file from that
     let ioSvc = Cc["@mozilla.org/network/io-service;1"].
                 getService(Ci.nsIIOService);
     // XXX it's possible that using a null char-set here is bad
     const fileUrl = ioSvc.newURI(aPathOrUrl, null, null).
                     QueryInterface(Ci.nsIFileURL);
     return fileUrl.file.clone().QueryInterface(Ci.nsILocalFile);
   } else {
     // if it's a pathname, create the nsILocalFile directly
     var f = new nsLocalFile(aPathOrUrl);
     return f;
   }
 }
 /**
  * Update the disabled state of the clear list button based on whether or not
  * there are items in the list that can potentially be removed.
  */
 function updateClearListButton()
 {
   let button = document.getElementById("clearListButton");
   // The button is enabled if we have items in the list and we can clean up
   button.disabled = !(gDownloadsView.itemCount && gDownloadManager.canCleanUp);
 }
 function getDownload(aID)
 {
   return document.getElementById("dl" + aID);
 }
 /**
  * Initialize the statement which is used to retrieve the list of downloads.
  */
 function initStatement()
 {
   if (gStmt)
     gStmt.finalize();
   gStmt = gDownloadManager.DBConnection.createStatement(
     "SELECT id, target, 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");
 }