Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

1 files changed, 1258 insertions, 0 deletions

diff --git a/browser/components/extensions/parent/ext-browser.js b/browser/components/extensions/parent/ext-browser.js
new file mode 100644
index 0000000000..3b8a179c8d
--- /dev/null
+++ b/browser/components/extensions/parent/ext-browser.js
@@ -0,0 +1,1258 @@
+/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set sts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+// This 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.
+
+ChromeUtils.defineESModuleGetters(this, {
+  AboutReaderParent: "resource:///actors/AboutReaderParent.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+  PromiseUtils: "resource://gre/modules/PromiseUtils.sys.mjs",
+});
+ChromeUtils.defineModuleGetter(
+  this,
+  "BrowserWindowTracker",
+  "resource:///modules/BrowserWindowTracker.jsm"
+);
+
+var { ExtensionError } = ExtensionUtils;
+
+var { defineLazyGetter } = ExtensionCommon;
+
+const READER_MODE_PREFIX = "about:reader";
+
+let tabTracker;
+let windowTracker;
+
+function isPrivateTab(nativeTab) {
+  return PrivateBrowsingUtils.isBrowserPrivate(nativeTab.linkedBrowser);
+}
+
+/* eslint-disable mozilla/balanced-listeners */
+extensions.on("uninstalling", (msg, extension) => {
+  if (extension.uninstallURL) {
+    let browser = windowTracker.topWindow.gBrowser;
+    browser.addTab(extension.uninstallURL, {
+      relatedToCurrent: true,
+      triggeringPrincipal: Services.scriptSecurityManager.createNullPrincipal(
+        {}
+      ),
+    });
+  }
+});
+
+extensions.on("page-shutdown", (type, context) => {
+  if (context.viewType == "tab") {
+    if (context.extension.id !== context.xulBrowser.contentPrincipal.addonId) {
+      // Only close extension tabs.
+      // This check prevents about:addons from closing when it contains a
+      // WebExtension as an embedded inline options page.
+      return;
+    }
+    let { gBrowser } = context.xulBrowser.ownerGlobal;
+    if (gBrowser && gBrowser.getTabForBrowser) {
+      let nativeTab = gBrowser.getTabForBrowser(context.xulBrowser);
+      if (nativeTab) {
+        gBrowser.removeTab(nativeTab);
+      }
+    }
+  }
+});
+/* eslint-enable mozilla/balanced-listeners */
+
+global.openOptionsPage = extension => {
+  let window = windowTracker.topWindow;
+  if (!window) {
+    return Promise.reject({ message: "No browser window available" });
+  }
+
+  if (extension.manifest.options_ui.open_in_tab) {
+    window.switchToTabHavingURI(extension.manifest.options_ui.page, true, {
+      triggeringPrincipal: extension.principal,
+    });
+    return Promise.resolve();
+  }
+
+  let viewId = `addons://detail/${encodeURIComponent(
+    extension.id
+  )}/preferences`;
+
+  return window.BrowserOpenAddonsMgr(viewId);
+};
+
+global.makeWidgetId = id => {
+  id = id.toLowerCase();
+  // FIXME: This allows for collisions.
+  return id.replace(/[^a-z0-9_-]/g, "_");
+};
+
+global.clickModifiersFromEvent = event => {
+  const map = {
+    shiftKey: "Shift",
+    altKey: "Alt",
+    metaKey: "Command",
+    ctrlKey: "Ctrl",
+  };
+  let modifiers = Object.keys(map)
+    .filter(key => event[key])
+    .map(key => map[key]);
+
+  if (event.ctrlKey && AppConstants.platform === "macosx") {
+    modifiers.push("MacCtrl");
+  }
+
+  return modifiers;
+};
+
+global.waitForTabLoaded = (tab, url) => {
+  return new Promise(resolve => {
+    windowTracker.addListener("progress", {
+      onLocationChange(browser, webProgress, request, locationURI, flags) {
+        if (
+          webProgress.isTopLevel &&
+          browser.ownerGlobal.gBrowser.getTabForBrowser(browser) == tab &&
+          (!url || locationURI.spec == url)
+        ) {
+          windowTracker.removeListener("progress", this);
+          resolve();
+        }
+      },
+    });
+  });
+};
+
+global.replaceUrlInTab = (gBrowser, tab, uri) => {
+  let loaded = waitForTabLoaded(tab, uri.spec);
+  gBrowser.loadURI(uri, {
+    flags: Ci.nsIWebNavigation.LOAD_FLAGS_REPLACE_HISTORY,
+    triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(), // This is safe from this functions usage however it would be preferred not to dot his.
+  });
+  return loaded;
+};
+
+/**
+ * Manages tab-specific and window-specific context data, and dispatches
+ * tab select events across all windows.
+ */
+global.TabContext = class extends EventEmitter {
+  /**
+   * @param {Function} getDefaultPrototype
+   *        Provides the prototype of the context value for a tab or window when there is none.
+   *        Called with a XULElement or ChromeWindow argument.
+   *        Should return an object or null.
+   */
+  constructor(getDefaultPrototype) {
+    super();
+
+    this.getDefaultPrototype = getDefaultPrototype;
+
+    this.tabData = new WeakMap();
+
+    windowTracker.addListener("progress", this);
+    windowTracker.addListener("TabSelect", this);
+
+    this.tabAdopted = this.tabAdopted.bind(this);
+    tabTracker.on("tab-adopted", this.tabAdopted);
+  }
+
+  /**
+   * Returns the context data associated with `keyObject`.
+   *
+   * @param {XULElement|ChromeWindow} keyObject
+   *        Browser tab or browser chrome window.
+   * @returns {object}
+   */
+  get(keyObject) {
+    if (!this.tabData.has(keyObject)) {
+      let data = Object.create(this.getDefaultPrototype(keyObject));
+      this.tabData.set(keyObject, data);
+    }
+
+    return this.tabData.get(keyObject);
+  }
+
+  /**
+   * Clears the context data associated with `keyObject`.
+   *
+   * @param {XULElement|ChromeWindow} keyObject
+   *        Browser tab or browser chrome window.
+   */
+  clear(keyObject) {
+    this.tabData.delete(keyObject);
+  }
+
+  handleEvent(event) {
+    if (event.type == "TabSelect") {
+      let nativeTab = event.target;
+      this.emit("tab-select", nativeTab);
+      this.emit("location-change", nativeTab);
+    }
+  }
+
+  onLocationChange(browser, webProgress, request, locationURI, flags) {
+    if (!webProgress.isTopLevel) {
+      // Only pageAction and browserAction are consuming the "location-change" event
+      // to update their per-tab status, and they should only do so in response of
+      // location changes related to the top level frame (See Bug 1493470 for a rationale).
+      return;
+    }
+    let gBrowser = browser.ownerGlobal.gBrowser;
+    let tab = gBrowser.getTabForBrowser(browser);
+    // fromBrowse will be false in case of e.g. a hash change or history.pushState
+    let fromBrowse = !(
+      flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT
+    );
+    this.emit("location-change", tab, fromBrowse);
+  }
+
+  /**
+   * Persists context data when a tab is moved between windows.
+   *
+   * @param {string} eventType
+   *        Event type, should be "tab-adopted".
+   * @param {NativeTab} adoptingTab
+   *        The tab which is being opened and adopting `adoptedTab`.
+   * @param {NativeTab} adoptedTab
+   *        The tab which is being closed and adopted by `adoptingTab`.
+   */
+  tabAdopted(eventType, adoptingTab, adoptedTab) {
+    if (!this.tabData.has(adoptedTab)) {
+      return;
+    }
+    // Create a new object (possibly with different inheritance) when a tab is moved
+    // into a new window. But then reassign own properties from the old object.
+    let newData = this.get(adoptingTab);
+    let oldData = this.tabData.get(adoptedTab);
+    this.tabData.delete(adoptedTab);
+    Object.assign(newData, oldData);
+  }
+
+  /**
+   * Makes the TabContext instance stop emitting events.
+   */
+  shutdown() {
+    windowTracker.removeListener("progress", this);
+    windowTracker.removeListener("TabSelect", this);
+    tabTracker.off("tab-adopted", this.tabAdopted);
+  }
+};
+
+// This promise is used to wait for the search service to be initialized.
+// None of the code in the WebExtension modules requests that initialization.
+// It is assumed that it is started at some point. That might never happen,
+// e.g. if the application shuts down before the search service initializes.
+XPCOMUtils.defineLazyGetter(global, "searchInitialized", () => {
+  if (Services.search.isInitialized) {
+    return Promise.resolve();
+  }
+  return ExtensionUtils.promiseObserved(
+    "browser-search-service",
+    (_, data) => data == "init-complete"
+  );
+});
+
+class WindowTracker extends WindowTrackerBase {
+  addProgressListener(window, listener) {
+    window.gBrowser.addTabsProgressListener(listener);
+  }
+
+  removeProgressListener(window, listener) {
+    window.gBrowser.removeTabsProgressListener(listener);
+  }
+
+  /**
+   * @param {BaseContext} context
+   *        The extension context
+   * @returns {DOMWindow|null} topNormalWindow
+   *        The currently active, or topmost, browser window, or null if no
+   *        browser window is currently open.
+   *        Will return the topmost "normal" (i.e., not popup) window.
+   */
+  getTopNormalWindow(context) {
+    let options = { allowPopups: false };
+    if (!context.privateBrowsingAllowed) {
+      options.private = false;
+    }
+    return BrowserWindowTracker.getTopWindow(options);
+  }
+}
+
+class TabTracker extends TabTrackerBase {
+  constructor() {
+    super();
+
+    this._tabs = new WeakMap();
+    this._browsers = new WeakMap();
+    this._tabIds = new Map();
+    this._nextId = 1;
+    this._deferredTabOpenEvents = new WeakMap();
+
+    this._handleTabDestroyed = this._handleTabDestroyed.bind(this);
+  }
+
+  init() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+
+    this.adoptedTabs = new WeakSet();
+
+    this._handleWindowOpen = this._handleWindowOpen.bind(this);
+    this._handleWindowClose = this._handleWindowClose.bind(this);
+
+    windowTracker.addListener("TabClose", this);
+    windowTracker.addListener("TabOpen", this);
+    windowTracker.addListener("TabSelect", this);
+    windowTracker.addListener("TabMultiSelect", this);
+    windowTracker.addOpenListener(this._handleWindowOpen);
+    windowTracker.addCloseListener(this._handleWindowClose);
+
+    AboutReaderParent.addMessageListener("Reader:UpdateReaderButton", this);
+
+    /* eslint-disable mozilla/balanced-listeners */
+    this.on("tab-detached", this._handleTabDestroyed);
+    this.on("tab-removed", this._handleTabDestroyed);
+    /* eslint-enable mozilla/balanced-listeners */
+  }
+
+  getId(nativeTab) {
+    let id = this._tabs.get(nativeTab);
+    if (id) {
+      return id;
+    }
+
+    this.init();
+
+    id = this._nextId++;
+    this.setId(nativeTab, id);
+    return id;
+  }
+
+  getBrowserTabId(browser) {
+    let id = this._browsers.get(browser);
+    if (id) {
+      return id;
+    }
+
+    let tab = browser.ownerGlobal.gBrowser.getTabForBrowser(browser);
+    if (tab) {
+      id = this.getId(tab);
+      this._browsers.set(browser, id);
+      return id;
+    }
+    return -1;
+  }
+
+  setId(nativeTab, id) {
+    if (!nativeTab.parentNode) {
+      throw new Error("Cannot attach ID to a destroyed tab.");
+    }
+    if (nativeTab.ownerGlobal.closed) {
+      throw new Error("Cannot attach ID to a tab in a closed window.");
+    }
+
+    this._tabs.set(nativeTab, id);
+    if (nativeTab.linkedBrowser) {
+      this._browsers.set(nativeTab.linkedBrowser, id);
+    }
+    this._tabIds.set(id, nativeTab);
+  }
+
+  /**
+   * Handles tab adoption when a tab is moved between windows.
+   * Ensures the new tab will have the same ID as the old one, and
+   * emits "tab-adopted", "tab-detached" and "tab-attached" events.
+   *
+   * @param {NativeTab} adoptingTab
+   *        The tab which is being opened and adopting `adoptedTab`.
+   * @param {NativeTab} adoptedTab
+   *        The tab which is being closed and adopted by `adoptingTab`.
+   */
+  adopt(adoptingTab, adoptedTab) {
+    if (this.adoptedTabs.has(adoptedTab)) {
+      // The adoption has already been handled.
+      return;
+    }
+    this.adoptedTabs.add(adoptedTab);
+    let tabId = this.getId(adoptedTab);
+    this.setId(adoptingTab, tabId);
+    this.emit("tab-adopted", adoptingTab, adoptedTab);
+    if (this.has("tab-detached")) {
+      let nativeTab = adoptedTab;
+      let adoptedBy = adoptingTab;
+      let oldWindowId = windowTracker.getId(nativeTab.ownerGlobal);
+      let oldPosition = nativeTab._tPos;
+      this.emit("tab-detached", {
+        nativeTab,
+        adoptedBy,
+        tabId,
+        oldWindowId,
+        oldPosition,
+      });
+    }
+    if (this.has("tab-attached")) {
+      let nativeTab = adoptingTab;
+      let newWindowId = windowTracker.getId(nativeTab.ownerGlobal);
+      let newPosition = nativeTab._tPos;
+      this.emit("tab-attached", {
+        nativeTab,
+        tabId,
+        newWindowId,
+        newPosition,
+      });
+    }
+  }
+
+  _handleTabDestroyed(event, { nativeTab }) {
+    let id = this._tabs.get(nativeTab);
+    if (id) {
+      this._tabs.delete(nativeTab);
+      if (this._tabIds.get(id) === nativeTab) {
+        this._tabIds.delete(id);
+      }
+    }
+  }
+
+  /**
+   * 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 {*} default_
+   *        The value to return if no tab exists with the given ID.
+   * @returns {Element<tab>}
+   *        A XUL <tab> element.
+   */
+  getTab(tabId, default_ = undefined) {
+    let nativeTab = this._tabIds.get(tabId);
+    if (nativeTab) {
+      return nativeTab;
+    }
+    if (default_ !== undefined) {
+      return default_;
+    }
+    throw new ExtensionError(`Invalid tab ID: ${tabId}`);
+  }
+
+  /**
+   * Sets the opener of `tab` to the ID `openerTab`. Both tabs must be in the
+   * same window, or this function will throw a type error.
+   *
+   * @param {Element} tab The tab for which to set the owner.
+   * @param {Element} openerTab The opener of <tab>.
+   */
+  setOpener(tab, openerTab) {
+    if (tab.ownerDocument !== openerTab.ownerDocument) {
+      throw new Error("Tab must be in the same window as its opener");
+    }
+    tab.openerTab = openerTab;
+  }
+
+  deferredForTabOpen(nativeTab) {
+    let deferred = this._deferredTabOpenEvents.get(nativeTab);
+    if (!deferred) {
+      deferred = PromiseUtils.defer();
+      this._deferredTabOpenEvents.set(nativeTab, deferred);
+      deferred.promise.then(() => {
+        this._deferredTabOpenEvents.delete(nativeTab);
+      });
+    }
+    return deferred;
+  }
+
+  async maybeWaitForTabOpen(nativeTab) {
+    let deferred = this._deferredTabOpenEvents.get(nativeTab);
+    return deferred && deferred.promise;
+  }
+
+  /**
+   * @param {Event} event
+   *        The DOM Event to handle.
+   * @private
+   */
+  handleEvent(event) {
+    let nativeTab = event.target;
+
+    switch (event.type) {
+      case "TabOpen":
+        let { adoptedTab } = event.detail;
+        if (adoptedTab) {
+          // This tab is being created to adopt a tab from a different window.
+          // Handle the adoption.
+          this.adopt(nativeTab, adoptedTab);
+        } else {
+          // Save the size of the current tab, since the newly-created tab will
+          // likely be active by the time the promise below resolves and the
+          // event is dispatched.
+          const currentTab = nativeTab.ownerGlobal.gBrowser.selectedTab;
+          const { frameLoader } = currentTab.linkedBrowser;
+          const currentTabSize = {
+            width: frameLoader.lazyWidth,
+            height: frameLoader.lazyHeight,
+          };
+
+          // We need to delay sending this event until the next tick, since the
+          // tab can become selected immediately after "TabOpen", then onCreated
+          // should be fired with `active: true`.
+          let deferred = this.deferredForTabOpen(event.originalTarget);
+          Promise.resolve().then(() => {
+            deferred.resolve();
+            if (!event.originalTarget.parentNode) {
+              // If the tab is already be destroyed, do nothing.
+              return;
+            }
+            this.emitCreated(event.originalTarget, currentTabSize);
+          });
+        }
+        break;
+
+      case "TabClose":
+        let { adoptedBy } = event.detail;
+        if (adoptedBy) {
+          // This tab is being closed because it was adopted by a new window.
+          // Handle the adoption 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.adopt(adoptedBy, nativeTab);
+        } else {
+          this.emitRemoved(nativeTab, false);
+        }
+        break;
+
+      case "TabSelect":
+        // Because we are delaying calling emitCreated above, we also need to
+        // delay sending this event because it shouldn't fire before onCreated.
+        this.maybeWaitForTabOpen(nativeTab).then(() => {
+          if (!nativeTab.parentNode) {
+            // If the tab is already be destroyed, do nothing.
+            return;
+          }
+          this.emitActivated(nativeTab, event.detail.previousTab);
+        });
+        break;
+
+      case "TabMultiSelect":
+        if (this.has("tabs-highlighted")) {
+          // Because we are delaying calling emitCreated above, we also need to
+          // delay sending this event because it shouldn't fire before onCreated.
+          // event.target is gBrowser, so we don't use maybeWaitForTabOpen.
+          Promise.resolve().then(() => {
+            this.emitHighlighted(event.target.ownerGlobal);
+          });
+        }
+        break;
+    }
+  }
+
+  /**
+   * @param {object} message
+   *        The message to handle.
+   * @private
+   */
+  receiveMessage(message) {
+    switch (message.name) {
+      case "Reader:UpdateReaderButton":
+        if (message.data && message.data.isArticle !== undefined) {
+          this.emit("tab-isarticle", message);
+        }
+        break;
+    }
+  }
+
+  /**
+   * A private method which is called whenever a new browser window is opened,
+   * and dispatches the necessary events for it.
+   *
+   * @param {DOMWindow} window
+   *        The window being opened.
+   * @private
+   */
+  _handleWindowOpen(window) {
+    const tabToAdopt = window.gBrowserInit.getTabToAdopt();
+    if (tabToAdopt) {
+      // Note that this event handler depends on running before the
+      // delayed startup code in browser.js, which is currently triggered
+      // by the first MozAfterPaint event. That code handles finally
+      // adopting the tab, and clears it from the arguments list in the
+      // process, so if we run later than it, we're too late.
+      let adoptedBy = window.gBrowser.tabs[0];
+      this.adopt(adoptedBy, tabToAdopt);
+    } else {
+      for (let nativeTab of window.gBrowser.tabs) {
+        this.emitCreated(nativeTab);
+      }
+
+      // emitActivated to trigger tab.onActivated/tab.onHighlighted for a newly opened window.
+      this.emitActivated(window.gBrowser.tabs[0]);
+      if (this.has("tabs-highlighted")) {
+        this.emitHighlighted(window);
+      }
+    }
+  }
+
+  /**
+   * A private method which is called whenever a browser window is closed,
+   * and dispatches the necessary events for it.
+   *
+   * @param {DOMWindow} window
+   *        The window being closed.
+   * @private
+   */
+  _handleWindowClose(window) {
+    for (let nativeTab of window.gBrowser.tabs) {
+      if (!this.adoptedTabs.has(nativeTab)) {
+        this.emitRemoved(nativeTab, true);
+      }
+    }
+  }
+
+  /**
+   * Emits a "tab-activated" event for the given tab element.
+   *
+   * @param {NativeTab} nativeTab
+   *        The tab element which has been activated.
+   * @param {NativeTab} previousTab
+   *        The tab element which was previously activated.
+   * @private
+   */
+  emitActivated(nativeTab, previousTab = undefined) {
+    let previousTabIsPrivate, previousTabId;
+    if (previousTab && !previousTab.closing) {
+      previousTabId = this.getId(previousTab);
+      previousTabIsPrivate = isPrivateTab(previousTab);
+    }
+    this.emit("tab-activated", {
+      tabId: this.getId(nativeTab),
+      previousTabId,
+      previousTabIsPrivate,
+      windowId: windowTracker.getId(nativeTab.ownerGlobal),
+      nativeTab,
+    });
+  }
+
+  /**
+   * Emits a "tabs-highlighted" event for the given tab element.
+   *
+   * @param {ChromeWindow} window
+   *        The window in which the active tab or the set of multiselected tabs changed.
+   * @private
+   */
+  emitHighlighted(window) {
+    let tabIds = window.gBrowser.selectedTabs.map(tab => this.getId(tab));
+    let windowId = windowTracker.getId(window);
+    this.emit("tabs-highlighted", {
+      tabIds,
+      windowId,
+    });
+  }
+
+  /**
+   * Emits a "tab-created" event for the given tab element.
+   *
+   * @param {NativeTab} nativeTab
+   *        The tab element which is being created.
+   * @param {object} [currentTabSize]
+   *        The size of the tab element for the currently active tab.
+   * @private
+   */
+  emitCreated(nativeTab, currentTabSize) {
+    this.emit("tab-created", {
+      nativeTab,
+      currentTabSize,
+    });
+  }
+
+  /**
+   * Emits a "tab-removed" event for the given tab element.
+   *
+   * @param {NativeTab} nativeTab
+   *        The tab element which is being removed.
+   * @param {boolean} isWindowClosing
+   *        True if the tab is being removed because the browser window is
+   *        closing.
+   * @private
+   */
+  emitRemoved(nativeTab, isWindowClosing) {
+    let windowId = windowTracker.getId(nativeTab.ownerGlobal);
+    let tabId = this.getId(nativeTab);
+
+    this.emit("tab-removed", {
+      nativeTab,
+      tabId,
+      windowId,
+      isWindowClosing,
+    });
+  }
+
+  getBrowserData(browser) {
+    let window = browser.ownerGlobal;
+    if (!window) {
+      return {
+        tabId: -1,
+        windowId: -1,
+      };
+    }
+    let { gBrowser } = window;
+    // Some non-browser windows have gBrowser but not getTabForBrowser!
+    if (!gBrowser || !gBrowser.getTabForBrowser) {
+      if (window.top.document.documentURI === "about:addons") {
+        // When we're loaded into a <browser> inside about:addons, we need to go up
+        // one more level.
+        browser = window.docShell.chromeEventHandler;
+
+        ({ gBrowser } = browser.ownerGlobal);
+      } else {
+        return {
+          tabId: -1,
+          windowId: -1,
+        };
+      }
+    }
+
+    return {
+      tabId: this.getBrowserTabId(browser),
+      windowId: windowTracker.getId(browser.ownerGlobal),
+    };
+  }
+
+  get activeTab() {
+    let window = windowTracker.topWindow;
+    if (window && window.gBrowser) {
+      return window.gBrowser.selectedTab;
+    }
+    return null;
+  }
+}
+
+windowTracker = new WindowTracker();
+tabTracker = new TabTracker();
+
+Object.assign(global, { tabTracker, windowTracker });
+
+class Tab extends TabBase {
+  get _favIconUrl() {
+    return this.window.gBrowser.getIcon(this.nativeTab);
+  }
+
+  get attention() {
+    return this.nativeTab.hasAttribute("attention");
+  }
+
+  get audible() {
+    return this.nativeTab.soundPlaying;
+  }
+
+  get browser() {
+    return this.nativeTab.linkedBrowser;
+  }
+
+  get discarded() {
+    return !this.nativeTab.linkedPanel;
+  }
+
+  get frameLoader() {
+    // If we don't have a frameLoader yet, just return a dummy with no width and
+    // height.
+    return super.frameLoader || { lazyWidth: 0, lazyHeight: 0 };
+  }
+
+  get hidden() {
+    return this.nativeTab.hidden;
+  }
+
+  get sharingState() {
+    return this.window.gBrowser.getTabSharingState(this.nativeTab);
+  }
+
+  get cookieStoreId() {
+    return getCookieStoreIdForTab(this, this.nativeTab);
+  }
+
+  get openerTabId() {
+    let opener = this.nativeTab.openerTab;
+    if (
+      opener &&
+      opener.parentNode &&
+      opener.ownerDocument == this.nativeTab.ownerDocument
+    ) {
+      return tabTracker.getId(opener);
+    }
+    return null;
+  }
+
+  get height() {
+    return this.frameLoader.lazyHeight;
+  }
+
+  get index() {
+    return this.nativeTab._tPos;
+  }
+
+  get mutedInfo() {
+    let { nativeTab } = this;
+
+    let mutedInfo = { muted: nativeTab.muted };
+    if (nativeTab.muteReason === null) {
+      mutedInfo.reason = "user";
+    } else if (nativeTab.muteReason) {
+      mutedInfo.reason = "extension";
+      mutedInfo.extensionId = nativeTab.muteReason;
+    }
+
+    return mutedInfo;
+  }
+
+  get lastAccessed() {
+    return this.nativeTab.lastAccessed;
+  }
+
+  get pinned() {
+    return this.nativeTab.pinned;
+  }
+
+  get active() {
+    return this.nativeTab.selected;
+  }
+
+  get highlighted() {
+    let { selected, multiselected } = this.nativeTab;
+    return selected || multiselected;
+  }
+
+  get status() {
+    if (this.nativeTab.getAttribute("busy") === "true") {
+      return "loading";
+    }
+    return "complete";
+  }
+
+  get width() {
+    return this.frameLoader.lazyWidth;
+  }
+
+  get window() {
+    return this.nativeTab.ownerGlobal;
+  }
+
+  get windowId() {
+    return windowTracker.getId(this.window);
+  }
+
+  get isArticle() {
+    return this.nativeTab.linkedBrowser.isArticle;
+  }
+
+  get isInReaderMode() {
+    return this.url && this.url.startsWith(READER_MODE_PREFIX);
+  }
+
+  get successorTabId() {
+    const { successor } = this.nativeTab;
+    return successor ? tabTracker.getId(successor) : -1;
+  }
+
+  /**
+   * Converts session store data to an object compatible with the return value
+   * of the convert() method, representing that data.
+   *
+   * @param {Extension} extension
+   *        The extension for which to convert the data.
+   * @param {object} tabData
+   *        Session store data for a closed tab, as returned by
+   *        `SessionStore.getClosedTabData()`.
+   * @param {DOMWindow} [window = null]
+   *        The browser window which the tab belonged to before it was closed.
+   *        May be null if the window the tab belonged to no longer exists.
+   *
+   * @returns {object}
+   * @static
+   */
+  static convertFromSessionStoreClosedData(extension, tabData, window = null) {
+    let result = {
+      sessionId: String(tabData.closedId),
+      index: tabData.pos ? tabData.pos : 0,
+      windowId: window && windowTracker.getId(window),
+      highlighted: false,
+      active: false,
+      pinned: false,
+      hidden: tabData.state ? tabData.state.hidden : tabData.hidden,
+      incognito: Boolean(tabData.state && tabData.state.isPrivate),
+      lastAccessed: tabData.state
+        ? tabData.state.lastAccessed
+        : tabData.lastAccessed,
+    };
+
+    let entries = tabData.state ? tabData.state.entries : tabData.entries;
+    let lastTabIndex = tabData.state ? tabData.state.index : tabData.index;
+
+    // Tab may have empty history.
+    if (entries.length) {
+      // We need to take lastTabIndex - 1 because the index in the tab data is
+      // 1-based rather than 0-based.
+      let entry = entries[lastTabIndex - 1];
+
+      // tabData is a representation of a tab, as stored in the session data,
+      // and given that is not a real nativeTab, we only need to check if the extension
+      // has the "tabs" or host permission (because tabData represents a closed tab,
+      // and so we already know that it can't be the activeTab).
+      if (
+        extension.hasPermission("tabs") ||
+        extension.allowedOrigins.matches(entry.url)
+      ) {
+        result.url = entry.url;
+        result.title = entry.title;
+        if (tabData.image) {
+          result.favIconUrl = tabData.image;
+        }
+      }
+    }
+
+    return result;
+  }
+}
+
+class Window extends WindowBase {
+  /**
+   * Update the geometry of the browser window.
+   *
+   * @param {object} options
+   *        An object containing new values for the window's geometry.
+   * @param {integer} [options.left]
+   *        The new pixel distance of the left side of the browser window from
+   *        the left of the screen.
+   * @param {integer} [options.top]
+   *        The new pixel distance of the top side of the browser window from
+   *        the top of the screen.
+   * @param {integer} [options.width]
+   *        The new pixel width of the window.
+   * @param {integer} [options.height]
+   *        The new pixel height of the window.
+   */
+  updateGeometry(options) {
+    let { window } = this;
+
+    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);
+    }
+  }
+
+  get _title() {
+    return this.window.document.title;
+  }
+
+  setTitlePreface(titlePreface) {
+    this.window.document.documentElement.setAttribute(
+      "titlepreface",
+      titlePreface
+    );
+  }
+
+  get focused() {
+    return this.window.document.hasFocus();
+  }
+
+  get top() {
+    return this.window.screenY;
+  }
+
+  get left() {
+    return this.window.screenX;
+  }
+
+  get width() {
+    return this.window.outerWidth;
+  }
+
+  get height() {
+    return this.window.outerHeight;
+  }
+
+  get incognito() {
+    return PrivateBrowsingUtils.isWindowPrivate(this.window);
+  }
+
+  get alwaysOnTop() {
+    return this.appWindow.zLevel >= Ci.nsIAppWindow.raisedZ;
+  }
+
+  get isLastFocused() {
+    return this.window === windowTracker.topWindow;
+  }
+
+  static getState(window) {
+    const STATES = {
+      [window.STATE_MAXIMIZED]: "maximized",
+      [window.STATE_MINIMIZED]: "minimized",
+      [window.STATE_FULLSCREEN]: "fullscreen",
+      [window.STATE_NORMAL]: "normal",
+    };
+    return STATES[window.windowState];
+  }
+
+  get state() {
+    return Window.getState(this.window);
+  }
+
+  async setState(state) {
+    let { window } = this;
+
+    const expectedState = (function () {
+      switch (state) {
+        case "maximized":
+          return window.STATE_MAXIMIZED;
+        case "minimized":
+        case "docked":
+          return window.STATE_MINIMIZED;
+        case "normal":
+          return window.STATE_NORMAL;
+        case "fullscreen":
+          return window.STATE_FULLSCREEN;
+      }
+      throw new Error(`Unexpected window state: ${state}`);
+    })();
+
+    const initialState = window.windowState;
+    if (expectedState == initialState) {
+      return;
+    }
+
+    // We check for window.fullScreen here to make sure to exit fullscreen even
+    // if DOM and widget disagree on what the state is. This is a speculative
+    // fix for bug 1780876, ideally it should not be needed.
+    if (initialState == window.STATE_FULLSCREEN || window.fullScreen) {
+      window.fullScreen = false;
+    }
+
+    switch (expectedState) {
+      case window.STATE_MAXIMIZED:
+        window.maximize();
+        break;
+      case window.STATE_MINIMIZED:
+        window.minimize();
+        break;
+
+      case window.STATE_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();
+        }
+        break;
+
+      case window.STATE_FULLSCREEN:
+        window.fullScreen = true;
+        break;
+
+      default:
+        throw new Error(`Unexpected window state: ${state}`);
+    }
+
+    if (window.windowState != expectedState) {
+      // On Linux, sizemode changes are asynchronous. Some of them might not
+      // even happen if the window manager doesn't want to, so wait for a bit
+      // instead of forever for a sizemode change that might not ever happen.
+      const noWindowManagerTimeout = 2000;
+
+      let onSizeModeChange;
+      const promiseExpectedSizeMode = new Promise(resolve => {
+        onSizeModeChange = function () {
+          if (window.windowState == expectedState) {
+            resolve();
+          }
+        };
+        window.addEventListener("sizemodechange", onSizeModeChange);
+      });
+
+      await Promise.any([
+        promiseExpectedSizeMode,
+        new Promise(resolve => setTimeout(resolve, noWindowManagerTimeout)),
+      ]);
+
+      window.removeEventListener("sizemodechange", onSizeModeChange);
+    }
+  }
+
+  *getTabs() {
+    // A new window is being opened and it is adopting an existing tab, we return
+    // an empty iterator here because there should be no other tabs to return during
+    // that duration (See Bug 1458918 for a rationale).
+    if (this.window.gBrowserInit.isAdoptingTab()) {
+      return;
+    }
+
+    let { tabManager } = this.extension;
+
+    for (let nativeTab of this.window.gBrowser.tabs) {
+      let tab = tabManager.getWrapper(nativeTab);
+      if (tab) {
+        yield tab;
+      }
+    }
+  }
+
+  *getHighlightedTabs() {
+    let { tabManager } = this.extension;
+    for (let nativeTab of this.window.gBrowser.selectedTabs) {
+      let tab = tabManager.getWrapper(nativeTab);
+      if (tab) {
+        yield tab;
+      }
+    }
+  }
+
+  get activeTab() {
+    let { tabManager } = this.extension;
+
+    // A new window is being opened and it is adopting a tab, and we do not create
+    // a TabWrapper for the tab being adopted because it will go away once the tab
+    // adoption has been completed (See Bug 1458918 for rationale).
+    if (this.window.gBrowserInit.isAdoptingTab()) {
+      return null;
+    }
+
+    return tabManager.getWrapper(this.window.gBrowser.selectedTab);
+  }
+
+  getTabAtIndex(index) {
+    let nativeTab = this.window.gBrowser.tabs[index];
+    if (nativeTab) {
+      return this.extension.tabManager.getWrapper(nativeTab);
+    }
+  }
+
+  /**
+   * Converts session store data to an object compatible with the return value
+   * of the convert() method, representing that data.
+   *
+   * @param {Extension} extension
+   *        The extension for which to convert the data.
+   * @param {object} windowData
+   *        Session store data for a closed window, as returned by
+   *        `SessionStore.getClosedWindowData()`.
+   *
+   * @returns {object}
+   * @static
+   */
+  static convertFromSessionStoreClosedData(extension, windowData) {
+    let result = {
+      sessionId: String(windowData.closedId),
+      focused: false,
+      incognito: false,
+      type: "normal", // this is always "normal" for a closed window
+      // Bug 1781226: we assert "state" is "normal" in tests, but we could use
+      // the "sizemode" property if we wanted.
+      state: "normal",
+      alwaysOnTop: false,
+    };
+
+    if (windowData.tabs.length) {
+      result.tabs = windowData.tabs.map(tabData => {
+        return Tab.convertFromSessionStoreClosedData(extension, tabData);
+      });
+    }
+
+    return result;
+  }
+}
+
+Object.assign(global, { Tab, Window });
+
+class TabManager extends TabManagerBase {
+  get(tabId, default_ = undefined) {
+    let nativeTab = tabTracker.getTab(tabId, default_);
+
+    if (nativeTab) {
+      if (!this.canAccessTab(nativeTab)) {
+        throw new ExtensionError(`Invalid tab ID: ${tabId}`);
+      }
+      return this.getWrapper(nativeTab);
+    }
+    return default_;
+  }
+
+  addActiveTabPermission(nativeTab = tabTracker.activeTab) {
+    return super.addActiveTabPermission(nativeTab);
+  }
+
+  revokeActiveTabPermission(nativeTab = tabTracker.activeTab) {
+    return super.revokeActiveTabPermission(nativeTab);
+  }
+
+  canAccessTab(nativeTab) {
+    // Check private browsing access at browser window level.
+    if (!this.extension.canAccessWindow(nativeTab.ownerGlobal)) {
+      return false;
+    }
+    if (
+      this.extension.userContextIsolation &&
+      !this.extension.canAccessContainer(nativeTab.userContextId)
+    ) {
+      return false;
+    }
+    return true;
+  }
+
+  wrapTab(nativeTab) {
+    return new Tab(this.extension, nativeTab, tabTracker.getId(nativeTab));
+  }
+
+  getWrapper(nativeTab) {
+    if (!nativeTab.ownerGlobal.gBrowserInit.isAdoptingTab()) {
+      return super.getWrapper(nativeTab);
+    }
+  }
+}
+
+class WindowManager extends WindowManagerBase {
+  get(windowId, context) {
+    let window = windowTracker.getWindow(windowId, context);
+
+    return this.getWrapper(window);
+  }
+
+  *getAll(context) {
+    for (let window of windowTracker.browserWindows()) {
+      if (!this.canAccessWindow(window, context)) {
+        continue;
+      }
+      let wrapped = this.getWrapper(window);
+      if (wrapped) {
+        yield wrapped;
+      }
+    }
+  }
+
+  wrapWindow(window) {
+    return new Window(this.extension, window, windowTracker.getId(window));
+  }
+}
+
+// eslint-disable-next-line mozilla/balanced-listeners
+extensions.on("startup", (type, extension) => {
+  defineLazyGetter(extension, "tabManager", () => new TabManager(extension));
+  defineLazyGetter(
+    extension,
+    "windowManager",
+    () => new WindowManager(extension)
+  );
+});