| <!doctype html> |
| <meta charset=utf-8> |
| <meta name="timeout" content="long"> |
| <button id="button">User gesture</button> |
| <script src="/resources/testharness.js"></script> |
| <script src="/resources/testharnessreport.js"></script> |
| <script src="/resources/testdriver.js"></script> |
| <script src="/resources/testdriver-vendor.js"></script> |
| <script> |
| 'use strict'; |
| |
| async function getFrameStatsUntil(track, condition) { |
| while (true) { |
| const stats = track.stats.toJSON(); |
| if (condition(stats)) { |
| return stats; |
| } |
| // Repeat in the next task execution cycle. |
| await Promise.resolve(); |
| } |
| }; |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ audio: true }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| const firstStats = |
| await getFrameStatsUntil(track, stats => stats.totalFrames > 0); |
| await getFrameStatsUntil(track, |
| stats => stats.totalFrames > firstStats.totalFrames && stats.totalFramesDuration > firstStats.totalFramesDuration); |
| }, `totalFrames and totalFramesDuration increase over time`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ audio: true }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Wait one second for stats |
| const stats = |
| await getFrameStatsUntil(track, stats => stats.totalFramesDuration > 1000); |
| assert_less_than_equal(stats.deliveredFrames, stats.totalFrames); |
| assert_less_than_equal(stats.deliveredFramesDuration, stats.totalFramesDuration); |
| assert_greater_than_equal(stats.deliveredFrames, 0); |
| assert_greater_than_equal(stats.deliveredFramesDuration, 0); |
| }, `deliveredFrames and deliveredFramesDuration are at most as large as totalFrames and totalFramesDuration`); |
| |
| promise_test(async t => { |
| function assertLatencyStatsInBounds(stats) { |
| assert_greater_than_equal(stats.maximumLatency, stats.latency); |
| assert_greater_than_equal(stats.maximumLatency, stats.averageLatency); |
| assert_less_than_equal(stats.minimumLatency, stats.latency); |
| assert_less_than_equal(stats.minimumLatency, stats.averageLatency); |
| }; |
| |
| const stream = await navigator.mediaDevices.getUserMedia({ audio: true }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| const firstStats = track.stats.toJSON(); |
| assertLatencyStatsInBounds(firstStats); |
| |
| // Wait one second for a second stats object. |
| const secondStats = |
| await getFrameStatsUntil(track, stats => stats.totalFramesDuration - firstStats.totalFramesDuration >= 1000); |
| assertLatencyStatsInBounds(secondStats); |
| |
| // Reset the latency stats and wait one second for a third stats object. |
| track.stats.resetLatency(); |
| const thirdStats = |
| await getFrameStatsUntil(track, stats => stats.totalFramesDuration - secondStats.totalFramesDuration >= 1000); |
| assertLatencyStatsInBounds(thirdStats); |
| }, `Latency and averageLatency is within the bounds of minimumLatency and maximumLatency`); |
| |
| promise_test(async t => { |
| // This behaviour is defined in |
| // https://w3c.github.io/mediacapture-extensions/#dom-mediastreamtrackaudiostats-resetlatency |
| const stream = await navigator.mediaDevices.getUserMedia({ audio: true }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Wait one second for stats |
| const stats = |
| await getFrameStatsUntil(track, stats => stats.totalFramesDuration > 1000); |
| track.stats.resetLatency(); |
| assert_equals(track.stats.latency, stats.latency); |
| assert_equals(track.stats.averageLatency, stats.latency); |
| assert_equals(track.stats.minimumLatency, stats.latency); |
| assert_equals(track.stats.maximumLatency, stats.latency); |
| }, `Immediately after resetLatency(), latency, averageLatency, minimumLatency and maximumLatency are equal to the most recent latency.`); |
| |
| promise_test(async t => { |
| // This behaviour is defined in |
| // https://w3c.github.io/mediacapture-extensions/#dfn-expose-audio-frame-counters-steps |
| const stream = await navigator.mediaDevices.getUserMedia({ audio: true }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Wait until we have meaningful data |
| await getFrameStatsUntil(track, stats => stats.totalFrames > 0); |
| const firstStats = track.stats.toJSON(); |
| |
| // Synchronously wait 500 ms. |
| const start = performance.now(); |
| while(performance.now() - start < 500); |
| |
| // The stats should still be the same, despite the time difference. |
| const secondStats = track.stats.toJSON(); |
| assert_equals(JSON.stringify(firstStats), JSON.stringify(secondStats)); |
| }, `Stats do not change within the same task execution cycle.`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ audio: true }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Wait for media to flow before disabling the `track`. |
| const initialStats = await getFrameStatsUntil(track, stats => stats.totalFrames > 0); |
| track.enabled = false; |
| // Upon disabling, the counters are not reset. |
| const disabledSnapshot = track.stats.toJSON(); |
| assert_greater_than_equal(disabledSnapshot.totalFramesDuration, |
| initialStats.totalFramesDuration); |
| |
| await new Promise(r => t.step_timeout(r, 4000)); |
| |
| // Frame metrics should be frozen, but because `enabled = false` does not |
| // return a promise, we allow some lee-way in case som buffers were still in flight |
| // during the disabling. |
| assert_approx_equals( |
| track.stats.totalFramesDuration, disabledSnapshot.totalFramesDuration, 1000); |
| }, `Stats are frozen while disabled`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({audio:true}); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| const a = track.stats; |
| await getFrameStatsUntil(track, stats => stats.totalFrames > 0); |
| const b = track.stats; |
| // The counters may have changed, but `a` and `b` are still the same object. |
| assert_equals(a, b); |
| }, `SameObject policy applies`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({audio:true}); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Hold a reference directly to the [SameObject] stats, bypassing the |
| // `track.stats` getter in the subsequent getting of `totalFrames`. |
| const stats = track.stats; |
| const firstTotalFrames = stats.totalFrames; |
| while (stats.totalFrames == firstTotalFrames) { |
| await Promise.resolve(); |
| } |
| assert_greater_than(stats.totalFrames, firstTotalFrames); |
| }, `Counters increase even if we don't call the track.stats getter`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({audio:true}); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Wait for 500 ms of audio to flow before disabling the `track`. |
| const initialStats = await getFrameStatsUntil(track, stats => |
| stats.totalFramesDuration > 500); |
| track.enabled = false; |
| |
| // Re-enable the track. The stats counters should be greater than or equal to |
| // what they were previously. |
| track.enabled = true; |
| assert_greater_than_equal(track.stats.totalFrames, |
| initialStats.totalFrames); |
| assert_greater_than_equal(track.stats.totalFramesDuration, |
| initialStats.totalFramesDuration); |
| // This should be true even in the next task execution cycle. |
| await Promise.resolve(); |
| assert_greater_than_equal(track.stats.totalFrames, |
| initialStats.totalFrames); |
| assert_greater_than_equal(track.stats.totalFramesDuration, |
| initialStats.totalFramesDuration); |
| }, `Disabling and re-enabling does not reset the counters`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({audio:true}); |
| const [originalTrack] = stream.getTracks(); |
| t.add_cleanup(() => originalTrack.stop()); |
| |
| // Wait for 500 ms of audio to flow. |
| await getFrameStatsUntil(originalTrack, stats => |
| stats.totalFramesDuration > 500); |
| |
| // Clone the track. While its counters should initially be zero, it would be |
| // racy to assert that they are exactly zero because media is flowing. |
| const clonedTrack = originalTrack.clone(); |
| t.add_cleanup(() => clonedTrack.stop()); |
| |
| // Ensure that as media continues to flow, the cloned track will necessarily |
| // have less frames than the original track on all accounts since its counters |
| // will have started from zero. |
| const clonedTrackStats = await getFrameStatsUntil(clonedTrack, stats => |
| stats.totalFramesDuration > 0); |
| assert_less_than(clonedTrackStats.totalFrames, |
| originalTrack.stats.totalFrames); |
| assert_less_than(clonedTrackStats.totalFramesDuration, |
| originalTrack.stats.totalFramesDuration); |
| }, `New stats baselines when a track is cloned from an enabled track`); |
| </script> |
