diff options
Diffstat (limited to 'browser/components/extensions/parent/ext-tabs.js')
| -rw-r--r-- | browser/components/extensions/parent/ext-tabs.js | 1623 |
1 files changed, 1623 insertions, 0 deletions
diff --git a/browser/components/extensions/parent/ext-tabs.js b/browser/components/extensions/parent/ext-tabs.js new file mode 100644 index 0000000000..93ac3fd2aa --- /dev/null +++ b/browser/components/extensions/parent/ext-tabs.js @@ -0,0 +1,1623 @@ +/* -*- 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"; + +ChromeUtils.defineModuleGetter( + this, + "BrowserUIUtils", + "resource:///modules/BrowserUIUtils.jsm" +); +ChromeUtils.defineESModuleGetters(this, { + DownloadPaths: "resource://gre/modules/DownloadPaths.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", + PromiseUtils: "resource://gre/modules/PromiseUtils.sys.mjs", + SessionStore: "resource:///modules/sessionstore/SessionStore.sys.mjs", +}); +ChromeUtils.defineModuleGetter( + this, + "ExtensionControlledPopup", + "resource:///modules/ExtensionControlledPopup.jsm" +); + +XPCOMUtils.defineLazyGetter(this, "strBundle", function() { + return Services.strings.createBundle( + "chrome://global/locale/extensions.properties" + ); +}); + +var { DefaultMap, ExtensionError } = ExtensionUtils; + +const TAB_HIDE_CONFIRMED_TYPE = "tabHideNotification"; + +const TAB_ID_NONE = -1; + +XPCOMUtils.defineLazyGetter(this, "tabHidePopup", () => { + return new ExtensionControlledPopup({ + confirmedType: TAB_HIDE_CONFIRMED_TYPE, + anchorId: "alltabs-button", + popupnotificationId: "extension-tab-hide-notification", + descriptionId: "extension-tab-hide-notification-description", + descriptionMessageId: "tabHideControlled.message", + getLocalizedDescription: (doc, message, addonDetails) => { + let image = doc.createXULElement("image"); + image.setAttribute("class", "extension-controlled-icon alltabs-icon"); + return BrowserUIUtils.getLocalizedFragment( + doc, + message, + addonDetails, + image + ); + }, + learnMoreMessageId: "tabHideControlled.learnMore", + learnMoreLink: "extension-hiding-tabs", + }); +}); + +function showHiddenTabs(id) { + for (let win of Services.wm.getEnumerator("navigator:browser")) { + if (win.closed || !win.gBrowser) { + continue; + } + + for (let tab of win.gBrowser.tabs) { + if ( + tab.hidden && + tab.ownerGlobal && + SessionStore.getCustomTabValue(tab, "hiddenBy") === id + ) { + win.gBrowser.showTab(tab); + } + } + } +} + +let tabListener = { + tabReadyInitialized: false, + // Map[tab -> Promise] + tabBlockedPromises: new WeakMap(), + // Map[tab -> Deferred] + tabReadyPromises: new WeakMap(), + initializingTabs: new WeakSet(), + + initTabReady() { + if (!this.tabReadyInitialized) { + windowTracker.addListener("progress", this); + + this.tabReadyInitialized = true; + } + }, + + onLocationChange(browser, webProgress, request, locationURI, flags) { + if (webProgress.isTopLevel) { + let { gBrowser } = browser.ownerGlobal; + let nativeTab = gBrowser.getTabForBrowser(browser); + + // Now we are certain that the first page in the tab was loaded. + this.initializingTabs.delete(nativeTab); + + // browser.innerWindowID is now set, resolve the promises if any. + let deferred = this.tabReadyPromises.get(nativeTab); + if (deferred) { + deferred.resolve(nativeTab); + this.tabReadyPromises.delete(nativeTab); + } + } + }, + + blockTabUntilRestored(nativeTab) { + let promise = ExtensionUtils.promiseEvent(nativeTab, "SSTabRestored").then( + ({ target }) => { + this.tabBlockedPromises.delete(target); + return target; + } + ); + + this.tabBlockedPromises.set(nativeTab, promise); + }, + + /** + * Returns a promise that resolves when the tab is ready. + * Tabs created via the `tabs.create` method are "ready" once the location + * changes to the requested URL. Other tabs are assumed to be ready once their + * inner window ID is known. + * + * @param {XULElement} nativeTab The <tab> element. + * @returns {Promise} Resolves with the given tab once ready. + */ + awaitTabReady(nativeTab) { + let deferred = this.tabReadyPromises.get(nativeTab); + if (!deferred) { + let promise = this.tabBlockedPromises.get(nativeTab); + if (promise) { + return promise; + } + deferred = PromiseUtils.defer(); + if ( + !this.initializingTabs.has(nativeTab) && + (nativeTab.linkedBrowser.innerWindowID || + nativeTab.linkedBrowser.currentURI.spec === "about:blank") + ) { + deferred.resolve(nativeTab); + } else { + this.initTabReady(); + this.tabReadyPromises.set(nativeTab, deferred); + } + } + return deferred.promise; + }, +}; + +const allAttrs = new Set([ + "attention", + "audible", + "favIconUrl", + "mutedInfo", + "sharingState", + "title", +]); +const allProperties = new Set([ + "attention", + "audible", + "discarded", + "favIconUrl", + "hidden", + "isArticle", + "mutedInfo", + "pinned", + "sharingState", + "status", + "title", + "url", +]); +const restricted = new Set(["url", "favIconUrl", "title"]); + +this.tabs = class extends ExtensionAPIPersistent { + static onUpdate(id, manifest) { + if (!manifest.permissions || !manifest.permissions.includes("tabHide")) { + showHiddenTabs(id); + } + } + + static onDisable(id) { + showHiddenTabs(id); + tabHidePopup.clearConfirmation(id); + } + + static onUninstall(id) { + tabHidePopup.clearConfirmation(id); + } + + tabEventRegistrar({ event, listener }) { + let { extension } = this; + let { tabManager } = extension; + return ({ fire }) => { + let listener2 = (eventName, eventData, ...args) => { + if (!tabManager.canAccessTab(eventData.nativeTab)) { + return; + } + + listener(fire, eventData, ...args); + }; + + tabTracker.on(event, listener2); + return { + unregister() { + tabTracker.off(event, listener2); + }, + convert(_fire) { + fire = _fire; + }, + }; + }; + } + + PERSISTENT_EVENTS = { + onActivated: this.tabEventRegistrar({ + event: "tab-activated", + listener: (fire, event) => { + let { extension } = this; + let { tabId, windowId, previousTabId, previousTabIsPrivate } = event; + if (previousTabIsPrivate && !extension.privateBrowsingAllowed) { + previousTabId = undefined; + } + fire.async({ tabId, previousTabId, windowId }); + }, + }), + onAttached: this.tabEventRegistrar({ + event: "tab-attached", + listener: (fire, event) => { + fire.async(event.tabId, { + newWindowId: event.newWindowId, + newPosition: event.newPosition, + }); + }, + }), + onCreated: this.tabEventRegistrar({ + event: "tab-created", + listener: (fire, event) => { + let { tabManager } = this.extension; + fire.async(tabManager.convert(event.nativeTab, event.currentTabSize)); + }, + }), + onDetached: this.tabEventRegistrar({ + event: "tab-detached", + listener: (fire, event) => { + fire.async(event.tabId, { + oldWindowId: event.oldWindowId, + oldPosition: event.oldPosition, + }); + }, + }), + onRemoved: this.tabEventRegistrar({ + event: "tab-removed", + listener: (fire, event) => { + fire.async(event.tabId, { + windowId: event.windowId, + isWindowClosing: event.isWindowClosing, + }); + }, + }), + onMoved({ fire }) { + let { tabManager } = this.extension; + let moveListener = event => { + let nativeTab = event.originalTarget; + if (tabManager.canAccessTab(nativeTab)) { + fire.async(tabTracker.getId(nativeTab), { + windowId: windowTracker.getId(nativeTab.ownerGlobal), + fromIndex: event.detail, + toIndex: nativeTab._tPos, + }); + } + }; + + windowTracker.addListener("TabMove", moveListener); + return { + unregister() { + windowTracker.removeListener("TabMove", moveListener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + + onHighlighted({ fire, context }) { + let { windowManager } = this.extension; + let highlightListener = (eventName, event) => { + // TODO see if we can avoid "context" here + let window = windowTracker.getWindow(event.windowId, context, false); + if (!window) { + return; + } + let windowWrapper = windowManager.getWrapper(window); + if (!windowWrapper) { + return; + } + let tabIds = Array.from( + windowWrapper.getHighlightedTabs(), + tab => tab.id + ); + fire.async({ tabIds: tabIds, windowId: event.windowId }); + }; + + tabTracker.on("tabs-highlighted", highlightListener); + return { + unregister() { + tabTracker.off("tabs-highlighted", highlightListener); + }, + convert(_fire, _context) { + fire = _fire; + context = _context; + }, + }; + }, + + onUpdated({ fire, context }, params) { + let { extension } = this; + let { tabManager } = extension; + let [filterProps] = params; + let filter = { ...filterProps }; + if (filter.urls) { + filter.urls = new MatchPatternSet(filter.urls, { + restrictSchemes: false, + }); + } + let needsModified = true; + if (filter.properties) { + // Default is to listen for all events. + needsModified = filter.properties.some(p => allAttrs.has(p)); + filter.properties = new Set(filter.properties); + } else { + filter.properties = allProperties; + } + + function sanitize(tab, changeInfo) { + let result = {}; + let nonempty = false; + for (let prop in changeInfo) { + // In practice, changeInfo contains at most one property from + // restricted. Therefore it is not necessary to cache the value + // of tab.hasTabPermission outside the loop. + // Unnecessarily accessing tab.hasTabPermission can cause bugs, see + // https://bugzilla.mozilla.org/show_bug.cgi?id=1694699#c21 + if (!restricted.has(prop) || tab.hasTabPermission) { + nonempty = true; + result[prop] = changeInfo[prop]; + } + } + return nonempty && result; + } + + function getWindowID(windowId) { + if (windowId === Window.WINDOW_ID_CURRENT) { + let window = windowTracker.getTopWindow(context); + if (!window) { + return undefined; + } + return windowTracker.getId(window); + } + return windowId; + } + + function matchFilters(tab, changed) { + if (!filterProps) { + return true; + } + if (filter.tabId != null && tab.id != filter.tabId) { + return false; + } + if ( + filter.windowId != null && + tab.windowId != getWindowID(filter.windowId) + ) { + return false; + } + if (filter.urls) { + return filter.urls.matches(tab._uri) && tab.hasTabPermission; + } + return true; + } + + let fireForTab = (tab, changed, nativeTab) => { + // Tab may be null if private and not_allowed. + if (!tab || !matchFilters(tab, changed)) { + return; + } + + let changeInfo = sanitize(tab, changed); + if (changeInfo) { + tabTracker.maybeWaitForTabOpen(nativeTab).then(() => { + if (!nativeTab.parentNode) { + // If the tab is already be destroyed, do nothing. + return; + } + fire.async(tab.id, changeInfo, tab.convert()); + }); + } + }; + + let listener = event => { + // Ignore any events prior to TabOpen + // and events that are triggered while tabs are swapped between windows. + if (event.originalTarget.initializingTab) { + return; + } + if (!extension.canAccessWindow(event.originalTarget.ownerGlobal)) { + return; + } + let needed = []; + if (event.type == "TabAttrModified") { + let changed = event.detail.changed; + if ( + changed.includes("image") && + filter.properties.has("favIconUrl") + ) { + needed.push("favIconUrl"); + } + if (changed.includes("muted") && filter.properties.has("mutedInfo")) { + needed.push("mutedInfo"); + } + if ( + changed.includes("soundplaying") && + filter.properties.has("audible") + ) { + needed.push("audible"); + } + if (changed.includes("label") && filter.properties.has("title")) { + needed.push("title"); + } + if ( + changed.includes("sharing") && + filter.properties.has("sharingState") + ) { + needed.push("sharingState"); + } + if ( + changed.includes("attention") && + filter.properties.has("attention") + ) { + needed.push("attention"); + } + } else if (event.type == "TabPinned") { + needed.push("pinned"); + } else if (event.type == "TabUnpinned") { + needed.push("pinned"); + } else if (event.type == "TabBrowserInserted") { + // This may be an adopted tab. Bail early to avoid asking tabManager + // about the tab before we run the adoption logic in ext-browser.js. + if (event.detail.insertedOnTabCreation) { + return; + } + needed.push("discarded"); + } else if (event.type == "TabBrowserDiscarded") { + needed.push("discarded"); + } else if (event.type == "TabShow") { + needed.push("hidden"); + } else if (event.type == "TabHide") { + needed.push("hidden"); + } + + let tab = tabManager.getWrapper(event.originalTarget); + + let changeInfo = {}; + for (let prop of needed) { + changeInfo[prop] = tab[prop]; + } + + fireForTab(tab, changeInfo, event.originalTarget); + }; + + let statusListener = ({ browser, status, url }) => { + let { gBrowser } = browser.ownerGlobal; + let tabElem = gBrowser.getTabForBrowser(browser); + if (tabElem) { + if (!extension.canAccessWindow(tabElem.ownerGlobal)) { + return; + } + + let changed = {}; + if (filter.properties.has("status")) { + changed.status = status; + } + if (url && filter.properties.has("url")) { + changed.url = url; + } + + fireForTab(tabManager.wrapTab(tabElem), changed, tabElem); + } + }; + + let isArticleChangeListener = (messageName, message) => { + let { gBrowser } = message.target.ownerGlobal; + let nativeTab = gBrowser.getTabForBrowser(message.target); + + if (nativeTab && extension.canAccessWindow(nativeTab.ownerGlobal)) { + let tab = tabManager.getWrapper(nativeTab); + fireForTab(tab, { isArticle: message.data.isArticle }, nativeTab); + } + }; + + let listeners = new Map(); + if (filter.properties.has("status") || filter.properties.has("url")) { + listeners.set("status", statusListener); + } + if (needsModified) { + listeners.set("TabAttrModified", listener); + } + if (filter.properties.has("pinned")) { + listeners.set("TabPinned", listener); + listeners.set("TabUnpinned", listener); + } + if (filter.properties.has("discarded")) { + listeners.set("TabBrowserInserted", listener); + listeners.set("TabBrowserDiscarded", listener); + } + if (filter.properties.has("hidden")) { + listeners.set("TabShow", listener); + listeners.set("TabHide", listener); + } + + for (let [name, listener] of listeners) { + windowTracker.addListener(name, listener); + } + + if (filter.properties.has("isArticle")) { + tabTracker.on("tab-isarticle", isArticleChangeListener); + } + + return { + unregister() { + for (let [name, listener] of listeners) { + windowTracker.removeListener(name, listener); + } + + if (filter.properties.has("isArticle")) { + tabTracker.off("tab-isarticle", isArticleChangeListener); + } + }, + convert(_fire, _context) { + fire = _fire; + context = _context; + }, + }; + }, + }; + + getAPI(context) { + let { extension } = context; + let { tabManager, windowManager } = extension; + let extensionApi = this; + let module = "tabs"; + + function getTabOrActive(tabId) { + let tab = + tabId !== null ? tabTracker.getTab(tabId) : tabTracker.activeTab; + if (!tabManager.canAccessTab(tab)) { + throw new ExtensionError( + tabId === null + ? "Cannot access activeTab" + : `Invalid tab ID: ${tabId}` + ); + } + return tab; + } + + function getNativeTabsFromIDArray(tabIds) { + if (!Array.isArray(tabIds)) { + tabIds = [tabIds]; + } + return tabIds.map(tabId => { + let tab = tabTracker.getTab(tabId); + if (!tabManager.canAccessTab(tab)) { + throw new ExtensionError(`Invalid tab ID: ${tabId}`); + } + return tab; + }); + } + + async function promiseTabWhenReady(tabId) { + let tab; + if (tabId !== null) { + tab = tabManager.get(tabId); + } else { + tab = tabManager.getWrapper(tabTracker.activeTab); + } + if (!tab) { + throw new ExtensionError( + tabId == null ? "Cannot access activeTab" : `Invalid tab ID: ${tabId}` + ); + } + + await tabListener.awaitTabReady(tab.nativeTab); + + return tab; + } + + function setContentTriggeringPrincipal(url, browser, options) { + // For urls that we want to allow an extension to open in a tab, but + // that it may not otherwise have access to, we set the triggering + // principal to the url that is being opened. This is used for newtab, + // about: and moz-extension: protocols. + options.triggeringPrincipal = Services.scriptSecurityManager.createContentPrincipal( + Services.io.newURI(url), + { + userContextId: options.userContextId, + privateBrowsingId: PrivateBrowsingUtils.isBrowserPrivate(browser) + ? 1 + : 0, + } + ); + } + + let tabsApi = { + tabs: { + onActivated: new EventManager({ + context, + module, + event: "onActivated", + extensionApi, + }).api(), + + onCreated: new EventManager({ + context, + module, + event: "onCreated", + extensionApi, + }).api(), + + onHighlighted: new EventManager({ + context, + module, + event: "onHighlighted", + extensionApi, + }).api(), + + onAttached: new EventManager({ + context, + module, + event: "onAttached", + extensionApi, + }).api(), + + onDetached: new EventManager({ + context, + module, + event: "onDetached", + extensionApi, + }).api(), + + onRemoved: new EventManager({ + context, + module, + event: "onRemoved", + extensionApi, + }).api(), + + onReplaced: new EventManager({ + context, + name: "tabs.onReplaced", + register: fire => { + return () => {}; + }, + }).api(), + + onMoved: new EventManager({ + context, + module, + event: "onMoved", + extensionApi, + }).api(), + + onUpdated: new EventManager({ + context, + module, + event: "onUpdated", + extensionApi, + }).api(), + + create(createProperties) { + return new Promise((resolve, reject) => { + let window = + createProperties.windowId !== null + ? windowTracker.getWindow(createProperties.windowId, context) + : windowTracker.getTopNormalWindow(context); + if (!window || !context.canAccessWindow(window)) { + throw new Error( + "Not allowed to create tabs on the target window" + ); + } + let { gBrowserInit } = window; + if (!gBrowserInit || !gBrowserInit.delayedStartupFinished) { + let obs = (finishedWindow, topic, data) => { + if (finishedWindow != window) { + return; + } + Services.obs.removeObserver( + obs, + "browser-delayed-startup-finished" + ); + resolve(window); + }; + Services.obs.addObserver(obs, "browser-delayed-startup-finished"); + } else { + resolve(window); + } + }).then(window => { + let url; + + let options = { triggeringPrincipal: context.principal }; + if (createProperties.cookieStoreId) { + // May throw if validation fails. + options.userContextId = getUserContextIdForCookieStoreId( + extension, + createProperties.cookieStoreId, + PrivateBrowsingUtils.isBrowserPrivate(window.gBrowser) + ); + } + + if (createProperties.url !== null) { + url = context.uri.resolve(createProperties.url); + + if ( + !url.startsWith("moz-extension://") && + !context.checkLoadURL(url, { dontReportErrors: true }) + ) { + return Promise.reject({ message: `Illegal URL: ${url}` }); + } + + if (createProperties.openInReaderMode) { + url = `about:reader?url=${encodeURIComponent(url)}`; + } + } else { + url = window.BROWSER_NEW_TAB_URL; + } + let discardable = url && !url.startsWith("about:"); + // Handle moz-ext separately from the discardable flag to retain prior behavior. + if (!discardable || url.startsWith("moz-extension://")) { + setContentTriggeringPrincipal(url, window.gBrowser, options); + } + + tabListener.initTabReady(); + const currentTab = window.gBrowser.selectedTab; + const { frameLoader } = currentTab.linkedBrowser; + const currentTabSize = { + width: frameLoader.lazyWidth, + height: frameLoader.lazyHeight, + }; + + if (createProperties.openerTabId !== null) { + options.ownerTab = tabTracker.getTab( + createProperties.openerTabId + ); + options.openerBrowser = options.ownerTab.linkedBrowser; + if (options.ownerTab.ownerGlobal !== window) { + return Promise.reject({ + message: + "Opener tab must be in the same window as the tab being created", + }); + } + } + + // Simple properties + const properties = ["index", "pinned"]; + for (let prop of properties) { + if (createProperties[prop] != null) { + options[prop] = createProperties[prop]; + } + } + + let active = + createProperties.active !== null + ? createProperties.active + : !createProperties.discarded; + if (createProperties.discarded) { + if (active) { + return Promise.reject({ + message: `Active tabs cannot be created and discarded.`, + }); + } + if (createProperties.pinned) { + return Promise.reject({ + message: `Pinned tabs cannot be created and discarded.`, + }); + } + if (!discardable) { + return Promise.reject({ + message: `Cannot create a discarded new tab or "about" urls.`, + }); + } + options.createLazyBrowser = true; + options.lazyTabTitle = createProperties.title; + } else if (createProperties.title) { + return Promise.reject({ + message: `Title may only be set for discarded tabs.`, + }); + } + + let nativeTab = window.gBrowser.addTab(url, options); + + if (active) { + window.gBrowser.selectedTab = nativeTab; + if (!createProperties.url) { + window.gURLBar.select(); + } + } + + if ( + createProperties.url && + createProperties.url !== window.BROWSER_NEW_TAB_URL + ) { + // We can't wait for a location change event for about:newtab, + // since it may be pre-rendered, in which case its initial + // location change event has already fired. + + // Mark the tab as initializing, so that operations like + // `executeScript` wait until the requested URL is loaded in + // the tab before dispatching messages to the inner window + // that contains the URL we're attempting to load. + tabListener.initializingTabs.add(nativeTab); + } + + if (createProperties.muted) { + nativeTab.toggleMuteAudio(extension.id); + } + + return tabManager.convert(nativeTab, currentTabSize); + }); + }, + + async remove(tabIds) { + let nativeTabs = getNativeTabsFromIDArray(tabIds); + + if (nativeTabs.length === 1) { + nativeTabs[0].ownerGlobal.gBrowser.removeTab(nativeTabs[0]); + return; + } + + // Or for multiple tabs, first group them by window + let windowTabMap = new DefaultMap(() => []); + for (let nativeTab of nativeTabs) { + windowTabMap.get(nativeTab.ownerGlobal).push(nativeTab); + } + + // Then make one call to removeTabs() for each window, to keep the + // count accurate for SessionStore.getLastClosedTabCount(). + // Note: always pass options to disable animation and the warning + // dialogue box, so that way all tabs are actually closed when the + // browser.tabs.remove() promise resolves + for (let [eachWindow, tabsToClose] of windowTabMap.entries()) { + eachWindow.gBrowser.removeTabs(tabsToClose, { + animate: false, + suppressWarnAboutClosingWindow: true, + }); + } + }, + + async discard(tabIds) { + for (let nativeTab of getNativeTabsFromIDArray(tabIds)) { + nativeTab.ownerGlobal.gBrowser.discardBrowser(nativeTab); + } + }, + + async update(tabId, updateProperties) { + let nativeTab = getTabOrActive(tabId); + + let tabbrowser = nativeTab.ownerGlobal.gBrowser; + + if (updateProperties.url !== null) { + let url = context.uri.resolve(updateProperties.url); + + let options = { + flags: updateProperties.loadReplace + ? Ci.nsIWebNavigation.LOAD_FLAGS_REPLACE_HISTORY + : Ci.nsIWebNavigation.LOAD_FLAGS_NONE, + triggeringPrincipal: context.principal, + }; + + if (!context.checkLoadURL(url, { dontReportErrors: true })) { + // We allow loading top level tabs for "other" extensions. + if (url.startsWith("moz-extension://")) { + setContentTriggeringPrincipal(url, tabbrowser, options); + } else { + return Promise.reject({ message: `Illegal URL: ${url}` }); + } + } + + let browser = nativeTab.linkedBrowser; + if (nativeTab.linkedPanel) { + browser.loadURI(url, options); + } else { + // Shift to fully loaded browser and make + // sure load handler is instantiated. + nativeTab.addEventListener( + "SSTabRestoring", + () => browser.loadURI(url, options), + { once: true } + ); + tabbrowser._insertBrowser(nativeTab); + } + } + + if (updateProperties.active) { + tabbrowser.selectedTab = nativeTab; + } + if (updateProperties.highlighted !== null) { + if (updateProperties.highlighted) { + if (!nativeTab.selected && !nativeTab.multiselected) { + tabbrowser.addToMultiSelectedTabs(nativeTab); + // Select the highlighted tab unless active:false is provided. + // Note that Chrome selects it even in that case. + if (updateProperties.active !== false) { + tabbrowser.lockClearMultiSelectionOnce(); + tabbrowser.selectedTab = nativeTab; + } + } + } else { + tabbrowser.removeFromMultiSelectedTabs(nativeTab); + } + } + if (updateProperties.muted !== null) { + if (nativeTab.muted != updateProperties.muted) { + nativeTab.toggleMuteAudio(extension.id); + } + } + if (updateProperties.pinned !== null) { + if (updateProperties.pinned) { + tabbrowser.pinTab(nativeTab); + } else { + tabbrowser.unpinTab(nativeTab); + } + } + if (updateProperties.openerTabId !== null) { + let opener = tabTracker.getTab(updateProperties.openerTabId); + if (opener.ownerDocument !== nativeTab.ownerDocument) { + return Promise.reject({ + message: + "Opener tab must be in the same window as the tab being updated", + }); + } + tabTracker.setOpener(nativeTab, opener); + } + if (updateProperties.successorTabId !== null) { + let successor = null; + if (updateProperties.successorTabId !== TAB_ID_NONE) { + successor = tabTracker.getTab( + updateProperties.successorTabId, + null + ); + if (!successor) { + throw new ExtensionError("Invalid successorTabId"); + } + // This also ensures "privateness" matches. + if (successor.ownerDocument !== nativeTab.ownerDocument) { + throw new ExtensionError( + "Successor tab must be in the same window as the tab being updated" + ); + } + } + tabbrowser.setSuccessor(nativeTab, successor); + } + + return tabManager.convert(nativeTab); + }, + + async reload(tabId, reloadProperties) { + let nativeTab = getTabOrActive(tabId); + + let flags = Ci.nsIWebNavigation.LOAD_FLAGS_NONE; + if (reloadProperties && reloadProperties.bypassCache) { + flags |= Ci.nsIWebNavigation.LOAD_FLAGS_BYPASS_CACHE; + } + nativeTab.linkedBrowser.reloadWithFlags(flags); + }, + + async warmup(tabId) { + let nativeTab = tabTracker.getTab(tabId); + if (!tabManager.canAccessTab(nativeTab)) { + throw new ExtensionError(`Invalid tab ID: ${tabId}`); + } + let tabbrowser = nativeTab.ownerGlobal.gBrowser; + tabbrowser.warmupTab(nativeTab); + }, + + async get(tabId) { + return tabManager.get(tabId).convert(); + }, + + getCurrent() { + let tabData; + if (context.tabId) { + tabData = tabManager.get(context.tabId).convert(); + } + return Promise.resolve(tabData); + }, + + async query(queryInfo) { + return Array.from(tabManager.query(queryInfo, context), tab => + tab.convert() + ); + }, + + async captureTab(tabId, options) { + let nativeTab = getTabOrActive(tabId); + await tabListener.awaitTabReady(nativeTab); + + let browser = nativeTab.linkedBrowser; + let window = browser.ownerGlobal; + let zoom = window.ZoomManager.getZoomForBrowser(browser); + + let tab = tabManager.wrapTab(nativeTab); + return tab.capture(context, zoom, options); + }, + + async captureVisibleTab(windowId, options) { + let window = + windowId == null + ? windowTracker.getTopWindow(context) + : windowTracker.getWindow(windowId, context); + + let tab = tabManager.wrapTab(window.gBrowser.selectedTab); + await tabListener.awaitTabReady(tab.nativeTab); + + let zoom = window.ZoomManager.getZoomForBrowser( + tab.nativeTab.linkedBrowser + ); + return tab.capture(context, zoom, options); + }, + + async detectLanguage(tabId) { + let tab = await promiseTabWhenReady(tabId); + let results = await tab.queryContent("DetectLanguage", {}); + return results[0]; + }, + + async executeScript(tabId, details) { + let tab = await promiseTabWhenReady(tabId); + return tab.executeScript(context, details); + }, + + async insertCSS(tabId, details) { + let tab = await promiseTabWhenReady(tabId); + return tab.insertCSS(context, details); + }, + + async removeCSS(tabId, details) { + let tab = await promiseTabWhenReady(tabId); + return tab.removeCSS(context, details); + }, + + async move(tabIds, moveProperties) { + let tabsMoved = []; + if (!Array.isArray(tabIds)) { + tabIds = [tabIds]; + } + + let destinationWindow = null; + if (moveProperties.windowId !== null) { + destinationWindow = windowTracker.getWindow( + moveProperties.windowId, + context + ); + // Fail on an invalid window. + if (!destinationWindow) { + return Promise.reject({ + message: `Invalid window ID: ${moveProperties.windowId}`, + }); + } + } + + /* + Indexes are maintained on a per window basis so that a call to + move([tabA, tabB], {index: 0}) + -> tabA to 0, tabB to 1 if tabA and tabB are in the same window + move([tabA, tabB], {index: 0}) + -> tabA to 0, tabB to 0 if tabA and tabB are in different windows + */ + let indexMap = new Map(); + let lastInsertion = new Map(); + + for (let nativeTab of getNativeTabsFromIDArray(tabIds)) { + // If the window is not specified, use the window from the tab. + let window = destinationWindow || nativeTab.ownerGlobal; + let gBrowser = window.gBrowser; + + // If we are not moving the tab to a different window, and the window + // only has one tab, do nothing. + if (nativeTab.ownerGlobal == window && gBrowser.tabs.length === 1) { + continue; + } + // If moving between windows, be sure privacy matches. While gBrowser + // prevents this, we want to silently ignore it. + if ( + nativeTab.ownerGlobal != window && + PrivateBrowsingUtils.isBrowserPrivate(window.gBrowser) != + PrivateBrowsingUtils.isBrowserPrivate( + nativeTab.ownerGlobal.gBrowser + ) + ) { + continue; + } + + let insertionPoint = indexMap.get(window) || moveProperties.index; + // If the index is -1 it should go to the end of the tabs. + if (insertionPoint == -1) { + insertionPoint = gBrowser.tabs.length; + } + + // We can only move pinned tabs to a point within, or just after, + // the current set of pinned tabs. Unpinned tabs, likewise, can only + // be moved to a position after the current set of pinned tabs. + // Attempts to move a tab to an illegal position are ignored. + let numPinned = gBrowser._numPinnedTabs; + let ok = nativeTab.pinned + ? insertionPoint <= numPinned + : insertionPoint >= numPinned; + if (!ok) { + continue; + } + + // If this is not the first tab to be inserted into this window and + // the insertion point is the same as the last insertion and + // the tab is further to the right than the current insertion point + // then you need to bump up the insertion point. See bug 1323311. + if ( + lastInsertion.has(window) && + lastInsertion.get(window) === insertionPoint && + nativeTab._tPos > insertionPoint + ) { + insertionPoint++; + indexMap.set(window, insertionPoint); + } + + if (nativeTab.ownerGlobal != window) { + // If the window we are moving the tab in is different, then move the tab + // to the new window. + nativeTab = gBrowser.adoptTab(nativeTab, insertionPoint, false); + } else { + // If the window we are moving is the same, just move the tab. + gBrowser.moveTabTo(nativeTab, insertionPoint); + } + lastInsertion.set(window, nativeTab._tPos); + tabsMoved.push(nativeTab); + } + + return tabsMoved.map(nativeTab => tabManager.convert(nativeTab)); + }, + + duplicate(tabId, duplicateProperties) { + const { active, index } = duplicateProperties || {}; + const inBackground = active === undefined ? false : !active; + + // Schema requires tab id. + let nativeTab = getTabOrActive(tabId); + + let gBrowser = nativeTab.ownerGlobal.gBrowser; + let newTab = gBrowser.duplicateTab(nativeTab, true, { + inBackground, + index, + }); + + tabListener.blockTabUntilRestored(newTab); + return new Promise(resolve => { + // Use SSTabRestoring to ensure that the tab's URL is ready before + // resolving the promise. + newTab.addEventListener( + "SSTabRestoring", + () => resolve(tabManager.convert(newTab)), + { once: true } + ); + }); + }, + + getZoom(tabId) { + let nativeTab = getTabOrActive(tabId); + + let { ZoomManager } = nativeTab.ownerGlobal; + let zoom = ZoomManager.getZoomForBrowser(nativeTab.linkedBrowser); + + return Promise.resolve(zoom); + }, + + setZoom(tabId, zoom) { + let nativeTab = getTabOrActive(tabId); + + let { FullZoom, ZoomManager } = nativeTab.ownerGlobal; + + if (zoom === 0) { + // A value of zero means use the default zoom factor. + return FullZoom.reset(nativeTab.linkedBrowser); + } else if (zoom >= ZoomManager.MIN && zoom <= ZoomManager.MAX) { + FullZoom.setZoom(zoom, nativeTab.linkedBrowser); + } else { + return Promise.reject({ + message: `Zoom value ${zoom} out of range (must be between ${ZoomManager.MIN} and ${ZoomManager.MAX})`, + }); + } + + return Promise.resolve(); + }, + + async getZoomSettings(tabId) { + let nativeTab = getTabOrActive(tabId); + + let { FullZoom, ZoomUI } = nativeTab.ownerGlobal; + + return { + mode: "automatic", + scope: FullZoom.siteSpecific ? "per-origin" : "per-tab", + defaultZoomFactor: await ZoomUI.getGlobalValue(), + }; + }, + + async setZoomSettings(tabId, settings) { + let nativeTab = getTabOrActive(tabId); + + let currentSettings = await this.getZoomSettings( + tabTracker.getId(nativeTab) + ); + + if ( + !Object.keys(settings).every( + key => settings[key] === currentSettings[key] + ) + ) { + throw new ExtensionError( + `Unsupported zoom settings: ${JSON.stringify(settings)}` + ); + } + }, + + onZoomChange: new EventManager({ + context, + name: "tabs.onZoomChange", + register: fire => { + let getZoomLevel = browser => { + let { ZoomManager } = browser.ownerGlobal; + + return ZoomManager.getZoomForBrowser(browser); + }; + + // Stores the last known zoom level for each tab's browser. + // WeakMap[<browser> -> number] + let zoomLevels = new WeakMap(); + + // Store the zoom level for all existing tabs. + for (let window of windowTracker.browserWindows()) { + if (!context.canAccessWindow(window)) { + continue; + } + for (let nativeTab of window.gBrowser.tabs) { + let browser = nativeTab.linkedBrowser; + zoomLevels.set(browser, getZoomLevel(browser)); + } + } + + let tabCreated = (eventName, event) => { + let browser = event.nativeTab.linkedBrowser; + if (!event.isPrivate || context.privateBrowsingAllowed) { + zoomLevels.set(browser, getZoomLevel(browser)); + } + }; + + let zoomListener = async event => { + let browser = event.originalTarget; + + // For non-remote browsers, this event is dispatched on the document + // rather than on the <browser>. But either way we have a node here. + if (browser.nodeType == browser.DOCUMENT_NODE) { + browser = browser.docShell.chromeEventHandler; + } + + if (!context.canAccessWindow(browser.ownerGlobal)) { + return; + } + + let { gBrowser } = browser.ownerGlobal; + let nativeTab = gBrowser.getTabForBrowser(browser); + if (!nativeTab) { + // We only care about zoom events in the top-level browser of a tab. + return; + } + + let oldZoomFactor = zoomLevels.get(browser); + let newZoomFactor = getZoomLevel(browser); + + if (oldZoomFactor != newZoomFactor) { + zoomLevels.set(browser, newZoomFactor); + + let tabId = tabTracker.getId(nativeTab); + fire.async({ + tabId, + oldZoomFactor, + newZoomFactor, + zoomSettings: await tabsApi.tabs.getZoomSettings(tabId), + }); + } + }; + + tabTracker.on("tab-attached", tabCreated); + tabTracker.on("tab-created", tabCreated); + + windowTracker.addListener("FullZoomChange", zoomListener); + windowTracker.addListener("TextZoomChange", zoomListener); + return () => { + tabTracker.off("tab-attached", tabCreated); + tabTracker.off("tab-created", tabCreated); + + windowTracker.removeListener("FullZoomChange", zoomListener); + windowTracker.removeListener("TextZoomChange", zoomListener); + }; + }, + }).api(), + + print() { + let activeTab = getTabOrActive(null); + let { PrintUtils } = activeTab.ownerGlobal; + PrintUtils.startPrintWindow(activeTab.linkedBrowser.browsingContext); + }, + + // Legacy API + printPreview() { + return Promise.resolve(this.print()); + }, + + saveAsPDF(pageSettings) { + let activeTab = getTabOrActive(null); + let picker = Cc["@mozilla.org/filepicker;1"].createInstance( + Ci.nsIFilePicker + ); + let title = strBundle.GetStringFromName( + "saveaspdf.saveasdialog.title" + ); + let filename; + if ( + pageSettings.toFileName !== null && + pageSettings.toFileName != "" + ) { + filename = pageSettings.toFileName; + } else if (activeTab.linkedBrowser.contentTitle != "") { + filename = activeTab.linkedBrowser.contentTitle; + } else { + let url = new URL(activeTab.linkedBrowser.currentURI.spec); + let path = decodeURIComponent(url.pathname); + path = path.replace(/\/$/, ""); + filename = path.split("/").pop(); + if (filename == "") { + filename = url.hostname; + } + } + filename = DownloadPaths.sanitize(filename); + + picker.init(activeTab.ownerGlobal, title, Ci.nsIFilePicker.modeSave); + picker.appendFilter("PDF", "*.pdf"); + picker.defaultExtension = "pdf"; + picker.defaultString = filename; + + return new Promise(resolve => { + picker.open(function(retval) { + if (retval == 0 || retval == 2) { + // OK clicked (retval == 0) or replace confirmed (retval == 2) + + // Workaround: When trying to replace an existing file that is open in another application (i.e. a locked file), + // the print progress listener is never called. This workaround ensures that a correct status is always returned. + try { + let fstream = Cc[ + "@mozilla.org/network/file-output-stream;1" + ].createInstance(Ci.nsIFileOutputStream); + fstream.init(picker.file, 0x2a, 0o666, 0); // ioflags = write|create|truncate, file permissions = rw-rw-rw- + fstream.close(); + } catch (e) { + resolve(retval == 0 ? "not_saved" : "not_replaced"); + return; + } + + let psService = Cc[ + "@mozilla.org/gfx/printsettings-service;1" + ].getService(Ci.nsIPrintSettingsService); + let printSettings = psService.createNewPrintSettings(); + + printSettings.printerName = ""; + printSettings.isInitializedFromPrinter = true; + printSettings.isInitializedFromPrefs = true; + + printSettings.outputDestination = + Ci.nsIPrintSettings.kOutputDestinationFile; + printSettings.toFileName = picker.file.path; + + printSettings.printSilent = true; + + printSettings.outputFormat = + Ci.nsIPrintSettings.kOutputFormatPDF; + + if (pageSettings.paperSizeUnit !== null) { + printSettings.paperSizeUnit = pageSettings.paperSizeUnit; + } + if (pageSettings.paperWidth !== null) { + printSettings.paperWidth = pageSettings.paperWidth; + } + if (pageSettings.paperHeight !== null) { + printSettings.paperHeight = pageSettings.paperHeight; + } + if (pageSettings.orientation !== null) { + printSettings.orientation = pageSettings.orientation; + } + if (pageSettings.scaling !== null) { + printSettings.scaling = pageSettings.scaling; + } + if (pageSettings.shrinkToFit !== null) { + printSettings.shrinkToFit = pageSettings.shrinkToFit; + } + if (pageSettings.showBackgroundColors !== null) { + printSettings.printBGColors = + pageSettings.showBackgroundColors; + } + if (pageSettings.showBackgroundImages !== null) { + printSettings.printBGImages = + pageSettings.showBackgroundImages; + } + if (pageSettings.edgeLeft !== null) { + printSettings.edgeLeft = pageSettings.edgeLeft; + } + if (pageSettings.edgeRight !== null) { + printSettings.edgeRight = pageSettings.edgeRight; + } + if (pageSettings.edgeTop !== null) { + printSettings.edgeTop = pageSettings.edgeTop; + } + if (pageSettings.edgeBottom !== null) { + printSettings.edgeBottom = pageSettings.edgeBottom; + } + if (pageSettings.marginLeft !== null) { + printSettings.marginLeft = pageSettings.marginLeft; + } + if (pageSettings.marginRight !== null) { + printSettings.marginRight = pageSettings.marginRight; + } + if (pageSettings.marginTop !== null) { + printSettings.marginTop = pageSettings.marginTop; + } + if (pageSettings.marginBottom !== null) { + printSettings.marginBottom = pageSettings.marginBottom; + } + if (pageSettings.headerLeft !== null) { + printSettings.headerStrLeft = pageSettings.headerLeft; + } + if (pageSettings.headerCenter !== null) { + printSettings.headerStrCenter = pageSettings.headerCenter; + } + if (pageSettings.headerRight !== null) { + printSettings.headerStrRight = pageSettings.headerRight; + } + if (pageSettings.footerLeft !== null) { + printSettings.footerStrLeft = pageSettings.footerLeft; + } + if (pageSettings.footerCenter !== null) { + printSettings.footerStrCenter = pageSettings.footerCenter; + } + if (pageSettings.footerRight !== null) { + printSettings.footerStrRight = pageSettings.footerRight; + } + + activeTab.linkedBrowser.browsingContext + .print(printSettings) + .then(() => resolve(retval == 0 ? "saved" : "replaced")) + .catch(() => + resolve(retval == 0 ? "not_saved" : "not_replaced") + ); + } else { + // Cancel clicked (retval == 1) + resolve("canceled"); + } + }); + }); + }, + + async toggleReaderMode(tabId) { + let tab = await promiseTabWhenReady(tabId); + if (!tab.isInReaderMode && !tab.isArticle) { + throw new ExtensionError( + "The specified tab cannot be placed into reader mode." + ); + } + let nativeTab = getTabOrActive(tabId); + + nativeTab.linkedBrowser.sendMessageToActor( + "Reader:ToggleReaderMode", + {}, + "AboutReader" + ); + }, + + moveInSuccession(tabIds, tabId, options) { + const { insert, append } = options || {}; + const tabIdSet = new Set(tabIds); + if (tabIdSet.size !== tabIds.length) { + throw new ExtensionError( + "IDs must not occur more than once in tabIds" + ); + } + if ((append || insert) && tabIdSet.has(tabId)) { + throw new ExtensionError( + "Value of tabId must not occur in tabIds if append or insert is true" + ); + } + + const referenceTab = tabTracker.getTab(tabId, null); + let referenceWindow = referenceTab && referenceTab.ownerGlobal; + if (referenceWindow && !context.canAccessWindow(referenceWindow)) { + throw new ExtensionError(`Invalid tab ID: ${tabId}`); + } + let previousTab, lastSuccessor; + if (append) { + previousTab = referenceTab; + lastSuccessor = + (insert && referenceTab && referenceTab.successor) || null; + } else { + lastSuccessor = referenceTab; + } + + let firstTab; + for (const tabId of tabIds) { + const tab = tabTracker.getTab(tabId, null); + if (tab === null) { + continue; + } + if (!tabManager.canAccessTab(tab)) { + throw new ExtensionError(`Invalid tab ID: ${tabId}`); + } + if (referenceWindow === null) { + referenceWindow = tab.ownerGlobal; + } else if (tab.ownerGlobal !== referenceWindow) { + continue; + } + referenceWindow.gBrowser.replaceInSuccession(tab, tab.successor); + if (append && tab === lastSuccessor) { + lastSuccessor = tab.successor; + } + if (previousTab) { + referenceWindow.gBrowser.setSuccessor(previousTab, tab); + } else { + firstTab = tab; + } + previousTab = tab; + } + + if (previousTab) { + if (!append && insert && lastSuccessor !== null) { + referenceWindow.gBrowser.replaceInSuccession( + lastSuccessor, + firstTab + ); + } + referenceWindow.gBrowser.setSuccessor(previousTab, lastSuccessor); + } + }, + + show(tabIds) { + for (let tab of getNativeTabsFromIDArray(tabIds)) { + if (tab.ownerGlobal) { + tab.ownerGlobal.gBrowser.showTab(tab); + } + } + }, + + hide(tabIds) { + let hidden = []; + for (let tab of getNativeTabsFromIDArray(tabIds)) { + if (tab.ownerGlobal && !tab.hidden) { + tab.ownerGlobal.gBrowser.hideTab(tab, extension.id); + if (tab.hidden) { + hidden.push(tabTracker.getId(tab)); + } + } + } + if (hidden.length) { + let win = Services.wm.getMostRecentWindow("navigator:browser"); + tabHidePopup.open(win, extension.id); + } + return hidden; + }, + + highlight(highlightInfo) { + let { windowId, tabs, populate } = highlightInfo; + if (windowId == null) { + windowId = Window.WINDOW_ID_CURRENT; + } + let window = windowTracker.getWindow(windowId, context); + if (!context.canAccessWindow(window)) { + throw new ExtensionError(`Invalid window ID: ${windowId}`); + } + + if (!Array.isArray(tabs)) { + tabs = [tabs]; + } else if (!tabs.length) { + throw new ExtensionError("No highlighted tab."); + } + window.gBrowser.selectedTabs = tabs.map(tabIndex => { + let tab = window.gBrowser.tabs[tabIndex]; + if (!tab || !tabManager.canAccessTab(tab)) { + throw new ExtensionError("No tab at index: " + tabIndex); + } + return tab; + }); + return windowManager.convert(window, { populate }); + }, + + goForward(tabId) { + let nativeTab = getTabOrActive(tabId); + nativeTab.linkedBrowser.goForward(); + }, + + goBack(tabId) { + let nativeTab = getTabOrActive(tabId); + nativeTab.linkedBrowser.goBack(); + }, + }, + }; + return tabsApi; + } +}; |