Separating internal and external methods of RtpSender/RtpReceiver.

webrtc/api/proxy.h

 /*
  *  Copyright 2013 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 289 matching lines @@
   Method m_;
   ReturnType<R> r_;
   T1 a1_;
   T2 a2_;
   T3 a3_;
   T4 a4_;
   T5 a5_;
 };
 
 #define BEGIN_SIGNALING_PROXY_MAP(c)                                     \
-  class c##Proxy : public c##Interface {                                  \
-   protected:                                                             \
-    typedef c##Interface C;                                               \
-    c##Proxy(rtc::Thread* signaling_thread, C* c)                         \
-      : signaling_thread_(signaling_thread), c_(c) {}                     \
-    ~c##Proxy() {                                                         \
-      MethodCall0<c##Proxy, void> call(                                   \
-          this, &c##Proxy::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>(                         \
-          signaling_thread, c);                                           \
-    }
+  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##ProxyEx(rtc::Thread* signaling_thread, INNER_CLASS* c)            \
+        : signaling_thread_(signaling_thread), c_(c) {}                  \
+    ~c##ProxyEx() {                                                      \
+      MethodCall0<c##ProxyEx, void> call(this, &c##ProxyEx::Release_s);  \
+      call.Marshal(signaling_thread_);                                   \
+    }                                                                    \
+                                                                         \
+   public:                                                               \
+    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>                                          \

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

Would it make sense to call this INTERNAL_CLASS?

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

Sure.

+  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) \
-      : signaling_thread_(signaling_thread),                            \
-        worker_thread_(worker_thread),                                  \
-        c_(c) {}                                                        \
-    ~c##Proxy() {                                                       \
-      MethodCall0<c##Proxy, void> call(this, &c##Proxy::Release_s);     \
+    c##ProxyEx(rtc::Thread* signaling_thread,                           \

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

Would it make senes for this to be InternalProxy?

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

See my other comment. That name implies to me that the inner object always has
"Internal" in its name.

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

I think it just implies that you can get to the "internal" thing via internal().
 I don't think it means anything about the name of the thing.  

For example, I'd be happy if we had RtpSenderBase instead of RtpSenderInternal.

+               rtc::Thread* worker_thread,                              \
+               INNER_CLASS* c)                                          \
+        : signaling_thread_(signaling_thread),                          \
+          worker_thread_(worker_thread),                                \
+          c_(c) {}                                                      \
+    ~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>(                       \
-          signaling_thread, worker_thread, c);                          \
-    }
+    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 {                           \
     MethodCall0<C, r> call(c_.get(), &C::method); \
     return call.Marshal(signaling_thread_);       \
   }
 
 #define PROXY_CONSTMETHOD0(r, method)                  \
   r method() const override {                          \
     ConstMethodCall0<C, r> call(c_.get(), &C::method); \
@@ skipping 44 matching lines @@
     MethodCall1<C, r, t1> call(c_.get(), &C::method, a1); \
     return call.Marshal(worker_thread_);                  \
   }
 
 #define PROXY_WORKER_METHOD2(r, method, t1, t2)                   \
   r method(t1 a1, t2 a2) override {                               \
     MethodCall2<C, r, t1, t2> call(c_.get(), &C::method, a1, a2); \
     return call.Marshal(worker_thread_);                          \
   }
 
-#define END_SIGNALING_PROXY() \
-   private:\
-    void Release_s() {\
-      c_ = NULL;\
-    }\
-    mutable rtc::Thread* signaling_thread_;\
-    rtc::scoped_refptr<C> c_;\
-  };
+#define END_SIGNALING_PROXY()             \
+ private:                                 \
+  void Release_s() { c_ = NULL; }         \
+  mutable rtc::Thread* signaling_thread_; \
+  rtc::scoped_refptr<INNER_CLASS> c_;     \
+  }                                       \
+  ;
 
-#define END_PROXY()                                  \
-   private:                                          \
-    void Release_s() {                               \
-      c_ = NULL;                                     \
-    }                                                \
-    mutable rtc::Thread* signaling_thread_;          \
-    mutable rtc::Thread* worker_thread_;             \
-    rtc::scoped_refptr<C> c_;                        \
-  };                                                 \
+#define END_PROXY()                       \
+ private:                                 \
+  void Release_s() { c_ = NULL; }         \
+  mutable rtc::Thread* signaling_thread_; \
+  mutable rtc::Thread* worker_thread_;    \
+  rtc::scoped_refptr<INNER_CLASS> c_;     \
+  }                                       \
+  ;

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

Should we undo the reformatting here?

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

This is just what "git cl format" did (yep, it's smart enough to format macros,
surprised me too). I can undo it if you like though.

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

It looked better before, so please undo it.

 
 }  // namespace webrtc
 
 #endif  //  WEBRTC_API_PROXY_H_