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/media_stream_proxy.h b/api/media_stream_proxy.h
index 773c5d8..8ee33ca 100644
--- a/api/media_stream_proxy.h
+++ b/api/media_stream_proxy.h
@@ -20,8 +20,8 @@
// TODO(deadbeef): Move this to .cc file and out of api/. What threads methods
// are called on is an implementation detail.
-BEGIN_PRIMARY_PROXY_MAP(MediaStream)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+BEGIN_SIGNALING_PROXY_MAP(MediaStream)
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
BYPASS_PROXY_CONSTMETHOD0(std::string, id)
PROXY_METHOD0(AudioTrackVector, GetAudioTracks)
PROXY_METHOD0(VideoTrackVector, GetVideoTracks)
diff --git a/api/media_stream_track_proxy.h b/api/media_stream_track_proxy.h
index a0fe676..59dcb77 100644
--- a/api/media_stream_track_proxy.h
+++ b/api/media_stream_track_proxy.h
@@ -24,8 +24,8 @@
// TODO(deadbeef): Move this to .cc file and out of api/. What threads methods
// are called on is an implementation detail.
-BEGIN_PRIMARY_PROXY_MAP(AudioTrack)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+BEGIN_SIGNALING_PROXY_MAP(AudioTrack)
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
BYPASS_PROXY_CONSTMETHOD0(std::string, kind)
BYPASS_PROXY_CONSTMETHOD0(std::string, id)
PROXY_CONSTMETHOD0(TrackState, state)
@@ -41,7 +41,7 @@
END_PROXY_MAP()
BEGIN_PROXY_MAP(VideoTrack)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
BYPASS_PROXY_CONSTMETHOD0(std::string, kind)
BYPASS_PROXY_CONSTMETHOD0(std::string, id)
PROXY_CONSTMETHOD0(TrackState, state)
@@ -49,11 +49,11 @@
PROXY_METHOD1(bool, set_enabled, bool)
PROXY_CONSTMETHOD0(ContentHint, content_hint)
PROXY_METHOD1(void, set_content_hint, ContentHint)
-PROXY_SECONDARY_METHOD2(void,
- AddOrUpdateSink,
- rtc::VideoSinkInterface<VideoFrame>*,
- const rtc::VideoSinkWants&)
-PROXY_SECONDARY_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
+PROXY_WORKER_METHOD2(void,
+ AddOrUpdateSink,
+ rtc::VideoSinkInterface<VideoFrame>*,
+ const rtc::VideoSinkWants&)
+PROXY_WORKER_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
PROXY_CONSTMETHOD0(VideoTrackSourceInterface*, GetSource)
PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
diff --git a/api/peer_connection_factory_proxy.h b/api/peer_connection_factory_proxy.h
index 9056495..58a4272 100644
--- a/api/peer_connection_factory_proxy.h
+++ b/api/peer_connection_factory_proxy.h
@@ -22,8 +22,8 @@
// TODO(deadbeef): Move this to .cc file and out of api/. What threads methods
// are called on is an implementation detail.
-BEGIN_PRIMARY_PROXY_MAP(PeerConnectionFactory)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+BEGIN_SIGNALING_PROXY_MAP(PeerConnectionFactory)
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
PROXY_METHOD1(void, SetOptions, const Options&)
PROXY_METHOD4(rtc::scoped_refptr<PeerConnectionInterface>,
CreatePeerConnection,
diff --git a/api/peer_connection_proxy.h b/api/peer_connection_proxy.h
index b9bf80a..43802f1 100644
--- a/api/peer_connection_proxy.h
+++ b/api/peer_connection_proxy.h
@@ -26,7 +26,7 @@
// TODO(deadbeef): Move this to .cc file and out of api/. What threads methods
// are called on is an implementation detail.
BEGIN_PROXY_MAP(PeerConnection)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
PROXY_METHOD0(rtc::scoped_refptr<StreamCollectionInterface>, local_streams)
PROXY_METHOD0(rtc::scoped_refptr<StreamCollectionInterface>, remote_streams)
PROXY_METHOD1(bool, AddStream, MediaStreamInterface*)
@@ -140,8 +140,8 @@
const std::string&)
// This method will be invoked on the network thread. See
// PeerConnectionFactory::CreatePeerConnectionOrError for more details.
-PROXY_SECONDARY_CONSTMETHOD0(rtc::scoped_refptr<SctpTransportInterface>,
- GetSctpTransport)
+PROXY_WORKER_CONSTMETHOD0(rtc::scoped_refptr<SctpTransportInterface>,
+ GetSctpTransport)
PROXY_METHOD0(SignalingState, signaling_state)
PROXY_METHOD0(IceConnectionState, ice_connection_state)
PROXY_METHOD0(IceConnectionState, standardized_ice_connection_state)
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).
diff --git a/api/rtp_receiver_interface.h b/api/rtp_receiver_interface.h
index e0ace54..8984d71 100644
--- a/api/rtp_receiver_interface.h
+++ b/api/rtp_receiver_interface.h
@@ -120,8 +120,8 @@
// Define proxy for RtpReceiverInterface.
// TODO(deadbeef): Move this to .cc file and out of api/. What threads methods
// are called on is an implementation detail.
-BEGIN_PRIMARY_PROXY_MAP(RtpReceiver)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+BEGIN_SIGNALING_PROXY_MAP(RtpReceiver)
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
PROXY_CONSTMETHOD0(rtc::scoped_refptr<MediaStreamTrackInterface>, track)
PROXY_CONSTMETHOD0(rtc::scoped_refptr<DtlsTransportInterface>, dtls_transport)
PROXY_CONSTMETHOD0(std::vector<std::string>, stream_ids)
diff --git a/api/rtp_sender_interface.h b/api/rtp_sender_interface.h
index dd93792..a33b800 100644
--- a/api/rtp_sender_interface.h
+++ b/api/rtp_sender_interface.h
@@ -104,8 +104,8 @@
// Define proxy for RtpSenderInterface.
// TODO(deadbeef): Move this to .cc file and out of api/. What threads methods
// are called on is an implementation detail.
-BEGIN_PRIMARY_PROXY_MAP(RtpSender)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+BEGIN_SIGNALING_PROXY_MAP(RtpSender)
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
PROXY_METHOD1(bool, SetTrack, MediaStreamTrackInterface*)
PROXY_CONSTMETHOD0(rtc::scoped_refptr<MediaStreamTrackInterface>, track)
PROXY_CONSTMETHOD0(rtc::scoped_refptr<DtlsTransportInterface>, dtls_transport)
diff --git a/api/video_track_source_proxy.h b/api/video_track_source_proxy.h
index 0b60d20..692ff64 100644
--- a/api/video_track_source_proxy.h
+++ b/api/video_track_source_proxy.h
@@ -21,27 +21,27 @@
// TODO(deadbeef): Move this to .cc file and out of api/. What threads methods
// are called on is an implementation detail.
BEGIN_PROXY_MAP(VideoTrackSource)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
PROXY_CONSTMETHOD0(SourceState, state)
BYPASS_PROXY_CONSTMETHOD0(bool, remote)
BYPASS_PROXY_CONSTMETHOD0(bool, is_screencast)
PROXY_CONSTMETHOD0(absl::optional<bool>, needs_denoising)
PROXY_METHOD1(bool, GetStats, Stats*)
-PROXY_SECONDARY_METHOD2(void,
- AddOrUpdateSink,
- rtc::VideoSinkInterface<VideoFrame>*,
- const rtc::VideoSinkWants&)
-PROXY_SECONDARY_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
+PROXY_WORKER_METHOD2(void,
+ AddOrUpdateSink,
+ rtc::VideoSinkInterface<VideoFrame>*,
+ const rtc::VideoSinkWants&)
+PROXY_WORKER_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
PROXY_CONSTMETHOD0(bool, SupportsEncodedOutput)
-PROXY_SECONDARY_METHOD0(void, GenerateKeyFrame)
-PROXY_SECONDARY_METHOD1(void,
- AddEncodedSink,
- rtc::VideoSinkInterface<RecordableEncodedFrame>*)
-PROXY_SECONDARY_METHOD1(void,
- RemoveEncodedSink,
- rtc::VideoSinkInterface<RecordableEncodedFrame>*)
+PROXY_WORKER_METHOD0(void, GenerateKeyFrame)
+PROXY_WORKER_METHOD1(void,
+ AddEncodedSink,
+ rtc::VideoSinkInterface<RecordableEncodedFrame>*)
+PROXY_WORKER_METHOD1(void,
+ RemoveEncodedSink,
+ rtc::VideoSinkInterface<RecordableEncodedFrame>*)
END_PROXY_MAP()
} // namespace webrtc