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

1 files changed, 1048 insertions, 0 deletions

diff --git a/toolkit/components/webextensions/ExtensionContent.jsm b/toolkit/components/webextensions/ExtensionContent.jsm
new file mode 100644
index 000000000..9b9a02091
--- /dev/null
+++ b/toolkit/components/webextensions/ExtensionContent.jsm
@@ -0,0 +1,1048 @@
+/* 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 = ["ExtensionContent"];
+
+/* globals ExtensionContent */
+
+/*
+ * This file handles the content process side of extensions. It mainly
+ * takes care of content script injection, content script APIs, and
+ * messaging.
+ *
+ * This file is also the initial entry point for addon processes.
+ * ExtensionChild.jsm is responsible for functionality specific to addon
+ * processes.
+ */
+
+const Ci = Components.interfaces;
+const Cc = Components.classes;
+const Cu = Components.utils;
+const Cr = Components.results;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/AppConstants.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "ExtensionManagement",
+                                  "resource://gre/modules/ExtensionManagement.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "LanguageDetector",
+                                  "resource:///modules/translation/LanguageDetector.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "MatchPattern",
+                                  "resource://gre/modules/MatchPattern.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "MatchGlobs",
+                                  "resource://gre/modules/MatchPattern.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "MessageChannel",
+                                  "resource://gre/modules/MessageChannel.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PromiseUtils",
+                                  "resource://gre/modules/PromiseUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Schemas",
+                                  "resource://gre/modules/Schemas.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "WebNavigationFrames",
+                                  "resource://gre/modules/WebNavigationFrames.jsm");
+
+Cu.import("resource://gre/modules/ExtensionChild.jsm");
+Cu.import("resource://gre/modules/ExtensionCommon.jsm");
+Cu.import("resource://gre/modules/ExtensionUtils.jsm");
+
+const {
+  EventEmitter,
+  LocaleData,
+  defineLazyGetter,
+  flushJarCache,
+  getInnerWindowID,
+  promiseDocumentReady,
+  runSafeSyncWithoutClone,
+} = ExtensionUtils;
+
+const {
+  BaseContext,
+  SchemaAPIManager,
+} = ExtensionCommon;
+
+const {
+  ChildAPIManager,
+  Messenger,
+} = ExtensionChild;
+
+XPCOMUtils.defineLazyGetter(this, "console", ExtensionUtils.getConsole);
+
+const CATEGORY_EXTENSION_SCRIPTS_CONTENT = "webextension-scripts-content";
+
+function isWhenBeforeOrSame(when1, when2) {
+  let table = {"document_start": 0,
+               "document_end": 1,
+               "document_idle": 2};
+  return table[when1] <= table[when2];
+}
+
+var apiManager = new class extends SchemaAPIManager {
+  constructor() {
+    super("content");
+    this.initialized = false;
+  }
+
+  generateAPIs(...args) {
+    if (!this.initialized) {
+      this.initialized = true;
+      for (let [/* name */, value] of XPCOMUtils.enumerateCategoryEntries(CATEGORY_EXTENSION_SCRIPTS_CONTENT)) {
+        this.loadScript(value);
+      }
+    }
+    return super.generateAPIs(...args);
+  }
+
+  registerSchemaAPI(namespace, envType, getAPI) {
+    if (envType == "content_child") {
+      super.registerSchemaAPI(namespace, envType, getAPI);
+    }
+  }
+}();
+
+// Represents a content script.
+function Script(extension, options, deferred = PromiseUtils.defer()) {
+  this.extension = extension;
+  this.options = options;
+  this.run_at = this.options.run_at;
+  this.js = this.options.js || [];
+  this.css = this.options.css || [];
+  this.remove_css = this.options.remove_css;
+  this.match_about_blank = this.options.match_about_blank;
+
+  this.deferred = deferred;
+
+  this.matches_ = new MatchPattern(this.options.matches);
+  this.exclude_matches_ = new MatchPattern(this.options.exclude_matches || null);
+  // TODO: MatchPattern should pre-mangle host-only patterns so that we
+  // don't need to call a separate match function.
+  this.matches_host_ = new MatchPattern(this.options.matchesHost || null);
+  this.include_globs_ = new MatchGlobs(this.options.include_globs);
+  this.exclude_globs_ = new MatchGlobs(this.options.exclude_globs);
+
+  this.requiresCleanup = !this.remove_css && (this.css.length > 0 || options.cssCode);
+}
+
+Script.prototype = {
+  get cssURLs() {
+    // We can handle CSS urls (css) and CSS code (cssCode).
+    let urls = [];
+    for (let url of this.css) {
+      urls.push(this.extension.baseURI.resolve(url));
+    }
+
+    if (this.options.cssCode) {
+      let url = "data:text/css;charset=utf-8," + encodeURIComponent(this.options.cssCode);
+      urls.push(url);
+    }
+
+    return urls;
+  },
+
+  matches(window) {
+    let uri = window.document.documentURIObject;
+    let principal = window.document.nodePrincipal;
+
+    // If mozAddonManager is present on this page, don't allow
+    // content scripts.
+    if (window.navigator.mozAddonManager !== undefined) {
+      return false;
+    }
+
+    if (this.match_about_blank && ["about:blank", "about:srcdoc"].includes(uri.spec)) {
+      // When matching about:blank/srcdoc documents, the checks below
+      // need to be performed against the "owner" document's URI.
+      uri = principal.URI;
+    }
+
+    // Documents from data: URIs also inherit the principal.
+    if (Services.netUtils.URIChainHasFlags(uri, Ci.nsIProtocolHandler.URI_INHERITS_SECURITY_CONTEXT)) {
+      if (!this.match_about_blank) {
+        return false;
+      }
+      uri = principal.URI;
+    }
+
+    if (!(this.matches_.matches(uri) || this.matches_host_.matchesIgnoringPath(uri))) {
+      return false;
+    }
+
+    if (this.exclude_matches_.matches(uri)) {
+      return false;
+    }
+
+    if (this.options.include_globs != null) {
+      if (!this.include_globs_.matches(uri.spec)) {
+        return false;
+      }
+    }
+
+    if (this.exclude_globs_.matches(uri.spec)) {
+      return false;
+    }
+
+    if (this.options.frame_id != null) {
+      if (WebNavigationFrames.getFrameId(window) != this.options.frame_id) {
+        return false;
+      }
+    } else if (!this.options.all_frames && window.top != window) {
+      return false;
+    }
+
+    return true;
+  },
+
+  cleanup(window) {
+    if (!this.remove_css) {
+      let winUtils = window.QueryInterface(Ci.nsIInterfaceRequestor)
+                           .getInterface(Ci.nsIDOMWindowUtils);
+
+      for (let url of this.cssURLs) {
+        runSafeSyncWithoutClone(winUtils.removeSheetUsingURIString, url, winUtils.AUTHOR_SHEET);
+      }
+    }
+  },
+
+  /**
+   * Tries to inject this script into the given window and sandbox, if
+   * there are pending operations for the window's current load state.
+   *
+   * @param {Window} window
+   *        The DOM Window to inject the scripts and CSS into.
+   * @param {Sandbox} sandbox
+   *        A Sandbox inheriting from `window` in which to evaluate the
+   *        injected scripts.
+   * @param {function} shouldRun
+   *        A function which, when passed the document load state that a
+   *        script is expected to run at, returns `true` if we should
+   *        currently be injecting scripts for that load state.
+   *
+   *        For initial injection of a script, this function should
+   *        return true if the document is currently in or has already
+   *        passed through the given state. For injections triggered by
+   *        document state changes, it should only return true if the
+   *        given state exactly matches the state that triggered the
+   *        change.
+   * @param {string} when
+   *        The document's current load state, or if triggered by a
+   *        document state change, the new document state that triggered
+   *        the injection.
+   */
+  tryInject(window, sandbox, shouldRun, when) {
+    if (shouldRun("document_start")) {
+      let {cssURLs} = this;
+      if (cssURLs.length > 0) {
+        let winUtils = window.QueryInterface(Ci.nsIInterfaceRequestor)
+                             .getInterface(Ci.nsIDOMWindowUtils);
+
+        let method = this.remove_css ? winUtils.removeSheetUsingURIString : winUtils.loadSheetUsingURIString;
+        for (let url of cssURLs) {
+          runSafeSyncWithoutClone(method, url, winUtils.AUTHOR_SHEET);
+        }
+
+        this.deferred.resolve();
+      }
+    }
+
+    let result;
+    let scheduled = this.run_at || "document_idle";
+    if (shouldRun(scheduled)) {
+      for (let [i, url] of this.js.entries()) {
+        let options = {
+          target: sandbox,
+          charset: "UTF-8",
+          // Inject the last script asynchronously unless we're expected to
+          // inject before any page scripts have run, and we haven't already
+          // missed that boat.
+          async: (i === this.js.length - 1) &&
+                 (this.run_at !== "document_start" || when !== "document_start"),
+        };
+        try {
+          result = Services.scriptloader.loadSubScriptWithOptions(url, options);
+        } catch (e) {
+          Cu.reportError(e);
+          this.deferred.reject(e);
+        }
+      }
+
+      if (this.options.jsCode) {
+        try {
+          result = Cu.evalInSandbox(this.options.jsCode, sandbox, "latest");
+        } catch (e) {
+          Cu.reportError(e);
+          this.deferred.reject(e);
+        }
+      }
+
+      this.deferred.resolve(result);
+    }
+  },
+};
+
+function getWindowMessageManager(contentWindow) {
+  let ir = contentWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+                        .getInterface(Ci.nsIDocShell)
+                        .QueryInterface(Ci.nsIInterfaceRequestor);
+  try {
+    return ir.getInterface(Ci.nsIContentFrameMessageManager);
+  } catch (e) {
+    // Some windows don't support this interface (hidden window).
+    return null;
+  }
+}
+
+var DocumentManager;
+var ExtensionManager;
+
+/**
+ * An execution context for semi-privileged extension content scripts.
+ *
+ * This is the child side of the ContentScriptContextParent class
+ * defined in ExtensionParent.jsm.
+ */
+class ContentScriptContextChild extends BaseContext {
+  constructor(extension, contentWindow, contextOptions = {}) {
+    super("content_child", extension);
+
+    let {isExtensionPage} = contextOptions;
+
+    this.isExtensionPage = isExtensionPage;
+
+    this.setContentWindow(contentWindow);
+
+    let frameId = WebNavigationFrames.getFrameId(contentWindow);
+    this.frameId = frameId;
+
+    this.scripts = [];
+
+    let contentPrincipal = contentWindow.document.nodePrincipal;
+    let ssm = Services.scriptSecurityManager;
+
+    // copy origin attributes from the content window origin attributes to
+    // preserve the user context id. overwrite the addonId.
+    let attrs = contentPrincipal.originAttributes;
+    attrs.addonId = this.extension.id;
+    let extensionPrincipal = ssm.createCodebasePrincipal(this.extension.baseURI, attrs);
+
+    let principal;
+    if (ssm.isSystemPrincipal(contentPrincipal)) {
+      // Make sure we don't hand out the system principal by accident.
+      // also make sure that the null principal has the right origin attributes
+      principal = ssm.createNullPrincipal(attrs);
+    } else {
+      principal = [contentPrincipal, extensionPrincipal];
+    }
+
+    if (isExtensionPage) {
+      if (ExtensionManagement.getAddonIdForWindow(this.contentWindow) != this.extension.id) {
+        throw new Error("Invalid target window for this extension context");
+      }
+      // This is an iframe with content script API enabled and its principal should be the
+      // contentWindow itself. (we create a sandbox with the contentWindow as principal and with X-rays disabled
+      // because it enables us to create the APIs object in this sandbox object and then copying it
+      // into the iframe's window, see Bug 1214658 for rationale)
+      this.sandbox = Cu.Sandbox(contentWindow, {
+        sandboxPrototype: contentWindow,
+        sameZoneAs: contentWindow,
+        wantXrays: false,
+        isWebExtensionContentScript: true,
+      });
+    } else {
+      // This metadata is required by the Developer Tools, in order for
+      // the content script to be associated with both the extension and
+      // the tab holding the content page.
+      let metadata = {
+        "inner-window-id": this.innerWindowID,
+        addonId: attrs.addonId,
+      };
+
+      this.sandbox = Cu.Sandbox(principal, {
+        metadata,
+        sandboxPrototype: contentWindow,
+        sameZoneAs: contentWindow,
+        wantXrays: true,
+        isWebExtensionContentScript: true,
+        wantExportHelpers: true,
+        wantGlobalProperties: ["XMLHttpRequest", "fetch"],
+        originAttributes: attrs,
+      });
+
+      Cu.evalInSandbox(`
+        window.JSON = JSON;
+        window.XMLHttpRequest = XMLHttpRequest;
+        window.fetch = fetch;
+      `, this.sandbox);
+    }
+
+    Object.defineProperty(this, "principal", {
+      value: Cu.getObjectPrincipal(this.sandbox),
+      enumerable: true,
+      configurable: true,
+    });
+
+    this.url = contentWindow.location.href;
+
+    defineLazyGetter(this, "chromeObj", () => {
+      let chromeObj = Cu.createObjectIn(this.sandbox);
+
+      Schemas.inject(chromeObj, this.childManager);
+      return chromeObj;
+    });
+
+    Schemas.exportLazyGetter(this.sandbox, "browser", () => this.chromeObj);
+    Schemas.exportLazyGetter(this.sandbox, "chrome", () => this.chromeObj);
+
+    // This is an iframe with content script API enabled (bug 1214658)
+    if (isExtensionPage) {
+      Schemas.exportLazyGetter(this.contentWindow,
+                               "browser", () => this.chromeObj);
+      Schemas.exportLazyGetter(this.contentWindow,
+                               "chrome", () => this.chromeObj);
+    }
+  }
+
+  get cloneScope() {
+    return this.sandbox;
+  }
+
+  execute(script, shouldRun, when) {
+    script.tryInject(this.contentWindow, this.sandbox, shouldRun, when);
+  }
+
+  addScript(script, when) {
+    let state = DocumentManager.getWindowState(this.contentWindow);
+    this.execute(script, scheduled => isWhenBeforeOrSame(scheduled, state), when);
+
+    // Save the script in case it has pending operations in later load
+    // states, but only if we're before document_idle, or require cleanup.
+    if (state != "document_idle" || script.requiresCleanup) {
+      this.scripts.push(script);
+    }
+  }
+
+  triggerScripts(documentState) {
+    for (let script of this.scripts) {
+      this.execute(script, scheduled => scheduled == documentState, documentState);
+    }
+    if (documentState == "document_idle") {
+      // Don't bother saving scripts after document_idle.
+      this.scripts = this.scripts.filter(script => script.requiresCleanup);
+    }
+  }
+
+  close() {
+    super.unload();
+
+    if (this.contentWindow) {
+      for (let script of this.scripts) {
+        if (script.requiresCleanup) {
+          script.cleanup(this.contentWindow);
+        }
+      }
+
+      // Overwrite the content script APIs with an empty object if the APIs objects are still
+      // defined in the content window (bug 1214658).
+      if (this.isExtensionPage) {
+        Cu.createObjectIn(this.contentWindow, {defineAs: "browser"});
+        Cu.createObjectIn(this.contentWindow, {defineAs: "chrome"});
+      }
+    }
+    Cu.nukeSandbox(this.sandbox);
+    this.sandbox = null;
+  }
+}
+
+defineLazyGetter(ContentScriptContextChild.prototype, "messenger", function() {
+  // The |sender| parameter is passed directly to the extension.
+  let sender = {id: this.extension.uuid, frameId: this.frameId, url: this.url};
+  let filter = {extensionId: this.extension.id};
+  let optionalFilter = {frameId: this.frameId};
+
+  return new Messenger(this, [this.messageManager], sender, filter, optionalFilter);
+});
+
+defineLazyGetter(ContentScriptContextChild.prototype, "childManager", function() {
+  let localApis = {};
+  apiManager.generateAPIs(this, localApis);
+
+  let childManager = new ChildAPIManager(this, this.messageManager, localApis, {
+    envType: "content_parent",
+    url: this.url,
+  });
+
+  this.callOnClose(childManager);
+
+  return childManager;
+});
+
+// Responsible for creating ExtensionContexts and injecting content
+// scripts into them when new documents are created.
+DocumentManager = {
+  extensionCount: 0,
+
+  // Map[windowId -> Map[extensionId -> ContentScriptContextChild]]
+  contentScriptWindows: new Map(),
+
+  // Map[windowId -> ContentScriptContextChild]
+  extensionPageWindows: new Map(),
+
+  init() {
+    Services.obs.addObserver(this, "content-document-global-created", false);
+    Services.obs.addObserver(this, "document-element-inserted", false);
+    Services.obs.addObserver(this, "inner-window-destroyed", false);
+  },
+
+  uninit() {
+    Services.obs.removeObserver(this, "content-document-global-created");
+    Services.obs.removeObserver(this, "document-element-inserted");
+    Services.obs.removeObserver(this, "inner-window-destroyed");
+  },
+
+  getWindowState(contentWindow) {
+    let readyState = contentWindow.document.readyState;
+    if (readyState == "complete") {
+      return "document_idle";
+    }
+    if (readyState == "interactive") {
+      return "document_end";
+    }
+    return "document_start";
+  },
+
+  loadInto(window) {
+    // Enable the content script APIs should be available in subframes' window
+    // if it is recognized as a valid addon id (see Bug 1214658 for rationale).
+    const {
+      NO_PRIVILEGES,
+      CONTENTSCRIPT_PRIVILEGES,
+      FULL_PRIVILEGES,
+    } = ExtensionManagement.API_LEVELS;
+    let extensionId = ExtensionManagement.getAddonIdForWindow(window);
+    let apiLevel = ExtensionManagement.getAPILevelForWindow(window, extensionId);
+
+    if (apiLevel != NO_PRIVILEGES) {
+      let extension = ExtensionManager.get(extensionId);
+      if (extension) {
+        if (apiLevel == CONTENTSCRIPT_PRIVILEGES) {
+          DocumentManager.getExtensionPageContext(extension, window);
+        } else if (apiLevel == FULL_PRIVILEGES) {
+          ExtensionChild.createExtensionContext(extension, window);
+        }
+      }
+    }
+  },
+
+  observe: function(subject, topic, data) {
+    // For some types of documents (about:blank), we only see the first
+    // notification, for others (data: URIs) we only observe the second.
+    if (topic == "content-document-global-created" || topic == "document-element-inserted") {
+      let document = subject;
+      let window = document && document.defaultView;
+
+      if (topic == "content-document-global-created") {
+        window = subject;
+        document = window && window.document;
+      }
+
+      if (!document || !document.location || !window) {
+        return;
+      }
+
+      // Make sure we only load into frames that ExtensionContent.init
+      // was called on (i.e., not frames for social or sidebars).
+      let mm = getWindowMessageManager(window);
+      if (!mm || !ExtensionContent.globals.has(mm)) {
+        return;
+      }
+
+      // Load on document-element-inserted, except for about:blank which doesn't
+      // see it, and needs special late handling on DOMContentLoaded event.
+      if (topic === "document-element-inserted") {
+        this.loadInto(window);
+        this.trigger("document_start", window);
+      }
+
+      /* eslint-disable mozilla/balanced-listeners */
+      window.addEventListener("DOMContentLoaded", this, true);
+      window.addEventListener("load", this, true);
+      /* eslint-enable mozilla/balanced-listeners */
+    } else if (topic == "inner-window-destroyed") {
+      let windowId = subject.QueryInterface(Ci.nsISupportsPRUint64).data;
+
+      MessageChannel.abortResponses({innerWindowID: windowId});
+
+      // Close any existent content-script context for the destroyed window.
+      if (this.contentScriptWindows.has(windowId)) {
+        let extensions = this.contentScriptWindows.get(windowId);
+        for (let [, context] of extensions) {
+          context.close();
+        }
+
+        this.contentScriptWindows.delete(windowId);
+      }
+
+      // Close any existent iframe extension page context for the destroyed window.
+      if (this.extensionPageWindows.has(windowId)) {
+        let context = this.extensionPageWindows.get(windowId);
+        context.close();
+        this.extensionPageWindows.delete(windowId);
+      }
+
+      ExtensionChild.destroyExtensionContext(windowId);
+    }
+  },
+
+  handleEvent: function(event) {
+    let window = event.currentTarget;
+    if (event.target != window.document) {
+      // We use capturing listeners so we have precedence over content script
+      // listeners, but only care about events targeted to the element we're
+      // listening on.
+      return;
+    }
+    window.removeEventListener(event.type, this, true);
+
+    // Need to check if we're still on the right page? Greasemonkey does this.
+
+    if (event.type == "DOMContentLoaded") {
+      // By this time, we can be sure if this is an explicit about:blank
+      // document, and if it needs special late loading and fake trigger.
+      if (window.location.href === "about:blank") {
+        this.loadInto(window);
+        this.trigger("document_start", window);
+      }
+      this.trigger("document_end", window);
+    } else if (event.type == "load") {
+      this.trigger("document_idle", window);
+    }
+  },
+
+  // Used to executeScript, insertCSS and removeCSS.
+  executeScript(global, extensionId, options) {
+    let extension = ExtensionManager.get(extensionId);
+
+    let executeInWin = (window) => {
+      let deferred = PromiseUtils.defer();
+      let script = new Script(extension, options, deferred);
+
+      if (script.matches(window)) {
+        let context = this.getContentScriptContext(extension, window);
+        context.addScript(script);
+        return deferred.promise;
+      }
+      return null;
+    };
+
+    let promises = Array.from(this.enumerateWindows(global.docShell), executeInWin)
+                        .filter(promise => promise);
+
+    if (!promises.length) {
+      let details = {};
+      for (let key of ["all_frames", "frame_id", "matches_about_blank", "matchesHost"]) {
+        if (key in options) {
+          details[key] = options[key];
+        }
+      }
+
+      return Promise.reject({message: `No window matching ${JSON.stringify(details)}`});
+    }
+    if (!options.all_frames && promises.length > 1) {
+      return Promise.reject({message: `Internal error: Script matched multiple windows`});
+    }
+    return Promise.all(promises);
+  },
+
+  enumerateWindows: function* (docShell) {
+    let window = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+                         .getInterface(Ci.nsIDOMWindow);
+    yield window;
+
+    for (let i = 0; i < docShell.childCount; i++) {
+      let child = docShell.getChildAt(i).QueryInterface(Ci.nsIDocShell);
+      yield* this.enumerateWindows(child);
+    }
+  },
+
+  getContentScriptGlobalsForWindow(window) {
+    let winId = getInnerWindowID(window);
+    let extensions = this.contentScriptWindows.get(winId);
+
+    if (extensions) {
+      return Array.from(extensions.values(), ctx => ctx.sandbox);
+    }
+
+    return [];
+  },
+
+  getContentScriptContext(extension, window) {
+    let winId = getInnerWindowID(window);
+    if (!this.contentScriptWindows.has(winId)) {
+      this.contentScriptWindows.set(winId, new Map());
+    }
+
+    let extensions = this.contentScriptWindows.get(winId);
+    if (!extensions.has(extension.id)) {
+      let context = new ContentScriptContextChild(extension, window);
+      extensions.set(extension.id, context);
+    }
+
+    return extensions.get(extension.id);
+  },
+
+  getExtensionPageContext(extension, window) {
+    let winId = getInnerWindowID(window);
+
+    let context = this.extensionPageWindows.get(winId);
+    if (!context) {
+      let context = new ContentScriptContextChild(extension, window, {isExtensionPage: true});
+      this.extensionPageWindows.set(winId, context);
+    }
+
+    return context;
+  },
+
+  startupExtension(extensionId) {
+    if (this.extensionCount == 0) {
+      this.init();
+    }
+    this.extensionCount++;
+
+    let extension = ExtensionManager.get(extensionId);
+    for (let global of ExtensionContent.globals.keys()) {
+      // Note that we miss windows in the bfcache here. In theory we
+      // could execute content scripts on a pageshow event for that
+      // window, but that seems extreme.
+      for (let window of this.enumerateWindows(global.docShell)) {
+        for (let script of extension.scripts) {
+          if (script.matches(window)) {
+            let context = this.getContentScriptContext(extension, window);
+            context.addScript(script);
+          }
+        }
+      }
+    }
+  },
+
+  shutdownExtension(extensionId) {
+    // Clean up content-script contexts on extension shutdown.
+    for (let [, extensions] of this.contentScriptWindows) {
+      let context = extensions.get(extensionId);
+      if (context) {
+        context.close();
+        extensions.delete(extensionId);
+      }
+    }
+
+    // Clean up iframe extension page contexts on extension shutdown.
+    for (let [winId, context] of this.extensionPageWindows) {
+      if (context.extension.id == extensionId) {
+        context.close();
+        this.extensionPageWindows.delete(winId);
+      }
+    }
+
+    ExtensionChild.shutdownExtension(extensionId);
+
+    MessageChannel.abortResponses({extensionId});
+
+    this.extensionCount--;
+    if (this.extensionCount == 0) {
+      this.uninit();
+    }
+  },
+
+  trigger(when, window) {
+    if (when === "document_start") {
+      for (let extension of ExtensionManager.extensions.values()) {
+        for (let script of extension.scripts) {
+          if (script.matches(window)) {
+            let context = this.getContentScriptContext(extension, window);
+            context.addScript(script, when);
+          }
+        }
+      }
+    } else {
+      let contexts = this.contentScriptWindows.get(getInnerWindowID(window)) || new Map();
+      for (let context of contexts.values()) {
+        context.triggerScripts(when);
+      }
+    }
+  },
+};
+
+// Represents a browser extension in the content process.
+class BrowserExtensionContent extends EventEmitter {
+  constructor(data) {
+    super();
+
+    this.id = data.id;
+    this.uuid = data.uuid;
+    this.data = data;
+    this.instanceId = data.instanceId;
+
+    this.MESSAGE_EMIT_EVENT = `Extension:EmitEvent:${this.instanceId}`;
+    Services.cpmm.addMessageListener(this.MESSAGE_EMIT_EVENT, this);
+
+    this.scripts = data.content_scripts.map(scriptData => new Script(this, scriptData));
+    this.webAccessibleResources = new MatchGlobs(data.webAccessibleResources);
+    this.whiteListedHosts = new MatchPattern(data.whiteListedHosts);
+    this.permissions = data.permissions;
+    this.principal = data.principal;
+
+    this.localeData = new LocaleData(data.localeData);
+
+    this.manifest = data.manifest;
+    this.baseURI = Services.io.newURI(data.baseURL, null, null);
+
+    // Only used in addon processes.
+    this.views = new Set();
+
+    let uri = Services.io.newURI(data.resourceURL, null, null);
+
+    if (Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT) {
+      // Extension.jsm takes care of this in the parent.
+      ExtensionManagement.startupExtension(this.uuid, uri, this);
+    }
+  }
+
+  shutdown() {
+    Services.cpmm.removeMessageListener(this.MESSAGE_EMIT_EVENT, this);
+
+    if (Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT) {
+      ExtensionManagement.shutdownExtension(this.uuid);
+    }
+  }
+
+  emit(event, ...args) {
+    Services.cpmm.sendAsyncMessage(this.MESSAGE_EMIT_EVENT, {event, args});
+
+    super.emit(event, ...args);
+  }
+
+  receiveMessage({name, data}) {
+    if (name === this.MESSAGE_EMIT_EVENT) {
+      super.emit(data.event, ...data.args);
+    }
+  }
+
+  localizeMessage(...args) {
+    return this.localeData.localizeMessage(...args);
+  }
+
+  localize(...args) {
+    return this.localeData.localize(...args);
+  }
+
+  hasPermission(perm) {
+    let match = /^manifest:(.*)/.exec(perm);
+    if (match) {
+      return this.manifest[match[1]] != null;
+    }
+    return this.permissions.has(perm);
+  }
+}
+
+ExtensionManager = {
+  // Map[extensionId, BrowserExtensionContent]
+  extensions: new Map(),
+
+  init() {
+    Schemas.init();
+    ExtensionChild.initOnce();
+
+    Services.cpmm.addMessageListener("Extension:Startup", this);
+    Services.cpmm.addMessageListener("Extension:Shutdown", this);
+    Services.cpmm.addMessageListener("Extension:FlushJarCache", this);
+
+    if (Services.cpmm.initialProcessData && "Extension:Extensions" in Services.cpmm.initialProcessData) {
+      let extensions = Services.cpmm.initialProcessData["Extension:Extensions"];
+      for (let data of extensions) {
+        this.extensions.set(data.id, new BrowserExtensionContent(data));
+        DocumentManager.startupExtension(data.id);
+      }
+    }
+  },
+
+  get(extensionId) {
+    return this.extensions.get(extensionId);
+  },
+
+  receiveMessage({name, data}) {
+    let extension;
+    switch (name) {
+      case "Extension:Startup": {
+        extension = new BrowserExtensionContent(data);
+
+        this.extensions.set(data.id, extension);
+
+        DocumentManager.startupExtension(data.id);
+
+        Services.cpmm.sendAsyncMessage("Extension:StartupComplete");
+        break;
+      }
+
+      case "Extension:Shutdown": {
+        extension = this.extensions.get(data.id);
+        extension.shutdown();
+
+        DocumentManager.shutdownExtension(data.id);
+
+        this.extensions.delete(data.id);
+        break;
+      }
+
+      case "Extension:FlushJarCache": {
+        let nsIFile = Components.Constructor("@mozilla.org/file/local;1", "nsIFile",
+                                             "initWithPath");
+        let file = new nsIFile(data.path);
+        flushJarCache(file);
+        Services.cpmm.sendAsyncMessage("Extension:FlushJarCacheComplete");
+        break;
+      }
+    }
+  },
+};
+
+class ExtensionGlobal {
+  constructor(global) {
+    this.global = global;
+
+    MessageChannel.addListener(global, "Extension:Capture", this);
+    MessageChannel.addListener(global, "Extension:DetectLanguage", this);
+    MessageChannel.addListener(global, "Extension:Execute", this);
+    MessageChannel.addListener(global, "WebNavigation:GetFrame", this);
+    MessageChannel.addListener(global, "WebNavigation:GetAllFrames", this);
+
+    this.windowId = global.content
+                          .QueryInterface(Ci.nsIInterfaceRequestor)
+                          .getInterface(Ci.nsIDOMWindowUtils)
+                          .outerWindowID;
+
+    global.sendAsyncMessage("Extension:TopWindowID", {windowId: this.windowId});
+  }
+
+  uninit() {
+    this.global.sendAsyncMessage("Extension:RemoveTopWindowID", {windowId: this.windowId});
+  }
+
+  get messageFilterStrict() {
+    return {
+      innerWindowID: getInnerWindowID(this.global.content),
+    };
+  }
+
+  receiveMessage({target, messageName, recipient, data}) {
+    switch (messageName) {
+      case "Extension:Capture":
+        return this.handleExtensionCapture(data.width, data.height, data.options);
+      case "Extension:DetectLanguage":
+        return this.handleDetectLanguage(target);
+      case "Extension:Execute":
+        return this.handleExtensionExecute(target, recipient.extensionId, data.options);
+      case "WebNavigation:GetFrame":
+        return this.handleWebNavigationGetFrame(data.options);
+      case "WebNavigation:GetAllFrames":
+        return this.handleWebNavigationGetAllFrames();
+    }
+  }
+
+  handleExtensionCapture(width, height, options) {
+    let win = this.global.content;
+
+    const XHTML_NS = "http://www.w3.org/1999/xhtml";
+    let canvas = win.document.createElementNS(XHTML_NS, "canvas");
+    canvas.width = width;
+    canvas.height = height;
+    canvas.mozOpaque = true;
+
+    let ctx = canvas.getContext("2d");
+
+    // We need to scale the image to the visible size of the browser,
+    // in order for the result to appear as the user sees it when
+    // settings like full zoom come into play.
+    ctx.scale(canvas.width / win.innerWidth, canvas.height / win.innerHeight);
+
+    ctx.drawWindow(win, win.scrollX, win.scrollY, win.innerWidth, win.innerHeight, "#fff");
+
+    return canvas.toDataURL(`image/${options.format}`, options.quality / 100);
+  }
+
+  handleDetectLanguage(target) {
+    let doc = target.content.document;
+
+    return promiseDocumentReady(doc).then(() => {
+      let elem = doc.documentElement;
+
+      let language = (elem.getAttribute("xml:lang") || elem.getAttribute("lang") ||
+                      doc.contentLanguage || null);
+
+      // We only want the last element of the TLD here.
+      // Only country codes have any effect on the results, but other
+      // values cause no harm.
+      let tld = doc.location.hostname.match(/[a-z]*$/)[0];
+
+      // The CLD2 library used by the language detector is capable of
+      // analyzing raw HTML. Unfortunately, that takes much more memory,
+      // and since it's hosted by emscripten, and therefore can't shrink
+      // its heap after it's grown, it has a performance cost.
+      // So we send plain text instead.
+      let encoder = Cc["@mozilla.org/layout/documentEncoder;1?type=text/plain"].createInstance(Ci.nsIDocumentEncoder);
+      encoder.init(doc, "text/plain", encoder.SkipInvisibleContent);
+      let text = encoder.encodeToStringWithMaxLength(60 * 1024);
+
+      let encoding = doc.characterSet;
+
+      return LanguageDetector.detectLanguage({language, tld, text, encoding})
+        .then(result => result.language === "un" ? "und" : result.language);
+    });
+  }
+
+  // Used to executeScript, insertCSS and removeCSS.
+  handleExtensionExecute(target, extensionId, options) {
+    return DocumentManager.executeScript(target, extensionId, options).then(result => {
+      try {
+        // Make sure we can structured-clone the result value before
+        // we try to send it back over the message manager.
+        Cu.cloneInto(result, target);
+      } catch (e) {
+        return Promise.reject({message: "Script returned non-structured-clonable data"});
+      }
+      return result;
+    });
+  }
+
+  handleWebNavigationGetFrame({frameId}) {
+    return WebNavigationFrames.getFrame(this.global.docShell, frameId);
+  }
+
+  handleWebNavigationGetAllFrames() {
+    return WebNavigationFrames.getAllFrames(this.global.docShell);
+  }
+}
+
+this.ExtensionContent = {
+  globals: new Map(),
+
+  init(global) {
+    this.globals.set(global, new ExtensionGlobal(global));
+    ExtensionChild.init(global);
+  },
+
+  uninit(global) {
+    ExtensionChild.uninit(global);
+    this.globals.get(global).uninit();
+    this.globals.delete(global);
+  },
+
+  // This helper is exported to be integrated in the devtools RDP actors,
+  // that can use it to retrieve the existent WebExtensions ContentScripts
+  // of a target window and be able to show the ContentScripts source in the
+  // DevTools Debugger panel.
+  getContentScriptGlobalsForWindow(window) {
+    return DocumentManager.getContentScriptGlobalsForWindow(window);
+  },
+};
+
+ExtensionManager.init();