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}

api/media_stream_proxy.h

@@ -20,8 +20,8 @@ namespace webrtc {
 
 // 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)
+BEGIN_SIGNALING_PROXY_MAP(MediaStream)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 BYPASS_PROXY_CONSTMETHOD0(std::string, id)
 PROXY_METHOD0(AudioTrackVector, GetAudioTracks)
 PROXY_METHOD0(VideoTrackVector, GetVideoTracks)

api/media_stream_track_proxy.h

@@ -24,8 +24,8 @@ namespace webrtc {
 // 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)
+BEGIN_SIGNALING_PROXY_MAP(AudioTrack)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 BYPASS_PROXY_CONSTMETHOD0(std::string, kind)
 BYPASS_PROXY_CONSTMETHOD0(std::string, id)
 PROXY_CONSTMETHOD0(TrackState, state)
@@ -41,7 +41,7 @@ PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
 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_CONSTMETHOD0(bool, enabled)
 PROXY_METHOD1(bool, set_enabled, bool)
 PROXY_CONSTMETHOD0(ContentHint, content_hint)
 PROXY_METHOD1(void, set_content_hint, ContentHint)
-PROXY_SECONDARY_METHOD2(void,
+PROXY_WORKER_METHOD2(void,
                      AddOrUpdateSink,
                      rtc::VideoSinkInterface<VideoFrame>*,
                      const rtc::VideoSinkWants&)
-PROXY_SECONDARY_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
+PROXY_WORKER_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
 PROXY_CONSTMETHOD0(VideoTrackSourceInterface*, GetSource)
 
 PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)

api/peer_connection_factory_proxy.h

@@ -22,8 +22,8 @@ namespace webrtc {
 
 // 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)
+BEGIN_SIGNALING_PROXY_MAP(PeerConnectionFactory)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD1(void, SetOptions, const Options&)
 PROXY_METHOD4(rtc::scoped_refptr<PeerConnectionInterface>,
               CreatePeerConnection,

api/peer_connection_proxy.h

@@ -26,7 +26,7 @@ namespace webrtc {
 // 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,7 +140,7 @@ PROXY_WORKER_METHOD1(rtc::scoped_refptr<DtlsTransportInterface>,
                      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>,
+PROXY_WORKER_CONSTMETHOD0(rtc::scoped_refptr<SctpTransportInterface>,
                           GetSctpTransport)
 PROXY_METHOD0(SignalingState, signaling_state)
 PROXY_METHOD0(IceConnectionState, ice_connection_state)

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
+// Where the destructor and first two methods are invoked on the signaling
-// thread, and the third is invoked on the secondary thread.
+// 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 variant defined with BEGIN_SIGNALING_PROXY_MAP is unaware of
-// the secondary thread, and invokes all methods on the primary thread.
+// 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 @@ class ConstMethodCall : public QueuedTask {
   };
 // clang-format on
 
-#define PRIMARY_PROXY_MAP_BOILERPLATE(c)                               \
+#define SIGNALING_PROXY_MAP_BOILERPLATE(c)                               \
  protected:                                                              \
-  c##ProxyWithInternal(rtc::Thread* primary_thread, INTERNAL_CLASS* c) \
+  c##ProxyWithInternal(rtc::Thread* signaling_thread, INTERNAL_CLASS* c) \
-      : primary_thread_(primary_thread), c_(c) {}                      \
+      : signaling_thread_(signaling_thread), c_(c) {}                    \
                                                                          \
  private:                                                                \
-  mutable rtc::Thread* primary_thread_;
+  mutable rtc::Thread* signaling_thread_;
 
-#define SECONDARY_PROXY_MAP_BOILERPLATE(c)                               \
+#define WORKER_PROXY_MAP_BOILERPLATE(c)                               \
  protected:                                                           \
-  c##ProxyWithInternal(rtc::Thread* primary_thread,                      \
+  c##ProxyWithInternal(rtc::Thread* signaling_thread,                 \
-                       rtc::Thread* secondary_thread, INTERNAL_CLASS* c) \
+                       rtc::Thread* worker_thread, INTERNAL_CLASS* c) \
-      : primary_thread_(primary_thread),                                 \
+      : signaling_thread_(signaling_thread),                          \
-        secondary_thread_(secondary_thread),                             \
+        worker_thread_(worker_thread),                                \
         c_(c) {}                                                      \
                                                                       \
  private:                                                             \
-  mutable rtc::Thread* primary_thread_;                                  \
+  mutable rtc::Thread* signaling_thread_;                             \
-  mutable rtc::Thread* secondary_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 @@ class ConstMethodCall : public QueuedTask {
   void DestroyInternal() { delete c_; }                \
   INTERNAL_CLASS* c_;
 
-#define BEGIN_PRIMARY_PROXY_MAP(c)                                             \
+#define BEGIN_SIGNALING_PROXY_MAP(c)                                         \
   PROXY_MAP_BOILERPLATE(c)                                                   \
-  PRIMARY_PROXY_MAP_BOILERPLATE(c)                                             \
+  SIGNALING_PROXY_MAP_BOILERPLATE(c)                                         \
   REFCOUNTED_PROXY_MAP_BOILERPLATE(c)                                        \
  public:                                                                     \
   static rtc::scoped_refptr<c##ProxyWithInternal> Create(                    \
-      rtc::Thread* primary_thread, INTERNAL_CLASS* c) {                        \
+      rtc::Thread* signaling_thread, INTERNAL_CLASS* c) {                    \
-    return new rtc::RefCountedObject<c##ProxyWithInternal>(primary_thread, c); \
+    return new rtc::RefCountedObject<c##ProxyWithInternal>(signaling_thread, \
+                                                           c);               \
   }
 
 #define BEGIN_PROXY_MAP(c)                                                    \
   PROXY_MAP_BOILERPLATE(c)                                                    \
-  SECONDARY_PROXY_MAP_BOILERPLATE(c)                              \
+  WORKER_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, \
+      rtc::Thread* signaling_thread, rtc::Thread* worker_thread,              \
       INTERNAL_CLASS* c) {                                                    \
-    return new rtc::RefCountedObject<c##ProxyWithInternal>(       \
+    return new rtc::RefCountedObject<c##ProxyWithInternal>(signaling_thread,  \
-        primary_thread, secondary_thread, c);                     \
+                                                           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()                            \
+#define PROXY_SIGNALING_THREAD_DESTRUCTOR()                            \
  private:                                                              \
