diff options
Diffstat (limited to '')
19 files changed, 1708 insertions, 0 deletions
diff --git a/dom/base/test/useractivation/file_clipboard_common.js b/dom/base/test/useractivation/file_clipboard_common.js new file mode 100644 index 0000000000..fe172e52c8 --- /dev/null +++ b/dom/base/test/useractivation/file_clipboard_common.js @@ -0,0 +1,505 @@ +// This test is called from both test_clipboard_editor.html and test_clipboard_noeditor.html +// This is to test that the code works both in the presence of a contentEditable node, and in the absense of one +var WATCH_TIMEOUT = 300; + +// Some global variables to make the debug messages easier to track down +var gTestN0 = 0, + gTestN1 = 0, + gTestN2 = 0; +function testLoc() { + return " " + gTestN0 + " - " + gTestN1 + " - " + gTestN2; +} + +// Listen for cut & copy events +var gCopyCount = 0, + gCutCount = 0; +document.addEventListener("copy", function () { + gCopyCount++; +}); +document.addEventListener("cut", function () { + gCutCount++; +}); + +// Helper methods +function selectNode(aSelector, aCb) { + var dn = document.querySelector(aSelector); + var range = document.createRange(); + range.selectNodeContents(dn); + window.getSelection().removeAllRanges(); + window.getSelection().addRange(range); + if (aCb) { + aCb(); + } +} + +function selectInputNode(aSelector, aCb) { + var dn = document.querySelector(aSelector); + synthesizeMouse(dn, 10, 10, {}); + SimpleTest.executeSoon(function () { + synthesizeKey("A", { accelKey: true }); + // Clear the user activation state which is set from synthesized mouse and + // key event. + SpecialPowers.wrap(document).clearUserGestureActivation(); + SimpleTest.executeSoon(aCb); + }); +} + +// Callback functions for attaching to the button +function execCommand(aCommand, aShouldSucceed, aAsync = false) { + var cb = function (e) { + e.preventDefault(); + document.removeEventListener("keydown", cb); + + if (aAsync) { + setTimeout(() => { + is( + aShouldSucceed, + document.execCommand(aCommand), + "Keydown caused " + aCommand + " invocation" + testLoc() + ); + }, 0); + } else { + is( + aShouldSucceed, + document.execCommand(aCommand), + "Keydown caused " + aCommand + " invocation" + testLoc() + ); + } + }; + return cb; +} + +// The basic test set. Tries to cut/copy everything +function cutCopyAll( + aDoCut, + aDoCopy, + aDone, + aNegate, + aClipOverride, + aJustClipboardNegate +) { + var execCommandAlwaysSucceed = !!(aClipOverride || aJustClipboardNegate); + + function waitForClipboard(aCond, aSetup, aNext, aNegateOne) { + if (aClipOverride) { + aCond = aClipOverride; + aNegateOne = false; + } + if (aNegate || aNegateOne || aJustClipboardNegate) { + SimpleTest.waitForClipboard( + null, + aSetup, + aNext, + aNext, + "text/plain", + WATCH_TIMEOUT, + true + ); + } else { + SimpleTest.waitForClipboard(aCond, aSetup, aNext, aNext); + } + } + + function validateCutCopy(aExpectedCut, aExpectedCopy) { + if (aNegate) { + aExpectedCut = aExpectedCopy = 0; + } // When we are negating - we always expect callbacks not to be run + + is( + aExpectedCut, + gCutCount, + (aExpectedCut > 0 + ? "Expect cut callback to run" + : "Expect cut callback not to run") + testLoc() + ); + is( + aExpectedCopy, + gCopyCount, + (aExpectedCopy > 0 + ? "Expect copy callback to run" + : "Expect copy callback not to run") + testLoc() + ); + gCutCount = gCopyCount = 0; + } + + function step(n) { + function nextStep() { + step(n + 1); + } + + // Reset the user activation state before running next test. + SpecialPowers.wrap(document).clearUserGestureActivation(); + + document.querySelector("span").textContent = "span text"; + document.querySelector("input[type=text]").value = "text text"; + document.querySelector("input[type=password]").value = "password text"; + document.querySelector("textarea").value = "textarea text"; + + var contentEditableNode = document.querySelector( + "div[contentEditable=true]" + ); + if (contentEditableNode) { + contentEditableNode.textContent = "contenteditable text"; + } + + gTestN2 = n; + switch (n) { + case 0: + // copy on readonly selection + selectNode("span"); + waitForClipboard( + "span text", + function () { + aDoCopy(true); + }, + nextStep + ); + return; + + case 1: + validateCutCopy(0, 1); + + // cut on readonly selection + selectNode("span"); + + waitForClipboard( + "span text", + function () { + aDoCut(execCommandAlwaysSucceed); + }, + nextStep, + true + ); + return; + + case 2: + validateCutCopy(1, 0); + + // copy on textbox selection + selectInputNode("input[type=text]", nextStep); + return; + + case 3: + waitForClipboard( + "text text", + function () { + selectInputNode("input[type=text]", function () { + aDoCopy(true); + }); + }, + nextStep + ); + return; + + case 4: + validateCutCopy(0, 1); + + // cut on textbox selection + selectInputNode("input[type=text]", nextStep); + return; + + case 5: + waitForClipboard( + "text text", + function () { + aDoCut(true); + }, + nextStep + ); + return; + + case 6: + validateCutCopy(1, 0); + + // copy on password selection + selectInputNode("input[type=password]", nextStep); + return; + + case 7: + waitForClipboard( + null, + function () { + aDoCopy(execCommandAlwaysSucceed); + }, + nextStep, + true + ); + return; + + case 8: + validateCutCopy(0, 1); + + // cut on password selection + selectInputNode("input[type=password]", nextStep); + return; + + case 9: + waitForClipboard( + null, + function () { + aDoCut(execCommandAlwaysSucceed); + }, + nextStep, + true + ); + return; + + case 10: + validateCutCopy(1, 0); + + // copy on textarea selection + selectInputNode("textarea", nextStep); + return; + + case 11: + waitForClipboard( + "textarea text", + function () { + aDoCopy(true); + }, + nextStep + ); + return; + + case 12: + validateCutCopy(0, 1); + + // cut on password selection + selectInputNode("textarea", nextStep); + return; + + case 13: + waitForClipboard( + "textarea text", + function () { + aDoCut(true); + }, + nextStep + ); + return; + + case 14: + validateCutCopy(1, 0); + + // copy on no selection + document.querySelector("textarea").blur(); + + waitForClipboard( + null, + function () { + aDoCopy(true); + }, + nextStep, + true + ); + return; + + case 15: + validateCutCopy(0, 1); + + // cut on no selection + waitForClipboard( + null, + function () { + aDoCut(execCommandAlwaysSucceed); + }, + nextStep, + true + ); + return; + + case 16: + validateCutCopy(1, 0); + + if (!document.querySelector("div[contentEditable=true]")) { + // We're done! (no contentEditable node!) + step(-1); + return; + } + break; + + case 17: + // copy on contenteditable selection + waitForClipboard( + "contenteditable text", + function () { + selectNode("div[contentEditable=true]", function () { + aDoCopy(true); + }); + }, + nextStep + ); + return; + + case 18: + validateCutCopy(0, 1); + break; + + case 19: + // cut on contenteditable selection + waitForClipboard( + "contenteditable text", + function () { + selectNode("div[contentEditable=true]", function () { + aDoCut(true); + }); + }, + nextStep + ); + return; + + case 20: + validateCutCopy(1, 0); + break; + + default: + aDone(); + return; + } + + SimpleTest.executeSoon(function () { + step(n + 1); + }); + } + + step(0); +} + +function allMechanisms(aCb, aClipOverride, aNegateAll) { + function testStep(n) { + gTestN1 = n; + switch (n) { + /** Test for Bug 1012662 **/ + case 0: + // Keyboard issued + cutCopyAll( + function docut(aSucc) { + synthesizeKey("x", { accelKey: true }); + }, + function docopy(aSucc) { + synthesizeKey("c", { accelKey: true }); + }, + function done() { + testStep(n + 1); + }, + false, + aClipOverride, + aNegateAll + ); + return; + + case 1: + // Button issued + cutCopyAll( + function docut(aSucc) { + document.addEventListener("keydown", execCommand("cut", aSucc)); + sendString("Q"); + }, + function docopy(aSucc) { + document.addEventListener("keydown", execCommand("copy", aSucc)); + sendString("Q"); + }, + function done() { + testStep(n + 1); + }, + false, + aClipOverride, + aNegateAll + ); + return; + + case 2: + // Not triggered by user gesture + cutCopyAll( + function doCut(aSucc) { + is( + false, + document.execCommand("cut"), + "Can't directly execCommand not in a user callback" + ); + }, + function doCopy(aSucc) { + is( + false, + document.execCommand("copy"), + "Can't directly execCommand not in a user callback" + ); + }, + function done() { + testStep(n + 1); + }, + true, + aClipOverride, + aNegateAll + ); + return; + + /** Test for Bug 1597857 **/ + case 3: + // Button issued async + cutCopyAll( + function docut(aSucc) { + document.addEventListener( + "keydown", + execCommand("cut", aSucc, true) + ); + sendString("Q"); + }, + function docopy(aSucc) { + document.addEventListener( + "keydown", + execCommand("copy", aSucc, true) + ); + sendString("Q"); + }, + function done() { + testStep(n + 1); + }, + false, + aClipOverride, + aNegateAll + ); + return; + + default: + aCb(); + } + } + testStep(0); +} + +// Run the tests +SimpleTest.waitForExplicitFinish(); +SimpleTest.requestLongerTimeout(5); // On the emulator - this times out occasionally +SimpleTest.waitForFocus(function () { + function justCancel(aEvent) { + aEvent.preventDefault(); + } + + function override(aEvent) { + aEvent.clipboardData.setData("text/plain", "overridden"); + aEvent.preventDefault(); + } + + allMechanisms(function () { + gTestN0 = 1; + document.addEventListener("cut", override); + document.addEventListener("copy", override); + + allMechanisms(function () { + gTestN0 = 2; + document.removeEventListener("cut", override); + document.removeEventListener("copy", override); + document.addEventListener("cut", justCancel); + document.addEventListener("copy", justCancel); + + allMechanisms( + function () { + SimpleTest.finish(); + }, + null, + true + ); + }, "overridden"); + }); +}); diff --git a/dom/base/test/useractivation/file_empty.html b/dom/base/test/useractivation/file_empty.html new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/dom/base/test/useractivation/file_empty.html diff --git a/dom/base/test/useractivation/file_iframe_check_user_activation.html b/dom/base/test/useractivation/file_iframe_check_user_activation.html new file mode 100644 index 0000000000..0a3ec734a6 --- /dev/null +++ b/dom/base/test/useractivation/file_iframe_check_user_activation.html @@ -0,0 +1,22 @@ +<!DOCTYPE html> +<html> +<head> + <title>user activated iframe</title> +</head> +<body> +<script> +onload = function() { + parent.postMessage("loaded", "*"); +}; +onmessage = function(e) { + if (e.data === "get") { + parent.postMessage({ + isActivated: SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + hasBeenActivated: SpecialPowers.wrap(document).hasBeenUserGestureActivated, + lastActivationTimestamp: SpecialPowers.wrap(document).lastUserGestureTimeStamp, + }, "*"); + } +}; +</script> +</body> +</html> diff --git a/dom/base/test/useractivation/file_iframe_consume_user_activation.html b/dom/base/test/useractivation/file_iframe_consume_user_activation.html new file mode 100644 index 0000000000..ad27453f1a --- /dev/null +++ b/dom/base/test/useractivation/file_iframe_consume_user_activation.html @@ -0,0 +1,15 @@ +<!DOCTYPE html> +<html> +<head> + <title>user activated iframe</title> +</head> +<body> +<script> +onload = function() { + SpecialPowers.wrap(document).notifyUserGestureActivation(); + SpecialPowers.wrap(document).consumeTransientUserGestureActivation(); + parent.postMessage("done", "*"); +} +</script> +</body> +</html>
\ No newline at end of file diff --git a/dom/base/test/useractivation/file_iframe_user_activated.html b/dom/base/test/useractivation/file_iframe_user_activated.html new file mode 100644 index 0000000000..8d188001e8 --- /dev/null +++ b/dom/base/test/useractivation/file_iframe_user_activated.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<html> +<head> + <title>user activated iframe</title> +</head> +<body> +<script> +onload = function() { + SpecialPowers.wrap(document).notifyUserGestureActivation(); + parent.postMessage("done", "*"); +} +</script> +</body> +</html>
\ No newline at end of file diff --git a/dom/base/test/useractivation/file_useractivation_sandbox_transient_popup.html b/dom/base/test/useractivation/file_useractivation_sandbox_transient_popup.html new file mode 100644 index 0000000000..25bc2037c3 --- /dev/null +++ b/dom/base/test/useractivation/file_useractivation_sandbox_transient_popup.html @@ -0,0 +1,20 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>User activation popup</title> +</head> +<body> +<iframe sandbox="allow-top-navigation-by-user-activation allow-scripts allow-same-origin"></iframe> +<script> + window.addEventListener("message", (e) => { + if (e.data === "triggerIframeLoad") { + // Load into the the iframe a script which notifies the opener of top level navigation or if it was prevented. + let script = `window.opener.postMessage("topNavigation");`; + frames[0].frameElement.src = `javascript:try{window.top.location='javascript:${encodeURIComponent(script)}';} catch (e) {window.top.opener.postMessage("topNavigationBlocked");}`; + } else { + window.opener.postMessage("unexpected"); + } + }); +</script> +</body> +</html> diff --git a/dom/base/test/useractivation/mochitest.ini b/dom/base/test/useractivation/mochitest.ini new file mode 100644 index 0000000000..26c8594be8 --- /dev/null +++ b/dom/base/test/useractivation/mochitest.ini @@ -0,0 +1,23 @@ +[DEFAULT] +support-files = + file_empty.html + file_iframe_user_activated.html + file_iframe_check_user_activation.html + file_iframe_consume_user_activation.html + file_clipboard_common.js +prefs = + formhelper.autozoom.force-disable.test-only=true + +[test_useractivation_has_been_activated.html] +[test_useractivation_key_events.html] +[test_useractivation_transient.html] +[test_useractivation_sandbox_transient.html] +support-files = file_useractivation_sandbox_transient_popup.html +[test_useractivation_scrollbar.html] +skip-if = os == 'android' # scrollbar not showed on mobile +[test_useractivation_transient_consuming.html] +[test_clipboard_editor.html] +[test_clipboard_noeditor.html] +[test_popup_blocker_mouse_event.html] +[test_popup_blocker_pointer_event.html] +[test_popup_blocker_async_callback.html] diff --git a/dom/base/test/useractivation/moz.build b/dom/base/test/useractivation/moz.build new file mode 100644 index 0000000000..60b508c774 --- /dev/null +++ b/dom/base/test/useractivation/moz.build @@ -0,0 +1,9 @@ +# -*- 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/. + +MOCHITEST_MANIFESTS += [ + "mochitest.ini", +] diff --git a/dom/base/test/useractivation/test_clipboard_editor.html b/dom/base/test/useractivation/test_clipboard_editor.html new file mode 100644 index 0000000000..691e8e4a20 --- /dev/null +++ b/dom/base/test/useractivation/test_clipboard_editor.html @@ -0,0 +1,31 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1012662 +https://bugzilla.mozilla.org/show_bug.cgi?id=1597857 +--> +<head> + <title>Test for Clipboard</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script src="/tests/SimpleTest/WindowSnapshot.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1012662">Mozilla Bug 1012662</a><br> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1597857">Mozilla Bug 1597857</a> +<p id="display"></p> + +<div id="content"> + <span>span text</span> + <input type="text" value="text text"> + <input type="password" value="password text"> + <textarea>textarea text</textarea> + <div contentEditable="true">contenteditable text</div> +</div> + +<pre id="test"> +<script type="application/javascript" src="file_clipboard_common.js"></script> +</pre> +</body> +</html> diff --git a/dom/base/test/useractivation/test_clipboard_noeditor.html b/dom/base/test/useractivation/test_clipboard_noeditor.html new file mode 100644 index 0000000000..f7f3d6cb99 --- /dev/null +++ b/dom/base/test/useractivation/test_clipboard_noeditor.html @@ -0,0 +1,29 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1012662 +--> +<head> + <title>Test for Clipboard</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script src="/tests/SimpleTest/WindowSnapshot.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1012662">Mozilla Bug 1012662</a><br> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1597857">Mozilla Bug 1597857</a> +<p id="display"></p> + +<div id="content"> + <span>span text</span> + <input type="text" value="text text"> + <input type="password" value="password text"> + <textarea>textarea text</textarea> +</div> + +<pre id="test"> +<script type="application/javascript" src="file_clipboard_common.js"></script> +</pre> +</body> +</html> diff --git a/dom/base/test/useractivation/test_popup_blocker_async_callback.html b/dom/base/test/useractivation/test_popup_blocker_async_callback.html new file mode 100644 index 0000000000..dc53596531 --- /dev/null +++ b/dom/base/test/useractivation/test_popup_blocker_async_callback.html @@ -0,0 +1,83 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> + <title>Test for triggering popup by mouse events</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<div id="target" style="width: 50px; height: 50px; background: green"></div> +<script> + +SimpleTest.requestFlakyTimeout("Need to test setTimeout"); + +function startTest(aTestAsyncFun, aAllowPopup = true) { + return new Promise(aResolve => { + let target = document.getElementById("target"); + target.addEventListener("click", (e) => { + aTestAsyncFun(() => { + let w = window.open("about:blank"); + is(!!w, aAllowPopup, `Should ${aAllowPopup ? "allow" : "block"} popup`); + if (w) { + w.close(); + } + aResolve(); + }); + }, {once: true}); + synthesizeMouseAtCenter(target, {type: "mousedown"}); + synthesizeMouseAtCenter(target, {type: "mouseup"}); + }); +} + +add_setup(async function() { + await SpecialPowers.pushPrefEnv({"set": [ + ["dom.disable_open_during_load", true], + ["dom.serviceWorkers.enabled", true], + ["dom.serviceWorkers.testing.enabled", true], + ]}); +}); + +[ + // setTimeout + function testSetTimout(aCallback) { + setTimeout(aCallback, 500); + }, + // fetch + function testFetch(aCallback) { + fetch("../dummy.html").then(aCallback); + }, + // requestStorageAccess + function testRequestStorageAccess(aCallback) { + document.requestStorageAccess().then(aCallback); + }, + // serviceWorker.getRegistration + function testGetServiceWorkerRegistration(aCallback) { + navigator.serviceWorker.getRegistration("/app").then(aCallback); + }, +].forEach(testAsyncFun => { + add_task(async function() { + info(`start ${testAsyncFun.name}`); + SpecialPowers.wrap(document).clearUserGestureActivation(); + await startTest(testAsyncFun); + await new Promise(aResolve => SimpleTest.executeSoon(aResolve)); + }); +}); + +// Test popup should be blocked if user transient is timeout +add_task(async function timeout() { + info(`start user transient timeout`); + await SpecialPowers.pushPrefEnv({"set": [ + ["dom.user_activation.transient.timeout", 1000], + ]}); + SpecialPowers.wrap(document).clearUserGestureActivation(); + await startTest((aCallback) => { + setTimeout(aCallback, 2000); + }, false); + await new Promise(aResolve => SimpleTest.executeSoon(aResolve)); +}); + +</script> +</body> +</html> diff --git a/dom/base/test/useractivation/test_popup_blocker_mouse_event.html b/dom/base/test/useractivation/test_popup_blocker_mouse_event.html new file mode 100644 index 0000000000..fd94150f1e --- /dev/null +++ b/dom/base/test/useractivation/test_popup_blocker_mouse_event.html @@ -0,0 +1,98 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> + <title>Test for triggering popup by mouse events</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<div id="target" style="width: 50px; height: 50px; background: green"></div> +<script> + +function sendMouseEvent(element, eventName, button, listenEventName, handler) { + let needToCheckHandler = false; + let handlerIsCalled = false; + if (listenEventName && handler) { + needToCheckHandler = true; + element.addEventListener(listenEventName, (e) => { + handler(e); + handlerIsCalled = true; + }, {once: true}); + } + synthesizeMouseAtCenter(element, {type: eventName, button}); + if (needToCheckHandler) { + ok(handlerIsCalled, "Handler should be called"); + } +} + +function checkAllowOpenPopup(e) { + let w = window.open("about:blank"); + ok(w, `Should allow popup in the ${e.type} listener with button=${e.button}`); + if (w) { + w.close(); + } +} + +function checkBlockOpenPopup(e) { + let w = window.open("about:blank"); + ok(!w, `Should block popup in the ${e.type} listener with button=${e.button}`); + if (w) { + w.close(); + } +} + +add_setup(async function() { + const DENY_ACTION = SpecialPowers.Ci.nsIPermissionManager.DENY_ACTION; + let xorigin = SimpleTest.getTestFileURL("").replace(location.hostname, 'mochi.xorigin-test'); + await SpecialPowers.pushPermissions([ + {'type': 'popup', 'allow': DENY_ACTION, + 'context': document}, + {'type': 'popup', 'allow': DENY_ACTION, + 'context': xorigin} + ]); + + await new Promise(resolve => SimpleTest.waitForFocus(resolve)); +}); + +const LEFT_BUTTON = 0; +const MIDDLE_BUTTON = 1; +const RIGHT_BUTTON = 2; +let target = document.getElementById("target"); + +add_task(function testMouseDownUpMove() { + // Left button + sendMouseEvent(target, "mousedown", LEFT_BUTTON, "mousedown", checkAllowOpenPopup); + sendMouseEvent(target, "mousemove", LEFT_BUTTON, "mousemove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", LEFT_BUTTON, "mouseup", checkAllowOpenPopup); + + // Middle button + sendMouseEvent(target, "mousedown", MIDDLE_BUTTON, "mousedown", checkAllowOpenPopup); + sendMouseEvent(target, "mousemove", MIDDLE_BUTTON, "mousemove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", MIDDLE_BUTTON, "mouseup", checkAllowOpenPopup); + + // Right button + sendMouseEvent(target, "mousedown", RIGHT_BUTTON, "mousedown", checkBlockOpenPopup); + sendMouseEvent(target, "mousemove", RIGHT_BUTTON, "mousemove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", RIGHT_BUTTON, "mouseup", checkBlockOpenPopup); +}); + +add_task(function testMouseClick() { + // Left button + sendMouseEvent(target, "mousedown", LEFT_BUTTON); + sendMouseEvent(target, "mouseup", LEFT_BUTTON, "click", checkAllowOpenPopup); +}); + +add_task(function testMouseAuxclick() { + // Middle button + sendMouseEvent(target, "mousedown", MIDDLE_BUTTON); + sendMouseEvent(target, "mouseup", MIDDLE_BUTTON, "auxclick", checkAllowOpenPopup); + + // Right button + sendMouseEvent(target, "mousedown", RIGHT_BUTTON); + sendMouseEvent(target, "mouseup", RIGHT_BUTTON, "auxclick", checkAllowOpenPopup); +}); +</script> +</body> +</html> diff --git a/dom/base/test/useractivation/test_popup_blocker_pointer_event.html b/dom/base/test/useractivation/test_popup_blocker_pointer_event.html new file mode 100644 index 0000000000..8d0b2c8cd1 --- /dev/null +++ b/dom/base/test/useractivation/test_popup_blocker_pointer_event.html @@ -0,0 +1,122 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> + <title>Test for triggering popup by pointer events</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> + <div id="target" style="width: 50px; height: 50px; background: green"></div> + <script> + + function sendMouseEvent(element, eventName, button, listenEventName, handler) { + let needToCheckHandler = false; + let handlerIsCalled = false; + if (listenEventName && handler) { + needToCheckHandler = true; + element.addEventListener(listenEventName, (e) => { + handler(e); + handlerIsCalled = true; + }, {once: true}); + } + synthesizeMouseAtCenter(element, {type: eventName, button}); + if (needToCheckHandler) { + ok(handlerIsCalled, "Handler should be called"); + } + } + + function checkAllowOpenPopup(e) { + let w = window.open("about:blank"); + ok(w, `Should allow popup in the ${e.type} listener with button=${e.button}`); + if (w) { + w.close(); + } + } + + function checkBlockOpenPopup(e) { + let w = window.open("about:blank"); + ok(!w, `Should block popup in the ${e.type} listener with button=${e.button}`); + if (w) { + w.close(); + } + } + + add_setup(async function() { + const DENY_ACTION = SpecialPowers.Ci.nsIPermissionManager.DENY_ACTION; + let xorigin = SimpleTest.getTestFileURL("").replace(location.hostname, 'mochi.xorigin-test'); + await SpecialPowers.pushPermissions([ + {'type': 'popup', 'allow': DENY_ACTION, + 'context': document}, + {'type': 'popup', 'allow': DENY_ACTION, + 'context': xorigin} + ]); + await new Promise(resolve => SimpleTest.waitForFocus(resolve)); + }); + + const LEFT_BUTTON = 0; + const MIDDLE_BUTTON = 1; + const RIGHT_BUTTON = 2; + let target = document.getElementById("target"); + + add_task(function testPointerEventDefault() { + // By default, only allow opening popup in the pointerup listener. + // Left button + sendMouseEvent(target, "mousedown", LEFT_BUTTON, "pointerdown", checkAllowOpenPopup); + sendMouseEvent(target, "mousemove", LEFT_BUTTON, "pointermove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", LEFT_BUTTON, "pointerup", checkAllowOpenPopup); + + // Middle button + sendMouseEvent(target, "mousedown", MIDDLE_BUTTON, "pointerdown", checkAllowOpenPopup); + sendMouseEvent(target, "mousemove", MIDDLE_BUTTON, "pointermove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", MIDDLE_BUTTON, "pointerup", checkAllowOpenPopup); + + // Right button + sendMouseEvent(target, "mousedown", RIGHT_BUTTON, "pointerdown", checkBlockOpenPopup); + sendMouseEvent(target, "mousemove", RIGHT_BUTTON, "pointermove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", RIGHT_BUTTON, "pointerup", checkBlockOpenPopup); + }); + + add_task(async function testPointerEventAddPointerDownToPref() { + // Adding pointerdown to preference + await SpecialPowers.pushPrefEnv({"set": [["dom.popup_allowed_events", + "pointerdown pointerup"]]}); + // Left button + sendMouseEvent(target, "mousedown", LEFT_BUTTON, "pointerdown", checkAllowOpenPopup); + sendMouseEvent(target, "mousemove", LEFT_BUTTON, "pointermove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", LEFT_BUTTON, "pointerup", checkAllowOpenPopup); + + // Middle button + sendMouseEvent(target, "mousedown", MIDDLE_BUTTON, "pointerdown", checkAllowOpenPopup); + sendMouseEvent(target, "mousemove", MIDDLE_BUTTON, "pointermove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", MIDDLE_BUTTON, "pointerup", checkAllowOpenPopup); + + // Right button + sendMouseEvent(target, "mousedown", RIGHT_BUTTON, "pointerdown", checkBlockOpenPopup); + sendMouseEvent(target, "mousemove", RIGHT_BUTTON, "pointermove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", RIGHT_BUTTON, "pointerup", checkBlockOpenPopup); + }); + + add_task(async function testPointerEventAddPointerMoveToPref() { + // Adding pointermove to preference should have no effect. + await SpecialPowers.pushPrefEnv({"set": [["dom.popup_allowed_events", + "pointerdown pointerup pointermove"]]}); + // Left button + sendMouseEvent(target, "mousedown", LEFT_BUTTON, "pointerdown", checkAllowOpenPopup); + sendMouseEvent(target, "mousemove", LEFT_BUTTON, "pointermove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", LEFT_BUTTON, "pointerup", checkAllowOpenPopup); + + // Middle button + sendMouseEvent(target, "mousedown", MIDDLE_BUTTON, "pointerdown", checkAllowOpenPopup); + sendMouseEvent(target, "mousemove", MIDDLE_BUTTON, "pointermove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", MIDDLE_BUTTON, "pointerup", checkAllowOpenPopup); + + // Right button + sendMouseEvent(target, "mousedown", RIGHT_BUTTON, "pointerdown", checkBlockOpenPopup); + sendMouseEvent(target, "mousemove", RIGHT_BUTTON, "pointermove", checkBlockOpenPopup); + sendMouseEvent(target, "mouseup", RIGHT_BUTTON, "pointerup", checkBlockOpenPopup); + }); + </script> +</body> +</html> diff --git a/dom/base/test/useractivation/test_useractivation_has_been_activated.html b/dom/base/test/useractivation/test_useractivation_has_been_activated.html new file mode 100644 index 0000000000..f46618915b --- /dev/null +++ b/dom/base/test/useractivation/test_useractivation_has_been_activated.html @@ -0,0 +1,115 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>User activation test: has been user gesture activated</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<iframe></iframe> +<script> + +function waitForEvent(aTarget, aEvent, aCallback) { + return new Promise((aResolve) => { + aTarget.addEventListener(aEvent, function listener(event) { + aCallback(event); + aResolve(); + }, { once: true }); + }); +} + +let [iframe0, iframe1] = document.querySelectorAll("iframe"); + +function doCheck(aDocument, aName, aHasBeenUserGestureActivated) { + is(SpecialPowers.wrap(aDocument).hasBeenUserGestureActivated, + aHasBeenUserGestureActivated, + `check has-been-user-activated on the ${aName}`); + if (aHasBeenUserGestureActivated) { + ok(SpecialPowers.wrap(aDocument).lastUserGestureTimeStamp > 0, + `check last-user-gesture-timestamp on the ${aName}`); + } else { + is(SpecialPowers.wrap(aDocument).lastUserGestureTimeStamp, 0, + `check last-user-gesture-timestamp on the ${aName}`); + } +} + +add_task(async function checkInitialStatus() { + doCheck(document, "top-level document", false); + doCheck(frames[0].document, "first iframe", false); + doCheck(frames[1].document, "second iframe", false); +}); + +add_task(async function triggerUserActivation() { + // Trigger user activation on the first iframe. + SpecialPowers.wrap(frames[0].document).notifyUserGestureActivation(); + // We should also propagate to all the ancestors. + doCheck(document, "top-level document", true); + doCheck(frames[0].document, "first iframe", true); + doCheck(frames[1].document, "second iframe", false); +}); + +add_task(async function iframeNavigation() { + frames[0].frameElement.src = "file_empty.html"; + await waitForEvent(frames[0].frameElement, "load", () => {}); + // We should reset the flag on iframe that navigates away from current page, + // but the flag on its ancestor isn't changed. + doCheck(document, "top-level document", true); + doCheck(frames[0].document, "first iframe", false); + doCheck(frames[1].document, "second iframe", false); +}); + +add_task(async function triggerUserActivationOnCrossOriginFrame() { + // Reset the activation flag. + SpecialPowers.wrap(document).clearUserGestureActivation(); + doCheck(document, "top-level document", false); + + // load cross-origin test page on iframe. + frames[0].frameElement.src = "https://example.com/tests/dom/base/test/useractivation/file_iframe_user_activated.html"; + await waitForEvent(window, "message", (event) => { + if (event.data === "done") { + doCheck(document, "top-level document", true); + doCheck(frames[1].document, "second iframe", false); + } else { + ok(false, "receive unexpected message: " + event.data); + } + }); +}); + +add_task(async function propagateToSameOriginConnectedSubframe() { + // Reset the activation flag. + SpecialPowers.wrap(document).clearUserGestureActivation(); + + // load cross-origin test page on iframe. + iframe0.src = "https://example.com/tests/dom/base/test/useractivation/file_iframe_check_user_activation.html"; + await waitForEvent(window, "message", (event) => { + if (event.data !== "loaded") { + ok(false, "receive unexpected message: " + event.data); + } + }); + + // Trigger user activation on top-level document. + SpecialPowers.wrap(document).notifyUserGestureActivation(); + doCheck(document, "top-level document", true); + doCheck(iframe1.contentDocument, "second iframe", true); + + iframe0.contentWindow.postMessage("get", "*"); + await waitForEvent(window, "message", (event) => { + if (typeof event.data === "object") { + ok(!event.data.hasBeenActivated, "check has-been-user-activated on the first iframe"); + is(event.data.lastActivationTimestamp, 0, "check last-user-gesture-timestamp on the first iframe"); + } else { + ok(false, "receive unexpected message: " + event.data); + } + }); +}); + +add_task(async function endTests() { + // Reset the activation flag in order not to interfere following test in the + // verify mode which would run the test using same document couple times. + SpecialPowers.wrap(document).clearUserGestureActivation(); +}); + +</script> +</body> diff --git a/dom/base/test/useractivation/test_useractivation_key_events.html b/dom/base/test/useractivation/test_useractivation_key_events.html new file mode 100644 index 0000000000..d97906c22b --- /dev/null +++ b/dom/base/test/useractivation/test_useractivation_key_events.html @@ -0,0 +1,91 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>User activation test: key events</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script> + +function synthesizeKeyAndWait(aKey, aEvent) { + let promise = new Promise(aResolve => { + document.addEventListener("keydown", function(e) { + e.preventDefault(); + aResolve(); + }, { once: true }); + }); + synthesizeKey(aKey, aEvent, window); + return promise; +} + +add_task(async function TestPrintableKey() { + let tests = [ 'a', 'b', 'c', 'A', 'B', '1', '2', '3' ]; + + for (let key of tests) { + SpecialPowers.wrap(document).clearUserGestureActivation(); + await synthesizeKeyAndWait(key, {}); + ok(SpecialPowers.wrap(document).hasBeenUserGestureActivated, + `check has-been-user-activated for ${key}`); + ok(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + `check has-valid-transient-user-activation for ${key}`); + } +}); + +add_task(async function TestNonPrintableKey() { + let tests = [ [ "KEY_Alt", false], + [ "KEY_Backspace", false], + [ "KEY_Escape" , false ], + [ "KEY_Tab" , false ], + // Treat as user input + [ "KEY_Enter", true], + [ " ", true] ]; + + for (let [key, expectedResult] of tests) { + SpecialPowers.wrap(document).clearUserGestureActivation(); + await synthesizeKeyAndWait(key, {}); + is(SpecialPowers.wrap(document).hasBeenUserGestureActivated, expectedResult, + `check has-been-user-activated for "${key}"`); + is(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, expectedResult, + `check has-valid-transient-user-activation for "${key}"`); + } +}); + +add_task(async function TestModifier() { + let tests = [ [ 'a', { altKey: true }, false], + [ 'a', { ctrlKey: true }, false], + [ 'a', { metaKey: true }, false], + [ 'a', { osKey: true }, false], + [ 'c', { altKey: true }, false ], + [ 'c', { osKey: true }, false ], + [ 'v', { altKey: true }, false ], + [ 'v', { osKey: true }, false ], + [ 'x', { altKey: true }, false ], + [ 'x', { osKey: true }, false ], + // Treat as user input + [ 'a', { altGraphKey: true }, true ], + [ 'a', { fnKey: true }, true ], + [ 'a', { shiftKey: true }, true ], + [ 'c', { accelKey: true }, true ], + [ 'v', { accelKey: true }, true ], + [ 'x', { accelKey: true }, true ] ]; + + for (let [key, event, expectedResult] of tests) { + SpecialPowers.wrap(document).clearUserGestureActivation(); + await synthesizeKeyAndWait(key, event); + is(SpecialPowers.wrap(document).hasBeenUserGestureActivated, expectedResult, + `check has-been-user-activated for ${key} with ${JSON.stringify(event)}`); + is(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, expectedResult, + `check has-valid-transient-user-activation for ${key} with ${JSON.stringify(event)}`); + } +}); + +add_task(async function endTests() { + // Reset the activation flag in order not to interfere following test in the + // verify mode which would run the test using same document couple times. + SpecialPowers.wrap(document).clearUserGestureActivation(); +}); + +</script> +</body> diff --git a/dom/base/test/useractivation/test_useractivation_sandbox_transient.html b/dom/base/test/useractivation/test_useractivation_sandbox_transient.html new file mode 100644 index 0000000000..6b0fcb50f0 --- /dev/null +++ b/dom/base/test/useractivation/test_useractivation_sandbox_transient.html @@ -0,0 +1,90 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>User activation test: transient flag</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<script> +SimpleTest.requestFlakyTimeout("Timeouts are needed to test transient user_activation"); +let timeout = SpecialPowers.getIntPref("dom.user_activation.transient.timeout") + 1000; + +function waitForEvent(aTarget, aEvent, aCallback) { + return new Promise((aResolve) => { + aTarget.addEventListener(aEvent, function listener(event) { + aCallback(event); + aResolve(); + }, { once: true }); + }); +} + +function checkPopupActivated(popup, activated) { + let state = activated ? "valid" : "invalid"; + ok(activated === SpecialPowers.wrap(popup.document).hasValidTransientUserGestureActivation, + `check has-${state}-transient-user-activation on top-level document`); + ok(activated === SpecialPowers.wrap(popup.frames[0].document).hasValidTransientUserGestureActivation, + `check has-${state}-transient-user-activation on iframe`); +} + +add_task(async function triggerUserActivation() { + let message = waitForEvent(window, "message", (e) => { + if (e.data === "topNavigation") { + ok(true, "Top navigation changed"); + } else { + ok(false, "Unexpected message"); + } + }); + let popup = window.open("./file_useractivation_sandbox_transient_popup.html", "_blank"); + await new Promise((r) => { + popup.addEventListener("load", r); + }); + checkPopupActivated(popup, false); + // Create user gesture into iframe within popup just opened + SpecialPowers.wrap(popup.frames[0].frameElement.contentDocument).notifyUserGestureActivation(); + checkPopupActivated(popup, true); + // Notify popup to load into the frame + popup.postMessage("triggerIframeLoad"); + await message; + popup.close(); +}); + +add_task(async function triggerUserActivationTimeout() { + let message = waitForEvent(window, "message", (e) => { + // Top navigation MUST be blocked + if (e.data === "topNavigationBlocked") { + ok(true, "Top navigation blocked"); + } else { + ok(false, "Unexpected message"); + } + }); + let popup = window.open("./file_useractivation_sandbox_transient_popup.html", "_blank"); + await new Promise((r) => { + popup.addEventListener("load", r); + }); + checkPopupActivated(popup, false); + // Create user gesture into iframe within popup just opened + SpecialPowers.wrap(popup.frames[0].frameElement.contentDocument).notifyUserGestureActivation(); + checkPopupActivated(popup, true); + // Ensure we timeout user gesture + await new Promise((aResolve) => { + setTimeout(() => { + checkPopupActivated(popup, false); + aResolve(); + }, timeout); + }); + // Notify popup to load into the frame + popup.postMessage("triggerIframeLoad"); + await message; + popup.close(); +}); + +add_task(async function endTests() { + // Reset the activation flag in order not to interfere following test in the + // verify mode which would run the test using same document couple times. + SpecialPowers.wrap(document).clearUserGestureActivation(); +}); + +</script> +</body> diff --git a/dom/base/test/useractivation/test_useractivation_scrollbar.html b/dom/base/test/useractivation/test_useractivation_scrollbar.html new file mode 100644 index 0000000000..778d6d0898 --- /dev/null +++ b/dom/base/test/useractivation/test_useractivation_scrollbar.html @@ -0,0 +1,135 @@ +<!DOCTYPE HTML> +<html> +<head> +<title>User activation test: consume transient flag</title> +<script src="/tests/SimpleTest/SimpleTest.js"></script> +<script src="/tests/SimpleTest/EventUtils.js"></script> +<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<textarea style="height: 100px; resize: none"> +  +  +  +  +  +  +  +  +  +  +  +  +  +</textarea> +<div id="target" style="height: 100px; width: 200px; overflow: scroll"> + <br> + <br> + <br> + <br> + <br> + <br> + <br> + <br> + <br> + <br> + <br> + <br> + <br> +</div> +<div style="height: 2000px; width: 500px; background-color: green;"></div> +<script> + +// Open a new window to ensure scrollbar is always visible. +if (!opener) { + add_task(async function init() { + // Turn on the prefs that force overlay scrollbars to always be visible. + await SpecialPowers.pushPrefEnv({ + set: [["layout.testing.overlay-scrollbars.always-visible", true]], + }); + }); + + async function testOnNewWindow(aPrefValue) { + await SpecialPowers.pushPrefEnv({ + set: [["dom.user_activation.ignore_scrollbars", aPrefValue]], + }); + + let win = window.open(location); + // wait for message + await new Promise((aResolve) => { + window.addEventListener("message", function listener(event) { + if ("done" == event.data) { + window.removeEventListener("message", listener); + aResolve(); + } + }); + }); + win.close(); + } + + add_task(async function test_pref_on() { + await testOnNewWindow(true); + }); + + add_task(async function test_pref_off() { + await testOnNewWindow(false); + }); +} else { + SimpleTest.waitForFocus(async function() { + function waitForEvent(aTarget, aEvent) { + return new Promise((aResolve) => { + aTarget.addEventListener(aEvent, function listener(event) { + aResolve(); + }, { once: true }); + }); + } + + let ignoreScrollbars = SpecialPowers.getBoolPref("dom.user_activation.ignore_scrollbars"); + + SpecialPowers.wrap(document).clearUserGestureActivation(); + let textarea = document.querySelector("textarea"); + var rect = textarea.getBoundingClientRect(); + + // click scrollbar of textarea + let promise = waitForEvent(textarea, "scroll"); + synthesizeMouse(textarea, rect.width - 5, rect.height / 2, {}); + await promise; + + opener.is(SpecialPowers.wrap(document).hasBeenUserGestureActivated, + !ignoreScrollbars, "check has-been-user-activated"); + opener.is(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + !ignoreScrollbars, "check has-valid-transient-user-activation"); + + SpecialPowers.wrap(document).clearUserGestureActivation(); + let div = document.querySelector("div[id=target]"); + rect = div.getBoundingClientRect(); + + // click scrollbar of div + promise = waitForEvent(div, "scroll"); + synthesizeMouse(div, rect.width - 5, rect.height / 2, {}); + await promise; + + opener.is(SpecialPowers.wrap(document).hasBeenUserGestureActivated, + !ignoreScrollbars, "check has-been-user-activated"); + opener.is(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + !ignoreScrollbars, "check has-valid-transient-user-activation"); + + SpecialPowers.wrap(document).clearUserGestureActivation(); + let body = document.querySelector("body"); + + // click scrollbar of page + promise = waitForEvent(document, "scroll"); + synthesizeMouse(body, innerWidth - 10, innerHeight / 2, {}); + await promise; + + opener.is(SpecialPowers.wrap(document).hasBeenUserGestureActivated, + !ignoreScrollbars, "check has-been-user-activated"); + opener.is(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + !ignoreScrollbars, "check has-valid-transient-user-activation"); + + opener.postMessage("done", "*"); + }, window); +} + +</script> +</body> diff --git a/dom/base/test/useractivation/test_useractivation_transient.html b/dom/base/test/useractivation/test_useractivation_transient.html new file mode 100644 index 0000000000..d3148e5d1d --- /dev/null +++ b/dom/base/test/useractivation/test_useractivation_transient.html @@ -0,0 +1,155 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>User activation test: transient flag</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<iframe></iframe> +<script> + +SimpleTest.requestFlakyTimeout("Timeouts are needed to test transient user_activation"); + +let timeout = SpecialPowers.getIntPref("dom.user_activation.transient.timeout") + 1000; +let [iframe0, iframe1] = document.querySelectorAll("iframe"); + +function waitForEvent(aTarget, aEvent, aCallback) { + return new Promise((aResolve) => { + aTarget.addEventListener(aEvent, function listener(event) { + aCallback(event); + aResolve(); + }, { once: true }); + }); +} + +add_task(async function checkInitialStatus() { + ok(!SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on top-level document"); + ok(!SpecialPowers.wrap(frames[0].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on first iframe"); + ok(!SpecialPowers.wrap(frames[1].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on second iframe"); +}); + +add_task(async function triggerUserActivation() { + // Trigger user activation on the first iframe. + SpecialPowers.wrap(frames[0].document).notifyUserGestureActivation(); + + // We should also propagate to all the ancestors. + ok(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the top-level document"); + ok(SpecialPowers.wrap(frames[0].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the first iframe"); + ok(!SpecialPowers.wrap(frames[1].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the second iframe"); +}); + +add_task(async function iframeNavigation() { + frames[0].frameElement.src = "file_empty.html"; + await waitForEvent(frames[0].frameElement, "load", () => {}); + // We should reset the flag on iframe that navigates away from current page, + // but the flag on its ancestor isn't changed. + ok(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the top-level document"); + ok(!SpecialPowers.wrap(frames[0].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the first iframe"); + ok(!SpecialPowers.wrap(frames[1].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the second iframe"); +}); + +add_task(async function triggerUserActivationTimeout() { + // Trigger user activation on the first iframe. + SpecialPowers.wrap(frames[0].document).notifyUserGestureActivation(); + + // hasValidTransientUserGestureActivation should return false after timeout. + await new Promise((aResolve) => { + setTimeout(() => { + ok(!SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the top-level document"); + ok(!SpecialPowers.wrap(frames[0].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the first iframe"); + ok(!SpecialPowers.wrap(frames[1].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the second iframe"); + aResolve(); + }, timeout); + }); + + // Trigger user activation again. + SpecialPowers.wrap(frames[0].document).notifyUserGestureActivation(); + ok(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the top-level document"); + ok(SpecialPowers.wrap(frames[0].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the first iframe"); + ok(!SpecialPowers.wrap(frames[1].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the second iframe"); +}); + +add_task(async function triggerUserActivationOnCrossOriginFrame() { + // Reset the activation flag. + SpecialPowers.wrap(document).clearUserGestureActivation(); + + // load cross-origin test page on iframe. + frames[0].frameElement.src = "https://example.com/tests/dom/base/test/useractivation/file_iframe_user_activated.html"; + await waitForEvent(window, "message", (event) => { + if (event.data === "done") { + ok(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the top-level document"); + ok(!SpecialPowers.wrap(frames[1].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the second iframe"); + } else { + ok(false, "receive unexpected message: " + event.data); + } + }); + + // hasValidTransientUserGestureActivation should return false after timeout. + await new Promise((aResolve) => { + setTimeout(() => { + ok(!SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the top-level document"); + ok(!SpecialPowers.wrap(frames[1].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the second iframe"); + aResolve(); + }, timeout); + }); +}); + +add_task(async function propagateToSameOriginConnectedSubframe() { + // Reset the activation flag. + SpecialPowers.wrap(document).clearUserGestureActivation(); + + // load cross-origin test page on iframe. + iframe0.src = "https://example.com/tests/dom/base/test/useractivation/file_iframe_check_user_activation.html"; + await waitForEvent(window, "message", (event) => { + if (event.data !== "loaded") { + ok(false, "receive unexpected message: " + event.data); + } + }); + + // Trigger user activation on top-level document. + SpecialPowers.wrap(document).notifyUserGestureActivation(); + ok(SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the top-level document"); + ok(SpecialPowers.wrap(iframe1.contentDocument).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the second iframe"); + + iframe0.contentWindow.postMessage("get", "*"); + await waitForEvent(window, "message", (event) => { + if (typeof event.data === "object") { + ok(!event.data.isActivated, "check has-valid-transient-user-activation on the first iframe"); + } else { + ok(false, "receive unexpected message: " + event.data); + } + }); +}); + +add_task(async function endTests() { + // Reset the activation flag in order not to interfere following test in the + // verify mode which would run the test using same document couple times. + SpecialPowers.wrap(document).clearUserGestureActivation(); +}); + +</script> +</body> diff --git a/dom/base/test/useractivation/test_useractivation_transient_consuming.html b/dom/base/test/useractivation/test_useractivation_transient_consuming.html new file mode 100644 index 0000000000..4178d24477 --- /dev/null +++ b/dom/base/test/useractivation/test_useractivation_transient_consuming.html @@ -0,0 +1,151 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>User activation test: consume transient flag</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<iframe></iframe> +<iframe></iframe> +<script> + +SimpleTest.requestFlakyTimeout("Timeouts are needed to test transient user_activation"); + +let timeout = SpecialPowers.getIntPref("dom.user_activation.transient.timeout") + 1000; + +function waitForEvent(aTarget, aEvent, aCallback) { + return new Promise((aResolve) => { + aTarget.addEventListener(aEvent, function listener(event) { + aCallback(event); + aResolve(); + }, { once: true }); + }); +} + +function doCheck(aDocument, aName, aHasBeenUserGestureActivated, + aHasValidTransientUserGestureActivation, + aLastUserGestureTimeStamp) { + is(SpecialPowers.wrap(aDocument).hasBeenUserGestureActivated, + aHasBeenUserGestureActivated, + `check has-been-user-activated on the ${aName}`); + is(SpecialPowers.wrap(aDocument).hasValidTransientUserGestureActivation, + aHasValidTransientUserGestureActivation, + `check has-valid-transient-user-activation on the ${aName}`); + is(SpecialPowers.wrap(aDocument).lastUserGestureTimeStamp, + aLastUserGestureTimeStamp, + `check last-user-gesture-timestamp on the ${aName}`); +} + +add_task(async function checkInitialStatus() { + doCheck(document, "top-level document", false, false, 0); + ok(!SpecialPowers.wrap(document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on top-level document"); + + doCheck(frames[0].document, "first iframe", false, false, 0); + ok(!SpecialPowers.wrap(frames[0].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on first iframe"); + + doCheck(frames[1].document, "second iframe", false, false, 0); + ok(!SpecialPowers.wrap(frames[1].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on second iframe"); +}); + +add_task(async function consumeTransientUserActivation() { + // Trigger user activation on the first iframe. + SpecialPowers.wrap(frames[0].document).notifyUserGestureActivation(); + let lastTimeStampTop = SpecialPowers.wrap(document).lastUserGestureTimeStamp; + let lastTimeStampFirst = SpecialPowers.wrap(frames[0].document).lastUserGestureTimeStamp; + + // Try to consume transient user activation. + ok(!SpecialPowers.wrap(frames[1].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on second iframe"); + ok(SpecialPowers.wrap(frames[0].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on first iframe"); + // Consuming a transient-user-activation should affect all tree. + ok(!SpecialPowers.wrap(document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on top-level document"); + + // Check has-valid-transient-user-activation and should not affect + // has-been-user-activated + doCheck(document, "top-level document", true, false, lastTimeStampTop); + doCheck(frames[0].document, "first iframe", true, false, lastTimeStampFirst); + doCheck(frames[1].document, "second iframe", false, false, 0); +}); + +add_task(async function consumeTransientUserActivationTimeout() { + // Trigger user activation on the first iframe. + SpecialPowers.wrap(frames[0].document).notifyUserGestureActivation(); + + // Should not able to consume successfully after timeout. + await new Promise((aResolve) => { + setTimeout(() => { + ok(!SpecialPowers.wrap(document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on top-level document"); + ok(!SpecialPowers.wrap(frames[0].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on first iframe"); + ok(!SpecialPowers.wrap(frames[1].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on second iframe"); + aResolve(); + }, timeout); + }); + + // Trigger user activation again. + SpecialPowers.wrap(frames[0].document).notifyUserGestureActivation(); + + // Try to consume transient user activation. + ok(!SpecialPowers.wrap(frames[1].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on second iframe"); + ok(SpecialPowers.wrap(frames[0].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on first iframe"); + // Consuming a transient-user-activation should affect all tree. + ok(!SpecialPowers.wrap(document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on top-level document"); +}); + +add_task(async function iframeNavigation() { + // Trigger user activation on the first iframe. + SpecialPowers.wrap(frames[0].document).notifyUserGestureActivation(); + + // Navigate away from current page. + frames[0].frameElement.src = "file_empty.html"; + await waitForEvent(frames[0].frameElement, "load", () => {}); + + // Try to consume transient user activation. + ok(!SpecialPowers.wrap(frames[1].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on second iframe"); + ok(!SpecialPowers.wrap(frames[0].document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on first iframe"); + ok(SpecialPowers.wrap(document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on top-level document"); +}); + +add_task(async function triggerUserActivationOnCrossOriginFrame() { + // Reset the activation flag. + SpecialPowers.wrap(document).clearUserGestureActivation(); + + // load cross-origin test page on iframe. + frames[0].frameElement.src = "https://example.com/tests/dom/base/test/useractivation/file_iframe_consume_user_activation.html"; + await waitForEvent(window, "message", (event) => { + if (event.data === "done") { + ok(!SpecialPowers.wrap(document).consumeTransientUserGestureActivation(), + "consume transient-user-activation on top-level document"); + ok(!SpecialPowers.wrap(document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the top-level document"); + ok(!SpecialPowers.wrap(frames[1].document).hasValidTransientUserGestureActivation, + "check has-valid-transient-user-activation on the second iframe"); + } else { + ok(false, "receive unexpected message: " + event.data); + } + }); +}); + +add_task(async function endTests() { + // Reset the activation flag in order not to interfere following test in the + // verify mode which would run the test using same document couple times. + SpecialPowers.wrap(document).clearUserGestureActivation(); +}); + +</script> +</body> |