Adding some features to proxy.h, and restructuring the macros.
New features are:
- Invoke a destructor on the worker thread.
- Make proxy wrapper for a non-refcounted object.
- Ability to use unique_ptrs (as arguments or return values).
These features are needed by this CL:
https://codereview.webrtc.org/2632613002/
BUG=None
Review-Url: https://codereview.webrtc.org/2628343003
Cr-Commit-Position: refs/heads/master@{#16151}
diff --git a/webrtc/api/proxy_unittest.cc b/webrtc/api/proxy_unittest.cc
index 193fb29..148b742 100644
--- a/webrtc/api/proxy_unittest.cc
+++ b/webrtc/api/proxy_unittest.cc
@@ -37,7 +37,7 @@
virtual std::string Method2(std::string s1, std::string s2) = 0;
protected:
- ~FakeInterface() {}
+ virtual ~FakeInterface() {}
};
// Implementation of the test interface.
@@ -46,6 +46,8 @@
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 @@
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 @@
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 @@
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 @@
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