Adding "adapter" ORTC objects on top of ChannelManager/BaseChannel/etc.

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 335 matching lines @@
   ReturnType<R> r_;
   T1 a1_;
   T2 a2_;
   T3 a3_;
   T4 a4_;
   T5 a5_;
 };
 
 
 // Helper macros to reduce code duplication.
-#define PROXY_MAP_BOILERPLATE(c)                                \
-  template <class INTERNAL_CLASS>                               \
-  class c##ProxyWithInternal;                                   \
-  typedef c##ProxyWithInternal<c##Interface> c##Proxy;          \
-  template <class INTERNAL_CLASS>                               \
-  class c##ProxyWithInternal : public c##Interface {            \
-   protected:                                                   \
-    typedef c##Interface C;                                     \
-                                                                \
-   public:                                                      \
-    const INTERNAL_CLASS* internal() const { return c_.get(); } \
-    INTERNAL_CLASS* internal() { return c_.get(); }
+#define PROXY_MAP_BOILERPLATE(c)                          \
+  template <class INTERNAL_CLASS>                         \
+  class c##ProxyWithInternal;                             \
+  typedef c##ProxyWithInternal<c##Interface> c##Proxy;    \
+  template <class INTERNAL_CLASS>                         \
+  class c##ProxyWithInternal : public c##Interface {      \
+   protected:                                             \
+    typedef c##Interface C;                               \
+                                                          \
+   public:                                                \
+    const INTERNAL_CLASS* internal() const { return c_; } \
+    INTERNAL_CLASS* internal() { return c_; }
 
 #define END_PROXY_MAP() \
   };
 
 #define SIGNALING_PROXY_MAP_BOILERPLATE(c)                               \
  protected:                                                              \
   c##ProxyWithInternal(rtc::Thread* signaling_thread, INTERNAL_CLASS* c) \
       : signaling_thread_(signaling_thread), c_(c) {}                    \
                                                                          \
  private:                                                                \
@@ skipping 18 matching lines @@
   ~c##ProxyWithInternal() {                            \
     MethodCall0<c##ProxyWithInternal, void> call(      \
         this, &c##ProxyWithInternal::DestroyInternal); \
     call.Marshal(RTC_FROM_HERE, destructor_thread());  \
   }                                                    \
                                                        \
  private:                                              \
   void DestroyInternal() { c_ = nullptr; }             \
   rtc::scoped_refptr<INTERNAL_CLASS> c_;
 
+// Note: This doesn't use a unique_ptr, because it intends to handle a corner
+// case where an object's deletion triggers a callback that calls back into
+// this proxy object. If relying on a unique_ptr to delete the object, its
+// inner pointer would be set to null before this reentrant callback would have
+// a chance to run, resulting in a segfault.
 #define OWNED_PROXY_MAP_BOILERPLATE(c)                 \
  public:                                               \
   ~c##ProxyWithInternal() {                            \
     MethodCall0<c##ProxyWithInternal, void> call(      \
         this, &c##ProxyWithInternal::DestroyInternal); \
     call.Marshal(RTC_FROM_HERE, destructor_thread());  \
   }                                                    \
                                                        \
  private:                                              \
-  void DestroyInternal() { c_.reset(nullptr); }        \
-  std::unique_ptr<INTERNAL_CLASS> c_;
+  void DestroyInternal() { delete c_; }                \
+  INTERNAL_CLASS* c_;
 
 #define BEGIN_SIGNALING_PROXY_MAP(c)                                         \
   PROXY_MAP_BOILERPLATE(c)                                                   \
   SIGNALING_PROXY_MAP_BOILERPLATE(c)                                         \
   REFCOUNTED_PROXY_MAP_BOILERPLATE(c)                                        \
  public:                                                                     \
   static rtc::scoped_refptr<c##ProxyWithInternal> Create(                    \
       rtc::Thread* signaling_thread, INTERNAL_CLASS* c) {                    \
     return new rtc::RefCountedObject<c##ProxyWithInternal>(signaling_thread, \
                                                            c);               \
   }
 
 #define BEGIN_PROXY_MAP(c)                                                    \
   PROXY_MAP_BOILERPLATE(c)                                                    \
   WORKER_PROXY_MAP_BOILERPLATE(c)                                             \
   REFCOUNTED_PROXY_MAP_BOILERPLATE(c)                                         \
  public:                                                                      \
   static rtc::scoped_refptr<c##ProxyWithInternal> Create(                     \
       rtc::Thread* signaling_thread, rtc::Thread* worker_thread,              \
       INTERNAL_CLASS* c) {                                                    \
     return new rtc::RefCountedObject<c##ProxyWithInternal>(signaling_thread,  \
                                                            worker_thread, c); \
   }
 
