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..ce55f34f8bff32611dc58a8d34e8d96834713696 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& sender : rtp_senders_) {
+    sender->DetachFromProvider();
+  }
+  for (const auto& receiver : rtp_receivers_) {
+    receiver->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.
 bool PeerConnection::AddStream(MediaStreamInterface* local_stream) {
   if (IsClosed()) {
     return false;
@@ -469,6 +475,23 @@ rtc::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
   return DtmfSenderProxy::Create(signaling_thread(), sender.get());
 }
 
+RtpSenderRefptrs PeerConnection::GetSenders() const {
+  RtpSenderRefptrs senders;
+  for (const auto& sender : rtp_senders_) {
+    senders.push_back(RtpSenderProxy::Create(signaling_thread(), sender.get()));
+  }

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

Why do we still have proxies here?
 

Can't we just "return senders_"?  If so, why not return a const ref?

[Taylor Brandstetter, 2015/09/24 20:54:20]

We still need to return an object that does thread hopping, since the RtpSender
expects everything to be called on the signaling thread. Just like we do for the
DataChannel, and the PeerConnection itself.

[pthatcher1, 2015/09/24 21:18:34]

OK, I get it now.  Thanks.

+  return senders;
+}
+
+RtpReceiverRefptrs PeerConnection::GetReceivers() const {
+  RtpReceiverRefptrs receivers;
+  for (const auto& receiver : rtp_receivers_) {
+    receivers.push_back(
+        RtpReceiverProxy::Create(signaling_thread(), receiver.get()));
+  }
+  return receivers;
+}
+
 bool PeerConnection::GetStats(StatsObserver* observer,
                               MediaStreamTrackInterface* track,
                               StatsOutputLevel level) {
@@ -806,7 +829,6 @@ void PeerConnection::OnAddRemoteStream(MediaStreamInterface* stream) {
 }
 
 void PeerConnection::OnRemoveRemoteStream(MediaStreamInterface* stream) {
-  stream_handler_container_->RemoveRemoteStream(stream);
   observer_->OnRemoveStream(stream);
 }
 
@@ -818,52 +840,89 @@ void PeerConnection::OnAddDataChannel(DataChannelInterface* data_channel) {
 void PeerConnection::OnAddRemoteAudioTrack(MediaStreamInterface* stream,
                                            AudioTrackInterface* audio_track,
                                            uint32 ssrc) {
-  stream_handler_container_->AddRemoteAudioTrack(stream, audio_track, ssrc);
+  rtp_receivers_.push_back(
+      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);
+  rtp_receivers_.push_back(
+      new VideoRtpReceiver(video_track, ssrc, session_.get()));
 }
 
+// TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
+// description.
 void PeerConnection::OnRemoveRemoteAudioTrack(
     MediaStreamInterface* stream,
     AudioTrackInterface* audio_track) {
-  stream_handler_container_->RemoveRemoteTrack(stream, audio_track);
+  auto it = FindRtpReceiverForTrack(audio_track);
+  if (it == rtp_receivers_.end()) {
+    LOG(LS_WARNING) << "RtpReceiver for track with id " << audio_track->id()
+                    << " doesn't exist.";
+  } else {
+    (*it)->DetachFromProvider();

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

Nit: our usual style is it.second->Foo() rather than (*it)->Foo()

[Taylor Brandstetter, 2015/09/24 20:54:20]

But this isn't an iterator to a pair of pointers, it's just an iterator to a
pointer.

[pthatcher1, 2015/09/24 21:18:34]

Oh, duh :).

+    rtp_receivers_.erase(it);
+  }
 }
 
 void PeerConnection::OnRemoveRemoteVideoTrack(
     MediaStreamInterface* stream,
     VideoTrackInterface* video_track) {
-  stream_handler_container_->RemoveRemoteTrack(stream, video_track);
+  auto it = FindRtpReceiverForTrack(video_track);
+  if (it == rtp_receivers_.end()) {
+    LOG(LS_WARNING) << "RtpReceiver for track with id " << video_track->id()
+                    << " doesn't exist.";
+  } else {
+    (*it)->DetachFromProvider();
+    rtp_receivers_.erase(it);
+  }
 }
+
 void PeerConnection::OnAddLocalAudioTrack(MediaStreamInterface* stream,
                                           AudioTrackInterface* audio_track,
                                           uint32 ssrc) {
-  stream_handler_container_->AddLocalAudioTrack(stream, audio_track, ssrc);
+  rtp_senders_.push_back(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);
+  rtp_senders_.push_back(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 = FindRtpSenderForTrack(audio_track);
+  if (it == rtp_senders_.end()) {
+    LOG(LS_WARNING) << "RtpSender for track with id " << audio_track->id()
+                    << " doesn't exist.";
+    return;
+  } else {
+    (*it)->DetachFromProvider();
+    rtp_senders_.erase(it);
+  }
   stats_->RemoveLocalAudioTrack(audio_track, ssrc);
 }
 
 void PeerConnection::OnRemoveLocalVideoTrack(MediaStreamInterface* stream,
                                              VideoTrackInterface* video_track) {
-  stream_handler_container_->RemoveLocalTrack(stream, video_track);
+  auto it = FindRtpSenderForTrack(video_track);
+  if (it == rtp_senders_.end()) {
+    LOG(LS_WARNING) << "RtpSender for track with id " << video_track->id()
+                    << " doesn't exist.";
+    return;
+  } else {
+    (*it)->DetachFromProvider();
+    rtp_senders_.erase(it);
+  }
 }
 
 void PeerConnection::OnRemoveLocalStream(MediaStreamInterface* stream) {
-  stream_handler_container_->RemoveLocalStream(stream);
 }
 
 void PeerConnection::OnIceConnectionChange(
@@ -913,4 +972,20 @@ void PeerConnection::ChangeSignalingState(
   observer_->OnStateChange(PeerConnectionObserver::kSignalingState);
 }
 
+PeerConnection::BaseRtpSenderRefptrs::iterator
+PeerConnection::FindRtpSenderForTrack(MediaStreamTrackInterface* track) {
+  return std::find_if(rtp_senders_.begin(), rtp_senders_.end(),
+                      [track](const rtc::scoped_refptr<BaseRtpSender>& sender) {
+                        return sender->track() == track;
+                      });
+}
+PeerConnection::BaseRtpReceiverRefptrs::iterator
+PeerConnection::FindRtpReceiverForTrack(MediaStreamTrackInterface* track) {
+  return std::find_if(
+      rtp_receivers_.begin(), rtp_receivers_.end(),
+      [track](const rtc::scoped_refptr<BaseRtpReceiver>& receiver) {
+        return receiver->track() == track;
+      });
+}
+
 }  // namespace webrtc