Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2619 insertions, 0 deletions

diff --git a/toolkit/components/extensions/ExtensionCommon.jsm b/toolkit/components/extensions/ExtensionCommon.jsm
new file mode 100644
index 0000000000..50585afc3a
--- /dev/null
+++ b/toolkit/components/extensions/ExtensionCommon.jsm
@@ -0,0 +1,2619 @@
+/* -*- 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/. */
+"use strict";
+
+/**
+ * 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.
+ */
+
+/* exported ExtensionCommon */
+
+var EXPORTED_SYMBOLS = ["ExtensionCommon"];
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+const { XPCOMUtils } = ChromeUtils.import(
+  "resource://gre/modules/XPCOMUtils.jsm"
+);
+
+XPCOMUtils.defineLazyGlobalGetters(this, ["fetch"]);
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+  AppConstants: "resource://gre/modules/AppConstants.jsm",
+  ConsoleAPI: "resource://gre/modules/Console.jsm",
+  MessageChannel: "resource://gre/modules/MessageChannel.jsm",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.jsm",
+  Schemas: "resource://gre/modules/Schemas.jsm",
+  SchemaRoot: "resource://gre/modules/Schemas.jsm",
+});
+
+XPCOMUtils.defineLazyServiceGetter(
+  this,
+  "styleSheetService",
+  "@mozilla.org/content/style-sheet-service;1",
+  "nsIStyleSheetService"
+);
+
+const { ExtensionUtils } = ChromeUtils.import(
+  "resource://gre/modules/ExtensionUtils.jsm"
+);
+
+var {
+  DefaultMap,
+  DefaultWeakMap,
+  ExtensionError,
+  filterStack,
+  getInnerWindowID,
+  getUniqueId,
+} = ExtensionUtils;
+
+function getConsole() {
+  return new ConsoleAPI({
+    maxLogLevelPref: "extensions.webextensions.log.level",
+    prefix: "WebExtensions",
+  });
+}
+
+XPCOMUtils.defineLazyGetter(this, "console", getConsole);
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  this,
+  "DELAYED_BG_STARTUP",
+  "extensions.webextensions.background-delayed-startup"
+);
+
+var ExtensionCommon;
+
+// Run a function and report exceptions.
+function runSafeSyncWithoutClone(f, ...args) {
+  try {
+    return f(...args);
+  } catch (e) {
+    dump(
+      `Extension error: ${e} ${e.fileName} ${
+        e.lineNumber
+      }\n[[Exception stack\n${filterStack(e)}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.
+ *
+ * @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 {function} getter
+ *        The function to call in order to generate the final property
+ *        value.
+ */
+function defineLazyGetter(object, prop, getter) {
+  let redefine = (obj, value) => {
+    Object.defineProperty(obj, prop, {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value,
+    });
+    return value;
+  };
+
+  Object.defineProperty(object, prop, {
+    enumerable: true,
+    configurable: true,
+
+    get() {
+      return redefine(this, getter.call(this));
+    },
+
+    set(value) {
+      redefine(this, value);
+    },
+  });
+}
+
+function checkLoadURL(url, 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, Services.io.newURI(url), flags);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+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)} 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)} 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)} listener
+   *        The listener to call when events are emitted.
+   */
+  once(event, listener) {
+    let wrapper = (...args) => {
+      this.off(event, wrapper);
+      this[ONCE_MAP].delete(listener);
+
+      return listener(...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() {}
+
+  onManifestEntry(entry) {}
+
+  getAPI(context) {
+    throw new Error("Not Implemented");
+  }
+}
+
+/**
+ * A wrapper around a window that returns the window iff the inner window
+ * matches the inner window at the construction of this wrapper.
+ *
+ * This wrapper should not be used after the inner window is destroyed.
+ **/
+class InnerWindowReference {
+  constructor(contentWindow, innerWindowID) {
+    this.contentWindow = contentWindow;
+    this.innerWindowID = innerWindowID;
+    this.needWindowIDCheck = false;
+
+    contentWindow.addEventListener(
+      "pagehide",
+      this,
+      { mozSystemGroup: true },
+      false
+    );
+    contentWindow.addEventListener(
+      "pageshow",
+      this,
+      { mozSystemGroup: true },
+      false
+    );
+  }
+
+  get() {
+    // If the pagehide event has fired, the inner window ID needs to be checked,
+    // in case the window ref is dereferenced in a pageshow listener (before our
+    // pageshow listener was dispatched) or during the unload event.
+    if (
+      !this.needWindowIDCheck ||
+      getInnerWindowID(this.contentWindow) === this.innerWindowID
+    ) {
+      return this.contentWindow;
+    }
+    return null;
+  }
+
+  invalidate() {
+    // If invalidate() is called while the inner window is in the bfcache, then
+    // we are unable to remove the event listener, and handleEvent will be
+    // called once more if the page is revived from the bfcache.
+    if (this.contentWindow && !Cu.isDeadWrapper(this.contentWindow)) {
+      this.contentWindow.removeEventListener("pagehide", this, {
+        mozSystemGroup: true,
+      });
+      this.contentWindow.removeEventListener("pageshow", this, {
+        mozSystemGroup: true,
+      });
+    }
+    this.contentWindow = null;
+    this.needWindowIDCheck = false;
+  }
+
+  handleEvent(event) {
+    if (this.contentWindow) {
+      this.needWindowIDCheck = event.type === "pagehide";
+    } else {
+      // Remove listener when restoring from the bfcache - see invalidate().
+      event.currentTarget.removeEventListener("pagehide", this, {
+        mozSystemGroup: true,
+      });
+      event.currentTarget.removeEventListener("pageshow", this, {
+        mozSystemGroup: true,
+      });
+    }
+  }
+}
+
+/**
+ * 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 {
+  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.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 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;
+  }
+
+  canAccessWindow(window) {
+    return this.extension.canAccessWindow(window);
+  }
+
+  /**
+   * 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 {PointConduit}
+   */
+  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 = PrivateBrowsingUtils.isContentWindowPrivate(
+        contentWindow
+      );
+    }
+
+    MessageChannel.setupMessageManagers([this.messageManager]);
+
+    let windowRef = new InnerWindowReference(contentWindow, this.innerWindowID);
+    Object.defineProperty(this, "active", {
+      configurable: true,
+      enumerable: true,
+      get: () => windowRef.get() !== null,
+    });
+    Object.defineProperty(this, "contentWindow", {
+      configurable: true,
+      enumerable: true,
+      get: () => windowRef.get(),
+    });
+    this.callOnClose({
+      close: () => {
+        // Allow other "close" handlers to use these properties, until the next tick.
+        Promise.resolve().then(() => {
+          windowRef.invalidate();
+          windowRef = null;
+          Object.defineProperty(this, "contentWindow", { value: null });
+          Object.defineProperty(this, "active", { value: false });
+        });
+      },
+    });
+  }
+
+  // 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}`);
+  }
+
+  get cloneScope() {
+    throw new Error("Not implemented");
+  }
+
+  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) {
+        dump(
+          `Extension error: ${e} ${e.fileName} ${
+            e.lineNumber
+          }\n[[Exception stack\n${filterStack(e)}Current stack\n${filterStack(
+            Error()
+          )}]]\n`
+        );
+        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 {array<any>} args Arguments 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);
+  }
+
+  /**
+   * A wrapper around MessageChannel.sendMessage which adds the extension ID
+   * to the recipient object, and ensures replies are not processed after the
+   * context has been unloaded.
+   *
+   * @param {nsIMessageManager} target
+   * @param {string} messageName
+   * @param {object} data
+   * @param {object} [options]
+   * @param {object} [options.sender]
+   * @param {object} [options.recipient]
+   *
+   * @returns {Promise}
+   */
+  sendMessage(target, messageName, data, options = {}) {
+    options.recipient = Object.assign(
+      { extensionId: this.extension.id },
+      options.recipient
+    );
+    options.sender = options.sender || {};
+
+    options.sender.extensionId = this.extension.id;
+    options.sender.contextId = this.contextId;
+
+    return MessageChannel.sendMessage(target, messageName, data, options);
+  }
+
+  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;
+
+    MessageChannel.abortResponses({
+      extensionId: this.extension.id,
+      contextId: this.contextId,
+    });
+
+    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 {function(*)} [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][Schemas.REVOKE]) {
+      this.pathObj[this.name][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 (!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 {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({
+      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 {class}
+   */
+  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<class>}
+   */
+  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.permissions &&
+      !module.permissions.some(perm => extension.hasPermission(perm))
+    ) {
+      return false;
+    }
+
+    if (!scope) {
+      return true;
+    }
+
+    if (!module.scopes.includes(scope)) {
+      return false;
+    }
+
+    if (!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, {
+      Cc,
+      ChromeWorker,
+      Ci,
+      Cr,
+      Cu,
+      ExtensionAPI,
+      ExtensionCommon,
+      MatchGlob,
+      MatchPattern,
+      MatchPatternSet,
+      StructuredCloneHolder,
+      XPCOMUtils,
+      extensions: this,
+      global,
+    });
+
+    ChromeUtils.import("resource://gre/modules/AppConstants.jsm", global);
+
+    XPCOMUtils.defineLazyGetter(global, "console", getConsole);
+
+    XPCOMUtils.defineLazyModuleGetters(global, {
+      ExtensionUtils: "resource://gre/modules/ExtensionUtils.jsm",
+      XPCOMUtils: "resource://gre/modules/XPCOMUtils.jsm",
+    });
+
+    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);
+
+    this.initialized = false;
+
+    this.initModuleData(moduleData);
+
+    this.schemaURLs = schemaURLs;
+  }
+}
+
+defineLazyGetter(LazyAPIManager.prototype, "schema", function() {
+  let root = new SchemaRoot(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] === Schemas) {
+    bases.pop();
+  }
+
+  if (bases.length === 1) {
+    bases = bases[0];
+  }
+  return new SchemaRoot(bases, new Map());
+});
+
+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;
+  },
+};
+
+defineLazyGetter(LocaleData.prototype, "availableLocales", function() {
+  return new Set(
+    [this.BUILTIN, this.selectedLocale, this.defaultLocale].filter(locale =>
+      this.messages.has(locale)
+    )
+  );
+});
+
+/**
+ * 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 {
+  /*
+   * @param {object} params
+   *        Parameters that control this EventManager.
+   * @param {BaseContext} params.context
+   *        An object representing the extension instance using this event.
+   * @param {string} params.name
+   *        A name used only for debugging.
+   * @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.
+   * @param {object} [params.persistent]
+   *        Details for persistent event listeners
+   * @param {string} params.persistent.module
+   *        The name of the module in which this event is defined.
+   * @param {string} params.persistent.event
+   *        The name of this event.
+   */
+  constructor(params) {
+    let {
+      context,
+      name,
+      register,
+      inputHandling = false,
+      persistent = null,
+    } = params;
+    this.context = context;
+    this.name = name;
+    this.register = register;
+    this.inputHandling = inputHandling;
+    this.persistent = persistent;
+
+    // Don't bother with persistent event handling if delayed background
+    // startup is not enabled.
+    if (!DELAYED_BG_STARTUP) {
+      this.persistent = null;
+    }
+
+    this.unregister = new Map();
+    this.remove = new Map();
+
+    if (this.persistent) {
+      if (AppConstants.DEBUG) {
+        if (this.context.envType !== "addon_parent") {
+          throw new Error(
+            "Persistent event managers can only be created for addon_parent"
+          );
+        }
+        if (!this.persistent.module || !this.persistent.event) {
+          throw new Error(
+            "Persistent event manager must specify module and event"
+          );
+        }
+      }
+      if (this.context.viewType !== "background") {
+        this.persistent = null;
+      }
+    }
+  }
+
+  /*
+   * 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 is a plain object with a property called
+   * `params` that is the original (ie, not uneval()ed) extra arguments to
+   * addListener().  For a primed listener (i.e., the stub listener created
+   * during browser startup before the extension background page is started,
+   * the object also has a `primed` property that holds the things needed
+   * to handle events during startup and eventually connect the listener
+   * with a callback registered from the extension.
+   *
+   * @param {Extension} extension
+   * @returns {boolean} True if the extension had any persistent listeners.
+   */
+  static _initPersistentListeners(extension) {
+    if (extension.persistentListeners) {
+      return false;
+    }
+
+    let listeners = new DefaultMap(() => new DefaultMap(() => new Map()));
+    extension.persistentListeners = listeners;
+
+    let { persistentListeners } = extension.startupData;
+    if (!persistentListeners) {
+      return false;
+    }
+
+    let found = false;
+    for (let [module, entry] of Object.entries(persistentListeners)) {
+      for (let [event, paramlists] of Object.entries(entry)) {
+        for (let paramlist of paramlists) {
+          let key = uneval(paramlist);
+          listeners
+            .get(module)
+            .get(event)
+            .set(key, { params: paramlist });
+          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) {
+        startupListeners[module][event] = Array.from(
+          eventEntry.values(),
+          listener => listener.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) {
+    if (!EventManager._initPersistentListeners(extension)) {
+      return;
+    }
+
+    for (let [module, moduleEntry] of extension.persistentListeners) {
+      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 listener of eventEntry.values()) {
+          let primed = { pendingEvents: [] };
+          listener.primed = primed;
+
+          let fireEvent = (...args) =>
+            new Promise((resolve, reject) => {
+              if (!listener.primed) {
+                reject(new Error("primed listener not re-registered"));
+                return;
+              }
+              primed.pendingEvents.push({ args, resolve, reject });
+              extension.emit("background-page-event");
+            });
+
+          let fire = {
+            wakeup: () => extension.wakeupBackground(),
+            sync: fireEvent,
+            async: fireEvent,
+          };
+
+          let { unregister, convert } = api.primeListener(
+            extension,
+            event,
+            fire,
+            listener.params
+          );
+          Object.assign(primed, { unregister, convert });
+        }
+      }
+    }
+  }
+
+  // Remove any primed listeners that were not re-registered.
+  // This function is called after the background page has started.
+  // The removed listeners are removed from the set of saved listeners, unless
+  // `clearPersistent` is false. If false, the listeners are cleared from
+  // memory, but not removed from the extension's startup data.
+  static clearPrimedListeners(extension, clearPersistent = true) {
+    for (let [module, moduleEntry] of extension.persistentListeners) {
+      for (let [event, listeners] of moduleEntry) {
+        for (let [key, listener] of listeners) {
+          let { primed } = listener;
+          if (!primed) {
+            continue;
+          }
+          listener.primed = null;
+
+          for (let evt of primed.pendingEvents) {
+            evt.reject(new Error("listener not re-registered"));
+          }
+
+          if (clearPersistent) {
+            EventManager.clearPersistentListener(extension, module, event, key);
+          }
+          primed.unregister();
+        }
+      }
+    }
+  }
+
+  // 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);
+    extension.persistentListeners
+      .get(module)
+      .get(event)
+      .set(key, { params: args });
+    EventManager._writePersistentListeners(extension);
+  }
+
+  // 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([])) {
+    let listeners = extension.persistentListeners.get(module).get(event);
+    listeners.delete(key);
+
+    if (listeners.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 fire = {
+      sync: (...args) => {
+        if (shouldFire()) {
+          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()) {
+            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");
+        }
+        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()) {
+            let result = this.context.applySafeWithoutClone(callback, args);
+            this.context.logActivity("api_event", this.name, { args, result });
+            return result;
+          }
+        });
+      },
+    };
+
+    let { extension } = this.context;
+
+    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.persistent) {
+      recordStartupData = true;
+      let { module, event } = this.persistent;
+
+      let key = uneval(args);
+      EventManager._initPersistentListeners(extension);
+      let listener = extension.persistentListeners
+        .get(module)
+        .get(event)
+        .get(key);
+
+      if (listener) {
+        // If extensions.webextensions.background-delayed-startup is disabled,
+        // we can have stored info here but no primed listener.  This check
+        // can be removed if/when we make delayed background startup the only
+        // supported setting.
+        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));
+          }
+        }
+
+        recordStartupData = false;
+        this.remove.set(callback, () => {
+          EventManager.clearPersistentListener(
+            extension,
+            module,
+            event,
+            uneval(args)
+          );
+        });
+      }
+    }
+
+    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) {
+      let { module, event } = this.persistent;
+      EventManager.savePersistentListener(extension, module, event, args);
+      this.remove.set(callback, () => {
+        EventManager.clearPersistentListener(
+          extension,
+          module,
+          event,
+          uneval(args)
+        );
+      });
+    }
+  }
+
+  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,
+      [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 styleSheetService.preloadSheet(uri, styleSheetService.AGENT_SHEET);
+});
+
+ExtensionCommon = {
+  BaseContext,
+  CanOfAPIs,
+  EventManager,
+  ExtensionAPI,
+  EventEmitter,
+  LocalAPIImplementation,
+  LocaleData,
+  NoCloneSpreadArgs,
+  SchemaAPIInterface,
+  SchemaAPIManager,
+  SpreadArgs,
+  checkLoadURL,
+  defineLazyGetter,
+  getConsole,
+  ignoreEvent,
+  instanceOf,
+  makeWidgetId,
+  normalizeTime,
+  runSafeSyncWithoutClone,
+  stylesheetMap,
+  withHandlingUserInput,
+
+  MultiAPIManager,
+  LazyAPIManager,
+};