From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- browser/actors/DOMFullscreenParent.sys.mjs | 318 +++++++++++++++++++++++++++++ 1 file changed, 318 insertions(+) create mode 100644 browser/actors/DOMFullscreenParent.sys.mjs (limited to 'browser/actors/DOMFullscreenParent.sys.mjs') diff --git a/browser/actors/DOMFullscreenParent.sys.mjs b/browser/actors/DOMFullscreenParent.sys.mjs new file mode 100644 index 0000000000..7c481c1051 --- /dev/null +++ b/browser/actors/DOMFullscreenParent.sys.mjs @@ -0,0 +1,318 @@ +/* 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 DOMFullscreenParent extends JSWindowActorParent { + // These properties get set by browser-fullScreenAndPointerLock.js. + // TODO: Bug 1743703 - Consider moving the messaging component of + // browser-fullScreenAndPointerLock.js into the actor + waitingForChildEnterFullscreen = false; + waitingForChildExitFullscreen = false; + // Cache the next message recipient actor and in-process browsing context that + // is computed by _getNextMsgRecipientActor() of + // browser-fullScreenAndPointerLock.js, this is used to ensure the fullscreen + // cleanup messages goes the same route as fullscreen request, especially for + // the cleanup that happens after actor is destroyed. + // TODO: Bug 1743703 - Consider moving the messaging component of + // browser-fullScreenAndPointerLock.js into the actor + nextMsgRecipient = null; + + updateFullscreenWindowReference(aWindow) { + if (aWindow.document.documentElement.hasAttribute("inDOMFullscreen")) { + this._fullscreenWindow = aWindow; + } else { + delete this._fullscreenWindow; + } + } + + cleanupDomFullscreen(aWindow) { + if (!aWindow.FullScreen) { + return; + } + + // If we don't need to wait for child reply, i.e. cleanupDomFullscreen + // doesn't message to child, and we've exit the fullscreen, there won't be + // DOMFullscreen:Painted message from child and it is possible that no more + // paint would be triggered, so just notify fullscreen-painted observer. + if ( + !aWindow.FullScreen.cleanupDomFullscreen(this) && + !aWindow.document.fullscreen + ) { + Services.obs.notifyObservers(aWindow, "fullscreen-painted"); + } + } + + /** + * Clean up fullscreen state and resume chrome UI if window is in fullscreen + * and this actor is the one where the original fullscreen enter or + * exit request comes. + */ + _cleanupFullscreenStateAndResumeChromeUI(aWindow) { + this.cleanupDomFullscreen(aWindow); + if (this.requestOrigin == this && aWindow.document.fullscreen) { + aWindow.windowUtils.remoteFrameFullscreenReverted(); + } + } + + didDestroy() { + this._didDestroy = true; + + let window = this._fullscreenWindow; + if (!window) { + let topBrowsingContext = this.browsingContext.top; + let browser = topBrowsingContext.embedderElement; + if (!browser) { + return; + } + + if ( + this.waitingForChildExitFullscreen || + this.waitingForChildEnterFullscreen + ) { + this.waitingForChildExitFullscreen = false; + this.waitingForChildEnterFullscreen = false; + // We were destroyed while waiting for our DOMFullscreenChild to exit + // or enter fullscreen, run cleanup steps anyway. + this._cleanupFullscreenStateAndResumeChromeUI(browser.ownerGlobal); + } + + if (this != this.requestOrigin) { + // The current fullscreen requester should handle the fullsceen event + // if any. + this.removeListeners(browser.ownerGlobal); + } + return; + } + + if (this.waitingForChildEnterFullscreen) { + this.waitingForChildEnterFullscreen = false; + if (window.document.fullscreen) { + // We were destroyed while waiting for our DOMFullscreenChild + // to transition to fullscreen so we abort the entire + // fullscreen transition to prevent getting stuck in a + // partial fullscreen state. We need to go through the + // document since window.Fullscreen could be undefined + // at this point. + // + // This could reject if we're not currently in fullscreen + // so just ignore rejection. + window.document.exitFullscreen().catch(() => {}); + return; + } + this.cleanupDomFullscreen(window); + } + + // Need to resume Chrome UI if the window is still in fullscreen UI + // to avoid the window stays in fullscreen problem. (See Bug 1620341) + if (window.document.documentElement.hasAttribute("inDOMFullscreen")) { + this.cleanupDomFullscreen(window); + if (window.windowUtils) { + window.windowUtils.remoteFrameFullscreenReverted(); + } + } else if (this.waitingForChildExitFullscreen) { + this.waitingForChildExitFullscreen = false; + // We were destroyed while waiting for our DOMFullscreenChild to exit + // run cleanup steps anyway. + this._cleanupFullscreenStateAndResumeChromeUI(window); + } + this.updateFullscreenWindowReference(window); + } + + receiveMessage(aMessage) { + let topBrowsingContext = this.browsingContext.top; + let browser = topBrowsingContext.embedderElement; + + if (!browser) { + // No need to go further when the browser is not accessible anymore + // (which can happen when the tab is closed for instance), + return; + } + + let window = browser.ownerGlobal; + switch (aMessage.name) { + case "DOMFullscreen:Request": { + this.manager.fullscreen = true; + this.waitingForChildExitFullscreen = false; + this.requestOrigin = this; + this.addListeners(window); + window.windowUtils.remoteFrameFullscreenChanged(browser); + break; + } + case "DOMFullscreen:NewOrigin": { + // Don't show the warning if we've already exited fullscreen. + if (window.document.fullscreen) { + window.PointerlockFsWarning.showFullScreen( + aMessage.data.originNoSuffix + ); + } + this.updateFullscreenWindowReference(window); + break; + } + case "DOMFullscreen:Entered": { + this.manager.fullscreen = true; + this.nextMsgRecipient = null; + this.waitingForChildEnterFullscreen = false; + window.FullScreen.enterDomFullscreen(browser, this); + this.updateFullscreenWindowReference(window); + break; + } + case "DOMFullscreen:Exit": { + this.manager.fullscreen = false; + this.waitingForChildEnterFullscreen = false; + window.windowUtils.remoteFrameFullscreenReverted(); + break; + } + case "DOMFullscreen:Exited": { + this.manager.fullscreen = false; + this.waitingForChildExitFullscreen = false; + this.cleanupDomFullscreen(window); + this.updateFullscreenWindowReference(window); + break; + } + case "DOMFullscreen:Painted": { + this.waitingForChildExitFullscreen = false; + Services.obs.notifyObservers(window, "fullscreen-painted"); + this.sendAsyncMessage("DOMFullscreen:Painted", {}); + TelemetryStopwatch.finish("FULLSCREEN_CHANGE_MS"); + break; + } + } + } + + handleEvent(aEvent) { + let window = aEvent.currentTarget.ownerGlobal; + // We can not get the corresponding browsing context from actor if the actor + // has already destroyed, so use event target to get browsing context + // instead. + let requestOrigin = window.browsingContext.fullscreenRequestOrigin?.get(); + if (this != requestOrigin) { + // The current fullscreen requester should handle the fullsceen event, + // ignore them if we are not the current requester. + this.removeListeners(window); + return; + } + + switch (aEvent.type) { + case "MozDOMFullscreen:Entered": { + // The event target is the element which requested the DOM + // fullscreen. If we were entering DOM fullscreen for a remote + // browser, the target would be the browser which was the parameter of + // `remoteFrameFullscreenChanged` call. If the fullscreen + // request was initiated from an in-process browser, we need + // to get its corresponding browser here. + let browser; + if (aEvent.target.ownerGlobal == window) { + browser = aEvent.target; + } else { + browser = aEvent.target.ownerGlobal.docShell.chromeEventHandler; + } + + // Addon installation should be cancelled when entering fullscreen for security and usability reasons. + // Installation prompts in fullscreen can trick the user into installing unwanted addons. + // In fullscreen the notification box does not have a clear visual association with its parent anymore. + if (window.gXPInstallObserver) { + window.gXPInstallObserver.removeAllNotifications(browser); + } + + TelemetryStopwatch.start("FULLSCREEN_CHANGE_MS"); + window.FullScreen.enterDomFullscreen(browser, this); + this.updateFullscreenWindowReference(window); + + if (!this.hasBeenDestroyed() && this.requestOrigin) { + window.PointerlockFsWarning.showFullScreen( + this.requestOrigin.manager.documentPrincipal.originNoSuffix + ); + } + break; + } + case "MozDOMFullscreen:Exited": { + TelemetryStopwatch.start("FULLSCREEN_CHANGE_MS"); + + // Make sure that the actor has not been destroyed before + // accessing its browsing context. Otherwise, a error may + // occur and hence cleanupDomFullscreen not executed, resulting + // in the browser window being in an unstable state. + // (Bug 1590138). + if (!this.hasBeenDestroyed() && !this.requestOrigin) { + this.requestOrigin = this; + } + this.cleanupDomFullscreen(window); + this.updateFullscreenWindowReference(window); + + // If the document is supposed to be in fullscreen, keep the listener to wait for + // further events. + if (!this.manager.fullscreen) { + this.removeListeners(window); + } + break; + } + } + } + + addListeners(aWindow) { + aWindow.addEventListener( + "MozDOMFullscreen:Entered", + this, + /* useCapture */ true, + /* wantsUntrusted */ + false + ); + aWindow.addEventListener( + "MozDOMFullscreen:Exited", + this, + /* useCapture */ true, + /* wantsUntrusted */ false + ); + } + + removeListeners(aWindow) { + aWindow.removeEventListener("MozDOMFullscreen:Entered", this, true); + aWindow.removeEventListener("MozDOMFullscreen:Exited", this, true); + } + + /** + * Get the actor where the original fullscreen + * enter or exit request comes from. + */ + get requestOrigin() { + let chromeBC = this.browsingContext.topChromeWindow?.browsingContext; + let requestOrigin = chromeBC?.fullscreenRequestOrigin; + return requestOrigin && requestOrigin.get(); + } + + /** + * Store the actor where the original fullscreen + * enter or exit request comes from in the top level + * browsing context. + */ + set requestOrigin(aActor) { + let chromeBC = this.browsingContext.topChromeWindow?.browsingContext; + if (!chromeBC) { + console.error("not able to get browsingContext for chrome window."); + return; + } + + if (aActor) { + chromeBC.fullscreenRequestOrigin = Cu.getWeakReference(aActor); + } else { + delete chromeBC.fullscreenRequestOrigin; + } + } + + hasBeenDestroyed() { + if (this._didDestroy) { + return true; + } + + // The 'didDestroy' callback is not always getting called. + // So we can't rely on it here. Instead, we will try to access + // the browsing context to judge wether the actor has + // been destroyed or not. + try { + return !this.browsingContext; + } catch { + return true; + } + } +} -- cgit v1.2.3