Rename Toolkit's webextensions component directory to better reflect what it is.

1 files changed, 1040 insertions, 0 deletions

diff --git a/toolkit/components/webextensions/ExtensionChild.jsm b/toolkit/components/webextensions/ExtensionChild.jsm
new file mode 100644
index 000000000..c953dd685
--- /dev/null
+++ b/toolkit/components/webextensions/ExtensionChild.jsm
@@ -0,0 +1,1040 @@
+/* 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.EXPORTED_SYMBOLS = ["ExtensionChild"];
+
+/*
+ * This file handles addon logic that is independent of the chrome process.
+ * When addons run out-of-process, this is the main entry point.
+ * Its primary function is managing addon globals.
+ *
+ * Don't put contentscript logic here, use ExtensionContent.jsm instead.
+ */
+
+const Ci = Components.interfaces;
+const Cc = Components.classes;
+const Cu = Components.utils;
+const Cr = Components.results;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "MessageChannel",
+                                  "resource://gre/modules/MessageChannel.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NativeApp",
+                                  "resource://gre/modules/NativeMessaging.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PromiseUtils",
+                                  "resource://gre/modules/PromiseUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Schemas",
+                                  "resource://gre/modules/Schemas.jsm");
+
+const CATEGORY_EXTENSION_SCRIPTS_ADDON = "webextension-scripts-addon";
+
+Cu.import("resource://gre/modules/ExtensionCommon.jsm");
+Cu.import("resource://gre/modules/ExtensionUtils.jsm");
+
+const {
+  DefaultMap,
+  EventManager,
+  SingletonEventManager,
+  SpreadArgs,
+  defineLazyGetter,
+  getInnerWindowID,
+  getMessageManager,
+  getUniqueId,
+  injectAPI,
+} = ExtensionUtils;
+
+const {
+  BaseContext,
+  LocalAPIImplementation,
+  SchemaAPIInterface,
+  SchemaAPIManager,
+} = ExtensionCommon;
+
+var ExtensionChild;
+
+/**
+ * Abstraction for a Port object in the extension API.
+ *
+ * @param {BaseContext} context The context that owns this port.
+ * @param {nsIMessageSender} senderMM The message manager to send messages to.
+ * @param {Array<nsIMessageListenerManager>} receiverMMs Message managers to
+ *     listen on.
+ * @param {string} name Arbitrary port name as defined by the addon.
+ * @param {string} id An ID that uniquely identifies this port's channel.
+ * @param {object} sender The `port.sender` property.
+ * @param {object} recipient The recipient of messages sent from this port.
+ */
+class Port {
+  constructor(context, senderMM, receiverMMs, name, id, sender, recipient) {
+    this.context = context;
+    this.senderMM = senderMM;
+    this.receiverMMs = receiverMMs;
+    this.name = name;
+    this.id = id;
+    this.sender = sender;
+    this.recipient = recipient;
+    this.disconnected = false;
+    this.disconnectListeners = new Set();
+    this.unregisterMessageFuncs = new Set();
+
+    // Common options for onMessage and onDisconnect.
+    this.handlerBase = {
+      messageFilterStrict: {portId: id},
+
+      filterMessage: (sender, recipient) => {
+        return sender.contextId !== this.context.contextId;
+      },
+    };
+
+    this.disconnectHandler = Object.assign({
+      receiveMessage: ({data}) => this.disconnectByOtherEnd(data),
+    }, this.handlerBase);
+
+    MessageChannel.addListener(this.receiverMMs, "Extension:Port:Disconnect", this.disconnectHandler);
+
+    this.context.callOnClose(this);
+  }
+
+  api() {
+    let portObj = Cu.createObjectIn(this.context.cloneScope);
+
+    let portError = null;
+    let publicAPI = {
+      name: this.name,
+
+      disconnect: () => {
+        this.disconnect();
+      },
+
+      postMessage: json => {
+        this.postMessage(json);
+      },
+
+      onDisconnect: new EventManager(this.context, "Port.onDisconnect", fire => {
+        return this.registerOnDisconnect(error => {
+          portError = error && this.context.normalizeError(error);
+          fire.withoutClone(portObj);
+        });
+      }).api(),
+
+      onMessage: new EventManager(this.context, "Port.onMessage", fire => {
+        return this.registerOnMessage(msg => {
+          msg = Cu.cloneInto(msg, this.context.cloneScope);
+          fire.withoutClone(msg, portObj);
+        });
+      }).api(),
+
+      get error() {
+        return portError;
+      },
+    };
+
+    if (this.sender) {
+      publicAPI.sender = this.sender;
+    }
+
+    injectAPI(publicAPI, portObj);
+    return portObj;
+  }
+
+  postMessage(json) {
+    if (this.disconnected) {
+      throw new this.context.cloneScope.Error("Attempt to postMessage on disconnected port");
+    }
+
+    this._sendMessage("Extension:Port:PostMessage", json);
+  }
+
+  /**
+   * Register a callback that is called when the port is disconnected by the
+   * *other* end. The callback is automatically unregistered when the port or
+   * context is closed.
+   *
+   * @param {function} callback Called when the other end disconnects the port.
+   *     If the disconnect is caused by an error, the first parameter is an
+   *     object with a "message" string property that describes the cause.
+   * @returns {function} Function to unregister the listener.
+   */
+  registerOnDisconnect(callback) {
+    let listener = error => {
+      if (this.context.active && !this.disconnected) {
+        callback(error);
+      }
+    };
+    this.disconnectListeners.add(listener);
+    return () => {
+      this.disconnectListeners.delete(listener);
+    };
+  }
+
+  /**
+   * Register a callback that is called when a message is received. The callback
+   * is automatically unregistered when the port or context is closed.
+   *
+   * @param {function} callback Called when a message is received.
+   * @returns {function} Function to unregister the listener.
+   */
+  registerOnMessage(callback) {
+    let handler = Object.assign({
+      receiveMessage: ({data}) => {
+        if (this.context.active && !this.disconnected) {
+          callback(data);
+        }
+      },
+    }, this.handlerBase);
+
+    let unregister = () => {
+      this.unregisterMessageFuncs.delete(unregister);
+      MessageChannel.removeListener(this.receiverMMs, "Extension:Port:PostMessage", handler);
+    };
+    MessageChannel.addListener(this.receiverMMs, "Extension:Port:PostMessage", handler);
+    this.unregisterMessageFuncs.add(unregister);
+    return unregister;
+  }
+
+  _sendMessage(message, data) {
+    let options = {
+      recipient: Object.assign({}, this.recipient, {portId: this.id}),
+      responseType: MessageChannel.RESPONSE_NONE,
+    };
+
+    return this.context.sendMessage(this.senderMM, message, data, options);
+  }
+
+  handleDisconnection() {
+    MessageChannel.removeListener(this.receiverMMs, "Extension:Port:Disconnect", this.disconnectHandler);
+    for (let unregister of this.unregisterMessageFuncs) {
+      unregister();
+    }
+    this.context.forgetOnClose(this);
+    this.disconnected = true;
+  }
+
+  /**
+   * Disconnect the port from the other end (which may not even exist).
+   *
+   * @param {Error|{message: string}} [error] The reason for disconnecting,
+   *     if it is an abnormal disconnect.
+   */
+  disconnectByOtherEnd(error = null) {
+    if (this.disconnected) {
+      return;
+    }
+
+    for (let listener of this.disconnectListeners) {
+      listener(error);
+    }
+
+    this.handleDisconnection();
+  }
+
+  /**
+   * Disconnect the port from this end.
+   *
+   * @param {Error|{message: string}} [error] The reason for disconnecting,
+   *     if it is an abnormal disconnect.
+   */
+  disconnect(error = null) {
+    if (this.disconnected) {
+      // disconnect() may be called without side effects even after the port is
+      // closed - https://developer.chrome.com/extensions/runtime#type-Port
+      return;
+    }
+    this.handleDisconnection();
+    if (error) {
+      error = {message: this.context.normalizeError(error).message};
+    }
+    this._sendMessage("Extension:Port:Disconnect", error);
+  }
+
+  close() {
+    this.disconnect();
+  }
+}
+
+class NativePort extends Port {
+  postMessage(data) {
+    data = NativeApp.encodeMessage(this.context, data);
+
+    return super.postMessage(data);
+  }
+}
+
+/**
+ * Each extension context gets its own Messenger object. It handles the
+ * basics of sendMessage, onMessage, connect and onConnect.
+ *
+ * @param {BaseContext} context The context to which this Messenger is tied.
+ * @param {Array<nsIMessageListenerManager>} messageManagers
+ *     The message managers used to receive messages (e.g. onMessage/onConnect
+ *     requests).
+ * @param {object} sender Describes this sender to the recipient. This object
+ *     is extended further by BaseContext's sendMessage method and appears as
+ *     the `sender` object to `onConnect` and `onMessage`.
+ *     Do not set the `extensionId`, `contextId` or `tab` properties. The former
+ *     two are added by BaseContext's sendMessage, while `sender.tab` is set by
+ *     the ProxyMessenger in the main process.
+ * @param {object} filter A recipient filter to apply to incoming messages from
+ *     the broker. Messages are only handled by this Messenger if all key-value
+ *     pairs match the `recipient` as specified by the sender of the message.
+ *     In other words, this filter defines the required fields of `recipient`.
+ * @param {object} [optionalFilter] An additional filter to apply to incoming
+ *     messages. Unlike `filter`, the keys from `optionalFilter` are allowed to
+ *     be omitted from `recipient`. Only keys that are present in both
+ *     `optionalFilter` and `recipient` are applied to filter incoming messages.
+ */
+class Messenger {
+  constructor(context, messageManagers, sender, filter, optionalFilter) {
+    this.context = context;
+    this.messageManagers = messageManagers;
+    this.sender = sender;
+    this.filter = filter;
+    this.optionalFilter = optionalFilter;
+  }
+
+  _sendMessage(messageManager, message, data, recipient) {
+    let options = {
+      recipient,
+      sender: this.sender,
+      responseType: MessageChannel.RESPONSE_FIRST,
+    };
+
+    return this.context.sendMessage(messageManager, message, data, options);
+  }
+
+  sendMessage(messageManager, msg, recipient, responseCallback) {
+    let promise = this._sendMessage(messageManager, "Extension:Message", msg, recipient)
+      .catch(error => {
+        if (error.result == MessageChannel.RESULT_NO_HANDLER) {
+          return Promise.reject({message: "Could not establish connection. Receiving end does not exist."});
+        } else if (error.result != MessageChannel.RESULT_NO_RESPONSE) {
+          return Promise.reject({message: error.message});
+        }
+      });
+
+    return this.context.wrapPromise(promise, responseCallback);
+  }
+
+  sendNativeMessage(messageManager, msg, recipient, responseCallback) {
+    msg = NativeApp.encodeMessage(this.context, msg);
+    return this.sendMessage(messageManager, msg, recipient, responseCallback);
+  }
+
+  onMessage(name) {
+    return new SingletonEventManager(this.context, name, callback => {
+      let listener = {
+        messageFilterPermissive: this.optionalFilter,
+        messageFilterStrict: this.filter,
+
+        filterMessage: (sender, recipient) => {
+          // Ignore the message if it was sent by this Messenger.
+          return sender.contextId !== this.context.contextId;
+        },
+
+        receiveMessage: ({target, data: message, sender, recipient}) => {
+          if (!this.context.active) {
+            return;
+          }
+
+          let sendResponse;
+          let response = undefined;
+          let promise = new Promise(resolve => {
+            sendResponse = value => {
+              resolve(value);
+              response = promise;
+            };
+          });
+
+          message = Cu.cloneInto(message, this.context.cloneScope);
+          sender = Cu.cloneInto(sender, this.context.cloneScope);
+          sendResponse = Cu.exportFunction(sendResponse, this.context.cloneScope);
+
+          // Note: We intentionally do not use runSafe here so that any
+          // errors are propagated to the message sender.
+          let result = callback(message, sender, sendResponse);
+          if (result instanceof this.context.cloneScope.Promise) {
+            return result;
+          } else if (result === true) {
+            return promise;
+          }
+          return response;
+        },
+      };
+
+      MessageChannel.addListener(this.messageManagers, "Extension:Message", listener);
+      return () => {
+        MessageChannel.removeListener(this.messageManagers, "Extension:Message", listener);
+      };
+    }).api();
+  }
+
+  _connect(messageManager, port, recipient) {
+    let msg = {
+      name: port.name,
+      portId: port.id,
+    };
+
+    this._sendMessage(messageManager, "Extension:Connect", msg, recipient).catch(error => {
+      if (error.result === MessageChannel.RESULT_NO_HANDLER) {
+        error = {message: "Could not establish connection. Receiving end does not exist."};
+      } else if (error.result === MessageChannel.RESULT_DISCONNECTED) {
+        error = null;
+      }
+      port.disconnectByOtherEnd(error);
+    });
+
+    return port.api();
+  }
+
+  connect(messageManager, name, recipient) {
+    let portId = getUniqueId();
+
+    let port = new Port(this.context, messageManager, this.messageManagers, name, portId, null, recipient);
+
+    return this._connect(messageManager, port, recipient);
+  }
+
+  connectNative(messageManager, name, recipient) {
+    let portId = getUniqueId();
+
+    let port = new NativePort(this.context, messageManager, this.messageManagers, name, portId, null, recipient);
+
+    return this._connect(messageManager, port, recipient);
+  }
+
+  onConnect(name) {
+    return new SingletonEventManager(this.context, name, callback => {
+      let listener = {
+        messageFilterPermissive: this.optionalFilter,
+        messageFilterStrict: this.filter,
+
+        filterMessage: (sender, recipient) => {
+          // Ignore the port if it was created by this Messenger.
+          return sender.contextId !== this.context.contextId;
+        },
+
+        receiveMessage: ({target, data: message, sender}) => {
+          let {name, portId} = message;
+          let mm = getMessageManager(target);
+          let recipient = Object.assign({}, sender);
+          if (recipient.tab) {
+            recipient.tabId = recipient.tab.id;
+            delete recipient.tab;
+          }
+          let port = new Port(this.context, mm, this.messageManagers, name, portId, sender, recipient);
+          this.context.runSafeWithoutClone(callback, port.api());
+          return true;
+        },
+      };
+
+      MessageChannel.addListener(this.messageManagers, "Extension:Connect", listener);
+      return () => {
+        MessageChannel.removeListener(this.messageManagers, "Extension:Connect", listener);
+      };
+    }).api();
+  }
+}
+
+var apiManager = new class extends SchemaAPIManager {
+  constructor() {
+    super("addon");
+    this.initialized = false;
+  }
+
+  generateAPIs(...args) {
+    if (!this.initialized) {
+      this.initialized = true;
+      for (let [/* name */, value] of XPCOMUtils.enumerateCategoryEntries(CATEGORY_EXTENSION_SCRIPTS_ADDON)) {
+        this.loadScript(value);
+      }
+    }
+    return super.generateAPIs(...args);
+  }
+
+  registerSchemaAPI(namespace, envType, getAPI) {
+    if (envType == "addon_child") {
+      super.registerSchemaAPI(namespace, envType, getAPI);
+    }
+  }
+}();
+
+/**
+ * An object that runs an remote implementation of an API.
+ */
+class ProxyAPIImplementation extends SchemaAPIInterface {
+  /**
+   * @param {string} namespace The full path to the namespace that contains the
+   *     `name` member. This may contain dots, e.g. "storage.local".
+   * @param {string} name The name of the method or property.
+   * @param {ChildAPIManager} childApiManager The owner of this implementation.
+   */
+  constructor(namespace, name, childApiManager) {
+    super();
+    this.path = `${namespace}.${name}`;
+    this.childApiManager = childApiManager;
+  }
+
+  callFunctionNoReturn(args) {
+    this.childApiManager.callParentFunctionNoReturn(this.path, args);
+  }
+
+  callAsyncFunction(args, callback) {
+    return this.childApiManager.callParentAsyncFunction(this.path, args, callback);
+  }
+
+  addListener(listener, args) {
+    let map = this.childApiManager.listeners.get(this.path);
+
+    if (map.listeners.has(listener)) {
+      // TODO: Called with different args?
+      return;
+    }
+
+    let id = getUniqueId();
+
+    map.ids.set(id, listener);
+    map.listeners.set(listener, id);
+
+    this.childApiManager.messageManager.sendAsyncMessage("API:AddListener", {
+      childId: this.childApiManager.id,
+      listenerId: id,
+      path: this.path,
+      args,
+    });
+  }
+
+  removeListener(listener) {
+    let map = this.childApiManager.listeners.get(this.path);
+
+    if (!map.listeners.has(listener)) {
+      return;
+    }
+
+    let id = map.listeners.get(listener);
+    map.listeners.delete(listener);
+    map.ids.delete(id);
+
+    this.childApiManager.messageManager.sendAsyncMessage("API:RemoveListener", {
+      childId: this.childApiManager.id,
+      listenerId: id,
+      path: this.path,
+    });
+  }
+
+  hasListener(listener) {
+    let map = this.childApiManager.listeners.get(this.path);
+    return map.listeners.has(listener);
+  }
+}
+
+// We create one instance of this class for every extension context that
+// needs to use remote APIs. It uses the message manager to communicate
+// with the ParentAPIManager singleton in ExtensionParent.jsm. It
+// handles asynchronous function calls as well as event listeners.
+class ChildAPIManager {
+  constructor(context, messageManager, localApis, contextData) {
+    this.context = context;
+    this.messageManager = messageManager;
+    this.url = contextData.url;
+
+    // The root namespace of all locally implemented APIs. If an extension calls
+    // an API that does not exist in this object, then the implementation is
+    // delegated to the ParentAPIManager.
+    this.localApis = localApis;
+
+    this.id = `${context.extension.id}.${context.contextId}`;
+
+    MessageChannel.addListener(messageManager, "API:RunListener", this);
+    messageManager.addMessageListener("API:CallResult", this);
+
+    this.messageFilterStrict = {childId: this.id};
+
+    this.listeners = new DefaultMap(() => ({
+      ids: new Map(),
+      listeners: new Map(),
+    }));
+
+    // Map[callId -> Deferred]
+    this.callPromises = new Map();
+
+    let params = {
+      childId: this.id,
+      extensionId: context.extension.id,
+      principal: context.principal,
+    };
+    Object.assign(params, contextData);
+
+    this.messageManager.sendAsyncMessage("API:CreateProxyContext", params);
+  }
+
+  receiveMessage({name, messageName, data}) {
+    if (data.childId != this.id) {
+      return;
+    }
+
+    switch (name || messageName) {
+      case "API:RunListener":
+        let map = this.listeners.get(data.path);
+        let listener = map.ids.get(data.listenerId);
+
+        if (listener) {
+          return this.context.runSafe(listener, ...data.args);
+        }
+
+        Cu.reportError(`Unknown listener at childId=${data.childId} path=${data.path} listenerId=${data.listenerId}\n`);
+        break;
+
+      case "API:CallResult":
+        let deferred = this.callPromises.get(data.callId);
+        if ("error" in data) {
+          deferred.reject(data.error);
+        } else {
+          deferred.resolve(new SpreadArgs(data.result));
+        }
+        this.callPromises.delete(data.callId);
+        break;
+    }
+  }
+
+  /**
+   * Call a function in the parent process and ignores its return value.
+   *
+   * @param {string} path The full name of the method, e.g. "tabs.create".
+   * @param {Array} args The parameters for the function.
+   */
+  callParentFunctionNoReturn(path, args) {
+    this.messageManager.sendAsyncMessage("API:Call", {
+      childId: this.id,
+      path,
+      args,
+    });
+  }
+
+  /**
+   * Calls a function in the parent process and returns its result
+   * asynchronously.
+   *
+   * @param {string} path The full name of the method, e.g. "tabs.create".
+   * @param {Array} args The parameters for the function.
+   * @param {function(*)} [callback] The callback to be called when the function
+   *     completes.
+   * @returns {Promise|undefined} Must be void if `callback` is set, and a
+   *     promise otherwise. The promise is resolved when the function completes.
+   */
+  callParentAsyncFunction(path, args, callback) {
+    let callId = getUniqueId();
+    let deferred = PromiseUtils.defer();
+    this.callPromises.set(callId, deferred);
+
+    this.messageManager.sendAsyncMessage("API:Call", {
+      childId: this.id,
+      callId,
+      path,
+      args,
+    });
+
+    return this.context.wrapPromise(deferred.promise, callback);
+  }
+
+  /**
+   * Create a proxy for an event in the parent process. The returned event
+   * object shares its internal state with other instances. For instance, if
+   * `removeListener` is used on a listener that was added on another object
+   * through `addListener`, then the event is unregistered.
+   *
+   * @param {string} path The full name of the event, e.g. "tabs.onCreated".
+   * @returns {object} An object with the addListener, removeListener and
+   *   hasListener methods. See SchemaAPIInterface for documentation.
+   */
+  getParentEvent(path) {
+    path = path.split(".");
+
+    let name = path.pop();
+    let namespace = path.join(".");
+
+    let impl = new ProxyAPIImplementation(namespace, name, this);
+    return {
+      addListener: (listener, ...args) => impl.addListener(listener, args),
+      removeListener: (listener) => impl.removeListener(listener),
+      hasListener: (listener) => impl.hasListener(listener),
+    };
+  }
+
+  close() {
+    this.messageManager.sendAsyncMessage("API:CloseProxyContext", {childId: this.id});
+  }
+
+  get cloneScope() {
+    return this.context.cloneScope;
+  }
+
+  get principal() {
+    return this.context.principal;
+  }
+
+  shouldInject(namespace, name, allowedContexts) {
+    // Do not generate content script APIs, unless explicitly allowed.
+    if (this.context.envType === "content_child" &&
+        !allowedContexts.includes("content")) {
+      return false;
+    }
+    if (allowedContexts.includes("addon_parent_only")) {
+      return false;
+    }
+    return true;
+  }
+
+  getImplementation(namespace, name) {
+    let obj = namespace.split(".").reduce(
+      (object, prop) => object && object[prop],
+      this.localApis);
+
+    if (obj && name in obj) {
+      return new LocalAPIImplementation(obj, name, this.context);
+    }
+
+    return this.getFallbackImplementation(namespace, name);
+  }
+
+  getFallbackImplementation(namespace, name) {
+    // No local API found, defer implementation to the parent.
+    return new ProxyAPIImplementation(namespace, name, this);
+  }
+
+  hasPermission(permission) {
+    return this.context.extension.hasPermission(permission);
+  }
+}
+
+class ExtensionPageContextChild extends BaseContext {
+  /**
+   * This ExtensionPageContextChild represents a privileged addon
+   * execution environment that has full access to the WebExtensions
+   * APIs (provided that the correct permissions have been requested).
+   *
+   * This is the child side of the ExtensionPageContextParent class
+   * defined in ExtensionParent.jsm.
+   *
+   * @param {BrowserExtensionContent} extension This context's owner.
+   * @param {object} params
+   * @param {nsIDOMWindow} params.contentWindow The window where the addon runs.
+   * @param {string} params.viewType One of "background", "popup" or "tab".
+   *     "background" and "tab" are used by `browser.extension.getViews`.
+   *     "popup" is only used internally to identify page action and browser
+   *     action popups and options_ui pages.
+   * @param {number} [params.tabId] This tab's ID, used if viewType is "tab".
+   */
+  constructor(extension, params) {
+    super("addon_child", extension);
+    if (Services.appinfo.processType != Services.appinfo.PROCESS_TYPE_DEFAULT) {
+      // This check is temporary. It should be removed once the proxy creation
+      // is asynchronous.
+      throw new Error("ExtensionPageContextChild cannot be created in child processes");
+    }
+
+    let {viewType, uri, contentWindow, tabId} = params;
+    this.viewType = viewType;
+    this.uri = uri || extension.baseURI;
+
+    this.setContentWindow(contentWindow);
+
+    // This is the MessageSender property passed to extension.
+    // It can be augmented by the "page-open" hook.
+    let sender = {id: extension.uuid};
+    if (viewType == "tab") {
+      sender.tabId = tabId;
+      this.tabId = tabId;
+    }
+    if (uri) {
+      sender.url = uri.spec;
+    }
+    this.sender = sender;
+
+    Schemas.exportLazyGetter(contentWindow, "browser", () => {
+      let browserObj = Cu.createObjectIn(contentWindow);
+      Schemas.inject(browserObj, this.childManager);
+      return browserObj;
+    });
+
+    Schemas.exportLazyGetter(contentWindow, "chrome", () => {
+      let chromeApiWrapper = Object.create(this.childManager);
+      chromeApiWrapper.isChromeCompat = true;
+
+      let chromeObj = Cu.createObjectIn(contentWindow);
+      Schemas.inject(chromeObj, chromeApiWrapper);
+      return chromeObj;
+    });
+
+    this.extension.views.add(this);
+  }
+
+  get cloneScope() {
+    return this.contentWindow;
+  }
+
+  get principal() {
+    return this.contentWindow.document.nodePrincipal;
+  }
+
+  get windowId() {
+    if (this.viewType == "tab" || this.viewType == "popup") {
+      let globalView = ExtensionChild.contentGlobals.get(this.messageManager);
+      return globalView ? globalView.windowId : -1;
+    }
+  }
+
+  // Called when the extension shuts down.
+  shutdown() {
+    this.unload();
+  }
+
+  // This method is called when an extension page navigates away or
+  // its tab is closed.
+  unload() {
+    // Note that without this guard, we end up running unload code
+    // multiple times for tab pages closed by the "page-unload" handlers
+    // triggered below.
+    if (this.unloaded) {
+      return;
+    }
+
+    if (this.contentWindow) {
+      this.contentWindow.close();
+    }
+
+    super.unload();
+    this.extension.views.delete(this);
+  }
+}
+
+defineLazyGetter(ExtensionPageContextChild.prototype, "messenger", function() {
+  let filter = {extensionId: this.extension.id};
+  let optionalFilter = {};
+  // Addon-generated messages (not necessarily from the same process as the
+  // addon itself) are sent to the main process, which forwards them via the
+  // parent process message manager. Specific replies can be sent to the frame
+  // message manager.
+  return new Messenger(this, [Services.cpmm, this.messageManager], this.sender,
+                       filter, optionalFilter);
+});
+
+defineLazyGetter(ExtensionPageContextChild.prototype, "childManager", function() {
+  let localApis = {};
+  apiManager.generateAPIs(this, localApis);
+
+  if (this.viewType == "background") {
+    apiManager.global.initializeBackgroundPage(this.contentWindow);
+  }
+
+  let childManager = new ChildAPIManager(this, this.messageManager, localApis, {
+    envType: "addon_parent",
+    viewType: this.viewType,
+    url: this.uri.spec,
+    incognito: this.incognito,
+  });
+
+  this.callOnClose(childManager);
+
+  return childManager;
+});
+
+// All subframes in a tab, background page, popup, etc. have the same view type.
+// This class keeps track of such global state.
+// Note that this is created even for non-extension tabs because at present we
+// do not have a way to distinguish regular tabs from extension tabs at the
+// initialization of a frame script.
+class ContentGlobal {
+  /**
+   * @param {nsIContentFrameMessageManager} global The frame script's global.
+   */
+  constructor(global) {
+    this.global = global;
+    // Unless specified otherwise assume that the extension page is in a tab,
+    // because the majority of all class instances are going to be a tab. Any
+    // special views (background page, extension popup) will immediately send an
+    // Extension:InitExtensionView message to change the viewType.
+    this.viewType = "tab";
+    this.tabId = -1;
+    this.windowId = -1;
+    this.initialized = false;
+    this.global.addMessageListener("Extension:InitExtensionView", this);
+    this.global.addMessageListener("Extension:SetTabAndWindowId", this);
+
+    this.initialDocuments = new WeakSet();
+  }
+
+  uninit() {
+    this.global.removeMessageListener("Extension:InitExtensionView", this);
+    this.global.removeMessageListener("Extension:SetTabAndWindowId", this);
+    this.global.removeEventListener("DOMContentLoaded", this);
+  }
+
+  ensureInitialized() {
+    if (!this.initialized) {
+      // Request tab and window ID in case "Extension:InitExtensionView" is not
+      // sent (e.g. when `viewType` is "tab").
+      let reply = this.global.sendSyncMessage("Extension:GetTabAndWindowId");
+      this.handleSetTabAndWindowId(reply[0] || {});
+    }
+    return this;
+  }
+
+  receiveMessage({name, data}) {
+    switch (name) {
+      case "Extension:InitExtensionView":
+        // The view type is initialized once and then fixed.
+        this.global.removeMessageListener("Extension:InitExtensionView", this);
+        let {viewType, url} = data;
+        this.viewType = viewType;
+        this.global.addEventListener("DOMContentLoaded", this);
+        if (url) {
+          // TODO(robwu): Remove this check. It is only here because the popup
+          // implementation does not always load a URL at the initialization,
+          // and the logic is too complex to fix at once.
+          let {document} = this.global.content;
+          this.initialDocuments.add(document);
+          document.location.replace(url);
+        }
+        /* Falls through to allow these properties to be initialized at once */
+      case "Extension:SetTabAndWindowId":
+        this.handleSetTabAndWindowId(data);
+        break;
+    }
+  }
+
+  handleSetTabAndWindowId(data) {
+    let {tabId, windowId} = data;
+    if (tabId) {
+      // Tab IDs are not expected to change.
+      if (this.tabId !== -1 && tabId !== this.tabId) {
+        throw new Error("Attempted to change a tabId after it was set");
+      }
+      this.tabId = tabId;
+    }
+    if (windowId !== undefined) {
+      // Window IDs may change if a tab is moved to a different location.
+      // Note: This is the ID of the browser window for the extension API.
+      // Do not confuse it with the innerWindowID of DOMWindows!
+      this.windowId = windowId;
+    }
+    this.initialized = true;
+  }
+
+  // "DOMContentLoaded" event.
+  handleEvent(event) {
+    let {document} = this.global.content;
+    if (event.target === document) {
+      // If the document was still being loaded at the time of navigation, then
+      // the DOMContentLoaded event is fired for the old document. Ignore it.
+      if (this.initialDocuments.has(document)) {
+        this.initialDocuments.delete(document);
+        return;
+      }
+      this.global.removeEventListener("DOMContentLoaded", this);
+      this.global.sendAsyncMessage("Extension:ExtensionViewLoaded");
+    }
+  }
+}
+
+ExtensionChild = {
+  // Map<nsIContentFrameMessageManager, ContentGlobal>
+  contentGlobals: new Map(),
+
+  // Map<innerWindowId, ExtensionPageContextChild>
+  extensionContexts: new Map(),
+
+  initOnce() {
+    // This initializes the default message handler for messages targeted at
+    // an addon process, in case the addon process receives a message before
+    // its Messenger has been instantiated. For example, if a content script
+    // sends a message while there is no background page.
+    MessageChannel.setupMessageManagers([Services.cpmm]);
+  },
+
+  init(global) {
+    this.contentGlobals.set(global, new ContentGlobal(global));
+  },
+
+  uninit(global) {
+    this.contentGlobals.get(global).uninit();
+    this.contentGlobals.delete(global);
+  },
+
+  /**
+   * Create a privileged context at document-element-inserted.
+   *
+   * @param {BrowserExtensionContent} extension
+   *     The extension for which the context should be created.
+   * @param {nsIDOMWindow} contentWindow The global of the page.
+   */
+  createExtensionContext(extension, contentWindow) {
+    let windowId = getInnerWindowID(contentWindow);
+    let context = this.extensionContexts.get(windowId);
+    if (context) {
+      if (context.extension !== extension) {
+        // Oops. This should never happen.
+        Cu.reportError("A different extension context already exists in this frame!");
+      } else {
+        // This should not happen either.
+        Cu.reportError("The extension context was already initialized in this frame.");
+      }
+      return;
+    }
+
+    let mm = contentWindow
+      .QueryInterface(Ci.nsIInterfaceRequestor)
+      .getInterface(Ci.nsIDocShell)
+      .QueryInterface(Ci.nsIInterfaceRequestor)
+      .getInterface(Ci.nsIContentFrameMessageManager);
+    let {viewType, tabId} = this.contentGlobals.get(mm).ensureInitialized();
+
+    let uri = contentWindow.document.documentURIObject;
+
+    context = new ExtensionPageContextChild(extension, {viewType, contentWindow, uri, tabId});
+    this.extensionContexts.set(windowId, context);
+  },
+
+  /**
+   * Close the ExtensionPageContextChild belonging to the given window, if any.
+   *
+   * @param {number} windowId The inner window ID of the destroyed context.
+   */
+  destroyExtensionContext(windowId) {
+    let context = this.extensionContexts.get(windowId);
+    if (context) {
+      context.unload();
+      this.extensionContexts.delete(windowId);
+    }
+  },
+
+  shutdownExtension(extensionId) {
+    for (let [windowId, context] of this.extensionContexts) {
+      if (context.extension.id == extensionId) {
+        context.shutdown();
+        this.extensionContexts.delete(windowId);
+      }
+    }
+  },
+};
+
+// TODO(robwu): Change this condition when addons move to a separate process.
+if (Services.appinfo.processType != Services.appinfo.PROCESS_TYPE_DEFAULT) {
+  Object.keys(ExtensionChild).forEach(function(key) {
+    if (typeof ExtensionChild[key] == "function") {
+      // :/
+      ExtensionChild[key] = () => {};
+    }
+  });
+}
+
+Object.assign(ExtensionChild, {
+  ChildAPIManager,
+  Messenger,
+  Port,
+});
+