1 files changed, 123 insertions, 0 deletions
diff --git a/dom/media/webrtc/tests/mochitests/test_getUserMedia_audioConstraints_concurrentStreams.html b/dom/media/webrtc/tests/mochitests/test_getUserMedia_audioConstraints_concurrentStreams.html
new file mode 100644
index 0000000000..f5b5e784ea
--- /dev/null
+++ b/dom/media/webrtc/tests/mochitests/test_getUserMedia_audioConstraints_concurrentStreams.html
@@ -0,0 +1,123 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <script type="application/javascript" src="mediaStreamPlayback.js"></script>
+</head>
+<body>
+<pre id="test">
+<script type="application/javascript">
+createHTML({
+  title: "getUserMedia multiple times, concurrently, and with different constraints",
+  bug: "1404977"
+});
+/**
+  * Verify that we can successfully call getUserMedia multiple times for the
+  * same device, concurrently. This is checked by calling getUserMedia a number
+  * of times with different constraints. We verify that the stream returned by
+  * that call has the same constraints as requested both immediately after the
+  * call and after all gUM calls have been made. The test then verifies the
+  * streams can be played.
+  */
+runTest(async function() {
+  // Compare constraints and return a string with the differences in
+  // echoCancellation, autoGainControl, and noiseSuppression. The string
+  // will be empty if there are no differences.
+  function getConstraintDifferenceString(constraints, otherConstraints) {
+    let diffString = "";
+    if (constraints.echoCancellation != otherConstraints.echoCancellation) {
+      diffString += "echoCancellation different: " +
+                    `${constraints.echoCancellation} != ${otherConstraints.echoCancellation}, `;
+    }
+    if (constraints.autoGainControl != otherConstraints.autoGainControl) {
+      diffString += "autoGainControl different: " +
+                    `${constraints.autoGainControl} != ${otherConstraints.autoGainControl}, `;
+    }
+    if (constraints.noiseSuppression != otherConstraints.noiseSuppression) {
+      diffString += "noiseSuppression different: " +
+                    `${constraints.noiseSuppression} != ${otherConstraints.noiseSuppression}, `;
+    }
+    // Replace trailing comma and space if any
+    return diffString.replace(/, $/, "");
+  }
+
+  // We need a real device to get a MediaEngine supporting constraints
+  let audioDevice = SpecialPowers.getCharPref("media.audio_loopback_dev", "");
+  if (!audioDevice) {
+    todo(false, "No device set by framework. Try --use-test-media-devices");
+    return;
+  }
+
+  let egn = (e, g, n) => ({
+    echoCancellation: e,
+    autoGainControl: g,
+    noiseSuppression: n
+  });
+
+  let constraintCombinations = [
+    egn(false, false, false),
+    egn(true,  false, false),
+    egn(false, true,  false),
+    egn(false, false, true),
+    egn(true,  true,  false),
+    egn(true,  false, true),
+    egn(false, true,  true),
+    egn(true,  true,  true),
+  ];
+
+  // Array to store objects that associate information used in our test such as
+  // constraints, gum streams, and various promises.
+  let testCases = [];
+
+  for (let constraints of constraintCombinations) {
+    let testCase = {requestedConstraints: constraints};
+    // Provide an id for logging, labeling related elements.
+    testCase.id = `testCase.` +
+                  `e=${constraints.echoCancellation}.` +
+                  `g=${constraints.noiseSuppression}.` +
+                  `n=${constraints.noiseSuppression}`;
+    testCases.push(testCase);
+    testCase.gumStream =
+      await getUserMedia({audio: testCase.requestedConstraints})
+      .catch(e => Promise.reject(`getUserMedia calls should not fail! Failed at ${testCase.id} with: ${e}!`));
+    let differenceString = getConstraintDifferenceString(
+      testCase.requestedConstraints,
+      testCase.gumStream.getAudioTracks()[0].getSettings());
+      ok(!differenceString,
+        `gUM stream for ${testCase.id} should have the same constraints as were ` +
+        `requested from gUM. Differences: ${differenceString}`);
+  }
+  is(testCases.length,
+    constraintCombinations.length,
+    "Should have a stream for each constraint");
+
+  // Once all streams are collected, make sure the constraints haven't been
+  // mutated by another gUM call.
+  for (let testCase of testCases) {
+    let differenceString = getConstraintDifferenceString(
+      testCase.requestedConstraints,
+      testCase.gumStream.getAudioTracks()[0].getSettings());
+    ok(!differenceString,
+      `gUM stream for ${testCase.id} should not have had constraints altered after ` +
+      `all gUM calls are done. Differences: ${differenceString}`);
+  }
+
+  // We do not currently have tests to verify the behaviour of the different
+  // constraints. Once we do we should do further verificaiton here. See
+  // bug 1406372, bug 1406376, and bug 1406377.
+
+  for (let testCase of testCases) {
+    let testAudio = createMediaElement("audio", `testAudio.${testCase.id}`);
+    let playback = new MediaStreamPlayback(testAudio, testCase.gumStream);
+    await playback.playMediaWithoutStoppingTracks(false);
+  }
+
+  // Stop the tracks for each stream, we left them running above via
+  // playMediaWithoutStoppingTracks to make sure they can play concurrently.
+  for (let testCase of testCases) {
+    testCase.gumStream.getTracks().map(t => t.stop());
+  }
+});
+</script>
+</pre>
+</body>
+</html>