forked from mirrors/gecko-dev
0b1a146519
ContentTask tasks have a different lifetime than SpecialPowers tasks, with the former being tied to the lifetime of a message manager and the latter tied to the lifetime of a window global. That means that existing ContentTask callers which expect to be able to register load listeners before the creation of a window global, or which expect to persist after a page has navigated, won't work as SpecialPowers tasks. Since those sorts of tasks are not really resilient in the face of Fission, they should really be written to work differently, but this patch mostly just reverts them to using ContentTask for the time being. Differential Revision: https://phabricator.services.mozilla.com/D53744 --HG-- extra : moz-landing-system : lando
851 lines
31 KiB
JavaScript
851 lines
31 KiB
JavaScript
"use strict";
|
|
|
|
const PAGE_URL =
|
|
"http://example.com/browser/dom/tests/browser/beforeunload_test_page.html";
|
|
|
|
/**
|
|
* Adds 1 or more inert beforeunload event listeners in this browser.
|
|
* By default, will target the top-level content window, but callers
|
|
* can specify the index of a subframe to target. See prepareSubframes
|
|
* for an idea of how the subframes are structured.
|
|
*
|
|
* @param {<xul:browser>} browser
|
|
* The browser to add the beforeunload event listener in.
|
|
* @param {int} howMany
|
|
* How many beforeunload event listeners to add. Note that these
|
|
* beforeunload event listeners are inert and will not actually
|
|
* prevent the host window from navigating.
|
|
* @param {optional int} frameDepth
|
|
* The depth of the frame to add the event listener to. Defaults
|
|
* to 0, which is the top-level content window.
|
|
* @return {Promise}
|
|
*/
|
|
function addBeforeUnloadListeners(browser, howMany = 1, frameDepth = 0) {
|
|
return controlFrameAt(browser, frameDepth, {
|
|
name: "AddBeforeUnload",
|
|
howMany,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Adds 1 or more inert beforeunload event listeners in this browser on
|
|
* a particular subframe. By default, this will target the first subframe
|
|
* under the top-level content window, but callers can specify the index
|
|
* of a subframe to target. See prepareSubframes for an idea of how the
|
|
* subframes are structured.
|
|
*
|
|
* Note that this adds the beforeunload event listener on the "outer" window,
|
|
* by doing:
|
|
*
|
|
* iframe.addEventListener("beforeunload", ...);
|
|
*
|
|
* @param {<xul:browser>} browser
|
|
* The browser to add the beforeunload event listener in.
|
|
* @param {int} howMany
|
|
* How many beforeunload event listeners to add. Note that these
|
|
* beforeunload event listeners are inert and will not actually
|
|
* prevent the host window from navigating.
|
|
* @param {optional int} frameDepth
|
|
* The depth of the frame to add the event listener to. Defaults
|
|
* to 1, which is the first subframe inside the top-level content
|
|
* window. Setting this to 0 will throw.
|
|
* @return {Promise}
|
|
*/
|
|
function addOuterBeforeUnloadListeners(browser, howMany = 1, frameDepth = 1) {
|
|
if (frameDepth == 0) {
|
|
throw new Error(
|
|
"When adding a beforeunload listener on an outer " +
|
|
"window, the frame you're targeting needs to be at " +
|
|
"depth > 0."
|
|
);
|
|
}
|
|
|
|
return controlFrameAt(browser, frameDepth, {
|
|
name: "AddOuterBeforeUnload",
|
|
howMany,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Removes 1 or more inert beforeunload event listeners in this browser.
|
|
* This assumes that addBeforeUnloadListeners has been called previously
|
|
* for the target frame.
|
|
*
|
|
* By default, will target the top-level content window, but callers
|
|
* can specify the index of a subframe to target. See prepareSubframes
|
|
* for an idea of how the subframes are structured.
|
|
*
|
|
* @param {<xul:browser>} browser
|
|
* The browser to remove the beforeunload event listener from.
|
|
* @param {int} howMany
|
|
* How many beforeunload event listeners to remove.
|
|
* @param {optional int} frameDepth
|
|
* The depth of the frame to remove the event listener from. Defaults
|
|
* to 0, which is the top-level content window.
|
|
* @return {Promise}
|
|
*/
|
|
function removeBeforeUnloadListeners(browser, howMany = 1, frameDepth = 0) {
|
|
return controlFrameAt(browser, frameDepth, {
|
|
name: "RemoveBeforeUnload",
|
|
howMany,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Removes 1 or more inert beforeunload event listeners in this browser on
|
|
* a particular subframe. By default, this will target the first subframe
|
|
* under the top-level content window, but callers can specify the index
|
|
* of a subframe to target. See prepareSubframes for an idea of how the
|
|
* subframes are structured.
|
|
*
|
|
* Note that this removes the beforeunload event listener on the "outer" window,
|
|
* by doing:
|
|
*
|
|
* iframe.removeEventListener("beforeunload", ...);
|
|
*
|
|
* @param {<xul:browser>} browser
|
|
* The browser to remove the beforeunload event listener from.
|
|
* @param {int} howMany
|
|
* How many beforeunload event listeners to remove.
|
|
* @param {optional int} frameDepth
|
|
* The depth of the frame to remove the event listener from. Defaults
|
|
* to 1, which is the first subframe inside the top-level content
|
|
* window. Setting this to 0 will throw.
|
|
* @return {Promise}
|
|
*/
|
|
function removeOuterBeforeUnloadListeners(
|
|
browser,
|
|
howMany = 1,
|
|
frameDepth = 1
|
|
) {
|
|
if (frameDepth == 0) {
|
|
throw new Error(
|
|
"When removing a beforeunload listener from an outer " +
|
|
"window, the frame you're targeting needs to be at " +
|
|
"depth > 0."
|
|
);
|
|
}
|
|
|
|
return controlFrameAt(browser, frameDepth, {
|
|
name: "RemoveOuterBeforeUnload",
|
|
howMany,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Navigates a content window to a particular URL and waits for it to
|
|
* finish loading that URL.
|
|
*
|
|
* By default, will target the top-level content window, but callers
|
|
* can specify the index of a subframe to target. See prepareSubframes
|
|
* for an idea of how the subframes are structured.
|
|
*
|
|
* @param {<xul:browser>} browser
|
|
* The browser that will have the navigation occur within it.
|
|
* @param {string} url
|
|
* The URL to send the content window to.
|
|
* @param {optional int} frameDepth
|
|
* The depth of the frame to navigate. Defaults to 0, which is
|
|
* the top-level content window.
|
|
* @return {Promise}
|
|
*/
|
|
function navigateSubframe(browser, url, frameDepth = 0) {
|
|
let navigatePromise = controlFrameAt(browser, frameDepth, {
|
|
name: "Navigate",
|
|
url,
|
|
});
|
|
let subframeLoad = BrowserTestUtils.browserLoaded(browser, true);
|
|
return Promise.all([navigatePromise, subframeLoad]);
|
|
}
|
|
|
|
/**
|
|
* Removes the <iframe> from a content window pointed at PAGE_URL.
|
|
*
|
|
* By default, will target the top-level content window, but callers
|
|
* can specify the index of a subframe to target. See prepareSubframes
|
|
* for an idea of how the subframes are structured.
|
|
*
|
|
* @param {<xul:browser>} browser
|
|
* The browser that will have removal occur within it.
|
|
* @param {optional int} frameDepth
|
|
* The depth of the frame that will have the removal occur within
|
|
* it. Defaults to 0, which is the top-level content window, meaning
|
|
* that the first subframe will be removed.
|
|
* @return {Promise}
|
|
*/
|
|
function removeSubframeFrom(browser, frameDepth = 0) {
|
|
return controlFrameAt(browser, frameDepth, {
|
|
name: "RemoveSubframe",
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Sends a command to a frame pointed at PAGE_URL. There are utility
|
|
* functions defined in this file that call this function. You should
|
|
* use those instead.
|
|
*
|
|
* @param {<xul:browser>} browser
|
|
* The browser to send the command to.
|
|
* @param {int} frameDepth
|
|
* The depth of the frame that we'll send the command to. 0 means
|
|
* sending it to the top-level content window.
|
|
* @param {object} command
|
|
* An object with the following structure:
|
|
*
|
|
* {
|
|
* name: (string),
|
|
* <arbitrary arguments to send with the command>
|
|
* }
|
|
*
|
|
* Here are the commands that can be sent:
|
|
*
|
|
* AddBeforeUnload
|
|
* {int} howMany
|
|
* How many beforeunload event listeners to add.
|
|
*
|
|
* AddOuterBeforeUnload
|
|
* {int} howMany
|
|
* How many beforeunload event listeners to add to
|
|
* the iframe in the document at this depth.
|
|
*
|
|
* RemoveBeforeUnload
|
|
* {int} howMany
|
|
* How many beforeunload event listeners to remove.
|
|
*
|
|
* RemoveOuterBeforeUnload
|
|
* {int} howMany
|
|
* How many beforeunload event listeners to remove from
|
|
* the iframe in the document at this depth.
|
|
*
|
|
* Navigate
|
|
* {string} url
|
|
* The URL to send the frame to.
|
|
*
|
|
* RemoveSubframe
|
|
*
|
|
* @return {Promise}
|
|
*/
|
|
function controlFrameAt(browser, frameDepth, command) {
|
|
return SpecialPowers.spawn(browser, [{ frameDepth, command }], async function(
|
|
args
|
|
) {
|
|
ChromeUtils.import("resource://testing-common/TestUtils.jsm", this);
|
|
|
|
let { command: contentCommand, frameDepth: contentFrameDepth } = args;
|
|
|
|
let targetContent = content;
|
|
let targetSubframe = content.document.getElementById("subframe");
|
|
|
|
// We want to not only find the frame that maps to the
|
|
// target frame depth that we've been given, but we also want
|
|
// to count the total depth so that if a middle frame is removed
|
|
// or navigated, then we know how many outer-window-destroyed
|
|
// observer notifications to expect.
|
|
let currentContent = targetContent;
|
|
let currentSubframe = targetSubframe;
|
|
|
|
let depth = 0;
|
|
|
|
do {
|
|
currentContent = currentSubframe.contentWindow;
|
|
currentSubframe = currentContent.document.getElementById("subframe");
|
|
depth++;
|
|
if (depth == contentFrameDepth) {
|
|
targetContent = currentContent;
|
|
targetSubframe = currentSubframe;
|
|
}
|
|
} while (currentSubframe);
|
|
|
|
switch (contentCommand.name) {
|
|
case "AddBeforeUnload": {
|
|
let BeforeUnloader = targetContent.wrappedJSObject.BeforeUnloader;
|
|
Assert.ok(BeforeUnloader, "Found BeforeUnloader in the test page.");
|
|
BeforeUnloader.pushInner(contentCommand.howMany);
|
|
break;
|
|
}
|
|
case "AddOuterBeforeUnload": {
|
|
let BeforeUnloader = targetContent.wrappedJSObject.BeforeUnloader;
|
|
Assert.ok(BeforeUnloader, "Found BeforeUnloader in the test page.");
|
|
BeforeUnloader.pushOuter(contentCommand.howMany);
|
|
break;
|
|
}
|
|
case "RemoveBeforeUnload": {
|
|
let BeforeUnloader = targetContent.wrappedJSObject.BeforeUnloader;
|
|
Assert.ok(BeforeUnloader, "Found BeforeUnloader in the test page.");
|
|
BeforeUnloader.popInner(contentCommand.howMany);
|
|
break;
|
|
}
|
|
case "RemoveOuterBeforeUnload": {
|
|
let BeforeUnloader = targetContent.wrappedJSObject.BeforeUnloader;
|
|
Assert.ok(BeforeUnloader, "Found BeforeUnloader in the test page.");
|
|
BeforeUnloader.popOuter(contentCommand.howMany);
|
|
break;
|
|
}
|
|
case "Navigate": {
|
|
// How many frames are going to be destroyed when we do this? We
|
|
// need to wait for that many window destroyed notifications.
|
|
targetContent.location = contentCommand.url;
|
|
|
|
let destroyedOuterWindows = depth - contentFrameDepth;
|
|
if (destroyedOuterWindows) {
|
|
await TestUtils.topicObserved("outer-window-destroyed", () => {
|
|
destroyedOuterWindows--;
|
|
return !destroyedOuterWindows;
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
case "RemoveSubframe": {
|
|
let subframe = targetContent.document.getElementById("subframe");
|
|
Assert.ok(
|
|
subframe,
|
|
"Found subframe at frame depth of " + contentFrameDepth
|
|
);
|
|
subframe.remove();
|
|
|
|
let destroyedOuterWindows = depth - contentFrameDepth;
|
|
if (destroyedOuterWindows) {
|
|
await TestUtils.topicObserved("outer-window-destroyed", () => {
|
|
destroyedOuterWindows--;
|
|
return !destroyedOuterWindows;
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}).catch(Cu.reportError);
|
|
}
|
|
|
|
/**
|
|
* Sets up a structure where a page at PAGE_URL will host an
|
|
* <iframe> also pointed at PAGE_URL, and does this repeatedly
|
|
* until we've achieved the desired frame depth. Note that this
|
|
* will cause the top-level browser to reload, and wipe out any
|
|
* previous changes to the DOM under it.
|
|
*
|
|
* @param {<xul:browser>} browser
|
|
* The browser in which we'll load our structure at the
|
|
* top level.
|
|
* @param {Array<object>} options
|
|
* Set-up options for each subframe. The following properties
|
|
* are accepted:
|
|
*
|
|
* {string} sandboxAttributes
|
|
* The value to set the sandbox attribute to. If null, no sandbox
|
|
* attribute will be set (and any pre-existing sandbox attributes)
|
|
* on the <iframe> will be removed.
|
|
*
|
|
* The number of entries on the options Array corresponds to how many
|
|
* subframes are under the top-level content window.
|
|
*
|
|
* Example:
|
|
*
|
|
* yield prepareSubframes(browser, [
|
|
* { sandboxAttributes: null },
|
|
* { sandboxAttributes: "allow-modals" },
|
|
* ]);
|
|
*
|
|
* This would create the following structure:
|
|
*
|
|
* <top-level content window at PAGE_URL>
|
|
* |
|
|
* |--> <iframe at PAGE_URL, no sandbox attributes>
|
|
* |
|
|
* |--> <iframe at PAGE_URL, sandbox="allow-modals">
|
|
*
|
|
* @return {Promise}
|
|
*/
|
|
async function prepareSubframes(browser, options) {
|
|
browser.reload();
|
|
await BrowserTestUtils.browserLoaded(browser);
|
|
|
|
await SpecialPowers.spawn(browser, [{ options, PAGE_URL }], async function(
|
|
args
|
|
) {
|
|
let { options: allSubframeOptions, PAGE_URL: contentPageURL } = args;
|
|
function loadBeforeUnloadHelper(doc, subframeOptions) {
|
|
let subframe = doc.getElementById("subframe");
|
|
subframe.remove();
|
|
if (subframeOptions.sandboxAttributes === null) {
|
|
subframe.removeAttribute("sandbox");
|
|
} else {
|
|
subframe.setAttribute("sandbox", subframeOptions.sandboxAttributes);
|
|
}
|
|
doc.body.appendChild(subframe);
|
|
subframe.contentWindow.location = contentPageURL;
|
|
return ContentTaskUtils.waitForEvent(subframe, "load").then(() => {
|
|
return subframe.contentDocument;
|
|
});
|
|
}
|
|
|
|
let currentDoc = content.document;
|
|
for (let subframeOptions of allSubframeOptions) {
|
|
currentDoc = await loadBeforeUnloadHelper(currentDoc, subframeOptions);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Ensures that a browser's nsIRemoteTab hasBeforeUnload attribute
|
|
* is set to the expected value.
|
|
*
|
|
* @param {<xul:browser>} browser
|
|
* The browser whose nsIRemoteTab we will check.
|
|
* @param {bool} expected
|
|
* True if hasBeforeUnload is expected to be true.
|
|
*/
|
|
function assertHasBeforeUnload(browser, expected) {
|
|
Assert.equal(browser.frameLoader.remoteTab.hasBeforeUnload, expected);
|
|
}
|
|
|
|
/**
|
|
* Tests that the nsIRemoteTab hasBeforeUnload attribute works under
|
|
* a number of different scenarios on inner windows. At a high-level,
|
|
* we test that hasBeforeUnload works properly during page / iframe
|
|
* navigation, or when an <iframe> with a beforeunload listener on its
|
|
* inner window is removed from the DOM.
|
|
*/
|
|
add_task(async function test_inner_window_scenarios() {
|
|
await BrowserTestUtils.withNewTab(
|
|
{
|
|
gBrowser,
|
|
url: PAGE_URL,
|
|
},
|
|
async function(browser) {
|
|
Assert.ok(
|
|
browser.isRemoteBrowser,
|
|
"This test only makes sense with out of process browsers."
|
|
);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Test the simple case on the top-level window by adding a single
|
|
// beforeunload event listener on the inner window and then removing
|
|
// it.
|
|
await addBeforeUnloadListeners(browser);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeBeforeUnloadListeners(browser);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Now let's add several beforeunload listeners, and
|
|
// ensure that we only set hasBeforeUnload to false once
|
|
// the last listener is removed.
|
|
await addBeforeUnloadListeners(browser, 3);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeBeforeUnloadListeners(browser); // 2 left...
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeBeforeUnloadListeners(browser); // 1 left...
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeBeforeUnloadListeners(browser); // None left!
|
|
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Now let's have the top-level content window navigate
|
|
// away with a beforeunload listener set, and ensure
|
|
// that we clear the hasBeforeUnload value.
|
|
await addBeforeUnloadListeners(browser, 5);
|
|
await navigateSubframe(browser, "http://example.com");
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Now send the page back to the test page for
|
|
// the next few tests.
|
|
BrowserTestUtils.loadURI(browser, PAGE_URL);
|
|
await BrowserTestUtils.browserLoaded(browser);
|
|
|
|
// We want to test hasBeforeUnload works properly with
|
|
// beforeunload event listeners in <iframe> elements too.
|
|
// We prepare a structure like this with 3 content windows
|
|
// to exercise:
|
|
//
|
|
// <top-level content window at PAGE_URL> (TOP)
|
|
// |
|
|
// |--> <iframe at PAGE_URL> (MIDDLE)
|
|
// |
|
|
// |--> <iframe at PAGE_URL> (BOTTOM)
|
|
//
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
// These constants are just to make it easier to know which
|
|
// frame we're referring to without having to remember the
|
|
// exact indices.
|
|
const TOP = 0;
|
|
const MIDDLE = 1;
|
|
const BOTTOM = 2;
|
|
|
|
// We should initially start with hasBeforeUnload set to false.
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Tests that if there are beforeunload event listeners on
|
|
// all levels of our window structure, that we only set
|
|
// hasBeforeUnload to false once the last beforeunload
|
|
// listener has been unset.
|
|
await addBeforeUnloadListeners(browser, 2, MIDDLE);
|
|
assertHasBeforeUnload(browser, true);
|
|
await addBeforeUnloadListeners(browser, 1, TOP);
|
|
assertHasBeforeUnload(browser, true);
|
|
await addBeforeUnloadListeners(browser, 5, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeBeforeUnloadListeners(browser, 1, TOP);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeBeforeUnloadListeners(browser, 5, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeBeforeUnloadListeners(browser, 2, MIDDLE);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Tests that if a beforeunload event listener is set on
|
|
// an iframe that navigates away to a page without a
|
|
// beforeunload listener, that hasBeforeUnload is set
|
|
// to false.
|
|
await addBeforeUnloadListeners(browser, 5, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await navigateSubframe(browser, "http://example.com", BOTTOM);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Reset our window structure now.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
|
|
// This time, add beforeunload event listeners to both the
|
|
// MIDDLE and BOTTOM frame, and then navigate the MIDDLE
|
|
// away. This should set hasBeforeUnload to false.
|
|
await addBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await navigateSubframe(browser, "http://example.com", MIDDLE);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Tests that if the MIDDLE and BOTTOM frames have beforeunload
|
|
// event listeners, and if we remove the BOTTOM <iframe> and the
|
|
// MIDDLE <iframe>, that hasBeforeUnload is set to false.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
await addBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeSubframeFrom(browser, MIDDLE);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeSubframeFrom(browser, TOP);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Tests that if the MIDDLE and BOTTOM frames have beforeunload
|
|
// event listeners, and if we remove just the MIDDLE <iframe>, that
|
|
// hasBeforeUnload is set to false.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
await addBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeSubframeFrom(browser, TOP);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Test that two sandboxed iframes, _without_ the allow-modals
|
|
// permission, do not result in the hasBeforeUnload attribute
|
|
// being set to true when beforeunload event listeners are added.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: "allow-scripts" },
|
|
{ sandboxAttributes: "allow-scripts" },
|
|
]);
|
|
|
|
await addBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
await removeBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await removeBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Test that two sandboxed iframes, both with the allow-modals
|
|
// permission, cause the hasBeforeUnload attribute to be set
|
|
// to true when beforeunload event listeners are added.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: "allow-scripts allow-modals" },
|
|
{ sandboxAttributes: "allow-scripts allow-modals" },
|
|
]);
|
|
|
|
await addBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
assertHasBeforeUnload(browser, false);
|
|
}
|
|
);
|
|
});
|
|
|
|
/**
|
|
* Tests that the nsIRemoteTab hasBeforeUnload attribute works under
|
|
* a number of different scenarios on outer windows. Very similar to
|
|
* the above set of tests, except that we add the beforeunload listeners
|
|
* to the iframe DOM nodes instead of the inner windows.
|
|
*/
|
|
add_task(async function test_outer_window_scenarios() {
|
|
await BrowserTestUtils.withNewTab(
|
|
{
|
|
gBrowser,
|
|
url: PAGE_URL,
|
|
},
|
|
async function(browser) {
|
|
Assert.ok(
|
|
browser.isRemoteBrowser,
|
|
"This test only makes sense with out of process browsers."
|
|
);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// We want to test hasBeforeUnload works properly with
|
|
// beforeunload event listeners in <iframe> elements.
|
|
// We prepare a structure like this with 3 content windows
|
|
// to exercise:
|
|
//
|
|
// <top-level content window at PAGE_URL> (TOP)
|
|
// |
|
|
// |--> <iframe at PAGE_URL> (MIDDLE)
|
|
// |
|
|
// |--> <iframe at PAGE_URL> (BOTTOM)
|
|
//
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
|
|
// These constants are just to make it easier to know which
|
|
// frame we're referring to without having to remember the
|
|
// exact indices.
|
|
const TOP = 0;
|
|
const MIDDLE = 1;
|
|
const BOTTOM = 2;
|
|
|
|
// Test the simple case on the top-level window by adding a single
|
|
// beforeunload event listener on the outer window of the iframe
|
|
// in the TOP document.
|
|
await addOuterBeforeUnloadListeners(browser);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeOuterBeforeUnloadListeners(browser);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Now let's add several beforeunload listeners, and
|
|
// ensure that we only set hasBeforeUnload to false once
|
|
// the last listener is removed.
|
|
await addOuterBeforeUnloadListeners(browser, 3);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeOuterBeforeUnloadListeners(browser); // 2 left...
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeOuterBeforeUnloadListeners(browser); // 1 left...
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeOuterBeforeUnloadListeners(browser); // None left!
|
|
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Now let's have the top-level content window navigate away
|
|
// with a beforeunload listener set on the outer window of the
|
|
// iframe inside it, and ensure that we clear the hasBeforeUnload
|
|
// value.
|
|
await addOuterBeforeUnloadListeners(browser, 5);
|
|
await navigateSubframe(browser, "http://example.com", TOP);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Now send the page back to the test page for
|
|
// the next few tests.
|
|
BrowserTestUtils.loadURI(browser, PAGE_URL);
|
|
await BrowserTestUtils.browserLoaded(browser);
|
|
|
|
// We should initially start with hasBeforeUnload set to false.
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
|
|
// Tests that if there are beforeunload event listeners on
|
|
// all levels of our window structure, that we only set
|
|
// hasBeforeUnload to false once the last beforeunload
|
|
// listener has been unset.
|
|
await addOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
assertHasBeforeUnload(browser, true);
|
|
await addOuterBeforeUnloadListeners(browser, 7, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeOuterBeforeUnloadListeners(browser, 7, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Tests that if a beforeunload event listener is set on
|
|
// an iframe that navigates away to a page without a
|
|
// beforeunload listener, that hasBeforeUnload is set
|
|
// to false. We're setting the event listener on the
|
|
// outer window on the <iframe> in the MIDDLE, which
|
|
// itself contains the BOTTOM frame it our structure.
|
|
await addOuterBeforeUnloadListeners(browser, 5, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
// Now navigate that BOTTOM frame.
|
|
await navigateSubframe(browser, "http://example.com", BOTTOM);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Reset our window structure now.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
|
|
// This time, add beforeunload event listeners to the outer
|
|
// windows for MIDDLE and BOTTOM. Then navigate the MIDDLE
|
|
// frame. This should set hasBeforeUnload to false.
|
|
await addOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addOuterBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await navigateSubframe(browser, "http://example.com", MIDDLE);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Adds beforeunload event listeners to the outer windows of
|
|
// MIDDLE and BOTOTM, and then removes those iframes. Removing
|
|
// both iframes should set hasBeforeUnload to false.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
await addOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addOuterBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeSubframeFrom(browser, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeSubframeFrom(browser, MIDDLE);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Adds beforeunload event listeners to the outer windows of MIDDLE
|
|
// and BOTTOM, and then removes just the MIDDLE iframe (which will
|
|
// take the bottom one with it). This should set hasBeforeUnload to
|
|
// false.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
await addOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addOuterBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeSubframeFrom(browser, TOP);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Test that two sandboxed iframes, _without_ the allow-modals
|
|
// permission, do not result in the hasBeforeUnload attribute
|
|
// being set to true when beforeunload event listeners are added
|
|
// to the outer windows. Note that this requires the
|
|
// allow-same-origin permission, otherwise a cross-origin
|
|
// security exception is thrown.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: "allow-same-origin allow-scripts" },
|
|
{ sandboxAttributes: "allow-same-origin allow-scripts" },
|
|
]);
|
|
|
|
await addOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addOuterBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
await removeOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await removeOuterBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// Test that two sandboxed iframes, both with the allow-modals
|
|
// permission, cause the hasBeforeUnload attribute to be set
|
|
// to true when beforeunload event listeners are added. Note
|
|
// that this requires the allow-same-origin permission,
|
|
// otherwise a cross-origin security exception is thrown.
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: "allow-same-origin allow-scripts allow-modals" },
|
|
{ sandboxAttributes: "allow-same-origin allow-scripts allow-modals" },
|
|
]);
|
|
|
|
await addOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
await addOuterBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeOuterBeforeUnloadListeners(browser, 1, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
await removeOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
assertHasBeforeUnload(browser, false);
|
|
}
|
|
);
|
|
});
|
|
|
|
/**
|
|
* Tests hasBeforeUnload behaviour when beforeunload event listeners
|
|
* are added on both inner and outer windows.
|
|
*/
|
|
add_task(async function test_mixed_inner_and_outer_window_scenarios() {
|
|
await BrowserTestUtils.withNewTab(
|
|
{
|
|
gBrowser,
|
|
url: PAGE_URL,
|
|
},
|
|
async function(browser) {
|
|
Assert.ok(
|
|
browser.isRemoteBrowser,
|
|
"This test only makes sense with out of process browsers."
|
|
);
|
|
assertHasBeforeUnload(browser, false);
|
|
|
|
// We want to test hasBeforeUnload works properly with
|
|
// beforeunload event listeners in <iframe> elements.
|
|
// We prepare a structure like this with 3 content windows
|
|
// to exercise:
|
|
//
|
|
// <top-level content window at PAGE_URL> (TOP)
|
|
// |
|
|
// |--> <iframe at PAGE_URL> (MIDDLE)
|
|
// |
|
|
// |--> <iframe at PAGE_URL> (BOTTOM)
|
|
//
|
|
await prepareSubframes(browser, [
|
|
{ sandboxAttributes: null },
|
|
{ sandboxAttributes: null },
|
|
]);
|
|
|
|
// These constants are just to make it easier to know which
|
|
// frame we're referring to without having to remember the
|
|
// exact indices.
|
|
const TOP = 0;
|
|
const MIDDLE = 1;
|
|
const BOTTOM = 2;
|
|
|
|
await addBeforeUnloadListeners(browser, 1, TOP);
|
|
assertHasBeforeUnload(browser, true);
|
|
await addBeforeUnloadListeners(browser, 2, MIDDLE);
|
|
assertHasBeforeUnload(browser, true);
|
|
await addBeforeUnloadListeners(browser, 5, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await addOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
assertHasBeforeUnload(browser, true);
|
|
await addOuterBeforeUnloadListeners(browser, 7, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeBeforeUnloadListeners(browser, 5, BOTTOM);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeBeforeUnloadListeners(browser, 2, MIDDLE);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeOuterBeforeUnloadListeners(browser, 3, MIDDLE);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeBeforeUnloadListeners(browser, 1, TOP);
|
|
assertHasBeforeUnload(browser, true);
|
|
|
|
await removeOuterBeforeUnloadListeners(browser, 7, BOTTOM);
|
|
assertHasBeforeUnload(browser, false);
|
|
}
|
|
);
|
|
});
|