/* 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 access to downloads from previous sessions on platforms that store * them in a different location than session downloads. * * This module works with objects that are compatible with Download, while using * the Places interfaces internally. Some of the Places objects may also be * exposed to allow the consumers to integrate with history view commands. */ import { DownloadList } from "resource://gre/modules/DownloadList.sys.mjs"; const lazy = {}; ChromeUtils.defineESModuleGetters(lazy, { Downloads: "resource://gre/modules/Downloads.sys.mjs", FileUtils: "resource://gre/modules/FileUtils.sys.mjs", PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs", }); // Places query used to retrieve all history downloads for the related list. const HISTORY_PLACES_QUERY = `place:transition=${Ci.nsINavHistoryService.TRANSITION_DOWNLOAD}&sort=${Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING}`; const DESTINATIONFILEURI_ANNO = "downloads/destinationFileURI"; const METADATA_ANNO = "downloads/metaData"; const METADATA_STATE_FINISHED = 1; const METADATA_STATE_FAILED = 2; const METADATA_STATE_CANCELED = 3; const METADATA_STATE_PAUSED = 4; const METADATA_STATE_BLOCKED_PARENTAL = 6; const METADATA_STATE_DIRTY = 8; /** * Provides methods to retrieve downloads from previous sessions and store * downloads for future sessions. */ export let DownloadHistory = { /** * Retrieves the main DownloadHistoryList object which provides a unified view * on downloads from both previous browsing sessions and this session. * * @param type * Determines which type of downloads from this session should be * included in the list. This is Downloads.PUBLIC by default, but can * also be Downloads.PRIVATE or Downloads.ALL. * @param maxHistoryResults * Optional number that limits the amount of results the history query * may return. * * @return {Promise} * @resolves The requested DownloadHistoryList object. * @rejects JavaScript exception. */ async getList({ type = lazy.Downloads.PUBLIC, maxHistoryResults } = {}) { await DownloadCache.ensureInitialized(); let key = `${type}|${maxHistoryResults ? maxHistoryResults : -1}`; if (!this._listPromises[key]) { this._listPromises[key] = lazy.Downloads.getList(type).then(list => { // When the amount of history downloads is capped, we request the list in // descending order, to make sure that the list can apply the limit. let query = HISTORY_PLACES_QUERY + (maxHistoryResults ? `&maxResults=${maxHistoryResults}` : ""); return new DownloadHistoryList(list, query); }); } return this._listPromises[key]; }, /** * This object is populated with one key for each type of download list that * can be returned by the getList method. The values are promises that resolve * to DownloadHistoryList objects. */ _listPromises: {}, async addDownloadToHistory(download) { if ( download.source.isPrivate || !lazy.PlacesUtils.history.canAddURI( lazy.PlacesUtils.toURI(download.source.url) ) ) { return; } await DownloadCache.addDownload(download); await this._updateHistoryListData(download.source.url); }, /** * Stores new detailed metadata for the given download in history. This is * normally called after a download finishes, fails, or is canceled. * * Failed or canceled downloads with partial data are not stored as paused, * because the information from the session download is required for resuming. * * @param download * Download object whose metadata should be updated. If the object * represents a private download, the call has no effect. */ async updateMetaData(download) { if ( download.source.isPrivate || !download.stopped || !lazy.PlacesUtils.history.canAddURI( lazy.PlacesUtils.toURI(download.source.url) ) ) { return; } let state = METADATA_STATE_CANCELED; if (download.succeeded) { state = METADATA_STATE_FINISHED; } else if (download.error) { if (download.error.becauseBlockedByParentalControls) { state = METADATA_STATE_BLOCKED_PARENTAL; } else if (download.error.becauseBlockedByReputationCheck) { state = METADATA_STATE_DIRTY; } else { state = METADATA_STATE_FAILED; } } let metaData = { state, deleted: download.deleted, endTime: download.endTime, }; if (download.succeeded) { metaData.fileSize = download.target.size; } // The verdict may still be present even if the download succeeded. if (download.error && download.error.reputationCheckVerdict) { metaData.reputationCheckVerdict = download.error.reputationCheckVerdict; } // This should be executed before any async parts, to ensure the cache is // updated before any notifications are activated. await DownloadCache.setMetadata(download.source.url, metaData); await this._updateHistoryListData(download.source.url); }, async _updateHistoryListData(sourceUrl) { for (let key of Object.getOwnPropertyNames(this._listPromises)) { let downloadHistoryList = await this._listPromises[key]; downloadHistoryList.updateForMetaDataChange( sourceUrl, DownloadCache.get(sourceUrl) ); } }, }; /** * This cache exists: * - in order to optimize the load of DownloadsHistoryList, when Places * annotations for history downloads must be read. In fact, annotations are * stored in a single table, and reading all of them at once is much more * efficient than an individual query. * - to avoid needing to do asynchronous reading of the database during download * list updates, which are designed to be synchronous (to improve UI * responsiveness). * * The cache is initialized the first time DownloadHistory.getList is called, or * when data is added. */ let DownloadCache = { _data: new Map(), _initializePromise: null, /** * Initializes the cache, loading the data from the places database. * * @return {Promise} Returns a promise that is resolved once the * initialization is complete. */ ensureInitialized() { if (this._initializePromise) { return this._initializePromise; } this._initializePromise = (async () => { const placesObserver = new PlacesWeakCallbackWrapper( this.handlePlacesEvents.bind(this) ); PlacesObservers.addListener( ["history-cleared", "page-removed"], placesObserver ); let pageAnnos = await lazy.PlacesUtils.history.fetchAnnotatedPages([ METADATA_ANNO, DESTINATIONFILEURI_ANNO, ]); let metaDataPages = pageAnnos.get(METADATA_ANNO); if (metaDataPages) { for (let { uri, content } of metaDataPages) { try { this._data.set(uri.href, JSON.parse(content)); } catch (ex) { // Do nothing - JSON.parse could throw. } } } let destinationFilePages = pageAnnos.get(DESTINATIONFILEURI_ANNO); if (destinationFilePages) { for (let { uri, content } of destinationFilePages) { let newData = this.get(uri.href); newData.targetFileSpec = content; this._data.set(uri.href, newData); } } })(); return this._initializePromise; }, /** * This returns an object containing the meta data for the supplied URL. * * @param {String} url The url to get the meta data for. * @return {Object|null} Returns an empty object if there is no meta data found, or * an object containing the meta data. The meta data * will look like: * * { targetFileSpec, state, deleted, endTime, fileSize, ... } * * The targetFileSpec property is the value of "downloads/destinationFileURI", * while the other properties are taken from "downloads/metaData". Any of the * properties may be missing from the object. */ get(url) { return this._data.get(url) || {}; }, /** * Adds a download to the cache and the places database. * * @param {Download} download The download to add to the database and cache. */ async addDownload(download) { await this.ensureInitialized(); let targetFile = new lazy.FileUtils.File(download.target.path); let targetUri = Services.io.newFileURI(targetFile); // This should be executed before any async parts, to ensure the cache is // updated before any notifications are activated. // Note: this intentionally overwrites any metadata as this is // the start of a new download. this._data.set(download.source.url, { targetFileSpec: targetUri.spec }); let originalPageInfo = await lazy.PlacesUtils.history.fetch( download.source.url ); let pageInfo = await lazy.PlacesUtils.history.insert({ url: download.source.url, // In case we are downloading a file that does not correspond to a web // page for which the title is present, we populate the otherwise empty // history title with the name of the destination file, to allow it to be // visible and searchable in history results. title: (originalPageInfo && originalPageInfo.title) || targetFile.leafName, visits: [ { // The start time is always available when we reach this point. date: download.startTime, transition: lazy.PlacesUtils.history.TRANSITIONS.DOWNLOAD, referrer: download.source.referrerInfo ? download.source.referrerInfo.originalReferrer : null, }, ], }); await lazy.PlacesUtils.history.update({ annotations: new Map([["downloads/destinationFileURI", targetUri.spec]]), // XXX Bug 1479445: We shouldn't have to supply both guid and url here, // but currently we do. guid: pageInfo.guid, url: pageInfo.url, }); }, /** * Sets the metadata for a given url. If the cache already contains meta data * for the given url, it will be overwritten (note: the targetFileSpec will be * maintained). * * @param {String} url The url to set the meta data for. * @param {Object} metadata The new metaData to save in the cache. */ async setMetadata(url, metadata) { await this.ensureInitialized(); // This should be executed before any async parts, to ensure the cache is // updated before any notifications are activated. let existingData = this.get(url); let newData = { ...metadata }; if ("targetFileSpec" in existingData) { newData.targetFileSpec = existingData.targetFileSpec; } this._data.set(url, newData); try { await lazy.PlacesUtils.history.update({ annotations: new Map([[METADATA_ANNO, JSON.stringify(metadata)]]), url, }); } catch (ex) { console.error(ex); } }, QueryInterface: ChromeUtils.generateQI(["nsISupportsWeakReference"]), handlePlacesEvents(events) { for (const event of events) { switch (event.type) { case "history-cleared": { this._data.clear(); break; } case "page-removed": { if (event.isRemovedFromStore) { this._data.delete(event.url); } break; } } } }, }; /** * Represents a download from the browser history. This object implements part * of the interface of the Download object. * * While Download objects are shared between the public DownloadList and all the * DownloadHistoryList instances, multiple HistoryDownload objects referring to * the same item can be created for different DownloadHistoryList instances. * * @param placesNode * The Places node from which the history download should be initialized. */ class HistoryDownload { constructor(placesNode) { this.placesNode = placesNode; // History downloads should get the referrer from Places (bug 829201). this.source = { url: placesNode.uri, isPrivate: false, }; this.target = { path: undefined, exists: false, size: undefined, }; // In case this download cannot obtain its end time from the Places metadata, // use the time from the Places node, that is the start time of the download. this.endTime = placesNode.time / 1000; } /** * DownloadSlot containing this history download. * * @type {DownloadSlot} */ slot = null; /** * History downloads are never in progress. * * @type {Boolean} */ stopped = true; /** * No percentage indication is shown for history downloads. * * @type {Boolean} */ hasProgress = false; /** * History downloads cannot be restarted using their partial data, even if * they are indicated as paused in their Places metadata. The only way is to * use the information from a persisted session download, that will be shown * instead of the history download. In case this session download is not * available, we show the history download as canceled, not paused. * * @type {Boolean} */ hasPartialData = false; /** * Pushes information from Places metadata into this object. */ updateFromMetaData(metaData) { try { this.target.path = Cc["@mozilla.org/network/protocol;1?name=file"] .getService(Ci.nsIFileProtocolHandler) .getFileFromURLSpec(metaData.targetFileSpec).path; } catch (ex) { this.target.path = undefined; } if ("state" in metaData) { this.succeeded = metaData.state == METADATA_STATE_FINISHED; this.canceled = metaData.state == METADATA_STATE_CANCELED || metaData.state == METADATA_STATE_PAUSED; this.endTime = metaData.endTime; this.deleted = metaData.deleted; // Recreate partial error information from the state saved in history. if (metaData.state == METADATA_STATE_FAILED) { this.error = { message: "History download failed." }; } else if (metaData.state == METADATA_STATE_BLOCKED_PARENTAL) { this.error = { becauseBlockedByParentalControls: true }; } else if (metaData.state == METADATA_STATE_DIRTY) { this.error = { becauseBlockedByReputationCheck: true, reputationCheckVerdict: metaData.reputationCheckVerdict || "", }; } else { this.error = null; } // Normal history downloads are assumed to exist until the user interface // is refreshed, at which point these values may be updated. this.target.exists = true; this.target.size = metaData.fileSize; } else { // Metadata might be missing from a download that has started but hasn't // stopped already. Normally, this state is overridden with the one from // the corresponding in-progress session download. But if the browser is // terminated abruptly and additionally the file with information about // in-progress downloads is lost, we may end up using this state. We use // the failed state to allow the download to be restarted. // // On the other hand, if the download is missing the target file // annotation as well, it is just a very old one, and we can assume it // succeeded. this.succeeded = !this.target.path; this.error = this.target.path ? { message: "Unstarted download." } : null; this.canceled = false; this.deleted = false; // These properties may be updated if the user interface is refreshed. this.target.exists = false; this.target.size = undefined; } } /** * This method may be called when deleting a history download. */ async finalize() {} /** * This method mimicks the "refresh" method of session downloads. */ async refresh() { try { this.target.size = (await IOUtils.stat(this.target.path)).size; this.target.exists = true; } catch (ex) { // We keep the known file size from the metadata, if any. this.target.exists = false; } this.slot.list._notifyAllViews("onDownloadChanged", this); } /** * This method mimicks the "manuallyRemoveData" method of session downloads. */ async manuallyRemoveData() { let { path } = this.target; if (this.target.path && this.succeeded) { // Temp files are made "read-only" by DownloadIntegration.downloadDone, so // reset the permission bits to read/write. This won't be necessary after // bug 1733587 since Downloads won't ever be temporary. await IOUtils.setPermissions(path, 0o660); await IOUtils.remove(path, { ignoreAbsent: true }); } this.deleted = true; await this.refresh(); } } /** * Represents one item in the list of public session and history downloads. * * The object may contain a session download, a history download, or both. When * both a history and a session download are present, the session download gets * priority and its information is accessed. * * @param list * The DownloadHistoryList that owns this DownloadSlot object. */ class DownloadSlot { constructor(list) { this.list = list; } /** * Download object representing the session download contained in this slot. */ sessionDownload = null; _historyDownload = null; /** * HistoryDownload object contained in this slot. */ get historyDownload() { return this._historyDownload; } set historyDownload(historyDownload) { this._historyDownload = historyDownload; if (historyDownload) { historyDownload.slot = this; } } /** * Returns the Download or HistoryDownload object for displaying information * and executing commands in the user interface. */ get download() { return this.sessionDownload || this.historyDownload; } } /** * Represents an ordered collection of DownloadSlot objects containing a merged * view on session downloads and history downloads. Views on this list will * receive notifications for changes to both types of downloads. * * Downloads in this list are sorted from oldest to newest, with all session * downloads after all the history downloads. When a new history download is * added and the list also contains session downloads, the insertBefore option * of the onDownloadAdded notification refers to the first session download. * * The list of downloads cannot be modified using the DownloadList methods. * * @param publicList * Underlying DownloadList containing public downloads. * @param place * Places query used to retrieve history downloads. */ class DownloadHistoryList extends DownloadList { constructor(publicList, place) { super(); // While "this._slots" contains all the data in order, the other properties // provide fast access for the most common operations. this._slots = []; this._slotsForUrl = new Map(); this._slotForDownload = new WeakMap(); // Start the asynchronous queries to retrieve history and session downloads. publicList.addView(this).catch(console.error); let query = {}, options = {}; lazy.PlacesUtils.history.queryStringToQuery(place, query, options); // NB: The addObserver call sets our nsINavHistoryResultObserver.result. let result = lazy.PlacesUtils.history.executeQuery( query.value, options.value ); result.addObserver(this); // Our history result observer is long lived for fast shared views, so free // the reference on shutdown to prevent leaks. Services.obs.addObserver(() => { this.result = null; }, "quit-application-granted"); } /** * This is set when executing the Places query. */ _result = null; /** * Index of the first slot that contains a session download. This is equal to * the length of the list when there are no session downloads. * * @type {Number} */ _firstSessionSlotIndex = 0; get result() { return this._result; } set result(result) { if (this._result == result) { return; } if (this._result) { this._result.removeObserver(this); this._result.root.containerOpen = false; } this._result = result; if (this._result) { this._result.root.containerOpen = true; } } /** * Updates the download history item when the meta data or destination file * changes. * * @param {String} sourceUrl The sourceUrl which was updated. * @param {Object} metaData The new meta data for the sourceUrl. */ updateForMetaDataChange(sourceUrl, metaData) { let slotsForUrl = this._slotsForUrl.get(sourceUrl); if (!slotsForUrl) { return; } for (let slot of slotsForUrl) { if (slot.sessionDownload) { // The visible data doesn't change, so we don't have to notify views. return; } slot.historyDownload.updateFromMetaData(metaData); this._notifyAllViews("onDownloadChanged", slot.download); } } _insertSlot({ slot, index, slotsForUrl }) { // Add the slot to the ordered array. this._slots.splice(index, 0, slot); this._downloads.splice(index, 0, slot.download); if (!slot.sessionDownload) { this._firstSessionSlotIndex++; } // Add the slot to the fast access maps. slotsForUrl.add(slot); this._slotsForUrl.set(slot.download.source.url, slotsForUrl); // Add the associated view items. this._notifyAllViews("onDownloadAdded", slot.download, { insertBefore: this._downloads[index + 1], }); } _removeSlot({ slot, slotsForUrl }) { // Remove the slot from the ordered array. let index = this._slots.indexOf(slot); this._slots.splice(index, 1); this._downloads.splice(index, 1); if (this._firstSessionSlotIndex > index) { this._firstSessionSlotIndex--; } // Remove the slot from the fast access maps. slotsForUrl.delete(slot); if (slotsForUrl.size == 0) { this._slotsForUrl.delete(slot.download.source.url); } // Remove the associated view items. this._notifyAllViews("onDownloadRemoved", slot.download); } /** * Ensures that the information about a history download is stored in at least * one slot, adding a new one at the end of the list if necessary. * * A reference to the same Places node will be stored in the HistoryDownload * object for all the DownloadSlot objects associated with the source URL. * * @param placesNode * The Places node that represents the history download. */ _insertPlacesNode(placesNode) { let slotsForUrl = this._slotsForUrl.get(placesNode.uri) || new Set(); // If there are existing slots associated with this URL, we only have to // ensure that the Places node reference is kept updated in case the more // recent Places notification contained a different node object. if (slotsForUrl.size > 0) { for (let slot of slotsForUrl) { if (!slot.historyDownload) { slot.historyDownload = new HistoryDownload(placesNode); } else { slot.historyDownload.placesNode = placesNode; } } return; } // If there are no existing slots for this URL, we have to create a new one. // Since the history download is visible in the slot, we also have to update // the object using the Places metadata. let historyDownload = new HistoryDownload(placesNode); historyDownload.updateFromMetaData(DownloadCache.get(placesNode.uri)); let slot = new DownloadSlot(this); slot.historyDownload = historyDownload; this._insertSlot({ slot, slotsForUrl, index: this._firstSessionSlotIndex }); } // nsINavHistoryResultObserver containerStateChanged(node) { this.invalidateContainer(node); } // nsINavHistoryResultObserver invalidateContainer(container) { this._notifyAllViews("onDownloadBatchStarting"); // Remove all the current slots containing only history downloads. for (let index = this._slots.length - 1; index >= 0; index--) { let slot = this._slots[index]; if (slot.sessionDownload) { // The visible data doesn't change, so we don't have to notify views. slot.historyDownload = null; } else { let slotsForUrl = this._slotsForUrl.get(slot.download.source.url); this._removeSlot({ slot, slotsForUrl }); } } // Add new slots or reuse existing ones for history downloads. for (let index = container.childCount - 1; index >= 0; --index) { try { this._insertPlacesNode(container.getChild(index)); } catch (ex) { console.error(ex); } } this._notifyAllViews("onDownloadBatchEnded"); } // nsINavHistoryResultObserver nodeInserted(parent, placesNode) { this._insertPlacesNode(placesNode); } // nsINavHistoryResultObserver nodeRemoved(parent, placesNode) { let slotsForUrl = this._slotsForUrl.get(placesNode.uri); for (let slot of slotsForUrl) { if (slot.sessionDownload) { // The visible data doesn't change, so we don't have to notify views. slot.historyDownload = null; } else { this._removeSlot({ slot, slotsForUrl }); } } } // nsINavHistoryResultObserver nodeIconChanged() {} nodeTitleChanged() {} nodeKeywordChanged() {} nodeDateAddedChanged() {} nodeLastModifiedChanged() {} nodeHistoryDetailsChanged() {} nodeTagsChanged() {} sortingChanged() {} nodeMoved() {} nodeURIChanged() {} batching() {} // DownloadList callback onDownloadAdded(download) { let url = download.source.url; let slotsForUrl = this._slotsForUrl.get(url) || new Set(); // For every source URL, there can be at most one slot containing a history // download without an associated session download. If we find one, then we // can reuse it for the current session download, although we have to move // it together with the other session downloads. let slot = [...slotsForUrl][0]; if (slot && !slot.sessionDownload) { // Remove the slot because we have to change its position. this._removeSlot({ slot, slotsForUrl }); } else { slot = new DownloadSlot(this); } slot.sessionDownload = download; this._insertSlot({ slot, slotsForUrl, index: this._slots.length }); this._slotForDownload.set(download, slot); } // DownloadList callback onDownloadChanged(download) { let slot = this._slotForDownload.get(download); this._notifyAllViews("onDownloadChanged", slot.download); } // DownloadList callback onDownloadRemoved(download) { let url = download.source.url; let slotsForUrl = this._slotsForUrl.get(url); let slot = this._slotForDownload.get(download); this._removeSlot({ slot, slotsForUrl }); this._slotForDownload.delete(download); // If there was only one slot for this source URL and it also contained a // history download, we should resurrect it in the correct area of the list. if (slotsForUrl.size == 0 && slot.historyDownload) { // We have one download slot containing both a session download and a // history download, and we are now removing the session download. // Previously, we did not use the Places metadata because it was obscured // by the session download. Since this is no longer the case, we have to // read the latest metadata before resurrecting the history download. slot.historyDownload.updateFromMetaData(DownloadCache.get(url)); slot.sessionDownload = null; // Place the resurrected history slot after all the session slots. this._insertSlot({ slot, slotsForUrl, index: this._firstSessionSlotIndex, }); } } // DownloadList add() { throw new Error("Not implemented."); } // DownloadList remove() { throw new Error("Not implemented."); } // DownloadList removeFinished() { throw new Error("Not implemented."); } }