Separating internal and external methods of RtpSender/RtpReceiver.

webrtc/api/peerconnection.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_API_PEERCONNECTION_H_
 #define WEBRTC_API_PEERCONNECTION_H_
 
 #include <string>
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "webrtc/api/peerconnectionfactory.h"
 #include "webrtc/api/peerconnectioninterface.h"
-#include "webrtc/api/rtpreceiverinterface.h"
-#include "webrtc/api/rtpsenderinterface.h"
+#include "webrtc/api/rtpreceiver.h"
+#include "webrtc/api/rtpsender.h"
 #include "webrtc/api/statscollector.h"
 #include "webrtc/api/streamcollection.h"
 #include "webrtc/api/webrtcsession.h"
 
 namespace webrtc {
 
 class MediaStreamObserver;
 class VideoRtpReceiver;
 
 // Populates |session_options| from |rtc_options|, and returns true if options
@@ skipping 294 matching lines @@
   // Notifications from WebRtcSession relating to BaseChannels.
   void OnVoiceChannelDestroyed();
   void OnVideoChannelDestroyed();
   void OnDataChannelCreated();
   void OnDataChannelDestroyed();
   // Called when the cricket::DataChannel receives a message indicating that a
   // webrtc::DataChannel should be opened.
   void OnDataChannelOpenMessage(const std::string& label,
                                 const InternalDataChannelInit& config);
 
-  RtpSenderInterface* FindSenderById(const std::string& id);
+  RtpSenderInternal* FindSenderById(const std::string& id);

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

Can you call this RtpSenderInternalInterface?

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

I'll probably move code to it in a future CL, in which case it won't just be an
interface.

[pthatcher1, 2016/06/03 23:05:49]

The purpose of that would be to share code between AudioRtpSender and
VideoRtpSender, right?  So why not RtpSenderBase or BaseRtpSender?

 
-  std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator
+  std::vector<rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>>>::iterator

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

How about RtpSenderInternalProxy?

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

So RtpSenderInternalProxy<RtpSenderInternal>? That works for this, but it's not
very generalized. What if there's "FooInterface" and "FooBar"/"FooBaz" that
implement it. Would we have "FooInternalProxy<FooBar>"? I still prefer my
earlier suggestions (FooProxyTo<FooBar>, FooProxyWithInternal<FooBar>...). What
do you think?

[pthatcher1, 2016/06/03 23:05:49]

I think FooInternalProxy is a good shortening of FooProxyWithInternal and just
as general.  So in the general case it would be FooInternalProxy<FooBar>.  In
this specific case, FooInternalProxy<RtpSenderBase>

   FindSenderForTrack(MediaStreamTrackInterface* track);
-  std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator
+  std::vector<
+      rtc::scoped_refptr<RtpReceiverProxyEx<RtpReceiverInternal>>>::iterator

[pthatcher1, 2016/06/01 22:18:57]

I think I need to chat with you next to a whiteboard to understand what you're
trying to accomplish here. 

[Taylor Brandstetter, 2016/06/01 23:13:02]

It's an iterator to a refptr to a RtpReceiverInterface proxy that exposes an
internal RtpReceiverInternal. Clear as mud, right? :)

   FindReceiverForTrack(const std::string& track_id);
 
   TrackInfos* GetRemoteTracks(cricket::MediaType media_type);
   TrackInfos* GetLocalTracks(cricket::MediaType media_type);
   const TrackInfo* FindTrackInfo(const TrackInfos& infos,
                                  const std::string& stream_label,
                                  const std::string track_id) const;
 
   // Returns the specified SCTP DataChannel in sctp_data_channels_,
   // or nullptr if not found.
@@ skipping 41 matching lines @@
   TrackInfos local_video_tracks_;
 
   SctpSidAllocator sid_allocator_;
   // label -> DataChannel
   std::map<std::string, rtc::scoped_refptr<DataChannel>> rtp_data_channels_;
   std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels_;
   std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels_to_free_;
 
   bool remote_peer_supports_msid_ = false;
 
-  std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders_;
-  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers_;
+  std::vector<rtc::scoped_refptr<RtpSenderProxyEx<RtpSenderInternal>>> senders_;
+  std::vector<rtc::scoped_refptr<RtpReceiverProxyEx<RtpReceiverInternal>>>
+      receivers_;
 
   std::unique_ptr<WebRtcSession> session_;
   std::unique_ptr<StatsCollector> stats_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_PEERCONNECTION_H_