If MSID is encoded in both ways, make the SSRC-level one take priority.

webrtc/api/webrtcsdp.cc

 /*
  *  Copyright 2011 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 194 matching lines @@
 static const int kIsacWbDefaultRate = 32000;  // From acm_common_defs.h
 static const int kIsacSwbDefaultRate = 56000;  // From acm_common_defs.h
 
 static const char kDefaultSctpmapProtocol[] = "webrtc-datachannel";
 
 // RTP payload type is in the 0-127 range. Use -1 to indicate "all" payload
 // types.
 const int kWildcardPayloadType = -1;
 
 struct SsrcInfo {
-  SsrcInfo()
-      : stream_id(kDefaultMsid),
-        // TODO(ronghuawu): What should we do if the track id doesn't appear?
-        // Create random string (which will be used as track label later)?
-        track_id(rtc::CreateRandomString(8)) {}
   uint32_t ssrc_id;
   std::string cname;
   std::string stream_id;
   std::string track_id;
 
   // For backward compatibility.
   // TODO(ronghuawu): Remove below 2 fields once all the clients support msid.
   std::string label;
   std::string mslabel;
 };
@@ skipping 336 matching lines @@
 }
 
 static bool GetPayloadTypeFromString(const std::string& line,
                                      const std::string& s,
                                      int* payload_type,
                                      SdpParseError* error) {
   return GetValueFromString(line, s, payload_type, error) &&
       cricket::IsValidRtpPayloadType(*payload_type);
 }
 
+// |msid_stream_id| and |msid_track_id| represent the stream/track ID from the
+// "a=msid" attribute, if it exists. They are empty if the attribute does not
+// exist.
 void CreateTracksFromSsrcInfos(const SsrcInfoVec& ssrc_infos,
+                               const std::string& msid_stream_id,
+                               const std::string& msid_track_id,
                                StreamParamsVec* tracks) {
   ASSERT(tracks != NULL);
+  ASSERT(msid_stream_id.empty() == msid_track_id.empty());
   for (SsrcInfoVec::const_iterator ssrc_info = ssrc_infos.begin();
        ssrc_info != ssrc_infos.end(); ++ssrc_info) {
     if (ssrc_info->cname.empty()) {
       continue;
     }
 
-    std::string sync_label;
+    std::string stream_id;
     std::string track_id;
-    if (ssrc_info->stream_id == kDefaultMsid && !ssrc_info->mslabel.empty()) {
+    if (ssrc_info->stream_id.empty() && !ssrc_info->mslabel.empty()) {
       // If there's no msid and there's mslabel, we consider this is a sdp from
       // a older version of client that doesn't support msid.
       // In that case, we use the mslabel and label to construct the track.
-      sync_label = ssrc_info->mslabel;
+      stream_id = ssrc_info->mslabel;
       track_id = ssrc_info->label;
+    } else if (ssrc_info->stream_id.empty() && !msid_stream_id.empty()) {
+      // If there's no msid in the SSRC attributes, but there's a global one
+      // (from a=msid), use that. This is the case with unified plan SDP.
+      stream_id = msid_stream_id;
+      track_id = msid_track_id;
     } else {
-      sync_label = ssrc_info->stream_id;
+      stream_id = ssrc_info->stream_id;
       track_id = ssrc_info->track_id;
     }
-    if (sync_label.empty() || track_id.empty()) {
-      ASSERT(false);
-      continue;
+    // If a stream/track ID wasn't populated from the SSRC attributes OR the
+    // msid attribute, use default/random values.
+    if (stream_id.empty()) {
+      stream_id = kDefaultMsid;
+    }
+    if (track_id.empty()) {
+      // TODO(ronghuawu): What should we do if the track id doesn't appear?
+      // Create random string (which will be used as track label later)?
+      track_id = rtc::CreateRandomString(8);
     }
 
     StreamParamsVec::iterator track = tracks->begin();
     for (; track != tracks->end(); ++track) {
       if (track->id == track_id) {
         break;
       }
     }
     if (track == tracks->end()) {
       // If we don't find an existing track, create a new one.
       tracks->push_back(StreamParams());
       track = tracks->end() - 1;
     }
     track->add_ssrc(ssrc_info->ssrc_id);
     track->cname = ssrc_info->cname;
-    track->sync_label = sync_label;
+    track->sync_label = stream_id;
     track->id = track_id;
   }
 }
 
 void GetMediaStreamLabels(const ContentInfo* content,
                           std::set<std::string>* labels) {
   const MediaContentDescription* media_desc =
       static_cast<const MediaContentDescription*>(
           content->description);
   const cricket::StreamParamsVec& streams =  media_desc->streams();
@@ skipping 2037 matching lines @@
           return false;
         }
       }
     } else {
       // Only parse lines that we are interested of.
       LOG(LS_INFO) << "Ignored line: " << line;
       continue;
     }
   }
 
-  // Found an msid attribute.
-  // Setting the stream_id/track_id will cause only one StreamParams
-  // to be created in CreateTracksFromSsrcInfos, containing all the SSRCs from
-  // the m= section.
-  if (!stream_id.empty() && !track_id.empty()) {
-    for (SsrcInfo& ssrc_info : ssrc_infos) {
-      ssrc_info.stream_id = stream_id;
-      ssrc_info.track_id = track_id;
-    }
-  }
-
   // Create tracks from the |ssrc_infos|.
-  CreateTracksFromSsrcInfos(ssrc_infos, &tracks);
+  // If the stream_id/track_id for all SSRCS are identical, one StreamParams
+  // will be created in CreateTracksFromSsrcInfos, containing all the SSRCs from
+  // the m= section.
+  CreateTracksFromSsrcInfos(ssrc_infos, stream_id, track_id, &tracks);
 
   // Add the ssrc group to the track.
   for (SsrcGroupVec::iterator ssrc_group = ssrc_groups.begin();
        ssrc_group != ssrc_groups.end(); ++ssrc_group) {
     if (ssrc_group->ssrcs.empty()) {
       continue;
     }
     uint32_t ssrc = ssrc_group->ssrcs.front();
     for (StreamParamsVec::iterator track = tracks.begin();
          track != tracks.end(); ++track) {
@@ skipping 428 matching lines @@
     UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
         media_desc, payload_type, feedback_param);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
         media_desc, payload_type, feedback_param);
   }
   return true;
 }
 
 }  // namespace webrtc