tor-browser

browser_webrtc_hooks.js (10059B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

const ORIGIN = "https://example.com";

async function tryPeerConnection(browser, expectedError = null) {
 let errtype = await SpecialPowers.spawn(browser, [], async function () {
   let pc = new content.RTCPeerConnection();
   try {
     await pc.createOffer({ offerToReceiveAudio: true });
     return null;
   } catch (err) {
     return err.name;
   }
 });

 let detail = expectedError
   ? `createOffer() threw a ${expectedError}`
   : "createOffer() succeeded";
 is(errtype, expectedError, detail);
}

// Helper for tests that use the peer-request-allowed and -blocked events.
// A test that expects some of those events does the following:
//  - call Events.on() before the test to setup event handlers
//  - call Events.expect(name) after a specific event is expected to have
//    occured.  This will fail if the event didn't occur, and will return
//    the details passed to the handler for furhter checking.
//  - call Events.off() at the end of the test to clean up.  At this point, if
//    any events were triggered that the test did not expect, the test fails.
const Events = {
 events: ["peer-request-allowed", "peer-request-blocked"],
 details: new Map(),
 handlers: new Map(),
 on() {
   for (let event of this.events) {
     let handler = data => {
       if (this.details.has(event)) {
         ok(false, `Got multiple ${event} events`);
       }
       this.details.set(event, data);
     };
     webrtcUI.on(event, handler);
     this.handlers.set(event, handler);
   }
 },
 expect(event) {
   let result = this.details.get(event);
   isnot(result, undefined, `${event} event was triggered`);
   this.details.delete(event);

   // All events should have a good origin
   is(result.origin, ORIGIN, `${event} event has correct origin`);

   return result;
 },
 off() {
   for (let event of this.events) {
     webrtcUI.off(event, this.handlers.get(event));
     this.handlers.delete(event);
   }
   for (let [event] of this.details) {
     ok(false, `Got unexpected event ${event}`);
   }
 },
};

var gTests = [
 {
   desc: "Basic peer-request-allowed event",
   run: async function testPeerRequestEvent(browser) {
     Events.on();

     await tryPeerConnection(browser);

     let details = Events.expect("peer-request-allowed");
     isnot(
       details.callID,
       undefined,
       "peer-request-allowed event includes callID"
     );
     isnot(
       details.windowID,
       undefined,
       "peer-request-allowed event includes windowID"
     );

     Events.off();
   },
 },

 {
   desc: "Immediate peer connection blocker can allow",
   run: async function testBlocker(browser) {
     Events.on();

     let blockerCalled = false;
     let blocker = params => {
       is(
         params.origin,
         ORIGIN,
         "Peer connection blocker origin parameter is correct"
       );
       blockerCalled = true;
       return "allow";
     };

     webrtcUI.addPeerConnectionBlocker(blocker);

     await tryPeerConnection(browser);
     is(blockerCalled, true, "Blocker was called");
     Events.expect("peer-request-allowed");

     webrtcUI.removePeerConnectionBlocker(blocker);
     Events.off();
   },
 },

 {
   desc: "Deferred peer connection blocker can allow",
   run: async function testDeferredBlocker(browser) {
     Events.on();

     let blocker = () => Promise.resolve("allow");
     webrtcUI.addPeerConnectionBlocker(blocker);

     await tryPeerConnection(browser);
     Events.expect("peer-request-allowed");

     webrtcUI.removePeerConnectionBlocker(blocker);
     Events.off();
   },
 },

 {
   desc: "Immediate peer connection blocker can deny",
   run: async function testBlockerDeny(browser) {
     Events.on();

     let blocker = () => "deny";
     webrtcUI.addPeerConnectionBlocker(blocker);

     await tryPeerConnection(browser, "NotAllowedError");

     Events.expect("peer-request-blocked");

     webrtcUI.removePeerConnectionBlocker(blocker);
     Events.off();
   },
 },

 {
   desc: "Multiple blockers work (both allow)",
   run: async function testMultipleAllowBlockers(browser) {
     Events.on();

     let blocker1Called = false,
       blocker1 = () => {
         blocker1Called = true;
         return "allow";
       };
     webrtcUI.addPeerConnectionBlocker(blocker1);

     let blocker2Called = false,
       blocker2 = () => {
         blocker2Called = true;
         return "allow";
       };
     webrtcUI.addPeerConnectionBlocker(blocker2);

     await tryPeerConnection(browser);

     Events.expect("peer-request-allowed");
     ok(blocker1Called, "First blocker was called");
     ok(blocker2Called, "Second blocker was called");

     webrtcUI.removePeerConnectionBlocker(blocker1);
     webrtcUI.removePeerConnectionBlocker(blocker2);
     Events.off();
   },
 },

 {
   desc: "Multiple blockers work (allow then deny)",
   run: async function testAllowDenyBlockers(browser) {
     Events.on();

     let blocker1Called = false,
       blocker1 = () => {
         blocker1Called = true;
         return "allow";
       };
     webrtcUI.addPeerConnectionBlocker(blocker1);

     let blocker2Called = false,
       blocker2 = () => {
         blocker2Called = true;
         return "deny";
       };
     webrtcUI.addPeerConnectionBlocker(blocker2);

     await tryPeerConnection(browser, "NotAllowedError");

     Events.expect("peer-request-blocked");
     ok(blocker1Called, "First blocker was called");
     ok(blocker2Called, "Second blocker was called");

     webrtcUI.removePeerConnectionBlocker(blocker1);
     webrtcUI.removePeerConnectionBlocker(blocker2);
     Events.off();
   },
 },

 {
   desc: "Multiple blockers work (deny first)",
   run: async function testDenyAllowBlockers(browser) {
     Events.on();

     let blocker1Called = false,
       blocker1 = () => {
         blocker1Called = true;
         return "deny";
       };
     webrtcUI.addPeerConnectionBlocker(blocker1);

     let blocker2Called = false,
       blocker2 = () => {
         blocker2Called = true;
         return "allow";
       };
     webrtcUI.addPeerConnectionBlocker(blocker2);

     await tryPeerConnection(browser, "NotAllowedError");

     Events.expect("peer-request-blocked");
     ok(blocker1Called, "First blocker was called");
     ok(
       !blocker2Called,
       "Peer connection blocker after a deny is not invoked"
     );

     webrtcUI.removePeerConnectionBlocker(blocker1);
     webrtcUI.removePeerConnectionBlocker(blocker2);
     Events.off();
   },
 },

 {
   desc: "Blockers may be removed",
   run: async function testRemoveBlocker(browser) {
     Events.on();

     let blocker1Called = false,
       blocker1 = () => {
         blocker1Called = true;
         return "allow";
       };
     webrtcUI.addPeerConnectionBlocker(blocker1);

     let blocker2Called = false,
       blocker2 = () => {
         blocker2Called = true;
         return "allow";
       };
     webrtcUI.addPeerConnectionBlocker(blocker2);
     webrtcUI.removePeerConnectionBlocker(blocker1);

     await tryPeerConnection(browser);

     Events.expect("peer-request-allowed");

     ok(!blocker1Called, "Removed peer connection blocker is not invoked");
     ok(blocker2Called, "Second peer connection blocker was invoked");

     webrtcUI.removePeerConnectionBlocker(blocker2);
     Events.off();
   },
 },

 {
   desc: "Blocker that throws is ignored",
   run: async function testBlockerThrows(browser) {
     Events.on();
     let blocker1Called = false,
       blocker1 = () => {
         blocker1Called = true;
         throw new Error("kaboom");
       };
     webrtcUI.addPeerConnectionBlocker(blocker1);

     let blocker2Called = false,
       blocker2 = () => {
         blocker2Called = true;
         return "allow";
       };
     webrtcUI.addPeerConnectionBlocker(blocker2);

     await tryPeerConnection(browser);

     Events.expect("peer-request-allowed");
     ok(blocker1Called, "First blocker was invoked");
     ok(blocker2Called, "Second blocker was invoked");

     webrtcUI.removePeerConnectionBlocker(blocker1);
     webrtcUI.removePeerConnectionBlocker(blocker2);
     Events.off();
   },
 },

 {
   desc: "Cancel peer request",
   run: async function testBlockerCancel(browser) {
     let blocker,
       blockerPromise = new Promise(resolve => {
         blocker = () => {
           resolve();
           // defer indefinitely
           return new Promise(() => {});
         };
       });
     webrtcUI.addPeerConnectionBlocker(blocker);

     await SpecialPowers.spawn(browser, [], async function () {
       new content.RTCPeerConnection().createOffer({
         offerToReceiveAudio: true,
       });
     });

     await blockerPromise;

     let eventPromise = new Promise(resolve => {
       webrtcUI.on("peer-request-cancel", function listener(details) {
         resolve(details);
         webrtcUI.off("peer-request-cancel", listener);
       });
     });

     await SpecialPowers.spawn(browser, [], async function () {
       content.location.reload();
     });

     let details = await eventPromise;
     isnot(
       details.callID,
       undefined,
       "peer-request-cancel event includes callID"
     );
     is(
       details.origin,
       ORIGIN,
       "peer-request-cancel event has correct origin"
     );

     webrtcUI.removePeerConnectionBlocker(blocker);
   },
 },
];

add_task(async function test() {
 await runTests(gTests, {
   skipObserverVerification: true,
   cleanup() {
     is(
       webrtcUI.peerConnectionBlockers.size,
       0,
       "Peer connection blockers list is empty"
     );
   },
 });
});