summaryrefslogtreecommitdiffstats
path: root/toolkit/components/extensions/ExtensionCommon.sys.mjs
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/components/extensions/ExtensionCommon.sys.mjs')
-rw-r--r--toolkit/components/extensions/ExtensionCommon.sys.mjs3082
1 files changed, 3082 insertions, 0 deletions
diff --git a/toolkit/components/extensions/ExtensionCommon.sys.mjs b/toolkit/components/extensions/ExtensionCommon.sys.mjs
new file mode 100644
index 0000000000..86c99042b6
--- /dev/null
+++ b/toolkit/components/extensions/ExtensionCommon.sys.mjs
@@ -0,0 +1,3082 @@
+/* -*- 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 utilities and base classes for logic which is
+ * common between the parent and child process, and in particular
+ * between ExtensionParent.jsm and 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, {
+ ConsoleAPI: "resource://gre/modules/Console.sys.mjs",
+ PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+ SchemaRoot: "resource://gre/modules/Schemas.sys.mjs",
+ Schemas: "resource://gre/modules/Schemas.sys.mjs",
+});
+
+XPCOMUtils.defineLazyServiceGetter(
+ lazy,
+ "styleSheetService",
+ "@mozilla.org/content/style-sheet-service;1",
+ "nsIStyleSheetService"
+);
+
+const ScriptError = Components.Constructor(
+ "@mozilla.org/scripterror;1",
+ "nsIScriptError",
+ "initWithWindowID"
+);
+
+import { ExtensionUtils } from "resource://gre/modules/ExtensionUtils.sys.mjs";
+
+var {
+ DefaultMap,
+ DefaultWeakMap,
+ ExtensionError,
+ filterStack,
+ getInnerWindowID,
+ getUniqueId,
+} = ExtensionUtils;
+
+function getConsole() {
+ return new lazy.ConsoleAPI({
+ maxLogLevelPref: "extensions.webextensions.log.level",
+ prefix: "WebExtensions",
+ });
+}
+
+// Run a function and report exceptions.
+function runSafeSyncWithoutClone(f, ...args) {
+ try {
+ return f(...args);
+ } catch (e) {
+ // This method is called with `this` unbound and it doesn't have
+ // access to a BaseContext instance and so we can't check if `e`
+ // is an instance of the extension context's Error constructor
+ // (like we do in BaseContext applySafeWithoutClone method).
+ dump(
+ `Extension error: ${e} ${e?.fileName} ${
+ e?.lineNumber
+ }\n[[Exception stack\n${
+ e?.stack ? filterStack(e) : undefined
+ }Current stack\n${filterStack(Error())}]]\n`
+ );
+ Cu.reportError(e);
+ }
+}
+
+// Return true if the given value is an instance of the given
+// native type.
+function instanceOf(value, type) {
+ return (
+ value &&
+ typeof value === "object" &&
+ ChromeUtils.getClassName(value) === type
+ );
+}
+
+/**
+ * Convert any of several different representations of a date/time to a Date object.
+ * Accepts several formats:
+ * a Date object, an ISO8601 string, or a number of milliseconds since the epoch as
+ * either a number or a string.
+ *
+ * @param {Date|string|number} date
+ * The date to convert.
+ * @returns {Date}
+ * A Date object
+ */
+function normalizeTime(date) {
+ // Of all the formats we accept the "number of milliseconds since the epoch as a string"
+ // is an outlier, everything else can just be passed directly to the Date constructor.
+ return new Date(
+ typeof date == "string" && /^\d+$/.test(date) ? parseInt(date, 10) : date
+ );
+}
+
+function withHandlingUserInput(window, callable) {
+ let handle = window.windowUtils.setHandlingUserInput(true);
+ try {
+ return callable();
+ } finally {
+ handle.destruct();
+ }
+}
+
+/**
+ * Defines a lazy getter for the given property on the given object. The
+ * first time the property is accessed, the return value of the getter
+ * is defined on the current `this` object with the given property name.
+ * Importantly, this means that a lazy getter defined on an object
+ * prototype will be invoked separately for each object instance that
+ * it's accessed on.
+ *
+ * Note: for better type inference, prefer redefineGetter() below.
+ *
+ * @param {object} object
+ * The prototype object on which to define the getter.
+ * @param {string | symbol} prop
+ * The property name for which to define the getter.
+ * @param {callback} getter
+ * The function to call in order to generate the final property
+ * value.
+ */
+function defineLazyGetter(object, prop, getter) {
+ Object.defineProperty(object, prop, {
+ enumerable: true,
+ configurable: true,
+ get() {
+ return redefineGetter(this, prop, getter.call(this), true);
+ },
+ set(value) {
+ redefineGetter(this, prop, value, true);
+ },
+ });
+}
+
+/**
+ * A more type-inference friendly version of defineLazyGetter() above.
+ * Call it from a real getter (and setter) for your class or object.
+ * On first run, it will redefine the property with the final value.
+ *
+ * @template Value
+ * @param {object} object
+ * @param {string | symbol} key
+ * @param {Value} value
+ * @returns {Value}
+ */
+function redefineGetter(object, key, value, writable = false) {
+ Object.defineProperty(object, key, {
+ enumerable: true,
+ configurable: true,
+ writable,
+ value,
+ });
+ return value;
+}
+
+function checkLoadURI(uri, principal, options) {
+ let ssm = Services.scriptSecurityManager;
+
+ let flags = ssm.STANDARD;
+ if (!options.allowScript) {
+ flags |= ssm.DISALLOW_SCRIPT;
+ }
+ if (!options.allowInheritsPrincipal) {
+ flags |= ssm.DISALLOW_INHERIT_PRINCIPAL;
+ }
+ if (options.dontReportErrors) {
+ flags |= ssm.DONT_REPORT_ERRORS;
+ }
+
+ try {
+ ssm.checkLoadURIWithPrincipal(principal, uri, flags);
+ } catch (e) {
+ return false;
+ }
+ return true;
+}
+
+function checkLoadURL(url, principal, options) {
+ try {
+ return checkLoadURI(Services.io.newURI(url), principal, options);
+ } catch (e) {
+ return false; // newURI threw.
+ }
+}
+
+function makeWidgetId(id) {
+ id = id.toLowerCase();
+ // FIXME: This allows for collisions.
+ return id.replace(/[^a-z0-9_-]/g, "_");
+}
+
+/**
+ * A sentinel class to indicate that an array of values should be
+ * treated as an array when used as a promise resolution value, but as a
+ * spread expression (...args) when passed to a callback.
+ */
+class SpreadArgs extends Array {
+ constructor(args) {
+ super();
+ this.push(...args);
+ }
+}
+
+/**
+ * Like SpreadArgs, but also indicates that the array values already
+ * belong to the target compartment, and should not be cloned before
+ * being passed.
+ *
+ * The `unwrappedValues` property contains an Array object which belongs
+ * to the target compartment, and contains the same unwrapped values
+ * passed the NoCloneSpreadArgs constructor.
+ */
+class NoCloneSpreadArgs {
+ constructor(args) {
+ this.unwrappedValues = args;
+ }
+
+ [Symbol.iterator]() {
+ return this.unwrappedValues[Symbol.iterator]();
+ }
+}
+
+const LISTENERS = Symbol("listeners");
+const ONCE_MAP = Symbol("onceMap");
+
+class EventEmitter {
+ constructor() {
+ this[LISTENERS] = new Map();
+ this[ONCE_MAP] = new WeakMap();
+ }
+
+ /**
+ * Checks whether there is some listener for the given event.
+ *
+ * @param {string} event
+ * The name of the event to listen for.
+ * @returns {boolean}
+ */
+ has(event) {
+ return this[LISTENERS].has(event);
+ }
+
+ /**
+ * Adds the given function as a listener for the given event.
+ *
+ * The listener function may optionally return a Promise which
+ * resolves when it has completed all operations which event
+ * dispatchers may need to block on.
+ *
+ * @param {string} event
+ * The name of the event to listen for.
+ * @param {function(string, ...any): any} listener
+ * The listener to call when events are emitted.
+ */
+ on(event, listener) {
+ let listeners = this[LISTENERS].get(event);
+ if (!listeners) {
+ listeners = new Set();
+ this[LISTENERS].set(event, listeners);
+ }
+
+ listeners.add(listener);
+ }
+
+ /**
+ * Removes the given function as a listener for the given event.
+ *
+ * @param {string} event
+ * The name of the event to stop listening for.
+ * @param {function(string, ...any): any} listener
+ * The listener function to remove.
+ */
+ off(event, listener) {
+ let set = this[LISTENERS].get(event);
+ if (set) {
+ set.delete(listener);
+ set.delete(this[ONCE_MAP].get(listener));
+ if (!set.size) {
+ this[LISTENERS].delete(event);
+ }
+ }
+ }
+
+ /**
+ * Adds the given function as a listener for the given event once.
+ *
+ * @param {string} event
+ * The name of the event to listen for.
+ * @param {function(string, ...any): any} listener
+ * The listener to call when events are emitted.
+ */
+ once(event, listener) {
+ let wrapper = (event, ...args) => {
+ this.off(event, wrapper);
+ this[ONCE_MAP].delete(listener);
+
+ return listener(event, ...args);
+ };
+ this[ONCE_MAP].set(listener, wrapper);
+
+ this.on(event, wrapper);
+ }
+
+ /**
+ * Triggers all listeners for the given event. If any listeners return
+ * a value, returns a promise which resolves when all returned
+ * promises have resolved. Otherwise, returns undefined.
+ *
+ * @param {string} event
+ * The name of the event to emit.
+ * @param {any} args
+ * Arbitrary arguments to pass to the listener functions, after
+ * the event name.
+ * @returns {Promise?}
+ */
+ emit(event, ...args) {
+ let listeners = this[LISTENERS].get(event);
+
+ if (listeners) {
+ let promises = [];
+
+ for (let listener of listeners) {
+ try {
+ let result = listener(event, ...args);
+ if (result !== undefined) {
+ promises.push(result);
+ }
+ } catch (e) {
+ Cu.reportError(e);
+ }
+ }
+
+ if (promises.length) {
+ return Promise.all(promises);
+ }
+ }
+ }
+}
+
+/**
+ * Base class for WebExtension APIs. Each API creates a new class
+ * that inherits from this class, the derived class is instantiated
+ * once for each extension that uses the API.
+ */
+class ExtensionAPI extends EventEmitter {
+ constructor(extension) {
+ super();
+
+ this.extension = extension;
+
+ extension.once("shutdown", (what, isAppShutdown) => {
+ if (this.onShutdown) {
+ this.onShutdown(isAppShutdown);
+ }
+ this.extension = null;
+ });
+ }
+
+ destroy() {}
+
+ /** @param {string} entryName */
+ onManifestEntry(entryName) {}
+
+ /** @param {boolean} isAppShutdown */
+ onShutdown(isAppShutdown) {}
+
+ /** @param {BaseContext} context */
+ getAPI(context) {
+ throw new Error("Not Implemented");
+ }
+
+ /** @param {string} id */
+ static onDisable(id) {}
+
+ /** @param {string} id */
+ static onUninstall(id) {}
+
+ /**
+ * @param {string} id
+ * @param {Record<string, JSONValue>} manifest
+ */
+ static onUpdate(id, manifest) {}
+}
+
+/**
+ * Subclass to add APIs commonly used with persistent events.
+ * If a namespace uses events, it should use this subclass.
+ *
+ * this.apiNamespace = class extends ExtensionAPIPersistent {};
+ */
+class ExtensionAPIPersistent extends ExtensionAPI {
+ /** @type {Record<string, callback>} */
+ PERSISTENT_EVENTS;
+
+ /**
+ * Check for event entry.
+ *
+ * @param {string} event The event name e.g. onStateChanged
+ * @returns {boolean}
+ */
+ hasEventRegistrar(event) {
+ return (
+ this.PERSISTENT_EVENTS && Object.hasOwn(this.PERSISTENT_EVENTS, event)
+ );
+ }
+
+ /**
+ * Get the event registration fuction
+ *
+ * @param {string} event The event name e.g. onStateChanged
+ * @returns {Function} register is used to start the listener
+ * register returns an object containing
+ * a convert and unregister function.
+ */
+ getEventRegistrar(event) {
+ if (this.hasEventRegistrar(event)) {
+ return this.PERSISTENT_EVENTS[event].bind(this);
+ }
+ }
+
+ /**
+ * Used when instantiating an EventManager instance to register the listener.
+ *
+ * @param {object} options Options used for event registration
+ * @param {BaseContext} options.context Extension Context passed when creating an EventManager instance.
+ * @param {string} options.event The eAPI vent name.
+ * @param {Function} options.fire The function passed to the listener to fire the event.
+ * @param {Array<any>} params An optional array of parameters received along with the
+ * addListener request.
+ * @returns {Function} The unregister function used in the EventManager.
+ */
+ registerEventListener(options, params) {
+ const apiRegistar = this.getEventRegistrar(options.event);
+ return apiRegistar?.(options, params).unregister;
+ }
+
+ /**
+ * Used to prime a listener for when the background script is not running.
+ *
+ * @param {string} event The event name e.g. onStateChanged or captiveURL.onChange.
+ * @param {Function} fire The function passed to the listener to fire the event.
+ * @param {Array} params Params passed to the event listener.
+ * @param {boolean} isInStartup unused here but passed for subclass use.
+ * @returns {object} the unregister and convert functions used in the EventManager.
+ */
+ primeListener(event, fire, params, isInStartup) {
+ const apiRegistar = this.getEventRegistrar(event);
+ return apiRegistar?.({ fire, isInStartup }, params);
+ }
+}
+
+/**
+ * This class contains the information we have about an individual
+ * extension. It is never instantiated directly, instead subclasses
+ * for each type of process extend this class and add members that are
+ * relevant for that process.
+ *
+ * @abstract
+ */
+class BaseContext {
+ /** @type {boolean} */
+ isTopContext;
+ /** @type {string} */
+ viewType;
+
+ constructor(envType, extension) {
+ this.envType = envType;
+ this.onClose = new Set();
+ this.checkedLastError = false;
+ this._lastError = null;
+ this.contextId = getUniqueId();
+ this.unloaded = false;
+ this.extension = extension;
+ this.manifestVersion = extension.manifestVersion;
+ this.jsonSandbox = null;
+ this.active = true;
+ this.incognito = null;
+ this.messageManager = null;
+ this.contentWindow = null;
+ this.innerWindowID = 0;
+
+ // These two properties are assigned in ContentScriptContextChild subclass
+ // to keep a copy of the content script sandbox Error and Promise globals
+ // (which are used by the WebExtensions internals) before any extension
+ // content script code had any chance to redefine them.
+ this.cloneScopeError = null;
+ this.cloneScopePromise = null;
+ }
+
+ get isProxyContextParent() {
+ return false;
+ }
+
+ get Error() {
+ // Return the copy stored in the context instance (when the context is an instance of
+ // ContentScriptContextChild or the global from extension page window otherwise).
+ return this.cloneScopeError || this.cloneScope.Error;
+ }
+
+ get Promise() {
+ // Return the copy stored in the context instance (when the context is an instance of
+ // ContentScriptContextChild or the global from extension page window otherwise).
+ return this.cloneScopePromise || this.cloneScope.Promise;
+ }
+
+ get privateBrowsingAllowed() {
+ return this.extension.privateBrowsingAllowed;
+ }
+
+ get isBackgroundContext() {
+ if (this.viewType === "background") {
+ if (this.isProxyContextParent) {
+ return !!this.isTopContext; // Set in ExtensionPageContextParent.
+ }
+ const { contentWindow } = this;
+ return !!contentWindow && contentWindow.top === contentWindow;
+ }
+ return this.viewType === "background_worker";
+ }
+
+ /**
+ * Whether the extension context is using the WebIDL bindings for the
+ * WebExtensions APIs.
+ * To be overridden in subclasses (e.g. WorkerContextChild) and to be
+ * optionally used in ExtensionAPI classes to customize the behavior of the
+ * API when the calls to the extension API are originated from the WebIDL
+ * bindings.
+ */
+ get useWebIDLBindings() {
+ return false;
+ }
+
+ canAccessWindow(window) {
+ return this.extension.canAccessWindow(window);
+ }
+
+ canAccessContainer(userContextId) {
+ return this.extension.canAccessContainer(userContextId);
+ }
+
+ /**
+ * Opens a conduit linked to this context, populating related address fields.
+ * Only available in child contexts with an associated contentWindow.
+ *
+ * @param {object} subject
+ * @param {ConduitAddress} address
+ * @returns {import("ConduitsChild.sys.mjs").PointConduit}
+ * @type {ConduitOpen}
+ */
+ openConduit(subject, address) {
+ let wgc = this.contentWindow.windowGlobalChild;
+ let conduit = wgc.getActor("Conduits").openConduit(subject, {
+ id: subject.id || getUniqueId(),
+ extensionId: this.extension.id,
+ envType: this.envType,
+ ...address,
+ });
+ this.callOnClose(conduit);
+ conduit.setCloseCallback(() => {
+ this.forgetOnClose(conduit);
+ });
+ return conduit;
+ }
+
+ setContentWindow(contentWindow) {
+ if (!this.canAccessWindow(contentWindow)) {
+ throw new Error(
+ "BaseContext attempted to load when extension is not allowed due to incognito settings."
+ );
+ }
+
+ this.innerWindowID = getInnerWindowID(contentWindow);
+ this.messageManager = contentWindow.docShell.messageManager;
+
+ if (this.incognito == null) {
+ this.incognito =
+ lazy.PrivateBrowsingUtils.isContentWindowPrivate(contentWindow);
+ }
+
+ let wgc = contentWindow.windowGlobalChild;
+ Object.defineProperty(this, "active", {
+ configurable: true,
+ enumerable: true,
+ get: () => wgc.isCurrentGlobal && !wgc.windowContext.isInBFCache,
+ });
+ Object.defineProperty(this, "contentWindow", {
+ configurable: true,
+ enumerable: true,
+ get: () => (this.active ? wgc.browsingContext.window : null),
+ });
+ this.callOnClose({
+ close: () => {
+ // Allow other "close" handlers to use these properties, until the next tick.
+ Promise.resolve().then(() => {
+ Object.defineProperty(this, "contentWindow", { value: null });
+ Object.defineProperty(this, "active", { value: false });
+ wgc = null;
+ });
+ },
+ });
+ }
+
+ // All child contexts must implement logActivity. This is handled if the child
+ // context subclasses ExtensionBaseContextChild. ProxyContextParent overrides
+ // this with a noop for parent contexts.
+ logActivity(type, name, data) {
+ throw new Error(`Not implemented for ${this.envType}`);
+ }
+
+ /** @type {object} */
+ get cloneScope() {
+ throw new Error("Not implemented");
+ }
+
+ /** @type {nsIPrincipal} */
+ get principal() {
+ throw new Error("Not implemented");
+ }
+
+ runSafe(callback, ...args) {
+ return this.applySafe(callback, args);
+ }
+
+ runSafeWithoutClone(callback, ...args) {
+ return this.applySafeWithoutClone(callback, args);
+ }
+
+ applySafe(callback, args, caller) {
+ if (this.unloaded) {
+ Cu.reportError("context.runSafe called after context unloaded", caller);
+ } else if (!this.active) {
+ Cu.reportError(
+ "context.runSafe called while context is inactive",
+ caller
+ );
+ } else {
+ try {
+ let { cloneScope } = this;
+ args = args.map(arg => Cu.cloneInto(arg, cloneScope));
+ } catch (e) {
+ Cu.reportError(e);
+ dump(
+ `runSafe failure: cloning into ${
+ this.cloneScope
+ }: ${e}\n\n${filterStack(Error())}`
+ );
+ }
+
+ return this.applySafeWithoutClone(callback, args, caller);
+ }
+ }
+
+ applySafeWithoutClone(callback, args, caller) {
+ if (this.unloaded) {
+ Cu.reportError(
+ "context.runSafeWithoutClone called after context unloaded",
+ caller
+ );
+ } else if (!this.active) {
+ Cu.reportError(
+ "context.runSafeWithoutClone called while context is inactive",
+ caller
+ );
+ } else {
+ try {
+ return Reflect.apply(callback, null, args);
+ } catch (e) {
+ // An extension listener may as well be throwing an object that isn't
+ // an instance of Error, in that case we have to use fallbacks for the
+ // error message, fileName, lineNumber and columnNumber properties.
+ const isError = e instanceof this.Error;
+ let message;
+ let fileName;
+ let lineNumber;
+ let columnNumber;
+
+ if (isError) {
+ message = `${e.name}: ${e.message}`;
+ lineNumber = e.lineNumber;
+ columnNumber = e.columnNumber;
+ fileName = e.fileName;
+ } else {
+ message = `uncaught exception: ${e}`;
+
+ try {
+ // TODO(Bug 1810582): the following fallback logic may go away once
+ // we introduced a better way to capture and log the exception in
+ // the right window and in all cases (included when the extension
+ // code is raising undefined or an object that isn't an instance of
+ // the Error constructor).
+ //
+ // Fallbacks for the error location:
+ // - the callback location if it is registered directly from the
+ // extension code (and not wrapped by the child/ext-APINAMe.js
+ // implementation, like e.g. browser.storage, browser.devtools.network
+ // are doing and browser.menus).
+ // - if the location of the extension callback is not directly
+ // available (e.g. browser.storage onChanged events, and similarly
+ // for browser.devtools.network and browser.menus events):
+ // - the extension page url if the context is an extension page
+ // - the extension base url if the context is a content script
+ const cbLoc = Cu.getFunctionSourceLocation(callback);
+ fileName = cbLoc.filename;
+ lineNumber = cbLoc.lineNumber ?? lineNumber;
+
+ const extBaseUrl = this.extension.baseURI.resolve("/");
+ if (fileName.startsWith(extBaseUrl)) {
+ fileName = cbLoc.filename;
+ lineNumber = cbLoc.lineNumber ?? lineNumber;
+ } else {
+ fileName = this.contentWindow?.location?.href;
+ if (!fileName || !fileName.startsWith(extBaseUrl)) {
+ fileName = extBaseUrl;
+ }
+ }
+ } catch {
+ // Ignore errors on retrieving the callback source location.
+ }
+ }
+
+ dump(
+ `Extension error: ${message} ${fileName} ${lineNumber}\n[[Exception stack\n${
+ isError ? filterStack(e) : undefined
+ }Current stack\n${filterStack(Error())}]]\n`
+ );
+
+ // If the error is coming from an extension context associated
+ // to a window (e.g. an extension page or extension content script).
+ //
+ // TODO(Bug 1810574): for the background service worker we will need to do
+ // something similar, but not tied to the innerWindowID because there
+ // wouldn't be one set for extension contexts related to the
+ // background service worker.
+ //
+ // TODO(Bug 1810582): change the error associated to the innerWindowID to also
+ // include a full stack from the original error.
+ if (!this.isProxyContextParent && this.contentWindow) {
+ Services.console.logMessage(
+ new ScriptError(
+ message,
+ fileName,
+ null,
+ lineNumber,
+ columnNumber,
+ Ci.nsIScriptError.errorFlag,
+ "content javascript",
+ this.innerWindowID
+ )
+ );
+ }
+ // Also report the original error object (because it also includes
+ // the full error stack).
+ Cu.reportError(e);
+ }
+ }
+ }
+
+ checkLoadURL(url, options = {}) {
+ // As an optimization, f the URL starts with the extension's base URL,
+ // don't do any further checks. It's always allowed to load it.
+ if (url.startsWith(this.extension.baseURL)) {
+ return true;
+ }
+
+ return checkLoadURL(url, this.principal, options);
+ }
+
+ /**
+ * Safely call JSON.stringify() on an object that comes from an
+ * extension.
+ *
+ * @param {[any, callback?, number?]} args for JSON.stringify()
+ * @returns {string} The stringified representation of obj
+ */
+ jsonStringify(...args) {
+ if (!this.jsonSandbox) {
+ this.jsonSandbox = Cu.Sandbox(this.principal, {
+ sameZoneAs: this.cloneScope,
+ wantXrays: false,
+ });
+ }
+
+ return Cu.waiveXrays(this.jsonSandbox.JSON).stringify(...args);
+ }
+
+ callOnClose(obj) {
+ this.onClose.add(obj);
+ }
+
+ forgetOnClose(obj) {
+ this.onClose.delete(obj);
+ }
+
+ get lastError() {
+ this.checkedLastError = true;
+ return this._lastError;
+ }
+
+ set lastError(val) {
+ this.checkedLastError = false;
+ this._lastError = val;
+ }
+
+ /**
+ * Normalizes the given error object for use by the target scope. If
+ * the target is an error object which belongs to that scope, it is
+ * returned as-is. If it is an ordinary object with a `message`
+ * property, it is converted into an error belonging to the target
+ * scope. If it is an Error object which does *not* belong to the
+ * clone scope, it is reported, and converted to an unexpected
+ * exception error.
+ *
+ * @param {Error|object} error
+ * @param {SavedFrame?} [caller]
+ * @returns {Error}
+ */
+ normalizeError(error, caller) {
+ if (error instanceof this.Error) {
+ return error;
+ }
+ let message, fileName;
+ if (error && typeof error === "object") {
+ const isPlain = ChromeUtils.getClassName(error) === "Object";
+ if (isPlain && error.mozWebExtLocation) {
+ caller = error.mozWebExtLocation;
+ }
+ if (isPlain && caller && (error.mozWebExtLocation || !error.fileName)) {
+ caller = Cu.cloneInto(caller, this.cloneScope);
+ return ChromeUtils.createError(error.message, caller);
+ }
+
+ if (
+ isPlain ||
+ error instanceof ExtensionError ||
+ this.principal.subsumes(Cu.getObjectPrincipal(error))
+ ) {
+ message = error.message;
+ fileName = error.fileName;
+ }
+ }
+
+ if (!message) {
+ Cu.reportError(error);
+ message = "An unexpected error occurred";
+ }
+ return new this.Error(message, fileName);
+ }
+
+ /**
+ * Sets the value of `.lastError` to `error`, calls the given
+ * callback, and reports an error if the value has not been checked
+ * when the callback returns.
+ *
+ * @param {object} error An object with a `message` property. May
+ * optionally be an `Error` object belonging to the target scope.
+ * @param {SavedFrame?} caller
+ * The optional caller frame which triggered this callback, to be used
+ * in error reporting.
+ * @param {Function} callback The callback to call.
+ * @returns {*} The return value of callback.
+ */
+ withLastError(error, caller, callback) {
+ this.lastError = this.normalizeError(error);
+ try {
+ return callback();
+ } finally {
+ if (!this.checkedLastError) {
+ Cu.reportError(`Unchecked lastError value: ${this.lastError}`, caller);
+ }
+ this.lastError = null;
+ }
+ }
+
+ /**
+ * Captures the most recent stack frame which belongs to the extension.
+ *
+ * @returns {SavedFrame?}
+ */
+ getCaller() {
+ return ChromeUtils.getCallerLocation(this.principal);
+ }
+
+ /**
+ * Wraps the given promise so it can be safely returned to extension
+ * code in this context.
+ *
+ * If `callback` is provided, however, it is used as a completion
+ * function for the promise, and no promise is returned. In this case,
+ * the callback is called when the promise resolves or rejects. In the
+ * latter case, `lastError` is set to the rejection value, and the
+ * callback function must check `browser.runtime.lastError` or
+ * `extension.runtime.lastError` in order to prevent it being reported
+ * to the console.
+ *
+ * @param {Promise} promise The promise with which to wrap the
+ * callback. May resolve to a `SpreadArgs` instance, in which case
+ * each element will be used as a separate argument.
+ *
+ * Unless the promise object belongs to the cloneScope global, its
+ * resolution value is cloned into cloneScope prior to calling the
+ * `callback` function or resolving the wrapped promise.
+ *
+ * @param {Function} [callback] The callback function to wrap
+ *
+ * @returns {Promise|undefined} If callback is null, a promise object
+ * belonging to the target scope. Otherwise, undefined.
+ */
+ wrapPromise(promise, callback = null) {
+ let caller = this.getCaller();
+ let applySafe = this.applySafe.bind(this);
+ if (Cu.getGlobalForObject(promise) === this.cloneScope) {
+ applySafe = this.applySafeWithoutClone.bind(this);
+ }
+
+ if (callback) {
+ promise.then(
+ args => {
+ if (this.unloaded) {
+ Cu.reportError(`Promise resolved after context unloaded\n`, caller);
+ } else if (!this.active) {
+ Cu.reportError(
+ `Promise resolved while context is inactive\n`,
+ caller
+ );
+ } else if (args instanceof NoCloneSpreadArgs) {
+ this.applySafeWithoutClone(callback, args.unwrappedValues, caller);
+ } else if (args instanceof SpreadArgs) {
+ applySafe(callback, args, caller);
+ } else {
+ applySafe(callback, [args], caller);
+ }
+ },
+ error => {
+ this.withLastError(error, caller, () => {
+ if (this.unloaded) {
+ Cu.reportError(
+ `Promise rejected after context unloaded\n`,
+ caller
+ );
+ } else if (!this.active) {
+ Cu.reportError(
+ `Promise rejected while context is inactive\n`,
+ caller
+ );
+ } else {
+ this.applySafeWithoutClone(callback, [], caller);
+ }
+ });
+ }
+ );
+ } else {
+ return new this.Promise((resolve, reject) => {
+ promise.then(
+ value => {
+ if (this.unloaded) {
+ Cu.reportError(
+ `Promise resolved after context unloaded\n`,
+ caller
+ );
+ } else if (!this.active) {
+ Cu.reportError(
+ `Promise resolved while context is inactive\n`,
+ caller
+ );
+ } else if (value instanceof NoCloneSpreadArgs) {
+ let values = value.unwrappedValues;
+ this.applySafeWithoutClone(
+ resolve,
+ values.length == 1 ? [values[0]] : [values],
+ caller
+ );
+ } else if (value instanceof SpreadArgs) {
+ applySafe(resolve, value.length == 1 ? value : [value], caller);
+ } else {
+ applySafe(resolve, [value], caller);
+ }
+ },
+ value => {
+ if (this.unloaded) {
+ Cu.reportError(
+ `Promise rejected after context unloaded: ${
+ value && value.message
+ }\n`,
+ caller
+ );
+ } else if (!this.active) {
+ Cu.reportError(
+ `Promise rejected while context is inactive: ${
+ value && value.message
+ }\n`,
+ caller
+ );
+ } else {
+ this.applySafeWithoutClone(
+ reject,
+ [this.normalizeError(value, caller)],
+ caller
+ );
+ }
+ }
+ );
+ });
+ }
+ }
+
+ unload() {
+ this.unloaded = true;
+
+ for (let obj of this.onClose) {
+ obj.close();
+ }
+ this.onClose.clear();
+ }
+
+ /**
+ * A simple proxy for unload(), for use with callOnClose().
+ */
+ close() {
+ this.unload();
+ }
+}
+
+/**
+ * An object that runs the implementation of a schema API. Instantiations of
+ * this interfaces are used by Schemas.jsm.
+ *
+ * @interface
+ */
+class SchemaAPIInterface {
+ /**
+ * Calls this as a function that returns its return value.
+ *
+ * @abstract
+ * @param {Array} args The parameters for the function.
+ * @returns {*} The return value of the invoked function.
+ */
+ callFunction(args) {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Calls this as a function and ignores its return value.
+ *
+ * @abstract
+ * @param {Array} args The parameters for the function.
+ */
+ callFunctionNoReturn(args) {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Calls this as a function that completes asynchronously.
+ *
+ * @abstract
+ * @param {Array} args The parameters for the function.
+ * @param {callback} [callback] The callback to be called when the function
+ * completes.
+ * @param {boolean} [requireUserInput=false] If true, the function should
+ * fail if the browser is not currently handling user input.
+ * @returns {Promise|undefined} Must be void if `callback` is set, and a
+ * promise otherwise. The promise is resolved when the function completes.
+ */
+ callAsyncFunction(args, callback, requireUserInput = false) {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Retrieves the value of this as a property.
+ *
+ * @abstract
+ * @returns {*} The value of the property.
+ */
+ getProperty() {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Assigns the value to this as property.
+ *
+ * @abstract
+ * @param {string} value The new value of the property.
+ */
+ setProperty(value) {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Registers a `listener` to this as an event.
+ *
+ * @abstract
+ * @param {Function} listener The callback to be called when the event fires.
+ * @param {Array} args Extra parameters for EventManager.addListener.
+ * @see EventManager.addListener
+ */
+ addListener(listener, args) {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Checks whether `listener` is listening to this as an event.
+ *
+ * @abstract
+ * @param {Function} listener The event listener.
+ * @returns {boolean} Whether `listener` is registered with this as an event.
+ * @see EventManager.hasListener
+ */
+ hasListener(listener) {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Unregisters `listener` from this as an event.
+ *
+ * @abstract
+ * @param {Function} listener The event listener.
+ * @see EventManager.removeListener
+ */
+ removeListener(listener) {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Revokes the implementation object, and prevents any further method
+ * calls from having external effects.
+ *
+ * @abstract
+ */
+ revoke() {
+ throw new Error("Not implemented");
+ }
+}
+
+/**
+ * An object that runs a locally implemented API.
+ */
+class LocalAPIImplementation extends SchemaAPIInterface {
+ /**
+ * Constructs an implementation of the `name` method or property of `pathObj`.
+ *
+ * @param {object} pathObj The object containing the member with name `name`.
+ * @param {string} name The name of the implemented member.
+ * @param {BaseContext} context The context in which the schema is injected.
+ */
+ constructor(pathObj, name, context) {
+ super();
+ this.pathObj = pathObj;
+ this.name = name;
+ this.context = context;
+ }
+
+ revoke() {
+ if (this.pathObj[this.name][lazy.Schemas.REVOKE]) {
+ this.pathObj[this.name][lazy.Schemas.REVOKE]();
+ }
+
+ this.pathObj = null;
+ this.name = null;
+ this.context = null;
+ }
+
+ callFunction(args) {
+ try {
+ return this.pathObj[this.name](...args);
+ } catch (e) {
+ throw this.context.normalizeError(e);
+ }
+ }
+
+ callFunctionNoReturn(args) {
+ try {
+ this.pathObj[this.name](...args);
+ } catch (e) {
+ throw this.context.normalizeError(e);
+ }
+ }
+
+ callAsyncFunction(args, callback, requireUserInput) {
+ let promise;
+ try {
+ if (requireUserInput) {
+ if (!this.context.contentWindow.windowUtils.isHandlingUserInput) {
+ throw new ExtensionError(
+ `${this.name} may only be called from a user input handler`
+ );
+ }
+ }
+ promise = this.pathObj[this.name](...args) || Promise.resolve();
+ } catch (e) {
+ promise = Promise.reject(e);
+ }
+ return this.context.wrapPromise(promise, callback);
+ }
+
+ getProperty() {
+ return this.pathObj[this.name];
+ }
+
+ setProperty(value) {
+ this.pathObj[this.name] = value;
+ }
+
+ addListener(listener, args) {
+ try {
+ this.pathObj[this.name].addListener.call(null, listener, ...args);
+ } catch (e) {
+ throw this.context.normalizeError(e);
+ }
+ }
+
+ hasListener(listener) {
+ return this.pathObj[this.name].hasListener.call(null, listener);
+ }
+
+ removeListener(listener) {
+ this.pathObj[this.name].removeListener.call(null, listener);
+ }
+}
+
+// Recursively copy properties from source to dest.
+function deepCopy(dest, source) {
+ for (let prop in source) {
+ let desc = Object.getOwnPropertyDescriptor(source, prop);
+ if (typeof desc.value == "object") {
+ if (!(prop in dest)) {
+ dest[prop] = {};
+ }
+ deepCopy(dest[prop], source[prop]);
+ } else {
+ Object.defineProperty(dest, prop, desc);
+ }
+ }
+}
+
+function getChild(map, key) {
+ let child = map.children.get(key);
+ if (!child) {
+ child = {
+ modules: new Set(),
+ children: new Map(),
+ };
+
+ map.children.set(key, child);
+ }
+ return child;
+}
+
+function getPath(map, path) {
+ for (let key of path) {
+ map = getChild(map, key);
+ }
+ return map;
+}
+
+function mergePaths(dest, source) {
+ for (let name of source.modules) {
+ dest.modules.add(name);
+ }
+
+ for (let [name, child] of source.children.entries()) {
+ mergePaths(getChild(dest, name), child);
+ }
+}
+
+/**
+ * Manages loading and accessing a set of APIs for a specific extension
+ * context.
+ *
+ * @param {BaseContext} context
+ * The context to manage APIs for.
+ * @param {SchemaAPIManager} apiManager
+ * The API manager holding the APIs to manage.
+ * @param {object} root
+ * The root object into which APIs will be injected.
+ */
+class CanOfAPIs {
+ constructor(context, apiManager, root) {
+ this.context = context;
+ this.scopeName = context.envType;
+ this.apiManager = apiManager;
+ this.root = root;
+
+ this.apiPaths = new Map();
+
+ this.apis = new Map();
+ }
+
+ /**
+ * Synchronously loads and initializes an ExtensionAPI instance.
+ *
+ * @param {string} name
+ * The name of the API to load.
+ */
+ loadAPI(name) {
+ if (this.apis.has(name)) {
+ return;
+ }
+
+ let { extension } = this.context;
+
+ let api = this.apiManager.getAPI(name, extension, this.scopeName);
+ if (!api) {
+ return;
+ }
+
+ this.apis.set(name, api);
+
+ deepCopy(this.root, api.getAPI(this.context));
+ }
+
+ /**
+ * Asynchronously loads and initializes an ExtensionAPI instance.
+ *
+ * @param {string} name
+ * The name of the API to load.
+ */
+ async asyncLoadAPI(name) {
+ if (this.apis.has(name)) {
+ return;
+ }
+
+ let { extension } = this.context;
+ if (!lazy.Schemas.checkPermissions(name, extension)) {
+ return;
+ }
+
+ let api = await this.apiManager.asyncGetAPI(
+ name,
+ extension,
+ this.scopeName
+ );
+ // Check again, because async;
+ if (this.apis.has(name)) {
+ return;
+ }
+
+ this.apis.set(name, api);
+
+ deepCopy(this.root, api.getAPI(this.context));
+ }
+
+ /**
+ * Finds the API at the given path from the root object, and
+ * synchronously loads the API that implements it if it has not
+ * already been loaded.
+ *
+ * @param {string} path
+ * The "."-separated path to find.
+ * @returns {*}
+ */
+ findAPIPath(path) {
+ if (this.apiPaths.has(path)) {
+ return this.apiPaths.get(path);
+ }
+
+ let obj = this.root;
+ let modules = this.apiManager.modulePaths;
+
+ let parts = path.split(".");
+ for (let [i, key] of parts.entries()) {
+ if (!obj) {
+ return;
+ }
+ modules = getChild(modules, key);
+
+ for (let name of modules.modules) {
+ if (!this.apis.has(name)) {
+ this.loadAPI(name);
+ }
+ }
+
+ if (!(key in obj) && i < parts.length - 1) {
+ obj[key] = {};
+ }
+ obj = obj[key];
+ }
+
+ this.apiPaths.set(path, obj);
+ return obj;
+ }
+
+ /**
+ * Finds the API at the given path from the root object, and
+ * asynchronously loads the API that implements it if it has not
+ * already been loaded.
+ *
+ * @param {string} path
+ * The "."-separated path to find.
+ * @returns {Promise<*>}
+ */
+ async asyncFindAPIPath(path) {
+ if (this.apiPaths.has(path)) {
+ return this.apiPaths.get(path);
+ }
+
+ let obj = this.root;
+ let modules = this.apiManager.modulePaths;
+
+ let parts = path.split(".");
+ for (let [i, key] of parts.entries()) {
+ if (!obj) {
+ return;
+ }
+ modules = getChild(modules, key);
+
+ for (let name of modules.modules) {
+ if (!this.apis.has(name)) {
+ await this.asyncLoadAPI(name);
+ }
+ }
+
+ if (!(key in obj) && i < parts.length - 1) {
+ obj[key] = {};
+ }
+
+ if (typeof obj[key] === "function") {
+ obj = obj[key].bind(obj);
+ } else {
+ obj = obj[key];
+ }
+ }
+
+ this.apiPaths.set(path, obj);
+ return obj;
+ }
+}
+
+/**
+ * @class APIModule
+ * @abstract
+ *
+ * @property {string} url
+ * The URL of the script which contains the module's
+ * implementation. This script must define a global property
+ * matching the modules name, which must be a class constructor
+ * which inherits from {@link ExtensionAPI}.
+ *
+ * @property {string} schema
+ * The URL of the JSON schema which describes the module's API.
+ *
+ * @property {Array<string>} scopes
+ * The list of scope names into which the API may be loaded.
+ *
+ * @property {Array<string>} manifest
+ * The list of top-level manifest properties which will trigger
+ * the module to be loaded, and its `onManifestEntry` method to be
+ * called.
+ *
+ * @property {Array<string>} events
+ * The list events which will trigger the module to be loaded, and
+ * its appropriate event handler method to be called. Currently
+ * only accepts "startup".
+ *
+ * @property {Array<string>} permissions
+ * An optional list of permissions, any of which must be present
+ * in order for the module to load.
+ *
+ * @property {Array<Array<string>>} paths
+ * A list of paths from the root API object which, when accessed,
+ * will cause the API module to be instantiated and injected.
+ */
+
+/**
+ * This object loads the ext-*.js scripts that define the extension API.
+ *
+ * This class instance is shared with the scripts that it loads, so that the
+ * ext-*.js scripts and the instantiator can communicate with each other.
+ */
+class SchemaAPIManager extends EventEmitter {
+ /**
+ * @param {string} processType
+ * "main" - The main, one and only chrome browser process.
+ * "addon" - An addon process.
+ * "content" - A content process.
+ * "devtools" - A devtools process.
+ * @param {import("Schemas.sys.mjs").SchemaRoot} [schema]
+ */
+ constructor(processType, schema) {
+ super();
+ this.processType = processType;
+ this.global = null;
+ if (schema) {
+ this.schema = schema;
+ }
+
+ this.modules = new Map();
+ this.modulePaths = { children: new Map(), modules: new Set() };
+ this.manifestKeys = new Map();
+ this.eventModules = new DefaultMap(() => new Set());
+ this.settingsModules = new Set();
+
+ this._modulesJSONLoaded = false;
+
+ this.schemaURLs = new Map();
+
+ this.apis = new DefaultWeakMap(() => new Map());
+
+ this._scriptScopes = [];
+ }
+
+ onStartup(extension) {
+ let promises = [];
+ for (let apiName of this.eventModules.get("startup")) {
+ promises.push(
+ extension.apiManager.asyncGetAPI(apiName, extension).then(api => {
+ if (api) {
+ api.onStartup();
+ }
+ })
+ );
+ }
+
+ return Promise.all(promises);
+ }
+
+ async loadModuleJSON(urls) {
+ let promises = urls.map(url => fetch(url).then(resp => resp.json()));
+
+ return this.initModuleJSON(await Promise.all(promises));
+ }
+
+ initModuleJSON(blobs) {
+ for (let json of blobs) {
+ this.registerModules(json);
+ }
+
+ this._modulesJSONLoaded = true;
+
+ return new StructuredCloneHolder("SchemaAPIManager/initModuleJSON", null, {
+ modules: this.modules,
+ modulePaths: this.modulePaths,
+ manifestKeys: this.manifestKeys,
+ eventModules: this.eventModules,
+ settingsModules: this.settingsModules,
+ schemaURLs: this.schemaURLs,
+ });
+ }
+
+ initModuleData(moduleData) {
+ if (!this._modulesJSONLoaded) {
+ let data = moduleData.deserialize({}, true);
+
+ this.modules = data.modules;
+ this.modulePaths = data.modulePaths;
+ this.manifestKeys = data.manifestKeys;
+ this.eventModules = new DefaultMap(() => new Set(), data.eventModules);
+ this.settingsModules = new Set(data.settingsModules);
+ this.schemaURLs = data.schemaURLs;
+ }
+
+ this._modulesJSONLoaded = true;
+ }
+
+ /**
+ * Registers a set of ExtensionAPI modules to be lazily loaded and
+ * managed by this manager.
+ *
+ * @param {object} obj
+ * An object containing property for eacy API module to be
+ * registered. Each value should be an object implementing the
+ * APIModule interface.
+ */
+ registerModules(obj) {
+ for (let [name, details] of Object.entries(obj)) {
+ details.namespaceName = name;
+
+ if (this.modules.has(name)) {
+ throw new Error(`Module '${name}' already registered`);
+ }
+ this.modules.set(name, details);
+
+ if (details.schema) {
+ let content =
+ details.scopes &&
+ (details.scopes.includes("content_parent") ||
+ details.scopes.includes("content_child"));
+ this.schemaURLs.set(details.schema, { content });
+ }
+
+ for (let event of details.events || []) {
+ this.eventModules.get(event).add(name);
+ }
+
+ if (details.settings) {
+ this.settingsModules.add(name);
+ }
+
+ for (let key of details.manifest || []) {
+ if (this.manifestKeys.has(key)) {
+ throw new Error(
+ `Manifest key '${key}' already registered by '${this.manifestKeys.get(
+ key
+ )}'`
+ );
+ }
+
+ this.manifestKeys.set(key, name);
+ }
+
+ for (let path of details.paths || []) {
+ getPath(this.modulePaths, path).modules.add(name);
+ }
+ }
+ }
+
+ /**
+ * Emits an `onManifestEntry` event for the top-level manifest entry
+ * on all relevant {@link ExtensionAPI} instances for the given
+ * extension.
+ *
+ * The API modules will be synchronously loaded if they have not been
+ * loaded already.
+ *
+ * @param {Extension} extension
+ * The extension for which to emit the events.
+ * @param {string} entry
+ * The name of the top-level manifest entry.
+ *
+ * @returns {*}
+ */
+ emitManifestEntry(extension, entry) {
+ let apiName = this.manifestKeys.get(entry);
+ if (apiName) {
+ let api = extension.apiManager.getAPI(apiName, extension);
+ return api.onManifestEntry(entry);
+ }
+ }
+ /**
+ * Emits an `onManifestEntry` event for the top-level manifest entry
+ * on all relevant {@link ExtensionAPI} instances for the given
+ * extension.
+ *
+ * The API modules will be asynchronously loaded if they have not been
+ * loaded already.
+ *
+ * @param {Extension} extension
+ * The extension for which to emit the events.
+ * @param {string} entry
+ * The name of the top-level manifest entry.
+ *
+ * @returns {Promise<*>}
+ */
+ async asyncEmitManifestEntry(extension, entry) {
+ let apiName = this.manifestKeys.get(entry);
+ if (apiName) {
+ let api = await extension.apiManager.asyncGetAPI(apiName, extension);
+ return api.onManifestEntry(entry);
+ }
+ }
+
+ /**
+ * Returns the {@link ExtensionAPI} instance for the given API module,
+ * for the given extension, in the given scope, synchronously loading
+ * and instantiating it if necessary.
+ *
+ * @param {string} name
+ * The name of the API module to load.
+ * @param {Extension} extension
+ * The extension for which to load the API.
+ * @param {string} [scope = null]
+ * The scope type for which to retrieve the API, or null if not
+ * being retrieved for a particular scope.
+ *
+ * @returns {ExtensionAPI?}
+ */
+ getAPI(name, extension, scope = null) {
+ if (!this._checkGetAPI(name, extension, scope)) {
+ return;
+ }
+
+ let apis = this.apis.get(extension);
+ if (apis.has(name)) {
+ return apis.get(name);
+ }
+
+ let module = this.loadModule(name);
+
+ let api = new module(extension);
+ apis.set(name, api);
+ return api;
+ }
+ /**
+ * Returns the {@link ExtensionAPI} instance for the given API module,
+ * for the given extension, in the given scope, asynchronously loading
+ * and instantiating it if necessary.
+ *
+ * @param {string} name
+ * The name of the API module to load.
+ * @param {Extension} extension
+ * The extension for which to load the API.
+ * @param {string} [scope = null]
+ * The scope type for which to retrieve the API, or null if not
+ * being retrieved for a particular scope.
+ *
+ * @returns {Promise<ExtensionAPI>?}
+ */
+ async asyncGetAPI(name, extension, scope = null) {
+ if (!this._checkGetAPI(name, extension, scope)) {
+ return;
+ }
+
+ let apis = this.apis.get(extension);
+ if (apis.has(name)) {
+ return apis.get(name);
+ }
+
+ let module = await this.asyncLoadModule(name);
+
+ // Check again, because async.
+ if (apis.has(name)) {
+ return apis.get(name);
+ }
+
+ let api = new module(extension);
+ apis.set(name, api);
+ return api;
+ }
+
+ /**
+ * Synchronously loads an API module, if not already loaded, and
+ * returns its ExtensionAPI constructor.
+ *
+ * @param {string} name
+ * The name of the module to load.
+ * @returns {typeof ExtensionAPI}
+ */
+ loadModule(name) {
+ let module = this.modules.get(name);
+ if (module.loaded) {
+ return this.global[name];
+ }
+
+ this._checkLoadModule(module, name);
+
+ this.initGlobal();
+
+ Services.scriptloader.loadSubScript(module.url, this.global);
+
+ module.loaded = true;
+
+ return this.global[name];
+ }
+ /**
+ * aSynchronously loads an API module, if not already loaded, and
+ * returns its ExtensionAPI constructor.
+ *
+ * @param {string} name
+ * The name of the module to load.
+ *
+ * @returns {Promise<typeof ExtensionAPI>}
+ */
+ asyncLoadModule(name) {
+ let module = this.modules.get(name);
+ if (module.loaded) {
+ return Promise.resolve(this.global[name]);
+ }
+ if (module.asyncLoaded) {
+ return module.asyncLoaded;
+ }
+
+ this._checkLoadModule(module, name);
+
+ module.asyncLoaded = ChromeUtils.compileScript(module.url).then(script => {
+ this.initGlobal();
+ script.executeInGlobal(this.global);
+
+ module.loaded = true;
+
+ return this.global[name];
+ });
+
+ return module.asyncLoaded;
+ }
+
+ asyncLoadSettingsModules() {
+ return Promise.all(
+ Array.from(this.settingsModules).map(apiName =>
+ this.asyncLoadModule(apiName)
+ )
+ );
+ }
+
+ getModule(name) {
+ return this.modules.get(name);
+ }
+
+ /**
+ * Checks whether the given API module may be loaded for the given
+ * extension, in the given scope.
+ *
+ * @param {string} name
+ * The name of the API module to check.
+ * @param {Extension} extension
+ * The extension for which to check the API.
+ * @param {string} [scope = null]
+ * The scope type for which to check the API, or null if not
+ * being checked for a particular scope.
+ *
+ * @returns {boolean}
+ * Whether the module may be loaded.
+ */
+ _checkGetAPI(name, extension, scope = null) {
+ let module = this.getModule(name);
+ if (!module) {
+ // A module may not exist for a particular manifest version, but
+ // we allow keys in the manifest. An example is pageAction.
+ return false;
+ }
+
+ if (
+ module.permissions &&
+ !module.permissions.some(perm => extension.hasPermission(perm))
+ ) {
+ return false;
+ }
+
+ if (!scope) {
+ return true;
+ }
+
+ if (!module.scopes.includes(scope)) {
+ return false;
+ }
+
+ if (!lazy.Schemas.checkPermissions(module.namespaceName, extension)) {
+ return false;
+ }
+
+ return true;
+ }
+
+ _checkLoadModule(module, name) {
+ if (!module) {
+ throw new Error(`Module '${name}' does not exist`);
+ }
+ if (module.asyncLoaded) {
+ throw new Error(`Module '${name}' currently being lazily loaded`);
+ }
+ if (this.global && this.global[name]) {
+ throw new Error(
+ `Module '${name}' conflicts with existing global property`
+ );
+ }
+ }
+
+ /**
+ * Create a global object that is used as the shared global for all ext-*.js
+ * scripts that are loaded via `loadScript`.
+ *
+ * @returns {object} A sandbox that is used as the global by `loadScript`.
+ */
+ _createExtGlobal() {
+ let global = Cu.Sandbox(
+ Services.scriptSecurityManager.getSystemPrincipal(),
+ {
+ wantXrays: false,
+ wantGlobalProperties: ["ChromeUtils"],
+ sandboxName: `Namespace of ext-*.js scripts for ${this.processType} (from: resource://gre/modules/ExtensionCommon.jsm)`,
+ }
+ );
+
+ Object.assign(global, {
+ AppConstants,
+ Cc,
+ ChromeWorker,
+ Ci,
+ Cr,
+ Cu,
+ ExtensionAPI,
+ ExtensionAPIPersistent,
+ ExtensionCommon,
+ IOUtils,
+ MatchGlob,
+ MatchPattern,
+ MatchPatternSet,
+ PathUtils,
+ Services,
+ StructuredCloneHolder,
+ WebExtensionPolicy,
+ XPCOMUtils,
+ extensions: this,
+ global,
+ });
+
+ ChromeUtils.defineLazyGetter(global, "console", getConsole);
+ // eslint-disable-next-line mozilla/lazy-getter-object-name
+ ChromeUtils.defineESModuleGetters(global, {
+ ExtensionUtils: "resource://gre/modules/ExtensionUtils.sys.mjs",
+ });
+
+ return global;
+ }
+
+ initGlobal() {
+ if (!this.global) {
+ this.global = this._createExtGlobal();
+ }
+ }
+
+ /**
+ * Load an ext-*.js script. The script runs in its own scope, if it wishes to
+ * share state with another script it can assign to the `global` variable. If
+ * it wishes to communicate with this API manager, use `extensions`.
+ *
+ * @param {string} scriptUrl The URL of the ext-*.js script.
+ */
+ loadScript(scriptUrl) {
+ // Create the object in the context of the sandbox so that the script runs
+ // in the sandbox's context instead of here.
+ let scope = Cu.createObjectIn(this.global);
+
+ Services.scriptloader.loadSubScript(scriptUrl, scope);
+
+ // Save the scope to avoid it being garbage collected.
+ this._scriptScopes.push(scope);
+ }
+}
+
+class LazyAPIManager extends SchemaAPIManager {
+ constructor(processType, moduleData, schemaURLs) {
+ super(processType);
+
+ /** @type {Promise | boolean} */
+ this.initialized = false;
+
+ this.initModuleData(moduleData);
+
+ this.schemaURLs = schemaURLs;
+ }
+
+ lazyInit() {}
+}
+
+defineLazyGetter(LazyAPIManager.prototype, "schema", function () {
+ let root = new lazy.SchemaRoot(lazy.Schemas.rootSchema, this.schemaURLs);
+ root.parseSchemas();
+ return root;
+});
+
+class MultiAPIManager extends SchemaAPIManager {
+ constructor(processType, children) {
+ super(processType);
+
+ this.initialized = false;
+
+ this.children = children;
+ }
+
+ async lazyInit() {
+ if (!this.initialized) {
+ this.initialized = true;
+
+ for (let child of this.children) {
+ if (child.lazyInit) {
+ let res = child.lazyInit();
+ if (res && typeof res.then === "function") {
+ await res;
+ }
+ }
+
+ mergePaths(this.modulePaths, child.modulePaths);
+ }
+ }
+ }
+
+ onStartup(extension) {
+ return Promise.all(this.children.map(child => child.onStartup(extension)));
+ }
+
+ getModule(name) {
+ for (let child of this.children) {
+ if (child.modules.has(name)) {
+ return child.modules.get(name);
+ }
+ }
+ }
+
+ loadModule(name) {
+ for (let child of this.children) {
+ if (child.modules.has(name)) {
+ return child.loadModule(name);
+ }
+ }
+ }
+
+ asyncLoadModule(name) {
+ for (let child of this.children) {
+ if (child.modules.has(name)) {
+ return child.asyncLoadModule(name);
+ }
+ }
+ }
+}
+
+defineLazyGetter(MultiAPIManager.prototype, "schema", function () {
+ let bases = this.children.map(child => child.schema);
+
+ // All API manager schema roots should derive from the global schema root,
+ // so it doesn't need its own entry.
+ if (bases[bases.length - 1] === lazy.Schemas) {
+ bases.pop();
+ }
+
+ if (bases.length === 1) {
+ bases = bases[0];
+ }
+ return new lazy.SchemaRoot(bases, new Map());
+});
+
+export function LocaleData(data) {
+ this.defaultLocale = data.defaultLocale;
+ this.selectedLocale = data.selectedLocale;
+ this.locales = data.locales || new Map();
+ this.warnedMissingKeys = new Set();
+
+ // Map(locale-name -> Map(message-key -> localized-string))
+ //
+ // Contains a key for each loaded locale, each of which is a
+ // Map of message keys to their localized strings.
+ this.messages = data.messages || new Map();
+
+ if (data.builtinMessages) {
+ this.messages.set(this.BUILTIN, data.builtinMessages);
+ }
+}
+
+LocaleData.prototype = {
+ // Representation of the object to send to content processes. This
+ // should include anything the content process might need.
+ serialize() {
+ return {
+ defaultLocale: this.defaultLocale,
+ selectedLocale: this.selectedLocale,
+ messages: this.messages,
+ locales: this.locales,
+ };
+ },
+
+ BUILTIN: "@@BUILTIN_MESSAGES",
+
+ has(locale) {
+ return this.messages.has(locale);
+ },
+
+ // https://developer.chrome.com/extensions/i18n
+ localizeMessage(message, substitutions = [], options = {}) {
+ let defaultOptions = {
+ defaultValue: "",
+ cloneScope: null,
+ };
+
+ let locales = this.availableLocales;
+ if (options.locale) {
+ locales = new Set(
+ [this.BUILTIN, options.locale, this.defaultLocale].filter(locale =>
+ this.messages.has(locale)
+ )
+ );
+ }
+
+ options = Object.assign(defaultOptions, options);
+
+ // Message names are case-insensitive, so normalize them to lower-case.
+ message = message.toLowerCase();
+ for (let locale of locales) {
+ let messages = this.messages.get(locale);
+ if (messages.has(message)) {
+ let str = messages.get(message);
+
+ if (!str.includes("$")) {
+ return str;
+ }
+
+ if (!Array.isArray(substitutions)) {
+ substitutions = [substitutions];
+ }
+
+ let replacer = (matched, index, dollarSigns) => {
+ if (index) {
+ // This is not quite Chrome-compatible. Chrome consumes any number
+ // of digits following the $, but only accepts 9 substitutions. We
+ // accept any number of substitutions.
+ index = parseInt(index, 10) - 1;
+ return index in substitutions ? substitutions[index] : "";
+ }
+ // For any series of contiguous `$`s, the first is dropped, and
+ // the rest remain in the output string.
+ return dollarSigns;
+ };
+ return str.replace(/\$(?:([1-9]\d*)|(\$+))/g, replacer);
+ }
+ }
+
+ // Check for certain pre-defined messages.
+ if (message == "@@ui_locale") {
+ return this.uiLocale;
+ } else if (message.startsWith("@@bidi_")) {
+ let rtl = Services.locale.isAppLocaleRTL;
+
+ if (message == "@@bidi_dir") {
+ return rtl ? "rtl" : "ltr";
+ } else if (message == "@@bidi_reversed_dir") {
+ return rtl ? "ltr" : "rtl";
+ } else if (message == "@@bidi_start_edge") {
+ return rtl ? "right" : "left";
+ } else if (message == "@@bidi_end_edge") {
+ return rtl ? "left" : "right";
+ }
+ }
+
+ if (!this.warnedMissingKeys.has(message)) {
+ let error = `Unknown localization message ${message}`;
+ if (options.cloneScope) {
+ error = new options.cloneScope.Error(error);
+ }
+ Cu.reportError(error);
+ this.warnedMissingKeys.add(message);
+ }
+ return options.defaultValue;
+ },
+
+ // Localize a string, replacing all |__MSG_(.*)__| tokens with the
+ // matching string from the current locale, as determined by
+ // |this.selectedLocale|.
+ //
+ // This may not be called before calling either |initLocale| or
+ // |initAllLocales|.
+ localize(str, locale = this.selectedLocale) {
+ if (!str) {
+ return str;
+ }
+
+ return str.replace(/__MSG_([A-Za-z0-9@_]+?)__/g, (matched, message) => {
+ return this.localizeMessage(message, [], {
+ locale,
+ defaultValue: matched,
+ });
+ });
+ },
+
+ // Validates the contents of a locale JSON file, normalizes the
+ // messages into a Map of message key -> localized string pairs.
+ addLocale(locale, messages, extension) {
+ let result = new Map();
+
+ let isPlainObject = obj =>
+ obj &&
+ typeof obj === "object" &&
+ ChromeUtils.getClassName(obj) === "Object";
+
+ // Chrome does not document the semantics of its localization
+ // system very well. It handles replacements by pre-processing
+ // messages, replacing |$[a-zA-Z0-9@_]+$| tokens with the value of their
+ // replacements. Later, it processes the resulting string for
+ // |$[0-9]| replacements.
+ //
+ // Again, it does not document this, but it accepts any number
+ // of sequential |$|s, and replaces them with that number minus
+ // 1. It also accepts |$| followed by any number of sequential
+ // digits, but refuses to process a localized string which
+ // provides more than 9 substitutions.
+ if (!isPlainObject(messages)) {
+ extension.packagingError(`Invalid locale data for ${locale}`);
+ return result;
+ }
+
+ for (let key of Object.keys(messages)) {
+ let msg = messages[key];
+
+ if (!isPlainObject(msg) || typeof msg.message != "string") {
+ extension.packagingError(
+ `Invalid locale message data for ${locale}, message ${JSON.stringify(
+ key
+ )}`
+ );
+ continue;
+ }
+
+ // Substitutions are case-insensitive, so normalize all of their names
+ // to lower-case.
+ let placeholders = new Map();
+ if ("placeholders" in msg && isPlainObject(msg.placeholders)) {
+ for (let key of Object.keys(msg.placeholders)) {
+ placeholders.set(key.toLowerCase(), msg.placeholders[key]);
+ }
+ }
+
+ let replacer = (match, name) => {
+ let replacement = placeholders.get(name.toLowerCase());
+ if (isPlainObject(replacement) && "content" in replacement) {
+ return replacement.content;
+ }
+ return "";
+ };
+
+ let value = msg.message.replace(/\$([A-Za-z0-9@_]+)\$/g, replacer);
+
+ // Message names are also case-insensitive, so normalize them to lower-case.
+ result.set(key.toLowerCase(), value);
+ }
+
+ this.messages.set(locale, result);
+ return result;
+ },
+
+ get acceptLanguages() {
+ let result = Services.prefs.getComplexValue(
+ "intl.accept_languages",
+ Ci.nsIPrefLocalizedString
+ ).data;
+ return result.split(/\s*,\s*/g);
+ },
+
+ get uiLocale() {
+ return Services.locale.appLocaleAsBCP47;
+ },
+
+ get availableLocales() {
+ const locales = [this.BUILTIN, this.selectedLocale, this.defaultLocale];
+ const value = new Set(locales.filter(locale => this.messages.has(locale)));
+ return redefineGetter(this, "availableLocales", value);
+ },
+};
+
+/**
+ * This is a generic class for managing event listeners.
+ *
+ * @example
+ * new EventManager({
+ * context,
+ * name: "api.subAPI",
+ * register: fire => {
+ * let listener = (...) => {
+ * // Fire any listeners registered with addListener.
+ * fire.async(arg1, arg2);
+ * };
+ * // Register the listener.
+ * SomehowRegisterListener(listener);
+ * return () => {
+ * // Return a way to unregister the listener.
+ * SomehowUnregisterListener(listener);
+ * };
+ * }
+ * }).api()
+ *
+ * The result is an object with addListener, removeListener, and
+ * hasListener methods. `context` is an add-on scope (either an
+ * ExtensionContext in the chrome process or ExtensionContext in a
+ * content process).
+ */
+class EventManager {
+ /*
+ * A persistent event must provide module and name. Additionally the
+ * module must implement primeListeners in the ExtensionAPI class.
+ *
+ * A startup blocking event must also add the startupBlocking flag in
+ * ext-toolkit.json or ext-browser.json.
+ *
+ * Listeners synchronously added from a background extension context
+ * will be persisted, for a persistent background script only the
+ * "startup blocking" events will be persisted.
+ *
+ * EventManager instances created in a child process can't persist any listener.
+ *
+ * @param {object} params
+ * Parameters that control this EventManager.
+ * @param {BaseContext} params.context
+ * An object representing the extension instance using this event.
+ * @param {string} params.module
+ * The API module name, required for persistent events.
+ * @param {string} params.event
+ * The API event name, required for persistent events.
+ * @param {ExtensionAPI} params.extensionApi
+ * The API intance. If the API uses the ExtensionAPIPersistent class, some simplification is
+ * possible by passing the api (self or this) and the internal register function will be used.
+ * @param {string} [params.name]
+ * A name used only for debugging. If not provided, name is built from module and event.
+ * @param {functon} params.register
+ * A function called whenever a new listener is added.
+ * @param {boolean} [params.inputHandling=false]
+ * If true, the "handling user input" flag is set while handlers
+ * for this event are executing.
+ */
+ constructor(params) {
+ let {
+ context,
+ module,
+ event,
+ name,
+ register,
+ extensionApi,
+ inputHandling = false,
+ resetIdleOnEvent = true,
+ } = params;
+ this.context = context;
+ this.module = module;
+ this.event = event;
+ this.name = name;
+ this.register = register;
+ this.inputHandling = inputHandling;
+ this.resetIdleOnEvent = resetIdleOnEvent;
+
+ const isBackgroundParent =
+ this.context.envType === "addon_parent" &&
+ this.context.isBackgroundContext;
+
+ // TODO(Bug 1844041): ideally we should restrict resetIdleOnEvent to
+ // EventManager instances that belongs to the event page, but along
+ // with that we should consider if calling sendMessage from an event
+ // page should also reset idle timer, and so in the shorter term
+ // here we are allowing listeners from other extension pages to
+ // also reset the idle timer.
+ const isAddonContext = ["addon_parent", "addon_child"].includes(
+ this.context.envType
+ );
+
+ // Avoid resetIdleOnEvent overhead by only consider it when applicable.
+ if (!isAddonContext || context.extension.persistentBackground) {
+ this.resetIdleOnEvent = false;
+ }
+
+ if (!name) {
+ this.name = `${module}.${event}`;
+ }
+
+ if (!this.register && extensionApi instanceof ExtensionAPIPersistent) {
+ this.register = (fire, ...params) => {
+ return extensionApi.registerEventListener(
+ { context, event, fire },
+ params
+ );
+ };
+ }
+ if (!this.register) {
+ throw new Error(
+ `EventManager requires register method for ${this.name}.`
+ );
+ }
+
+ this.canPersistEvents = module && event && isBackgroundParent;
+
+ if (this.canPersistEvents) {
+ let { extension } = context;
+ if (extension.persistentBackground) {
+ // Persistent backgrounds will only persist startup blocking APIs.
+ let api_module = extension.apiManager.getModule(this.module);
+ if (!api_module?.startupBlocking) {
+ this.canPersistEvents = false;
+ }
+ } else {
+ // Event pages will persist all APIs that implement primeListener.
+ // The api is already loaded so this does not have performance effect.
+ let api = extension.apiManager.getAPI(
+ this.module,
+ extension,
+ "addon_parent"
+ );
+
+ // If the api doesn't implement primeListener we do not persist the events.
+ if (!api?.primeListener) {
+ this.canPersistEvents = false;
+ }
+ }
+ }
+
+ this.unregister = new Map();
+ this.remove = new Map();
+ }
+
+ /*
+ * Information about listeners to persistent events is associated with
+ * the extension to which they belong. Any extension thas has such
+ * listeners has a property called `persistentListeners` that is a
+ * 3-level Map:
+ *
+ * - the first 2 keys are the module name (e.g., webRequest)
+ * and the name of the event within the module (e.g., onBeforeRequest).
+ *
+ * - the third level of the map is used to track multiple listeners for
+ * the same event, these listeners are distinguished by the extra arguments
+ * passed to addListener()
+ *
+ * - for quick lookups, the key to the third Map is the result of calling
+ * uneval() on the array of extra arguments.
+ *
+ * - the value stored in the Map or persistent listeners we keep in memory
+ * is a plain object with:
+ * - a property called `params` that is the original (ie, not uneval()ed)
+ * extra arguments to addListener()
+ * - and a property called `listeners` that is an array of plain object
+ * each representing a listener to be primed and a `primeId` autoincremented
+ * integer that represents each of the primed listeners that belongs to the
+ * group listeners with the same set of extra params.
+ * - a `nextPrimeId` property keeps track of the numeric primeId that should
+ * be assigned to new persistent listeners added for the same event and
+ * same set of extra params.
+ *
+ * For a primed listener (i.e., the stub listener created during browser startup
+ * before the extension background page is started, and after an event page is
+ * suspended on idle), the object will be later populated (by the callers of
+ * EventManager.primeListeners) with an additional `primed` property that serves
+ * as a placeholder listener, collecting all events that got emitted while the
+ * background page was not yet started, and eventually replaced by a callback
+ * registered from the extension code, once the background page scripts have been
+ * executed (or dropped if the background page scripts do not register the same
+ * listener anymore).
+ *
+ * @param {Extension} extension
+ * @returns {boolean} True if the extension had any persistent listeners.
+ */
+ static _initPersistentListeners(extension) {
+ if (extension.persistentListeners) {
+ return !!extension.persistentListeners.size;
+ }
+
+ let listeners = new DefaultMap(() => new DefaultMap(() => new Map()));
+ extension.persistentListeners = listeners;
+
+ let persistentListeners = extension.startupData?.persistentListeners;
+ if (!persistentListeners) {
+ return false;
+ }
+
+ let found = false;
+ for (let [module, savedModuleEntry] of Object.entries(
+ persistentListeners
+ )) {
+ for (let [event, savedEventEntry] of Object.entries(savedModuleEntry)) {
+ for (let paramList of savedEventEntry) {
+ /* Before Bug 1795801 (Firefox < 113) each entry was related to a listener
+ * registered with a different set of extra params (and so only one listener
+ * could be persisted for the same set of extra params)
+ *
+ * After Bug 1795801 (Firefox >= 113) each entry still represents a listener
+ * registered for that event, but multiple listeners registered with the same
+ * set of extra params will be captured as multiple entries in the
+ * paramsList array.
+ *
+ * NOTE: persisted listeners are stored in the startupData part of the Addon DB
+ * and are expected to be preserved across Firefox and Addons upgrades and downgrades
+ * (unlike the WebExtensions startupCache data which is cleared when Firefox or the
+ * addon is updated) and so we are taking special care about forward and backward
+ * compatibility of the persistentListeners on-disk format:
+ *
+ * - forward compatibility: when this new version of this startupData loading logic
+ * is loading the old persistentListeners on-disk format:
+ * - on the first run only one listener will be primed for each of the extra params
+ * recorded in the startupData (same as in older Firefox versions)
+ * and Bug 1795801 will still be hit, but once the background
+ * context is started once the startupData will be updated to
+ * include each of the listeners (indipendently if the set of
+ * extra params is the same as another listener already been
+ * persisted).
+ * - after the first run, all listeners will be primed separately, even if the extra
+ * params are the same as other listeners already primed, and so
+ * each of the listener will receive the pending events collected
+ * by their related primed listener and Bug 1795801 not to be hit anymore.
+ *
+ * - backward compatibility: when the old version of this startupData loading logic
+ * (https://searchfox.org/mozilla-central/rev/cd2121e7d8/toolkit/components/extensions/ExtensionCommon.jsm#2360-2371)
+ * is loading the new persistentListeners on-disk format, the last
+ * entry with the same set of extra params will be eventually overwritting the
+ * entry for another primed listener with the same extra params, Bug 1795801 will still
+ * be hit, but no actual change in behavior is expected.
+ */
+ let key = uneval(paramList);
+ const eventEntry = listeners.get(module).get(event);
+
+ if (eventEntry.has(key)) {
+ const keyEntry = eventEntry.get(key);
+ let primeId = keyEntry.nextPrimeId;
+ keyEntry.listeners.push({ primeId });
+ keyEntry.nextPrimeId++;
+ } else {
+ eventEntry.set(key, {
+ params: paramList,
+ nextPrimeId: 1,
+ listeners: [{ primeId: 0 }],
+ });
+ }
+ found = true;
+ }
+ }
+ }
+ return found;
+ }
+
+ // Extract just the information needed at startup for all persistent
+ // listeners, and arrange for it to be saved. This should be called
+ // whenever the set of persistent listeners for an extension changes.
+ static _writePersistentListeners(extension) {
+ let startupListeners = {};
+ for (let [module, moduleEntry] of extension.persistentListeners) {
+ startupListeners[module] = {};
+ for (let [event, eventEntry] of moduleEntry) {
+ // Turn the per-event entries from the format they are being kept
+ // in memory:
+ //
+ // [
+ // { params: paramList1, listeners: [listener1, listener2, ...] },
+ // { params: paramList2, listeners: [listener3, listener3, ...] },
+ // ...
+ // ]
+ //
+ // into the format used for storing them on disk (in the startupData),
+ // which is an array of the params for each listener (with the param list
+ // included as many times as many listeners are persisted for the same
+ // set of params):
+ //
+ // [paramList1, paramList1, ..., paramList2, paramList2, ...]
+ //
+ // This format will also work as expected on older Firefox versions where
+ // only one listener was being persisted for each set of params.
+ startupListeners[module][event] = Array.from(
+ eventEntry.values()
+ ).flatMap(keyEntry => keyEntry.listeners.map(() => keyEntry.params));
+ }
+ }
+
+ extension.startupData.persistentListeners = startupListeners;
+ extension.saveStartupData();
+ }
+
+ // Set up "primed" event listeners for any saved event listeners
+ // in an extension's startup data.
+ // This function is only called during browser startup, it stores details
+ // about all primed listeners in the extension's persistentListeners Map.
+ static primeListeners(extension, isInStartup = false) {
+ if (!EventManager._initPersistentListeners(extension)) {
+ return;
+ }
+
+ for (let [module, moduleEntry] of extension.persistentListeners) {
+ // If we're in startup, we only want to continue attempting to prime a
+ // subset of events that should be startup blocking.
+ if (isInStartup) {
+ let api_module = extension.apiManager.getModule(module);
+ if (!api_module.startupBlocking) {
+ continue;
+ }
+ }
+
+ let api = extension.apiManager.getAPI(module, extension, "addon_parent");
+
+ // If an extension is upgraded and a permission, such as webRequest, is
+ // removed, we will have been called but the API is no longer available.
+ if (!api?.primeListener) {
+ // The runtime module no longer implements primed listeners, drop them.
+ extension.persistentListeners.delete(module);
+ EventManager._writePersistentListeners(extension);
+ continue;
+ }
+ for (let [event, eventEntry] of moduleEntry) {
+ for (let [key, { params, listeners }] of eventEntry) {
+ for (let listener of listeners) {
+ // Reset the `listener.added` flag by setting it to `false` while
+ // re-priming the listeners because the event page has suspended
+ // and the previous converted listener is no longer listening.
+ const listenerWasAdded = listener.added;
+ listener.added = false;
+ listener.params = params;
+ let primed = { pendingEvents: [] };
+
+ let fireEvent = (...args) =>
+ new Promise((resolve, reject) => {
+ if (!listener.primed) {
+ reject(
+ new Error(
+ `primed listener ${module}.${event} not re-registered`
+ )
+ );
+ return;
+ }
+ primed.pendingEvents.push({ args, resolve, reject });
+ extension.emit("background-script-event");
+ });
+
+ let fire = {
+ wakeup: () => extension.wakeupBackground(),
+ sync: fireEvent,
+ async: fireEvent,
+ // fire.async for ProxyContextParent is already not cloning.
+ raw: fireEvent,
+ };
+
+ try {
+ let handler = api.primeListener(
+ event,
+ fire,
+ listener.params,
+ isInStartup
+ );
+ if (handler) {
+ listener.primed = primed;
+ Object.assign(primed, handler);
+ }
+ } catch (e) {
+ Cu.reportError(
+ `Error priming listener ${module}.${event}: ${e} :: ${e.stack}`
+ );
+ // Force this listener to be cleared.
+ listener.error = true;
+ }
+
+ // If an attempt to prime a listener failed, ensure it is cleared now.
+ // If a module is a startup blocking module, not all listeners may
+ // get primed during early startup. For that reason, we don't clear
+ // persisted listeners during early startup. At the end of background
+ // execution any listeners that were not renewed will be cleared.
+ //
+ // TODO(Bug 1797474): consider priming runtime.onStartup and
+ // avoid to special handling it here.
+ if (
+ listener.error ||
+ (!isInStartup &&
+ !(
+ (`${module}.${event}` === "runtime.onStartup" &&
+ listenerWasAdded) ||
+ listener.primed
+ ))
+ ) {
+ EventManager.clearPersistentListener(
+ extension,
+ module,
+ event,
+ key,
+ listener.primeId
+ );
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * This is called as a result of background script startup-finished and shutdown.
+ *
+ * After startup, it removes any remaining primed listeners. These exist if the
+ * listener was not renewed during startup. In this case the persisted listener
+ * data is also removed.
+ *
+ * During shutdown, care should be taken to set clearPersistent to false.
+ * persisted listener data should NOT be cleared during shutdown.
+ *
+ * @param {Extension} extension
+ * @param {boolean} clearPersistent whether the persisted listener data should be cleared.
+ */
+ static clearPrimedListeners(extension, clearPersistent = true) {
+ if (!extension.persistentListeners) {
+ return;
+ }
+
+ for (let [module, moduleEntry] of extension.persistentListeners) {
+ for (let [event, eventEntry] of moduleEntry) {
+ for (let [key, { listeners }] of eventEntry) {
+ for (let listener of listeners) {
+ let { primed, added, primeId } = listener;
+ // When a primed listener is added or renewed during initial
+ // background execution we set an added flag. If it was primed
+ // when added, primed is set to null.
+ if (added) {
+ continue;
+ }
+
+ if (primed) {
+ // When a primed listener was not renewed, primed will still be truthy.
+ // These need to be cleared on shutdown (important for event pages), but
+ // we only clear the persisted listener data after the startup of a background.
+ // Release any pending events and unregister the primed handler.
+ listener.primed = null;
+
+ for (let evt of primed.pendingEvents) {
+ evt.reject(new Error("listener not re-registered"));
+ }
+ primed.unregister();
+ }
+
+ // Clear any persisted events that were not renewed, should typically
+ // only be done at the end of the background page load.
+ if (clearPersistent) {
+ EventManager.clearPersistentListener(
+ extension,
+ module,
+ event,
+ key,
+ primeId
+ );
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Record the fact that there is a listener for the given event in
+ // the given extension. `args` is an Array containing any extra
+ // arguments that were passed to addListener().
+ static savePersistentListener(extension, module, event, args = []) {
+ EventManager._initPersistentListeners(extension);
+ let key = uneval(args);
+ const eventEntry = extension.persistentListeners.get(module).get(event);
+
+ let primeId;
+ if (!eventEntry.has(key)) {
+ // when writing, only args are written, other properties are dropped
+ primeId = 0;
+ eventEntry.set(key, {
+ params: args,
+ listeners: [{ added: true, primeId }],
+ nextPrimeId: 1,
+ });
+ } else {
+ const keyEntry = eventEntry.get(key);
+ primeId = keyEntry.nextPrimeId;
+ keyEntry.listeners.push({ added: true, primeId });
+ keyEntry.nextPrimeId = primeId + 1;
+ }
+
+ EventManager._writePersistentListeners(extension);
+ return [module, event, key, primeId];
+ }
+
+ // Remove the record for the given event listener from the extension's
+ // startup data. `key` must be a string, the result of calling uneval()
+ // on the array of extra arguments originally passed to addListener().
+ static clearPersistentListener(
+ extension,
+ module,
+ event,
+ key = uneval([]),
+ primeId = undefined
+ ) {
+ let eventEntry = extension.persistentListeners.get(module).get(event);
+
+ let keyEntry = eventEntry.get(key);
+
+ if (primeId != undefined && keyEntry) {
+ keyEntry.listeners = keyEntry.listeners.filter(
+ listener => listener.primeId !== primeId
+ );
+ }
+
+ if (primeId == undefined || keyEntry?.listeners.length === 0) {
+ eventEntry.delete(key);
+ if (eventEntry.size == 0) {
+ let moduleEntry = extension.persistentListeners.get(module);
+ moduleEntry.delete(event);
+ if (moduleEntry.size == 0) {
+ extension.persistentListeners.delete(module);
+ }
+ }
+ }
+
+ EventManager._writePersistentListeners(extension);
+ }
+
+ addListener(callback, ...args) {
+ if (this.unregister.has(callback)) {
+ return;
+ }
+ this.context.logActivity("api_call", `${this.name}.addListener`, { args });
+
+ let shouldFire = () => {
+ if (this.context.unloaded) {
+ dump(`${this.name} event fired after context unloaded.\n`);
+ } else if (!this.context.active) {
+ dump(`${this.name} event fired while context is inactive.\n`);
+ } else if (this.unregister.has(callback)) {
+ return true;
+ }
+ return false;
+ };
+
+ let { extension } = this.context;
+ const resetIdle = () => {
+ if (this.resetIdleOnEvent) {
+ extension?.emit("background-script-reset-idle", {
+ reason: "event",
+ eventName: this.name,
+ });
+ }
+ };
+
+ let fire = {
+ // Bug 1754866 fire.sync doesn't match documentation.
+ sync: (...args) => {
+ if (shouldFire()) {
+ resetIdle();
+ let result = this.context.applySafe(callback, args);
+ this.context.logActivity("api_event", this.name, { args, result });
+ return result;
+ }
+ },
+ async: (...args) => {
+ return Promise.resolve().then(() => {
+ if (shouldFire()) {
+ resetIdle();
+ let result = this.context.applySafe(callback, args);
+ this.context.logActivity("api_event", this.name, { args, result });
+ return result;
+ }
+ });
+ },
+ raw: (...args) => {
+ if (!shouldFire()) {
+ throw new Error("Called raw() on unloaded/inactive context");
+ }
+ resetIdle();
+ let result = Reflect.apply(callback, null, args);
+ this.context.logActivity("api_event", this.name, { args, result });
+ return result;
+ },
+ asyncWithoutClone: (...args) => {
+ return Promise.resolve().then(() => {
+ if (shouldFire()) {
+ resetIdle();
+ let result = this.context.applySafeWithoutClone(callback, args);
+ this.context.logActivity("api_event", this.name, { args, result });
+ return result;
+ }
+ });
+ },
+ };
+
+ let { module, event } = this;
+
+ let unregister = null;
+ let recordStartupData = false;
+
+ // If this is a persistent event, check for a listener that was already
+ // created during startup. If there is one, use it and don't create a
+ // new one.
+ if (this.canPersistEvents) {
+ // Once a background is started, listenerPromises is set to null. At
+ // that point, we stop recording startup data.
+ recordStartupData = !!this.context.listenerPromises;
+
+ let key = uneval(args);
+ EventManager._initPersistentListeners(extension);
+ let keyEntry = extension.persistentListeners
+ .get(module)
+ .get(event)
+ .get(key);
+
+ // Get the first persistent listener which matches the module, event and extra arguments
+ // and not added back by the extension yet, the persistent listener found may be either
+ // primed or not (in particular API Events that belongs to APIs that should not be blocking
+ // startup may have persistent listeners that are not primed during the first execution
+ // of the background context happening as part of the applications startup, whereas they
+ // will be primed when the background context will be suspended on the idle timeout).
+ let listener = keyEntry?.listeners.find(listener => !listener.added);
+ if (listener) {
+ // During startup only a subset of persisted listeners are primed. As
+ // well, each API determines whether to prime a specific listener.
+ let { primed } = listener;
+ if (primed) {
+ listener.primed = null;
+
+ primed.convert(fire, this.context);
+ unregister = primed.unregister;
+
+ for (let evt of primed.pendingEvents) {
+ evt.resolve(fire.async(...evt.args));
+ }
+ }
+ listener.added = true;
+
+ recordStartupData = false;
+ this.remove.set(callback, () => {
+ EventManager.clearPersistentListener(
+ extension,
+ module,
+ event,
+ uneval(args),
+ listener.primeId
+ );
+ });
+ }
+ }
+
+ if (!unregister) {
+ unregister = this.register(fire, ...args);
+ }
+
+ this.unregister.set(callback, unregister);
+ this.context.callOnClose(this);
+
+ // If this is a new listener for a persistent event, record
+ // the details for subsequent startups.
+ if (recordStartupData) {
+ const [, , , /* _module */ /* _event */ /* _key */ primeId] =
+ EventManager.savePersistentListener(extension, module, event, args);
+ this.remove.set(callback, () => {
+ EventManager.clearPersistentListener(
+ extension,
+ module,
+ event,
+ uneval(args),
+ primeId
+ );
+ });
+ }
+ }
+
+ removeListener(callback, clearPersistentListener = true) {
+ if (!this.unregister.has(callback)) {
+ return;
+ }
+ this.context.logActivity("api_call", `${this.name}.removeListener`, {
+ args: [],
+ });
+
+ let unregister = this.unregister.get(callback);
+ this.unregister.delete(callback);
+ try {
+ unregister();
+ } catch (e) {
+ Cu.reportError(e);
+ }
+
+ if (clearPersistentListener && this.remove.has(callback)) {
+ let cleanup = this.remove.get(callback);
+ this.remove.delete(callback);
+ cleanup();
+ }
+
+ if (this.unregister.size == 0) {
+ this.context.forgetOnClose(this);
+ }
+ }
+
+ hasListener(callback) {
+ return this.unregister.has(callback);
+ }
+
+ revoke() {
+ for (let callback of this.unregister.keys()) {
+ this.removeListener(callback, false);
+ }
+ }
+
+ close() {
+ this.revoke();
+ }
+
+ api() {
+ return {
+ addListener: (...args) => this.addListener(...args),
+ removeListener: (...args) => this.removeListener(...args),
+ hasListener: (...args) => this.hasListener(...args),
+ setUserInput: this.inputHandling,
+ [lazy.Schemas.REVOKE]: () => this.revoke(),
+ };
+ }
+}
+
+// Simple API for event listeners where events never fire.
+function ignoreEvent(context, name) {
+ return {
+ addListener: function (callback) {
+ let id = context.extension.id;
+ let frame = Components.stack.caller;
+ let msg = `In add-on ${id}, attempting to use listener "${name}", which is unimplemented.`;
+ let scriptError = Cc["@mozilla.org/scripterror;1"].createInstance(
+ Ci.nsIScriptError
+ );
+ scriptError.init(
+ msg,
+ frame.filename,
+ null,
+ frame.lineNumber,
+ frame.columnNumber,
+ Ci.nsIScriptError.warningFlag,
+ "content javascript"
+ );
+ Services.console.logMessage(scriptError);
+ },
+ removeListener: function (callback) {},
+ hasListener: function (callback) {},
+ };
+}
+
+const stylesheetMap = new DefaultMap(url => {
+ let uri = Services.io.newURI(url);
+ return lazy.styleSheetService.preloadSheet(
+ uri,
+ // Note: keep in sync with ext-browser-content.js. This used to be
+ // AGENT_SHEET, but changed to AUTHOR_SHEET, see bug 1873024.
+ lazy.styleSheetService.AUTHOR_SHEET
+ );
+});
+
+/**
+ * Updates the in-memory representation of extension host permissions, i.e.
+ * policy.allowedOrigins.
+ *
+ * @param {WebExtensionPolicy} policy
+ * A policy. All MatchPattern instances in policy.allowedOrigins are
+ * expected to have been constructed with ignorePath: true.
+ * @param {string[]} origins
+ * A list of already-normalized origins, equivalent to using the
+ * MatchPattern constructor with ignorePath: true.
+ * @param {boolean} isAdd
+ * Whether to add instead of removing the host permissions.
+ */
+function updateAllowedOrigins(policy, origins, isAdd) {
+ if (!origins.length) {
+ // Nothing to modify.
+ return;
+ }
+ let patternMap = new Map();
+ for (let pattern of policy.allowedOrigins.patterns) {
+ patternMap.set(pattern.pattern, pattern);
+ }
+ if (!isAdd) {
+ for (let origin of origins) {
+ patternMap.delete(origin);
+ }
+ } else {
+ // In the parent process, policy.extension.restrictSchemes is available.
+ // In the content process, we need to check the mozillaAddons permission,
+ // which is only available if approved by the parent.
+ const restrictSchemes =
+ policy.extension?.restrictSchemes ??
+ policy.hasPermission("mozillaAddons");
+ for (let origin of origins) {
+ if (patternMap.has(origin)) {
+ continue;
+ }
+ patternMap.set(
+ origin,
+ new MatchPattern(origin, { restrictSchemes, ignorePath: true })
+ );
+ }
+ }
+ // patternMap contains only MatchPattern instances, so we don't need to set
+ // the options parameter (with restrictSchemes, etc.) since that is only used
+ // if the input is a string.
+ policy.allowedOrigins = new MatchPatternSet(Array.from(patternMap.values()));
+}
+
+export var ExtensionCommon = {
+ BaseContext,
+ CanOfAPIs,
+ EventManager,
+ ExtensionAPI,
+ ExtensionAPIPersistent,
+ EventEmitter,
+ LocalAPIImplementation,
+ LocaleData,
+ NoCloneSpreadArgs,
+ SchemaAPIInterface,
+ SchemaAPIManager,
+ SpreadArgs,
+ checkLoadURI,
+ checkLoadURL,
+ defineLazyGetter,
+ redefineGetter,
+ getConsole,
+ ignoreEvent,
+ instanceOf,
+ makeWidgetId,
+ normalizeTime,
+ runSafeSyncWithoutClone,
+ stylesheetMap,
+ updateAllowedOrigins,
+ withHandlingUserInput,
+
+ MultiAPIManager,
+ LazyAPIManager,
+};