mozilla-central/dom/tests/browser/browser_test_new_window_from_content.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

/* Any copyright is dedicated to the Public Domain.
"use strict";
/*
We have three ways for content to open new windows:
1) window.open (with the default features)
2) window.open (with non-default features)
3) target="_blank" in <a> tags
We also have two prefs that modify our window opening behaviours:
1) browser.link.open_newwindow
This has a numeric value that allows us to set our window-opening behaviours from
content in three ways:
1) Open links that would normally open a new window in the current tab
2) Open links that would normally open a new window in a new window
3) Open links that would normally open a new window in a new tab (default)
2) browser.link.open_newwindow.restriction
This has a numeric value that allows us to fine tune the browser.link.open_newwindow
pref so that it can discriminate between different techniques for opening windows.
0) All things that open windows should behave according to browser.link.open_newwindow.
1) No things that open windows should behave according to browser.link.open_newwindow
(essentially rendering browser.link.open_newwindow inert).
2) Most things that open windows should behave according to browser.link.open_newwindow,
_except_ for window.open calls with the "feature" parameter. This will open in a new
window regardless of what browser.link.open_newwindow is set at. (default)
This file attempts to test each window opening technique against all possible settings for
each preference.
*/
const kContentDoc =
const kNewWindowPrefKey = "browser.link.open_newwindow";
const kNewWindowRestrictionPrefKey = "browser.link.open_newwindow.restriction";
const kSameTab = "same tab";
const kNewWin = "new window";
const kNewTab = "new tab";
SpecialPowers.pushPrefEnv({
set: [["dom.require_user_interaction_for_beforeunload", false]],
});
requestLongerTimeout(3);
// The following "matrices" represent the result of content attempting to
// open a window with window.open with the default feature set. The key of
// the kWinOpenDefault object represents the value of browser.link.open_newwindow.
// The value for each key is an array that represents the result (either opening
// the link in the same tab, a new window, or a new tab), where the index of each
// result maps to the browser.link.open_newwindow.restriction pref. I've tried
// to illustrate this more clearly in the kWinOpenDefault object.
const kWinOpenDefault = {
// open_newwindow.restriction
// 0 1 2
// open_newwindow
1: [kSameTab, kNewWin, kSameTab],
2: [kNewWin, kNewWin, kNewWin],
3: [kNewTab, kNewWin, kNewTab],
};
const kWinOpenNonDefault = {
1: [kSameTab, kNewWin, kNewWin],
2: [kNewWin, kNewWin, kNewWin],
3: [kNewTab, kNewWin, kNewWin],
};
const kTargetBlank = {
1: [kSameTab, kSameTab, kSameTab],
2: [kNewWin, kNewWin, kNewWin],
3: [kNewTab, kNewTab, kNewTab],
};
// We'll be changing these preferences a lot, so we'll stash their original
// values and make sure we restore them at the end of the test.
var originalNewWindowPref = Services.prefs.getIntPref(kNewWindowPrefKey);
var originalNewWindowRestrictionPref = Services.prefs.getIntPref(
kNewWindowRestrictionPrefKey
);
registerCleanupFunction(function () {
Services.prefs.setIntPref(kNewWindowPrefKey, originalNewWindowPref);
Services.prefs.setIntPref(
kNewWindowRestrictionPrefKey,
originalNewWindowRestrictionPref
);
});
/**
* For some expectation when a link is clicked, creates and
* returns a Promise that resolves when that expectation is
* fulfilled. For example, aExpectation might be kSameTab, which
* will cause this function to return a Promise that resolves when
* the current tab attempts to browse to about:blank.
*
* This function also takes care of cleaning up once the result has
* occurred - for example, if a new window was opened, this function
* closes it before resolving.
*
* @param aBrowser the <xul:browser> with the test document
* @param aExpectation one of kSameTab, kNewWin, or kNewTab.
* @return a Promise that resolves when the expectation is fulfilled,
* and cleaned up after.
*/
function prepareForResult(aBrowser, aExpectation) {
let expectedSpec = kContentDoc.replace(/[^\/]*$/, "dummy.html");
switch (aExpectation) {
case kSameTab:
return (async function () {
await BrowserTestUtils.browserLoaded(aBrowser);
is(aBrowser.currentURI.spec, expectedSpec, "Should be at dummy.html");
// Now put the browser back where it came from
BrowserTestUtils.startLoadingURIString(aBrowser, kContentDoc);
await BrowserTestUtils.browserLoaded(aBrowser);
})();
case kNewWin:
return (async function () {
let newWin = await BrowserTestUtils.waitForNewWindow({
url: expectedSpec,
});
let newBrowser = newWin.gBrowser.selectedBrowser;
is(newBrowser.currentURI.spec, expectedSpec, "Should be at dummy.html");
await BrowserTestUtils.closeWindow(newWin);
})();
case kNewTab:
return (async function () {
let newTab = await BrowserTestUtils.waitForNewTab(gBrowser);
is(
newTab.linkedBrowser.currentURI.spec,
expectedSpec,
"Should be at dummy.html"
);
BrowserTestUtils.removeTab(newTab);
})();
default:
ok(
false,
"prepareForResult can't handle an expectation of " + aExpectation
);
return Promise.resolve();
}
}
/**
* Ensure that clicks on a link with ID aLinkID cause us to
* perform as specified in the supplied aMatrix (kWinOpenDefault,
* for example).
*
* @param aLinkSelector a selector for the link within the testing page to click.
* @param aMatrix a testing matrix for the
* browser.link.open_newwindow and browser.link.open_newwindow.restriction
* prefs to test against. See kWinOpenDefault for an example.
*/
function testLinkWithMatrix(aLinkSelector, aMatrix) {
return BrowserTestUtils.withNewTab(
{
gBrowser,
url: kContentDoc,
},
async function (browser) {
// This nested for-loop is unravelling the matrix const
// we set up, and gives us three things through each tick
// of the inner loop:
// 1) newWindowPref: a browser.link.open_newwindow pref to try
// 2) newWindowRestPref: a browser.link.open_newwindow.restriction pref to try
// 3) expectation: what we expect the click outcome on this link to be,
// which will either be kSameTab, kNewWin or kNewTab.
for (let newWindowPref in aMatrix) {
let expectations = aMatrix[newWindowPref];
for (let i = 0; i < expectations.length; ++i) {
let newWindowRestPref = i;
let expectation = expectations[i];
Services.prefs.setIntPref(
"browser.link.open_newwindow",
newWindowPref
);
Services.prefs.setIntPref(
"browser.link.open_newwindow.restriction",
newWindowRestPref
);
info("Clicking on " + aLinkSelector);
info(
"Testing with browser.link.open_newwindow = " +
newWindowPref +
" and " +
"browser.link.open_newwindow.restriction = " +
newWindowRestPref
);
info("Expecting: " + expectation);
let resultPromise = prepareForResult(browser, expectation);
BrowserTestUtils.synthesizeMouseAtCenter(aLinkSelector, {}, browser);
await resultPromise;
info("Got expectation: " + expectation);
}
}
}
);
}
add_task(async function test_window_open_with_defaults() {
await testLinkWithMatrix("#winOpenDefault", kWinOpenDefault);
});
add_task(async function test_window_open_with_non_defaults() {
await testLinkWithMatrix("#winOpenNonDefault", kWinOpenNonDefault);
});
add_task(async function test_window_open_dialog() {
await testLinkWithMatrix("#winOpenDialog", kWinOpenNonDefault);
});
add_task(async function test_target__blank() {
await testLinkWithMatrix("#targetBlank", kTargetBlank);
});