diff --git a/pc/proxy.h b/pc/proxy.h
index 565ae80175..85cb70d34c 100644
--- a/pc/proxy.h
+++ b/pc/proxy.h
@@ -202,61 +202,66 @@ class ConstMethodCall : public QueuedTask {
 #define PROXY_STRINGIZE(x) PROXY_STRINGIZE_IMPL(x)
 
 // 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;    \
-  template <class INTERNAL_CLASS>                         \
-  class c##ProxyWithInternal : public c##Interface {      \
-   protected:                                             \
-    static constexpr char proxy_name_[] = #c "Proxy";     \
-    typedef c##Interface C;                               \
-                                                          \
-   public:                                                \
-    const INTERNAL_CLASS* internal() const { return c_; } \
-    INTERNAL_CLASS* internal() { return c_; }
+#define PROXY_MAP_BOILERPLATE(class_name)                              \
+  template <class INTERNAL_CLASS>                                      \
+  class class_name##ProxyWithInternal;                                 \
+  typedef class_name##ProxyWithInternal<class_name##Interface>         \
+      class_name##Proxy;                                               \
+  template <class INTERNAL_CLASS>                                      \
+  class class_name##ProxyWithInternal : public class_name##Interface { \
+   protected:                                                          \
+    static constexpr char proxy_name_[] = #class_name "Proxy";         \
+    typedef class_name##Interface C;                                   \
+                                                                       \
+   public:                                                             \
+    const INTERNAL_CLASS* internal() const { return c(); }             \
+    INTERNAL_CLASS* internal() { return c(); }
 
 // clang-format off
 // clang-format would put the semicolon alone,
 // leading to a presubmit error (cpplint.py)
-#define END_PROXY_MAP(c)          \
-  };                              \
-  template <class INTERNAL_CLASS> \
-  constexpr char c##ProxyWithInternal<INTERNAL_CLASS>::proxy_name_[];
+#define END_PROXY_MAP(class_name)                                       \
+  };                                                                    \
+  template <class INTERNAL_CLASS>                                       \
+  constexpr char class_name##ProxyWithInternal<INTERNAL_CLASS>::proxy_name_[];
 // 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:                                                              \
+#define PRIMARY_PROXY_MAP_BOILERPLATE(class_name)            \
+ protected:                                                  \
+  class_name##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)                               \
- protected:                                                              \
-  c##ProxyWithInternal(rtc::Thread* primary_thread,                      \
-                       rtc::Thread* secondary_thread, INTERNAL_CLASS* c) \
-      : primary_thread_(primary_thread),                                 \
-        secondary_thread_(secondary_thread),                             \
-        c_(c) {}                                                         \
-                                                                         \
- private:                                                                \
-  mutable rtc::Thread* primary_thread_;                                  \
+#define SECONDARY_PROXY_MAP_BOILERPLATE(class_name)            \
+ protected:                                                    \
+  class_name##ProxyWithInternal(rtc::Thread* primary_thread,   \
+                                rtc::Thread* secondary_thread, \
+                                INTERNAL_CLASS* c)             \
+      : primary_thread_(primary_thread),                       \
+        secondary_thread_(secondary_thread),                   \
+        c_(c) {}                                               \
+                                                               \
+ private:                                                      \
+  mutable rtc::Thread* primary_thread_;                        \
   mutable rtc::Thread* secondary_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() {                            \
-    MethodCall<c##ProxyWithInternal, void> call(       \
-        this, &c##ProxyWithInternal::DestroyInternal); \
-    call.Marshal(RTC_FROM_HERE, destructor_thread());  \
-  }                                                    \
-                                                       \
- private:                                              \
-  void DestroyInternal() { c_ = nullptr; }             \
+#define REFCOUNTED_PROXY_MAP_BOILERPLATE(class_name)            \
+ protected:                                                     \
+  ~class_name##ProxyWithInternal() {                            \
+    MethodCall<class_name##ProxyWithInternal, void> call(       \
+        this, &class_name##ProxyWithInternal::DestroyInternal); \
+    call.Marshal(RTC_FROM_HERE, destructor_thread());           \
+  }                                                             \
+                                                                \
+ private:                                                       \
+  const INTERNAL_CLASS* c() const { return c_.get(); }          \
+  INTERNAL_CLASS* c() { return c_.get(); }                      \
+  void DestroyInternal() { c_ = nullptr; }                      \
   rtc::scoped_refptr<INTERNAL_CLASS> c_;
 
 // Note: This doesn't use a unique_ptr, because it intends to handle a corner
