Adding some features to proxy.h, and restructuring the macros.

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 10 matching lines @@
 //   std::string FooC(bool arg1) = 0;
 //  };
 //
 // Note that return types can not be a const reference.
 //
 // class Test : public TestInterface {
 // ... implementation of the interface.
 // };
 //
 // BEGIN_PROXY_MAP(Test)
+//   PROXY_SIGNALING_THREAD_DESTRUCTOR()

[pthatcher1, 2017/01/17 19:44:00]

What happens if one doesn't include this line?  Would it be too easy to forget
and cause something bad to happen?  Would it make sense to keep the default to
be as if the line were there?

[Taylor Brandstetter, 2017/01/18 01:17:14]

You'd get a compile error: "use of undeclared identifier 'destructor_thread'"

 //   PROXY_METHOD0(std::string, FooA)
 //   PROXY_CONSTMETHOD1(std::string, FooB, arg1)
 //   PROXY_WORKER_METHOD1(std::string, FooC, arg1)
-// END_PROXY()
+// END_PROXY_MAP()
 //
-// where the first two methods are invoked on the signaling thread,
-// and the third is invoked on the worker thread.
+// Where the destructor and first two methods are invoked on the signaling
+// thread, and the third is invoked on the worker thread.
 //
 // The proxy can be created using
 //
 //   TestProxy::Create(Thread* signaling_thread, Thread* worker_thread,
 //                     TestInterface*).
 //
 // The variant defined with BEGIN_SIGNALING_PROXY_MAP is unaware of
 // the worker thread, and invokes all methods on the signaling thread.
+//
+// The variant defined with BEGIN_NON_REFCOUNTED_PROXY_MAP does not use

[pthatcher1, 2017/01/17 19:44:00]

Would BEGIN_OWNED_PROXY_MAP be a better name?

[Taylor Brandstetter, 2017/01/18 01:17:14]

Done.

+// refcounting, and instead just takes ownership of the object being proxied.
 
 #ifndef WEBRTC_API_PROXY_H_
 #define WEBRTC_API_PROXY_H_
 
 #include <memory>
 
 #include "webrtc/base/event.h"
 #include "webrtc/base/thread.h"
 
 namespace webrtc {
@@ skipping 243 matching lines @@
   C* c_;
   Method m_;
   ReturnType<R> r_;
   T1 a1_;
   T2 a2_;
   T3 a3_;
   T4 a4_;
   T5 a5_;
 };
 
-#define BEGIN_SIGNALING_PROXY_MAP(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;                                                    \
-    c##ProxyWithInternal(rtc::Thread* signaling_thread, INTERNAL_CLASS* c)     \
-        : signaling_thread_(signaling_thread), c_(c) {}                        \
-    ~c##ProxyWithInternal() {                                                  \
-      MethodCall0<c##ProxyWithInternal, void> call(                            \
-          this, &c##ProxyWithInternal::Release_s);                             \
-      call.Marshal(RTC_FROM_HERE, signaling_thread_);                          \
-    }                                                                          \
-                                                                               \
-   public:                                                                     \
-    static rtc::scoped_refptr<c##ProxyWithInternal> Create(                    \
-        rtc::Thread* signaling_thread,                                         \
-        INTERNAL_CLASS* c) {                                                   \
-      return new rtc::RefCountedObject<c##ProxyWithInternal>(signaling_thread, \
-                                                             c);               \
-    }                                                                          \
-    const INTERNAL_CLASS* internal() const { return c_.get(); }                \
-    INTERNAL_CLASS* internal() { return c_.get(); }
-
-#define BEGIN_PROXY_MAP(c)                                      \
+// 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;                                     \
-    c##ProxyWithInternal(rtc::Thread* signaling_thread,         \
-                         rtc::Thread* worker_thread,            \
-                         INTERNAL_CLASS* c)                     \
-        : signaling_thread_(signaling_thread),                  \
-          worker_thread_(worker_thread),                        \
-          c_(c) {}                                              \
-    ~c##ProxyWithInternal() {                                   \
-      MethodCall0<c##ProxyWithInternal, void> call(             \
-          this, &c##ProxyWithInternal::Release_s);              \
-      call.Marshal(RTC_FROM_HERE, signaling_thread_);           \
-    }                                                           \
                                                                 \
    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);                  \