-  rtc::Thread* destructor_thread() const { return primary_thread_; } \
+  rtc::Thread* destructor_thread() const { return signaling_thread_; } \
                                                                        \
  public:  // NOLINTNEXTLINE
 
-#define PROXY_SECONDARY_THREAD_DESTRUCTOR()                            \
+#define PROXY_WORKER_THREAD_DESTRUCTOR()                            \
  private:                                                           \
-  rtc::Thread* destructor_thread() const { return secondary_thread_; } \
+  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, primary_thread_); \
+    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_); \
+    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 @@ class ConstMethodCall : public QueuedTask {
     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 @@ class ConstMethodCall : public QueuedTask {
     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 methods which should be invoked on the worker thread.
-#define PROXY_SECONDARY_METHOD0(r, method)                 \
+#define PROXY_WORKER_METHOD0(r, method)                 \
   r method() override {                                 \
     MethodCall<C, r> call(c_, &C::method);              \
-    return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+    return call.Marshal(RTC_FROM_HERE, worker_thread_); \
   }
 
-#define PROXY_SECONDARY_CONSTMETHOD0(r, method)            \
+#define PROXY_WORKER_CONSTMETHOD0(r, method)            \
   r method() const override {                           \
     ConstMethodCall<C, r> call(c_, &C::method);         \
-    return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
+    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).

api/rtp_receiver_interface.h

@@ -120,8 +120,8 @@ class RTC_EXPORT RtpReceiverInterface : public rtc::RefCountInterface {
 // 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)
+BEGIN_SIGNALING_PROXY_MAP(RtpReceiver)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+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)

api/rtp_sender_interface.h

@@ -104,8 +104,8 @@ class RTC_EXPORT RtpSenderInterface : public rtc::RefCountInterface {
 // 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)
+BEGIN_SIGNALING_PROXY_MAP(RtpSender)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD1(bool, SetTrack, MediaStreamTrackInterface*)
 PROXY_CONSTMETHOD0(rtc::scoped_refptr<MediaStreamTrackInterface>, track)
 PROXY_CONSTMETHOD0(rtc::scoped_refptr<DtlsTransportInterface>, dtls_transport)

api/video_track_source_proxy.h

@@ -21,25 +21,25 @@ namespace webrtc {
 // 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,
+PROXY_WORKER_METHOD2(void,
                      AddOrUpdateSink,
                      rtc::VideoSinkInterface<VideoFrame>*,
                      const rtc::VideoSinkWants&)
-PROXY_SECONDARY_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
+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_WORKER_METHOD0(void, GenerateKeyFrame)
-PROXY_SECONDARY_METHOD1(void,
+PROXY_WORKER_METHOD1(void,
                      AddEncodedSink,
                      rtc::VideoSinkInterface<RecordableEncodedFrame>*)
-PROXY_SECONDARY_METHOD1(void,
+PROXY_WORKER_METHOD1(void,
                      RemoveEncodedSink,
                      rtc::VideoSinkInterface<RecordableEncodedFrame>*)
 END_PROXY_MAP()

pc/dtmf_sender.h

@@ -99,9 +99,9 @@ class DtmfSender : public DtmfSenderInterface, public sigslot::has_slots<> {
 };
 
 // Define proxy for DtmfSenderInterface.
-BEGIN_PRIMARY_PROXY_MAP(DtmfSender)
+BEGIN_SIGNALING_PROXY_MAP(DtmfSender)
 
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD1(void, RegisterObserver, DtmfSenderObserverInterface*)
 PROXY_METHOD0(void, UnregisterObserver)
 PROXY_METHOD0(bool, CanInsertDtmf)

pc/jitter_buffer_delay_proxy.h

@@ -20,10 +20,10 @@
 namespace webrtc {
 
 BEGIN_PROXY_MAP(JitterBufferDelay)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD2(void, OnStart, cricket::Delayable*, uint32_t)
 PROXY_METHOD0(void, OnStop)
-PROXY_SECONDARY_METHOD1(void, Set, absl::optional<double>)
+PROXY_WORKER_METHOD1(void, Set, absl::optional<double>)
 END_PROXY_MAP()
 
 }  // namespace webrtc

pc/proxy_unittest.cc

@@ -64,20 +64,20 @@ class Fake : public FakeInterface {
 
 // Proxies for the test interface.
 BEGIN_PROXY_MAP(Fake)
-PROXY_SECONDARY_THREAD_DESTRUCTOR()
+PROXY_WORKER_THREAD_DESTRUCTOR()
 PROXY_METHOD0(void, VoidMethod0)
 PROXY_METHOD0(std::string, Method0)
 PROXY_CONSTMETHOD0(std::string, ConstMethod0)
-PROXY_SECONDARY_METHOD1(std::string, Method1, std::string)
+PROXY_WORKER_METHOD1(std::string, Method1, std::string)
 PROXY_CONSTMETHOD1(std::string, ConstMethod1, std::string)
-PROXY_SECONDARY_METHOD2(std::string, Method2, std::string, std::string)
+PROXY_WORKER_METHOD2(std::string, Method2, std::string, std::string)
 END_PROXY_MAP()
 
 // Preprocessor hack to get a proxy class a name different than FakeProxy.
 #define FakeProxy FakeSignalingProxy
 #define FakeProxyWithInternal FakeSignalingProxyWithInternal
-BEGIN_PRIMARY_PROXY_MAP(Fake)
+BEGIN_SIGNALING_PROXY_MAP(Fake)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD0(void, VoidMethod0)
 PROXY_METHOD0(std::string, Method0)
 PROXY_CONSTMETHOD0(std::string, ConstMethod0)
@@ -270,7 +270,7 @@ class Foo : public FooInterface {
 };
 
 BEGIN_OWNED_PROXY_MAP(Foo)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD0(void, Bar)
 END_PROXY_MAP()
 

pc/rtp_data_channel.cc

@@ -34,8 +34,8 @@ int GenerateUniqueId() {
 }
 
 // Define proxy for DataChannelInterface.
-BEGIN_PRIMARY_PROXY_MAP(DataChannel)
+BEGIN_SIGNALING_PROXY_MAP(DataChannel)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD1(void, RegisterObserver, DataChannelObserver*)
 PROXY_METHOD0(void, UnregisterObserver)
 BYPASS_PROXY_CONSTMETHOD0(std::string, label)

pc/rtp_transceiver.h

@@ -264,9 +264,9 @@ class RtpTransceiver final
   const std::function<void()> on_negotiation_needed_;
 };
 
-BEGIN_PRIMARY_PROXY_MAP(RtpTransceiver)
+BEGIN_SIGNALING_PROXY_MAP(RtpTransceiver)
 
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 BYPASS_PROXY_CONSTMETHOD0(cricket::MediaType, media_type)
 PROXY_CONSTMETHOD0(absl::optional<std::string>, mid)
 PROXY_CONSTMETHOD0(rtc::scoped_refptr<RtpSenderInterface>, sender)

pc/sctp_data_channel.cc

@@ -38,8 +38,8 @@ int GenerateUniqueId() {
 }
 
 // Define proxy for DataChannelInterface.
-BEGIN_PRIMARY_PROXY_MAP(DataChannel)
+BEGIN_SIGNALING_PROXY_MAP(DataChannel)
-PROXY_PRIMARY_THREAD_DESTRUCTOR()
+PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD1(void, RegisterObserver, DataChannelObserver*)
 PROXY_METHOD0(void, UnregisterObserver)
 BYPASS_PROXY_CONSTMETHOD0(std::string, label)