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 28 matching lines @@
 #include "webrtc/p2p/client/basicportallocator.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::RtpSender;
 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 280 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<RtpSender>>>& 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());
   }
 
   // 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 143 matching lines @@
       ice_gathering_state_(kIceGatheringNew),
       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();
   }
 }
 
 bool PeerConnection::Initialize(
     const PeerConnectionInterface::RTCConfiguration& configuration,
     std::unique_ptr<cricket::PortAllocator> allocator,
     std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
@@ skipping 148 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<RtpSender>> new_sender;
   if (track->kind() == MediaStreamTrackInterface::kAudioKind) {
-    new_sender = RtpSenderProxy::Create(
+    new_sender = RtpSenderProxyEx<RtpSender>::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<RtpSender>::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<RtpSender>> new_sender;
   if (kind == MediaStreamTrackInterface::kAudioKind) {
-    new_sender = RtpSenderProxy::Create(
+    new_sender = RtpSenderProxyEx<RtpSender>::Create(
         signaling_thread(), new AudioRtpSender(session_.get(), stats_.get()));
   } else if (kind == MediaStreamTrackInterface::kVideoKind) {
-    new_sender = RtpSenderProxy::Create(signaling_thread(),
+    new_sender = RtpSenderProxyEx<RtpSender>::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_;
 }
 
 bool PeerConnection::GetStats(StatsObserver* observer,
                               MediaStreamTrackInterface* track,
                               StatsOutputLevel level) {
@@ skipping 573 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(
+  rtc::scoped_refptr<RtpSenderProxyEx<RtpSender>> new_sender = RtpSenderProxyEx<RtpSender>::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(
+  rtc::scoped_refptr<RtpSenderProxyEx<RtpSender>> new_sender = RtpSenderProxyEx<RtpSender>::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 272 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);
+  RtpSender* 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);
+  RtpSender* 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 218 matching lines @@
       InternalCreateDataChannel(label, &config));
   if (!channel.get()) {
     LOG(LS_ERROR) << "Failed to create DataChannel from the OPEN message.";
     return;
   }
 
   observer_->OnDataChannel(
       DataChannelProxy::Create(signaling_thread(), channel));
 }
 
-RtpSenderInterface* PeerConnection::FindSenderById(const std::string& id) {
+RtpSender* PeerConnection::FindSenderById(const std::string& id) {
   auto it =
       std::find_if(senders_.begin(), senders_.end(),
-                   [id](const rtc::scoped_refptr<RtpSenderInterface>& sender) {
+                   [id](const rtc::scoped_refptr<RtpSenderProxyEx<RtpSender>>& sender) {
                      return sender->id() == id;
                    });
-  return it != senders_.end() ? it->get() : nullptr;
+  return it != senders_.end() ? it->get()->get() : nullptr;
 }
 
-std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator
+std::vector<rtc::scoped_refptr<RtpSenderProxyEx<RtpSender>>>::iterator
 PeerConnection::FindSenderForTrack(MediaStreamTrackInterface* track) {
   return std::find_if(
       senders_.begin(), senders_.end(),
       [track](const rtc::scoped_refptr<RtpSenderInterface>& sender) {
         return sender->track() == track;
       });
 }
 
 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator
 PeerConnection::FindReceiverForTrack(const std::string& track_id) {
@@ skipping 36 matching lines @@
 DataChannel* PeerConnection::FindDataChannelBySid(int sid) const {
   for (const auto& channel : sctp_data_channels_) {
     if (channel->id() == sid) {
       return channel;
     }
   }
   return nullptr;
 }
 
 }  // namespace webrtc