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..7666fd35621222a2bc91fa325db09e485ee4836c 100644
--- a/talk/app/webrtc/peerconnection.cc
+++ b/talk/app/webrtc/peerconnection.cc
@@ -33,7 +33,8 @@
 #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/rtpreceiver.h"
+#include "talk/app/webrtc/rtpsender.h"
 #include "talk/app/webrtc/streamcollection.h"
 #include "webrtc/p2p/client/basicportallocator.h"
 #include "talk/session/media/channelmanager.h"
@@ -339,10 +340,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->Stop();
+  }
+  for (const auto& receiver : rtp_receivers_) {
+    receiver->Stop();
+  }
 }
 
 bool PeerConnection::Initialize(
@@ -399,8 +407,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.
@@ -806,7 +812,6 @@ void PeerConnection::OnAddRemoteStream(MediaStreamInterface* stream) {
 }
 
 void PeerConnection::OnRemoveRemoteStream(MediaStreamInterface* stream) {
-  stream_handler_container_->RemoveRemoteStream(stream);
   observer_->OnRemoveStream(stream);
 }
 
@@ -817,53 +822,96 @@ void PeerConnection::OnAddDataChannel(DataChannelInterface* data_channel) {
 
 void PeerConnection::OnAddRemoteAudioTrack(MediaStreamInterface* stream,
                                            AudioTrackInterface* audio_track,
-                                           uint32 ssrc) {
-  stream_handler_container_->AddRemoteAudioTrack(stream, audio_track, ssrc);
+                                           uint32 ssrc,
+                                           const std::string& mid) {
+  rtp_receivers_.push_back(rtc::scoped_refptr<RtpReceiverInterface>(
+      new rtc::RefCountedObject<AudioRtpReceiver>(audio_track, ssrc, mid,
+                                                  session_.get())));
 }
 
 void PeerConnection::OnAddRemoteVideoTrack(MediaStreamInterface* stream,
                                            VideoTrackInterface* video_track,
-                                           uint32 ssrc) {
-  stream_handler_container_->AddRemoteVideoTrack(stream, video_track, ssrc);
+                                           uint32 ssrc,
+                                           const std::string& mid) {
+  rtp_receivers_.push_back(rtc::scoped_refptr<RtpReceiverInterface>(
+      new rtc::RefCountedObject<VideoRtpReceiver>(video_track, ssrc, mid,
+                                                  session_.get())));
 }
 
 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)->Stop();
+    rtp_receivers_.erase(it);

[pthatcher1, 2015/09/17 04:25:46]

Long-term, I think we want to keep senders and receivers in here (perhaps as
Transceivers), because we'll want to use them track m-lines, and m-lines can't
go away

Just having a TODO might be sufficient for now.

[Taylor Brandstetter, 2015/09/23 00:10:45]

Can't an m-line go away if someone calls "stop" on the Transceiver? Or if it's
send-only and the local track is removed? Anyway, for now I'll add a TODO.

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

No, an m-line can never go away.  

+  }
 }
 
 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)->Stop();
+    rtp_receivers_.erase(it);
+  }
 }
+
 void PeerConnection::OnAddLocalAudioTrack(MediaStreamInterface* stream,
                                           AudioTrackInterface* audio_track,
-                                          uint32 ssrc) {
-  stream_handler_container_->AddLocalAudioTrack(stream, audio_track, ssrc);
+                                          uint32 ssrc,
+                                          const std::string& mid) {
+  rtp_senders_.push_back(rtc::scoped_refptr<RtpSenderInterface>(
+      new rtc::RefCountedObject<AudioRtpSender>(audio_track, ssrc, mid,
+                                                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);
+                                          uint32 ssrc,
+                                          const std::string& mid) {
+  rtp_senders_.push_back(rtc::scoped_refptr<RtpSenderInterface>(
+      new rtc::RefCountedObject<VideoRtpSender>(video_track, ssrc, mid,
+                                                session_.get())));
 }
 
 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)->Stop();
+    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)->Stop();
+    rtp_senders_.erase(it);
+  }
 }
 
 void PeerConnection::OnRemoveLocalStream(MediaStreamInterface* stream) {
-  stream_handler_container_->RemoveLocalStream(stream);
 }
 
 void PeerConnection::OnIceConnectionChange(
@@ -913,4 +961,19 @@ void PeerConnection::ChangeSignalingState(
   observer_->OnStateChange(PeerConnectionObserver::kSignalingState);
 }
 
+PeerConnectionInterface::RtpSenders::iterator
+PeerConnection::FindRtpSenderForTrack(MediaStreamTrackInterface* track) {
+  return std::find_if(
+      rtp_senders_.begin(), rtp_senders_.end(),
+      [track](const rtc::scoped_refptr<RtpSenderInterface>& sender)
+          -> bool { return sender->track() == track; });

[pthatcher1, 2015/09/17 04:25:46]

Is the "-> bool" necessary?  I thought it could infer that.

[Taylor Brandstetter, 2015/09/23 00:10:45]

Oh, I guess so. Removed.

+}
+PeerConnectionInterface::RtpReceivers::iterator
+PeerConnection::FindRtpReceiverForTrack(MediaStreamTrackInterface* track) {
+  return std::find_if(
+      rtp_receivers_.begin(), rtp_receivers_.end(),
+      [track](const rtc::scoped_refptr<RtpReceiverInterface>& receiver)
+          -> bool { return receiver->track() == track; });
+}
+
 }  // namespace webrtc