Adding upstream version 124.0.1.upstream/124.0.1

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

11 files changed, 914 insertions, 0 deletions

diff --git a/browser/components/extensions/child/.eslintrc.js b/browser/components/extensions/child/.eslintrc.js
new file mode 100644
index 0000000000..3073b22caf
--- /dev/null
+++ b/browser/components/extensions/child/.eslintrc.js
@@ -0,0 +1,9 @@
+/* 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";
+
+module.exports = {
+  extends: "../../../../toolkit/components/extensions/child/.eslintrc.js",
+};
diff --git a/browser/components/extensions/child/ext-browser-content-only.js b/browser/components/extensions/child/ext-browser-content-only.js
new file mode 100644
index 0000000000..af5b8accf9
--- /dev/null
+++ b/browser/components/extensions/child/ext-browser-content-only.js
@@ -0,0 +1,13 @@
+/* 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";
+
+extensions.registerModules({
+  menusChild: {
+    url: "chrome://browser/content/child/ext-menus-child.js",
+    scopes: ["content_child"],
+    paths: [["menus"]],
+  },
+});
diff --git a/browser/components/extensions/child/ext-browser.js b/browser/components/extensions/child/ext-browser.js
new file mode 100644
index 0000000000..790b2d4bd0
--- /dev/null
+++ b/browser/components/extensions/child/ext-browser.js
@@ -0,0 +1,49 @@
+/* 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";
+
+extensions.registerModules({
+  devtools: {
+    url: "chrome://browser/content/child/ext-devtools.js",
+    scopes: ["devtools_child"],
+    paths: [["devtools"]],
+  },
+  devtools_inspectedWindow: {
+    url: "chrome://browser/content/child/ext-devtools-inspectedWindow.js",
+    scopes: ["devtools_child"],
+    paths: [["devtools", "inspectedWindow"]],
+  },
+  devtools_panels: {
+    url: "chrome://browser/content/child/ext-devtools-panels.js",
+    scopes: ["devtools_child"],
+    paths: [["devtools", "panels"]],
+  },
+  devtools_network: {
+    url: "chrome://browser/content/child/ext-devtools-network.js",
+    scopes: ["devtools_child"],
+    paths: [["devtools", "network"]],
+  },
+  // Because of permissions, the module name must differ from both namespaces.
+  menusInternal: {
+    url: "chrome://browser/content/child/ext-menus.js",
+    scopes: ["addon_child"],
+    paths: [["contextMenus"], ["menus"]],
+  },
+  menusChild: {
+    url: "chrome://browser/content/child/ext-menus-child.js",
+    scopes: ["addon_child", "devtools_child"],
+    paths: [["menus"]],
+  },
+  omnibox: {
+    url: "chrome://browser/content/child/ext-omnibox.js",
+    scopes: ["addon_child"],
+    paths: [["omnibox"]],
+  },
+  tabs: {
+    url: "chrome://browser/content/child/ext-tabs.js",
+    scopes: ["addon_child"],
+    paths: [["tabs"]],
+  },
+});
diff --git a/browser/components/extensions/child/ext-devtools-inspectedWindow.js b/browser/components/extensions/child/ext-devtools-inspectedWindow.js
new file mode 100644
index 0000000000..fdd8b97c17
--- /dev/null
+++ b/browser/components/extensions/child/ext-devtools-inspectedWindow.js
@@ -0,0 +1,29 @@
+/* -*- 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.devtools_inspectedWindow = class extends ExtensionAPI {
+  getAPI(context) {
+    // `devtoolsToolboxInfo` is received from the child process when the root devtools view
+    // has been created, and every sub-frame of that top level devtools frame will
+    // receive the same information when the context has been created from the
+    // `ExtensionChild.createExtensionContext` method.
+    let tabId =
+      context.devtoolsToolboxInfo &&
+      context.devtoolsToolboxInfo.inspectedWindowTabId;
+
+    return {
+      devtools: {
+        inspectedWindow: {
+          get tabId() {
+            return tabId;
+          },
+        },
+      },
+    };
+  }
+};
diff --git a/browser/components/extensions/child/ext-devtools-network.js b/browser/components/extensions/child/ext-devtools-network.js
new file mode 100644
index 0000000000..e36043f491
--- /dev/null
+++ b/browser/components/extensions/child/ext-devtools-network.js
@@ -0,0 +1,70 @@
+/* -*- 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";
+
+/**
+ * Responsible for fetching HTTP response content from the backend.
+ *
+ * @param {DevtoolsExtensionContext}
+ *   A devtools extension context running in a child process.
+ * @param {object} options
+ */
+class ChildNetworkResponseLoader {
+  constructor(context, requestId) {
+    this.context = context;
+    this.requestId = requestId;
+  }
+
+  api() {
+    const { context, requestId } = this;
+    return {
+      getContent(callback) {
+        return context.childManager.callParentAsyncFunction(
+          "devtools.network.Request.getContent",
+          [requestId],
+          callback
+        );
+      },
+    };
+  }
+}
+
+this.devtools_network = class extends ExtensionAPI {
+  getAPI(context) {
+    return {
+      devtools: {
+        network: {
+          onRequestFinished: new EventManager({
+            context,
+            name: "devtools.network.onRequestFinished",
+            register: fire => {
+              let onFinished = data => {
+                const loader = new ChildNetworkResponseLoader(
+                  context,
+                  data.requestId
+                );
+                const harEntry = { ...data.harEntry, ...loader.api() };
+                const result = Cu.cloneInto(harEntry, context.cloneScope, {
+                  cloneFunctions: true,
+                });
+                fire.asyncWithoutClone(result);
+              };
+
+              let parent = context.childManager.getParentEvent(
+                "devtools.network.onRequestFinished"
+              );
+              parent.addListener(onFinished);
+              return () => {
+                parent.removeListener(onFinished);
+              };
+            },
+          }).api(),
+        },
+      },
+    };
+  }
+};
diff --git a/browser/components/extensions/child/ext-devtools-panels.js b/browser/components/extensions/child/ext-devtools-panels.js
new file mode 100644
index 0000000000..e055976aec
--- /dev/null
+++ b/browser/components/extensions/child/ext-devtools-panels.js
@@ -0,0 +1,326 @@
+/* -*- 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";
+
+var { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+XPCOMUtils.defineLazyGlobalGetters(this, ["URL"]);
+
+ChromeUtils.defineESModuleGetters(this, {
+  ExtensionChildDevToolsUtils:
+    "resource://gre/modules/ExtensionChildDevToolsUtils.sys.mjs",
+});
+
+var { promiseDocumentLoaded } = ExtensionUtils;
+
+/**
+ * Represents an addon devtools panel in the child process.
+ *
+ * @param {DevtoolsExtensionContext}
+ *   A devtools extension context running in a child process.
+ * @param {object} panelOptions
+ * @param {string} panelOptions.id
+ *   The id of the addon devtools panel registered in the main process.
+ */
+class ChildDevToolsPanel extends ExtensionCommon.EventEmitter {
+  constructor(context, { id }) {
+    super();
+
+    this.context = context;
+    this.context.callOnClose(this);
+
+    this.id = id;
+    this._panelContext = null;
+
+    this.conduit = context.openConduit(this, {
+      recv: ["PanelHidden", "PanelShown"],
+    });
+  }
+
+  get panelContext() {
+    if (this._panelContext) {
+      return this._panelContext;
+    }
+
+    for (let view of this.context.extension.devtoolsViews) {
+      if (
+        view.viewType === "devtools_panel" &&
+        view.devtoolsToolboxInfo.toolboxPanelId === this.id
+      ) {
+        this._panelContext = view;
+
+        // Reset the cached _panelContext property when the view is closed.
+        view.callOnClose({
+          close: () => {
+            this._panelContext = null;
+          },
+        });
+        return view;
+      }
+    }
+
+    return null;
+  }
+
+  recvPanelShown() {
+    // Ignore received call before the panel context exist.
+    if (!this.panelContext || !this.panelContext.contentWindow) {
+      return;
+    }
+    const { document } = this.panelContext.contentWindow;
+
+    // Ensure that the onShown event is fired when the panel document has
+    // been fully loaded.
+    promiseDocumentLoaded(document).then(() => {
+      this.emit("shown", this.panelContext.contentWindow);
+    });
+  }
+
+  recvPanelHidden() {
+    this.emit("hidden");
+  }
+
+  api() {
+    return {
+      onShown: new EventManager({
+        context: this.context,
+        name: "devtoolsPanel.onShown",
+        register: fire => {
+          const listener = (eventName, panelContentWindow) => {
+            fire.asyncWithoutClone(panelContentWindow);
+          };
+          this.on("shown", listener);
+          return () => {
+            this.off("shown", listener);
+          };
+        },
+      }).api(),
+
+      onHidden: new EventManager({
+        context: this.context,
+        name: "devtoolsPanel.onHidden",
+        register: fire => {
+          const listener = () => {
+            fire.async();
+          };
+          this.on("hidden", listener);
+          return () => {
+            this.off("hidden", listener);
+          };
+        },
+      }).api(),
+
+      // TODO(rpl): onSearch event and createStatusBarButton method
+    };
+  }
+
+  close() {
+    this._panelContext = null;
+    this.context = null;
+  }
+}
+
+/**
+ * Represents an addon devtools inspector sidebar in the child process.
+ *
+ * @param {DevtoolsExtensionContext}
+ *   A devtools extension context running in a child process.
+ * @param {object} sidebarOptions
+ * @param {string} sidebarOptions.id
+ *   The id of the addon devtools sidebar registered in the main process.
+ */
+class ChildDevToolsInspectorSidebar extends ExtensionCommon.EventEmitter {
+  constructor(context, { id }) {
+    super();
+
+    this.context = context;
+    this.context.callOnClose(this);
+
+    this.id = id;
+
+    this.conduit = context.openConduit(this, {
+      recv: ["InspectorSidebarHidden", "InspectorSidebarShown"],
+    });
+  }
+
+  close() {
+    this.context = null;
+  }
+
+  recvInspectorSidebarShown() {
+    // TODO: wait and emit sidebar contentWindow once sidebar.setPage is supported.
+    this.emit("shown");
+  }
+
+  recvInspectorSidebarHidden() {
+    this.emit("hidden");
+  }
+
+  api() {
+    const { context, id } = this;
+
+    let extensionURL = new URL("/", context.uri.spec);
+
+    // This is currently needed by sidebar.setPage because API objects are not automatically wrapped
+    // by the API Schema validations and so the ExtensionURL type used in the JSON schema
+    // doesn't have any effect on the parameter received by the setPage API method.
+    function resolveExtensionURL(url) {
+      let sidebarPageURL = new URL(url, context.uri.spec);
+
+      if (
+        extensionURL.protocol !== sidebarPageURL.protocol ||
+        extensionURL.host !== sidebarPageURL.host
+      ) {
+        throw new context.cloneScope.Error(
+          `Invalid sidebar URL: ${sidebarPageURL.href} is not a valid extension URL`
+        );
+      }
+
+      return sidebarPageURL.href;
+    }
+
+    return {
+      onShown: new EventManager({
+        context,
+        name: "devtoolsInspectorSidebar.onShown",
+        register: fire => {
+          const listener = (eventName, panelContentWindow) => {
+            fire.asyncWithoutClone(panelContentWindow);
+          };
+          this.on("shown", listener);
+          return () => {
+            this.off("shown", listener);
+          };
+        },
+      }).api(),
+
+      onHidden: new EventManager({
+        context,
+        name: "devtoolsInspectorSidebar.onHidden",
+        register: fire => {
+          const listener = () => {
+            fire.async();
+          };
+          this.on("hidden", listener);
+          return () => {
+            this.off("hidden", listener);
+          };
+        },
+      }).api(),
+
+      setPage(extensionPageURL) {
+        let resolvedSidebarURL = resolveExtensionURL(extensionPageURL);
+
+        return context.childManager.callParentAsyncFunction(
+          "devtools.panels.elements.Sidebar.setPage",
+          [id, resolvedSidebarURL]
+        );
+      },
+
+      setObject(jsonObject, rootTitle) {
+        return context.cloneScope.Promise.resolve().then(() => {
+          return context.childManager.callParentAsyncFunction(
+            "devtools.panels.elements.Sidebar.setObject",
+            [id, jsonObject, rootTitle]
+          );
+        });
+      },
+
+      setExpression(evalExpression, rootTitle) {
+        return context.cloneScope.Promise.resolve().then(() => {
+          return context.childManager.callParentAsyncFunction(
+            "devtools.panels.elements.Sidebar.setExpression",
+            [id, evalExpression, rootTitle]
+          );
+        });
+      },
+    };
+  }
+}
+
+this.devtools_panels = class extends ExtensionAPI {
+  getAPI(context) {
+    const themeChangeObserver =
+      ExtensionChildDevToolsUtils.getThemeChangeObserver();
+
+    return {
+      devtools: {
+        panels: {
+          elements: {
+            createSidebarPane(title) {
+              // NOTE: this is needed to be able to return to the caller (the extension)
+              // a promise object that it had the privileges to use (e.g. by marking this
+              // method async we will return a promise object which can only be used by
+              // chrome privileged code).
+              return context.cloneScope.Promise.resolve().then(async () => {
+                const sidebarId =
+                  await context.childManager.callParentAsyncFunction(
+                    "devtools.panels.elements.createSidebarPane",
+                    [title]
+                  );
+
+                const sidebar = new ChildDevToolsInspectorSidebar(context, {
+                  id: sidebarId,
+                });
+
+                const sidebarAPI = Cu.cloneInto(
+                  sidebar.api(),
+                  context.cloneScope,
+                  { cloneFunctions: true }
+                );
+
+                return sidebarAPI;
+              });
+            },
+          },
+          create(title, icon, url) {
+            // NOTE: this is needed to be able to return to the caller (the extension)
+            // a promise object that it had the privileges to use (e.g. by marking this
+            // method async we will return a promise object which can only be used by
+            // chrome privileged code).
+            return context.cloneScope.Promise.resolve().then(async () => {
+              const panelId =
+                await context.childManager.callParentAsyncFunction(
+                  "devtools.panels.create",
+                  [title, icon, url]
+                );
+
+              const devtoolsPanel = new ChildDevToolsPanel(context, {
+                id: panelId,
+              });
+
+              const devtoolsPanelAPI = Cu.cloneInto(
+                devtoolsPanel.api(),
+                context.cloneScope,
+                { cloneFunctions: true }
+              );
+              return devtoolsPanelAPI;
+            });
+          },
+          get themeName() {
+            return themeChangeObserver.themeName;
+          },
+          onThemeChanged: new EventManager({
+            context,
+            name: "devtools.panels.onThemeChanged",
+            register: fire => {
+              const listener = (eventName, themeName) => {
+                fire.async(themeName);
+              };
+              themeChangeObserver.on("themeChanged", listener);
+              return () => {
+                themeChangeObserver.off("themeChanged", listener);
+              };
+            },
+          }).api(),
+        },
+      },
+    };
+  }
+};
diff --git a/browser/components/extensions/child/ext-devtools.js b/browser/components/extensions/child/ext-devtools.js
new file mode 100644
index 0000000000..219df7cb07
--- /dev/null
+++ b/browser/components/extensions/child/ext-devtools.js
@@ -0,0 +1,15 @@
+/* -*- 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.devtools = class extends ExtensionAPI {
+  getAPI(context) {
+    return {
+      devtools: {},
+    };
+  }
+};
diff --git a/browser/components/extensions/child/ext-menus-child.js b/browser/components/extensions/child/ext-menus-child.js
new file mode 100644
index 0000000000..2819ec219e
--- /dev/null
+++ b/browser/components/extensions/child/ext-menus-child.js
@@ -0,0 +1,38 @@
+/* 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";
+
+ChromeUtils.defineESModuleGetters(this, {
+  ContextMenuChild: "resource:///actors/ContextMenuChild.sys.mjs",
+});
+
+this.menusChild = class extends ExtensionAPI {
+  getAPI(context) {
+    return {
+      menus: {
+        getTargetElement(targetElementId) {
+          let element;
+          let lastMenuTarget = ContextMenuChild.getLastTarget(
+            context.contentWindow.docShell.browsingContext
+          );
+          if (
+            lastMenuTarget &&
+            Math.floor(lastMenuTarget.timeStamp) === targetElementId
+          ) {
+            element = lastMenuTarget.targetRef.get();
+          }
+          if (
+            element &&
+            element.getRootNode({ composed: true }) ===
+              context.contentWindow.document
+          ) {
+            return element;
+          }
+          return null;
+        },
+      },
+    };
+  }
+};
diff --git a/browser/components/extensions/child/ext-menus.js b/browser/components/extensions/child/ext-menus.js
new file mode 100644
index 0000000000..6c3b7ae492
--- /dev/null
+++ b/browser/components/extensions/child/ext-menus.js
@@ -0,0 +1,305 @@
+/* -*- 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";
+
+var { withHandlingUserInput } = ExtensionCommon;
+
+var { ExtensionError } = ExtensionUtils;
+
+// If id is not specified for an item we use an integer.
+// This ID need only be unique within a single addon. Since all addon code that
+// can use this API runs in the same process, this local variable suffices.
+var gNextMenuItemID = 0;
+
+// Map[Extension -> Map[string or id, ContextMenusClickPropHandler]]
+var gPropHandlers = new Map();
+
+// The contextMenus API supports an "onclick" attribute in the create/update
+// methods to register a callback. This class manages these onclick properties.
+class ContextMenusClickPropHandler {
+  constructor(context) {
+    this.context = context;
+    // Map[string or integer -> callback]
+    this.onclickMap = new Map();
+    this.dispatchEvent = this.dispatchEvent.bind(this);
+  }
+
+  // A listener on contextMenus.onClicked that forwards the event to the only
+  // listener, if any.
+  dispatchEvent(info, tab) {
+    let onclick = this.onclickMap.get(info.menuItemId);
+    if (onclick) {
+      // No need for runSafe or anything because we are already being run inside
+      // an event handler -- the event is just being forwarded to the actual
+      // handler.
+      withHandlingUserInput(this.context.contentWindow, () =>
+        onclick(info, tab)
+      );
+    }
+  }
+
+  // Sets the `onclick` handler for the given menu item.
+  // The `onclick` function MUST be owned by `this.context`.
+  setListener(id, onclick) {
+    if (this.onclickMap.size === 0) {
+      this.context.childManager
+        .getParentEvent("menusInternal.onClicked")
+        .addListener(this.dispatchEvent);
+      this.context.callOnClose(this);
+    }
+    this.onclickMap.set(id, onclick);
+
+    let propHandlerMap = gPropHandlers.get(this.context.extension);
+    if (!propHandlerMap) {
+      propHandlerMap = new Map();
+    } else {
+      // If the current callback was created in a different context, remove it
+      // from the other context.
+      let propHandler = propHandlerMap.get(id);
+      if (propHandler && propHandler !== this) {
+        propHandler.unsetListener(id);
+      }
+    }
+    propHandlerMap.set(id, this);
+    gPropHandlers.set(this.context.extension, propHandlerMap);
+  }
+
+  // Deletes the `onclick` handler for the given menu item.
+  // The `onclick` function MUST be owned by `this.context`.
+  unsetListener(id) {
+    if (!this.onclickMap.delete(id)) {
+      return;
+    }
+    if (this.onclickMap.size === 0) {
+      this.context.childManager
+        .getParentEvent("menusInternal.onClicked")
+        .removeListener(this.dispatchEvent);
+      this.context.forgetOnClose(this);
+    }
+    let propHandlerMap = gPropHandlers.get(this.context.extension);
+    propHandlerMap.delete(id);
+    if (propHandlerMap.size === 0) {
+      gPropHandlers.delete(this.context.extension);
+    }
+  }
+
+  // Deletes the `onclick` handler for the given menu item, if any, regardless
+  // of the context where it was created.
+  unsetListenerFromAnyContext(id) {
+    let propHandlerMap = gPropHandlers.get(this.context.extension);
+    let propHandler = propHandlerMap && propHandlerMap.get(id);
+    if (propHandler) {
+      propHandler.unsetListener(id);
+    }
+  }
+
+  // Remove all `onclick` handlers of the extension.
+  deleteAllListenersFromExtension() {
+    let propHandlerMap = gPropHandlers.get(this.context.extension);
+    if (propHandlerMap) {
+      for (let [id, propHandler] of propHandlerMap) {
+        propHandler.unsetListener(id);
+      }
+    }
+  }
+
+  // Removes all `onclick` handlers from this context.
+  close() {
+    for (let id of this.onclickMap.keys()) {
+      this.unsetListener(id);
+    }
+  }
+}
+
+this.menusInternal = class extends ExtensionAPI {
+  getAPI(context) {
+    let { extension } = context;
+    let onClickedProp = new ContextMenusClickPropHandler(context);
+    let pendingMenuEvent;
+
+    let api = {
+      menus: {
+        create(createProperties, callback) {
+          let caller = context.getCaller();
+
+          if (extension.persistentBackground && createProperties.id === null) {
+            createProperties.id = ++gNextMenuItemID;
+          }
+          let { onclick } = createProperties;
+          if (onclick && !context.extension.persistentBackground) {
+            throw new ExtensionError(
+              `Property "onclick" cannot be used in menus.create, replace with an "onClicked" event listener.`
+            );
+          }
+          delete createProperties.onclick;
+          context.childManager
+            .callParentAsyncFunction("menusInternal.create", [createProperties])
+            .then(() => {
+              if (onclick) {
+                onClickedProp.setListener(createProperties.id, onclick);
+              }
+              if (callback) {
+                context.runSafeWithoutClone(callback);
+              }
+            })
+            .catch(error => {
+              context.withLastError(error, caller, () => {
+                if (callback) {
+                  context.runSafeWithoutClone(callback);
+                }
+              });
+            });
+          return createProperties.id;
+        },
+
+        update(id, updateProperties) {
+          let { onclick } = updateProperties;
+          if (onclick && !context.extension.persistentBackground) {
+            throw new ExtensionError(
+              `Property "onclick" cannot be used in menus.update, replace with an "onClicked" event listener.`
+            );
+          }
+          delete updateProperties.onclick;
+          return context.childManager
+            .callParentAsyncFunction("menusInternal.update", [
+              id,
+              updateProperties,
+            ])
+            .then(() => {
+              if (onclick) {
+                onClickedProp.setListener(id, onclick);
+              } else if (onclick === null) {
+                onClickedProp.unsetListenerFromAnyContext(id);
+              }
+              // else onclick is not set so it should not be changed.
+            });
+        },
+
+        remove(id) {
+          onClickedProp.unsetListenerFromAnyContext(id);
+          return context.childManager.callParentAsyncFunction(
+            "menusInternal.remove",
+            [id]
+          );
+        },
+
+        removeAll() {
+          onClickedProp.deleteAllListenersFromExtension();
+
+          return context.childManager.callParentAsyncFunction(
+            "menusInternal.removeAll",
+            []
+          );
+        },
+
+        overrideContext(contextOptions) {
+          let checkValidArg = (contextType, propKey) => {
+            if (contextOptions.context !== contextType) {
+              if (contextOptions[propKey]) {
+                throw new ExtensionError(
+                  `Property "${propKey}" can only be used with context "${contextType}"`
+                );
+              }
+              return false;
+            }
+            if (contextOptions.showDefaults) {
+              throw new ExtensionError(
+                `Property "showDefaults" cannot be used with context "${contextType}"`
+              );
+            }
+            if (!contextOptions[propKey]) {
+              throw new ExtensionError(
+                `Property "${propKey}" is required for context "${contextType}"`
+              );
+            }
+            return true;
+          };
+          if (checkValidArg("tab", "tabId")) {
+            if (!context.extension.hasPermission("tabs")) {
+              throw new ExtensionError(
+                `The "tab" context requires the "tabs" permission.`
+              );
+            }
+          }
+          if (checkValidArg("bookmark", "bookmarkId")) {
+            if (!context.extension.hasPermission("bookmarks")) {
+              throw new ExtensionError(
+                `The "bookmark" context requires the "bookmarks" permission.`
+              );
+            }
+          }
+
+          let webExtContextData = {
+            extensionId: context.extension.id,
+            showDefaults: contextOptions.showDefaults,
+            overrideContext: contextOptions.context,
+            bookmarkId: contextOptions.bookmarkId,
+            tabId: contextOptions.tabId,
+          };
+
+          if (pendingMenuEvent) {
+            // overrideContext is called more than once during the same event.
+            pendingMenuEvent.webExtContextData = webExtContextData;
+            return;
+          }
+          pendingMenuEvent = {
+            webExtContextData,
+            observe(subject, topic, data) {
+              pendingMenuEvent = null;
+              Services.obs.removeObserver(this, "on-prepare-contextmenu");
+              subject = subject.wrappedJSObject;
+              if (context.principal.subsumes(subject.principal)) {
+                subject.setWebExtContextData(this.webExtContextData);
+              }
+            },
+            run() {
+              // "on-prepare-contextmenu" is expected to be observed before the
+              // end of the "contextmenu" event dispatch. This task is queued
+              // in case that does not happen, e.g. when the menu is not shown.
+              // ... or if the method was not called during a contextmenu event.
+              if (pendingMenuEvent === this) {
+                pendingMenuEvent = null;
+                Services.obs.removeObserver(this, "on-prepare-contextmenu");
+              }
+            },
+          };
+          Services.obs.addObserver(pendingMenuEvent, "on-prepare-contextmenu");
+          Services.tm.dispatchToMainThread(pendingMenuEvent);
+        },
+
+        onClicked: new EventManager({
+          context,
+          name: "menus.onClicked",
+          register: fire => {
+            let listener = (info, tab) => {
+              withHandlingUserInput(context.contentWindow, () =>
+                fire.sync(info, tab)
+              );
+            };
+
+            let event = context.childManager.getParentEvent(
+              "menusInternal.onClicked"
+            );
+            event.addListener(listener);
+            return () => {
+              event.removeListener(listener);
+            };
+          },
+        }).api(),
+      },
+    };
+
+    const result = {};
+    if (context.extension.hasPermission("menus")) {
+      result.menus = api.menus;
+    }
+    if (context.extension.hasPermission("contextMenus")) {
+      result.contextMenus = api.menus;
+    }
+    return result;
+  }
+};
diff --git a/browser/components/extensions/child/ext-omnibox.js b/browser/components/extensions/child/ext-omnibox.js
new file mode 100644
index 0000000000..1121b11390
--- /dev/null
+++ b/browser/components/extensions/child/ext-omnibox.js
@@ -0,0 +1,38 @@
+/* -*- 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.omnibox = class extends ExtensionAPI {
+  getAPI(context) {
+    return {
+      omnibox: {
+        onInputChanged: new EventManager({
+          context,
+          name: "omnibox.onInputChanged",
+          register: fire => {
+            let listener = (text, id) => {
+              fire.asyncWithoutClone(text, suggestions => {
+                context.childManager.callParentFunctionNoReturn(
+                  "omnibox.addSuggestions",
+                  [id, suggestions]
+                );
+              });
+            };
+            context.childManager
+              .getParentEvent("omnibox.onInputChanged")
+              .addListener(listener);
+            return () => {
+              context.childManager
+                .getParentEvent("omnibox.onInputChanged")
+                .removeListener(listener);
+            };
+          },
+        }).api(),
+      },
+    };
+  }
+};
diff --git a/browser/components/extensions/child/ext-tabs.js b/browser/components/extensions/child/ext-tabs.js
new file mode 100644
index 0000000000..ae3ef1cb75
--- /dev/null
+++ b/browser/components/extensions/child/ext-tabs.js
@@ -0,0 +1,22 @@
+/* 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.tabs = class extends ExtensionAPI {
+  getAPI(context) {
+    return {
+      tabs: {
+        connect(tabId, options) {
+          let { frameId = null, name = "" } = options || {};
+          return context.messenger.connect({ name, tabId, frameId });
+        },
+
+        sendMessage(tabId, message, options, callback) {
+          let arg = { tabId, frameId: options?.frameId, message, callback };
+          return context.messenger.sendRuntimeMessage(arg);
+        },
+      },
+    };
+  }
+};