@@ -264,50 +269,54 @@ class ConstMethodCall : public QueuedTask {
 // this proxy object. If relying on a unique_ptr to delete the object, its
 // inner pointer would be set to null before this reentrant callback would have
 // a chance to run, resulting in a segfault.
-#define OWNED_PROXY_MAP_BOILERPLATE(c)                 \
- public:                                               \
-  ~c##ProxyWithInternal() {                            \
-    MethodCall<c##ProxyWithInternal, void> call(       \
-        this, &c##ProxyWithInternal::DestroyInternal); \
-    call.Marshal(RTC_FROM_HERE, destructor_thread());  \
-  }                                                    \
-                                                       \
- private:                                              \
-  void DestroyInternal() { delete c_; }                \
+#define OWNED_PROXY_MAP_BOILERPLATE(class_name)                 \
+ public:                                                        \
+  ~class_name##ProxyWithInternal() {                            \
+    MethodCall<class_name##ProxyWithInternal, void> call(       \
+        this, &class_name##ProxyWithInternal::DestroyInternal); \
+    call.Marshal(RTC_FROM_HERE, destructor_thread());           \
+  }                                                             \
+                                                                \
+ private:                                                       \
+  const INTERNAL_CLASS* c() const { return c_; }                \
+  INTERNAL_CLASS* c() { return c_; }                            \
+  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 rtc::make_ref_counted<c##ProxyWithInternal>(primary_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 rtc::make_ref_counted<c##ProxyWithInternal>(primary_thread,       \
-                                                       secondary_thread, c); \
-  }
-
-#define BEGIN_OWNED_PROXY_MAP(c)                                   \
-  PROXY_MAP_BOILERPLATE(c)                                         \
-  SECONDARY_PROXY_MAP_BOILERPLATE(c)                               \
-  OWNED_PROXY_MAP_BOILERPLATE(c)                                   \
+#define BEGIN_PRIMARY_PROXY_MAP(class_name)                        \
+  PROXY_MAP_BOILERPLATE(class_name)                                \
+  PRIMARY_PROXY_MAP_BOILERPLATE(class_name)                        \
+  REFCOUNTED_PROXY_MAP_BOILERPLATE(class_name)                     \
  public:                                                           \
-  static std::unique_ptr<c##Interface> Create(                     \
+  static rtc::scoped_refptr<class_name##ProxyWithInternal> Create( \
+      rtc::Thread* primary_thread, INTERNAL_CLASS* c) {            \
+    return rtc::make_ref_counted<class_name##ProxyWithInternal>(   \
+        primary_thread, c);                                        \
+  }
+
+#define BEGIN_PROXY_MAP(class_name)                                \
+  PROXY_MAP_BOILERPLATE(class_name)                                \
+  SECONDARY_PROXY_MAP_BOILERPLATE(class_name)                      \
+  REFCOUNTED_PROXY_MAP_BOILERPLATE(class_name)                     \
+ public:                                                           \
+  static rtc::scoped_refptr<class_name##ProxyWithInternal> Create( \
       rtc::Thread* primary_thread, rtc::Thread* secondary_thread,  \
-      std::unique_ptr<INTERNAL_CLASS> c) {                         \
-    return std::unique_ptr<c##Interface>(new c##ProxyWithInternal( \
-        primary_thread, secondary_thread, c.release()));           \
+      INTERNAL_CLASS* c) {                                         \
+    return rtc::make_ref_counted<class_name##ProxyWithInternal>(   \
+        primary_thread, secondary_thread, c);                      \
+  }
+
+#define BEGIN_OWNED_PROXY_MAP(class_name)                                   \
+  PROXY_MAP_BOILERPLATE(class_name)                                         \
+  SECONDARY_PROXY_MAP_BOILERPLATE(class_name)                               \
+  OWNED_PROXY_MAP_BOILERPLATE(class_name)                                   \
+ public:                                                                    \
+  static std::unique_ptr<class_name##Interface> Create(                     \
+      rtc::Thread* primary_thread, rtc::Thread* secondary_thread,           \
+      std::unique_ptr<INTERNAL_CLASS> c) {                                  \
+    return std::unique_ptr<class_name##Interface>(                          \
+        new class_name##ProxyWithInternal(primary_thread, secondary_thread, \
+                                          c.release()));                    \
   }
 
 #define PROXY_PRIMARY_THREAD_DESTRUCTOR()                            \
