Source code
Revision control
Copy as Markdown
Other Tools
Test Info: Warnings
- This test gets skipped with pattern: os == 'linux' && os_version == '18.04' && asan OR os == 'linux' && os_version == '18.04' && tsan OR apple_catalina && verify OR apple_silicon && verify OR os == 'mac' && os_version == '10.15' && debug OR os == 'linux' && os_version == '18.04'
- Manifest: browser/components/extensions/test/browser/browser.toml
/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set sts=2 sw=2 et tw=80: */
"use strict";
add_task(async function () {
function promiseWaitForFocus(window) {
return new Promise(resolve => {
waitForFocus(function () {
Assert.strictEqual(
Services.focus.activeWindow,
window,
"correct window focused"
);
resolve();
}, window);
});
}
let window1 = window;
let window2 = await BrowserTestUtils.openNewBrowserWindow();
window2.focus();
await promiseWaitForFocus(window2);
let extension = ExtensionTestUtils.loadExtension({
background: function () {
browser.windows.getAll(undefined, function (wins) {
browser.test.assertEq(wins.length, 2, "should have two windows");
// Sort the unfocused window to the lower index.
wins.sort(function (win1, win2) {
if (win1.focused === win2.focused) {
return 0;
}
return win1.focused ? 1 : -1;
});
browser.windows.update(wins[0].id, { focused: true }, function () {
browser.test.sendMessage("check");
});
});
},
});
await Promise.all([extension.startup(), extension.awaitMessage("check")]);
await promiseWaitForFocus(window1);
await extension.unload();
await BrowserTestUtils.closeWindow(window2);
});
add_task(async function testWindowUpdate() {
let extension = ExtensionTestUtils.loadExtension({
async background() {
let _checkWindowPromise;
browser.test.onMessage.addListener(msg => {
if (msg == "checked-window") {
_checkWindowPromise.resolve();
_checkWindowPromise = null;
}
});
let os;
function checkWindow(expected) {
return new Promise(resolve => {
_checkWindowPromise = { resolve };
browser.test.sendMessage("check-window", expected);
});
}
let currentWindowId;
async function updateWindow(windowId, params, expected, otherChecks) {
let window = await browser.windows.update(windowId, params);
browser.test.assertEq(
currentWindowId,
window.id,
"Expected WINDOW_ID_CURRENT to refer to the same window"
);
for (let key of Object.keys(params)) {
if (key == "state" && os == "mac" && params.state == "normal") {
// OS-X doesn't have a hard distinction between "normal" and
// "maximized" states.
browser.test.assertTrue(
window.state == "normal" || window.state == "maximized",
`Expected window.state (currently ${window.state}) to be "normal" but will accept "maximized"`
);
} else {
browser.test.assertEq(
params[key],
window[key],
`Got expected value for window.${key}`
);
}
}
if (otherChecks) {
for (let key of Object.keys(otherChecks)) {
browser.test.assertEq(
otherChecks[key],
window[key],
`Got expected value for window.${key}`
);
}
}
return checkWindow(expected);
}
try {
let windowId = browser.windows.WINDOW_ID_CURRENT;
({ os } = await browser.runtime.getPlatformInfo());
let window = await browser.windows.getCurrent();
currentWindowId = window.id;
// Store current, "normal" width and height to compare against
// window width and height after updating to "normal" state.
let normalWidth = window.width;
let normalHeight = window.height;
await updateWindow(
windowId,
{ state: "maximized" },
{ state: "STATE_MAXIMIZED" }
);
await updateWindow(
windowId,
{ state: "normal" },
{ state: "STATE_NORMAL" },
{ width: normalWidth, height: normalHeight }
);
await updateWindow(
windowId,
{ state: "minimized" },
{ state: "STATE_MINIMIZED" }
);
await updateWindow(
windowId,
{ state: "normal" },
{ state: "STATE_NORMAL" },
{ width: normalWidth, height: normalHeight }
);
await updateWindow(
windowId,
{ state: "fullscreen" },
{ state: "STATE_FULLSCREEN" }
);
await updateWindow(
windowId,
{ state: "normal" },
{ state: "STATE_NORMAL" },
{ width: normalWidth, height: normalHeight }
);
browser.test.notifyPass("window-update");
} catch (e) {
browser.test.fail(`${e} :: ${e.stack}`);
browser.test.notifyFail("window-update");
}
},
});
extension.onMessage("check-window", expected => {
if (expected.state != null) {
let { windowState } = window;
if (window.fullScreen) {
windowState = window.STATE_FULLSCREEN;
}
if (
expected.state == "STATE_NORMAL" &&
(AppConstants.platform == "macosx" || AppConstants.platform == "linux")
) {
ok(
windowState == window.STATE_NORMAL ||
windowState == window.STATE_MAXIMIZED,
`Expected windowState (currently ${windowState}) to be STATE_NORMAL but will accept STATE_MAXIMIZED`
);
} else {
is(
windowState,
window[expected.state],
`Expected window state to be ${expected.state}`
);
}
}
extension.sendMessage("checked-window");
});
await extension.startup();
await extension.awaitFinish("window-update");
await extension.unload();
});
add_task(async function () {
let window2 = await BrowserTestUtils.openNewBrowserWindow();
let extension = ExtensionTestUtils.loadExtension({
background: function () {
browser.windows.getAll(undefined, function (wins) {
browser.test.assertEq(wins.length, 2, "should have two windows");
let unfocused = wins.find(win => !win.focused);
browser.windows.update(
unfocused.id,
{ drawAttention: true },
function () {
browser.test.sendMessage("check");
}
);
});
},
});
await Promise.all([extension.startup(), extension.awaitMessage("check")]);
await extension.unload();
await BrowserTestUtils.closeWindow(window2);
});
// Tests that incompatible parameters can't be used together.
add_task(async function testWindowUpdateParams() {
let extension = ExtensionTestUtils.loadExtension({
async background() {
try {
for (let state of ["minimized", "maximized", "fullscreen"]) {
for (let param of ["left", "top", "width", "height"]) {
let expected = `"state": "${state}" may not be combined with "left", "top", "width", or "height"`;
let windowId = browser.windows.WINDOW_ID_CURRENT;
await browser.test.assertRejects(
browser.windows.update(windowId, { state, [param]: 100 }),
RegExp(expected),
`Got expected error for create(${param}=100`
);
}
}
browser.test.notifyPass("window-update-params");
} catch (e) {
browser.test.fail(`${e} :: ${e.stack}`);
browser.test.notifyFail("window-update-params");
}
},
});
await extension.startup();
await extension.awaitFinish("window-update-params");
await extension.unload();
});
add_task(async function testPositionBoundaryCheck() {
const extension = ExtensionTestUtils.loadExtension({
async background() {
function waitMessage() {
return new Promise(resolve => {
const onMessage = message => {
if (message == "continue") {
browser.test.onMessage.removeListener(onMessage);
resolve();
}
};
browser.test.onMessage.addListener(onMessage);
});
}
const win = await browser.windows.create({
type: "popup",
left: 50,
top: 50,
width: 150,
height: 150,
});
await browser.test.sendMessage("ready");
await waitMessage();
await browser.windows.update(win.id, {
left: 123,
top: 123,
});
await browser.test.sendMessage("regular");
await waitMessage();
await browser.windows.update(win.id, {
left: 123,
});
await browser.test.sendMessage("only-left");
await waitMessage();
await browser.windows.update(win.id, {
top: 123,
});
await browser.test.sendMessage("only-top");
await waitMessage();
await browser.windows.update(win.id, {
left: screen.availWidth * 100,
top: screen.availHeight * 100,
});
await browser.test.sendMessage("too-large");
await waitMessage();
await browser.windows.update(win.id, {
left: -screen.availWidth * 100,
top: -screen.availHeight * 100,
});
await browser.test.sendMessage("too-small");
},
});
const promisedWin = new Promise(resolve => {
const windowListener = (window, topic) => {
if (topic == "domwindowopened") {
Services.ww.unregisterNotification(windowListener);
resolve(window);
}
};
Services.ww.registerNotification(windowListener);
});
await extension.startup();
const win = await promisedWin;
const regularScreen = getScreenAt(0, 0, 150, 150);
const roundedX = roundCssPixcel(123, regularScreen);
const roundedY = roundCssPixcel(123, regularScreen);
const availRectLarge = getCssAvailRect(
getScreenAt(screen.width * 100, screen.height * 100, 150, 150)
);
const maxRight = availRectLarge.right;
const maxBottom = availRectLarge.bottom;
const availRectSmall = getCssAvailRect(
getScreenAt(-screen.width * 100, -screen.height * 100, 150, 150)
);
const minLeft = availRectSmall.left;
const minTop = availRectSmall.top;
const expectedCoordinates = [
`${roundedX},${roundedY}`,
`${roundedX},${win.screenY}`,
`${win.screenX},${roundedY}`,
];
await extension.awaitMessage("ready");
const actualCoordinates = [];
extension.sendMessage("continue");
await extension.awaitMessage("regular");
actualCoordinates.push(`${win.screenX},${win.screenY}`);
win.moveTo(50, 50);
extension.sendMessage("continue");
await extension.awaitMessage("only-left");
actualCoordinates.push(`${win.screenX},${win.screenY}`);
win.moveTo(50, 50);
extension.sendMessage("continue");
await extension.awaitMessage("only-top");
actualCoordinates.push(`${win.screenX},${win.screenY}`);
is(
actualCoordinates.join(" / "),
expectedCoordinates.join(" / "),
"expected window is placed at given coordinates"
);
const actualRect = {};
const maxRect = {
top: minTop,
bottom: maxBottom,
left: minLeft,
right: maxRight,
};
extension.sendMessage("continue");
await extension.awaitMessage("too-large");
actualRect.right = win.screenX + win.outerWidth;
actualRect.bottom = win.screenY + win.outerHeight;
extension.sendMessage("continue");
await extension.awaitMessage("too-small");
actualRect.top = win.screenY;
actualRect.left = win.screenX;
isRectContained(actualRect, maxRect);
await extension.unload();
await BrowserTestUtils.closeWindow(win);
});