forked from mirrors/gecko-dev
59a78c104f
Automatic update from web-platform-tests [idle] Add a threshold minimum of 60 seconds in IdleDetector This change adds a minimum threshold of 60 seconds to prevent sites from observing user signals such as typing cadence, or identifying users with physical or cognitive imparments that may require more time to interact with user agents and content. Bug: 939883 Change-Id: I3ab19b2f7d6711c14356575d338819f501eafb9a Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1535286 Commit-Queue: Ayu Ishii <ayui@chromium.org> Reviewed-by: Reilly Grant <reillyg@chromium.org> Cr-Commit-Position: refs/heads/master@{#643965} -- wpt-commits: ea7981d4c3eb888bcc3d19b0270937c06b92e4f6 wpt-pr: 16033
276 lines
7 KiB
HTML
276 lines
7 KiB
HTML
<!DOCTYPE html>
|
|
<link rel="help" href="https://github.com/samuelgoto/idle-detection">
|
|
<title>Tests the Idle Detection API</title>
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
<script src="/gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
|
|
<script src="/gen/mojo/public/mojom/base/string16.mojom.js"></script>
|
|
<script src="/gen/mojo/public/mojom/base/time.mojom.js"></script>
|
|
<script src="/gen/third_party/blink/public/mojom/idle/idle_manager.mojom.js"></script>
|
|
<script src="mock.js"></script>
|
|
<script>
|
|
'use strict';
|
|
|
|
promise_test(async t => {
|
|
// Basic test that expects start() to call internally
|
|
// addMonitor, which in turn return an ACTIVE state.
|
|
expect(addMonitor).andReturn((threshold, monitorPtr) => {
|
|
return Promise.resolve({
|
|
state: {
|
|
user: UserIdleState.ACTIVE,
|
|
screen: ScreenIdleState.LOCKED
|
|
}
|
|
});
|
|
});
|
|
|
|
let detector = new IdleDetector({threshold: 60});
|
|
|
|
let watcher = new EventWatcher(t, detector, ["change"]);
|
|
|
|
await detector.start();
|
|
|
|
// Waits for the first event.
|
|
await watcher.wait_for("change");
|
|
|
|
assert_equals(detector.state.user, "active");
|
|
assert_equals(detector.state.screen, "locked");
|
|
|
|
detector.stop();
|
|
}, 'query()');
|
|
|
|
promise_test(async t => {
|
|
// Verifies that an event is thrown when a change of state from IDLE to ACTIVE
|
|
// is detected.
|
|
expect(addMonitor).andReturn((threshold, monitorPtr) => {
|
|
let first = Promise.resolve({
|
|
state: {
|
|
user: UserIdleState.ACTIVE,
|
|
screen: ScreenIdleState.UNLOCKED
|
|
}
|
|
});
|
|
|
|
t.step_timeout(() => {
|
|
monitorPtr.update({
|
|
user: UserIdleState.IDLE,
|
|
screen: ScreenIdleState.UNLOCKED
|
|
});
|
|
}, 0);
|
|
|
|
return first;
|
|
});
|
|
|
|
let detector = new IdleDetector({threshold: 60});
|
|
|
|
let watcher = new EventWatcher(t, detector, ["change"]);
|
|
|
|
await detector.start();
|
|
|
|
// Wait for the initial state.
|
|
await watcher.wait_for("change");
|
|
|
|
// Wait for the first change in state.
|
|
await watcher.wait_for("change");
|
|
|
|
assert_equals(detector.state.user, "idle");
|
|
assert_equals(detector.state.screen, "unlocked");
|
|
|
|
detector.stop();
|
|
}, 'updates once');
|
|
|
|
|
|
promise_test(async t => {
|
|
// Simulates the user being active, going idle and then going back active
|
|
// again.
|
|
expect(addMonitor).andReturn((threshold, monitorPtr) => {
|
|
let first = Promise.resolve({
|
|
state: {
|
|
user: UserIdleState.ACTIVE,
|
|
screen: ScreenIdleState.UNLOCKED
|
|
}
|
|
});
|
|
|
|
// Updates the client once with the user idle.
|
|
t.step_timeout(() => {
|
|
monitorPtr.update({
|
|
user: UserIdleState.IDLE,
|
|
screen: ScreenIdleState.UNLOCKED
|
|
});
|
|
}, 0);
|
|
// Updates the client a second time with the user active.
|
|
t.step_timeout(() => {
|
|
monitorPtr.update({
|
|
user: UserIdleState.ACTIVE,
|
|
screen: ScreenIdleState.UNLOCKED
|
|
});
|
|
}, 1);
|
|
return first;
|
|
});
|
|
|
|
let detector = new IdleDetector({threshold: 60});
|
|
|
|
let watcher = new EventWatcher(t, detector, ["change"]);
|
|
|
|
await detector.start();
|
|
|
|
// Waits for the initial state.
|
|
await watcher.wait_for("change");
|
|
|
|
// Waits for the first event.
|
|
await watcher.wait_for("change");
|
|
assert_equals(detector.state.user, "idle");
|
|
|
|
// Waits for the second event.
|
|
await watcher.wait_for("change");
|
|
assert_equals(detector.state.user, "active");
|
|
|
|
detector.stop();
|
|
}, 'updates twice');
|
|
|
|
promise_test(async t => {
|
|
// Simulates a locked screen.
|
|
expect(addMonitor).andReturn((threshold, monitorPtr) => {
|
|
return Promise.resolve({
|
|
state: {
|
|
user: UserIdleState.ACTIVE,
|
|
screen: ScreenIdleState.LOCKED
|
|
}
|
|
});
|
|
});
|
|
|
|
let detector = new IdleDetector({threshold: 60});
|
|
|
|
let watcher = new EventWatcher(t, detector, ["change"]);
|
|
|
|
await detector.start();
|
|
|
|
// waits for the initial state.
|
|
await watcher.wait_for("change");
|
|
|
|
assert_equals(detector.state.screen, "locked");
|
|
|
|
detector.stop();
|
|
}, 'locked screen');
|
|
|
|
promise_test(async t => {
|
|
expect(addMonitor).andReturn((threshold, monitorPtr) => {
|
|
return Promise.resolve({
|
|
state: {
|
|
user: UserIdleState.ACTIVE,
|
|
screen: ScreenIdleState.LOCKED
|
|
}
|
|
});
|
|
});
|
|
|
|
let detector = new IdleDetector({threshold: 60});
|
|
|
|
let event = new Promise((resolve, reject) => {
|
|
detector.onchange = resolve;
|
|
});
|
|
|
|
await detector.start();
|
|
|
|
// Waits for the first event.
|
|
await event;
|
|
|
|
assert_equals(detector.state.user, "active");
|
|
assert_equals(detector.state.screen, "locked");
|
|
|
|
detector.stop();
|
|
}, 'IdleDetector.onchange');
|
|
|
|
promise_test(async t => {
|
|
expect(addMonitor).andReturn((threshold, monitorPtr) => {
|
|
return Promise.resolve({
|
|
state: {
|
|
user: UserIdleState.ACTIVE,
|
|
screen: ScreenIdleState.UNLOCKED
|
|
}
|
|
});
|
|
});
|
|
|
|
let detector = new IdleDetector({threshold: 60});
|
|
|
|
let watcher = new EventWatcher(t, detector, ["change"]);
|
|
|
|
// Calling start() multiple times should be safe.
|
|
await detector.start();
|
|
await detector.start();
|
|
await detector.start();
|
|
await detector.start();
|
|
|
|
// waits for the initial state.
|
|
await watcher.wait_for("change");
|
|
assert_equals(detector.state.user, "active");
|
|
assert_equals(detector.state.screen, "unlocked");
|
|
|
|
// Calling stop() multiple times should be safe.
|
|
detector.stop();
|
|
detector.stop();
|
|
detector.stop();
|
|
detector.stop();
|
|
}, 'Safe to call start() or stop() multiple times');
|
|
|
|
promise_test(async t => {
|
|
expect(addMonitor).andReturn((threshold, monitorPtr) => {
|
|
return Promise.resolve({
|
|
state: {
|
|
user: UserIdleState.ACTIVE,
|
|
screen: ScreenIdleState.UNLOCKED
|
|
}
|
|
});
|
|
});
|
|
|
|
let detector = new IdleDetector({threshold: 60});
|
|
|
|
// Calling stop() before start() is a no-op.
|
|
detector.stop();
|
|
|
|
let watcher = new EventWatcher(t, detector, ["change"]);
|
|
|
|
await detector.start();
|
|
|
|
// waits for the initial state.
|
|
await watcher.wait_for("change");
|
|
assert_equals(detector.state.user, "active");
|
|
assert_equals(detector.state.screen, "unlocked");
|
|
|
|
detector.stop();
|
|
}, 'Calling stop() after start() is a no-op');
|
|
|
|
promise_test(async t => {
|
|
expect(addMonitor).andReturn((threshold, monitorPtr) => {
|
|
return Promise.resolve({
|
|
state: {
|
|
user: UserIdleState.ACTIVE,
|
|
screen: ScreenIdleState.UNLOCKED
|
|
}
|
|
});
|
|
});
|
|
|
|
let detector = new IdleDetector({threshold: 60});
|
|
|
|
let watcher = new EventWatcher(t, detector, ["change"]);
|
|
|
|
await detector.start();
|
|
await watcher.wait_for("change");
|
|
detector.stop();
|
|
|
|
expect(addMonitor).andReturn((threshold, monitorPtr) => {
|
|
return Promise.resolve({
|
|
state: {
|
|
user: UserIdleState.IDLE,
|
|
screen: ScreenIdleState.LOCKED
|
|
}
|
|
});
|
|
});
|
|
|
|
// Restarting the monitor.
|
|
await detector.start();
|
|
await watcher.wait_for("change");
|
|
assert_equals(detector.state.user, "idle");
|
|
assert_equals(detector.state.screen, "locked");
|
|
|
|
detector.stop();
|
|
}, 'Calling start() after stop(): re-starting monitor.');
|
|
|
|
</script>
|