Exposing RtpSenders and RtpReceivers from PeerConnection.

talk/app/webrtc/mediastreamsignaling.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 341 matching lines @@
   // description is not changed and RemoveLocalStream
   // is called and later AddLocalStream is called again with the same stream.
   AudioTrackVector audio_tracks = local_stream->GetAudioTracks();
   for (AudioTrackVector::const_iterator it = audio_tracks.begin();
        it != audio_tracks.end(); ++it) {
     const TrackInfo* track_info = FindTrackInfo(local_audio_tracks_,
                                                 local_stream->label(),
                                                 (*it)->id());
     if (track_info) {
       OnLocalTrackSeen(track_info->stream_label, track_info->track_id,
-                       track_info->ssrc, cricket::MEDIA_TYPE_AUDIO);
+                       track_info->ssrc, cricket::MEDIA_TYPE_AUDIO,
+                       track_info->mid);
     }
   }
 
   VideoTrackVector video_tracks = local_stream->GetVideoTracks();
   for (VideoTrackVector::const_iterator it = video_tracks.begin();
        it != video_tracks.end(); ++it) {
     const TrackInfo* track_info = FindTrackInfo(local_video_tracks_,
                                                 local_stream->label(),
                                                 (*it)->id());
     if (track_info) {
       OnLocalTrackSeen(track_info->stream_label, track_info->track_id,
-                       track_info->ssrc, cricket::MEDIA_TYPE_VIDEO);
+                       track_info->ssrc, cricket::MEDIA_TYPE_VIDEO,
+                       track_info->mid);
     }
   }
   return true;
 }
 
 void MediaStreamSignaling::RemoveLocalStream(
     MediaStreamInterface* local_stream) {
   AudioTrackVector audio_tracks = local_stream->GetAudioTracks();
   for (AudioTrackVector::const_iterator it = audio_tracks.begin();
        it != audio_tracks.end(); ++it) {
@@ skipping 79 matching lines @@
   rtc::scoped_refptr<StreamCollection> new_streams(
       StreamCollection::Create());
 
   // Find all audio rtp streams and create corresponding remote AudioTracks
   // and MediaStreams.
   const cricket::ContentInfo* audio_content = GetFirstAudioContent(remote_desc);
   if (audio_content) {
     const cricket::AudioContentDescription* desc =
         static_cast<const cricket::AudioContentDescription*>(
             audio_content->description);
-    UpdateRemoteStreamsList(desc->streams(), desc->type(), new_streams);
+    UpdateRemoteStreamsList(desc->streams(), desc->type(), audio_content->name,
+                            new_streams);
     remote_info_.default_audio_track_needed =
         MediaContentDirectionHasSend(desc->direction()) &&
             desc->streams().empty();
+    if (remote_info_.default_audio_track_needed) {
+      remote_info_.default_audio_mid = audio_content->name;
+    }
   }
 
   // Find all video rtp streams and create corresponding remote VideoTracks
   // and MediaStreams.
   const cricket::ContentInfo* video_content = GetFirstVideoContent(remote_desc);
   if (video_content) {
     const cricket::VideoContentDescription* desc =
         static_cast<const cricket::VideoContentDescription*>(
             video_content->description);
-    UpdateRemoteStreamsList(desc->streams(), desc->type(), new_streams);
+    UpdateRemoteStreamsList(desc->streams(), desc->type(), video_content->name,
+                            new_streams);
     remote_info_.default_video_track_needed =
         MediaContentDirectionHasSend(desc->direction()) &&
             desc->streams().empty();
+    if (remote_info_.default_video_track_needed) {
+      remote_info_.default_video_mid = video_content->name;
+    }
   }
 
   // Update the DataChannels with the information from the remote peer.
   const cricket::ContentInfo* data_content = GetFirstDataContent(remote_desc);
   if (data_content) {
     const cricket::DataContentDescription* data_desc =
         static_cast<const cricket::DataContentDescription*>(
             data_content->description);
     if (rtc::starts_with(
             data_desc->protocol().data(), cricket::kMediaProtocolRtpPrefix)) {
@@ skipping 22 matching lines @@
     const SessionDescriptionInterface* desc) {
   const cricket::ContentInfo* audio_content =
       GetFirstAudioContent(desc->description());
   if (audio_content) {
     if (audio_content->rejected) {
       RejectRemoteTracks(cricket::MEDIA_TYPE_AUDIO);
     }
     const cricket::AudioContentDescription* audio_desc =
         static_cast<const cricket::AudioContentDescription*>(
             audio_content->description);
-    UpdateLocalTracks(audio_desc->streams(), audio_desc->type());
+    UpdateLocalTracks(audio_desc->streams(), audio_desc->type(),
+                      audio_content->name);
   }
 
   const cricket::ContentInfo* video_content =
       GetFirstVideoContent(desc->description());
   if (video_content) {
     if (video_content->rejected) {
       RejectRemoteTracks(cricket::MEDIA_TYPE_VIDEO);
     }
     const cricket::VideoContentDescription* video_desc =
         static_cast<const cricket::VideoContentDescription*>(
             video_content->description);
-    UpdateLocalTracks(video_desc->streams(), video_desc->type());
+    UpdateLocalTracks(video_desc->streams(), video_desc->type(),
+                      video_content->name);
   }
 
   const cricket::ContentInfo* data_content =
       GetFirstDataContent(desc->description());
   if (data_content) {
     const cricket::DataContentDescription* data_desc =
         static_cast<const cricket::DataContentDescription*>(
             data_content->description);
     if (rtc::starts_with(
             data_desc->protocol().data(), cricket::kMediaProtocolRtpPrefix)) {
@@ skipping 24 matching lines @@
   temp_sctp_dcs.swap(sctp_data_channels_);
   SctpDataChannels::iterator it2 = temp_sctp_dcs.begin();
   for (; it2 != temp_sctp_dcs.end(); ++it2) {
     (*it2)->OnDataEngineClose();
   }
 }
 
 void MediaStreamSignaling::UpdateRemoteStreamsList(
     const cricket::StreamParamsVec& streams,
     cricket::MediaType media_type,
+    const std::string& mid,
     StreamCollection* new_streams) {
   TrackInfos* current_tracks = GetRemoteTracks(media_type);
 
   // Find removed tracks. Ie tracks where the track id or ssrc don't match the
   // new StreamParam.
   TrackInfos::iterator track_it = current_tracks->begin();
   while (track_it != current_tracks->end()) {
     const TrackInfo& info = *track_it;
     const cricket::StreamParams* params =
         cricket::GetStreamBySsrc(streams, info.ssrc);
@@ skipping 19 matching lines @@
     if (!stream) {
       // This is a new MediaStream. Create a new remote MediaStream.
       stream = remote_stream_factory_->CreateMediaStream(stream_label);
       remote_streams_->AddStream(stream);
       new_streams->AddStream(stream);
     }
 
     const TrackInfo* track_info = FindTrackInfo(*current_tracks, stream_label,
                                                 track_id);
     if (!track_info) {
-      current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc));
-      OnRemoteTrackSeen(stream_label, track_id, it->first_ssrc(), media_type);
+      current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc, mid));
+      OnRemoteTrackSeen(stream_label, track_id, it->first_ssrc(), media_type,
+                        mid);
     }
   }
 }
 
 void MediaStreamSignaling::OnRemoteTrackSeen(const std::string& stream_label,
                                              const std::string& track_id,
                                              uint32 ssrc,
-                                             cricket::MediaType media_type) {
+                                             cricket::MediaType media_type,
+                                             const std::string& mid) {
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     AudioTrackInterface* audio_track =
         remote_stream_factory_->AddAudioTrack(stream, track_id);
-    stream_observer_->OnAddRemoteAudioTrack(stream, audio_track, ssrc);
+    stream_observer_->OnAddRemoteAudioTrack(stream, audio_track, ssrc, mid);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     VideoTrackInterface* video_track =
         remote_stream_factory_->AddVideoTrack(stream, track_id);
-    stream_observer_->OnAddRemoteVideoTrack(stream, video_track, ssrc);
+    stream_observer_->OnAddRemoteVideoTrack(stream, video_track, ssrc, mid);
   } else {
     ASSERT(false && "Invalid media type");
   }
 }
 
 void MediaStreamSignaling::OnRemoteTrackRemoved(
     const std::string& stream_label,
     const std::string& track_id,
     cricket::MediaType media_type) {
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
@@ skipping 70 matching lines @@
       remote_streams_->find(kDefaultStreamLabel);
   if (default_remote_stream == NULL) {
     default_created = true;
     default_remote_stream =
         remote_stream_factory_->CreateMediaStream(kDefaultStreamLabel);
     remote_streams_->AddStream(default_remote_stream);
   }
   if (remote_info_.default_audio_track_needed &&
       default_remote_stream->GetAudioTracks().size() == 0) {
     remote_audio_tracks_.push_back(TrackInfo(kDefaultStreamLabel,
-                                             kDefaultAudioTrackLabel, 0));
+                                             kDefaultAudioTrackLabel, 0,
+                                             remote_info_.default_audio_mid));
 
     OnRemoteTrackSeen(kDefaultStreamLabel, kDefaultAudioTrackLabel, 0,
-                       cricket::MEDIA_TYPE_AUDIO);
+                      cricket::MEDIA_TYPE_AUDIO,
+                      remote_info_.default_audio_mid);
   }
   if (remote_info_.default_video_track_needed &&
       default_remote_stream->GetVideoTracks().size() == 0) {
     remote_video_tracks_.push_back(TrackInfo(kDefaultStreamLabel,
-                                             kDefaultVideoTrackLabel, 0));
+                                             kDefaultVideoTrackLabel, 0,
+                                             remote_info_.default_video_mid));
     OnRemoteTrackSeen(kDefaultStreamLabel, kDefaultVideoTrackLabel, 0,
-                       cricket::MEDIA_TYPE_VIDEO);
+                      cricket::MEDIA_TYPE_VIDEO,
+                      remote_info_.default_video_mid);
   }
   if (default_created) {
     stream_observer_->OnAddRemoteStream(default_remote_stream);
   }
 }
 
 MediaStreamSignaling::TrackInfos* MediaStreamSignaling::GetRemoteTracks(
     cricket::MediaType type) {
   if (type == cricket::MEDIA_TYPE_AUDIO)
     return &remote_audio_tracks_;
   else if (type == cricket::MEDIA_TYPE_VIDEO)
     return &remote_video_tracks_;
   ASSERT(false && "Unknown MediaType");
   return NULL;
 }
 
 MediaStreamSignaling::TrackInfos* MediaStreamSignaling::GetLocalTracks(
     cricket::MediaType media_type) {
   ASSERT(media_type == cricket::MEDIA_TYPE_AUDIO ||
          media_type == cricket::MEDIA_TYPE_VIDEO);
 
   return (media_type == cricket::MEDIA_TYPE_AUDIO) ?
       &local_audio_tracks_ : &local_video_tracks_;
 }
 
 void MediaStreamSignaling::UpdateLocalTracks(
     const std::vector<cricket::StreamParams>& streams,
-    cricket::MediaType media_type) {
+    cricket::MediaType media_type,
+    const std::string& mid) {
   TrackInfos* current_tracks = GetLocalTracks(media_type);
 
   // Find removed tracks. Ie tracks where the track id, stream label or ssrc
   // don't match the new StreamParam.
   TrackInfos::iterator track_it = current_tracks->begin();
   while (track_it != current_tracks->end()) {
     const TrackInfo& info = *track_it;
     const cricket::StreamParams* params =
         cricket::GetStreamBySsrc(streams, info.ssrc);
     if (!params || params->id != info.track_id ||
@@ skipping 11 matching lines @@
        it != streams.end(); ++it) {
     // The sync_label is the MediaStream label and the |stream.id| is the
     // track id.
     const std::string& stream_label = it->sync_label;
     const std::string& track_id = it->id;
     uint32 ssrc = it->first_ssrc();
     const TrackInfo* track_info = FindTrackInfo(*current_tracks,
                                                 stream_label,
                                                 track_id);
     if (!track_info) {
-      current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc));
-      OnLocalTrackSeen(stream_label, track_id, it->first_ssrc(),
-                       media_type);
+      current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc, mid));
+      OnLocalTrackSeen(stream_label, track_id, it->first_ssrc(), media_type,
+                       mid);
     }
   }
 }
 
