Rename BEGIN_PROXY_MAP --> BEGIN_SIGNALLING_PROXY_MAP.

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.
  */
 
 // This file contains Macros for creating proxies for webrtc MediaStream and
 // PeerConnection classes.
 
 //
 // Example usage:
 //
 // class TestInterface : public rtc::RefCountInterface {
 //  public:
 //   std::string FooA() = 0;
 //   std::string FooB(bool arg1) const = 0;
-//   std::string FooC(bool arg1)= 0;
+//   std::string FooC(bool arg1) = 0;
 //  };
 //
 // Note that return types can not be a const reference.
 //
 // class Test : public TestInterface {
 // ... implementation of the interface.
 // };
 //
 // BEGIN_PROXY_MAP(Test)
 //   PROXY_METHOD0(std::string, FooA)
 //   PROXY_CONSTMETHOD1(std::string, FooB, arg1)
-//   PROXY_METHOD1(std::string, FooC, arg1)
+//   PROXY_WORKER_METHOD1(std::string, FooC, arg1)
 // END_PROXY()
 //
-// The proxy can be created using TestProxy::Create(Thread*, TestInterface*).
+// where the 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_SIGNALING_PROXY_MAP is unaware of
+// the worker thread, and invokes all methods on the signaling thread.
 
 #ifndef WEBRTC_API_PROXY_H_
 #define WEBRTC_API_PROXY_H_
 
 #include "webrtc/base/event.h"
 #include "webrtc/base/thread.h"
 
 namespace webrtc {
 
 template <typename R>
@@ skipping 241 matching lines @@
   C* c_;
   Method m_;
   ReturnType<R> r_;
   T1 a1_;
   T2 a2_;
   T3 a3_;
   T4 a4_;
   T5 a5_;
 };
 
-// TODO(nisse): Rename this to {BEGIN|END}_SIGNALLING_PROXY_MAP, and
-// the below to {BEGIN|END}_PROXY_MAP. Also rename the class to
-// c##SignallingProxy.
-#define BEGIN_PROXY_MAP(c)                                                \
+#define BEGIN_SIGNALING_PROXY_MAP(c)                                     \
   class c##Proxy : public c##Interface {                                  \
    protected:                                                             \
     typedef c##Interface C;                                               \
     c##Proxy(rtc::Thread* signaling_thread, C* c)                         \
       : signaling_thread_(signaling_thread), c_(c) {}                     \
     ~c##Proxy() {                                                         \
-      MethodCall0<c##Proxy, void> call(this, &c##Proxy::Release_s);       \
+      MethodCall0<c##Proxy, void> call(                                   \
+          this, &c##Proxy::Release_s);                                    \
       call.Marshal(signaling_thread_);                                    \
     }                                                                     \
                                                                           \
    public:                                                                \
     static rtc::scoped_refptr<C> Create(rtc::Thread* signaling_thread, C* c) { \
-      return new rtc::RefCountedObject<c##Proxy>(signaling_thread, c);    \
+      return new rtc::RefCountedObject<c##Proxy>(                         \
+          signaling_thread, c);                                           \
     }
 
-#define BEGIN_WORKER_PROXY_MAP(c)                                       \
+#define BEGIN_PROXY_MAP(c)                                              \
   class c##Proxy : public c##Interface {                                \
    protected:                                                           \
     typedef c##Interface C;                                             \
     c##Proxy(rtc::Thread* signaling_thread, rtc::Thread* worker_thread, C* c) \
       : signaling_thread_(signaling_thread),                            \
         worker_thread_(worker_thread),                                  \
         c_(c) {}                                                        \
     ~c##Proxy() {                                                       \
       MethodCall0<c##Proxy, void> call(this, &c##Proxy::Release_s);     \
       call.Marshal(signaling_thread_);                                  \
@@ skipping 62 matching lines @@
     MethodCall1<C, r, t1> call(c_.get(), &C::method, a1); \
     return call.Marshal(worker_thread_);                  \
   }
 
 #define PROXY_WORKER_METHOD2(r, method, t1, t2)                   \
   r method(t1 a1, t2 a2) override {                               \
     MethodCall2<C, r, t1, t2> call(c_.get(), &C::method, a1, a2); \
     return call.Marshal(worker_thread_);                          \
   }
 
-#define END_PROXY() \
+#define END_SIGNALING_PROXY() \
    private:\
     void Release_s() {\
       c_ = NULL;\
     }\
     mutable rtc::Thread* signaling_thread_;\
     rtc::scoped_refptr<C> c_;\
-  };\
+  };
 
-#define END_WORKER_PROXY()                           \
+#define END_PROXY()                                  \
    private:                                          \
     void Release_s() {                               \
       c_ = NULL;                                     \
     }                                                \
     mutable rtc::Thread* signaling_thread_;          \
     mutable rtc::Thread* worker_thread_;             \
     rtc::scoped_refptr<C> c_;                        \
   };                                                 \
 
 }  // namespace webrtc
 
 #endif  //  WEBRTC_API_PROXY_H_