Separating internal and external methods of RtpSender/RtpReceiver.

webrtc/api/peerconnection.cc

 /*
  *  Copyright 2012 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 27 matching lines @@
 #include "webrtc/media/sctp/sctpdataengine.h"
 #include "webrtc/pc/channelmanager.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace {
 
 using webrtc::DataChannel;
 using webrtc::MediaConstraintsInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::PeerConnectionInterface;
+using webrtc::RtpSenderInternal;
 using webrtc::RtpSenderInterface;
+using webrtc::RtpSenderProxy;
+using webrtc::RtpSenderProxyEx;
 using webrtc::StreamCollection;
 
 static const char kDefaultStreamLabel[] = "default";
 static const char kDefaultAudioTrackLabel[] = "defaulta0";
 static const char kDefaultVideoTrackLabel[] = "defaultv0";
 
 // The min number of tokens must present in Turn host uri.
 // e.g. user@turn.example.org
 static const size_t kTurnHostTokensNum = 2;
 // Number of tokens must be preset when TURN uri has transport param.
@@ skipping 283 matching lines @@
 
 bool IsValidOfferToReceiveMedia(int value) {
   typedef PeerConnectionInterface::RTCOfferAnswerOptions Options;
   return (value >= Options::kUndefined) &&
          (value <= Options::kMaxOfferToReceiveMedia);
 }
 
 // Add the stream and RTP data channel info to |session_options|.
 void AddSendStreams(
     cricket::MediaSessionOptions* session_options,
-    const std::vector<rtc::scoped_refptr<RtpSenderInterface>>& senders,
+    const std::vector<rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>>>&
+        senders,
     const std::map<std::string, rtc::scoped_refptr<DataChannel>>&
         rtp_data_channels) {
   session_options->streams.clear();
   for (const auto& sender : senders) {
     session_options->AddSendStream(sender->media_type(), sender->id(),
-                                   sender->stream_id());
+                                   sender->get()->stream_id());

[pthatcher1, 2016/06/03 00:23:50]

would it make sense to call it internal() instead of get()?

[Taylor Brandstetter, 2016/06/03 22:48:39]

Done.

   }
 
   // Check for data channels.
   for (const auto& kv : rtp_data_channels) {
     const DataChannel* channel = kv.second;
     if (channel->state() == DataChannel::kConnecting ||
         channel->state() == DataChannel::kOpen) {
       // |streamid| and |sync_label| are both set to the DataChannel label
       // here so they can be signaled the same way as MediaStreams and Tracks.
       // For MediaStreams, the sync_label is the MediaStream label and the
@@ skipping 171 matching lines @@
       rtcp_cname_(GenerateRtcpCname()),
       local_streams_(StreamCollection::Create()),
       remote_streams_(StreamCollection::Create()) {}
 
 PeerConnection::~PeerConnection() {
   TRACE_EVENT0("webrtc", "PeerConnection::~PeerConnection");
   RTC_DCHECK(signaling_thread()->IsCurrent());
   // Need to detach RTP senders/receivers from WebRtcSession,
   // since it's about to be destroyed.
   for (const auto& sender : senders_) {
-    sender->Stop();
+    sender->get()->Stop();
   }
   for (const auto& receiver : receivers_) {
-    receiver->Stop();
+    receiver->get()->Stop();
   }
   // Destroy stats_ because it depends on session_.
   stats_.reset(nullptr);
   // Now destroy session_ before destroying other members,
   // because its destruction fires signals (such as VoiceChannelDestroyed)
   // which will trigger some final actions in PeerConnection...
   session_.reset(nullptr);
   // port_allocator_ lives on the network thread and should be destroyed there.
   network_thread()->Invoke<void>([this] { port_allocator_.reset(nullptr); });
 }
@@ skipping 131 matching lines @@
         << "Adding a track with two streams is not currently supported.";
     return nullptr;
   }
   // TODO(deadbeef): Support adding a track to two different senders.
   if (FindSenderForTrack(track) != senders_.end()) {
     LOG(LS_ERROR) << "Sender for track " << track->id() << " already exists.";
     return nullptr;
   }
 
   // TODO(deadbeef): Support adding a track to multiple streams.
-  rtc::scoped_refptr<RtpSenderInterface> new_sender;
+  rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>> new_sender;
   if (track->kind() == MediaStreamTrackInterface::kAudioKind) {
-    new_sender = RtpSenderProxy::Create(
+    new_sender = RtpSenderProxyEx<RtpSenderInternal>::Create(
         signaling_thread(),
         new AudioRtpSender(static_cast<AudioTrackInterface*>(track),
                            session_.get(), stats_.get()));
     if (!streams.empty()) {
-      new_sender->set_stream_id(streams[0]->label());
+      new_sender->get()->set_stream_id(streams[0]->label());
     }
     const TrackInfo* track_info = FindTrackInfo(
-        local_audio_tracks_, new_sender->stream_id(), track->id());
+        local_audio_tracks_, new_sender->get()->stream_id(), track->id());
     if (track_info) {
-      new_sender->SetSsrc(track_info->ssrc);
+      new_sender->get()->SetSsrc(track_info->ssrc);
     }
   } else if (track->kind() == MediaStreamTrackInterface::kVideoKind) {
-    new_sender = RtpSenderProxy::Create(
+    new_sender = RtpSenderProxyEx<RtpSenderInternal>::Create(
         signaling_thread(),
         new VideoRtpSender(static_cast<VideoTrackInterface*>(track),
                            session_.get()));
     if (!streams.empty()) {
-      new_sender->set_stream_id(streams[0]->label());
+      new_sender->get()->set_stream_id(streams[0]->label());
     }
     const TrackInfo* track_info = FindTrackInfo(
-        local_video_tracks_, new_sender->stream_id(), track->id());
+        local_video_tracks_, new_sender->get()->stream_id(), track->id());
     if (track_info) {
-      new_sender->SetSsrc(track_info->ssrc);
+      new_sender->get()->SetSsrc(track_info->ssrc);
     }
   } else {
     LOG(LS_ERROR) << "CreateSender called with invalid kind: " << track->kind();
     return rtc::scoped_refptr<RtpSenderInterface>();
   }
 
   senders_.push_back(new_sender);
   observer_->OnRenegotiationNeeded();
   return new_sender;
 }
 
 bool PeerConnection::RemoveTrack(RtpSenderInterface* sender) {
   TRACE_EVENT0("webrtc", "PeerConnection::RemoveTrack");
   if (IsClosed()) {
     return false;
   }
 
   auto it = std::find(senders_.begin(), senders_.end(), sender);
   if (it == senders_.end()) {
     LOG(LS_ERROR) << "Couldn't find sender " << sender->id() << " to remove.";
     return false;
   }
-  (*it)->Stop();
+  (*it)->get()->Stop();
   senders_.erase(it);
 
   observer_->OnRenegotiationNeeded();
   return true;
 }
 
 rtc::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
     AudioTrackInterface* track) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateDtmfSender");
   if (!track) {
@@ skipping 11 matching lines @@
     LOG(LS_ERROR) << "CreateDtmfSender failed on DtmfSender::Create.";
     return NULL;
   }
   return DtmfSenderProxy::Create(signaling_thread(), sender.get());
 }
 
 rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
     const std::string& kind,
     const std::string& stream_id) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateSender");
-  rtc::scoped_refptr<RtpSenderInterface> new_sender;
+  rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>> new_sender;
   if (kind == MediaStreamTrackInterface::kAudioKind) {
-    new_sender = RtpSenderProxy::Create(
+    new_sender = RtpSenderProxyEx<RtpSenderInternal>::Create(
         signaling_thread(), new AudioRtpSender(session_.get(), stats_.get()));
   } else if (kind == MediaStreamTrackInterface::kVideoKind) {
-    new_sender = RtpSenderProxy::Create(signaling_thread(),
-                                        new VideoRtpSender(session_.get()));
+    new_sender = RtpSenderProxyEx<RtpSenderInternal>::Create(
+        signaling_thread(), new VideoRtpSender(session_.get()));
   } else {
     LOG(LS_ERROR) << "CreateSender called with invalid kind: " << kind;
     return new_sender;
   }
   if (!stream_id.empty()) {
-    new_sender->set_stream_id(stream_id);
+    new_sender->get()->set_stream_id(stream_id);
   }
   senders_.push_back(new_sender);
   return new_sender;
 }
 
 std::vector<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::GetSenders()
     const {
-  return senders_;
+  std::vector<rtc::scoped_refptr<RtpSenderInterface>> ret;
+  for (const auto& sender : senders_) {
+    ret.push_back(sender.get());
+  }
+  return ret;
 }
 
 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>
 PeerConnection::GetReceivers() const {
-  return receivers_;
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> ret;
+  for (const auto& receiver : receivers_) {
+    ret.push_back(receiver.get());
+  }
+  return ret;
 }
 
 bool PeerConnection::GetStats(StatsObserver* observer,
                               MediaStreamTrackInterface* track,
                               StatsOutputLevel level) {
   TRACE_EVENT0("webrtc", "PeerConnection::GetStats");
   RTC_DCHECK(signaling_thread()->IsCurrent());
   if (!VERIFY(observer != NULL)) {
     LOG(LS_ERROR) << "GetStats - observer is NULL.";
     return false;
@@ skipping 475 matching lines @@
     }
     default:
       RTC_DCHECK(false && "Not implemented");
       break;
   }
 }
 
 void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream,
                                          const std::string& track_id,
                                          uint32_t ssrc) {
-  receivers_.push_back(RtpReceiverProxy::Create(
+  receivers_.push_back(RtpReceiverProxyEx<RtpReceiverInternal>::Create(
       signaling_thread(),
       new AudioRtpReceiver(stream, track_id, ssrc, session_.get())));
 }
 
 void PeerConnection::CreateVideoReceiver(MediaStreamInterface* stream,
                                          const std::string& track_id,
                                          uint32_t ssrc) {
-  receivers_.push_back(RtpReceiverProxy::Create(
+  receivers_.push_back(RtpReceiverProxyEx<RtpReceiverInternal>::Create(
       signaling_thread(),
       new VideoRtpReceiver(stream, track_id, factory_->worker_thread(), ssrc,
                            session_.get())));
 }
 
 // TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
 // description.
 void PeerConnection::DestroyReceiver(const std::string& track_id) {
   auto it = FindReceiverForTrack(track_id);
   if (it == receivers_.end()) {
     LOG(LS_WARNING) << "RtpReceiver for track with id " << track_id
                     << " doesn't exist.";
   } else {
-    (*it)->Stop();
+    (*it)->get()->Stop();
     receivers_.erase(it);
   }
 }
 
 void PeerConnection::StopReceivers(cricket::MediaType media_type) {
   TrackInfos* current_tracks = GetRemoteTracks(media_type);
   for (const auto& track_info : *current_tracks) {
     auto it = FindReceiverForTrack(track_info.track_id);
     if (it == receivers_.end()) {
       LOG(LS_WARNING) << "RtpReceiver for track with id " << track_info.track_id
                       << " doesn't exist.";
     } else {
-      (*it)->Stop();
+      (*it)->get()->Stop();
     }
   }
 }
 
 void PeerConnection::OnIceConnectionChange(
     PeerConnectionInterface::IceConnectionState new_state) {
   RTC_DCHECK(signaling_thread()->IsCurrent());
   // After transitioning to "closed", ignore any additional states from
   // WebRtcSession (such as "disconnected").
   if (IsClosed()) {
@@ skipping 42 matching lines @@
   }
   observer_->OnSignalingChange(signaling_state_);
 }
 
 void PeerConnection::OnAudioTrackAdded(AudioTrackInterface* track,
                                        MediaStreamInterface* stream) {
   auto sender = FindSenderForTrack(track);
   if (sender != senders_.end()) {
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
-    (*sender)->set_stream_id(stream->label());
+    (*sender)->get()->set_stream_id(stream->label());
     return;
   }
 
   // Normal case; we've never seen this track before.
-  rtc::scoped_refptr<RtpSenderInterface> new_sender = RtpSenderProxy::Create(
-      signaling_thread(),
-      new AudioRtpSender(track, stream->label(), session_.get(), stats_.get()));
+  rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>> new_sender =
+      RtpSenderProxyEx<RtpSenderInternal>::Create(
+          signaling_thread(), new AudioRtpSender(track, stream->label(),
+                                                 session_.get(), stats_.get()));
   senders_.push_back(new_sender);
   // If the sender has already been configured in SDP, we call SetSsrc,
   // which will connect the sender to the underlying transport. This can
   // occur if a local session description that contains the ID of the sender
   // is set before AddStream is called. It can also occur if the local
   // session description is not changed and RemoveStream is called, and
   // later AddStream is called again with the same stream.
   const TrackInfo* track_info =
       FindTrackInfo(local_audio_tracks_, stream->label(), track->id());
   if (track_info) {
-    new_sender->SetSsrc(track_info->ssrc);
+    new_sender->get()->SetSsrc(track_info->ssrc);
   }
 }
 
 // TODO(deadbeef): Don't destroy RtpSenders here; they should be kept around
 // indefinitely, when we have unified plan SDP.
 void PeerConnection::OnAudioTrackRemoved(AudioTrackInterface* track,
                                          MediaStreamInterface* stream) {
   auto sender = FindSenderForTrack(track);
   if (sender == senders_.end()) {
     LOG(LS_WARNING) << "RtpSender for track with id " << track->id()
                     << " doesn't exist.";
     return;
   }
-  (*sender)->Stop();
+  (*sender)->get()->Stop();
   senders_.erase(sender);
 }
 
 void PeerConnection::OnVideoTrackAdded(VideoTrackInterface* track,
                                        MediaStreamInterface* stream) {
   auto sender = FindSenderForTrack(track);
   if (sender != senders_.end()) {
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
-    (*sender)->set_stream_id(stream->label());
+    (*sender)->get()->set_stream_id(stream->label());
     return;
   }
 
   // Normal case; we've never seen this track before.
-  rtc::scoped_refptr<RtpSenderInterface> new_sender = RtpSenderProxy::Create(
-      signaling_thread(),
-      new VideoRtpSender(track, stream->label(), session_.get()));
+  rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>> new_sender =
+      RtpSenderProxyEx<RtpSenderInternal>::Create(
+          signaling_thread(),
+          new VideoRtpSender(track, stream->label(), session_.get()));
   senders_.push_back(new_sender);
   const TrackInfo* track_info =
       FindTrackInfo(local_video_tracks_, stream->label(), track->id());
   if (track_info) {
-    new_sender->SetSsrc(track_info->ssrc);
+    new_sender->get()->SetSsrc(track_info->ssrc);
   }
 }
 
 void PeerConnection::OnVideoTrackRemoved(VideoTrackInterface* track,
                                          MediaStreamInterface* stream) {
   auto sender = FindSenderForTrack(track);
   if (sender == senders_.end()) {
     LOG(LS_WARNING) << "RtpSender for track with id " << track->id()
                     << " doesn't exist.";
     return;
   }
-  (*sender)->Stop();
+  (*sender)->get()->Stop();
   senders_.erase(sender);
 }
 
 void PeerConnection::PostSetSessionDescriptionFailure(
     SetSessionDescriptionObserver* observer,
     const std::string& error) {
   SetSessionDescriptionMsg* msg = new SetSessionDescriptionMsg(observer);
   msg->error = error;
   signaling_thread()->Post(this, MSG_SET_SESSIONDESCRIPTION_FAILED, msg);
 }
@@ skipping 281 matching lines @@
       current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc));
       OnLocalTrackSeen(stream_label, track_id, params.first_ssrc(), media_type);
     }
   }
 }
 
 void PeerConnection::OnLocalTrackSeen(const std::string& stream_label,
                                       const std::string& track_id,
                                       uint32_t ssrc,
                                       cricket::MediaType media_type) {
-  RtpSenderInterface* sender = FindSenderById(track_id);
+  RtpSenderInternal* sender = FindSenderById(track_id);
   if (!sender) {
     LOG(LS_WARNING) << "An unknown RtpSender with id " << track_id
                     << " has been configured in the local description.";
     return;
   }
 
   if (sender->media_type() != media_type) {
     LOG(LS_WARNING) << "An RtpSender has been configured in the local"
                     << " description with an unexpected media type.";
     return;
   }
 
   sender->set_stream_id(stream_label);
   sender->SetSsrc(ssrc);
 }
 
 void PeerConnection::OnLocalTrackRemoved(const std::string& stream_label,
                                          const std::string& track_id,
                                          uint32_t ssrc,
                                          cricket::MediaType media_type) {
-  RtpSenderInterface* sender = FindSenderById(track_id);
+  RtpSenderInternal* sender = FindSenderById(track_id);
   if (!sender) {
     // This is the normal case. I.e., RemoveStream has been called and the
     // SessionDescriptions has been renegotiated.
     return;
   }
 
   // A sender has been removed from the SessionDescription but it's still
   // associated with the PeerConnection. This only occurs if the SDP doesn't
   // match with the calls to CreateSender, AddStream and RemoveStream.
   if (sender->media_type() != media_type) {
@@ skipping 83 matching lines @@
 void PeerConnection::CreateRemoteRtpDataChannel(const std::string& label,
                                                 uint32_t remote_ssrc) {
   rtc::scoped_refptr<DataChannel> channel(
       InternalCreateDataChannel(label, nullptr));
   if (!channel.get()) {
     LOG(LS_WARNING) << "Remote peer requested a DataChannel but"
                     << "CreateDataChannel failed.";
     return;
   }
   channel->SetReceiveSsrc(remote_ssrc);
-  auto proxy_channel = DataChannelProxy::Create(signaling_thread(), channel);
+  rtc::scoped_refptr<DataChannelInterface> proxy_channel =
+      DataChannelProxy::Create(signaling_thread(), channel);
   // Call both the raw pointer and scoped_refptr versions of the method
   // for compatibility.
   observer_->OnDataChannel(proxy_channel.get());
   observer_->OnDataChannel(std::move(proxy_channel));
 }
 
 rtc::scoped_refptr<DataChannel> PeerConnection::InternalCreateDataChannel(
     const std::string& label,
     const InternalDataChannelInit* config) {
   if (IsClosed()) {
@@ skipping 113 matching lines @@
 void PeerConnection::OnDataChannelOpenMessage(
     const std::string& label,
     const InternalDataChannelInit& config) {
   rtc::scoped_refptr<DataChannel> channel(
       InternalCreateDataChannel(label, &config));
   if (!channel.get()) {
     LOG(LS_ERROR) << "Failed to create DataChannel from the OPEN message.";
     return;
   }
 
-  auto proxy_channel = DataChannelProxy::Create(signaling_thread(), channel);
+  rtc::scoped_refptr<DataChannelInterface> proxy_channel =
+      DataChannelProxy::Create(signaling_thread(), channel);
   // Call both the raw pointer and scoped_refptr versions of the method
   // for compatibility.
   observer_->OnDataChannel(proxy_channel.get());
   observer_->OnDataChannel(std::move(proxy_channel));
 }
 
-RtpSenderInterface* PeerConnection::FindSenderById(const std::string& id) {
-  auto it =
-      std::find_if(senders_.begin(), senders_.end(),
-                   [id](const rtc::scoped_refptr<RtpSenderInterface>& sender) {
-                     return sender->id() == id;
-                   });
-  return it != senders_.end() ? it->get() : nullptr;
+RtpSenderInternal* PeerConnection::FindSenderById(const std::string& id) {
+  auto it = std::find_if(
+      senders_.begin(), senders_.end(),
+      [id](const rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>>&
+               sender) { return sender->id() == id; });
+  return it != senders_.end() ? it->get()->get() : nullptr;
 }
 
-std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator
+std::vector<rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>>>::iterator
 PeerConnection::FindSenderForTrack(MediaStreamTrackInterface* track) {
   return std::find_if(
       senders_.begin(), senders_.end(),
-      [track](const rtc::scoped_refptr<RtpSenderInterface>& sender) {
-        return sender->track() == track;
-      });
+      [track](const rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>>&
+                  sender) { return sender->track() == track; });
 }
 
-std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator
+std::vector<
+    rtc::scoped_refptr<RtpReceiverProxyEx<RtpReceiverInternal>>>::iterator
 PeerConnection::FindReceiverForTrack(const std::string& track_id) {
   return std::find_if(
       receivers_.begin(), receivers_.end(),
-      [track_id](const rtc::scoped_refptr<RtpReceiverInterface>& receiver) {
-        return receiver->id() == track_id;
-      });
+      [track_id](
+          const rtc::scoped_refptr<RtpReceiverProxyEx<RtpReceiverInternal>>&
+              receiver) { return receiver->id() == track_id; });
 }
 
 PeerConnection::TrackInfos* PeerConnection::GetRemoteTracks(
     cricket::MediaType media_type) {
   RTC_DCHECK(media_type == cricket::MEDIA_TYPE_AUDIO ||
              media_type == cricket::MEDIA_TYPE_VIDEO);
   return (media_type == cricket::MEDIA_TYPE_AUDIO) ? &remote_audio_tracks_
                                                    : &remote_video_tracks_;
 }
 
@@ skipping 83 matching lines @@
   port_allocator_->set_candidate_filter(
       ConvertIceTransportTypeToCandidateFilter(configuration.type));
   // Call this last since it may create pooled allocator sessions using the
   // candidate filter set above.
   port_allocator_->SetConfiguration(stun_servers, turn_servers,
                                     configuration.ice_candidate_pool_size);
   return true;
 }
 
 }  // namespace webrtc