Source code
Revision control
Copy as Markdown
Other Tools
/* -*- mode: js; indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set ts=2 sw=2 sts=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
const lazy = {};
ChromeUtils.defineESModuleGetters(lazy, {
InlineSpellCheckerContent:
});
let contextMenus = new WeakMap();
export class ContextMenuChild extends JSWindowActorChild {
// PUBLIC
constructor() {
super();
this.target = null;
this.context = null;
this.lastMenuTarget = null;
}
static getTarget(browsingContext, message, key) {
let actor = contextMenus.get(browsingContext);
if (!actor) {
throw new Error(
"Can't find ContextMenu actor for browsing context with " +
"ID: " +
browsingContext.id
);
}
return actor.getTarget(message, key);
}
static getLastTarget(browsingContext) {
let contextMenu = contextMenus.get(browsingContext);
return contextMenu && contextMenu.lastMenuTarget;
}
receiveMessage(message) {
switch (message.name) {
case "ContextMenu:GetFrameTitle": {
let target = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
return Promise.resolve(target.ownerDocument.title);
}
case "ContextMenu:Canvas:ToBlobURL": {
let target = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
return new Promise(resolve => {
target.toBlob(blob => {
let blobURL = URL.createObjectURL(blob);
resolve(blobURL);
});
});
}
case "ContextMenu:Hiding": {
this.context = null;
this.target = null;
break;
}
case "ContextMenu:MediaCommand": {
lazy.E10SUtils.wrapHandlingUserInput(
this.contentWindow,
message.data.handlingUserInput,
() => {
let media = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
switch (message.data.command) {
case "play":
media.play();
break;
case "pause":
media.pause();
break;
case "loop":
media.loop = !media.loop;
break;
case "mute":
media.muted = true;
break;
case "unmute":
media.muted = false;
break;
case "playbackRate":
media.playbackRate = message.data.data;
break;
case "hidecontrols":
media.removeAttribute("controls");
break;
case "showcontrols":
media.setAttribute("controls", "true");
break;
case "fullscreen":
if (this.document.fullscreenEnabled) {
media.requestFullscreen();
}
break;
case "pictureinpicture":
if (!media.isCloningElementVisually) {
Services.telemetry.keyedScalarAdd(
"pictureinpicture.opened_method",
"contextmenu",
1
);
}
let event = new this.contentWindow.CustomEvent(
"MozTogglePictureInPicture",
{
bubbles: true,
detail: { reason: "contextMenu" },
},
this.contentWindow
);
media.dispatchEvent(event);
break;
}
}
);
break;
}
case "ContextMenu:ReloadFrame": {
let target = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
target.ownerDocument.location.reload(message.data.forceReload);
break;
}
case "ContextMenu:GetImageText": {
let img = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
const { direction } = this.contentWindow.getComputedStyle(img);
return img.recognizeCurrentImageText().then(results => {
return { results, direction };
});
}
case "ContextMenu:ToggleRevealPassword": {
let target = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
target.revealPassword = !target.revealPassword;
break;
}
case "ContextMenu:UseRelayMask": {
const input = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
input.setUserInput(message.data.emailMask);
break;
}
case "ContextMenu:ReloadImage": {
let image = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
if (image instanceof Ci.nsIImageLoadingContent) {
image.forceReload();
}
break;
}
case "ContextMenu:SearchFieldBookmarkData": {
let node = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
let charset = node.ownerDocument.characterSet;
let formBaseURI = Services.io.newURI(node.form.baseURI, charset);
let formURI = Services.io.newURI(
node.form.getAttribute("action"),
charset,
formBaseURI
);
let spec = formURI.spec;
let isURLEncoded =
node.form.method.toUpperCase() == "POST" &&
(node.form.enctype == "application/x-www-form-urlencoded" ||
node.form.enctype == "");
let title = node.ownerDocument.title;
function escapeNameValuePair([aName, aValue]) {
if (isURLEncoded) {
return escape(aName + "=" + aValue);
}
return encodeURIComponent(aName) + "=" + encodeURIComponent(aValue);
}
let formData = new this.contentWindow.FormData(node.form);
formData.delete(node.name);
formData = Array.from(formData).map(escapeNameValuePair);
formData.push(
escape(node.name) + (isURLEncoded ? escape("=%s") : "=%s")
);
let postData;
if (isURLEncoded) {
postData = formData.join("&");
} else {
let separator = spec.includes("?") ? "&" : "?";
spec += separator + formData.join("&");
}
return Promise.resolve({ spec, title, postData, charset });
}
case "ContextMenu:SaveVideoFrameAsImage": {
let video = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
let canvas = this.document.createElementNS(
"canvas"
);
canvas.width = video.videoWidth;
canvas.height = video.videoHeight;
let ctxDraw = canvas.getContext("2d");
ctxDraw.drawImage(video, 0, 0);
// Note: if changing the content type, don't forget to update
// consumers that also hardcode this content type.
return Promise.resolve(canvas.toDataURL("image/jpeg", ""));
}
case "ContextMenu:SetAsDesktopBackground": {
let target = lazy.ContentDOMReference.resolve(
message.data.targetIdentifier
);
// Paranoia: check disableSetDesktopBackground again, in case the
// image changed since the context menu was initiated.
let disable = this._disableSetDesktopBackground(target);
if (!disable) {
try {
Services.scriptSecurityManager.checkLoadURIWithPrincipal(
target.ownerDocument.nodePrincipal,
target.currentURI
);
let canvas = this.document.createElement("canvas");
canvas.width = target.naturalWidth;
canvas.height = target.naturalHeight;
let ctx = canvas.getContext("2d");
ctx.drawImage(target, 0, 0);
let dataURL = canvas.toDataURL();
let url = new URL(target.ownerDocument.location.href).pathname;
let imageName = url.substr(url.lastIndexOf("/") + 1);
return Promise.resolve({ failed: false, dataURL, imageName });
} catch (e) {
console.error(e);
}
}
return Promise.resolve({
failed: true,
dataURL: null,
imageName: null,
});
}
}
return undefined;
}
/**
* Returns the event target of the context menu, using a locally stored
* reference if possible. If not, and aMessage.objects is defined,
* aMessage.objects[aKey] is returned. Otherwise null.
* @param {Object} aMessage Message with a objects property
* @param {String} aKey Key for the target on aMessage.objects
* @return {Object} Context menu target
*/
getTarget(aMessage, aKey = "target") {
return this.target || (aMessage.objects && aMessage.objects[aKey]);
}
// PRIVATE
_isXULTextLinkLabel(aNode) {
const XUL_NS =
return (
aNode.namespaceURI == XUL_NS &&
aNode.tagName == "label" &&
aNode.classList.contains("text-link") &&
aNode.href
);
}
// Generate fully qualified URL for clicked-on link.
_getLinkURL() {
let href = this.context.link.href;
if (href) {
// Handle SVG links:
if (typeof href == "object" && href.animVal) {
return this._makeURLAbsolute(this.context.link.baseURI, href.animVal);
}
return href;
}
href =
this.context.link.getAttribute("href") ||
if (!href || !href.match(/\S/)) {
// Without this we try to save as the current doc,
// for example, HTML case also throws if empty
throw new Error("Empty href");
}
return this._makeURLAbsolute(this.context.link.baseURI, href);
}
_getLinkURI() {
try {
return Services.io.newURI(this.context.linkURL);
} catch (ex) {
// e.g. empty URL string
}
return null;
}
// Get text of link.
_getLinkText() {
let text = this._gatherTextUnder(this.context.link);
if (!text || !text.match(/\S/)) {
text = this.context.link.getAttribute("title");
if (!text || !text.match(/\S/)) {
text = this.context.link.getAttribute("alt");
if (!text || !text.match(/\S/)) {
text = this.context.linkURL;
}
}
}
return text;
}
_getLinkProtocol() {
if (this.context.linkURI) {
return this.context.linkURI.scheme; // can be |undefined|
}
return null;
}
// Returns true if clicked-on link targets a resource that can be saved.
_isLinkSaveable() {
// We don't do the Right Thing for news/snews yet, so turn them off
// until we do.
return (
this.context.linkProtocol &&
!(
this.context.linkProtocol == "mailto" ||
this.context.linkProtocol == "tel" ||
this.context.linkProtocol == "javascript" ||
this.context.linkProtocol == "news" ||
this.context.linkProtocol == "snews"
)
);
}
// Gather all descendent text under given document node.
_gatherTextUnder(root) {
let text = "";
let node = root.firstChild;
let depth = 1;
while (node && depth > 0) {
// See if this node is text.
if (node.nodeType == node.TEXT_NODE) {
// Add this text to our collection.
text += " " + node.data;
} else if (this.contentWindow.HTMLImageElement.isInstance(node)) {
// If it has an "alt" attribute, add that.
let altText = node.getAttribute("alt");
if (altText && altText != "") {
text += " " + altText;
}
}
// Find next node to test.
// First, see if this node has children.
if (node.hasChildNodes()) {
// Go to first child.
node = node.firstChild;
depth++;
} else {
// No children, try next sibling (or parent next sibling).
while (depth > 0 && !node.nextSibling) {
node = node.parentNode;
depth--;
}
if (node.nextSibling) {
node = node.nextSibling;
}
}
}
// Strip leading and tailing whitespace.
text = text.trim();
// Compress remaining whitespace.
text = text.replace(/\s+/g, " ");
return text;
}
// Returns a "url"-type computed style attribute value, with the url() stripped.
_getComputedURL(aElem, aProp) {
let urls = aElem.ownerGlobal.getComputedStyle(aElem).getCSSImageURLs(aProp);
if (!urls.length) {
return null;
}
if (urls.length != 1) {
throw new Error("found multiple URLs");
}
return urls[0];
}
_makeURLAbsolute(aBase, aUrl) {
return Services.io.newURI(aUrl, null, Services.io.newURI(aBase)).spec;
}
_isProprietaryDRM() {
return (
this.context.target.isEncrypted &&
this.context.target.mediaKeys &&
this.context.target.mediaKeys.keySystem != "org.w3.clearkey"
);
}
_isMediaURLReusable(aURL) {
if (aURL.startsWith("blob:")) {
return URL.isValidObjectURL(aURL);
}
return true;
}
_isTargetATextBox(node) {
if (this.contentWindow.HTMLInputElement.isInstance(node)) {
return node.mozIsTextField(false);
}
return this.contentWindow.HTMLTextAreaElement.isInstance(node);
}
_isSpellCheckEnabled(aNode) {
// We can always force-enable spellchecking on textboxes
if (this._isTargetATextBox(aNode)) {
return true;
}
// We can never spell check something which is not content editable
let editable = aNode.isContentEditable;
if (!editable && aNode.ownerDocument) {
editable = aNode.ownerDocument.designMode == "on";
}
if (!editable) {
return false;
}
// Otherwise make sure that nothing in the parent chain disables spellchecking
return aNode.spellcheck;
}
_disableSetDesktopBackground(aTarget) {
// Disable the Set as Desktop Background menu item if we're still trying
// to load the image or the load failed.
if (!(aTarget instanceof Ci.nsIImageLoadingContent)) {
return true;
}
if ("complete" in aTarget && !aTarget.complete) {
return true;
}
if (aTarget.currentURI.schemeIs("javascript")) {
return true;
}
let request = aTarget.getRequest(Ci.nsIImageLoadingContent.CURRENT_REQUEST);
if (!request) {
return true;
}
return false;
}
async handleEvent(aEvent) {
contextMenus.set(this.browsingContext, this);
let defaultPrevented = aEvent.defaultPrevented;
if (
// If the event is not from a chrome-privileged document, and if
// `dom.event.contextmenu.enabled` is false, force defaultPrevented=false.
!aEvent.composedTarget.nodePrincipal.isSystemPrincipal &&
!Services.prefs.getBoolPref("dom.event.contextmenu.enabled")
) {
defaultPrevented = false;
}
if (defaultPrevented) {
return;
}
let doc = aEvent.composedTarget.ownerDocument;
if (!doc && Cu.isInAutomation) {
// doc has been observed to be null for many years, causing intermittent
// is too low to debug locally, but frequent enough to be a nuisance.
dump(
);
// A potential fix is to fall back to aEvent.target.ownerDocument, per
// Let's print potentially viable alternatives to see what we should use.
for (let k of ["target", "originalTarget", "explicitOriginalTarget"]) {
dump(
` Alternative: ${k}=${aEvent[k]} and its doc=${aEvent[k]?.ownerDocument}\n`
);
}
}
let {
mozDocumentURIIfNotForErrorPages: docLocation,
characterSet: charSet,
baseURI,
} = doc;
docLocation = docLocation && docLocation.spec;
const loginManagerChild = lazy.LoginManagerChild.forWindow(doc.defaultView);
const docState = loginManagerChild.stateForDocument(doc);
const loginFillInfo = docState.getFieldContext(aEvent.composedTarget);
let disableSetDesktopBackground = null;
// Media related cache info parent needs for saving
let contentType = null;
let contentDisposition = null;
if (
aEvent.composedTarget.nodeType == aEvent.composedTarget.ELEMENT_NODE &&
aEvent.composedTarget instanceof Ci.nsIImageLoadingContent &&
aEvent.composedTarget.currentURI
) {
disableSetDesktopBackground = this._disableSetDesktopBackground(
aEvent.composedTarget
);
try {
let imageCache = Cc["@mozilla.org/image/tools;1"]
.getService(Ci.imgITools)
.getImgCacheForDocument(doc);
// The image cache's notion of where this image is located is
// the currentURI of the image loading content.
let props = imageCache.findEntryProperties(
aEvent.composedTarget.currentURI,
doc
);
try {
contentType = props.get("type", Ci.nsISupportsCString).data;
} catch (e) {}
try {
contentDisposition = props.get(
"content-disposition",
Ci.nsISupportsCString
).data;
} catch (e) {}
} catch (e) {}
}
let selectionInfo = lazy.SelectionUtils.getSelectionDetails(
this.contentWindow
);
this._setContext(aEvent);
let context = this.context;
this.target = context.target;
let spellInfo = null;
let editFlags = null;
let referrerInfo = Cc["@mozilla.org/referrer-info;1"].createInstance(
Ci.nsIReferrerInfo
);
referrerInfo.initWithElement(aEvent.composedTarget);
referrerInfo = lazy.E10SUtils.serializeReferrerInfo(referrerInfo);
// In the case "onLink" we may have to send link referrerInfo to use in
// _openLinkInParameters
let linkReferrerInfo = null;
if (context.onLink) {
linkReferrerInfo = Cc["@mozilla.org/referrer-info;1"].createInstance(
Ci.nsIReferrerInfo
);
linkReferrerInfo.initWithElement(context.link);
}
let target = context.target;
if (target) {
this._cleanContext();
}
editFlags = lazy.SpellCheckHelper.isEditable(
aEvent.composedTarget,
this.contentWindow
);
if (editFlags & lazy.SpellCheckHelper.SPELLCHECKABLE) {
spellInfo = lazy.InlineSpellCheckerContent.initContextMenu(
aEvent,
editFlags,
this
);
}
// Set the event target first as the copy image command needs it to
// determine what was context-clicked on. Then, update the state of the
// commands on the context menu.
this.docShell.docViewer
.QueryInterface(Ci.nsIDocumentViewerEdit)
.setCommandNode(aEvent.composedTarget);
aEvent.composedTarget.ownerGlobal.updateCommands("contentcontextmenu");
let data = {
context,
charSet,
baseURI,
referrerInfo,
editFlags,
contentType,
docLocation,
loginFillInfo,
selectionInfo,
contentDisposition,
disableSetDesktopBackground,
};
if (context.inFrame && !context.inSrcdocFrame) {
data.frameReferrerInfo = lazy.E10SUtils.serializeReferrerInfo(
doc.referrerInfo
);
}
if (linkReferrerInfo) {
data.linkReferrerInfo =
lazy.E10SUtils.serializeReferrerInfo(linkReferrerInfo);
}
// Notify observers (currently only webextensions) of the context menu being
// prepared, allowing them to set webExtContextData for us.
let prepareContextMenu = {
principal: doc.nodePrincipal,
setWebExtContextData(webExtContextData) {
data.webExtContextData = webExtContextData;
},
};
Services.obs.notifyObservers(prepareContextMenu, "on-prepare-contextmenu");
// In the event that the content is running in the parent process, we don't
// actually want the contextmenu events to reach the parent - we'll dispatch
// a new contextmenu event after the async message has reached the parent
// instead.
aEvent.stopPropagation();
data.spellInfo = null;
if (!spellInfo) {
this.sendAsyncMessage("contextmenu", data);
return;
}
try {
data.spellInfo = await spellInfo;
} catch (ex) {}
this.sendAsyncMessage("contextmenu", data);
}
/**
* Some things are not serializable, so we either have to only send
* their needed data or regenerate them in nsContextMenu.js
* - target and target.ownerDocument
* - link
* - linkURI
*/
_cleanContext() {
const context = this.context;
const cleanTarget = Object.create(null);
cleanTarget.ownerDocument = {
// used for nsContextMenu.initLeaveDOMFullScreenItems and
// nsContextMenu.initMediaPlayerItems
fullscreen: context.target.ownerDocument.fullscreen,
// used for nsContextMenu.initMiscItems
contentType: context.target.ownerDocument.contentType,
};
// used for nsContextMenu.initMediaPlayerItems
Object.assign(cleanTarget, {
ended: context.target.ended,
muted: context.target.muted,
paused: context.target.paused,
controls: context.target.controls,
duration: context.target.duration,
});
const onMedia = context.onVideo || context.onAudio;
if (onMedia) {
Object.assign(cleanTarget, {
loop: context.target.loop,
error: context.target.error,
networkState: context.target.networkState,
playbackRate: context.target.playbackRate,
NETWORK_NO_SOURCE: context.target.NETWORK_NO_SOURCE,
});
if (context.onVideo) {
Object.assign(cleanTarget, {
readyState: context.target.readyState,
HAVE_CURRENT_DATA: context.target.HAVE_CURRENT_DATA,
});
}
}
context.target = cleanTarget;
if (context.link) {
context.link = { href: context.linkURL };
}
delete context.linkURI;
}
_setContext(aEvent) {
this.context = Object.create(null);
const context = this.context;
context.timeStamp = aEvent.timeStamp;
context.screenXDevPx = aEvent.screenX * this.contentWindow.devicePixelRatio;
context.screenYDevPx = aEvent.screenY * this.contentWindow.devicePixelRatio;
context.inputSource = aEvent.inputSource;
let node = aEvent.composedTarget;
// Set the node to containing <video>/<audio>/<embed>/<object> if the node
// is in the videocontrols UA Widget.
if (node.containingShadowRoot?.isUAWidget()) {
const host = node.containingShadowRoot.host;
if (
this.contentWindow.HTMLMediaElement.isInstance(host) ||
this.contentWindow.HTMLEmbedElement.isInstance(host) ||
this.contentWindow.HTMLObjectElement.isInstance(host)
) {
node = host;
}
}
const XUL_NS =
context.shouldDisplay = true;
if (
node.nodeType == node.DOCUMENT_NODE ||
// Don't display for XUL element unless <label class="text-link">
(node.namespaceURI == XUL_NS && !this._isXULTextLinkLabel(node))
) {
context.shouldDisplay = false;
return;
}
const isAboutDevtoolsToolbox = this.document.documentURI.startsWith(
"about:devtools-toolbox"
);
const editFlags = lazy.SpellCheckHelper.isEditable(
node,
this.contentWindow
);
if (
isAboutDevtoolsToolbox &&
(editFlags & lazy.SpellCheckHelper.TEXTINPUT) === 0
) {
// Don't display for about:devtools-toolbox page unless the source was text input.
context.shouldDisplay = false;
return;
}
// Initialize context to be sent to nsContextMenu
// Keep this consistent with the similar code in nsContextMenu's setContext
context.bgImageURL = "";
context.imageDescURL = "";
context.imageInfo = null;
context.mediaURL = "";
context.webExtBrowserType = "";
context.canSpellCheck = false;
context.hasBGImage = false;
context.hasMultipleBGImages = false;
context.isDesignMode = false;
context.inFrame = false;
context.inPDFViewer = false;
context.inSrcdocFrame = false;
context.inSyntheticDoc = false;
context.inTabBrowser = true;
context.inWebExtBrowser = false;
context.link = null;
context.linkDownload = "";
context.linkProtocol = "";
context.linkTextStr = "";
context.linkURL = "";
context.linkURI = null;
context.onAudio = false;
context.onCanvas = false;
context.onCompletedImage = false;
context.onDRMMedia = false;
context.onPiPVideo = false;
context.onEditable = false;
context.onImage = false;
context.onKeywordField = false;
context.onLink = false;
context.onLoadedImage = false;
context.onMailtoLink = false;
context.onTelLink = false;
context.onMozExtLink = false;
context.onNumeric = false;
context.onPassword = false;
context.passwordRevealed = false;
context.onSaveableLink = false;
context.onSpellcheckable = false;
context.onTextInput = false;
context.onVideo = false;
context.inPDFEditor = false;
// Remember the node and its owner document that was clicked
// This may be modifed before sending to nsContextMenu
context.target = node;
context.targetIdentifier = lazy.ContentDOMReference.get(node);
context.csp = lazy.E10SUtils.serializeCSP(context.target.ownerDocument.csp);
// Check if we are in the PDF Viewer.
context.inPDFViewer =
context.target.ownerDocument.nodePrincipal.originNoSuffix ==
if (context.inPDFViewer) {
context.pdfEditorStates = context.target.ownerDocument.editorStates;
context.inPDFEditor = !!context.pdfEditorStates?.isEditing;
}
// Check if we are in a synthetic document (stand alone image, video, etc.).
context.inSyntheticDoc = context.target.ownerDocument.mozSyntheticDocument;
context.shouldInitInlineSpellCheckerUINoChildren = false;
context.shouldInitInlineSpellCheckerUIWithChildren = false;
this._setContextForNodesNoChildren(editFlags);
this._setContextForNodesWithChildren(editFlags);
this.lastMenuTarget = {
// Remember the node for extensions.
targetRef: Cu.getWeakReference(node),
// The timestamp is used to verify that the target wasn't changed since the observed menu event.
timeStamp: context.timeStamp,
};
if (isAboutDevtoolsToolbox) {
// Setup the menu items on text input in about:devtools-toolbox.
context.inAboutDevtoolsToolbox = true;
context.canSpellCheck = false;
context.inTabBrowser = false;
context.inFrame = false;
context.inSrcdocFrame = false;
context.onSpellcheckable = false;
}
}
/**
* Sets up the parts of the context menu for when when nodes have no children.
*
* @param {Integer} editFlags The edit flags for the node. See SpellCheckHelper
* for the details.
*/
_setContextForNodesNoChildren(editFlags) {
const context = this.context;
if (context.target.nodeType == context.target.TEXT_NODE) {
// For text nodes, look at the parent node to determine the spellcheck attribute.
context.canSpellCheck =
context.target.parentNode && this._isSpellCheckEnabled(context.target);
return;
}
// We only deal with TEXT_NODE and ELEMENT_NODE in this function, so return
// early if we don't have one.
if (context.target.nodeType != context.target.ELEMENT_NODE) {
return;
}
// See if the user clicked on an image. This check mirrors
// nsDocumentViewer::GetInImage. Make sure to update both if this is
// changed.
if (
context.target instanceof Ci.nsIImageLoadingContent &&
(context.target.currentRequestFinalURI || context.target.currentURI)
) {
context.onImage = true;
context.imageInfo = {
currentSrc: context.target.currentSrc,
width: context.target.width,
height: context.target.height,
imageText: this.contentWindow.ImageDocument.isInstance(
context.target.ownerDocument
)
? undefined
: context.target.title || context.target.alt,
};
const { SVGAnimatedLength } = context.target.ownerGlobal;
if (SVGAnimatedLength.isInstance(context.imageInfo.height)) {
context.imageInfo.height = context.imageInfo.height.animVal.value;
}
if (SVGAnimatedLength.isInstance(context.imageInfo.width)) {
context.imageInfo.width = context.imageInfo.width.animVal.value;
}
const request = context.target.getRequest(
Ci.nsIImageLoadingContent.CURRENT_REQUEST
);
if (request && request.imageStatus & request.STATUS_SIZE_AVAILABLE) {
context.onLoadedImage = true;
}
if (
request &&
request.imageStatus & request.STATUS_LOAD_COMPLETE &&
!(request.imageStatus & request.STATUS_ERROR)
) {
context.onCompletedImage = true;
}
// The URL of the image before redirects is the currentURI. This is
// intended to be used for "Copy Image Link".
context.originalMediaURL = (() => {
let currentURI = context.target.currentURI?.spec;
if (currentURI && this._isMediaURLReusable(currentURI)) {
return currentURI;
}
return "";
})();
// The actual URL the image was loaded from (after redirects) is the
// currentRequestFinalURI. We should use that as the URL for purposes of
// deciding on the filename, if it is present. It might not be present
// if images are blocked.
//
// It is important to check both the final and the current URI, as they
context.mediaURL = (() => {
let finalURI = context.target.currentRequestFinalURI?.spec;
if (finalURI && this._isMediaURLReusable(finalURI)) {
return finalURI;
}
let currentURI = context.target.currentURI?.spec;
if (currentURI && this._isMediaURLReusable(currentURI)) {
return currentURI;
}
return "";
})();
const descURL = context.target.getAttribute("longdesc");
if (descURL) {
context.imageDescURL = this._makeURLAbsolute(
context.target.ownerDocument.body.baseURI,
descURL
);
}
} else if (
this.contentWindow.HTMLCanvasElement.isInstance(context.target)
) {
context.onCanvas = true;
} else if (this.contentWindow.HTMLVideoElement.isInstance(context.target)) {
const mediaURL = context.target.currentSrc || context.target.src;
if (this._isMediaURLReusable(mediaURL)) {
context.mediaURL = mediaURL;
}
if (this._isProprietaryDRM()) {
context.onDRMMedia = true;
}
if (context.target.isCloningElementVisually) {
context.onPiPVideo = true;
}
// Firefox always creates a HTMLVideoElement when loading an ogg file
// directly. If the media is actually audio, be smarter and provide a
// context menu with audio operations.
if (
context.target.readyState >= context.target.HAVE_METADATA &&
(context.target.videoWidth == 0 || context.target.videoHeight == 0)
) {
context.onAudio = true;
} else {
context.onVideo = true;
}
} else if (this.contentWindow.HTMLAudioElement.isInstance(context.target)) {
context.onAudio = true;
const mediaURL = context.target.currentSrc || context.target.src;
if (this._isMediaURLReusable(mediaURL)) {
context.mediaURL = mediaURL;
}
if (this._isProprietaryDRM()) {
context.onDRMMedia = true;
}
} else if (
editFlags &
(lazy.SpellCheckHelper.INPUT | lazy.SpellCheckHelper.TEXTAREA)
) {
context.onTextInput = (editFlags & lazy.SpellCheckHelper.TEXTINPUT) !== 0;
context.onNumeric = (editFlags & lazy.SpellCheckHelper.NUMERIC) !== 0;
context.onEditable = (editFlags & lazy.SpellCheckHelper.EDITABLE) !== 0;
context.onPassword = (editFlags & lazy.SpellCheckHelper.PASSWORD) !== 0;
context.showRelay =
HTMLInputElement.isInstance(context.target) &&
!context.target.disabled &&
!context.target.readOnly &&
(lazy.LoginHelper.isInferredEmailField(context.target) ||
lazy.LoginHelper.isInferredUsernameField(context.target));
context.isDesignMode =
(editFlags & lazy.SpellCheckHelper.CONTENTEDITABLE) !== 0;
context.passwordRevealed =
context.onPassword && context.target.revealPassword;
context.onSpellcheckable =
(editFlags & lazy.SpellCheckHelper.SPELLCHECKABLE) !== 0;
// This is guaranteed to be an input or textarea because of the condition above,
// so the no-children flag is always correct. We deal with contenteditable elsewhere.
if (context.onSpellcheckable) {
context.shouldInitInlineSpellCheckerUINoChildren = true;
}
context.onKeywordField = editFlags & lazy.SpellCheckHelper.KEYWORD;
} else if (this.contentWindow.HTMLHtmlElement.isInstance(context.target)) {
const bodyElt = context.target.ownerDocument.body;
if (bodyElt) {
let computedURL;
try {
computedURL = this._getComputedURL(bodyElt, "background-image");
context.hasMultipleBGImages = false;
} catch (e) {
context.hasMultipleBGImages = true;
}
if (computedURL) {
context.hasBGImage = true;
context.bgImageURL = this._makeURLAbsolute(
bodyElt.baseURI,
computedURL
);
}
}
}
context.canSpellCheck = this._isSpellCheckEnabled(context.target);
}
/**
* Sets up the parts of the context menu for when when nodes have children.
*
* @param {Integer} editFlags The edit flags for the node. See SpellCheckHelper
* for the details.
*/
_setContextForNodesWithChildren(editFlags) {
const context = this.context;
// Second, bubble out, looking for items of interest that can have childen.
// Always pick the innermost link, background image, etc.
let elem = context.target;
while (elem) {
if (elem.nodeType == elem.ELEMENT_NODE) {
// Link?
if (
!context.onLink &&
// Be consistent with what hrefAndLinkNodeForClickEvent
// does in browser.js
(this._isXULTextLinkLabel(elem) ||
(this.contentWindow.HTMLAnchorElement.isInstance(elem) &&
elem.href) ||
(this.contentWindow.SVGAElement.isInstance(elem) &&
(elem.href || elem.hasAttributeNS(XLINK_NS, "href"))) ||
(this.contentWindow.HTMLAreaElement.isInstance(elem) &&
elem.href) ||
this.contentWindow.HTMLLinkElement.isInstance(elem) ||
elem.getAttributeNS(XLINK_NS, "type") == "simple")
) {
// Target is a link or a descendant of a link.
context.onLink = true;
// Remember corresponding element.
context.link = elem;
context.linkURL = this._getLinkURL();
context.linkURI = this._getLinkURI();
context.linkTextStr = this._getLinkText();
context.linkProtocol = this._getLinkProtocol();
context.onMailtoLink = context.linkProtocol == "mailto";
context.onTelLink = context.linkProtocol == "tel";
context.onMozExtLink = context.linkProtocol == "moz-extension";
context.onSaveableLink = this._isLinkSaveable(context.link);
context.isSponsoredLink =
(elem.ownerDocument.URL === "about:newtab" ||
elem.ownerDocument.URL === "about:home") &&
elem.dataset.isSponsoredLink === "true";
try {
if (elem.download) {
// Ignore download attribute on cross-origin links
context.target.ownerDocument.nodePrincipal.checkMayLoad(
context.linkURI,
true
);
context.linkDownload = elem.download;
}
} catch (ex) {}
}
// Background image? Don't bother if we've already found a
// background image further down the hierarchy. Otherwise,
// we look for the computed background-image style.
if (!context.hasBGImage && !context.hasMultipleBGImages) {
let bgImgUrl = null;
try {
bgImgUrl = this._getComputedURL(elem, "background-image");
context.hasMultipleBGImages = false;
} catch (e) {
context.hasMultipleBGImages = true;
}
if (bgImgUrl) {
context.hasBGImage = true;
context.bgImageURL = this._makeURLAbsolute(elem.baseURI, bgImgUrl);
}
}
}
elem = elem.flattenedTreeParentNode;
}
// See if the user clicked in a frame.
const docDefaultView = context.target.ownerGlobal;
if (docDefaultView != docDefaultView.top) {
context.inFrame = true;
if (context.target.ownerDocument.isSrcdocDocument) {
context.inSrcdocFrame = true;
}
}
// if the document is editable, show context menu like in text inputs
if (!context.onEditable) {
if (editFlags & lazy.SpellCheckHelper.CONTENTEDITABLE) {
// If this.onEditable is false but editFlags is CONTENTEDITABLE, then
// the document itself must be editable.
context.onTextInput = true;
context.onKeywordField = false;
context.onImage = false;
context.onLoadedImage = false;
context.onCompletedImage = false;
context.inFrame = false;
context.inSrcdocFrame = false;
context.hasBGImage = false;
context.isDesignMode = true;
context.onEditable = true;
context.onSpellcheckable = true;
context.shouldInitInlineSpellCheckerUIWithChildren = true;
}
}
}
_destructionObservers = new Set();
registerDestructionObserver(obj) {
this._destructionObservers.add(obj);
}
unregisterDestructionObserver(obj) {
this._destructionObservers.delete(obj);
}
didDestroy() {
for (let obs of this._destructionObservers) {
obs.actorDestroyed(this);
}
this._destructionObservers = null;
}
}