-#define BEGIN_OWNED_PROXY_MAP(c)                                       \
-  PROXY_MAP_BOILERPLATE(c)                                             \
-  WORKER_PROXY_MAP_BOILERPLATE(c)                                      \
-  OWNED_PROXY_MAP_BOILERPLATE(c)                                       \
- public:                                                               \
-  static std::unique_ptr<c##ProxyWithInternal> Create(                 \
-      rtc::Thread* signaling_thread, rtc::Thread* worker_thread,       \
-      INTERNAL_CLASS* c) {                                             \
-    return std::unique_ptr<c##ProxyWithInternal>(                      \
-        new c##ProxyWithInternal(signaling_thread, worker_thread, c)); \
+#define BEGIN_OWNED_PROXY_MAP(c)                                   \
+  PROXY_MAP_BOILERPLATE(c)                                         \
+  WORKER_PROXY_MAP_BOILERPLATE(c)                                  \
+  OWNED_PROXY_MAP_BOILERPLATE(c)                                   \
+ public:                                                           \
+  static std::unique_ptr<c##Interface> Create(                     \
+      rtc::Thread* signaling_thread, rtc::Thread* worker_thread,   \
+      std::unique_ptr<INTERNAL_CLASS> c) {                         \
+    return std::unique_ptr<c##Interface>(new c##ProxyWithInternal( \
+        signaling_thread, worker_thread, c.release()));            \
   }
 
 #define PROXY_SIGNALING_THREAD_DESTRUCTOR()                            \
  private:                                                              \
   rtc::Thread* destructor_thread() const { return signaling_thread_; } \
                                                                        \
  public:  // NOLINTNEXTLINE
 
 #define PROXY_WORKER_THREAD_DESTRUCTOR()                            \
  private:                                                           \
   rtc::Thread* destructor_thread() const { return worker_thread_; } \
                                                                     \
  public:  // NOLINTNEXTLINE
 
 #define PROXY_METHOD0(r, method)                           \
   r method() override {                                    \
-    MethodCall0<C, r> call(c_.get(), &C::method);          \
+    MethodCall0<C, r> call(c_, &C::method);                \
     return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
   }
 
 #define PROXY_CONSTMETHOD0(r, method)                      \
   r method() const override {                              \
-    ConstMethodCall0<C, r> call(c_.get(), &C::method);     \
+    ConstMethodCall0<C, r> call(c_, &C::method);           \
     return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
   }
 
