firefox/browser/base/content/test/webrtc/browser_webrtc_hooks.js

/* 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"
      );
    },
  });
});