Adding some features to proxy.h, and restructuring the macros.

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 193fb298a281ddd681ce0decb6cb057a3b1bafea..148b74210e34e60b75b069ae670d65e0e62fde82 100644
--- a/webrtc/api/proxy_unittest.cc
+++ b/webrtc/api/proxy_unittest.cc
@@ -37,7 +37,7 @@ class FakeInterface : public rtc::RefCountInterface {
   virtual std::string Method2(std::string s1, std::string s2) = 0;
 
  protected:
-  ~FakeInterface() {}
+  virtual ~FakeInterface() {}
 };
 
 // Implementation of the test interface.
@@ -46,6 +46,8 @@ class Fake : public FakeInterface {
   static rtc::scoped_refptr<Fake> Create() {
     return new rtc::RefCountedObject<Fake>();
   }
+  // Used to verify destructor is called on the correct thread.
+  MOCK_METHOD0(Destroy, void());
 
   MOCK_METHOD0(VoidMethod0, void());
   MOCK_METHOD0(Method0, std::string());
@@ -58,30 +60,32 @@ class Fake : public FakeInterface {
 
  protected:
   Fake() {}
-  ~Fake() {}
+  ~Fake() { Destroy(); }
 };
 
 // Proxies for the test interface.
 BEGIN_PROXY_MAP(Fake)
+  PROXY_WORKER_THREAD_DESTRUCTOR()
   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()
+END_PROXY_MAP()
 
 // Preprocessor hack to get a proxy class a name different than FakeProxy.
 #define FakeProxy FakeSignalingProxy
 #define FakeProxyWithInternal FakeSignalingProxyWithInternal
 BEGIN_SIGNALING_PROXY_MAP(Fake)
+  PROXY_SIGNALING_THREAD_DESTRUCTOR()
   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_SIGNALING_PROXY()
+END_PROXY_MAP()
 #undef FakeProxy
 
 class SignalingProxyTest : public testing::Test {
@@ -104,6 +108,15 @@ class SignalingProxyTest : public testing::Test {
   rtc::scoped_refptr<Fake> fake_;
 };
 
+TEST_F(SignalingProxyTest, SignalingThreadDestructor) {
+  EXPECT_CALL(*fake_, Destroy())
+      .Times(Exactly(1))
+      .WillOnce(
+          InvokeWithoutArgs(this, &SignalingProxyTest::CheckSignalingThread));
+  fake_ = nullptr;
+  fake_signaling_proxy_ = nullptr;
+}
+
 TEST_F(SignalingProxyTest, VoidMethod0) {
   EXPECT_CALL(*fake_, VoidMethod0())
       .Times(Exactly(1))
@@ -161,25 +174,38 @@ TEST_F(SignalingProxyTest, Method2) {
   EXPECT_EQ("Method2", fake_signaling_proxy_->Method2(arg1, arg2));
 }
 
-class ProxyTest : public SignalingProxyTest {
+class ProxyTest : public testing::Test {
  public:
   // Checks that the functions are called on the right thread.
+  void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_->IsCurrent()); }
   void CheckWorkerThread() { EXPECT_TRUE(worker_thread_->IsCurrent()); }
 
  protected:
   void SetUp() override {
-    SignalingProxyTest::SetUp();
+    signaling_thread_.reset(new rtc::Thread());
     worker_thread_.reset(new rtc::Thread());
+    ASSERT_TRUE(signaling_thread_->Start());
     ASSERT_TRUE(worker_thread_->Start());
+    fake_ = Fake::Create();
     fake_proxy_ = FakeProxy::Create(signaling_thread_.get(),
                                     worker_thread_.get(), fake_.get());
   }
 
  protected:
+  std::unique_ptr<rtc::Thread> signaling_thread_;
   std::unique_ptr<rtc::Thread> worker_thread_;
   rtc::scoped_refptr<FakeInterface> fake_proxy_;
+  rtc::scoped_refptr<Fake> fake_;
 };
 
+TEST_F(ProxyTest, WorkerThreadDestructor) {
+  EXPECT_CALL(*fake_, Destroy())
+      .Times(Exactly(1))
+      .WillOnce(InvokeWithoutArgs(this, &ProxyTest::CheckWorkerThread));
+  fake_ = nullptr;
+  fake_proxy_ = nullptr;
+}
+
 TEST_F(ProxyTest, VoidMethod0) {
   EXPECT_CALL(*fake_, VoidMethod0())
       .Times(Exactly(1))
@@ -236,4 +262,51 @@ TEST_F(ProxyTest, WorkerMethod2) {
   EXPECT_EQ("Method2", fake_proxy_->Method2(arg1, arg2));
 }
 
+// Interface for testing OWNED_PROXY_MAP.
+class FooInterface {
+ public:
+  virtual ~FooInterface() {}
+  virtual void Bar() = 0;
+};
+
+class Foo : public FooInterface {
+ public:
+  Foo() {}
+  MOCK_METHOD0(Bar, void());
+};
+
+BEGIN_OWNED_PROXY_MAP(Foo)
+  PROXY_SIGNALING_THREAD_DESTRUCTOR()
+  PROXY_METHOD0(void, Bar)
+END_PROXY_MAP()
+
+class OwnedProxyTest : public testing::Test {
+ public:
+  OwnedProxyTest()
+      : foo_(new Foo()),
+        foo_proxy_(
+            FooProxy::Create(&signaling_thread_, &worker_thread_, foo_)) {
+    signaling_thread_.Start();
+    worker_thread_.Start();
+  }
+
+  void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_.IsCurrent()); }
+  void CheckWorkerThread() { EXPECT_TRUE(worker_thread_.IsCurrent()); }
+
+ protected:
+  rtc::Thread signaling_thread_;
+  rtc::Thread worker_thread_;
+  Foo* foo_;  // Owned by foo_proxy_, not this class.
+  std::unique_ptr<FooInterface> foo_proxy_;
+};
+
+// Just tests that a method can be invoked using an "owned proxy" (as opposed
+// to normal ref-counted version).
+TEST_F(OwnedProxyTest, BasicTest) {
+  EXPECT_CALL(*foo_, Bar())
+      .Times(Exactly(1))
+      .WillOnce(InvokeWithoutArgs(this, &OwnedProxyTest::CheckSignalingThread));
+  foo_proxy_->Bar();
+}
+
 }  // namespace webrtc