@@ -339,124 +348,124 @@ class ConstMethodCall : public QueuedTask {
 #define PROXY_METHOD0(r, method)                         \
   r method() override {                                  \
     TRACE_BOILERPLATE(method);                           \
-    MethodCall<C, r> call(c_, &C::method);               \
+    MethodCall<C, r> call(c(), &C::method);              \
     return call.Marshal(RTC_FROM_HERE, primary_thread_); \
   }
 
 #define PROXY_CONSTMETHOD0(r, method)                    \
   r method() const override {                            \
     TRACE_BOILERPLATE(method);                           \
-    ConstMethodCall<C, r> call(c_, &C::method);          \
+    ConstMethodCall<C, r> call(c(), &C::method);         \
     return call.Marshal(RTC_FROM_HERE, primary_thread_); \
   }
 
-#define PROXY_METHOD1(r, method, t1)                          \
-  r method(t1 a1) override {                                  \
-    TRACE_BOILERPLATE(method);                                \
-    MethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
-    return call.Marshal(RTC_FROM_HERE, primary_thread_);      \
+#define PROXY_METHOD1(r, method, t1)                           \
+  r method(t1 a1) override {                                   \
+    TRACE_BOILERPLATE(method);                                 \
+    MethodCall<C, r, t1> call(c(), &C::method, std::move(a1)); \
+    return call.Marshal(RTC_FROM_HERE, primary_thread_);       \
   }
 
-#define PROXY_CONSTMETHOD1(r, method, t1)                          \
-  r method(t1 a1) const override {                                 \
-    TRACE_BOILERPLATE(method);                                     \
-    ConstMethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
-    return call.Marshal(RTC_FROM_HERE, primary_thread_);           \
+#define PROXY_CONSTMETHOD1(r, method, t1)                           \
+  r method(t1 a1) const override {                                  \
+    TRACE_BOILERPLATE(method);                                      \
+    ConstMethodCall<C, r, t1> call(c(), &C::method, std::move(a1)); \
+    return call.Marshal(RTC_FROM_HERE, primary_thread_);            \
   }
 
-#define PROXY_METHOD2(r, method, t1, t2)                         \
-  r method(t1 a1, t2 a2) override {                              \
-    TRACE_BOILERPLATE(method);                                   \
-    MethodCall<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
-                                  std::move(a2));                \
-    return call.Marshal(RTC_FROM_HERE, primary_thread_);         \
+#define PROXY_METHOD2(r, method, t1, t2)                          \
+  r method(t1 a1, t2 a2) override {                               \
+    TRACE_BOILERPLATE(method);                                    \
+    MethodCall<C, r, t1, t2> call(c(), &C::method, std::move(a1), \
+                                  std::move(a2));                 \
+    return call.Marshal(RTC_FROM_HERE, primary_thread_);          \
   }
 
-#define PROXY_METHOD3(r, method, t1, t2, t3)                         \
-  r method(t1 a1, t2 a2, t3 a3) override {                           \
-    TRACE_BOILERPLATE(method);                                       \
-    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_);             \
+#define PROXY_METHOD3(r, method, t1, t2, t3)                          \
+  r method(t1 a1, t2 a2, t3 a3) override {                            \
+    TRACE_BOILERPLATE(method);                                        \
+    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_);              \
   }
 
-#define PROXY_METHOD4(r, method, t1, t2, t3, t4)                         \
-  r method(t1 a1, t2 a2, t3 a3, t4 a4) override {                        \
-    TRACE_BOILERPLATE(method);                                           \
-    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_);                 \
+#define PROXY_METHOD4(r, method, t1, t2, t3, t4)                          \
+  r method(t1 a1, t2 a2, t3 a3, t4 a4) override {                         \
+    TRACE_BOILERPLATE(method);                                            \
+    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_);                  \
   }
 
-#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5)                         \
-  r method(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) override {                     \
-    TRACE_BOILERPLATE(method);                                               \
-    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_);                     \
+#define PROXY_METHOD5(r, method, t1, t2, t3, t4, t5)                          \
+  r method(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) override {                      \
+    TRACE_BOILERPLATE(method);                                                \
+    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_);                      \
   }
 
 // Define methods which should be invoked on the secondary thread.
 #define PROXY_SECONDARY_METHOD0(r, method)                 \
   r method() override {                                    \
     TRACE_BOILERPLATE(method);                             \
-    MethodCall<C, r> call(c_, &C::method);                 \
+    MethodCall<C, r> call(c(), &C::method);                \
     return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
   }
 
 #define PROXY_SECONDARY_CONSTMETHOD0(r, method)            \
   r method() const override {                              \
     TRACE_BOILERPLATE(method);                             \
-    ConstMethodCall<C, r> call(c_, &C::method);            \
+    ConstMethodCall<C, r> call(c(), &C::method);           \
     return call.Marshal(RTC_FROM_HERE, secondary_thread_); \
   }
 
