Separating internal and external methods of RtpSender/RtpReceiver.

webrtc/api/proxy.h

Index: webrtc/api/proxy.h
diff --git a/webrtc/api/proxy.h b/webrtc/api/proxy.h
index 2df85c4bf46f4adb2f03196f2487287ab9a31d56..87588cf10b3656679b5c1be73be284313288c725 100644
--- a/webrtc/api/proxy.h
+++ b/webrtc/api/proxy.h
@@ -306,43 +306,56 @@ class MethodCall5 : public rtc::Message,
   T5 a5_;
 };
 
-#define BEGIN_SIGNALING_PROXY_MAP(c)                                     \
-  class c##Proxy : public c##Interface {                                  \
+#define BEGIN_SIGNALING_PROXY_MAP(c)                                      \
+  template <class INNER_CLASS>                             \
+  class c##ProxyEx;                                  \

[Taylor Brandstetter, 2016/06/01 20:04:26]

I know that "ProxyEx" is a terrible name; what do you suggest? "ProxyTo<Thing>"?
"ProxyWithInner<Thing>"?

+  typedef c##ProxyEx<c##Interface> c##Proxy; \
+  template <class INNER_CLASS>                             \
+  class c##ProxyEx : public c##Interface {                                  \
    protected:                                                             \
     typedef c##Interface C;                                               \
-    c##Proxy(rtc::Thread* signaling_thread, C* c)                         \
+    c##ProxyEx(rtc::Thread* signaling_thread, INNER_CLASS* c)               \
       : signaling_thread_(signaling_thread), c_(c) {}                     \
-    ~c##Proxy() {                                                         \
-      MethodCall0<c##Proxy, void> call(                                   \
-          this, &c##Proxy::Release_s);                                    \
+    ~c##ProxyEx() {                                                         \
+      MethodCall0<c##ProxyEx, void> call(                                   \
+          this, &c##ProxyEx::Release_s);                                    \
       call.Marshal(signaling_thread_);                                    \
     }                                                                     \
                                                                           \
    public:                                                                \
-    static rtc::scoped_refptr<C> Create(rtc::Thread* signaling_thread, C* c) { \
-      return new rtc::RefCountedObject<c##Proxy>(                         \
+    static rtc::scoped_refptr<c##ProxyEx> Create(rtc::Thread* signaling_thread, INNER_CLASS* c) { \
+      return new rtc::RefCountedObject<c##ProxyEx>(                         \
           signaling_thread, c);                                           \
-    }
+    }                                                                     \
+    const INNER_CLASS* get() const { return c_.get(); }                   \
+    INNER_CLASS* get() { return c_.get(); }                               \
 
 #define BEGIN_PROXY_MAP(c)                                              \
-  class c##Proxy : public c##Interface {                                \
+  template <class INNER_CLASS>                             \
+  class c##ProxyEx;                                  \
+  typedef c##ProxyEx<c##Interface> c##Proxy; \
+  template <class INNER_CLASS>                             \
+  class c##ProxyEx : public c##Interface {                                  \
    protected:                                                           \
     typedef c##Interface C;                                             \
-    c##Proxy(rtc::Thread* signaling_thread, rtc::Thread* worker_thread, C* c) \
+    c##ProxyEx(rtc::Thread* signaling_thread, rtc::Thread* worker_thread, \
+             INNER_CLASS* c)                                            \
       : signaling_thread_(signaling_thread),                            \
         worker_thread_(worker_thread),                                  \
         c_(c) {}                                                        \
-    ~c##Proxy() {                                                       \
-      MethodCall0<c##Proxy, void> call(this, &c##Proxy::Release_s);     \
+    ~c##ProxyEx() {                                                       \
+      MethodCall0<c##ProxyEx, void> call(this, &c##ProxyEx::Release_s);     \
       call.Marshal(signaling_thread_);                                  \
     }                                                                   \
                                                                         \
    public:                                                              \
-    static rtc::scoped_refptr<C> Create(                                \
-        rtc::Thread* signaling_thread, rtc::Thread* worker_thread, C* c) { \
-      return new rtc::RefCountedObject<c##Proxy>(                       \
+    static rtc::scoped_refptr<c##ProxyEx> Create(                                \
+        rtc::Thread* signaling_thread, rtc::Thread* worker_thread, INNER_CLASS* c) { \
+      return new rtc::RefCountedObject<c##ProxyEx>(                       \
           signaling_thread, worker_thread, c);                          \
-    }
+    }                                                                   \
+    const INNER_CLASS* get() const { return c_.get(); }                 \
+    INNER_CLASS* get() { return c_.get(); }                             \
 
 #define PROXY_METHOD0(r, method)                  \
   r method() override {                           \
@@ -413,7 +426,7 @@ class MethodCall5 : public rtc::Message,
       c_ = NULL;\
     }\
     mutable rtc::Thread* signaling_thread_;\
-    rtc::scoped_refptr<C> c_;\
+    rtc::scoped_refptr<INNER_CLASS> c_;\
   };
 
 #define END_PROXY()                                  \
@@ -423,7 +436,7 @@ class MethodCall5 : public rtc::Message,
     }                                                \
     mutable rtc::Thread* signaling_thread_;          \
     mutable rtc::Thread* worker_thread_;             \
-    rtc::scoped_refptr<C> c_;                        \
+    rtc::scoped_refptr<INNER_CLASS> c_;              \
   };                                                 \
 
 }  // namespace webrtc