/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80 filetype=javascript: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/**
* Provides functions to integrate with the host application, handling for
* example the global prompts on shutdown.
*/
"use strict";
this.EXPORTED_SYMBOLS = [
"DownloadIntegration",
];
////////////////////////////////////////////////////////////////////////////////
//// Globals
const Cc = Components.classes;
const Ci = Components.interfaces;
const Cu = Components.utils;
const Cr = Components.results;
Cu.import("resource://gre/modules/Integration.jsm");
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "AsyncShutdown",
"resource://gre/modules/AsyncShutdown.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "AppConstants",
"resource://gre/modules/AppConstants.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "DeferredTask",
"resource://gre/modules/DeferredTask.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "Downloads",
"resource://gre/modules/Downloads.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "DownloadStore",
"resource://gre/modules/DownloadStore.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "DownloadImport",
"resource://gre/modules/DownloadImport.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "DownloadUIHelper",
"resource://gre/modules/DownloadUIHelper.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
"resource://gre/modules/FileUtils.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
"resource://gre/modules/NetUtil.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "OS",
"resource://gre/modules/osfile.jsm");
#ifdef MOZ_PLACES
XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils",
"resource://gre/modules/PlacesUtils.jsm");
#endif
XPCOMUtils.defineLazyModuleGetter(this, "Promise",
"resource://gre/modules/Promise.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "Services",
"resource://gre/modules/Services.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "Task",
"resource://gre/modules/Task.jsm");
XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
"resource://gre/modules/NetUtil.jsm");
XPCOMUtils.defineLazyServiceGetter(this, "gDownloadPlatform",
"@mozilla.org/toolkit/download-platform;1",
"mozIDownloadPlatform");
XPCOMUtils.defineLazyServiceGetter(this, "gEnvironment",
"@mozilla.org/process/environment;1",
"nsIEnvironment");
XPCOMUtils.defineLazyServiceGetter(this, "gMIMEService",
"@mozilla.org/mime;1",
"nsIMIMEService");
XPCOMUtils.defineLazyServiceGetter(this, "gExternalProtocolService",
"@mozilla.org/uriloader/external-protocol-service;1",
"nsIExternalProtocolService");
#ifdef MOZ_WIDGET_ANDROID
XPCOMUtils.defineLazyModuleGetter(this, "RuntimePermissions",
"resource://gre/modules/RuntimePermissions.jsm");
#endif
XPCOMUtils.defineLazyGetter(this, "gParentalControlsService", function() {
if ("@mozilla.org/parental-controls-service;1" in Cc) {
return Cc["@mozilla.org/parental-controls-service;1"]
.createInstance(Ci.nsIParentalControlsService);
}
return null;
});
XPCOMUtils.defineLazyServiceGetter(this, "gApplicationReputationService",
"@mozilla.org/downloads/application-reputation-service;1",
Ci.nsIApplicationReputationService);
XPCOMUtils.defineLazyServiceGetter(this, "volumeService",
"@mozilla.org/telephony/volume-service;1",
"nsIVolumeService");
// We have to use the gCombinedDownloadIntegration identifier because, in this
// module only, the DownloadIntegration identifier refers to the base version.
Integration.downloads.defineModuleGetter(this, "gCombinedDownloadIntegration",
"resource://gre/modules/DownloadIntegration.jsm",
"DownloadIntegration");
const Timer = Components.Constructor("@mozilla.org/timer;1", "nsITimer",
"initWithCallback");
/**
* Indicates the delay between a change to the downloads data and the related
* save operation.
*
* For best efficiency, this value should be high enough that the input/output
* for opening or closing the target file does not overlap with the one for
* saving the list of downloads.
*/
const kSaveDelayMs = 1500;
/**
* This pref indicates if we have already imported (or attempted to import)
* the downloads database from the previous SQLite storage.
*/
const kPrefImportedFromSqlite = "browser.download.importedFromSqlite";
/**
* List of observers to listen against
*/
const kObserverTopics = [
"quit-application-requested",
"offline-requested",
"last-pb-context-exiting",
"last-pb-context-exited",
"sleep_notification",
"suspend_process_notification",
"wake_notification",
"resume_process_notification",
"network:offline-about-to-go-offline",
"network:offline-status-changed",
"xpcom-will-shutdown",
];
/**
* Maps nsIApplicationReputationService verdicts with the DownloadError ones.
*/
const kVerdictMap = {
[Ci.nsIApplicationReputationService.VERDICT_DANGEROUS]:
Downloads.Error.BLOCK_VERDICT_MALWARE,
[Ci.nsIApplicationReputationService.VERDICT_UNCOMMON]:
Downloads.Error.BLOCK_VERDICT_UNCOMMON,
[Ci.nsIApplicationReputationService.VERDICT_POTENTIALLY_UNWANTED]:
Downloads.Error.BLOCK_VERDICT_POTENTIALLY_UNWANTED,
[Ci.nsIApplicationReputationService.VERDICT_DANGEROUS_HOST]:
Downloads.Error.BLOCK_VERDICT_MALWARE,
};
////////////////////////////////////////////////////////////////////////////////
//// DownloadIntegration
/**
* Provides functions to integrate with the host application, handling for
* example the global prompts on shutdown.
*/
this.DownloadIntegration = {
/**
* Main DownloadStore object for loading and saving the list of persistent
* downloads, or null if the download list was never requested and thus it
* doesn't need to be persisted.
*/
_store: null,
/**
* Returns whether data for blocked downloads should be kept on disk.
* Implementations which support unblocking downloads may return true to
* keep the blocked download on disk until its fate is decided.
*
* If a download is blocked and the partial data is kept the Download's
* 'hasBlockedData' property will be true. In this state Download.unblock()
* or Download.confirmBlock() may be used to either unblock the download or
* remove the downloaded data respectively.
*
* Even if shouldKeepBlockedData returns true, if the download did not use a
* partFile the blocked data will be removed - preventing the complete
* download from existing on disk with its final filename.
*
* @return boolean True if data should be kept.
*/
shouldKeepBlockedData() {
const FIREFOX_ID = "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}";
return Services.appinfo.ID == FIREFOX_ID;
},
/**
* Performs initialization of the list of persistent downloads, before its
* first use by the host application. This function may be called only once
* during the entire lifetime of the application.
*
* @param list
* DownloadList object to be initialized.
*
* @return {Promise}
* @resolves When the list has been initialized.
* @rejects JavaScript exception.
*/
initializePublicDownloadList: Task.async(function* (list) {
try {
yield this.loadPublicDownloadListFromStore(list);
} catch (ex) {
Cu.reportError(ex);
}
// After the list of persistent downloads has been loaded, we can add the
// history observers, even if the load operation failed. This object is kept
// alive by the history service.
new DownloadHistoryObserver(list);
}),
/**
* Called by initializePublicDownloadList to load the list of persistent
* downloads, before its first use by the host application. This function may
* be called only once during the entire lifetime of the application.
*
* @param list
* DownloadList object to be populated with the download objects
* serialized from the previous session. This list will be persisted
* to disk during the session lifetime.
*
* @return {Promise}
* @resolves When the list has been populated.
* @rejects JavaScript exception.
*/
loadPublicDownloadListFromStore: Task.async(function* (list) {
if (this._store) {
throw new Error("Initialization may be performed only once.");
}
this._store = new DownloadStore(list, OS.Path.join(
OS.Constants.Path.profileDir,
"downloads.json"));
this._store.onsaveitem = this.shouldPersistDownload.bind(this);
try {
if (this._importedFromSqlite) {
yield this._store.load();
} else {
let sqliteDBpath = OS.Path.join(OS.Constants.Path.profileDir,
"downloads.sqlite");
if (yield OS.File.exists(sqliteDBpath)) {
let sqliteImport = new DownloadImport(list, sqliteDBpath);
yield sqliteImport.import();
let importCount = (yield list.getAll()).length;
if (importCount > 0) {
try {
yield this._store.save();
} catch (ex) { }
}
// No need to wait for the file removal.
OS.File.remove(sqliteDBpath).then(null, Cu.reportError);
}
Services.prefs.setBoolPref(kPrefImportedFromSqlite, true);
// Don't even report error here because this file is pre Firefox 3
// and most likely doesn't exist.
OS.File.remove(OS.Path.join(OS.Constants.Path.profileDir,
"downloads.rdf")).catch(() => {});
}
} catch (ex) {
Cu.reportError(ex);
}
// Add the view used for detecting changes to downloads to be persisted.
// We must do this after the list of persistent downloads has been loaded,
// even if the load operation failed. We wait for a complete initialization
// so other callers cannot modify the list without being detected. The
// DownloadAutoSaveView is kept alive by the underlying DownloadList.
yield new DownloadAutoSaveView(list, this._store).initialize();
}),
/**
* Determines if a Download object from the list of persistent downloads
* should be saved into a file, so that it can be restored across sessions.
*
* This function allows filtering out downloads that the host application is
* not interested in persisting across sessions, for example downloads that
* finished successfully.
*
* @param aDownload
* The Download object to be inspected. This is originally taken from
* the global DownloadList object for downloads that were not started
* from a private browsing window. The item may have been removed
* from the list since the save operation started, though in this case
* the save operation will be repeated later.
*
* @return True to save the download, false otherwise.
*/
shouldPersistDownload(aDownload) {
// On all platforms, we save all the downloads currently in progress, as
// well as stopped downloads for which we retained partially downloaded
// data or we have blocked data.
if (!aDownload.stopped || aDownload.hasPartialData ||
aDownload.hasBlockedData) {
return true;
}
#if defined(MOZ_WIDGET_ANDROID)
// On Android we store all history.
return true;
#else
// On Desktop, stopped downloads for which we don't need to track the
// presence of a ".part" file are only retained in the browser history.
return false;
#endif
},
/**
* Returns the system downloads directory asynchronously.
*
* @return {Promise}
* @resolves The downloads directory string path.
*/
getSystemDownloadsDirectory: Task.async(function* () {
if (this._downloadsDirectory) {
return this._downloadsDirectory;
}
let directoryPath = null;
#ifdef XP_MACOSX
directoryPath = this._getDirectory("DfltDwnld");
#elifdef XP_WIN
// For XP/2K, use My Documents/Downloads. Other version uses
// the default Downloads directory.
let version = parseFloat(Services.sysinfo.getProperty("version"));
if (version < 6) {
directoryPath = yield this._createDownloadsDirectory("Pers");
} else {
directoryPath = this._getDirectory("DfltDwnld");
}
#elifdef XP_UNIX
#ifdef MOZ_WIDGET_ANDROID
// Android doesn't have a $HOME directory, and by default we only have
// write access to /data/data/org.mozilla.{$APP} and /sdcard
directoryPath = gEnvironment.get("DOWNLOADS_DIRECTORY");
if (!directoryPath) {
throw new Components.Exception("DOWNLOADS_DIRECTORY is not set.",
Cr.NS_ERROR_FILE_UNRECOGNIZED_PATH);
}
#else
// For Linux, use XDG download dir, with a fallback to Home/Downloads
// if the XDG user dirs are disabled.
try {
directoryPath = this._getDirectory("DfltDwnld");
} catch(e) {
directoryPath = yield this._createDownloadsDirectory("Home");
}
#endif
#else
directoryPath = yield this._createDownloadsDirectory("Home");
#endif
this._downloadsDirectory = directoryPath;
return this._downloadsDirectory;
}),
_downloadsDirectory: null,
/**
* Returns the user downloads directory asynchronously.
*
* @return {Promise}
* @resolves The downloads directory string path.
*/
getPreferredDownloadsDirectory: Task.async(function* () {
let directoryPath = null;
let prefValue = 1;
try {
prefValue = Services.prefs.getIntPref("browser.download.folderList");
} catch(e) {}
switch(prefValue) {
case 0: // Desktop
directoryPath = this._getDirectory("Desk");
break;
case 1: // Downloads
directoryPath = yield this.getSystemDownloadsDirectory();
break;
case 2: // Custom
try {
let directory = Services.prefs.getComplexValue("browser.download.dir",
Ci.nsIFile);
directoryPath = directory.path;
yield OS.File.makeDir(directoryPath, { ignoreExisting: true });
} catch(ex) {
// Either the preference isn't set or the directory cannot be created.
directoryPath = yield this.getSystemDownloadsDirectory();
}
break;
default:
directoryPath = yield this.getSystemDownloadsDirectory();
}
return directoryPath;
}),
/**
* Returns the temporary downloads directory asynchronously.
*
* @return {Promise}
* @resolves The downloads directory string path.
*/
getTemporaryDownloadsDirectory: Task.async(function* () {
let directoryPath = null;
#ifdef XP_MACOSX
directoryPath = yield this.getPreferredDownloadsDirectory();
#elifdef MOZ_WIDGET_ANDROID
directoryPath = yield this.getSystemDownloadsDirectory();
#else
directoryPath = this._getDirectory("TmpD");
#endif
return directoryPath;
}),
/**
* Checks to determine whether to block downloads for parental controls.
*
* aParam aDownload
* The download object.
*
* @return {Promise}
* @resolves The boolean indicates to block downloads or not.
*/
shouldBlockForParentalControls(aDownload) {
let isEnabled = gParentalControlsService &&
gParentalControlsService.parentalControlsEnabled;
let shouldBlock = isEnabled &&
gParentalControlsService.blockFileDownloadsEnabled;
// Log the event if required by parental controls settings.
if (isEnabled && gParentalControlsService.loggingEnabled) {
gParentalControlsService.log(gParentalControlsService.ePCLog_FileDownload,
shouldBlock,
NetUtil.newURI(aDownload.source.url), null);
}
return Promise.resolve(shouldBlock);
},
/**
* Checks to determine whether to block downloads for not granted runtime permissions.
*
* @return {Promise}
* @resolves The boolean indicates to block downloads or not.
*/
shouldBlockForRuntimePermissions() {
#ifdef MOZ_WIDGET_ANDROID
return RuntimePermissions.waitForPermissions(RuntimePermissions.WRITE_EXTERNAL_STORAGE)
.then(permissionGranted => !permissionGranted);
#else
return Promise.resolve(false);
#endif
},
/**
* Checks to determine whether to block downloads because they might be
* malware, based on application reputation checks.
*
* aParam aDownload
* The download object.
*
* @return {Promise}
* @resolves Object with the following properties:
* {
* shouldBlock: Whether the download should be blocked.
* verdict: Detailed reason for the block, according to the
* "Downloads.Error.BLOCK_VERDICT_" constants, or empty
* string if the reason is unknown.
* }
*/
shouldBlockForReputationCheck(aDownload) {
let hash;
let sigInfo;
let channelRedirects;
try {
hash = aDownload.saver.getSha256Hash();
sigInfo = aDownload.saver.getSignatureInfo();
channelRedirects = aDownload.saver.getRedirects();
} catch (ex) {
// Bail if DownloadSaver doesn't have a hash or signature info.
return Promise.resolve({
shouldBlock: false,
verdict: "",
});
}
if (!hash || !sigInfo) {
return Promise.resolve({
shouldBlock: false,
verdict: "",
});
}
let deferred = Promise.defer();
let aReferrer = null;
if (aDownload.source.referrer) {
aReferrer = NetUtil.newURI(aDownload.source.referrer);
}
gApplicationReputationService.queryReputation({
sourceURI: NetUtil.newURI(aDownload.source.url),
referrerURI: aReferrer,
fileSize: aDownload.currentBytes,
sha256Hash: hash,
suggestedFileName: OS.Path.basename(aDownload.target.path),
signatureInfo: sigInfo,
redirects: channelRedirects },
function onComplete(aShouldBlock, aRv, aVerdict) {
deferred.resolve({
shouldBlock: aShouldBlock,
verdict: (aShouldBlock && kVerdictMap[aVerdict]) || "",
});
});
return deferred.promise;
},
#ifdef XP_WIN
/**
* Checks whether downloaded files should be marked as coming from
* Internet Zone.
*
* @return true if files should be marked
*/
_shouldSaveZoneInformation() {
let zonePref = 2;
try {
zonePref = Services.prefs.getIntPref("browser.download.saveZoneInformation");
} catch (ex) {}
switch (zonePref) {
case 0: // Never
return false;
case 1: // Always
return true;
case 2: // System-defined
let key = Cc["@mozilla.org/windows-registry-key;1"]
.createInstance(Ci.nsIWindowsRegKey);
try {
key.open(Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Attachments",
Ci.nsIWindowsRegKey.ACCESS_QUERY_VALUE);
try {
return key.readIntValue("SaveZoneInformation") != 1;
} finally {
key.close();
}
} catch (ex) {
// If the key is not present, files should be marked by default.
return true;
}
default: // Invalid pref value defaults marking files.
return true;
}
},
#endif
/**
* Performs platform-specific operations when a download is done.
*
* aParam aDownload
* The Download object.
*
* @return {Promise}
* @resolves When all the operations completed successfully.
* @rejects JavaScript exception if any of the operations failed.
*/
downloadDone: Task.async(function* (aDownload) {
#ifdef XP_WIN
// On Windows, we mark any file saved to the NTFS file system as coming
// from the Internet security zone unless Group Policy disables the
// feature. We do this by writing to the "Zone.Identifier" Alternate
// Data Stream directly, because the Save method of the
// IAttachmentExecute interface would trigger operations that may cause
// the application to hang, or other performance issues.
// The stream created in this way is forward-compatible with all the
// current and future versions of Windows.
if (this._shouldSaveZoneInformation()) {
let zone;
try {
zone = gDownloadPlatform.mapUrlToZone(aDownload.source.url);
} catch (e) {
// Default to Internet Zone if mapUrlToZone failed for
// whatever reason.
zone = Ci.mozIDownloadPlatform.ZONE_INTERNET;
}
try {
// Don't write zone IDs for Local, Intranet, or Trusted sites
// to match Windows behavior.
if (zone >= Ci.mozIDownloadPlatform.ZONE_INTERNET) {
let streamPath = aDownload.target.path + ":Zone.Identifier";
let stream = yield OS.File.open(
streamPath,
{ create: true },
{ winAllowLengthBeyondMaxPathWithCaveats: true }
);
try {
yield stream.write(new TextEncoder().encode("[ZoneTransfer]\r\nZoneId=" + zone + "\r\n"));
} finally {
yield stream.close();
}
}
} catch (ex) {
// If writing to the stream fails, we ignore the error and continue.
// The Windows API error 123 (ERROR_INVALID_NAME) is expected to
// occur when working on a file system that does not support
// Alternate Data Streams, like FAT32, thus we don't report this
// specific error.
if (!(ex instanceof OS.File.Error) || ex.winLastError != 123) {
Cu.reportError(ex);
}
}
}
#endif
// The file with the partially downloaded data has restrictive permissions
// that don't allow other users on the system to access it. Now that the
// download is completed, we need to adjust permissions based on whether
// this is a permanently downloaded file or a temporary download to be
// opened read-only with an external application.
try {
// The following logic to determine whether this is a temporary download
// is due to the fact that "deleteTempFileOnExit" is false on Mac, where
// downloads to be opened with external applications are preserved in
// the "Downloads" folder like normal downloads.
let isTemporaryDownload =
aDownload.launchWhenSucceeded && (aDownload.source.isPrivate ||
Services.prefs.getBoolPref("browser.helperApps.deleteTempFileOnExit"));
// Permanently downloaded files are made accessible by other users on
// this system, while temporary downloads are marked as read-only.
let options = {};
if (isTemporaryDownload) {
options.unixMode = 0o400;
options.winAttributes = {readOnly: true};
} else {
options.unixMode = 0o666;
}
// On Unix, the umask of the process is respected.
yield OS.File.setPermissions(aDownload.target.path, options);
} catch (ex) {
// We should report errors with making the permissions less restrictive
// or marking the file as read-only on Unix and Mac, but this should not
// prevent the download from completing.
// The setPermissions API error EPERM is expected to occur when working
// on a file system that does not support file permissions, like FAT32,
// thus we don't report this error.
if (!(ex instanceof OS.File.Error) || ex.unixErrno != OS.Constants.libc.EPERM) {
Cu.reportError(ex);
}
}
let aReferrer = null;
if (aDownload.source.referrer) {
aReferrer = NetUtil.newURI(aDownload.source.referrer);
}
gDownloadPlatform.downloadDone(NetUtil.newURI(aDownload.source.url),
aReferrer,
new FileUtils.File(aDownload.target.path),
aDownload.contentType,
aDownload.source.isPrivate);
}),
/**
* Launches a file represented by the target of a download. This can
* open the file with the default application for the target MIME type
* or file extension, or with a custom application if
* aDownload.launcherPath is set.
*
* @param aDownload
* A Download object that contains the necessary information
* to launch the file. The relevant properties are: the target
* file, the contentType and the custom application chosen
* to launch it.
*
* @return {Promise}
* @resolves When the instruction to launch the file has been
* successfully given to the operating system. Note that
* the OS might still take a while until the file is actually
* launched.
* @rejects JavaScript exception if there was an error trying to launch
* the file.
*/
launchDownload: Task.async(function* (aDownload) {
let file = new FileUtils.File(aDownload.target.path);
// In case of a double extension, like ".tar.gz", we only
// consider the last one, because the MIME service cannot
// handle multiple extensions.
let fileExtension = null, mimeInfo = null;
let match = file.leafName.match(/\.([^.]+)$/);
if (match) {
fileExtension = match[1];
}
let isWindowsExe = AppConstants.platform == "win" &&
fileExtension.toLowerCase() == "exe";
// Ask for confirmation if the file is executable, except for .exe on
// Windows where the operating system will show the prompt based on the
// security zone. We do this here, instead of letting the caller handle
// the prompt separately in the user interface layer, for two reasons. The
// first is because of its security nature, so that add-ons cannot forget
// to do this check. The second is that the system-level security prompt
// would be displayed at launch time in any case.
if (file.isExecutable() && !isWindowsExe &&
!(yield this.confirmLaunchExecutable(file.path))) {
return;
}
try {
// The MIME service might throw if contentType == "" and it can't find
// a MIME type for the given extension, so we'll treat this case as
// an unknown mimetype.
mimeInfo = gMIMEService.getFromTypeAndExtension(aDownload.contentType,
fileExtension);
} catch (e) { }
if (aDownload.launcherPath) {
if (!mimeInfo) {
// This should not happen on normal circumstances because launcherPath
// is only set when we had an instance of nsIMIMEInfo to retrieve
// the custom application chosen by the user.
throw new Error(
"Unable to create nsIMIMEInfo to launch a custom application");
}
// Custom application chosen
let localHandlerApp = Cc["@mozilla.org/uriloader/local-handler-app;1"]
.createInstance(Ci.nsILocalHandlerApp);
localHandlerApp.executable = new FileUtils.File(aDownload.launcherPath);
mimeInfo.preferredApplicationHandler = localHandlerApp;
mimeInfo.preferredAction = Ci.nsIMIMEInfo.useHelperApp;
this.launchFile(file, mimeInfo);
return;
}
// No custom application chosen, let's launch the file with the default
// handler. First, let's try to launch it through the MIME service.
if (mimeInfo) {
mimeInfo.preferredAction = Ci.nsIMIMEInfo.useSystemDefault;
try {
this.launchFile(file, mimeInfo);
return;
} catch (ex) { }
}
// If it didn't work or if there was no MIME info available,
// let's try to directly launch the file.
try {
this.launchFile(file);
return;
} catch (ex) { }
// If our previous attempts failed, try sending it through
// the system's external "file:" URL handler.
gExternalProtocolService.loadUrl(NetUtil.newURI(file));
}),
/**
* Asks for confirmation for launching the specified executable file. This
* can be overridden by regression tests to avoid the interactive prompt.
*/
confirmLaunchExecutable: Task.async(function* (path) {
// We don't anchor the prompt to a specific window intentionally, not
// only because this is the same behavior as the system-level prompt,
// but also because the most recently active window is the right choice
// in basically all cases.
return yield DownloadUIHelper.getPrompter().confirmLaunchExecutable(path);
}),
/**
* Launches the specified file, unless overridden by regression tests.
*/
launchFile(file, mimeInfo) {
if (mimeInfo) {
mimeInfo.launchWithFile(file);
} else {
file.launch();
}
},
/**
* Shows the containing folder of a file.
*
* @param aFilePath
* The path to the file.
*
* @return {Promise}
* @resolves When the instruction to open the containing folder has been
* successfully given to the operating system. Note that
* the OS might still take a while until the folder is actually
* opened.
* @rejects JavaScript exception if there was an error trying to open
* the containing folder.
*/
showContainingDirectory: Task.async(function* (aFilePath) {
let file = new FileUtils.File(aFilePath);
try {
// Show the directory containing the file and select the file.
file.reveal();
return;
} 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 = file.parent;
if (!parent) {
throw new Error(
"Unexpected reference to a top-level directory instead of a file");
}
try {
// Open the parent directory to show where the file should be.
parent.launch();
return;
} catch (ex) { }
// If launch also fails (probably because it's not implemented), let
// the OS handler try to open the parent.
gExternalProtocolService.loadUrl(NetUtil.newURI(parent));
}),
/**
* Calls the directory service, create a downloads directory and returns an
* nsIFile for the downloads directory.
*
* @return {Promise}
* @resolves The directory string path.
*/
_createDownloadsDirectory(aName) {
// We read the name of the directory from the list of translated strings
// that is kept by the UI helper module, even if this string is not strictly
// displayed in the user interface.
let directoryPath = OS.Path.join(this._getDirectory(aName),
DownloadUIHelper.strings.downloadsFolder);
// Create the Downloads folder and ignore if it already exists.
return OS.File.makeDir(directoryPath, { ignoreExisting: true })
.then(() => directoryPath);
},
/**
* Returns the string path for the given directory service location name. This
* can be overridden by regression tests to return the path of the system
* temporary directory in all cases.
*/
_getDirectory(name) {
return Services.dirsvc.get(name, Ci.nsIFile).path;
},
/**
* Register the downloads interruption observers.
*
* @param aList
* The public or private downloads list.
* @param aIsPrivate
* True if the list is private, false otherwise.
*
* @return {Promise}
* @resolves When the views and observers are added.
*/
addListObservers(aList, aIsPrivate) {
DownloadObserver.registerView(aList, aIsPrivate);
if (!DownloadObserver.observersAdded) {
DownloadObserver.observersAdded = true;
for (let topic of kObserverTopics) {
Services.obs.addObserver(DownloadObserver, topic, false);
}
}
return Promise.resolve();
},
/**
* Force a save on _store if it exists. Used to ensure downloads do not
* persist after being sanitized on Android.
*
* @return {Promise}
* @resolves When _store.save() completes.
*/
forceSave() {
if (this._store) {
return this._store.save();
}
return Promise.resolve();
},
/**
* Checks if we have already imported (or attempted to import)
* the downloads database from the previous SQLite storage.
*
* @return boolean True if we the previous DB was imported.
*/
get _importedFromSqlite() {
try {
return Services.prefs.getBoolPref(kPrefImportedFromSqlite);
} catch (ex) {
return false;
}
},
};
////////////////////////////////////////////////////////////////////////////////
//// DownloadObserver
this.DownloadObserver = {
/**
* Flag to determine if the observers have been added previously.
*/
observersAdded: false,
/**
* Timer used to delay restarting canceled downloads upon waking and returning
* online.
*/
_wakeTimer: null,
/**
* Set that contains the in progress publics downloads.
* It's kept updated when a public download is added, removed or changes its
* properties.
*/
_publicInProgressDownloads: new Set(),
/**
* Set that contains the in progress private downloads.
* It's kept updated when a private download is added, removed or changes its
* properties.
*/
_privateInProgressDownloads: new Set(),
/**
* Set that contains the downloads that have been canceled when going offline
* or to sleep. These are started again when returning online or waking. This
* list is not persisted so when exiting and restarting, the downloads will not
* be started again.
*/
_canceledOfflineDownloads: new Set(),
/**
* Registers a view that updates the corresponding downloads state set, based
* on the aIsPrivate argument. The set is updated when a download is added,
* removed or changes its properties.
*
* @param aList
* The public or private downloads list.
* @param aIsPrivate
* True if the list is private, false otherwise.
*/
registerView: function DO_registerView(aList, aIsPrivate) {
let downloadsSet = aIsPrivate ? this._privateInProgressDownloads
: this._publicInProgressDownloads;
let downloadsView = {
onDownloadAdded: aDownload => {
if (!aDownload.stopped) {
downloadsSet.add(aDownload);
}
},
onDownloadChanged: aDownload => {
if (aDownload.stopped) {
downloadsSet.delete(aDownload);
} else {
downloadsSet.add(aDownload);
}
},
onDownloadRemoved: aDownload => {
downloadsSet.delete(aDownload);
// The download must also be removed from the canceled when offline set.
this._canceledOfflineDownloads.delete(aDownload);
}
};
// We register the view asynchronously.
aList.addView(downloadsView).then(null, Cu.reportError);
},
/**
* Wrapper that handles the test mode before calling the prompt that display
* a warning message box that informs that there are active downloads,
* and asks whether the user wants to cancel them or not.
*
* @param aCancel
* The observer notification subject.
* @param aDownloadsCount
* The current downloads count.
* @param aPrompter
* The prompter object that shows the confirm dialog.
* @param aPromptType
* The type of prompt notification depending on the observer.
*/
_confirmCancelDownloads: function DO_confirmCancelDownload(
aCancel, aDownloadsCount, aPrompter, aPromptType) {
// If user has already dismissed the request, then do nothing.
if ((aCancel instanceof Ci.nsISupportsPRBool) && aCancel.data) {
return;
}
// Handle test mode
if (gCombinedDownloadIntegration._testPromptDownloads) {
gCombinedDownloadIntegration._testPromptDownloads = aDownloadsCount;
return;
}
aCancel.data = aPrompter.confirmCancelDownloads(aDownloadsCount, aPromptType);
},
/**
* Resume all downloads that were paused when going offline, used when waking
* from sleep or returning from being offline.
*/
_resumeOfflineDownloads: function DO_resumeOfflineDownloads() {
this._wakeTimer = null;
for (let download of this._canceledOfflineDownloads) {
download.start().catch(() => {});
}
},
////////////////////////////////////////////////////////////////////////////
//// nsIObserver
observe: function DO_observe(aSubject, aTopic, aData) {
let downloadsCount;
let p = DownloadUIHelper.getPrompter();
switch (aTopic) {
case "quit-application-requested":
downloadsCount = this._publicInProgressDownloads.size +
this._privateInProgressDownloads.size;
this._confirmCancelDownloads(aSubject, downloadsCount, p, p.ON_QUIT);
break;
case "offline-requested":
downloadsCount = this._publicInProgressDownloads.size +
this._privateInProgressDownloads.size;
this._confirmCancelDownloads(aSubject, downloadsCount, p, p.ON_OFFLINE);
break;
case "last-pb-context-exiting":
downloadsCount = this._privateInProgressDownloads.size;
this._confirmCancelDownloads(aSubject, downloadsCount, p,
p.ON_LEAVE_PRIVATE_BROWSING);
break;
case "last-pb-context-exited":
let promise = Task.spawn(function() {
let list = yield Downloads.getList(Downloads.PRIVATE);
let downloads = yield list.getAll();
// We can remove the downloads and finalize them in parallel.
for (let download of downloads) {
list.remove(download).then(null, Cu.reportError);
download.finalize(true).then(null, Cu.reportError);
}
});
// Handle test mode
if (gCombinedDownloadIntegration._testResolveClearPrivateList) {
gCombinedDownloadIntegration._testResolveClearPrivateList(promise);
} else {
promise.catch(ex => Cu.reportError(ex));
}
break;
case "sleep_notification":
case "suspend_process_notification":
case "network:offline-about-to-go-offline":
for (let download of this._publicInProgressDownloads) {
download.cancel();
this._canceledOfflineDownloads.add(download);
}
for (let download of this._privateInProgressDownloads) {
download.cancel();
this._canceledOfflineDownloads.add(download);
}
break;
case "wake_notification":
case "resume_process_notification":
let wakeDelay = 10000;
try {
wakeDelay = Services.prefs.getIntPref("browser.download.manager.resumeOnWakeDelay");
} catch(e) {}
if (wakeDelay >= 0) {
this._wakeTimer = new Timer(this._resumeOfflineDownloads.bind(this), wakeDelay,
Ci.nsITimer.TYPE_ONE_SHOT);
}
break;
case "network:offline-status-changed":
if (aData == "online") {
this._resumeOfflineDownloads();
}
break;
// We need to unregister observers explicitly before we reach the
// "xpcom-shutdown" phase, otherwise observers may be notified when some
// required services are not available anymore. We can't unregister
// observers on "quit-application", because this module is also loaded
// during "make package" automation, and the quit notification is not sent
// in that execution environment (bug 973637).
case "xpcom-will-shutdown":
for (let topic of kObserverTopics) {
Services.obs.removeObserver(this, topic);
}
break;
}
},
////////////////////////////////////////////////////////////////////////////
//// nsISupports
QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver])
};
////////////////////////////////////////////////////////////////////////////////
//// DownloadHistoryObserver
#ifdef MOZ_PLACES
/**
* Registers a Places observer so that operations on download history are
* reflected on the provided list of downloads.
*
* You do not need to keep a reference to this object in order to keep it alive,
* because the history service already keeps a strong reference to it.
*
* @param aList
* DownloadList object linked to this observer.
*/
this.DownloadHistoryObserver = function (aList)
{
this._list = aList;
PlacesUtils.history.addObserver(this, false);
}
this.DownloadHistoryObserver.prototype = {
/**
* DownloadList object linked to this observer.
*/
_list: null,
////////////////////////////////////////////////////////////////////////////
//// nsISupports
QueryInterface: XPCOMUtils.generateQI([Ci.nsINavHistoryObserver]),
////////////////////////////////////////////////////////////////////////////
//// nsINavHistoryObserver
onDeleteURI: function DL_onDeleteURI(aURI, aGUID) {
this._list.removeFinished(download => aURI.equals(NetUtil.newURI(
download.source.url)));
},
onClearHistory: function DL_onClearHistory() {
this._list.removeFinished();
},
onTitleChanged: function () {},
onBeginUpdateBatch: function () {},
onEndUpdateBatch: function () {},
onVisit: function () {},
onPageChanged: function () {},
onDeleteVisits: function () {},
};
#else
/**
* Empty implementation when we have no Places support, for example on B2G.
*/
this.DownloadHistoryObserver = function (aList) {}
#endif
////////////////////////////////////////////////////////////////////////////////
//// DownloadAutoSaveView
/**
* This view can be added to a DownloadList object to trigger a save operation
* in the given DownloadStore object when a relevant change occurs. You should
* call the "initialize" method in order to register the view and load the
* current state from disk.
*
* You do not need to keep a reference to this object in order to keep it alive,
* because the DownloadList object already keeps a strong reference to it.
*
* @param aList
* The DownloadList object on which the view should be registered.
* @param aStore
* The DownloadStore object used for saving.
*/
this.DownloadAutoSaveView = function (aList, aStore)
{
this._list = aList;
this._store = aStore;
this._downloadsMap = new Map();
this._writer = new DeferredTask(() => this._store.save(), kSaveDelayMs);
AsyncShutdown.profileBeforeChange.addBlocker("DownloadAutoSaveView: writing data",
() => this._writer.finalize());
}
this.DownloadAutoSaveView.prototype = {
/**
* DownloadList object linked to this view.
*/
_list: null,
/**
* The DownloadStore object used for saving.
*/
_store: null,
/**
* True when the initial state of the downloads has been loaded.
*/
_initialized: false,
/**
* Registers the view and loads the current state from disk.
*
* @return {Promise}
* @resolves When the view has been registered.
* @rejects JavaScript exception.
*/
initialize: function ()
{
// We set _initialized to true after adding the view, so that
// onDownloadAdded doesn't cause a save to occur.
return this._list.addView(this).then(() => this._initialized = true);
},
/**
* This map contains only Download objects that should be saved to disk, and
* associates them with the result of their getSerializationHash function, for
* the purpose of detecting changes to the relevant properties.
*/
_downloadsMap: null,
/**
* DeferredTask for the save operation.
*/
_writer: null,
/**
* Called when the list of downloads changed, this triggers the asynchronous
* serialization of the list of downloads.
*/
saveSoon: function ()
{
this._writer.arm();
},
//////////////////////////////////////////////////////////////////////////////
//// DownloadList view
onDownloadAdded: function (aDownload)
{
if (gCombinedDownloadIntegration.shouldPersistDownload(aDownload)) {
this._downloadsMap.set(aDownload, aDownload.getSerializationHash());
if (this._initialized) {
this.saveSoon();
}
}
},
onDownloadChanged: function (aDownload)
{
if (!gCombinedDownloadIntegration.shouldPersistDownload(aDownload)) {
if (this._downloadsMap.has(aDownload)) {
this._downloadsMap.delete(aDownload);
this.saveSoon();
}
return;
}
let hash = aDownload.getSerializationHash();
if (this._downloadsMap.get(aDownload) != hash) {
this._downloadsMap.set(aDownload, hash);
this.saveSoon();
}
},
onDownloadRemoved: function (aDownload)
{
if (this._downloadsMap.has(aDownload)) {
this._downloadsMap.delete(aDownload);
this.saveSoon();
}
},
};