Separating internal and external methods of RtpSender/RtpReceiver.

webrtc/api/peerconnection.h

Index: webrtc/api/peerconnection.h
diff --git a/webrtc/api/peerconnection.h b/webrtc/api/peerconnection.h
index a683e8d6858524a83986946372787b1221542b7a..f4af7e119c39ffbacbdfe940bd1db158164c2841 100644
--- a/webrtc/api/peerconnection.h
+++ b/webrtc/api/peerconnection.h
@@ -18,8 +18,8 @@
 
 #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"
@@ -334,11 +334,12 @@ class PeerConnection : public PeerConnectionInterface,
   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);
@@ -400,8 +401,9 @@ class PeerConnection : public PeerConnectionInterface,
 
   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_;