Exposing RtpSenders and RtpReceivers from PeerConnection.

talk/app/webrtc/peerconnection.cc

Index: talk/app/webrtc/peerconnection.cc
diff --git a/talk/app/webrtc/peerconnection.cc b/talk/app/webrtc/peerconnection.cc
index 9e2cc731c07cdab9af64a69c103f30ccb28878cc..45bb6829699c444477086a366f9c79c78afd293b 100644
--- a/talk/app/webrtc/peerconnection.cc
+++ b/talk/app/webrtc/peerconnection.cc
@@ -33,7 +33,6 @@
 #include "talk/app/webrtc/jsepicecandidate.h"
 #include "talk/app/webrtc/jsepsessiondescription.h"
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
-#include "talk/app/webrtc/mediastreamhandler.h"
 #include "talk/app/webrtc/streamcollection.h"
 #include "webrtc/p2p/client/basicportallocator.h"
 #include "talk/session/media/channelmanager.h"
@@ -339,10 +338,17 @@ PeerConnection::PeerConnection(PeerConnectionFactory* factory)
 
 PeerConnection::~PeerConnection() {
   ASSERT(signaling_thread()->IsCurrent());
-  if (mediastream_signaling_)
+  if (mediastream_signaling_) {
     mediastream_signaling_->TearDown();
-  if (stream_handler_container_)
-    stream_handler_container_->TearDown();
+  }
+  // Need to detach RTP senders/receivers from WebRtcSession,
+  // since it's about to be destroyed.
+  for (const auto& pair : rtp_sender_pairs_) {
+    pair.first->DetachFromProvider();
+  }
+  for (const auto& pair : rtp_receiver_pairs_) {
+    pair.first->DetachFromProvider();
+  }
 }
 
 bool PeerConnection::Initialize(
@@ -399,8 +405,6 @@ bool PeerConnection::Initialize(
                                    factory_->worker_thread(),
                                    port_allocator_.get(),
                                    mediastream_signaling_.get()));
-  stream_handler_container_.reset(new MediaStreamHandlerContainer(
-      session_.get(), session_.get()));
   stats_.reset(new StatsCollector(session_.get()));
 
   // Initialize the WebRtcSession. It creates transport channels etc.
@@ -425,6 +429,8 @@ PeerConnection::remote_streams() {
   return mediastream_signaling_->remote_streams();
 }
 
+// TODO(deadbeef): Create RtpSenders immediately here, even if local
+// description hasn't yet been set.

[pthatcher1, 2015/09/23 14:47:39]

More like "Replace with addTrack, which may create RtpSenders and RtpReceivers
immediately.".

[pthatcher1, 2015/09/24 06:32:29]