-void MediaStreamSignaling::OnLocalTrackSeen(
-    const std::string& stream_label,
-    const std::string& track_id,
-    uint32 ssrc,
-    cricket::MediaType media_type) {
+void MediaStreamSignaling::OnLocalTrackSeen(const std::string& stream_label,
+                                            const std::string& track_id,
+                                            uint32 ssrc,
+                                            cricket::MediaType media_type,
+                                            const std::string& mid) {
   MediaStreamInterface* stream = local_streams_->find(stream_label);
   if (!stream) {
     LOG(LS_WARNING) << "An unknown local MediaStream with label "
                     << stream_label <<  " has been configured.";
     return;
   }
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     AudioTrackInterface* audio_track = stream->FindAudioTrack(track_id);
     if (!audio_track) {
       LOG(LS_WARNING) << "An unknown local AudioTrack with id , "
                       << track_id <<  " has been configured.";
       return;
     }
-    stream_observer_->OnAddLocalAudioTrack(stream, audio_track, ssrc);
+    stream_observer_->OnAddLocalAudioTrack(stream, audio_track, ssrc, mid);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     VideoTrackInterface* video_track = stream->FindVideoTrack(track_id);
     if (!video_track) {
       LOG(LS_WARNING) << "An unknown local VideoTrack with id , "
                       << track_id <<  " has been configured.";
       return;
     }
-    stream_observer_->OnAddLocalVideoTrack(stream, video_track, ssrc);
+    stream_observer_->OnAddLocalVideoTrack(stream, video_track, ssrc, mid);
   } else {
     ASSERT(false && "Invalid media type");
   }
 }
 
 void MediaStreamSignaling::OnLocalTrackRemoved(
     const std::string& stream_label,
     const std::string& track_id,
     uint32 ssrc,
     cricket::MediaType media_type) {
@@ skipping 167 matching lines @@
 int MediaStreamSignaling::FindDataChannelBySid(int sid) const {
   for (size_t i = 0; i < sctp_data_channels_.size(); ++i) {
     if (sctp_data_channels_[i]->id() == sid) {
       return static_cast<int>(i);
     }
   }
   return -1;
 }
 
 }  // namespace webrtc