tor-browser

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

routines.js (3261B)

      1 async function getNextMessage(portOrWorker) {
      2  return new Promise(resolve => {
      3    const resolveWithData = event => resolve(event.data);
      4    const rejectWithData = event => reject(event.data);
      5    portOrWorker.addEventListener('message', resolveWithData, {once: true});
      6    portOrWorker.addEventListener('messageerror', rejectWithData, {once: true});
      7  });
      8 }
      9 
     10 
     11 async function postMethod(port, method, options) {
     12  port.postMessage(Object.assign({method}, options));
     13  return await getNextMessage(port);
     14 }
     15 
     16 async function createWorker(script) {
     17  const worker = new Worker(script);
     18  const data = await getNextMessage(worker);
     19  assert_equals(data, "registered");
     20  return worker;
     21 }
     22 
     23 async function createTransform(worker) {
     24  const channel = new MessageChannel;
     25  const transform = new RTCRtpScriptTransform(worker, {name:'MockRTCRtpTransform', port: channel.port2}, [channel.port2]);
     26  transform.port = channel.port1;
     27  channel.port1.start();
     28  assert_equals(await getNextMessage(channel.port1), "started");
     29  return transform;
     30 }
     31 
     32 async function createTransforms(script) {
     33  const worker = await createWorker(script)
     34  return Promise.all([createTransform(worker), createTransform(worker)]);
     35 }
     36 
     37 async function createConnectionWithTransform(test, script, gumOptions) {
     38  const [senderTransform, receiverTransform] = await createTransforms(script);
     39 
     40  const localStream = await navigator.mediaDevices.getUserMedia(gumOptions);
     41 
     42  let senderPc, receiverPc, sender, receiver;
     43 
     44  await createConnections(test, (firstConnection) => {
     45      senderPc = firstConnection;
     46      sender = firstConnection.addTrack(localStream.getTracks()[0], localStream);
     47      sender.transform = senderTransform;
     48    }, (secondConnection) => {
     49      receiverPc = secondConnection;
     50      secondConnection.ontrack = (trackEvent) => {
     51        receiver = trackEvent.receiver;
     52        receiver.transform = receiverTransform;
     53      };
     54    });
     55 
     56  assert_true(!!sender, "sender should be set");
     57  assert_true(!!receiver, "receiver should be set");
     58 
     59  return {sender, receiver, senderPc, receiverPc};
     60 }
     61 
     62 async function createConnections(test, setupLocalConnection, setupRemoteConnection, doNotCloseAutmoatically) {
     63    const localConnection = new RTCPeerConnection();
     64    const remoteConnection = new RTCPeerConnection();
     65 
     66    remoteConnection.onicecandidate = (event) => { localConnection.addIceCandidate(event.candidate); };
     67    localConnection.onicecandidate = (event) => { remoteConnection.addIceCandidate(event.candidate); };
     68 
     69    await setupLocalConnection(localConnection);
     70    await setupRemoteConnection(remoteConnection);
     71 
     72    const offer = await localConnection.createOffer();
     73    await localConnection.setLocalDescription(offer);
     74    await remoteConnection.setRemoteDescription(offer);
     75 
     76    const answer = await remoteConnection.createAnswer();
     77    await remoteConnection.setLocalDescription(answer);
     78    await localConnection.setRemoteDescription(answer);
     79 
     80    if (!doNotCloseAutmoatically) {
     81        test.add_cleanup(() => {
     82            localConnection.close();
     83            remoteConnection.close();
     84        });
     85    }
     86 
     87    return [localConnection, remoteConnection];
     88 }
     89 
     90 function waitFor(test, duration)
     91 {
     92    return new Promise((resolve) => test.step_timeout(resolve, duration));
     93 }