diff options
Diffstat (limited to 'toolkit/components/extensions/ExtensionParent.sys.mjs')
| -rw-r--r-- | toolkit/components/extensions/ExtensionParent.sys.mjs | 2331 |
1 files changed, 2331 insertions, 0 deletions
diff --git a/toolkit/components/extensions/ExtensionParent.sys.mjs b/toolkit/components/extensions/ExtensionParent.sys.mjs new file mode 100644 index 0000000000..13125f7a4b --- /dev/null +++ b/toolkit/components/extensions/ExtensionParent.sys.mjs @@ -0,0 +1,2331 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +/* 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/. */ + +/** + * This module contains code for managing APIs that need to run in the + * parent process, and handles the parent side of operations that need + * to be proxied from ExtensionChild.jsm. + */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + AddonManager: "resource://gre/modules/AddonManager.sys.mjs", + AsyncShutdown: "resource://gre/modules/AsyncShutdown.sys.mjs", + BroadcastConduit: "resource://gre/modules/ConduitsParent.sys.mjs", + DeferredTask: "resource://gre/modules/DeferredTask.sys.mjs", + DevToolsShim: "chrome://devtools-startup/content/DevToolsShim.sys.mjs", + ExtensionActivityLog: "resource://gre/modules/ExtensionActivityLog.sys.mjs", + ExtensionData: "resource://gre/modules/Extension.sys.mjs", + GeckoViewConnection: "resource://gre/modules/GeckoViewWebExtension.sys.mjs", + MessageManagerProxy: "resource://gre/modules/MessageManagerProxy.sys.mjs", + NativeApp: "resource://gre/modules/NativeMessaging.sys.mjs", + PerformanceCounters: "resource://gre/modules/PerformanceCounters.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", + Schemas: "resource://gre/modules/Schemas.sys.mjs", + getErrorNameForTelemetry: "resource://gre/modules/ExtensionTelemetry.sys.mjs", +}); + +XPCOMUtils.defineLazyServiceGetters(lazy, { + aomStartup: [ + "@mozilla.org/addons/addon-manager-startup;1", + "amIAddonManagerStartup", + ], +}); + +// We're using the pref to avoid loading PerformanceCounters.jsm for nothing. +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "gTimingEnabled", + "extensions.webextensions.enablePerformanceCounters", + false +); +import { ExtensionCommon } from "resource://gre/modules/ExtensionCommon.sys.mjs"; +import { ExtensionUtils } from "resource://gre/modules/ExtensionUtils.sys.mjs"; + +const DUMMY_PAGE_URI = Services.io.newURI( + "chrome://extensions/content/dummy.xhtml" +); + +var { BaseContext, CanOfAPIs, SchemaAPIManager, SpreadArgs, defineLazyGetter } = + ExtensionCommon; + +var { + DefaultMap, + DefaultWeakMap, + ExtensionError, + promiseDocumentLoaded, + promiseEvent, + promiseObserved, +} = ExtensionUtils; + +const ERROR_NO_RECEIVERS = + "Could not establish connection. Receiving end does not exist."; + +const BASE_SCHEMA = "chrome://extensions/content/schemas/manifest.json"; +const CATEGORY_EXTENSION_MODULES = "webextension-modules"; +const CATEGORY_EXTENSION_SCHEMAS = "webextension-schemas"; +const CATEGORY_EXTENSION_SCRIPTS = "webextension-scripts"; + +let schemaURLs = new Set(); + +schemaURLs.add("chrome://extensions/content/schemas/experiments.json"); + +let GlobalManager; +let ParentAPIManager; +let StartupCache; + +function verifyActorForContext(actor, context) { + if (JSWindowActorParent.isInstance(actor)) { + let target = actor.browsingContext.top.embedderElement; + if (context.parentMessageManager !== target.messageManager) { + throw new Error("Got message on unexpected message manager"); + } + } else if (JSProcessActorParent.isInstance(actor)) { + if (actor.manager.remoteType !== context.extension.remoteType) { + throw new Error("Got message from unexpected process"); + } + } +} + +// This object loads the ext-*.js scripts that define the extension API. +let apiManager = new (class extends SchemaAPIManager { + constructor() { + super("main", lazy.Schemas); + this.initialized = null; + + /* eslint-disable mozilla/balanced-listeners */ + this.on("startup", (e, extension) => { + return extension.apiManager.onStartup(extension); + }); + + this.on("update", async (e, { id, resourceURI, isPrivileged }) => { + let modules = this.eventModules.get("update"); + if (modules.size == 0) { + return; + } + + let extension = new lazy.ExtensionData(resourceURI, isPrivileged); + await extension.loadManifest(); + + return Promise.all( + Array.from(modules).map(async apiName => { + let module = await this.asyncLoadModule(apiName); + module.onUpdate(id, extension.manifest); + }) + ); + }); + + this.on("uninstall", (e, { id }) => { + let modules = this.eventModules.get("uninstall"); + return Promise.all( + Array.from(modules).map(async apiName => { + let module = await this.asyncLoadModule(apiName); + return module.onUninstall(id); + }) + ); + }); + /* eslint-enable mozilla/balanced-listeners */ + + // Handle any changes that happened during startup + let disabledIds = lazy.AddonManager.getStartupChanges( + lazy.AddonManager.STARTUP_CHANGE_DISABLED + ); + if (disabledIds.length) { + this._callHandlers(disabledIds, "disable", "onDisable"); + } + + let uninstalledIds = lazy.AddonManager.getStartupChanges( + lazy.AddonManager.STARTUP_CHANGE_UNINSTALLED + ); + if (uninstalledIds.length) { + this._callHandlers(uninstalledIds, "uninstall", "onUninstall"); + } + } + + getModuleJSONURLs() { + return Array.from( + Services.catMan.enumerateCategory(CATEGORY_EXTENSION_MODULES), + ({ value }) => value + ); + } + + // Loads all the ext-*.js scripts currently registered. + lazyInit() { + if (this.initialized) { + return this.initialized; + } + + let modulesPromise = StartupCache.other.get(["parentModules"], () => + this.loadModuleJSON(this.getModuleJSONURLs()) + ); + + let scriptURLs = []; + for (let { value } of Services.catMan.enumerateCategory( + CATEGORY_EXTENSION_SCRIPTS + )) { + scriptURLs.push(value); + } + + let promise = (async () => { + let scripts = await Promise.all( + scriptURLs.map(url => ChromeUtils.compileScript(url)) + ); + + this.initModuleData(await modulesPromise); + + this.initGlobal(); + for (let script of scripts) { + script.executeInGlobal(this.global); + } + + // Load order matters here. The base manifest defines types which are + // extended by other schemas, so needs to be loaded first. + return lazy.Schemas.load(BASE_SCHEMA).then(() => { + let promises = []; + for (let { value } of Services.catMan.enumerateCategory( + CATEGORY_EXTENSION_SCHEMAS + )) { + promises.push(lazy.Schemas.load(value)); + } + for (let [url, { content }] of this.schemaURLs) { + promises.push(lazy.Schemas.load(url, content)); + } + for (let url of schemaURLs) { + promises.push(lazy.Schemas.load(url)); + } + return Promise.all(promises).then(() => { + lazy.Schemas.updateSharedSchemas(); + }); + }); + })(); + + Services.mm.addMessageListener("Extension:GetFrameData", this); + + this.initialized = promise; + return this.initialized; + } + + receiveMessage({ target }) { + let data = GlobalManager.frameData.get(target) || {}; + Object.assign(data, this.global.tabTracker.getBrowserData(target)); + return data; + } + + // Call static handlers for the given event on the given extension ids, + // and set up a shutdown blocker to ensure they all complete. + _callHandlers(ids, event, method) { + let promises = Array.from(this.eventModules.get(event)) + .map(async modName => { + let module = await this.asyncLoadModule(modName); + return ids.map(id => module[method](id)); + }) + .flat(); + if (event === "disable") { + promises.push(...ids.map(id => this.emit("disable", id))); + } + if (event === "enabling") { + promises.push(...ids.map(id => this.emit("enabling", id))); + } + + lazy.AsyncShutdown.profileBeforeChange.addBlocker( + `Extension API ${event} handlers for ${ids.join(",")}`, + Promise.all(promises) + ); + } +})(); + +// Receives messages related to the extension messaging API and forwards them +// to relevant child messengers. Also handles Native messaging and GeckoView. +const ProxyMessenger = { + /** + * @typedef {object} ParentPort + * @property {function(StructuredCloneHolder)} onPortMessage + * @property {function()} onPortDisconnect + */ + + /** @type {Map<number, ParentPort>} */ + ports: new Map(), + + init() { + this.conduit = new lazy.BroadcastConduit(ProxyMessenger, { + id: "ProxyMessenger", + reportOnClosed: "portId", + recv: ["PortConnect", "PortMessage", "NativeMessage", "RuntimeMessage"], + cast: ["PortConnect", "PortMessage", "PortDisconnect", "RuntimeMessage"], + }); + }, + + openNative(nativeApp, sender) { + let context = ParentAPIManager.getContextById(sender.childId); + if (context.extension.hasPermission("geckoViewAddons")) { + return new lazy.GeckoViewConnection( + this.getSender(context.extension, sender), + sender.actor.browsingContext.top.embedderElement, + nativeApp, + context.extension.hasPermission("nativeMessagingFromContent") + ); + } else if (sender.verified) { + return new lazy.NativeApp(context, nativeApp); + } + sender = this.getSender(context.extension, sender); + throw new Error(`Native messaging not allowed: ${JSON.stringify(sender)}`); + }, + + recvNativeMessage({ nativeApp, holder }, { sender }) { + const app = this.openNative(nativeApp, sender); + + // Track in-flight NativeApp sendMessage requests as + // a NativeApp port destroyed when the request + // has been handled. + const promiseSendMessage = app.sendMessage(holder); + const sendMessagePort = { + native: true, + senderChildId: sender.childId, + }; + this.trackNativeAppPort(sendMessagePort); + const untrackSendMessage = () => this.untrackNativeAppPort(sendMessagePort); + promiseSendMessage.then(untrackSendMessage, untrackSendMessage); + + return promiseSendMessage; + }, + + getSender(extension, source) { + let sender = { + contextId: source.id, + id: source.extensionId, + envType: source.envType, + url: source.url, + }; + + if (JSWindowActorParent.isInstance(source.actor)) { + let browser = source.actor.browsingContext.top.embedderElement; + let data = + browser && apiManager.global.tabTracker.getBrowserData(browser); + if (data?.tabId > 0) { + sender.tab = extension.tabManager.get(data.tabId, null)?.convert(); + // frameId is documented to only be set if sender.tab is set. + sender.frameId = source.frameId; + } + } + + return sender; + }, + + getTopBrowsingContextId(tabId) { + // If a tab alredy has content scripts, no need to check private browsing. + let tab = apiManager.global.tabTracker.getTab(tabId, null); + if (!tab || (tab.browser || tab).getAttribute("pending") === "true") { + // No receivers in discarded tabs, so bail early to keep the browser lazy. + throw new ExtensionError(ERROR_NO_RECEIVERS); + } + let browser = tab.linkedBrowser || tab.browser; + return browser.browsingContext.id; + }, + + // TODO: Rework/simplify this and getSender/getTopBC after bug 1580766. + async normalizeArgs(arg, sender) { + arg.extensionId = arg.extensionId || sender.extensionId; + let extension = GlobalManager.extensionMap.get(arg.extensionId); + if (!extension) { + return Promise.reject({ message: ERROR_NO_RECEIVERS }); + } + await extension.wakeupBackground?.(); + + arg.sender = this.getSender(extension, sender); + arg.topBC = arg.tabId && this.getTopBrowsingContextId(arg.tabId); + return arg.tabId ? "tab" : "messenger"; + }, + + async recvRuntimeMessage(arg, { sender }) { + arg.firstResponse = true; + let kind = await this.normalizeArgs(arg, sender); + let result = await this.conduit.castRuntimeMessage(kind, arg); + if (!result) { + // "throw new ExtensionError" cannot be used because then the stack of the + // sendMessage call would not be added to the error object generated by + // context.normalizeError. Test coverage by test_ext_error_location.js. + return Promise.reject({ message: ERROR_NO_RECEIVERS }); + } + return result.value; + }, + + async recvPortConnect(arg, { sender }) { + if (arg.native) { + let port = this.openNative(arg.name, sender).onConnect(arg.portId, this); + port.senderChildId = sender.childId; + port.native = true; + this.ports.set(arg.portId, port); + this.trackNativeAppPort(port); + return; + } + + // PortMessages that follow will need to wait for the port to be opened. + let resolvePort; + this.ports.set(arg.portId, new Promise(res => (resolvePort = res))); + + let kind = await this.normalizeArgs(arg, sender); + let all = await this.conduit.castPortConnect(kind, arg); + resolvePort(); + + // If there are no active onConnect listeners. + if (!all.some(x => x.value)) { + throw new ExtensionError(ERROR_NO_RECEIVERS); + } + }, + + async recvPortMessage({ holder }, { sender }) { + if (sender.native) { + // If the nativeApp port connect fails (e.g. if triggered by a content + // script), the portId may not be in the map (because it did throw in + // the openNative method). + return this.ports.get(sender.portId)?.onPortMessage(holder); + } + // NOTE: the following await make sure we await for promised ports + // (ports that were not yet open when added to the Map, + // see recvPortConnect). + await this.ports.get(sender.portId); + this.sendPortMessage(sender.portId, holder, !sender.source); + }, + + recvConduitClosed(sender) { + let app = this.ports.get(sender.portId); + if (this.ports.delete(sender.portId) && sender.native) { + this.untrackNativeAppPort(app); + return app.onPortDisconnect(); + } + this.sendPortDisconnect(sender.portId, null, !sender.source); + }, + + sendPortMessage(portId, holder, source = true) { + this.conduit.castPortMessage("port", { portId, source, holder }); + }, + + sendPortDisconnect(portId, error, source = true) { + let port = this.ports.get(portId); + this.untrackNativeAppPort(port); + this.conduit.castPortDisconnect("port", { portId, source, error }); + this.ports.delete(portId); + }, + + trackNativeAppPort(port) { + if (!port?.native) { + return; + } + + try { + let context = ParentAPIManager.getContextById(port.senderChildId); + context?.trackNativeAppPort(port); + } catch { + // getContextById will throw if the context has been destroyed + // in the meantime. + } + }, + + untrackNativeAppPort(port) { + if (!port?.native) { + return; + } + + try { + let context = ParentAPIManager.getContextById(port.senderChildId); + context?.untrackNativeAppPort(port); + } catch { + // getContextById will throw if the context has been destroyed + // in the meantime. + } + }, +}; +ProxyMessenger.init(); + +// Responsible for loading extension APIs into the right globals. +GlobalManager = { + // Map[extension ID -> Extension]. Determines which extension is + // responsible for content under a particular extension ID. + extensionMap: new Map(), + initialized: false, + + /** @type {WeakMap<Browser, object>} Extension Context init data. */ + frameData: new WeakMap(), + + init(extension) { + if (this.extensionMap.size == 0) { + apiManager.on("extension-browser-inserted", this._onExtensionBrowser); + this.initialized = true; + Services.ppmm.addMessageListener( + "Extension:SendPerformanceCounter", + this + ); + } + this.extensionMap.set(extension.id, extension); + }, + + uninit(extension) { + this.extensionMap.delete(extension.id); + + if (this.extensionMap.size == 0 && this.initialized) { + apiManager.off("extension-browser-inserted", this._onExtensionBrowser); + this.initialized = false; + Services.ppmm.removeMessageListener( + "Extension:SendPerformanceCounter", + this + ); + } + }, + + async receiveMessage({ name, data }) { + switch (name) { + case "Extension:SendPerformanceCounter": + lazy.PerformanceCounters.merge(data.counters); + break; + } + }, + + _onExtensionBrowser(type, browser, data = {}) { + data.viewType = browser.getAttribute("webextension-view-type"); + if (data.viewType) { + GlobalManager.frameData.set(browser, data); + } + }, + + getExtension(extensionId) { + return this.extensionMap.get(extensionId); + }, +}; + +/** + * The proxied parent side of a context in ExtensionChild.jsm, for the + * parent side of a proxied API. + */ +class ProxyContextParent extends BaseContext { + constructor(envType, extension, params, xulBrowser, principal) { + super(envType, extension); + + this.childId = params.childId; + this.uri = Services.io.newURI(params.url); + + this.incognito = params.incognito; + + this.listenerPromises = new Set(); + + // This message manager is used by ParentAPIManager to send messages and to + // close the ProxyContext if the underlying message manager closes. This + // message manager object may change when `xulBrowser` swaps docshells, e.g. + // when a tab is moved to a different window. + this.messageManagerProxy = + xulBrowser && new lazy.MessageManagerProxy(xulBrowser); + + Object.defineProperty(this, "principal", { + value: principal, + enumerable: true, + configurable: true, + }); + + this.listenerProxies = new Map(); + + this.pendingEventBrowser = null; + this.callContextData = null; + + // Set of active NativeApp ports. + this.activeNativePorts = new WeakSet(); + + // Set of pending queryRunListener promises. + this.runListenerPromises = new Set(); + + apiManager.emit("proxy-context-load", this); + } + + get isProxyContextParent() { + return true; + } + + trackRunListenerPromise(runListenerPromise) { + if ( + // The extension was already shutdown. + !this.extension || + // Not a non persistent background script context. + !this.isBackgroundContext || + this.extension.persistentBackground + ) { + return; + } + const clearFromSet = () => + this.runListenerPromises.delete(runListenerPromise); + runListenerPromise.then(clearFromSet, clearFromSet); + this.runListenerPromises.add(runListenerPromise); + } + + clearPendingRunListenerPromises() { + this.runListenerPromises.clear(); + } + + get pendingRunListenerPromisesCount() { + return this.runListenerPromises.size; + } + + trackNativeAppPort(port) { + if ( + // Not a native port. + !port?.native || + // Not a non persistent background script context. + !this.isBackgroundContext || + this.extension?.persistentBackground || + // The extension was already shutdown. + !this.extension + ) { + return; + } + this.activeNativePorts.add(port); + } + + untrackNativeAppPort(port) { + this.activeNativePorts.delete(port); + } + + get hasActiveNativeAppPorts() { + return !!ChromeUtils.nondeterministicGetWeakSetKeys(this.activeNativePorts) + .length; + } + + /** + * Call the `callable` parameter with `context.callContextData` set to the value passed + * as the first parameter of this method. + * + * `context.callContextData` is expected to: + * - don't be set when context.withCallContextData is being called + * - be set back to null right after calling the `callable` function, without + * awaiting on any async code that the function may be running internally + * + * The callable method itself is responsabile of eventually retrieve the value initially set + * on the `context.callContextData` before any code executed asynchronously (e.g. from a + * callback or after awaiting internally on a promise if the `callable` function was async). + * + * @param {object} callContextData + * @param {boolean} callContextData.isHandlingUserInput + * @param {Function} callable + * + * @returns {any} Returns the value returned by calling the `callable` method. + */ + withCallContextData({ isHandlingUserInput }, callable) { + if (this.callContextData) { + Cu.reportError( + `Unexpected pre-existing callContextData on "${this.extension?.policy.debugName}" contextId ${this.contextId}` + ); + } + + try { + this.callContextData = { + isHandlingUserInput, + }; + return callable(); + } finally { + this.callContextData = null; + } + } + + async withPendingBrowser(browser, callable) { + let savedBrowser = this.pendingEventBrowser; + this.pendingEventBrowser = browser; + try { + let result = await callable(); + return result; + } finally { + this.pendingEventBrowser = savedBrowser; + } + } + + logActivity(type, name, data) { + // The base class will throw so we catch any subclasses that do not implement. + // We do not want to throw here, but we also do not log here. + } + + get cloneScope() { + return this.sandbox; + } + + applySafe(callback, args) { + // There's no need to clone when calling listeners for a proxied + // context. + return this.applySafeWithoutClone(callback, args); + } + + get xulBrowser() { + return this.messageManagerProxy?.eventTarget; + } + + get parentMessageManager() { + return this.messageManagerProxy?.messageManager; + } + + shutdown() { + this.unload(); + } + + unload() { + if (this.unloaded) { + return; + } + + this.messageManagerProxy?.dispose(); + + super.unload(); + apiManager.emit("proxy-context-unload", this); + } +} + +defineLazyGetter(ProxyContextParent.prototype, "apiCan", function () { + let obj = {}; + let can = new CanOfAPIs(this, this.extension.apiManager, obj); + return can; +}); + +defineLazyGetter(ProxyContextParent.prototype, "apiObj", function () { + return this.apiCan.root; +}); + +defineLazyGetter(ProxyContextParent.prototype, "sandbox", function () { + // NOTE: the required Blob and URL globals are used in the ext-registerContentScript.js + // API module to convert JS and CSS data into blob URLs. + return Cu.Sandbox(this.principal, { + sandboxName: this.uri.spec, + wantGlobalProperties: ["Blob", "URL"], + }); +}); + +/** + * The parent side of proxied API context for extension content script + * running in ExtensionContent.jsm. + */ +class ContentScriptContextParent extends ProxyContextParent {} + +/** + * The parent side of proxied API context for extension page, such as a + * background script, a tab page, or a popup, running in + * ExtensionChild.jsm. + */ +class ExtensionPageContextParent extends ProxyContextParent { + constructor(envType, extension, params, xulBrowser) { + super(envType, extension, params, xulBrowser, extension.principal); + + this.viewType = params.viewType; + + this.extension.views.add(this); + + extension.emit("extension-proxy-context-load", this); + } + + // The window that contains this context. This may change due to moving tabs. + get appWindow() { + let win = this.xulBrowser.ownerGlobal; + return win.browsingContext.topChromeWindow; + } + + get currentWindow() { + if (this.viewType !== "background") { + return this.appWindow; + } + } + + get tabId() { + let { tabTracker } = apiManager.global; + let data = tabTracker.getBrowserData(this.xulBrowser); + if (data.tabId >= 0) { + return data.tabId; + } + } + + onBrowserChange(browser) { + super.onBrowserChange(browser); + this.xulBrowser = browser; + } + + unload() { + super.unload(); + this.extension.views.delete(this); + } + + shutdown() { + apiManager.emit("page-shutdown", this); + super.shutdown(); + } +} + +/** + * The parent side of proxied API context for devtools extension page, such as a + * devtools pages and panels running in ExtensionChild.jsm. + */ +class DevToolsExtensionPageContextParent extends ExtensionPageContextParent { + constructor(...params) { + super(...params); + + // Set all attributes that are lazily defined to `null` here. + // + // Note that we can't do that for `this._devToolsToolbox` because it will + // be defined when calling our parent constructor and so would override it back to `null`. + this._devToolsCommands = null; + this._onNavigatedListeners = null; + + this._onResourceAvailable = this._onResourceAvailable.bind(this); + } + + set devToolsToolbox(toolbox) { + if (this._devToolsToolbox) { + throw new Error("Cannot set the context DevTools toolbox twice"); + } + + this._devToolsToolbox = toolbox; + } + + get devToolsToolbox() { + return this._devToolsToolbox; + } + + async addOnNavigatedListener(listener) { + if (!this._onNavigatedListeners) { + this._onNavigatedListeners = new Set(); + + await this.devToolsToolbox.resourceCommand.watchResources( + [this.devToolsToolbox.resourceCommand.TYPES.DOCUMENT_EVENT], + { + onAvailable: this._onResourceAvailable, + ignoreExistingResources: true, + } + ); + } + + this._onNavigatedListeners.add(listener); + } + + removeOnNavigatedListener(listener) { + if (this._onNavigatedListeners) { + this._onNavigatedListeners.delete(listener); + } + } + + /** + * The returned "commands" object, exposing modules implemented from devtools/shared/commands. + * Each attribute being a static interface to communicate with the server backend. + * + * @returns {Promise<object>} + */ + async getDevToolsCommands() { + // Ensure that we try to instantiate a commands only once, + // even if createCommandsForTabForWebExtension is async. + if (this._devToolsCommandsPromise) { + return this._devToolsCommandsPromise; + } + if (this._devToolsCommands) { + return this._devToolsCommands; + } + + this._devToolsCommandsPromise = (async () => { + const commands = + await lazy.DevToolsShim.createCommandsForTabForWebExtension( + this.devToolsToolbox.commands.descriptorFront.localTab + ); + await commands.targetCommand.startListening(); + this._devToolsCommands = commands; + this._devToolsCommandsPromise = null; + return commands; + })(); + return this._devToolsCommandsPromise; + } + + unload() { + // Bail if the toolbox reference was already cleared. + if (!this.devToolsToolbox) { + return; + } + + if (this._onNavigatedListeners) { + this.devToolsToolbox.resourceCommand.unwatchResources( + [this.devToolsToolbox.resourceCommand.TYPES.DOCUMENT_EVENT], + { onAvailable: this._onResourceAvailable } + ); + } + + if (this._devToolsCommands) { + this._devToolsCommands.destroy(); + this._devToolsCommands = null; + } + + if (this._onNavigatedListeners) { + this._onNavigatedListeners.clear(); + this._onNavigatedListeners = null; + } + + this._devToolsToolbox = null; + + super.unload(); + } + + async _onResourceAvailable(resources) { + for (const resource of resources) { + const { targetFront } = resource; + if (targetFront.isTopLevel && resource.name === "dom-complete") { + for (const listener of this._onNavigatedListeners) { + listener(targetFront.url); + } + } + } + } +} + +/** + * The parent side of proxied API context for extension background service + * worker script. + */ +class BackgroundWorkerContextParent extends ProxyContextParent { + constructor(envType, extension, params) { + // TODO: split out from ProxyContextParent a base class that + // doesn't expect a xulBrowser and one for contexts that are + // expected to have a xulBrowser associated. + super(envType, extension, params, null, extension.principal); + + this.viewType = params.viewType; + this.workerDescriptorId = params.workerDescriptorId; + + this.extension.views.add(this); + + extension.emit("extension-proxy-context-load", this); + } +} + +ParentAPIManager = { + proxyContexts: new Map(), + + init() { + // TODO: Bug 1595186 - remove/replace all usage of MessageManager below. + Services.obs.addObserver(this, "message-manager-close"); + + this.conduit = new lazy.BroadcastConduit(this, { + id: "ParentAPIManager", + reportOnClosed: "childId", + recv: [ + "CreateProxyContext", + "ContextLoaded", + "APICall", + "AddListener", + "RemoveListener", + ], + send: ["CallResult"], + query: ["RunListener", "StreamFilterSuspendCancel"], + }); + }, + + attachMessageManager(extension, processMessageManager) { + extension.parentMessageManager = processMessageManager; + }, + + async observe(subject, topic, data) { + if (topic === "message-manager-close") { + let mm = subject; + for (let [childId, context] of this.proxyContexts) { + if (context.parentMessageManager === mm) { + this.closeProxyContext(childId); + } + } + + // Reset extension message managers when their child processes shut down. + for (let extension of GlobalManager.extensionMap.values()) { + if (extension.parentMessageManager === mm) { + extension.parentMessageManager = null; + } + } + } + }, + + shutdownExtension(extensionId, reason) { + if (["ADDON_DISABLE", "ADDON_UNINSTALL"].includes(reason)) { + apiManager._callHandlers([extensionId], "disable", "onDisable"); + } + + for (let [childId, context] of this.proxyContexts) { + if (context.extension.id == extensionId) { + context.shutdown(); + this.proxyContexts.delete(childId); + } + } + }, + + queryStreamFilterSuspendCancel(childId) { + return this.conduit.queryStreamFilterSuspendCancel(childId); + }, + + recvCreateProxyContext(data, { actor, sender }) { + let { envType, extensionId, childId, principal } = data; + let target = actor.browsingContext?.top.embedderElement; + + if (this.proxyContexts.has(childId)) { + throw new Error( + "A WebExtension context with the given ID already exists!" + ); + } + + let extension = GlobalManager.getExtension(extensionId); + if (!extension) { + throw new Error(`No WebExtension found with ID ${extensionId}`); + } + + let context; + if (envType == "addon_parent" || envType == "devtools_parent") { + if (!sender.verified) { + throw new Error(`Bad sender context envType: ${sender.envType}`); + } + + if (JSWindowActorParent.isInstance(actor)) { + let processMessageManager = + target.messageManager.processMessageManager || + Services.ppmm.getChildAt(0); + + if (!extension.parentMessageManager) { + if (target.remoteType === extension.remoteType) { + this.attachMessageManager(extension, processMessageManager); + } + } + + if (processMessageManager !== extension.parentMessageManager) { + throw new Error( + "Attempt to create privileged extension parent from incorrect child process" + ); + } + } else if (JSProcessActorParent.isInstance(actor)) { + if (actor.manager.remoteType !== extension.remoteType) { + throw new Error( + "Attempt to create privileged extension parent from incorrect child process" + ); + } + + if (envType !== "addon_parent") { + throw new Error( + `Unexpected envType ${envType} on an extension process actor` + ); + } + } + + if (envType == "addon_parent" && data.viewType === "background_worker") { + context = new BackgroundWorkerContextParent(envType, extension, data); + } else if (envType == "addon_parent") { + context = new ExtensionPageContextParent( + envType, + extension, + data, + target + ); + } else if (envType == "devtools_parent") { + context = new DevToolsExtensionPageContextParent( + envType, + extension, + data, + target + ); + } + } else if (envType == "content_parent") { + context = new ContentScriptContextParent( + envType, + extension, + data, + target, + principal + ); + } else { + throw new Error(`Invalid WebExtension context envType: ${envType}`); + } + this.proxyContexts.set(childId, context); + }, + + recvContextLoaded(data, { actor, sender }) { + let context = this.getContextById(data.childId); + verifyActorForContext(actor, context); + const { extension } = context; + extension.emit("extension-proxy-context-load:completed", context); + }, + + recvConduitClosed(sender) { + this.closeProxyContext(sender.id); + }, + + closeProxyContext(childId) { + let context = this.proxyContexts.get(childId); + if (context) { + context.unload(); + this.proxyContexts.delete(childId); + } + }, + + async retrievePerformanceCounters() { + // getting the parent counters + return lazy.PerformanceCounters.getData(); + }, + + /** + * Call the given function and also log the call as appropriate + * (i.e., with PerformanceCounters and/or activity logging) + * + * @param {BaseContext} context The context making this call. + * @param {object} data Additional data about the call. + * @param {Function} callable The actual implementation to invoke. + */ + async callAndLog(context, data, callable) { + let { id } = context.extension; + // If we were called via callParentAsyncFunction we don't want + // to log again, check for the flag. + const { alreadyLogged } = data.options || {}; + if (!alreadyLogged) { + lazy.ExtensionActivityLog.log( + id, + context.viewType, + "api_call", + data.path, + { + args: data.args, + } + ); + } + + let start = Cu.now(); + try { + return callable(); + } finally { + ChromeUtils.addProfilerMarker( + "ExtensionParent", + { startTime: start }, + `${id}, api_call: ${data.path}` + ); + if (lazy.gTimingEnabled) { + let end = Cu.now() * 1000; + lazy.PerformanceCounters.storeExecutionTime( + id, + data.path, + end - start * 1000 + ); + } + } + }, + + async recvAPICall(data, { actor }) { + let context = this.getContextById(data.childId); + let target = actor.browsingContext?.top.embedderElement; + + verifyActorForContext(actor, context); + + let reply = result => { + if (target && !context.parentMessageManager) { + Services.console.logStringMessage( + "Cannot send function call result: other side closed connection " + + `(call data: ${uneval({ path: data.path, args: data.args })})` + ); + return; + } + + this.conduit.sendCallResult(data.childId, { + childId: data.childId, + callId: data.callId, + path: data.path, + ...result, + }); + }; + + try { + let args = data.args; + let { isHandlingUserInput = false } = data.options || {}; + let pendingBrowser = context.pendingEventBrowser; + let fun = await context.apiCan.asyncFindAPIPath(data.path); + let result = this.callAndLog(context, data, () => { + return context.withPendingBrowser(pendingBrowser, () => + context.withCallContextData({ isHandlingUserInput }, () => + fun(...args) + ) + ); + }); + + if (data.callId) { + result = result || Promise.resolve(); + + result.then( + result => { + result = result instanceof SpreadArgs ? [...result] : [result]; + + let holder = new StructuredCloneHolder( + `ExtensionParent/${context.extension.id}/recvAPICall/${data.path}`, + null, + result + ); + + reply({ result: holder }); + }, + error => { + error = context.normalizeError(error); + reply({ + error: { message: error.message, fileName: error.fileName }, + }); + } + ); + } + } catch (e) { + if (data.callId) { + let error = context.normalizeError(e); + reply({ error: { message: error.message } }); + } else { + Cu.reportError(e); + } + } + }, + + async recvAddListener(data, { actor }) { + let context = this.getContextById(data.childId); + + verifyActorForContext(actor, context); + + let { childId, alreadyLogged = false } = data; + let handlingUserInput = false; + + let listener = async (...listenerArgs) => { + let startTime = Cu.now(); + // Extract urgentSend flag to avoid deserializing args holder later. + let urgentSend = false; + if (listenerArgs[0] && data.path.startsWith("webRequest.")) { + urgentSend = listenerArgs[0].urgentSend; + delete listenerArgs[0].urgentSend; + } + let runListenerPromise = this.conduit.queryRunListener(childId, { + childId, + handlingUserInput, + listenerId: data.listenerId, + path: data.path, + urgentSend, + get args() { + return new StructuredCloneHolder( + `ExtensionParent/${context.extension.id}/recvAddListener/${data.path}`, + null, + listenerArgs + ); + }, + }); + context.trackRunListenerPromise(runListenerPromise); + + const result = await runListenerPromise; + let rv = result && result.deserialize(globalThis); + ChromeUtils.addProfilerMarker( + "ExtensionParent", + { startTime }, + `${context.extension.id}, api_event: ${data.path}` + ); + lazy.ExtensionActivityLog.log( + context.extension.id, + context.viewType, + "api_event", + data.path, + { args: listenerArgs, result: rv } + ); + return rv; + }; + + context.listenerProxies.set(data.listenerId, listener); + + let args = data.args; + let promise = context.apiCan.asyncFindAPIPath(data.path); + + // Store pending listener additions so we can be sure they're all + // fully initialize before we consider extension startup complete. + if (context.isBackgroundContext && context.listenerPromises) { + const { listenerPromises } = context; + listenerPromises.add(promise); + let remove = () => { + listenerPromises.delete(promise); + }; + promise.then(remove, remove); + } + + let handler = await promise; + if (handler.setUserInput) { + handlingUserInput = true; + } + handler.addListener(listener, ...args); + if (!alreadyLogged) { + lazy.ExtensionActivityLog.log( + context.extension.id, + context.viewType, + "api_call", + `${data.path}.addListener`, + { args } + ); + } + }, + + async recvRemoveListener(data) { + let context = this.getContextById(data.childId); + let listener = context.listenerProxies.get(data.listenerId); + + let handler = await context.apiCan.asyncFindAPIPath(data.path); + handler.removeListener(listener); + + let { alreadyLogged = false } = data; + if (!alreadyLogged) { + lazy.ExtensionActivityLog.log( + context.extension.id, + context.viewType, + "api_call", + `${data.path}.removeListener`, + { args: [] } + ); + } + }, + + getContextById(childId) { + let context = this.proxyContexts.get(childId); + if (!context) { + throw new Error("WebExtension context not found!"); + } + return context; + }, +}; + +ParentAPIManager.init(); + +/** + * A hidden window which contains the extension pages that are not visible + * (i.e., background pages and devtools pages), and is also used by + * ExtensionDebuggingUtils to contain the browser elements used by the + * addon debugger to connect to the devtools actors running in the same + * process of the target extension (and be able to stay connected across + * the addon reloads). + */ +class HiddenXULWindow { + constructor() { + this._windowlessBrowser = null; + this.unloaded = false; + this.waitInitialized = this.initWindowlessBrowser(); + } + + shutdown() { + if (this.unloaded) { + throw new Error( + "Unable to shutdown an unloaded HiddenXULWindow instance" + ); + } + + this.unloaded = true; + + this.waitInitialized = null; + + if (!this._windowlessBrowser) { + Cu.reportError("HiddenXULWindow was shut down while it was loading."); + // initWindowlessBrowser will close windowlessBrowser when possible. + return; + } + + this._windowlessBrowser.close(); + this._windowlessBrowser = null; + } + + get chromeDocument() { + return this._windowlessBrowser.document; + } + + /** + * Private helper that create a HTMLDocument in a windowless browser. + * + * @returns {Promise<void>} + * A promise which resolves when the windowless browser is ready. + */ + async initWindowlessBrowser() { + if (this.waitInitialized) { + throw new Error("HiddenXULWindow already initialized"); + } + + // The invisible page is currently wrapped in a XUL window to fix an issue + // with using the canvas API from a background page (See Bug 1274775). + let windowlessBrowser = Services.appShell.createWindowlessBrowser(true); + + // The windowless browser is a thin wrapper around a docShell that keeps + // its related resources alive. It implements nsIWebNavigation and + // forwards its methods to the underlying docShell. That .docShell + // needs `QueryInterface(nsIWebNavigation)` to give us access to the + // webNav methods that are already available on the windowless browser. + let chromeShell = windowlessBrowser.docShell; + chromeShell.QueryInterface(Ci.nsIWebNavigation); + + if (lazy.PrivateBrowsingUtils.permanentPrivateBrowsing) { + let attrs = chromeShell.getOriginAttributes(); + attrs.privateBrowsingId = 1; + chromeShell.setOriginAttributes(attrs); + } + + windowlessBrowser.browsingContext.useGlobalHistory = false; + chromeShell.loadURI(DUMMY_PAGE_URI, { + triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(), + }); + + await promiseObserved( + "chrome-document-global-created", + win => win.document == chromeShell.document + ); + await promiseDocumentLoaded(windowlessBrowser.document); + if (this.unloaded) { + windowlessBrowser.close(); + return; + } + this._windowlessBrowser = windowlessBrowser; + } + + /** + * Creates the browser XUL element that will contain the WebExtension Page. + * + * @param {object} xulAttributes + * An object that contains the xul attributes to set of the newly + * created browser XUL element. + * + * @returns {Promise<XULElement>} + * A Promise which resolves to the newly created browser XUL element. + */ + async createBrowserElement(xulAttributes) { + if (!xulAttributes || Object.keys(xulAttributes).length === 0) { + throw new Error("missing mandatory xulAttributes parameter"); + } + + await this.waitInitialized; + + const chromeDoc = this.chromeDocument; + + const browser = chromeDoc.createXULElement("browser"); + browser.setAttribute("type", "content"); + browser.setAttribute("disableglobalhistory", "true"); + browser.setAttribute("messagemanagergroup", "webext-browsers"); + + for (const [name, value] of Object.entries(xulAttributes)) { + if (value != null) { + browser.setAttribute(name, value); + } + } + + let awaitFrameLoader = Promise.resolve(); + + if (browser.getAttribute("remote") === "true") { + awaitFrameLoader = promiseEvent(browser, "XULFrameLoaderCreated"); + } + + chromeDoc.documentElement.appendChild(browser); + + // Forcibly flush layout so that we get a pres shell soon enough, see + // bug 1274775. + browser.getBoundingClientRect(); + + await awaitFrameLoader; + return browser; + } +} + +const SharedWindow = { + _window: null, + _count: 0, + + acquire() { + if (this._window == null) { + if (this._count != 0) { + throw new Error( + `Shared window already exists with count ${this._count}` + ); + } + + this._window = new HiddenXULWindow(); + } + + this._count++; + return this._window; + }, + + release() { + if (this._count < 1) { + throw new Error(`Releasing shared window with count ${this._count}`); + } + + this._count--; + if (this._count == 0) { + this._window.shutdown(); + this._window = null; + } + }, +}; + +/** + * This is a base class used by the ext-backgroundPage and ext-devtools API implementations + * to inherits the shared boilerplate code needed to create a parent document for the hidden + * extension pages (e.g. the background page, the devtools page) in the BackgroundPage and + * DevToolsPage classes. + * + * @param {Extension} extension + * The Extension which owns the hidden extension page created (used to decide + * if the hidden extension page parent doc is going to be a windowlessBrowser or + * a visible XUL window). + * @param {string} viewType + * The viewType of the WebExtension page that is going to be loaded + * in the created browser element (e.g. "background" or "devtools_page"). + */ +class HiddenExtensionPage { + constructor(extension, viewType) { + if (!extension || !viewType) { + throw new Error("extension and viewType parameters are mandatory"); + } + + this.extension = extension; + this.viewType = viewType; + this.browser = null; + this.unloaded = false; + } + + /** + * Destroy the created parent document. + */ + shutdown() { + if (this.unloaded) { + throw new Error( + "Unable to shutdown an unloaded HiddenExtensionPage instance" + ); + } + + this.unloaded = true; + + if (this.browser) { + this._releaseBrowser(); + } + } + + _releaseBrowser() { + this.browser.remove(); + this.browser = null; + SharedWindow.release(); + } + + /** + * Creates the browser XUL element that will contain the WebExtension Page. + * + * @returns {Promise<XULElement>} + * A Promise which resolves to the newly created browser XUL element. + */ + async createBrowserElement() { + if (this.browser) { + throw new Error("createBrowserElement called twice"); + } + + let window = SharedWindow.acquire(); + try { + this.browser = await window.createBrowserElement({ + "webextension-view-type": this.viewType, + remote: this.extension.remote ? "true" : null, + remoteType: this.extension.remoteType, + initialBrowsingContextGroupId: this.extension.browsingContextGroupId, + }); + } catch (e) { + SharedWindow.release(); + throw e; + } + + if (this.unloaded) { + this._releaseBrowser(); + throw new Error("Extension shut down before browser element was created"); + } + + return this.browser; + } +} + +/** + * This object provides utility functions needed by the devtools actors to + * be able to connect and debug an extension (which can run in the main or in + * a child extension process). + */ +const DebugUtils = { + // A lazily created hidden XUL window, which contains the browser elements + // which are used to connect the webextension patent actor to the extension process. + hiddenXULWindow: null, + + // Map<extensionId, Promise<XULElement>> + debugBrowserPromises: new Map(), + // DefaultWeakMap<Promise<browser XULElement>, Set<WebExtensionParentActor>> + debugActors: new DefaultWeakMap(() => new Set()), + + _extensionUpdatedWatcher: null, + watchExtensionUpdated() { + if (!this._extensionUpdatedWatcher) { + // Watch the updated extension objects. + this._extensionUpdatedWatcher = async (evt, extension) => { + const browserPromise = this.debugBrowserPromises.get(extension.id); + if (browserPromise) { + const browser = await browserPromise; + if ( + browser.isRemoteBrowser !== extension.remote && + this.debugBrowserPromises.get(extension.id) === browserPromise + ) { + // If the cached browser element is not anymore of the same + // remote type of the extension, remove it. + this.debugBrowserPromises.delete(extension.id); + browser.remove(); + } + } + }; + + apiManager.on("ready", this._extensionUpdatedWatcher); + } + }, + + unwatchExtensionUpdated() { + if (this._extensionUpdatedWatcher) { + apiManager.off("ready", this._extensionUpdatedWatcher); + delete this._extensionUpdatedWatcher; + } + }, + + getExtensionManifestWarnings(id) { + const addon = GlobalManager.extensionMap.get(id); + if (addon) { + return addon.warnings; + } + return []; + }, + + /** + * Determine if the extension does have a non-persistent background script + * (either an event page or a background service worker): + * + * Based on this the DevTools client will determine if this extension should provide + * to the extension developers a button to forcefully terminate the background + * script. + * + * @param {string} addonId + * The id of the addon + * + * @returns {void|boolean} + * - undefined => does not apply (no background script in the manifest) + * - true => the background script is persistent. + * - false => the background script is an event page or a service worker. + */ + hasPersistentBackgroundScript(addonId) { + const policy = WebExtensionPolicy.getByID(addonId); + + // The addon doesn't have any background script or we + // can't be sure yet. + if ( + policy?.extension?.type !== "extension" || + !policy?.extension?.manifest?.background + ) { + return undefined; + } + + return policy.extension.persistentBackground; + }, + + /** + * Determine if the extension background page is running. + * + * Based on this the DevTools client will show the status of the background + * script in about:debugging. + * + * @param {string} addonId + * The id of the addon + * + * @returns {void|boolean} + * - undefined => does not apply (no background script in the manifest) + * - true => the background script is running. + * - false => the background script is stopped. + */ + isBackgroundScriptRunning(addonId) { + const policy = WebExtensionPolicy.getByID(addonId); + + // The addon doesn't have any background script or we + // can't be sure yet. + if (!(this.hasPersistentBackgroundScript(addonId) === false)) { + return undefined; + } + + const views = policy?.extension?.views || []; + for (const view of views) { + if ( + view.viewType === "background" || + (view.viewType === "background_worker" && !view.unloaded) + ) { + return true; + } + } + + return false; + }, + + async terminateBackgroundScript(addonId) { + // Terminate the background if the extension does have + // a non-persistent background script (event page or background + // service worker). + if (this.hasPersistentBackgroundScript(addonId) === false) { + const policy = WebExtensionPolicy.getByID(addonId); + // When the event page is being terminated through the Devtools + // action, we should terminate it even if there are DevTools + // toolboxes attached to the extension. + return policy.extension.terminateBackground({ + ignoreDevToolsAttached: true, + }); + } + throw Error(`Unable to terminate background script for ${addonId}`); + }, + + /** + * Determine whether a devtools toolbox attached to the extension. + * + * This method is called by the background page idle timeout handler, + * to inhibit terminating the event page when idle while the extension + * developer is debugging the extension through the Addon Debugging window + * (similarly to how service workers are kept alive while the devtools are + * attached). + * + * @param {string} id + * The id of the extension. + * + * @returns {boolean} + * true when a devtools toolbox is attached to an extension with + * the given id, false otherwise. + */ + hasDevToolsAttached(id) { + return this.debugBrowserPromises.has(id); + }, + + /** + * Retrieve a XUL browser element which has been configured to be able to connect + * the devtools actor with the process where the extension is running. + * + * @param {WebExtensionParentActor} webExtensionParentActor + * The devtools actor that is retrieving the browser element. + * + * @returns {Promise<XULElement>} + * A promise which resolves to the configured browser XUL element. + */ + async getExtensionProcessBrowser(webExtensionParentActor) { + const extensionId = webExtensionParentActor.addonId; + const extension = GlobalManager.getExtension(extensionId); + if (!extension) { + throw new Error(`Extension not found: ${extensionId}`); + } + + const createBrowser = () => { + if (!this.hiddenXULWindow) { + this.hiddenXULWindow = new HiddenXULWindow(); + this.watchExtensionUpdated(); + } + + return this.hiddenXULWindow.createBrowserElement({ + "webextension-addon-debug-target": extensionId, + remote: extension.remote ? "true" : null, + remoteType: extension.remoteType, + initialBrowsingContextGroupId: extension.browsingContextGroupId, + }); + }; + + let browserPromise = this.debugBrowserPromises.get(extensionId); + + // Create a new promise if there is no cached one in the map. + if (!browserPromise) { + browserPromise = createBrowser(); + this.debugBrowserPromises.set(extensionId, browserPromise); + browserPromise.then(browser => { + browserPromise.browser = browser; + }); + browserPromise.catch(e => { + Cu.reportError(e); + this.debugBrowserPromises.delete(extensionId); + }); + } + + this.debugActors.get(browserPromise).add(webExtensionParentActor); + + return browserPromise; + }, + + getFrameLoader(extensionId) { + let promise = this.debugBrowserPromises.get(extensionId); + return promise && promise.browser && promise.browser.frameLoader; + }, + + /** + * Given the devtools actor that has retrieved an addon debug browser element, + * it destroys the XUL browser element, and it also destroy the hidden XUL window + * if it is not currently needed. + * + * @param {WebExtensionParentActor} webExtensionParentActor + * The devtools actor that has retrieved an addon debug browser element. + */ + async releaseExtensionProcessBrowser(webExtensionParentActor) { + const extensionId = webExtensionParentActor.addonId; + const browserPromise = this.debugBrowserPromises.get(extensionId); + + if (browserPromise) { + const actorsSet = this.debugActors.get(browserPromise); + actorsSet.delete(webExtensionParentActor); + if (actorsSet.size === 0) { + this.debugActors.delete(browserPromise); + this.debugBrowserPromises.delete(extensionId); + await browserPromise.then(browser => browser.remove()); + } + } + + if (this.debugBrowserPromises.size === 0 && this.hiddenXULWindow) { + this.hiddenXULWindow.shutdown(); + this.hiddenXULWindow = null; + this.unwatchExtensionUpdated(); + } + }, +}; + +/** + * Returns a Promise which resolves with the message data when the given message + * was received by the message manager. The promise is rejected if the message + * manager was closed before a message was received. + * + * @param {MessageListenerManager} messageManager + * The message manager on which to listen for messages. + * @param {string} messageName + * The message to listen for. + * @returns {Promise<*>} + */ +function promiseMessageFromChild(messageManager, messageName) { + return new Promise((resolve, reject) => { + let unregister; + function listener(message) { + unregister(); + resolve(message.data); + } + function observer(subject, topic, data) { + if (subject === messageManager) { + unregister(); + reject( + new Error( + `Message manager was disconnected before receiving ${messageName}` + ) + ); + } + } + unregister = () => { + Services.obs.removeObserver(observer, "message-manager-close"); + messageManager.removeMessageListener(messageName, listener); + }; + messageManager.addMessageListener(messageName, listener); + Services.obs.addObserver(observer, "message-manager-close"); + }); +} + +// This should be called before browser.loadURI is invoked. +async function promiseExtensionViewLoaded(browser) { + let { childId } = await promiseMessageFromChild( + browser.messageManager, + "Extension:ExtensionViewLoaded" + ); + if (childId) { + return ParentAPIManager.getContextById(childId); + } +} + +/** + * This helper is used to subscribe a listener (e.g. in the ext-devtools API implementation) + * to be called for every ExtensionProxyContext created for an extension page given + * its related extension, viewType and browser element (both the top level context and any context + * created for the extension urls running into its iframe descendants). + * + * @param {object} params + * @param {object} params.extension + * The Extension on which we are going to listen for the newly created ExtensionProxyContext. + * @param {string} params.viewType + * The viewType of the WebExtension page that we are watching (e.g. "background" or + * "devtools_page"). + * @param {XULElement} params.browser + * The browser element of the WebExtension page that we are watching. + * @param {Function} onExtensionProxyContextLoaded + * The callback that is called when a new context has been loaded (as `callback(context)`); + * + * @returns {Function} + * Unsubscribe the listener. + */ +function watchExtensionProxyContextLoad( + { extension, viewType, browser }, + onExtensionProxyContextLoaded +) { + if (typeof onExtensionProxyContextLoaded !== "function") { + throw new Error("Missing onExtensionProxyContextLoaded handler"); + } + + const listener = (event, context) => { + if (context.viewType == viewType && context.xulBrowser == browser) { + onExtensionProxyContextLoaded(context); + } + }; + + extension.on("extension-proxy-context-load", listener); + + return () => { + extension.off("extension-proxy-context-load", listener); + }; +} + +/** + * This helper is used to subscribe a listener (e.g. in the ext-backgroundPage) + * to be called for every ExtensionProxyContext created for an extension + * background service worker given its related extension. + * + * @param {object} params + * @param {object} params.extension + * The Extension on which we are going to listen for the newly created ExtensionProxyContext. + * @param {Function} onExtensionWorkerContextLoaded + * The callback that is called when the worker script has been fully loaded (as `callback(context)`); + * + * @returns {Function} + * Unsubscribe the listener. + */ +function watchExtensionWorkerContextLoaded( + { extension }, + onExtensionWorkerContextLoaded +) { + if (typeof onExtensionWorkerContextLoaded !== "function") { + throw new Error("Missing onExtensionWorkerContextLoaded handler"); + } + + const listener = (event, context) => { + if (context.viewType == "background_worker") { + onExtensionWorkerContextLoaded(context); + } + }; + + extension.on("extension-proxy-context-load:completed", listener); + + return () => { + extension.off("extension-proxy-context-load:completed", listener); + }; +} + +// Manages icon details for toolbar buttons in the |pageAction| and +// |browserAction| APIs. +let IconDetails = { + DEFAULT_ICON: "chrome://mozapps/skin/extensions/extensionGeneric.svg", + + // WeakMap<Extension -> Map<url-string -> Map<iconType-string -> object>>> + iconCache: new DefaultWeakMap(() => { + return new DefaultMap(() => new DefaultMap(() => new Map())); + }), + + // Normalizes the various acceptable input formats into an object + // with icon size as key and icon URL as value. + // + // If a context is specified (function is called from an extension): + // Throws an error if an invalid icon size was provided or the + // extension is not allowed to load the specified resources. + // + // If no context is specified, instead of throwing an error, this + // function simply logs a warning message. + normalize(details, extension, context = null) { + if (!details.imageData && details.path != null) { + // Pick a cache key for the icon paths. If the path is a string, + // use it directly. Otherwise, stringify the path object. + let key = details.path; + if (typeof key !== "string") { + key = uneval(key); + } + + let icons = this.iconCache + .get(extension) + .get(context && context.uri.spec) + .get(details.iconType); + + let icon = icons.get(key); + if (!icon) { + icon = this._normalize(details, extension, context); + icons.set(key, icon); + } + return icon; + } + + return this._normalize(details, extension, context); + }, + + _normalize(details, extension, context = null) { + let result = {}; + + try { + let { imageData, path, themeIcons } = details; + + if (imageData) { + if (typeof imageData == "string") { + imageData = { 19: imageData }; + } + + for (let size of Object.keys(imageData)) { + result[size] = imageData[size]; + } + } + + let baseURI = context ? context.uri : extension.baseURI; + + if (path != null) { + if (typeof path != "object") { + path = { 19: path }; + } + + for (let size of Object.keys(path)) { + let url = path[size]; + if (url) { + url = baseURI.resolve(path[size]); + + // The Chrome documentation specifies these parameters as + // relative paths. We currently accept absolute URLs as well, + // which means we need to check that the extension is allowed + // to load them. This will throw an error if it's not allowed. + this._checkURL(url, extension); + } + result[size] = url || this.DEFAULT_ICON; + } + } + + if (themeIcons) { + themeIcons.forEach(({ size, light, dark }) => { + let lightURL = baseURI.resolve(light); + let darkURL = baseURI.resolve(dark); + + this._checkURL(lightURL, extension); + this._checkURL(darkURL, extension); + + let defaultURL = result[size] || result[19]; // always fallback to default first + result[size] = { + default: defaultURL || darkURL, // Fallback to the dark url if no default is specified. + light: lightURL, + dark: darkURL, + }; + }); + } + } catch (e) { + // Function is called from extension code, delegate error. + if (context) { + throw e; + } + // If there's no context, it's because we're handling this + // as a manifest directive. Log a warning rather than + // raising an error. + extension.manifestError(`Invalid icon data: ${e}`); + } + + return result; + }, + + // Checks if the extension is allowed to load the given URL with the specified principal. + // This will throw an error if the URL is not allowed. + _checkURL(url, extension) { + if (!extension.checkLoadURL(url, { allowInheritsPrincipal: true })) { + throw new ExtensionError(`Illegal URL ${url}`); + } + }, + + // Returns the appropriate icon URL for the given icons object and the + // screen resolution of the given window. + getPreferredIcon(icons, extension = null, size = 16) { + const DEFAULT = "chrome://mozapps/skin/extensions/extensionGeneric.svg"; + + let bestSize = null; + if (icons[size]) { + bestSize = size; + } else if (icons[2 * size]) { + bestSize = 2 * size; + } else { + let sizes = Object.keys(icons) + .map(key => parseInt(key, 10)) + .sort((a, b) => a - b); + + bestSize = sizes.find(candidate => candidate > size) || sizes.pop(); + } + + if (bestSize) { + return { size: bestSize, icon: icons[bestSize] || DEFAULT }; + } + + return { size, icon: DEFAULT }; + }, + + // These URLs should already be properly escaped, but make doubly sure CSS + // string escape characters are escaped here, since they could lead to a + // sandbox break. + escapeUrl(url) { + return url.replace(/[\\\s"]/g, encodeURIComponent); + }, +}; + +// A cache to support faster initialization of extensions at browser startup. +// All cached data is removed when the browser is updated. +// Extension-specific data is removed when the add-on is updated. +StartupCache = { + STORE_NAMES: Object.freeze([ + "general", + "locales", + "manifests", + "other", + "permissions", + "schemas", + "menus", + ]), + + _ensureDirectoryPromise: null, + _saveTask: null, + + _ensureDirectory() { + if (this._ensureDirectoryPromise === null) { + this._ensureDirectoryPromise = IOUtils.makeDirectory( + PathUtils.parent(this.file), + { + ignoreExisting: true, + createAncestors: true, + } + ); + } + + return this._ensureDirectoryPromise; + }, + + // When the application version changes, this file is removed by + // RemoveComponentRegistries in nsAppRunner.cpp. + file: PathUtils.join( + Services.dirsvc.get("ProfLD", Ci.nsIFile).path, + "startupCache", + "webext.sc.lz4" + ), + + async _saveNow() { + let data = new Uint8Array(lazy.aomStartup.encodeBlob(this._data)); + await this._ensureDirectoryPromise; + await IOUtils.write(this.file, data, { tmpPath: `${this.file}.tmp` }); + Services.telemetry.scalarSet( + "extensions.startupCache.write_byteLength", + data.byteLength + ); + }, + + save() { + this._ensureDirectory(); + + if (!this._saveTask) { + this._saveTask = new lazy.DeferredTask(() => this._saveNow(), 5000); + + IOUtils.profileBeforeChange.addBlocker( + "Flush WebExtension StartupCache", + async () => { + await this._saveTask.finalize(); + this._saveTask = null; + } + ); + } + + return this._saveTask.arm(); + }, + + _data: null, + async _readData() { + let result = new Map(); + try { + Glean.extensions.startupCacheLoadTime.start(); + let { buffer } = await IOUtils.read(this.file); + + result = lazy.aomStartup.decodeBlob(buffer); + Glean.extensions.startupCacheLoadTime.stop(); + } catch (e) { + Glean.extensions.startupCacheLoadTime.cancel(); + if (!DOMException.isInstance(e) || e.name !== "NotFoundError") { + Cu.reportError(e); + } + + Services.telemetry.keyedScalarAdd( + "extensions.startupCache.read_errors", + lazy.getErrorNameForTelemetry(e), + 1 + ); + } + + this._data = result; + return result; + }, + + get dataPromise() { + if (!this._dataPromise) { + this._dataPromise = this._readData(); + } + return this._dataPromise; + }, + + clearAddonData(id) { + return Promise.all([ + this.general.delete(id), + this.locales.delete(id), + this.manifests.delete(id), + this.permissions.delete(id), + this.menus.delete(id), + ]).catch(e => { + // Ignore the error. It happens when we try to flush the add-on + // data after the AddonManager has flushed the entire startup cache. + }); + }, + + observe(subject, topic, data) { + if (topic === "startupcache-invalidate") { + this._data = new Map(); + this._dataPromise = Promise.resolve(this._data); + } + }, + + get(extension, path, createFunc) { + return this.general.get( + [extension.id, extension.version, ...path], + createFunc + ); + }, + + delete(extension, path) { + return this.general.delete([extension.id, extension.version, ...path]); + }, +}; + +Services.obs.addObserver(StartupCache, "startupcache-invalidate"); + +class CacheStore { + constructor(storeName) { + this.storeName = storeName; + } + + async getStore(path = null) { + let data = await StartupCache.dataPromise; + + let store = data.get(this.storeName); + if (!store) { + store = new Map(); + data.set(this.storeName, store); + } + + let key = path; + if (Array.isArray(path)) { + for (let elem of path.slice(0, -1)) { + let next = store.get(elem); + if (!next) { + next = new Map(); + store.set(elem, next); + } + store = next; + } + key = path[path.length - 1]; + } + + return [store, key]; + } + + async get(path, createFunc) { + let [store, key] = await this.getStore(path); + + let result = store.get(key); + + if (result === undefined) { + result = await createFunc(path); + store.set(key, result); + StartupCache.save(); + } + + return result; + } + + async set(path, value) { + let [store, key] = await this.getStore(path); + + store.set(key, value); + StartupCache.save(); + } + + async getAll() { + let [store] = await this.getStore(); + + return new Map(store); + } + + async delete(path) { + let [store, key] = await this.getStore(path); + + if (store.delete(key)) { + StartupCache.save(); + } + } +} + +for (let name of StartupCache.STORE_NAMES) { + StartupCache[name] = new CacheStore(name); +} + +export var ExtensionParent = { + GlobalManager, + HiddenExtensionPage, + IconDetails, + ParentAPIManager, + StartupCache, + WebExtensionPolicy, + apiManager, + promiseExtensionViewLoaded, + watchExtensionProxyContextLoad, + watchExtensionWorkerContextLoaded, + DebugUtils, +}; + +// browserPaintedPromise and browserStartupPromise are promises that +// resolve after the first browser window is painted and after browser +// windows have been restored, respectively. Alternatively, +// browserStartupPromise also resolves from the extensions-late-startup +// notification sent by Firefox Reality on desktop platforms, because it +// doesn't support SessionStore. +// _resetStartupPromises should only be called from outside this file in tests. +ExtensionParent._resetStartupPromises = () => { + ExtensionParent.browserPaintedPromise = promiseObserved( + "browser-delayed-startup-finished" + ).then(() => {}); + ExtensionParent.browserStartupPromise = Promise.race([ + promiseObserved("sessionstore-windows-restored"), + promiseObserved("extensions-late-startup"), + ]).then(() => {}); +}; +ExtensionParent._resetStartupPromises(); + +XPCOMUtils.defineLazyGetter(ExtensionParent, "PlatformInfo", () => { + return Object.freeze({ + os: (function () { + let os = AppConstants.platform; + if (os == "macosx") { + os = "mac"; + } + return os; + })(), + arch: (function () { + let abi = Services.appinfo.XPCOMABI; + let [arch] = abi.split("-"); + if (arch == "x86") { + arch = "x86-32"; + } else if (arch == "x86_64") { + arch = "x86-64"; + } + return arch; + })(), + }); +}); + +/** + * Retreives the browser_style stylesheets needed for extension popups and sidebars. + * + * @returns {Array<string>} an array of stylesheets needed for the current platform. + */ +XPCOMUtils.defineLazyGetter(ExtensionParent, "extensionStylesheets", () => { + let stylesheets = ["chrome://browser/content/extension.css"]; + + if (AppConstants.platform === "macosx") { + stylesheets.push("chrome://browser/content/extension-mac.css"); + } + + return stylesheets; +}); |