-    }                                                           \
     const INTERNAL_CLASS* internal() const { return c_.get(); } \
     INTERNAL_CLASS* internal() { return c_.get(); }
 
+#define SIGNALING_PROXY_MAP_BOILERPLATE(c)                               \
+ protected:                                                              \
+  c##ProxyWithInternal(rtc::Thread* signaling_thread, INTERNAL_CLASS* c) \
+      : signaling_thread_(signaling_thread), c_(c) {}                    \
+                                                                         \
+ private:                                                                \
+  mutable rtc::Thread* signaling_thread_;
+
+#define WORKER_PROXY_MAP_BOILERPLATE(c)                               \
+ protected:                                                           \
+  c##ProxyWithInternal(rtc::Thread* signaling_thread,                 \
+                       rtc::Thread* worker_thread, INTERNAL_CLASS* c) \
+      : signaling_thread_(signaling_thread),                          \
+        worker_thread_(worker_thread),                                \
+        c_(c) {}                                                      \
+                                                                      \
+ private:                                                             \
+  mutable rtc::Thread* signaling_thread_;                             \
+  mutable rtc::Thread* worker_thread_;
+
+// Note that the destructor is protected so that the proxy can only be
+// destroyed via RefCountInterface.
+#define REFCOUNTED_PROXY_MAP_BOILERPLATE(c)            \
+ protected:                                            \
+  ~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_;
+
+#define NON_REFCOUNTED_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_;
+
+#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_NON_REFCOUNTED_PROXY_MAP(c)                              \
+  PROXY_MAP_BOILERPLATE(c)                                             \
+  WORKER_PROXY_MAP_BOILERPLATE(c)                                      \
+  NON_REFCOUNTED_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 PROXY_SIGNALING_THREAD_DESTRUCTOR()                            \
+ private:                                                              \
+  rtc::Thread* destructor_thread() const { return signaling_thread_; } \
+                                                                       \
+ public:
+
+#define PROXY_WORKER_THREAD_DESTRUCTOR()                            \
+ private:                                                           \
+  rtc::Thread* destructor_thread() const { return worker_thread_; } \
+                                                                    \
+ public:
+
 #define PROXY_METHOD0(r, method)                           \
   r method() override {                                    \
     MethodCall0<C, r> call(c_.get(), &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);     \
     return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
@@ skipping 31 matching lines @@
   }
 
 #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, a1, a2, \
                                                a3, a4, 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);       \
+    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);  \
+    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, 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, 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, a1, a2); \
     return call.Marshal(RTC_FROM_HERE, worker_thread_);           \
   }
 
-#define END_SIGNALING_PROXY()             \
- private:                                 \
-  void Release_s() { c_ = NULL; }         \
-  mutable rtc::Thread* signaling_thread_; \
-  rtc::scoped_refptr<INTERNAL_CLASS> c_;  \
-  }                                       \
-  ;
+#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, a1, a2); \
+    return call.Marshal(RTC_FROM_HERE, worker_thread_);                \
+  }
 
-#define END_PROXY()                       \
- private:                                 \
-  void Release_s() { c_ = NULL; }         \
-  mutable rtc::Thread* signaling_thread_; \
-  mutable rtc::Thread* worker_thread_;    \
-  rtc::scoped_refptr<INTERNAL_CLASS> c_;  \
-  }                                       \
+#define END_PROXY_MAP() \
+  }                     \
   ;
 
 }  // namespace webrtc
 
 #endif  //  WEBRTC_API_PROXY_H_