Index: webrtc/api/proxy.h |
diff --git a/webrtc/api/proxy.h b/webrtc/api/proxy.h |
index 746a758ba4315181cfb04688487fa1d70179eb0c..51cdd296cf586563a571ecf3c1c723cd7f2e1a73 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 @@ class ReturnType { |
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 @@ class ReturnType<void> { |
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); } |
- |
- void value() {} |
+ 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 moved_result() {} |
}; |
namespace internal { |
@@ -134,7 +151,7 @@ class MethodCall0 : public rtc::Message, |
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 @@ class ConstMethodCall0 : public rtc::Message, |
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 @@ class MethodCall1 : public rtc::Message, |
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 @@ class ConstMethodCall1 : public rtc::Message, |
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 @@ class MethodCall2 : public rtc::Message, |
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 @@ class MethodCall3 : public rtc::Message, |
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 @@ class MethodCall4 : public rtc::Message, |
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 @@ class MethodCall5 : public rtc::Message, |
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 @@ class MethodCall5 : public rtc::Message, |
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 MethodCall5 : public rtc::Message, |
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 @@ class MethodCall5 : public rtc::Message, |
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_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_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_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_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); \ |
- 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, a1, a2, a3, \ |
- a4); \ |
- 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, a1, a2, \ |
- a3, a4, 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_.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 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() \ |
- 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 |