RTCPeerConnection.addTrack and removeTrack added (behind flag)

chrome/test/data/webrtc/munge_sdp.js

 /**
  * Copyright 2016 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.
  */
 
 /**
+ * Parses the SDP to find all streams, tracks and stream-track relationships.
+ * Returns "{ streamIds, trackIds, streamTrackMap }" where |streamIds| and
+ * |trackIds| are |Set| of IDs and |streamTrackMap| is a string-set |Map| from
+ * stream IDs to track IDs (which tracks are members of which streams).
+ *
+ * @param {string} sdp
+ */
+function getSdpStreamsAndTracks(sdp) {

[Taylor_Brandstetter, 2017/07/06 22:45:14]

Relying on SDP parsing in this test is somewhat fragile (it will break when we
switch to "a=msid"); would it be possible to get the track/stream relationships
simply by seeing what remote streams are created on the "right tab" after
setting the remote description?

[hbos_chromium, 2017/07/07 12:07:48]

Good point. Done. Removed SDP usage from test, and added a test to check if
there is a remote stream containing a track with specified ids.

For the addTrack without a stream case the stream id is unknown without sdp
parsing, but we can still verify that some stream contain the track (before
addTrack with no stream is fixed not to create streams), and in both cases we
can make sure there is a receiver for the track.

+  let sdpLines = splitSdpLines(sdp);
+  let streamIds = new Set();
+  let trackIds = new Set();
+  // Find streams and tracks.
+  // a=ssrc:<ssrc> mslabel:<stream id>
+  // a=ssrc:<ssrc> label:<track id>
+  for (let lineNo = 0; lineNo = findLine(sdpLines, 'a=ssrc:', lineNo);
+       lineNo++) {
+    let line = sdpLines[lineNo];
+    let tokens = line.split(' ');
+    if (tokens.length !== 2)
+      continue;
+    if (tokens[1].startsWith('mslabel:')) {
+      streamIds.add(tokens[1].substring(8));
+    } else if (tokens[1].startsWith('label:')) {
+      trackIds.add(tokens[1].substring(6));
+    }
+  }
+  // Find stream and track relationships.
+  // a=ssrc:<ssrc> msid:<stream id> <track id>
+  let streamTrackMap = new Map();
+  for (let lineNo = 0; lineNo = findLine(sdpLines, 'a=ssrc:', lineNo);
+       lineNo++) {
+    let line = sdpLines[lineNo];
+    let tokens = line.split(' ');
+    if (tokens.length !== 3)
+      continue;
+    let ssrc = parseInt(tokens[0].substring(7));
+    if (!tokens[1].startsWith('msid:'))
+      failure('getSdpStreamsAndTracks', 'Expected \'msid:<stream id>\'.');
+    let streamId = tokens[1].substring(5);
+    if (!streamIds.has(streamId)) {
+      failure(
+          'getSdpStreamsAndTracks',
+          'Unknown stream ID \'' + streamId + '\' (\'mslabel\' line missing).');
+    }
+    let trackId = tokens[2];
+    if (!trackIds.has(trackId)) {
+      failure('getSdpStreamsAndTracks',
+              'Unknown track ID \'' + trackId + '\' (\'label\' line missing).');
+    }
+    if (!streamTrackMap.has(streamId))
+      streamTrackMap.set(streamId, new Set([ trackId ]));
+    else
+      streamTrackMap.get(streamId).add(trackId);
+  }
+  return { streamIds:streamIds,
+           trackIds:trackIds,
+           streamTrackMap:streamTrackMap };
+}
+
+/**
  * See |setSdpDefaultCodec|.
  */
 function setSdpDefaultAudioCodec(sdp, codec) {
   return setSdpDefaultCodec(sdp, 'audio', codec);
 }
 
 /**
  * See |setSdpDefaultCodec|.
  */
 function setSdpDefaultVideoCodec(sdp, codec) {
   return setSdpDefaultCodec(sdp, 'video', codec);
 }
 
 /**
  * Returns a modified version of |sdp| where the opus DTX flag has been
  * enabled.
  */
 function setOpusDtxEnabled(sdp) {
   var sdpLines = splitSdpLines(sdp);
 
   // Get default audio codec
   var defaultCodec = getSdpDefaultAudioCodec(sdp);
   if (defaultCodec !== 'opus') {
     failure('setOpusDtxEnabled',
-             'Default audio codec is not set to \'opus\'.');
+            'Default audio codec is not set to \'opus\'.');
   }
 
   // Find codec ID for Opus, e.g. 111 if 'a=rtpmap:111 opus/48000/2'.
   var codecId = findRtpmapId(sdpLines, 'opus');
   if (codecId === null) {
     failure('setOpusDtxEnabled', 'Unknown ID for |codec| = \'opus\'.');
   }
 
   // Find 'a=fmtp:111' line, where 111 is the codecId
   var fmtLineNo = findFmtpLine(sdpLines, codecId);
