Rename BEGIN_PROXY_MAP --> BEGIN_SIGNALLING_PROXY_MAP.

webrtc/api/proxy_unittest.cc

Index: webrtc/api/proxy_unittest.cc
diff --git a/webrtc/api/proxy_unittest.cc b/webrtc/api/proxy_unittest.cc
index 2578e9b4b10d1d83c8f668f0634716ad43798514..6f2e260687b969ac5cc500365b05c19ff3b7df70 100644
--- a/webrtc/api/proxy_unittest.cc
+++ b/webrtc/api/proxy_unittest.cc
@@ -40,16 +40,6 @@ class FakeInterface : public rtc::RefCountInterface {
   ~FakeInterface() {}
 };
 
-// Proxy for the test interface.
-BEGIN_PROXY_MAP(Fake)
-  PROXY_METHOD0(void, VoidMethod0)
-  PROXY_METHOD0(std::string, Method0)
-  PROXY_CONSTMETHOD0(std::string, ConstMethod0)
-  PROXY_METHOD1(std::string, Method1, std::string)
-  PROXY_CONSTMETHOD1(std::string, ConstMethod1, std::string)
-  PROXY_METHOD2(std::string, Method2, std::string, std::string)
-END_PROXY()
-
 // Implementation of the test interface.
 class Fake : public FakeInterface {
  public:
@@ -71,60 +61,156 @@ class Fake : public FakeInterface {
   ~Fake() {}
 };
 
-class ProxyTest: public testing::Test {
+// Proxies for the test interface.
+BEGIN_PROXY_MAP(Fake)
+  PROXY_METHOD0(void, VoidMethod0)
+  PROXY_METHOD0(std::string, Method0)
+  PROXY_CONSTMETHOD0(std::string, ConstMethod0)
+  PROXY_WORKER_METHOD1(std::string, Method1, std::string)
+  PROXY_CONSTMETHOD1(std::string, ConstMethod1, std::string)
+  PROXY_WORKER_METHOD2(std::string, Method2, std::string, std::string)
+END_PROXY()
+
+// Preprocessor hack to get a proxy class a name different than FakeProxy.
+#define FakeProxy FakeSignallingProxy
+BEGIN_SIGNALLING_PROXY_MAP(Fake)

[perkj_webrtc, 2016/04/12 07:12:14]

Sorry for late discovery. /s Signalling -> Signaling

[nisse-webrtc, 2016/04/12 07:38:55]

Fixed. Still 17 occurences elsewhere in the code, mostly in comments, but also
rtc::HttpServer::Connection::signalling_.

+  PROXY_METHOD0(void, VoidMethod0)
+  PROXY_METHOD0(std::string, Method0)
+  PROXY_CONSTMETHOD0(std::string, ConstMethod0)
+  PROXY_METHOD1(std::string, Method1, std::string)
+  PROXY_CONSTMETHOD1(std::string, ConstMethod1, std::string)
+  PROXY_METHOD2(std::string, Method2, std::string, std::string)
+END_SIGNALLING_PROXY()
+#undef FakeProxy
+
+class SignallingProxyTest : public testing::Test {
  public:
-  // Checks that the functions is called on the |signaling_thread_|.
-  void CheckThread() {
-    EXPECT_EQ(rtc::Thread::Current(), signaling_thread_.get());
-  }
+  // Checks that the functions are called on the right thread.
+  void CheckSignallingThread() { EXPECT_TRUE(signaling_thread_->IsCurrent()); }
 
  protected:
-  virtual void SetUp() {
+  void SetUp() override {
     signaling_thread_.reset(new rtc::Thread());
     ASSERT_TRUE(signaling_thread_->Start());
     fake_ = Fake::Create();
-    fake_proxy_ = FakeProxy::Create(signaling_thread_.get(), fake_.get());
+    fake_signalling_proxy_ =
+        FakeSignallingProxy::Create(signaling_thread_.get(), fake_.get());
   }
 
  protected:
   rtc::scoped_ptr<rtc::Thread> signaling_thread_;
-  rtc::scoped_refptr<FakeInterface> fake_proxy_;
+  rtc::scoped_refptr<FakeInterface> fake_signalling_proxy_;

[perkj_webrtc, 2016/04/12 07:12:14]

fake_signaling_....

   rtc::scoped_refptr<Fake> fake_;
 };
 
+TEST_F(SignallingProxyTest, VoidMethod0) {
+  EXPECT_CALL(*fake_, VoidMethod0())
+      .Times(Exactly(1))
+      .WillOnce(
+          InvokeWithoutArgs(this, &SignallingProxyTest::CheckSignallingThread));
+  fake_signalling_proxy_->VoidMethod0();
+}
+
+TEST_F(SignallingProxyTest, Method0) {
+  EXPECT_CALL(*fake_, Method0())
+      .Times(Exactly(1))
+      .WillOnce(DoAll(
+          InvokeWithoutArgs(this, &SignallingProxyTest::CheckSignallingThread),
+          Return("Method0")));
+  EXPECT_EQ("Method0", fake_signalling_proxy_->Method0());
+}
+
+TEST_F(SignallingProxyTest, ConstMethod0) {
+  EXPECT_CALL(*fake_, ConstMethod0())
+      .Times(Exactly(1))
+      .WillOnce(DoAll(
+          InvokeWithoutArgs(this, &SignallingProxyTest::CheckSignallingThread),
+          Return("ConstMethod0")));
+  EXPECT_EQ("ConstMethod0", fake_signalling_proxy_->ConstMethod0());
+}
+
+TEST_F(SignallingProxyTest, Method1) {
+  const std::string arg1 = "arg1";
+  EXPECT_CALL(*fake_, Method1(arg1))
+      .Times(Exactly(1))
+      .WillOnce(DoAll(
+          InvokeWithoutArgs(this, &SignallingProxyTest::CheckSignallingThread),
+          Return("Method1")));
+  EXPECT_EQ("Method1", fake_signalling_proxy_->Method1(arg1));
+}
+
+TEST_F(SignallingProxyTest, ConstMethod1) {
+  const std::string arg1 = "arg1";
+  EXPECT_CALL(*fake_, ConstMethod1(arg1))
+      .Times(Exactly(1))
+      .WillOnce(DoAll(
+          InvokeWithoutArgs(this, &SignallingProxyTest::CheckSignallingThread),
+          Return("ConstMethod1")));
+  EXPECT_EQ("ConstMethod1", fake_signalling_proxy_->ConstMethod1(arg1));
+}
+
+TEST_F(SignallingProxyTest, Method2) {
+  const std::string arg1 = "arg1";
+  const std::string arg2 = "arg2";
+  EXPECT_CALL(*fake_, Method2(arg1, arg2))
+      .Times(Exactly(1))
+      .WillOnce(DoAll(
+          InvokeWithoutArgs(this, &SignallingProxyTest::CheckSignallingThread),
+          Return("Method2")));
+  EXPECT_EQ("Method2", fake_signalling_proxy_->Method2(arg1, arg2));
+}
+
+class ProxyTest : public SignallingProxyTest {

[perkj_webrtc, 2016/04/12 07:12:14]

nit: I prefer a totally separate test that does not inherit from
SignallingProxyTest just because its easier to read.

[nisse-webrtc, 2016/04/12 07:38:55]

I think this is a simple enough case of inheritance. I was first going to use
the same class for all the tests. But decided to create a new derived class
mainly because I prefer 

  ProxyTest.Method1
  ProxySignalingTest.Method1

over

  ProxyTest.Method1
  ProxyTest.SignalingMethod1

in the test log. I'll eliminate the inheritance if you insist.

+ public:
+  // Checks that the functions are called on the right thread.
+  void CheckWorkerThread() { EXPECT_TRUE(worker_thread_->IsCurrent()); }
+
+ protected:
+  void SetUp() override {
+    SignallingProxyTest::SetUp();
+    worker_thread_.reset(new rtc::Thread());
+    ASSERT_TRUE(worker_thread_->Start());
+    fake_proxy_ = FakeProxy::Create(signaling_thread_.get(),
+                                    worker_thread_.get(), fake_.get());
+  }
+
+ protected:
+  rtc::scoped_ptr<rtc::Thread> worker_thread_;
+  rtc::scoped_refptr<FakeInterface> fake_proxy_;
+};
+
 TEST_F(ProxyTest, VoidMethod0) {
   EXPECT_CALL(*fake_, VoidMethod0())
-            .Times(Exactly(1))
-            .WillOnce(InvokeWithoutArgs(this, &ProxyTest::CheckThread));
+      .Times(Exactly(1))
+      .WillOnce(InvokeWithoutArgs(this, &ProxyTest::CheckSignallingThread));
   fake_proxy_->VoidMethod0();
 }
 
 TEST_F(ProxyTest, Method0) {
   EXPECT_CALL(*fake_, Method0())
-            .Times(Exactly(1))
-            .WillOnce(
-                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
-                      Return("Method0")));
+      .Times(Exactly(1))
+      .WillOnce(
+          DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckSignallingThread),
+                Return("Method0")));
   EXPECT_EQ("Method0",
             fake_proxy_->Method0());
 }
 
 TEST_F(ProxyTest, ConstMethod0) {
   EXPECT_CALL(*fake_, ConstMethod0())
-            .Times(Exactly(1))
-            .WillOnce(
-                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
-                      Return("ConstMethod0")));
+      .Times(Exactly(1))
+      .WillOnce(
+          DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckSignallingThread),
+                Return("ConstMethod0")));
   EXPECT_EQ("ConstMethod0",
             fake_proxy_->ConstMethod0());
 }
 
