diff options
Diffstat (limited to 'toolkit/components/cleardata/ClearDataService.sys.mjs')
| -rw-r--r-- | toolkit/components/cleardata/ClearDataService.sys.mjs | 1794 |
1 files changed, 1794 insertions, 0 deletions
diff --git a/toolkit/components/cleardata/ClearDataService.sys.mjs b/toolkit/components/cleardata/ClearDataService.sys.mjs new file mode 100644 index 0000000000..88d1835f3c --- /dev/null +++ b/toolkit/components/cleardata/ClearDataService.sys.mjs @@ -0,0 +1,1794 @@ +/* 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/. */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + Downloads: "resource://gre/modules/Downloads.sys.mjs", + PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs", + ServiceWorkerCleanUp: "resource://gre/modules/ServiceWorkerCleanUp.sys.mjs", +}); + +XPCOMUtils.defineLazyServiceGetter( + lazy, + "sas", + "@mozilla.org/storage/activity-service;1", + "nsIStorageActivityService" +); +XPCOMUtils.defineLazyServiceGetter( + lazy, + "TrackingDBService", + "@mozilla.org/tracking-db-service;1", + "nsITrackingDBService" +); +XPCOMUtils.defineLazyServiceGetter( + lazy, + "IdentityCredentialStorageService", + "@mozilla.org/browser/identity-credential-storage-service;1", + "nsIIdentityCredentialStorageService" +); + +/** + * Test if host, OriginAttributes or principal belong to a baseDomain. Also + * considers partitioned storage by inspecting OriginAttributes partitionKey. + * @param options + * @param {string} [options.host] - Optional host to compare to base domain. + * @param {object} [options.originAttributes] - Optional origin attributes to + * inspect for aBaseDomain. If omitted, partitionKey will not be matched. + * @param {nsIPrincipal} [options.principal] - Optional principal to compare to + * base domain. + * @param {string} aBaseDomain - Domain to check for. Must be a valid, non-empty + * baseDomain string. + * @returns {boolean} Whether the host, originAttributes or principal matches + * the base domain. + */ +function hasBaseDomain( + { host = null, originAttributes = null, principal = null }, + aBaseDomain +) { + if (!aBaseDomain) { + throw new Error("Missing baseDomain."); + } + if (!host && !originAttributes && !principal) { + throw new Error( + "Missing host, originAttributes or principal to match with baseDomain." + ); + } + if (principal && (host || originAttributes)) { + throw new Error( + "Can only pass either principal or host and originAttributes." + ); + } + + if (host && Services.eTLD.hasRootDomain(host, aBaseDomain)) { + return true; + } + + if (principal?.baseDomain == aBaseDomain) { + return true; + } + + originAttributes = originAttributes || principal?.originAttributes; + if (!originAttributes) { + return false; + } + + return ChromeUtils.originAttributesMatchPattern(originAttributes, { + partitionKeyPattern: { baseDomain: aBaseDomain }, + }); +} + +// Here is a list of methods cleaners may implement. These methods must return a +// Promise object. +// * deleteAll() - this method _must_ exist. When called, it deletes all the +// data owned by the cleaner. +// * deleteByPrincipal() - this method _must_ exist. +// * deleteByBaseDomain() - this method _must_ exist. +// * deleteByHost() - this method is implemented only if the cleaner knows +// how to delete data by host + originAttributes pattern. If +// not implemented, deleteAll() will be used as fallback. +// * deleteByRange() - this method is implemented only if the cleaner knows how +// to delete data by time range. It receives 2 time range +// parameters: aFrom/aTo. If not implemented, deleteAll() is +// used as fallback. +// * deleteByLocalFiles() - this method removes data held for local files and +// other hostless origins. If not implemented, +// **no fallback is used**, as for a number of +// cleaners, no such data will ever exist and +// therefore clearing it does not make sense. +// * deleteByOriginAttributes() - this method is implemented only if the cleaner +// knows how to delete data by originAttributes +// pattern. +// * cleanupAfterDeletionAtShutdown() - this method is implemented only if the +// cleaner needs a separate step after +// deletion. No-op if not implemented. +// Currently called via +// Sanitizer.maybeSanitizeSessionPrincipals(). + +const CookieCleaner = { + deleteByLocalFiles(aOriginAttributes) { + return new Promise(aResolve => { + Services.cookies.removeCookiesFromExactHost( + "", + JSON.stringify(aOriginAttributes) + ); + aResolve(); + }); + }, + + deleteByHost(aHost, aOriginAttributes) { + return new Promise(aResolve => { + Services.cookies.removeCookiesFromExactHost( + aHost, + JSON.stringify(aOriginAttributes) + ); + aResolve(); + }); + }, + + deleteByPrincipal(aPrincipal) { + // Fall back to clearing by host and OA pattern. This will over-clear, since + // any properties that are not explicitly set in aPrincipal.originAttributes + // will be wildcard matched. + return this.deleteByHost(aPrincipal.host, aPrincipal.originAttributes); + }, + + async deleteByBaseDomain(aDomain) { + Services.cookies.cookies + .filter(({ rawHost, originAttributes }) => + hasBaseDomain({ host: rawHost, originAttributes }, aDomain) + ) + .forEach(cookie => { + Services.cookies.removeCookiesFromExactHost( + cookie.rawHost, + JSON.stringify(cookie.originAttributes) + ); + }); + }, + + deleteByRange(aFrom, aTo) { + return Services.cookies.removeAllSince(aFrom); + }, + + deleteByOriginAttributes(aOriginAttributesString) { + return new Promise(aResolve => { + try { + Services.cookies.removeCookiesWithOriginAttributes( + aOriginAttributesString + ); + } catch (ex) {} + aResolve(); + }); + }, + + deleteAll() { + return new Promise(aResolve => { + Services.cookies.removeAll(); + aResolve(); + }); + }, +}; + +const CertCleaner = { + async deleteByHost(aHost, aOriginAttributes) { + let overrideService = Cc["@mozilla.org/security/certoverride;1"].getService( + Ci.nsICertOverrideService + ); + + overrideService.clearValidityOverride(aHost, -1, aOriginAttributes); + }, + + deleteByPrincipal(aPrincipal) { + return this.deleteByHost(aPrincipal.host, aPrincipal.originAttributes); + }, + + async deleteByBaseDomain(aBaseDomain) { + let overrideService = Cc["@mozilla.org/security/certoverride;1"].getService( + Ci.nsICertOverrideService + ); + overrideService + .getOverrides() + .filter(({ asciiHost }) => + hasBaseDomain({ host: asciiHost }, aBaseDomain) + ) + .forEach(({ asciiHost, port }) => + overrideService.clearValidityOverride(asciiHost, port, {}) + ); + }, + + async deleteAll() { + let overrideService = Cc["@mozilla.org/security/certoverride;1"].getService( + Ci.nsICertOverrideService + ); + + overrideService.clearAllOverrides(); + }, +}; + +const NetworkCacheCleaner = { + async deleteByHost(aHost, aOriginAttributes) { + // Delete data from both HTTP and HTTPS sites. + let httpURI = Services.io.newURI("http://" + aHost); + let httpsURI = Services.io.newURI("https://" + aHost); + let httpPrincipal = Services.scriptSecurityManager.createContentPrincipal( + httpURI, + aOriginAttributes + ); + let httpsPrincipal = Services.scriptSecurityManager.createContentPrincipal( + httpsURI, + aOriginAttributes + ); + + Services.cache2.clearOrigin(httpPrincipal); + Services.cache2.clearOrigin(httpsPrincipal); + }, + + async deleteByBaseDomain(aBaseDomain) { + Services.cache2.clearBaseDomain(aBaseDomain); + }, + + deleteByPrincipal(aPrincipal) { + return new Promise(aResolve => { + Services.cache2.clearOrigin(aPrincipal); + aResolve(); + }); + }, + + deleteByOriginAttributes(aOriginAttributesString) { + return new Promise(aResolve => { + Services.cache2.clearOriginAttributes(aOriginAttributesString); + aResolve(); + }); + }, + + deleteAll() { + return new Promise(aResolve => { + Services.cache2.clear(); + aResolve(); + }); + }, +}; + +const CSSCacheCleaner = { + async deleteByHost(aHost, aOriginAttributes) { + // Delete data from both HTTP and HTTPS sites. + let httpURI = Services.io.newURI("http://" + aHost); + let httpsURI = Services.io.newURI("https://" + aHost); + let httpPrincipal = Services.scriptSecurityManager.createContentPrincipal( + httpURI, + aOriginAttributes + ); + let httpsPrincipal = Services.scriptSecurityManager.createContentPrincipal( + httpsURI, + aOriginAttributes + ); + + ChromeUtils.clearStyleSheetCacheByPrincipal(httpPrincipal); + ChromeUtils.clearStyleSheetCacheByPrincipal(httpsPrincipal); + }, + + async deleteByPrincipal(aPrincipal) { + ChromeUtils.clearStyleSheetCacheByPrincipal(aPrincipal); + }, + + async deleteByBaseDomain(aBaseDomain) { + ChromeUtils.clearStyleSheetCacheByBaseDomain(aBaseDomain); + }, + + async deleteAll() { + ChromeUtils.clearStyleSheetCache(); + }, +}; + +const ImageCacheCleaner = { + async deleteByHost(aHost, aOriginAttributes) { + let imageCache = Cc["@mozilla.org/image/tools;1"] + .getService(Ci.imgITools) + .getImgCacheForDocument(null); + + // Delete data from both HTTP and HTTPS sites. + let httpURI = Services.io.newURI("http://" + aHost); + let httpsURI = Services.io.newURI("https://" + aHost); + let httpPrincipal = Services.scriptSecurityManager.createContentPrincipal( + httpURI, + aOriginAttributes + ); + let httpsPrincipal = Services.scriptSecurityManager.createContentPrincipal( + httpsURI, + aOriginAttributes + ); + + imageCache.removeEntriesFromPrincipalInAllProcesses(httpPrincipal); + imageCache.removeEntriesFromPrincipalInAllProcesses(httpsPrincipal); + }, + + async deleteByPrincipal(aPrincipal) { + let imageCache = Cc["@mozilla.org/image/tools;1"] + .getService(Ci.imgITools) + .getImgCacheForDocument(null); + imageCache.removeEntriesFromPrincipalInAllProcesses(aPrincipal); + }, + + async deleteByBaseDomain(aBaseDomain) { + let imageCache = Cc["@mozilla.org/image/tools;1"] + .getService(Ci.imgITools) + .getImgCacheForDocument(null); + imageCache.removeEntriesFromBaseDomainInAllProcesses(aBaseDomain); + }, + + deleteAll() { + return new Promise(aResolve => { + let imageCache = Cc["@mozilla.org/image/tools;1"] + .getService(Ci.imgITools) + .getImgCacheForDocument(null); + imageCache.clearCache(false); // true=chrome, false=content + aResolve(); + }); + }, +}; + +const DownloadsCleaner = { + async _deleteInternal({ hostOrBaseDomain, principal, originAttributes }) { + originAttributes = originAttributes || principal?.originAttributes || {}; + + let list = await lazy.Downloads.getList(lazy.Downloads.ALL); + list.removeFinished(({ source }) => { + if ( + "userContextId" in originAttributes && + "userContextId" in source && + originAttributes.userContextId != source.userContextId + ) { + return false; + } + if ( + "privateBrowsingId" in originAttributes && + !!originAttributes.privateBrowsingId != source.isPrivate + ) { + return false; + } + + let entryURI = Services.io.newURI(source.url); + if (hostOrBaseDomain) { + return Services.eTLD.hasRootDomain(entryURI.host, hostOrBaseDomain); + } + if (principal) { + return principal.equalsURI(entryURI); + } + return false; + }); + }, + + async deleteByHost(aHost, aOriginAttributes) { + // Clearing by host also clears associated subdomains. + return this._deleteInternal({ + hostOrBaseDomain: aHost, + originAttributes: aOriginAttributes, + }); + }, + + deleteByPrincipal(aPrincipal) { + return this._deleteInternal({ principal: aPrincipal }); + }, + + async deleteByBaseDomain(aBaseDomain) { + return this._deleteInternal({ hostOrBaseDomain: aBaseDomain }); + }, + + deleteByRange(aFrom, aTo) { + // Convert microseconds back to milliseconds for date comparisons. + let rangeBeginMs = aFrom / 1000; + let rangeEndMs = aTo / 1000; + + return lazy.Downloads.getList(lazy.Downloads.ALL).then(aList => { + aList.removeFinished( + aDownload => + aDownload.startTime >= rangeBeginMs && + aDownload.startTime <= rangeEndMs + ); + }); + }, + + deleteAll() { + return lazy.Downloads.getList(lazy.Downloads.ALL).then(aList => { + aList.removeFinished(null); + }); + }, +}; + +const PasswordsCleaner = { + deleteByHost(aHost, aOriginAttributes) { + // Clearing by host also clears associated subdomains. + return this._deleteInternal(aLogin => + Services.eTLD.hasRootDomain(aLogin.hostname, aHost) + ); + }, + + deleteByPrincipal(aPrincipal) { + // Login origins don't contain any origin attributes. + return this._deleteInternal( + aLogin => aLogin.origin == aPrincipal.originNoSuffix + ); + }, + + deleteByBaseDomain(aBaseDomain) { + return this._deleteInternal(aLogin => + Services.eTLD.hasRootDomain(aLogin.hostname, aBaseDomain) + ); + }, + + deleteAll() { + return this._deleteInternal(() => true); + }, + + async _deleteInternal(aCb) { + try { + let logins = Services.logins.getAllLogins(); + for (let login of logins) { + if (aCb(login)) { + Services.logins.removeLogin(login); + } + } + } catch (ex) { + // XXXehsan: is there a better way to do this rather than this + // hacky comparison? + if ( + !ex.message.includes("User canceled Master Password entry") && + ex.result != Cr.NS_ERROR_NOT_IMPLEMENTED + ) { + throw new Error("Exception occured in clearing passwords: " + ex); + } + } + }, +}; + +const MediaDevicesCleaner = { + async deleteByRange(aFrom, aTo) { + let mediaMgr = Cc["@mozilla.org/mediaManagerService;1"].getService( + Ci.nsIMediaManagerService + ); + mediaMgr.sanitizeDeviceIds(aFrom); + }, + + // TODO: We should call the MediaManager to clear by principal, rather than + // over-clearing for user requests or bailing out for programmatic calls. + async deleteByPrincipal(aPrincipal, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + // TODO: Same as above, but for base domain. + async deleteByBaseDomain(aBaseDomain, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + async deleteAll() { + let mediaMgr = Cc["@mozilla.org/mediaManagerService;1"].getService( + Ci.nsIMediaManagerService + ); + mediaMgr.sanitizeDeviceIds(null); + }, +}; + +const QuotaCleaner = { + /** + * Clear quota storage for matching principals. + * @param {function} filterFn - Filter function which is passed a principal. + * Return true to clear storage for given principal or false to skip it. + * @returns {Promise} - Resolves once all matching items have been cleared. + * Rejects on error. + */ + async _qmsClearStoragesForPrincipalsMatching(filterFn) { + // Clearing quota storage by first getting all entry origins and then + // iterating over them is not ideal, since we can not ensure an entirely + // consistent clearing state. Between fetching the origins and clearing + // them, additional entries could be added. This means we could end up with + // stray entries after the clearing operation. To fix this we would need to + // move the clearing code to the QuotaManager itself which could either + // prevent new writes while clearing or clean up any additional entries + // which get written during the clearing operation. + // Performance is also not ideal, since we iterate over storage multiple + // times for this two step process. + // See Bug 1719195. + let origins = await new Promise((resolve, reject) => { + Services.qms.listOrigins().callback = request => { + if (request.resultCode != Cr.NS_OK) { + reject({ message: "Deleting quota storages failed" }); + return; + } + resolve(request.result); + }; + }); + + let clearPromises = origins + // Parse origins into principals. + .map(Services.scriptSecurityManager.createContentPrincipalFromOrigin) + // Filter out principals that don't match the filterFn. + .filter(filterFn) + // Clear quota storage by principal and collect the promises. + .map( + principal => + new Promise((resolve, reject) => { + let clearRequest = + Services.qms.clearStoragesForPrincipal(principal); + clearRequest.callback = () => { + if (clearRequest.resultCode != Cr.NS_OK) { + reject({ message: "Deleting quota storages failed" }); + return; + } + resolve(); + }; + }) + ); + return Promise.all(clearPromises); + }, + + deleteByPrincipal(aPrincipal) { + // localStorage: The legacy LocalStorage implementation that will + // eventually be removed depends on this observer notification to clear by + // principal. + Services.obs.notifyObservers( + null, + "extension:purge-localStorage", + aPrincipal.host + ); + + // Clear sessionStorage + Services.sessionStorage.clearStoragesForOrigin(aPrincipal); + + // ServiceWorkers: they must be removed before cleaning QuotaManager. + return lazy.ServiceWorkerCleanUp.removeFromPrincipal(aPrincipal) + .then( + _ => /* exceptionThrown = */ false, + _ => /* exceptionThrown = */ true + ) + .then(exceptionThrown => { + // QuotaManager: In the event of a failure, we call reject to propagate + // the error upwards. + return new Promise((aResolve, aReject) => { + let req = Services.qms.clearStoragesForPrincipal(aPrincipal); + req.callback = () => { + if (exceptionThrown || req.resultCode != Cr.NS_OK) { + aReject({ message: "Delete by principal failed" }); + } else { + aResolve(); + } + }; + }); + }); + }, + + async deleteByBaseDomain(aBaseDomain) { + // localStorage: The legacy LocalStorage implementation that will + // eventually be removed depends on this observer notification to clear by + // host. Some other subsystems like Reporting headers depend on this too. + Services.obs.notifyObservers( + null, + "extension:purge-localStorage", + aBaseDomain + ); + + // Clear sessionStorage + Services.obs.notifyObservers( + null, + "browser:purge-sessionStorage", + aBaseDomain + ); + + // Clear third-party storage partitioned under aBaseDomain. + // This notification is forwarded via the StorageObserver and consumed only + // by the SessionStorageManager and (legacy) LocalStorageManager. + // There is a similar (legacy) notification "clear-origin-attributes-data" + // which additionally clears data across various other storages unrelated to + // the QuotaCleaner. + Services.obs.notifyObservers( + null, + "dom-storage:clear-origin-attributes-data", + JSON.stringify({ partitionKeyPattern: { baseDomain: aBaseDomain } }) + ); + + // ServiceWorkers must be removed before cleaning QuotaManager. We store + // potential errors so we can re-throw later, once all operations have + // completed. + let swCleanupError; + try { + await lazy.ServiceWorkerCleanUp.removeFromBaseDomain(aBaseDomain); + } catch (error) { + swCleanupError = error; + } + + await this._qmsClearStoragesForPrincipalsMatching(principal => + hasBaseDomain({ principal }, aBaseDomain) + ); + + // Re-throw any service worker cleanup errors. + if (swCleanupError) { + throw swCleanupError; + } + }, + + async deleteByHost(aHost, aOriginAttributes) { + // XXX: The aOriginAttributes is expected to always be empty({}). Maybe have + // a debug assertion here to ensure that? + + // localStorage: The legacy LocalStorage implementation that will + // eventually be removed depends on this observer notification to clear by + // host. Some other subsystems like Reporting headers depend on this too. + Services.obs.notifyObservers(null, "extension:purge-localStorage", aHost); + + // Clear sessionStorage + Services.obs.notifyObservers(null, "browser:purge-sessionStorage", aHost); + + // ServiceWorkers must be removed before cleaning QuotaManager. We store any + // errors so we can re-throw later once all operations have completed. + let swCleanupError; + try { + await lazy.ServiceWorkerCleanUp.removeFromHost(aHost); + } catch (error) { + swCleanupError = error; + } + + await this._qmsClearStoragesForPrincipalsMatching(principal => { + try { + // deleteByHost has the semantics that "foo.example.com" should be + // wiped if we are provided an aHost of "example.com". + return Services.eTLD.hasRootDomain(principal.host, aHost); + } catch (e) { + // There is no host for the given principal. + return false; + } + }); + + // Re-throw any service worker cleanup errors. + if (swCleanupError) { + throw swCleanupError; + } + }, + + deleteByRange(aFrom, aTo) { + let principals = lazy.sas + .getActiveOrigins(aFrom, aTo) + .QueryInterface(Ci.nsIArray); + + let promises = []; + for (let i = 0; i < principals.length; ++i) { + let principal = principals.queryElementAt(i, Ci.nsIPrincipal); + + if ( + !principal.schemeIs("http") && + !principal.schemeIs("https") && + !principal.schemeIs("file") + ) { + continue; + } + + promises.push(this.deleteByPrincipal(principal)); + } + + return Promise.all(promises); + }, + + deleteByOriginAttributes(aOriginAttributesString) { + // The legacy LocalStorage implementation that will eventually be removed. + // And it should've been cleared while notifying observers with + // clear-origin-attributes-data. + + return lazy.ServiceWorkerCleanUp.removeFromOriginAttributes( + aOriginAttributesString + ) + .then( + _ => /* exceptionThrown = */ false, + _ => /* exceptionThrown = */ true + ) + .then(exceptionThrown => { + // QuotaManager: In the event of a failure, we call reject to propagate + // the error upwards. + return new Promise((aResolve, aReject) => { + let req = Services.qms.clearStoragesForOriginAttributesPattern( + aOriginAttributesString + ); + req.callback = () => { + if (req.resultCode == Cr.NS_OK) { + aResolve(); + } else { + aReject({ message: "Delete by origin attributes failed" }); + } + }; + }); + }); + }, + + async deleteAll() { + // localStorage + Services.obs.notifyObservers(null, "extension:purge-localStorage"); + + // sessionStorage + Services.obs.notifyObservers(null, "browser:purge-sessionStorage"); + + // ServiceWorkers must be removed before cleaning QuotaManager. We store any + // errors so we can re-throw later once all operations have completed. + let swCleanupError; + try { + await lazy.ServiceWorkerCleanUp.removeAll(); + } catch (error) { + swCleanupError = error; + } + + await this._qmsClearStoragesForPrincipalsMatching( + principal => + principal.schemeIs("http") || + principal.schemeIs("https") || + principal.schemeIs("file") + ); + + // Re-throw any service worker cleanup errors. + if (swCleanupError) { + throw swCleanupError; + } + }, + + async cleanupAfterDeletionAtShutdown() { + const storageDir = PathUtils.join( + PathUtils.profileDir, + Services.prefs.getStringPref("dom.quotaManager.storageName") + ); + + if ( + !AppConstants.MOZ_BACKGROUNDTASKS || + !Services.prefs.getBoolPref("dom.quotaManager.backgroundTask.enabled") + ) { + await IOUtils.remove(PathUtils.join(storageDir, "to-be-removed"), { + recursive: true, + }); + return; + } + + const runner = Cc["@mozilla.org/backgroundtasksrunner;1"].getService( + Ci.nsIBackgroundTasksRunner + ); + + runner.removeDirectoryInDetachedProcess( + storageDir, + "to-be-removed", + "0", + "", + "Quota" + ); + }, +}; + +const PredictorNetworkCleaner = { + async deleteAll() { + // Predictive network data - like cache, no way to clear this per + // domain, so just trash it all + let np = Cc["@mozilla.org/network/predictor;1"].getService( + Ci.nsINetworkPredictor + ); + np.reset(); + }, + + // TODO: We should call the NetworkPredictor to clear by principal, rather + // than over-clearing for user requests or bailing out for programmatic calls. + async deleteByPrincipal(aPrincipal, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + // TODO: Same as above, but for base domain. + async deleteByBaseDomain(aBaseDomain, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, +}; + +const PushNotificationsCleaner = { + /** + * Clear entries for aDomain including subdomains of aDomain. + * @param {string} aDomain - Domain to clear data for. + * @returns {Promise} a promise which resolves once data has been cleared. + */ + _deleteByRootDomain(aDomain) { + if (!Services.prefs.getBoolPref("dom.push.enabled", false)) { + return Promise.resolve(); + } + + return new Promise((aResolve, aReject) => { + let push = Cc["@mozilla.org/push/Service;1"].getService( + Ci.nsIPushService + ); + // ClearForDomain also clears subdomains. + push.clearForDomain(aDomain, aStatus => { + if (!Components.isSuccessCode(aStatus)) { + aReject(); + } else { + aResolve(); + } + }); + }); + }, + + deleteByHost(aHost, aOriginAttributes) { + // Will also clear entries for subdomains of aHost. Data is cleared across + // all origin attributes. + return this._deleteByRootDomain(aHost); + }, + + deleteByPrincipal(aPrincipal) { + // Will also clear entries for subdomains of the principal host. Data is + // cleared across all origin attributes. + return this._deleteByRootDomain(aPrincipal.host); + }, + + deleteByBaseDomain(aBaseDomain) { + return this._deleteByRootDomain(aBaseDomain); + }, + + deleteAll() { + if (!Services.prefs.getBoolPref("dom.push.enabled", false)) { + return Promise.resolve(); + } + + return new Promise((aResolve, aReject) => { + let push = Cc["@mozilla.org/push/Service;1"].getService( + Ci.nsIPushService + ); + push.clearForDomain("*", aStatus => { + if (!Components.isSuccessCode(aStatus)) { + aReject(); + } else { + aResolve(); + } + }); + }); + }, +}; + +const StorageAccessCleaner = { + // This is a special function to implement deleteUserInteractionForClearingHistory. + async deleteExceptPrincipals(aPrincipalsWithStorage, aFrom) { + // We compare by base domain in order to simulate the behavior + // from purging, Consider a scenario where the user is logged + // into sub.example.com but the cookies are on example.com. In this + // case, we will remove the user interaction for sub.example.com + // because its principal does not match the one with storage. + let baseDomainsWithStorage = new Set(); + for (let principal of aPrincipalsWithStorage) { + baseDomainsWithStorage.add(principal.baseDomain); + } + for (let perm of Services.perms.getAllByTypeSince( + "storageAccessAPI", + // The permission manager uses milliseconds instead of microseconds + aFrom / 1000 + )) { + if (!baseDomainsWithStorage.has(perm.principal.baseDomain)) { + Services.perms.removePermission(perm); + } + } + }, + + async deleteByPrincipal(aPrincipal) { + return Services.perms.removeFromPrincipal(aPrincipal, "storageAccessAPI"); + }, + + _deleteInternal(filter) { + Services.perms.all + .filter(({ type }) => type == "storageAccessAPI") + .filter(filter) + .forEach(perm => { + try { + Services.perms.removePermission(perm); + } catch (ex) { + console.error(ex); + } + }); + }, + + async deleteByHost(aHost, aOriginAttributes) { + // Clearing by host also clears associated subdomains. + this._deleteInternal(({ principal }) => { + let toBeRemoved = false; + try { + toBeRemoved = Services.eTLD.hasRootDomain(principal.host, aHost); + } catch (ex) {} + return toBeRemoved; + }); + }, + + async deleteByBaseDomain(aBaseDomain) { + this._deleteInternal( + ({ principal }) => principal.baseDomain == aBaseDomain + ); + }, + + async deleteByRange(aFrom, aTo) { + Services.perms.removeByTypeSince("storageAccessAPI", aFrom / 1000); + }, + + async deleteAll() { + Services.perms.removeByType("storageAccessAPI"); + }, +}; + +const HistoryCleaner = { + deleteByHost(aHost, aOriginAttributes) { + if (!AppConstants.MOZ_PLACES) { + return Promise.resolve(); + } + return lazy.PlacesUtils.history.removeByFilter({ host: "." + aHost }); + }, + + deleteByPrincipal(aPrincipal) { + if (!AppConstants.MOZ_PLACES) { + return Promise.resolve(); + } + return lazy.PlacesUtils.history.removeByFilter({ host: aPrincipal.host }); + }, + + deleteByBaseDomain(aBaseDomain) { + return this.deleteByHost(aBaseDomain, {}); + }, + + deleteByRange(aFrom, aTo) { + if (!AppConstants.MOZ_PLACES) { + return Promise.resolve(); + } + return lazy.PlacesUtils.history.removeVisitsByFilter({ + beginDate: new Date(aFrom / 1000), + endDate: new Date(aTo / 1000), + }); + }, + + deleteAll() { + if (!AppConstants.MOZ_PLACES) { + return Promise.resolve(); + } + return lazy.PlacesUtils.history.clear(); + }, +}; + +const SessionHistoryCleaner = { + async deleteByHost(aHost, aOriginAttributes) { + // Session storage and history also clear subdomains of aHost. + Services.obs.notifyObservers(null, "browser:purge-sessionStorage", aHost); + Services.obs.notifyObservers( + null, + "browser:purge-session-history-for-domain", + aHost + ); + }, + + deleteByPrincipal(aPrincipal) { + return this.deleteByHost(aPrincipal.host, aPrincipal.originAttributes); + }, + + deleteByBaseDomain(aBaseDomain) { + return this.deleteByHost(aBaseDomain, {}); + }, + + async deleteByRange(aFrom, aTo) { + Services.obs.notifyObservers( + null, + "browser:purge-session-history", + String(aFrom) + ); + }, + + async deleteAll() { + Services.obs.notifyObservers(null, "browser:purge-session-history"); + }, +}; + +const AuthTokensCleaner = { + // TODO: Bug 1726742 + async deleteByPrincipal(aPrincipal, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + // TODO: Bug 1726742 + async deleteByBaseDomain(aBaseDomain, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + async deleteAll() { + let sdr = Cc["@mozilla.org/security/sdr;1"].getService( + Ci.nsISecretDecoderRing + ); + sdr.logoutAndTeardown(); + }, +}; + +const AuthCacheCleaner = { + // TODO: Bug 1726743 + async deleteByPrincipal(aPrincipal, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + // TODO: Bug 1726743 + async deleteByBaseDomain(aBaseDomain, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + deleteAll() { + return new Promise(aResolve => { + Services.obs.notifyObservers(null, "net:clear-active-logins"); + aResolve(); + }); + }, +}; + +const PermissionsCleaner = { + /** + * Delete permissions by either base domain or host. + * Clearing by host also clears associated subdomains. + * For example, clearing "example.com" will also clear permissions for + * "test.example.com" and "another.test.example.com". + * @param options + * @param {string} options.baseDomain - Base domain to delete permissions for. + * @param {string} options.host - Host to delete permissions for. + */ + async _deleteInternal({ baseDomain, host }) { + for (let perm of Services.perms.all) { + let toBeRemoved; + + if (baseDomain) { + toBeRemoved = perm.principal.baseDomain == baseDomain; + } else { + try { + toBeRemoved = Services.eTLD.hasRootDomain(perm.principal.host, host); + } catch (ex) { + continue; + } + } + + if (!toBeRemoved && perm.type.startsWith("3rdPartyStorage^")) { + let parts = perm.type.split("^"); + let uri; + try { + uri = Services.io.newURI(parts[1]); + } catch (ex) { + continue; + } + + toBeRemoved = Services.eTLD.hasRootDomain(uri.host, baseDomain || host); + } + + if (!toBeRemoved) { + continue; + } + + try { + Services.perms.removePermission(perm); + } catch (ex) { + // Ignore entry + } + } + }, + + deleteByHost(aHost, aOriginAttributes) { + return this._deleteInternal({ host: aHost }); + }, + + deleteByPrincipal(aPrincipal) { + return this.deleteByHost(aPrincipal.host, aPrincipal.originAttributes); + }, + + deleteByBaseDomain(aBaseDomain) { + return this._deleteInternal({ baseDomain: aBaseDomain }); + }, + + async deleteByRange(aFrom, aTo) { + Services.perms.removeAllSince(aFrom / 1000); + }, + + async deleteByOriginAttributes(aOriginAttributesString) { + Services.perms.removePermissionsWithAttributes(aOriginAttributesString); + }, + + async deleteAll() { + Services.perms.removeAll(); + }, +}; + +const PreferencesCleaner = { + deleteByHost(aHost, aOriginAttributes) { + // Also clears subdomains of aHost. + return new Promise((aResolve, aReject) => { + let cps2 = Cc["@mozilla.org/content-pref/service;1"].getService( + Ci.nsIContentPrefService2 + ); + cps2.removeBySubdomain(aHost, null, { + handleCompletion: aReason => { + if (aReason === cps2.COMPLETE_ERROR) { + aReject(); + } else { + aResolve(); + } + }, + handleError() {}, + }); + }); + }, + + deleteByPrincipal(aPrincipal) { + return this.deleteByHost(aPrincipal.host, aPrincipal.originAttributes); + }, + + deleteByBaseDomain(aBaseDomain) { + return this.deleteByHost(aBaseDomain, {}); + }, + + async deleteByRange(aFrom, aTo) { + let cps2 = Cc["@mozilla.org/content-pref/service;1"].getService( + Ci.nsIContentPrefService2 + ); + cps2.removeAllDomainsSince(aFrom / 1000, null); + }, + + async deleteAll() { + let cps2 = Cc["@mozilla.org/content-pref/service;1"].getService( + Ci.nsIContentPrefService2 + ); + cps2.removeAllDomains(null); + }, +}; + +const ClientAuthRememberCleaner = { + async deleteByHost(aHost, aOriginAttributes) { + let cars = Cc[ + "@mozilla.org/security/clientAuthRememberService;1" + ].getService(Ci.nsIClientAuthRememberService); + + cars.deleteDecisionsByHost(aHost, aOriginAttributes); + }, + + deleteByPrincipal(aPrincipal) { + return this.deleteByHost(aPrincipal.host, aPrincipal.originAttributes); + }, + + async deleteByBaseDomain(aDomain) { + let cars = Cc[ + "@mozilla.org/security/clientAuthRememberService;1" + ].getService(Ci.nsIClientAuthRememberService); + + cars + .getDecisions() + .filter(({ asciiHost, entryKey }) => { + // Get the origin attributes which are in the third component of the + // entryKey. ',' is used as the delimiter. + let originSuffixEncoded = entryKey.split(",")[2]; + let originAttributes; + + if (originSuffixEncoded) { + try { + // Decoding the suffix or parsing the origin attributes can fail. In + // this case we won't match the partitionKey, but we can still match + // the asciiHost. + let originSuffix = decodeURIComponent(originSuffixEncoded); + originAttributes = + ChromeUtils.CreateOriginAttributesFromOriginSuffix(originSuffix); + } catch (e) { + console.error(e); + } + } + + return hasBaseDomain( + { + host: asciiHost, + originAttributes, + }, + aDomain + ); + }) + .forEach(({ entryKey }) => cars.forgetRememberedDecision(entryKey)); + }, + + async deleteAll() { + let cars = Cc[ + "@mozilla.org/security/clientAuthRememberService;1" + ].getService(Ci.nsIClientAuthRememberService); + cars.clearRememberedDecisions(); + }, +}; + +const HSTSCleaner = { + async deleteByHost(aHost, aOriginAttributes) { + let sss = Cc["@mozilla.org/ssservice;1"].getService( + Ci.nsISiteSecurityService + ); + let uri = Services.io.newURI("https://" + aHost); + sss.resetState( + uri, + aOriginAttributes, + Ci.nsISiteSecurityService.RootDomain + ); + }, + + deleteByPrincipal(aPrincipal) { + return this.deleteByHost(aPrincipal.host, aPrincipal.originAttributes); + }, + + async deleteByBaseDomain(aDomain) { + let sss = Cc["@mozilla.org/ssservice;1"].getService( + Ci.nsISiteSecurityService + ); + let uri = Services.io.newURI("https://" + aDomain); + sss.resetState(uri, {}, Ci.nsISiteSecurityService.BaseDomain); + }, + + async deleteAll() { + // Clear site security settings - no support for ranges in this + // interface either, so we clearAll(). + let sss = Cc["@mozilla.org/ssservice;1"].getService( + Ci.nsISiteSecurityService + ); + sss.clearAll(); + }, +}; + +const EMECleaner = { + async deleteByHost(aHost, aOriginAttributes) { + let mps = Cc["@mozilla.org/gecko-media-plugin-service;1"].getService( + Ci.mozIGeckoMediaPluginChromeService + ); + mps.forgetThisSite(aHost, JSON.stringify(aOriginAttributes)); + }, + + deleteByPrincipal(aPrincipal) { + return this.deleteByHost(aPrincipal.host, aPrincipal.originAttributes); + }, + + async deleteByBaseDomain(aBaseDomain) { + let mps = Cc["@mozilla.org/gecko-media-plugin-service;1"].getService( + Ci.mozIGeckoMediaPluginChromeService + ); + mps.forgetThisBaseDomain(aBaseDomain); + }, + + deleteAll() { + // Not implemented. + return Promise.resolve(); + }, +}; + +const ReportsCleaner = { + deleteByHost(aHost, aOriginAttributes) { + // Also clears subdomains of aHost. + return new Promise(aResolve => { + Services.obs.notifyObservers(null, "reporting:purge-host", aHost); + aResolve(); + }); + }, + + deleteByPrincipal(aPrincipal) { + return this.deleteByHost(aPrincipal.host, aPrincipal.originAttributes); + }, + + deleteByBaseDomain(aBaseDomain) { + return this.deleteByHost(aBaseDomain, {}); + }, + + deleteAll() { + return new Promise(aResolve => { + Services.obs.notifyObservers(null, "reporting:purge-all"); + aResolve(); + }); + }, +}; + +const ContentBlockingCleaner = { + deleteAll() { + return lazy.TrackingDBService.clearAll(); + }, + + async deleteByPrincipal(aPrincipal, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + async deleteByBaseDomain(aBaseDomain, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + deleteByRange(aFrom, aTo) { + return lazy.TrackingDBService.clearSince(aFrom); + }, +}; + +/** + * The about:home startup cache, if it exists, might contain information + * about where the user has been, or what they've downloaded. + */ +const AboutHomeStartupCacheCleaner = { + async deleteByPrincipal(aPrincipal, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + async deleteByBaseDomain(aBaseDomain, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + deleteAll() { + // This cleaner only makes sense on Firefox desktop, which is the only + // application that uses the about:home startup cache. + if (!AppConstants.MOZ_BUILD_APP == "browser") { + return Promise.resolve(); + } + + return new Promise((aResolve, aReject) => { + let lci = Services.loadContextInfo.default; + let storage = Services.cache2.diskCacheStorage(lci); + let uri = Services.io.newURI("about:home"); + try { + storage.asyncDoomURI(uri, "", { + onCacheEntryDoomed(aResult) { + if ( + Components.isSuccessCode(aResult) || + aResult == Cr.NS_ERROR_NOT_AVAILABLE + ) { + aResolve(); + } else { + aReject({ + message: "asyncDoomURI for about:home failed", + }); + } + }, + }); + } catch (e) { + aReject({ + message: "Failed to doom about:home startup cache entry", + }); + } + }); + }, +}; + +const PreflightCacheCleaner = { + // TODO: Bug 1727141: We should call the cache to clear by principal, rather + // than over-clearing for user requests or bailing out for programmatic calls. + async deleteByPrincipal(aPrincipal, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + // TODO: Bug 1727141 (see deleteByPrincipal). + async deleteByBaseDomain(aBaseDomain, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + await this.deleteAll(); + }, + + async deleteAll() { + Cc[`@mozilla.org/network/protocol;1?name=http`] + .getService(Ci.nsIHttpProtocolHandler) + .clearCORSPreflightCache(); + }, +}; + +const IdentityCredentialStorageCleaner = { + async deleteAll() { + if ( + Services.prefs.getBoolPref( + "dom.security.credentialmanagement.identity.enabled", + false + ) + ) { + lazy.IdentityCredentialStorageService.clear(); + } + }, + + async deleteByPrincipal(aPrincipal, aIsUserRequest) { + if ( + Services.prefs.getBoolPref( + "dom.security.credentialmanagement.identity.enabled", + false + ) + ) { + lazy.IdentityCredentialStorageService.deleteFromPrincipal(aPrincipal); + } + }, + + async deleteByBaseDomain(aBaseDomain, aIsUserRequest) { + if (!aIsUserRequest) { + return; + } + if ( + Services.prefs.getBoolPref( + "dom.security.credentialmanagement.identity.enabled", + false + ) + ) { + lazy.IdentityCredentialStorageService.deleteFromBaseDomain(aBaseDomain); + } + }, + + async deleteByRange(aFrom, aTo) { + if ( + Services.prefs.getBoolPref( + "dom.security.credentialmanagement.identity.enabled", + false + ) + ) { + lazy.IdentityCredentialStorageService.deleteFromTimeRange(aFrom, aTo); + } + }, + + async deleteByHost(aHost, aOriginAttributes) { + if ( + Services.prefs.getBoolPref( + "dom.security.credentialmanagement.identity.enabled", + false + ) + ) { + // Delete data from both HTTP and HTTPS sites. + let httpURI = Services.io.newURI("http://" + aHost); + let httpsURI = Services.io.newURI("https://" + aHost); + let httpPrincipal = Services.scriptSecurityManager.createContentPrincipal( + httpURI, + aOriginAttributes + ); + let httpsPrincipal = + Services.scriptSecurityManager.createContentPrincipal( + httpsURI, + aOriginAttributes + ); + lazy.IdentityCredentialStorageService.deleteFromPrincipal(httpPrincipal); + lazy.IdentityCredentialStorageService.deleteFromPrincipal(httpsPrincipal); + } + }, + + async deleteByOriginAttributes(aOriginAttributesString) { + if ( + Services.prefs.getBoolPref( + "dom.security.credentialmanagement.identity.enabled", + false + ) + ) { + lazy.IdentityCredentialStorageService.deleteFromOriginAttributesPattern( + aOriginAttributesString + ); + } + }, +}; + +// Here the map of Flags-Cleaners. +const FLAGS_MAP = [ + { + flag: Ci.nsIClearDataService.CLEAR_CERT_EXCEPTIONS, + cleaners: [CertCleaner], + }, + + { flag: Ci.nsIClearDataService.CLEAR_COOKIES, cleaners: [CookieCleaner] }, + + { + flag: Ci.nsIClearDataService.CLEAR_NETWORK_CACHE, + cleaners: [NetworkCacheCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_IMAGE_CACHE, + cleaners: [ImageCacheCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_CSS_CACHE, + cleaners: [CSSCacheCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_CLIENT_AUTH_REMEMBER_SERVICE, + cleaners: [ClientAuthRememberCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_DOWNLOADS, + cleaners: [DownloadsCleaner, AboutHomeStartupCacheCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_PASSWORDS, + cleaners: [PasswordsCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_MEDIA_DEVICES, + cleaners: [MediaDevicesCleaner], + }, + + { flag: Ci.nsIClearDataService.CLEAR_DOM_QUOTA, cleaners: [QuotaCleaner] }, + + { + flag: Ci.nsIClearDataService.CLEAR_PREDICTOR_NETWORK_DATA, + cleaners: [PredictorNetworkCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_DOM_PUSH_NOTIFICATIONS, + cleaners: [PushNotificationsCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_HISTORY, + cleaners: [HistoryCleaner, AboutHomeStartupCacheCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_SESSION_HISTORY, + cleaners: [SessionHistoryCleaner, AboutHomeStartupCacheCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_AUTH_TOKENS, + cleaners: [AuthTokensCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_AUTH_CACHE, + cleaners: [AuthCacheCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_PERMISSIONS, + cleaners: [PermissionsCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_CONTENT_PREFERENCES, + cleaners: [PreferencesCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_HSTS, + cleaners: [HSTSCleaner], + }, + + { flag: Ci.nsIClearDataService.CLEAR_EME, cleaners: [EMECleaner] }, + + { flag: Ci.nsIClearDataService.CLEAR_REPORTS, cleaners: [ReportsCleaner] }, + + { + flag: Ci.nsIClearDataService.CLEAR_STORAGE_ACCESS, + cleaners: [StorageAccessCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_CONTENT_BLOCKING_RECORDS, + cleaners: [ContentBlockingCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_PREFLIGHT_CACHE, + cleaners: [PreflightCacheCleaner], + }, + + { + flag: Ci.nsIClearDataService.CLEAR_CREDENTIAL_MANAGER_STATE, + cleaners: [IdentityCredentialStorageCleaner], + }, +]; + +export function ClearDataService() { + this._initialize(); +} + +ClearDataService.prototype = Object.freeze({ + classID: Components.ID("{0c06583d-7dd8-4293-b1a5-912205f779aa}"), + QueryInterface: ChromeUtils.generateQI(["nsIClearDataService"]), + + _initialize() { + // Let's start all the service we need to cleanup data. + + // This is mainly needed for GeckoView that doesn't start QMS on startup + // time. + if (!Services.qms) { + console.error("Failed initializiation of QuotaManagerService."); + } + }, + + deleteDataFromLocalFiles(aIsUserRequest, aFlags, aCallback) { + if (!aCallback) { + return Cr.NS_ERROR_INVALID_ARG; + } + + return this._deleteInternal(aFlags, aCallback, aCleaner => { + // Some of the 'Cleaners' do not support clearing data for + // local files. Ignore those. + if (aCleaner.deleteByLocalFiles) { + // A generic originAttributes dictionary. + return aCleaner.deleteByLocalFiles({}); + } + return Promise.resolve(); + }); + }, + + deleteDataFromHost(aHost, aIsUserRequest, aFlags, aCallback) { + if (!aHost || !aCallback) { + return Cr.NS_ERROR_INVALID_ARG; + } + + return this._deleteInternal(aFlags, aCallback, aCleaner => { + // Some of the 'Cleaners' do not support to delete by principal. Let's + // use deleteAll() as fallback. + if (aCleaner.deleteByHost) { + // A generic originAttributes dictionary. + return aCleaner.deleteByHost(aHost, {}); + } + // The user wants to delete data. Let's remove as much as we can. + if (aIsUserRequest) { + return aCleaner.deleteAll(); + } + // We don't want to delete more than what is strictly required. + return Promise.resolve(); + }); + }, + + deleteDataFromBaseDomain(aDomainOrHost, aIsUserRequest, aFlags, aCallback) { + if (!aDomainOrHost || !aCallback) { + return Cr.NS_ERROR_INVALID_ARG; + } + // We may throw here if aDomainOrHost can't be converted to a base domain. + let baseDomain = Services.eTLD.getBaseDomainFromHost(aDomainOrHost); + + return this._deleteInternal(aFlags, aCallback, aCleaner => + aCleaner.deleteByBaseDomain(baseDomain, aIsUserRequest) + ); + }, + + deleteDataFromPrincipal(aPrincipal, aIsUserRequest, aFlags, aCallback) { + if (!aPrincipal || !aCallback) { + return Cr.NS_ERROR_INVALID_ARG; + } + + return this._deleteInternal(aFlags, aCallback, aCleaner => + aCleaner.deleteByPrincipal(aPrincipal, aIsUserRequest) + ); + }, + + deleteDataInTimeRange(aFrom, aTo, aIsUserRequest, aFlags, aCallback) { + if (aFrom > aTo || !aCallback) { + return Cr.NS_ERROR_INVALID_ARG; + } + + return this._deleteInternal(aFlags, aCallback, aCleaner => { + // Some of the 'Cleaners' do not support to delete by range. Let's use + // deleteAll() as fallback. + if (aCleaner.deleteByRange) { + return aCleaner.deleteByRange(aFrom, aTo); + } + // The user wants to delete data. Let's remove as much as we can. + if (aIsUserRequest) { + return aCleaner.deleteAll(); + } + // We don't want to delete more than what is strictly required. + return Promise.resolve(); + }); + }, + + deleteData(aFlags, aCallback) { + if (!aCallback) { + return Cr.NS_ERROR_INVALID_ARG; + } + + return this._deleteInternal(aFlags, aCallback, aCleaner => { + return aCleaner.deleteAll(); + }); + }, + + deleteDataFromOriginAttributesPattern(aPattern, aCallback) { + if (!aPattern) { + return Cr.NS_ERROR_INVALID_ARG; + } + + let patternString = JSON.stringify(aPattern); + // XXXtt remove clear-origin-attributes-data entirely + Services.obs.notifyObservers( + null, + "clear-origin-attributes-data", + patternString + ); + + if (!aCallback) { + aCallback = { + onDataDeleted: () => {}, + }; + } + return this._deleteInternal( + Ci.nsIClearDataService.CLEAR_ALL, + aCallback, + aCleaner => { + if (aCleaner.deleteByOriginAttributes) { + return aCleaner.deleteByOriginAttributes(patternString); + } + + // We don't want to delete more than what is strictly required. + return Promise.resolve(); + } + ); + }, + + deleteUserInteractionForClearingHistory( + aPrincipalsWithStorage, + aFrom, + aCallback + ) { + if (!aCallback) { + return Cr.NS_ERROR_INVALID_ARG; + } + + StorageAccessCleaner.deleteExceptPrincipals( + aPrincipalsWithStorage, + aFrom + ).then(() => { + aCallback.onDataDeleted(0); + }); + return Cr.NS_OK; + }, + + cleanupAfterDeletionAtShutdown(aFlags, aCallback) { + return this._deleteInternal(aFlags, aCallback, async aCleaner => { + if (aCleaner.cleanupAfterDeletionAtShutdown) { + await aCleaner.cleanupAfterDeletionAtShutdown(); + } + }); + }, + + // This internal method uses aFlags against FLAGS_MAP in order to retrieve a + // list of 'Cleaners'. For each of them, the aHelper callback retrieves a + // promise object. All these promise objects are resolved before calling + // onDataDeleted. + _deleteInternal(aFlags, aCallback, aHelper) { + let resultFlags = 0; + let promises = FLAGS_MAP.filter(c => aFlags & c.flag).map(c => { + return Promise.all( + c.cleaners.map(cleaner => { + return aHelper(cleaner).catch(e => { + console.error(e); + resultFlags |= c.flag; + }); + }) + ); + // Let's collect the failure in resultFlags. + }); + Promise.all(promises).then(() => { + aCallback.onDataDeleted(resultFlags); + }); + return Cr.NS_OK; + }, +}); |