| <!DOCTYPE html> |
| |
| <head> |
| <title>Cobalt WindowTimers test with freeze state</title> |
| <script src='black_box_js_test_utils.js'></script> |
| </head> |
| |
| <body> |
| <h1> |
| <span>ID element</span> |
| </h1> |
| <script> |
| |
| // Delay for setInterval (ms) |
| var kSetIntervalDelay = 600; |
| // Delay for setTimeout (ms) |
| var kSetTimeoutDelay = 800; |
| // Delay for the long setTimeout (ms) |
| var kLongSetTimeoutDelay = 13000; |
| |
| // Allowed time difference for callback expected execution time (ms) |
| // This value is quite high because in devel builds on slower devices there |
| // may occesionally be larger delays. |
| var kAllowedTimeDifference = 100; |
| |
| // Last time when the app was resumed from frozen state. |
| var resumeTime = 0; |
| // Expected execution time for interval callback |
| var expectedIntervalTime = 0; |
| // Expected execution time for timeout callback |
| var expectedTimeoutTime = 0; |
| // Expected execution time for long timeout callback |
| var expectedLongTimeoutTime = 0; |
| |
| let wasEverFrozen = false; |
| let frozen = false; |
| let eventWhileFrozen = false; |
| |
| // Callback for registering entering freeze state. |
| function freezeCallback() { |
| console.log("document.onfreeze") |
| wasEverFrozen = true; |
| frozen = true; |
| } |
| |
| // Callback for registering leaving freeze state. |
| function resumeCallback() { |
| resumeTime = performance.now(); |
| console.log("document.onresume") |
| if (!frozen) { |
| console.log('ERROR: Resuming while not frozen'); |
| notReached(); |
| } |
| if (eventWhileFrozen) { |
| console.log('ERROR: Timer callback received while frozen'); |
| notReached(); |
| } |
| frozen = false; |
| } |
| |
| function logState(prefix) { |
| console.log(prefix + ": State:" + |
| " document.visibilityState == " + document.visibilityState + |
| " document.hidden == " + document.hidden + |
| " document.hasFocus() == " + document.hasFocus()); |
| } |
| |
| function verifyNotFrozen() { |
| eventWhileFrozen |= frozen; |
| } |
| |
| function CheckTiming(expectedTime) { |
| if (expectedTime != 0) { |
| // Callbacks are allowed to execute no more than kAllowedTimeDifference |
| // before or after the expected time, except when the app was frozen, |
| // in which case it should be executed immediately when resuming, while |
| // the document is still hidden. |
| if (wasEverFrozen && resumeTime > expectedTime && document.hidden) { |
| // The callback is too late, but that is because the document was |
| // frozen. |
| return; |
| } |
| |
| if (Math.abs(performance.now() - expectedTime) > kAllowedTimeDifference) { |
| console.log('ERROR: Timer callback timing out of allowed range (' + |
| Math.round(Math.abs(performance.now() - expectedTime)) + |
| 'ms difference)'); |
| notReached(); |
| } |
| } |
| } |
| |
| function DoTimeout() { |
| verifyNotFrozen(); |
| CheckTiming(expectedTimeoutTime); |
| logState('Timeout'); |
| expectedTimeoutTime = performance.now() + kSetTimeoutDelay; |
| setTimeout(DoTimeout, kSetTimeoutDelay); |
| } |
| |
| function DoLongTimeout() { |
| verifyNotFrozen(); |
| CheckTiming(expectedLongTimeoutTime); |
| logState('Long Timeout'); |
| if (wasEverFrozen && !eventWhileFrozen) { |
| onEndTest(); |
| } |
| |
| expectedLongTimeoutTime = performance.now() + kLongSetTimeoutDelay; |
| setTimeout(DoLongTimeout, kLongSetTimeoutDelay); |
| } |
| |
| function DoInterval() {performance.now() |
| var now = performance.now(); |
| verifyNotFrozen(); |
| CheckTiming(expectedIntervalTime); |
| logState('Interval'); |
| expectedIntervalTime = now + kSetIntervalDelay; |
| } |
| |
| document.addEventListener("freeze", freezeCallback); |
| document.addEventListener("resume", resumeCallback); |
| |
| DoLongTimeout(); |
| DoTimeout(); |
| setInterval(DoInterval, kSetIntervalDelay); |
| |
| setupFinished(); |
| </script> |
| </body> |
