diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
| commit | 36d22d82aa202bb199967e9512281e9a53db42c9 (patch) | |
| tree | 105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/base/test/test_timeout_clamp.html | |
| parent | Initial commit. (diff) | |
| download | firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip | |
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/base/test/test_timeout_clamp.html')
| -rw-r--r-- | dom/base/test/test_timeout_clamp.html | 163 |
1 files changed, 163 insertions, 0 deletions
diff --git a/dom/base/test/test_timeout_clamp.html b/dom/base/test/test_timeout_clamp.html new file mode 100644 index 0000000000..1f0496235e --- /dev/null +++ b/dom/base/test/test_timeout_clamp.html @@ -0,0 +1,163 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=1378586 +--> +<head> + <meta charset="utf-8"> + <title>Test for Bug 1378586</title> + <script src="/tests/SimpleTest/SimpleTest.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=1378586">Mozilla Bug 1378586</a> + +<script> +SimpleTest.waitForExplicitFinish(); + +// We need to clear our nesting level periodically. We do this by firing +// a postMessage() to get a runnable on the event loop without any setTimeout() +// nesting. +function clearNestingLevel() { + return new Promise(resolve => { + window.addEventListener('message', () => { + resolve(); + }, {once: true}); + postMessage('done', '*'); + }); +} + +function delayByTimeoutChain(iterations) { + return new Promise(resolve => { + let count = 0; + function tick() { + count += 1; + if (count >= iterations) { + resolve(); + return; + } + setTimeout(tick, 0); + } + setTimeout(tick, 0); + }); +} + +function delayByInterval(iterations) { + return new Promise(resolve => { + let count = 0; + function tick() { + count += 1; + if (count >= iterations) { + resolve(); + return; + } + } + setInterval(tick, 0); + }); +} + +function testNestedIntervals() { + return new Promise(resolve => { + const runCount = 100; + let counter = 0; + let intervalId = 0; + let prevInitTime = performance.now(); + let totalTime = 0; + function intervalCallback() { + let now = performance.now(); + let delay = now - prevInitTime; + totalTime += delay; + prevInitTime = now; + clearInterval(intervalId); + if (++counter < runCount) { + intervalId = setInterval(intervalCallback, 0); + } else { + // Delays should be clamped to 4ms after the initial calls, but allow + // some fuzziness, so divide by 2. + let expectedTime = runCount * 4 / 2; + ok(totalTime > expectedTime, "Should not run callbacks too fast."); + resolve(); + } + } + + // Use the timeout value defined in the spec, 4ms. + SpecialPowers.pushPrefEnv({ 'set': [["dom.min_timeout_value", 4]]}, + intervalCallback); + }); +} + +// Use a very long clamp delay to make it easier to measure the change +// in automation. Some of our test servers are very slow and noisy. +const clampDelayMS = 10000; + +// We expect that we will clamp on the 5th callback. This should +// be the same for both setTimeout() chains and setInterval(). +const expectedClampIteration = 5; + +async function runTests() { + // Things like pushPrefEnv() can use setTimeout() internally which may give + // us a nesting level. Clear the nesting level to start so this doesn't + // confuse the test. + await clearNestingLevel(); + + // Verify a setTimeout() chain clamps correctly + let start = performance.now(); + await delayByTimeoutChain(expectedClampIteration); + let stop = performance.now(); + let delta = stop - start; + + ok(delta >= clampDelayMS, "setTimeout() chain clamped: " + stop + " - " + start + " = " + delta); + ok(delta < (2*clampDelayMS), "setTimeout() chain did not clamp twice"); + + await clearNestingLevel(); + + // Verify setInterval() clamps correctly + start = performance.now(); + await delayByInterval(expectedClampIteration); + stop = performance.now(); + delta = stop - start; + + ok(delta >= clampDelayMS, "setInterval() clamped: " + stop + " - " + start + " = " + delta); + ok(delta < (2*clampDelayMS), "setInterval() did not clamp twice"); + + await clearNestingLevel(); + + // Verify a setTimeout() chain will continue to clamp past the first + // expected iteration. + const expectedDelay = (1 + expectedClampIteration) * clampDelayMS; + + start = performance.now(); + await delayByTimeoutChain(2 * expectedClampIteration); + stop = performance.now(); + delta = stop - start; + + ok(delta >= expectedDelay, "setTimeout() chain continued to clamp: " + stop + " - " + start + " = " + delta); + + await clearNestingLevel(); + + // Verify setInterval() will continue to clamp past the first expected + // iteration. + start = performance.now(); + await delayByTimeoutChain(2 * expectedClampIteration); + stop = performance.now(); + delta = stop - start; + + ok(delta >= expectedDelay, "setInterval() continued to clamp: " + stop + " - " + start + " = " + delta); + + await testNestedIntervals(); + + SimpleTest.finish(); +} + +// It appears that it's possible to get unlucky with time jittering and fail this test. +// If start is jittered upwards, everything executes very quickly, and delta has +// a very high midpoint, we may have taken between 10 and 10.002 seconds to execute; but +// it will appear to be 9.998. Turn off jitter (and add logging) to test this. +SpecialPowers.pushPrefEnv({ 'set': [ + ["dom.min_timeout_value", clampDelayMS], + ["privacy.resistFingerprinting.reduceTimerPrecision.jitter", false], + ]}, runTests); +</script> + +</body> +</html> |