diff options
Diffstat (limited to 'browser/components/extensions/parent')
25 files changed, 11283 insertions, 0 deletions
diff --git a/browser/components/extensions/parent/.eslintrc.js b/browser/components/extensions/parent/.eslintrc.js new file mode 100644 index 0000000000..1efdd83ff4 --- /dev/null +++ b/browser/components/extensions/parent/.eslintrc.js @@ -0,0 +1,33 @@ +/* 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"; + +module.exports = { + extends: "../../../../toolkit/components/extensions/parent/.eslintrc.js", + + globals: { + Tab: true, + TabContext: true, + Window: true, + actionContextMenu: true, + browserActionFor: true, + clickModifiersFromEvent: true, + getContainerForCookieStoreId: true, + getTargetTabIdForToolbox: true, + getToolboxEvalOptions: true, + isContainerCookieStoreId: true, + isPrivateCookieStoreId: true, + isValidCookieStoreId: true, + makeWidgetId: true, + openOptionsPage: true, + pageActionFor: true, + replaceUrlInTab: true, + searchInitialized: true, + sidebarActionFor: true, + tabTracker: true, + waitForTabLoaded: true, + windowTracker: true, + }, +}; diff --git a/browser/components/extensions/parent/ext-bookmarks.js b/browser/components/extensions/parent/ext-bookmarks.js new file mode 100644 index 0000000000..6dbb41dc17 --- /dev/null +++ b/browser/components/extensions/parent/ext-bookmarks.js @@ -0,0 +1,515 @@ +/* -*- 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"; + +var { XPCOMUtils } = ChromeUtils.importESModule( + "resource://gre/modules/XPCOMUtils.sys.mjs" +); + +ChromeUtils.defineESModuleGetters(this, { + PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs", +}); + +var { ExtensionError } = ExtensionUtils; + +const { TYPE_BOOKMARK, TYPE_FOLDER, TYPE_SEPARATOR } = PlacesUtils.bookmarks; + +const BOOKMARKS_TYPES_TO_API_TYPES_MAP = new Map([ + [TYPE_BOOKMARK, "bookmark"], + [TYPE_FOLDER, "folder"], + [TYPE_SEPARATOR, "separator"], +]); + +const BOOKMARK_SEPERATOR_URL = "data:"; + +XPCOMUtils.defineLazyGetter(this, "API_TYPES_TO_BOOKMARKS_TYPES_MAP", () => { + let theMap = new Map(); + + for (let [code, name] of BOOKMARKS_TYPES_TO_API_TYPES_MAP) { + theMap.set(name, code); + } + return theMap; +}); + +let listenerCount = 0; + +function getUrl(type, url) { + switch (type) { + case TYPE_BOOKMARK: + return url; + case TYPE_SEPARATOR: + return BOOKMARK_SEPERATOR_URL; + default: + return undefined; + } +} + +const getTree = (rootGuid, onlyChildren) => { + function convert(node, parent) { + let treenode = { + id: node.guid, + title: PlacesUtils.bookmarks.getLocalizedTitle(node) || "", + index: node.index, + dateAdded: node.dateAdded / 1000, + type: BOOKMARKS_TYPES_TO_API_TYPES_MAP.get(node.typeCode), + url: getUrl(node.typeCode, node.uri), + }; + + if (parent && node.guid != PlacesUtils.bookmarks.rootGuid) { + treenode.parentId = parent.guid; + } + + if (node.typeCode == TYPE_FOLDER) { + treenode.dateGroupModified = node.lastModified / 1000; + + if (!onlyChildren) { + treenode.children = node.children + ? node.children.map(child => convert(child, node)) + : []; + } + } + + return treenode; + } + + return PlacesUtils.promiseBookmarksTree(rootGuid) + .then(root => { + if (onlyChildren) { + let children = root.children || []; + return children.map(child => convert(child, root)); + } + let treenode = convert(root, null); + treenode.parentId = root.parentGuid; + // It seems like the array always just contains the root node. + return [treenode]; + }) + .catch(e => Promise.reject({ message: e.message })); +}; + +const convertBookmarks = result => { + let node = { + id: result.guid, + title: PlacesUtils.bookmarks.getLocalizedTitle(result) || "", + index: result.index, + dateAdded: result.dateAdded.getTime(), + type: BOOKMARKS_TYPES_TO_API_TYPES_MAP.get(result.type), + url: getUrl(result.type, result.url && result.url.href), + }; + + if (result.guid != PlacesUtils.bookmarks.rootGuid) { + node.parentId = result.parentGuid; + } + + if (result.type == TYPE_FOLDER) { + node.dateGroupModified = result.lastModified.getTime(); + } + + return node; +}; + +const throwIfRootId = id => { + if (id == PlacesUtils.bookmarks.rootGuid) { + throw new ExtensionError("The bookmark root cannot be modified"); + } +}; + +let observer = new (class extends EventEmitter { + constructor() { + super(); + this.handlePlacesEvents = this.handlePlacesEvents.bind(this); + } + + handlePlacesEvents(events) { + for (let event of events) { + switch (event.type) { + case "bookmark-added": + if (event.isTagging) { + continue; + } + let bookmark = { + id: event.guid, + parentId: event.parentGuid, + index: event.index, + title: event.title, + dateAdded: event.dateAdded, + type: BOOKMARKS_TYPES_TO_API_TYPES_MAP.get(event.itemType), + url: getUrl(event.itemType, event.url), + }; + + if (event.itemType == TYPE_FOLDER) { + bookmark.dateGroupModified = bookmark.dateAdded; + } + + this.emit("created", bookmark); + break; + case "bookmark-removed": + if (event.isTagging || event.isDescendantRemoval) { + continue; + } + let node = { + id: event.guid, + parentId: event.parentGuid, + index: event.index, + type: BOOKMARKS_TYPES_TO_API_TYPES_MAP.get(event.itemType), + url: getUrl(event.itemType, event.url), + title: event.title, + }; + + this.emit("removed", { + guid: event.guid, + info: { parentId: event.parentGuid, index: event.index, node }, + }); + break; + case "bookmark-moved": + this.emit("moved", { + guid: event.guid, + info: { + parentId: event.parentGuid, + index: event.index, + oldParentId: event.oldParentGuid, + oldIndex: event.oldIndex, + }, + }); + break; + case "bookmark-title-changed": + if (event.isTagging) { + continue; + } + + this.emit("changed", { + guid: event.guid, + info: { title: event.title }, + }); + break; + case "bookmark-url-changed": + if (event.isTagging) { + continue; + } + + this.emit("changed", { + guid: event.guid, + info: { url: event.url }, + }); + break; + } + } + } +})(); + +const decrementListeners = () => { + listenerCount -= 1; + if (!listenerCount) { + PlacesUtils.observers.removeListener( + [ + "bookmark-added", + "bookmark-removed", + "bookmark-moved", + "bookmark-title-changed", + "bookmark-url-changed", + ], + observer.handlePlacesEvents + ); + } +}; + +const incrementListeners = () => { + listenerCount++; + if (listenerCount == 1) { + PlacesUtils.observers.addListener( + [ + "bookmark-added", + "bookmark-removed", + "bookmark-moved", + "bookmark-title-changed", + "bookmark-url-changed", + ], + observer.handlePlacesEvents + ); + } +}; + +this.bookmarks = class extends ExtensionAPIPersistent { + PERSISTENT_EVENTS = { + onCreated({ fire }) { + let listener = (event, bookmark) => { + fire.sync(bookmark.id, bookmark); + }; + + observer.on("created", listener); + incrementListeners(); + return { + unregister() { + observer.off("created", listener); + decrementListeners(); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + + onRemoved({ fire }) { + let listener = (event, data) => { + fire.sync(data.guid, data.info); + }; + + observer.on("removed", listener); + incrementListeners(); + return { + unregister() { + observer.off("removed", listener); + decrementListeners(); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + + onChanged({ fire }) { + let listener = (event, data) => { + fire.sync(data.guid, data.info); + }; + + observer.on("changed", listener); + incrementListeners(); + return { + unregister() { + observer.off("changed", listener); + decrementListeners(); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + + onMoved({ fire }) { + let listener = (event, data) => { + fire.sync(data.guid, data.info); + }; + + observer.on("moved", listener); + incrementListeners(); + return { + unregister() { + observer.off("moved", listener); + decrementListeners(); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + }; + + getAPI(context) { + return { + bookmarks: { + async get(idOrIdList) { + let list = Array.isArray(idOrIdList) ? idOrIdList : [idOrIdList]; + + try { + let bookmarks = []; + for (let id of list) { + let bookmark = await PlacesUtils.bookmarks.fetch({ guid: id }); + if (!bookmark) { + throw new Error("Bookmark not found"); + } + bookmarks.push(convertBookmarks(bookmark)); + } + return bookmarks; + } catch (error) { + return Promise.reject({ message: error.message }); + } + }, + + getChildren: function (id) { + // TODO: We should optimize this. + return getTree(id, true); + }, + + getTree: function () { + return getTree(PlacesUtils.bookmarks.rootGuid, false); + }, + + getSubTree: function (id) { + return getTree(id, false); + }, + + search: function (query) { + return PlacesUtils.bookmarks + .search(query) + .then(result => result.map(convertBookmarks)); + }, + + getRecent: function (numberOfItems) { + return PlacesUtils.bookmarks + .getRecent(numberOfItems) + .then(result => result.map(convertBookmarks)); + }, + + create: function (bookmark) { + let info = { + title: bookmark.title || "", + }; + + info.type = API_TYPES_TO_BOOKMARKS_TYPES_MAP.get(bookmark.type); + if (!info.type) { + // If url is NULL or missing, it will be a folder. + if (bookmark.url !== null) { + info.type = TYPE_BOOKMARK; + } else { + info.type = TYPE_FOLDER; + } + } + + if (info.type === TYPE_BOOKMARK) { + info.url = bookmark.url || ""; + } + + if (bookmark.index !== null) { + info.index = bookmark.index; + } + + if (bookmark.parentId !== null) { + throwIfRootId(bookmark.parentId); + info.parentGuid = bookmark.parentId; + } else { + info.parentGuid = PlacesUtils.bookmarks.unfiledGuid; + } + + try { + return PlacesUtils.bookmarks + .insert(info) + .then(convertBookmarks) + .catch(error => Promise.reject({ message: error.message })); + } catch (e) { + return Promise.reject({ + message: `Invalid bookmark: ${JSON.stringify(info)}`, + }); + } + }, + + move: function (id, destination) { + throwIfRootId(id); + let info = { + guid: id, + }; + + if (destination.parentId !== null) { + throwIfRootId(destination.parentId); + info.parentGuid = destination.parentId; + } + info.index = + destination.index === null + ? PlacesUtils.bookmarks.DEFAULT_INDEX + : destination.index; + + try { + return PlacesUtils.bookmarks + .update(info) + .then(convertBookmarks) + .catch(error => Promise.reject({ message: error.message })); + } catch (e) { + return Promise.reject({ + message: `Invalid bookmark: ${JSON.stringify(info)}`, + }); + } + }, + + update: function (id, changes) { + throwIfRootId(id); + let info = { + guid: id, + }; + + if (changes.title !== null) { + info.title = changes.title; + } + if (changes.url !== null) { + info.url = changes.url; + } + + try { + return PlacesUtils.bookmarks + .update(info) + .then(convertBookmarks) + .catch(error => Promise.reject({ message: error.message })); + } catch (e) { + return Promise.reject({ + message: `Invalid bookmark: ${JSON.stringify(info)}`, + }); + } + }, + + remove: function (id) { + throwIfRootId(id); + let info = { + guid: id, + }; + + // The API doesn't give you the old bookmark at the moment + try { + return PlacesUtils.bookmarks + .remove(info, { preventRemovalOfNonEmptyFolders: true }) + .catch(error => Promise.reject({ message: error.message })); + } catch (e) { + return Promise.reject({ + message: `Invalid bookmark: ${JSON.stringify(info)}`, + }); + } + }, + + removeTree: function (id) { + throwIfRootId(id); + let info = { + guid: id, + }; + + try { + return PlacesUtils.bookmarks + .remove(info) + .catch(error => Promise.reject({ message: error.message })); + } catch (e) { + return Promise.reject({ + message: `Invalid bookmark: ${JSON.stringify(info)}`, + }); + } + }, + + onCreated: new EventManager({ + context, + module: "bookmarks", + event: "onCreated", + extensionApi: this, + }).api(), + + onRemoved: new EventManager({ + context, + module: "bookmarks", + event: "onRemoved", + extensionApi: this, + }).api(), + + onChanged: new EventManager({ + context, + module: "bookmarks", + event: "onChanged", + extensionApi: this, + }).api(), + + onMoved: new EventManager({ + context, + module: "bookmarks", + event: "onMoved", + extensionApi: this, + }).api(), + }, + }; + } +}; 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) + ); +}); diff --git a/browser/components/extensions/parent/ext-browserAction.js b/browser/components/extensions/parent/ext-browserAction.js new file mode 100644 index 0000000000..92555c54a5 --- /dev/null +++ b/browser/components/extensions/parent/ext-browserAction.js @@ -0,0 +1,992 @@ +/* -*- 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.defineESModuleGetters(this, { + CustomizableUI: "resource:///modules/CustomizableUI.sys.mjs", + ExtensionTelemetry: "resource://gre/modules/ExtensionTelemetry.sys.mjs", + OriginControls: "resource://gre/modules/ExtensionPermissions.sys.mjs", + ViewPopup: "resource:///modules/ExtensionPopups.sys.mjs", + clearTimeout: "resource://gre/modules/Timer.sys.mjs", + setTimeout: "resource://gre/modules/Timer.sys.mjs", +}); +ChromeUtils.defineModuleGetter( + this, + "BrowserUsageTelemetry", + "resource:///modules/BrowserUsageTelemetry.jsm" +); + +var { DefaultWeakMap, ExtensionError } = ExtensionUtils; + +var { ExtensionParent } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionParent.sys.mjs" +); +var { BrowserActionBase } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionActions.sys.mjs" +); + +var { IconDetails, StartupCache } = ExtensionParent; + +const POPUP_PRELOAD_TIMEOUT_MS = 200; + +// WeakMap[Extension -> BrowserAction] +const browserActionMap = new WeakMap(); + +XPCOMUtils.defineLazyGetter(this, "browserAreas", () => { + return { + navbar: CustomizableUI.AREA_NAVBAR, + menupanel: CustomizableUI.AREA_ADDONS, + tabstrip: CustomizableUI.AREA_TABSTRIP, + personaltoolbar: CustomizableUI.AREA_BOOKMARKS, + }; +}); + +function actionWidgetId(widgetId) { + return `${widgetId}-browser-action`; +} + +class BrowserAction extends BrowserActionBase { + constructor(extension, buttonDelegate) { + let tabContext = new TabContext(target => { + let window = target.ownerGlobal; + if (target === window) { + return this.getContextData(null); + } + return tabContext.get(window); + }); + super(tabContext, extension); + this.buttonDelegate = buttonDelegate; + } + + updateOnChange(target) { + if (target) { + let window = target.ownerGlobal; + if (target === window || target.selected) { + this.buttonDelegate.updateWindow(window); + } + } else { + for (let window of windowTracker.browserWindows()) { + this.buttonDelegate.updateWindow(window); + } + } + } + + getTab(tabId) { + if (tabId !== null) { + return tabTracker.getTab(tabId); + } + return null; + } + + getWindow(windowId) { + if (windowId !== null) { + return windowTracker.getWindow(windowId); + } + return null; + } + + dispatchClick(tab, clickInfo) { + this.buttonDelegate.emit("click", tab, clickInfo); + } +} + +this.browserAction = class extends ExtensionAPIPersistent { + static for(extension) { + return browserActionMap.get(extension); + } + + async onManifestEntry(entryName) { + let { extension } = this; + + let options = + extension.manifest.browser_action || extension.manifest.action; + + this.action = new BrowserAction(extension, this); + await this.action.loadIconData(); + + this.iconData = new DefaultWeakMap(icons => this.getIconData(icons)); + this.iconData.set( + this.action.getIcon(), + await StartupCache.get( + extension, + ["browserAction", "default_icon_data"], + () => this.getIconData(this.action.getIcon()) + ) + ); + + let widgetId = makeWidgetId(extension.id); + this.id = actionWidgetId(widgetId); + this.viewId = `PanelUI-webext-${widgetId}-BAV`; + this.widget = null; + + this.pendingPopup = null; + this.pendingPopupTimeout = null; + this.eventQueue = []; + + this.tabManager = extension.tabManager; + this.browserStyle = options.browser_style; + + browserActionMap.set(extension, this); + + this.build(); + } + + static onUpdate(id, manifest) { + if (!("browser_action" in manifest || "action" in manifest)) { + // If the new version has no browser action then mark this widget as + // hidden in the telemetry. If it is already marked hidden then this will + // do nothing. + BrowserUsageTelemetry.recordWidgetChange( + actionWidgetId(makeWidgetId(id)), + null, + "addon" + ); + } + } + + static onDisable(id) { + BrowserUsageTelemetry.recordWidgetChange( + actionWidgetId(makeWidgetId(id)), + null, + "addon" + ); + } + + static onUninstall(id) { + // If the telemetry already has this widget as hidden then this will not + // record anything. + BrowserUsageTelemetry.recordWidgetChange( + actionWidgetId(makeWidgetId(id)), + null, + "addon" + ); + } + + onShutdown() { + browserActionMap.delete(this.extension); + this.action.onShutdown(); + + CustomizableUI.destroyWidget(this.id); + + this.clearPopup(); + } + + build() { + let { extension } = this; + let widgetId = makeWidgetId(extension.id); + let widget = CustomizableUI.createWidget({ + id: this.id, + viewId: this.viewId, + type: "custom", + webExtension: true, + removable: true, + label: this.action.getProperty(null, "title"), + tooltiptext: this.action.getProperty(null, "title"), + defaultArea: browserAreas[this.action.getDefaultArea()], + showInPrivateBrowsing: extension.privateBrowsingAllowed, + disallowSubView: true, + + // Don't attempt to load properties from the built-in widget string + // bundle. + localized: false, + + // Build a custom widget that looks like a `unified-extensions-item` + // custom element. + onBuild(document) { + let viewId = widgetId + "-BAP"; + let button = document.createXULElement("toolbarbutton"); + button.setAttribute("id", viewId); + // Ensure the extension context menuitems are available by setting this + // on all button children and the item. + button.setAttribute("data-extensionid", extension.id); + button.classList.add("unified-extensions-item-action-button"); + + let contents = document.createXULElement("vbox"); + contents.classList.add("unified-extensions-item-contents"); + contents.setAttribute("move-after-stack", "true"); + + let name = document.createXULElement("label"); + name.classList.add("unified-extensions-item-name"); + contents.appendChild(name); + + // This deck (and its labels) should be kept in sync with + // `browser/base/content/unified-extensions-viewcache.inc.xhtml`. + let deck = document.createXULElement("deck"); + deck.classList.add("unified-extensions-item-message-deck"); + + let messageDefault = document.createXULElement("label"); + messageDefault.classList.add( + "unified-extensions-item-message", + "unified-extensions-item-message-default" + ); + deck.appendChild(messageDefault); + + let messageHover = document.createXULElement("label"); + messageHover.classList.add( + "unified-extensions-item-message", + "unified-extensions-item-message-hover" + ); + deck.appendChild(messageHover); + + let messageHoverForMenuButton = document.createXULElement("label"); + messageHoverForMenuButton.classList.add( + "unified-extensions-item-message", + "unified-extensions-item-message-hover-menu-button" + ); + messageHoverForMenuButton.setAttribute( + "data-l10n-id", + "unified-extensions-item-message-manage" + ); + deck.appendChild(messageHoverForMenuButton); + + contents.appendChild(deck); + + button.appendChild(contents); + + let menuButton = document.createXULElement("toolbarbutton"); + menuButton.classList.add( + "toolbarbutton-1", + "unified-extensions-item-menu-button" + ); + + menuButton.setAttribute( + "data-l10n-id", + "unified-extensions-item-open-menu" + ); + // Allow the users to quickly move between extension items using + // the arrow keys, see: `PanelMultiView._isNavigableWithTabOnly()`. + menuButton.setAttribute("data-navigable-with-tab-only", true); + + menuButton.setAttribute("data-extensionid", extension.id); + menuButton.setAttribute("closemenu", "none"); + + let node = document.createXULElement("toolbaritem"); + node.classList.add( + "toolbaritem-combined-buttons", + "unified-extensions-item" + ); + node.setAttribute("view-button-id", viewId); + node.setAttribute("data-extensionid", extension.id); + node.append(button, menuButton); + node.viewButton = button; + + return node; + }, + + onBeforeCreated: document => { + let view = document.createXULElement("panelview"); + view.id = this.viewId; + view.setAttribute("flex", "1"); + view.setAttribute("extension", true); + view.setAttribute("neverhidden", true); + view.setAttribute("disallowSubView", true); + + document.getElementById("appMenu-viewCache").appendChild(view); + + if ( + this.extension.hasPermission("menus") || + this.extension.hasPermission("contextMenus") + ) { + document.addEventListener("popupshowing", this); + } + }, + + onDestroyed: document => { + document.removeEventListener("popupshowing", this); + + let view = document.getElementById(this.viewId); + if (view) { + this.clearPopup(); + CustomizableUI.hidePanelForNode(view); + view.remove(); + } + }, + + onCreated: node => { + let actionButton = node.querySelector( + ".unified-extensions-item-action-button" + ); + actionButton.classList.add("panel-no-padding"); + actionButton.classList.add("webextension-browser-action"); + actionButton.setAttribute("badged", "true"); + actionButton.setAttribute("constrain-size", "true"); + actionButton.setAttribute("data-extensionid", this.extension.id); + + actionButton.onmousedown = event => this.handleEvent(event); + actionButton.onmouseover = event => this.handleEvent(event); + actionButton.onmouseout = event => this.handleEvent(event); + actionButton.onauxclick = event => this.handleEvent(event); + + const menuButton = node.querySelector( + ".unified-extensions-item-menu-button" + ); + menuButton.setAttribute( + "data-l10n-args", + JSON.stringify({ extensionName: this.extension.name }) + ); + + menuButton.onblur = event => this.handleMenuButtonEvent(event); + menuButton.onfocus = event => this.handleMenuButtonEvent(event); + menuButton.onmouseout = event => this.handleMenuButtonEvent(event); + menuButton.onmouseover = event => this.handleMenuButtonEvent(event); + + actionButton.onblur = event => this.handleEvent(event); + actionButton.onfocus = event => this.handleEvent(event); + + this.updateButton(node, this.action.getContextData(null), true, false); + }, + + onBeforeCommand: (event, node) => { + this.lastClickInfo = { + button: event.button || 0, + modifiers: clickModifiersFromEvent(event), + }; + + // The openPopupWithoutUserInteraction flag may be set by openPopup. + this.openPopupWithoutUserInteraction = + event.detail?.openPopupWithoutUserInteraction === true; + + if ( + event.target.classList.contains( + "unified-extensions-item-action-button" + ) + ) { + return "view"; + } else if ( + event.target.classList.contains("unified-extensions-item-menu-button") + ) { + return "command"; + } + }, + + onCommand: event => { + const { target } = event; + + if (event.button !== 0) { + return; + } + + // Open the unified extensions context menu. + const popup = target.ownerDocument.getElementById( + "unified-extensions-context-menu" + ); + // Anchor to the visible part of the button. + const anchor = target.firstElementChild; + popup.openPopup( + anchor, + "after_end", + 0, + 0, + true /* isContextMenu */, + false /* attributesOverride */, + event + ); + }, + + onViewShowing: async event => { + const { extension } = this; + + ExtensionTelemetry.browserActionPopupOpen.stopwatchStart( + extension, + this + ); + let document = event.target.ownerDocument; + let tabbrowser = document.defaultView.gBrowser; + + let tab = tabbrowser.selectedTab; + + let popupURL = !this.openPopupWithoutUserInteraction + ? this.action.triggerClickOrPopup(tab, this.lastClickInfo) + : this.action.getPopupUrl(tab); + + if (popupURL) { + try { + let popup = this.getPopup(document.defaultView, popupURL); + let attachPromise = popup.attach(event.target); + event.detail.addBlocker(attachPromise); + await attachPromise; + ExtensionTelemetry.browserActionPopupOpen.stopwatchFinish( + extension, + this + ); + if (this.eventQueue.length) { + ExtensionTelemetry.browserActionPreloadResult.histogramAdd({ + category: "popupShown", + extension, + }); + this.eventQueue = []; + } + } catch (e) { + ExtensionTelemetry.browserActionPopupOpen.stopwatchCancel( + extension, + this + ); + Cu.reportError(e); + event.preventDefault(); + } + } else { + ExtensionTelemetry.browserActionPopupOpen.stopwatchCancel( + extension, + this + ); + // This isn't not a hack, but it seems to provide the correct behavior + // with the fewest complications. + event.preventDefault(); + // Ensure we close any popups this node was in: + CustomizableUI.hidePanelForNode(event.target); + } + }, + }); + + if (this.extension.startupReason != "APP_STARTUP") { + // Make sure the browser telemetry has the correct state for this widget. + // Defer loading BrowserUsageTelemetry until after startup is complete. + ExtensionParent.browserStartupPromise.then(() => { + let placement = CustomizableUI.getPlacementOfWidget(widget.id); + BrowserUsageTelemetry.recordWidgetChange( + widget.id, + placement?.area || null, + "addon" + ); + }); + } + + this.widget = widget; + } + + /** + * Shows the popup. The caller is expected to check if a popup is set before + * this is called. + * + * @param {Window} window Window to show the popup for + * @param {boolean} openPopupWithoutUserInteraction + * If the popup was opened without user interaction + */ + async openPopup(window, openPopupWithoutUserInteraction = false) { + const widgetForWindow = this.widget.forWindow(window); + + if (!widgetForWindow.node) { + return; + } + + // We want to focus hidden or minimized windows (both for the API, and to + // avoid an issue where showing the popup in a non-focused window + // immediately triggers a popuphidden event) + window.focus(); + + if (widgetForWindow.node.firstElementChild.open) { + return; + } + + if (this.widget.areaType == CustomizableUI.TYPE_PANEL) { + await window.gUnifiedExtensions.togglePanel(); + } + + // This should already have been checked by callers, but acts as an + // an additional safeguard. It also makes sure we don't dispatch a click + // if the URL is removed while waiting for the overflow to show above. + if (!this.action.getPopupUrl(window.gBrowser.selectedTab)) { + return; + } + + const event = new window.CustomEvent("command", { + bubbles: true, + cancelable: true, + detail: { + openPopupWithoutUserInteraction, + }, + }); + widgetForWindow.node.firstElementChild.dispatchEvent(event); + } + + /** + * Triggers this browser action for the given window, with the same effects as + * if it were clicked by a user. + * + * This has no effect if the browser action is disabled for, or not + * present in, the given window. + * + * @param {Window} window + */ + triggerAction(window) { + let popup = ViewPopup.for(this.extension, window); + if (!this.pendingPopup && popup) { + popup.closePopup(); + return; + } + + let tab = window.gBrowser.selectedTab; + + let popupUrl = this.action.triggerClickOrPopup(tab, { + button: 0, + modifiers: [], + }); + if (popupUrl) { + this.openPopup(window); + } + } + + /** + * Handles events on the (secondary) menu/cog button in an extension widget. + * + * @param {Event} event + */ + handleMenuButtonEvent(event) { + let window = event.target.ownerGlobal; + let { node } = window.gBrowser && this.widget.forWindow(window); + let messageDeck = node?.querySelector( + ".unified-extensions-item-message-deck" + ); + + switch (event.type) { + case "focus": + case "mouseover": { + if (messageDeck) { + messageDeck.selectedIndex = + window.gUnifiedExtensions.MESSAGE_DECK_INDEX_MENU_HOVER; + } + break; + } + + case "blur": + case "mouseout": { + if (messageDeck) { + messageDeck.selectedIndex = + window.gUnifiedExtensions.MESSAGE_DECK_INDEX_DEFAULT; + } + break; + } + } + } + + handleEvent(event) { + // This button is the action/primary button in the custom widget. + let button = event.target; + let window = button.ownerGlobal; + + switch (event.type) { + case "mousedown": + if (event.button == 0) { + let tab = window.gBrowser.selectedTab; + + // Begin pre-loading the browser for the popup, so it's more likely to + // be ready by the time we get a complete click. + let popupURL = this.action.getPopupUrl(tab); + if ( + popupURL && + (this.pendingPopup || !ViewPopup.for(this.extension, window)) + ) { + // Add permission for the active tab so it will exist for the popup. + this.action.setActiveTabForPreload(tab); + this.eventQueue.push("Mousedown"); + this.pendingPopup = this.getPopup(window, popupURL); + window.addEventListener("mouseup", this, true); + } else { + this.clearPopup(); + } + } + break; + + case "mouseup": + if (event.button == 0) { + this.clearPopupTimeout(); + // If we have a pending pre-loaded popup, cancel it after we've waited + // long enough that we can be relatively certain it won't be opening. + if (this.pendingPopup) { + let node = window.gBrowser && this.widget.forWindow(window).node; + if (node && node.contains(event.originalTarget)) { + this.pendingPopupTimeout = setTimeout( + () => this.clearPopup(), + POPUP_PRELOAD_TIMEOUT_MS + ); + } else { + this.clearPopup(); + } + } + } + break; + + case "focus": + case "mouseover": { + let tab = window.gBrowser.selectedTab; + let popupURL = this.action.getPopupUrl(tab); + + let { node } = window.gBrowser && this.widget.forWindow(window); + if (node) { + node.querySelector( + ".unified-extensions-item-message-deck" + ).selectedIndex = window.gUnifiedExtensions.MESSAGE_DECK_INDEX_HOVER; + } + + // We don't want to preload the popup on focus (for now). + if (event.type === "focus") { + break; + } + + // Begin pre-loading the browser for the popup, so it's more likely to + // be ready by the time we get a complete click. + if ( + popupURL && + (this.pendingPopup || !ViewPopup.for(this.extension, window)) + ) { + this.eventQueue.push("Hover"); + this.pendingPopup = this.getPopup(window, popupURL, true); + } + break; + } + + case "blur": + case "mouseout": { + let { node } = window.gBrowser && this.widget.forWindow(window); + if (node) { + node.querySelector( + ".unified-extensions-item-message-deck" + ).selectedIndex = + window.gUnifiedExtensions.MESSAGE_DECK_INDEX_DEFAULT; + } + + // We don't want to clear the popup on blur for now. + if (event.type === "blur") { + break; + } + + if (this.pendingPopup) { + if (this.eventQueue.length) { + ExtensionTelemetry.browserActionPreloadResult.histogramAdd({ + category: `clearAfter${this.eventQueue.pop()}`, + extension: this.extension, + }); + this.eventQueue = []; + } + this.clearPopup(); + } + break; + } + + case "popupshowing": + const menu = event.target; + const trigger = menu.triggerNode; + const node = window.document.getElementById(this.id); + const contexts = [ + "toolbar-context-menu", + "customizationPanelItemContextMenu", + ]; + + if (contexts.includes(menu.id) && node && node.contains(trigger)) { + this.updateContextMenu(menu); + } + break; + + case "auxclick": + if (event.button !== 1) { + return; + } + + let tab = window.gBrowser.selectedTab; + if (this.action.getProperty(tab, "enabled")) { + this.action.setActiveTabForPreload(null); + this.tabManager.addActiveTabPermission(tab); + this.action.dispatchClick(tab, { + button: 1, + modifiers: clickModifiersFromEvent(event), + }); + // Ensure we close any popups this node was in: + CustomizableUI.hidePanelForNode(event.target); + } + break; + } + } + + /** + * Updates the given context menu with the extension's actions. + * + * @param {Element} menu + * The context menu element that should be updated. + */ + updateContextMenu(menu) { + const action = + this.extension.manifestVersion < 3 ? "onBrowserAction" : "onAction"; + + global.actionContextMenu({ + extension: this.extension, + [action]: true, + menu, + }); + } + + /** + * Returns a potentially pre-loaded popup for the given URL in the given + * window. If a matching pre-load popup already exists, returns that. + * Otherwise, initializes a new one. + * + * If a pre-load popup exists which does not match, it is destroyed before a + * new one is created. + * + * @param {Window} window + * The browser window in which to create the popup. + * @param {string} popupURL + * The URL to load into the popup. + * @param {boolean} [blockParser = false] + * True if the HTML parser should initially be blocked. + * @returns {ViewPopup} + */ + getPopup(window, popupURL, blockParser = false) { + this.clearPopupTimeout(); + let { pendingPopup } = this; + this.pendingPopup = null; + + if (pendingPopup) { + if ( + pendingPopup.window === window && + pendingPopup.popupURL === popupURL + ) { + if (!blockParser) { + pendingPopup.unblockParser(); + } + + return pendingPopup; + } + pendingPopup.destroy(); + } + + return new ViewPopup( + this.extension, + window, + popupURL, + this.browserStyle, + false, + blockParser + ); + } + + /** + * Clears any pending pre-loaded popup and related timeouts. + */ + clearPopup() { + this.clearPopupTimeout(); + this.action.setActiveTabForPreload(null); + if (this.pendingPopup) { + this.pendingPopup.destroy(); + this.pendingPopup = null; + } + } + + /** + * Clears any pending timeouts to clear stale, pre-loaded popups. + */ + clearPopupTimeout() { + if (this.pendingPopup) { + this.pendingPopup.window.removeEventListener("mouseup", this, true); + } + + if (this.pendingPopupTimeout) { + clearTimeout(this.pendingPopupTimeout); + this.pendingPopupTimeout = null; + } + } + + // Update the toolbar button |node| with the tab context data + // in |tabData|. + updateButton(node, tabData, sync = false, attention = false) { + // This is the primary/action button in the custom widget. + let button = node.querySelector(".unified-extensions-item-action-button"); + let extensionTitle = tabData.title || this.extension.name; + + let policy = WebExtensionPolicy.getByID(this.extension.id); + let messages = OriginControls.getStateMessageIDs({ + policy, + tab: node.ownerGlobal.gBrowser.selectedTab, + isAction: true, + hasPopup: !!tabData.popup, + }); + + let callback = () => { + // This is set on the node so that it looks good in the toolbar. + node.toggleAttribute("attention", attention); + + node.ownerDocument.l10n.setAttributes( + button, + attention + ? "origin-controls-toolbar-button-permission-needed" + : "origin-controls-toolbar-button", + { extensionTitle } + ); + + button.querySelector(".unified-extensions-item-name").textContent = + this.extension?.name; + + if (messages) { + const messageDefaultElement = button.querySelector( + ".unified-extensions-item-message-default" + ); + node.ownerDocument.l10n.setAttributes( + messageDefaultElement, + messages.default + ); + + const messageHoverElement = button.querySelector( + ".unified-extensions-item-message-hover" + ); + node.ownerDocument.l10n.setAttributes( + messageHoverElement, + messages.onHover || messages.default + ); + } + + if (tabData.badgeText) { + button.setAttribute("badge", tabData.badgeText); + } else { + button.removeAttribute("badge"); + } + + if (tabData.enabled) { + button.removeAttribute("disabled"); + } else { + button.setAttribute("disabled", "true"); + } + + let serializeColor = ([r, g, b, a]) => + `rgba(${r}, ${g}, ${b}, ${a / 255})`; + button.setAttribute( + "badgeStyle", + [ + `background-color: ${serializeColor(tabData.badgeBackgroundColor)}`, + `color: ${serializeColor(this.action.getTextColor(tabData))}`, + ].join("; ") + ); + + let style = this.iconData.get(tabData.icon); + button.setAttribute("style", style); + }; + if (sync) { + callback(); + } else { + node.ownerGlobal.requestAnimationFrame(callback); + } + } + + getIconData(icons) { + let getIcon = (icon, theme) => { + if (typeof icon === "object") { + return IconDetails.escapeUrl(icon[theme]); + } + return IconDetails.escapeUrl(icon); + }; + + let getStyle = (name, icon) => { + return ` + --webextension-${name}: url("${getIcon(icon, "default")}"); + --webextension-${name}-light: url("${getIcon(icon, "light")}"); + --webextension-${name}-dark: url("${getIcon(icon, "dark")}"); + `; + }; + + let icon16 = IconDetails.getPreferredIcon(icons, this.extension, 16).icon; + let icon32 = IconDetails.getPreferredIcon(icons, this.extension, 32).icon; + let icon64 = IconDetails.getPreferredIcon(icons, this.extension, 64).icon; + + return ` + ${getStyle("menupanel-image", icon32)} + ${getStyle("menupanel-image-2x", icon64)} + ${getStyle("toolbar-image", icon16)} + ${getStyle("toolbar-image-2x", icon32)} + `; + } + + /** + * Update the toolbar button for a given window. + * + * @param {ChromeWindow} window + * Browser chrome window. + */ + updateWindow(window) { + let node = this.widget.forWindow(window).node; + if (node) { + let tab = window.gBrowser.selectedTab; + this.updateButton( + node, + this.action.getContextData(tab), + false, + OriginControls.getAttention(this.extension.policy, window) + ); + } + } + + PERSISTENT_EVENTS = { + onClicked({ context, fire }) { + const { extension } = this; + const { tabManager } = extension; + async function listener(_event, tab, clickInfo) { + if (fire.wakeup) { + await fire.wakeup(); + } + // TODO: we should double-check if the tab is already being closed by the time + // the background script got started and we converted the primed listener. + context?.withPendingBrowser(tab.linkedBrowser, () => + fire.sync(tabManager.convert(tab), clickInfo) + ); + } + this.on("click", listener); + return { + unregister: () => { + this.off("click", listener); + }, + convert(newFire, extContext) { + fire = newFire; + context = extContext; + }, + }; + }, + }; + + getAPI(context) { + let { extension } = context; + let { action } = this; + let namespace = extension.manifestVersion < 3 ? "browserAction" : "action"; + + return { + [namespace]: { + ...action.api(context), + + onClicked: new EventManager({ + context, + // module name is "browserAction" because it the name used in the + // ext-browser.json, indipendently from the manifest version. + module: "browserAction", + event: "onClicked", + inputHandling: true, + extensionApi: this, + }).api(), + + openPopup: async options => { + const isHandlingUserInput = + context.callContextData?.isHandlingUserInput; + + if ( + !Services.prefs.getBoolPref( + "extensions.openPopupWithoutUserGesture.enabled" + ) && + !isHandlingUserInput + ) { + throw new ExtensionError("openPopup requires a user gesture"); + } + + const window = + typeof options?.windowId === "number" + ? windowTracker.getWindow(options.windowId, context) + : windowTracker.getTopNormalWindow(context); + + if (this.action.getPopupUrl(window.gBrowser.selectedTab, true)) { + await this.openPopup(window, !isHandlingUserInput); + } + }, + }, + }; + } +}; + +global.browserActionFor = this.browserAction.for; diff --git a/browser/components/extensions/parent/ext-chrome-settings-overrides.js b/browser/components/extensions/parent/ext-chrome-settings-overrides.js new file mode 100644 index 0000000000..6c9b35d66c --- /dev/null +++ b/browser/components/extensions/parent/ext-chrome-settings-overrides.js @@ -0,0 +1,577 @@ +/* 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"; + +var { ExtensionPreferencesManager } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionPreferencesManager.sys.mjs" +); +var { ExtensionParent } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionParent.sys.mjs" +); + +ChromeUtils.defineESModuleGetters(this, { + ExtensionControlledPopup: + "resource:///modules/ExtensionControlledPopup.sys.mjs", + ExtensionPermissions: "resource://gre/modules/ExtensionPermissions.sys.mjs", + ExtensionSettingsStore: + "resource://gre/modules/ExtensionSettingsStore.sys.mjs", +}); + +ChromeUtils.defineModuleGetter( + this, + "HomePage", + "resource:///modules/HomePage.jsm" +); + +const DEFAULT_SEARCH_STORE_TYPE = "default_search"; +const DEFAULT_SEARCH_SETTING_NAME = "defaultSearch"; + +const HOMEPAGE_PREF = "browser.startup.homepage"; +const HOMEPAGE_PRIVATE_ALLOWED = + "browser.startup.homepage_override.privateAllowed"; +const HOMEPAGE_EXTENSION_CONTROLLED = + "browser.startup.homepage_override.extensionControlled"; +const HOMEPAGE_CONFIRMED_TYPE = "homepageNotification"; +const HOMEPAGE_SETTING_TYPE = "prefs"; +const HOMEPAGE_SETTING_NAME = "homepage_override"; + +XPCOMUtils.defineLazyGetter(this, "homepagePopup", () => { + return new ExtensionControlledPopup({ + confirmedType: HOMEPAGE_CONFIRMED_TYPE, + observerTopic: "browser-open-homepage-start", + popupnotificationId: "extension-homepage-notification", + settingType: HOMEPAGE_SETTING_TYPE, + settingKey: HOMEPAGE_SETTING_NAME, + descriptionId: "extension-homepage-notification-description", + descriptionMessageId: "homepageControlled.message", + learnMoreMessageId: "homepageControlled.learnMore", + learnMoreLink: "extension-home", + preferencesLocation: "home-homeOverride", + preferencesEntrypoint: "addon-manage-home-override", + async beforeDisableAddon(popup, win) { + // Disabling an add-on should remove the tabs that it has open, but we want + // to open the new homepage in this tab (which might get closed). + // 1. Replace the tab's URL with about:blank, wait for it to change + // 2. Now that this tab isn't associated with the add-on, disable the add-on + // 3. Trigger the browser's homepage method + let gBrowser = win.gBrowser; + let tab = gBrowser.selectedTab; + await replaceUrlInTab(gBrowser, tab, Services.io.newURI("about:blank")); + Services.prefs.addObserver(HOMEPAGE_PREF, async function prefObserver() { + Services.prefs.removeObserver(HOMEPAGE_PREF, prefObserver); + let loaded = waitForTabLoaded(tab); + win.BrowserHome(); + await loaded; + // Manually trigger an event in case this is controlled again. + popup.open(); + }); + }, + }); +}); + +// When the browser starts up it will trigger the observer topic we're expecting +// but that happens before our observer has been registered. To handle the +// startup case we need to check if the preferences are set to load the homepage +// and check if the homepage is active, then show the doorhanger in that case. +async function handleInitialHomepagePopup(extensionId, homepageUrl) { + // browser.startup.page == 1 is show homepage. + if ( + Services.prefs.getIntPref("browser.startup.page") == 1 && + windowTracker.topWindow + ) { + let { gBrowser } = windowTracker.topWindow; + let tab = gBrowser.selectedTab; + let currentUrl = gBrowser.currentURI.spec; + // When the first window is still loading the URL might be about:blank. + // Wait for that the actual page to load before checking the URL, unless + // the homepage is set to about:blank. + if (currentUrl != homepageUrl && currentUrl == "about:blank") { + await waitForTabLoaded(tab); + currentUrl = gBrowser.currentURI.spec; + } + // Once the page has loaded, if necessary and the active tab hasn't changed, + // then show the popup now. + if (currentUrl == homepageUrl && gBrowser.selectedTab == tab) { + homepagePopup.open(); + return; + } + } + homepagePopup.addObserver(extensionId); +} + +/** + * Handles the homepage url setting for an extension. + * + * @param {object} extension + * The extension setting the hompage url. + * @param {string} homepageUrl + * The homepage url to set. + */ +async function handleHomepageUrl(extension, homepageUrl) { + // For new installs and enabling a disabled addon, we will show + // the prompt. We clear the confirmation in onDisabled and + // onUninstalled, so in either ADDON_INSTALL or ADDON_ENABLE it + // is already cleared, resulting in the prompt being shown if + // necessary the next time the homepage is shown. + + // For localizing the homepageUrl, or otherwise updating the value + // we need to always set the setting here. + let inControl = await ExtensionPreferencesManager.setSetting( + extension.id, + "homepage_override", + homepageUrl + ); + + if (inControl) { + Services.prefs.setBoolPref( + HOMEPAGE_PRIVATE_ALLOWED, + extension.privateBrowsingAllowed + ); + // Also set this now as an upgraded browser will need this. + Services.prefs.setBoolPref(HOMEPAGE_EXTENSION_CONTROLLED, true); + if (extension.startupReason == "APP_STARTUP") { + handleInitialHomepagePopup(extension.id, homepageUrl); + } else { + homepagePopup.addObserver(extension.id); + } + } + + // We need to monitor permission change and update the preferences. + // eslint-disable-next-line mozilla/balanced-listeners + extension.on("add-permissions", async (ignoreEvent, permissions) => { + if (permissions.permissions.includes("internal:privateBrowsingAllowed")) { + let item = await ExtensionPreferencesManager.getSetting( + "homepage_override" + ); + if (item && item.id == extension.id) { + Services.prefs.setBoolPref(HOMEPAGE_PRIVATE_ALLOWED, true); + } + } + }); + // eslint-disable-next-line mozilla/balanced-listeners + extension.on("remove-permissions", async (ignoreEvent, permissions) => { + if (permissions.permissions.includes("internal:privateBrowsingAllowed")) { + let item = await ExtensionPreferencesManager.getSetting( + "homepage_override" + ); + if (item && item.id == extension.id) { + Services.prefs.setBoolPref(HOMEPAGE_PRIVATE_ALLOWED, false); + } + } + }); +} + +// When an extension starts up, a search engine may asynchronously be +// registered, without blocking the startup. When an extension is +// uninstalled, we need to wait for this registration to finish +// before running the uninstallation handler. +// Map[extension id -> Promise] +var pendingSearchSetupTasks = new Map(); + +this.chrome_settings_overrides = class extends ExtensionAPI { + static async processDefaultSearchSetting(action, id) { + await ExtensionSettingsStore.initialize(); + let item = ExtensionSettingsStore.getSetting( + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME, + id + ); + if (!item) { + return; + } + let control = await ExtensionSettingsStore.getLevelOfControl( + id, + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME + ); + item = ExtensionSettingsStore[action]( + id, + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME + ); + if (item && control == "controlled_by_this_extension") { + try { + let engine = Services.search.getEngineByName( + item.value || item.initialValue + ); + if (engine) { + await Services.search.setDefault( + engine, + action == "enable" + ? Ci.nsISearchService.CHANGE_REASON_ADDON_INSTALL + : Ci.nsISearchService.CHANGE_REASON_ADDON_UNINSTALL + ); + } + } catch (e) { + Cu.reportError(e); + } + } + } + + static async removeEngine(id) { + try { + await Services.search.removeWebExtensionEngine(id); + } catch (e) { + Cu.reportError(e); + } + } + + static removeSearchSettings(id) { + return Promise.all([ + this.processDefaultSearchSetting("removeSetting", id), + this.removeEngine(id), + ]); + } + + static async onUninstall(id) { + let searchStartupPromise = pendingSearchSetupTasks.get(id); + if (searchStartupPromise) { + await searchStartupPromise.catch(Cu.reportError); + } + // Note: We do not have to manage the homepage setting here + // as it is managed by the ExtensionPreferencesManager. + return Promise.all([ + this.removeSearchSettings(id), + homepagePopup.clearConfirmation(id), + ]); + } + + static async onUpdate(id, manifest) { + if (!manifest?.chrome_settings_overrides?.homepage) { + // New or changed values are handled during onManifest. + ExtensionPreferencesManager.removeSetting(id, "homepage_override"); + } + + let search_provider = manifest?.chrome_settings_overrides?.search_provider; + + if (!search_provider) { + // Remove setting and engine from search if necessary. + this.removeSearchSettings(id); + } else if (!search_provider.is_default) { + // Remove the setting, but keep the engine in search. + chrome_settings_overrides.processDefaultSearchSetting( + "removeSetting", + id + ); + } + } + + static async onDisable(id) { + homepagePopup.clearConfirmation(id); + + await chrome_settings_overrides.processDefaultSearchSetting("disable", id); + await chrome_settings_overrides.removeEngine(id); + } + + async onManifestEntry(entryName) { + let { extension } = this; + let { manifest } = extension; + let homepageUrl = manifest.chrome_settings_overrides.homepage; + + // If this is a page we ignore, just skip the homepage setting completely. + if (homepageUrl) { + const ignoreHomePageUrl = await HomePage.shouldIgnore(homepageUrl); + + if (ignoreHomePageUrl) { + Services.telemetry.recordEvent( + "homepage", + "preference", + "ignore", + "set_blocked_extension", + { + webExtensionId: extension.id, + } + ); + } else { + await handleHomepageUrl(extension, homepageUrl); + } + } + if (manifest.chrome_settings_overrides.search_provider) { + // Registering a search engine can potentially take a long while, + // or not complete at all (when searchInitialized is never resolved), + // so we are deliberately not awaiting the returned promise here. + let searchStartupPromise = + this.processSearchProviderManifestEntry().finally(() => { + if ( + pendingSearchSetupTasks.get(extension.id) === searchStartupPromise + ) { + pendingSearchSetupTasks.delete(extension.id); + // This is primarily for tests so that we know when an extension + // has finished initialising. + ExtensionParent.apiManager.emit("searchEngineProcessed", extension); + } + }); + + // Save the promise so we can await at onUninstall. + pendingSearchSetupTasks.set(extension.id, searchStartupPromise); + } + } + + async ensureSetting(engineName, disable = false) { + let { extension } = this; + // Ensure the addon always has a setting + await ExtensionSettingsStore.initialize(); + let item = ExtensionSettingsStore.getSetting( + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME, + extension.id + ); + if (!item) { + let defaultEngine = await Services.search.getDefault(); + item = await ExtensionSettingsStore.addSetting( + extension.id, + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME, + engineName, + () => defaultEngine.name + ); + // If there was no setting, we're fixing old behavior in this api. + // A lack of a setting would mean it was disabled before, disable it now. + disable = + disable || + ["ADDON_UPGRADE", "ADDON_DOWNGRADE", "ADDON_ENABLE"].includes( + extension.startupReason + ); + } + + // Ensure the item is disabled (either if exists and is not default or if it does not + // exist yet). + if (disable) { + item = await ExtensionSettingsStore.disable( + extension.id, + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME + ); + } + return item; + } + + async promptDefaultSearch(engineName) { + let { extension } = this; + // Don't ask if it is already the current engine + let engine = Services.search.getEngineByName(engineName); + let defaultEngine = await Services.search.getDefault(); + if (defaultEngine.name == engine.name) { + return; + } + // Ensures the setting exists and is disabled. If the + // user somehow bypasses the prompt, we do not want this + // setting enabled for this extension. + await this.ensureSetting(engineName, true); + + let subject = { + wrappedJSObject: { + // This is a hack because we don't have the browser of + // the actual install. This means the popup might show + // in a different window. Will be addressed in a followup bug. + // As well, we still notify if no topWindow exists to support + // testing from xpcshell. + browser: windowTracker.topWindow?.gBrowser.selectedBrowser, + id: extension.id, + name: extension.name, + icon: extension.getPreferredIcon(32), + currentEngine: defaultEngine.name, + newEngine: engineName, + async respond(allow) { + if (allow) { + await chrome_settings_overrides.processDefaultSearchSetting( + "enable", + extension.id + ); + await Services.search.setDefault( + Services.search.getEngineByName(engineName), + Ci.nsISearchService.CHANGE_REASON_ADDON_INSTALL + ); + } + // For testing + Services.obs.notifyObservers( + null, + "webextension-defaultsearch-prompt-response" + ); + }, + }, + }; + Services.obs.notifyObservers(subject, "webextension-defaultsearch-prompt"); + } + + async processSearchProviderManifestEntry() { + let { extension } = this; + let { manifest } = extension; + let searchProvider = manifest.chrome_settings_overrides.search_provider; + + // If we're not being requested to be set as default, then all we need + // to do is to add the engine to the service. The search service can cope + // with receiving added engines before it is initialised, so we don't have + // to wait for it. Search Service will also prevent overriding a builtin + // engine appropriately. + if (!searchProvider.is_default) { + await this.addSearchEngine(); + return; + } + + await searchInitialized; + if (!this.extension) { + Cu.reportError( + `Extension shut down before search provider was registered` + ); + return; + } + + let engineName = searchProvider.name.trim(); + let result = await Services.search.maybeSetAndOverrideDefault(extension); + // This will only be set to true when the specified engine is an app-provided + // engine, or when it is an allowed add-on defined in the list stored in + // SearchDefaultOverrideAllowlistHandler. + if (result.canChangeToAppProvided) { + await this.setDefault(engineName, true); + } + if (!result.canInstallEngine) { + // This extension is overriding an app-provided one, so we don't + // add its engine as well. + return; + } + await this.addSearchEngine(); + if (extension.startupReason === "ADDON_INSTALL") { + await this.promptDefaultSearch(engineName); + } else { + // Needs to be called every time to handle reenabling. + await this.setDefault(engineName); + } + } + + async setDefault(engineName, skipEnablePrompt = false) { + let { extension } = this; + + if (extension.startupReason === "ADDON_INSTALL") { + // We should only get here if an extension is setting an app-provided + // engine to default and we are ignoring the addons other engine settings. + // In this case we do not show the prompt to the user. + let item = await this.ensureSetting(engineName); + await Services.search.setDefault( + Services.search.getEngineByName(item.value), + Ci.nsISearchService.CHANGE_REASON_ADDON_INSTALL + ); + } else if ( + ["ADDON_UPGRADE", "ADDON_DOWNGRADE", "ADDON_ENABLE"].includes( + extension.startupReason + ) + ) { + // We would be called for every extension being enabled, we should verify + // that it has control and only then set it as default + let control = await ExtensionSettingsStore.getLevelOfControl( + extension.id, + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME + ); + + // Check for an inconsistency between the value returned by getLevelOfcontrol + // and the current engine actually set. + if ( + control === "controlled_by_this_extension" && + Services.search.defaultEngine.name !== engineName + ) { + // Check for and fix any inconsistency between the extensions settings storage + // and the current engine actually set. If settings claims the extension is default + // but the search service claims otherwise, select what the search service claims + // (See Bug 1767550). + const allSettings = ExtensionSettingsStore.getAllSettings( + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME + ); + for (const setting of allSettings) { + if (setting.value !== Services.search.defaultEngine.name) { + await ExtensionSettingsStore.disable( + setting.id, + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME + ); + } + } + control = await ExtensionSettingsStore.getLevelOfControl( + extension.id, + DEFAULT_SEARCH_STORE_TYPE, + DEFAULT_SEARCH_SETTING_NAME + ); + } + + if (control === "controlled_by_this_extension") { + await Services.search.setDefault( + Services.search.getEngineByName(engineName), + Ci.nsISearchService.CHANGE_REASON_ADDON_INSTALL + ); + } else if (control === "controllable_by_this_extension") { + if (skipEnablePrompt) { + // For overriding app-provided engines, we don't prompt, so set + // the default straight away. + await chrome_settings_overrides.processDefaultSearchSetting( + "enable", + extension.id + ); + await Services.search.setDefault( + Services.search.getEngineByName(engineName), + Ci.nsISearchService.CHANGE_REASON_ADDON_INSTALL + ); + } else if (extension.startupReason == "ADDON_ENABLE") { + // This extension has precedence, but is not in control. Ask the user. + await this.promptDefaultSearch(engineName); + } + } + } + } + + async addSearchEngine() { + let { extension } = this; + try { + await Services.search.addEnginesFromExtension(extension); + } catch (e) { + Cu.reportError(e); + return false; + } + return true; + } +}; + +ExtensionPreferencesManager.addSetting("homepage_override", { + prefNames: [ + HOMEPAGE_PREF, + HOMEPAGE_EXTENSION_CONTROLLED, + HOMEPAGE_PRIVATE_ALLOWED, + ], + // ExtensionPreferencesManager will call onPrefsChanged when control changes + // and it updates the preferences. We are passed the item from + // ExtensionSettingsStore that details what is in control. If there is an id + // then control has changed to an extension, if there is no id then control + // has been returned to the user. + async onPrefsChanged(item) { + if (item.id) { + homepagePopup.addObserver(item.id); + + let policy = ExtensionParent.WebExtensionPolicy.getByID(item.id); + let allowed = policy && policy.privateBrowsingAllowed; + if (!policy) { + // We'll generally hit this path during safe mode changes. + let perms = await ExtensionPermissions.get(item.id); + allowed = perms.permissions.includes("internal:privateBrowsingAllowed"); + } + Services.prefs.setBoolPref(HOMEPAGE_PRIVATE_ALLOWED, allowed); + Services.prefs.setBoolPref(HOMEPAGE_EXTENSION_CONTROLLED, true); + } else { + homepagePopup.removeObserver(); + + Services.prefs.clearUserPref(HOMEPAGE_PRIVATE_ALLOWED); + Services.prefs.clearUserPref(HOMEPAGE_EXTENSION_CONTROLLED); + } + }, + setCallback(value) { + // Setting the pref will result in onPrefsChanged being called, which + // will then set HOMEPAGE_PRIVATE_ALLOWED. We want to ensure that this + // pref will be set/unset as apropriate. + return { + [HOMEPAGE_PREF]: value, + [HOMEPAGE_EXTENSION_CONTROLLED]: !!value, + [HOMEPAGE_PRIVATE_ALLOWED]: false, + }; + }, +}); diff --git a/browser/components/extensions/parent/ext-commands.js b/browser/components/extensions/parent/ext-commands.js new file mode 100644 index 0000000000..88e7dae307 --- /dev/null +++ b/browser/components/extensions/parent/ext-commands.js @@ -0,0 +1,82 @@ +/* -*- 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.defineESModuleGetters(this, { + ExtensionShortcuts: "resource://gre/modules/ExtensionShortcuts.sys.mjs", +}); + +this.commands = class extends ExtensionAPIPersistent { + PERSISTENT_EVENTS = { + onCommand({ fire }) { + let listener = (eventName, commandName) => { + fire.async(commandName); + }; + this.on("command", listener); + return { + unregister: () => this.off("command", listener), + convert(_fire) { + fire = _fire; + }, + }; + }, + onChanged({ fire }) { + let listener = (eventName, changeInfo) => { + fire.async(changeInfo); + }; + this.on("shortcutChanged", listener); + return { + unregister: () => this.off("shortcutChanged", listener), + convert(_fire) { + fire = _fire; + }, + }; + }, + }; + + static onUninstall(extensionId) { + return ExtensionShortcuts.removeCommandsFromStorage(extensionId); + } + + async onManifestEntry(entryName) { + let shortcuts = new ExtensionShortcuts({ + extension: this.extension, + onCommand: name => this.emit("command", name), + onShortcutChanged: changeInfo => this.emit("shortcutChanged", changeInfo), + }); + this.extension.shortcuts = shortcuts; + await shortcuts.loadCommands(); + await shortcuts.register(); + } + + onShutdown() { + this.extension.shortcuts.unregister(); + } + + getAPI(context) { + return { + commands: { + getAll: () => this.extension.shortcuts.allCommands(), + update: args => this.extension.shortcuts.updateCommand(args), + reset: name => this.extension.shortcuts.resetCommand(name), + onCommand: new EventManager({ + context, + module: "commands", + event: "onCommand", + inputHandling: true, + extensionApi: this, + }).api(), + onChanged: new EventManager({ + context, + module: "commands", + event: "onChanged", + extensionApi: this, + }).api(), + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-devtools-inspectedWindow.js b/browser/components/extensions/parent/ext-devtools-inspectedWindow.js new file mode 100644 index 0000000000..9da54b9cfc --- /dev/null +++ b/browser/components/extensions/parent/ext-devtools-inspectedWindow.js @@ -0,0 +1,53 @@ +/* -*- 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"; + +var { SpreadArgs } = ExtensionCommon; + +this.devtools_inspectedWindow = class extends ExtensionAPI { + getAPI(context) { + // TODO - Bug 1448878: retrieve a more detailed callerInfo object, + // like the filename and lineNumber of the actual extension called + // in the child process. + const callerInfo = { + addonId: context.extension.id, + url: context.extension.baseURI.spec, + }; + + return { + devtools: { + inspectedWindow: { + async eval(expression, options) { + const toolboxEvalOptions = await getToolboxEvalOptions(context); + const evalOptions = Object.assign({}, options, toolboxEvalOptions); + + const commands = await context.getDevToolsCommands(); + const evalResult = await commands.inspectedWindowCommand.eval( + callerInfo, + expression, + evalOptions + ); + + // TODO(rpl): check for additional undocumented behaviors on chrome + // (e.g. if we should also print error to the console or set lastError?). + return new SpreadArgs([evalResult.value, evalResult.exceptionInfo]); + }, + async reload(options) { + const { ignoreCache, userAgent, injectedScript } = options || {}; + + const commands = await context.getDevToolsCommands(); + commands.inspectedWindowCommand.reload(callerInfo, { + ignoreCache, + userAgent, + injectedScript, + }); + }, + }, + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-devtools-network.js b/browser/components/extensions/parent/ext-devtools-network.js new file mode 100644 index 0000000000..5c69b4a03b --- /dev/null +++ b/browser/components/extensions/parent/ext-devtools-network.js @@ -0,0 +1,82 @@ +/* -*- 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"; + +var { SpreadArgs } = ExtensionCommon; + +var { ExtensionError } = ExtensionUtils; + +this.devtools_network = class extends ExtensionAPI { + getAPI(context) { + return { + devtools: { + network: { + onNavigated: new EventManager({ + context, + name: "devtools.onNavigated", + register: fire => { + const listener = url => { + fire.async(url); + }; + + const promise = context.addOnNavigatedListener(listener); + return () => { + promise.then(() => { + context.removeOnNavigatedListener(listener); + }); + }; + }, + }).api(), + + getHAR: function () { + return context.devToolsToolbox.getHARFromNetMonitor(); + }, + + onRequestFinished: new EventManager({ + context, + name: "devtools.network.onRequestFinished", + register: fire => { + const listener = data => { + fire.async(data); + }; + + const toolbox = context.devToolsToolbox; + toolbox.addRequestFinishedListener(listener); + + return () => { + toolbox.removeRequestFinishedListener(listener); + }; + }, + }).api(), + + // The following method is used internally to allow the request API + // piece that is running in the child process to ask the parent process + // to fetch response content from the back-end. + Request: { + async getContent(requestId) { + return context.devToolsToolbox + .fetchResponseContent(requestId) + .then( + ({ content }) => + new SpreadArgs([content.text, content.mimeType]) + ) + .catch(err => { + const debugName = context.extension.policy.debugName; + const errorMsg = + "Unexpected error while fetching response content"; + Cu.reportError( + `${debugName}: ${errorMsg} for ${requestId}: ${err}` + ); + throw new ExtensionError(errorMsg); + }); + }, + }, + }, + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-devtools-panels.js b/browser/components/extensions/parent/ext-devtools-panels.js new file mode 100644 index 0000000000..9f0dba5c25 --- /dev/null +++ b/browser/components/extensions/parent/ext-devtools-panels.js @@ -0,0 +1,691 @@ +/* -*- 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"; + +var { ExtensionParent } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionParent.sys.mjs" +); + +ChromeUtils.defineESModuleGetters(this, { + BroadcastConduit: "resource://gre/modules/ConduitsParent.sys.mjs", +}); + +var { watchExtensionProxyContextLoad } = ExtensionParent; + +var { promiseDocumentLoaded } = ExtensionUtils; + +const WEBEXT_PANELS_URL = "chrome://browser/content/webext-panels.xhtml"; + +class BaseDevToolsPanel { + constructor(context, panelOptions) { + const toolbox = context.devToolsToolbox; + if (!toolbox) { + // This should never happen when this constructor is called with a valid + // devtools extension context. + throw Error("Missing mandatory toolbox"); + } + + this.context = context; + this.extension = context.extension; + this.toolbox = toolbox; + this.viewType = "devtools_panel"; + this.panelOptions = panelOptions; + this.id = panelOptions.id; + + this.unwatchExtensionProxyContextLoad = null; + + // References to the panel browser XUL element and the toolbox window global which + // contains the devtools panel UI. + this.browser = null; + this.browserContainerWindow = null; + } + + async createBrowserElement(window) { + const { toolbox } = this; + const { extension } = this.context; + const { url } = this.panelOptions || { url: "about:blank" }; + + this.browser = await window.getBrowser({ + extension, + extensionUrl: url, + browserStyle: false, + viewType: "devtools_panel", + browserInsertedData: { + devtoolsToolboxInfo: { + toolboxPanelId: this.id, + inspectedWindowTabId: getTargetTabIdForToolbox(toolbox), + }, + }, + }); + + let hasTopLevelContext = false; + + // Listening to new proxy contexts. + this.unwatchExtensionProxyContextLoad = watchExtensionProxyContextLoad( + this, + context => { + // Keep track of the toolbox and target associated to the context, which is + // needed by the API methods implementation. + context.devToolsToolbox = toolbox; + + if (!hasTopLevelContext) { + hasTopLevelContext = true; + + // Resolve the promise when the root devtools_panel context has been created. + if (this._resolveTopLevelContext) { + this._resolveTopLevelContext(context); + } + } + } + ); + + this.browser.fixupAndLoadURIString(url, { + triggeringPrincipal: this.context.principal, + }); + } + + destroyBrowserElement() { + const { browser, unwatchExtensionProxyContextLoad } = this; + if (unwatchExtensionProxyContextLoad) { + this.unwatchExtensionProxyContextLoad = null; + unwatchExtensionProxyContextLoad(); + } + + if (browser) { + browser.remove(); + this.browser = null; + } + } +} + +/** + * Represents an addon devtools panel in the main process. + * + * @param {ExtensionChildProxyContext} context + * A devtools extension proxy context running in a main process. + * @param {object} options + * @param {string} options.id + * The id of the addon devtools panel. + * @param {string} options.icon + * The icon of the addon devtools panel. + * @param {string} options.title + * The title of the addon devtools panel. + * @param {string} options.url + * The url of the addon devtools panel, relative to the extension base URL. + */ +class ParentDevToolsPanel extends BaseDevToolsPanel { + constructor(context, panelOptions) { + super(context, panelOptions); + + this.visible = false; + this.destroyed = false; + + this.context.callOnClose(this); + + this.conduit = new BroadcastConduit(this, { + id: `${this.id}-parent`, + send: ["PanelHidden", "PanelShown"], + }); + + this.onToolboxPanelSelect = this.onToolboxPanelSelect.bind(this); + this.onToolboxHostWillChange = this.onToolboxHostWillChange.bind(this); + this.onToolboxHostChanged = this.onToolboxHostChanged.bind(this); + + this.waitTopLevelContext = new Promise(resolve => { + this._resolveTopLevelContext = resolve; + }); + + this.panelAdded = false; + this.addPanel(); + } + + addPanel() { + const { icon, title } = this.panelOptions; + const extensionName = this.context.extension.name; + + this.toolbox.addAdditionalTool({ + id: this.id, + extensionId: this.context.extension.id, + url: WEBEXT_PANELS_URL, + icon: icon, + label: title, + // panelLabel is used to set the aria-label attribute (See Bug 1570645). + panelLabel: title, + tooltip: `DevTools Panel added by "${extensionName}" add-on.`, + isToolSupported: toolbox => toolbox.commands.descriptorFront.isLocalTab, + build: (window, toolbox) => { + if (toolbox !== this.toolbox) { + throw new Error( + "Unexpected toolbox received on addAdditionalTool build property" + ); + } + + const destroy = this.buildPanel(window); + + return { toolbox, destroy }; + }, + }); + + this.panelAdded = true; + } + + buildPanel(window) { + const { toolbox } = this; + + this.createBrowserElement(window); + + // Store the last panel's container element (used to restore it when the toolbox + // host is switched between docked and undocked). + this.browserContainerWindow = window; + + toolbox.on("select", this.onToolboxPanelSelect); + toolbox.on("host-will-change", this.onToolboxHostWillChange); + toolbox.on("host-changed", this.onToolboxHostChanged); + + // Return a cleanup method that is when the panel is destroyed, e.g. + // - when addon devtool panel has been disabled by the user from the toolbox preferences, + // its ParentDevToolsPanel instance is still valid, but the built devtools panel is removed from + // the toolbox (and re-built again if the user re-enables it from the toolbox preferences panel) + // - when the creator context has been destroyed, the ParentDevToolsPanel close method is called, + // it removes the tool definition from the toolbox, which will call this destroy method. + return () => { + this.destroyBrowserElement(); + this.browserContainerWindow = null; + toolbox.off("select", this.onToolboxPanelSelect); + toolbox.off("host-will-change", this.onToolboxHostWillChange); + toolbox.off("host-changed", this.onToolboxHostChanged); + }; + } + + onToolboxHostWillChange() { + // NOTE: Using a content iframe here breaks the devtools panel + // switching between docked and undocked mode, + // because of a swapFrameLoader exception (see bug 1075490), + // destroy the browser and recreate it after the toolbox host has been + // switched is a reasonable workaround to fix the issue on release and beta + // Firefox versions (at least until the underlying bug can be fixed). + if (this.browser) { + // Fires a panel.onHidden event before destroying the browser element because + // the toolbox hosts is changing. + if (this.visible) { + this.conduit.sendPanelHidden(this.id); + } + + this.destroyBrowserElement(); + } + } + + async onToolboxHostChanged() { + if (this.browserContainerWindow) { + this.createBrowserElement(this.browserContainerWindow); + + // Fires a panel.onShown event once the browser element has been recreated + // after the toolbox hosts has been changed (needed to provide the new window + // object to the extension page that has created the devtools panel). + if (this.visible) { + await this.waitTopLevelContext; + this.conduit.sendPanelShown(this.id); + } + } + } + + async onToolboxPanelSelect(id) { + if (!this.waitTopLevelContext || !this.panelAdded) { + return; + } + + // Wait that the panel is fully loaded and emit show. + await this.waitTopLevelContext; + + if (!this.visible && id === this.id) { + this.visible = true; + this.conduit.sendPanelShown(this.id); + } else if (this.visible && id !== this.id) { + this.visible = false; + this.conduit.sendPanelHidden(this.id); + } + } + + close() { + const { toolbox } = this; + + if (!toolbox) { + throw new Error("Unable to destroy a closed devtools panel"); + } + + this.conduit.close(); + + // Explicitly remove the panel if it is registered and the toolbox is not + // closing itself. + if (this.panelAdded && toolbox.isToolRegistered(this.id)) { + this.destroyBrowserElement(); + toolbox.removeAdditionalTool(this.id); + } + + this.waitTopLevelContext = null; + this._resolveTopLevelContext = null; + this.context = null; + this.toolbox = null; + this.browser = null; + this.browserContainerWindow = null; + } + + destroyBrowserElement() { + super.destroyBrowserElement(); + + // If the panel has been removed or disabled (e.g. from the toolbox preferences + // or during the toolbox switching between docked and undocked), + // we need to re-initialize the waitTopLevelContext Promise. + this.waitTopLevelContext = new Promise(resolve => { + this._resolveTopLevelContext = resolve; + }); + } +} + +class DevToolsSelectionObserver extends EventEmitter { + constructor(context) { + if (!context.devToolsToolbox) { + // This should never happen when this constructor is called with a valid + // devtools extension context. + throw Error("Missing mandatory toolbox"); + } + + super(); + context.callOnClose(this); + + this.toolbox = context.devToolsToolbox; + this.onSelected = this.onSelected.bind(this); + this.initialized = false; + } + + on(...args) { + this.lazyInit(); + super.on.apply(this, args); + } + + once(...args) { + this.lazyInit(); + super.once.apply(this, args); + } + + async lazyInit() { + if (!this.initialized) { + this.initialized = true; + this.toolbox.on("selection-changed", this.onSelected); + } + } + + close() { + if (this.destroyed) { + throw new Error("Unable to close a destroyed DevToolsSelectionObserver"); + } + + if (this.initialized) { + this.toolbox.off("selection-changed", this.onSelected); + } + + this.toolbox = null; + this.destroyed = true; + } + + onSelected() { + this.emit("selectionChanged"); + } +} + +/** + * Represents an addon devtools inspector sidebar in the main process. + * + * @param {ExtensionChildProxyContext} context + * A devtools extension proxy context running in a main process. + * @param {object} options + * @param {string} options.id + * The id of the addon devtools sidebar. + * @param {string} options.title + * The title of the addon devtools sidebar. + */ +class ParentDevToolsInspectorSidebar extends BaseDevToolsPanel { + constructor(context, panelOptions) { + super(context, panelOptions); + + this.visible = false; + this.destroyed = false; + + this.context.callOnClose(this); + + this.conduit = new BroadcastConduit(this, { + id: `${this.id}-parent`, + send: ["InspectorSidebarHidden", "InspectorSidebarShown"], + }); + + this.onSidebarSelect = this.onSidebarSelect.bind(this); + this.onSidebarCreated = this.onSidebarCreated.bind(this); + this.onExtensionPageMount = this.onExtensionPageMount.bind(this); + this.onExtensionPageUnmount = this.onExtensionPageUnmount.bind(this); + this.onToolboxHostWillChange = this.onToolboxHostWillChange.bind(this); + this.onToolboxHostChanged = this.onToolboxHostChanged.bind(this); + + this.toolbox.once( + `extension-sidebar-created-${this.id}`, + this.onSidebarCreated + ); + this.toolbox.on("inspector-sidebar-select", this.onSidebarSelect); + this.toolbox.on("host-will-change", this.onToolboxHostWillChange); + this.toolbox.on("host-changed", this.onToolboxHostChanged); + + // Set by setObject if the sidebar has not been created yet. + this._initializeSidebar = null; + + // Set by _updateLastExpressionResult to keep track of the last + // object value grip (to release the previous selected actor + // on the remote debugging server when the actor changes). + this._lastExpressionResult = null; + + this.toolbox.registerInspectorExtensionSidebar(this.id, { + title: panelOptions.title, + }); + } + + close() { + if (this.destroyed) { + throw new Error("Unable to close a destroyed DevToolsSelectionObserver"); + } + + this.conduit.close(); + + if (this.extensionSidebar) { + this.extensionSidebar.off( + "extension-page-mount", + this.onExtensionPageMount + ); + this.extensionSidebar.off( + "extension-page-unmount", + this.onExtensionPageUnmount + ); + } + + if (this.browser) { + this.destroyBrowserElement(); + this.browser = null; + this.containerEl = null; + } + + this.toolbox.off( + `extension-sidebar-created-${this.id}`, + this.onSidebarCreated + ); + this.toolbox.off("inspector-sidebar-select", this.onSidebarSelect); + this.toolbox.off("host-changed", this.onToolboxHostChanged); + this.toolbox.off("host-will-change", this.onToolboxHostWillChange); + + this.toolbox.unregisterInspectorExtensionSidebar(this.id); + this.extensionSidebar = null; + this._lazySidebarInit = null; + + this.destroyed = true; + } + + onToolboxHostWillChange() { + if (this.browser) { + this.destroyBrowserElement(); + } + } + + onToolboxHostChanged() { + if (this.containerEl && this.panelOptions.url) { + this.createBrowserElement(this.containerEl.contentWindow); + } + } + + onExtensionPageMount(containerEl) { + this.containerEl = containerEl; + + // Wait the webext-panel.xhtml page to have been loaded in the + // inspector sidebar panel. + promiseDocumentLoaded(containerEl.contentDocument).then(() => { + this.createBrowserElement(containerEl.contentWindow); + }); + } + + onExtensionPageUnmount() { + this.containerEl = null; + this.destroyBrowserElement(); + } + + onSidebarCreated(sidebar) { + this.extensionSidebar = sidebar; + + sidebar.on("extension-page-mount", this.onExtensionPageMount); + sidebar.on("extension-page-unmount", this.onExtensionPageUnmount); + + const { _lazySidebarInit } = this; + this._lazySidebarInit = null; + + if (typeof _lazySidebarInit === "function") { + _lazySidebarInit(); + } + } + + onSidebarSelect(id) { + if (!this.extensionSidebar) { + return; + } + + if (!this.visible && id === this.id) { + this.visible = true; + this.conduit.sendInspectorSidebarShown(this.id); + } else if (this.visible && id !== this.id) { + this.visible = false; + this.conduit.sendInspectorSidebarHidden(this.id); + } + } + + setPage(extensionPageURL) { + this.panelOptions.url = extensionPageURL; + + if (this.extensionSidebar) { + if (this.browser) { + // Just load the new extension page url in the existing browser, if + // it already exists. + this.browser.fixupAndLoadURIString(this.panelOptions.url, { + triggeringPrincipal: this.context.extension.principal, + }); + } else { + // The browser element doesn't exist yet, but the sidebar has been + // already created (e.g. because the inspector was already selected + // in a open toolbox and the extension has been installed/reloaded/updated). + this.extensionSidebar.setExtensionPage(WEBEXT_PANELS_URL); + } + } else { + // Defer the sidebar.setExtensionPage call. + this._setLazySidebarInit(() => + this.extensionSidebar.setExtensionPage(WEBEXT_PANELS_URL) + ); + } + } + + setObject(object, rootTitle) { + delete this.panelOptions.url; + + this._updateLastExpressionResult(null); + + // Nest the object inside an object, as the value of the `rootTitle` property. + if (rootTitle) { + object = { [rootTitle]: object }; + } + + if (this.extensionSidebar) { + this.extensionSidebar.setObject(object); + } else { + // Defer the sidebar.setObject call. + this._setLazySidebarInit(() => this.extensionSidebar.setObject(object)); + } + } + + _setLazySidebarInit(cb) { + this._lazySidebarInit = cb; + } + + setExpressionResult(expressionResult, rootTitle) { + delete this.panelOptions.url; + + this._updateLastExpressionResult(expressionResult); + + if (this.extensionSidebar) { + this.extensionSidebar.setExpressionResult(expressionResult, rootTitle); + } else { + // Defer the sidebar.setExpressionResult call. + this._setLazySidebarInit(() => { + this.extensionSidebar.setExpressionResult(expressionResult, rootTitle); + }); + } + } + + _updateLastExpressionResult(newExpressionResult = null) { + const { _lastExpressionResult } = this; + + this._lastExpressionResult = newExpressionResult; + + const oldActor = _lastExpressionResult && _lastExpressionResult.actorID; + const newActor = newExpressionResult && newExpressionResult.actorID; + + // Release the previously active actor on the remote debugging server. + if ( + oldActor && + oldActor !== newActor && + typeof _lastExpressionResult.release === "function" + ) { + _lastExpressionResult.release(); + } + } +} + +const sidebarsById = new Map(); + +this.devtools_panels = class extends ExtensionAPI { + getAPI(context) { + // TODO - Bug 1448878: retrieve a more detailed callerInfo object, + // like the filename and lineNumber of the actual extension called + // in the child process. + const callerInfo = { + addonId: context.extension.id, + url: context.extension.baseURI.spec, + }; + + // An incremental "per context" id used in the generated devtools panel id. + let nextPanelId = 0; + + const toolboxSelectionObserver = new DevToolsSelectionObserver(context); + + function newBasePanelId() { + return `${context.extension.id}-${context.contextId}-${nextPanelId++}`; + } + + return { + devtools: { + panels: { + elements: { + onSelectionChanged: new EventManager({ + context, + name: "devtools.panels.elements.onSelectionChanged", + register: fire => { + const listener = eventName => { + fire.async(); + }; + toolboxSelectionObserver.on("selectionChanged", listener); + return () => { + toolboxSelectionObserver.off("selectionChanged", listener); + }; + }, + }).api(), + createSidebarPane(title) { + const id = `devtools-inspector-sidebar-${makeWidgetId( + newBasePanelId() + )}`; + + const parentSidebar = new ParentDevToolsInspectorSidebar( + context, + { title, id } + ); + sidebarsById.set(id, parentSidebar); + + context.callOnClose({ + close() { + sidebarsById.delete(id); + }, + }); + + // Resolved to the devtools sidebar id into the child addon process, + // where it will be used to identify the messages related + // to the panel API onShown/onHidden events. + return Promise.resolve(id); + }, + // The following methods are used internally to allow the sidebar API + // piece that is running in the child process to asks the parent process + // to execute the sidebar methods. + Sidebar: { + setPage(sidebarId, extensionPageURL) { + const sidebar = sidebarsById.get(sidebarId); + return sidebar.setPage(extensionPageURL); + }, + setObject(sidebarId, jsonObject, rootTitle) { + const sidebar = sidebarsById.get(sidebarId); + return sidebar.setObject(jsonObject, rootTitle); + }, + async setExpression(sidebarId, evalExpression, rootTitle) { + const sidebar = sidebarsById.get(sidebarId); + + const toolboxEvalOptions = await getToolboxEvalOptions(context); + + const commands = await context.getDevToolsCommands(); + const target = commands.targetCommand.targetFront; + const consoleFront = await target.getFront("console"); + toolboxEvalOptions.consoleFront = consoleFront; + + const evalResult = await commands.inspectedWindowCommand.eval( + callerInfo, + evalExpression, + toolboxEvalOptions + ); + + let jsonObject; + + if (evalResult.exceptionInfo) { + jsonObject = evalResult.exceptionInfo; + + return sidebar.setObject(jsonObject, rootTitle); + } + + return sidebar.setExpressionResult(evalResult, rootTitle); + }, + }, + }, + create(title, icon, url) { + // Get a fallback icon from the manifest data. + if (icon === "") { + icon = context.extension.getPreferredIcon(128); + } + + icon = context.extension.baseURI.resolve(icon); + url = context.extension.baseURI.resolve(url); + + const id = `webext-devtools-panel-${makeWidgetId( + newBasePanelId() + )}`; + + new ParentDevToolsPanel(context, { title, icon, url, id }); + + // Resolved to the devtools panel id into the child addon process, + // where it will be used to identify the messages related + // to the panel API onShown/onHidden events. + return Promise.resolve(id); + }, + }, + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-devtools.js b/browser/components/extensions/parent/ext-devtools.js new file mode 100644 index 0000000000..98efd25489 --- /dev/null +++ b/browser/components/extensions/parent/ext-devtools.js @@ -0,0 +1,510 @@ +/* -*- 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 module provides helpers used by the other specialized `ext-devtools-*.js` modules + * and the implementation of the `devtools_page`. + */ + +ChromeUtils.defineESModuleGetters(this, { + DevToolsShim: "chrome://devtools-startup/content/DevToolsShim.sys.mjs", +}); + +var { ExtensionParent } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionParent.sys.mjs" +); + +var { HiddenExtensionPage, watchExtensionProxyContextLoad } = ExtensionParent; + +// Get the devtools preference given the extension id. +function getDevToolsPrefBranchName(extensionId) { + return `devtools.webextensions.${extensionId}`; +} + +/** + * Retrieve the tabId for the given devtools toolbox. + * + * @param {Toolbox} toolbox + * A devtools toolbox instance. + * + * @returns {number} + * The corresponding WebExtensions tabId. + */ +global.getTargetTabIdForToolbox = toolbox => { + let { descriptorFront } = toolbox.commands; + + if (!descriptorFront.isLocalTab) { + throw new Error( + "Unexpected target type: only local tabs are currently supported." + ); + } + + let parentWindow = descriptorFront.localTab.linkedBrowser.ownerGlobal; + let tab = parentWindow.gBrowser.getTabForBrowser( + descriptorFront.localTab.linkedBrowser + ); + + return tabTracker.getId(tab); +}; + +// Get the WebExtensionInspectedWindowActor eval options (needed to provide the $0 and inspect +// binding provided to the evaluated js code). +global.getToolboxEvalOptions = async function (context) { + const options = {}; + const toolbox = context.devToolsToolbox; + const selectedNode = toolbox.selection; + + if (selectedNode && selectedNode.nodeFront) { + // If there is a selected node in the inspector, we hand over + // its actor id to the eval request in order to provide the "$0" binding. + options.toolboxSelectedNodeActorID = selectedNode.nodeFront.actorID; + } + + // Provide the console actor ID to implement the "inspect" binding. + const consoleFront = await toolbox.target.getFront("console"); + options.toolboxConsoleActorID = consoleFront.actor; + + return options; +}; + +/** + * The DevToolsPage represents the "devtools_page" related to a particular + * Toolbox and WebExtension. + * + * The devtools_page contexts are invisible WebExtensions contexts, similar to the + * background page, associated to a single developer toolbox (e.g. If an add-on + * registers a devtools_page and the user opens 3 developer toolbox in 3 webpages, + * 3 devtools_page contexts will be created for that add-on). + * + * @param {Extension} extension + * The extension that owns the devtools_page. + * @param {object} options + * @param {Toolbox} options.toolbox + * The developer toolbox instance related to this devtools_page. + * @param {string} options.url + * The path to the devtools page html page relative to the extension base URL. + * @param {DevToolsPageDefinition} options.devToolsPageDefinition + * The instance of the devToolsPageDefinition class related to this DevToolsPage. + */ +class DevToolsPage extends HiddenExtensionPage { + constructor(extension, options) { + super(extension, "devtools_page"); + + this.url = extension.baseURI.resolve(options.url); + this.toolbox = options.toolbox; + this.devToolsPageDefinition = options.devToolsPageDefinition; + + this.unwatchExtensionProxyContextLoad = null; + + this.waitForTopLevelContext = new Promise(resolve => { + this.resolveTopLevelContext = resolve; + }); + } + + async build() { + await this.createBrowserElement(); + + // Listening to new proxy contexts. + this.unwatchExtensionProxyContextLoad = watchExtensionProxyContextLoad( + this, + context => { + // Keep track of the toolbox and target associated to the context, which is + // needed by the API methods implementation. + context.devToolsToolbox = this.toolbox; + + if (!this.topLevelContext) { + this.topLevelContext = context; + + // Ensure this devtools page is destroyed, when the top level context proxy is + // closed. + this.topLevelContext.callOnClose(this); + + this.resolveTopLevelContext(context); + } + } + ); + + extensions.emit("extension-browser-inserted", this.browser, { + devtoolsToolboxInfo: { + inspectedWindowTabId: getTargetTabIdForToolbox(this.toolbox), + themeName: DevToolsShim.getTheme(), + }, + }); + + this.browser.fixupAndLoadURIString(this.url, { + triggeringPrincipal: this.extension.principal, + }); + + await this.waitForTopLevelContext; + } + + close() { + if (this.closed) { + throw new Error("Unable to shutdown a closed DevToolsPage instance"); + } + + this.closed = true; + + // Unregister the devtools page instance from the devtools page definition. + this.devToolsPageDefinition.forgetForToolbox(this.toolbox); + + // Unregister it from the resources to cleanup when the context has been closed. + if (this.topLevelContext) { + this.topLevelContext.forgetOnClose(this); + } + + // Stop watching for any new proxy contexts from the devtools page. + if (this.unwatchExtensionProxyContextLoad) { + this.unwatchExtensionProxyContextLoad(); + this.unwatchExtensionProxyContextLoad = null; + } + + super.shutdown(); + } +} + +/** + * The DevToolsPageDefinitions class represents the "devtools_page" manifest property + * of a WebExtension. + * + * A DevToolsPageDefinition instance is created automatically when a WebExtension + * which contains the "devtools_page" manifest property has been loaded, and it is + * automatically destroyed when the related WebExtension has been unloaded, + * and so there will be at most one DevtoolsPageDefinition per add-on. + * + * Every time a developer tools toolbox is opened, the DevToolsPageDefinition creates + * and keep track of a DevToolsPage instance (which represents the actual devtools_page + * instance related to that particular toolbox). + * + * @param {Extension} extension + * The extension that owns the devtools_page. + * @param {string} url + * The path to the devtools page html page relative to the extension base URL. + */ +class DevToolsPageDefinition { + constructor(extension, url) { + this.url = url; + this.extension = extension; + + // Map[Toolbox -> DevToolsPage] + this.devtoolsPageForToolbox = new Map(); + } + + onThemeChanged(themeName) { + Services.ppmm.broadcastAsyncMessage("Extension:DevToolsThemeChanged", { + themeName, + }); + } + + buildForToolbox(toolbox) { + if ( + !this.extension.canAccessWindow( + toolbox.commands.descriptorFront.localTab.ownerGlobal + ) + ) { + // We should never create a devtools page for a toolbox related to a private browsing window + // if the extension is not allowed to access it. + return; + } + + if (this.devtoolsPageForToolbox.has(toolbox)) { + return Promise.reject( + new Error("DevtoolsPage has been already created for this toolbox") + ); + } + + const devtoolsPage = new DevToolsPage(this.extension, { + toolbox, + url: this.url, + devToolsPageDefinition: this, + }); + + // If this is the first DevToolsPage, subscribe to the theme-changed event + if (this.devtoolsPageForToolbox.size === 0) { + DevToolsShim.on("theme-changed", this.onThemeChanged); + } + this.devtoolsPageForToolbox.set(toolbox, devtoolsPage); + + return devtoolsPage.build(); + } + + shutdownForToolbox(toolbox) { + if (this.devtoolsPageForToolbox.has(toolbox)) { + const devtoolsPage = this.devtoolsPageForToolbox.get(toolbox); + devtoolsPage.close(); + + // `devtoolsPage.close()` should remove the instance from the map, + // raise an exception if it is still there. + if (this.devtoolsPageForToolbox.has(toolbox)) { + throw new Error( + `Leaked DevToolsPage instance for target "${toolbox.commands.descriptorFront.url}", extension "${this.extension.policy.debugName}"` + ); + } + + // If this was the last DevToolsPage, unsubscribe from the theme-changed event + if (this.devtoolsPageForToolbox.size === 0) { + DevToolsShim.off("theme-changed", this.onThemeChanged); + } + this.extension.emit("devtools-page-shutdown", toolbox); + } + } + + forgetForToolbox(toolbox) { + this.devtoolsPageForToolbox.delete(toolbox); + } + + /** + * Build the devtools_page instances for all the existing toolboxes + * (if the toolbox target is supported). + */ + build() { + // Iterate over the existing toolboxes and create the devtools page for them + // (if the toolbox target is supported). + for (let toolbox of DevToolsShim.getToolboxes()) { + if ( + !toolbox.commands.descriptorFront.isLocalTab || + !this.extension.canAccessWindow( + toolbox.commands.descriptorFront.localTab.ownerGlobal + ) + ) { + // Skip any non-local tab and private browsing windows if the extension + // is not allowed to access them. + continue; + } + + // Ensure that the WebExtension is listed in the toolbox options. + toolbox.registerWebExtension(this.extension.uuid, { + name: this.extension.name, + pref: `${getDevToolsPrefBranchName(this.extension.id)}.enabled`, + }); + + this.buildForToolbox(toolbox); + } + } + + /** + * Shutdown all the devtools_page instances. + */ + shutdown() { + for (let toolbox of this.devtoolsPageForToolbox.keys()) { + this.shutdownForToolbox(toolbox); + } + + if (this.devtoolsPageForToolbox.size > 0) { + throw new Error( + `Leaked ${this.devtoolsPageForToolbox.size} DevToolsPage instances in devtoolsPageForToolbox Map` + ); + } + } +} + +this.devtools = class extends ExtensionAPI { + constructor(extension) { + super(extension); + + this._initialized = false; + + // DevToolsPageDefinition instance (created in onManifestEntry). + this.pageDefinition = null; + + this.onToolboxReady = this.onToolboxReady.bind(this); + this.onToolboxDestroy = this.onToolboxDestroy.bind(this); + + /* eslint-disable mozilla/balanced-listeners */ + extension.on("add-permissions", (ignoreEvent, permissions) => { + if (permissions.permissions.includes("devtools")) { + Services.prefs.setBoolPref( + `${getDevToolsPrefBranchName(extension.id)}.enabled`, + true + ); + + this._initialize(); + } + }); + + extension.on("remove-permissions", (ignoreEvent, permissions) => { + if (permissions.permissions.includes("devtools")) { + Services.prefs.setBoolPref( + `${getDevToolsPrefBranchName(extension.id)}.enabled`, + false + ); + + this._uninitialize(); + } + }); + } + + onManifestEntry() { + this._initialize(); + } + + static onUninstall(extensionId) { + // Remove the preference branch on uninstall. + const prefBranch = Services.prefs.getBranch( + `${getDevToolsPrefBranchName(extensionId)}.` + ); + + prefBranch.deleteBranch(""); + } + + _initialize() { + const { extension } = this; + + if (!extension.hasPermission("devtools") || this._initialized) { + return; + } + + this.initDevToolsPref(); + + // Create the devtools_page definition. + this.pageDefinition = new DevToolsPageDefinition( + extension, + extension.manifest.devtools_page + ); + + // Build the extension devtools_page on all existing toolboxes (if the extension + // devtools_page is not disabled by the related preference). + if (!this.isDevToolsPageDisabled()) { + this.pageDefinition.build(); + } + + DevToolsShim.on("toolbox-ready", this.onToolboxReady); + DevToolsShim.on("toolbox-destroy", this.onToolboxDestroy); + this._initialized = true; + } + + _uninitialize() { + // devtoolsPrefBranch is set in onManifestEntry, and nullified + // later in onShutdown. If it isn't set, then onManifestEntry + // did not initialize devtools for the extension. + if (!this._initialized) { + return; + } + + DevToolsShim.off("toolbox-ready", this.onToolboxReady); + DevToolsShim.off("toolbox-destroy", this.onToolboxDestroy); + + // Shutdown the extension devtools_page from all existing toolboxes. + this.pageDefinition.shutdown(); + this.pageDefinition = null; + + // Iterate over the existing toolboxes and unlist the devtools webextension from them. + for (let toolbox of DevToolsShim.getToolboxes()) { + toolbox.unregisterWebExtension(this.extension.uuid); + } + + this.uninitDevToolsPref(); + this._initialized = false; + } + + onShutdown() { + this._uninitialize(); + } + + getAPI(context) { + return { + devtools: {}, + }; + } + + onToolboxReady(toolbox) { + if ( + !toolbox.commands.descriptorFront.isLocalTab || + !this.extension.canAccessWindow( + toolbox.commands.descriptorFront.localTab.ownerGlobal + ) + ) { + // Skip any non-local (as remote tabs are not yet supported, see Bug 1304378 for additional details + // related to remote targets support), and private browsing windows if the extension + // is not allowed to access them. + return; + } + + // Ensure that the WebExtension is listed in the toolbox options. + toolbox.registerWebExtension(this.extension.uuid, { + name: this.extension.name, + pref: `${getDevToolsPrefBranchName(this.extension.id)}.enabled`, + }); + + // Do not build the devtools page if the extension has been disabled + // (e.g. based on the devtools preference). + if (toolbox.isWebExtensionEnabled(this.extension.uuid)) { + this.pageDefinition.buildForToolbox(toolbox); + } + } + + onToolboxDestroy(toolbox) { + if (!toolbox.commands.descriptorFront.isLocalTab) { + // Only local tabs are currently supported (See Bug 1304378 for additional details + // related to remote targets support). + return; + } + + this.pageDefinition.shutdownForToolbox(toolbox); + } + + /** + * Initialize the DevTools preferences branch for the extension and + * start to observe it for changes on the "enabled" preference. + */ + initDevToolsPref() { + const prefBranch = Services.prefs.getBranch( + `${getDevToolsPrefBranchName(this.extension.id)}.` + ); + + // Initialize the devtools extension preference if it doesn't exist yet. + if (prefBranch.getPrefType("enabled") === prefBranch.PREF_INVALID) { + prefBranch.setBoolPref("enabled", true); + } + + this.devtoolsPrefBranch = prefBranch; + this.devtoolsPrefBranch.addObserver("enabled", this); + } + + /** + * Stop from observing the DevTools preferences branch for the extension. + */ + uninitDevToolsPref() { + this.devtoolsPrefBranch.removeObserver("enabled", this); + this.devtoolsPrefBranch = null; + } + + /** + * Test if the extension's devtools_page has been disabled using the + * DevTools preference. + * + * @returns {boolean} + * true if the devtools_page for this extension is disabled. + */ + isDevToolsPageDisabled() { + return !this.devtoolsPrefBranch.getBoolPref("enabled", false); + } + + /** + * Observes the changed preferences on the DevTools preferences branch + * related to the extension. + * + * @param {nsIPrefBranch} subject The observed preferences branch. + * @param {string} topic The notified topic. + * @param {string} prefName The changed preference name. + */ + observe(subject, topic, prefName) { + // We are currently interested only in the "enabled" preference from the + // WebExtension devtools preferences branch. + if (subject !== this.devtoolsPrefBranch || prefName !== "enabled") { + return; + } + + // Shutdown or build the devtools_page on any existing toolbox. + if (this.isDevToolsPageDisabled()) { + this.pageDefinition.shutdown(); + } else { + this.pageDefinition.build(); + } + } +}; diff --git a/browser/components/extensions/parent/ext-find.js b/browser/components/extensions/parent/ext-find.js new file mode 100644 index 0000000000..5397caa85b --- /dev/null +++ b/browser/components/extensions/parent/ext-find.js @@ -0,0 +1,272 @@ +/* -*- 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/. */ + +/* global tabTracker */ +"use strict"; + +ChromeUtils.defineESModuleGetters(this, { + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", +}); + +var { ExtensionError } = ExtensionUtils; + +// A mapping of top-level ExtFind actors to arrays of results in each subframe. +let findResults = new WeakMap(); + +function getActorForBrowsingContext(browsingContext) { + let windowGlobal = browsingContext.currentWindowGlobal; + return windowGlobal ? windowGlobal.getActor("ExtFind") : null; +} + +function getTopLevelActor(browser) { + return getActorForBrowsingContext(browser.browsingContext); +} + +function gatherActors(browsingContext) { + let list = []; + + let actor = getActorForBrowsingContext(browsingContext); + if (actor) { + list.push({ actor, result: null }); + } + + let children = browsingContext.children; + for (let child of children) { + list.push(...gatherActors(child)); + } + + return list; +} + +function mergeFindResults(params, list) { + let finalResult = { + count: 0, + }; + + if (params.includeRangeData) { + finalResult.rangeData = []; + } + if (params.includeRectData) { + finalResult.rectData = []; + } + + let currentFramePos = -1; + for (let item of list) { + if (item.result.count == 0) { + continue; + } + + // The framePos is incremented for each different document that has matches. + currentFramePos++; + + finalResult.count += item.result.count; + if (params.includeRangeData && item.result.rangeData) { + for (let range of item.result.rangeData) { + range.framePos = currentFramePos; + } + + finalResult.rangeData.push(...item.result.rangeData); + } + + if (params.includeRectData && item.result.rectData) { + finalResult.rectData.push(...item.result.rectData); + } + } + + return finalResult; +} + +function sendMessageToAllActors(browser, message, params) { + for (let { actor } of gatherActors(browser.browsingContext)) { + actor.sendAsyncMessage("ext-Finder:" + message, params); + } +} + +async function getFindResultsForActor(findContext, message, params) { + findContext.result = await findContext.actor.sendQuery( + "ext-Finder:" + message, + params + ); + return findContext; +} + +function queryAllActors(browser, message, params) { + let promises = []; + for (let findContext of gatherActors(browser.browsingContext)) { + promises.push(getFindResultsForActor(findContext, message, params)); + } + return Promise.all(promises); +} + +async function collectFindResults(browser, findResults, params) { + let results = await queryAllActors(browser, "CollectResults", params); + findResults.set(getTopLevelActor(browser), results); + return mergeFindResults(params, results); +} + +async function runHighlight(browser, params) { + let hasResults = false; + let foundResults = false; + let list = findResults.get(getTopLevelActor(browser)); + if (!list) { + return Promise.reject({ message: "no search results to highlight" }); + } + + let highlightPromises = []; + + let index = params.rangeIndex; + const highlightAll = typeof index != "number"; + + for (let c = 0; c < list.length; c++) { + if (list[c].result.count) { + hasResults = true; + } + + let actor = list[c].actor; + if (highlightAll) { + // Highlight all ranges. + highlightPromises.push( + actor.sendQuery("ext-Finder:HighlightResults", params) + ); + } else if (!foundResults && index < list[c].result.count) { + foundResults = true; + params.rangeIndex = index; + highlightPromises.push( + actor.sendQuery("ext-Finder:HighlightResults", params) + ); + } else { + highlightPromises.push( + actor.sendQuery("ext-Finder:ClearHighlighting", params) + ); + } + + index -= list[c].result.count; + } + + let responses = await Promise.all(highlightPromises); + if (hasResults) { + if (responses.includes("OutOfRange") || index >= 0) { + return Promise.reject({ message: "index supplied was out of range" }); + } else if (responses.includes("Success")) { + return; + } + } + + return Promise.reject({ message: "no search results to highlight" }); +} + +/** + * runFindOperation + * Utility for `find` and `highlightResults`. + * + * @param {BaseContext} context - context the find operation runs in. + * @param {object} params - params to pass to message sender. + * @param {string} message - identifying component of message name. + * + * @returns {Promise} a promise that will be resolved or rejected based on the + * data received by the message listener. + */ +function runFindOperation(context, params, message) { + let { tabId } = params; + let tab = tabId ? tabTracker.getTab(tabId) : tabTracker.activeTab; + let browser = tab.linkedBrowser; + tabId = tabId || tabTracker.getId(tab); + if ( + !context.privateBrowsingAllowed && + PrivateBrowsingUtils.isBrowserPrivate(browser) + ) { + return Promise.reject({ message: `Unable to search: ${tabId}` }); + } + // We disallow find in about: urls. + if ( + tab.linkedBrowser.contentPrincipal.isSystemPrincipal || + (["about", "chrome", "resource"].includes( + tab.linkedBrowser.currentURI.scheme + ) && + tab.linkedBrowser.currentURI.spec != "about:blank") + ) { + return Promise.reject({ message: `Unable to search: ${tabId}` }); + } + + if (message == "HighlightResults") { + return runHighlight(browser, params); + } else if (message == "CollectResults") { + // Remove prior highlights before starting a new find operation. + findResults.delete(getTopLevelActor(browser)); + return collectFindResults(browser, findResults, params); + } +} + +this.find = class extends ExtensionAPI { + getAPI(context) { + return { + find: { + /** + * browser.find.find + * Searches document and its frames for a given queryphrase and stores all found + * Range objects in an array accessible by other browser.find methods. + * + * @param {string} queryphrase - The string to search for. + * @param {object} params optional - may contain any of the following properties, + * all of which are optional: + * {number} tabId - Tab to query. Defaults to the active tab. + * {boolean} caseSensitive - Highlight only ranges with case sensitive match. + * {boolean} entireWord - Highlight only ranges that match entire word. + * {boolean} includeRangeData - Whether to return range data. + * {boolean} includeRectData - Whether to return rectangle data. + * + * @returns {object} data received by the message listener that includes: + * {number} count - number of results found. + * {array} rangeData (if opted) - serialized representation of ranges found. + * {array} rectData (if opted) - rect data of ranges found. + */ + find(queryphrase, params) { + params = params || {}; + params.queryphrase = queryphrase; + return runFindOperation(context, params, "CollectResults"); + }, + + /** + * browser.find.highlightResults + * Highlights range(s) found in previous browser.find.find. + * + * @param {object} params optional - may contain any of the following properties, + * all of which are optional: + * {number} rangeIndex - Found range to be highlighted. Default highlights all ranges. + * {number} tabId - Tab to highlight. Defaults to the active tab. + * {boolean} noScroll - Don't scroll to highlighted item. + * + * @returns {string} - data received by the message listener that may be: + * "Success" - Highlighting succeeded. + * "OutOfRange" - The index supplied was out of range. + * "NoResults" - There were no search results to highlight. + */ + highlightResults(params) { + params = params || {}; + return runFindOperation(context, params, "HighlightResults"); + }, + + /** + * browser.find.removeHighlighting + * Removes all highlighting from previous search. + * + * @param {number} tabId optional + * Tab to clear highlighting in. Defaults to the active tab. + */ + removeHighlighting(tabId) { + let tab = tabId ? tabTracker.getTab(tabId) : tabTracker.activeTab; + if ( + !context.privateBrowsingAllowed && + PrivateBrowsingUtils.isBrowserPrivate(tab.linkedBrowser) + ) { + throw new ExtensionError(`Invalid tab ID: ${tabId}`); + } + sendMessageToAllActors(tab.linkedBrowser, "ClearHighlighting", {}); + }, + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-history.js b/browser/components/extensions/parent/ext-history.js new file mode 100644 index 0000000000..b7e24aecaa --- /dev/null +++ b/browser/components/extensions/parent/ext-history.js @@ -0,0 +1,326 @@ +/* -*- 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.defineESModuleGetters(this, { + PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs", +}); + +var { normalizeTime } = ExtensionCommon; + +let nsINavHistoryService = Ci.nsINavHistoryService; +const TRANSITION_TO_TRANSITION_TYPES_MAP = new Map([ + ["link", nsINavHistoryService.TRANSITION_LINK], + ["typed", nsINavHistoryService.TRANSITION_TYPED], + ["auto_bookmark", nsINavHistoryService.TRANSITION_BOOKMARK], + ["auto_subframe", nsINavHistoryService.TRANSITION_EMBED], + ["manual_subframe", nsINavHistoryService.TRANSITION_FRAMED_LINK], + ["reload", nsINavHistoryService.TRANSITION_RELOAD], +]); + +let TRANSITION_TYPE_TO_TRANSITIONS_MAP = new Map(); +for (let [transition, transitionType] of TRANSITION_TO_TRANSITION_TYPES_MAP) { + TRANSITION_TYPE_TO_TRANSITIONS_MAP.set(transitionType, transition); +} + +const getTransitionType = transition => { + // cannot set a default value for the transition argument as the framework sets it to null + transition = transition || "link"; + let transitionType = TRANSITION_TO_TRANSITION_TYPES_MAP.get(transition); + if (!transitionType) { + throw new Error( + `|${transition}| is not a supported transition for history` + ); + } + return transitionType; +}; + +const getTransition = transitionType => { + return TRANSITION_TYPE_TO_TRANSITIONS_MAP.get(transitionType) || "link"; +}; + +/* + * Converts a mozIStorageRow into a HistoryItem + */ +const convertRowToHistoryItem = row => { + return { + id: row.getResultByName("guid"), + url: row.getResultByName("url"), + title: row.getResultByName("page_title"), + lastVisitTime: PlacesUtils.toDate( + row.getResultByName("last_visit_date") + ).getTime(), + visitCount: row.getResultByName("visit_count"), + }; +}; + +/* + * Converts a mozIStorageRow into a VisitItem + */ +const convertRowToVisitItem = row => { + return { + id: row.getResultByName("guid"), + visitId: String(row.getResultByName("id")), + visitTime: PlacesUtils.toDate(row.getResultByName("visit_date")).getTime(), + referringVisitId: String(row.getResultByName("from_visit")), + transition: getTransition(row.getResultByName("visit_type")), + }; +}; + +/* + * Converts a mozIStorageResultSet into an array of objects + */ +const accumulateNavHistoryResults = (resultSet, converter, results) => { + let row; + while ((row = resultSet.getNextRow())) { + results.push(converter(row)); + } +}; + +function executeAsyncQuery(historyQuery, options, resultConverter) { + let results = []; + return new Promise((resolve, reject) => { + PlacesUtils.history.asyncExecuteLegacyQuery(historyQuery, options, { + handleResult(resultSet) { + accumulateNavHistoryResults(resultSet, resultConverter, results); + }, + handleError(error) { + reject( + new Error( + "Async execution error (" + error.result + "): " + error.message + ) + ); + }, + handleCompletion(reason) { + resolve(results); + }, + }); + }); +} + +this.history = class extends ExtensionAPIPersistent { + PERSISTENT_EVENTS = { + onVisited({ fire }) { + const listener = events => { + for (const event of events) { + const visit = { + id: event.pageGuid, + url: event.url, + title: event.lastKnownTitle || "", + lastVisitTime: event.visitTime, + visitCount: event.visitCount, + typedCount: event.typedCount, + }; + fire.sync(visit); + } + }; + + PlacesUtils.observers.addListener(["page-visited"], listener); + return { + unregister() { + PlacesUtils.observers.removeListener(["page-visited"], listener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + onVisitRemoved({ fire }) { + const listener = events => { + const removedURLs = []; + + for (const event of events) { + switch (event.type) { + case "history-cleared": { + fire.sync({ allHistory: true, urls: [] }); + break; + } + case "page-removed": { + if (!event.isPartialVisistsRemoval) { + removedURLs.push(event.url); + } + break; + } + } + } + + if (removedURLs.length) { + fire.sync({ allHistory: false, urls: removedURLs }); + } + }; + + PlacesUtils.observers.addListener( + ["history-cleared", "page-removed"], + listener + ); + return { + unregister() { + PlacesUtils.observers.removeListener( + ["history-cleared", "page-removed"], + listener + ); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + onTitleChanged({ fire }) { + const listener = events => { + for (const event of events) { + const titleChanged = { + id: event.pageGuid, + url: event.url, + title: event.title, + }; + fire.sync(titleChanged); + } + }; + + PlacesUtils.observers.addListener(["page-title-changed"], listener); + return { + unregister() { + PlacesUtils.observers.removeListener( + ["page-title-changed"], + listener + ); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + }; + + getAPI(context) { + return { + history: { + addUrl: function (details) { + let transition, date; + try { + transition = getTransitionType(details.transition); + } catch (error) { + return Promise.reject({ message: error.message }); + } + if (details.visitTime) { + date = normalizeTime(details.visitTime); + } + let pageInfo = { + title: details.title, + url: details.url, + visits: [ + { + transition, + date, + }, + ], + }; + try { + return PlacesUtils.history.insert(pageInfo).then(() => undefined); + } catch (error) { + return Promise.reject({ message: error.message }); + } + }, + + deleteAll: function () { + return PlacesUtils.history.clear(); + }, + + deleteRange: function (filter) { + let newFilter = { + beginDate: normalizeTime(filter.startTime), + endDate: normalizeTime(filter.endTime), + }; + // History.removeVisitsByFilter returns a boolean, but our API should return nothing + return PlacesUtils.history + .removeVisitsByFilter(newFilter) + .then(() => undefined); + }, + + deleteUrl: function (details) { + let url = details.url; + // History.remove returns a boolean, but our API should return nothing + return PlacesUtils.history.remove(url).then(() => undefined); + }, + + search: function (query) { + let beginTime = + query.startTime == null + ? PlacesUtils.toPRTime(Date.now() - 24 * 60 * 60 * 1000) + : PlacesUtils.toPRTime(normalizeTime(query.startTime)); + let endTime = + query.endTime == null + ? Number.MAX_VALUE + : PlacesUtils.toPRTime(normalizeTime(query.endTime)); + if (beginTime > endTime) { + return Promise.reject({ + message: "The startTime cannot be after the endTime", + }); + } + + let options = PlacesUtils.history.getNewQueryOptions(); + options.includeHidden = true; + options.sortingMode = options.SORT_BY_DATE_DESCENDING; + options.maxResults = query.maxResults || 100; + + let historyQuery = PlacesUtils.history.getNewQuery(); + historyQuery.searchTerms = query.text; + historyQuery.beginTime = beginTime; + historyQuery.endTime = endTime; + return executeAsyncQuery( + historyQuery, + options, + convertRowToHistoryItem + ); + }, + + getVisits: function (details) { + let url = details.url; + if (!url) { + return Promise.reject({ + message: "A URL must be provided for getVisits", + }); + } + + let options = PlacesUtils.history.getNewQueryOptions(); + options.includeHidden = true; + options.sortingMode = options.SORT_BY_DATE_DESCENDING; + options.resultType = options.RESULTS_AS_VISIT; + + let historyQuery = PlacesUtils.history.getNewQuery(); + historyQuery.uri = Services.io.newURI(url); + return executeAsyncQuery( + historyQuery, + options, + convertRowToVisitItem + ); + }, + + onVisited: new EventManager({ + context, + module: "history", + event: "onVisited", + extensionApi: this, + }).api(), + + onVisitRemoved: new EventManager({ + context, + module: "history", + event: "onVisitRemoved", + extensionApi: this, + }).api(), + + onTitleChanged: new EventManager({ + context, + module: "history", + event: "onTitleChanged", + extensionApi: this, + }).api(), + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-menus.js b/browser/components/extensions/parent/ext-menus.js new file mode 100644 index 0000000000..74ce398b48 --- /dev/null +++ b/browser/components/extensions/parent/ext-menus.js @@ -0,0 +1,1471 @@ +/* -*- 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.defineESModuleGetters(this, { + PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", +}); + +var { DefaultMap, ExtensionError, parseMatchPatterns } = ExtensionUtils; + +var { ExtensionParent } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionParent.sys.mjs" +); + +var { IconDetails, StartupCache } = ExtensionParent; + +const ACTION_MENU_TOP_LEVEL_LIMIT = 6; + +// Map[Extension -> Map[ID -> MenuItem]] +// Note: we want to enumerate all the menu items so +// this cannot be a weak map. +var gMenuMap = new Map(); + +// Map[Extension -> Map[ID -> MenuCreateProperties]] +// The map object for each extension is a reference to the same +// object in StartupCache.menus. This provides a non-async +// getter for that object. +var gStartupCache = new Map(); + +// Map[Extension -> MenuItem] +var gRootItems = new Map(); + +// Map[Extension -> ID[]] +// Menu IDs that were eligible for being shown in the current menu. +var gShownMenuItems = new DefaultMap(() => []); + +// Map[Extension -> Set[Contexts]] +// A DefaultMap (keyed by extension) which keeps track of the +// contexts with a subscribed onShown event listener. +var gOnShownSubscribers = new DefaultMap(() => new Set()); + +// If id is not specified for an item we use an integer. +var gNextMenuItemID = 0; + +// Used to assign unique names to radio groups. +var gNextRadioGroupID = 0; + +// The max length of a menu item's label. +var gMaxLabelLength = 64; + +var gMenuBuilder = { + // When a new menu is opened, this function is called and + // we populate the |xulMenu| with all the items from extensions + // to be displayed. We always clear all the items again when + // popuphidden fires. + build(contextData) { + contextData = this.maybeOverrideContextData(contextData); + let xulMenu = contextData.menu; + xulMenu.addEventListener("popuphidden", this); + this.xulMenu = xulMenu; + for (let [, root] of gRootItems) { + this.createAndInsertTopLevelElements(root, contextData, null); + } + this.afterBuildingMenu(contextData); + + if ( + contextData.webExtContextData && + !contextData.webExtContextData.showDefaults + ) { + // Wait until nsContextMenu.js has toggled the visibility of the default + // menu items before hiding the default items. + Promise.resolve().then(() => this.hideDefaultMenuItems()); + } + }, + + maybeOverrideContextData(contextData) { + let { webExtContextData } = contextData; + if (!webExtContextData || !webExtContextData.overrideContext) { + return contextData; + } + let contextDataBase = { + menu: contextData.menu, + // eslint-disable-next-line no-use-before-define + originalViewType: getContextViewType(contextData), + originalViewUrl: contextData.inFrame + ? contextData.frameUrl + : contextData.pageUrl, + webExtContextData, + }; + if (webExtContextData.overrideContext === "bookmark") { + return { + ...contextDataBase, + bookmarkId: webExtContextData.bookmarkId, + onBookmark: true, + }; + } + if (webExtContextData.overrideContext === "tab") { + // TODO: Handle invalid tabs more gracefully (instead of throwing). + let tab = tabTracker.getTab(webExtContextData.tabId); + return { + ...contextDataBase, + tab, + pageUrl: tab.linkedBrowser.currentURI.spec, + onTab: true, + }; + } + throw new Error( + `Unexpected overrideContext: ${webExtContextData.overrideContext}` + ); + }, + + canAccessContext(extension, contextData) { + if (!extension.privateBrowsingAllowed) { + let nativeTab = contextData.tab; + if ( + nativeTab && + PrivateBrowsingUtils.isBrowserPrivate(nativeTab.linkedBrowser) + ) { + return false; + } else if ( + PrivateBrowsingUtils.isWindowPrivate(contextData.menu.ownerGlobal) + ) { + return false; + } + } + return true; + }, + + createAndInsertTopLevelElements(root, contextData, nextSibling) { + let rootElements; + if (!this.canAccessContext(root.extension, contextData)) { + return; + } + if ( + contextData.onAction || + contextData.onBrowserAction || + contextData.onPageAction + ) { + if (contextData.extension.id !== root.extension.id) { + return; + } + rootElements = this.buildTopLevelElements( + root, + contextData, + ACTION_MENU_TOP_LEVEL_LIMIT, + false + ); + + // Action menu items are prepended to the menu, followed by a separator. + nextSibling = nextSibling || this.xulMenu.firstElementChild; + if (rootElements.length && !this.itemsToCleanUp.has(nextSibling)) { + rootElements.push( + this.xulMenu.ownerDocument.createXULElement("menuseparator") + ); + } + } else if (contextData.webExtContextData) { + let { extensionId, showDefaults, overrideContext } = + contextData.webExtContextData; + if (extensionId === root.extension.id) { + rootElements = this.buildTopLevelElements( + root, + contextData, + Infinity, + false + ); + if (!nextSibling) { + // The extension menu should be rendered at the top. If we use + // a navigation group (on non-macOS), the extension menu should + // come after that to avoid styling issues. + if (AppConstants.platform == "macosx") { + nextSibling = this.xulMenu.firstElementChild; + } else { + nextSibling = this.xulMenu.querySelector( + ":scope > #context-sep-navigation + *" + ); + } + } + if ( + rootElements.length && + showDefaults && + !this.itemsToCleanUp.has(nextSibling) + ) { + rootElements.push( + this.xulMenu.ownerDocument.createXULElement("menuseparator") + ); + } + } else if (!showDefaults && !overrideContext) { + // When the default menu items should be hidden, menu items from other + // extensions should be hidden too. + return; + } + // Fall through to show default extension menu items. + } + if (!rootElements) { + rootElements = this.buildTopLevelElements(root, contextData, 1, true); + if ( + rootElements.length && + !this.itemsToCleanUp.has(this.xulMenu.lastElementChild) + ) { + // All extension menu items are appended at the end. + // Prepend separator if this is the first extension menu item. + rootElements.unshift( + this.xulMenu.ownerDocument.createXULElement("menuseparator") + ); + } + } + + if (!rootElements.length) { + return; + } + + if (nextSibling) { + nextSibling.before(...rootElements); + } else { + this.xulMenu.append(...rootElements); + } + for (let item of rootElements) { + this.itemsToCleanUp.add(item); + } + }, + + buildElementWithChildren(item, contextData) { + const element = this.buildSingleElement(item, contextData); + const children = this.buildChildren(item, contextData); + if (children.length) { + element.firstElementChild.append(...children); + } + return element; + }, + + buildChildren(item, contextData) { + let groupName; + let children = []; + for (let child of item.children) { + if (child.type == "radio" && !child.groupName) { + if (!groupName) { + groupName = `webext-radio-group-${gNextRadioGroupID++}`; + } + child.groupName = groupName; + } else { + groupName = null; + } + + if (child.enabledForContext(contextData)) { + children.push(this.buildElementWithChildren(child, contextData)); + } + } + return children; + }, + + buildTopLevelElements(root, contextData, maxCount, forceManifestIcons) { + let children = this.buildChildren(root, contextData); + + // TODO: Fix bug 1492969 and remove this whole if block. + if ( + children.length === 1 && + maxCount === 1 && + forceManifestIcons && + AppConstants.platform === "linux" && + children[0].getAttribute("type") === "checkbox" + ) { + // Keep single checkbox items in the submenu on Linux since + // the extension icon overlaps the checkbox otherwise. + maxCount = 0; + } + + if (children.length > maxCount) { + // Move excess items into submenu. + let rootElement = this.buildSingleElement(root, contextData); + rootElement.setAttribute("ext-type", "top-level-menu"); + rootElement.firstElementChild.append(...children.splice(maxCount - 1)); + children.push(rootElement); + } + + if (forceManifestIcons) { + for (let rootElement of children) { + // Display the extension icon on the root element. + if ( + root.extension.manifest.icons && + rootElement.getAttribute("type") !== "checkbox" + ) { + this.setMenuItemIcon( + rootElement, + root.extension, + contextData, + root.extension.manifest.icons + ); + } else { + this.removeMenuItemIcon(rootElement); + } + } + } + return children; + }, + + buildSingleElement(item, contextData) { + let doc = contextData.menu.ownerDocument; + let element; + if (item.children.length) { + element = this.createMenuElement(doc, item); + } else if (item.type == "separator") { + element = doc.createXULElement("menuseparator"); + } else { + element = doc.createXULElement("menuitem"); + } + + return this.customizeElement(element, item, contextData); + }, + + createMenuElement(doc, item) { + let element = doc.createXULElement("menu"); + // Menu elements need to have a menupopup child for its menu items. + let menupopup = doc.createXULElement("menupopup"); + element.appendChild(menupopup); + return element; + }, + + customizeElement(element, item, contextData) { + let label = item.title; + if (label) { + let accessKey; + label = label.replace(/&([\S\s]|$)/g, (_, nextChar, i) => { + if (nextChar === "&") { + return "&"; + } + if (accessKey === undefined) { + if (nextChar === "%" && label.charAt(i + 2) === "s") { + accessKey = ""; + } else { + accessKey = nextChar; + } + } + return nextChar; + }); + element.setAttribute("accesskey", accessKey || ""); + + if (contextData.isTextSelected && label.indexOf("%s") > -1) { + let selection = contextData.selectionText.trim(); + // The rendering engine will truncate the title if it's longer than 64 characters. + // But if it makes sense let's try truncate selection text only, to handle cases like + // 'look up "%s" in MyDictionary' more elegantly. + + let codePointsToRemove = 0; + + let selectionArray = Array.from(selection); + + let completeLabelLength = label.length - 2 + selectionArray.length; + if (completeLabelLength > gMaxLabelLength) { + codePointsToRemove = completeLabelLength - gMaxLabelLength; + } + + if (codePointsToRemove) { + let ellipsis = "\u2026"; + try { + ellipsis = Services.prefs.getComplexValue( + "intl.ellipsis", + Ci.nsIPrefLocalizedString + ).data; + } catch (e) {} + codePointsToRemove += 1; + selection = + selectionArray.slice(0, -codePointsToRemove).join("") + ellipsis; + } + + label = label.replace(/%s/g, selection); + } + + element.setAttribute("label", label); + } + + element.setAttribute("id", item.elementId); + + if ("icons" in item) { + if (item.icons) { + this.setMenuItemIcon(element, item.extension, contextData, item.icons); + } else { + this.removeMenuItemIcon(element); + } + } + + if (item.type == "checkbox") { + element.setAttribute("type", "checkbox"); + if (item.checked) { + element.setAttribute("checked", "true"); + } + } else if (item.type == "radio") { + element.setAttribute("type", "radio"); + element.setAttribute("name", item.groupName); + if (item.checked) { + element.setAttribute("checked", "true"); + } + } + + if (!item.enabled) { + element.setAttribute("disabled", "true"); + } + + element.addEventListener( + "command", + event => { + if (event.target !== event.currentTarget) { + return; + } + const wasChecked = item.checked; + if (item.type == "checkbox") { + item.checked = !item.checked; + } else if (item.type == "radio") { + // Deselect all radio items in the current radio group. + for (let child of item.parent.children) { + if (child.type == "radio" && child.groupName == item.groupName) { + child.checked = false; + } + } + // Select the clicked radio item. + item.checked = true; + } + + let { webExtContextData } = contextData; + if ( + contextData.tab && + // If the menu context was overridden by the extension, do not grant + // activeTab since the extension also controls the tabId. + (!webExtContextData || + webExtContextData.extensionId !== item.extension.id) + ) { + item.tabManager.addActiveTabPermission(contextData.tab); + } + + let info = item.getClickInfo(contextData, wasChecked); + info.modifiers = clickModifiersFromEvent(event); + + info.button = event.button; + + let _execute_action = + item.extension.manifestVersion < 3 + ? "_execute_browser_action" + : "_execute_action"; + + // Allow menus to open various actions supported in webext prior + // to notifying onclicked. + let actionFor = { + [_execute_action]: global.browserActionFor, + _execute_page_action: global.pageActionFor, + _execute_sidebar_action: global.sidebarActionFor, + }[item.command]; + if (actionFor) { + let win = event.target.ownerGlobal; + actionFor(item.extension).triggerAction(win); + return; + } + + item.extension.emit( + "webext-menu-menuitem-click", + info, + contextData.tab + ); + }, + { once: true } + ); + + // Don't publish the ID of the root because the root element is + // auto-generated. + if (item.parent) { + gShownMenuItems.get(item.extension).push(item.id); + } + + return element; + }, + + setMenuItemIcon(element, extension, contextData, icons) { + let parentWindow = contextData.menu.ownerGlobal; + + let { icon } = IconDetails.getPreferredIcon( + icons, + extension, + 16 * parentWindow.devicePixelRatio + ); + + // The extension icons in the manifest are not pre-resolved, since + // they're sometimes used by the add-on manager when the extension is + // not enabled, and its URLs are not resolvable. + let resolvedURL = extension.baseURI.resolve(icon); + + if (element.localName == "menu") { + element.setAttribute("class", "menu-iconic"); + } else if (element.localName == "menuitem") { + element.setAttribute("class", "menuitem-iconic"); + } + + element.setAttribute("image", resolvedURL); + }, + + // Undo changes from setMenuItemIcon. + removeMenuItemIcon(element) { + element.removeAttribute("class"); + element.removeAttribute("image"); + }, + + rebuildMenu(extension) { + let { contextData } = this; + if (!contextData) { + // This happens if the menu is not visible. + return; + } + + // Find the group of existing top-level items (usually 0 or 1 items) + // and remember its position for when the new items are inserted. + let elementIdPrefix = `${makeWidgetId(extension.id)}-menuitem-`; + let nextSibling = null; + for (let item of this.itemsToCleanUp) { + if (item.id && item.id.startsWith(elementIdPrefix)) { + nextSibling = item.nextSibling; + item.remove(); + this.itemsToCleanUp.delete(item); + } + } + + let root = gRootItems.get(extension); + if (root) { + this.createAndInsertTopLevelElements(root, contextData, nextSibling); + } + + this.xulMenu.showHideSeparators?.(); + }, + + // This should be called once, after constructing the top-level menus, if any. + afterBuildingMenu(contextData) { + let dispatchOnShownEvent = extension => { + if (!this.canAccessContext(extension, contextData)) { + return; + } + + // Note: gShownMenuItems is a DefaultMap, so .get(extension) causes the + // extension to be stored in the map even if there are currently no + // shown menu items. This ensures that the onHidden event can be fired + // when the menu is closed. + let menuIds = gShownMenuItems.get(extension); + extension.emit("webext-menu-shown", menuIds, contextData); + }; + + if ( + contextData.onAction || + contextData.onBrowserAction || + contextData.onPageAction + ) { + dispatchOnShownEvent(contextData.extension); + } else { + for (const extension of gOnShownSubscribers.keys()) { + dispatchOnShownEvent(extension); + } + } + + this.contextData = contextData; + }, + + hideDefaultMenuItems() { + for (let item of this.xulMenu.children) { + if (!this.itemsToCleanUp.has(item)) { + item.hidden = true; + } + } + + if (this.xulMenu.showHideSeparators) { + this.xulMenu.showHideSeparators(); + } + }, + + handleEvent(event) { + if (this.xulMenu != event.target || event.type != "popuphidden") { + return; + } + + delete this.xulMenu; + delete this.contextData; + + let target = event.target; + target.removeEventListener("popuphidden", this); + for (let item of this.itemsToCleanUp) { + item.remove(); + } + this.itemsToCleanUp.clear(); + for (let extension of gShownMenuItems.keys()) { + extension.emit("webext-menu-hidden"); + } + gShownMenuItems.clear(); + }, + + itemsToCleanUp: new Set(), +}; + +// Called from pageAction or browserAction popup. +global.actionContextMenu = function (contextData) { + contextData.tab = tabTracker.activeTab; + contextData.pageUrl = contextData.tab.linkedBrowser.currentURI.spec; + gMenuBuilder.build(contextData); +}; + +const contextsMap = { + onAudio: "audio", + onEditable: "editable", + inFrame: "frame", + onImage: "image", + onLink: "link", + onPassword: "password", + isTextSelected: "selection", + onVideo: "video", + + onBookmark: "bookmark", + onAction: "action", + onBrowserAction: "browser_action", + onPageAction: "page_action", + onTab: "tab", + inToolsMenu: "tools_menu", +}; + +const getMenuContexts = contextData => { + let contexts = new Set(); + + for (const [key, value] of Object.entries(contextsMap)) { + if (contextData[key]) { + contexts.add(value); + } + } + + if (contexts.size === 0) { + contexts.add("page"); + } + + // New non-content contexts supported in Firefox are not part of "all". + if ( + !contextData.onBookmark && + !contextData.onTab && + !contextData.inToolsMenu + ) { + contexts.add("all"); + } + + return contexts; +}; + +function getContextViewType(contextData) { + if ("originalViewType" in contextData) { + return contextData.originalViewType; + } + if ( + contextData.webExtBrowserType === "popup" || + contextData.webExtBrowserType === "sidebar" + ) { + return contextData.webExtBrowserType; + } + if (contextData.tab && contextData.menu.id === "contentAreaContextMenu") { + return "tab"; + } + return undefined; +} + +function addMenuEventInfo(info, contextData, extension, includeSensitiveData) { + info.viewType = getContextViewType(contextData); + if (contextData.onVideo) { + info.mediaType = "video"; + } else if (contextData.onAudio) { + info.mediaType = "audio"; + } else if (contextData.onImage) { + info.mediaType = "image"; + } + if (contextData.frameId !== undefined) { + info.frameId = contextData.frameId; + } + if (contextData.onBookmark) { + info.bookmarkId = contextData.bookmarkId; + } + info.editable = contextData.onEditable || false; + if (includeSensitiveData) { + // menus.getTargetElement requires the "menus" permission, so do not set + // targetElementId for extensions with only the "contextMenus" permission. + if (contextData.timeStamp && extension.hasPermission("menus")) { + // Convert to integer, in case the DOMHighResTimeStamp has a fractional part. + info.targetElementId = Math.floor(contextData.timeStamp); + } + if (contextData.onLink) { + info.linkText = contextData.linkText; + info.linkUrl = contextData.linkUrl; + } + if (contextData.onAudio || contextData.onImage || contextData.onVideo) { + info.srcUrl = contextData.srcUrl; + } + if (!contextData.onBookmark) { + info.pageUrl = contextData.pageUrl; + } + if (contextData.inFrame) { + info.frameUrl = contextData.frameUrl; + } + if (contextData.isTextSelected) { + info.selectionText = contextData.selectionText; + } + } + // If the context was overridden, then frameUrl should be the URL of the + // document in which the menu was opened (instead of undefined, even if that + // document is not in a frame). + if (contextData.originalViewUrl) { + info.frameUrl = contextData.originalViewUrl; + } +} + +class MenuItem { + constructor(extension, createProperties, isRoot = false) { + this.extension = extension; + this.children = []; + this.parent = null; + this.tabManager = extension.tabManager; + + this.setDefaults(); + this.setProps(createProperties); + + if (!this.hasOwnProperty("_id")) { + this.id = gNextMenuItemID++; + } + // If the item is not the root and has no parent + // it must be a child of the root. + if (!isRoot && !this.parent) { + this.root.addChild(this); + } + } + + static mergeProps(obj, properties) { + for (let propName in properties) { + if (properties[propName] === null) { + // Omitted optional argument. + continue; + } + obj[propName] = properties[propName]; + } + + if ("icons" in properties && properties.icons === null && obj.icons) { + obj.icons = null; + } + } + + setProps(createProperties) { + MenuItem.mergeProps(this, createProperties); + + if (createProperties.documentUrlPatterns != null) { + this.documentUrlMatchPattern = parseMatchPatterns( + this.documentUrlPatterns, + { + restrictSchemes: this.extension.restrictSchemes, + } + ); + } + + if (createProperties.targetUrlPatterns != null) { + this.targetUrlMatchPattern = parseMatchPatterns(this.targetUrlPatterns, { + // restrictSchemes default to false when matching links instead of pages + // (see Bug 1280370 for a rationale). + restrictSchemes: false, + }); + } + + // If a child MenuItem does not specify any contexts, then it should + // inherit the contexts specified from its parent. + if (createProperties.parentId && !createProperties.contexts) { + this.contexts = this.parent.contexts; + } + } + + setDefaults() { + this.setProps({ + type: "normal", + checked: false, + contexts: ["all"], + enabled: true, + visible: true, + }); + } + + set id(id) { + if (this.hasOwnProperty("_id")) { + throw new ExtensionError("ID of a MenuItem cannot be changed"); + } + let isIdUsed = gMenuMap.get(this.extension).has(id); + if (isIdUsed) { + throw new ExtensionError(`ID already exists: ${id}`); + } + this._id = id; + } + + get id() { + return this._id; + } + + get elementId() { + let id = this.id; + // If the ID is an integer, it is auto-generated and globally unique. + // If the ID is a string, it is only unique within one extension and the + // ID needs to be concatenated with the extension ID. + if (typeof id !== "number") { + // To avoid collisions with numeric IDs, add a prefix to string IDs. + id = `_${id}`; + } + return `${makeWidgetId(this.extension.id)}-menuitem-${id}`; + } + + ensureValidParentId(parentId) { + if (parentId === undefined) { + return; + } + let menuMap = gMenuMap.get(this.extension); + if (!menuMap.has(parentId)) { + throw new ExtensionError( + `Could not find any MenuItem with id: ${parentId}` + ); + } + for (let item = menuMap.get(parentId); item; item = item.parent) { + if (item === this) { + throw new ExtensionError( + "MenuItem cannot be an ancestor (or self) of its new parent." + ); + } + } + } + + /** + * When updating menu properties we need to ensure parents exist + * in the cache map before children. That allows the menus to be + * created in the correct sequence on startup. This reparents the + * tree starting from this instance of MenuItem. + */ + reparentInCache() { + let { id, extension } = this; + let cachedMap = gStartupCache.get(extension); + let createProperties = cachedMap.get(id); + cachedMap.delete(id); + cachedMap.set(id, createProperties); + + for (let child of this.children) { + child.reparentInCache(); + } + } + + set parentId(parentId) { + this.ensureValidParentId(parentId); + + if (this.parent) { + this.parent.detachChild(this); + } + + if (parentId === undefined) { + this.root.addChild(this); + } else { + let menuMap = gMenuMap.get(this.extension); + menuMap.get(parentId).addChild(this); + } + } + + get parentId() { + return this.parent ? this.parent.id : undefined; + } + + addChild(child) { + if (child.parent) { + throw new Error("Child MenuItem already has a parent."); + } + this.children.push(child); + child.parent = this; + } + + detachChild(child) { + let idx = this.children.indexOf(child); + if (idx < 0) { + throw new Error("Child MenuItem not found, it cannot be removed."); + } + this.children.splice(idx, 1); + child.parent = null; + } + + get root() { + let extension = this.extension; + if (!gRootItems.has(extension)) { + let root = new MenuItem( + extension, + { title: extension.name }, + /* isRoot = */ true + ); + gRootItems.set(extension, root); + } + + return gRootItems.get(extension); + } + + remove() { + if (this.parent) { + this.parent.detachChild(this); + } + let children = this.children.slice(0); + for (let child of children) { + child.remove(); + } + + let menuMap = gMenuMap.get(this.extension); + menuMap.delete(this.id); + // Menu items are saved if !extension.persistentBackground. + if (gStartupCache.get(this.extension)?.delete(this.id)) { + StartupCache.save(); + } + if (this.root == this) { + gRootItems.delete(this.extension); + } + } + + getClickInfo(contextData, wasChecked) { + let info = { + menuItemId: this.id, + }; + if (this.parent) { + info.parentMenuItemId = this.parentId; + } + + addMenuEventInfo(info, contextData, this.extension, true); + + if (this.type === "checkbox" || this.type === "radio") { + info.checked = this.checked; + info.wasChecked = wasChecked; + } + + return info; + } + + enabledForContext(contextData) { + if (!this.visible) { + return false; + } + let contexts = getMenuContexts(contextData); + if (!this.contexts.some(n => contexts.has(n))) { + return false; + } + + if ( + this.viewTypes && + !this.viewTypes.includes(getContextViewType(contextData)) + ) { + return false; + } + + let docPattern = this.documentUrlMatchPattern; + // When viewTypes is specified, the menu item is expected to be restricted + // to documents. So let documentUrlPatterns always apply to the URL of the + // document in which the menu was opened. When maybeOverrideContextData + // changes the context, contextData.pageUrl does not reflect that URL any + // more, so use contextData.originalViewUrl instead. + if (docPattern && this.viewTypes && contextData.originalViewUrl) { + if ( + !docPattern.matches(Services.io.newURI(contextData.originalViewUrl)) + ) { + return false; + } + docPattern = null; // Null it so that it won't be used with pageURI below. + } + + if (contextData.onBookmark) { + return this.extension.hasPermission("bookmarks"); + } + + let pageURI = Services.io.newURI( + contextData[contextData.inFrame ? "frameUrl" : "pageUrl"] + ); + if (docPattern && !docPattern.matches(pageURI)) { + return false; + } + + let targetPattern = this.targetUrlMatchPattern; + if (targetPattern) { + let targetURIs = []; + if (contextData.onImage || contextData.onAudio || contextData.onVideo) { + // TODO: double check if srcUrl is always set when we need it + targetURIs.push(Services.io.newURI(contextData.srcUrl)); + } + // contextData.linkURI may be null despite contextData.onLink, when + // contextData.linkUrl is an invalid URL. + if (contextData.onLink && contextData.linkURI) { + targetURIs.push(contextData.linkURI); + } + if (!targetURIs.some(targetURI => targetPattern.matches(targetURI))) { + return false; + } + } + + return true; + } +} + +// windowTracker only looks as browser windows, but we're also interested in +// the Library window. Helper for menuTracker below. +const libraryTracker = { + libraryWindowType: "Places:Organizer", + + isLibraryWindow(window) { + let winType = window.document.documentElement.getAttribute("windowtype"); + return winType === this.libraryWindowType; + }, + + init(listener) { + this._listener = listener; + Services.ww.registerNotification(this); + + // See WindowTrackerBase#*browserWindows in ext-tabs-base.js for why we + // can't use the enumerator's windowtype filter. + for (let window of Services.wm.getEnumerator("")) { + if (window.document.readyState === "complete") { + if (this.isLibraryWindow(window)) { + this.notify(window); + } + } else { + window.addEventListener("load", this, { once: true }); + } + } + }, + + // cleanupWindow is called on any library window that's open. + uninit(cleanupWindow) { + Services.ww.unregisterNotification(this); + + for (let window of Services.wm.getEnumerator("")) { + window.removeEventListener("load", this); + try { + if (this.isLibraryWindow(window)) { + cleanupWindow(window); + } + } catch (e) { + Cu.reportError(e); + } + } + }, + + // Gets notifications from Services.ww.registerNotification. + // Defer actually doing anything until the window's loaded, though. + observe(window, topic) { + if (topic === "domwindowopened") { + window.addEventListener("load", this, { once: true }); + } + }, + + // Gets the load event for new windows(registered in observe()). + handleEvent(event) { + let window = event.target.defaultView; + if (this.isLibraryWindow(window)) { + this.notify(window); + } + }, + + notify(window) { + try { + this._listener.call(null, window); + } catch (e) { + Cu.reportError(e); + } + }, +}; + +// While any extensions are active, this Tracker registers to observe/listen +// for menu events from both Tools and context menus, both content and chrome. +const menuTracker = { + menuIds: ["placesContext", "menu_ToolsPopup", "tabContextMenu"], + + register() { + Services.obs.addObserver(this, "on-build-contextmenu"); + for (const window of windowTracker.browserWindows()) { + this.onWindowOpen(window); + } + windowTracker.addOpenListener(this.onWindowOpen); + libraryTracker.init(this.onLibraryOpen); + }, + + unregister() { + Services.obs.removeObserver(this, "on-build-contextmenu"); + for (const window of windowTracker.browserWindows()) { + this.cleanupWindow(window); + } + windowTracker.removeOpenListener(this.onWindowOpen); + libraryTracker.uninit(this.cleanupLibrary); + }, + + observe(subject, topic, data) { + subject = subject.wrappedJSObject; + gMenuBuilder.build(subject); + }, + + async onWindowOpen(window) { + for (const id of menuTracker.menuIds) { + const menu = window.document.getElementById(id); + menu.addEventListener("popupshowing", menuTracker); + } + + const sidebarHeader = window.document.getElementById( + "sidebar-switcher-target" + ); + sidebarHeader.addEventListener("SidebarShown", menuTracker.onSidebarShown); + + await window.SidebarUI.promiseInitialized; + + if ( + !window.closed && + window.SidebarUI.currentID === "viewBookmarksSidebar" + ) { + menuTracker.onSidebarShown({ currentTarget: sidebarHeader }); + } + }, + + cleanupWindow(window) { + for (const id of this.menuIds) { + const menu = window.document.getElementById(id); + menu.removeEventListener("popupshowing", this); + } + + const sidebarHeader = window.document.getElementById( + "sidebar-switcher-target" + ); + sidebarHeader.removeEventListener("SidebarShown", this.onSidebarShown); + + if (window.SidebarUI.currentID === "viewBookmarksSidebar") { + let sidebarBrowser = window.SidebarUI.browser; + sidebarBrowser.removeEventListener("load", this.onSidebarShown); + const menu = + sidebarBrowser.contentDocument.getElementById("placesContext"); + menu.removeEventListener("popupshowing", this.onBookmarksContextMenu); + } + }, + + onSidebarShown(event) { + // The event target is an element in a browser window, so |window| will be + // the browser window that contains the sidebar. + const window = event.currentTarget.ownerGlobal; + if (window.SidebarUI.currentID === "viewBookmarksSidebar") { + let sidebarBrowser = window.SidebarUI.browser; + if (sidebarBrowser.contentDocument.readyState !== "complete") { + // SidebarUI.currentID may be updated before the bookmark sidebar's + // document has finished loading. This sometimes happens when the + // sidebar is automatically shown when a new window is opened. + sidebarBrowser.addEventListener("load", menuTracker.onSidebarShown, { + once: true, + }); + return; + } + const menu = + sidebarBrowser.contentDocument.getElementById("placesContext"); + menu.addEventListener("popupshowing", menuTracker.onBookmarksContextMenu); + } + }, + + onLibraryOpen(window) { + const menu = window.document.getElementById("placesContext"); + menu.addEventListener("popupshowing", menuTracker.onBookmarksContextMenu); + }, + + cleanupLibrary(window) { + const menu = window.document.getElementById("placesContext"); + menu.removeEventListener( + "popupshowing", + menuTracker.onBookmarksContextMenu + ); + }, + + handleEvent(event) { + const menu = event.target; + + if (menu.id === "placesContext") { + const trigger = menu.triggerNode; + if (!trigger._placesNode?.bookmarkGuid) { + return; + } + + gMenuBuilder.build({ + menu, + bookmarkId: trigger._placesNode.bookmarkGuid, + onBookmark: true, + }); + } + if (menu.id === "menu_ToolsPopup") { + const tab = tabTracker.activeTab; + const pageUrl = tab.linkedBrowser.currentURI.spec; + gMenuBuilder.build({ menu, tab, pageUrl, inToolsMenu: true }); + } + if (menu.id === "tabContextMenu") { + const tab = menu.ownerGlobal.TabContextMenu.contextTab; + const pageUrl = tab.linkedBrowser.currentURI.spec; + gMenuBuilder.build({ menu, tab, pageUrl, onTab: true }); + } + }, + + onBookmarksContextMenu(event) { + const menu = event.target; + const tree = menu.triggerNode.parentElement; + const cell = tree.getCellAt(event.x, event.y); + const node = tree.view.nodeForTreeIndex(cell.row); + const bookmarkId = node && PlacesUtils.getConcreteItemGuid(node); + + if (!bookmarkId || PlacesUtils.isVirtualLeftPaneItem(bookmarkId)) { + return; + } + + gMenuBuilder.build({ menu, bookmarkId, onBookmark: true }); + }, +}; + +this.menusInternal = class extends ExtensionAPIPersistent { + constructor(extension) { + super(extension); + + if (!gMenuMap.size) { + menuTracker.register(); + } + gMenuMap.set(extension, new Map()); + } + + restoreFromCache() { + let { extension } = this; + // ensure extension has not shutdown + if (!this.extension) { + return; + } + for (let createProperties of gStartupCache.get(extension).values()) { + // The order of menu creation is significant, see reparentInCache. + let menuItem = new MenuItem(extension, createProperties); + gMenuMap.get(extension).set(menuItem.id, menuItem); + } + // Used for testing + extension.emit("webext-menus-created", gMenuMap.get(extension)); + } + + async onStartup() { + let { extension } = this; + if (extension.persistentBackground) { + return; + } + // Using the map retains insertion order. + let cachedMenus = await StartupCache.menus.get(extension.id, () => { + return new Map(); + }); + gStartupCache.set(extension, cachedMenus); + if (!cachedMenus.size) { + return; + } + + this.restoreFromCache(); + } + + onShutdown() { + let { extension } = this; + + if (gMenuMap.has(extension)) { + gMenuMap.delete(extension); + gRootItems.delete(extension); + gShownMenuItems.delete(extension); + gStartupCache.delete(extension); + gOnShownSubscribers.delete(extension); + if (!gMenuMap.size) { + menuTracker.unregister(); + } + } + } + + PERSISTENT_EVENTS = { + onShown({ fire }) { + let { extension } = this; + let listener = (event, menuIds, contextData) => { + let info = { + menuIds, + contexts: Array.from(getMenuContexts(contextData)), + }; + + let nativeTab = contextData.tab; + + // The menus.onShown event is fired before the user has consciously + // interacted with an extension, so we require permissions before + // exposing sensitive contextual data. + let contextUrl = contextData.inFrame + ? contextData.frameUrl + : contextData.pageUrl; + let includeSensitiveData = + (nativeTab && + extension.tabManager.hasActiveTabPermission(nativeTab)) || + (contextUrl && extension.allowedOrigins.matches(contextUrl)); + + addMenuEventInfo(info, contextData, extension, includeSensitiveData); + + let tab = nativeTab && extension.tabManager.convert(nativeTab); + fire.sync(info, tab); + }; + gOnShownSubscribers.get(extension).add(listener); + extension.on("webext-menu-shown", listener); + return { + unregister() { + const listeners = gOnShownSubscribers.get(extension); + listeners.delete(listener); + if (listeners.size === 0) { + gOnShownSubscribers.delete(extension); + } + extension.off("webext-menu-shown", listener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + onHidden({ fire }) { + let { extension } = this; + let listener = () => { + fire.sync(); + }; + extension.on("webext-menu-hidden", listener); + return { + unregister() { + extension.off("webext-menu-hidden", listener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + onClicked({ context, fire }) { + let { extension } = this; + let listener = async (event, info, nativeTab) => { + let { linkedBrowser } = nativeTab || tabTracker.activeTab; + let tab = nativeTab && extension.tabManager.convert(nativeTab); + if (fire.wakeup) { + // force the wakeup, thus the call to convert to get the context. + await fire.wakeup(); + // If while waiting the tab disappeared we bail out. + if ( + !linkedBrowser.ownerGlobal.gBrowser.getTabForBrowser(linkedBrowser) + ) { + Cu.reportError( + `menus.onClicked: target tab closed during background startup.` + ); + return; + } + } + context.withPendingBrowser(linkedBrowser, () => fire.sync(info, tab)); + }; + + extension.on("webext-menu-menuitem-click", listener); + return { + unregister() { + extension.off("webext-menu-menuitem-click", listener); + }, + convert(_fire, _context) { + fire = _fire; + context = _context; + }, + }; + }, + }; + + getAPI(context) { + let { extension } = context; + + const menus = { + refresh() { + gMenuBuilder.rebuildMenu(extension); + }, + + onShown: new EventManager({ + context, + module: "menusInternal", + event: "onShown", + name: "menus.onShown", + extensionApi: this, + }).api(), + onHidden: new EventManager({ + context, + module: "menusInternal", + event: "onHidden", + name: "menus.onHidden", + extensionApi: this, + }).api(), + }; + + return { + contextMenus: menus, + menus, + menusInternal: { + create(createProperties) { + // event pages require id + if (!extension.persistentBackground) { + if (!createProperties.id) { + throw new ExtensionError( + "menus.create requires an id for non-persistent background scripts." + ); + } + if (gMenuMap.get(extension).has(createProperties.id)) { + throw new ExtensionError( + `The menu id ${createProperties.id} already exists in menus.create.` + ); + } + } + + // Note that the id is required by the schema. If the addon did not set + // it, the implementation of menus.create in the child will add it for + // extensions with persistent backgrounds, but not otherwise. + let menuItem = new MenuItem(extension, createProperties); + gMenuMap.get(extension).set(menuItem.id, menuItem); + if (!extension.persistentBackground) { + // Only cache properties that are necessary. + let cached = {}; + MenuItem.mergeProps(cached, createProperties); + gStartupCache.get(extension).set(menuItem.id, cached); + StartupCache.save(); + } + }, + + update(id, updateProperties) { + let menuItem = gMenuMap.get(extension).get(id); + if (!menuItem) { + return; + } + menuItem.setProps(updateProperties); + + // Update the startup cache for non-persistent extensions. + if (extension.persistentBackground) { + return; + } + + let cached = gStartupCache.get(extension).get(id); + let reparent = + updateProperties.parentId != null && + cached.parentId != updateProperties.parentId; + MenuItem.mergeProps(cached, updateProperties); + if (reparent) { + // The order of menu creation is significant, see reparentInCache. + menuItem.reparentInCache(); + } + StartupCache.save(); + }, + + remove(id) { + let menuItem = gMenuMap.get(extension).get(id); + if (menuItem) { + menuItem.remove(); + } + }, + + removeAll() { + let root = gRootItems.get(extension); + if (root) { + root.remove(); + } + // Should be empty, just extra assurance. + if (!extension.persistentBackground) { + let cached = gStartupCache.get(extension); + if (cached.size) { + cached.clear(); + StartupCache.save(); + } + } + }, + + onClicked: new EventManager({ + context, + module: "menusInternal", + event: "onClicked", + name: "menus.onClicked", + extensionApi: this, + }).api(), + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-normandyAddonStudy.js b/browser/components/extensions/parent/ext-normandyAddonStudy.js new file mode 100644 index 0000000000..0fcca4c678 --- /dev/null +++ b/browser/components/extensions/parent/ext-normandyAddonStudy.js @@ -0,0 +1,84 @@ +/* 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"; + +const { AddonStudies } = ChromeUtils.importESModule( + "resource://normandy/lib/AddonStudies.sys.mjs" +); +const { ClientID } = ChromeUtils.importESModule( + "resource://gre/modules/ClientID.sys.mjs" +); + +ChromeUtils.defineESModuleGetters(this, { + AddonManager: "resource://gre/modules/AddonManager.sys.mjs", +}); + +this.normandyAddonStudy = class extends ExtensionAPI { + getAPI(context) { + let { extension } = context; + + return { + normandyAddonStudy: { + /** + * Returns a study object for the current study. + * + * @returns {Study} + */ + async getStudy() { + const studies = await AddonStudies.getAll(); + return studies.find(study => study.addonId === extension.id); + }, + + /** + * Marks the study as ended and then uninstalls the addon. + * + * @param {string} reason Why the study is ending + */ + async endStudy(reason) { + const study = await this.getStudy(); + + // Mark the study as ended + await AddonStudies.markAsEnded(study, reason); + + // Uninstall the addon + const addon = await AddonManager.getAddonByID(study.addonId); + if (addon) { + await addon.uninstall(); + } + }, + + /** + * Returns an object with metadata about the client which may + * be required for constructing survey URLs. + * + * @returns {object} + */ + async getClientMetadata() { + return { + updateChannel: Services.appinfo.defaultUpdateChannel, + fxVersion: Services.appinfo.version, + clientID: await ClientID.getClientID(), + }; + }, + + onUnenroll: new EventManager({ + context, + name: "normandyAddonStudy.onUnenroll", + register: fire => { + const listener = async reason => { + await fire.async(reason); + }; + + AddonStudies.addUnenrollListener(extension.id, listener); + + return () => { + AddonStudies.removeUnenrollListener(extension.id, listener); + }; + }, + }).api(), + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-omnibox.js b/browser/components/extensions/parent/ext-omnibox.js new file mode 100644 index 0000000000..363db67325 --- /dev/null +++ b/browser/components/extensions/parent/ext-omnibox.js @@ -0,0 +1,177 @@ +/* -*- 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.defineESModuleGetters(this, { + ExtensionSearchHandler: + "resource://gre/modules/ExtensionSearchHandler.sys.mjs", +}); + +this.omnibox = class extends ExtensionAPIPersistent { + PERSISTENT_EVENTS = { + onInputStarted({ fire }) { + let { extension } = this; + let listener = eventName => { + fire.sync(); + }; + extension.on(ExtensionSearchHandler.MSG_INPUT_STARTED, listener); + return { + unregister() { + extension.off(ExtensionSearchHandler.MSG_INPUT_STARTED, listener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + onInputCancelled({ fire }) { + let { extension } = this; + let listener = eventName => { + fire.sync(); + }; + extension.on(ExtensionSearchHandler.MSG_INPUT_CANCELLED, listener); + return { + unregister() { + extension.off(ExtensionSearchHandler.MSG_INPUT_CANCELLED, listener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + onInputEntered({ fire }) { + let { extension } = this; + let listener = (eventName, text, disposition) => { + fire.sync(text, disposition); + }; + extension.on(ExtensionSearchHandler.MSG_INPUT_ENTERED, listener); + return { + unregister() { + extension.off(ExtensionSearchHandler.MSG_INPUT_ENTERED, listener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + onInputChanged({ fire }) { + let { extension } = this; + let listener = (eventName, text, id) => { + fire.sync(text, id); + }; + extension.on(ExtensionSearchHandler.MSG_INPUT_CHANGED, listener); + return { + unregister() { + extension.off(ExtensionSearchHandler.MSG_INPUT_CHANGED, listener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + onDeleteSuggestion({ fire }) { + let { extension } = this; + let listener = (eventName, text) => { + fire.sync(text); + }; + extension.on(ExtensionSearchHandler.MSG_INPUT_DELETED, listener); + return { + unregister() { + extension.off(ExtensionSearchHandler.MSG_INPUT_DELETED, listener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + }; + + onManifestEntry(entryName) { + let { extension } = this; + let { manifest } = extension; + + let keyword = manifest.omnibox.keyword; + try { + // This will throw if the keyword is already registered. + ExtensionSearchHandler.registerKeyword(keyword, extension); + this.keyword = keyword; + } catch (e) { + extension.manifestError(e.message); + } + } + + onShutdown() { + ExtensionSearchHandler.unregisterKeyword(this.keyword); + } + + getAPI(context) { + return { + omnibox: { + setDefaultSuggestion: suggestion => { + try { + // This will throw if the keyword failed to register. + ExtensionSearchHandler.setDefaultSuggestion( + this.keyword, + suggestion + ); + } catch (e) { + return Promise.reject(e.message); + } + }, + + onInputStarted: new EventManager({ + context, + module: "omnibox", + event: "onInputStarted", + extensionApi: this, + }).api(), + + onInputCancelled: new EventManager({ + context, + module: "omnibox", + event: "onInputCancelled", + extensionApi: this, + }).api(), + + onInputEntered: new EventManager({ + context, + module: "omnibox", + event: "onInputEntered", + extensionApi: this, + }).api(), + + onInputChanged: new EventManager({ + context, + module: "omnibox", + event: "onInputChanged", + extensionApi: this, + }).api(), + + onDeleteSuggestion: new EventManager({ + context, + module: "omnibox", + event: "onDeleteSuggestion", + extensionApi: this, + }).api(), + + // Internal APIs. + addSuggestions: (id, suggestions) => { + try { + ExtensionSearchHandler.addSuggestions( + this.keyword, + id, + suggestions + ); + } catch (e) { + // Silently fail because the extension developer can not know for sure if the user + // has already invalidated the callback when asynchronously providing suggestions. + } + }, + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-pageAction.js b/browser/components/extensions/parent/ext-pageAction.js new file mode 100644 index 0000000000..bfd8d14fd2 --- /dev/null +++ b/browser/components/extensions/parent/ext-pageAction.js @@ -0,0 +1,391 @@ +/* -*- 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.defineESModuleGetters(this, { + ExtensionTelemetry: "resource://gre/modules/ExtensionTelemetry.sys.mjs", + PanelPopup: "resource:///modules/ExtensionPopups.sys.mjs", +}); +ChromeUtils.defineModuleGetter( + this, + "PageActions", + "resource:///modules/PageActions.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "BrowserUsageTelemetry", + "resource:///modules/BrowserUsageTelemetry.jsm" +); + +var { DefaultWeakMap } = ExtensionUtils; + +var { ExtensionParent } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionParent.sys.mjs" +); +var { PageActionBase } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionActions.sys.mjs" +); + +// WeakMap[Extension -> PageAction] +let pageActionMap = new WeakMap(); + +class PageAction extends PageActionBase { + constructor(extension, buttonDelegate) { + let tabContext = new TabContext(tab => this.getContextData(null)); + super(tabContext, extension); + this.buttonDelegate = buttonDelegate; + } + + updateOnChange(target) { + this.buttonDelegate.updateButton(target.ownerGlobal); + } + + dispatchClick(tab, clickInfo) { + this.buttonDelegate.emit("click", tab, clickInfo); + } + + getTab(tabId) { + if (tabId !== null) { + return tabTracker.getTab(tabId); + } + return null; + } +} + +this.pageAction = class extends ExtensionAPIPersistent { + static for(extension) { + return pageActionMap.get(extension); + } + + static onUpdate(id, manifest) { + if (!("page_action" in manifest)) { + // If the new version has no page action then mark this widget as hidden + // in the telemetry. If it is already marked hidden then this will do + // nothing. + BrowserUsageTelemetry.recordWidgetChange(makeWidgetId(id), null, "addon"); + } + } + + static onDisable(id) { + BrowserUsageTelemetry.recordWidgetChange(makeWidgetId(id), null, "addon"); + } + + static onUninstall(id) { + // If the telemetry already has this widget as hidden then this will not + // record anything. + BrowserUsageTelemetry.recordWidgetChange(makeWidgetId(id), null, "addon"); + } + + async onManifestEntry(entryName) { + let { extension } = this; + let options = extension.manifest.page_action; + + this.action = new PageAction(extension, this); + await this.action.loadIconData(); + + let widgetId = makeWidgetId(extension.id); + this.id = widgetId + "-page-action"; + + this.tabManager = extension.tabManager; + + this.browserStyle = options.browser_style; + + pageActionMap.set(extension, this); + + this.lastValues = new DefaultWeakMap(() => ({})); + + if (!this.browserPageAction) { + let onPlacedHandler = (buttonNode, isPanel) => { + // eslint-disable-next-line mozilla/balanced-listeners + buttonNode.addEventListener("auxclick", event => { + if (event.button !== 1 || event.target.disabled) { + return; + } + + // The panel is not automatically closed when middle-clicked. + if (isPanel) { + buttonNode.closest("#pageActionPanel").hidePopup(); + } + let window = event.target.ownerGlobal; + let tab = window.gBrowser.selectedTab; + this.tabManager.addActiveTabPermission(tab); + this.action.dispatchClick(tab, { + button: event.button, + modifiers: clickModifiersFromEvent(event), + }); + }); + }; + + this.browserPageAction = PageActions.addAction( + new PageActions.Action({ + id: widgetId, + extensionID: extension.id, + title: this.action.getProperty(null, "title"), + iconURL: this.action.getProperty(null, "icon"), + pinnedToUrlbar: this.action.getPinned(), + disabled: !this.action.getProperty(null, "enabled"), + onCommand: (event, buttonNode) => { + this.handleClick(event.target.ownerGlobal, { + button: event.button || 0, + modifiers: clickModifiersFromEvent(event), + }); + }, + onBeforePlacedInWindow: browserWindow => { + if ( + this.extension.hasPermission("menus") || + this.extension.hasPermission("contextMenus") + ) { + browserWindow.document.addEventListener("popupshowing", this); + } + }, + onPlacedInPanel: buttonNode => onPlacedHandler(buttonNode, true), + onPlacedInUrlbar: buttonNode => onPlacedHandler(buttonNode, false), + onRemovedFromWindow: browserWindow => { + browserWindow.document.removeEventListener("popupshowing", this); + }, + }) + ); + + if (this.extension.startupReason != "APP_STARTUP") { + // Make sure the browser telemetry has the correct state for this widget. + // Defer loading BrowserUsageTelemetry until after startup is complete. + ExtensionParent.browserStartupPromise.then(() => { + BrowserUsageTelemetry.recordWidgetChange( + widgetId, + this.browserPageAction.pinnedToUrlbar + ? "page-action-buttons" + : null, + "addon" + ); + }); + } + + // If the page action is only enabled in some URLs, do pattern matching in + // the active tabs and update the button if necessary. + if (this.action.getProperty(null, "enabled") === undefined) { + for (let window of windowTracker.browserWindows()) { + let tab = window.gBrowser.selectedTab; + if (this.action.isShownForTab(tab)) { + this.updateButton(window); + } + } + } + } + } + + onShutdown(isAppShutdown) { + pageActionMap.delete(this.extension); + this.action.onShutdown(); + + // Removing the browser page action causes PageActions to forget about it + // across app restarts, so don't remove it on app shutdown, but do remove + // it on all other shutdowns since there's no guarantee the action will be + // coming back. + if (!isAppShutdown && this.browserPageAction) { + this.browserPageAction.remove(); + this.browserPageAction = null; + } + } + + // Updates the page action button in the given window to reflect the + // properties of the currently selected tab: + // + // Updates "tooltiptext" and "aria-label" to match "title" property. + // Updates "image" to match the "icon" property. + // Enables or disables the icon, based on the "enabled" and "patternMatching" properties. + updateButton(window) { + let tab = window.gBrowser.selectedTab; + let tabData = this.action.getContextData(tab); + let last = this.lastValues.get(window); + + window.requestAnimationFrame(() => { + // If we get called just before shutdown, we might have been destroyed by + // this point. + if (!this.browserPageAction) { + return; + } + + let title = tabData.title || this.extension.name; + if (last.title !== title) { + this.browserPageAction.setTitle(title, window); + last.title = title; + } + + let enabled = + tabData.enabled != null ? tabData.enabled : tabData.patternMatching; + if (last.enabled !== enabled) { + this.browserPageAction.setDisabled(!enabled, window); + last.enabled = enabled; + } + + let icon = tabData.icon; + if (last.icon !== icon) { + this.browserPageAction.setIconURL(icon, window); + last.icon = icon; + } + }); + } + + /** + * Triggers this page action for the given window, with the same effects as + * if it were clicked by a user. + * + * This has no effect if the page action is hidden for the selected tab. + * + * @param {Window} window + */ + triggerAction(window) { + this.handleClick(window, { button: 0, modifiers: [] }); + } + + handleEvent(event) { + switch (event.type) { + case "popupshowing": + const menu = event.target; + const trigger = menu.triggerNode; + const getActionId = () => { + let actionId = trigger.getAttribute("actionid"); + if (actionId) { + return actionId; + } + // When a page action is clicked, triggerNode will be an ancestor of + // a node corresponding to an action. triggerNode will be the page + // action node itself when a page action is selected with the + // keyboard. That's because the semantic meaning of page action is on + // an hbox that contains an <image>. + for (let n = trigger; n && !actionId; n = n.parentElement) { + if (n.id == "page-action-buttons" || n.localName == "panelview") { + // We reached the page-action-buttons or panelview container. + // Stop looking; no action was found. + break; + } + actionId = n.getAttribute("actionid"); + } + return actionId; + }; + if ( + menu.id === "pageActionContextMenu" && + trigger && + getActionId() === this.browserPageAction.id && + !this.browserPageAction.getDisabled(trigger.ownerGlobal) + ) { + global.actionContextMenu({ + extension: this.extension, + onPageAction: true, + menu: menu, + }); + } + break; + } + } + + // Handles a click event on the page action button for the given + // window. + // If the page action has a |popup| property, a panel is opened to + // that URL. Otherwise, a "click" event is emitted, and dispatched to + // the any click listeners in the add-on. + async handleClick(window, clickInfo) { + const { extension } = this; + + ExtensionTelemetry.pageActionPopupOpen.stopwatchStart(extension, this); + let tab = window.gBrowser.selectedTab; + let popupURL = this.action.triggerClickOrPopup(tab, clickInfo); + + // If the widget has a popup URL defined, we open a popup, but do not + // dispatch a click event to the extension. + // If it has no popup URL defined, we dispatch a click event, but do not + // open a popup. + if (popupURL) { + if (this.popupNode && this.popupNode.panel.state !== "closed") { + // The panel is being toggled closed. + ExtensionTelemetry.pageActionPopupOpen.stopwatchCancel(extension, this); + window.BrowserPageActions.togglePanelForAction( + this.browserPageAction, + this.popupNode.panel + ); + return; + } + + this.popupNode = new PanelPopup( + extension, + window.document, + popupURL, + this.browserStyle + ); + // Remove popupNode when it is closed. + this.popupNode.panel.addEventListener( + "popuphiding", + () => { + this.popupNode = undefined; + }, + { once: true } + ); + await this.popupNode.contentReady; + window.BrowserPageActions.togglePanelForAction( + this.browserPageAction, + this.popupNode.panel + ); + ExtensionTelemetry.pageActionPopupOpen.stopwatchFinish(extension, this); + } else { + ExtensionTelemetry.pageActionPopupOpen.stopwatchCancel(extension, this); + } + } + + PERSISTENT_EVENTS = { + onClicked({ context, fire }) { + const { extension } = this; + const { tabManager } = extension; + + let listener = async (_event, tab, clickInfo) => { + if (fire.wakeup) { + await fire.wakeup(); + } + // TODO: we should double-check if the tab is already being closed by the time + // the background script got started and we converted the primed listener. + context?.withPendingBrowser(tab.linkedBrowser, () => + fire.sync(tabManager.convert(tab), clickInfo) + ); + }; + + this.on("click", listener); + return { + unregister: () => { + this.off("click", listener); + }, + convert(newFire, extContext) { + fire = newFire; + context = extContext; + }, + }; + }, + }; + + getAPI(context) { + const { action } = this; + + return { + pageAction: { + ...action.api(context), + + onClicked: new EventManager({ + context, + module: "pageAction", + event: "onClicked", + inputHandling: true, + extensionApi: this, + }).api(), + + openPopup: () => { + let window = windowTracker.topWindow; + this.triggerAction(window); + }, + }, + }; + } +}; + +global.pageActionFor = this.pageAction.for; diff --git a/browser/components/extensions/parent/ext-pkcs11.js b/browser/components/extensions/parent/ext-pkcs11.js new file mode 100644 index 0000000000..696133bfc5 --- /dev/null +++ b/browser/components/extensions/parent/ext-pkcs11.js @@ -0,0 +1,187 @@ +/* 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.defineESModuleGetters(this, { + NativeManifests: "resource://gre/modules/NativeManifests.sys.mjs", + ctypes: "resource://gre/modules/ctypes.sys.mjs", +}); + +XPCOMUtils.defineLazyServiceGetter( + this, + "pkcs11db", + "@mozilla.org/security/pkcs11moduledb;1", + "nsIPKCS11ModuleDB" +); + +// eslint-disable-next-line mozilla/reject-importGlobalProperties +Cu.importGlobalProperties(["PathUtils"]); + +var { DefaultMap } = ExtensionUtils; + +const findModuleByPath = function (path) { + for (let module of pkcs11db.listModules()) { + if (module && module.libName === path) { + return module; + } + } + return null; +}; + +this.pkcs11 = class extends ExtensionAPI { + getAPI(context) { + let manifestCache = new DefaultMap(async name => { + let hostInfo = await NativeManifests.lookupManifest( + "pkcs11", + name, + context + ); + if (hostInfo) { + // We don't normalize the absolute path below because + // `Path.normalize` throws when the target file doesn't + // exist, and that might be the case on non Windows + // builds. + let absolutePath = PathUtils.isAbsolute(hostInfo.manifest.path) + ? hostInfo.manifest.path + : PathUtils.joinRelative( + PathUtils.parent(hostInfo.path), + hostInfo.manifest.path + ); + + if (AppConstants.platform === "win") { + // On Windows, `hostInfo.manifest.path` is expected to be a normalized + // absolute path. On other platforms, this path may be relative but we + // cannot use `PathUtils.normalize()` on non-absolute paths. + absolutePath = PathUtils.normalize(absolutePath); + hostInfo.manifest.path = absolutePath; + } + + // PathUtils.filename throws if the path is not an absolute path. + // The result is expected to be the basename of the file (without + // the dir path and the extension) so it is fine to use an absolute + // path that may not be normalized (non-Windows platforms). + let manifestLib = PathUtils.filename(absolutePath); + + if (AppConstants.platform !== "linux") { + manifestLib = manifestLib.toLowerCase(manifestLib); + } + if ( + manifestLib !== ctypes.libraryName("nssckbi") && + manifestLib !== ctypes.libraryName("osclientcerts") && + manifestLib !== ctypes.libraryName("ipcclientcerts") + ) { + return hostInfo.manifest; + } + } + return Promise.reject({ message: `No such PKCS#11 module ${name}` }); + }); + return { + pkcs11: { + /** + * Verify whether a given PKCS#11 module is installed. + * + * @param {string} name The name of the module, as specified in + * the manifest file. + * @returns {Promise} A Promise that resolves to true if the package + * is installed, or false if it is not. May be + * rejected if the module could not be found. + */ + async isModuleInstalled(name) { + let manifest = await manifestCache.get(name); + return findModuleByPath(manifest.path) !== null; + }, + /** + * Install a PKCS#11 module + * + * @param {string} name The name of the module, as specified in + * the manifest file. + * @param {integer} [flags = 0] Any flags to be passed on to the + * nsIPKCS11ModuleDB.addModule method + * @returns {Promise} When the Promise resolves, the module will have + * been installed. When it is rejected, the module + * either is already installed or could not be + * installed for some reason. + */ + async installModule(name, flags = 0) { + let manifest = await manifestCache.get(name); + if (!manifest.description) { + return Promise.reject({ + message: `The description field in the manifest for PKCS#11 module ${name} must have a value`, + }); + } + pkcs11db.addModule(manifest.description, manifest.path, flags, 0); + }, + /** + * Uninstall a PKCS#11 module + * + * @param {string} name The name of the module, as specified in + * the manifest file. + * @returns {Promise}. When the Promise resolves, the module will have + * been uninstalled. When it is rejected, the + * module either was not installed or could not be + * uninstalled for some reason. + */ + async uninstallModule(name) { + let manifest = await manifestCache.get(name); + let module = findModuleByPath(manifest.path); + if (!module) { + return Promise.reject({ + message: `The PKCS#11 module ${name} is not loaded`, + }); + } + pkcs11db.deleteModule(module.name); + }, + /** + * Get a list of slots for a given PKCS#11 module, with + * information on the token (if any) in the slot. + * + * The PKCS#11 standard defines slots as an abstract concept + * that may or may not have at most one token. In practice, when + * using PKCS#11 for smartcards (the most likely use case of + * PKCS#11 for Firefox), a slot corresponds to a cardreader, and + * a token corresponds to a card. + * + * @param {string} name The name of the PKCS#11 module, as + * specified in the manifest file. + * @returns {Promise} A promise that resolves to an array of objects + * with two properties. The `name` object contains + * the name of the slot; the `token` object is null + * if there is no token in the slot, or is an object + * describing various properties of the token if + * there is. + */ + async getModuleSlots(name) { + let manifest = await manifestCache.get(name); + let module = findModuleByPath(manifest.path); + if (!module) { + return Promise.reject({ + message: `The module ${name} is not installed`, + }); + } + let rv = []; + for (let slot of module.listSlots()) { + let token = slot.getToken(); + let slotobj = { + name: slot.name, + token: null, + }; + if (slot.status != 1 /* SLOT_NOT_PRESENT */) { + slotobj.token = { + name: token.tokenName, + manufacturer: token.tokenManID, + HWVersion: token.tokenHWVersion, + FWVersion: token.tokenFWVersion, + serial: token.tokenSerialNumber, + isLoggedIn: token.isLoggedIn(), + }; + } + rv.push(slotobj); + } + return rv; + }, + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-search.js b/browser/components/extensions/parent/ext-search.js new file mode 100644 index 0000000000..be51f5a17a --- /dev/null +++ b/browser/components/extensions/parent/ext-search.js @@ -0,0 +1,118 @@ +/* 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/. */ + +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ + +"use strict"; + +var { ExtensionError } = ExtensionUtils; + +const dispositionMap = { + CURRENT_TAB: "current", + NEW_TAB: "tab", + NEW_WINDOW: "window", +}; + +this.search = class extends ExtensionAPI { + getAPI(context) { + function getTarget({ tabId, disposition, defaultDisposition }) { + let tab, where; + if (disposition) { + if (tabId) { + throw new ExtensionError(`Cannot set both 'disposition' and 'tabId'`); + } + where = dispositionMap[disposition]; + } else if (tabId) { + tab = tabTracker.getTab(tabId); + } else { + where = dispositionMap[defaultDisposition]; + } + return { tab, where }; + } + + return { + search: { + async get() { + await searchInitialized; + let visibleEngines = await Services.search.getVisibleEngines(); + let defaultEngine = await Services.search.getDefault(); + return Promise.all( + visibleEngines.map(async engine => { + let favIconUrl; + if (engine.iconURI) { + // Convert moz-extension:-URLs to data:-URLs to make sure that + // extensions can see icons from other extensions, even if they + // are not web-accessible. + // Also prevents leakage of extension UUIDs to other extensions.. + if ( + engine.iconURI.schemeIs("moz-extension") && + engine.iconURI.host !== context.extension.uuid + ) { + favIconUrl = await ExtensionUtils.makeDataURI( + engine.iconURI.spec + ); + } else { + favIconUrl = engine.iconURI.spec; + } + } + + return { + name: engine.name, + isDefault: engine.name === defaultEngine.name, + alias: engine.alias || undefined, + favIconUrl, + }; + }) + ); + }, + + async search(searchProperties) { + await searchInitialized; + let engine; + + if (searchProperties.engine) { + engine = Services.search.getEngineByName(searchProperties.engine); + if (!engine) { + throw new ExtensionError( + `${searchProperties.engine} was not found` + ); + } + } + + let { tab, where } = getTarget({ + tabId: searchProperties.tabId, + disposition: searchProperties.disposition, + defaultDisposition: "NEW_TAB", + }); + + await windowTracker.topWindow.BrowserSearch.loadSearchFromExtension({ + query: searchProperties.query, + where, + engine, + tab, + triggeringPrincipal: context.principal, + }); + }, + + async query(queryProperties) { + await searchInitialized; + + let { tab, where } = getTarget({ + tabId: queryProperties.tabId, + disposition: queryProperties.disposition, + defaultDisposition: "CURRENT_TAB", + }); + + await windowTracker.topWindow.BrowserSearch.loadSearchFromExtension({ + query: queryProperties.text, + where, + tab, + triggeringPrincipal: context.principal, + }); + }, + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-sessions.js b/browser/components/extensions/parent/ext-sessions.js new file mode 100644 index 0000000000..eb50a147f0 --- /dev/null +++ b/browser/components/extensions/parent/ext-sessions.js @@ -0,0 +1,274 @@ +/* -*- 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"; + +var { ExtensionError, promiseObserved } = ExtensionUtils; + +ChromeUtils.defineESModuleGetters(this, { + AddonManagerPrivate: "resource://gre/modules/AddonManager.sys.mjs", + SessionStore: "resource:///modules/sessionstore/SessionStore.sys.mjs", +}); + +const SS_ON_CLOSED_OBJECTS_CHANGED = "sessionstore-closed-objects-changed"; + +const getRecentlyClosed = (maxResults, extension) => { + let recentlyClosed = []; + + // Get closed windows + // Closed private windows are not stored in sessionstore, we do + // not need to check access for that. + let closedWindowData = SessionStore.getClosedWindowData(); + for (let window of closedWindowData) { + recentlyClosed.push({ + lastModified: window.closedAt, + window: Window.convertFromSessionStoreClosedData(extension, window), + }); + } + + // Get closed tabs + // Private closed tabs are in sessionstore if the owning window is still open . + for (let window of windowTracker.browserWindows()) { + if (!extension.canAccessWindow(window)) { + continue; + } + let closedTabData = SessionStore.getClosedTabDataForWindow(window); + for (let tab of closedTabData) { + recentlyClosed.push({ + lastModified: tab.closedAt, + tab: Tab.convertFromSessionStoreClosedData(extension, tab, window), + }); + } + } + + // Sort windows and tabs + recentlyClosed.sort((a, b) => b.lastModified - a.lastModified); + return recentlyClosed.slice(0, maxResults); +}; + +const createSession = async function createSession( + restored, + extension, + sessionId +) { + if (!restored) { + throw new ExtensionError( + `Could not restore object using sessionId ${sessionId}.` + ); + } + let sessionObj = { lastModified: Date.now() }; + if (restored instanceof Ci.nsIDOMChromeWindow) { + await promiseObserved( + "sessionstore-single-window-restored", + subject => subject == restored + ); + sessionObj.window = extension.windowManager.convert(restored, { + populate: true, + }); + return sessionObj; + } + sessionObj.tab = extension.tabManager.convert(restored); + return sessionObj; +}; + +const getEncodedKey = function getEncodedKey(extensionId, key) { + // Throw if using a temporary extension id. + if (AddonManagerPrivate.isTemporaryInstallID(extensionId)) { + let message = + "Sessions API storage methods will not work with a temporary addon ID. " + + "Please add an explicit addon ID to your manifest."; + throw new ExtensionError(message); + } + + return `extension:${extensionId}:${key}`; +}; + +this.sessions = class extends ExtensionAPIPersistent { + PERSISTENT_EVENTS = { + onChanged({ fire }) { + let observer = () => { + fire.async(); + }; + + Services.obs.addObserver(observer, SS_ON_CLOSED_OBJECTS_CHANGED); + return { + unregister() { + Services.obs.removeObserver(observer, SS_ON_CLOSED_OBJECTS_CHANGED); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + }; + + getAPI(context) { + let { extension } = context; + + function getTabParams(key, id) { + let encodedKey = getEncodedKey(extension.id, key); + let tab = tabTracker.getTab(id); + if (!context.canAccessWindow(tab.ownerGlobal)) { + throw new ExtensionError(`Invalid tab ID: ${id}`); + } + return { encodedKey, tab }; + } + + function getWindowParams(key, id) { + let encodedKey = getEncodedKey(extension.id, key); + let win = windowTracker.getWindow(id, context); + return { encodedKey, win }; + } + + return { + sessions: { + async getRecentlyClosed(filter) { + await SessionStore.promiseInitialized; + let maxResults = + filter.maxResults == undefined + ? this.MAX_SESSION_RESULTS + : filter.maxResults; + return getRecentlyClosed(maxResults, extension); + }, + + async forgetClosedTab(windowId, sessionId) { + await SessionStore.promiseInitialized; + let window = windowTracker.getWindow(windowId, context); + let closedTabData = SessionStore.getClosedTabDataForWindow(window); + + let closedTabIndex = closedTabData.findIndex(closedTab => { + return closedTab.closedId === parseInt(sessionId, 10); + }); + + if (closedTabIndex < 0) { + throw new ExtensionError( + `Could not find closed tab using sessionId ${sessionId}.` + ); + } + + SessionStore.forgetClosedTab(window, closedTabIndex); + }, + + async forgetClosedWindow(sessionId) { + await SessionStore.promiseInitialized; + let closedWindowData = SessionStore.getClosedWindowData(); + + let closedWindowIndex = closedWindowData.findIndex(closedWindow => { + return closedWindow.closedId === parseInt(sessionId, 10); + }); + + if (closedWindowIndex < 0) { + throw new ExtensionError( + `Could not find closed window using sessionId ${sessionId}.` + ); + } + + SessionStore.forgetClosedWindow(closedWindowIndex); + }, + + async restore(sessionId) { + await SessionStore.promiseInitialized; + let session, closedId; + if (sessionId) { + closedId = sessionId; + session = SessionStore.undoCloseById( + closedId, + extension.privateBrowsingAllowed + ); + } else if (SessionStore.lastClosedObjectType == "window") { + // If the most recently closed object is a window, just undo closing the most recent window. + session = SessionStore.undoCloseWindow(0); + } else { + // It is a tab, and we cannot call SessionStore.undoCloseTab without a window, + // so we must find the tab in which case we can just use its closedId. + let recentlyClosedTabs = []; + for (let window of windowTracker.browserWindows()) { + let closedTabData = + SessionStore.getClosedTabDataForWindow(window); + for (let tab of closedTabData) { + recentlyClosedTabs.push(tab); + } + } + + if (recentlyClosedTabs.length) { + // Sort the tabs. + recentlyClosedTabs.sort((a, b) => b.closedAt - a.closedAt); + + // Use the closedId of the most recently closed tab to restore it. + closedId = recentlyClosedTabs[0].closedId; + session = SessionStore.undoCloseById( + closedId, + extension.privateBrowsingAllowed + ); + } + } + return createSession(session, extension, closedId); + }, + + setTabValue(tabId, key, value) { + let { tab, encodedKey } = getTabParams(key, tabId); + + SessionStore.setCustomTabValue( + tab, + encodedKey, + JSON.stringify(value) + ); + }, + + async getTabValue(tabId, key) { + let { tab, encodedKey } = getTabParams(key, tabId); + + let value = SessionStore.getCustomTabValue(tab, encodedKey); + if (value) { + return JSON.parse(value); + } + + return undefined; + }, + + removeTabValue(tabId, key) { + let { tab, encodedKey } = getTabParams(key, tabId); + + SessionStore.deleteCustomTabValue(tab, encodedKey); + }, + + setWindowValue(windowId, key, value) { + let { win, encodedKey } = getWindowParams(key, windowId); + + SessionStore.setCustomWindowValue( + win, + encodedKey, + JSON.stringify(value) + ); + }, + + async getWindowValue(windowId, key) { + let { win, encodedKey } = getWindowParams(key, windowId); + + let value = SessionStore.getCustomWindowValue(win, encodedKey); + if (value) { + return JSON.parse(value); + } + + return undefined; + }, + + removeWindowValue(windowId, key) { + let { win, encodedKey } = getWindowParams(key, windowId); + + SessionStore.deleteCustomWindowValue(win, encodedKey); + }, + + onChanged: new EventManager({ + context, + module: "sessions", + event: "onChanged", + extensionApi: this, + }).api(), + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-sidebarAction.js b/browser/components/extensions/parent/ext-sidebarAction.js new file mode 100644 index 0000000000..a07f9a9f0e --- /dev/null +++ b/browser/components/extensions/parent/ext-sidebarAction.js @@ -0,0 +1,532 @@ +/* -*- 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"; + +var { ExtensionParent } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionParent.sys.mjs" +); + +var { ExtensionError } = ExtensionUtils; + +var { IconDetails } = ExtensionParent; + +// WeakMap[Extension -> SidebarAction] +let sidebarActionMap = new WeakMap(); + +const sidebarURL = "chrome://browser/content/webext-panels.xhtml"; + +/** + * Responsible for the sidebar_action section of the manifest as well + * as the associated sidebar browser. + */ +this.sidebarAction = class extends ExtensionAPI { + static for(extension) { + return sidebarActionMap.get(extension); + } + + onManifestEntry(entryName) { + let { extension } = this; + + extension.once("ready", this.onReady.bind(this)); + + let options = extension.manifest.sidebar_action; + + // Add the extension to the sidebar menu. The sidebar widget will copy + // from that when it is viewed, so we shouldn't need to update that. + let widgetId = makeWidgetId(extension.id); + this.id = `${widgetId}-sidebar-action`; + this.menuId = `menu_${this.id}`; + this.buttonId = `button_${this.id}`; + + this.browserStyle = options.browser_style; + + this.defaults = { + enabled: true, + title: options.default_title || extension.name, + icon: IconDetails.normalize({ path: options.default_icon }, extension), + panel: options.default_panel || "", + }; + this.globals = Object.create(this.defaults); + + this.tabContext = new TabContext(target => { + let window = target.ownerGlobal; + if (target === window) { + return this.globals; + } + return this.tabContext.get(window); + }); + + // We need to ensure our elements are available before session restore. + this.windowOpenListener = window => { + this.createMenuItem(window, this.globals); + }; + windowTracker.addOpenListener(this.windowOpenListener); + + this.updateHeader = event => { + let window = event.target.ownerGlobal; + let details = this.tabContext.get(window.gBrowser.selectedTab); + let header = window.document.getElementById("sidebar-switcher-target"); + if (window.SidebarUI.currentID === this.id) { + this.setMenuIcon(header, details); + } + }; + + this.windowCloseListener = window => { + let header = window.document.getElementById("sidebar-switcher-target"); + if (header) { + header.removeEventListener("SidebarShown", this.updateHeader); + } + }; + windowTracker.addCloseListener(this.windowCloseListener); + + sidebarActionMap.set(extension, this); + } + + onReady() { + this.build(); + } + + onShutdown(isAppShutdown) { + sidebarActionMap.delete(this.this); + + this.tabContext.shutdown(); + + // Don't remove everything on app shutdown so session restore can handle + // restoring open sidebars. + if (isAppShutdown) { + return; + } + + for (let window of windowTracker.browserWindows()) { + let { document, SidebarUI } = window; + if (SidebarUI.currentID === this.id) { + SidebarUI.hide(); + } + let menu = document.getElementById(this.menuId); + if (menu) { + menu.remove(); + } + let button = document.getElementById(this.buttonId); + if (button) { + button.remove(); + } + let header = document.getElementById("sidebar-switcher-target"); + header.removeEventListener("SidebarShown", this.updateHeader); + SidebarUI.sidebars.delete(this.id); + } + windowTracker.removeOpenListener(this.windowOpenListener); + windowTracker.removeCloseListener(this.windowCloseListener); + } + + static onUninstall(id) { + const sidebarId = `${makeWidgetId(id)}-sidebar-action`; + for (let window of windowTracker.browserWindows()) { + let { SidebarUI } = window; + if (SidebarUI.lastOpenedId === sidebarId) { + SidebarUI.lastOpenedId = null; + } + } + } + + build() { + // eslint-disable-next-line mozilla/balanced-listeners + this.tabContext.on("tab-select", (evt, tab) => { + this.updateWindow(tab.ownerGlobal); + }); + + let install = this.extension.startupReason === "ADDON_INSTALL"; + for (let window of windowTracker.browserWindows()) { + this.updateWindow(window); + let { SidebarUI } = window; + if ( + (install && this.extension.manifest.sidebar_action.open_at_install) || + SidebarUI.lastOpenedId == this.id + ) { + SidebarUI.show(this.id); + } + } + } + + createMenuItem(window, details) { + if (!this.extension.canAccessWindow(window)) { + return; + } + let { document, SidebarUI } = window; + let keyId = `ext-key-id-${this.id}`; + + SidebarUI.sidebars.set(this.id, { + title: details.title, + url: sidebarURL, + menuId: this.menuId, + buttonId: this.buttonId, + // The following properties are specific to extensions + extensionId: this.extension.id, + panel: details.panel, + browserStyle: this.browserStyle, + }); + + let header = document.getElementById("sidebar-switcher-target"); + header.addEventListener("SidebarShown", this.updateHeader); + + // Insert a menuitem for View->Show Sidebars. + let menuitem = document.createXULElement("menuitem"); + menuitem.setAttribute("id", this.menuId); + menuitem.setAttribute("type", "checkbox"); + menuitem.setAttribute("label", details.title); + menuitem.setAttribute("oncommand", `SidebarUI.toggle("${this.id}");`); + menuitem.setAttribute("class", "menuitem-iconic webextension-menuitem"); + menuitem.setAttribute("key", keyId); + this.setMenuIcon(menuitem, details); + + // Insert a toolbarbutton for the sidebar dropdown selector. + let toolbarbutton = document.createXULElement("toolbarbutton"); + toolbarbutton.setAttribute("id", this.buttonId); + toolbarbutton.setAttribute("label", details.title); + toolbarbutton.setAttribute("oncommand", `SidebarUI.show("${this.id}");`); + toolbarbutton.setAttribute( + "class", + "subviewbutton subviewbutton-iconic webextension-menuitem" + ); + toolbarbutton.setAttribute("key", keyId); + this.setMenuIcon(toolbarbutton, details); + + document.getElementById("viewSidebarMenu").appendChild(menuitem); + let separator = document.getElementById("sidebar-extensions-separator"); + separator.parentNode.insertBefore(toolbarbutton, separator); + SidebarUI.updateShortcut({ button: toolbarbutton }); + + return menuitem; + } + + setMenuIcon(menuitem, details) { + let getIcon = size => + IconDetails.escapeUrl( + IconDetails.getPreferredIcon(details.icon, this.extension, size).icon + ); + + menuitem.setAttribute( + "style", + ` + --webextension-menuitem-image: url("${getIcon(16)}"); + --webextension-menuitem-image-2x: url("${getIcon(32)}"); + ` + ); + } + + /** + * Update the menu items with the tab context data in `tabData`. + * + * @param {ChromeWindow} window + * Browser chrome window. + * @param {object} tabData + * Tab specific sidebar configuration. + */ + updateButton(window, tabData) { + let { document, SidebarUI } = window; + let title = tabData.title || this.extension.name; + let menu = document.getElementById(this.menuId); + if (!menu) { + menu = this.createMenuItem(window, tabData); + } + + let urlChanged = tabData.panel !== SidebarUI.sidebars.get(this.id).panel; + if (urlChanged) { + SidebarUI.sidebars.get(this.id).panel = tabData.panel; + } + + menu.setAttribute("label", title); + this.setMenuIcon(menu, tabData); + + let button = document.getElementById(this.buttonId); + button.setAttribute("label", title); + this.setMenuIcon(button, tabData); + + // Update the sidebar if this extension is the current sidebar. + if (SidebarUI.currentID === this.id) { + SidebarUI.title = title; + let header = document.getElementById("sidebar-switcher-target"); + this.setMenuIcon(header, tabData); + if (SidebarUI.isOpen && urlChanged) { + SidebarUI.show(this.id); + } + } + } + + /** + * Update the menu items for a given window. + * + * @param {ChromeWindow} window + * Browser chrome window. + */ + updateWindow(window) { + if (!this.extension.canAccessWindow(window)) { + return; + } + let nativeTab = window.gBrowser.selectedTab; + this.updateButton(window, this.tabContext.get(nativeTab)); + } + + /** + * Update the menu items when the extension changes the icon, + * title, url, etc. If it only changes a parameter for a single tab, `target` + * will be that tab. If it only changes a parameter for a single window, + * `target` will be that window. Otherwise `target` will be null. + * + * @param {XULElement|ChromeWindow|null} target + * Browser tab or browser chrome window, may be null. + */ + updateOnChange(target) { + if (target) { + let window = target.ownerGlobal; + if (target === window || target.selected) { + this.updateWindow(window); + } + } else { + for (let window of windowTracker.browserWindows()) { + this.updateWindow(window); + } + } + } + + /** + * Gets the target object corresponding to the `details` parameter of the various + * get* and set* API methods. + * + * @param {object} details + * An object with optional `tabId` or `windowId` properties. + * @param {number} [details.tabId] + * The target tab. + * @param {number} [details.windowId] + * The target window. + * @throws if both `tabId` and `windowId` are specified, or if they are invalid. + * @returns {XULElement|ChromeWindow|null} + * If a `tabId` was specified, the corresponding XULElement tab. + * If a `windowId` was specified, the corresponding ChromeWindow. + * Otherwise, `null`. + */ + getTargetFromDetails({ tabId, windowId }) { + if (tabId != null && windowId != null) { + throw new ExtensionError( + "Only one of tabId and windowId can be specified." + ); + } + let target = null; + if (tabId != null) { + target = tabTracker.getTab(tabId); + if (!this.extension.canAccessWindow(target.ownerGlobal)) { + throw new ExtensionError(`Invalid tab ID: ${tabId}`); + } + } else if (windowId != null) { + target = windowTracker.getWindow(windowId); + if (!this.extension.canAccessWindow(target)) { + throw new ExtensionError(`Invalid window ID: ${windowId}`); + } + } + return target; + } + + /** + * Gets the data associated with a tab, window, or the global one. + * + * @param {XULElement|ChromeWindow|null} target + * A XULElement tab, a ChromeWindow, or null for the global data. + * @returns {object} + * The icon, title, panel, etc. associated with the target. + */ + getContextData(target) { + if (target) { + return this.tabContext.get(target); + } + return this.globals; + } + + /** + * Set a global, window specific or tab specific property. + * + * @param {XULElement|ChromeWindow|null} target + * A XULElement tab, a ChromeWindow, or null for the global data. + * @param {string} prop + * String property to set ["icon", "title", or "panel"]. + * @param {string} value + * Value for property. + */ + setProperty(target, prop, value) { + let values = this.getContextData(target); + if (value === null) { + delete values[prop]; + } else { + values[prop] = value; + } + + this.updateOnChange(target); + } + + /** + * Retrieve the value of a global, window specific or tab specific property. + * + * @param {XULElement|ChromeWindow|null} target + * A XULElement tab, a ChromeWindow, or null for the global data. + * @param {string} prop + * String property to retrieve ["icon", "title", or "panel"] + * @returns {string} value + * Value of prop. + */ + getProperty(target, prop) { + return this.getContextData(target)[prop]; + } + + setPropertyFromDetails(details, prop, value) { + return this.setProperty(this.getTargetFromDetails(details), prop, value); + } + + getPropertyFromDetails(details, prop) { + return this.getProperty(this.getTargetFromDetails(details), prop); + } + + /** + * Triggers this sidebar action for the given window, with the same effects as + * if it were toggled via menu or toolbarbutton by a user. + * + * @param {ChromeWindow} window + */ + triggerAction(window) { + let { SidebarUI } = window; + if (SidebarUI && this.extension.canAccessWindow(window)) { + SidebarUI.toggle(this.id); + } + } + + /** + * Opens this sidebar action for the given window. + * + * @param {ChromeWindow} window + */ + open(window) { + let { SidebarUI } = window; + if (SidebarUI && this.extension.canAccessWindow(window)) { + SidebarUI.show(this.id); + } + } + + /** + * Closes this sidebar action for the given window if this sidebar action is open. + * + * @param {ChromeWindow} window + */ + close(window) { + if (this.isOpen(window)) { + window.SidebarUI.hide(); + } + } + + /** + * Toogles this sidebar action for the given window + * + * @param {ChromeWindow} window + */ + toggle(window) { + let { SidebarUI } = window; + if (!SidebarUI || !this.extension.canAccessWindow(window)) { + return; + } + + if (!this.isOpen(window)) { + SidebarUI.show(this.id); + } else { + SidebarUI.hide(); + } + } + + /** + * Checks whether this sidebar action is open in the given window. + * + * @param {ChromeWindow} window + * @returns {boolean} + */ + isOpen(window) { + let { SidebarUI } = window; + return SidebarUI.isOpen && this.id == SidebarUI.currentID; + } + + getAPI(context) { + let { extension } = context; + const sidebarAction = this; + + return { + sidebarAction: { + async setTitle(details) { + sidebarAction.setPropertyFromDetails(details, "title", details.title); + }, + + getTitle(details) { + return sidebarAction.getPropertyFromDetails(details, "title"); + }, + + async setIcon(details) { + let icon = IconDetails.normalize(details, extension, context); + if (!Object.keys(icon).length) { + icon = null; + } + sidebarAction.setPropertyFromDetails(details, "icon", icon); + }, + + async setPanel(details) { + let url; + // Clear the url when given null or empty string. + if (!details.panel) { + url = null; + } else { + url = context.uri.resolve(details.panel); + if (!context.checkLoadURL(url)) { + return Promise.reject({ + message: `Access denied for URL ${url}`, + }); + } + } + + sidebarAction.setPropertyFromDetails(details, "panel", url); + }, + + getPanel(details) { + return sidebarAction.getPropertyFromDetails(details, "panel"); + }, + + open() { + let window = windowTracker.topWindow; + if (context.canAccessWindow(window)) { + sidebarAction.open(window); + } + }, + + close() { + let window = windowTracker.topWindow; + if (context.canAccessWindow(window)) { + sidebarAction.close(window); + } + }, + + toggle() { + let window = windowTracker.topWindow; + if (context.canAccessWindow(window)) { + sidebarAction.toggle(window); + } + }, + + isOpen(details) { + let { windowId } = details; + if (windowId == null) { + windowId = Window.WINDOW_ID_CURRENT; + } + let window = windowTracker.getWindow(windowId, context); + return sidebarAction.isOpen(window); + }, + }, + }; + } +}; + +global.sidebarActionFor = this.sidebarAction.for; diff --git a/browser/components/extensions/parent/ext-tabs.js b/browser/components/extensions/parent/ext-tabs.js new file mode 100644 index 0000000000..c8d6b9f6dd --- /dev/null +++ b/browser/components/extensions/parent/ext-tabs.js @@ -0,0 +1,1627 @@ +/* -*- 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", + ExtensionControlledPopup: + "resource:///modules/ExtensionControlledPopup.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", + PromiseUtils: "resource://gre/modules/PromiseUtils.sys.mjs", + SessionStore: "resource:///modules/sessionstore/SessionStore.sys.mjs", +}); + +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.fixupAndLoadURIString(url, options); + } else { + // Shift to fully loaded browser and make + // sure load handler is instantiated. + nativeTab.addEventListener( + "SSTabRestoring", + () => browser.fixupAndLoadURIString(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 lastInsertionMap = 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 isSameWindow = nativeTab.ownerGlobal == window; + 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 (isSameWindow && gBrowser.tabs.length === 1) { + lastInsertionMap.set(window, 0); + continue; + } + // If moving between windows, be sure privacy matches. While gBrowser + // prevents this, we want to silently ignore it. + if ( + !isSameWindow && + PrivateBrowsingUtils.isBrowserPrivate(gBrowser) != + PrivateBrowsingUtils.isBrowserPrivate( + nativeTab.ownerGlobal.gBrowser + ) + ) { + continue; + } + + let insertionPoint; + let lastInsertion = lastInsertionMap.get(window); + if (lastInsertion == null) { + insertionPoint = moveProperties.index; + let maxIndex = gBrowser.tabs.length - (isSameWindow ? 1 : 0); + if (insertionPoint == -1) { + // If the index is -1 it should go to the end of the tabs. + insertionPoint = maxIndex; + } else { + insertionPoint = Math.min(insertionPoint, maxIndex); + } + } else if (isSameWindow && nativeTab._tPos <= lastInsertion) { + // lastInsertion is the current index of the last inserted tab. + // insertionPoint is the desired index of the current tab *after* moving it. + // When the tab is moved, the last inserted tab will no longer be at index + // lastInsertion, but (lastInsertion - 1). To position the tabs adjacent to + // each other, the tab should therefore be at index (lastInsertion - 1 + 1). + insertionPoint = lastInsertion; + } else { + // In this case the last inserted tab will stay at index lastInsertion, + // so we should move the current tab to index (lastInsertion + 1). + insertionPoint = lastInsertion + 1; + } + + // 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 (isSameWindow) { + // If the window we are moving is the same, just move the tab. + gBrowser.moveTabTo(nativeTab, insertionPoint); + } else { + // 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); + } + lastInsertionMap.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; + } +}; diff --git a/browser/components/extensions/parent/ext-topSites.js b/browser/components/extensions/parent/ext-topSites.js new file mode 100644 index 0000000000..76a815f1ef --- /dev/null +++ b/browser/components/extensions/parent/ext-topSites.js @@ -0,0 +1,120 @@ +/* -*- 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.defineESModuleGetters(this, { + NewTabUtils: "resource://gre/modules/NewTabUtils.sys.mjs", + getSearchProvider: "resource://activity-stream/lib/SearchShortcuts.sys.mjs", +}); + +XPCOMUtils.defineLazyModuleGetters(this, { + AboutNewTab: "resource:///modules/AboutNewTab.jsm", + shortURL: "resource://activity-stream/lib/ShortURL.jsm", +}); + +const SHORTCUTS_PREF = + "browser.newtabpage.activity-stream.improvesearch.topSiteSearchShortcuts"; +const TOPSITES_FEED_PREF = + "browser.newtabpage.activity-stream.feeds.system.topsites"; + +this.topSites = class extends ExtensionAPI { + getAPI(context) { + return { + topSites: { + get: async function (options) { + // We fallback to newtab = false behavior if the user disabled their + // Top Sites feed. + let getNewtabSites = + options.newtab && + Services.prefs.getBoolPref(TOPSITES_FEED_PREF, false); + let links = getNewtabSites + ? AboutNewTab.getTopSites() + : await NewTabUtils.activityStreamLinks.getTopSites({ + ignoreBlocked: options.includeBlocked, + onePerDomain: options.onePerDomain, + numItems: options.limit, + includeFavicon: options.includeFavicon, + }); + + if (options.includePinned && !getNewtabSites) { + let pinnedLinks = NewTabUtils.pinnedLinks.links; + if (options.includeFavicon) { + pinnedLinks = + NewTabUtils.activityStreamProvider._faviconBytesToDataURI( + await NewTabUtils.activityStreamProvider._addFavicons( + pinnedLinks + ) + ); + } + pinnedLinks.forEach((pinnedLink, index) => { + if ( + pinnedLink && + (!pinnedLink.searchTopSite || options.includeSearchShortcuts) + ) { + // Remove any dupes from history. + links = links.filter( + link => + link.url != pinnedLink.url && + (!options.onePerDomain || + NewTabUtils.extractSite(link.url) != + pinnedLink.baseDomain) + ); + links.splice(index, 0, pinnedLink); + } + }); + } + + // Convert links to search shortcuts, if necessary. + if ( + options.includeSearchShortcuts && + Services.prefs.getBoolPref(SHORTCUTS_PREF, false) && + !getNewtabSites + ) { + // Pinned shortcuts are already returned as searchTopSite links, + // with a proper label and url. But certain non-pinned links may + // also be promoted to search shortcuts; here we convert them. + links = links.map(link => { + let searchProvider = getSearchProvider(shortURL(link)); + if (searchProvider) { + link.searchTopSite = true; + link.label = searchProvider.keyword; + link.url = searchProvider.url; + } + return link; + }); + } + + // Because we may have added links, we must crop again. + if (typeof options.limit == "number") { + links = links.slice(0, options.limit); + } + + const makeDataURI = url => url && ExtensionUtils.makeDataURI(url); + + return Promise.all( + links.map(async link => ({ + type: link.searchTopSite ? "search" : "url", + url: link.url, + // The newtab page allows the user to set custom site titles, which + // are stored in `label`, so prefer it. Search top sites currently + // don't have titles but `hostname` instead. + title: link.label || link.title || link.hostname || "", + // Default top sites don't have a favicon property. Instead they + // have tippyTopIcon, a 96x96pt image used on the newtab page. + // We'll use it as the favicon for now, but ideally default top + // sites would have real favicons. Non-default top sites (i.e., + // those from the user's history) will have favicons. + favicon: options.includeFavicon + ? link.favicon || (await makeDataURI(link.tippyTopIcon)) || null + : null, + })) + ); + }, + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-url-overrides.js b/browser/components/extensions/parent/ext-url-overrides.js new file mode 100644 index 0000000000..07e35441ef --- /dev/null +++ b/browser/components/extensions/parent/ext-url-overrides.js @@ -0,0 +1,210 @@ +/* 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"; + +var { ExtensionParent } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionParent.sys.mjs" +); + +ChromeUtils.defineESModuleGetters(this, { + ExtensionControlledPopup: + "resource:///modules/ExtensionControlledPopup.sys.mjs", + ExtensionSettingsStore: + "resource://gre/modules/ExtensionSettingsStore.sys.mjs", +}); +ChromeUtils.defineModuleGetter( + this, + "AboutNewTab", + "resource:///modules/AboutNewTab.jsm" +); + +const STORE_TYPE = "url_overrides"; +const NEW_TAB_SETTING_NAME = "newTabURL"; +const NEW_TAB_CONFIRMED_TYPE = "newTabNotification"; +const NEW_TAB_PRIVATE_ALLOWED = "browser.newtab.privateAllowed"; +const NEW_TAB_EXTENSION_CONTROLLED = "browser.newtab.extensionControlled"; + +XPCOMUtils.defineLazyGetter(this, "newTabPopup", () => { + return new ExtensionControlledPopup({ + confirmedType: NEW_TAB_CONFIRMED_TYPE, + observerTopic: "browser-open-newtab-start", + popupnotificationId: "extension-new-tab-notification", + settingType: STORE_TYPE, + settingKey: NEW_TAB_SETTING_NAME, + descriptionId: "extension-new-tab-notification-description", + descriptionMessageId: "newTabControlled.message2", + learnMoreMessageId: "newTabControlled.learnMore", + learnMoreLink: "extension-home", + preferencesLocation: "home-newtabOverride", + preferencesEntrypoint: "addon-manage-newtab-override", + onObserverAdded() { + AboutNewTab.willNotifyUser = true; + }, + onObserverRemoved() { + AboutNewTab.willNotifyUser = false; + }, + async beforeDisableAddon(popup, win) { + // ExtensionControlledPopup will disable the add-on once this function completes. + // Disabling an add-on should remove the tabs that it has open, but we want + // to open the new New Tab in this tab (which might get closed). + // 1. Replace the tab's URL with about:blank + // 2. Return control to ExtensionControlledPopup once about:blank has loaded + // 3. Once the New Tab URL has changed, replace the tab's URL with the new New Tab URL + let gBrowser = win.gBrowser; + let tab = gBrowser.selectedTab; + await replaceUrlInTab(gBrowser, tab, Services.io.newURI("about:blank")); + Services.obs.addObserver( + { + async observe() { + await replaceUrlInTab( + gBrowser, + tab, + Services.io.newURI(AboutNewTab.newTabURL) + ); + // Now that the New Tab is loading, try to open the popup again. This + // will only open the popup if a new extension is controlling the New Tab. + popup.open(); + Services.obs.removeObserver(this, "newtab-url-changed"); + }, + }, + "newtab-url-changed" + ); + }, + }); +}); + +function setNewTabURL(extensionId, url) { + if (extensionId) { + newTabPopup.addObserver(extensionId); + let policy = ExtensionParent.WebExtensionPolicy.getByID(extensionId); + Services.prefs.setBoolPref( + NEW_TAB_PRIVATE_ALLOWED, + policy && policy.privateBrowsingAllowed + ); + Services.prefs.setBoolPref(NEW_TAB_EXTENSION_CONTROLLED, true); + } else { + newTabPopup.removeObserver(); + Services.prefs.clearUserPref(NEW_TAB_PRIVATE_ALLOWED); + Services.prefs.clearUserPref(NEW_TAB_EXTENSION_CONTROLLED); + } + if (url) { + AboutNewTab.newTabURL = url; + } +} + +// eslint-disable-next-line mozilla/balanced-listeners +ExtensionParent.apiManager.on( + "extension-setting-changed", + async (eventName, setting) => { + let extensionId, url; + if (setting.type === STORE_TYPE && setting.key === NEW_TAB_SETTING_NAME) { + // If the actual setting has changed in some way, we will have + // setting.item which is what the setting has been changed to. If + // we have an item, we always want to update the newTabUrl values. + let { item } = setting; + if (item) { + // If we're resetting, id will be undefined. + extensionId = item.id; + url = item.value || item.initialValue; + setNewTabURL(extensionId, url); + } + } + } +); + +async function processSettings(action, id) { + await ExtensionSettingsStore.initialize(); + if (ExtensionSettingsStore.hasSetting(id, STORE_TYPE, NEW_TAB_SETTING_NAME)) { + ExtensionSettingsStore[action](id, STORE_TYPE, NEW_TAB_SETTING_NAME); + } +} + +this.urlOverrides = class extends ExtensionAPI { + static async onDisable(id) { + newTabPopup.clearConfirmation(id); + await processSettings("disable", id); + } + + static async onEnabling(id) { + await processSettings("enable", id); + } + + static async onUninstall(id) { + // TODO: This can be removed once bug 1438364 is fixed and all data is cleaned up. + newTabPopup.clearConfirmation(id); + await processSettings("removeSetting", id); + } + + static async onUpdate(id, manifest) { + if ( + !manifest.chrome_url_overrides || + !manifest.chrome_url_overrides.newtab + ) { + await ExtensionSettingsStore.initialize(); + if ( + ExtensionSettingsStore.hasSetting(id, STORE_TYPE, NEW_TAB_SETTING_NAME) + ) { + ExtensionSettingsStore.removeSetting( + id, + STORE_TYPE, + NEW_TAB_SETTING_NAME + ); + } + } + } + + async onManifestEntry(entryName) { + let { extension } = this; + let { manifest } = extension; + + if (manifest.chrome_url_overrides.newtab) { + let url = extension.baseURI.resolve(manifest.chrome_url_overrides.newtab); + + await ExtensionSettingsStore.initialize(); + let item = await ExtensionSettingsStore.addSetting( + extension.id, + STORE_TYPE, + NEW_TAB_SETTING_NAME, + url, + () => AboutNewTab.newTabURL + ); + + // Set the newTabURL to the current value of the setting. + if (item) { + setNewTabURL(item.id, item.value || item.initialValue); + } + + // We need to monitor permission change and update the preferences. + // eslint-disable-next-line mozilla/balanced-listeners + extension.on("add-permissions", async (ignoreEvent, permissions) => { + if ( + permissions.permissions.includes("internal:privateBrowsingAllowed") + ) { + let item = await ExtensionSettingsStore.getSetting( + STORE_TYPE, + NEW_TAB_SETTING_NAME + ); + if (item && item.id == extension.id) { + Services.prefs.setBoolPref(NEW_TAB_PRIVATE_ALLOWED, true); + } + } + }); + // eslint-disable-next-line mozilla/balanced-listeners + extension.on("remove-permissions", async (ignoreEvent, permissions) => { + if ( + permissions.permissions.includes("internal:privateBrowsingAllowed") + ) { + let item = await ExtensionSettingsStore.getSetting( + STORE_TYPE, + NEW_TAB_SETTING_NAME + ); + if (item && item.id == extension.id) { + Services.prefs.setBoolPref(NEW_TAB_PRIVATE_ALLOWED, false); + } + } + }); + } + } +}; diff --git a/browser/components/extensions/parent/ext-urlbar.js b/browser/components/extensions/parent/ext-urlbar.js new file mode 100644 index 0000000000..1632558461 --- /dev/null +++ b/browser/components/extensions/parent/ext-urlbar.js @@ -0,0 +1,153 @@ +/* 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.defineESModuleGetters(this, { + UrlbarPrefs: "resource:///modules/UrlbarPrefs.sys.mjs", + UrlbarProviderExtension: + "resource:///modules/UrlbarProviderExtension.sys.mjs", +}); + +var { ExtensionPreferencesManager } = ChromeUtils.importESModule( + "resource://gre/modules/ExtensionPreferencesManager.sys.mjs" +); +var { getSettingsAPI } = ExtensionPreferencesManager; + +ExtensionPreferencesManager.addSetting("engagementTelemetry", { + prefNames: ["browser.urlbar.eventTelemetry.enabled"], + setCallback(value) { + return { [this.prefNames[0]]: value }; + }, +}); + +this.urlbar = class extends ExtensionAPI { + getAPI(context) { + return { + urlbar: { + closeView() { + let window = windowTracker.getTopNormalWindow(context); + window.gURLBar.view.close(); + }, + + focus(select = false) { + let window = windowTracker.getTopNormalWindow(context); + if (select) { + window.gURLBar.select(); + } else { + window.gURLBar.focus(); + } + }, + + search(searchString, options = {}) { + let window = windowTracker.getTopNormalWindow(context); + window.gURLBar.search(searchString, options); + }, + + onBehaviorRequested: new EventManager({ + context, + name: "urlbar.onBehaviorRequested", + register: (fire, providerName) => { + let provider = UrlbarProviderExtension.getOrCreate(providerName); + provider.setEventListener( + "behaviorRequested", + async queryContext => { + if (queryContext.isPrivate && !context.privateBrowsingAllowed) { + return "inactive"; + } + return fire.async(queryContext).catch(error => { + throw context.normalizeError(error); + }); + } + ); + return () => provider.setEventListener("behaviorRequested", null); + }, + }).api(), + + onEngagement: new EventManager({ + context, + name: "urlbar.onEngagement", + register: (fire, providerName) => { + let provider = UrlbarProviderExtension.getOrCreate(providerName); + provider.setEventListener( + "engagement", + async (isPrivate, state) => { + if (isPrivate && !context.privateBrowsingAllowed) { + return; + } + return fire.async(state).catch(error => { + throw context.normalizeError(error); + }); + } + ); + return () => provider.setEventListener("engagement", null); + }, + }).api(), + + onQueryCanceled: new EventManager({ + context, + name: "urlbar.onQueryCanceled", + register: (fire, providerName) => { + let provider = UrlbarProviderExtension.getOrCreate(providerName); + provider.setEventListener("queryCanceled", async queryContext => { + if (queryContext.isPrivate && !context.privateBrowsingAllowed) { + return; + } + await fire.async(queryContext).catch(error => { + throw context.normalizeError(error); + }); + }); + return () => provider.setEventListener("queryCanceled", null); + }, + }).api(), + + onResultsRequested: new EventManager({ + context, + name: "urlbar.onResultsRequested", + register: (fire, providerName) => { + let provider = UrlbarProviderExtension.getOrCreate(providerName); + provider.setEventListener( + "resultsRequested", + async queryContext => { + if (queryContext.isPrivate && !context.privateBrowsingAllowed) { + return []; + } + return fire.async(queryContext).catch(error => { + throw context.normalizeError(error); + }); + } + ); + return () => provider.setEventListener("resultsRequested", null); + }, + }).api(), + + onResultPicked: new EventManager({ + context, + name: "urlbar.onResultPicked", + inputHandling: true, + register: (fire, providerName) => { + let provider = UrlbarProviderExtension.getOrCreate(providerName); + provider.setEventListener( + "resultPicked", + async (resultPayload, dynamicElementName) => { + return fire + .async(resultPayload, dynamicElementName) + .catch(error => { + throw context.normalizeError(error); + }); + } + ); + return () => provider.setEventListener("resultPicked", null); + }, + }).api(), + + engagementTelemetry: getSettingsAPI({ + context, + name: "engagementTelemetry", + callback: () => UrlbarPrefs.get("eventTelemetry.enabled"), + }), + }, + }; + } +}; diff --git a/browser/components/extensions/parent/ext-windows.js b/browser/components/extensions/parent/ext-windows.js new file mode 100644 index 0000000000..37c837b99e --- /dev/null +++ b/browser/components/extensions/parent/ext-windows.js @@ -0,0 +1,548 @@ +/* -*- 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, + "HomePage", + "resource:///modules/HomePage.jsm" +); +ChromeUtils.defineESModuleGetters(this, { + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", +}); + +var { ExtensionError, promiseObserved } = ExtensionUtils; + +function sanitizePositionParams(params, window = null, positionOffset = 0) { + if (params.left === null && params.top === null) { + return; + } + + if (params.left === null) { + const baseLeft = window ? window.screenX : 0; + params.left = baseLeft + positionOffset; + } + if (params.top === null) { + const baseTop = window ? window.screenY : 0; + params.top = baseTop + positionOffset; + } + + // boundary check: don't put window out of visible area + const baseWidth = window ? window.outerWidth : 0; + const baseHeight = window ? window.outerHeight : 0; + // Secure minimum size of an window should be same to the one + // defined at nsGlobalWindowOuter::CheckSecurityWidthAndHeight. + const minWidth = 100; + const minHeight = 100; + const width = Math.max( + minWidth, + params.width !== null ? params.width : baseWidth + ); + const height = Math.max( + minHeight, + params.height !== null ? params.height : baseHeight + ); + const screenManager = Cc["@mozilla.org/gfx/screenmanager;1"].getService( + Ci.nsIScreenManager + ); + const screen = screenManager.screenForRect( + params.left, + params.top, + width, + height + ); + const availDeviceLeft = {}; + const availDeviceTop = {}; + const availDeviceWidth = {}; + const availDeviceHeight = {}; + screen.GetAvailRect( + availDeviceLeft, + availDeviceTop, + availDeviceWidth, + availDeviceHeight + ); + const slopX = window?.screenEdgeSlopX || 0; + const slopY = window?.screenEdgeSlopY || 0; + const factor = screen.defaultCSSScaleFactor; + const availLeft = Math.floor(availDeviceLeft.value / factor) - slopX; + const availTop = Math.floor(availDeviceTop.value / factor) - slopY; + const availWidth = Math.floor(availDeviceWidth.value / factor) + slopX; + const availHeight = Math.floor(availDeviceHeight.value / factor) + slopY; + params.left = Math.min( + availLeft + availWidth - width, + Math.max(availLeft, params.left) + ); + params.top = Math.min( + availTop + availHeight - height, + Math.max(availTop, params.top) + ); +} + +this.windows = class extends ExtensionAPIPersistent { + windowEventRegistrar(event, listener) { + let { extension } = this; + return ({ fire }) => { + let listener2 = (window, ...args) => { + if (extension.canAccessWindow(window)) { + listener(fire, window, ...args); + } + }; + + windowTracker.addListener(event, listener2); + return { + unregister() { + windowTracker.removeListener(event, listener2); + }, + convert(_fire) { + fire = _fire; + }, + }; + }; + } + + PERSISTENT_EVENTS = { + onCreated: this.windowEventRegistrar("domwindowopened", (fire, window) => { + fire.async(this.extension.windowManager.convert(window)); + }), + onRemoved: this.windowEventRegistrar("domwindowclosed", (fire, window) => { + fire.async(windowTracker.getId(window)); + }), + onFocusChanged({ fire }) { + let { extension } = this; + // Keep track of the last windowId used to fire an onFocusChanged event + let lastOnFocusChangedWindowId; + + let listener = event => { + // Wait a tick to avoid firing a superfluous WINDOW_ID_NONE + // event when switching focus between two Firefox windows. + Promise.resolve().then(() => { + let windowId = Window.WINDOW_ID_NONE; + let window = Services.focus.activeWindow; + if (window && extension.canAccessWindow(window)) { + windowId = windowTracker.getId(window); + } + if (windowId !== lastOnFocusChangedWindowId) { + fire.async(windowId); + lastOnFocusChangedWindowId = windowId; + } + }); + }; + windowTracker.addListener("focus", listener); + windowTracker.addListener("blur", listener); + return { + unregister() { + windowTracker.removeListener("focus", listener); + windowTracker.removeListener("blur", listener); + }, + convert(_fire) { + fire = _fire; + }, + }; + }, + }; + + getAPI(context) { + let { extension } = context; + + const { windowManager } = extension; + + return { + windows: { + onCreated: new EventManager({ + context, + module: "windows", + event: "onCreated", + extensionApi: this, + }).api(), + + onRemoved: new EventManager({ + context, + module: "windows", + event: "onRemoved", + extensionApi: this, + }).api(), + + onFocusChanged: new EventManager({ + context, + module: "windows", + event: "onFocusChanged", + extensionApi: this, + }).api(), + + get: function (windowId, getInfo) { + let window = windowTracker.getWindow(windowId, context); + if (!window || !context.canAccessWindow(window)) { + return Promise.reject({ + message: `Invalid window ID: ${windowId}`, + }); + } + return Promise.resolve(windowManager.convert(window, getInfo)); + }, + + getCurrent: function (getInfo) { + let window = context.currentWindow || windowTracker.topWindow; + if (!context.canAccessWindow(window)) { + return Promise.reject({ message: `Invalid window` }); + } + return Promise.resolve(windowManager.convert(window, getInfo)); + }, + + getLastFocused: function (getInfo) { + let window = windowTracker.topWindow; + if (!context.canAccessWindow(window)) { + return Promise.reject({ message: `Invalid window` }); + } + return Promise.resolve(windowManager.convert(window, getInfo)); + }, + + getAll: function (getInfo) { + let doNotCheckTypes = + getInfo === null || getInfo.windowTypes === null; + let windows = []; + // incognito access is checked in getAll + for (let win of windowManager.getAll()) { + if (doNotCheckTypes || getInfo.windowTypes.includes(win.type)) { + windows.push(win.convert(getInfo)); + } + } + return windows; + }, + + create: async function (createData) { + let needResize = + createData.left !== null || + createData.top !== null || + createData.width !== null || + createData.height !== null; + if (createData.incognito && !context.privateBrowsingAllowed) { + throw new ExtensionError( + "Extension does not have permission for incognito mode" + ); + } + + if (needResize) { + if (createData.state !== null && createData.state != "normal") { + throw new ExtensionError( + `"state": "${createData.state}" may not be combined with "left", "top", "width", or "height"` + ); + } + createData.state = "normal"; + } + + function mkstr(s) { + let result = Cc["@mozilla.org/supports-string;1"].createInstance( + Ci.nsISupportsString + ); + result.data = s; + return result; + } + + let args = Cc["@mozilla.org/array;1"].createInstance( + Ci.nsIMutableArray + ); + + // Whether there is only one URL to load, and it is a moz-extension:-URL. + let isOnlyMozExtensionUrl = false; + + // Creating a new window allows one single triggering principal for all tabs that + // are created in the window. Due to that, if we need a browser principal to load + // some urls, we fallback to using a content principal like we do in the tabs api. + // Throws if url is an array and any url can't be loaded by the extension principal. + let principal = context.principal; + function setContentTriggeringPrincipal(url) { + principal = Services.scriptSecurityManager.createContentPrincipal( + Services.io.newURI(url), + { + // Note: privateBrowsingAllowed was already checked before. + privateBrowsingId: createData.incognito ? 1 : 0, + } + ); + } + + if (createData.tabId !== null) { + if (createData.url !== null) { + throw new ExtensionError( + "`tabId` may not be used in conjunction with `url`" + ); + } + + if (createData.allowScriptsToClose) { + throw new ExtensionError( + "`tabId` may not be used in conjunction with `allowScriptsToClose`" + ); + } + + let tab = tabTracker.getTab(createData.tabId); + if (!context.canAccessWindow(tab.ownerGlobal)) { + throw new ExtensionError(`Invalid tab ID: ${createData.tabId}`); + } + // Private browsing tabs can only be moved to private browsing + // windows. + let incognito = PrivateBrowsingUtils.isBrowserPrivate( + tab.linkedBrowser + ); + if ( + createData.incognito !== null && + createData.incognito != incognito + ) { + throw new ExtensionError( + "`incognito` property must match the incognito state of tab" + ); + } + createData.incognito = incognito; + + if ( + createData.cookieStoreId && + createData.cookieStoreId !== + getCookieStoreIdForTab(createData, tab) + ) { + throw new ExtensionError( + "`cookieStoreId` must match the tab's cookieStoreId" + ); + } + + args.appendElement(tab); + } else if (createData.url !== null) { + if (Array.isArray(createData.url)) { + let array = Cc["@mozilla.org/array;1"].createInstance( + Ci.nsIMutableArray + ); + for (let url of createData.url.map(u => context.uri.resolve(u))) { + // We can only provide a single triggering principal when + // opening a window, so if the extension cannot normally + // access a url, we fail. This includes about and moz-ext + // urls. + if (!context.checkLoadURL(url, { dontReportErrors: true })) { + return Promise.reject({ message: `Illegal URL: ${url}` }); + } + array.appendElement(mkstr(url)); + } + args.appendElement(array); + // TODO bug 1780583: support multiple triggeringPrincipals to + // avoid having to use the system principal here. + principal = Services.scriptSecurityManager.getSystemPrincipal(); + } else { + let url = context.uri.resolve(createData.url); + args.appendElement(mkstr(url)); + isOnlyMozExtensionUrl = url.startsWith("moz-extension://"); + if (!context.checkLoadURL(url, { dontReportErrors: true })) { + if (isOnlyMozExtensionUrl) { + // For backwards-compatibility (also in tabs APIs), we allow + // extensions to open other moz-extension:-URLs even if that + // other resource is not listed in web_accessible_resources. + setContentTriggeringPrincipal(url); + } else { + throw new ExtensionError(`Illegal URL: ${url}`); + } + } + } + } else { + let url = + createData.incognito && + !PrivateBrowsingUtils.permanentPrivateBrowsing + ? "about:privatebrowsing" + : HomePage.get().split("|", 1)[0]; + args.appendElement(mkstr(url)); + isOnlyMozExtensionUrl = url.startsWith("moz-extension://"); + + if (!context.checkLoadURL(url, { dontReportErrors: true })) { + // The extension principal cannot directly load about:-URLs, + // except for about:blank, or other moz-extension:-URLs that are + // not in web_accessible_resources. Ensure any page set as a home + // page will load by using a content principal. + setContentTriggeringPrincipal(url); + } + } + + args.appendElement(null); // extraOptions + args.appendElement(null); // referrerInfo + args.appendElement(null); // postData + args.appendElement(null); // allowThirdPartyFixup + + if (createData.cookieStoreId) { + let userContextIdSupports = Cc[ + "@mozilla.org/supports-PRUint32;1" + ].createInstance(Ci.nsISupportsPRUint32); + // May throw if validation fails. + userContextIdSupports.data = getUserContextIdForCookieStoreId( + extension, + createData.cookieStoreId, + createData.incognito + ); + + args.appendElement(userContextIdSupports); // userContextId + } else { + args.appendElement(null); + } + + args.appendElement(context.principal); // originPrincipal - not important. + args.appendElement(context.principal); // originStoragePrincipal - not important. + args.appendElement(principal); // triggeringPrincipal + args.appendElement( + Cc["@mozilla.org/supports-PRBool;1"].createInstance( + Ci.nsISupportsPRBool + ) + ); // allowInheritPrincipal + // There is no CSP associated with this extension, hence we explicitly pass null as the CSP argument. + args.appendElement(null); // csp + + let features = ["chrome"]; + + if (createData.type === null || createData.type == "normal") { + features.push("dialog=no", "all"); + } else { + // All other types create "popup"-type windows by default. + features.push( + "dialog", + "resizable", + "minimizable", + "titlebar", + "close" + ); + if (createData.left === null && createData.top === null) { + features.push("centerscreen"); + } + } + + if (createData.incognito !== null) { + if (createData.incognito) { + if (!PrivateBrowsingUtils.enabled) { + throw new ExtensionError( + "`incognito` cannot be used if incognito mode is disabled" + ); + } + features.push("private"); + } else { + features.push("non-private"); + } + } + + const baseWindow = windowTracker.getTopNormalWindow(context); + // 10px offset is same to Chromium + sanitizePositionParams(createData, baseWindow, 10); + + let window = Services.ww.openWindow( + null, + AppConstants.BROWSER_CHROME_URL, + "_blank", + features.join(","), + args + ); + + let win = windowManager.getWrapper(window); + win.updateGeometry(createData); + + // TODO: focused, type + + const contentLoaded = new Promise(resolve => { + window.addEventListener( + "DOMContentLoaded", + function () { + let { allowScriptsToClose } = createData; + if (allowScriptsToClose === null && isOnlyMozExtensionUrl) { + allowScriptsToClose = true; + } + if (allowScriptsToClose) { + window.gBrowserAllowScriptsToCloseInitialTabs = true; + } + resolve(); + }, + { once: true } + ); + }); + + const startupFinished = promiseObserved( + "browser-delayed-startup-finished", + win => win == window + ); + + await contentLoaded; + await startupFinished; + + if ( + [ + "minimized", + "fullscreen", + "docked", + "normal", + "maximized", + ].includes(createData.state) + ) { + await win.setState(createData.state); + } + + if (createData.titlePreface !== null) { + win.setTitlePreface(createData.titlePreface); + } + return win.convert({ populate: true }); + }, + + update: async function (windowId, updateInfo) { + if (updateInfo.state !== null && updateInfo.state != "normal") { + if ( + updateInfo.left !== null || + updateInfo.top !== null || + updateInfo.width !== null || + updateInfo.height !== null + ) { + throw new ExtensionError( + `"state": "${updateInfo.state}" may not be combined with "left", "top", "width", or "height"` + ); + } + } + + let win = windowManager.get(windowId, context); + if (!win) { + throw new ExtensionError(`Invalid window ID: ${windowId}`); + } + if (updateInfo.focused) { + win.window.focus(); + } + + if (updateInfo.state !== null) { + await win.setState(updateInfo.state); + } + + if (updateInfo.drawAttention) { + // Bug 1257497 - Firefox can't cancel attention actions. + win.window.getAttention(); + } + + sanitizePositionParams(updateInfo, win.window); + win.updateGeometry(updateInfo); + + if (updateInfo.titlePreface !== null) { + win.setTitlePreface(updateInfo.titlePreface); + win.window.gBrowser.updateTitlebar(); + } + + // TODO: All the other properties, focused=false... + + return win.convert(); + }, + + remove: function (windowId) { + let window = windowTracker.getWindow(windowId, context); + if (!context.canAccessWindow(window)) { + return Promise.reject({ + message: `Invalid window ID: ${windowId}`, + }); + } + window.close(); + + return new Promise(resolve => { + let listener = () => { + windowTracker.removeListener("domwindowclosed", listener); + resolve(); + }; + windowTracker.addListener("domwindowclosed", listener); + }); + }, + }, + }; + } +}; |