summaryrefslogtreecommitdiffstats
path: root/browser/components/webextensions/ext-utils.js
diff options
context:
space:
mode:
Diffstat (limited to 'browser/components/webextensions/ext-utils.js')
-rw-r--r--browser/components/webextensions/ext-utils.js1239
1 files changed, 1239 insertions, 0 deletions
diff --git a/browser/components/webextensions/ext-utils.js b/browser/components/webextensions/ext-utils.js
new file mode 100644
index 000000000..75b2f4bd4
--- /dev/null
+++ b/browser/components/webextensions/ext-utils.js
@@ -0,0 +1,1239 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+"use strict";
+
+XPCOMUtils.defineLazyModuleGetter(this, "CustomizableUI",
+ "resource:///modules/CustomizableUI.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+ "resource://gre/modules/NetUtil.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PrivateBrowsingUtils",
+ "resource://gre/modules/PrivateBrowsingUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+ "resource://gre/modules/Task.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "setTimeout",
+ "resource://gre/modules/Timer.jsm");
+
+XPCOMUtils.defineLazyServiceGetter(this, "styleSheetService",
+ "@mozilla.org/content/style-sheet-service;1",
+ "nsIStyleSheetService");
+
+Cu.import("resource://gre/modules/ExtensionUtils.jsm");
+Cu.import("resource://gre/modules/AppConstants.jsm");
+
+const POPUP_LOAD_TIMEOUT_MS = 200;
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+var {
+ DefaultWeakMap,
+ EventManager,
+ promiseEvent,
+} = ExtensionUtils;
+
+// This file provides some useful code for the |tabs| and |windows|
+// modules. All of the code is installed on |global|, which is a scope
+// shared among the different ext-*.js scripts.
+
+global.makeWidgetId = id => {
+ id = id.toLowerCase();
+ // FIXME: This allows for collisions.
+ return id.replace(/[^a-z0-9_-]/g, "_");
+};
+
+function promisePopupShown(popup) {
+ return new Promise(resolve => {
+ if (popup.state == "open") {
+ resolve();
+ } else {
+ popup.addEventListener("popupshown", function onPopupShown(event) {
+ popup.removeEventListener("popupshown", onPopupShown);
+ resolve();
+ });
+ }
+ });
+}
+
+XPCOMUtils.defineLazyGetter(this, "popupStylesheets", () => {
+ let stylesheets = ["chrome://browser/content/extension.css"];
+
+ if (AppConstants.platform === "macosx") {
+ stylesheets.push("chrome://browser/content/extension-mac.css");
+ }
+ return stylesheets;
+});
+
+XPCOMUtils.defineLazyGetter(this, "standaloneStylesheets", () => {
+ let stylesheets = [];
+
+ if (AppConstants.platform === "macosx") {
+ stylesheets.push("chrome://browser/content/extension-mac-panel.css");
+ }
+ if (AppConstants.platform === "win") {
+ stylesheets.push("chrome://browser/content/extension-win-panel.css");
+ }
+ return stylesheets;
+});
+
+class BasePopup {
+ constructor(extension, viewNode, popupURL, browserStyle, fixedWidth = false) {
+ this.extension = extension;
+ this.popupURL = popupURL;
+ this.viewNode = viewNode;
+ this.browserStyle = browserStyle;
+ this.window = viewNode.ownerGlobal;
+ this.destroyed = false;
+ this.fixedWidth = fixedWidth;
+
+ extension.callOnClose(this);
+
+ this.contentReady = new Promise(resolve => {
+ this._resolveContentReady = resolve;
+ });
+
+ this.viewNode.addEventListener(this.DESTROY_EVENT, this);
+
+ let doc = viewNode.ownerDocument;
+ let arrowContent = doc.getAnonymousElementByAttribute(this.panel, "class", "panel-arrowcontent");
+ this.borderColor = doc.defaultView.getComputedStyle(arrowContent).borderTopColor;
+
+ this.browser = null;
+ this.browserLoaded = new Promise((resolve, reject) => {
+ this.browserLoadedDeferred = {resolve, reject};
+ });
+ this.browserReady = this.createBrowser(viewNode, popupURL);
+
+ BasePopup.instances.get(this.window).set(extension, this);
+ }
+
+ static for(extension, window) {
+ return BasePopup.instances.get(window).get(extension);
+ }
+
+ close() {
+ this.closePopup();
+ }
+
+ destroy() {
+ this.extension.forgetOnClose(this);
+
+ this.destroyed = true;
+ this.browserLoadedDeferred.reject(new Error("Popup destroyed"));
+ return this.browserReady.then(() => {
+ this.destroyBrowser(this.browser);
+ this.browser.remove();
+
+ this.viewNode.removeEventListener(this.DESTROY_EVENT, this);
+ this.viewNode.style.maxHeight = "";
+
+ if (this.panel) {
+ this.panel.style.removeProperty("--arrowpanel-background");
+ this.panel.style.removeProperty("--panel-arrow-image-vertical");
+ }
+
+ BasePopup.instances.get(this.window).delete(this.extension);
+
+ this.browser = null;
+ this.viewNode = null;
+ });
+ }
+
+ destroyBrowser(browser) {
+ let mm = browser.messageManager;
+ // If the browser has already been removed from the document, because the
+ // popup was closed externally, there will be no message manager here.
+ if (mm) {
+ mm.removeMessageListener("DOMTitleChanged", this);
+ mm.removeMessageListener("Extension:BrowserBackgroundChanged", this);
+ mm.removeMessageListener("Extension:BrowserContentLoaded", this);
+ mm.removeMessageListener("Extension:BrowserResized", this);
+ mm.removeMessageListener("Extension:DOMWindowClose", this);
+ }
+ }
+
+ // Returns the name of the event fired on `viewNode` when the popup is being
+ // destroyed. This must be implemented by every subclass.
+ get DESTROY_EVENT() {
+ throw new Error("Not implemented");
+ }
+
+ get STYLESHEETS() {
+ let sheets = [];
+
+ if (this.browserStyle) {
+ sheets.push(...popupStylesheets);
+ }
+ if (!this.fixedWidth) {
+ sheets.push(...standaloneStylesheets);
+ }
+
+ return sheets;
+ }
+
+ get panel() {
+ let panel = this.viewNode;
+ while (panel && panel.localName != "panel") {
+ panel = panel.parentNode;
+ }
+ return panel;
+ }
+
+ receiveMessage({name, data}) {
+ switch (name) {
+ case "DOMTitleChanged":
+ this.viewNode.setAttribute("aria-label", this.browser.contentTitle);
+ break;
+
+ case "Extension:BrowserBackgroundChanged":
+ this.setBackground(data.background);
+ break;
+
+ case "Extension:BrowserContentLoaded":
+ this.browserLoadedDeferred.resolve();
+ break;
+
+ case "Extension:BrowserResized":
+ this._resolveContentReady();
+ if (this.ignoreResizes) {
+ this.dimensions = data;
+ } else {
+ this.resizeBrowser(data);
+ }
+ break;
+
+ case "Extension:DOMWindowClose":
+ this.closePopup();
+ break;
+ }
+ }
+
+ handleEvent(event) {
+ switch (event.type) {
+ case this.DESTROY_EVENT:
+ this.destroy();
+ break;
+ }
+ }
+
+ createBrowser(viewNode, popupURL = null) {
+ let document = viewNode.ownerDocument;
+ this.browser = document.createElementNS(XUL_NS, "browser");
+ this.browser.setAttribute("type", "content");
+ this.browser.setAttribute("disableglobalhistory", "true");
+ this.browser.setAttribute("transparent", "true");
+ this.browser.setAttribute("class", "webextension-popup-browser");
+ this.browser.setAttribute("tooltip", "aHTMLTooltip");
+
+ // We only need flex sizing for the sake of the slide-in sub-views of the
+ // main menu panel, so that the browser occupies the full width of the view,
+ // and also takes up any extra height that's available to it.
+ this.browser.setAttribute("flex", "1");
+
+ // Note: When using noautohide panels, the popup manager will add width and
+ // height attributes to the panel, breaking our resize code, if the browser
+ // starts out smaller than 30px by 10px. This isn't an issue now, but it
+ // will be if and when we popup debugging.
+
+ viewNode.appendChild(this.browser);
+
+ extensions.emit("extension-browser-inserted", this.browser);
+ let windowId = WindowManager.getId(this.browser.ownerGlobal);
+ this.browser.messageManager.sendAsyncMessage("Extension:InitExtensionView", {
+ viewType: "popup",
+ windowId,
+ });
+ // TODO(robwu): Rework this to use the Extension:ExtensionViewLoaded message
+ // to detect loads and so on. And definitely move this content logic inside
+ // a file in the child process.
+
+ let initBrowser = browser => {
+ let mm = browser.messageManager;
+ mm.addMessageListener("DOMTitleChanged", this);
+ mm.addMessageListener("Extension:BrowserBackgroundChanged", this);
+ mm.addMessageListener("Extension:BrowserContentLoaded", this);
+ mm.addMessageListener("Extension:BrowserResized", this);
+ mm.addMessageListener("Extension:DOMWindowClose", this, true);
+ };
+
+ if (!popupURL) {
+ initBrowser(this.browser);
+ return this.browser;
+ }
+
+ return promiseEvent(this.browser, "load").then(() => {
+ initBrowser(this.browser);
+
+ let mm = this.browser.messageManager;
+
+ mm.loadFrameScript(
+ "chrome://extensions/content/ext-browser-content.js", false);
+
+ mm.sendAsyncMessage("Extension:InitBrowser", {
+ allowScriptsToClose: true,
+ fixedWidth: this.fixedWidth,
+ maxWidth: 800,
+ maxHeight: 600,
+ stylesheets: this.STYLESHEETS,
+ });
+
+ this.browser.setAttribute("src", popupURL);
+ });
+ }
+
+ resizeBrowser({width, height, detail}) {
+ if (this.fixedWidth) {
+ // Figure out how much extra space we have on the side of the panel
+ // opposite the arrow.
+ let side = this.panel.getAttribute("side") == "top" ? "bottom" : "top";
+ let maxHeight = this.viewHeight + this.extraHeight[side];
+
+ height = Math.min(height, maxHeight);
+ this.browser.style.height = `${height}px`;
+
+ // Set a maximum height on the <panelview> element to our preferred
+ // maximum height, so that the PanelUI resizing code can make an accurate
+ // calculation. If we don't do this, the flex sizing logic will prevent us
+ // from ever reporting a preferred size smaller than the height currently
+ // available to us in the panel.
+ height = Math.max(height, this.viewHeight);
+ this.viewNode.style.maxHeight = `${height}px`;
+ } else {
+ this.browser.style.width = `${width}px`;
+ this.browser.style.height = `${height}px`;
+ }
+
+ let event = new this.window.CustomEvent("WebExtPopupResized", {detail});
+ this.browser.dispatchEvent(event);
+ }
+
+ setBackground(background) {
+ let panelBackground = "";
+ let panelArrow = "";
+
+ if (background) {
+ let borderColor = this.borderColor || background;
+
+ panelBackground = background;
+ panelArrow = `url("data:image/svg+xml,${encodeURIComponent(`<?xml version="1.0" encoding="UTF-8"?>
+ <svg xmlns="http://www.w3.org/2000/svg" width="20" height="10">
+ <path d="M 0,10 L 10,0 20,10 z" fill="${borderColor}"/>
+ <path d="M 1,10 L 10,1 19,10 z" fill="${background}"/>
+ </svg>
+ `)}")`;
+ }
+
+ this.panel.style.setProperty("--arrowpanel-background", panelBackground);
+ this.panel.style.setProperty("--panel-arrow-image-vertical", panelArrow);
+ this.background = background;
+ }
+}
+
+/**
+ * A map of active popups for a given browser window.
+ *
+ * WeakMap[window -> WeakMap[Extension -> BasePopup]]
+ */
+BasePopup.instances = new DefaultWeakMap(() => new WeakMap());
+
+class PanelPopup extends BasePopup {
+ constructor(extension, imageNode, popupURL, browserStyle) {
+ let document = imageNode.ownerDocument;
+
+ let panel = document.createElement("panel");
+ panel.setAttribute("id", makeWidgetId(extension.id) + "-panel");
+ panel.setAttribute("class", "browser-extension-panel");
+ panel.setAttribute("tabspecific", "true");
+ panel.setAttribute("type", "arrow");
+ panel.setAttribute("role", "group");
+
+ document.getElementById("mainPopupSet").appendChild(panel);
+
+ super(extension, panel, popupURL, browserStyle);
+
+ this.contentReady.then(() => {
+ panel.openPopup(imageNode, "bottomcenter topright", 0, 0, false, false);
+
+ let event = new this.window.CustomEvent("WebExtPopupLoaded", {
+ bubbles: true,
+ detail: {extension},
+ });
+ this.browser.dispatchEvent(event);
+ });
+ }
+
+ get DESTROY_EVENT() {
+ return "popuphidden";
+ }
+
+ destroy() {
+ super.destroy();
+ this.viewNode.remove();
+ }
+
+ closePopup() {
+ promisePopupShown(this.viewNode).then(() => {
+ // Make sure we're not already destroyed.
+ if (this.viewNode) {
+ this.viewNode.hidePopup();
+ }
+ });
+ }
+}
+
+class ViewPopup extends BasePopup {
+ constructor(extension, window, popupURL, browserStyle, fixedWidth) {
+ let document = window.document;
+
+ // Create a temporary panel to hold the browser while it pre-loads its
+ // content. This panel will never be shown, but the browser's docShell will
+ // be swapped with the browser in the real panel when it's ready.
+ let panel = document.createElement("panel");
+ panel.setAttribute("type", "arrow");
+ document.getElementById("mainPopupSet").appendChild(panel);
+
+ super(extension, panel, popupURL, browserStyle, fixedWidth);
+
+ this.ignoreResizes = true;
+
+ this.attached = false;
+ this.tempPanel = panel;
+
+ this.browser.classList.add("webextension-preload-browser");
+ }
+
+ /**
+ * Attaches the pre-loaded browser to the given view node, and reserves a
+ * promise which resolves when the browser is ready.
+ *
+ * @param {Element} viewNode
+ * The node to attach the browser to.
+ * @returns {Promise<boolean>}
+ * Resolves when the browser is ready. Resolves to `false` if the
+ * browser was destroyed before it was fully loaded, and the popup
+ * should be closed, or `true` otherwise.
+ */
+ attach(viewNode) {
+ return Task.spawn(function* () {
+ this.viewNode = viewNode;
+ this.viewNode.addEventListener(this.DESTROY_EVENT, this);
+
+ // Wait until the browser element is fully initialized, and give it at least
+ // a short grace period to finish loading its initial content, if necessary.
+ //
+ // In practice, the browser that was created by the mousdown handler should
+ // nearly always be ready by this point.
+ yield Promise.all([
+ this.browserReady,
+ Promise.race([
+ // This promise may be rejected if the popup calls window.close()
+ // before it has fully loaded.
+ this.browserLoaded.catch(() => {}),
+ new Promise(resolve => setTimeout(resolve, POPUP_LOAD_TIMEOUT_MS)),
+ ]),
+ ]);
+
+ if (!this.destroyed && !this.panel) {
+ this.destroy();
+ }
+
+ if (this.destroyed) {
+ return false;
+ }
+
+ this.attached = true;
+
+ // Store the initial height of the view, so that we never resize menu panel
+ // sub-views smaller than the initial height of the menu.
+ this.viewHeight = this.viewNode.boxObject.height;
+
+ // Calculate the extra height available on the screen above and below the
+ // menu panel. Use that to calculate the how much the sub-view may grow.
+ let popupRect = this.panel.getBoundingClientRect();
+
+ this.setBackground(this.background);
+
+ let win = this.window;
+ let popupBottom = win.mozInnerScreenY + popupRect.bottom;
+ let popupTop = win.mozInnerScreenY + popupRect.top;
+
+ let screenBottom = win.screen.availTop + win.screen.availHeight;
+ this.extraHeight = {
+ bottom: Math.max(0, screenBottom - popupBottom),
+ top: Math.max(0, popupTop - win.screen.availTop),
+ };
+
+ // Create a new browser in the real popup.
+ let browser = this.browser;
+ this.createBrowser(this.viewNode);
+
+ this.browser.swapDocShells(browser);
+ this.destroyBrowser(browser);
+
+ this.ignoreResizes = false;
+ if (this.dimensions) {
+ this.resizeBrowser(this.dimensions);
+ }
+
+ this.tempPanel.remove();
+ this.tempPanel = null;
+
+ let event = new this.window.CustomEvent("WebExtPopupLoaded", {
+ bubbles: true,
+ detail: {extension: this.extension},
+ });
+ this.browser.dispatchEvent(event);
+
+ return true;
+ }.bind(this));
+ }
+
+ destroy() {
+ return super.destroy().then(() => {
+ if (this.tempPanel) {
+ this.tempPanel.remove();
+ this.tempPanel = null;
+ }
+ });
+ }
+
+ get DESTROY_EVENT() {
+ return "ViewHiding";
+ }
+
+ closePopup() {
+ if (this.attached) {
+ CustomizableUI.hidePanelForNode(this.viewNode);
+ } else {
+ this.destroy();
+ }
+ }
+}
+
+Object.assign(global, {PanelPopup, ViewPopup});
+
+// Manages tab-specific context data, and dispatching tab select events
+// across all windows.
+global.TabContext = function TabContext(getDefaults, extension) {
+ this.extension = extension;
+ this.getDefaults = getDefaults;
+
+ this.tabData = new WeakMap();
+ this.lastLocation = new WeakMap();
+
+ AllWindowEvents.addListener("progress", this);
+ AllWindowEvents.addListener("TabSelect", this);
+
+ EventEmitter.decorate(this);
+};
+
+TabContext.prototype = {
+ get(tab) {
+ if (!this.tabData.has(tab)) {
+ this.tabData.set(tab, this.getDefaults(tab));
+ }
+
+ return this.tabData.get(tab);
+ },
+
+ clear(tab) {
+ this.tabData.delete(tab);
+ },
+
+ handleEvent(event) {
+ if (event.type == "TabSelect") {
+ let tab = event.target;
+ this.emit("tab-select", tab);
+ this.emit("location-change", tab);
+ }
+ },
+
+ onStateChange(browser, webProgress, request, stateFlags, statusCode) {
+ let flags = Ci.nsIWebProgressListener;
+
+ if (!(~stateFlags & (flags.STATE_IS_WINDOW | flags.STATE_START) ||
+ this.lastLocation.has(browser))) {
+ this.lastLocation.set(browser, request.URI);
+ }
+ },
+
+ onLocationChange(browser, webProgress, request, locationURI, flags) {
+ let gBrowser = browser.ownerGlobal.gBrowser;
+ let lastLocation = this.lastLocation.get(browser);
+ if (browser === gBrowser.selectedBrowser &&
+ !(lastLocation && lastLocation.equalsExceptRef(browser.currentURI))) {
+ let tab = gBrowser.getTabForBrowser(browser);
+ this.emit("location-change", tab, true);
+ }
+ this.lastLocation.set(browser, browser.currentURI);
+ },
+
+ shutdown() {
+ AllWindowEvents.removeListener("progress", this);
+ AllWindowEvents.removeListener("TabSelect", this);
+ },
+};
+
+// Manages tab mappings and permissions for a specific extension.
+function ExtensionTabManager(extension) {
+ this.extension = extension;
+
+ // A mapping of tab objects to the inner window ID the extension currently has
+ // the active tab permission for. The active permission for a given tab is
+ // valid only for the inner window that was active when the permission was
+ // granted. If the tab navigates, the inner window ID changes, and the
+ // permission automatically becomes stale.
+ //
+ // WeakMap[tab => inner-window-id<int>]
+ this.hasTabPermissionFor = new WeakMap();
+}
+
+ExtensionTabManager.prototype = {
+ addActiveTabPermission(tab = TabManager.activeTab) {
+ if (this.extension.hasPermission("activeTab")) {
+ // Note that, unlike Chrome, we don't currently clear this permission with
+ // the tab navigates. If the inner window is revived from BFCache before
+ // we've granted this permission to a new inner window, the extension
+ // maintains its permissions for it.
+ this.hasTabPermissionFor.set(tab, tab.linkedBrowser.innerWindowID);
+ }
+ },
+
+ revokeActiveTabPermission(tab = TabManager.activeTab) {
+ this.hasTabPermissionFor.delete(tab);
+ },
+
+ // Returns true if the extension has the "activeTab" permission for this tab.
+ // This is somewhat more permissive than the generic "tabs" permission, as
+ // checked by |hasTabPermission|, in that it also allows programmatic script
+ // injection without an explicit host permission.
+ hasActiveTabPermission(tab) {
+ // This check is redundant with addTabPermission, but cheap.
+ if (this.extension.hasPermission("activeTab")) {
+ return (this.hasTabPermissionFor.has(tab) &&
+ this.hasTabPermissionFor.get(tab) === tab.linkedBrowser.innerWindowID);
+ }
+ return false;
+ },
+
+ hasTabPermission(tab) {
+ return this.extension.hasPermission("tabs") || this.hasActiveTabPermission(tab);
+ },
+
+ convert(tab) {
+ let window = tab.ownerGlobal;
+ let browser = tab.linkedBrowser;
+
+ let mutedInfo = {muted: tab.muted};
+ if (tab.muteReason === null) {
+ mutedInfo.reason = "user";
+ } else if (tab.muteReason) {
+ mutedInfo.reason = "extension";
+ mutedInfo.extensionId = tab.muteReason;
+ }
+
+ let result = {
+ id: TabManager.getId(tab),
+ index: tab._tPos,
+ windowId: WindowManager.getId(window),
+ selected: tab.selected,
+ highlighted: tab.selected,
+ active: tab.selected,
+ pinned: tab.pinned,
+ status: TabManager.getStatus(tab),
+ incognito: WindowManager.isBrowserPrivate(browser),
+ width: browser.frameLoader.lazyWidth || browser.clientWidth,
+ height: browser.frameLoader.lazyHeight || browser.clientHeight,
+ audible: tab.soundPlaying,
+ mutedInfo,
+ };
+ if (this.extension.hasPermission("cookies")) {
+ result.cookieStoreId = getCookieStoreIdForTab(result, tab);
+ }
+
+ if (this.hasTabPermission(tab)) {
+ result.url = browser.currentURI.spec;
+ let title = browser.contentTitle || tab.label;
+ if (title) {
+ result.title = title;
+ }
+ let icon = window.gBrowser.getIcon(tab);
+ if (icon) {
+ result.favIconUrl = icon;
+ }
+ }
+
+ return result;
+ },
+
+ // Converts tabs returned from SessionStore.getClosedTabData and
+ // SessionStore.getClosedWindowData into API tab objects
+ convertFromSessionStoreClosedData(tab, window) {
+ let result = {
+ sessionId: String(tab.closedId),
+ index: tab.pos ? tab.pos : 0,
+ windowId: WindowManager.getId(window),
+ selected: false,
+ highlighted: false,
+ active: false,
+ pinned: false,
+ incognito: Boolean(tab.state && tab.state.isPrivate),
+ };
+
+ if (this.hasTabPermission(tab)) {
+ let entries = tab.state ? tab.state.entries : tab.entries;
+ result.url = entries[0].url;
+ result.title = entries[0].title;
+ if (tab.image) {
+ result.favIconUrl = tab.image;
+ }
+ }
+
+ return result;
+ },
+
+ getTabs(window) {
+ return Array.from(window.gBrowser.tabs)
+ .filter(tab => !tab.closing)
+ .map(tab => this.convert(tab));
+ },
+};
+
+// Sends the tab and windowId upon request. This is primarily used to support
+// the synchronous `browser.extension.getViews` API.
+let onGetTabAndWindowId = {
+ receiveMessage({name, target, sync}) {
+ let {gBrowser} = target.ownerGlobal;
+ let tab = gBrowser && gBrowser.getTabForBrowser(target);
+ if (tab) {
+ let reply = {
+ tabId: TabManager.getId(tab),
+ windowId: WindowManager.getId(tab.ownerGlobal),
+ };
+ if (sync) {
+ return reply;
+ }
+ target.messageManager.sendAsyncMessage("Extension:SetTabAndWindowId", reply);
+ }
+ },
+};
+/* eslint-disable mozilla/balanced-listeners */
+Services.mm.addMessageListener("Extension:GetTabAndWindowId", onGetTabAndWindowId);
+/* eslint-enable mozilla/balanced-listeners */
+
+
+// Manages global mappings between XUL tabs and extension tab IDs.
+global.TabManager = {
+ _tabs: new WeakMap(),
+ _nextId: 1,
+ _initialized: false,
+
+ // We begin listening for TabOpen and TabClose events once we've started
+ // assigning IDs to tabs, so that we can remap the IDs of tabs which are moved
+ // between windows.
+ initListener() {
+ if (this._initialized) {
+ return;
+ }
+
+ AllWindowEvents.addListener("TabOpen", this);
+ AllWindowEvents.addListener("TabClose", this);
+ WindowListManager.addOpenListener(this.handleWindowOpen.bind(this));
+
+ this._initialized = true;
+ },
+
+ handleEvent(event) {
+ if (event.type == "TabOpen") {
+ let {adoptedTab} = event.detail;
+ if (adoptedTab) {
+ // This tab is being created to adopt a tab from a different window.
+ // Copy the ID from the old tab to the new.
+ let tab = event.target;
+ this._tabs.set(tab, this.getId(adoptedTab));
+
+ tab.linkedBrowser.messageManager.sendAsyncMessage("Extension:SetTabAndWindowId", {
+ windowId: WindowManager.getId(tab.ownerGlobal),
+ });
+ }
+ } else if (event.type == "TabClose") {
+ let {adoptedBy} = event.detail;
+ if (adoptedBy) {
+ // This tab is being closed because it was adopted by a new window.
+ // Copy its ID to the new tab, in case it was created as the first tab
+ // of a new window, and did not have an `adoptedTab` detail when it was
+ // opened.
+ this._tabs.set(adoptedBy, this.getId(event.target));
+
+ adoptedBy.linkedBrowser.messageManager.sendAsyncMessage("Extension:SetTabAndWindowId", {
+ windowId: WindowManager.getId(adoptedBy),
+ });
+ }
+ }
+ },
+
+ handleWindowOpen(window) {
+ if (window.arguments && window.arguments[0] instanceof window.XULElement) {
+ // If the first window argument is a XUL element, it means the
+ // window is about to adopt a tab from another window to replace its
+ // initial tab.
+ let adoptedTab = window.arguments[0];
+
+ this._tabs.set(window.gBrowser.tabs[0], this.getId(adoptedTab));
+ }
+ },
+
+ getId(tab) {
+ if (this._tabs.has(tab)) {
+ return this._tabs.get(tab);
+ }
+ this.initListener();
+
+ let id = this._nextId++;
+ this._tabs.set(tab, id);
+ return id;
+ },
+
+ getBrowserId(browser) {
+ let gBrowser = browser.ownerGlobal.gBrowser;
+ // Some non-browser windows have gBrowser but not
+ // getTabForBrowser!
+ if (gBrowser && gBrowser.getTabForBrowser) {
+ let tab = gBrowser.getTabForBrowser(browser);
+ if (tab) {
+ return this.getId(tab);
+ }
+ }
+ return -1;
+ },
+
+ /**
+ * Returns the XUL <tab> element associated with the given tab ID. If no tab
+ * with the given ID exists, and no default value is provided, an error is
+ * raised, belonging to the scope of the given context.
+ *
+ * @param {integer} tabId
+ * The ID of the tab to retrieve.
+ * @param {ExtensionContext} context
+ * The context of the caller.
+ * This value may be omitted if `default_` is not `undefined`.
+ * @param {*} default_
+ * The value to return if no tab exists with the given ID.
+ * @returns {Element<tab>}
+ * A XUL <tab> element.
+ */
+ getTab(tabId, context, default_ = undefined) {
+ // FIXME: Speed this up without leaking memory somehow.
+ for (let window of WindowListManager.browserWindows()) {
+ if (!window.gBrowser) {
+ continue;
+ }
+ for (let tab of window.gBrowser.tabs) {
+ if (this.getId(tab) == tabId) {
+ return tab;
+ }
+ }
+ }
+ if (default_ !== undefined) {
+ return default_;
+ }
+ throw new context.cloneScope.Error(`Invalid tab ID: ${tabId}`);
+ },
+
+ get activeTab() {
+ let window = WindowManager.topWindow;
+ if (window && window.gBrowser) {
+ return window.gBrowser.selectedTab;
+ }
+ return null;
+ },
+
+ getStatus(tab) {
+ return tab.getAttribute("busy") == "true" ? "loading" : "complete";
+ },
+
+ convert(extension, tab) {
+ return TabManager.for(extension).convert(tab);
+ },
+};
+
+// WeakMap[Extension -> ExtensionTabManager]
+let tabManagers = new WeakMap();
+
+// Returns the extension-specific tab manager for the given extension, or
+// creates one if it doesn't already exist.
+TabManager.for = function(extension) {
+ if (!tabManagers.has(extension)) {
+ tabManagers.set(extension, new ExtensionTabManager(extension));
+ }
+ return tabManagers.get(extension);
+};
+
+/* eslint-disable mozilla/balanced-listeners */
+extensions.on("shutdown", (type, extension) => {
+ tabManagers.delete(extension);
+});
+/* eslint-enable mozilla/balanced-listeners */
+
+function memoize(fn) {
+ let weakMap = new DefaultWeakMap(fn);
+ return weakMap.get.bind(weakMap);
+}
+
+// Manages mapping between XUL windows and extension window IDs.
+global.WindowManager = {
+ _windows: new WeakMap(),
+ _nextId: 0,
+
+ // Note: These must match the values in windows.json.
+ WINDOW_ID_NONE: -1,
+ WINDOW_ID_CURRENT: -2,
+
+ get topWindow() {
+ return Services.wm.getMostRecentWindow("navigator:browser");
+ },
+
+ windowType(window) {
+ // TODO: Make this work.
+
+ let {chromeFlags} = window.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDocShell)
+ .treeOwner.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIXULWindow);
+
+ if (chromeFlags & Ci.nsIWebBrowserChrome.CHROME_OPENAS_DIALOG) {
+ return "popup";
+ }
+
+ return "normal";
+ },
+
+ updateGeometry(window, options) {
+ if (options.left !== null || options.top !== null) {
+ let left = options.left !== null ? options.left : window.screenX;
+ let top = options.top !== null ? options.top : window.screenY;
+ window.moveTo(left, top);
+ }
+
+ if (options.width !== null || options.height !== null) {
+ let width = options.width !== null ? options.width : window.outerWidth;
+ let height = options.height !== null ? options.height : window.outerHeight;
+ window.resizeTo(width, height);
+ }
+ },
+
+ isBrowserPrivate: memoize(browser => {
+ return PrivateBrowsingUtils.isBrowserPrivate(browser);
+ }),
+
+ getId(window) {
+ if (this._windows.has(window)) {
+ return this._windows.get(window);
+ }
+ let id = this._nextId++;
+ this._windows.set(window, id);
+ return id;
+ },
+
+ getWindow(id, context) {
+ if (id == this.WINDOW_ID_CURRENT) {
+ return currentWindow(context);
+ }
+
+ for (let window of WindowListManager.browserWindows(true)) {
+ if (this.getId(window) == id) {
+ return window;
+ }
+ }
+ return null;
+ },
+
+ getState(window) {
+ const STATES = {
+ [window.STATE_MAXIMIZED]: "maximized",
+ [window.STATE_MINIMIZED]: "minimized",
+ [window.STATE_NORMAL]: "normal",
+ };
+ let state = STATES[window.windowState];
+ if (window.fullScreen) {
+ state = "fullscreen";
+ }
+ return state;
+ },
+
+ setState(window, state) {
+ if (state != "fullscreen" && window.fullScreen) {
+ window.fullScreen = false;
+ }
+
+ switch (state) {
+ case "maximized":
+ window.maximize();
+ break;
+
+ case "minimized":
+ case "docked":
+ window.minimize();
+ break;
+
+ case "normal":
+ // Restore sometimes returns the window to its previous state, rather
+ // than to the "normal" state, so it may need to be called anywhere from
+ // zero to two times.
+ window.restore();
+ if (window.windowState != window.STATE_NORMAL) {
+ window.restore();
+ }
+ if (window.windowState != window.STATE_NORMAL) {
+ // And on OS-X, where normal vs. maximized is basically a heuristic,
+ // we need to cheat.
+ window.sizeToContent();
+ }
+ break;
+
+ case "fullscreen":
+ window.fullScreen = true;
+ break;
+
+ default:
+ throw new Error(`Unexpected window state: ${state}`);
+ }
+ },
+
+ convert(extension, window, getInfo) {
+ let xulWindow = window.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDocShell)
+ .treeOwner.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIXULWindow);
+
+ let result = {
+ id: this.getId(window),
+ focused: window.document.hasFocus(),
+ top: window.screenY,
+ left: window.screenX,
+ width: window.outerWidth,
+ height: window.outerHeight,
+ incognito: PrivateBrowsingUtils.isWindowPrivate(window),
+ type: this.windowType(window),
+ state: this.getState(window),
+ alwaysOnTop: xulWindow.zLevel >= Ci.nsIXULWindow.raisedZ,
+ };
+
+ if (getInfo && getInfo.populate) {
+ result.tabs = TabManager.for(extension).getTabs(window);
+ }
+
+ return result;
+ },
+
+ // Converts windows returned from SessionStore.getClosedWindowData
+ // into API window objects
+ convertFromSessionStoreClosedData(window, extension) {
+ let result = {
+ sessionId: String(window.closedId),
+ focused: false,
+ incognito: false,
+ type: "normal", // this is always "normal" for a closed window
+ state: this.getState(window),
+ alwaysOnTop: false,
+ };
+
+ if (window.tabs.length) {
+ result.tabs = [];
+ window.tabs.forEach((tab, index) => {
+ result.tabs.push(TabManager.for(extension).convertFromSessionStoreClosedData(tab, window, index));
+ });
+ }
+
+ return result;
+ },
+};
+
+// Manages listeners for window opening and closing. A window is
+// considered open when the "load" event fires on it. A window is
+// closed when a "domwindowclosed" notification fires for it.
+global.WindowListManager = {
+ _openListeners: new Set(),
+ _closeListeners: new Set(),
+
+ // Returns an iterator for all browser windows. Unless |includeIncomplete| is
+ // true, only fully-loaded windows are returned.
+ * browserWindows(includeIncomplete = false) {
+ // The window type parameter is only available once the window's document
+ // element has been created. This means that, when looking for incomplete
+ // browser windows, we need to ignore the type entirely for windows which
+ // haven't finished loading, since we would otherwise skip browser windows
+ // in their early loading stages.
+ // This is particularly important given that the "domwindowcreated" event
+ // fires for browser windows when they're in that in-between state, and just
+ // before we register our own "domwindowcreated" listener.
+
+ let e = Services.wm.getEnumerator("");
+ while (e.hasMoreElements()) {
+ let window = e.getNext();
+
+ let ok = includeIncomplete;
+ if (window.document.readyState == "complete") {
+ ok = window.document.documentElement.getAttribute("windowtype") == "navigator:browser";
+ }
+
+ if (ok) {
+ yield window;
+ }
+ }
+ },
+
+ addOpenListener(listener) {
+ if (this._openListeners.size == 0 && this._closeListeners.size == 0) {
+ Services.ww.registerNotification(this);
+ }
+ this._openListeners.add(listener);
+
+ for (let window of this.browserWindows(true)) {
+ if (window.document.readyState != "complete") {
+ window.addEventListener("load", this);
+ }
+ }
+ },
+
+ removeOpenListener(listener) {
+ this._openListeners.delete(listener);
+ if (this._openListeners.size == 0 && this._closeListeners.size == 0) {
+ Services.ww.unregisterNotification(this);
+ }
+ },
+
+ addCloseListener(listener) {
+ if (this._openListeners.size == 0 && this._closeListeners.size == 0) {
+ Services.ww.registerNotification(this);
+ }
+ this._closeListeners.add(listener);
+ },
+
+ removeCloseListener(listener) {
+ this._closeListeners.delete(listener);
+ if (this._openListeners.size == 0 && this._closeListeners.size == 0) {
+ Services.ww.unregisterNotification(this);
+ }
+ },
+
+ handleEvent(event) {
+ event.currentTarget.removeEventListener(event.type, this);
+ let window = event.target.defaultView;
+ if (window.document.documentElement.getAttribute("windowtype") != "navigator:browser") {
+ return;
+ }
+
+ for (let listener of this._openListeners) {
+ listener(window);
+ }
+ },
+
+ observe(window, topic, data) {
+ if (topic == "domwindowclosed") {
+ if (window.document.documentElement.getAttribute("windowtype") != "navigator:browser") {
+ return;
+ }
+
+ window.removeEventListener("load", this);
+ for (let listener of this._closeListeners) {
+ listener(window);
+ }
+ } else {
+ window.addEventListener("load", this);
+ }
+ },
+};
+
+// Provides a facility to listen for DOM events across all XUL windows.
+global.AllWindowEvents = {
+ _listeners: new Map(),
+
+ // If |type| is a normal event type, invoke |listener| each time
+ // that event fires in any open window. If |type| is "progress", add
+ // a web progress listener that covers all open windows.
+ addListener(type, listener) {
+ if (type == "domwindowopened") {
+ return WindowListManager.addOpenListener(listener);
+ } else if (type == "domwindowclosed") {
+ return WindowListManager.addCloseListener(listener);
+ }
+
+ if (this._listeners.size == 0) {
+ WindowListManager.addOpenListener(this.openListener);
+ }
+
+ if (!this._listeners.has(type)) {
+ this._listeners.set(type, new Set());
+ }
+ let list = this._listeners.get(type);
+ list.add(listener);
+
+ // Register listener on all existing windows.
+ for (let window of WindowListManager.browserWindows()) {
+ this.addWindowListener(window, type, listener);
+ }
+ },
+
+ removeListener(eventType, listener) {
+ if (eventType == "domwindowopened") {
+ return WindowListManager.removeOpenListener(listener);
+ } else if (eventType == "domwindowclosed") {
+ return WindowListManager.removeCloseListener(listener);
+ }
+
+ let listeners = this._listeners.get(eventType);
+ listeners.delete(listener);
+ if (listeners.size == 0) {
+ this._listeners.delete(eventType);
+ if (this._listeners.size == 0) {
+ WindowListManager.removeOpenListener(this.openListener);
+ }
+ }
+
+ // Unregister listener from all existing windows.
+ let useCapture = eventType === "focus" || eventType === "blur";
+ for (let window of WindowListManager.browserWindows()) {
+ if (eventType == "progress") {
+ window.gBrowser.removeTabsProgressListener(listener);
+ } else {
+ window.removeEventListener(eventType, listener, useCapture);
+ }
+ }
+ },
+
+ /* eslint-disable mozilla/balanced-listeners */
+ addWindowListener(window, eventType, listener) {
+ let useCapture = eventType === "focus" || eventType === "blur";
+
+ if (eventType == "progress") {
+ window.gBrowser.addTabsProgressListener(listener);
+ } else {
+ window.addEventListener(eventType, listener, useCapture);
+ }
+ },
+ /* eslint-enable mozilla/balanced-listeners */
+
+ // Runs whenever the "load" event fires for a new window.
+ openListener(window) {
+ for (let [eventType, listeners] of AllWindowEvents._listeners) {
+ for (let listener of listeners) {
+ this.addWindowListener(window, eventType, listener);
+ }
+ }
+ },
+};
+
+AllWindowEvents.openListener = AllWindowEvents.openListener.bind(AllWindowEvents);
+
+// Subclass of EventManager where we just need to call
+// add/removeEventListener on each XUL window.
+global.WindowEventManager = function(context, name, event, listener) {
+ EventManager.call(this, context, name, fire => {
+ let listener2 = (...args) => listener(fire, ...args);
+ AllWindowEvents.addListener(event, listener2);
+ return () => {
+ AllWindowEvents.removeListener(event, listener2);
+ };
+ });
+};
+
+WindowEventManager.prototype = Object.create(EventManager.prototype);