RTCPeerConnection.addTrack and removeTrack added (behind flag)

chrome/test/data/webrtc/peerconnection_rtp.js

 /**
  * Copyright 2017 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
+/** @private */
+var gOnNegotiationNeededCount = undefined;
+
 // Public interface to tests. These are expected to be called with
 // ExecuteJavascript invocations from the browser tests and will return answers
 // through the DOM automation controller.
 
 /**
  * Adds |count| streams to the peer connection, with one audio and one video
  * track per stream.
  *
  * Returns "ok-streams-created-and-added" on success.
  */
@@ skipping 21 matching lines @@
 function verifyRtpSenders(expectedNumTracks = null) {
   if (expectedNumTracks != null &&
       peerConnection_().getSenders().length != expectedNumTracks) {
     throw failTest('getSenders().length != expectedNumTracks');
   }
   if (!arrayEquals_(peerConnection_().getSenders(),
                     peerConnection_().getSenders())) {
     throw failTest('One getSenders() call is not equal to the next.');
   }
 
-  let localTracks = new Set();
-  peerConnection_().getLocalStreams().forEach(function(stream) {
-    stream.getTracks().forEach(function(track) {
-      localTracks.add(track);
-    });
-  });
-  if (peerConnection_().getSenders().length != localTracks.size)
-    throw failTest('The number of senders and tracks are not the same.');
-
   let senders = new Set();
   let senderTracks = new Set();
   peerConnection_().getSenders().forEach(function(sender) {
     if (sender == null)
       throw failTest('sender is null or undefined.');
     if (sender.track == null)
       throw failTest('sender.track is null or undefined.');
     senders.add(sender);
     senderTracks.add(sender.track);
   });
   if (senderTracks.size != senders.size)
     throw failTest('senderTracks.size != senders.size');
 
-  if (!setEquals_(senderTracks, localTracks)) {
-    throw failTest('The set of sender tracks is not equal to the set of ' +
-                   'stream tracks.');
-  }
   returnToTest('ok-senders-verified');
 }
 
 /**
  * Verifies that the peer connection's getReceivers() returns one receiver per
  * remote track, that there are no duplicates and that object identity is
  * preserved.
  *
  * Returns "ok-receivers-verified" on success.
  */
 function verifyRtpReceivers(expectedNumTracks = null) {
   if (peerConnection_().getReceivers() == null)
     throw failTest('getReceivers() returns null or undefined.');
   if (expectedNumTracks != null &&
       peerConnection_().getReceivers().length != expectedNumTracks) {
     throw failTest('getReceivers().length != expectedNumTracks');
   }
   if (!arrayEquals_(peerConnection_().getReceivers(),
                     peerConnection_().getReceivers())) {
     throw failTest('One getReceivers() call is not equal to the next.');
   }
 
-  let remoteTracks = new Set();
-  peerConnection_().getRemoteStreams().forEach(function(stream) {
-    stream.getTracks().forEach(function(track) {
-      remoteTracks.add(track);
-    });
-  });
-  if (peerConnection_().getReceivers().length != remoteTracks.size)
-    throw failTest('The number of receivers and tracks are not the same.');
-
   let receivers = new Set();
   let receiverTracks = new Set();
   peerConnection_().getReceivers().forEach(function(receiver) {
     if (receiver == null)
       throw failTest('receiver is null or undefined.');
     if (receiver.track == null)
       throw failTest('receiver.track is null or undefined.');
     if (receiver.getContributingSources().length != 0)
       throw failTest('receiver.getContributingSources() is not empty.');
     receivers.add(receiver);
     receiverTracks.add(receiver.track);
   });
   if (receiverTracks.size != receivers.size)
     throw failTest('receiverTracks.size != receivers.size');
 
-  if (!setEquals_(receiverTracks, remoteTracks)) {
-    throw failTest('The set of receiver tracks is not equal to the set of ' +
-                   'stream tracks.');
+  returnToTest('ok-receivers-verified');
+}
+
+/**
+ * Creates an audio and video track and adds them to the peer connection using
+ * |addTrack|. They are added with or without a stream in accordance with
+ * |streamArgumentType|.
+ *
+ * Returns
+ * "ok-<audio stream id> <audio track id> <video stream id> <video track id>" on
+ * success. If no stream is backing up the track, <stream id> is "null".
+ *
+ * @param {string} streamArgumentType Must be one of the following values:
+ * 'no-stream' - The tracks are added without an associated stream.
+ * 'shared-stream' - The tracks are added with the same associated stream.
+ * 'individual-streams' - A stream is created for each track.
+ */
+function createAndAddAudioAndVideoTrack(streamArgumentType) {
+  if (streamArgumentType !== 'no-stream' &&
+      streamArgumentType !== 'shared-stream' &&
+      streamArgumentType !== 'individual-streams')
+    throw failTest('Unsupported streamArgumentType.');
+  getUserMedia({ audio: true, video: true },
+      function(stream) {
+        let audioStream = undefined;
+        if (streamArgumentType !== 'no-stream')
+          audioStream = new MediaStream();
+
+        let audioTrack = stream.getAudioTracks()[0];
+        let audioSender =
+            audioStream ? peerConnection_().addTrack(audioTrack, audioStream)
+                        : peerConnection_().addTrack(audioTrack);
+        if (!audioSender || audioSender.track != audioTrack)
+          throw failTest('addTrack did not return a sender with the track.');
+
+        let videoStream = undefined;
+        if (streamArgumentType === 'shared-stream') {
+          videoStream = audioStream;
+        } else if (streamArgumentType === 'individual-streams') {
+          videoStream = new MediaStream();
+        }
+
+        let videoTrack = stream.getVideoTracks()[0];
+        let videoSender =
+            videoStream ? peerConnection_().addTrack(videoTrack, videoStream)
+                        : peerConnection_().addTrack(videoTrack);
+        if (!videoSender || videoSender.track != videoTrack)
+          throw failTest('addTrack did not return a sender with the track.');
+
+        let audioStreamId = audioStream ? audioStream.id : 'null';
+        let videoStreamId = videoStream ? videoStream.id : 'null';
+        returnToTest('ok-' + audioStreamId + ' ' + audioTrack.id
+                     + ' ' + videoStreamId + ' ' + videoTrack.id);
+      },
+      function(error) {
+        throw failTest('getUserMedia failed: ' + error);
+      });
+}
+
+/**
+ * Calls |removeTrack| with the first sender that has the track with |trackId|
+ * and verifies the SDP is updated accordingly.
+ *
+ * Returns "ok-sender-removed" on success.
+ */
+function removeTrack(trackId) {
+  let sender = null;
+  let otherSenderHasTrack = false;
+  peerConnection_().getSenders().forEach(function(s) {
+    if (s.track && s.track.id == trackId) {
+      if (!sender)
+        sender = s;
+      else
+        otherSenderHasTrack = true;
+    }
+  });
+  if (!sender)
+    throw failTest('There is no sender for track ' + trackId);
+  peerConnection_().removeTrack(sender);
+  if (sender.track)
+    throw failTest('sender.track was not nulled by removeTrack.');
+  returnToTest('ok-sender-removed');
+}
+
+/**
+ */
+function hasLocalStreamWithTrack(streamId, trackId) {
+  if (hasStreamWithTrack(
+          peerConnection_().getLocalStreams(), streamId, trackId)) {
+    returnToTest('ok-stream-with-track-found');
+    return;
   }
-  returnToTest('ok-receivers-verified');
+  returnToTest('ok-stream-with-track-not-found');
+}
+
+/**
+ */
+function hasRemoteStreamWithTrack(streamId, trackId) {
+  if (hasStreamWithTrack(
+          peerConnection_().getRemoteStreams(), streamId, trackId)) {
+    returnToTest('ok-stream-with-track-found');
+    return;
+  }
+  returnToTest('ok-stream-with-track-not-found');
+}
+
+/**
+ */
+function hasSenderWithTrack(trackId) {
+  if (hasSenderOrReceiverWithTrack(peerConnection_().getSenders(), trackId)) {
+    returnToTest('ok-sender-with-track-found');
+    return;
+  }
+  returnToTest('ok-sender-with-track-not-found');
+}
+
+/**
+ */
+function hasReceiverWithTrack(trackId) {
+  if (hasSenderOrReceiverWithTrack(peerConnection_().getReceivers(), trackId)) {
+    returnToTest('ok-receiver-with-track-found');
+    return;
+  }
+  returnToTest('ok-receiver-with-track-not-found');
+}
+
+/**
+ */
+function startCountingOnNegotiationNeeded() {

[Taylor_Brandstetter, 2017/07/07 19:44:14]

I don't think you really need a "start counting" method; you could just always
count, and have the test take the difference between the count at two points.

[hbos_chromium, 2017/07/10 12:32:59]

I moved this to peerconnection.js where it always sets up the counting as part
of creating the pc and moved all this counter stuff to the same file.

I changed it to a count getter instead.

+  gOnNegotiationNeededCount = 0;
+  peerConnection_().onnegotiationneeded = function() {
+    ++gOnNegotiationNeededCount;
+  }
+  returnToTest('ok-onnegotiationneeded-wired');
+}
+
+/**
+ */
+function waitUntilOnNegotiationCountIs(count) {
+  if (gOnNegotiationNeededCount === undefined)
+    throw failTest('Must call startCountingOnNegotiationNeeded() first.');
+  let checkCount = function() {
+    if (gOnNegotiationNeededCount === count) {
+      returnToTest('ok-expected-count');
+      return;
+    }
+    window.setTimeout(checkCount, 10);

[Taylor_Brandstetter, 2017/07/07 19:44:13]

Does this really need a timeout, even if it's only 10 milliseconds? In theory,
addTrack will queue a task to fire "negotiationneeded". So as long as this task
is added to the end of the queue, it should be executed after the task that
fires the event. At least, if we follow the spec in that regard....

[hbos_chromium, 2017/07/10 12:32:59]

Done, changed to a getter instead of a "wait" and doing a single
window.setTimeout(..., 0) to make sure any queued events are included in the
result / avoid a race.

+  };
+  checkCount();
 }
 
 // Internals.
 
 /** @private */
+function hasStreamWithTrack(streams, streamId, trackId) {
+  for (let i = 0; i < streams.length; ++i) {
+    let stream = streams[i];
+    if (streamId && stream.id !== streamId)
+      continue;
+    let tracks = stream.getTracks();
+    for (let j = 0; j < tracks.length; ++j) {
+      let track = tracks[j];
+      if (track.id == trackId) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/** @private */
+function hasSenderOrReceiverWithTrack(sendersOrReceivers, trackId) {
+  for (let i = 0; i < sendersOrReceivers.length; ++i) {
+    if (sendersOrReceivers[i].track &&
+        sendersOrReceivers[i].track.id === trackId) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** @private */
 function arrayEquals_(a, b) {
   if (a == null)
     return b == null;
   if (a.length != b.length)
     return false;
   for (let i = 0; i < a.length; ++i) {
     if (a[i] !== b[i])
       return false;
   }
   return true;
 }
 
 /** @private */
 function setEquals_(a, b) {
   if (a == null)
     return b == null;
   if (a.size != b.size)
     return false;
   a.forEach(function(value) {
     if (!b.has(value))
       return false;
   });
   return true;
 }