tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

RTCRtpReceiver-getSynchronizationSources.https.html (4335B)

      1 <!doctype html>
      2 <meta charset=utf-8>
      3 <!-- This file contains two tests that wait for 10 seconds each. -->
      4 <meta name="timeout" content="long">
      5 <title>RTCRtpReceiver.prototype.getSynchronizationSources</title>
      6 <script src="/resources/testharness.js"></script>
      7 <script src="/resources/testharnessreport.js"></script>
      8 <script src="RTCPeerConnection-helper.js"></script>
      9 <script>
     10 'use strict';
     11 
     12 async function initiateSingleTrackCallAndReturnReceiver(t, kind) {
     13  const pc1 = new RTCPeerConnection();
     14  t.add_cleanup(() => pc1.close());
     15  const pc2 = new RTCPeerConnection();
     16  t.add_cleanup(() => pc2.close());
     17 
     18  const stream = await getNoiseStream({[kind]:true});
     19  const [track] = stream.getTracks();
     20  t.add_cleanup(() => track.stop());
     21  pc1.addTrack(track, stream);
     22 
     23  exchangeIceCandidates(pc1, pc2);
     24  const trackEvent = await exchangeOfferAndListenToOntrack(t, pc1, pc2);
     25  await exchangeAnswer(pc1, pc2);
     26 
     27  // Some browsers might need an audio element attached to the DOM.
     28  const element = document.createElement(kind);
     29  element.autoplay = true;
     30  element.srcObject = trackEvent.streams[0];
     31  document.body.appendChild(element);
     32  t.add_cleanup(() => { document.body.removeChild(element) });
     33 
     34  return trackEvent.receiver;
     35 }
     36 
     37 for (const kind of ['audio', 'video']) {
     38  promise_test(async t => {
     39    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
     40    await listenForSSRCs(t, receiver);
     41  }, '[' + kind + '] getSynchronizationSources() eventually returns a ' +
     42     'non-empty list');
     43 
     44  promise_test(async t => {
     45    const startTime = performance.now();
     46    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
     47    const [ssrc] = await listenForSSRCs(t, receiver);
     48    assert_equals(typeof ssrc.timestamp, 'number');
     49    assert_true(ssrc.timestamp >= startTime);
     50  }, '[' + kind + '] RTCRtpSynchronizationSource.timestamp is a number');
     51 
     52  promise_test(async t => {
     53    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
     54    const [ssrc] = await listenForSSRCs(t, receiver);
     55    assert_equals(typeof ssrc.rtpTimestamp, 'number');
     56    assert_greater_than_equal(ssrc.rtpTimestamp, 0);
     57    assert_less_than_equal(ssrc.rtpTimestamp, 0xffffffff);
     58  }, '[' + kind + '] RTCRtpSynchronizationSource.rtpTimestamp is a number ' +
     59     '[0, 2^32-1]');
     60 
     61  promise_test(async t => {
     62    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
     63    // Wait for packets to start flowing.
     64    await listenForSSRCs(t, receiver);
     65    // Wait for 10 seconds.
     66    await new Promise(resolve => t.step_timeout(resolve, 10000));
     67    let earliestTimestamp = undefined;
     68    let latestTimestamp = undefined;
     69    for (const ssrc of await listenForSSRCs(t, receiver)) {
     70      if (earliestTimestamp == undefined || earliestTimestamp > ssrc.timestamp)
     71        earliestTimestamp = ssrc.timestamp;
     72      if (latestTimestamp == undefined || latestTimestamp < ssrc.timestamp)
     73        latestTimestamp = ssrc.timestamp;
     74    }
     75    assert_true(latestTimestamp - earliestTimestamp <= 10000);
     76  }, '[' + kind + '] getSynchronizationSources() does not contain SSRCs ' +
     77     'older than 10 seconds');
     78 
     79  promise_test(async t => {
     80    const startTime = performance.timeOrigin + performance.now();
     81    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
     82    const [ssrc] = await listenForSSRCs(t, receiver);
     83    const endTime = performance.timeOrigin + performance.now();
     84    assert_true(startTime <= ssrc.timestamp && ssrc.timestamp <= endTime);
     85  }, '[' + kind + '] RTCRtpSynchronizationSource.timestamp is comparable to ' +
     86     'performance.timeOrigin + performance.now()');
     87 
     88  promise_test(async t => {
     89    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
     90    const [ssrc] = await listenForSSRCs(t, receiver);
     91    assert_equals(typeof ssrc.source, 'number');
     92  }, '[' + kind + '] RTCRtpSynchronizationSource.source is a number');
     93 }
     94 
     95 promise_test(async t => {
     96  const receiver = await initiateSingleTrackCallAndReturnReceiver(t, 'audio');
     97  const [ssrc] = await listenForSSRCs(t, receiver);
     98  assert_equals(typeof ssrc.audioLevel, 'number');
     99  assert_greater_than_equal(ssrc.audioLevel, 0);
    100  assert_less_than_equal(ssrc.audioLevel, 1);
    101 }, '[audio-only] RTCRtpSynchronizationSource.audioLevel is a number [0, 1]');
    102 
    103 </script>