Revert "Rename SIGNALING and WORKER to PRIMARY and SECONDARY"
This reverts commit a37f2bd9421868e222d591d3371486a6ab939fd6.
Reason for revert: Breaks compile step (e.g. https://ci.chromium.org/ui/p/webrtc/builders/ci/Android64%20Builder%20x64%20(dbg)/19773/overview).
Original change's description:
> Rename SIGNALING and WORKER to PRIMARY and SECONDARY
>
> This makes the proxy macros less confusing when the secondary thread
> is sometimes the worker thread, sometimes the networking thread.
>
> Bug: none
> Change-Id: I1a8cebb82d09be44fe40e80c861bcfb47b9928e8
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/208763
> Reviewed-by: Tommi <tommi@webrtc.org>
> Commit-Queue: Harald Alvestrand <hta@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#33346}
TBR=hta@webrtc.org
Bug: none
Change-Id: I2014faab3392f445f56edd9e833d00000ebc5ca3
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/208840
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33347}
diff --git a/api/proxy.h b/api/proxy.h
index 3be9f93..05f7414 100644
--- a/api/proxy.h
+++ b/api/proxy.h
@@ -12,13 +12,6 @@
// PeerConnection classes.
// TODO(deadbeef): Move this to pc/; this is part of the implementation.
-// The proxied objects are initialized with either one or two thread
-// objects that operations can be proxied to: The primary and secondary
-// threads.
-// In common usage, the primary thread will be the PeerConnection's
-// signaling thread, and the secondary thread will be either the
-// PeerConnection's worker thread or the PeerConnection's network thread.
-
//
// Example usage:
//
@@ -36,22 +29,22 @@
// };
//
// BEGIN_PROXY_MAP(Test)
-// PROXY_PRIMARY_THREAD_DESTRUCTOR()
+// PROXY_SIGNALING_THREAD_DESTRUCTOR()
// PROXY_METHOD0(std::string, FooA)
// PROXY_CONSTMETHOD1(std::string, FooB, arg1)
-// PROXY_SECONDARY_METHOD1(std::string, FooC, arg1)
+// PROXY_WORKER_METHOD1(std::string, FooC, arg1)
// END_PROXY_MAP()
//
-// Where the destructor and first two methods are invoked on the primary
-// thread, and the third is invoked on the secondary 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_PRIMARY_PROXY_MAP is unaware of
-// the secondary thread, and invokes all methods on the primary thread.
+// 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.
@@ -202,25 +195,25 @@
};
// clang-format on
-#define PRIMARY_PROXY_MAP_BOILERPLATE(c) \
- protected: \
- c##ProxyWithInternal(rtc::Thread* primary_thread, INTERNAL_CLASS* c) \
- : primary_thread_(primary_thread), c_(c) {} \
- \
- private: \
- mutable rtc::Thread* primary_thread_;
-
-#define SECONDARY_PROXY_MAP_BOILERPLATE(c) \
+#define SIGNALING_PROXY_MAP_BOILERPLATE(c) \
protected: \
- c##ProxyWithInternal(rtc::Thread* primary_thread, \
- rtc::Thread* secondary_thread, INTERNAL_CLASS* c) \
- : primary_thread_(primary_thread), \
- secondary_thread_(secondary_thread), \
- c_(c) {} \
+ c##ProxyWithInternal(rtc::Thread* signaling_thread, INTERNAL_CLASS* c) \
+ : signaling_thread_(signaling_thread), c_(c) {} \
\
private: \
- mutable rtc::Thread* primary_thread_; \
- mutable rtc::Thread* secondary_thread_;
+ 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.
@@ -253,88 +246,89 @@
void DestroyInternal() { delete c_; } \
INTERNAL_CLASS* c_;
-#define BEGIN_PRIMARY_PROXY_MAP(c) \
- PROXY_MAP_BOILERPLATE(c) \
- PRIMARY_PROXY_MAP_BOILERPLATE(c) \
- REFCOUNTED_PROXY_MAP_BOILERPLATE(c) \
- public: \
- static rtc::scoped_refptr<c##ProxyWithInternal> Create( \
- rtc::Thread* primary_thread, INTERNAL_CLASS* c) { \
- return new rtc::RefCountedObject<c##ProxyWithInternal>(primary_thread, 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) \
- SECONDARY_PROXY_MAP_BOILERPLATE(c) \
- REFCOUNTED_PROXY_MAP_BOILERPLATE(c) \
- public: \
- static rtc::scoped_refptr<c##ProxyWithInternal> Create( \
- rtc::Thread* primary_thread, rtc::Thread* secondary_thread, \
- INTERNAL_CLASS* c) { \
- return new rtc::RefCountedObject<c##ProxyWithInternal>( \
- primary_thread, secondary_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) \
- SECONDARY_PROXY_MAP_BOILERPLATE(c) \
+ WORKER_PROXY_MAP_BOILERPLATE(c) \
OWNED_PROXY_MAP_BOILERPLATE(c) \
public: \
static std::unique_ptr<c##Interface> Create( \
- rtc::Thread* primary_thread, rtc::Thread* secondary_thread, \
+ rtc::Thread* signaling_thread, rtc::Thread* worker_thread, \
std::unique_ptr<INTERNAL_CLASS> c) { \
return std::unique_ptr<c##Interface>(new c##ProxyWithInternal( \
- primary_thread, secondary_thread, c.release())); \
+ signaling_thread, worker_thread, c.release())); \
}
-#define PROXY_PRIMARY_THREAD_DESTRUCTOR() \
- private: \
- rtc::Thread* destructor_thread() const { return primary_thread_; } \
- \
- public: // NOLINTNEXTLINE
-
-#define PROXY_SECONDARY_THREAD_DESTRUCTOR() \
+#define PROXY_SIGNALING_THREAD_DESTRUCTOR() \
private: \
- rtc::Thread* destructor_thread() const { return secondary_thread_; } \
+ rtc::Thread* destructor_thread() const { return signaling_thread_; } \
\
public: // NOLINTNEXTLINE
-#define PROXY_METHOD0(r, method) \
- r method() override { \
- MethodCall<C, r> call(c_, &C::method); \
- return call.Marshal(RTC_FROM_HERE, primary_thread_); \
+#define PROXY_WORKER_THREAD_DESTRUCTOR() \
+ private: \
+ rtc::Thread* destructor_thread() const { return worker_thread_; } \
+ \
+ public: // NOLINTNEXTLINE
+
+#define PROXY_METHOD0(r, method) \
+ r method() override { \
+ MethodCall<C, r> call(c_, &C::method); \
+ return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
}
-#define PROXY_CONSTMETHOD0(r, method) \
- r method() const override { \
- ConstMethodCall<C, r> call(c_, &C::method); \
- return call.Marshal(RTC_FROM_HERE, primary_thread_); \
+#define PROXY_CONSTMETHOD0(r, method) \
+ r method() const override { \
+ ConstMethodCall<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 { \
MethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
- return call.Marshal(RTC_FROM_HERE, primary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
}
#define PROXY_CONSTMETHOD1(r, method, t1) \
r method(t1 a1) const override { \
ConstMethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
- return call.Marshal(RTC_FROM_HERE, primary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
}
#define PROXY_METHOD2(r, method, t1, t2) \
r method(t1 a1, t2 a2) override { \
MethodCall<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
std::move(a2)); \
- return call.Marshal(RTC_FROM_HERE, primary_thread_); \
+ 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 { \
MethodCall<C, r, t1, t2, t3> call(c_, &C::method, std::move(a1), \
std::move(a2), std::move(a3)); \
- return call.Marshal(RTC_FROM_HERE, primary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
}
#define PROXY_METHOD4(r, method, t1, t2, t3, t4) \
@@ -342,7 +336,7 @@
MethodCall<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, primary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
}
#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5) \
@@ -350,60 +344,60 @@
MethodCall<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, primary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, signaling_thread_); \
}
-// Define methods which should be invoked on the secondary thread.
-#define PROXY_SECONDARY_METHOD0(r, method) \
- r method() override { \
- MethodCall<C, r> call(c_, &C::method); \
- return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+// Define methods which should be invoked on the worker thread.
+#define PROXY_WORKER_METHOD0(r, method) \
+ r method() override { \
+ MethodCall<C, r> call(c_, &C::method); \
+ return call.Marshal(RTC_FROM_HERE, worker_thread_); \
}
-#define PROXY_SECONDARY_CONSTMETHOD0(r, method) \
- r method() const override { \
- ConstMethodCall<C, r> call(c_, &C::method); \
- return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+#define PROXY_WORKER_CONSTMETHOD0(r, method) \
+ r method() const override { \
+ ConstMethodCall<C, r> call(c_, &C::method); \
+ return call.Marshal(RTC_FROM_HERE, worker_thread_); \
}
-#define PROXY_SECONDARY_METHOD1(r, method, t1) \
+#define PROXY_WORKER_METHOD1(r, method, t1) \
r method(t1 a1) override { \
MethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
- return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, worker_thread_); \
}
-#define PROXY_SECONDARY_CONSTMETHOD1(r, method, t1) \
+#define PROXY_WORKER_CONSTMETHOD1(r, method, t1) \
r method(t1 a1) const override { \
ConstMethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
- return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, worker_thread_); \
}
-#define PROXY_SECONDARY_METHOD2(r, method, t1, t2) \
+#define PROXY_WORKER_METHOD2(r, method, t1, t2) \
r method(t1 a1, t2 a2) override { \
MethodCall<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
std::move(a2)); \
- return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, worker_thread_); \
}
-#define PROXY_SECONDARY_CONSTMETHOD2(r, method, t1, t2) \
+#define PROXY_WORKER_CONSTMETHOD2(r, method, t1, t2) \
r method(t1 a1, t2 a2) const override { \
ConstMethodCall<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
std::move(a2)); \
- return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, worker_thread_); \
}
-#define PROXY_SECONDARY_METHOD3(r, method, t1, t2, t3) \
+#define PROXY_WORKER_METHOD3(r, method, t1, t2, t3) \
r method(t1 a1, t2 a2, t3 a3) override { \
MethodCall<C, r, t1, t2, t3> call(c_, &C::method, std::move(a1), \
std::move(a2), std::move(a3)); \
- return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, worker_thread_); \
}
-#define PROXY_SECONDARY_CONSTMETHOD3(r, method, t1, t2) \
+#define PROXY_WORKER_CONSTMETHOD3(r, method, t1, t2) \
r method(t1 a1, t2 a2, t3 a3) const override { \
ConstMethodCall<C, r, t1, t2, t3> call(c_, &C::method, std::move(a1), \
std::move(a2), std::move(a3)); \
- return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+ return call.Marshal(RTC_FROM_HERE, worker_thread_); \
}
// For use when returning purely const state (set during construction).