-#define PROXY_SECONDARY_METHOD1(r, method, t1)                \
-  r method(t1 a1) override {                                  \
-    TRACE_BOILERPLATE(method);                                \
-    MethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
-    return call.Marshal(RTC_FROM_HERE, secondary_thread_);    \
+#define PROXY_SECONDARY_METHOD1(r, method, t1)                 \
+  r method(t1 a1) override {                                   \
+    TRACE_BOILERPLATE(method);                                 \
+    MethodCall<C, r, t1> call(c(), &C::method, std::move(a1)); \
+    return call.Marshal(RTC_FROM_HERE, secondary_thread_);     \
   }
 
-#define PROXY_SECONDARY_CONSTMETHOD1(r, method, t1)                \
-  r method(t1 a1) const override {                                 \
-    TRACE_BOILERPLATE(method);                                     \
-    ConstMethodCall<C, r, t1> call(c_, &C::method, std::move(a1)); \
-    return call.Marshal(RTC_FROM_HERE, secondary_thread_);         \
+#define PROXY_SECONDARY_CONSTMETHOD1(r, method, t1)                 \
+  r method(t1 a1) const override {                                  \
+    TRACE_BOILERPLATE(method);                                      \
+    ConstMethodCall<C, r, t1> call(c(), &C::method, std::move(a1)); \
+    return call.Marshal(RTC_FROM_HERE, secondary_thread_);          \
   }
 
-#define PROXY_SECONDARY_METHOD2(r, method, t1, t2)               \
-  r method(t1 a1, t2 a2) override {                              \
-    TRACE_BOILERPLATE(method);                                   \
-    MethodCall<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
-                                  std::move(a2));                \
-    return call.Marshal(RTC_FROM_HERE, secondary_thread_);       \
+#define PROXY_SECONDARY_METHOD2(r, method, t1, t2)                \
+  r method(t1 a1, t2 a2) override {                               \
+    TRACE_BOILERPLATE(method);                                    \
+    MethodCall<C, r, t1, t2> call(c(), &C::method, std::move(a1), \
+                                  std::move(a2));                 \
+    return call.Marshal(RTC_FROM_HERE, secondary_thread_);        \
   }
 
-#define PROXY_SECONDARY_CONSTMETHOD2(r, method, t1, t2)               \
-  r method(t1 a1, t2 a2) const override {                             \
+#define PROXY_SECONDARY_CONSTMETHOD2(r, method, t1, t2)                \
+  r method(t1 a1, t2 a2) const override {                              \
+    TRACE_BOILERPLATE(method);                                         \
+    ConstMethodCall<C, r, t1, t2> call(c(), &C::method, std::move(a1), \
+                                       std::move(a2));                 \
+    return call.Marshal(RTC_FROM_HERE, secondary_thread_);             \
+  }
+
+#define PROXY_SECONDARY_METHOD3(r, method, t1, t2, t3)                \
+  r method(t1 a1, t2 a2, t3 a3) override {                            \
     TRACE_BOILERPLATE(method);                                        \
-    ConstMethodCall<C, r, t1, t2> call(c_, &C::method, std::move(a1), \
-                                       std::move(a2));                \
+    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_);            \
   }
 
-#define PROXY_SECONDARY_METHOD3(r, method, t1, t2, t3)               \
-  r method(t1 a1, t2 a2, t3 a3) override {                           \
-    TRACE_BOILERPLATE(method);                                       \
-    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_);           \
-  }
-
-#define PROXY_SECONDARY_CONSTMETHOD3(r, method, t1, t2)                   \
-  r method(t1 a1, t2 a2, t3 a3) const override {                          \
-    TRACE_BOILERPLATE(method);                                            \
-    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_);                \
+#define PROXY_SECONDARY_CONSTMETHOD3(r, method, t1, t2)                    \
+  r method(t1 a1, t2 a2, t3 a3) const override {                           \
+    TRACE_BOILERPLATE(method);                                             \
+    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_);                 \
   }
 
 // For use when returning purely const state (set during construction).