tor-browser

testLegacyEnumerateDevices.js (5474B)

---

/* 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/. */
/*
 This is a modified copy of test_enumerateDevices.html testing the
 enumerateDevices() legacy version and deviceId constraint.
*/

async function mustSucceedWithStream(msg, f) {
 try {
   const stream = await f();
   for (const track of stream.getTracks()) {
     track.stop();
   }
   ok(true, msg + " must succeed");
 } catch (e) {
   is(e.name, null, msg + " must succeed: " + e.message);
 }
}

async function mustFailWith(msg, reason, constraint, f) {
 try {
   await f();
   ok(false, msg + " must fail");
 } catch (e) {
   is(e.name, reason, msg + " must fail: " + e.message);
   if (constraint) {
     is(e.constraint, constraint, msg + " must fail w/correct constraint.");
   }
 }
}

const gUM = c => navigator.mediaDevices.getUserMedia(c);

const kinds = ["videoinput", "audioinput", "audiooutput"];

function validateDevice({ kind, label, deviceId, groupId }) {
 ok(kinds.includes(kind), "Known device kind");
 is(deviceId.length, 44, "deviceId length id as expected for Firefox");
 ok(label.length !== undefined, "Device label: " + label);
 isnot(groupId, "", "groupId must be present.");
}

// Validate enumerated devices before gUM (legacy).

async function testLegacyEnumerateDevices() {
 let devices = await navigator.mediaDevices.enumerateDevices();
 ok(devices.length, "At least one device found");
 const jsoned = JSON.parse(JSON.stringify(devices));
 is(jsoned[0].kind, devices[0].kind, "kind survived serializer");
 is(jsoned[0].deviceId, devices[0].deviceId, "deviceId survived serializer");
 for (const device of devices) {
   validateDevice(device);
   if (device.kind == "audiooutput") {
     continue;
   }
   is(device.label, "", "Device label is empty");
   // Test deviceId constraint
   let deviceId = device.deviceId;
   let constraints =
     device.kind == "videoinput"
       ? { video: { deviceId } }
       : { audio: { deviceId } };
   let namedDevices;
   for (const track of (await gUM(constraints)).getTracks()) {
     is(typeof track.label, "string", "Track label is a string");
     isnot(track.label.length, 0, "Track label is not empty");
     if (!namedDevices) {
       namedDevices = await navigator.mediaDevices.enumerateDevices();
     }
     const namedDevice = namedDevices.find(d => d.deviceId == device.deviceId);
     is(track.label, namedDevice.label, "Track label is the device label");
     track.stop();
   }
 }

 const unknownId = "unknown9qHr8B0JIbcHlbl9xR+jMbZZ8WyoPfpCXPfc=";

 // Check deviceId failure paths for video.

 await mustSucceedWithStream("unknown plain deviceId on video", () =>
   gUM({ video: { deviceId: unknownId } })
 );
 await mustSucceedWithStream("unknown plain deviceId on audio", () =>
   gUM({ audio: { deviceId: unknownId } })
 );
 await mustFailWith(
   "unknown exact deviceId on video",
   "OverconstrainedError",
   "deviceId",
   () => gUM({ video: { deviceId: { exact: unknownId } } })
 );
 await mustFailWith(
   "unknown exact deviceId on audio",
   "OverconstrainedError",
   "deviceId",
   () => gUM({ audio: { deviceId: { exact: unknownId } } })
 );

 // Check that deviceIds are stable for same origin and differ across origins.

 const path =
   "/tests/dom/media/webrtc/tests/mochitests/test_enumerateDevices_iframe_pre_gum.html";
 const origins = ["https://example.com", "https://test1.example.com"];
 info(window.location);

 const haveDevicesMap = new Promise(resolve => {
   const map = new Map();
   window.addEventListener("message", ({ origin, data }) => {
     ok(origins.includes(origin), "Got message from expected origin");
     map.set(origin, JSON.parse(data));
     if (map.size < origins.length) {
       return;
     }
     resolve(map);
   });
 });

 await Promise.all(
   origins.map(origin => {
     const iframe = document.createElement("iframe");
     iframe.src = origin + path;
     iframe.allow = "camera;microphone;speaker-selection";
     info(iframe.src);
     document.documentElement.appendChild(iframe);
     return new Promise(resolve => (iframe.onload = resolve));
   })
 );
 let devicesMap = await haveDevicesMap;
 let [sameOriginDevices, differentOriginDevices] = origins.map(o =>
   devicesMap.get(o)
 );

 is(sameOriginDevices.length, devices.length, "same origin same devices");
 is(
   differentOriginDevices.length,
   devices.length,
   "cross origin same devices"
 );
 [...sameOriginDevices, ...differentOriginDevices].forEach(d =>
   validateDevice(d)
 );

 for (const device of sameOriginDevices) {
   ok(
     devices.find(d => d.deviceId == device.deviceId),
     "Same origin deviceId for " + device.label + " must match"
   );
 }
 for (const device of differentOriginDevices) {
   ok(
     !devices.find(d => d.deviceId == device.deviceId),
     "Different origin deviceId for " + device.label + " must be different"
   );
 }

 // Check the special case of no devices found.
 await pushPrefs(
   ["media.navigator.streams.fake", false],
   ["media.audio_loopback_dev", "none"],
   ["media.video_loopback_dev", "none"]
 );
 devices = await navigator.mediaDevices.enumerateDevices();
 devices = devices.filter(({ kind }) => kind != "audiooutput");
 is(devices.length, 0, "No devices");
}