Can you update this comment?

 bool PeerConnection::AddStream(MediaStreamInterface* local_stream) {
   if (IsClosed()) {
     return false;
@@ -469,6 +475,22 @@ rtc::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
   return DtmfSenderProxy::Create(signaling_thread(), sender.get());
 }
 
+RtpSenderRefptrs PeerConnection::GetSenders() const {
+  RtpSenderRefptrs senders;
+  for (const auto& pair : rtp_sender_pairs_) {
+    senders.push_back(pair.second);
+  }
+  return senders;
+}
+
+RtpReceiverRefptrs PeerConnection::GetReceivers() const {
+  RtpReceiverRefptrs receivers;
+  for (const auto& pair : rtp_receiver_pairs_) {
+    receivers.push_back(pair.second);
+  }
+  return receivers;
+}
+
 bool PeerConnection::GetStats(StatsObserver* observer,
                               MediaStreamTrackInterface* track,
                               StatsOutputLevel level) {
@@ -806,7 +828,6 @@ void PeerConnection::OnAddRemoteStream(MediaStreamInterface* stream) {
 }
 
 void PeerConnection::OnRemoveRemoteStream(MediaStreamInterface* stream) {
-  stream_handler_container_->RemoveRemoteStream(stream);
   observer_->OnRemoveStream(stream);
 }
 
@@ -818,52 +839,87 @@ void PeerConnection::OnAddDataChannel(DataChannelInterface* data_channel) {
 void PeerConnection::OnAddRemoteAudioTrack(MediaStreamInterface* stream,
                                            AudioTrackInterface* audio_track,
                                            uint32 ssrc) {
-  stream_handler_container_->AddRemoteAudioTrack(stream, audio_track, ssrc);
+  AddRtpReceiver(new AudioRtpReceiver(audio_track, ssrc, session_.get()));
 }
 
 void PeerConnection::OnAddRemoteVideoTrack(MediaStreamInterface* stream,
                                            VideoTrackInterface* video_track,
                                            uint32 ssrc) {
-  stream_handler_container_->AddRemoteVideoTrack(stream, video_track, ssrc);
+  AddRtpReceiver(new VideoRtpReceiver(video_track, ssrc, session_.get()));
 }
 
+// TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
+// description.

[pthatcher1, 2015/09/23 14:47:39]

Well, in unified plan m-lines can never go away.  So this TODO is really
"Implement Unified Plan, in which case RtpReceivers will never be removed."

 void PeerConnection::OnRemoveRemoteAudioTrack(
     MediaStreamInterface* stream,
     AudioTrackInterface* audio_track) {
-  stream_handler_container_->RemoveRemoteTrack(stream, audio_track);
+  auto it = FindRtpReceiverPairForTrack(audio_track);
+  if (it == rtp_receiver_pairs_.end()) {
+    LOG(LS_WARNING) << "RtpReceiver for track with id " << audio_track->id()
+                    << " doesn't exist.";
+  } else {
+    it->first->DetachFromProvider();
+    rtp_receiver_pairs_.erase(it);
+  }
 }
 
 void PeerConnection::OnRemoveRemoteVideoTrack(
     MediaStreamInterface* stream,
     VideoTrackInterface* video_track) {
-  stream_handler_container_->RemoveRemoteTrack(stream, video_track);
+  auto it = FindRtpReceiverPairForTrack(video_track);
+  if (it == rtp_receiver_pairs_.end()) {
+    LOG(LS_WARNING) << "RtpReceiver for track with id " << video_track->id()
+                    << " doesn't exist.";
+  } else {
+    it->first->DetachFromProvider();
+    rtp_receiver_pairs_.erase(it);
+  }
 }
+
 void PeerConnection::OnAddLocalAudioTrack(MediaStreamInterface* stream,
                                           AudioTrackInterface* audio_track,
                                           uint32 ssrc) {
-  stream_handler_container_->AddLocalAudioTrack(stream, audio_track, ssrc);
+  AddRtpSender(new AudioRtpSender(audio_track, ssrc, session_.get()));
   stats_->AddLocalAudioTrack(audio_track, ssrc);
 }
+
 void PeerConnection::OnAddLocalVideoTrack(MediaStreamInterface* stream,
                                           VideoTrackInterface* video_track,
                                           uint32 ssrc) {
-  stream_handler_container_->AddLocalVideoTrack(stream, video_track, ssrc);
+  AddRtpSender(new VideoRtpSender(video_track, ssrc, session_.get()));
 }
 
+// TODO(deadbeef): Keep RtpSenders around even if track goes away in local
+// description.
 void PeerConnection::OnRemoveLocalAudioTrack(MediaStreamInterface* stream,
                                              AudioTrackInterface* audio_track,
                                              uint32 ssrc) {
-  stream_handler_container_->RemoveLocalTrack(stream, audio_track);
+  auto it = FindRtpSenderPairForTrack(audio_track);
+  if (it == rtp_sender_pairs_.end()) {
+    LOG(LS_WARNING) << "RtpSender for track with id " << audio_track->id()
+                    << " doesn't exist.";
+    return;
+  } else {
+    it->first->DetachFromProvider();
+    rtp_sender_pairs_.erase(it);
+  }
   stats_->RemoveLocalAudioTrack(audio_track, ssrc);
 }
 
 void PeerConnection::OnRemoveLocalVideoTrack(MediaStreamInterface* stream,
                                              VideoTrackInterface* video_track) {
-  stream_handler_container_->RemoveLocalTrack(stream, video_track);
+  auto it = FindRtpSenderPairForTrack(video_track);
+  if (it == rtp_sender_pairs_.end()) {
+    LOG(LS_WARNING) << "RtpSender for track with id " << video_track->id()
+                    << " doesn't exist.";
+    return;
+  } else {
+    it->first->DetachFromProvider();
+    rtp_sender_pairs_.erase(it);
+  }
 }
 
 void PeerConnection::OnRemoveLocalStream(MediaStreamInterface* stream) {
-  stream_handler_container_->RemoveLocalStream(stream);
 }
 
 void PeerConnection::OnIceConnectionChange(
@@ -913,4 +969,30 @@ void PeerConnection::ChangeSignalingState(
   observer_->OnStateChange(PeerConnectionObserver::kSignalingState);
 }
 
+void PeerConnection::AddRtpSender(BaseRtpSender* sender) {
+  rtp_sender_pairs_.push_back(RtpSenderPair(
+      sender, RtpSenderProxy::Create(signaling_thread(), sender)));
+}
+
+void PeerConnection::AddRtpReceiver(BaseRtpReceiver* receiver) {
+  rtp_receiver_pairs_.push_back(RtpReceiverPair(
+      receiver, RtpReceiverProxy::Create(signaling_thread(), receiver)));
+}
+
+PeerConnection::RtpSenderPairList::iterator
+PeerConnection::FindRtpSenderPairForTrack(MediaStreamTrackInterface* track) {
+  return std::find_if(rtp_sender_pairs_.begin(), rtp_sender_pairs_.end(),
+                      [track](const RtpSenderPair& pair) {
+                        return pair.first->track() == track;
+                      });
+}
+
+PeerConnection::RtpReceiverPairList::iterator
+PeerConnection::FindRtpReceiverPairForTrack(MediaStreamTrackInterface* track) {
+  return std::find_if(rtp_receiver_pairs_.begin(), rtp_receiver_pairs_.end(),
+                      [track](const RtpReceiverPair& pair) {
+                        return pair.first->track() == track;
+                      });
+}
+
 }  // namespace webrtc