-TEST_F(ProxyTest, Method1) {
+TEST_F(ProxyTest, WorkerMethod1) {
   const std::string arg1 = "arg1";
   EXPECT_CALL(*fake_, Method1(arg1))
-            .Times(Exactly(1))
-            .WillOnce(
-                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
+      .Times(Exactly(1))
+      .WillOnce(DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckWorkerThread),
                       Return("Method1")));
   EXPECT_EQ("Method1", fake_proxy_->Method1(arg1));
 }
@@ -132,20 +218,19 @@ TEST_F(ProxyTest, Method1) {
 TEST_F(ProxyTest, ConstMethod1) {
   const std::string arg1 = "arg1";
   EXPECT_CALL(*fake_, ConstMethod1(arg1))
-            .Times(Exactly(1))
-            .WillOnce(
-                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
-                      Return("ConstMethod1")));
+      .Times(Exactly(1))
+      .WillOnce(
+          DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckSignallingThread),
+                Return("ConstMethod1")));
   EXPECT_EQ("ConstMethod1", fake_proxy_->ConstMethod1(arg1));
 }
 
-TEST_F(ProxyTest, Method2) {
+TEST_F(ProxyTest, WorkerMethod2) {
   const std::string arg1 = "arg1";
   const std::string arg2 = "arg2";
   EXPECT_CALL(*fake_, Method2(arg1, arg2))
-            .Times(Exactly(1))
-            .WillOnce(
-                DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckThread),
+      .Times(Exactly(1))
+      .WillOnce(DoAll(InvokeWithoutArgs(this, &ProxyTest::CheckWorkerThread),
                       Return("Method2")));
   EXPECT_EQ("Method2", fake_proxy_->Method2(arg1, arg2));
 }