| <!DOCTYPE html> |
| <meta name="timeout" content="long"> |
| <script src="/resources/testharness.js"></script> |
| <script src="/resources/testharnessreport.js"></script> |
| <script src="/resources/testdriver.js"></script> |
| <script src="/resources/testdriver-actions.js"></script> |
| <script src="/resources/testdriver-vendor.js"></script> |
| <script src="/common/utils.js"></script> |
| <script src="/common/dispatcher/dispatcher.js"></script> |
| <script src="/common/get-host-info.sub.js"></script> |
| <script src="resources/utils.js"></script> |
| <title>Test that fenced frame notifyEvent() cannot reuse a cached event</title> |
| |
| <body> |
| <script> |
| promise_test(async (t) => { |
| const fencedframe = await attachFencedFrameContext( |
| {generator_api: 'fledge'}); |
| |
| let notified_promise = new Promise((resolve) => { |
| fencedframe.element.addEventListener('fencedtreeclick', () => resolve()); |
| }); |
| |
| await fencedframe.execute(() => { |
| window.first_click_listener = (e) => { |
| // Before calling notifyEvent, cache the event for later. After this |
| // first notifyEvent call fires, we'll attempt to re-use the cached |
| // event to scam additional notifyEvent calls later. |
| window.cached_event = e; |
| window.fence.notifyEvent(e); |
| }; |
| document.addEventListener('click', window.first_click_listener); |
| }); |
| |
| await multiClick(10, 10, fencedframe.element); |
| await notified_promise; |
| |
| // That notifyEvent call should have consumed user activation. |
| let frame_has_activation = await fencedframe.execute(() => { |
| return navigator.userActivation.isActive; |
| }); |
| assert_false(frame_has_activation); |
| |
| // Now, let's do another activation, and try to call notifyEvent on |
| // the cached event. |
| // If we click again, the frame will receive another activation. If we |
| // try to call notifyEvent with the cached event instead, the call should |
| // fail, because even though the trusted click event still exists and the |
| // frame has activation, the original event has finished dispatching. |
| let second_notified_promise = new Promise((resolve) => { |
| fencedframe.element.addEventListener('fencedtreeclick', () => resolve()); |
| }); |
| await fencedframe.execute(() => { |
| // Unfortunately, a failed assertion in an event handler won't fail the |
| // whole test. So we have to wrap the handler in a Promise that can |
| // be awaited and examined from the test code. |
| document.removeEventListener('click', window.first_click_listener); |
| window.activation_promise = new Promise((resolve, reject) => { |
| document.addEventListener('click', (e) => { |
| try { |
| assert_equals(window.cached_event.type, 'click'); |
| assert_true(window.cached_event.isTrusted); |
| assert_true(navigator.userActivation.isActive); |
| // 0 = NONE, no longer dispatching. |
| assert_equals(window.cached_event.eventPhase, 0); |
| window.fence.notifyEvent(window.cached_event); |
| reject('notifyEvent() should not fire.'); |
| } catch (err) { |
| if (err.name != 'SecurityError') { |
| reject('Unexpected error: ' + err.message); |
| return; |
| } |
| resolve('PASS'); |
| } |
| }); |
| }); |
| }); |
| |
| await multiClick(10, 10, fencedframe.element); |
| |
| // After sending the mousedown events to reactivate the frame, we have to |
| // wait for the fenced frame to indicate that the notifyEvent call fails. |
| // If we get an unexpected result, we'll unwrap the promise into an |
| // exception, which should fail the test. |
| await fencedframe.execute(async () => { |
| await window.activation_promise; |
| }); |
| |
| // Lastly, we need to make sure the notifyEvent call never reached the |
| // parent frame. |
| let result = await Promise.race([ |
| second_notified_promise, |
| new Promise((resolve) => { |
| t.step_timeout(() => resolve('timeout'), 2000); |
| }) |
| ]); |
| assert_equals(result, 'timeout'); |
| |
| }, 'Test that fenced frame notifyEvent() cannot reuse a cached event' + |
| ' after dispatch finishes.'); |
| |
| |
| promise_test(async (t) => { |
| const fencedframe = await attachFencedFrameContext( |
| {generator_api: 'fledge'}); |
| |
| await fencedframe.execute(() => { |
| window.first_click_listener = (e) => { |
| window.cached_event = e; |
| }; |
| document.addEventListener('click', window.first_click_listener); |
| }); |
| |
| await multiClick(10, 10, fencedframe.element); |
| |
| let notified_promise = new Promise((resolve) => { |
| fencedframe.element.addEventListener('fencedtreeclick', () => resolve()); |
| }); |
| |
| await fencedframe.execute(() => { |
| document.removeEventListener('click', window.first_click_listener); |
| window.activation_promise = new Promise((resolve, reject) => { |
| document.addEventListener('click', (e) => { |
| try { |
| assert_equals(window.cached_event.type, 'click'); |
| assert_true(window.cached_event.isTrusted); |
| assert_true(navigator.userActivation.isActive); |
| // 0 = NONE, no longer dispatching. |
| assert_equals(window.cached_event.eventPhase, 0); |
| window.fence.notifyEvent(window.cached_event); |
| reject('notifyEvent() should not fire.'); |
| } catch (err) { |
| if (err.name != 'SecurityError') { |
| reject('Unexpected error: ' + err.message); |
| return; |
| } |
| resolve('PASS'); |
| } |
| }); |
| }); |
| }); |
| |
| await multiClick(10, 10, fencedframe.element); |
| |
| await fencedframe.execute(async () => { |
| await window.activation_promise; |
| }); |
| |
| // Lastly, we need to make sure the notifyEvent call never reached the |
| // parent frame. |
| let result = await Promise.race([ |
| notified_promise, |
| new Promise((resolve) => { |
| t.step_timeout(() => resolve('timeout'), 2000); |
| }) |
| ]); |
| assert_equals(result, 'timeout'); |
| |
| }, 'Test that fenced frame notifyEvent() cannot reuse a cached event' + |
| ' after dispatch finishes, even if it has never been notified before.'); |
| |
| promise_test(async (t) => { |
| const fencedframe = await attachFencedFrameContext( |
| {generator_api: 'fledge'}); |
| |
| // First, click and cache a click event. |
| await fencedframe.execute(() => { |
| window.first_click_listener = (e) => { |
| window.cached_event = e; |
| }; |
| document.addEventListener('click', window.first_click_listener); |
| }); |
| |
| await multiClick(10, 10, fencedframe.element); |
| |
| // Next, register a new click listener to catch the cached event when it's |
| // re-dispatched. |
| await fencedframe.execute(async () => { |
| document.removeEventListener('click', window.first_click_listener); |
| window.click_promise = new Promise((resolve, reject) => { |
| document.addEventListener('click', (e) => { |
| try { |
| assert_true(navigator.userActivation.isActive); |
| window.fence.notifyEvent(e); |
| reject('notifyEvent() should not fire.') |
| } catch (err) { |
| if (err.name != 'SecurityError') { |
| reject('Unexpected error: ' + err.message); |
| } |
| |
| resolve('PASS'); |
| } |
| }); |
| }); |
| |
| // We need user activation when re-dispatching the event, which will |
| // ensure that the re-dispatch is the sole reason for notifyEvent() |
| // failing to fire. We'll simulate a mousedown to provide transient |
| // activation, and *then* re-dispatch the cached click event, in an |
| // attempt to scam an additional notifyEvent(). |
| document.addEventListener('mousedown', (e) => { |
| document.dispatchEvent(window.cached_event); |
| }); |
| }); |
| |
| // Send a mousedown event to the fenced frame. We can't send a full |
| // click because it will interfere with the manual event dispatch. |
| for (let i = 0; i < 3; i++) { |
| await new test_driver.Actions() |
| .pointerMove(10, 10, {origin: fencedframe.element}) |
| .pointerDown() |
| .send(); |
| } |
| |
| await fencedframe.execute(async () => { |
| await window.click_promise; |
| }); |
| |
| }, 'Test that re-dispatching a cached click event does not allow it to be' + |
| ' used with notifyEvent()'); |
| </script> |
| </body> |
