From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- .../components/extensions/parent/ext-browser.js | 1258 ++++++++++++++++++++ 1 file changed, 1258 insertions(+) create mode 100644 browser/components/extensions/parent/ext-browser.js (limited to 'browser/components/extensions/parent/ext-browser.js') 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 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} + * A XUL 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 . + */ + 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 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) + ); +}); -- cgit v1.2.3