Adding some features to proxy.h, and restructuring the macros.
New features are:
- Invoke a destructor on the worker thread.
- Make proxy wrapper for a non-refcounted object.
- Ability to use unique_ptrs (as arguments or return values).
These features are needed by this CL:
https://codereview.webrtc.org/2632613002/
BUG=None
Review-Url: https://codereview.webrtc.org/2628343003
Cr-Commit-Position: refs/heads/master@{#16151}
diff --git a/webrtc/api/proxy.h b/webrtc/api/proxy.h
index 746a758..51cdd29 100644
--- a/webrtc/api/proxy.h
+++ b/webrtc/api/proxy.h
@@ -28,13 +28,14 @@
// };
//
// BEGIN_PROXY_MAP(Test)
+// PROXY_SIGNALING_THREAD_DESTRUCTOR()
// 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
//
@@ -43,6 +44,9 @@
//
// 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_OWNED_PROXY_MAP does not use
+// refcounting, and instead just takes ownership of the object being proxied.
#ifndef WEBRTC_API_PROXY_H_
#define WEBRTC_API_PROXY_H_
@@ -59,24 +63,31 @@
public:
template<typename C, typename M>
void Invoke(C* c, M m) { r_ = (c->*m)(); }
- template<typename C, typename M, typename T1>
- void Invoke(C* c, M m, T1 a1) { r_ = (c->*m)(a1); }
- template<typename C, typename M, typename T1, typename T2>
- void Invoke(C* c, M m, T1 a1, T2 a2) { r_ = (c->*m)(a1, a2); }
- template<typename C, typename M, typename T1, typename T2, typename T3>
- void Invoke(C* c, M m, T1 a1, T2 a2, T3 a3) { r_ = (c->*m)(a1, a2, a3); }
+ template <typename C, typename M, typename T1>
+ void Invoke(C* c, M m, T1 a1) {
+ r_ = (c->*m)(std::move(a1));
+ }
+ template <typename C, typename M, typename T1, typename T2>
+ void Invoke(C* c, M m, T1 a1, T2 a2) {
+ r_ = (c->*m)(std::move(a1), std::move(a2));
+ }
+ template <typename C, typename M, typename T1, typename T2, typename T3>
+ void Invoke(C* c, M m, T1 a1, T2 a2, T3 a3) {
+ r_ = (c->*m)(std::move(a1), std::move(a2), std::move(a3));
+ }
template<typename C, typename M, typename T1, typename T2, typename T3,
typename T4>
void Invoke(C* c, M m, T1 a1, T2 a2, T3 a3, T4 a4) {
- r_ = (c->*m)(a1, a2, a3, a4);
+ r_ = (c->*m)(std::move(a1), std::move(a2), std::move(a3), std::move(a4));
}
template<typename C, typename M, typename T1, typename T2, typename T3,
typename T4, typename T5>
void Invoke(C* c, M m, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) {
- r_ = (c->*m)(a1, a2, a3, a4, a5);
+ r_ = (c->*m)(std::move(a1), std::move(a2), std::move(a3), std::move(a4),
+ std::move(a5));
}
- R value() { return r_; }
+ R moved_result() { return std::move(r_); }
private:
R r_;
@@ -87,14 +98,20 @@
public:
template<typename C, typename M>
void Invoke(C* c, M m) { (c->*m)(); }
- template<typename C, typename M, typename T1>
- void Invoke(C* c, M m, T1 a1) { (c->*m)(a1); }
- template<typename C, typename M, typename T1, typename T2>
- void Invoke(C* c, M m, T1 a1, T2 a2) { (c->*m)(a1, a2); }
- template<typename C, typename M, typename T1, typename T2, typename T3>
- void Invoke(C* c, M m, T1 a1, T2 a2, T3 a3) { (c->*m)(a1, a2, a3); }
+ template <typename C, typename M, typename T1>
+ void Invoke(C* c, M m, T1 a1) {
+ (c->*m)(std::move(a1));
+ }
+ template <typename C, typename M, typename T1, typename T2>
+ void Invoke(C* c, M m, T1 a1, T2 a2) {
+ (c->*m)(std::move(a1), std::move(a2));
+ }
+ template <typename C, typename M, typename T1, typename T2, typename T3>
+ void Invoke(C* c, M m, T1 a1, T2 a2, T3 a3) {
+ (c->*m)(std::move(a1), std::move(a2), std::move(a3));
+ }
- void value() {}
+ void moved_result() {}
};
namespace internal {
@@ -134,7 +151,7 @@
R Marshal(const rtc::Location& posted_from, rtc::Thread* t) {
internal::SynchronousMethodCall(this).Invoke(posted_from, t);
- return r_.value();
+ return r_.moved_result();
}
private:
@@ -154,7 +171,7 @@
R Marshal(const rtc::Location& posted_from, rtc::Thread* t) {
internal::SynchronousMethodCall(this).Invoke(posted_from, t);
- return r_.value();
+ return r_.moved_result();
}
private:
@@ -170,15 +187,15 @@
public rtc::MessageHandler {
public:
typedef R (C::*Method)(T1 a1);
- MethodCall1(C* c, Method m, T1 a1) : c_(c), m_(m), a1_(a1) {}
+ MethodCall1(C* c, Method m, T1 a1) : c_(c), m_(m), a1_(std::move(a1)) {}
R Marshal(const rtc::Location& posted_from, rtc::Thread* t) {
internal::SynchronousMethodCall(this).Invoke(posted_from, t);
- return r_.value();
+ return r_.moved_result();
}
private:
- void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_); }
+ void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, std::move(a1_)); }
C* c_;
Method m_;
@@ -191,15 +208,15 @@
public rtc::MessageHandler {
public:
typedef R (C::*Method)(T1 a1) const;
- ConstMethodCall1(C* c, Method m, T1 a1) : c_(c), m_(m), a1_(a1) {}
+ ConstMethodCall1(C* c, Method m, T1 a1) : c_(c), m_(m), a1_(std::move(a1)) {}
R Marshal(const rtc::Location& posted_from, rtc::Thread* t) {
internal::SynchronousMethodCall(this).Invoke(posted_from, t);
- return r_.value();
+ return r_.moved_result();
}
private:
- void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_); }
+ void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, std::move(a1_)); }
C* c_;
Method m_;
@@ -212,15 +229,18 @@
public rtc::MessageHandler {
public:
typedef R (C::*Method)(T1 a1, T2 a2);
- MethodCall2(C* c, Method m, T1 a1, T2 a2) : c_(c), m_(m), a1_(a1), a2_(a2) {}
+ MethodCall2(C* c, Method m, T1 a1, T2 a2)
+ : c_(c), m_(m), a1_(std::move(a1)), a2_(std::move(a2)) {}
R Marshal(const rtc::Location& posted_from, rtc::Thread* t) {
internal::SynchronousMethodCall(this).Invoke(posted_from, t);
- return r_.value();
+ return r_.moved_result();
}
private:
- void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_, a2_); }
+ void OnMessage(rtc::Message*) {
+ r_.Invoke(c_, m_, std::move(a1_), std::move(a2_));
+ }
C* c_;
Method m_;
@@ -235,15 +255,21 @@
public:
typedef R (C::*Method)(T1 a1, T2 a2, T3 a3);
MethodCall3(C* c, Method m, T1 a1, T2 a2, T3 a3)
- : c_(c), m_(m), a1_(a1), a2_(a2), a3_(a3) {}
+ : c_(c),
+ m_(m),
+ a1_(std::move(a1)),
+ a2_(std::move(a2)),
+ a3_(std::move(a3)) {}
R Marshal(const rtc::Location& posted_from, rtc::Thread* t) {
internal::SynchronousMethodCall(this).Invoke(posted_from, t);
- return r_.value();
+ return r_.moved_result();
}
private:
- void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_, a2_, a3_); }
+ void OnMessage(rtc::Message*) {
+ r_.Invoke(c_, m_, std::move(a1_), std::move(a2_), std::move(a3_));
+ }
C* c_;
Method m_;
@@ -260,15 +286,23 @@
public:
typedef R (C::*Method)(T1 a1, T2 a2, T3 a3, T4 a4);
MethodCall4(C* c, Method m, T1 a1, T2 a2, T3 a3, T4 a4)
- : c_(c), m_(m), a1_(a1), a2_(a2), a3_(a3), a4_(a4) {}
+ : c_(c),
+ m_(m),
+ a1_(std::move(a1)),
+ a2_(std::move(a2)),
+ a3_(std::move(a3)),
+ a4_(std::move(a4)) {}
R Marshal(const rtc::Location& posted_from, rtc::Thread* t) {
internal::SynchronousMethodCall(this).Invoke(posted_from, t);
- return r_.value();
+ return r_.moved_result();
}
private:
- void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_, a2_, a3_, a4_); }
+ void OnMessage(rtc::Message*) {
+ r_.Invoke(c_, m_, std::move(a1_), std::move(a2_), std::move(a3_),
+ std::move(a4_));
+ }
C* c_;
Method m_;
@@ -286,15 +320,24 @@
public:
typedef R (C::*Method)(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5);
MethodCall5(C* c, Method m, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5)
- : c_(c), m_(m), a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5) {}
+ : c_(c),
+ m_(m),
+ a1_(std::move(a1)),
+ a2_(std::move(a2)),
+ a3_(std::move(a3)),
+ a4_(std::move(a4)),
+ a5_(std::move(a5)) {}
R Marshal(const rtc::Location& posted_from, rtc::Thread* t) {
internal::SynchronousMethodCall(this).Invoke(posted_from, t);
- return r_.value();
+ return r_.moved_result();
}
private:
- void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_, a2_, a3_, a4_, a5_); }
+ void OnMessage(rtc::Message*) {
+ r_.Invoke(c_, m_, std::move(a1_), std::move(a2_), std::move(a3_),
+ std::move(a4_), std::move(a5_));
+ }
C* c_;
Method m_;
@@ -306,33 +349,8 @@
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; \
@@ -340,29 +358,104 @@
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 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_;
+
+#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 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); \
@@ -375,72 +468,89 @@
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, 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_.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_.get(), &C::method, 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, a1, 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, a1, a2, a3); \
+#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_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, a1, a2, a3, \
- a4); \
- 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_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 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_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)); \
+ 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 methods which should be invoked on the 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_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_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 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 END_SIGNALING_PROXY() \
- private: \
- void Release_s() { c_ = NULL; } \
- mutable rtc::Thread* signaling_thread_; \
- rtc::scoped_refptr<INTERNAL_CLASS> c_; \
- } \
- ;
+#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 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 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_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_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 END_PROXY_MAP() \
+ } \
;
} // namespace webrtc