-#define PROXY_METHOD1(r, method, t1)                                 \
-  r method(t1 a1) override {                                         \
-    MethodCall1<C, r, t1> call(c_.get(), &C::method, std::move(a1)); \
-    return call.Marshal(RTC_FROM_HERE, signaling_thread_);           \
+#define PROXY_METHOD1(r, method, t1)                           \
+  r method(t1 a1) override {                                   \
+    MethodCall1<C, r, t1> call(c_, &C::method, std::move(a1)); \
+    return call.Marshal(RTC_FROM_HERE, signaling_thread_);     \
   }
 
-#define PROXY_CONSTMETHOD1(r, method, t1)                                 \
-  r method(t1 a1) const override {                                        \
-    ConstMethodCall1<C, r, t1> call(c_.get(), &C::method, std::move(a1)); \
-    return call.Marshal(RTC_FROM_HERE, signaling_thread_);                \
+#define PROXY_CONSTMETHOD1(r, method, t1)                           \
+  r method(t1 a1) const override {                                  \
+    ConstMethodCall1<C, r, t1> call(c_, &C::method, std::move(a1)); \
+    return call.Marshal(RTC_FROM_HERE, signaling_thread_);          \
   }
 
-#define PROXY_METHOD2(r, method, t1, t2)                                \
-  r method(t1 a1, t2 a2) override {                                     \
-    MethodCall2<C, r, t1, t2> call(c_.get(), &C::method, std::move(a1), \
-                                   std::move(a2));                      \
-    return call.Marshal(RTC_FROM_HERE, signaling_thread_);              \
+#define PROXY_METHOD2(r, method, t1, t2)                          \
+  r method(t1 a1, t2 a2) override {                               \
+    MethodCall2<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
+                                   std::move(a2));                \
+    return call.Marshal(RTC_FROM_HERE, signaling_thread_);        \
   }
 
-#define PROXY_METHOD3(r, method, t1, t2, t3)                                \
-  r method(t1 a1, t2 a2, t3 a3) override {                                  \
-    MethodCall3<C, r, t1, t2, t3> call(c_.get(), &C::method, std::move(a1), \
-                                       std::move(a2), std::move(a3));       \
-    return call.Marshal(RTC_FROM_HERE, signaling_thread_);                  \
+#define PROXY_METHOD3(r, method, t1, t2, t3)                          \
+  r method(t1 a1, t2 a2, t3 a3) override {                            \
+    MethodCall3<C, r, t1, t2, t3> call(c_, &C::method, std::move(a1), \
+                                       std::move(a2), std::move(a3)); \
+    return call.Marshal(RTC_FROM_HERE, signaling_thread_);            \
   }
 
 #define PROXY_METHOD4(r, method, t1, t2, t3, t4)                          \
   r method(t1 a1, t2 a2, t3 a3, t4 a4) override {                         \
-    MethodCall4<C, r, t1, t2, t3, t4> call(c_.get(), &C::method,          \
-                                           std::move(a1), std::move(a2),  \
-                                           std::move(a3), std::move(a4)); \
+    MethodCall4<C, r, t1, t2, t3, t4> call(c_, &C::method, std::move(a1), \
+                                           std::move(a2), std::move(a3),  \
+                                           std::move(a4));                \
     return call.Marshal(RTC_FROM_HERE, signaling_thread_);                \
   }
 
-#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5)                       \
-  r method(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) override {                   \
-    MethodCall5<C, r, t1, t2, t3, t4, t5> call(                            \
-        c_.get(), &C::method, std::move(a1), std::move(a2), std::move(a3), \
-        std::move(a4), std::move(a5));                                     \
-    return call.Marshal(RTC_FROM_HERE, signaling_thread_);                 \
+#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5)                          \
+  r method(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) override {                      \
+    MethodCall5<C, r, t1, t2, t3, t4, t5> call(c_, &C::method, std::move(a1), \
+                                               std::move(a2), std::move(a3),  \
+                                               std::move(a4), std::move(a5)); \
+    return call.Marshal(RTC_FROM_HERE, signaling_thread_);                    \
   }
 
 // Define methods which should be invoked on the worker thread.
 #define PROXY_WORKER_METHOD0(r, method)                 \
   r method() override {                                 \
-    MethodCall0<C, r> call(c_.get(), &C::method);       \
+    MethodCall0<C, r> call(c_, &C::method);             \
     return call.Marshal(RTC_FROM_HERE, worker_thread_); \
   }
 
 #define PROXY_WORKER_CONSTMETHOD0(r, method)            \
   r method() const override {                           \
-    ConstMethodCall0<C, r> call(c_.get(), &C::method);  \
+    ConstMethodCall0<C, r> call(c_, &C::method);        \
     return call.Marshal(RTC_FROM_HERE, worker_thread_); \
   }
 
-#define PROXY_WORKER_METHOD1(r, method, t1)                          \
-  r method(t1 a1) override {                                         \
-    MethodCall1<C, r, t1> call(c_.get(), &C::method, std::move(a1)); \
-    return call.Marshal(RTC_FROM_HERE, worker_thread_);              \
+#define PROXY_WORKER_METHOD1(r, method, t1)                    \
+  r method(t1 a1) override {                                   \
+    MethodCall1<C, r, t1> call(c_, &C::method, std::move(a1)); \
+    return call.Marshal(RTC_FROM_HERE, worker_thread_);        \
   }
 
-#define PROXY_WORKER_CONSTMETHOD1(r, method, t1)                          \
-  r method(t1 a1) const override {                                        \
-    ConstMethodCall1<C, r, t1> call(c_.get(), &C::method, std::move(a1)); \
-    return call.Marshal(RTC_FROM_HERE, worker_thread_);                   \
+#define PROXY_WORKER_CONSTMETHOD1(r, method, t1)                    \
+  r method(t1 a1) const override {                                  \
+    ConstMethodCall1<C, r, t1> call(c_, &C::method, std::move(a1)); \
+    return call.Marshal(RTC_FROM_HERE, 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, std::move(a1), \
-                                   std::move(a2));                      \
-    return call.Marshal(RTC_FROM_HERE, worker_thread_);                 \
+#define PROXY_WORKER_METHOD2(r, method, t1, t2)                   \
+  r method(t1 a1, t2 a2) override {                               \
+    MethodCall2<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
+                                   std::move(a2));                \
+    return call.Marshal(RTC_FROM_HERE, worker_thread_);           \
   }
 
-#define PROXY_WORKER_CONSTMETHOD2(r, method, t1, t2)                         \
-  r method(t1 a1, t2 a2) const override {                                    \
-    ConstMethodCall2<C, r, t1, t2> call(c_.get(), &C::method, std::move(a1), \
-                                        std::move(a2));                      \
-    return call.Marshal(RTC_FROM_HERE, worker_thread_);                      \
+#define PROXY_WORKER_CONSTMETHOD2(r, method, t1, t2)                   \
+  r method(t1 a1, t2 a2) const override {                              \
+    ConstMethodCall2<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
+                                        std::move(a2));                \
+    return call.Marshal(RTC_FROM_HERE, worker_thread_);                \
+  }
+
+#define PROXY_WORKER_METHOD3(r, method, t1, t2, t3)                   \
+  r method(t1 a1, t2 a2, t3 a3) override {                            \
+    MethodCall3<C, r, t1, t2, t3> call(c_, &C::method, std::move(a1), \
+                                       std::move(a2), std::move(a3)); \
+    return call.Marshal(RTC_FROM_HERE, worker_thread_);               \
+  }
+
+#define PROXY_WORKER_CONSTMETHOD3(r, method, t1, t2)                       \
+  r method(t1 a1, t2 a2, t3 a3) const override {                           \
+    ConstMethodCall3<C, r, t1, t2, t3> call(c_, &C::method, std::move(a1), \
+                                            std::move(a2), std::move(a3)); \
+    return call.Marshal(RTC_FROM_HERE, worker_thread_);                    \
   }
 
 }  // namespace webrtc
 
 #endif  //  WEBRTC_API_PROXY_H_