<!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>
Codebase Browser
chromium