diff options
Diffstat (limited to '')
59 files changed, 11236 insertions, 0 deletions
diff --git a/toolkit/actors/AboutHttpsOnlyErrorChild.sys.mjs b/toolkit/actors/AboutHttpsOnlyErrorChild.sys.mjs new file mode 100644 index 0000000000..20313d30c0 --- /dev/null +++ b/toolkit/actors/AboutHttpsOnlyErrorChild.sys.mjs @@ -0,0 +1,83 @@ +/* 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/. */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +import { RemotePageChild } from "resource://gre/actors/RemotePageChild.sys.mjs"; + +const lazy = {}; + +XPCOMUtils.defineLazyServiceGetter( + lazy, + "@mozilla.org/network/serialization-helper;1", + "nsISerializationHelper" +); + +export class AboutHttpsOnlyErrorChild extends RemotePageChild { + actorCreated() { + super.actorCreated(); + + // If you add a new function, remember to add it to RemotePageAccessManager.sys.mjs + // to allow content-privileged about:httpsonlyerror to use it. + const exportableFunctions = [ + "RPMTryPingSecureWWWLink", + "RPMOpenSecureWWWLink", + ]; + this.exportFunctions(exportableFunctions); + } + + RPMTryPingSecureWWWLink() { + // try if the page can be reached with www prefix + // if so send message to the parent to send message to the error page to display + // suggestion button for www + + const httpsOnlySuggestionPref = Services.prefs.getBoolPref( + "dom.security.https_only_mode_error_page_user_suggestions" + ); + + // only check if pref is true otherwise return + if (!httpsOnlySuggestionPref) { + return; + } + + // get the host url without the path with www in front + const wwwURL = "https://www." + this.contentWindow.location.host; + fetch(wwwURL, { + credentials: "omit", + cache: "no-store", + }) + .then(data => { + if (data.status === 200) { + this.contentWindow.dispatchEvent( + new this.contentWindow.CustomEvent("pingSecureWWWLinkSuccess") + ); + } + }) + .catch(() => { + dump("No secure www suggestion possible for " + wwwURL); + }); + } + + RPMOpenSecureWWWLink() { + // if user wants to visit suggested secure www page: visit page with www prefix and delete errorpage from history + const context = this.manager.browsingContext; + const docShell = context.docShell; + const httpChannel = docShell.failedChannel.QueryInterface( + Ci.nsIHttpChannel + ); + const webNav = docShell.QueryInterface(Ci.nsIWebNavigation); + const triggeringPrincipal = + docShell.failedChannel.loadInfo.triggeringPrincipal; + const oldURI = httpChannel.URI; + const newWWWURI = oldURI + .mutate() + .setHost("www." + oldURI.host) + .finalize(); + + webNav.loadURI(newWWWURI, { + triggeringPrincipal, + loadFlags: Ci.nsIWebNavigation.LOAD_FLAGS_REPLACE_HISTORY, + }); + } +} diff --git a/toolkit/actors/AboutHttpsOnlyErrorParent.sys.mjs b/toolkit/actors/AboutHttpsOnlyErrorParent.sys.mjs new file mode 100644 index 0000000000..a7a4b23cfa --- /dev/null +++ b/toolkit/actors/AboutHttpsOnlyErrorParent.sys.mjs @@ -0,0 +1,48 @@ +/* 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/. */ + +const { HomePage } = ChromeUtils.import("resource:///modules/HomePage.jsm"); +import { PrivateBrowsingUtils } from "resource://gre/modules/PrivateBrowsingUtils.sys.mjs"; + +export class AboutHttpsOnlyErrorParent extends JSWindowActorParent { + get browser() { + return this.browsingContext.top.embedderElement; + } + + receiveMessage(aMessage) { + switch (aMessage.name) { + case "goBack": + this.goBackFromErrorPage(this.browser); + break; + } + } + + goBackFromErrorPage(aBrowser) { + if (!aBrowser.canGoBack) { + // If the unsafe page is the first or the only one in history, go to the + // start page. + aBrowser.fixupAndLoadURIString( + this.getDefaultHomePage(aBrowser.ownerGlobal), + { + triggeringPrincipal: + Services.scriptSecurityManager.getSystemPrincipal(), + } + ); + } else { + aBrowser.goBack(); + } + } + + getDefaultHomePage(win) { + if (PrivateBrowsingUtils.isWindowPrivate(win)) { + return win.BROWSER_NEW_TAB_URL || "about:blank"; + } + let url = HomePage.getDefault(); + // If url is a pipe-delimited set of pages, just take the first one. + if (url.includes("|")) { + url = url.split("|")[0]; + } + return url; + } +} diff --git a/toolkit/actors/AudioPlaybackChild.sys.mjs b/toolkit/actors/AudioPlaybackChild.sys.mjs new file mode 100644 index 0000000000..a392a73464 --- /dev/null +++ b/toolkit/actors/AudioPlaybackChild.sys.mjs @@ -0,0 +1,20 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class AudioPlaybackChild extends JSWindowActorChild { + observe(subject, topic, data) { + if (topic === "audio-playback") { + let name = "AudioPlayback:"; + if (data === "activeMediaBlockStart") { + name += "ActiveMediaBlockStart"; + } else if (data === "activeMediaBlockStop") { + name += "ActiveMediaBlockStop"; + } else { + name += data === "active" ? "Start" : "Stop"; + } + this.sendAsyncMessage(name); + } + } +} diff --git a/toolkit/actors/AudioPlaybackParent.sys.mjs b/toolkit/actors/AudioPlaybackParent.sys.mjs new file mode 100644 index 0000000000..db682fd90b --- /dev/null +++ b/toolkit/actors/AudioPlaybackParent.sys.mjs @@ -0,0 +1,42 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class AudioPlaybackParent extends JSWindowActorParent { + constructor() { + super(); + this._hasAudioPlayback = false; + this._hasBlockMedia = false; + } + receiveMessage(aMessage) { + const browser = this.browsingContext.top.embedderElement; + switch (aMessage.name) { + case "AudioPlayback:Start": + this._hasAudioPlayback = true; + browser.audioPlaybackStarted(); + break; + case "AudioPlayback:Stop": + this._hasAudioPlayback = false; + browser.audioPlaybackStopped(); + break; + case "AudioPlayback:ActiveMediaBlockStart": + this._hasBlockMedia = true; + browser.activeMediaBlockStarted(); + break; + case "AudioPlayback:ActiveMediaBlockStop": + this._hasBlockMedia = false; + browser.activeMediaBlockStopped(); + break; + } + } + didDestroy() { + const browser = this.browsingContext.top.embedderElement; + if (browser && this._hasAudioPlayback) { + browser.audioPlaybackStopped(); + } + if (browser && this._hasBlockMedia) { + browser.activeMediaBlockStopped(); + } + } +} diff --git a/toolkit/actors/AutoCompleteChild.sys.mjs b/toolkit/actors/AutoCompleteChild.sys.mjs new file mode 100644 index 0000000000..a405834ca9 --- /dev/null +++ b/toolkit/actors/AutoCompleteChild.sys.mjs @@ -0,0 +1,197 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +/* eslint no-unused-vars: ["error", {args: "none"}] */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + ContentDOMReference: "resource://gre/modules/ContentDOMReference.sys.mjs", + LayoutUtils: "resource://gre/modules/LayoutUtils.sys.mjs", + LoginHelper: "resource://gre/modules/LoginHelper.sys.mjs", +}); + +let autoCompleteListeners = new Set(); + +export class AutoCompleteChild extends JSWindowActorChild { + constructor() { + super(); + + this._input = null; + this._popupOpen = false; + } + + static addPopupStateListener(listener) { + autoCompleteListeners.add(listener); + } + + static removePopupStateListener(listener) { + autoCompleteListeners.delete(listener); + } + + receiveMessage(message) { + switch (message.name) { + case "FormAutoComplete:HandleEnter": { + this.selectedIndex = message.data.selectedIndex; + + let controller = Cc[ + "@mozilla.org/autocomplete/controller;1" + ].getService(Ci.nsIAutoCompleteController); + controller.handleEnter(message.data.isPopupSelection); + break; + } + + case "FormAutoComplete:PopupClosed": { + this._popupOpen = false; + this.notifyListeners(message.name, message.data); + break; + } + + case "FormAutoComplete:PopupOpened": { + this._popupOpen = true; + this.notifyListeners(message.name, message.data); + break; + } + + case "FormAutoComplete:Focus": { + // XXX See bug 1582722 + // Before bug 1573836, the messages here didn't match + // ("FormAutoComplete:Focus" versus "FormAutoComplete:RequestFocus") + // so this was never called. However this._input is actually a + // nsIAutoCompleteInput, which doesn't have a focus() method, so it + // wouldn't have worked anyway. So for now, I have just disabled this. + /* + if (this._input) { + this._input.focus(); + } + */ + break; + } + } + } + + notifyListeners(messageName, data) { + for (let listener of autoCompleteListeners) { + try { + listener.popupStateChanged(messageName, data, this.contentWindow); + } catch (ex) { + console.error(ex); + } + } + } + + get input() { + return this._input; + } + + set selectedIndex(index) { + this.sendAsyncMessage("FormAutoComplete:SetSelectedIndex", { index }); + } + + get selectedIndex() { + // selectedIndex getter must be synchronous because we need the + // correct value when the controller is in controller::HandleEnter. + // We can't easily just let the parent inform us the new value every + // time it changes because not every action that can change the + // selectedIndex is trivial to catch (e.g. moving the mouse over the + // list). + let selectedIndexResult = Services.cpmm.sendSyncMessage( + "FormAutoComplete:GetSelectedIndex", + { + browsingContext: this.browsingContext, + } + ); + + if ( + selectedIndexResult.length != 1 || + !Number.isInteger(selectedIndexResult[0]) + ) { + throw new Error("Invalid autocomplete selectedIndex"); + } + return selectedIndexResult[0]; + } + + get popupOpen() { + return this._popupOpen; + } + + openAutocompletePopup(input, element) { + if (this._popupOpen || !input) { + return; + } + + let rect = lazy.LayoutUtils.getElementBoundingScreenRect(element); + let window = element.ownerGlobal; + let dir = window.getComputedStyle(element).direction; + let results = this.getResultsFromController(input); + let formOrigin = lazy.LoginHelper.getLoginOrigin( + element.ownerDocument.documentURI + ); + let inputElementIdentifier = lazy.ContentDOMReference.get(element); + + this.sendAsyncMessage("FormAutoComplete:MaybeOpenPopup", { + results, + rect, + dir, + inputElementIdentifier, + formOrigin, + }); + + this._input = input; + } + + closePopup() { + // We set this here instead of just waiting for the + // PopupClosed message to do it so that we don't end + // up in a state where the content thinks that a popup + // is open when it isn't (or soon won't be). + this._popupOpen = false; + this.sendAsyncMessage("FormAutoComplete:ClosePopup", {}); + } + + invalidate() { + if (this._popupOpen) { + let results = this.getResultsFromController(this._input); + this.sendAsyncMessage("FormAutoComplete:Invalidate", { results }); + } + } + + selectBy(reverse, page) { + Services.cpmm.sendSyncMessage("FormAutoComplete:SelectBy", { + browsingContext: this.browsingContext, + reverse, + page, + }); + } + + getResultsFromController(inputField) { + let results = []; + + if (!inputField) { + return results; + } + + let controller = inputField.controller; + if (!(controller instanceof Ci.nsIAutoCompleteController)) { + return results; + } + + for (let i = 0; i < controller.matchCount; ++i) { + let result = {}; + result.value = controller.getValueAt(i); + result.label = controller.getLabelAt(i); + result.comment = controller.getCommentAt(i); + result.style = controller.getStyleAt(i); + result.image = controller.getImageAt(i); + results.push(result); + } + + return results; + } +} + +AutoCompleteChild.prototype.QueryInterface = ChromeUtils.generateQI([ + "nsIAutoCompletePopup", +]); diff --git a/toolkit/actors/AutoCompleteParent.sys.mjs b/toolkit/actors/AutoCompleteParent.sys.mjs new file mode 100644 index 0000000000..82ebf22dcf --- /dev/null +++ b/toolkit/actors/AutoCompleteParent.sys.mjs @@ -0,0 +1,516 @@ +/* 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/. */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const lazy = {}; + +XPCOMUtils.defineLazyModuleGetters(lazy, { + GeckoViewAutocomplete: "resource://gre/modules/GeckoViewAutocomplete.jsm", +}); + +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "DELEGATE_AUTOCOMPLETE", + "toolkit.autocomplete.delegate", + false +); + +ChromeUtils.defineESModuleGetters(lazy, { + setTimeout: "resource://gre/modules/Timer.sys.mjs", +}); + +const PREF_SECURITY_DELAY = "security.notification_enable_delay"; + +// Stores the actor that has the active popup, used by formfill +let currentActor = null; + +let autoCompleteListeners = new Set(); + +function compareContext(message) { + if ( + !currentActor || + (currentActor.browsingContext != message.data.browsingContext && + currentActor.browsingContext.top != message.data.browsingContext) + ) { + return false; + } + + return true; +} + +// These are two synchronous messages sent by the child. +// The browsingContext within the message data is either the one that has +// the active autocomplete popup or the top-level of the one that has +// the active autocomplete popup. +Services.ppmm.addMessageListener( + "FormAutoComplete:GetSelectedIndex", + message => { + if (compareContext(message)) { + let actor = currentActor; + if (actor && actor.openedPopup) { + return actor.openedPopup.selectedIndex; + } + } + + return -1; + } +); + +Services.ppmm.addMessageListener("FormAutoComplete:SelectBy", message => { + if (compareContext(message)) { + let actor = currentActor; + if (actor && actor.openedPopup) { + actor.openedPopup.selectBy(message.data.reverse, message.data.page); + } + } +}); + +// AutoCompleteResultView is an abstraction around a list of results. +// It implements enough of nsIAutoCompleteController and +// nsIAutoCompleteInput to make the richlistbox popup work. Since only +// one autocomplete popup should be open at a time, this is a singleton. +var AutoCompleteResultView = { + // nsISupports + QueryInterface: ChromeUtils.generateQI([ + "nsIAutoCompleteController", + "nsIAutoCompleteInput", + ]), + + // Private variables + results: [], + + // The AutoCompleteParent currently showing results or null otherwise. + currentActor: null, + + // nsIAutoCompleteController + get matchCount() { + return this.results.length; + }, + + getValueAt(index) { + return this.results[index].value; + }, + + getFinalCompleteValueAt(index) { + return this.results[index].value; + }, + + getLabelAt(index) { + // Backwardly-used by richlist autocomplete - see getCommentAt. + // The label is used for secondary information. + return this.results[index].comment; + }, + + getCommentAt(index) { + // The richlist autocomplete popup uses comment for its main + // display of an item, which is why we're returning the label + // here instead. + return this.results[index].label; + }, + + getStyleAt(index) { + return this.results[index].style; + }, + + getImageAt(index) { + return this.results[index].image; + }, + + handleEnter(aIsPopupSelection) { + if (this.currentActor) { + this.currentActor.handleEnter(aIsPopupSelection); + } + }, + + stopSearch() {}, + + searchString: "", + + // nsIAutoCompleteInput + get controller() { + return this; + }, + + get popup() { + return null; + }, + + _focus() { + if (this.currentActor) { + this.currentActor.requestFocus(); + } + }, + + // Internal JS-only API + clearResults() { + this.currentActor = null; + this.results = []; + }, + + setResults(actor, results) { + this.currentActor = actor; + this.results = results; + }, +}; + +export class AutoCompleteParent extends JSWindowActorParent { + didDestroy() { + if (this.openedPopup) { + this.openedPopup.closePopup(); + } + } + + static getCurrentActor() { + return currentActor; + } + + static addPopupStateListener(listener) { + autoCompleteListeners.add(listener); + } + + static removePopupStateListener(listener) { + autoCompleteListeners.delete(listener); + } + + handleEvent(evt) { + switch (evt.type) { + case "popupshowing": { + this.sendAsyncMessage("FormAutoComplete:PopupOpened", {}); + break; + } + + case "popuphidden": { + let selectedIndex = this.openedPopup.selectedIndex; + let selectedRowComment = + selectedIndex != -1 + ? AutoCompleteResultView.getCommentAt(selectedIndex) + : ""; + let selectedRowStyle = + selectedIndex != -1 + ? AutoCompleteResultView.getStyleAt(selectedIndex) + : ""; + this.sendAsyncMessage("FormAutoComplete:PopupClosed", { + selectedRowComment, + selectedRowStyle, + }); + AutoCompleteResultView.clearResults(); + // adjustHeight clears the height from the popup so that + // we don't have a big shrink effect if we closed with a + // large list, and then open on a small one. + this.openedPopup.adjustHeight(); + this.openedPopup = null; + currentActor = null; + evt.target.removeEventListener("popuphidden", this); + evt.target.removeEventListener("popupshowing", this); + break; + } + } + } + + showPopupWithResults({ rect, dir, results }) { + if (!results.length || this.openedPopup) { + // We shouldn't ever be showing an empty popup, and if we + // already have a popup open, the old one needs to close before + // we consider opening a new one. + return; + } + + let browser = this.browsingContext.top.embedderElement; + let window = browser.ownerGlobal; + // Also check window top in case this is a sidebar. + if ( + Services.focus.activeWindow !== window.top && + Services.focus.focusedWindow.top !== window.top + ) { + // We were sent a message from a window or tab that went into the + // background, so we'll ignore it for now. + return; + } + + // Non-empty result styles + let resultStyles = new Set(results.map(r => r.style).filter(r => !!r)); + currentActor = this; + this.openedPopup = browser.autoCompletePopup; + // the layout varies according to different result type + this.openedPopup.setAttribute("resultstyles", [...resultStyles].join(" ")); + this.openedPopup.hidden = false; + // don't allow the popup to become overly narrow + this.openedPopup.style.setProperty( + "--panel-width", + Math.max(100, rect.width) + "px" + ); + this.openedPopup.style.direction = dir; + + AutoCompleteResultView.setResults(this, results); + this.openedPopup.view = AutoCompleteResultView; + this.openedPopup.selectedIndex = -1; + + // Reset fields that were set from the last time the search popup was open + this.openedPopup.mInput = AutoCompleteResultView; + // Temporarily increase the maxRows as we don't want to show + // the scrollbar in login or form autofill popups. + if ( + resultStyles.size && + (resultStyles.has("autofill-profile") || resultStyles.has("loginsFooter")) + ) { + this.openedPopup._normalMaxRows = this.openedPopup.maxRows; + this.openedPopup.mInput.maxRows = 10; + } + browser.constrainPopup(this.openedPopup); + this.openedPopup.addEventListener("popuphidden", this); + this.openedPopup.addEventListener("popupshowing", this); + this.openedPopup.openPopupAtScreenRect( + "after_start", + rect.left, + rect.top, + rect.width, + rect.height, + false, + false + ); + this.openedPopup.invalidate(); + this._maybeRecordTelemetryEvents(results); + + // This is a temporary solution. We should replace it with + // proper meta information about the popup once such field + // becomes available. + let isCreditCard = results.some(result => + result?.comment?.includes("cc-number") + ); + + if (isCreditCard) { + this.delayPopupInput(); + } + } + + /** + * @param {object[]} results - Non-empty array of autocomplete results. + */ + _maybeRecordTelemetryEvents(results) { + let actor = + this.browsingContext.currentWindowGlobal.getActor("LoginManager"); + actor.maybeRecordPasswordGenerationShownTelemetryEvent(results); + + // Assume the result with the start time (loginsFooter) is last. + let lastResult = results[results.length - 1]; + if (lastResult.style != "loginsFooter") { + return; + } + + // The comment field of `loginsFooter` results have many additional pieces of + // information for telemetry purposes. After bug 1555209, this information + // can be passed to the parent process outside of nsIAutoCompleteResult APIs + // so we won't need this hack. + let rawExtraData = JSON.parse(lastResult.comment).telemetryEventData; + if (!rawExtraData.searchStartTimeMS) { + throw new Error("Invalid autocomplete search start time"); + } + + if (rawExtraData.stringLength > 1) { + // To reduce event volume, only record for lengths 0 and 1. + return; + } + + let duration = + Services.telemetry.msSystemNow() - rawExtraData.searchStartTimeMS; + delete rawExtraData.searchStartTimeMS; + + // Add counts by result style to rawExtraData. + results.reduce((accumulated, r) => { + // Ignore learn more as it is only added after importable logins. + // Do not track generic items in the telemetry. + if (r.style === "importableLearnMore" || r.style === "generic") { + return accumulated; + } + + // Keys can be a maximum of 15 characters and values must be strings. + // Also treat both "loginWithOrigin" and "login" as "login" as extra_keys + // is limited to 10. + let truncatedStyle = r.style.substring( + 0, + r.style === "loginWithOrigin" ? 5 : 15 + ); + accumulated[truncatedStyle] = (accumulated[truncatedStyle] || 0) + 1; + return accumulated; + }, rawExtraData); + + // Convert extra values to strings since recordEvent requires that. + let extraStrings = Object.fromEntries( + Object.entries(rawExtraData).map(([key, val]) => { + let stringVal = ""; + if (typeof val == "boolean") { + stringVal += val ? "1" : "0"; + } else { + stringVal += val; + } + return [key, stringVal]; + }) + ); + + Services.telemetry.recordEvent( + "form_autocomplete", + "show", + "logins", + // Convert to a string + duration + "", + extraStrings + ); + } + + invalidate(results) { + if (!this.openedPopup) { + return; + } + + if (!results.length) { + this.closePopup(); + } else { + AutoCompleteResultView.setResults(this, results); + this.openedPopup.invalidate(); + this._maybeRecordTelemetryEvents(results); + } + } + + closePopup() { + if (this.openedPopup) { + // Note that hidePopup() closes the popup immediately, + // so popuphiding or popuphidden events will be fired + // and handled during this call. + this.openedPopup.hidePopup(); + } + } + + receiveMessage(message) { + let browser = this.browsingContext.top.embedderElement; + + if ( + !browser || + (!lazy.DELEGATE_AUTOCOMPLETE && !browser.autoCompletePopup) + ) { + // If there is no browser or popup, just make sure that the popup has been closed. + if (this.openedPopup) { + this.openedPopup.closePopup(); + } + + // Returning false to pacify ESLint, but this return value is + // ignored by the messaging infrastructure. + return false; + } + + switch (message.name) { + case "FormAutoComplete:SetSelectedIndex": { + let { index } = message.data; + if (this.openedPopup) { + this.openedPopup.selectedIndex = index; + } + break; + } + + case "FormAutoComplete:MaybeOpenPopup": { + let { results, rect, dir, inputElementIdentifier, formOrigin } = + message.data; + if (lazy.DELEGATE_AUTOCOMPLETE) { + lazy.GeckoViewAutocomplete.delegateSelection({ + browsingContext: this.browsingContext, + options: results, + inputElementIdentifier, + formOrigin, + }); + } else { + this.showPopupWithResults({ results, rect, dir }); + this.notifyListeners(); + } + break; + } + + case "FormAutoComplete:Invalidate": { + let { results } = message.data; + this.invalidate(results); + break; + } + + case "FormAutoComplete:ClosePopup": { + if (lazy.DELEGATE_AUTOCOMPLETE) { + lazy.GeckoViewAutocomplete.delegateDismiss(); + break; + } + this.closePopup(); + break; + } + } + // Returning false to pacify ESLint, but this return value is + // ignored by the messaging infrastructure. + return false; + } + + // Imposes a brief period during which the popup will not respond to + // a click, so as to reduce the chances of a successful clickjacking + // attempt + delayPopupInput() { + if (!this.openedPopup) { + return; + } + const popupDelay = Services.prefs.getIntPref(PREF_SECURITY_DELAY); + + // Mochitests set this to 0, and many will fail on integration + // if we make the popup items inactive, even briefly. + if (!popupDelay) { + return; + } + + const items = Array.from( + this.openedPopup.getElementsByTagName("richlistitem") + ); + items.forEach(item => (item.disabled = true)); + + lazy.setTimeout( + () => items.forEach(item => (item.disabled = false)), + popupDelay + ); + } + + notifyListeners() { + let window = this.browsingContext.top.embedderElement.ownerGlobal; + for (let listener of autoCompleteListeners) { + try { + listener(window); + } catch (ex) { + console.error(ex); + } + } + } + + /** + * Despite its name, this handleEnter is only called when the user clicks on + * one of the items in the popup since the popup is rendered in the parent process. + * The real controller's handleEnter is called directly in the content process + * for other methods of completing a selection (e.g. using the tab or enter + * keys) since the field with focus is in that process. + * @param {boolean} aIsPopupSelection + */ + handleEnter(aIsPopupSelection) { + if (this.openedPopup) { + this.sendAsyncMessage("FormAutoComplete:HandleEnter", { + selectedIndex: this.openedPopup.selectedIndex, + isPopupSelection: aIsPopupSelection, + }); + } + } + + stopSearch() {} + + /** + * Sends a message to the browser that is requesting the input + * that the open popup should be focused. + */ + requestFocus() { + // Bug 1582722 - See the response in AutoCompleteChild.jsm for why this disabled. + /* + if (this.openedPopup) { + this.sendAsyncMessage("FormAutoComplete:Focus"); + } + */ + } +} diff --git a/toolkit/actors/AutoScrollChild.sys.mjs b/toolkit/actors/AutoScrollChild.sys.mjs new file mode 100644 index 0000000000..88fa078c28 --- /dev/null +++ b/toolkit/actors/AutoScrollChild.sys.mjs @@ -0,0 +1,445 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + BrowserUtils: "resource://gre/modules/BrowserUtils.sys.mjs", +}); + +export class AutoScrollChild extends JSWindowActorChild { + constructor() { + super(); + + this._scrollable = null; + this._scrolldir = ""; + this._startX = null; + this._startY = null; + this._screenX = null; + this._screenY = null; + this._lastFrame = null; + this._autoscrollHandledByApz = false; + this._scrollId = null; + + this.observer = new AutoScrollObserver(this); + this.autoscrollLoop = this.autoscrollLoop.bind(this); + } + + isAutoscrollBlocker(event) { + let mmPaste = Services.prefs.getBoolPref("middlemouse.paste"); + let mmScrollbarPosition = Services.prefs.getBoolPref( + "middlemouse.scrollbarPosition" + ); + let node = event.originalTarget; + let content = node.ownerGlobal; + + // If the node is in editable document or content, we don't want to start + // autoscroll. + if (mmPaste) { + if (node.ownerDocument?.designMode == "on") { + return true; + } + const element = + node.nodeType === content.Node.ELEMENT_NODE ? node : node.parentElement; + if (element.isContentEditable) { + return true; + } + } + + // Don't start if we're on a link. + let [href] = lazy.BrowserUtils.hrefAndLinkNodeForClickEvent(event); + if (href) { + return true; + } + + // Or if we're pasting into an input field of sorts. + let closestInput = mmPaste && node.closest("input,textarea"); + if ( + content.HTMLInputElement.isInstance(closestInput) || + content.HTMLTextAreaElement.isInstance(closestInput) + ) { + return true; + } + + // Or if we're on a scrollbar or XUL <tree> + if ( + (mmScrollbarPosition && + content.XULElement.isInstance( + node.closest("scrollbar,scrollcorner") + )) || + content.XULElement.isInstance(node.closest("treechildren")) + ) { + return true; + } + return false; + } + + isScrollableElement(aNode) { + let content = aNode.ownerGlobal; + if (content.HTMLElement.isInstance(aNode)) { + return !content.HTMLSelectElement.isInstance(aNode) || aNode.multiple; + } + + return content.XULElement.isInstance(aNode); + } + + computeWindowScrollDirection(global) { + if (!global.scrollbars.visible) { + return null; + } + if (global.scrollMaxX != global.scrollMinX) { + return global.scrollMaxY != global.scrollMinY ? "NSEW" : "EW"; + } + if (global.scrollMaxY != global.scrollMinY) { + return "NS"; + } + return null; + } + + computeNodeScrollDirection(node) { + if (!this.isScrollableElement(node)) { + return null; + } + + let global = node.ownerGlobal; + + // this is a list of overflow property values that allow scrolling + const scrollingAllowed = ["scroll", "auto"]; + + let cs = global.getComputedStyle(node); + let overflowx = cs.getPropertyValue("overflow-x"); + let overflowy = cs.getPropertyValue("overflow-y"); + // we already discarded non-multiline selects so allow vertical + // scroll for multiline ones directly without checking for a + // overflow property + let scrollVert = + node.scrollTopMax && + (global.HTMLSelectElement.isInstance(node) || + scrollingAllowed.includes(overflowy)); + + // do not allow horizontal scrolling for select elements, it leads + // to visual artifacts and is not the expected behavior anyway + if ( + !global.HTMLSelectElement.isInstance(node) && + node.scrollLeftMin != node.scrollLeftMax && + scrollingAllowed.includes(overflowx) + ) { + return scrollVert ? "NSEW" : "EW"; + } + + if (scrollVert) { + return "NS"; + } + + return null; + } + + findNearestScrollableElement(aNode) { + // go upward in the DOM and find any parent element that has a overflow + // area and can therefore be scrolled + this._scrollable = null; + for (let node = aNode; node; node = node.flattenedTreeParentNode) { + // do not use overflow based autoscroll for <html> and <body> + // Elements or non-html/non-xul elements such as svg or Document nodes + // also make sure to skip select elements that are not multiline + let direction = this.computeNodeScrollDirection(node); + if (direction) { + this._scrolldir = direction; + this._scrollable = node; + break; + } + } + + if (!this._scrollable) { + let direction = this.computeWindowScrollDirection(aNode.ownerGlobal); + if (direction) { + this._scrolldir = direction; + this._scrollable = aNode.ownerGlobal; + } else if (aNode.ownerGlobal.frameElement) { + // Note, in case of out of process iframes frameElement is null, and + // a caller is supposed to communicate to iframe's parent on its own to + // support cross process scrolling. + this.findNearestScrollableElement(aNode.ownerGlobal.frameElement); + } + } + } + + async startScroll(event) { + this.findNearestScrollableElement(event.originalTarget); + if (!this._scrollable) { + this.sendAsyncMessage("Autoscroll:MaybeStartInParent", { + browsingContextId: this.browsingContext.id, + screenX: event.screenX, + screenY: event.screenY, + }); + return; + } + + let content = event.originalTarget.ownerGlobal; + + // In some configurations like Print Preview, content.performance + // (which we use below) is null. Autoscrolling is broken in Print + // Preview anyways (see bug 1393494), so just don't start it at all. + if (!content.performance) { + return; + } + + let domUtils = content.windowUtils; + let scrollable = this._scrollable; + if (scrollable instanceof Ci.nsIDOMWindow) { + // getViewId() needs an element to operate on. + scrollable = scrollable.document.documentElement; + } + this._scrollId = null; + try { + this._scrollId = domUtils.getViewId(scrollable); + } catch (e) { + // No view ID - leave this._scrollId as null. Receiving side will check. + } + let presShellId = domUtils.getPresShellId(); + let { autoscrollEnabled, usingApz } = await this.sendQuery( + "Autoscroll:Start", + { + scrolldir: this._scrolldir, + screenXDevPx: event.screenX * content.devicePixelRatio, + screenYDevPx: event.screenY * content.devicePixelRatio, + scrollId: this._scrollId, + presShellId, + browsingContext: this.browsingContext, + } + ); + if (!autoscrollEnabled) { + this._scrollable = null; + return; + } + + Services.els.addSystemEventListener(this.document, "mousemove", this, true); + Services.els.addSystemEventListener(this.document, "mouseup", this, true); + this.document.addEventListener("pagehide", this, true); + + this._startX = event.screenX; + this._startY = event.screenY; + this._screenX = event.screenX; + this._screenY = event.screenY; + this._scrollErrorX = 0; + this._scrollErrorY = 0; + this._autoscrollHandledByApz = usingApz; + + if (!usingApz) { + // If the browser didn't hand the autoscroll off to APZ, + // scroll here in the main thread. + this.startMainThreadScroll(); + } else { + // Even if the browser did hand the autoscroll to APZ, + // APZ might reject it in which case it will notify us + // and we need to take over. + Services.obs.addObserver(this.observer, "autoscroll-rejected-by-apz"); + } + + if (Cu.isInAutomation) { + Services.obs.notifyObservers(content, "autoscroll-start"); + } + } + + startMainThreadScroll() { + let content = this.document.defaultView; + this._lastFrame = content.performance.now(); + content.requestAnimationFrame(this.autoscrollLoop); + } + + stopScroll() { + if (this._scrollable) { + this._scrollable.mozScrollSnap(); + this._scrollable = null; + + Services.els.removeSystemEventListener( + this.document, + "mousemove", + this, + true + ); + Services.els.removeSystemEventListener( + this.document, + "mouseup", + this, + true + ); + this.document.removeEventListener("pagehide", this, true); + if (this._autoscrollHandledByApz) { + Services.obs.removeObserver( + this.observer, + "autoscroll-rejected-by-apz" + ); + } + } + } + + accelerate(curr, start) { + const speed = 12; + var val = (curr - start) / speed; + + if (val > 1) { + return val * Math.sqrt(val) - 1; + } + if (val < -1) { + return val * Math.sqrt(-val) + 1; + } + return 0; + } + + roundToZero(num) { + if (num > 0) { + return Math.floor(num); + } + return Math.ceil(num); + } + + autoscrollLoop(timestamp) { + if (!this._scrollable) { + // Scrolling has been canceled + return; + } + + // avoid long jumps when the browser hangs for more than + // |maxTimeDelta| ms + const maxTimeDelta = 100; + var timeDelta = Math.min(maxTimeDelta, timestamp - this._lastFrame); + // we used to scroll |accelerate()| pixels every 20ms (50fps) + var timeCompensation = timeDelta / 20; + this._lastFrame = timestamp; + + var actualScrollX = 0; + var actualScrollY = 0; + // don't bother scrolling vertically when the scrolldir is only horizontal + // and the other way around + if (this._scrolldir != "EW") { + var y = this.accelerate(this._screenY, this._startY) * timeCompensation; + var desiredScrollY = this._scrollErrorY + y; + actualScrollY = this.roundToZero(desiredScrollY); + this._scrollErrorY = desiredScrollY - actualScrollY; + } + if (this._scrolldir != "NS") { + var x = this.accelerate(this._screenX, this._startX) * timeCompensation; + var desiredScrollX = this._scrollErrorX + x; + actualScrollX = this.roundToZero(desiredScrollX); + this._scrollErrorX = desiredScrollX - actualScrollX; + } + + this._scrollable.scrollBy({ + left: actualScrollX, + top: actualScrollY, + behavior: "instant", + }); + + this._scrollable.ownerGlobal.requestAnimationFrame(this.autoscrollLoop); + } + + canStartAutoScrollWith(event) { + if ( + !event.isTrusted || + event.defaultPrevented || + event.button !== 1 || + event.clickEventPrevented() + ) { + return false; + } + + for (const modifier of ["shift", "alt", "ctrl", "meta"]) { + if ( + event[modifier + "Key"] && + Services.prefs.getBoolPref( + `general.autoscroll.prevent_to_start.${modifier}Key`, + false + ) + ) { + return false; + } + } + if ( + event.getModifierState("OS") && + Services.prefs.getBoolPref("general.autoscroll.prevent_to_start.osKey") + ) { + return false; + } + return true; + } + + handleEvent(event) { + switch (event.type) { + case "mousemove": + this._screenX = event.screenX; + this._screenY = event.screenY; + break; + case "mousedown": + if ( + this.canStartAutoScrollWith(event) && + !this._scrollable && + !this.isAutoscrollBlocker(event) + ) { + this.startScroll(event); + } + // fallthrough + case "mouseup": + if (this._scrollable) { + // Middle mouse click event shouldn't be fired in web content for + // compatibility with Chrome. + event.preventClickEvent(); + } + break; + case "pagehide": + if (this._scrollable) { + var doc = this._scrollable.ownerDocument || this._scrollable.document; + if (doc == event.target) { + this.sendAsyncMessage("Autoscroll:Cancel"); + this.stopScroll(); + } + } + break; + } + } + + receiveMessage(msg) { + let data = msg.data; + switch (msg.name) { + case "Autoscroll:MaybeStart": + for (let child of this.browsingContext.children) { + if (data.browsingContextId == child.id) { + this.startScroll({ + screenX: data.screenX, + screenY: data.screenY, + originalTarget: child.embedderElement, + }); + break; + } + } + break; + case "Autoscroll:Stop": { + this.stopScroll(); + break; + } + } + } + + rejectedByApz(data) { + // The caller passes in the scroll id via 'data'. + if (data == this._scrollId) { + this._autoscrollHandledByApz = false; + this.startMainThreadScroll(); + Services.obs.removeObserver(this.observer, "autoscroll-rejected-by-apz"); + } + } +} + +class AutoScrollObserver { + constructor(actor) { + this.actor = actor; + } + + observe(subject, topic, data) { + if (topic === "autoscroll-rejected-by-apz") { + this.actor.rejectedByApz(data); + } + } +} diff --git a/toolkit/actors/AutoScrollParent.sys.mjs b/toolkit/actors/AutoScrollParent.sys.mjs new file mode 100644 index 0000000000..1f9f780902 --- /dev/null +++ b/toolkit/actors/AutoScrollParent.sys.mjs @@ -0,0 +1,48 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class AutoScrollParent extends JSWindowActorParent { + receiveMessage(msg) { + let browser = this.manager.browsingContext.top.embedderElement; + if (!browser) { + return null; + } + + // If another tab is activated, we shouldn't start autoscroll requested + // for the previous active window if and only if the browser is a remote + // browser. This is required for web apps which don't prevent default of + // middle click after opening a new window. If the active tab is our + // documents like about:*, we don't need this check since our documents + // should do it correctly. + const requestedInForegroundTab = browser.isRemoteBrowser + ? Services.focus.focusedElement == browser + : true; + + let data = msg.data; + switch (msg.name) { + case "Autoscroll:Start": + // Don't start autoscroll if the tab has already been a background tab. + if (!requestedInForegroundTab) { + return Promise.resolve({ autoscrollEnabled: false, usingAPZ: false }); + } + return Promise.resolve(browser.startScroll(data)); + case "Autoscroll:MaybeStartInParent": + // Don't start autoscroll if the tab has already been a background tab. + if (!requestedInForegroundTab) { + return Promise.resolve({ autoscrollEnabled: false, usingAPZ: false }); + } + let parent = this.browsingContext.parent; + if (parent) { + let actor = parent.currentWindowGlobal.getActor("AutoScroll"); + actor.sendAsyncMessage("Autoscroll:MaybeStart", data); + } + break; + case "Autoscroll:Cancel": + browser.cancelScroll(); + break; + } + return null; + } +} diff --git a/toolkit/actors/AutoplayChild.sys.mjs b/toolkit/actors/AutoplayChild.sys.mjs new file mode 100644 index 0000000000..87fa966cb1 --- /dev/null +++ b/toolkit/actors/AutoplayChild.sys.mjs @@ -0,0 +1,10 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class AutoplayChild extends JSWindowActorChild { + handleEvent(event) { + this.sendAsyncMessage("GloballyAutoplayBlocked", {}); + } +} diff --git a/toolkit/actors/AutoplayParent.sys.mjs b/toolkit/actors/AutoplayParent.sys.mjs new file mode 100644 index 0000000000..3e9f807b3a --- /dev/null +++ b/toolkit/actors/AutoplayParent.sys.mjs @@ -0,0 +1,17 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class AutoplayParent extends JSWindowActorParent { + receiveMessage(aMessage) { + let topBrowsingContext = this.manager.browsingContext.top; + let browser = topBrowsingContext.embedderElement; + let document = browser.ownerDocument; + let event = document.createEvent("CustomEvent"); + event.initCustomEvent("GloballyAutoplayBlocked", true, false, { + url: this.documentURI, + }); + browser.dispatchEvent(event); + } +} diff --git a/toolkit/actors/BackgroundThumbnailsChild.sys.mjs b/toolkit/actors/BackgroundThumbnailsChild.sys.mjs new file mode 100644 index 0000000000..3af51b3b80 --- /dev/null +++ b/toolkit/actors/BackgroundThumbnailsChild.sys.mjs @@ -0,0 +1,102 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + PageThumbUtils: "resource://gre/modules/PageThumbUtils.sys.mjs", +}); + +// NOTE: Copied from nsSandboxFlags.h +/** + * This flag prevents content from creating new auxiliary browsing contexts, + * e.g. using the target attribute, or the window.open() method. + */ +const SANDBOXED_AUXILIARY_NAVIGATION = 0x2; + +export class BackgroundThumbnailsChild extends JSWindowActorChild { + receiveMessage(message) { + switch (message.name) { + case "Browser:Thumbnail:ContentInfo": { + if ( + message.data.isImage || + this.contentWindow.ImageDocument.isInstance(this.document) + ) { + // To avoid sending additional messages between processes, we return + // the image data directly with the size info. + return lazy.PageThumbUtils.createImageThumbnailCanvas( + this.contentWindow, + this.document.location, + message.data.targetWidth, + message.data.backgroundColor + ); + } + + let [width, height] = lazy.PageThumbUtils.getContentSize( + this.contentWindow + ); + return { width, height }; + } + + case "Browser:Thumbnail:LoadURL": { + let docShell = this.docShell.QueryInterface(Ci.nsIWebNavigation); + + // We want a low network priority for this service - lower than b/g tabs + // etc - so set it to the lowest priority available. + docShell + .QueryInterface(Ci.nsIDocumentLoader) + .loadGroup.QueryInterface(Ci.nsISupportsPriority).priority = + Ci.nsISupportsPriority.PRIORITY_LOWEST; + + docShell.allowMedia = false; + docShell.allowPlugins = false; + docShell.allowContentRetargeting = false; + let defaultFlags = + Ci.nsIRequest.LOAD_ANONYMOUS | + Ci.nsIRequest.LOAD_BYPASS_CACHE | + Ci.nsIRequest.INHIBIT_CACHING | + Ci.nsIWebNavigation.LOAD_FLAGS_BYPASS_HISTORY; + docShell.defaultLoadFlags = defaultFlags; + this.browsingContext.sandboxFlags |= SANDBOXED_AUXILIARY_NAVIGATION; + docShell.useTrackingProtection = true; + + // Get the document to force a content viewer to be created, otherwise + // the first load can fail. + if (!this.document) { + return false; + } + + let loadURIOptions = { + // Bug 1498603 verify usages of systemPrincipal here + triggeringPrincipal: + Services.scriptSecurityManager.getSystemPrincipal(), + loadFlags: Ci.nsIWebNavigation.LOAD_FLAGS_STOP_CONTENT, + }; + try { + docShell.loadURI( + Services.io.newURI(message.data.url), + loadURIOptions + ); + } catch (ex) { + return false; + } + + return true; + } + } + + return undefined; + } + + handleEvent(event) { + if (event.type == "DOMDocElementInserted") { + // Arrange to prevent (most) popup dialogs for this window - popups done + // in the parent (eg, auth) aren't prevented, but alert() etc are. + // disableDialogs only works on the current inner window, so it has + // to be called every page load, but before scripts run. + this.contentWindow.windowUtils.disableDialogs(); + } + } +} diff --git a/toolkit/actors/BrowserElementChild.sys.mjs b/toolkit/actors/BrowserElementChild.sys.mjs new file mode 100644 index 0000000000..97e1327821 --- /dev/null +++ b/toolkit/actors/BrowserElementChild.sys.mjs @@ -0,0 +1,35 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class BrowserElementChild extends JSWindowActorChild { + handleEvent(event) { + if ( + event.type == "DOMWindowClose" && + !this.manager.browsingContext.parent + ) { + this.sendAsyncMessage("DOMWindowClose", {}); + } + } + + receiveMessage(message) { + switch (message.name) { + case "EnterModalState": { + this.contentWindow.windowUtils.enterModalState(); + break; + } + + case "LeaveModalState": { + if ( + !message.data.forceLeave && + !this.contentWindow.windowUtils.isInModalState() + ) { + break; + } + this.contentWindow.windowUtils.leaveModalState(); + break; + } + } + } +} diff --git a/toolkit/actors/BrowserElementParent.sys.mjs b/toolkit/actors/BrowserElementParent.sys.mjs new file mode 100644 index 0000000000..c3cb0991a3 --- /dev/null +++ b/toolkit/actors/BrowserElementParent.sys.mjs @@ -0,0 +1,36 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/** + * The BrowserElementParent is for performing actions on one or more subframes of + * a <xul:browser> from the browser element binding. + */ +export class BrowserElementParent extends JSWindowActorParent { + receiveMessage(message) { + switch (message.name) { + case "DOMWindowClose": { + // This message is sent whenever window.close() is called within a window + // that had originally been opened via window.open. Double-check that this is + // coming from a top-level frame, and then dispatch the DOMWindowClose event + // on the browser so that the front-end code can do the right thing with the + // request to close. + if (!this.manager.browsingContext.parent) { + let browser = this.manager.browsingContext.embedderElement; + let win = browser.ownerGlobal; + // If this is a non-remote browser, the DOMWindowClose event will bubble + // up naturally, and doesn't need to be re-dispatched. + if (browser.isRemoteBrowser) { + browser.dispatchEvent( + new win.CustomEvent("DOMWindowClose", { + bubbles: true, + }) + ); + } + } + break; + } + } + } +} diff --git a/toolkit/actors/ClipboardReadPasteChild.sys.mjs b/toolkit/actors/ClipboardReadPasteChild.sys.mjs new file mode 100644 index 0000000000..e8b113bd68 --- /dev/null +++ b/toolkit/actors/ClipboardReadPasteChild.sys.mjs @@ -0,0 +1,39 @@ +/* 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/. */ + +/** + * Propagates "MozClipboardReadPaste" events from a content process to the + * chrome process. + * Receives messages from the chrome process. + */ +export class ClipboardReadPasteChild extends JSWindowActorChild { + constructor() { + super(); + } + + // EventListener interface. + handleEvent(aEvent) { + if (aEvent.type == "MozClipboardReadPaste" && aEvent.isTrusted) { + this.sendAsyncMessage("ClipboardReadPaste:ShowMenupopup", {}); + } + } + + // For JSWindowActorChild. + receiveMessage(value) { + switch (value.name) { + case "ClipboardReadPaste:PasteMenuItemClicked": { + this.contentWindow.navigator.clipboard.onUserReactedToPasteMenuPopup( + true + ); + break; + } + case "ClipboardReadPaste:PasteMenuItemDismissed": { + this.contentWindow.navigator.clipboard.onUserReactedToPasteMenuPopup( + false + ); + break; + } + } + } +} diff --git a/toolkit/actors/ClipboardReadPasteParent.sys.mjs b/toolkit/actors/ClipboardReadPasteParent.sys.mjs new file mode 100644 index 0000000000..a0b37f1041 --- /dev/null +++ b/toolkit/actors/ClipboardReadPasteParent.sys.mjs @@ -0,0 +1,194 @@ +/* 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/. */ + +const kMenuPopupId = "clipboardReadPasteMenuPopup"; + +// Exchanges messages with the child actor and handles events from the +// pasteMenuHandler. +export class ClipboardReadPasteParent extends JSWindowActorParent { + constructor() { + super(); + + this._menupopup = null; + this._menuitem = null; + this._delayTimer = null; + this._pasteMenuItemClicked = false; + this._lastBeepTime = 0; + } + + didDestroy() { + if (this._menupopup) { + this._menupopup.hidePopup(true); + } + } + + // EventListener interface. + handleEvent(aEvent) { + switch (aEvent.type) { + case "command": { + this.onCommand(); + break; + } + case "popuphiding": { + this.onPopupHiding(); + break; + } + case "keydown": { + this.onKeyDown(aEvent); + break; + } + } + } + + onCommand() { + this._pasteMenuItemClicked = true; + this.sendAsyncMessage("ClipboardReadPaste:PasteMenuItemClicked"); + } + + onPopupHiding() { + // Remove the listeners before potentially sending the async message + // below, because that might throw. + this._removeMenupopupEventListeners(); + this._clearDelayTimer(); + this._stopWatchingForSpammyActivation(); + + if (this._pasteMenuItemClicked) { + // A message was already sent. Reset the state to handle further + // click/dismiss events properly. + this._pasteMenuItemClicked = false; + } else { + this.sendAsyncMessage("ClipboardReadPaste:PasteMenuItemDismissed"); + } + } + + onKeyDown(aEvent) { + if (!this._menuitem.disabled) { + return; + } + + let accesskey = this._menuitem.getAttribute("accesskey"); + if ( + aEvent.key == accesskey.toLowerCase() || + aEvent.key == accesskey.toUpperCase() + ) { + if (Date.now() - this._lastBeepTime > 1000) { + Cc["@mozilla.org/sound;1"].getService(Ci.nsISound).beep(); + this._lastBeepTime = Date.now(); + } + this._refreshDelayTimer(); + } + } + + // For JSWindowActorParent. + receiveMessage(value) { + if (value.name == "ClipboardReadPaste:ShowMenupopup") { + if (!this._menupopup) { + this._menupopup = this._getMenupopup(); + this._menuitem = this._menupopup.firstElementChild; + } + + this._addMenupopupEventListeners(); + + const browser = this.browsingContext.top.embedderElement; + const window = browser.ownerGlobal; + const windowUtils = window.windowUtils; + + let mouseXInCSSPixels = {}; + let mouseYInCSSPixels = {}; + windowUtils.getLastOverWindowPointerLocationInCSSPixels( + mouseXInCSSPixels, + mouseYInCSSPixels + ); + + this._menuitem.disabled = true; + this._startWatchingForSpammyActivation(); + // `openPopup` is a no-op if the popup is already opened. + // That property is used when `navigator.clipboard.readText()` or + // `navigator.clipboard.read()`is called from two different frames, e.g. + // an iframe and the top level frame. In that scenario, the two frames + // correspond to different `navigator.clipboard` instances. When + // `readText()` or `read()` is called from both frames, an actor pair is + // instantiated for each of them. Both actor parents will call `openPopup` + // on the same `_menupopup` object. If the popup is already open, + // `openPopup` is a no-op. When the popup is clicked or dismissed both + // actor parents will receive the corresponding event. + this._menupopup.openPopup( + null, + "overlap" /* options */, + mouseXInCSSPixels.value, + mouseYInCSSPixels.value, + true /* isContextMenu */ + ); + + this._refreshDelayTimer(); + } + } + + _addMenupopupEventListeners() { + this._menupopup.addEventListener("command", this); + this._menupopup.addEventListener("popuphiding", this); + } + + _removeMenupopupEventListeners() { + this._menupopup.removeEventListener("command", this); + this._menupopup.removeEventListener("popuphiding", this); + } + + _createMenupopup(aChromeDoc) { + let menuitem = aChromeDoc.createXULElement("menuitem"); + menuitem.id = "clipboardReadPasteMenuItem"; + menuitem.setAttribute("data-l10n-id", "text-action-paste"); + + let menupopup = aChromeDoc.createXULElement("menupopup"); + menupopup.id = kMenuPopupId; + menupopup.appendChild(menuitem); + return menupopup; + } + + _getMenupopup() { + let browser = this.browsingContext.top.embedderElement; + let window = browser.ownerGlobal; + let chromeDoc = window.document; + + let menupopup = chromeDoc.getElementById(kMenuPopupId); + if (menupopup == null) { + menupopup = this._createMenupopup(chromeDoc); + const parent = + chromeDoc.querySelector("popupset") || chromeDoc.documentElement; + parent.appendChild(menupopup); + } + + return menupopup; + } + + _startWatchingForSpammyActivation() { + let doc = this._menuitem.ownerDocument; + Services.els.addSystemEventListener(doc, "keydown", this, true); + } + + _stopWatchingForSpammyActivation() { + let doc = this._menuitem.ownerDocument; + Services.els.removeSystemEventListener(doc, "keydown", this, true); + } + + _clearDelayTimer() { + if (this._delayTimer) { + let window = this._menuitem.ownerGlobal; + window.clearTimeout(this._delayTimer); + this._delayTimer = null; + } + } + + _refreshDelayTimer() { + this._clearDelayTimer(); + + let window = this._menuitem.ownerGlobal; + let delay = Services.prefs.getIntPref("security.dialog_enable_delay"); + this._delayTimer = window.setTimeout(() => { + this._menuitem.disabled = false; + this._stopWatchingForSpammyActivation(); + this._delayTimer = null; + }, delay); + } +} diff --git a/toolkit/actors/ContentMetaChild.sys.mjs b/toolkit/actors/ContentMetaChild.sys.mjs new file mode 100644 index 0000000000..929d92db47 --- /dev/null +++ b/toolkit/actors/ContentMetaChild.sys.mjs @@ -0,0 +1,199 @@ +/* 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/. */ + +// Debounce time in milliseconds - this should be long enough to account for +// sync script tags that could appear between desired meta tags +const TIMEOUT_DELAY = 1000; + +const ACCEPTED_PROTOCOLS = ["http:", "https:"]; + +// Possible description tags, listed in order from least favourable to most favourable +const DESCRIPTION_RULES = [ + "twitter:description", + "description", + "og:description", +]; + +// Possible image tags, listed in order from least favourable to most favourable +const PREVIEW_IMAGE_RULES = [ + "thumbnail", + "twitter:image", + "og:image", + "og:image:url", + "og:image:secure_url", +]; + +/* + * Checks if the incoming meta tag has a greater score than the current best + * score by checking the index of the meta tag in the list of rules provided. + * + * @param {Array} aRules + * The list of rules for a given type of meta tag + * @param {String} aTag + * The name or property of the incoming meta tag + * @param {String} aEntry + * The current best entry for the given meta tag + * + * @returns {Boolean} true if the incoming meta tag is better than the current + * best meta tag of that same kind, false otherwise + */ +function shouldExtractMetadata(aRules, aTag, aEntry) { + return aRules.indexOf(aTag) > aEntry.currMaxScore; +} + +/* + * Ensure that the preview image URL is safe and valid before storing + * + * @param {URL} aURL + * A URL object that needs to be checked for valid principal and protocol + * + * @returns {Boolean} true if the preview URL is safe and can be stored, false otherwise + */ +function checkLoadURIStr(aURL) { + if (!ACCEPTED_PROTOCOLS.includes(aURL.protocol)) { + return false; + } + try { + let ssm = Services.scriptSecurityManager; + let principal = ssm.createNullPrincipal({}); + ssm.checkLoadURIStrWithPrincipal( + principal, + aURL.href, + ssm.DISALLOW_INHERIT_PRINCIPAL + ); + } catch (e) { + return false; + } + return true; +} + +/* + * This listens to DOMMetaAdded events and collects relevant metadata about the + * meta tag received. Then, it sends the metadata gathered from the meta tags + * and the url of the page as it's payload to be inserted into moz_places. + */ +export class ContentMetaChild extends JSWindowActorChild { + constructor() { + super(); + + // Store a mapping of the best description and preview + // image collected so far for a given URL. + this.metaTags = new Map(); + } + + didDestroy() { + for (let entry of this.metaTags.values()) { + entry.timeout.cancel(); + } + } + + handleEvent(event) { + switch (event.type) { + case "DOMContentLoaded": + const metaTags = this.contentWindow.document.querySelectorAll("meta"); + for (let metaTag of metaTags) { + this.onMetaTag(metaTag); + } + break; + case "DOMMetaAdded": + this.onMetaTag(event.originalTarget); + break; + default: + } + } + + onMetaTag(metaTag) { + const window = metaTag.ownerGlobal; + + // If there's no meta tag, ignore this. Also verify that the window + // matches just to be safe. + if (!metaTag || !metaTag.ownerDocument || window != this.contentWindow) { + return; + } + + const url = metaTag.ownerDocument.documentURI; + + let name = metaTag.name; + let prop = metaTag.getAttributeNS(null, "property"); + if (!name && !prop) { + return; + } + + let tag = name || prop; + + const entry = this.metaTags.get(url) || { + description: { value: null, currMaxScore: -1 }, + image: { value: null, currMaxScore: -1 }, + timeout: null, + }; + + // Malformed meta tag - do not store it + const content = metaTag.getAttributeNS(null, "content"); + if (!content) { + return; + } + + if (shouldExtractMetadata(DESCRIPTION_RULES, tag, entry.description)) { + // Extract the description + entry.description.value = content; + entry.description.currMaxScore = DESCRIPTION_RULES.indexOf(tag); + } else if (shouldExtractMetadata(PREVIEW_IMAGE_RULES, tag, entry.image)) { + // Extract the preview image + let value; + try { + value = new URL(content, url); + } catch (e) { + return; + } + if (value && checkLoadURIStr(value)) { + entry.image.value = value.href; + entry.image.currMaxScore = PREVIEW_IMAGE_RULES.indexOf(tag); + } + } else { + // We don't care about other meta tags + return; + } + + if (!this.metaTags.has(url)) { + this.metaTags.set(url, entry); + } + + if (entry.timeout) { + entry.timeout.delay = TIMEOUT_DELAY; + } else { + // We want to debounce incoming meta tags until we're certain we have the + // best one for description and preview image, and only store that one + entry.timeout = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + entry.timeout.initWithCallback( + () => { + entry.timeout = null; + this.metaTags.delete(url); + // We try to cancel the timers when we get destroyed, but if + // there's a race, catch it: + if (!this.manager || this.manager.isClosed) { + return; + } + + // Save description and preview image to moz_places + this.sendAsyncMessage("Meta:SetPageInfo", { + url, + description: entry.description.value, + previewImageURL: entry.image.value, + }); + + // Telemetry for recording the size of page metadata + let metadataSize = entry.description.value + ? entry.description.value.length + : 0; + metadataSize += entry.image.value ? entry.image.value.length : 0; + Services.telemetry + .getHistogramById("PAGE_METADATA_SIZE") + .add(metadataSize); + }, + TIMEOUT_DELAY, + Ci.nsITimer.TYPE_ONE_SHOT + ); + } + } +} diff --git a/toolkit/actors/ContentMetaParent.sys.mjs b/toolkit/actors/ContentMetaParent.sys.mjs new file mode 100644 index 0000000000..4cdc6c3c85 --- /dev/null +++ b/toolkit/actors/ContentMetaParent.sys.mjs @@ -0,0 +1,23 @@ +/* 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/. */ + +export class ContentMetaParent extends JSWindowActorParent { + receiveMessage(message) { + if (message.name == "Meta:SetPageInfo") { + let browser = this.manager.browsingContext.top.embedderElement; + if (browser) { + let event = new browser.ownerGlobal.CustomEvent("pageinfo", { + bubbles: true, + cancelable: false, + detail: { + url: message.data.url, + description: message.data.description, + previewImageURL: message.data.previewImageURL, + }, + }); + browser.dispatchEvent(event); + } + } + } +} diff --git a/toolkit/actors/ControllersChild.sys.mjs b/toolkit/actors/ControllersChild.sys.mjs new file mode 100644 index 0000000000..d975c1f431 --- /dev/null +++ b/toolkit/actors/ControllersChild.sys.mjs @@ -0,0 +1,63 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class ControllersChild extends JSWindowActorChild { + receiveMessage(message) { + switch (message.name) { + case "ControllerCommands:Do": + if (this.docShell && this.docShell.isCommandEnabled(message.data)) { + this.docShell.doCommand(message.data); + } + break; + + case "ControllerCommands:DoWithParams": + var data = message.data; + if (this.docShell && this.docShell.isCommandEnabled(data.cmd)) { + var params = Cu.createCommandParams(); + let substituteXY = false; + let x = 0; + let y = 0; + if ( + data.cmd == "cmd_lookUpDictionary" && + "x" in data.params && + "y" in data.params && + data.params.x.type == "long" && + data.params.y.type == "long" + ) { + substituteXY = true; + x = parseInt(data.params.x.value); + y = parseInt(data.params.y.value); + + let rect = + this.contentWindow.windowUtils.convertFromParentProcessWidgetToLocal( + x, + y, + 1, + 1 + ); + x = Math.round(rect.x); + y = Math.round(rect.y); + } + + for (var name in data.params) { + var value = data.params[name]; + if (value.type == "long") { + if (substituteXY && name === "x") { + params.setLongValue(name, x); + } else if (substituteXY && name === "y") { + params.setLongValue(name, y); + } else { + params.setLongValue(name, parseInt(value.value)); + } + } else { + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + } + } + this.docShell.doCommandWithParams(data.cmd, params); + } + break; + } + } +} diff --git a/toolkit/actors/ControllersParent.sys.mjs b/toolkit/actors/ControllersParent.sys.mjs new file mode 100644 index 0000000000..05ea166112 --- /dev/null +++ b/toolkit/actors/ControllersParent.sys.mjs @@ -0,0 +1,90 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class ControllersParent extends JSWindowActorParent { + constructor() { + super(); + + // A map of commands that have had their enabled/disabled state assigned. The + // value of each key will be true if enabled, and false if disabled. + this.supportedCommands = {}; + } + + get browser() { + return this.browsingContext.top.embedderElement; + } + + // Update the set of enabled and disabled commands. + enableDisableCommands(aAction, aEnabledCommands, aDisabledCommands) { + // Clear the list first + this.supportedCommands = {}; + + for (let command of aEnabledCommands) { + this.supportedCommands[command] = true; + } + + for (let command of aDisabledCommands) { + this.supportedCommands[command] = false; + } + + let browser = this.browser; + if (browser) { + browser.ownerGlobal.updateCommands(aAction); + } + } + + isCommandEnabled(aCommand) { + return this.supportedCommands[aCommand] || false; + } + + supportsCommand(aCommand) { + return aCommand in this.supportedCommands; + } + + doCommand(aCommand) { + this.sendAsyncMessage("ControllerCommands:Do", aCommand); + } + + getCommandStateWithParams(aCommand, aCommandParams) { + throw Components.Exception("Not implemented", Cr.NS_ERROR_NOT_IMPLEMENTED); + } + + doCommandWithParams(aCommand, aCommandParams) { + let cmd = { + cmd: aCommand, + params: null, + }; + if (aCommand == "cmd_lookUpDictionary") { + cmd.params = { + x: { + type: "long", + value: aCommandParams.getLongValue("x"), + }, + y: { + type: "long", + value: aCommandParams.getLongValue("y"), + }, + }; + } else { + throw Components.Exception( + "Not implemented", + Cr.NS_ERROR_NOT_IMPLEMENTED + ); + } + this.sendAsyncMessage("ControllerCommands:DoWithParams", cmd); + } + + getSupportedCommands() { + throw Components.Exception("Not implemented", Cr.NS_ERROR_NOT_IMPLEMENTED); + } + + onEvent() {} +} + +ControllersParent.prototype.QueryInterface = ChromeUtils.generateQI([ + "nsIBrowserController", + "nsIController", + "nsICommandController", +]); diff --git a/toolkit/actors/DateTimePickerChild.sys.mjs b/toolkit/actors/DateTimePickerChild.sys.mjs new file mode 100644 index 0000000000..9ef55af435 --- /dev/null +++ b/toolkit/actors/DateTimePickerChild.sys.mjs @@ -0,0 +1,204 @@ +/* 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/. */ + +const lazy = {}; +ChromeUtils.defineESModuleGetters(lazy, { + LayoutUtils: "resource://gre/modules/LayoutUtils.sys.mjs", +}); + +/** + * DateTimePickerChild is the communication channel between the input box + * (content) for date/time input types and its picker (chrome). + */ +export class DateTimePickerChild extends JSWindowActorChild { + /** + * On init, just listen for the event to open the picker, once the picker is + * opened, we'll listen for update and close events. + */ + constructor() { + super(); + + this._inputElement = null; + } + + /** + * Cleanup function called when picker is closed. + */ + close() { + this.removeListeners(this._inputElement); + let dateTimeBoxElement = this._inputElement.dateTimeBoxElement; + if (!dateTimeBoxElement) { + this._inputElement = null; + return; + } + + // dateTimeBoxElement is within UA Widget Shadow DOM. + // An event dispatch to it can't be accessed by document. + let win = this._inputElement.ownerGlobal; + dateTimeBoxElement.dispatchEvent( + new win.CustomEvent("MozSetDateTimePickerState", { detail: false }) + ); + + this._inputElement = null; + } + + /** + * Called after picker is opened to start listening for input box update + * events. + */ + addListeners(aElement) { + aElement.ownerGlobal.addEventListener("pagehide", this); + } + + /** + * Stop listeneing for events when picker is closed. + */ + removeListeners(aElement) { + aElement.ownerGlobal.removeEventListener("pagehide", this); + } + + /** + * Helper function that returns the CSS direction property of the element. + */ + getComputedDirection(aElement) { + return aElement.ownerGlobal + .getComputedStyle(aElement) + .getPropertyValue("direction"); + } + + /** + * Helper function that returns the rect of the element, which is the position + * relative to the left/top of the content area. + */ + getBoundingContentRect(aElement) { + return lazy.LayoutUtils.getElementBoundingScreenRect(aElement); + } + + getTimePickerPref() { + return Services.prefs.getBoolPref("dom.forms.datetime.timepicker"); + } + + /** + * nsIMessageListener. + */ + receiveMessage(aMessage) { + switch (aMessage.name) { + case "FormDateTime:PickerClosed": { + if (!this._inputElement) { + return; + } + + this.close(); + break; + } + case "FormDateTime:PickerValueChanged": { + if (!this._inputElement) { + return; + } + + let dateTimeBoxElement = this._inputElement.dateTimeBoxElement; + if (!dateTimeBoxElement) { + return; + } + + let win = this._inputElement.ownerGlobal; + + // dateTimeBoxElement is within UA Widget Shadow DOM. + // An event dispatch to it can't be accessed by document. + dateTimeBoxElement.dispatchEvent( + new win.CustomEvent("MozPickerValueChanged", { + detail: Cu.cloneInto(aMessage.data, win), + }) + ); + break; + } + default: + break; + } + } + + /** + * nsIDOMEventListener, for chrome events sent by the input element and other + * DOM events. + */ + handleEvent(aEvent) { + switch (aEvent.type) { + case "MozOpenDateTimePicker": { + // Time picker is disabled when preffed off + if ( + !aEvent.originalTarget.ownerGlobal.HTMLInputElement.isInstance( + aEvent.originalTarget + ) || + (aEvent.originalTarget.type == "time" && !this.getTimePickerPref()) + ) { + return; + } + + if (this._inputElement) { + // This happens when we're trying to open a picker when another picker + // is still open. We ignore this request to let the first picker + // close gracefully. + return; + } + + this._inputElement = aEvent.originalTarget; + + let dateTimeBoxElement = this._inputElement.dateTimeBoxElement; + if (!dateTimeBoxElement) { + throw new Error("How do we get this event without a UA Widget?"); + } + + // dateTimeBoxElement is within UA Widget Shadow DOM. + // An event dispatch to it can't be accessed by document, because + // the event is not composed. + let win = this._inputElement.ownerGlobal; + dateTimeBoxElement.dispatchEvent( + new win.CustomEvent("MozSetDateTimePickerState", { detail: true }) + ); + + this.addListeners(this._inputElement); + + let value = this._inputElement.getDateTimeInputBoxValue(); + this.sendAsyncMessage("FormDateTime:OpenPicker", { + rect: this.getBoundingContentRect(this._inputElement), + dir: this.getComputedDirection(this._inputElement), + type: this._inputElement.type, + detail: { + // Pass partial value if it's available, otherwise pass input + // element's value. + value: Object.keys(value).length ? value : this._inputElement.value, + min: this._inputElement.getMinimum(), + max: this._inputElement.getMaximum(), + step: this._inputElement.getStep(), + stepBase: this._inputElement.getStepBase(), + }, + }); + break; + } + case "MozUpdateDateTimePicker": { + let value = this._inputElement.getDateTimeInputBoxValue(); + value.type = this._inputElement.type; + this.sendAsyncMessage("FormDateTime:UpdatePicker", { value }); + break; + } + case "MozCloseDateTimePicker": { + this.sendAsyncMessage("FormDateTime:ClosePicker", {}); + this.close(); + break; + } + case "pagehide": { + if ( + this._inputElement && + this._inputElement.ownerDocument == aEvent.target + ) { + this.sendAsyncMessage("FormDateTime:ClosePicker", {}); + this.close(); + } + break; + } + default: + break; + } + } +} diff --git a/toolkit/actors/DateTimePickerParent.sys.mjs b/toolkit/actors/DateTimePickerParent.sys.mjs new file mode 100644 index 0000000000..ba78a39ffb --- /dev/null +++ b/toolkit/actors/DateTimePickerParent.sys.mjs @@ -0,0 +1,157 @@ +/* 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/. */ + +const DEBUG = false; +function debug(aStr) { + if (DEBUG) { + dump("-*- DateTimePickerParent: " + aStr + "\n"); + } +} + +const lazy = {}; +ChromeUtils.defineESModuleGetters(lazy, { + DateTimePickerPanel: "resource://gre/modules/DateTimePickerPanel.sys.mjs", +}); + +/* + * DateTimePickerParent receives message from content side (input box) and + * is reposible for opening, closing and updating the picker. Similarly, + * DateTimePickerParent listens for picker's events and notifies the content + * side (input box) about them. + */ +export class DateTimePickerParent extends JSWindowActorParent { + receiveMessage(aMessage) { + debug("receiveMessage: " + aMessage.name); + switch (aMessage.name) { + case "FormDateTime:OpenPicker": { + this.showPicker(aMessage.data); + break; + } + case "FormDateTime:ClosePicker": { + if (!this._picker) { + return; + } + this.close(); + break; + } + case "FormDateTime:UpdatePicker": { + if (!this._picker) { + return; + } + this._picker.setPopupValue(aMessage.data); + break; + } + default: + break; + } + } + + handleEvent(aEvent) { + debug("handleEvent: " + aEvent.type); + switch (aEvent.type) { + case "DateTimePickerValueCleared": { + this.sendAsyncMessage("FormDateTime:PickerValueChanged", null); + break; + } + case "DateTimePickerValueChanged": { + this.sendAsyncMessage("FormDateTime:PickerValueChanged", aEvent.detail); + break; + } + case "popuphidden": { + this.sendAsyncMessage("FormDateTime:PickerClosed", {}); + this.close(); + break; + } + default: + break; + } + } + + // Get picker from browser and show it anchored to the input box. + showPicker(aData) { + let rect = aData.rect; + let type = aData.type; + let detail = aData.detail; + + debug("Opening picker with details: " + JSON.stringify(detail)); + let topBC = this.browsingContext.top; + let window = topBC.topChromeWindow; + if (Services.focus.activeWindow != window) { + debug("Not in the active window"); + return; + } + + { + let browser = topBC.embedderElement; + if ( + browser && + browser.ownerGlobal.gBrowser && + browser.ownerGlobal.gBrowser.selectedBrowser != browser + ) { + debug("In background tab"); + return; + } + } + + let doc = window.document; + let panel = doc.getElementById("DateTimePickerPanel"); + if (!panel) { + panel = doc.createXULElement("panel"); + panel.id = "DateTimePickerPanel"; + panel.setAttribute("type", "arrow"); + panel.setAttribute("orient", "vertical"); + panel.setAttribute("ignorekeys", "true"); + panel.setAttribute("noautofocus", "true"); + // This ensures that clicks on the anchored input box are never consumed. + panel.setAttribute("consumeoutsideclicks", "never"); + panel.setAttribute("level", "parent"); + panel.setAttribute("tabspecific", "true"); + let container = + doc.getElementById("mainPopupSet") || + doc.querySelector("popupset") || + doc.documentElement.appendChild(doc.createXULElement("popupset")); + container.appendChild(panel); + } + this._oldFocus = doc.activeElement; + this._picker = new lazy.DateTimePickerPanel(panel); + this._picker.openPicker(type, rect, detail); + this.addPickerListeners(); + } + + // Close the picker and do some cleanup. + close() { + this._picker.closePicker(); + // Restore focus to where it was before the picker opened. + this._oldFocus?.focus(); + this._oldFocus = null; + this.removePickerListeners(); + this._picker = null; + } + + // Listen to picker's event. + addPickerListeners() { + if (!this._picker) { + return; + } + this._picker.element.addEventListener("popuphidden", this); + this._picker.element.addEventListener("DateTimePickerValueChanged", this); + this._picker.element.addEventListener("DateTimePickerValueCleared", this); + } + + // Stop listening to picker's event. + removePickerListeners() { + if (!this._picker) { + return; + } + this._picker.element.removeEventListener("popuphidden", this); + this._picker.element.removeEventListener( + "DateTimePickerValueChanged", + this + ); + this._picker.element.removeEventListener( + "DateTimePickerValueCleared", + this + ); + } +} diff --git a/toolkit/actors/ExtFindChild.sys.mjs b/toolkit/actors/ExtFindChild.sys.mjs new file mode 100644 index 0000000000..dc6d296d88 --- /dev/null +++ b/toolkit/actors/ExtFindChild.sys.mjs @@ -0,0 +1,31 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + FindContent: "resource://gre/modules/FindContent.sys.mjs", +}); + +export class ExtFindChild extends JSWindowActorChild { + receiveMessage(message) { + if (!this._findContent) { + this._findContent = new lazy.FindContent(this.docShell); + } + + switch (message.name) { + case "ext-Finder:CollectResults": + this.finderInited = true; + return this._findContent.findRanges(message.data); + case "ext-Finder:HighlightResults": + return this._findContent.highlightResults(message.data); + case "ext-Finder:ClearHighlighting": + this._findContent.highlighter.highlight(false); + break; + } + + return null; + } +} diff --git a/toolkit/actors/FindBarChild.sys.mjs b/toolkit/actors/FindBarChild.sys.mjs new file mode 100644 index 0000000000..a82615a253 --- /dev/null +++ b/toolkit/actors/FindBarChild.sys.mjs @@ -0,0 +1,157 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + BrowserUtils: "resource://gre/modules/BrowserUtils.sys.mjs", +}); + +export class FindBarChild extends JSWindowActorChild { + constructor() { + super(); + + this._findKey = null; + + XPCOMUtils.defineLazyProxy( + this, + "FindBarContent", + () => { + const { FindBarContent } = ChromeUtils.importESModule( + "resource://gre/modules/FindBarContent.sys.mjs" + ); + return new FindBarContent(this); + }, + { inQuickFind: false, inPassThrough: false } + ); + } + + receiveMessage(msg) { + if (msg.name == "Findbar:UpdateState") { + let { FindBarContent } = this; + FindBarContent.updateState(msg.data); + } + } + + /** + * Check whether this key event will start the findbar in the parent, + * in which case we should pass any further key events to the parent to avoid + * them being lost. + * @param aEvent the key event to check. + */ + eventMatchesFindShortcut(aEvent) { + if (!this._findKey) { + this._findKey = Services.cpmm.sharedData.get("Findbar:Shortcut"); + if (!this._findKey) { + return false; + } + } + for (let k in this._findKey) { + if (this._findKey[k] != aEvent[k]) { + return false; + } + } + return true; + } + + handleEvent(event) { + if (event.type == "keypress") { + this.onKeypress(event); + } + } + + onKeypress(event) { + let { FindBarContent } = this; + + if (!FindBarContent.inPassThrough && this.eventMatchesFindShortcut(event)) { + return FindBarContent.start(event); + } + + // disable FAYT in about:blank to prevent FAYT opening unexpectedly. + let location = this.document.location.href; + if (location == "about:blank") { + return null; + } + + if ( + event.ctrlKey || + event.altKey || + event.metaKey || + event.defaultPrevented || + !lazy.BrowserUtils.mimeTypeIsTextBased(this.document.contentType) || + !lazy.BrowserUtils.canFindInPage(location) + ) { + return null; + } + + if (FindBarContent.inPassThrough || FindBarContent.inQuickFind) { + return FindBarContent.onKeypress(event); + } + + if (event.charCode && this.shouldFastFind(event.target)) { + let key = String.fromCharCode(event.charCode); + if ((key == "/" || key == "'") && FindBarChild.manualFAYT) { + return FindBarContent.startQuickFind(event); + } + if (key != " " && FindBarChild.findAsYouType) { + return FindBarContent.startQuickFind(event, true); + } + } + return null; + } + + /** + * Return true if we should FAYT for this node: + * + * @param elt + * The element that is focused + */ + shouldFastFind(elt) { + if (elt) { + let win = elt.ownerGlobal; + if (win.HTMLInputElement.isInstance(elt) && elt.mozIsTextField(false)) { + return false; + } + + if (elt.isContentEditable || win.document.designMode == "on") { + return false; + } + + if ( + win.HTMLTextAreaElement.isInstance(elt) || + win.HTMLSelectElement.isInstance(elt) || + win.HTMLObjectElement.isInstance(elt) || + win.HTMLEmbedElement.isInstance(elt) + ) { + return false; + } + + if ( + (win.HTMLIFrameElement.isInstance(elt) && elt.mozbrowser) || + win.XULFrameElement.isInstance(elt) + ) { + // If we're targeting a mozbrowser iframe or an embedded XULFrameElement + // (e.g. about:addons extensions inline options page), do not activate + // fast find. + return false; + } + } + + return true; + } +} + +XPCOMUtils.defineLazyPreferenceGetter( + FindBarChild, + "findAsYouType", + "accessibility.typeaheadfind" +); +XPCOMUtils.defineLazyPreferenceGetter( + FindBarChild, + "manualFAYT", + "accessibility.typeaheadfind.manual" +); diff --git a/toolkit/actors/FindBarParent.sys.mjs b/toolkit/actors/FindBarParent.sys.mjs new file mode 100644 index 0000000000..eaf42b634e --- /dev/null +++ b/toolkit/actors/FindBarParent.sys.mjs @@ -0,0 +1,47 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// Map of browser elements to findbars. +let findbars = new WeakMap(); + +export class FindBarParent extends JSWindowActorParent { + setFindbar(browser, findbar) { + if (findbar) { + findbars.set(browser, findbar); + } else { + findbars.delete(browser, findbar); + } + } + + receiveMessage(message) { + let browser = this.manager.browsingContext.top.embedderElement; + if (!browser) { + return; + } + + let respondToMessage = () => { + let findBar = findbars.get(browser); + if (!findBar) { + return; + } + + switch (message.name) { + case "Findbar:Keypress": + findBar._onBrowserKeypress(message.data); + break; + case "Findbar:Mouseup": + findBar.onMouseUp(); + break; + } + }; + + let findPromise = browser.ownerGlobal.gFindBarPromise; + if (findPromise) { + findPromise.then(respondToMessage); + } else { + respondToMessage(); + } + } +} diff --git a/toolkit/actors/FinderChild.sys.mjs b/toolkit/actors/FinderChild.sys.mjs new file mode 100644 index 0000000000..6a245cd606 --- /dev/null +++ b/toolkit/actors/FinderChild.sys.mjs @@ -0,0 +1,129 @@ +// -*- 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 +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + Finder: "resource://gre/modules/Finder.sys.mjs", +}); + +export class FinderChild extends JSWindowActorChild { + get finder() { + if (!this._finder) { + this._finder = new lazy.Finder(this.docShell); + } + return this._finder; + } + + receiveMessage(aMessage) { + let data = aMessage.data; + + switch (aMessage.name) { + case "Finder:CaseSensitive": + this.finder.caseSensitive = data.caseSensitive; + break; + + case "Finder:MatchDiacritics": + this.finder.matchDiacritics = data.matchDiacritics; + break; + + case "Finder:EntireWord": + this.finder.entireWord = data.entireWord; + break; + + case "Finder:SetSearchStringToSelection": { + return new Promise(resolve => { + resolve(this.finder.setSearchStringToSelection()); + }); + } + + case "Finder:GetInitialSelection": { + return new Promise(resolve => { + resolve(this.finder.getActiveSelectionText()); + }); + } + + case "Finder:Find": + return this.finder.find(data); + + case "Finder:Highlight": + return this.finder + .highlight( + data.highlight, + data.searchString, + data.linksOnly, + data.useSubFrames + ) + .then(result => { + if (result) { + result.browsingContextId = this.browsingContext.id; + } + return result; + }); + + case "Finder:UpdateHighlightAndMatchCount": + return this.finder.updateHighlightAndMatchCount(data).then(result => { + if (result) { + result.browsingContextId = this.browsingContext.id; + } + return result; + }); + + case "Finder:HighlightAllChange": + this.finder.onHighlightAllChange(data.highlightAll); + break; + + case "Finder:EnableSelection": + this.finder.enableSelection(); + break; + + case "Finder:RemoveSelection": + this.finder.removeSelection(data.keepHighlight); + break; + + case "Finder:FocusContent": + this.finder.focusContent(); + break; + + case "Finder:FindbarClose": + this.finder.onFindbarClose(); + break; + + case "Finder:FindbarOpen": + this.finder.onFindbarOpen(); + break; + + case "Finder:KeyPress": + var KeyboardEvent = this.finder._getWindow().KeyboardEvent; + this.finder.keyPress(new KeyboardEvent("keypress", data)); + break; + + case "Finder:MatchesCount": + return this.finder + .requestMatchesCount( + data.searchString, + data.linksOnly, + data.useSubFrames + ) + .then(result => { + if (result) { + result.browsingContextId = this.browsingContext.id; + } + return result; + }); + + case "Finder:ModalHighlightChange": + this.finder.onModalHighlightChange(data.useModalHighlight); + break; + + case "Finder:EnableMarkTesting": + this.finder.highlighter.enableTesting(data.enable); + break; + } + + return null; + } +} diff --git a/toolkit/actors/InlineSpellCheckerChild.sys.mjs b/toolkit/actors/InlineSpellCheckerChild.sys.mjs new file mode 100644 index 0000000000..c8262c749a --- /dev/null +++ b/toolkit/actors/InlineSpellCheckerChild.sys.mjs @@ -0,0 +1,38 @@ +/* -*- 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + InlineSpellCheckerContent: + "resource://gre/modules/InlineSpellCheckerContent.sys.mjs", +}); + +export class InlineSpellCheckerChild extends JSWindowActorChild { + receiveMessage(msg) { + switch (msg.name) { + case "InlineSpellChecker:selectDictionaries": + lazy.InlineSpellCheckerContent.selectDictionaries(msg.data.localeCodes); + break; + + case "InlineSpellChecker:replaceMisspelling": + lazy.InlineSpellCheckerContent.replaceMisspelling(msg.data.suggestion); + break; + + case "InlineSpellChecker:toggleEnabled": + lazy.InlineSpellCheckerContent.toggleEnabled(); + break; + + case "InlineSpellChecker:recheck": + lazy.InlineSpellCheckerContent.recheck(); + break; + + case "InlineSpellChecker:uninit": + lazy.InlineSpellCheckerContent.uninitContextMenu(); + break; + } + } +} diff --git a/toolkit/actors/InlineSpellCheckerParent.sys.mjs b/toolkit/actors/InlineSpellCheckerParent.sys.mjs new file mode 100644 index 0000000000..ff5f55724e --- /dev/null +++ b/toolkit/actors/InlineSpellCheckerParent.sys.mjs @@ -0,0 +1,50 @@ +/* -*- 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class InlineSpellCheckerParent extends JSWindowActorParent { + selectDictionaries({ localeCodes }) { + this.sendAsyncMessage("InlineSpellChecker:selectDictionaries", { + localeCodes, + }); + } + + replaceMisspelling({ suggestion }) { + this.sendAsyncMessage("InlineSpellChecker:replaceMisspelling", { + suggestion, + }); + } + + toggleEnabled() { + this.sendAsyncMessage("InlineSpellChecker:toggleEnabled", {}); + } + + recheckSpelling() { + this.sendAsyncMessage("InlineSpellChecker:recheck", {}); + } + + uninit() { + // This method gets called by InlineSpellChecker when the context menu + // goes away and the InlineSpellChecker instance is still alive. + // Stop referencing it and tidy the child end of us. + this.sendAsyncMessage("InlineSpellChecker:uninit", {}); + } + + _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; + } +} diff --git a/toolkit/actors/KeyPressEventModelCheckerChild.sys.mjs b/toolkit/actors/KeyPressEventModelCheckerChild.sys.mjs new file mode 100644 index 0000000000..8b4fe82f17 --- /dev/null +++ b/toolkit/actors/KeyPressEventModelCheckerChild.sys.mjs @@ -0,0 +1,107 @@ +/* -*- 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; + +export class KeyPressEventModelCheckerChild extends JSWindowActorChild { + // Currently, the event is dispatched only when the document becomes editable + // because of contenteditable. If you need to add new editor which is in + // designMode, you need to change MaybeDispatchCheckKeyPressEventModelEvent() + // of Document. + handleEvent(aEvent) { + if (!AppConstants.DEBUG) { + // Stop propagation in opt build to save the propagation cost. + // However, the event is necessary for running test_bug1514940.html. + // Therefore, we need to keep propagating it at least on debug build. + aEvent.stopImmediatePropagation(); + } + + // Currently, even if we set Document.KEYPRESS_EVENT_MODEL_CONFLATED + // here, conflated model isn't used forcibly. If you need it, you need + // to change WidgetKeyboardEvent, dom::KeyboardEvent and PresShell. + let model = Document.KEYPRESS_EVENT_MODEL_DEFAULT; + if ( + this._isOldOfficeOnlineServer(aEvent.target) || + this._isOldConfluence(aEvent.target.ownerGlobal) + ) { + model = Document.KEYPRESS_EVENT_MODEL_SPLIT; + } + aEvent.target.setKeyPressEventModel(model); + } + + _isOldOfficeOnlineServer(aDocument) { + let editingElement = aDocument.getElementById( + "WACViewPanel_EditingElement" + ); + // If it's not Office Online Server, don't include it into the telemetry + // because we just need to collect percentage of old version in all loaded + // Office Online Server instances. + if (!editingElement) { + return false; + } + let isOldVersion = !editingElement.classList.contains( + "WACViewPanel_DisableLegacyKeyCodeAndCharCode" + ); + Services.telemetry.keyedScalarAdd( + "dom.event.office_online_load_count", + isOldVersion ? "old" : "new", + 1 + ); + return isOldVersion; + } + + _isOldConfluence(aWindow) { + if (!aWindow) { + return false; + } + // aWindow should be an editor window in <iframe>. However, we don't know + // whether it can be without <iframe>. Anyway, there should be tinyMCE + // object in the parent window or in the window. + let tinyMCEObject; + // First, try to retrieve tinyMCE object from parent window. + try { + tinyMCEObject = ChromeUtils.waiveXrays(aWindow.parent).tinyMCE; + } catch (e) { + // Ignore the exception for now. + } + // Next, if there is no tinyMCE object in the parent window, let's check + // the window. + if (!tinyMCEObject) { + try { + tinyMCEObject = ChromeUtils.waiveXrays(aWindow).tinyMCE; + } catch (e) { + // Fallthrough to return false below. + } + // If we couldn't find tinyMCE object, let's assume that it's not + // Confluence instance. + if (!tinyMCEObject) { + return false; + } + } + // If there is tinyMCE object, we can assume that we loaded Confluence + // instance. So, let's check the version whether it allows conflated + // keypress event model. + try { + let { author, version } = + new tinyMCEObject.plugins.CursorTargetPlugin().getInfo(); + // If it's not Confluence, don't include it into the telemetry because + // we just need to collect percentage of old version in all loaded + // Confluence instances. + if (author !== "Atlassian") { + return false; + } + let isOldVersion = version === "1.0"; + Services.telemetry.keyedScalarAdd( + "dom.event.confluence_load_count", + isOldVersion ? "old" : "new", + 1 + ); + return isOldVersion; + } catch (e) { + return false; + } + } +} diff --git a/toolkit/actors/NetErrorChild.sys.mjs b/toolkit/actors/NetErrorChild.sys.mjs new file mode 100644 index 0000000000..671eb22baa --- /dev/null +++ b/toolkit/actors/NetErrorChild.sys.mjs @@ -0,0 +1,244 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + AppInfo: "chrome://remote/content/shared/AppInfo.sys.mjs", +}); + +import { RemotePageChild } from "resource://gre/actors/RemotePageChild.sys.mjs"; + +export class NetErrorChild extends RemotePageChild { + actorCreated() { + super.actorCreated(); + + // If you add a new function, remember to add it to RemotePageAccessManager.sys.mjs + // to allow content-privileged about:neterror or about:certerror to use it. + const exportableFunctions = [ + "RPMGetAppBuildID", + "RPMGetInnerMostURI", + "RPMAddToHistogram", + "RPMRecordTelemetryEvent", + "RPMCheckAlternateHostAvailable", + "RPMGetHttpResponseHeader", + "RPMIsTRROnlyFailure", + "RPMIsFirefox", + "RPMIsNativeFallbackFailure", + "RPMOpenPreferences", + "RPMGetTRRSkipReason", + "RPMGetTRRDomain", + "RPMIsSiteSpecificTRRError", + "RPMSetTRRDisabledLoadFlags", + "RPMGetCurrentTRRMode", + ]; + this.exportFunctions(exportableFunctions); + } + + getFailedCertChain(docShell) { + let securityInfo = + docShell.failedChannel && docShell.failedChannel.securityInfo; + if (!securityInfo) { + return []; + } + return securityInfo.failedCertChain.map(cert => cert.getBase64DERString()); + } + + handleEvent(aEvent) { + // Documents have a null ownerDocument. + let doc = aEvent.originalTarget.ownerDocument || aEvent.originalTarget; + + switch (aEvent.type) { + case "click": + let elem = aEvent.originalTarget; + if (elem.id == "viewCertificate") { + // Call through the superclass to avoid the security check. + this.sendAsyncMessage("Browser:CertExceptionError", { + location: doc.location.href, + elementId: elem.id, + failedCertChain: this.getFailedCertChain(doc.defaultView.docShell), + }); + } + break; + } + } + + RPMGetInnerMostURI(uriString) { + let uri = Services.io.newURI(uriString); + if (uri instanceof Ci.nsINestedURI) { + uri = uri.QueryInterface(Ci.nsINestedURI).innermostURI; + } + + return uri.spec; + } + + RPMGetAppBuildID() { + return Services.appinfo.appBuildID; + } + + RPMAddToHistogram(histID, bin) { + Services.telemetry.getHistogramById(histID).add(bin); + } + + RPMRecordTelemetryEvent(category, event, object, value, extra) { + Services.telemetry.recordEvent(category, event, object, value, extra); + } + + RPMCheckAlternateHostAvailable() { + const host = this.contentWindow.location.host.trim(); + + // Adapted from UrlbarUtils::looksLikeSingleWordHost + // https://searchfox.org/mozilla-central/rev/a26af613a476fafe6c3eba05a81bef63dff3c9f1/browser/components/urlbar/UrlbarUtils.sys.mjs#893 + const REGEXP_SINGLE_WORD = /^[^\s@:/?#]+(:\d+)?$/; + if (!REGEXP_SINGLE_WORD.test(host)) { + return; + } + + let info = Services.uriFixup.forceHttpFixup( + this.contentWindow.location.href + ); + + if (!info.fixupCreatedAlternateURI && !info.fixupChangedProtocol) { + return; + } + + let { displayHost, displaySpec, pathQueryRef } = info.fixedURI; + + if (pathQueryRef.endsWith("/")) { + pathQueryRef = pathQueryRef.slice(0, pathQueryRef.length - 1); + } + + let weakDoc = Cu.getWeakReference(this.contentWindow.document); + let onLookupCompleteListener = { + onLookupComplete(request, record, status) { + let doc = weakDoc.get(); + if (!doc || !Components.isSuccessCode(status)) { + return; + } + + let link = doc.createElement("a"); + link.href = displaySpec; + link.setAttribute("data-l10n-name", "website"); + + let span = doc.createElement("span"); + span.appendChild(link); + doc.l10n.setAttributes(span, "neterror-dns-not-found-with-suggestion", { + hostAndPath: displayHost + pathQueryRef, + }); + + const shortDesc = doc.getElementById("errorShortDesc"); + shortDesc.textContent += " "; + shortDesc.appendChild(span); + }, + }; + + Services.uriFixup.checkHost( + info.fixedURI, + onLookupCompleteListener, + this.document.nodePrincipal.originAttributes + ); + } + + // Get the header from the http response of the failed channel. This function + // is used in the 'about:neterror' page. + RPMGetHttpResponseHeader(responseHeader) { + let channel = this.contentWindow.docShell.failedChannel; + if (!channel) { + return ""; + } + + let httpChannel = channel.QueryInterface(Ci.nsIHttpChannel); + if (!httpChannel) { + return ""; + } + + try { + return httpChannel.getResponseHeader(responseHeader); + } catch (e) {} + + return ""; + } + + RPMIsTRROnlyFailure() { + // We will only show this in Firefox because the options may direct users to settings only available on Firefox Desktop + let channel = this.contentWindow?.docShell?.failedChannel?.QueryInterface( + Ci.nsIHttpChannelInternal + ); + if (!channel) { + return false; + } + return channel.effectiveTRRMode == Ci.nsIRequest.TRR_ONLY_MODE; + } + + RPMIsFirefox() { + return lazy.AppInfo.isFirefox; + } + + _getTRRSkipReason() { + let channel = this.contentWindow?.docShell?.failedChannel?.QueryInterface( + Ci.nsIHttpChannelInternal + ); + return channel?.trrSkipReason ?? Ci.nsITRRSkipReason.TRR_UNSET; + } + + RPMIsNativeFallbackFailure() { + if (!this.contentWindow?.navigator.onLine) { + return false; + } + + let skipReason = this._getTRRSkipReason(); + + if ( + Services.dns.currentTrrMode === Ci.nsIDNSService.MODE_TRRFIRST && + skipReason === Ci.nsITRRSkipReason.TRR_NOT_CONFIRMED + ) { + return true; + } + + const warningReasons = new Set([ + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_GOOGLE_SAFESEARCH, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_YOUTUBE_SAFESEARCH, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_ZSCALER_CANARY, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_CANARY, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_MODIFIED_ROOTS, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_PARENTAL_CONTROLS, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_THIRD_PARTY_ROOTS, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_ENTERPRISE_POLICY, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_VPN, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_PROXY, + Ci.nsITRRSkipReason.TRR_HEURISTIC_TRIPPED_NRPT, + ]); + + return ( + Services.dns.currentTrrMode === Ci.nsIDNSService.MODE_NATIVEONLY && + warningReasons.has(skipReason) + ); + } + + RPMGetTRRSkipReason() { + let skipReason = this._getTRRSkipReason(); + return Services.dns.getTRRSkipReasonName(skipReason); + } + + RPMGetTRRDomain() { + return Services.dns.trrDomain; + } + + RPMIsSiteSpecificTRRError() { + let skipReason = this._getTRRSkipReason(); + switch (skipReason) { + case Ci.nsITRRSkipReason.TRR_NXDOMAIN: + case Ci.nsITRRSkipReason.TRR_RCODE_FAIL: + case Ci.nsITRRSkipReason.TRR_NO_ANSWERS: + return true; + } + return false; + } + + RPMSetTRRDisabledLoadFlags() { + this.contentWindow.docShell.browsingContext.defaultLoadFlags |= + Ci.nsIRequest.LOAD_TRR_DISABLED_MODE; + } +} diff --git a/toolkit/actors/NetErrorParent.sys.mjs b/toolkit/actors/NetErrorParent.sys.mjs new file mode 100644 index 0000000000..7d1f0f3f0f --- /dev/null +++ b/toolkit/actors/NetErrorParent.sys.mjs @@ -0,0 +1,353 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; + +import { PrivateBrowsingUtils } from "resource://gre/modules/PrivateBrowsingUtils.sys.mjs"; +import { TelemetryController } from "resource://gre/modules/TelemetryController.sys.mjs"; + +const PREF_SSL_IMPACT_ROOTS = [ + "security.tls.version.", + "security.ssl3.", + "security.tls13.", +]; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + BrowserUtils: "resource://gre/modules/BrowserUtils.sys.mjs", +}); + +ChromeUtils.defineModuleGetter( + lazy, + "HomePage", + "resource:///modules/HomePage.jsm" +); + +class CaptivePortalObserver { + constructor(actor) { + this.actor = actor; + Services.obs.addObserver(this, "captive-portal-login-abort"); + Services.obs.addObserver(this, "captive-portal-login-success"); + } + + stop() { + Services.obs.removeObserver(this, "captive-portal-login-abort"); + Services.obs.removeObserver(this, "captive-portal-login-success"); + } + + observe(aSubject, aTopic, aData) { + switch (aTopic) { + case "captive-portal-login-abort": + case "captive-portal-login-success": + // Send a message to the content when a captive portal is freed + // so that error pages can refresh themselves. + this.actor.sendAsyncMessage("AboutNetErrorCaptivePortalFreed"); + break; + } + } +} + +export class NetErrorParent extends JSWindowActorParent { + constructor() { + super(); + this.captivePortalObserver = new CaptivePortalObserver(this); + } + + didDestroy() { + if (this.captivePortalObserver) { + this.captivePortalObserver.stop(); + } + } + + get browser() { + return this.browsingContext.top.embedderElement; + } + + hasChangedCertPrefs() { + let prefSSLImpact = PREF_SSL_IMPACT_ROOTS.reduce((prefs, root) => { + return prefs.concat(Services.prefs.getChildList(root)); + }, []); + for (let prefName of prefSSLImpact) { + if (Services.prefs.prefHasUserValue(prefName)) { + return true; + } + } + + return false; + } + + async ReportBlockingError(bcID, scheme, host, port, path, xfoAndCspInfo) { + // For reporting X-Frame-Options error and CSP: frame-ancestors errors, We + // are collecting 4 pieces of information. + // 1. The X-Frame-Options in the response header. + // 2. The CSP: frame-ancestors in the response header. + // 3. The URI of the frame who triggers this error. + // 4. The top-level URI which loads the frame. + // + // We will exclude the query strings from the reporting URIs. + // + // More details about the data we send can be found in + // https://firefox-source-docs.mozilla.org/toolkit/components/telemetry/telemetry/data/xfocsp-error-report-ping.html + // + + let topBC = BrowsingContext.get(bcID).top; + let topURI = topBC.currentWindowGlobal.documentURI; + + // Get the URLs without query strings. + let frame_uri = `${scheme}://${host}${port == -1 ? "" : ":" + port}${path}`; + let top_uri = `${topURI.scheme}://${topURI.hostPort}${topURI.filePath}`; + + TelemetryController.submitExternalPing( + "xfocsp-error-report", + { + ...xfoAndCspInfo, + frame_hostname: host, + top_hostname: topURI.host, + frame_uri, + top_uri, + }, + { addClientId: false, addEnvironment: false } + ); + } + + /** + * Return the default start page for the cases when the user's own homepage is + * infected, so we can get them somewhere safe. + */ + getDefaultHomePage(win) { + let url; + if ( + !PrivateBrowsingUtils.isWindowPrivate(win) && + AppConstants.MOZ_BUILD_APP == "browser" + ) { + url = lazy.HomePage.getDefault(); + } + url ||= win.BROWSER_NEW_TAB_URL || "about:blank"; + + // If url is a pipe-delimited set of pages, just take the first one. + if (url.includes("|")) { + url = url.split("|")[0]; + } + return url; + } + + /** + * Re-direct the browser to the previous page or a known-safe page if no + * previous page is found in history. This function is used when the user + * browses to a secure page with certificate issues and is presented with + * about:certerror. The "Go Back" button should take the user to the previous + * or a default start page so that even when their own homepage is on a server + * that has certificate errors, we can get them somewhere safe. + */ + goBackFromErrorPage(browser) { + if (!browser.canGoBack) { + // If the unsafe page is the first or the only one in history, go to the + // start page. + browser.fixupAndLoadURIString( + this.getDefaultHomePage(browser.ownerGlobal), + { + triggeringPrincipal: + Services.scriptSecurityManager.getSystemPrincipal(), + } + ); + } else { + browser.goBack(); + } + } + + /** + * This function does a canary request to a reliable, maintained endpoint, in + * order to help network code detect a system-wide man-in-the-middle. + */ + primeMitm(browser) { + // If we already have a mitm canary issuer stored, then don't bother with the + // extra request. This will be cleared on every update ping. + if (Services.prefs.getStringPref("security.pki.mitm_canary_issuer", null)) { + return; + } + + let url = Services.prefs.getStringPref( + "security.certerrors.mitm.priming.endpoint" + ); + let request = new XMLHttpRequest({ mozAnon: true }); + request.open("HEAD", url); + request.channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE; + request.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING; + + request.addEventListener("error", event => { + // Make sure the user is still on the cert error page. + if (!browser.documentURI.spec.startsWith("about:certerror")) { + return; + } + + let secInfo = request.channel.securityInfo; + if (secInfo.errorCodeString != "SEC_ERROR_UNKNOWN_ISSUER") { + return; + } + + // When we get to this point there's already something deeply wrong, it's very likely + // that there is indeed a system-wide MitM. + if (secInfo.serverCert && secInfo.serverCert.issuerName) { + // Grab the issuer of the certificate used in the exchange and store it so that our + // network-level MitM detection code has a comparison baseline. + Services.prefs.setStringPref( + "security.pki.mitm_canary_issuer", + secInfo.serverCert.issuerName + ); + + // MitM issues are sometimes caused by software not registering their root certs in the + // Firefox root store. We might opt for using third party roots from the system root store. + if ( + Services.prefs.getBoolPref( + "security.certerrors.mitm.auto_enable_enterprise_roots" + ) + ) { + if ( + !Services.prefs.getBoolPref("security.enterprise_roots.enabled") + ) { + // Loading enterprise roots happens on a background thread, so wait for import to finish. + lazy.BrowserUtils.promiseObserved( + "psm:enterprise-certs-imported" + ).then(() => { + if (browser.documentURI.spec.startsWith("about:certerror")) { + browser.reload(); + } + }); + + Services.prefs.setBoolPref( + "security.enterprise_roots.enabled", + true + ); + // Record that this pref was automatically set. + Services.prefs.setBoolPref( + "security.enterprise_roots.auto-enabled", + true + ); + } + } else { + // Need to reload the page to make sure network code picks up the canary issuer pref. + browser.reload(); + } + } + }); + + request.send(null); + } + + displayOfflineSupportPage(supportPageSlug) { + const AVAILABLE_PAGES = ["connection-not-secure", "time-errors"]; + if (!AVAILABLE_PAGES.includes(supportPageSlug)) { + console.log( + `[Not supported] Offline support is not yet available for ${supportPageSlug} errors.` + ); + return; + } + + let offlinePagePath = `chrome://global/content/neterror/supportpages/${supportPageSlug}.html`; + let triggeringPrincipal = + Services.scriptSecurityManager.getSystemPrincipal(); + this.browser.loadURI(Services.io.newURI(offlinePagePath), { + triggeringPrincipal, + }); + } + + receiveMessage(message) { + switch (message.name) { + case "Browser:EnableOnlineMode": + // Reset network state and refresh the page. + Services.io.offline = false; + this.browser.reload(); + break; + case "Browser:OpenCaptivePortalPage": + this.browser.ownerGlobal.CaptivePortalWatcher.ensureCaptivePortalTab(); + break; + case "Browser:PrimeMitm": + this.primeMitm(this.browser); + break; + case "Browser:ResetEnterpriseRootsPref": + Services.prefs.clearUserPref("security.enterprise_roots.enabled"); + Services.prefs.clearUserPref("security.enterprise_roots.auto-enabled"); + break; + case "Browser:ResetSSLPreferences": + let prefSSLImpact = PREF_SSL_IMPACT_ROOTS.reduce((prefs, root) => { + return prefs.concat(Services.prefs.getChildList(root)); + }, []); + for (let prefName of prefSSLImpact) { + Services.prefs.clearUserPref(prefName); + } + this.browser.reload(); + break; + case "Browser:SSLErrorGoBack": + this.goBackFromErrorPage(this.browser); + break; + case "Browser:SSLErrorReportTelemetry": + let reportStatus = message.data.reportStatus; + Services.telemetry + .getHistogramById("TLS_ERROR_REPORT_UI") + .add(reportStatus); + break; + case "GetChangedCertPrefs": + let hasChangedCertPrefs = this.hasChangedCertPrefs(); + this.sendAsyncMessage("HasChangedCertPrefs", { + hasChangedCertPrefs, + }); + break; + case "ReportBlockingError": + this.ReportBlockingError( + this.browsingContext.id, + message.data.scheme, + message.data.host, + message.data.port, + message.data.path, + message.data.xfoAndCspInfo + ); + break; + case "DisplayOfflineSupportPage": + this.displayOfflineSupportPage(message.data.supportPageSlug); + break; + case "Browser:CertExceptionError": + switch (message.data.elementId) { + case "viewCertificate": { + let certs = message.data.failedCertChain.map(certBase64 => + encodeURIComponent(certBase64) + ); + let certsStringURL = certs.map(elem => `cert=${elem}`); + certsStringURL = certsStringURL.join("&"); + let url = `about:certificate?${certsStringURL}`; + + let window = this.browser.ownerGlobal; + if (AppConstants.MOZ_BUILD_APP === "browser") { + window.switchToTabHavingURI(url, true, {}); + } else { + window.open(url, "_blank"); + } + break; + } + } + break; + case "Browser:AddTRRExcludedDomain": + let domain = message.data.hostname; + let excludedDomains = Services.prefs.getStringPref( + "network.trr.excluded-domains" + ); + excludedDomains += `, ${domain}`; + Services.prefs.setStringPref( + "network.trr.excluded-domains", + excludedDomains + ); + break; + case "OpenTRRPreferences": + let browser = this.browsingContext.top.embedderElement; + if (!browser) { + break; + } + + let win = browser.ownerGlobal; + win.openPreferences("privacy-doh"); + break; + } + } +} diff --git a/toolkit/actors/PictureInPictureChild.sys.mjs b/toolkit/actors/PictureInPictureChild.sys.mjs new file mode 100644 index 0000000000..ffaabbd5da --- /dev/null +++ b/toolkit/actors/PictureInPictureChild.sys.mjs @@ -0,0 +1,3152 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + ContentDOMReference: "resource://gre/modules/ContentDOMReference.sys.mjs", + DeferredTask: "resource://gre/modules/DeferredTask.sys.mjs", + KEYBOARD_CONTROLS: "resource://gre/modules/PictureInPictureControls.sys.mjs", + NimbusFeatures: "resource://nimbus/ExperimentAPI.sys.mjs", + Rect: "resource://gre/modules/Geometry.sys.mjs", + TOGGLE_POLICIES: "resource://gre/modules/PictureInPictureControls.sys.mjs", + TOGGLE_POLICY_STRINGS: + "resource://gre/modules/PictureInPictureControls.sys.mjs", +}); + +import { WebVTT } from "resource://gre/modules/vtt.sys.mjs"; +import { setTimeout, clearTimeout } from "resource://gre/modules/Timer.sys.mjs"; +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "DISPLAY_TEXT_TRACKS_PREF", + "media.videocontrols.picture-in-picture.display-text-tracks.enabled", + false +); +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "IMPROVED_CONTROLS_ENABLED_PREF", + "media.videocontrols.picture-in-picture.improved-video-controls.enabled", + false +); +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "MIN_VIDEO_LENGTH", + "media.videocontrols.picture-in-picture.video-toggle.min-video-secs", + 45 +); +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "PIP_TOGGLE_ALWAYS_SHOW", + "media.videocontrols.picture-in-picture.video-toggle.always-show", + false +); +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "PIP_URLBAR_BUTTON", + "media.videocontrols.picture-in-picture.urlbar-button.enabled", + false +); + +const PIP_ENABLED_PREF = "media.videocontrols.picture-in-picture.enabled"; +const TOGGLE_ENABLED_PREF = + "media.videocontrols.picture-in-picture.video-toggle.enabled"; +const TOGGLE_FIRST_SEEN_PREF = + "media.videocontrols.picture-in-picture.video-toggle.first-seen-secs"; +const TOGGLE_FIRST_TIME_DURATION_DAYS = 28; +const TOGGLE_HAS_USED_PREF = + "media.videocontrols.picture-in-picture.video-toggle.has-used"; +const TOGGLE_TESTING_PREF = + "media.videocontrols.picture-in-picture.video-toggle.testing"; +const TOGGLE_VISIBILITY_THRESHOLD_PREF = + "media.videocontrols.picture-in-picture.video-toggle.visibility-threshold"; +const TEXT_TRACK_FONT_SIZE = + "media.videocontrols.picture-in-picture.display-text-tracks.size"; + +const MOUSEMOVE_PROCESSING_DELAY_MS = 50; +const TOGGLE_HIDING_TIMEOUT_MS = 3000; +// If you change this, also change VideoControlsWidget.SEEK_TIME_SECS: +const SEEK_TIME_SECS = 5; +const EMPTIED_TIMEOUT_MS = 1000; + +// The ToggleChild does not want to capture events from the PiP +// windows themselves. This set contains all currently open PiP +// players' content windows +var gPlayerContents = new WeakSet(); + +// To make it easier to write tests, we have a process-global +// WeakSet of all <video> elements that are being tracked for +// mouseover +var gWeakIntersectingVideosForTesting = new WeakSet(); + +// Overrides are expected to stay constant for the lifetime of a +// content process, so we set this as a lazy process global. +// See PictureInPictureToggleChild.getSiteOverrides for a +// sense of what the return types are. +XPCOMUtils.defineLazyGetter(lazy, "gSiteOverrides", () => { + return PictureInPictureToggleChild.getSiteOverrides(); +}); + +XPCOMUtils.defineLazyGetter(lazy, "logConsole", () => { + return console.createInstance({ + prefix: "PictureInPictureChild", + maxLogLevel: Services.prefs.getBoolPref( + "media.videocontrols.picture-in-picture.log", + false + ) + ? "Debug" + : "Error", + }); +}); + +/** + * Creates and returns an instance of the PictureInPictureChildVideoWrapper class responsible + * for applying site-specific wrapper methods around the original video. + * + * The Picture-In-Picture add-on can use this to provide site-specific wrappers for + * sites that require special massaging to control. + * @param {Object} pipChild reference to PictureInPictureChild class calling this function + * @param {Element} originatingVideo + * The <video> element to wrap. + * @returns {PictureInPictureChildVideoWrapper} instance of PictureInPictureChildVideoWrapper + */ +function applyWrapper(pipChild, originatingVideo) { + let originatingDoc = originatingVideo.ownerDocument; + let originatingDocumentURI = originatingDoc.documentURI; + + let overrides = lazy.gSiteOverrides.find(([matcher]) => { + return matcher.matches(originatingDocumentURI); + }); + + // gSiteOverrides is a list of tuples where the first element is the MatchPattern + // for a supported site and the second is the actual overrides object for it. + let wrapperPath = overrides ? overrides[1].videoWrapperScriptPath : null; + return new PictureInPictureChildVideoWrapper( + wrapperPath, + originatingVideo, + pipChild + ); +} + +export class PictureInPictureLauncherChild extends JSWindowActorChild { + handleEvent(event) { + switch (event.type) { + case "MozTogglePictureInPicture": { + if (event.isTrusted) { + this.togglePictureInPicture({ + video: event.target, + reason: event.detail?.reason, + }); + } + break; + } + } + } + + receiveMessage(message) { + switch (message.name) { + case "PictureInPicture:KeyToggle": { + this.keyToggle(); + break; + } + } + } + + /** + * Tells the parent to open a Picture-in-Picture window hosting + * a clone of the passed video. If we know about a pre-existing + * Picture-in-Picture window existing, this tells the parent to + * close it before opening the new one. + * + * @param {Object} pipObject An object containing the video and reason + * for toggling the PiP video + * + * @return {Promise} + * @resolves {undefined} Once the new Picture-in-Picture window + * has been requested. + */ + async togglePictureInPicture(pipObject) { + let { video, reason } = pipObject; + if (video.isCloningElementVisually) { + // The only way we could have entered here for the same video is if + // we are toggling via the context menu or via the urlbar button, + // since we hide the inline Picture-in-Picture toggle when a video + // is being displayed in Picture-in-Picture. Turn off PiP in this case + const stopPipEvent = new this.contentWindow.CustomEvent( + "MozStopPictureInPicture", + { + bubbles: true, + detail: { reason }, + } + ); + video.dispatchEvent(stopPipEvent); + return; + } + + if (!PictureInPictureChild.videoWrapper) { + PictureInPictureChild.videoWrapper = applyWrapper( + PictureInPictureChild, + video + ); + } + + let timestamp = undefined; + let scrubberPosition = undefined; + + if (lazy.IMPROVED_CONTROLS_ENABLED_PREF) { + timestamp = PictureInPictureChild.videoWrapper.formatTimestamp( + PictureInPictureChild.videoWrapper.getCurrentTime(video), + PictureInPictureChild.videoWrapper.getDuration(video) + ); + + // Scrubber is hidden if undefined, so only set it to something else + // if the timestamp is not undefined. + scrubberPosition = + timestamp === undefined + ? undefined + : PictureInPictureChild.videoWrapper.getCurrentTime(video) / + PictureInPictureChild.videoWrapper.getDuration(video); + } + + // All other requests to toggle PiP should open a new PiP + // window + const videoRef = lazy.ContentDOMReference.get(video); + this.sendAsyncMessage("PictureInPicture:Request", { + isMuted: PictureInPictureChild.videoIsMuted(video), + playing: PictureInPictureChild.videoIsPlaying(video), + videoHeight: video.videoHeight, + videoWidth: video.videoWidth, + videoRef, + ccEnabled: lazy.DISPLAY_TEXT_TRACKS_PREF, + webVTTSubtitles: !!video.textTracks?.length, + scrubberPosition, + timestamp, + }); + + let args = { + firstTimeToggle: (!Services.prefs.getBoolPref( + TOGGLE_HAS_USED_PREF + )).toString(), + }; + + Services.telemetry.recordEvent( + "pictureinpicture", + "opened_method", + reason, + null, + args + ); + } + + /** + * The keyboard was used to attempt to open Picture-in-Picture. If a video is focused, + * select that video. Otherwise find the first playing video, or if none, the largest + * dimension video. We suspect this heuristic will handle most cases, though we + * might refine this later on. Note that we assume that this method will only be + * called for the focused document. + */ + keyToggle() { + let doc = this.document; + if (doc) { + let video = doc.activeElement; + if (!HTMLVideoElement.isInstance(video)) { + let listOfVideos = [...doc.querySelectorAll("video")].filter( + video => !isNaN(video.duration) + ); + // Get the first non-paused video, otherwise the longest video. This + // fallback is designed to skip over "preview"-style videos on sidebars. + video = + listOfVideos.filter(v => !v.paused)[0] || + listOfVideos.sort((a, b) => b.duration - a.duration)[0]; + } + if (video) { + this.togglePictureInPicture({ video, reason: "shortcut" }); + } + } + } +} + +/** + * The PictureInPictureToggleChild is responsible for displaying the overlaid + * Picture-in-Picture toggle over top of <video> elements that the mouse is + * hovering. + */ +export class PictureInPictureToggleChild extends JSWindowActorChild { + constructor() { + super(); + // We need to maintain some state about various things related to the + // Picture-in-Picture toggles - however, for now, the same + // PictureInPictureToggleChild might be re-used for different documents. + // We keep the state stashed inside of this WeakMap, keyed on the document + // itself. + this.weakDocStates = new WeakMap(); + this.toggleEnabled = + Services.prefs.getBoolPref(TOGGLE_ENABLED_PREF) && + Services.prefs.getBoolPref(PIP_ENABLED_PREF); + this.toggleTesting = Services.prefs.getBoolPref(TOGGLE_TESTING_PREF, false); + + // Bug 1570744 - JSWindowActorChild's cannot be used as nsIObserver's + // directly, so we create a new function here instead to act as our + // nsIObserver, which forwards the notification to the observe method. + this.observerFunction = (subject, topic, data) => { + this.observe(subject, topic, data); + }; + Services.prefs.addObserver(TOGGLE_ENABLED_PREF, this.observerFunction); + Services.prefs.addObserver(PIP_ENABLED_PREF, this.observerFunction); + Services.prefs.addObserver(TOGGLE_FIRST_SEEN_PREF, this.observerFunction); + Services.cpmm.sharedData.addEventListener("change", this); + + this.eligiblePipVideos = new WeakSet(); + this.trackingVideos = new WeakSet(); + } + + receiveMessage(message) { + switch (message.name) { + case "PictureInPicture:UrlbarToggle": { + this.urlbarToggle(); + break; + } + } + return null; + } + + didDestroy() { + this.stopTrackingMouseOverVideos(); + Services.prefs.removeObserver(TOGGLE_ENABLED_PREF, this.observerFunction); + Services.prefs.removeObserver(PIP_ENABLED_PREF, this.observerFunction); + Services.prefs.removeObserver( + TOGGLE_FIRST_SEEN_PREF, + this.observerFunction + ); + Services.cpmm.sharedData.removeEventListener("change", this); + + // remove the observer on the <video> element + let state = this.docState; + if (state?.intersectionObserver) { + state.intersectionObserver.disconnect(); + } + + // ensure the sandbox created by the video is destroyed + this.videoWrapper?.destroy(); + this.videoWrapper = null; + + for (let video of ChromeUtils.nondeterministicGetWeakSetKeys( + this.eligiblePipVideos + )) { + video.removeEventListener("emptied", this); + video.removeEventListener("loadedmetadata", this); + video.removeEventListener("durationchange", this); + } + + for (let video of ChromeUtils.nondeterministicGetWeakSetKeys( + this.trackingVideos + )) { + video.removeEventListener("emptied", this); + video.removeEventListener("loadedmetadata", this); + video.removeEventListener("durationchange", this); + } + + // ensure we don't access the state + this.isDestroyed = true; + } + + observe(subject, topic, data) { + if (topic != "nsPref:changed") { + return; + } + + this.toggleEnabled = + Services.prefs.getBoolPref(TOGGLE_ENABLED_PREF) && + Services.prefs.getBoolPref(PIP_ENABLED_PREF); + + if (this.toggleEnabled) { + // We have enabled the Picture-in-Picture toggle, so we need to make + // sure we register all of the videos that might already be on the page. + this.contentWindow.requestIdleCallback(() => { + let videos = this.document.querySelectorAll("video"); + for (let video of videos) { + this.registerVideo(video); + } + }); + } + + switch (data) { + case TOGGLE_FIRST_SEEN_PREF: + const firstSeenSeconds = Services.prefs.getIntPref( + TOGGLE_FIRST_SEEN_PREF + ); + if (!firstSeenSeconds || firstSeenSeconds < 0) { + return; + } + this.changeToIconIfDurationEnd(firstSeenSeconds); + break; + } + } + + /** + * Returns the state for the current document referred to via + * this.document. If no such state exists, creates it, stores it + * and returns it. + */ + get docState() { + if (this.isDestroyed || !this.document) { + return false; + } + + let state = this.weakDocStates.get(this.document); + + let visibilityThresholdPref = Services.prefs.getFloatPref( + TOGGLE_VISIBILITY_THRESHOLD_PREF, + "1.0" + ); + + if (!state) { + state = { + // A reference to the IntersectionObserver that's monitoring for videos + // to become visible. + intersectionObserver: null, + // A WeakSet of videos that are supposedly visible, according to the + // IntersectionObserver. + weakVisibleVideos: new WeakSet(), + // The number of videos that are supposedly visible, according to the + // IntersectionObserver + visibleVideosCount: 0, + // The DeferredTask that we'll arm every time a mousemove event occurs + // on a page where we have one or more visible videos. + mousemoveDeferredTask: null, + // A weak reference to the last video we displayed the toggle over. + weakOverVideo: null, + // True if the user is in the midst of clicking the toggle. + isClickingToggle: false, + // Set to the original target element on pointerdown if the user is clicking + // the toggle - this way, we can determine if a "click" event will need to be + // suppressed ("click" events don't fire if a "mouseup" occurs on a different + // element from the "pointerdown" / "mousedown" event). + clickedElement: null, + // This is a DeferredTask to hide the toggle after a period of mouse + // inactivity. + hideToggleDeferredTask: null, + // If we reach a point where we're tracking videos for mouse movements, + // then this will be true. If there are no videos worth tracking, then + // this is false. + isTrackingVideos: false, + togglePolicy: lazy.TOGGLE_POLICIES.DEFAULT, + toggleVisibilityThreshold: visibilityThresholdPref, + // The documentURI that has been checked with toggle policies and + // visibility thresholds for this document. Note that the documentURI + // might change for a document via the history API, so we remember + // the last checked documentURI to determine if we need to check again. + checkedPolicyDocumentURI: null, + }; + this.weakDocStates.set(this.document, state); + } + + return state; + } + + /** + * Returns the video that the user was last hovering with the mouse if it + * still exists. + * + * @return {Element} the <video> element that the user was last hovering, + * or null if there was no such <video>, or the <video> no longer exists. + */ + getWeakOverVideo() { + let { weakOverVideo } = this.docState; + if (weakOverVideo) { + // Bug 800957 - Accessing weakrefs at the wrong time can cause us to + // throw NS_ERROR_XPC_BAD_CONVERT_NATIVE + try { + return weakOverVideo.get(); + } catch (e) { + return null; + } + } + return null; + } + + handleEvent(event) { + if (!event.isTrusted) { + // We don't care about synthesized events that might be coming from + // content JS. + return; + } + + // Don't capture events from Picture-in-Picture content windows + if (gPlayerContents.has(this.contentWindow)) { + return; + } + + switch (event.type) { + case "touchstart": { + // Even if this is a touch event, there may be subsequent click events. + // Suppress those events after selecting the toggle to prevent playback changes + // when opening the Picture-in-Picture window. + if (this.docState.isClickingToggle) { + event.stopImmediatePropagation(); + event.preventDefault(); + } + break; + } + case "change": { + const { changedKeys } = event; + if (changedKeys.includes("PictureInPicture:SiteOverrides")) { + // For now we only update our cache if the site overrides change. + // the user will need to refresh the page for changes to apply. + try { + lazy.gSiteOverrides = + PictureInPictureToggleChild.getSiteOverrides(); + } catch (e) { + // Ignore resulting TypeError if gSiteOverrides is still unloaded + if (!(e instanceof TypeError)) { + throw e; + } + } + } + break; + } + case "UAWidgetSetupOrChange": { + if ( + this.toggleEnabled && + this.contentWindow.HTMLVideoElement.isInstance(event.target) && + event.target.ownerDocument == this.document + ) { + this.registerVideo(event.target); + } + break; + } + case "contextmenu": { + if (this.toggleEnabled) { + this.checkContextMenu(event); + } + break; + } + case "mouseout": { + this.onMouseOut(event); + break; + } + case "click": + if (event.detail == 0) { + let shadowRoot = event.originalTarget.containingShadowRoot; + let toggle = this.getToggleElement(shadowRoot); + if (event.originalTarget == toggle) { + this.startPictureInPicture(event, shadowRoot.host, toggle); + return; + } + } + // fall through + case "mousedown": + case "pointerup": + case "mouseup": { + this.onMouseButtonEvent(event); + break; + } + case "pointerdown": { + this.onPointerDown(event); + break; + } + case "mousemove": { + this.onMouseMove(event); + break; + } + case "pageshow": { + this.onPageShow(event); + break; + } + case "pagehide": { + this.onPageHide(event); + break; + } + case "durationchange": + // Intentional fall-through + case "emptied": + // Intentional fall-through + case "loadedmetadata": { + this.updatePipVideoEligibility(event.target); + break; + } + } + } + + /** + * Adds a <video> to the IntersectionObserver so that we know when it becomes + * visible. + * + * @param {Element} video The <video> element to register. + */ + registerVideo(video) { + let state = this.docState; + if (!state.intersectionObserver) { + let fn = this.onIntersection.bind(this); + state.intersectionObserver = new this.contentWindow.IntersectionObserver( + fn, + { + threshold: [0.0, 0.5], + } + ); + } + + state.intersectionObserver.observe(video); + + if (!lazy.PIP_URLBAR_BUTTON) { + return; + } + + video.addEventListener("emptied", this); + video.addEventListener("loadedmetadata", this); + video.addEventListener("durationchange", this); + + this.trackingVideos.add(video); + + this.updatePipVideoEligibility(video); + } + + updatePipVideoEligibility(video) { + let isEligible = this.isVideoPiPEligible(video); + if (isEligible) { + if (!this.eligiblePipVideos.has(video)) { + this.eligiblePipVideos.add(video); + + let mutationObserver = new this.contentWindow.MutationObserver( + mutationList => { + this.handleEligiblePipVideoMutation(mutationList); + } + ); + mutationObserver.observe(video.parentElement, { childList: true }); + } + } else if (this.eligiblePipVideos.has(video)) { + this.eligiblePipVideos.delete(video); + } + + let videos = ChromeUtils.nondeterministicGetWeakSetKeys( + this.eligiblePipVideos + ); + + this.sendAsyncMessage("PictureInPicture:UpdateEligiblePipVideoCount", { + pipCount: videos.length, + pipDisabledCount: videos.reduce( + (accumulator, currentVal) => + accumulator + + (currentVal.getAttribute("disablePictureInPicture") === "true" + ? 1 + : 0), + 0 + ), + }); + } + + handleEligiblePipVideoMutation(mutationList) { + for (let mutationRecord of mutationList) { + let video = mutationRecord.removedNodes[0]; + this.eligiblePipVideos.delete(video); + } + + let videos = ChromeUtils.nondeterministicGetWeakSetKeys( + this.eligiblePipVideos + ); + + this.sendAsyncMessage("PictureInPicture:UpdateEligiblePipVideoCount", { + pipCount: videos.length, + pipDisabledCount: videos.reduce( + (accumulator, currentVal) => + accumulator + + (currentVal.getAttribute("disablePictureInPicture") === "true" + ? 1 + : 0), + 0 + ), + }); + } + + urlbarToggle() { + let video = ChromeUtils.nondeterministicGetWeakSetKeys( + this.eligiblePipVideos + )[0]; + if (video) { + let pipEvent = new this.contentWindow.CustomEvent( + "MozTogglePictureInPicture", + { + bubbles: true, + detail: { reason: "urlBar" }, + } + ); + video.dispatchEvent(pipEvent); + } + } + + isVideoPiPEligible(video) { + if (lazy.PIP_TOGGLE_ALWAYS_SHOW) { + return true; + } + + if (isNaN(video.duration) || video.duration < lazy.MIN_VIDEO_LENGTH) { + return false; + } + + const MIN_VIDEO_DIMENSION = 140; // pixels + if ( + video.clientWidth < MIN_VIDEO_DIMENSION || + video.clientHeight < MIN_VIDEO_DIMENSION + ) { + return false; + } + + return true; + } + + /** + * Changes from the first-time toggle to the icon toggle if the Nimbus variable `displayDuration`'s + * end date is reached when hovering over a video. The end date is calculated according to the timestamp + * indicating when the PiP toggle was first seen. + * @param {Number} firstSeenStartSeconds the timestamp in seconds indicating when the PiP toggle was first seen + */ + changeToIconIfDurationEnd(firstSeenStartSeconds) { + const { displayDuration } = + lazy.NimbusFeatures.pictureinpicture.getAllVariables({ + defaultValues: { + displayDuration: TOGGLE_FIRST_TIME_DURATION_DAYS, + }, + }); + if (!displayDuration || displayDuration < 0) { + return; + } + + let daysInSeconds = displayDuration * 24 * 60 * 60; + let firstSeenEndSeconds = daysInSeconds + firstSeenStartSeconds; + let currentDateSeconds = Math.round(Date.now() / 1000); + + lazy.logConsole.debug( + "Toggle duration experiment - first time toggle seen on:", + new Date(firstSeenStartSeconds * 1000).toLocaleDateString() + ); + lazy.logConsole.debug( + "Toggle duration experiment - first time toggle will change on:", + new Date(firstSeenEndSeconds * 1000).toLocaleDateString() + ); + lazy.logConsole.debug( + "Toggle duration experiment - current date:", + new Date(currentDateSeconds * 1000).toLocaleDateString() + ); + + if (currentDateSeconds >= firstSeenEndSeconds) { + this.sendAsyncMessage("PictureInPicture:SetHasUsed", { + hasUsed: true, + }); + } + } + + /** + * Called by the IntersectionObserver callback once a video becomes visible. + * This adds some fine-grained checking to ensure that a sufficient amount of + * the video is visible before we consider showing the toggles on it. For now, + * that means that the entirety of the video must be in the viewport. + * + * @param {IntersectionEntry} intersectionEntry An IntersectionEntry passed to + * the IntersectionObserver callback. + * @return bool Whether or not we should start tracking mousemove events for + * this registered video. + */ + worthTracking(intersectionEntry) { + return intersectionEntry.isIntersecting; + } + + /** + * Called by the IntersectionObserver once a video crosses one of the + * thresholds dictated by the IntersectionObserver configuration. + * + * @param {Array<IntersectionEntry>} A collection of one or more + * IntersectionEntry's for <video> elements that might have entered or exited + * the viewport. + */ + onIntersection(entries) { + // The IntersectionObserver will also fire when a previously intersecting + // element is removed from the DOM. We know, however, that the node is + // still alive and referrable from the WeakSet because the + // IntersectionObserverEntry holds a strong reference to the video. + let state = this.docState; + if (!state) { + return; + } + let oldVisibleVideosCount = state.visibleVideosCount; + for (let entry of entries) { + let video = entry.target; + if (this.worthTracking(entry)) { + if (!state.weakVisibleVideos.has(video)) { + state.weakVisibleVideos.add(video); + state.visibleVideosCount++; + if (this.toggleTesting) { + gWeakIntersectingVideosForTesting.add(video); + } + } + } else if (state.weakVisibleVideos.has(video)) { + state.weakVisibleVideos.delete(video); + state.visibleVideosCount--; + if (this.toggleTesting) { + gWeakIntersectingVideosForTesting.delete(video); + } + } + } + + // For testing, especially in debug or asan builds, we might not + // run this idle callback within an acceptable time. While we're + // testing, we'll bypass the idle callback performance optimization + // and run our callbacks as soon as possible during the next idle + // period. + if (!oldVisibleVideosCount && state.visibleVideosCount) { + if (this.toggleTesting || !this.contentWindow) { + this.beginTrackingMouseOverVideos(); + } else { + this.contentWindow.requestIdleCallback(() => { + this.beginTrackingMouseOverVideos(); + }); + } + } else if (oldVisibleVideosCount && !state.visibleVideosCount) { + if (this.toggleTesting || !this.contentWindow) { + this.stopTrackingMouseOverVideos(); + } else { + this.contentWindow.requestIdleCallback(() => { + this.stopTrackingMouseOverVideos(); + }); + } + } + } + + addMouseButtonListeners() { + // We want to try to cancel the mouse events from continuing + // on into content if the user has clicked on the toggle, so + // we don't use the mozSystemGroup here, and add the listener + // to the parent target of the window, which in this case, + // is the windowRoot. Since this event listener is attached to + // part of the outer window, we need to also remove it in a + // pagehide event listener in the event that the page unloads + // before stopTrackingMouseOverVideos fires. + this.contentWindow.windowRoot.addEventListener("pointerdown", this, { + capture: true, + }); + this.contentWindow.windowRoot.addEventListener("mousedown", this, { + capture: true, + }); + this.contentWindow.windowRoot.addEventListener("mouseup", this, { + capture: true, + }); + this.contentWindow.windowRoot.addEventListener("pointerup", this, { + capture: true, + }); + this.contentWindow.windowRoot.addEventListener("click", this, { + capture: true, + }); + this.contentWindow.windowRoot.addEventListener("mouseout", this, { + capture: true, + }); + this.contentWindow.windowRoot.addEventListener("touchstart", this, { + capture: true, + }); + } + + removeMouseButtonListeners() { + // This can be null when closing the tab, but the event + // listeners should be removed in that case already. + if (!this.contentWindow || !this.contentWindow.windowRoot) { + return; + } + + this.contentWindow.windowRoot.removeEventListener("pointerdown", this, { + capture: true, + }); + this.contentWindow.windowRoot.removeEventListener("mousedown", this, { + capture: true, + }); + this.contentWindow.windowRoot.removeEventListener("mouseup", this, { + capture: true, + }); + this.contentWindow.windowRoot.removeEventListener("pointerup", this, { + capture: true, + }); + this.contentWindow.windowRoot.removeEventListener("click", this, { + capture: true, + }); + this.contentWindow.windowRoot.removeEventListener("mouseout", this, { + capture: true, + }); + this.contentWindow.windowRoot.removeEventListener("touchstart", this, { + capture: true, + }); + } + + /** + * One of the challenges of displaying this toggle is that many sites put + * things over top of <video> elements, like custom controls, or images, or + * all manner of things that might intercept mouseevents that would normally + * fire directly on the <video>. In order to properly detect when the mouse + * is over top of one of the <video> elements in this situation, we currently + * add a mousemove event handler to the entire document, and stash the most + * recent mousemove that fires. At periodic intervals, that stashed mousemove + * event is checked to see if it's hovering over one of our registered + * <video> elements. + * + * This sort of thing will not be necessary once bug 1539652 is fixed. + */ + beginTrackingMouseOverVideos() { + let state = this.docState; + if (!state.mousemoveDeferredTask) { + state.mousemoveDeferredTask = new lazy.DeferredTask(() => { + this.checkLastMouseMove(); + }, MOUSEMOVE_PROCESSING_DELAY_MS); + } + this.document.addEventListener("mousemove", this, { + mozSystemGroup: true, + capture: true, + }); + this.contentWindow.addEventListener("pageshow", this, { + mozSystemGroup: true, + }); + this.contentWindow.addEventListener("pagehide", this, { + mozSystemGroup: true, + }); + this.addMouseButtonListeners(); + state.isTrackingVideos = true; + } + + /** + * If we no longer have any interesting videos in the viewport, we deregister + * the mousemove and click listeners, and also remove any toggles that might + * be on the page still. + */ + stopTrackingMouseOverVideos() { + let state = this.docState; + // We initialize `mousemoveDeferredTask` in `beginTrackingMouseOverVideos`. + // If it doesn't exist, that can't have happened. Nothing else ever sets + // this value (though we arm/disarm in various places). So we don't need + // to do anything else here and can return early. + if (!state.mousemoveDeferredTask) { + return; + } + state.mousemoveDeferredTask.disarm(); + this.document.removeEventListener("mousemove", this, { + mozSystemGroup: true, + capture: true, + }); + if (this.contentWindow) { + this.contentWindow.removeEventListener("pageshow", this, { + mozSystemGroup: true, + }); + this.contentWindow.removeEventListener("pagehide", this, { + mozSystemGroup: true, + }); + } + this.removeMouseButtonListeners(); + let oldOverVideo = this.getWeakOverVideo(); + if (oldOverVideo) { + this.onMouseLeaveVideo(oldOverVideo); + } + state.isTrackingVideos = false; + } + + /** + * This pageshow event handler will get called if and when we complete a tab + * tear out or in. If we happened to be tracking videos before the tear + * occurred, we re-add the mouse event listeners so that they're attached to + * the right WindowRoot. + * + * @param {Event} event The pageshow event fired when completing a tab tear + * out or in. + */ + onPageShow(event) { + let state = this.docState; + if (state.isTrackingVideos) { + this.addMouseButtonListeners(); + } + } + + /** + * This pagehide event handler will get called if and when we start a tab + * tear out or in. If we happened to be tracking videos before the tear + * occurred, we remove the mouse event listeners. We'll re-add them when the + * pageshow event fires. + * + * @param {Event} event The pagehide event fired when starting a tab tear + * out or in. + */ + onPageHide(event) { + let state = this.docState; + if (state.isTrackingVideos) { + this.removeMouseButtonListeners(); + } + } + + /** + * If we're tracking <video> elements, this pointerdown event handler is run anytime + * a pointerdown occurs on the document. This function is responsible for checking + * if the user clicked on the Picture-in-Picture toggle. It does this by first + * checking if the video is visible beneath the point that was clicked. Then + * it tests whether or not the pointerdown occurred within the rectangle of the + * toggle. If so, the event's propagation is stopped, and Picture-in-Picture is + * triggered. + * + * @param {Event} event The mousemove event. + */ + onPointerDown(event) { + // The toggle ignores non-primary mouse clicks. + if (event.button != 0) { + return; + } + + let video = this.getWeakOverVideo(); + if (!video) { + return; + } + + let shadowRoot = video.openOrClosedShadowRoot; + if (!shadowRoot) { + return; + } + + let state = this.docState; + + let overVideo = (() => { + let { clientX, clientY } = event; + let winUtils = this.contentWindow.windowUtils; + // We use winUtils.nodesFromRect instead of document.elementsFromPoint, + // since document.elementsFromPoint always flushes layout. The 1's in that + // function call are for the size of the rect that we want, which is 1x1. + // + // We pass the aOnlyVisible boolean argument to check that the video isn't + // occluded by anything visible at the point of mousedown. If it is, we'll + // ignore the mousedown. + let elements = winUtils.nodesFromRect( + clientX, + clientY, + 1, + 1, + 1, + 1, + true, + false, + /* aOnlyVisible = */ true, + state.toggleVisibilityThreshold + ); + + for (let element of elements) { + if (element == video || element.containingShadowRoot == shadowRoot) { + return true; + } + } + + return false; + })(); + + if (!overVideo) { + return; + } + + let toggle = this.getToggleElement(shadowRoot); + if (this.isMouseOverToggle(toggle, event)) { + state.isClickingToggle = true; + state.clickedElement = Cu.getWeakReference(event.originalTarget); + event.stopImmediatePropagation(); + + this.startPictureInPicture(event, video, toggle); + } + } + + startPictureInPicture(event, video, toggle) { + Services.telemetry.keyedScalarAdd( + "pictureinpicture.opened_method", + "toggle", + 1 + ); + + let pipEvent = new this.contentWindow.CustomEvent( + "MozTogglePictureInPicture", + { + bubbles: true, + detail: { reason: "toggle" }, + } + ); + video.dispatchEvent(pipEvent); + + // Since we've initiated Picture-in-Picture, we can go ahead and + // hide the toggle now. + this.onMouseLeaveVideo(video); + } + + /** + * Called for mousedown, pointerup, mouseup and click events. If we + * detected that the user is clicking on the Picture-in-Picture toggle, + * these events are cancelled in the capture-phase before they reach + * content. The state for suppressing these events is cleared on the + * click event (unless the mouseup occurs on a different element from + * the mousedown, in which case, the state is cleared on mouseup). + * + * @param {Event} event A mousedown, pointerup, mouseup or click event. + */ + onMouseButtonEvent(event) { + // The toggle ignores non-primary mouse clicks. + if (event.button != 0) { + return; + } + + let state = this.docState; + if (state.isClickingToggle) { + event.stopImmediatePropagation(); + + // If this is a mouseup event, check to see if we have a record of what + // the original target was on pointerdown. If so, and if it doesn't match + // the mouseup original target, that means we won't get a click event, and + // we can clear the "clicking the toggle" state right away. + // + // Otherwise, we wait for the click event to do that. + let isMouseUpOnOtherElement = + event.type == "mouseup" && + (!state.clickedElement || + state.clickedElement.get() != event.originalTarget); + + if ( + isMouseUpOnOtherElement || + event.type == "click" || + // pointerup event still triggers after a touchstart event. We just need to detect + // the pointer type and determine if we got to this part of the code through a touch event. + event.pointerType == "touch" + ) { + // The click is complete, so now we reset the state so that + // we stop suppressing these events. + state.isClickingToggle = false; + state.clickedElement = null; + } + } + } + + /** + * Called on mouseout events to determine whether or not the mouse has + * exited the window. + * + * @param {Event} event The mouseout event. + */ + onMouseOut(event) { + if (!event.relatedTarget) { + // For mouseout events, if there's no relatedTarget (which normally + // maps to the element that the mouse entered into) then this means that + // we left the window. + let video = this.getWeakOverVideo(); + if (!video) { + return; + } + + this.onMouseLeaveVideo(video); + } + } + + /** + * Called for each mousemove event when we're tracking those events to + * determine if the cursor is hovering over a <video>. + * + * @param {Event} event The mousemove event. + */ + onMouseMove(event) { + let state = this.docState; + + if (state.hideToggleDeferredTask) { + state.hideToggleDeferredTask.disarm(); + state.hideToggleDeferredTask.arm(); + } + + state.lastMouseMoveEvent = event; + state.mousemoveDeferredTask.arm(); + } + + /** + * Called by the DeferredTask after MOUSEMOVE_PROCESSING_DELAY_MS + * milliseconds. Checked to see if that mousemove happens to be overtop of + * any interesting <video> elements that we want to display the toggle + * on. If so, puts the toggle on that video. + */ + checkLastMouseMove() { + let state = this.docState; + let event = state.lastMouseMoveEvent; + let { clientX, clientY } = event; + lazy.logConsole.debug("Visible videos count:", state.visibleVideosCount); + lazy.logConsole.debug("Tracking videos:", state.isTrackingVideos); + let winUtils = this.contentWindow.windowUtils; + // We use winUtils.nodesFromRect instead of document.elementsFromPoint, + // since document.elementsFromPoint always flushes layout. The 1's in that + // function call are for the size of the rect that we want, which is 1x1. + let elements = winUtils.nodesFromRect( + clientX, + clientY, + 1, + 1, + 1, + 1, + true, + false, + /* aOnlyVisible = */ true + ); + + for (let element of elements) { + lazy.logConsole.debug("Element id under cursor:", element.id); + lazy.logConsole.debug( + "Node name of an element under cursor:", + element.nodeName + ); + lazy.logConsole.debug( + "Supported <video> element:", + state.weakVisibleVideos.has(element) + ); + lazy.logConsole.debug( + "PiP window is open:", + element.isCloningElementVisually + ); + + // Check for hovering over the video controls or so too, not only + // directly over the video. + for (let el = element; el; el = el.containingShadowRoot?.host) { + if (state.weakVisibleVideos.has(el) && !el.isCloningElementVisually) { + lazy.logConsole.debug("Found supported element"); + this.onMouseOverVideo(el, event); + return; + } + } + } + + let oldOverVideo = this.getWeakOverVideo(); + if (oldOverVideo) { + this.onMouseLeaveVideo(oldOverVideo); + } + } + + /** + * Called once it has been determined that the mouse is overtop of a video + * that is in the viewport. + * + * @param {Element} video The video the mouse is over. + */ + onMouseOverVideo(video, event) { + let oldOverVideo = this.getWeakOverVideo(); + let shadowRoot = video.openOrClosedShadowRoot; + + if (shadowRoot.firstChild && video != oldOverVideo) { + if (video.getTransformToViewport().a == -1) { + shadowRoot.firstChild.setAttribute("flipped", true); + } else { + shadowRoot.firstChild.removeAttribute("flipped"); + } + } + + // It seems from automated testing that if it's still very early on in the + // lifecycle of a <video> element, it might not yet have a shadowRoot, + // in which case, we can bail out here early. + if (!shadowRoot) { + if (oldOverVideo) { + // We also clear the hover state on the old video we were hovering, + // if there was one. + this.onMouseLeaveVideo(oldOverVideo); + } + + return; + } + + let state = this.docState; + let toggle = this.getToggleElement(shadowRoot); + let controlsOverlay = shadowRoot.querySelector(".controlsOverlay"); + + if (state.checkedPolicyDocumentURI != this.document.documentURI) { + state.togglePolicy = lazy.TOGGLE_POLICIES.DEFAULT; + // We cache the matchers process-wide. We'll skip this while running tests to make that + // easier. + let siteOverrides = this.toggleTesting + ? PictureInPictureToggleChild.getSiteOverrides() + : lazy.gSiteOverrides; + + let visibilityThresholdPref = Services.prefs.getFloatPref( + TOGGLE_VISIBILITY_THRESHOLD_PREF, + "1.0" + ); + + if (!this.videoWrapper) { + this.videoWrapper = applyWrapper(this, video); + } + + // Do we have any toggle overrides? If so, try to apply them. + for (let [override, { policy, visibilityThreshold }] of siteOverrides) { + if ( + (policy || visibilityThreshold) && + override.matches(this.document.documentURI) + ) { + state.togglePolicy = this.videoWrapper?.shouldHideToggle(video) + ? lazy.TOGGLE_POLICIES.HIDDEN + : policy || lazy.TOGGLE_POLICIES.DEFAULT; + state.toggleVisibilityThreshold = + visibilityThreshold || visibilityThresholdPref; + break; + } + } + + state.checkedPolicyDocumentURI = this.document.documentURI; + } + + // The built-in <video> controls are along the bottom, which would overlap the + // toggle if the override is set to BOTTOM, so we ignore overrides that set + // a policy of BOTTOM for <video> elements with controls. + if ( + state.togglePolicy != lazy.TOGGLE_POLICIES.DEFAULT && + !(state.togglePolicy == lazy.TOGGLE_POLICIES.BOTTOM && video.controls) + ) { + toggle.setAttribute( + "policy", + lazy.TOGGLE_POLICY_STRINGS[state.togglePolicy] + ); + } else { + toggle.removeAttribute("policy"); + } + + // nimbusExperimentVariables will be defaultValues when the experiment is disabled + const nimbusExperimentVariables = + lazy.NimbusFeatures.pictureinpicture.getAllVariables({ + defaultValues: { + oldToggle: true, + title: null, + message: false, + showIconOnly: false, + displayDuration: TOGGLE_FIRST_TIME_DURATION_DAYS, + }, + }); + + /** + * If a Nimbus variable exists for the first-time PiP toggle design, + * override the old design via a classname "experiment". + */ + if (!nimbusExperimentVariables.oldToggle) { + let controlsContainer = shadowRoot.querySelector(".controlsContainer"); + let pipWrapper = shadowRoot.querySelector(".pip-wrapper"); + + controlsContainer.classList.add("experiment"); + pipWrapper.classList.add("experiment"); + } else { + let controlsContainer = shadowRoot.querySelector(".controlsContainer"); + let pipWrapper = shadowRoot.querySelector(".pip-wrapper"); + + controlsContainer.classList.remove("experiment"); + pipWrapper.classList.remove("experiment"); + } + + if (nimbusExperimentVariables.title) { + let pipExplainer = shadowRoot.querySelector(".pip-explainer"); + let pipLabel = shadowRoot.querySelector(".pip-label"); + + if (pipExplainer && nimbusExperimentVariables.message) { + pipExplainer.innerText = nimbusExperimentVariables.message; + } + pipLabel.innerText = nimbusExperimentVariables.title; + } else if (nimbusExperimentVariables.showIconOnly) { + // We only want to show the PiP icon in this experiment scenario + let pipExpanded = shadowRoot.querySelector(".pip-expanded"); + pipExpanded.style.display = "none"; + let pipSmall = shadowRoot.querySelector(".pip-small"); + pipSmall.style.opacity = "1"; + + let pipIcon = shadowRoot.querySelectorAll(".pip-icon")[1]; + pipIcon.style.display = "block"; + } + + controlsOverlay.removeAttribute("hidetoggle"); + + // The hideToggleDeferredTask we create here is for automatically hiding + // the toggle after a period of no mousemove activity for + // TOGGLE_HIDING_TIMEOUT_MS. If the mouse moves, then the DeferredTask + // timer is reset. + // + // We disable the toggle hiding timeout during testing to reduce + // non-determinism from timers when testing the toggle. + if (!state.hideToggleDeferredTask && !this.toggleTesting) { + state.hideToggleDeferredTask = new lazy.DeferredTask(() => { + controlsOverlay.setAttribute("hidetoggle", true); + }, TOGGLE_HIDING_TIMEOUT_MS); + } + + if (oldOverVideo) { + if (oldOverVideo == video) { + // If we're still hovering the old video, we might have entered or + // exited the toggle region. + this.checkHoverToggle(toggle, event); + return; + } + + // We had an old video that we were hovering, and we're not hovering + // it anymore. Let's leave it. + this.onMouseLeaveVideo(oldOverVideo); + } + + state.weakOverVideo = Cu.getWeakReference(video); + controlsOverlay.classList.add("hovering"); + + if ( + state.togglePolicy != lazy.TOGGLE_POLICIES.HIDDEN && + !toggle.hasAttribute("hidden") + ) { + Services.telemetry.scalarAdd("pictureinpicture.saw_toggle", 1); + const hasUsedPiP = Services.prefs.getBoolPref(TOGGLE_HAS_USED_PREF); + let args = { + firstTime: (!hasUsedPiP).toString(), + }; + Services.telemetry.recordEvent( + "pictureinpicture", + "saw_toggle", + "toggle", + null, + args + ); + // only record if this is the first time seeing the toggle + if (!hasUsedPiP) { + lazy.NimbusFeatures.pictureinpicture.recordExposureEvent(); + + const firstSeenSeconds = Services.prefs.getIntPref( + TOGGLE_FIRST_SEEN_PREF, + 0 + ); + + if (!firstSeenSeconds || firstSeenSeconds < 0) { + let firstTimePiPStartDate = Math.round(Date.now() / 1000); + this.sendAsyncMessage("PictureInPicture:SetFirstSeen", { + dateSeconds: firstTimePiPStartDate, + }); + } else if (nimbusExperimentVariables.displayDuration) { + this.changeToIconIfDurationEnd(firstSeenSeconds); + } + } + } + + // Now that we're hovering the video, we'll check to see if we're + // hovering the toggle too. + this.checkHoverToggle(toggle, event); + } + + /** + * Checks if a mouse event is happening over a toggle element. If it is, + * sets the hovering class on it. Otherwise, it clears the hovering + * class. + * + * @param {Element} toggle The Picture-in-Picture toggle to check. + * @param {MouseEvent} event A MouseEvent to test. + */ + checkHoverToggle(toggle, event) { + toggle.classList.toggle("hovering", this.isMouseOverToggle(toggle, event)); + } + + /** + * Called once it has been determined that the mouse is no longer overlapping + * a video that we'd previously called onMouseOverVideo with. + * + * @param {Element} video The video that the mouse left. + */ + onMouseLeaveVideo(video) { + let state = this.docState; + let shadowRoot = video.openOrClosedShadowRoot; + + if (shadowRoot) { + let controlsOverlay = shadowRoot.querySelector(".controlsOverlay"); + let toggle = this.getToggleElement(shadowRoot); + controlsOverlay.classList.remove("hovering"); + toggle.classList.remove("hovering"); + } + + state.weakOverVideo = null; + + if (!this.toggleTesting) { + state.hideToggleDeferredTask.disarm(); + state.mousemoveDeferredTask.disarm(); + } + + state.hideToggleDeferredTask = null; + } + + /** + * Given a reference to a Picture-in-Picture toggle element, determines + * if a MouseEvent event is occurring within its bounds. + * + * @param {Element} toggle The Picture-in-Picture toggle. + * @param {MouseEvent} event A MouseEvent to test. + * + * @return {Boolean} + */ + isMouseOverToggle(toggle, event) { + let toggleRect = + toggle.ownerGlobal.windowUtils.getBoundsWithoutFlushing(toggle); + + // The way the toggle is currently implemented with + // absolute positioning, the root toggle element bounds don't actually + // contain all of the toggle child element bounds. Until we find a way to + // sort that out, we workaround the issue by having each clickable child + // elements of the toggle have a clicklable class, and then compute the + // smallest rect that contains all of their bounding rects and use that + // as the hitbox. + toggleRect = lazy.Rect.fromRect(toggleRect); + let clickableChildren = toggle.querySelectorAll(".clickable"); + for (let child of clickableChildren) { + let childRect = lazy.Rect.fromRect( + child.ownerGlobal.windowUtils.getBoundsWithoutFlushing(child) + ); + toggleRect.expandToContain(childRect); + } + + // If the toggle has no dimensions, we're definitely not over it. + if (!toggleRect.width || !toggleRect.height) { + return false; + } + + let { clientX, clientY } = event; + + return ( + clientX >= toggleRect.left && + clientX <= toggleRect.right && + clientY >= toggleRect.top && + clientY <= toggleRect.bottom + ); + } + + /** + * Checks a contextmenu event to see if the mouse is currently over the + * Picture-in-Picture toggle. If so, sends a message to the parent process + * to open up the Picture-in-Picture toggle context menu. + * + * @param {MouseEvent} event A contextmenu event. + */ + checkContextMenu(event) { + let video = this.getWeakOverVideo(); + if (!video) { + return; + } + + let shadowRoot = video.openOrClosedShadowRoot; + if (!shadowRoot) { + return; + } + + let toggle = this.getToggleElement(shadowRoot); + if (this.isMouseOverToggle(toggle, event)) { + let devicePixelRatio = toggle.ownerGlobal.devicePixelRatio; + this.sendAsyncMessage("PictureInPicture:OpenToggleContextMenu", { + screenXDevPx: event.screenX * devicePixelRatio, + screenYDevPx: event.screenY * devicePixelRatio, + mozInputSource: event.mozInputSource, + }); + event.stopImmediatePropagation(); + event.preventDefault(); + } + } + + /** + * Returns the appropriate root element for the Picture-in-Picture toggle, + * depending on whether or not we're using the experimental toggle preference. + * + * @param {Element} shadowRoot The shadowRoot of the video element. + * @returns {Element} The toggle element. + */ + getToggleElement(shadowRoot) { + return shadowRoot.getElementById("pictureInPictureToggle"); + } + + /** + * This is a test-only function that returns true if a video is being tracked + * for mouseover events after having intersected the viewport. + */ + static isTracking(video) { + return gWeakIntersectingVideosForTesting.has(video); + } + + /** + * Gets any Picture-in-Picture site-specific overrides stored in the + * sharedData struct, and returns them as an Array of two-element Arrays, + * where the first element is a MatchPattern and the second element is an + * object of the form { policy, disabledKeyboardControls } (where each property + * may be missing or undefined). + * + * @returns {Array<Array<2>>} Array of 2-element Arrays where the first element + * is a MatchPattern and the second element is an object with optional policy + * and/or disabledKeyboardControls properties. + */ + static getSiteOverrides() { + let result = []; + let patterns = Services.cpmm.sharedData.get( + "PictureInPicture:SiteOverrides" + ); + for (let pattern in patterns) { + let matcher = new MatchPattern(pattern); + result.push([matcher, patterns[pattern]]); + } + return result; + } +} + +export class PictureInPictureChild extends JSWindowActorChild { + #subtitlesEnabled = false; + // A weak reference to this PiP window's video element + weakVideo = null; + + // A weak reference to this PiP window's content window + weakPlayerContent = null; + + // A reference to current WebVTT track currently displayed on the content window + _currentWebVTTTrack = null; + + observerFunction = null; + + observe(subject, topic, data) { + if (topic != "nsPref:changed") { + return; + } + + switch (data) { + case "media.videocontrols.picture-in-picture.display-text-tracks.enabled": { + const originatingVideo = this.getWeakVideo(); + let isTextTrackPrefEnabled = Services.prefs.getBoolPref( + "media.videocontrols.picture-in-picture.display-text-tracks.enabled" + ); + + // Enable or disable text track support + if (isTextTrackPrefEnabled) { + this.setupTextTracks(originatingVideo); + } else { + this.removeTextTracks(originatingVideo); + } + break; + } + } + } + + /** + * Creates a link element with a reference to the css stylesheet needed + * for text tracks responsive styling. + * @returns {Element} the link element containing text tracks stylesheet. + */ + createTextTracksStyleSheet() { + let headStyleElement = this.document.createElement("link"); + headStyleElement.setAttribute("rel", "stylesheet"); + headStyleElement.setAttribute( + "href", + "chrome://global/skin/pictureinpicture/texttracks.css" + ); + headStyleElement.setAttribute("type", "text/css"); + return headStyleElement; + } + + /** + * Sets up Picture-in-Picture to support displaying text tracks from WebVTT + * or if WebVTT isn't supported we will register the caption change mutation observer if + * the site wrapper exists. + * + * If the originating video supports WebVTT, try to read the + * active track and cues. Display any active cues on the pip window + * right away if applicable. + * + * @param originatingVideo {Element|null} + * The <video> being displayed in Picture-in-Picture mode, or null if that <video> no longer exists. + */ + setupTextTracks(originatingVideo) { + const isWebVTTSupported = !!originatingVideo.textTracks?.length; + + if (!isWebVTTSupported) { + this.setUpCaptionChangeListener(originatingVideo); + return; + } + + // Verify active track for originating video + this.setActiveTextTrack(originatingVideo.textTracks); + + if (!this._currentWebVTTTrack) { + // If WebVTT track is invalid, try using a video wrapper + this.setUpCaptionChangeListener(originatingVideo); + return; + } + + // Listen for changes in tracks and active cues + originatingVideo.textTracks.addEventListener("change", this); + this._currentWebVTTTrack.addEventListener("cuechange", this.onCueChange); + + const cues = this._currentWebVTTTrack.activeCues; + this.updateWebVTTTextTracksDisplay(cues); + } + + /** + * Toggle the visibility of the subtitles in the PiP window + */ + toggleTextTracks() { + let textTracks = this.document.getElementById("texttracks"); + textTracks.style.display = + textTracks.style.display === "none" ? "" : "none"; + } + + /** + * Removes existing text tracks on the Picture in Picture window. + * + * If the originating video supports WebVTT, clear references to active + * tracks and cues. No longer listen for any track or cue changes. + * + * @param originatingVideo {Element|null} + * The <video> being displayed in Picture-in-Picture mode, or null if that <video> no longer exists. + */ + removeTextTracks(originatingVideo) { + const isWebVTTSupported = !!originatingVideo.textTracks; + + if (!isWebVTTSupported) { + return; + } + + // No longer listen for changes to tracks and active cues + originatingVideo.textTracks.removeEventListener("change", this); + this._currentWebVTTTrack?.removeEventListener( + "cuechange", + this.onCueChange + ); + this._currentWebVTTTrack = null; + this.updateWebVTTTextTracksDisplay(null); + } + + /** + * Moves the text tracks container position above the pip window's video controls + * if their positions visually overlap. Since pip controls are within the parent + * process, we determine if pip video controls and text tracks visually overlap by + * comparing their relative positions with DOMRect. + * + * If overlap is found, set attribute "overlap-video-controls" to move text tracks + * and define a new relative bottom position according to pip window size and the + * position of video controls. + * @param {Object} data args needed to determine if text tracks must be moved + */ + moveTextTracks(data) { + const { + isFullscreen, + isVideoControlsShowing, + playerBottomControlsDOMRect, + isScrubberShowing, + } = data; + let textTracks = this.document.getElementById("texttracks"); + const originatingWindow = this.getWeakVideo().ownerGlobal; + const isReducedMotionEnabled = originatingWindow.matchMedia( + "(prefers-reduced-motion: reduce)" + ).matches; + const textTracksFontScale = this.document + .querySelector(":root") + .style.getPropertyValue("--font-scale"); + + if (isFullscreen || isReducedMotionEnabled) { + textTracks.removeAttribute("overlap-video-controls"); + return; + } + + if (isVideoControlsShowing) { + let playerVideoRect = textTracks.parentElement.getBoundingClientRect(); + let isOverlap = + playerVideoRect.bottom - textTracksFontScale * playerVideoRect.height > + playerBottomControlsDOMRect.top; + + if (isOverlap) { + const root = this.document.querySelector(":root"); + if (isScrubberShowing) { + root.style.setProperty("--player-controls-scrubber-height", "30px"); + } else { + root.style.setProperty("--player-controls-scrubber-height", "0px"); + } + textTracks.setAttribute("overlap-video-controls", true); + } else { + textTracks.removeAttribute("overlap-video-controls"); + } + } else { + textTracks.removeAttribute("overlap-video-controls"); + } + } + + /** + * Updates the text content for the container that holds and displays text tracks + * on the pip window. + * @param textTrackCues {TextTrackCueList|null} + * Collection of TextTrackCue objects containing text displayed, or null if there is no cue to display. + */ + updateWebVTTTextTracksDisplay(textTrackCues) { + let pipWindowTracksContainer = this.document.getElementById("texttracks"); + let playerVideo = this.document.getElementById("playervideo"); + let playerVideoWindow = playerVideo.ownerGlobal; + + // To prevent overlap with previous cues, clear all text from the pip window + pipWindowTracksContainer.replaceChildren(); + + if (!textTrackCues) { + return; + } + + if (!this.isSubtitlesEnabled) { + this.isSubtitlesEnabled = true; + this.sendAsyncMessage("PictureInPicture:EnableSubtitlesButton"); + } + + let allCuesArray = [...textTrackCues]; + // Re-order cues + this.getOrderedWebVTTCues(allCuesArray); + // Parse through WebVTT cue using vtt.js to ensure + // semantic markup like <b> and <i> tags are rendered. + allCuesArray.forEach(cue => { + let text = cue.text; + // Trim extra newlines and whitespaces + const re = /(\s*\n{2,}\s*)/g; + text = text.trim(); + text = text.replace(re, "\n"); + let cueTextNode = WebVTT.convertCueToDOMTree(playerVideoWindow, text); + let cueDiv = this.document.createElement("div"); + cueDiv.appendChild(cueTextNode); + pipWindowTracksContainer.appendChild(cueDiv); + }); + } + + /** + * Re-orders list of multiple active cues to ensure cues are rendered in the correct order. + * How cues are ordered depends on the VTTCue.line value of the cue. + * + * If line is string "auto", we want to reverse the order of cues. + * Cues are read from top to bottom in a vtt file, but are inserted into a video from bottom to top. + * Ensure this order is followed. + * + * If line is an integer or percentage, we want to order cues according to numeric value. + * Assumptions: + * 1) all active cues are numeric + * 2) all active cues are in range 0..100 + * 3) all actives cue are horizontal (no VTTCue.vertical) + * 4) all active cues with VTTCue.line integer have VTTCue.snapToLines = true + * 5) all active cues with VTTCue.line percentage have VTTCue.snapToLines = false + * + * vtt.jsm currently sets snapToLines to false if line is a percentage value, but + * cues are still ordered by line. In most cases, snapToLines is set to true by default, + * unless intentionally overridden. + * @param allCuesArray {Array<VTTCue>} array of active cues + */ + getOrderedWebVTTCues(allCuesArray) { + if (!allCuesArray || allCuesArray.length <= 1) { + return; + } + + let allCuesHaveNumericLines = allCuesArray.find(cue => cue.line !== "auto"); + + if (allCuesHaveNumericLines) { + allCuesArray.sort((cue1, cue2) => cue1.line - cue2.line); + } else if (allCuesArray.length >= 2) { + allCuesArray.reverse(); + } + } + + /** + * Returns a reference to the PiP's <video> element being displayed in Picture-in-Picture + * mode. + * + * @return {Element} The <video> being displayed in Picture-in-Picture mode, or null + * if that <video> no longer exists. + */ + getWeakVideo() { + if (this.weakVideo) { + // Bug 800957 - Accessing weakrefs at the wrong time can cause us to + // throw NS_ERROR_XPC_BAD_CONVERT_NATIVE + try { + return this.weakVideo.get(); + } catch (e) { + return null; + } + } + return null; + } + + /** + * Returns a reference to the inner window of the about:blank document that is + * cloning the originating <video> in the always-on-top player <xul:browser>. + * + * @return {Window} The inner window of the about:blank player <xul:browser>, or + * null if that window has been closed. + */ + getWeakPlayerContent() { + if (this.weakPlayerContent) { + // Bug 800957 - Accessing weakrefs at the wrong time can cause us to + // throw NS_ERROR_XPC_BAD_CONVERT_NATIVE + try { + return this.weakPlayerContent.get(); + } catch (e) { + return null; + } + } + return null; + } + + /** + * Returns true if the passed video happens to be the one that this + * content process is running in a Picture-in-Picture window. + * + * @param {Element} video The <video> element to check. + * + * @return {Boolean} + */ + inPictureInPicture(video) { + return this.getWeakVideo() === video; + } + + static videoIsPlaying(video) { + return !!(!video.paused && !video.ended && video.readyState > 2); + } + + static videoIsMuted(video) { + return this.videoWrapper.isMuted(video); + } + + handleEvent(event) { + switch (event.type) { + case "MozStopPictureInPicture": { + if (event.isTrusted && event.target === this.getWeakVideo()) { + const reason = event.detail?.reason || "videoElRemove"; + this.closePictureInPicture({ reason }); + } + break; + } + case "pagehide": { + // The originating video's content document has unloaded, + // so close Picture-in-Picture. + this.closePictureInPicture({ reason: "pagehide" }); + break; + } + case "MozDOMFullscreen:Request": { + this.closePictureInPicture({ reason: "fullscreen" }); + break; + } + case "play": { + this.sendAsyncMessage("PictureInPicture:Playing"); + break; + } + case "pause": { + this.sendAsyncMessage("PictureInPicture:Paused"); + break; + } + case "volumechange": { + let video = this.getWeakVideo(); + + // Just double-checking that we received the event for the right + // video element. + if (video !== event.target) { + lazy.logConsole.error( + "PictureInPictureChild received volumechange for " + + "the wrong video!" + ); + return; + } + + if (this.constructor.videoIsMuted(video)) { + this.sendAsyncMessage("PictureInPicture:Muting"); + } else { + this.sendAsyncMessage("PictureInPicture:Unmuting"); + } + break; + } + case "resize": { + let video = event.target; + if (this.inPictureInPicture(video)) { + this.sendAsyncMessage("PictureInPicture:Resize", { + videoHeight: video.videoHeight, + videoWidth: video.videoWidth, + }); + } + this.setupTextTracks(video); + break; + } + case "emptied": { + this.isSubtitlesEnabled = false; + if (this.emptiedTimeout) { + clearTimeout(this.emptiedTimeout); + this.emptiedTimeout = null; + } + let video = this.getWeakVideo(); + // We may want to keep the pip window open if the video + // is still in DOM. But if video src is no longer defined, + // close Picture-in-Picture. + this.emptiedTimeout = setTimeout(() => { + if (!video || !video.src) { + this.closePictureInPicture({ reason: "videoElEmptied" }); + } + }, EMPTIED_TIMEOUT_MS); + break; + } + case "change": { + // Clear currently stored track data (webvtt support) before reading + // a new track. + if (this._currentWebVTTTrack) { + this._currentWebVTTTrack.removeEventListener( + "cuechange", + this.onCueChange + ); + this._currentWebVTTTrack = null; + } + + const tracks = event.target; + this.setActiveTextTrack(tracks); + const isCurrentTrackAvailable = this._currentWebVTTTrack; + + // If tracks are disabled or invalid while change occurs, + // remove text tracks from the pip window and stop here. + if (!isCurrentTrackAvailable || !tracks.length) { + this.updateWebVTTTextTracksDisplay(null); + return; + } + + this._currentWebVTTTrack.addEventListener( + "cuechange", + this.onCueChange + ); + const cues = this._currentWebVTTTrack.activeCues; + this.updateWebVTTTextTracksDisplay(cues); + break; + } + case "timeupdate": + case "durationchange": { + let video = this.getWeakVideo(); + let currentTime = this.videoWrapper.getCurrentTime(video); + let duration = this.videoWrapper.getDuration(video); + let scrubberPosition = currentTime === 0 ? 0 : currentTime / duration; + let timestamp = this.videoWrapper.formatTimestamp( + currentTime, + duration + ); + // There's no point in sending this message unless we have a + // reasonable timestamp. + if (timestamp !== undefined && lazy.IMPROVED_CONTROLS_ENABLED_PREF) { + this.sendAsyncMessage( + "PictureInPicture:SetTimestampAndScrubberPosition", + { + scrubberPosition, + timestamp, + } + ); + } + break; + } + } + } + + /** + * Tells the parent to close a pre-existing Picture-in-Picture + * window. + * + * @return {Promise} + * + * @resolves {undefined} Once the pre-existing Picture-in-Picture + * window has unloaded. + */ + async closePictureInPicture({ reason }) { + let video = this.getWeakVideo(); + if (video) { + this.untrackOriginatingVideo(video); + } + this.sendAsyncMessage("PictureInPicture:Close", { + reason, + }); + + let playerContent = this.getWeakPlayerContent(); + if (playerContent) { + if (!playerContent.closed) { + await new Promise(resolve => { + playerContent.addEventListener("unload", resolve, { + once: true, + }); + }); + } + // Nothing should be holding a reference to the Picture-in-Picture + // player window content at this point, but just in case, we'll + // clear the weak reference directly so nothing else can get a hold + // of it from this angle. + this.weakPlayerContent = null; + } + } + + receiveMessage(message) { + switch (message.name) { + case "PictureInPicture:SetupPlayer": { + const { videoRef } = message.data; + this.setupPlayer(videoRef); + break; + } + case "PictureInPicture:Play": { + this.play(); + break; + } + case "PictureInPicture:Pause": { + if (message.data && message.data.reason == "pip-closed") { + let video = this.getWeakVideo(); + + // Currently in Firefox srcObjects are MediaStreams. However, by spec a srcObject + // can be either a MediaStream, MediaSource or Blob. In case of future changes + // we do not want to pause MediaStream srcObjects and we want to maintain current + // behavior for non-MediaStream srcObjects. + if (video && MediaStream.isInstance(video.srcObject)) { + break; + } + } + this.pause(); + break; + } + case "PictureInPicture:Mute": { + this.mute(); + break; + } + case "PictureInPicture:Unmute": { + this.unmute(); + break; + } + case "PictureInPicture:SeekForward": + case "PictureInPicture:SeekBackward": { + let selectedTime; + let video = this.getWeakVideo(); + let currentTime = this.videoWrapper.getCurrentTime(video); + if (message.name == "PictureInPicture:SeekBackward") { + selectedTime = currentTime - SEEK_TIME_SECS; + selectedTime = selectedTime >= 0 ? selectedTime : 0; + } else { + const maxtime = this.videoWrapper.getDuration(video); + selectedTime = currentTime + SEEK_TIME_SECS; + selectedTime = selectedTime <= maxtime ? selectedTime : maxtime; + } + this.videoWrapper.setCurrentTime(video, selectedTime); + break; + } + case "PictureInPicture:KeyDown": { + this.keyDown(message.data); + break; + } + case "PictureInPicture:EnterFullscreen": + case "PictureInPicture:ExitFullscreen": { + let textTracks = this.document.getElementById("texttracks"); + if (textTracks) { + this.moveTextTracks(message.data); + } + break; + } + case "PictureInPicture:ShowVideoControls": + case "PictureInPicture:HideVideoControls": { + let textTracks = this.document.getElementById("texttracks"); + if (textTracks) { + this.moveTextTracks(message.data); + } + break; + } + case "PictureInPicture:ToggleTextTracks": { + this.toggleTextTracks(); + break; + } + case "PictureInPicture:ChangeFontSizeTextTracks": { + this.setTextTrackFontSize(); + break; + } + case "PictureInPicture:SetVideoTime": { + const { scrubberPosition, wasPlaying } = message.data; + this.setVideoTime(scrubberPosition, wasPlaying); + break; + } + } + } + + /** + * Set the current time of the video based of the position of the scrubber + * @param {Number} scrubberPosition A number between 0 and 1 representing the position of the scrubber + */ + setVideoTime(scrubberPosition, wasPlaying) { + const video = this.getWeakVideo(); + let duration = this.videoWrapper.getDuration(video); + let currentTime = scrubberPosition * duration; + this.videoWrapper.setCurrentTime(video, currentTime, wasPlaying); + } + + /** + * @returns {boolean} true if a textTrack with mode "hidden" should be treated as "showing" + */ + shouldShowHiddenTextTracks() { + const video = this.getWeakVideo(); + if (!video) { + return false; + } + const { documentURI } = video.ownerDocument; + if (!documentURI) { + return false; + } + for (let [override, { showHiddenTextTracks }] of lazy.gSiteOverrides) { + if (override.matches(documentURI) && showHiddenTextTracks) { + return true; + } + } + return false; + } + + /** + * Updates this._currentWebVTTTrack if an active track is found + * for the originating video. + * @param {TextTrackList} textTrackList list of text tracks + */ + setActiveTextTrack(textTrackList) { + this._currentWebVTTTrack = null; + + for (let i = 0; i < textTrackList.length; i++) { + let track = textTrackList[i]; + let isCCText = track.kind === "subtitles" || track.kind === "captions"; + let shouldShowTrack = + track.mode === "showing" || + (track.mode === "hidden" && this.shouldShowHiddenTextTracks()); + if (isCCText && shouldShowTrack && track.cues) { + this._currentWebVTTTrack = track; + break; + } + } + } + + /** + * Set the font size on the PiP window using the current font size value from + * the "media.videocontrols.picture-in-picture.display-text-tracks.size" pref + */ + setTextTrackFontSize() { + const fontSize = Services.prefs.getStringPref( + TEXT_TRACK_FONT_SIZE, + "medium" + ); + const root = this.document.querySelector(":root"); + if (fontSize === "small") { + root.style.setProperty("--font-scale", "0.03"); + } else if (fontSize === "large") { + root.style.setProperty("--font-scale", "0.09"); + } else { + root.style.setProperty("--font-scale", "0.06"); + } + } + + /** + * Keeps an eye on the originating video's document. If it ever + * goes away, this will cause the Picture-in-Picture window for any + * of its content to go away as well. + */ + trackOriginatingVideo(originatingVideo) { + this.observerFunction = (subject, topic, data) => { + this.observe(subject, topic, data); + }; + Services.prefs.addObserver( + "media.videocontrols.picture-in-picture.display-text-tracks.enabled", + this.observerFunction + ); + + let originatingWindow = originatingVideo.ownerGlobal; + if (originatingWindow) { + originatingWindow.addEventListener("pagehide", this); + originatingVideo.addEventListener("play", this); + originatingVideo.addEventListener("pause", this); + originatingVideo.addEventListener("volumechange", this); + originatingVideo.addEventListener("resize", this); + originatingVideo.addEventListener("emptied", this); + originatingVideo.addEventListener("timeupdate", this); + + if (lazy.DISPLAY_TEXT_TRACKS_PREF) { + this.setupTextTracks(originatingVideo); + } + + let chromeEventHandler = originatingWindow.docShell.chromeEventHandler; + chromeEventHandler.addEventListener( + "MozDOMFullscreen:Request", + this, + true + ); + chromeEventHandler.addEventListener( + "MozStopPictureInPicture", + this, + true + ); + } + } + + setUpCaptionChangeListener(originatingVideo) { + if (this.videoWrapper) { + this.videoWrapper.setCaptionContainerObserver(originatingVideo, this); + } + } + + /** + * Stops tracking the originating video's document. This should + * happen once the Picture-in-Picture window goes away (or is about + * to go away), and we no longer care about hearing when the originating + * window's document unloads. + */ + untrackOriginatingVideo(originatingVideo) { + Services.prefs.removeObserver( + "media.videocontrols.picture-in-picture.display-text-tracks.enabled", + this.observerFunction + ); + + let originatingWindow = originatingVideo.ownerGlobal; + if (originatingWindow) { + originatingWindow.removeEventListener("pagehide", this); + originatingVideo.removeEventListener("play", this); + originatingVideo.removeEventListener("pause", this); + originatingVideo.removeEventListener("volumechange", this); + originatingVideo.removeEventListener("resize", this); + originatingVideo.removeEventListener("emptied", this); + originatingVideo.removeEventListener("timeupdate", this); + + if (lazy.DISPLAY_TEXT_TRACKS_PREF) { + this.removeTextTracks(originatingVideo); + } + + let chromeEventHandler = originatingWindow.docShell.chromeEventHandler; + chromeEventHandler.removeEventListener( + "MozDOMFullscreen:Request", + this, + true + ); + chromeEventHandler.removeEventListener( + "MozStopPictureInPicture", + this, + true + ); + } + } + + /** + * Runs in an instance of PictureInPictureChild for the + * player window's content, and not the originating video + * content. Sets up the player so that it clones the originating + * video. If anything goes wrong during set up, a message is + * sent to the parent to close the Picture-in-Picture window. + * + * @param videoRef {ContentDOMReference} + * A reference to the video element that a Picture-in-Picture window + * is being created for + * @return {Promise} + * @resolves {undefined} Once the player window has been set up + * properly, or a pre-existing Picture-in-Picture window has gone + * away due to an unexpected error. + */ + async setupPlayer(videoRef) { + const video = await lazy.ContentDOMReference.resolve(videoRef); + + this.weakVideo = Cu.getWeakReference(video); + let originatingVideo = this.getWeakVideo(); + if (!originatingVideo) { + // If the video element has gone away before we've had a chance to set up + // Picture-in-Picture for it, tell the parent to close the Picture-in-Picture + // window. + await this.closePictureInPicture({ reason: "setupFailure" }); + return; + } + + this.videoWrapper = applyWrapper(this, originatingVideo); + + let loadPromise = new Promise(resolve => { + this.contentWindow.addEventListener("load", resolve, { + once: true, + mozSystemGroup: true, + capture: true, + }); + }); + this.contentWindow.location.reload(); + await loadPromise; + + // We're committed to adding the video to this window now. Ensure we track + // the content window before we do so, so that the toggle actor can + // distinguish this new video we're creating from web-controlled ones. + this.weakPlayerContent = Cu.getWeakReference(this.contentWindow); + gPlayerContents.add(this.contentWindow); + + let doc = this.document; + let playerVideo = doc.createElement("video"); + playerVideo.id = "playervideo"; + let textTracks = doc.createElement("div"); + + doc.body.style.overflow = "hidden"; + doc.body.style.margin = "0"; + + // Force the player video to assume maximum height and width of the + // containing window + playerVideo.style.height = "100vh"; + playerVideo.style.width = "100vw"; + playerVideo.style.backgroundColor = "#000"; + + // Load text tracks container in the content process so that + // we can load text tracks without having to constantly + // access the parent process. + textTracks.id = "texttracks"; + // When starting pip, player controls are expected to appear. + textTracks.setAttribute("overlap-video-controls", true); + doc.body.appendChild(playerVideo); + doc.body.appendChild(textTracks); + // Load text tracks stylesheet + let textTracksStyleSheet = this.createTextTracksStyleSheet(); + doc.head.appendChild(textTracksStyleSheet); + + this.setTextTrackFontSize(); + + originatingVideo.cloneElementVisually(playerVideo); + + let shadowRoot = originatingVideo.openOrClosedShadowRoot; + if (originatingVideo.getTransformToViewport().a == -1) { + shadowRoot.firstChild.setAttribute("flipped", true); + playerVideo.style.transform = "scaleX(-1)"; + } + + this.onCueChange = this.onCueChange.bind(this); + this.trackOriginatingVideo(originatingVideo); + + // A request to open PIP implies that the user intends to be interacting + // with the page, even if they open PIP by some means outside of the page + // itself (e.g., the keyboard shortcut or the page action button). So we + // manually record that the document has been activated via user gesture + // to make sure the video can be played regardless of autoplay permissions. + originatingVideo.ownerDocument.notifyUserGestureActivation(); + + this.contentWindow.addEventListener( + "unload", + () => { + let video = this.getWeakVideo(); + if (video) { + this.untrackOriginatingVideo(video); + video.stopCloningElementVisually(); + } + this.weakVideo = null; + }, + { once: true } + ); + } + + play() { + let video = this.getWeakVideo(); + if (video && this.videoWrapper) { + this.videoWrapper.play(video); + } + } + + pause() { + let video = this.getWeakVideo(); + if (video && this.videoWrapper) { + this.videoWrapper.pause(video); + } + } + + mute() { + let video = this.getWeakVideo(); + if (video && this.videoWrapper) { + this.videoWrapper.setMuted(video, true); + } + } + + unmute() { + let video = this.getWeakVideo(); + if (video && this.videoWrapper) { + this.videoWrapper.setMuted(video, false); + } + } + + onCueChange(e) { + if (!lazy.DISPLAY_TEXT_TRACKS_PREF) { + this.updateWebVTTTextTracksDisplay(null); + } else { + const cues = this._currentWebVTTTrack.activeCues; + this.updateWebVTTTextTracksDisplay(cues); + } + } + + /** + * This checks if a given keybinding has been disabled for the specific site + * currently being viewed. + */ + isKeyDisabled(key) { + const video = this.getWeakVideo(); + if (!video) { + return false; + } + const { documentURI } = video.ownerDocument; + if (!documentURI) { + return true; + } + for (let [override, { disabledKeyboardControls }] of lazy.gSiteOverrides) { + if ( + disabledKeyboardControls !== undefined && + override.matches(documentURI) + ) { + if (disabledKeyboardControls === lazy.KEYBOARD_CONTROLS.ALL) { + return true; + } + return !!(disabledKeyboardControls & key); + } + } + return false; + } + + /** + * This reuses the keyHandler logic in the VideoControlsWidget + * https://searchfox.org/mozilla-central/rev/cfd1cc461f1efe0d66c2fdc17c024a203d5a2fd8/toolkit/content/widgets/videocontrols.js#1687-1810. + * There are future plans to eventually combine the two implementations. + */ + /* eslint-disable complexity */ + keyDown({ altKey, shiftKey, metaKey, ctrlKey, keyCode }) { + let video = this.getWeakVideo(); + if (!video) { + return; + } + + var keystroke = ""; + if (altKey) { + keystroke += "alt-"; + } + if (shiftKey) { + keystroke += "shift-"; + } + if (this.contentWindow.navigator.platform.startsWith("Mac")) { + if (metaKey) { + keystroke += "accel-"; + } + if (ctrlKey) { + keystroke += "control-"; + } + } else { + if (metaKey) { + keystroke += "meta-"; + } + if (ctrlKey) { + keystroke += "accel-"; + } + } + + switch (keyCode) { + case this.contentWindow.KeyEvent.DOM_VK_UP: + keystroke += "upArrow"; + break; + case this.contentWindow.KeyEvent.DOM_VK_DOWN: + keystroke += "downArrow"; + break; + case this.contentWindow.KeyEvent.DOM_VK_LEFT: + keystroke += "leftArrow"; + break; + case this.contentWindow.KeyEvent.DOM_VK_RIGHT: + keystroke += "rightArrow"; + break; + case this.contentWindow.KeyEvent.DOM_VK_HOME: + keystroke += "home"; + break; + case this.contentWindow.KeyEvent.DOM_VK_END: + keystroke += "end"; + break; + case this.contentWindow.KeyEvent.DOM_VK_SPACE: + keystroke += "space"; + break; + case this.contentWindow.KeyEvent.DOM_VK_W: + keystroke += "w"; + break; + } + + const isVideoStreaming = this.videoWrapper.isLive(video); + var oldval, newval; + + try { + switch (keystroke) { + case "space" /* Toggle Play / Pause */: + if (this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.PLAY_PAUSE)) { + return; + } + + if ( + this.videoWrapper.getPaused(video) || + this.videoWrapper.getEnded(video) + ) { + this.videoWrapper.play(video); + } else { + this.videoWrapper.pause(video); + } + + break; + case "accel-w" /* Close video */: + if (this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.CLOSE)) { + return; + } + this.pause(); + this.closePictureInPicture({ reason: "closePlayerShortcut" }); + break; + case "downArrow" /* Volume decrease */: + if (this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.VOLUME)) { + return; + } + oldval = this.videoWrapper.getVolume(video); + this.videoWrapper.setVolume(video, oldval < 0.1 ? 0 : oldval - 0.1); + this.videoWrapper.setMuted(video, false); + break; + case "upArrow" /* Volume increase */: + if (this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.VOLUME)) { + return; + } + oldval = this.videoWrapper.getVolume(video); + this.videoWrapper.setVolume(video, oldval > 0.9 ? 1 : oldval + 0.1); + this.videoWrapper.setMuted(video, false); + break; + case "accel-downArrow" /* Mute */: + if (this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.MUTE_UNMUTE)) { + return; + } + this.videoWrapper.setMuted(video, true); + break; + case "accel-upArrow" /* Unmute */: + if (this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.MUTE_UNMUTE)) { + return; + } + this.videoWrapper.setMuted(video, false); + break; + case "leftArrow": /* Seek back 5 seconds */ + case "accel-leftArrow" /* Seek back 10% */: + if ( + this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.SEEK) || + (isVideoStreaming && + this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.LIVE_SEEK)) + ) { + return; + } + + oldval = this.videoWrapper.getCurrentTime(video); + if (keystroke == "leftArrow") { + newval = oldval - SEEK_TIME_SECS; + } else { + newval = oldval - this.videoWrapper.getDuration(video) / 10; + } + this.videoWrapper.setCurrentTime(video, newval >= 0 ? newval : 0); + break; + case "rightArrow": /* Seek forward 5 seconds */ + case "accel-rightArrow" /* Seek forward 10% */: + if ( + this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.SEEK) || + (isVideoStreaming && + this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.LIVE_SEEK)) + ) { + return; + } + + oldval = this.videoWrapper.getCurrentTime(video); + var maxtime = this.videoWrapper.getDuration(video); + if (keystroke == "rightArrow") { + newval = oldval + SEEK_TIME_SECS; + } else { + newval = oldval + maxtime / 10; + } + let selectedTime = newval <= maxtime ? newval : maxtime; + this.videoWrapper.setCurrentTime(video, selectedTime); + break; + case "home" /* Seek to beginning */: + if (this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.SEEK)) { + return; + } + if (!isVideoStreaming) { + this.videoWrapper.setCurrentTime(video, 0); + } + break; + case "end" /* Seek to end */: + if (this.isKeyDisabled(lazy.KEYBOARD_CONTROLS.SEEK)) { + return; + } + + let duration = this.videoWrapper.getDuration(video); + if ( + !isVideoStreaming && + this.videoWrapper.getCurrentTime(video) != duration + ) { + this.videoWrapper.setCurrentTime(video, duration); + } + break; + default: + } + } catch (e) { + /* ignore any exception from setting video.currentTime */ + } + } + + get isSubtitlesEnabled() { + return this.#subtitlesEnabled; + } + + set isSubtitlesEnabled(val) { + if (val) { + Services.telemetry.recordEvent( + "pictureinpicture", + "subtitles_shown", + "subtitles", + null, + { + webVTTSubtitles: (!!this.getWeakVideo().textTracks + ?.length).toString(), + } + ); + } else { + this.sendAsyncMessage("PictureInPicture:DisableSubtitlesButton"); + } + this.#subtitlesEnabled = val; + } +} + +/** + * The PictureInPictureChildVideoWrapper class handles providing a path to a script that + * defines a "site wrapper" for the original <video> (or other controls API provided + * by the site) to command it. + * + * This "site wrapper" provided to PictureInPictureChildVideoWrapper is a script file that + * defines a class called `PictureInPictureVideoWrapper` and exports it. These scripts can + * be found under "browser/extensions/pictureinpicture/video-wrappers" as part of the + * Picture-In-Picture addon. + * + * Site wrappers need to adhere to a specific interface to work properly with + * PictureInPictureChildVideoWrapper: + * + * - The "site wrapper" script must export a class called "PictureInPictureVideoWrapper" + * - Method names on a site wrapper class should match its caller's name + * (i.e: PictureInPictureChildVideoWrapper.play will only call `play` on a site-wrapper, if available) + */ +class PictureInPictureChildVideoWrapper { + #sandbox; + #siteWrapper; + #PictureInPictureChild; + + /** + * Create a wrapper for the original <video> + * + * @param {String|null} videoWrapperScriptPath + * Path to a wrapper script from the Picture-in-Picture addon. If a wrapper isn't + * provided to the class, then we fallback on a default implementation for + * commanding the original <video>. + * @param {HTMLVideoElement} video + * The original <video> we want to create a wrapper class for. + * @param {Object} pipChild + * Reference to PictureInPictureChild class calling this function. + */ + constructor(videoWrapperScriptPath, video, pipChild) { + this.#sandbox = videoWrapperScriptPath + ? this.#createSandbox(videoWrapperScriptPath, video) + : null; + this.#PictureInPictureChild = pipChild; + } + + /** + * Handles calling methods defined on the site wrapper class to perform video + * controls operations on the source video. If the method doesn't exist, + * or if an error is thrown while calling it, use a fallback implementation. + * + * @param {String} methodInfo.name + * The method name to call. + * @param {Array} methodInfo.args + * Arguments to pass to the site wrapper method being called. + * @param {Function} methodInfo.fallback + * A fallback function that's invoked when a method doesn't exist on the site + * wrapper class or an error is thrown while calling a method + * @param {Function} methodInfo.validateReturnVal + * Validates whether or not the return value of the wrapper method is correct. + * If this isn't provided or if it evaluates false for a return value, then + * return null. + * + * @returns The expected output of the wrapper function. + */ + #callWrapperMethod({ name, args = [], fallback = () => {}, validateRetVal }) { + try { + const wrappedMethod = this.#siteWrapper?.[name]; + if (typeof wrappedMethod === "function") { + let retVal = wrappedMethod.call(this.#siteWrapper, ...args); + + if (!validateRetVal) { + lazy.logConsole.error( + `No return value validator was provided for method ${name}(). Returning null.` + ); + return null; + } + + if (!validateRetVal(retVal)) { + lazy.logConsole.error( + `Calling method ${name}() returned an unexpected value: ${retVal}. Returning null.` + ); + return null; + } + + return retVal; + } + } catch (e) { + lazy.logConsole.error( + `There was an error while calling ${name}(): `, + e.message + ); + } + + return fallback(); + } + + /** + * Creates a sandbox with Xray vision to execute content code in an unprivileged + * context. This way, privileged code (PictureInPictureChild) can call into the + * sandbox to perform video controls operations on the originating video + * (content code) and still be protected from direct access by it. + * + * @param {String} videoWrapperScriptPath + * Path to a wrapper script from the Picture-in-Picture addon. + * @param {HTMLVideoElement} video + * The source video element whose window to create a sandbox for. + */ + #createSandbox(videoWrapperScriptPath, video) { + const addonPolicy = WebExtensionPolicy.getByID( + "pictureinpicture@mozilla.org" + ); + let wrapperScriptUrl = addonPolicy.getURL(videoWrapperScriptPath); + let originatingWin = video.ownerGlobal; + let originatingDoc = video.ownerDocument; + + let sandbox = Cu.Sandbox([originatingDoc.nodePrincipal], { + sandboxName: "Picture-in-Picture video wrapper sandbox", + sandboxPrototype: originatingWin, + sameZoneAs: originatingWin, + wantXrays: false, + }); + + try { + Services.scriptloader.loadSubScript(wrapperScriptUrl, sandbox); + } catch (e) { + Cu.nukeSandbox(sandbox); + lazy.logConsole.error( + "Error loading wrapper script for Picture-in-Picture", + e + ); + return null; + } + + // The prototype of the wrapper class instantiated from the sandbox with Xray + // vision is `Object` and not actually `PictureInPictureVideoWrapper`. But we + // need to be able to access methods defined on this class to perform site-specific + // video control operations otherwise we fallback to a default implementation. + // Because of this, we need to "waive Xray vision" by adding `.wrappedObject` to the + // end. + this.#siteWrapper = new sandbox.PictureInPictureVideoWrapper( + video + ).wrappedJSObject; + + return sandbox; + } + + #isBoolean(val) { + return typeof val === "boolean"; + } + + #isNumber(val) { + return typeof val === "number"; + } + + /** + * Destroys the sandbox for the site wrapper class + */ + destroy() { + if (this.#sandbox) { + Cu.nukeSandbox(this.#sandbox); + } + } + + /** + * Function to display the captions on the PiP window + * @param text The captions to be shown on the PiP window + */ + updatePiPTextTracks(text) { + if (!this.#PictureInPictureChild.isSubtitlesEnabled && text) { + this.#PictureInPictureChild.isSubtitlesEnabled = true; + this.#PictureInPictureChild.sendAsyncMessage( + "PictureInPicture:EnableSubtitlesButton" + ); + } + let pipWindowTracksContainer = + this.#PictureInPictureChild.document.getElementById("texttracks"); + pipWindowTracksContainer.textContent = text; + } + + /* Video methods to be used for video controls from the PiP window. */ + + /** + * OVERRIDABLE - calls the play() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to handle video + * behaviour when a video is played. + * @param {HTMLVideoElement} video + * The originating video source element + */ + play(video) { + return this.#callWrapperMethod({ + name: "play", + args: [video], + fallback: () => video.play(), + validateRetVal: retVal => retVal == null, + }); + } + + /** + * OVERRIDABLE - calls the pause() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to handle video + * behaviour when a video is paused. + * @param {HTMLVideoElement} video + * The originating video source element + */ + pause(video) { + return this.#callWrapperMethod({ + name: "pause", + args: [video], + fallback: () => video.pause(), + validateRetVal: retVal => retVal == null, + }); + } + + /** + * OVERRIDABLE - calls the getPaused() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to determine if + * a video is paused or not. + * @param {HTMLVideoElement} video + * The originating video source element + * @returns {Boolean} Boolean value true if paused, or false if video is still playing + */ + getPaused(video) { + return this.#callWrapperMethod({ + name: "getPaused", + args: [video], + fallback: () => video.paused, + validateRetVal: retVal => this.#isBoolean(retVal), + }); + } + + /** + * OVERRIDABLE - calls the getEnded() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to determine if + * video playback or streaming has stopped. + * @param {HTMLVideoElement} video + * The originating video source element + * @returns {Boolean} Boolean value true if the video has ended, or false if still playing + */ + getEnded(video) { + return this.#callWrapperMethod({ + name: "getEnded", + args: [video], + fallback: () => video.ended, + validateRetVal: retVal => this.#isBoolean(retVal), + }); + } + + /** + * OVERRIDABLE - calls the getDuration() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to get the current + * duration of a video in seconds. + * @param {HTMLVideoElement} video + * The originating video source element + * @returns {Number} Duration of the video in seconds + */ + getDuration(video) { + return this.#callWrapperMethod({ + name: "getDuration", + args: [video], + fallback: () => video.duration, + validateRetVal: retVal => this.#isNumber(retVal), + }); + } + + /** + * OVERRIDABLE - calls the getCurrentTime() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to get the current + * time of a video in seconds. + * @param {HTMLVideoElement} video + * The originating video source element + * @returns {Number} Current time of the video in seconds + */ + getCurrentTime(video) { + return this.#callWrapperMethod({ + name: "getCurrentTime", + args: [video], + fallback: () => video.currentTime, + validateRetVal: retVal => this.#isNumber(retVal), + }); + } + + /** + * OVERRIDABLE - calls the setCurrentTime() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to set the current + * time of a video. + * @param {HTMLVideoElement} video + * The originating video source element + * @param {Number} position + * The current playback time of the video + * @param {Boolean} wasPlaying + * True if the video was playing before seeking else false + */ + setCurrentTime(video, position, wasPlaying) { + return this.#callWrapperMethod({ + name: "setCurrentTime", + args: [video, position, wasPlaying], + fallback: () => { + video.currentTime = position; + }, + validateRetVal: retVal => retVal == null, + }); + } + + /** + * Return hours, minutes, and seconds from seconds + * @param {Number} aSeconds + * The time in seconds + * @returns {String} Timestamp string + **/ + timeFromSeconds(aSeconds) { + aSeconds = isNaN(aSeconds) ? 0 : Math.round(aSeconds); + let seconds = Math.floor(aSeconds % 60), + minutes = Math.floor((aSeconds / 60) % 60), + hours = Math.floor(aSeconds / 3600); + seconds = seconds < 10 ? "0" + seconds : seconds; + minutes = hours > 0 && minutes < 10 ? "0" + minutes : minutes; + return aSeconds < 3600 + ? `${minutes}:${seconds}` + : `${hours}:${minutes}:${seconds}`; + } + + /** + * Format a timestamp from current time and total duration, + * output as a string in the form '0:00 / 0:00' + * @param {Number} aCurrentTime + * The current time in seconds + * @param {Number} aDuration + * The total duration in seconds + * @returns {String} Formatted timestamp + **/ + formatTimestamp(aCurrentTime, aDuration) { + // We can't format numbers that can't be represented as decimal digits. + if (!Number.isFinite(aCurrentTime) || !Number.isFinite(aDuration)) { + return undefined; + } + + return `${this.timeFromSeconds(aCurrentTime)} / ${this.timeFromSeconds( + aDuration + )}`; + } + + /** + * OVERRIDABLE - calls the getVolume() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to get the volume + * value of a video. + * @param {HTMLVideoElement} video + * The originating video source element + * @returns {Number} Volume of the video between 0 (muted) and 1 (loudest) + */ + getVolume(video) { + return this.#callWrapperMethod({ + name: "getVolume", + args: [video], + fallback: () => video.volume, + validateRetVal: retVal => this.#isNumber(retVal), + }); + } + + /** + * OVERRIDABLE - calls the setVolume() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to set the volume + * value of a video. + * @param {HTMLVideoElement} video + * The originating video source element + * @param {Number} volume + * Value between 0 (muted) and 1 (loudest) + */ + setVolume(video, volume) { + return this.#callWrapperMethod({ + name: "setVolume", + args: [video, volume], + fallback: () => { + video.volume = volume; + }, + validateRetVal: retVal => retVal == null, + }); + } + + /** + * OVERRIDABLE - calls the isMuted() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to get the mute + * state a video. + * @param {HTMLVideoElement} video + * The originating video source element + * @param {Boolean} shouldMute + * Boolean value true to mute the video, or false to unmute the video + */ + isMuted(video) { + return this.#callWrapperMethod({ + name: "isMuted", + args: [video], + fallback: () => video.muted, + validateRetVal: retVal => this.#isBoolean(retVal), + }); + } + + /** + * OVERRIDABLE - calls the setMuted() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to mute or unmute + * a video. + * @param {HTMLVideoElement} video + * The originating video source element + * @param {Boolean} shouldMute + * Boolean value true to mute the video, or false to unmute the video + */ + setMuted(video, shouldMute) { + return this.#callWrapperMethod({ + name: "setMuted", + args: [video, shouldMute], + fallback: () => { + video.muted = shouldMute; + }, + validateRetVal: retVal => retVal == null, + }); + } + + /** + * OVERRIDABLE - calls the setCaptionContainerObserver() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to listen for any cue changes in a + * video's caption container and execute a callback function responsible for updating the pip window's text tracks container whenever + * a cue change is triggered {@see updatePiPTextTracks()}. + * @param {HTMLVideoElement} video + * The originating video source element + * @param {Function} callback + * The callback function to be executed when cue changes are detected + */ + setCaptionContainerObserver(video, callback) { + return this.#callWrapperMethod({ + name: "setCaptionContainerObserver", + args: [ + video, + text => { + this.updatePiPTextTracks(text); + }, + ], + fallback: () => {}, + validateRetVal: retVal => retVal == null, + }); + } + + /** + * OVERRIDABLE - calls the shouldHideToggle() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to determine if the pip toggle + * for a video should be hidden by the site wrapper. + * @param {HTMLVideoElement} video + * The originating video source element + * @returns {Boolean} Boolean value true if the pip toggle should be hidden by the site wrapper, or false if it should not + */ + shouldHideToggle(video) { + return this.#callWrapperMethod({ + name: "shouldHideToggle", + args: [video], + fallback: () => false, + validateRetVal: retVal => this.#isBoolean(retVal), + }); + } + + /** + * OVERRIDABLE - calls the isLive() method defined in the site wrapper script. Runs a fallback implementation + * if the method does not exist or if an error is thrown while calling it. This method is meant to get if the + * video is a live stream. + * @param {HTMLVideoElement} video + * The originating video source element + */ + isLive(video) { + return this.#callWrapperMethod({ + name: "isLive", + args: [video], + fallback: () => video.duration === Infinity, + validateRetVal: retVal => this.#isBoolean(retVal), + }); + } +} diff --git a/toolkit/actors/PopupBlockingChild.sys.mjs b/toolkit/actors/PopupBlockingChild.sys.mjs new file mode 100644 index 0000000000..053f9683c5 --- /dev/null +++ b/toolkit/actors/PopupBlockingChild.sys.mjs @@ -0,0 +1,147 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +/* eslint no-unused-vars: ["error", {args: "none"}] */ + +// The maximum number of popup information we'll send to the parent. +const MAX_SENT_POPUPS = 15; + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +export class PopupBlockingChild extends JSWindowActorChild { + constructor() { + super(); + this.weakDocStates = new WeakMap(); + } + + /** + * Returns the state for the current document referred to via + * this.document. If no such state exists, creates it, stores it + * and returns it. + */ + get docState() { + let state = this.weakDocStates.get(this.document); + if (!state) { + state = { + popupData: [], + }; + this.weakDocStates.set(this.document, state); + } + + return state; + } + + receiveMessage(msg) { + switch (msg.name) { + case "UnblockPopup": { + let i = msg.data.index; + let state = this.docState; + let popupData = state.popupData[i]; + if (popupData) { + let dwi = popupData.requestingWindow; + + // If we have a requesting window and the requesting document is + // still the current document, open the popup. + if (dwi && dwi.document == popupData.requestingDocument) { + dwi.open( + popupData.popupWindowURISpec, + popupData.popupWindowName, + popupData.popupWindowFeatures + ); + } + } + break; + } + + case "GetBlockedPopupList": { + let state = this.docState; + let length = Math.min(state.popupData.length, MAX_SENT_POPUPS); + + let result = []; + + for (let i = 0; i < length; ++i) { + let popup = state.popupData[i]; + + let popupWindowURISpec = popup.popupWindowURISpec; + + if (this.contentWindow.location.href == popupWindowURISpec) { + popupWindowURISpec = "<self>"; + } else { + // Limit 500 chars to be sent because the URI will be cropped + // by the UI anyway, and data: URIs can be significantly larger. + popupWindowURISpec = popupWindowURISpec.substring(0, 500); + } + + result.push({ + popupWindowURISpec, + }); + } + + return result; + } + } + + return null; + } + + handleEvent(event) { + switch (event.type) { + case "DOMPopupBlocked": + this.onPopupBlocked(event); + break; + case "pageshow": { + this.onPageShow(event); + break; + } + } + } + + onPopupBlocked(event) { + if (event.target != this.document) { + return; + } + + let state = this.docState; + + // Avoid spamming the parent process with too many blocked popups. + if (state.popupData.length >= PopupBlockingChild.maxReportedPopups) { + return; + } + + let popup = { + popupWindowURISpec: event.popupWindowURI + ? event.popupWindowURI.spec + : "about:blank", + popupWindowFeatures: event.popupWindowFeatures, + popupWindowName: event.popupWindowName, + requestingWindow: event.requestingWindow, + requestingDocument: event.requestingWindow.document, + }; + + state.popupData.push(popup); + this.updateBlockedPopups(true); + } + + onPageShow(event) { + if (event.target != this.document) { + return; + } + + this.updateBlockedPopups(false); + } + + updateBlockedPopups(shouldNotify) { + this.sendAsyncMessage("UpdateBlockedPopups", { + shouldNotify, + count: this.docState.popupData.length, + }); + } +} + +XPCOMUtils.defineLazyPreferenceGetter( + PopupBlockingChild, + "maxReportedPopups", + "privacy.popups.maxReported" +); diff --git a/toolkit/actors/PopupBlockingParent.sys.mjs b/toolkit/actors/PopupBlockingParent.sys.mjs new file mode 100644 index 0000000000..adb49a1ba2 --- /dev/null +++ b/toolkit/actors/PopupBlockingParent.sys.mjs @@ -0,0 +1,268 @@ +/* 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/. */ + +/** + * This class manages all popup blocking operations on a <xul:browser>, including + * notifying the UI about updates to the blocked popups, and allowing popups to + * be unblocked. + */ +export class PopupBlocker { + constructor(browser) { + this._browser = browser; + this._allBlockedPopupCounts = new WeakMap(); + this._shouldShowNotification = false; + } + + /** + * Returns whether or not there are new blocked popups for the associated + * <xul:browser> that the user might need to be notified about. + */ + get shouldShowNotification() { + return this._shouldShowNotification; + } + + /** + * Should be called by the UI when the user has been notified about blocked + * popups for the associated <xul:browser>. + */ + didShowNotification() { + this._shouldShowNotification = false; + } + + /** + * Synchronously returns the most recent count of blocked popups for + * the associated <xul:browser>. + * + * @return {Number} + * The total number of blocked popups for this <xul:browser>. + */ + getBlockedPopupCount() { + let totalBlockedPopups = 0; + + let contextsToVisit = [this._browser.browsingContext]; + while (contextsToVisit.length) { + let currentBC = contextsToVisit.pop(); + let windowGlobal = currentBC.currentWindowGlobal; + + if (!windowGlobal) { + continue; + } + + let popupCountForGlobal = + this._allBlockedPopupCounts.get(windowGlobal) || 0; + totalBlockedPopups += popupCountForGlobal; + contextsToVisit.push(...currentBC.children); + } + + return totalBlockedPopups; + } + + /** + * Asynchronously retrieve information about the popups that have + * been blocked for the associated <xul:browser>. This information + * can be used to unblock those popups. + * + * @return {Promise} + * @resolves {Array} + * When the blocked popup information has been gathered, + * resolves with an Array of Objects with the following properties: + * + * browsingContext {BrowsingContext} + * The BrowsingContext that the popup was blocked for. + * + * innerWindowId {Number} + * The inner window ID for the blocked popup. This is used to differentiate + * popups that were blocked from one page load to the next. + * + * popupWindowURISpec {String} + * A string representing part or all of the URI that tried to be opened in a + * popup. + */ + async getBlockedPopups() { + let contextsToVisit = [this._browser.browsingContext]; + let result = []; + while (contextsToVisit.length) { + let currentBC = contextsToVisit.pop(); + let windowGlobal = currentBC.currentWindowGlobal; + + if (!windowGlobal) { + continue; + } + + let popupCountForGlobal = + this._allBlockedPopupCounts.get(windowGlobal) || 0; + if (popupCountForGlobal) { + let actor = windowGlobal.getActor("PopupBlocking"); + let popups = await actor.sendQuery("GetBlockedPopupList"); + + for (let popup of popups) { + if (!popup.popupWindowURISpec) { + continue; + } + + result.push({ + browsingContext: currentBC, + innerWindowId: windowGlobal.innerWindowId, + popupWindowURISpec: popup.popupWindowURISpec, + }); + } + } + + contextsToVisit.push(...currentBC.children); + } + + return result; + } + + /** + * Unblocks a popup that had been blocked. The information passed should + * come from the list of blocked popups returned via getBlockedPopups(). + * + * Unblocking a popup causes that popup to open. + * + * @param browsingContext {BrowsingContext} + * The BrowsingContext that the popup was blocked for. + * + * @param innerWindowId {Number} + * The inner window ID for the blocked popup. This is used to differentiate popups + * that were blocked from one page load to the next. + * + * @param popupIndex {Number} + * The index of the entry in the Array returned by getBlockedPopups(). + */ + unblockPopup(browsingContext, innerWindowId, popupIndex) { + let popupFrame = browsingContext.top.embedderElement; + let popupBrowser = popupFrame.outerBrowser + ? popupFrame.outerBrowser + : popupFrame; + + if (this._browser != popupBrowser) { + throw new Error( + "Attempting to unblock popup in a BrowsingContext no longer hosted in this browser." + ); + } + + let windowGlobal = browsingContext.currentWindowGlobal; + + if (!windowGlobal || windowGlobal.innerWindowId != innerWindowId) { + // The inner window has moved on since the user clicked on + // the blocked popups dropdown, so we'll just exit silently. + return; + } + + let actor = browsingContext.currentWindowGlobal.getActor("PopupBlocking"); + actor.sendAsyncMessage("UnblockPopup", { index: popupIndex }); + } + + /** + * Goes through the most recent list of blocked popups for the associated + * <xul:browser> and unblocks all of them. Unblocking a popup causes the popup + * to open. + */ + async unblockAllPopups() { + let popups = await this.getBlockedPopups(); + for (let i = 0; i < popups.length; ++i) { + let popup = popups[i]; + this.unblockPopup(popup.browsingContext, popup.innerWindowId, i); + } + } + + /** + * Fires a DOMUpdateBlockedPopups chrome-only event so that the UI can + * update itself to represent the current state of popup blocking for + * the associated <xul:browser>. + */ + updateBlockedPopupsUI() { + let event = this._browser.ownerDocument.createEvent("Events"); + event.initEvent("DOMUpdateBlockedPopups", true, true); + this._browser.dispatchEvent(event); + } + + /** Private methods **/ + + /** + * Updates the current popup count for a particular BrowsingContext based + * on messages from the underlying process. + * + * This should only be called by a PopupBlockingParent instance. + * + * @param browsingContext {BrowsingContext} + * The BrowsingContext to update the internal blocked popup count for. + * + * @param blockedPopupData {Object} + * An Object representing information about how many popups are blocked + * for the BrowsingContext. The Object has the following properties: + * + * count {Number} + * The total number of blocked popups for the BrowsingContext. + * + * shouldNotify {Boolean} + * Whether or not the list of blocked popups has changed in such a way that + * the UI should be updated about it. + */ + _updateBlockedPopupEntries(browsingContext, blockedPopupData) { + let windowGlobal = browsingContext.currentWindowGlobal; + let { count, shouldNotify } = blockedPopupData; + + if (!this.shouldShowNotification && shouldNotify) { + this._shouldShowNotification = true; + } + + if (windowGlobal) { + this._allBlockedPopupCounts.set(windowGlobal, count); + } + + this.updateBlockedPopupsUI(); + } +} + +/** + * To keep things properly encapsulated, these should only be instantiated via + * the PopupBlocker class for a particular <xul:browser>. + * + * Instantiated for a WindowGlobalParent for a BrowsingContext in one of two cases: + * + * 1. One or more popups have been blocked for the underlying frame represented + * by the WindowGlobalParent. + * + * 2. Something in the parent process is querying a frame for information about + * any popups that may have been blocked inside of it. + */ +export class PopupBlockingParent extends JSWindowActorParent { + didDestroy() { + this.updatePopupCountForBrowser({ count: 0, shouldNotify: false }); + } + + receiveMessage(message) { + if (message.name == "UpdateBlockedPopups") { + this.updatePopupCountForBrowser({ + count: message.data.count, + shouldNotify: message.data.shouldNotify, + }); + } + } + + /** + * Updates the PopupBlocker for the <xul:browser> associated with this + * PopupBlockingParent with the most recent count of blocked popups. + * + * @param data {Object} + * An Object with the following properties: + * + * count {Number}: + * The number of blocked popups for the underlying document. + * + * shouldNotify {Boolean}: + * Whether or not the list of blocked popups has changed in such a way that + * the UI should be updated about it. + */ + updatePopupCountForBrowser(data) { + let browser = this.browsingContext.top.embedderElement; + if (!browser) { + return; + } + + browser.popupBlocker._updateBlockedPopupEntries(this.browsingContext, data); + } +} diff --git a/toolkit/actors/PrintingChild.sys.mjs b/toolkit/actors/PrintingChild.sys.mjs new file mode 100644 index 0000000000..4ebfaf9faf --- /dev/null +++ b/toolkit/actors/PrintingChild.sys.mjs @@ -0,0 +1,260 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + DeferredTask: "resource://gre/modules/DeferredTask.sys.mjs", + ReaderMode: "resource://gre/modules/ReaderMode.sys.mjs", + setTimeout: "resource://gre/modules/Timer.sys.mjs", +}); + +let gPendingPreviewsMap = new Map(); + +export class PrintingChild extends JSWindowActorChild { + actorCreated() { + // When the print preview page is loaded, the actor will change, so update + // the state/progress listener to the new actor. + let listener = gPendingPreviewsMap.get(this.browsingContext.id); + if (listener) { + listener.actor = this; + } + this.contentWindow.addEventListener("scroll", this); + } + + didDestroy() { + this._scrollTask?.disarm(); + this.contentWindow?.removeEventListener("scroll", this); + } + + handleEvent(event) { + switch (event.type) { + case "PrintingError": { + let win = event.target.defaultView; + let wbp = win.getInterface(Ci.nsIWebBrowserPrint); + let nsresult = event.detail; + this.sendAsyncMessage("Printing:Error", { + isPrinting: wbp.doingPrint, + nsresult, + }); + break; + } + + case "scroll": + if (!this._scrollTask) { + this._scrollTask = new lazy.DeferredTask( + () => this.updateCurrentPage(), + 16, + 16 + ); + } + this._scrollTask.arm(); + break; + } + } + + receiveMessage(message) { + let data = message.data; + switch (message.name) { + case "Printing:Preview:Navigate": { + this.navigate(data.navType, data.pageNum); + break; + } + + case "Printing:Preview:ParseDocument": { + return this.parseDocument( + data.URL, + Services.wm.getOuterWindowWithId(data.windowID) + ); + } + } + + return undefined; + } + + async parseDocument(URL, contentWindow) { + // The document in 'contentWindow' will be simplified and the resulting nodes + // will be inserted into this.contentWindow. + let thisWindow = this.contentWindow; + + // By using ReaderMode primitives, we parse given document and place the + // resulting JS object into the DOM of current browser. + let article; + try { + article = await lazy.ReaderMode.parseDocument(contentWindow.document); + } catch (ex) { + console.error(ex); + } + + await new Promise(resolve => { + // We make use of a web progress listener in order to know when the content we inject + // into the DOM has finished rendering. If our layout engine is still painting, we + // will wait for MozAfterPaint event to be fired. + let actor = thisWindow.windowGlobalChild.getActor("Printing"); + let webProgressListener = { + onStateChange(webProgress, req, flags, status) { + if (flags & Ci.nsIWebProgressListener.STATE_STOP) { + webProgress.removeProgressListener(webProgressListener); + let domUtils = contentWindow.windowUtils; + // Here we tell the parent that we have parsed the document successfully + // using ReaderMode primitives and we are able to enter on preview mode. + if (domUtils.isMozAfterPaintPending) { + let onPaint = function () { + contentWindow.removeEventListener("MozAfterPaint", onPaint); + actor.sendAsyncMessage("Printing:Preview:ReaderModeReady"); + resolve(); + }; + contentWindow.addEventListener("MozAfterPaint", onPaint); + // This timer is needed for when display list invalidation doesn't invalidate. + lazy.setTimeout(() => { + contentWindow.removeEventListener("MozAfterPaint", onPaint); + actor.sendAsyncMessage("Printing:Preview:ReaderModeReady"); + resolve(); + }, 100); + } else { + actor.sendAsyncMessage("Printing:Preview:ReaderModeReady"); + resolve(); + } + } + }, + + QueryInterface: ChromeUtils.generateQI([ + "nsIWebProgressListener", + "nsISupportsWeakReference", + "nsIObserver", + ]), + }; + + // Here we QI the docShell into a nsIWebProgress passing our web progress listener in. + let webProgress = thisWindow.docShell + .QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIWebProgress); + webProgress.addProgressListener( + webProgressListener, + Ci.nsIWebProgress.NOTIFY_STATE_REQUEST + ); + + let document = thisWindow.document; + document.head.innerHTML = ""; + + // Set base URI of document. Print preview code will read this value to + // populate the URL field in print settings so that it doesn't show + // "about:blank" as its URI. + let headBaseElement = document.createElement("base"); + headBaseElement.setAttribute("href", URL); + document.head.appendChild(headBaseElement); + + // Create link element referencing aboutReader.css and append it to head + let headStyleElement = document.createElement("link"); + headStyleElement.setAttribute("rel", "stylesheet"); + headStyleElement.setAttribute( + "href", + "chrome://global/skin/aboutReader.css" + ); + headStyleElement.setAttribute("type", "text/css"); + document.head.appendChild(headStyleElement); + + // Create link element referencing simplifyMode.css and append it to head + headStyleElement = document.createElement("link"); + headStyleElement.setAttribute("rel", "stylesheet"); + headStyleElement.setAttribute( + "href", + "chrome://global/content/simplifyMode.css" + ); + headStyleElement.setAttribute("type", "text/css"); + document.head.appendChild(headStyleElement); + + document.body.innerHTML = ""; + + // Create container div (main element) and append it to body + let containerElement = document.createElement("div"); + containerElement.setAttribute("class", "container"); + document.body.appendChild(containerElement); + + // Reader Mode might return null if there's a failure when parsing the document. + // We'll render the error message for the Simplify Page document when that happens. + if (article) { + // Set title of document + document.title = article.title; + + // Create header div and append it to container + let headerElement = document.createElement("div"); + headerElement.setAttribute("class", "reader-header"); + headerElement.setAttribute("class", "header"); + containerElement.appendChild(headerElement); + + // Jam the article's title and byline into header div + let titleElement = document.createElement("h1"); + titleElement.setAttribute("class", "reader-title"); + titleElement.textContent = article.title; + headerElement.appendChild(titleElement); + + let bylineElement = document.createElement("div"); + bylineElement.setAttribute("class", "reader-credits credits"); + bylineElement.textContent = article.byline; + headerElement.appendChild(bylineElement); + + // Display header element + headerElement.style.display = "block"; + + // Create content div and append it to container + let contentElement = document.createElement("div"); + contentElement.setAttribute("class", "content"); + containerElement.appendChild(contentElement); + + // Jam the article's content into content div + let readerContent = document.createElement("div"); + readerContent.setAttribute("class", "moz-reader-content"); + contentElement.appendChild(readerContent); + + let articleUri = Services.io.newURI(article.url); + let parserUtils = Cc["@mozilla.org/parserutils;1"].getService( + Ci.nsIParserUtils + ); + let contentFragment = parserUtils.parseFragment( + article.content, + Ci.nsIParserUtils.SanitizerDropForms | + Ci.nsIParserUtils.SanitizerAllowStyle, + false, + articleUri, + readerContent + ); + + readerContent.appendChild(contentFragment); + + // Display reader content element + readerContent.style.display = "block"; + } else { + const l10n = new Localization(["toolkit/about/aboutReader.ftl"], true); + const errorMessage = l10n.formatValueSync("about-reader-load-error"); + + document.title = errorMessage; + + // Create reader message div and append it to body + let readerMessageElement = document.createElement("div"); + readerMessageElement.setAttribute("class", "reader-message"); + readerMessageElement.textContent = errorMessage; + containerElement.appendChild(readerMessageElement); + + // Display reader message element + readerMessageElement.style.display = "block"; + } + }); + } + + updateCurrentPage() { + let cv = this.docShell.contentViewer; + cv.QueryInterface(Ci.nsIWebBrowserPrint); + this.sendAsyncMessage("Printing:Preview:CurrentPage", { + currentPage: cv.printPreviewCurrentPageNumber, + }); + } + + navigate(navType, pageNum) { + let cv = this.docShell.contentViewer; + cv.QueryInterface(Ci.nsIWebBrowserPrint); + cv.printPreviewScrollToPage(navType, pageNum); + } +} diff --git a/toolkit/actors/PrintingParent.sys.mjs b/toolkit/actors/PrintingParent.sys.mjs new file mode 100644 index 0000000000..31b8c6bbc7 --- /dev/null +++ b/toolkit/actors/PrintingParent.sys.mjs @@ -0,0 +1,22 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class PrintingParent extends JSWindowActorParent { + receiveMessage(message) { + let browser = this.browsingContext.top.embedderElement; + + if (message.name == "Printing:Error") { + browser.ownerGlobal.PrintUtils._displayPrintingError( + message.data.nsresult, + message.data.isPrinting, + browser + ); + } else if (message.name == "Printing:Preview:CurrentPage") { + browser.setAttribute("current-page", message.data.currentPage); + } + + return undefined; + } +} diff --git a/toolkit/actors/PrintingSelectionChild.sys.mjs b/toolkit/actors/PrintingSelectionChild.sys.mjs new file mode 100644 index 0000000000..c8dfe39449 --- /dev/null +++ b/toolkit/actors/PrintingSelectionChild.sys.mjs @@ -0,0 +1,20 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class PrintingSelectionChild extends JSWindowActorChild { + receiveMessage(message) { + switch (message.name) { + case "PrintingSelection:HasSelection": + return this.hasSelection(); + } + + return undefined; + } + + hasSelection() { + let selection = this.browsingContext.associatedWindow?.getSelection(); + return selection && selection.type == "Range"; + } +} diff --git a/toolkit/actors/PurgeSessionHistoryChild.sys.mjs b/toolkit/actors/PurgeSessionHistoryChild.sys.mjs new file mode 100644 index 0000000000..32de7929a0 --- /dev/null +++ b/toolkit/actors/PurgeSessionHistoryChild.sys.mjs @@ -0,0 +1,35 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class PurgeSessionHistoryChild extends JSWindowActorChild { + receiveMessage(message) { + if (message.name != "Browser:PurgeSessionHistory") { + return; + } + let sessionHistory = this.docShell.QueryInterface( + Ci.nsIWebNavigation + ).sessionHistory; + if (!sessionHistory) { + return; + } + + // place the entry at current index at the end of the history list, so it won't get removed + if (sessionHistory.index < sessionHistory.count - 1) { + let legacy = sessionHistory.legacySHistory; + let indexEntry = legacy.getEntryAtIndex(sessionHistory.index); + indexEntry.QueryInterface(Ci.nsISHEntry); + legacy.addEntry(indexEntry, true); + } + + let purge = sessionHistory.count; + if (this.document.location.href != "about:blank") { + --purge; // Don't remove the page the user's staring at from shistory + } + + if (purge > 0) { + sessionHistory.legacySHistory.purgeHistory(purge); + } + } +} diff --git a/toolkit/actors/RemotePageChild.sys.mjs b/toolkit/actors/RemotePageChild.sys.mjs new file mode 100644 index 0000000000..48cd4d0df9 --- /dev/null +++ b/toolkit/actors/RemotePageChild.sys.mjs @@ -0,0 +1,219 @@ +/* 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/. */ + +/** + * RemotePageChild is a base class for an unprivileged internal page, typically + * an about: page. A specific implementation should subclass the RemotePageChild + * actor with a more specific actor for that page. Typically, the child is not + * needed, but the parent actor will respond to messages and provide results + * directly to the page. + */ + +const lazy = {}; +ChromeUtils.defineESModuleGetters(lazy, { + AsyncPrefs: "resource://gre/modules/AsyncPrefs.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", + RemotePageAccessManager: + "resource://gre/modules/RemotePageAccessManager.sys.mjs", +}); + +export class RemotePageChild extends JSWindowActorChild { + actorCreated() { + this.listeners = new Map(); + this.exportBaseFunctions(); + } + + exportBaseFunctions() { + const exportableFunctions = [ + "RPMSendAsyncMessage", + "RPMSendQuery", + "RPMAddMessageListener", + "RPMRemoveMessageListener", + "RPMGetIntPref", + "RPMGetStringPref", + "RPMGetBoolPref", + "RPMSetBoolPref", + "RPMGetFormatURLPref", + "RPMIsWindowPrivate", + ]; + + this.exportFunctions(exportableFunctions); + } + + /** + * Exports a list of functions to be accessible by the privileged page. + * Subclasses may call this function to add functions that are specific + * to a page. When the page calls a function, a function with the same + * name is called within the child actor. + * + * Only functions that appear in the whitelist in the + * RemotePageAccessManager for that page will be exported. + * + * @param array of function names. + */ + exportFunctions(functions) { + let document = this.document; + let principal = document.nodePrincipal; + + // If there is no content principal, don't export any functions. + if (!principal) { + return; + } + + let window = this.contentWindow; + + for (let fnname of functions) { + let allowAccess = lazy.RemotePageAccessManager.checkAllowAccessToFeature( + principal, + fnname, + document + ); + + if (allowAccess) { + // Wrap each function in an access checking function. + function accessCheckedFn(...args) { + this.checkAllowAccess(fnname, args[0]); + return this[fnname](...args); + } + + Cu.exportFunction(accessCheckedFn.bind(this), window, { + defineAs: fnname, + }); + } + } + } + + handleEvent() { + // Do nothing. The DOMDocElementInserted event is just used to create + // the actor. + } + + receiveMessage(messagedata) { + let message = { + name: messagedata.name, + data: messagedata.data, + }; + + let listeners = this.listeners.get(message.name); + if (!listeners) { + return; + } + + let clonedMessage = Cu.cloneInto(message, this.contentWindow); + for (let listener of listeners.values()) { + try { + listener(clonedMessage); + } catch (e) { + console.error(e); + } + } + } + + wrapPromise(promise) { + return new this.contentWindow.Promise((resolve, reject) => + promise.then(resolve, reject) + ); + } + + /** + * Returns true if a feature cannot be accessed by the current page. + * Throws an exception if the feature may not be accessed. + + * @param aDocument child process document to call from + * @param aFeature to feature to check access to + * @param aValue value that must be included with that feature's whitelist + * @returns true if access is allowed or throws an exception otherwise + */ + checkAllowAccess(aFeature, aValue) { + let doc = this.document; + if (!lazy.RemotePageAccessManager.checkAllowAccess(doc, aFeature, aValue)) { + throw new Error( + "RemotePageAccessManager does not allow access to " + aFeature + ); + } + + return true; + } + + addPage(aUrl, aFunctionMap) { + lazy.RemotePageAccessManager.addPage(aUrl, aFunctionMap); + } + + // Implementation of functions that are exported into the page. + + RPMSendAsyncMessage(aName, aData = null) { + this.sendAsyncMessage(aName, aData); + } + + RPMSendQuery(aName, aData = null) { + return this.wrapPromise( + new Promise(resolve => { + this.sendQuery(aName, aData).then(result => { + resolve(Cu.cloneInto(result, this.contentWindow)); + }); + }) + ); + } + + /** + * Adds a listener for messages. Many callbacks can be registered for the + * same message if necessary. An attempt to register the same callback for the + * same message twice will be ignored. When called the callback is passed an + * object with these properties: + * name: The message name + * data: Any data sent with the message + */ + RPMAddMessageListener(aName, aCallback) { + if (!this.listeners.has(aName)) { + this.listeners.set(aName, new Set([aCallback])); + } else { + this.listeners.get(aName).add(aCallback); + } + } + + /** + * Removes a listener for messages. + */ + RPMRemoveMessageListener(aName, aCallback) { + if (!this.listeners.has(aName)) { + return; + } + + this.listeners.get(aName).delete(aCallback); + } + + RPMGetIntPref(aPref, defaultValue) { + // Only call with a default value if it's defined, to be able to throw + // errors for non-existent prefs. + if (defaultValue !== undefined) { + return Services.prefs.getIntPref(aPref, defaultValue); + } + return Services.prefs.getIntPref(aPref); + } + + RPMGetStringPref(aPref) { + return Services.prefs.getStringPref(aPref); + } + + RPMGetBoolPref(aPref, defaultValue) { + // Only call with a default value if it's defined, to be able to throw + // errors for non-existent prefs. + if (defaultValue !== undefined) { + return Services.prefs.getBoolPref(aPref, defaultValue); + } + return Services.prefs.getBoolPref(aPref); + } + + RPMSetBoolPref(aPref, aVal) { + return this.wrapPromise(lazy.AsyncPrefs.set(aPref, aVal)); + } + + RPMGetFormatURLPref(aFormatURL) { + return Services.urlFormatter.formatURLPref(aFormatURL); + } + + RPMIsWindowPrivate() { + return lazy.PrivateBrowsingUtils.isContentWindowPrivate(this.contentWindow); + } +} diff --git a/toolkit/actors/SelectChild.sys.mjs b/toolkit/actors/SelectChild.sys.mjs new file mode 100644 index 0000000000..add2024093 --- /dev/null +++ b/toolkit/actors/SelectChild.sys.mjs @@ -0,0 +1,470 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + DeferredTask: "resource://gre/modules/DeferredTask.sys.mjs", + LayoutUtils: "resource://gre/modules/LayoutUtils.sys.mjs", +}); + +const kStateActive = 0x00000001; // ElementState::ACTIVE +const kStateHover = 0x00000004; // ElementState::HOVER + +// Duplicated in SelectParent.jsm +// Please keep these lists in sync. +const SUPPORTED_OPTION_OPTGROUP_PROPERTIES = [ + "direction", + "color", + "background-color", + "text-shadow", + "text-transform", + "font-family", + "font-weight", + "font-size", + "font-style", +]; + +const SUPPORTED_SELECT_PROPERTIES = [ + ...SUPPORTED_OPTION_OPTGROUP_PROPERTIES, + "scrollbar-width", + "scrollbar-color", +]; + +// A process global state for whether or not content thinks +// that a <select> dropdown is open or not. This is managed +// entirely within this module, and is read-only accessible +// via SelectContentHelper.open. +var gOpen = false; + +export var SelectContentHelper = function (aElement, aOptions, aActor) { + this.element = aElement; + this.initialSelection = aElement[aElement.selectedIndex] || null; + this.actor = aActor; + this.closedWithClickOn = false; + this.isOpenedViaTouch = aOptions.isOpenedViaTouch; + this._closeAfterBlur = true; + this._pseudoStylesSetup = false; + this._lockedDescendants = null; + this.init(); + this.showDropDown(); + this._updateTimer = new lazy.DeferredTask(this._update.bind(this), 0); +}; + +Object.defineProperty(SelectContentHelper, "open", { + get() { + return gOpen; + }, +}); + +SelectContentHelper.prototype = { + init() { + let win = this.element.ownerGlobal; + win.addEventListener("pagehide", this, { mozSystemGroup: true }); + this.element.addEventListener("blur", this, { mozSystemGroup: true }); + this.element.addEventListener("transitionend", this, { + mozSystemGroup: true, + }); + let MutationObserver = this.element.ownerGlobal.MutationObserver; + this.mut = new MutationObserver(mutations => { + // Something changed the <select> while it was open, so + // we'll poke a DeferredTask to update the parent sometime + // in the very near future. + this._updateTimer.arm(); + }); + this.mut.observe(this.element, { + childList: true, + subtree: true, + attributes: true, + }); + + XPCOMUtils.defineLazyPreferenceGetter( + this, + "disablePopupAutohide", + "ui.popup.disable_autohide", + false + ); + }, + + uninit() { + this.element.openInParentProcess = false; + let win = this.element.ownerGlobal; + win.removeEventListener("pagehide", this, { mozSystemGroup: true }); + this.element.removeEventListener("blur", this, { mozSystemGroup: true }); + this.element.removeEventListener("transitionend", this, { + mozSystemGroup: true, + }); + this.element = null; + this.actor = null; + this.mut.disconnect(); + this._updateTimer.disarm(); + this._updateTimer = null; + gOpen = false; + }, + + showDropDown() { + this.element.openInParentProcess = true; + this._setupPseudoClassStyles(); + let rect = this._getBoundingContentRect(); + let computedStyles = getComputedStyles(this.element); + let options = this._buildOptionList(); + let defaultStyles = this.element.ownerGlobal.getDefaultComputedStyle( + this.element + ); + this.actor.sendAsyncMessage("Forms:ShowDropDown", { + isOpenedViaTouch: this.isOpenedViaTouch, + options, + rect, + custom: !this.element.nodePrincipal.isSystemPrincipal, + selectedIndex: this.element.selectedIndex, + isDarkBackground: ChromeUtils.isDarkBackground(this.element), + style: supportedStyles(computedStyles, SUPPORTED_SELECT_PROPERTIES), + defaultStyle: supportedStyles(defaultStyles, SUPPORTED_SELECT_PROPERTIES), + }); + this._clearPseudoClassStyles(); + gOpen = true; + }, + + _setupPseudoClassStyles() { + if (this._pseudoStylesSetup) { + throw new Error("pseudo styles must not be set up yet"); + } + // Do all of the things that change style at once, before we read + // any styles. + this._pseudoStylesSetup = true; + InspectorUtils.addPseudoClassLock(this.element, ":focus"); + let lockedDescendants = (this._lockedDescendants = + this.element.querySelectorAll(":checked")); + for (let child of lockedDescendants) { + // Selected options have the :checked pseudo-class, which + // we want to disable before calculating the computed + // styles since the user agent styles alter the styling + // based on :checked. + InspectorUtils.addPseudoClassLock(child, ":checked", false); + } + }, + + _clearPseudoClassStyles() { + if (!this._pseudoStylesSetup) { + throw new Error("pseudo styles must be set up already"); + } + // Undo all of the things that change style at once, after we're + // done reading styles. + InspectorUtils.clearPseudoClassLocks(this.element); + let lockedDescendants = this._lockedDescendants; + for (let child of lockedDescendants) { + InspectorUtils.clearPseudoClassLocks(child); + } + this._lockedDescendants = null; + this._pseudoStylesSetup = false; + }, + + _getBoundingContentRect() { + return lazy.LayoutUtils.getElementBoundingScreenRect(this.element); + }, + + _buildOptionList() { + if (!this._pseudoStylesSetup) { + throw new Error("pseudo styles must be set up"); + } + let uniqueStyles = []; + let options = buildOptionListForChildren(this.element, uniqueStyles); + return { options, uniqueStyles }; + }, + + _update() { + // The <select> was updated while the dropdown was open. + // Let's send up a new list of options. + // Technically we might not need to set this pseudo-class + // during _update() since the element should organically + // have :focus, though it is here for belt-and-suspenders. + this._setupPseudoClassStyles(); + let computedStyles = getComputedStyles(this.element); + let defaultStyles = this.element.ownerGlobal.getDefaultComputedStyle( + this.element + ); + this.actor.sendAsyncMessage("Forms:UpdateDropDown", { + options: this._buildOptionList(), + custom: !this.element.nodePrincipal.isSystemPrincipal, + selectedIndex: this.element.selectedIndex, + isDarkBackground: ChromeUtils.isDarkBackground(this.element), + style: supportedStyles(computedStyles, SUPPORTED_SELECT_PROPERTIES), + defaultStyle: supportedStyles(defaultStyles, SUPPORTED_SELECT_PROPERTIES), + }); + this._clearPseudoClassStyles(); + }, + + dispatchMouseEvent(win, target, eventName) { + let mouseEvent = new win.MouseEvent(eventName, { + view: win, + bubbles: true, + cancelable: true, + composed: true, + }); + target.dispatchEvent(mouseEvent); + }, + + receiveMessage(message) { + switch (message.name) { + case "Forms:SelectDropDownItem": + this.element.selectedIndex = message.data.value; + this.closedWithClickOn = !message.data.closedWithEnter; + break; + + case "Forms:DismissedDropDown": { + if (!this.element) { + return; + } + + let win = this.element.ownerGlobal; + + // Running arbitrary script below (dispatching events for example) can + // close us, but we should still send events consistently. + let element = this.element; + + let selectedOption = element.item(element.selectedIndex); + + // For ordering of events, we're using non-e10s as our guide here, + // since the spec isn't exactly clear. In non-e10s: + // - If the user clicks on an element in the dropdown, we fire + // mousedown, mouseup, input, change, and click events. + // - If the user uses the keyboard to select an element in the + // dropdown, we only fire input and change events. + // - If the user pressed ESC key or clicks outside the dropdown, + // we fire nothing as the selected option is unchanged. + if (this.closedWithClickOn) { + this.dispatchMouseEvent(win, selectedOption, "mousedown"); + this.dispatchMouseEvent(win, selectedOption, "mouseup"); + } + + // Clear active document no matter user selects via keyboard or mouse + InspectorUtils.removeContentState( + element, + kStateActive, + /* aClearActiveDocument */ true + ); + + // Fire input and change events when selected option changes + if (this.initialSelection !== selectedOption) { + let inputEvent = new win.Event("input", { + bubbles: true, + composed: true, + }); + + let changeEvent = new win.Event("change", { + bubbles: true, + }); + + let handlingUserInput = win.windowUtils.setHandlingUserInput(true); + try { + element.dispatchEvent(inputEvent); + element.dispatchEvent(changeEvent); + } finally { + handlingUserInput.destruct(); + } + } + + // Fire click event + if (this.closedWithClickOn) { + this.dispatchMouseEvent(win, selectedOption, "click"); + } + + this.uninit(); + break; + } + + case "Forms:MouseOver": + InspectorUtils.setContentState(this.element, kStateHover); + break; + + case "Forms:MouseOut": + InspectorUtils.removeContentState(this.element, kStateHover); + break; + + case "Forms:MouseUp": + let win = this.element.ownerGlobal; + if (message.data.onAnchor) { + this.dispatchMouseEvent(win, this.element, "mouseup"); + } + InspectorUtils.removeContentState(this.element, kStateActive); + if (message.data.onAnchor) { + this.dispatchMouseEvent(win, this.element, "click"); + } + break; + + case "Forms:SearchFocused": + this._closeAfterBlur = false; + break; + + case "Forms:BlurDropDown-Pong": + if (!this._closeAfterBlur || !gOpen) { + return; + } + this.actor.sendAsyncMessage("Forms:HideDropDown", {}); + this.uninit(); + break; + } + }, + + handleEvent(event) { + switch (event.type) { + case "pagehide": + if (this.element.ownerDocument === event.target) { + this.actor.sendAsyncMessage("Forms:HideDropDown", {}); + this.uninit(); + } + break; + case "blur": { + if (this.element !== event.target || this.disablePopupAutohide) { + break; + } + this._closeAfterBlur = true; + // Send a ping-pong message to make sure that we wait for + // enough cycles to pass from the potential focusing of the + // search box to disable closing-after-blur. + this.actor.sendAsyncMessage("Forms:BlurDropDown-Ping", {}); + break; + } + case "mozhidedropdown": + if (this.element === event.target) { + this.actor.sendAsyncMessage("Forms:HideDropDown", {}); + this.uninit(); + } + break; + case "transitionend": + if ( + this.element === event.target && + SUPPORTED_SELECT_PROPERTIES.includes(event.propertyName) + ) { + this._updateTimer.arm(); + } + break; + } + }, +}; + +function getComputedStyles(element) { + return element.ownerGlobal.getComputedStyle(element); +} + +function supportedStyles(cs, supportedProps) { + let styles = {}; + for (let property of supportedProps) { + styles[property] = cs.getPropertyValue(property); + } + return styles; +} + +function supportedStylesEqual(styles, otherStyles) { + for (let property in styles) { + if (styles[property] !== otherStyles[property]) { + return false; + } + } + return true; +} + +function uniqueStylesIndex(cs, uniqueStyles) { + let styles = supportedStyles(cs, SUPPORTED_OPTION_OPTGROUP_PROPERTIES); + for (let i = uniqueStyles.length; i--; ) { + if (supportedStylesEqual(uniqueStyles[i], styles)) { + return i; + } + } + uniqueStyles.push(styles); + return uniqueStyles.length - 1; +} + +function buildOptionListForChildren(node, uniqueStyles) { + let result = []; + + for (let child of node.children) { + let className = ChromeUtils.getClassName(child); + let isOption = className == "HTMLOptionElement"; + let isOptGroup = className == "HTMLOptGroupElement"; + if (!isOption && !isOptGroup) { + continue; + } + if (child.hidden) { + continue; + } + + // The option code-path should match HTMLOptionElement::GetRenderedLabel. + let textContent = isOptGroup + ? child.getAttribute("label") + : child.label || child.text; + if (textContent == null) { + textContent = ""; + } + + let cs = getComputedStyles(child); + let info = { + index: child.index, + isOptGroup, + textContent, + disabled: child.disabled, + display: cs.display, + tooltip: child.title, + children: isOptGroup + ? buildOptionListForChildren(child, uniqueStyles) + : [], + // Most options have the same style. In order to reduce the size of the + // IPC message, coalesce them in uniqueStyles. + styleIndex: uniqueStylesIndex(cs, uniqueStyles), + }; + result.push(info); + } + return result; +} + +// Hold the instance of SelectContentHelper created +// when the dropdown list is opened. This variable helps +// re-route the received message from SelectChild to SelectContentHelper object. +let currentSelectContentHelper = new WeakMap(); + +export class SelectChild extends JSWindowActorChild { + handleEvent(event) { + if (SelectContentHelper.open) { + // The SelectContentHelper object handles captured + // events when the <select> popup is open. + let contentHelper = currentSelectContentHelper.get(this); + if (contentHelper) { + contentHelper.handleEvent(event); + } + return; + } + + switch (event.type) { + case "mozshowdropdown": { + let contentHelper = new SelectContentHelper( + event.target, + { isOpenedViaTouch: false }, + this + ); + currentSelectContentHelper.set(this, contentHelper); + break; + } + + case "mozshowdropdown-sourcetouch": { + let contentHelper = new SelectContentHelper( + event.target, + { isOpenedViaTouch: true }, + this + ); + currentSelectContentHelper.set(this, contentHelper); + break; + } + } + } + + receiveMessage(message) { + let contentHelper = currentSelectContentHelper.get(this); + if (contentHelper) { + contentHelper.receiveMessage(message); + } + } +} diff --git a/toolkit/actors/SelectParent.sys.mjs b/toolkit/actors/SelectParent.sys.mjs new file mode 100644 index 0000000000..6c41903994 --- /dev/null +++ b/toolkit/actors/SelectParent.sys.mjs @@ -0,0 +1,798 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const lazy = {}; + +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "DOM_FORMS_SELECTSEARCH", + "dom.forms.selectSearch", + false +); + +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "CUSTOM_STYLING_ENABLED", + "dom.forms.select.customstyling", + false +); + +// Maximum number of rows to display in the select dropdown. +const MAX_ROWS = 20; + +// Minimum elements required to show select search +const SEARCH_MINIMUM_ELEMENTS = 40; + +// The properties that we should respect only when the item is not active. +const PROPERTIES_RESET_WHEN_ACTIVE = [ + "color", + "background-color", + "text-shadow", +]; + +// Duplicated in SelectChild.jsm +// Please keep these lists in sync. +const SUPPORTED_OPTION_OPTGROUP_PROPERTIES = [ + "direction", + "color", + "background-color", + "text-shadow", + "text-transform", + "font-family", + "font-weight", + "font-size", + "font-style", +]; + +const SUPPORTED_SELECT_PROPERTIES = [ + ...SUPPORTED_OPTION_OPTGROUP_PROPERTIES, + "scrollbar-width", + "scrollbar-color", +]; + +export var SelectParentHelper = { + /** + * `populate` takes the `menulist` element and a list of `items` and generates + * a popup list of options. + * + * If `CUSTOM_STYLING_ENABLED` is set to `true`, the function will also + * style the select and its popup trying to prevent the text + * and background to end up in the same color. + * + * All `ua*` variables represent the color values for the default colors + * for their respective form elements used by the user agent. + * The `select*` variables represent the color values defined for the + * particular <select> element. + * + * The `customoptionstyling` attribute controls the application of + * `-moz-appearance` on the elements and is disabled if the element is + * defining its own background-color. + * + * @param {Element} menulist + * @param {Array<Element>} items + * @param {Array<Object>} uniqueItemStyles + * @param {Number} selectedIndex + * @param {Number} zoom + * @param {Boolean} custom + * @param {Boolean} isDarkBackground + * @param {Object} uaStyle + * @param {Object} selectStyle + */ + populate( + menulist, + items, + uniqueItemStyles, + selectedIndex, + zoom, + custom, + isDarkBackground, + uaStyle, + selectStyle + ) { + let doc = menulist.ownerDocument; + + // Clear the current contents of the popup + let menupopup = menulist.menupopup; + menupopup.textContent = ""; + + let stylesheet = menulist.querySelector("#ContentSelectDropdownStylesheet"); + if (stylesheet) { + stylesheet.remove(); + } + + menupopup.setAttribute("style", ""); + menupopup.style.colorScheme = isDarkBackground ? "dark" : "light"; + menupopup.style.direction = selectStyle.direction; + + stylesheet = doc.createElementNS("http://www.w3.org/1999/xhtml", "style"); + stylesheet.setAttribute("id", "ContentSelectDropdownStylesheet"); + stylesheet.hidden = true; + stylesheet = menulist.appendChild(stylesheet); + + let sheet = stylesheet.sheet; + + if (!custom) { + selectStyle = uaStyle; + } + + if (selectStyle["background-color"] == "rgba(0, 0, 0, 0)") { + selectStyle["background-color"] = uaStyle["background-color"]; + } + + if (selectStyle.color == selectStyle["background-color"]) { + selectStyle.color = uaStyle.color; + } + + // We ensure that we set the content background if the color changes as + // well, to prevent contrast issues. + let selectBackgroundSet = + selectStyle["background-color"] != uaStyle["background-color"] || + selectStyle.color != uaStyle.color; + + if (custom) { + if (selectStyle["text-shadow"] != "none") { + sheet.insertRule( + `#ContentSelectDropdown > menupopup > :is(menuitem, menucaption)[_moz-menuactive="true"] { + text-shadow: none; + }`, + 0 + ); + } + + for (let property of SUPPORTED_SELECT_PROPERTIES) { + let shouldSkip = (function () { + if (property == "direction") { + // Handled elsewhere. + return true; + } + if (!selectStyle[property]) { + return true; + } + if (property == "background-color") { + // This also depends on whether "color" is set. + return !selectBackgroundSet; + } + return selectStyle[property] == uaStyle[property]; + })(); + + if (shouldSkip) { + continue; + } + let value = selectStyle[property]; + if (property == "scrollbar-width") { + // This needs to actually apply to the relevant scrollbox, because + // scrollbar-width doesn't inherit. + property = "--content-select-scrollbar-width"; + } + if (property == "color") { + property = "--panel-color"; + } + menupopup.style.setProperty(property, value); + } + // Some webpages set the <select> backgroundColor to transparent, + // but they don't intend to change the popup to transparent. + // So we remove the backgroundColor and turn it into an image instead. + if (selectBackgroundSet) { + // We intentionally use the parsed color to prevent color + // values like `url(..)` being injected into the + // `background-image` property. + let parsedColor = menupopup.style.backgroundColor; + menupopup.style.setProperty( + "--content-select-background-image", + `linear-gradient(${parsedColor}, ${parsedColor})` + ); + // Always drop the background color to avoid messing with the custom + // shadow on Windows 10 styling. + menupopup.style.backgroundColor = ""; + // If the background is set, we also make sure we set the color, to + // prevent contrast issues. + menupopup.style.setProperty("--panel-color", selectStyle.color); + + sheet.insertRule( + `#ContentSelectDropdown > menupopup > :is(menuitem, menucaption):not([_moz-menuactive="true"]) { + color: inherit; + }`, + 0 + ); + } + } + + for (let i = 0, len = uniqueItemStyles.length; i < len; ++i) { + sheet.insertRule( + `#ContentSelectDropdown .ContentSelectDropdown-item-${i} {}`, + 0 + ); + let style = uniqueItemStyles[i]; + let rule = sheet.cssRules[0].style; + rule.direction = style.direction; + rule.fontSize = zoom * parseFloat(style["font-size"], 10) + "px"; + + if (!custom) { + continue; + } + let optionBackgroundIsTransparent = + style["background-color"] == "rgba(0, 0, 0, 0)"; + let optionBackgroundSet = + !optionBackgroundIsTransparent || style.color != selectStyle.color; + + if (optionBackgroundIsTransparent && style.color != selectStyle.color) { + style["background-color"] = selectStyle["background-color"]; + } + + if (style.color == style["background-color"]) { + style.color = selectStyle.color; + } + + let inactiveRule = null; + for (const property of SUPPORTED_OPTION_OPTGROUP_PROPERTIES) { + let shouldSkip = (function () { + if (property == "direction" || property == "font-size") { + // Handled elsewhere. + return true; + } + if (!style[property]) { + return true; + } + if (property == "background-color" || property == "color") { + // This also depends on whether "color" is set. + return !optionBackgroundSet; + } + return style[property] == selectStyle[property]; + })(); + if (shouldSkip) { + continue; + } + if (PROPERTIES_RESET_WHEN_ACTIVE.includes(property)) { + if (!inactiveRule) { + sheet.insertRule( + `#ContentSelectDropdown .ContentSelectDropdown-item-${i}:not([_moz-menuactive="true"]) {}`, + 0 + ); + inactiveRule = sheet.cssRules[0].style; + } + inactiveRule[property] = style[property]; + } else { + rule[property] = style[property]; + } + } + style.customStyling = selectBackgroundSet || optionBackgroundSet; + } + + // We only set the `customoptionstyling` if the background has been + // manually set. This prevents the overlap between moz-appearance and + // background-color. `color` and `text-shadow` do not interfere with it. + if (custom && selectBackgroundSet) { + menulist.menupopup.setAttribute("customoptionstyling", "true"); + } else { + menulist.menupopup.removeAttribute("customoptionstyling"); + } + + this._currentZoom = zoom; + this._currentMenulist = menulist; + this.populateChildren(menulist, items, uniqueItemStyles, selectedIndex); + }, + + open(browser, menulist, rect, isOpenedViaTouch, selectParentActor) { + this._actor = selectParentActor; + menulist.hidden = false; + this._currentBrowser = browser; + this._closedWithEnter = false; + this._selectRect = rect; + this._registerListeners(menulist.menupopup); + + // Set the maximum height to show exactly MAX_ROWS items. + let menupopup = menulist.menupopup; + let firstItem = menupopup.firstElementChild; + while (firstItem && firstItem.hidden) { + firstItem = firstItem.nextElementSibling; + } + + let win = menulist.ownerGlobal; + if (firstItem) { + let itemHeight = firstItem.getBoundingClientRect().height; + + // Include the padding and border on the popup. + let cs = win.getComputedStyle(menupopup); + let bpHeight = + parseFloat(cs.borderTopWidth) + + parseFloat(cs.borderBottomWidth) + + parseFloat(cs.paddingTop) + + parseFloat(cs.paddingBottom); + menupopup.style.maxHeight = itemHeight * MAX_ROWS + bpHeight + "px"; + } + + menupopup.classList.toggle("isOpenedViaTouch", isOpenedViaTouch); + + if (browser) { + browser.constrainPopup(menupopup); + } else { + menupopup.setConstraintRect(new win.DOMRect(0, 0, 0, 0)); + } + menupopup.openPopupAtScreenRect( + AppConstants.platform == "macosx" ? "selection" : "after_start", + rect.left, + rect.top, + rect.width, + rect.height, + false, + false + ); + }, + + hide(menulist, browser) { + if (this._currentBrowser == browser) { + menulist.menupopup.hidePopup(); + } + }, + + handleEvent(event) { + switch (event.type) { + case "mouseup": + function inRect(rect, x, y) { + return ( + x >= rect.left && + x <= rect.left + rect.width && + y >= rect.top && + y <= rect.top + rect.height + ); + } + + let x = event.screenX, + y = event.screenY; + let onAnchor = + !inRect(this._currentMenulist.menupopup.getOuterScreenRect(), x, y) && + inRect(this._selectRect, x, y) && + this._currentMenulist.menupopup.state == "open"; + this._actor.sendAsyncMessage("Forms:MouseUp", { onAnchor }); + break; + + case "mouseover": + if ( + !event.relatedTarget || + !this._currentMenulist.contains(event.relatedTarget) + ) { + this._actor.sendAsyncMessage("Forms:MouseOver", {}); + } + break; + + case "mouseout": + if ( + !event.relatedTarget || + !this._currentMenulist.contains(event.relatedTarget) + ) { + this._actor.sendAsyncMessage("Forms:MouseOut", {}); + } + break; + + case "keydown": + if (event.keyCode == event.DOM_VK_RETURN) { + this._closedWithEnter = true; + } + break; + + case "command": + if (event.target.hasAttribute("value")) { + this._actor.sendAsyncMessage("Forms:SelectDropDownItem", { + value: event.target.value, + closedWithEnter: this._closedWithEnter, + }); + } + break; + + case "fullscreen": + if (this._currentMenulist) { + this._currentMenulist.menupopup.hidePopup(); + } + break; + + case "popuphidden": + this._actor.sendAsyncMessage("Forms:DismissedDropDown", {}); + let popup = event.target; + this._unregisterListeners(popup); + popup.parentNode.hidden = true; + this._currentBrowser = null; + this._currentMenulist = null; + this._selectRect = null; + this._currentZoom = 1; + this._actor = null; + break; + } + }, + + receiveMessage(browser, msg) { + // Sanity check - we'd better know what the currently opened menulist is, + // and what browser it belongs to... + if (!this._currentMenulist || this._currentBrowser != browser) { + return; + } + + if (msg.name == "Forms:UpdateDropDown") { + let scrollBox = this._currentMenulist.menupopup.scrollBox.scrollbox; + let scrollTop = scrollBox.scrollTop; + + let options = msg.data.options; + let selectedIndex = msg.data.selectedIndex; + this.populate( + this._currentMenulist, + options.options, + options.uniqueStyles, + selectedIndex, + this._currentZoom, + msg.data.custom && lazy.CUSTOM_STYLING_ENABLED, + msg.data.isDarkBackground, + msg.data.defaultStyle, + msg.data.style + ); + + // Restore scroll position to what it was prior to the update. + scrollBox.scrollTop = scrollTop; + } else if (msg.name == "Forms:BlurDropDown-Ping") { + this._actor.sendAsyncMessage("Forms:BlurDropDown-Pong", {}); + } + }, + + _registerListeners(popup) { + popup.addEventListener("command", this); + popup.addEventListener("popuphidden", this); + popup.addEventListener("mouseover", this); + popup.addEventListener("mouseout", this); + popup.ownerGlobal.addEventListener("mouseup", this, true); + popup.ownerGlobal.addEventListener("keydown", this, true); + popup.ownerGlobal.addEventListener("fullscreen", this, true); + }, + + _unregisterListeners(popup) { + popup.removeEventListener("command", this); + popup.removeEventListener("popuphidden", this); + popup.removeEventListener("mouseover", this); + popup.removeEventListener("mouseout", this); + popup.ownerGlobal.removeEventListener("mouseup", this, true); + popup.ownerGlobal.removeEventListener("keydown", this, true); + popup.ownerGlobal.removeEventListener("fullscreen", this, true); + }, + + /** + * `populateChildren` creates all <menuitem> elements for the popup menu + * based on the list of <option> elements from the <select> element. + * + * It attempts to intelligently add per-item CSS rules if the single + * item values differ from the parent menu values and attempting to avoid + * ending up with the same color of text and background. + * + * @param {Element} menulist + * @param {Array<Element>} options + * @param {Array<Object>} uniqueOptionStyles + * @param {Number} selectedIndex + * @param {Element} parentElement + * @param {Boolean} isGroupDisabled + * @param {Boolean} addSearch + * @param {Number} nthChildIndex + * @returns {Number} + */ + populateChildren( + menulist, + options, + uniqueOptionStyles, + selectedIndex, + parentElement = null, + isGroupDisabled = false, + addSearch = true, + nthChildIndex = 1 + ) { + let element = menulist.menupopup; + + let ariaOwns = ""; + for (let option of options) { + let isOptGroup = option.isOptGroup; + let item = element.ownerDocument.createXULElement( + isOptGroup ? "menucaption" : "menuitem" + ); + if (isOptGroup) { + item.setAttribute("role", "group"); + } + item.setAttribute("label", option.textContent); + item.className = `ContentSelectDropdown-item-${option.styleIndex}`; + item.hidden = + option.display == "none" || (parentElement && parentElement.hidden); + // Keep track of which options are hidden by page content, so we can avoid + // showing them on search input. + item.hiddenByContent = item.hidden; + item.setAttribute("tooltiptext", option.tooltip); + + if (uniqueOptionStyles[option.styleIndex].customStyling) { + item.setAttribute("customoptionstyling", "true"); + } else { + item.removeAttribute("customoptionstyling"); + } + + if (parentElement) { + // In the menupopup, the optgroup is a sibling of its contained options. + // For accessibility, we want to preserve the hierarchy such that the + // options are inside the optgroup. We do this using aria-owns on the + // parent. + item.id = "ContentSelectDropdownOption" + nthChildIndex; + item.setAttribute("aria-level", "2"); + ariaOwns += item.id + " "; + } + + element.appendChild(item); + nthChildIndex++; + + // A disabled optgroup disables all of its child options. + let isDisabled = isGroupDisabled || option.disabled; + if (isDisabled) { + item.setAttribute("disabled", "true"); + } + + if (isOptGroup) { + nthChildIndex = this.populateChildren( + menulist, + option.children, + uniqueOptionStyles, + selectedIndex, + item, + isDisabled, + false, + nthChildIndex + ); + } else { + if (option.index == selectedIndex) { + // We expect the parent element of the popup to be a <xul:menulist> that + // has the popuponly attribute set to "true". This is necessary in order + // for a <xul:menupopup> to act like a proper <html:select> dropdown, as + // the <xul:menulist> does things like remember state and set the + // _moz-menuactive attribute on the selected <xul:menuitem>. + menulist.selectedItem = item; + + // It's hack time. In the event that we've re-populated the menulist due + // to a mutation in the <select> in content, that means that the -moz_activemenu + // may have been removed from the selected item. Since that's normally only + // set for the initially selected on popupshowing for the menulist, and we + // don't want to close and re-open the popup, we manually set it here. + menulist.activeChild = item; + } + + item.setAttribute("value", option.index); + + if (parentElement) { + item.classList.add("contentSelectDropdown-ingroup"); + } + } + } + + if (parentElement && ariaOwns) { + parentElement.setAttribute("aria-owns", ariaOwns); + } + + // Check if search pref is enabled, if this is the first time iterating through + // the dropdown, and if the list is long enough for a search element to be added. + if ( + lazy.DOM_FORMS_SELECTSEARCH && + addSearch && + element.childElementCount > SEARCH_MINIMUM_ELEMENTS + ) { + // Add a search text field as the first element of the dropdown + let searchbox = element.ownerDocument.createXULElement("search-textbox"); + searchbox.className = "contentSelectDropdown-searchbox"; + searchbox.addEventListener("input", this.onSearchInput); + searchbox.addEventListener("focus", this.onSearchFocus.bind(this)); + searchbox.addEventListener("blur", this.onSearchBlur); + searchbox.addEventListener("command", this.onSearchInput); + + // Handle special keys for exiting search + searchbox.addEventListener( + "keydown", + event => { + this.onSearchKeydown(event, menulist); + }, + true + ); + + element.insertBefore(searchbox, element.children[0]); + } + + return nthChildIndex; + }, + + onSearchKeydown(event, menulist) { + if (event.defaultPrevented) { + return; + } + + let searchbox = event.currentTarget; + switch (event.key) { + case "Escape": + searchbox.parentElement.hidePopup(); + break; + case "ArrowDown": + case "Enter": + case "Tab": + searchbox.blur(); + if ( + searchbox.nextElementSibling.localName == "menuitem" && + !searchbox.nextElementSibling.hidden + ) { + menulist.activeChild = searchbox.nextElementSibling; + } else { + let currentOption = searchbox.nextElementSibling; + while ( + currentOption && + (currentOption.localName != "menuitem" || currentOption.hidden) + ) { + currentOption = currentOption.nextElementSibling; + } + if (currentOption) { + menulist.activeChild = currentOption; + } else { + searchbox.focus(); + } + } + break; + default: + return; + } + event.preventDefault(); + }, + + onSearchInput(event) { + let searchObj = event.currentTarget; + + // Get input from search field, set to all lower case for comparison + let input = searchObj.value.toLowerCase(); + // Get all items in dropdown (could be options or optgroups) + let menupopup = searchObj.parentElement; + let menuItems = menupopup.querySelectorAll("menuitem, menucaption"); + + // Flag used to detect any group headers with no visible options. + // These group headers should be hidden. + let allHidden = true; + // Keep a reference to the previous group header (menucaption) to go back + // and set to hidden if all options within are hidden. + let prevCaption = null; + + for (let currentItem of menuItems) { + // Make sure we don't show any options that were hidden by page content + if (!currentItem.hiddenByContent) { + // Get label and tooltip (title) from option and change to + // lower case for comparison + let itemLabel = currentItem.getAttribute("label").toLowerCase(); + let itemTooltip = currentItem.getAttribute("title").toLowerCase(); + + // If search input is empty, all options should be shown + if (!input) { + currentItem.hidden = false; + } else if (currentItem.localName == "menucaption") { + if (prevCaption != null) { + prevCaption.hidden = allHidden; + } + prevCaption = currentItem; + allHidden = true; + } else { + if ( + !currentItem.classList.contains("contentSelectDropdown-ingroup") && + currentItem.previousElementSibling.classList.contains( + "contentSelectDropdown-ingroup" + ) + ) { + if (prevCaption != null) { + prevCaption.hidden = allHidden; + } + prevCaption = null; + allHidden = true; + } + if (itemLabel.includes(input) || itemTooltip.includes(input)) { + currentItem.hidden = false; + allHidden = false; + } else { + currentItem.hidden = true; + } + } + if (prevCaption != null) { + prevCaption.hidden = allHidden; + } + } + } + }, + + onSearchFocus(event) { + let menupopup = event.target.closest("menupopup"); + menupopup.parentElement.activeChild = null; + menupopup.setAttribute("ignorekeys", "true"); + this._actor.sendAsyncMessage("Forms:SearchFocused", {}); + }, + + onSearchBlur(event) { + let menupopup = event.target.closest("menupopup"); + menupopup.setAttribute( + "ignorekeys", + AppConstants.platform == "win" ? "shortcuts" : "false" + ); + }, +}; + +export class SelectParent extends JSWindowActorParent { + get relevantBrowser() { + return this.browsingContext.top.embedderElement; + } + + get _document() { + return this.browsingContext.topChromeWindow.document; + } + + get _menulist() { + return this._document.getElementById("ContentSelectDropdown"); + } + + _createMenulist() { + let document = this._document; + let menulist = document.createXULElement("menulist"); + menulist.setAttribute("id", "ContentSelectDropdown"); + menulist.setAttribute("popuponly", "true"); + menulist.setAttribute("hidden", "true"); + + let popup = menulist.appendChild(document.createXULElement("menupopup")); + popup.setAttribute("id", "ContentSelectDropdownPopup"); + popup.setAttribute("activateontab", "true"); + popup.setAttribute("position", "after_start"); + popup.setAttribute("level", "parent"); + if (AppConstants.platform == "win") { + popup.setAttribute("consumeoutsideclicks", "false"); + popup.setAttribute("ignorekeys", "shortcuts"); + } + + let container = + document.getElementById("mainPopupSet") || + document.querySelector("popupset") || + document.documentElement.appendChild( + document.createXULElement("popupset") + ); + + container.appendChild(menulist); + return menulist; + } + + receiveMessage(message) { + switch (message.name) { + case "Forms:ShowDropDown": { + let menulist = this._menulist || this._createMenulist(); + + let data = message.data; + + SelectParentHelper.populate( + menulist, + data.options.options, + data.options.uniqueStyles, + data.selectedIndex, + // We only want to apply the full zoom. The text zoom is already + // applied in the font-size. + this.browsingContext.fullZoom, + data.custom && lazy.CUSTOM_STYLING_ENABLED, + data.isDarkBackground, + data.defaultStyle, + data.style + ); + SelectParentHelper.open( + this.relevantBrowser, + menulist, + data.rect, + data.isOpenedViaTouch, + this + ); + break; + } + + case "Forms:HideDropDown": { + SelectParentHelper.hide(this._menulist, this.relevantBrowser); + break; + } + + default: + SelectParentHelper.receiveMessage(this.relevantBrowser, message); + } + } +} diff --git a/toolkit/actors/TestProcessActorChild.jsm b/toolkit/actors/TestProcessActorChild.jsm new file mode 100644 index 0000000000..20b7382624 --- /dev/null +++ b/toolkit/actors/TestProcessActorChild.jsm @@ -0,0 +1,59 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +var EXPORTED_SYMBOLS = ["TestProcessActorChild"]; + +class TestProcessActorChild extends JSProcessActorChild { + constructor() { + super(); + this.sawActorCreated = false; + } + + actorCreated() { + this.sawActorCreated = true; + } + + receiveMessage(aMessage) { + switch (aMessage.name) { + case "toChild": + aMessage.data.toChild = true; + this.sendAsyncMessage("toParent", aMessage.data); + break; + case "asyncAdd": + let { a, b } = aMessage.data; + return new Promise(resolve => { + resolve({ result: a + b }); + }); + case "error": + return Promise.reject(new SyntaxError(aMessage.data.message)); + case "exception": + return Promise.reject( + Components.Exception(aMessage.data.message, aMessage.data.result) + ); + case "done": + this.done(aMessage.data); + break; + } + + return undefined; + } + + observe(subject, topic, data) { + this.lastObserved = { subject, topic, data }; + } + + show() { + return "TestProcessActorChild"; + } + + didDestroy() { + Services.obs.notifyObservers( + this, + "test-js-content-actor-diddestroy", + true + ); + } +} diff --git a/toolkit/actors/TestProcessActorChild.sys.mjs b/toolkit/actors/TestProcessActorChild.sys.mjs new file mode 100644 index 0000000000..b9631ff9d9 --- /dev/null +++ b/toolkit/actors/TestProcessActorChild.sys.mjs @@ -0,0 +1,56 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class TestProcessActorChild extends JSProcessActorChild { + constructor() { + super(); + this.sawActorCreated = false; + } + + actorCreated() { + this.sawActorCreated = true; + } + + receiveMessage(aMessage) { + switch (aMessage.name) { + case "toChild": + aMessage.data.toChild = true; + this.sendAsyncMessage("toParent", aMessage.data); + break; + case "asyncAdd": + let { a, b } = aMessage.data; + return new Promise(resolve => { + resolve({ result: a + b }); + }); + case "error": + return Promise.reject(new SyntaxError(aMessage.data.message)); + case "exception": + return Promise.reject( + Components.Exception(aMessage.data.message, aMessage.data.result) + ); + case "done": + this.done(aMessage.data); + break; + } + + return undefined; + } + + observe(subject, topic, data) { + this.lastObserved = { subject, topic, data }; + } + + show() { + return "TestProcessActorChild"; + } + + didDestroy() { + Services.obs.notifyObservers( + this, + "test-js-content-actor-diddestroy", + true + ); + } +} diff --git a/toolkit/actors/TestProcessActorParent.jsm b/toolkit/actors/TestProcessActorParent.jsm new file mode 100644 index 0000000000..dfa1fc1df0 --- /dev/null +++ b/toolkit/actors/TestProcessActorParent.jsm @@ -0,0 +1,41 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +var EXPORTED_SYMBOLS = ["TestProcessActorParent"]; + +class TestProcessActorParent extends JSProcessActorParent { + constructor() { + super(); + this.wrappedJSObject = this; + this.sawActorCreated = false; + } + + actorCreated() { + this.sawActorCreated = true; + } + + receiveMessage(aMessage) { + switch (aMessage.name) { + case "init": + aMessage.data.initial = true; + this.sendAsyncMessage("toChild", aMessage.data); + break; + case "toParent": + aMessage.data.toParent = true; + this.sendAsyncMessage("done", aMessage.data); + break; + case "asyncMul": + let { a, b } = aMessage.data; + return { result: a * b }; + } + + return undefined; + } + + show() { + return "TestProcessActorParent"; + } +} diff --git a/toolkit/actors/TestProcessActorParent.sys.mjs b/toolkit/actors/TestProcessActorParent.sys.mjs new file mode 100644 index 0000000000..c86bd8ad84 --- /dev/null +++ b/toolkit/actors/TestProcessActorParent.sys.mjs @@ -0,0 +1,38 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class TestProcessActorParent extends JSProcessActorParent { + constructor() { + super(); + this.wrappedJSObject = this; + this.sawActorCreated = false; + } + + actorCreated() { + this.sawActorCreated = true; + } + + receiveMessage(aMessage) { + switch (aMessage.name) { + case "init": + aMessage.data.initial = true; + this.sendAsyncMessage("toChild", aMessage.data); + break; + case "toParent": + aMessage.data.toParent = true; + this.sendAsyncMessage("done", aMessage.data); + break; + case "asyncMul": + let { a, b } = aMessage.data; + return { result: a * b }; + } + + return undefined; + } + + show() { + return "TestProcessActorParent"; + } +} diff --git a/toolkit/actors/TestWindowChild.jsm b/toolkit/actors/TestWindowChild.jsm new file mode 100644 index 0000000000..127c03fa0e --- /dev/null +++ b/toolkit/actors/TestWindowChild.jsm @@ -0,0 +1,102 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +var EXPORTED_SYMBOLS = ["TestWindowChild"]; + +var docShellThunks = new Map(); + +class TestWindowChild extends JSWindowActorChild { + constructor() { + super(); + this.sawActorCreated = false; + + try { + void this.contentWindow; + } catch (e) { + this.uninitializedGetterError = e; + } + } + + actorCreated() { + this.sawActorCreated = true; + } + + receiveMessage(aMessage) { + switch (aMessage.name) { + case "toChild": + aMessage.data.toChild = true; + this.sendAsyncMessage("toParent", aMessage.data); + break; + case "asyncAdd": + let { a, b } = aMessage.data; + return new Promise(resolve => { + resolve({ result: a + b }); + }); + case "error": + return Promise.reject(new SyntaxError(aMessage.data.message)); + case "exception": + return Promise.reject( + Components.Exception(aMessage.data.message, aMessage.data.result) + ); + case "done": + this.done(aMessage.data); + break; + case "noncloneReply": + // Return a value which is non-cloneable, like a WindowProxy. + return this.contentWindow; + case "storeActor": + docShellThunks.set(this.docShell, this); + break; + case "checkActor": { + let actor = docShellThunks.get(this.docShell); + docShellThunks.delete(this.docShell); + + let contentWindow; + let error; + try { + contentWindow = actor.contentWindow; + } catch (e) { + error = e; + } + if (error) { + return { + status: "error", + errorType: error.name, + }; + } + return { + status: "success", + valueIsNull: contentWindow === null, + }; + } + } + + return undefined; + } + + handleEvent(aEvent) { + this.sendAsyncMessage("event", { type: aEvent.type }); + } + + observe(subject, topic, data) { + switch (topic) { + case "audio-playback": + this.done({ subject, topic, data }); + break; + default: + this.lastObserved = { subject, topic, data }; + break; + } + } + + show() { + return "TestWindowChild"; + } + + didDestroy() { + Services.obs.notifyObservers(this, "test-js-window-actor-diddestroy", true); + } +} diff --git a/toolkit/actors/TestWindowChild.sys.mjs b/toolkit/actors/TestWindowChild.sys.mjs new file mode 100644 index 0000000000..5df64c932c --- /dev/null +++ b/toolkit/actors/TestWindowChild.sys.mjs @@ -0,0 +1,99 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +var docShellThunks = new Map(); + +export class TestWindowChild extends JSWindowActorChild { + constructor() { + super(); + this.sawActorCreated = false; + + try { + void this.contentWindow; + } catch (e) { + this.uninitializedGetterError = e; + } + } + + actorCreated() { + this.sawActorCreated = true; + } + + receiveMessage(aMessage) { + switch (aMessage.name) { + case "toChild": + aMessage.data.toChild = true; + this.sendAsyncMessage("toParent", aMessage.data); + break; + case "asyncAdd": + let { a, b } = aMessage.data; + return new Promise(resolve => { + resolve({ result: a + b }); + }); + case "error": + return Promise.reject(new SyntaxError(aMessage.data.message)); + case "exception": + return Promise.reject( + Components.Exception(aMessage.data.message, aMessage.data.result) + ); + case "done": + this.done(aMessage.data); + break; + case "noncloneReply": + // Return a value which is non-cloneable, like a WindowProxy. + return this.contentWindow; + case "storeActor": + docShellThunks.set(this.docShell, this); + break; + case "checkActor": { + let actor = docShellThunks.get(this.docShell); + docShellThunks.delete(this.docShell); + + let contentWindow; + let error; + try { + contentWindow = actor.contentWindow; + } catch (e) { + error = e; + } + if (error) { + return { + status: "error", + errorType: error.name, + }; + } + return { + status: "success", + valueIsNull: contentWindow === null, + }; + } + } + + return undefined; + } + + handleEvent(aEvent) { + this.sendAsyncMessage("event", { type: aEvent.type }); + } + + observe(subject, topic, data) { + switch (topic) { + case "audio-playback": + this.done({ subject, topic, data }); + break; + default: + this.lastObserved = { subject, topic, data }; + break; + } + } + + show() { + return "TestWindowChild"; + } + + didDestroy() { + Services.obs.notifyObservers(this, "test-js-window-actor-diddestroy", true); + } +} diff --git a/toolkit/actors/TestWindowParent.jsm b/toolkit/actors/TestWindowParent.jsm new file mode 100644 index 0000000000..5c368d3321 --- /dev/null +++ b/toolkit/actors/TestWindowParent.jsm @@ -0,0 +1,49 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +"use strict"; + +var EXPORTED_SYMBOLS = ["TestWindowParent"]; + +class TestWindowParent extends JSWindowActorParent { + constructor() { + super(); + this.wrappedJSObject = this; + this.sawActorCreated = false; + } + + actorCreated() { + this.sawActorCreated = true; + } + + receiveMessage(aMessage) { + switch (aMessage.name) { + case "init": + aMessage.data.initial = true; + this.sendAsyncMessage("toChild", aMessage.data); + break; + case "toParent": + aMessage.data.toParent = true; + this.sendAsyncMessage("done", aMessage.data); + break; + case "asyncMul": + let { a, b } = aMessage.data; + return { result: a * b }; + + case "event": + Services.obs.notifyObservers( + this, + "test-js-window-actor-parent-event", + aMessage.data.type + ); + break; + } + + return undefined; + } + + show() { + return "TestWindowParent"; + } +} diff --git a/toolkit/actors/TestWindowParent.sys.mjs b/toolkit/actors/TestWindowParent.sys.mjs new file mode 100644 index 0000000000..d7d0c2b547 --- /dev/null +++ b/toolkit/actors/TestWindowParent.sys.mjs @@ -0,0 +1,46 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class TestWindowParent extends JSWindowActorParent { + constructor() { + super(); + this.wrappedJSObject = this; + this.sawActorCreated = false; + } + + actorCreated() { + this.sawActorCreated = true; + } + + receiveMessage(aMessage) { + switch (aMessage.name) { + case "init": + aMessage.data.initial = true; + this.sendAsyncMessage("toChild", aMessage.data); + break; + case "toParent": + aMessage.data.toParent = true; + this.sendAsyncMessage("done", aMessage.data); + break; + case "asyncMul": + let { a, b } = aMessage.data; + return { result: a * b }; + + case "event": + Services.obs.notifyObservers( + this, + "test-js-window-actor-parent-event", + aMessage.data.type + ); + break; + } + + return undefined; + } + + show() { + return "TestWindowParent"; + } +} diff --git a/toolkit/actors/ThumbnailsChild.sys.mjs b/toolkit/actors/ThumbnailsChild.sys.mjs new file mode 100644 index 0000000000..9ab6fc3b08 --- /dev/null +++ b/toolkit/actors/ThumbnailsChild.sys.mjs @@ -0,0 +1,60 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + PageThumbUtils: "resource://gre/modules/PageThumbUtils.sys.mjs", +}); + +export class ThumbnailsChild extends JSWindowActorChild { + receiveMessage(message) { + switch (message.name) { + case "Browser:Thumbnail:ContentInfo": { + let [width, height] = lazy.PageThumbUtils.getContentSize( + this.contentWindow + ); + return { width, height }; + } + case "Browser:Thumbnail:CheckState": { + /** + * Remote isSafeForCapture request handler for PageThumbs. + */ + return new Promise(resolve => + Services.tm.idleDispatchToMainThread(() => { + if (!this.manager) { + // If we have no manager, our actor has been destroyed, which + // means we can't respond, and trying to touch + // `this.contentWindow` or `this.browsingContext` will throw. + // The `sendQuery` call in the parent will already have been + // rejected when the actor was destroyed, so there's no need to + // reject our promise or log an additional error. + return; + } + + let result = lazy.PageThumbUtils.shouldStoreContentThumbnail( + this.contentWindow, + this.browsingContext.docShell + ); + resolve(result); + }) + ); + } + case "Browser:Thumbnail:GetOriginalURL": { + /** + * Remote GetOriginalURL request handler for PageThumbs. + */ + let channel = this.browsingContext.docShell.currentDocumentChannel; + let channelError = lazy.PageThumbUtils.isChannelErrorResponse(channel); + let originalURL; + try { + originalURL = channel.originalURI.spec; + } catch (ex) {} + return { channelError, originalURL }; + } + } + return undefined; + } +} diff --git a/toolkit/actors/UAWidgetsChild.sys.mjs b/toolkit/actors/UAWidgetsChild.sys.mjs new file mode 100644 index 0000000000..6f4244ffe9 --- /dev/null +++ b/toolkit/actors/UAWidgetsChild.sys.mjs @@ -0,0 +1,236 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class UAWidgetsChild extends JSWindowActorChild { + constructor() { + super(); + + this.widgets = new WeakMap(); + this.prefsCache = new Map(); + this.observedPrefs = []; + + // Bug 1570744 - JSWindowActorChild's cannot be used as nsIObserver's + // directly, so we create a new function here instead to act as our + // nsIObserver, which forwards the notification to the observe method. + this.observerFunction = (subject, topic, data) => { + this.observe(subject, topic, data); + }; + } + + didDestroy() { + for (let pref in this.observedPrefs) { + Services.prefs.removeObserver(pref, this.observerFunction); + } + } + + unwrap(obj) { + return Cu.isXrayWrapper(obj) ? obj.wrappedJSObject : obj; + } + + handleEvent(aEvent) { + switch (aEvent.type) { + case "UAWidgetSetupOrChange": + this.setupOrNotifyWidget(aEvent.target); + break; + case "UAWidgetTeardown": + this.teardownWidget(aEvent.target); + break; + } + } + + setupOrNotifyWidget(aElement) { + if (!this.widgets.has(aElement)) { + this.setupWidget(aElement); + return; + } + + let { widget } = this.widgets.get(aElement); + + if (typeof widget.onchange == "function") { + if ( + this.unwrap(aElement.openOrClosedShadowRoot) != + this.unwrap(widget.shadowRoot) + ) { + console.error( + "Getting a UAWidgetSetupOrChange event without the ShadowRoot. " + + "Torn down already?" + ); + return; + } + try { + widget.onchange(); + } catch (ex) { + console.error(ex); + } + } + } + + setupWidget(aElement) { + let uri; + let widgetName; + // Use prefKeys to optionally send a list of preferences to forward to + // the UAWidget. The UAWidget will receive those preferences as key-value + // pairs as the second argument to its constructor. Updates to those prefs + // can be observed by implementing an optional onPrefChange method for the + // UAWidget that receives the changed pref name as the first argument, and + // the updated value as the second. + let prefKeys = []; + switch (aElement.localName) { + case "video": + case "audio": + uri = "chrome://global/content/elements/videocontrols.js"; + widgetName = "VideoControlsWidget"; + prefKeys = [ + "media.videocontrols.picture-in-picture.enabled", + "media.videocontrols.picture-in-picture.video-toggle.enabled", + "media.videocontrols.picture-in-picture.video-toggle.always-show", + "media.videocontrols.picture-in-picture.video-toggle.min-video-secs", + "media.videocontrols.picture-in-picture.video-toggle.position", + "media.videocontrols.picture-in-picture.video-toggle.has-used", + "media.videocontrols.keyboard-tab-to-all-controls", + "media.videocontrols.picture-in-picture.respect-disablePictureInPicture", + ]; + break; + case "input": + uri = "chrome://global/content/elements/datetimebox.js"; + widgetName = "DateTimeBoxWidget"; + break; + case "marquee": + uri = "chrome://global/content/elements/marquee.js"; + widgetName = "MarqueeWidget"; + break; + case "img": + uri = "chrome://global/content/elements/textrecognition.js"; + widgetName = "TextRecognitionWidget"; + } + + if (!uri || !widgetName) { + console.error( + "Getting a UAWidgetSetupOrChange event on undefined element." + ); + return; + } + + let shadowRoot = aElement.openOrClosedShadowRoot; + if (!shadowRoot) { + console.error( + "Getting a UAWidgetSetupOrChange event without the Shadow Root. " + + "Torn down already?" + ); + return; + } + + let isSystemPrincipal = aElement.nodePrincipal.isSystemPrincipal; + let sandbox = isSystemPrincipal + ? Object.create(null) + : Cu.getUAWidgetScope(aElement.nodePrincipal); + + if (!sandbox[widgetName]) { + Services.scriptloader.loadSubScript(uri, sandbox); + } + + let prefs = Cu.cloneInto( + this.getPrefsForUAWidget(widgetName, prefKeys), + sandbox + ); + + let widget = new sandbox[widgetName](shadowRoot, prefs); + if (!isSystemPrincipal) { + widget = widget.wrappedJSObject; + } + if (this.unwrap(widget.shadowRoot) != this.unwrap(shadowRoot)) { + console.error("Widgets should expose their shadow root."); + } + this.widgets.set(aElement, { widget, widgetName }); + try { + widget.onsetup(); + } catch (ex) { + console.error(ex); + } + } + + teardownWidget(aElement) { + if (!this.widgets.has(aElement)) { + return; + } + let { widget } = this.widgets.get(aElement); + if (typeof widget.teardown == "function") { + try { + widget.teardown(); + } catch (ex) { + console.error(ex); + } + } + this.widgets.delete(aElement); + } + + getPrefsForUAWidget(aWidgetName, aPrefKeys) { + let result = this.prefsCache.get(aWidgetName); + if (result) { + return result; + } + + result = {}; + for (let key of aPrefKeys) { + result[key] = this.getPref(key); + this.observePref(key); + } + + this.prefsCache.set(aWidgetName, result); + return result; + } + + observePref(prefKey) { + Services.prefs.addObserver(prefKey, this.observerFunction); + this.observedPrefs.push(prefKey); + } + + getPref(prefKey) { + switch (Services.prefs.getPrefType(prefKey)) { + case Ci.nsIPrefBranch.PREF_BOOL: { + return Services.prefs.getBoolPref(prefKey); + } + case Ci.nsIPrefBranch.PREF_INT: { + return Services.prefs.getIntPref(prefKey); + } + case Ci.nsIPrefBranch.PREF_STRING: { + return Services.prefs.getStringPref(prefKey); + } + } + + return undefined; + } + + observe(subject, topic, data) { + if (topic == "nsPref:changed") { + for (let [widgetName, prefCache] of this.prefsCache) { + if (prefCache.hasOwnProperty(data)) { + let newValue = this.getPref(data); + prefCache[data] = newValue; + + this.notifyWidgetsOnPrefChange(widgetName, data, newValue); + } + } + } + } + + notifyWidgetsOnPrefChange(nameOfWidgetToNotify, prefKey, newValue) { + let elements = ChromeUtils.nondeterministicGetWeakMapKeys(this.widgets); + for (let element of elements) { + if (!Cu.isDeadWrapper(element) && element.isConnected) { + let { widgetName, widget } = this.widgets.get(element); + if (widgetName == nameOfWidgetToNotify) { + if (typeof widget.onPrefChange == "function") { + try { + widget.onPrefChange(prefKey, newValue); + } catch (ex) { + console.error(ex); + } + } + } + } + } + } +} diff --git a/toolkit/actors/UnselectedTabHoverChild.sys.mjs b/toolkit/actors/UnselectedTabHoverChild.sys.mjs new file mode 100644 index 0000000000..1cf1ddb9fd --- /dev/null +++ b/toolkit/actors/UnselectedTabHoverChild.sys.mjs @@ -0,0 +1,20 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class UnselectedTabHoverChild extends JSWindowActorChild { + receiveMessage(message) { + Services.obs.notifyObservers( + this.contentWindow, + "unselected-tab-hover", + message.data.hovered + ); + } + + handleEvent(event) { + this.sendAsyncMessage("UnselectedTabHover:Toggle", { + enable: event.type == "UnselectedTabHover:Enable", + }); + } +} diff --git a/toolkit/actors/UnselectedTabHoverParent.sys.mjs b/toolkit/actors/UnselectedTabHoverParent.sys.mjs new file mode 100644 index 0000000000..797cbd8af2 --- /dev/null +++ b/toolkit/actors/UnselectedTabHoverParent.sys.mjs @@ -0,0 +1,15 @@ +/* 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +export class UnselectedTabHoverParent extends JSWindowActorParent { + receiveMessage(message) { + const topBrowsingContext = this.manager.browsingContext.top; + const browser = topBrowsingContext.embedderElement; + if (!browser) { + return; + } + browser.shouldHandleUnselectedTabHover = message.data.enable; + } +} diff --git a/toolkit/actors/ViewSourceChild.sys.mjs b/toolkit/actors/ViewSourceChild.sys.mjs new file mode 100644 index 0000000000..4c573865b7 --- /dev/null +++ b/toolkit/actors/ViewSourceChild.sys.mjs @@ -0,0 +1,346 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + ViewSourcePageChild: "resource://gre/actors/ViewSourcePageChild.sys.mjs", +}); + +export class ViewSourceChild extends JSWindowActorChild { + receiveMessage(message) { + let data = message.data; + switch (message.name) { + case "ViewSource:LoadSource": + this.viewSource(data.URL, data.outerWindowID, data.lineNumber); + break; + case "ViewSource:LoadSourceWithSelection": + this.viewSourceWithSelection( + data.URL, + data.drawSelection, + data.baseURI + ); + break; + case "ViewSource:GetSelection": + let selectionDetails; + try { + selectionDetails = this.getSelection(this.document.ownerGlobal); + } catch (e) {} + return selectionDetails; + } + + return undefined; + } + + /** + * Called when the parent sends a message to view some source code. + * + * @param URL (required) + * The URL string of the source to be shown. + * @param outerWindowID (optional) + * The outerWindowID of the content window that has hosted + * the document, in case we want to retrieve it from the network + * cache. + * @param lineNumber (optional) + * The line number to focus as soon as the source has finished + * loading. + */ + viewSource(URL, outerWindowID, lineNumber) { + let otherDocShell; + let forceEncodingDetection = false; + + if (outerWindowID) { + let contentWindow = Services.wm.getOuterWindowWithId(outerWindowID); + if (contentWindow) { + otherDocShell = contentWindow.docShell; + + forceEncodingDetection = contentWindow.windowUtils.docCharsetIsForced; + } + } + + this.loadSource(URL, otherDocShell, lineNumber, forceEncodingDetection); + } + + /** + * Loads a view source selection showing the given view-source url and + * highlight the selection. + * + * @param uri view-source uri to show + * @param drawSelection true to highlight the selection + * @param baseURI base URI of the original document + */ + viewSourceWithSelection(uri, drawSelection, baseURI) { + // This isn't ideal, but set a global in the view source page actor + // that indicates that a selection should be drawn. It will be read + // when by the page's pageshow listener. This should work as the + // view source page is always loaded in the same process. + lazy.ViewSourcePageChild.setNeedsDrawSelection(drawSelection); + + // all our content is held by the data:URI and URIs are internally stored as utf-8 (see nsIURI.idl) + let loadFlags = Ci.nsIWebNavigation.LOAD_FLAGS_NONE; + let webNav = this.docShell.QueryInterface(Ci.nsIWebNavigation); + let loadURIOptions = { + triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(), + loadFlags, + baseURI: Services.io.newURI(baseURI), + }; + webNav.fixupAndLoadURIString(uri, loadURIOptions); + } + + /** + * Common utility function used by both the current and deprecated APIs + * for loading source. + * + * @param URL (required) + * The URL string of the source to be shown. + * @param otherDocShell (optional) + * The docshell of the content window that is hosting the document. + * @param lineNumber (optional) + * The line number to focus as soon as the source has finished + * loading. + * @param forceEncodingDetection (optional) + * Force autodetection of the character encoding. + */ + loadSource(URL, otherDocShell, lineNumber, forceEncodingDetection) { + const viewSrcURL = "view-source:" + URL; + + if (forceEncodingDetection) { + this.docShell.forceEncodingDetection(); + } + + if (lineNumber) { + lazy.ViewSourcePageChild.setInitialLineNumber(lineNumber); + } + + if (!otherDocShell) { + this.loadSourceFromURL(viewSrcURL); + return; + } + + try { + let pageLoader = this.docShell.QueryInterface(Ci.nsIWebPageDescriptor); + pageLoader.loadPageAsViewSource(otherDocShell, viewSrcURL); + } catch (e) { + // We were not able to load the source from the network cache. + this.loadSourceFromURL(viewSrcURL); + } + } + + /** + * Load some URL in the browser. + * + * @param URL + * The URL string to load. + */ + loadSourceFromURL(URL) { + let loadFlags = Ci.nsIWebNavigation.LOAD_FLAGS_NONE; + let webNav = this.docShell.QueryInterface(Ci.nsIWebNavigation); + let loadURIOptions = { + triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(), + loadFlags, + }; + webNav.fixupAndLoadURIString(URL, loadURIOptions); + } + + /** + * A helper to get a path like FIXptr, but with an array instead of the + * "tumbler" notation. + * See FIXptr: http://lists.w3.org/Archives/Public/www-xml-linking-comments/2001AprJun/att-0074/01-NOTE-FIXptr-20010425.htm + */ + getPath(ancestor, node) { + var n = node; + var p = n.parentNode; + if (n == ancestor || !p) { + return null; + } + var path = []; + if (!path) { + return null; + } + do { + for (var i = 0; i < p.childNodes.length; i++) { + if (p.childNodes.item(i) == n) { + path.push(i); + break; + } + } + n = p; + p = n.parentNode; + } while (n != ancestor && p); + return path; + } + + getSelection(global) { + const { content } = global; + + // These are markers used to delimit the selection during processing. They + // are removed from the final rendering. + // We use noncharacter Unicode codepoints to minimize the risk of clashing + // with anything that might legitimately be present in the document. + // U+FDD0..FDEF <noncharacters> + const MARK_SELECTION_START = "\uFDD0"; + const MARK_SELECTION_END = "\uFDEF"; + + var focusedWindow = Services.focus.focusedWindow || content; + var selection = focusedWindow.getSelection(); + + var range = selection.getRangeAt(0); + var ancestorContainer = range.commonAncestorContainer; + var doc = ancestorContainer.ownerDocument; + + var startContainer = range.startContainer; + var endContainer = range.endContainer; + var startOffset = range.startOffset; + var endOffset = range.endOffset; + + // let the ancestor be an element + var Node = doc.defaultView.Node; + if ( + ancestorContainer.nodeType == Node.TEXT_NODE || + ancestorContainer.nodeType == Node.CDATA_SECTION_NODE + ) { + ancestorContainer = ancestorContainer.parentNode; + } + + // for selectAll, let's use the entire document, including <html>...</html> + // @see nsDocumentViewer::SelectAll() for how selectAll is implemented + try { + if (ancestorContainer == doc.body) { + ancestorContainer = doc.documentElement; + } + } catch (e) {} + + // each path is a "child sequence" (a.k.a. "tumbler") that + // descends from the ancestor down to the boundary point + var startPath = this.getPath(ancestorContainer, startContainer); + var endPath = this.getPath(ancestorContainer, endContainer); + + // clone the fragment of interest and reset everything to be relative to it + // note: it is with the clone that we operate/munge from now on. Also note + // that we clone into a data document to prevent images in the fragment from + // loading and the like. The use of importNode here, as opposed to adoptNode, + // is _very_ important. + // XXXbz wish there were a less hacky way to create an untrusted document here + var isHTML = doc.createElement("div").tagName == "DIV"; + var dataDoc = isHTML + ? ancestorContainer.ownerDocument.implementation.createHTMLDocument("") + : ancestorContainer.ownerDocument.implementation.createDocument( + "", + "", + null + ); + ancestorContainer = dataDoc.importNode(ancestorContainer, true); + startContainer = ancestorContainer; + endContainer = ancestorContainer; + + // Only bother with the selection if it can be remapped. Don't mess with + // leaf elements (such as <isindex>) that secretly use anynomous content + // for their display appearance. + var canDrawSelection = ancestorContainer.hasChildNodes(); + var tmpNode; + if (canDrawSelection) { + var i; + for (i = startPath ? startPath.length - 1 : -1; i >= 0; i--) { + startContainer = startContainer.childNodes.item(startPath[i]); + } + for (i = endPath ? endPath.length - 1 : -1; i >= 0; i--) { + endContainer = endContainer.childNodes.item(endPath[i]); + } + + // add special markers to record the extent of the selection + // note: |startOffset| and |endOffset| are interpreted either as + // offsets in the text data or as child indices (see the Range spec) + // (here, munging the end point first to keep the start point safe...) + if ( + endContainer.nodeType == Node.TEXT_NODE || + endContainer.nodeType == Node.CDATA_SECTION_NODE + ) { + // do some extra tweaks to try to avoid the view-source output to look like + // ...<tag>]... or ...]</tag>... (where ']' marks the end of the selection). + // To get a neat output, the idea here is to remap the end point from: + // 1. ...<tag>]... to ...]<tag>... + // 2. ...]</tag>... to ...</tag>]... + if ( + (endOffset > 0 && endOffset < endContainer.data.length) || + !endContainer.parentNode || + !endContainer.parentNode.parentNode + ) { + endContainer.insertData(endOffset, MARK_SELECTION_END); + } else { + tmpNode = dataDoc.createTextNode(MARK_SELECTION_END); + endContainer = endContainer.parentNode; + if (endOffset === 0) { + endContainer.parentNode.insertBefore(tmpNode, endContainer); + } else { + endContainer.parentNode.insertBefore( + tmpNode, + endContainer.nextSibling + ); + } + } + } else { + tmpNode = dataDoc.createTextNode(MARK_SELECTION_END); + endContainer.insertBefore( + tmpNode, + endContainer.childNodes.item(endOffset) + ); + } + + if ( + startContainer.nodeType == Node.TEXT_NODE || + startContainer.nodeType == Node.CDATA_SECTION_NODE + ) { + // do some extra tweaks to try to avoid the view-source output to look like + // ...<tag>[... or ...[</tag>... (where '[' marks the start of the selection). + // To get a neat output, the idea here is to remap the start point from: + // 1. ...<tag>[... to ...[<tag>... + // 2. ...[</tag>... to ...</tag>[... + if ( + (startOffset > 0 && startOffset < startContainer.data.length) || + !startContainer.parentNode || + !startContainer.parentNode.parentNode || + startContainer != startContainer.parentNode.lastChild + ) { + startContainer.insertData(startOffset, MARK_SELECTION_START); + } else { + tmpNode = dataDoc.createTextNode(MARK_SELECTION_START); + startContainer = startContainer.parentNode; + if (startOffset === 0) { + startContainer.parentNode.insertBefore(tmpNode, startContainer); + } else { + startContainer.parentNode.insertBefore( + tmpNode, + startContainer.nextSibling + ); + } + } + } else { + tmpNode = dataDoc.createTextNode(MARK_SELECTION_START); + startContainer.insertBefore( + tmpNode, + startContainer.childNodes.item(startOffset) + ); + } + } + + // now extract and display the syntax highlighted source + tmpNode = dataDoc.createElementNS("http://www.w3.org/1999/xhtml", "div"); + tmpNode.appendChild(ancestorContainer); + + return { + URL: + (isHTML + ? "view-source:data:text/html;charset=utf-8," + : "view-source:data:application/xml;charset=utf-8,") + + encodeURIComponent(tmpNode.innerHTML), + drawSelection: canDrawSelection, + baseURI: doc.baseURI, + }; + } + + get wrapLongLines() { + return Services.prefs.getBoolPref("view_source.wrap_long_lines"); + } +} diff --git a/toolkit/actors/ViewSourcePageChild.sys.mjs b/toolkit/actors/ViewSourcePageChild.sys.mjs new file mode 100644 index 0000000000..2f5c53cc2e --- /dev/null +++ b/toolkit/actors/ViewSourcePageChild.sys.mjs @@ -0,0 +1,474 @@ +/* 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/. */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const BUNDLE_URL = "chrome://global/locale/viewSource.properties"; + +// These are markers used to delimit the selection during processing. They +// are removed from the final rendering. +// We use noncharacter Unicode codepoints to minimize the risk of clashing +// with anything that might legitimately be present in the document. +// U+FDD0..FDEF <noncharacters> +const MARK_SELECTION_START = "\uFDD0"; +const MARK_SELECTION_END = "\uFDEF"; + +/** + * When showing selection source, chrome will construct a page fragment to + * show, and then instruct content to draw a selection after load. This is + * set true when there is a pending request to draw selection. + */ +let gNeedsDrawSelection = false; + +/** + * Start at a specific line number. + */ +let gInitialLineNumber = -1; + +export class ViewSourcePageChild extends JSWindowActorChild { + constructor() { + super(); + + XPCOMUtils.defineLazyGetter(this, "bundle", function () { + return Services.strings.createBundle(BUNDLE_URL); + }); + } + + static setNeedsDrawSelection(value) { + gNeedsDrawSelection = value; + } + + static setInitialLineNumber(value) { + gInitialLineNumber = value; + } + + receiveMessage(msg) { + switch (msg.name) { + case "ViewSource:GoToLine": + this.goToLine(msg.data.lineNumber); + break; + case "ViewSource:IsWrapping": + return this.isWrapping; + case "ViewSource:IsSyntaxHighlighting": + return this.isSyntaxHighlighting; + case "ViewSource:ToggleWrapping": + this.toggleWrapping(); + break; + case "ViewSource:ToggleSyntaxHighlighting": + this.toggleSyntaxHighlighting(); + break; + } + return undefined; + } + + /** + * Any events should get handled here, and should get dispatched to + * a specific function for the event type. + */ + handleEvent(event) { + switch (event.type) { + case "pageshow": + this.onPageShow(event); + break; + case "click": + this.onClick(event); + break; + } + } + + /** + * A shortcut to the nsISelectionController for the content. + */ + get selectionController() { + return this.docShell + .QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsISelectionDisplay) + .QueryInterface(Ci.nsISelectionController); + } + + /** + * A shortcut to the nsIWebBrowserFind for the content. + */ + get webBrowserFind() { + return this.docShell + .QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIWebBrowserFind); + } + + /** + * This handler is for click events from: + * * error page content, which can show up if the user attempts to view the + * source of an attack page. + */ + onClick(event) { + let target = event.originalTarget; + + // Don't trust synthetic events + if (!event.isTrusted || event.target.localName != "button") { + return; + } + + let errorDoc = target.ownerDocument; + + if (/^about:blocked/.test(errorDoc.documentURI)) { + // The event came from a button on a malware/phishing block page + + if (target == errorDoc.getElementById("goBackButton")) { + // Instead of loading some safe page, just close the window + this.sendAsyncMessage("ViewSource:Close"); + } + } + } + + /** + * Handler for the pageshow event. + * + * @param event + * The pageshow event being handled. + */ + onPageShow(event) { + // If we need to draw the selection, wait until an actual view source page + // has loaded, instead of about:blank. + if ( + gNeedsDrawSelection && + this.document.documentURI.startsWith("view-source:") + ) { + gNeedsDrawSelection = false; + this.drawSelection(); + } + + if (gInitialLineNumber >= 0) { + this.goToLine(gInitialLineNumber); + gInitialLineNumber = -1; + } + } + + /** + * Attempts to go to a particular line in the source code being + * shown. If it succeeds in finding the line, it will fire a + * "ViewSource:GoToLine:Success" message, passing up an object + * with the lineNumber we just went to. If it cannot find the line, + * it will fire a "ViewSource:GoToLine:Failed" message. + * + * @param lineNumber + * The line number to attempt to go to. + */ + goToLine(lineNumber) { + let body = this.document.body; + + // The source document is made up of a number of pre elements with + // id attributes in the format <pre id="line123">, meaning that + // the first line in the pre element is number 123. + // Do binary search to find the pre element containing the line. + // However, in the plain text case, we have only one pre without an + // attribute, so assume it begins on line 1. + let pre; + for (let lbound = 0, ubound = body.childNodes.length; ; ) { + let middle = (lbound + ubound) >> 1; + pre = body.childNodes[middle]; + + let firstLine = pre.id ? parseInt(pre.id.substring(4)) : 1; + + if (lbound == ubound - 1) { + break; + } + + if (lineNumber >= firstLine) { + lbound = middle; + } else { + ubound = middle; + } + } + + let result = {}; + let found = this.findLocation(pre, lineNumber, null, -1, false, result); + + if (!found) { + this.sendAsyncMessage("ViewSource:GoToLine:Failed"); + return; + } + + let selection = this.document.defaultView.getSelection(); + selection.removeAllRanges(); + + // In our case, the range's startOffset is after "\n" on the previous line. + // Tune the selection at the beginning of the next line and do some tweaking + // to position the focusNode and the caret at the beginning of the line. + selection.interlinePosition = true; + + selection.addRange(result.range); + + if (!selection.isCollapsed) { + selection.collapseToEnd(); + + let offset = result.range.startOffset; + let node = result.range.startContainer; + if (offset < node.data.length) { + // The same text node spans across the "\n", just focus where we were. + selection.extend(node, offset); + } else { + // There is another tag just after the "\n", hook there. We need + // to focus a safe point because there are edgy cases such as + // <span>...\n</span><span>...</span> vs. + // <span>...\n<span>...</span></span><span>...</span> + node = node.nextSibling + ? node.nextSibling + : node.parentNode.nextSibling; + selection.extend(node, 0); + } + } + + let selCon = this.selectionController; + selCon.setDisplaySelection(Ci.nsISelectionController.SELECTION_ON); + selCon.setCaretVisibilityDuringSelection(true); + + // Scroll the beginning of the line into view. + selCon.scrollSelectionIntoView( + Ci.nsISelectionController.SELECTION_NORMAL, + Ci.nsISelectionController.SELECTION_FOCUS_REGION, + true + ); + + this.sendAsyncMessage("ViewSource:GoToLine:Success", { lineNumber }); + } + + /** + * Some old code from the original view source implementation. Original + * documentation follows: + * + * "Loops through the text lines in the pre element. The arguments are either + * (pre, line) or (node, offset, interlinePosition). result is an out + * argument. If (pre, line) are specified (and node == null), result.range is + * a range spanning the specified line. If the (node, offset, + * interlinePosition) are specified, result.line and result.col are the line + * and column number of the specified offset in the specified node relative to + * the whole file." + */ + findLocation(pre, lineNumber, node, offset, interlinePosition, result) { + if (node && !pre) { + // Look upwards to find the current pre element. + // eslint-disable-next-line no-empty + for (pre = node; pre.nodeName != "PRE"; pre = pre.parentNode) {} + } + + // The source document is made up of a number of pre elements with + // id attributes in the format <pre id="line123">, meaning that + // the first line in the pre element is number 123. + // However, in the plain text case, there is only one <pre> without an id, + // so assume line 1. + let curLine = pre.id ? parseInt(pre.id.substring(4)) : 1; + + // Walk through each of the text nodes and count newlines. + let treewalker = this.document.createTreeWalker( + pre, + NodeFilter.SHOW_TEXT, + null + ); + + // The column number of the first character in the current text node. + let firstCol = 1; + + let found = false; + for ( + let textNode = treewalker.firstChild(); + textNode && !found; + textNode = treewalker.nextNode() + ) { + // \r is not a valid character in the DOM, so we only check for \n. + let lineArray = textNode.data.split(/\n/); + let lastLineInNode = curLine + lineArray.length - 1; + + // Check if we can skip the text node without further inspection. + if (node ? textNode != node : lastLineInNode < lineNumber) { + if (lineArray.length > 1) { + firstCol = 1; + } + firstCol += lineArray[lineArray.length - 1].length; + curLine = lastLineInNode; + continue; + } + + // curPos is the offset within the current text node of the first + // character in the current line. + for ( + var i = 0, curPos = 0; + i < lineArray.length; + curPos += lineArray[i++].length + 1 + ) { + if (i > 0) { + curLine++; + } + + if (node) { + if (offset >= curPos && offset <= curPos + lineArray[i].length) { + // If we are right after the \n of a line and interlinePosition is + // false, the caret looks as if it were at the end of the previous + // line, so we display that line and column instead. + + if (i > 0 && offset == curPos && !interlinePosition) { + result.line = curLine - 1; + var prevPos = curPos - lineArray[i - 1].length; + result.col = (i == 1 ? firstCol : 1) + offset - prevPos; + } else { + result.line = curLine; + result.col = (i == 0 ? firstCol : 1) + offset - curPos; + } + found = true; + + break; + } + } else if (curLine == lineNumber && !("range" in result)) { + result.range = this.document.createRange(); + result.range.setStart(textNode, curPos); + + // This will always be overridden later, except when we look for + // the very last line in the file (this is the only line that does + // not end with \n). + result.range.setEndAfter(pre.lastChild); + } else if (curLine == lineNumber + 1) { + result.range.setEnd(textNode, curPos - 1); + found = true; + break; + } + } + } + + return found || "range" in result; + } + + /** + * @return {boolean} whether the "wrap" class exists on the document body. + */ + get isWrapping() { + return this.document.body.classList.contains("wrap"); + } + + /** + * @return {boolean} whether the "highlight" class exists on the document body. + */ + get isSyntaxHighlighting() { + return this.document.body.classList.contains("highlight"); + } + + /** + * Toggles the "wrap" class on the document body, which sets whether + * or not long lines are wrapped. Notifies parent to update the pref. + */ + toggleWrapping() { + let body = this.document.body; + let state = body.classList.toggle("wrap"); + this.sendAsyncMessage("ViewSource:StoreWrapping", { state }); + } + + /** + * Toggles the "highlight" class on the document body, which sets whether + * or not syntax highlighting is displayed. Notifies parent to update the + * pref. + */ + toggleSyntaxHighlighting() { + let body = this.document.body; + let state = body.classList.toggle("highlight"); + this.sendAsyncMessage("ViewSource:StoreSyntaxHighlighting", { state }); + } + + /** + * Using special markers left in the serialized source, this helper makes the + * underlying markup of the selected fragment to automatically appear as + * selected on the inflated view-source DOM. + */ + drawSelection() { + this.document.title = this.bundle.GetStringFromName( + "viewSelectionSourceTitle" + ); + + // find the special selection markers that we added earlier, and + // draw the selection between the two... + var findService = null; + try { + // get the find service which stores the global find state + findService = Cc["@mozilla.org/find/find_service;1"].getService( + Ci.nsIFindService + ); + } catch (e) {} + if (!findService) { + return; + } + + // cache the current global find state + var matchCase = findService.matchCase; + var entireWord = findService.entireWord; + var wrapFind = findService.wrapFind; + var findBackwards = findService.findBackwards; + var searchString = findService.searchString; + var replaceString = findService.replaceString; + + // setup our find instance + var findInst = this.webBrowserFind; + findInst.matchCase = true; + findInst.entireWord = false; + findInst.wrapFind = true; + findInst.findBackwards = false; + + // ...lookup the start mark + findInst.searchString = MARK_SELECTION_START; + var startLength = MARK_SELECTION_START.length; + findInst.findNext(); + + var selection = this.document.defaultView.getSelection(); + if (!selection.rangeCount) { + return; + } + + var range = selection.getRangeAt(0); + + var startContainer = range.startContainer; + var startOffset = range.startOffset; + + // ...lookup the end mark + findInst.searchString = MARK_SELECTION_END; + var endLength = MARK_SELECTION_END.length; + findInst.findNext(); + + var endContainer = selection.anchorNode; + var endOffset = selection.anchorOffset; + + // reset the selection that find has left + selection.removeAllRanges(); + + // delete the special markers now... + endContainer.deleteData(endOffset, endLength); + startContainer.deleteData(startOffset, startLength); + if (startContainer == endContainer) { + endOffset -= startLength; + } // has shrunk if on same text node... + range.setEnd(endContainer, endOffset); + + // show the selection and scroll it into view + selection.addRange(range); + // the default behavior of the selection is to scroll at the end of + // the selection, whereas in this situation, it is more user-friendly + // to scroll at the beginning. So we override the default behavior here + try { + this.selectionController.scrollSelectionIntoView( + Ci.nsISelectionController.SELECTION_NORMAL, + Ci.nsISelectionController.SELECTION_ANCHOR_REGION, + true + ); + } catch (e) {} + + // restore the current find state + findService.matchCase = matchCase; + findService.entireWord = entireWord; + findService.wrapFind = wrapFind; + findService.findBackwards = findBackwards; + findService.searchString = searchString; + findService.replaceString = replaceString; + + findInst.matchCase = matchCase; + findInst.entireWord = entireWord; + findInst.wrapFind = wrapFind; + findInst.findBackwards = findBackwards; + findInst.searchString = searchString; + } +} diff --git a/toolkit/actors/ViewSourcePageParent.sys.mjs b/toolkit/actors/ViewSourcePageParent.sys.mjs new file mode 100644 index 0000000000..cc45b248cc --- /dev/null +++ b/toolkit/actors/ViewSourcePageParent.sys.mjs @@ -0,0 +1,165 @@ +// -*- indent-tabs-mode: nil; js-indent-level: 2 -*- + +/* 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/. */ + +const BUNDLE_URL = "chrome://global/locale/viewSource.properties"; + +/** + * ViewSourcePageParent manages the view source <browser> from the chrome side. + */ +export class ViewSourcePageParent extends JSWindowActorParent { + constructor() { + super(); + + /** + * Holds the value of the last line found via the "Go to line" + * command, to pre-populate the prompt the next time it is + * opened. + */ + this.lastLineFound = null; + } + + /** + * Anything added to the messages array will get handled here, and should + * get dispatched to a specific function for the message name. + */ + receiveMessage(message) { + let data = message.data; + + switch (message.name) { + case "ViewSource:PromptAndGoToLine": + this.promptAndGoToLine(); + break; + case "ViewSource:GoToLine:Success": + this.onGoToLineSuccess(data.lineNumber); + break; + case "ViewSource:GoToLine:Failed": + this.onGoToLineFailed(); + break; + case "ViewSource:StoreWrapping": + this.storeWrapping(data.state); + break; + case "ViewSource:StoreSyntaxHighlighting": + this.storeSyntaxHighlighting(data.state); + break; + } + } + + /** + * A getter for the view source string bundle. + */ + get bundle() { + if (this._bundle) { + return this._bundle; + } + return (this._bundle = Services.strings.createBundle(BUNDLE_URL)); + } + + /** + * Opens the "Go to line" prompt for a user to hop to a particular line + * of the source code they're viewing. This will keep prompting until the + * user either cancels out of the prompt, or enters a valid line number. + */ + promptAndGoToLine() { + let input = { value: this.lastLineFound }; + let window = Services.wm.getMostRecentWindow(null); + + let ok = Services.prompt.prompt( + window, + this.bundle.GetStringFromName("goToLineTitle"), + this.bundle.GetStringFromName("goToLineText"), + input, + null, + { value: 0 } + ); + + if (!ok) { + return; + } + + let line = parseInt(input.value, 10); + + if (!(line > 0)) { + Services.prompt.alert( + window, + this.bundle.GetStringFromName("invalidInputTitle"), + this.bundle.GetStringFromName("invalidInputText") + ); + this.promptAndGoToLine(); + } else { + this.goToLine(line); + } + } + + /** + * Go to a particular line of the source code. This act is asynchronous. + * + * @param lineNumber + * The line number to try to go to to. + */ + goToLine(lineNumber) { + this.sendAsyncMessage("ViewSource:GoToLine", { lineNumber }); + } + + /** + * Called when the frame script reports that a line was successfully gotten + * to. + * + * @param lineNumber + * The line number that we successfully got to. + */ + onGoToLineSuccess(lineNumber) { + // We'll pre-populate the "Go to line" prompt with this value the next + // time it comes up. + this.lastLineFound = lineNumber; + } + + /** + * Called when the child reports that we failed to go to a particular + * line. This informs the user that their selection was likely out of range, + * and then reprompts the user to try again. + */ + onGoToLineFailed() { + let window = Services.wm.getMostRecentWindow(null); + Services.prompt.alert( + window, + this.bundle.GetStringFromName("outOfRangeTitle"), + this.bundle.GetStringFromName("outOfRangeText") + ); + this.promptAndGoToLine(); + } + + /** + * @return {boolean} the wrapping state + */ + queryIsWrapping() { + return this.sendQuery("ViewSource:IsWrapping"); + } + + /** + * @return {boolean} the syntax highlighting state + */ + queryIsSyntaxHighlighting() { + return this.sendQuery("ViewSource:IsSyntaxHighlighting"); + } + + /** + * Update the wrapping pref based on the child's current state. + * @param state + * Whether wrapping is currently enabled in the child. + */ + storeWrapping(state) { + Services.prefs.setBoolPref("view_source.wrap_long_lines", state); + } + + /** + * Update the syntax highlighting pref based on the child's current state. + * @param state + * Whether syntax highlighting is currently enabled in the child. + */ + storeSyntaxHighlighting(state) { + Services.prefs.setBoolPref("view_source.syntax_highlight", state); + } +} diff --git a/toolkit/actors/WebChannelChild.sys.mjs b/toolkit/actors/WebChannelChild.sys.mjs new file mode 100644 index 0000000000..563f2566a0 --- /dev/null +++ b/toolkit/actors/WebChannelChild.sys.mjs @@ -0,0 +1,132 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +import { ContentDOMReference } from "resource://gre/modules/ContentDOMReference.sys.mjs"; + +// Preference containing the list (space separated) of origins that are +// allowed to send non-string values through a WebChannel, mainly for +// backwards compatability. See bug 1238128 for more information. +const URL_WHITELIST_PREF = "webchannel.allowObject.urlWhitelist"; + +let _cachedWhitelist = null; + +const CACHED_PREFS = {}; +XPCOMUtils.defineLazyPreferenceGetter( + CACHED_PREFS, + "URL_WHITELIST", + URL_WHITELIST_PREF, + "", + // Null this out so we update it. + () => (_cachedWhitelist = null) +); + +export class WebChannelChild extends JSWindowActorChild { + handleEvent(event) { + if (event.type === "WebChannelMessageToChrome") { + return this._onMessageToChrome(event); + } + return undefined; + } + + receiveMessage(msg) { + if (msg.name === "WebChannelMessageToContent") { + return this._onMessageToContent(msg); + } + return undefined; + } + + _getWhitelistedPrincipals() { + if (!_cachedWhitelist) { + let urls = CACHED_PREFS.URL_WHITELIST.split(/\s+/); + _cachedWhitelist = urls.map(origin => + Services.scriptSecurityManager.createContentPrincipalFromOrigin(origin) + ); + } + return _cachedWhitelist; + } + + _onMessageToChrome(e) { + // If target is window then we want the document principal, otherwise fallback to target itself. + let principal = e.target.nodePrincipal + ? e.target.nodePrincipal + : e.target.document.nodePrincipal; + + if (e.detail) { + if (typeof e.detail != "string") { + // Check if the principal is one of the ones that's allowed to send + // non-string values for e.detail. They're whitelisted by site origin, + // so we compare on originNoSuffix in order to avoid other origin attributes + // that are not relevant here, such as containers or private browsing. + let objectsAllowed = this._getWhitelistedPrincipals().some( + whitelisted => principal.originNoSuffix == whitelisted.originNoSuffix + ); + if (!objectsAllowed) { + console.error( + "WebChannelMessageToChrome sent with an object from a non-whitelisted principal" + ); + return; + } + } + + let eventTarget = + e.target instanceof Ci.nsIDOMWindow + ? null + : ContentDOMReference.get(e.target); + this.sendAsyncMessage("WebChannelMessageToChrome", { + contentData: e.detail, + eventTarget, + principal, + }); + } else { + console.error("WebChannel message failed. No message detail."); + } + } + + _onMessageToContent(msg) { + if (msg.data && this.contentWindow) { + // msg.objects.eventTarget will be defined if sending a response to + // a WebChannelMessageToChrome event. An unsolicited send + // may not have an eventTarget defined, in this case send to the + // main content window. + let { eventTarget, principal } = msg.data; + if (!eventTarget) { + eventTarget = this.contentWindow; + } else { + eventTarget = ContentDOMReference.resolve(eventTarget); + } + if (!eventTarget) { + console.error("WebChannel message failed. No target."); + return; + } + + // Use nodePrincipal if available, otherwise fallback to document principal. + let targetPrincipal = + eventTarget instanceof Ci.nsIDOMWindow + ? eventTarget.document.nodePrincipal + : eventTarget.nodePrincipal; + + if (principal.subsumes(targetPrincipal)) { + let targetWindow = this.contentWindow; + eventTarget.dispatchEvent( + new targetWindow.CustomEvent("WebChannelMessageToContent", { + detail: Cu.cloneInto( + { + id: msg.data.id, + message: msg.data.message, + }, + targetWindow + ), + }) + ); + } else { + console.error("WebChannel message failed. Principal mismatch."); + } + } else { + console.error("WebChannel message failed. No message data."); + } + } +} diff --git a/toolkit/actors/WebChannelParent.sys.mjs b/toolkit/actors/WebChannelParent.sys.mjs new file mode 100644 index 0000000000..98b3ad093a --- /dev/null +++ b/toolkit/actors/WebChannelParent.sys.mjs @@ -0,0 +1,92 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +import { WebChannelBroker } from "resource://gre/modules/WebChannel.sys.mjs"; + +const ERRNO_MISSING_PRINCIPAL = 1; +const ERRNO_NO_SUCH_CHANNEL = 2; + +export class WebChannelParent extends JSWindowActorParent { + receiveMessage(msg) { + let data = msg.data.contentData; + let sendingContext = { + browsingContext: this.browsingContext, + browser: this.browsingContext.top.embedderElement, + eventTarget: msg.data.eventTarget, + principal: msg.data.principal, + }; + // data must be a string except for a few legacy origins allowed by browser-content.js. + if (typeof data == "string") { + try { + data = JSON.parse(data); + } catch (e) { + console.error("Failed to parse WebChannel data as a JSON object"); + return; + } + } + + if (data && data.id) { + if (!msg.data.principal) { + this._sendErrorEventToContent( + data.id, + sendingContext, + ERRNO_MISSING_PRINCIPAL, + "Message principal missing" + ); + } else { + let validChannelFound = WebChannelBroker.tryToDeliver( + data, + sendingContext + ); + + // if no valid origins send an event that there is no such valid channel + if (!validChannelFound) { + this._sendErrorEventToContent( + data.id, + sendingContext, + ERRNO_NO_SUCH_CHANNEL, + "No Such Channel" + ); + } + } + } else { + console.error("WebChannel channel id missing"); + } + } + + /** + * + * @param id {String} + * The WebChannel id to include in the message + * @param sendingContext {Object} + * Message sending context + * @param [errorMsg] {String} + * Error message + * @private + */ + _sendErrorEventToContent(id, sendingContext, errorNo, errorMsg) { + let { eventTarget, principal } = sendingContext; + + errorMsg = errorMsg || "Web Channel Parent error"; + + let { currentWindowGlobal = null } = this.browsingContext; + if (currentWindowGlobal) { + currentWindowGlobal + .getActor("WebChannel") + .sendAsyncMessage("WebChannelMessageToContent", { + id, + message: { + errno: errorNo, + error: errorMsg, + }, + eventTarget, + principal, + }); + } else { + console.error("Failed to send a WebChannel error. Target invalid."); + } + console.error(id.toString() + " error message. ", errorMsg); + } +} diff --git a/toolkit/actors/docs/picture-in-picture-child-video-wrapper-api.rst b/toolkit/actors/docs/picture-in-picture-child-video-wrapper-api.rst new file mode 100644 index 0000000000..2e33741539 --- /dev/null +++ b/toolkit/actors/docs/picture-in-picture-child-video-wrapper-api.rst @@ -0,0 +1,6 @@ +.. _picture_in_picture_child_video_wrapper_api: + +PictureInPictureChildVideoWrapper Reference +=========================================== +.. js:autoclass:: PictureInPictureChildVideoWrapper + :members: diff --git a/toolkit/actors/moz.build b/toolkit/actors/moz.build new file mode 100644 index 0000000000..a0a987a5e6 --- /dev/null +++ b/toolkit/actors/moz.build @@ -0,0 +1,85 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +with Files("**"): + BUG_COMPONENT = ("Toolkit", "General") + +with Files("AutoScroll*.jsm"): + BUG_COMPONENT = ("Core", "Panning and Zooming") + +with Files("Finder*.jsm"): + BUG_COMPONENT = ("Toolkit", "Find Toolbar") + +with Files("KeyPressEventModelCheckerChild.sys.mjs"): + BUG_COMPONENT = ("Core", "DOM: Events") + +with Files("PictureInPictureChild.sys.mjs"): + BUG_COMPONENT = ("Toolkit", "Picture-in-Picture") + +SPHINX_TREES["actors"] = "docs" + +TESTING_JS_MODULES += [ + "TestProcessActorChild.jsm", + "TestProcessActorChild.sys.mjs", + "TestProcessActorParent.jsm", + "TestProcessActorParent.sys.mjs", + "TestWindowChild.jsm", + "TestWindowChild.sys.mjs", + "TestWindowParent.jsm", + "TestWindowParent.sys.mjs", +] + +FINAL_TARGET_FILES.actors += [ + "AboutHttpsOnlyErrorChild.sys.mjs", + "AboutHttpsOnlyErrorParent.sys.mjs", + "AudioPlaybackChild.sys.mjs", + "AudioPlaybackParent.sys.mjs", + "AutoCompleteChild.sys.mjs", + "AutoCompleteParent.sys.mjs", + "AutoplayChild.sys.mjs", + "AutoplayParent.sys.mjs", + "AutoScrollChild.sys.mjs", + "AutoScrollParent.sys.mjs", + "BackgroundThumbnailsChild.sys.mjs", + "BrowserElementChild.sys.mjs", + "BrowserElementParent.sys.mjs", + "ClipboardReadPasteChild.sys.mjs", + "ClipboardReadPasteParent.sys.mjs", + "ContentMetaChild.sys.mjs", + "ContentMetaParent.sys.mjs", + "ControllersChild.sys.mjs", + "ControllersParent.sys.mjs", + "DateTimePickerChild.sys.mjs", + "DateTimePickerParent.sys.mjs", + "ExtFindChild.sys.mjs", + "FindBarChild.sys.mjs", + "FindBarParent.sys.mjs", + "FinderChild.sys.mjs", + "InlineSpellCheckerChild.sys.mjs", + "InlineSpellCheckerParent.sys.mjs", + "KeyPressEventModelCheckerChild.sys.mjs", + "NetErrorChild.sys.mjs", + "NetErrorParent.sys.mjs", + "PictureInPictureChild.sys.mjs", + "PopupBlockingChild.sys.mjs", + "PopupBlockingParent.sys.mjs", + "PrintingChild.sys.mjs", + "PrintingParent.sys.mjs", + "PrintingSelectionChild.sys.mjs", + "PurgeSessionHistoryChild.sys.mjs", + "RemotePageChild.sys.mjs", + "SelectChild.sys.mjs", + "SelectParent.sys.mjs", + "ThumbnailsChild.sys.mjs", + "UAWidgetsChild.sys.mjs", + "UnselectedTabHoverChild.sys.mjs", + "UnselectedTabHoverParent.sys.mjs", + "ViewSourceChild.sys.mjs", + "ViewSourcePageChild.sys.mjs", + "ViewSourcePageParent.sys.mjs", + "WebChannelChild.sys.mjs", + "WebChannelParent.sys.mjs", +] |