Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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,
"use strict";
ChromeUtils.defineESModuleGetters(this, {
});
var { DefaultMap, ExtensionError, parseMatchPatterns } = ExtensionUtils;
var { ExtensionParent } = ChromeUtils.importESModule(
);
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);
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) {
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
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) {
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(),
},
};
}
};