@@ skipping 14 matching lines @@
  * the default codec, i.e. the codec whose ID is first in the list of codecs on
  * the 'm=|type|' line, where |type| is 'audio' or 'video'.
  * @private
  */
 function setSdpDefaultCodec(sdp, type, codec) {
   var sdpLines = splitSdpLines(sdp);
 
   // Find codec ID, e.g. 100 for 'VP8' if 'a=rtpmap:100 VP8/9000'.
   var codecId = findRtpmapId(sdpLines, codec);
   if (codecId === null) {
-    failure('sdpPreferCodec', 'Unknown ID for |codec| = \'' + codec + '\'.');
+    failure('setSdpDefaultCodec',
+            'Unknown ID for |codec| = \'' + codec + '\'.');
   }
 
   // Find 'm=|type|' line, e.g. 'm=video 9 UDP/TLS/RTP/SAVPF 100 101 107 116'.
   var mLineNo = findLine(sdpLines, 'm=' + type);
   if (mLineNo === null) {
     failure('setSdpDefaultCodec',
-             '\'m=' + type + '\' line missing from |sdp|.');
+            '\'m=' + type + '\' line missing from |sdp|.');
   }
 
   // Modify video line to use the desired codec as the default.
   sdpLines[mLineNo] = setMLineDefaultCodec(sdpLines[mLineNo], codecId);
   return mergeSdpLines(sdpLines);
 }
 
 /**
  * See |getSdpDefaultCodec|.
  */
@@ skipping 14 matching lines @@
  * is 'audio' or 'video'.
  * @private
  */
 function getSdpDefaultCodec(sdp, type) {
   var sdpLines = splitSdpLines(sdp);
 
   // Find 'm=|type|' line, e.g. 'm=video 9 UDP/TLS/RTP/SAVPF 100 101 107 116'.
   var mLineNo = findLine(sdpLines, 'm=' + type);
   if (mLineNo === null) {
     failure('getSdpDefaultCodec',
-             '\'m=' + type + '\' line missing from |sdp|.');
+            '\'m=' + type + '\' line missing from |sdp|.');
   }
 
   // The default codec's ID.
   var defaultCodecId = getMLineDefaultCodec(sdpLines[mLineNo]);
   if (defaultCodecId === null) {
     failure('getSdpDefaultCodec',
-             '\'m=' + type + '\' line contains no codecs.');
+            '\'m=' + type + '\' line contains no codecs.');
   }
 
   // Find codec name, e.g. 'VP8' for 100 if 'a=rtpmap:100 VP8/9000'.
   var defaultCodec = findRtpmapCodec(sdpLines, defaultCodecId);
   if (defaultCodec === null) {
     failure('getSdpDefaultCodec',
-             'Unknown codec name for default codec ' + defaultCodecId + '.');
+            'Unknown codec name for default codec ' + defaultCodecId + '.');
   }
   return defaultCodec;
 }
 
 /**
  * Searches through all |sdpLines| for the 'a=rtpmap:' line for the codec of
  * the specified name, returning its ID as an int if found, or null otherwise.
  * |codec| is the case-sensitive name of the codec.
  * For example, if |sdpLines| contains 'a=rtpmap:100 VP8/9000' and |codec| is
  * 'VP8', this function returns 100.
@@ skipping 103 matching lines @@
 function splitSdpLines(sdp) {
   return sdp.split('\r\n');
 }
 
 /** @private */
 function mergeSdpLines(sdpLines) {
   return sdpLines.join('\r\n');
 }
 
 /** @private */
-function findLine(lines, startsWith) {
-  for (var i = 0; i < lines.length; i++) {
-    if (lines[i].startsWith(startsWith))
+function findLine(lines, lineStartsWith, startingLine = 0) {
+  for (var i = startingLine; i < lines.length; i++) {
+    if (lines[i].startsWith(lineStartsWith))
       return i;
   }
   return null;
 }