Adding "adapter" ORTC objects on top of ChannelManager/BaseChannel/etc.

webrtc/api/proxy.h

 /*
  *  Copyright 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 420 matching lines @@
   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 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##Interface> Create(rtc::Thread* signaling_thread, \
+                                              rtc::Thread* worker_thread,    \
+                                              INTERNAL_CLASS* c) {           \
+    return std::unique_ptr<c##Interface>(                                    \
+        new c##ProxyWithInternal(signaling_thread, worker_thread, c));       \
   }
 
 #define PROXY_SIGNALING_THREAD_DESTRUCTOR()                            \
  private:                                                              \
   rtc::Thread* destructor_thread() const { return signaling_thread_; } \
                                                                        \
  public:  // NOLINTNEXTLINE
 
 #define PROXY_WORKER_THREAD_DESTRUCTOR()                            \
  private:                                                           \
@@ skipping 87 matching lines @@
     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 PROXY_WORKER_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, worker_thread_);                     \
+  }
+
+#define PROXY_WORKER_CONSTMETHOD3(r, method, t1, t2)                        \
+  r method(t1 a1, t2 a2, t3 a3) const override {                            \
+    ConstMethodCall3<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, worker_thread_);                     \
+  }
+
 }  // namespace webrtc
 
 #endif  //  WEBRTC_API_PROXY_H_