OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/remoting/rpc/rpc_broker.h" | 5 #include "media/remoting/rpc_broker.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
11 #include "base/callback_helpers.h" | 11 #include "base/callback_helpers.h" |
12 #include "base/macros.h" | 12 #include "base/macros.h" |
13 #include "base/memory/ref_counted.h" | 13 #include "base/memory/ref_counted.h" |
14 #include "base/message_loop/message_loop.h" | 14 #include "base/message_loop/message_loop.h" |
15 #include "base/run_loop.h" | 15 #include "base/run_loop.h" |
16 #include "media/remoting/remoting_rpc_message.pb.h" | 16 #include "media/remoting/rpc.pb.h" |
17 #include "testing/gmock/include/gmock/gmock.h" | 17 #include "testing/gmock/include/gmock/gmock.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
19 | 19 |
20 using testing::_; | 20 using testing::_; |
21 using testing::Invoke; | 21 using testing::Invoke; |
22 using testing::Return; | 22 using testing::Return; |
23 | 23 |
24 namespace media { | 24 namespace media { |
25 namespace remoting { | 25 namespace remoting { |
26 | 26 |
| 27 namespace { |
| 28 |
27 class FakeMessageSender { | 29 class FakeMessageSender { |
28 public: | 30 public: |
29 FakeMessageSender() | 31 FakeMessageSender() |
30 : received_rpc_(new pb::RpcMessage()), | 32 : received_rpc_(new pb::RpcMessage()), |
31 has_sent_message_(false), | 33 has_sent_message_(false), |
32 send_count_(0), | 34 send_count_(0), |
33 weak_factory_(this) {} | 35 weak_factory_(this) {} |
34 ~FakeMessageSender() {} | 36 ~FakeMessageSender() {} |
35 | 37 |
36 void OnSendMessageAndQuit(std::unique_ptr<std::vector<uint8_t>> message) { | 38 void OnSendMessageAndQuit(std::unique_ptr<std::vector<uint8_t>> message) { |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
77 const pb::RpcMessage* received_rpc() const { return received_rpc_.get(); } | 79 const pb::RpcMessage* received_rpc() const { return received_rpc_.get(); } |
78 | 80 |
79 private: | 81 private: |
80 std::unique_ptr<pb::RpcMessage> received_rpc_; | 82 std::unique_ptr<pb::RpcMessage> received_rpc_; |
81 int has_received_message_; | 83 int has_received_message_; |
82 base::WeakPtrFactory<FakeMessageReceiver> weak_factory_; | 84 base::WeakPtrFactory<FakeMessageReceiver> weak_factory_; |
83 | 85 |
84 DISALLOW_COPY_AND_ASSIGN(FakeMessageReceiver); | 86 DISALLOW_COPY_AND_ASSIGN(FakeMessageReceiver); |
85 }; | 87 }; |
86 | 88 |
| 89 } // namespace |
| 90 |
87 class RpcBrokerTest : public testing::Test { | 91 class RpcBrokerTest : public testing::Test { |
88 protected: | 92 protected: |
89 void SetUp() override {} | 93 void SetUp() override {} |
90 }; | 94 }; |
91 | 95 |
92 TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteRegistered) { | 96 TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteRegistered) { |
93 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver()); | 97 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver()); |
94 ASSERT_FALSE(fake_receiver->has_received_message()); | 98 ASSERT_FALSE(fake_receiver->has_received_message()); |
95 | 99 |
96 // Creates receiver RpcBroker and registers FakeMessageReceiver. | 100 // Creates receiver RpcBroker and registers FakeMessageReceiver. |
97 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind( | 101 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind( |
98 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr()))); | 102 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr()))); |
99 | 103 |
100 int handle = rpc_broker->GetUniqueHandle(); | 104 int handle = rpc_broker->GetUniqueHandle(); |
101 const remoting::RpcBroker::ReceiveMessageCallback receive_callback = | 105 const RpcBroker::ReceiveMessageCallback receive_callback = base::Bind( |
102 base::Bind(&FakeMessageReceiver::OnReceivedRpc, | 106 &FakeMessageReceiver::OnReceivedRpc, fake_receiver->GetWeakPtr()); |
103 fake_receiver->GetWeakPtr()); | |
104 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback); | 107 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback); |
105 | 108 |
106 std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage()); | 109 std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage()); |
107 rpc->set_handle(handle); | 110 rpc->set_handle(handle); |
108 rpc_broker->ProcessMessageFromRemote(std::move(rpc)); | 111 rpc_broker->ProcessMessageFromRemote(std::move(rpc)); |
109 ASSERT_EQ(fake_receiver->has_received_message(), 1); | 112 ASSERT_EQ(fake_receiver->has_received_message(), 1); |
110 } | 113 } |
111 | 114 |
112 TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteUnregistered) { | 115 TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteUnregistered) { |
113 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver()); | 116 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver()); |
114 ASSERT_FALSE(fake_receiver->has_received_message()); | 117 ASSERT_FALSE(fake_receiver->has_received_message()); |
115 | 118 |
116 // Creates receiver RpcBroker and registers FakeMessageReceiver. | 119 // Creates receiver RpcBroker and registers FakeMessageReceiver. |
117 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind( | 120 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind( |
118 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr()))); | 121 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr()))); |
119 | 122 |
120 int handle = rpc_broker->GetUniqueHandle(); | 123 int handle = rpc_broker->GetUniqueHandle(); |
121 const remoting::RpcBroker::ReceiveMessageCallback receive_callback = | 124 const RpcBroker::ReceiveMessageCallback receive_callback = base::Bind( |
122 base::Bind(&FakeMessageReceiver::OnReceivedRpc, | 125 &FakeMessageReceiver::OnReceivedRpc, fake_receiver->GetWeakPtr()); |
123 fake_receiver->GetWeakPtr()); | |
124 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback); | 126 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback); |
125 | 127 |
126 std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage()); | 128 std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage()); |
127 rpc_broker->UnregisterMessageReceiverCallback(handle); | 129 rpc_broker->UnregisterMessageReceiverCallback(handle); |
128 rpc_broker->ProcessMessageFromRemote(std::move(rpc)); | 130 rpc_broker->ProcessMessageFromRemote(std::move(rpc)); |
129 ASSERT_EQ(fake_receiver->has_received_message(), 0); | 131 ASSERT_EQ(fake_receiver->has_received_message(), 0); |
130 } | 132 } |
131 | 133 |
132 TEST_F(RpcBrokerTest, TestSendMessageToRemote) { | 134 TEST_F(RpcBrokerTest, TestSendMessageToRemote) { |
133 std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop()); | 135 std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop()); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
176 } | 178 } |
177 | 179 |
178 TEST_F(RpcBrokerTest, RpcBrokerProcessMessageWithRegisteredHandle) { | 180 TEST_F(RpcBrokerTest, RpcBrokerProcessMessageWithRegisteredHandle) { |
179 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver()); | 181 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver()); |
180 ASSERT_FALSE(fake_receiver->has_received_message()); | 182 ASSERT_FALSE(fake_receiver->has_received_message()); |
181 | 183 |
182 // Creates receiver RpcBroker and registers FakeMessageReceiver. | 184 // Creates receiver RpcBroker and registers FakeMessageReceiver. |
183 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind( | 185 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind( |
184 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr()))); | 186 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr()))); |
185 int handle = rpc_broker->GetUniqueHandle(); | 187 int handle = rpc_broker->GetUniqueHandle(); |
186 const remoting::RpcBroker::ReceiveMessageCallback receive_callback = | 188 const RpcBroker::ReceiveMessageCallback receive_callback = base::Bind( |
187 base::Bind(&FakeMessageReceiver::OnReceivedRpc, | 189 &FakeMessageReceiver::OnReceivedRpc, fake_receiver->GetWeakPtr()); |
188 fake_receiver->GetWeakPtr()); | |
189 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback); | 190 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback); |
190 | 191 |
191 // Generates RPC message with handle value |handle| and send it to receover | 192 // Generates RPC message with handle value |handle| and send it to receover |
192 // RpcBroker to process. | 193 // RpcBroker to process. |
193 std::unique_ptr<pb::RpcMessage> sent_rpc(new pb::RpcMessage()); | 194 std::unique_ptr<pb::RpcMessage> sent_rpc(new pb::RpcMessage()); |
194 sent_rpc->set_handle(handle); | 195 sent_rpc->set_handle(handle); |
195 sent_rpc->set_proc(pb::RpcMessage::RPC_R_SETVOLUME); | 196 sent_rpc->set_proc(pb::RpcMessage::RPC_R_SETVOLUME); |
196 sent_rpc->set_double_value(2.2); | 197 sent_rpc->set_double_value(2.2); |
197 rpc_broker->ProcessMessageFromRemote(std::move(sent_rpc)); | 198 rpc_broker->ProcessMessageFromRemote(std::move(sent_rpc)); |
198 | 199 |
199 // Checks if received message is identical to the one sent earlier. | 200 // Checks if received message is identical to the one sent earlier. |
200 ASSERT_TRUE(fake_receiver->has_received_message()); | 201 ASSERT_TRUE(fake_receiver->has_received_message()); |
201 auto* received_rpc = fake_receiver->received_rpc(); | 202 auto* received_rpc = fake_receiver->received_rpc(); |
202 ASSERT_EQ(handle, received_rpc->handle()); | 203 ASSERT_EQ(handle, received_rpc->handle()); |
203 ASSERT_EQ(pb::RpcMessage::RPC_R_SETVOLUME, received_rpc->proc()); | 204 ASSERT_EQ(pb::RpcMessage::RPC_R_SETVOLUME, received_rpc->proc()); |
204 ASSERT_EQ(2.2, received_rpc->double_value()); | 205 ASSERT_EQ(2.2, received_rpc->double_value()); |
205 | 206 |
206 // Unregisters FakeMessageReceiver. | 207 // Unregisters FakeMessageReceiver. |
207 rpc_broker->UnregisterMessageReceiverCallback(handle); | 208 rpc_broker->UnregisterMessageReceiverCallback(handle); |
208 } | 209 } |
209 | 210 |
210 TEST_F(RpcBrokerTest, RpcBrokerProcessMessageWithUnregisteredHandle) { | 211 TEST_F(RpcBrokerTest, RpcBrokerProcessMessageWithUnregisteredHandle) { |
211 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver()); | 212 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver()); |
212 ASSERT_FALSE(fake_receiver->has_received_message()); | 213 ASSERT_FALSE(fake_receiver->has_received_message()); |
213 | 214 |
214 // Creates receiver RpcBroker and registers FakeMessageReceiver. | 215 // Creates receiver RpcBroker and registers FakeMessageReceiver. |
215 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind( | 216 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind( |
216 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr()))); | 217 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr()))); |
217 int handle = rpc_broker->GetUniqueHandle(); | 218 int handle = rpc_broker->GetUniqueHandle(); |
218 const remoting::RpcBroker::ReceiveMessageCallback receive_callback = | 219 const RpcBroker::ReceiveMessageCallback receive_callback = base::Bind( |
219 base::Bind(&FakeMessageReceiver::OnReceivedRpc, | 220 &FakeMessageReceiver::OnReceivedRpc, fake_receiver->GetWeakPtr()); |
220 fake_receiver->GetWeakPtr()); | |
221 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback); | 221 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback); |
222 | 222 |
223 // Generates RPC message with handle value |handle| and send it to receover | 223 // Generates RPC message with handle value |handle| and send it to receover |
224 // RpcBroker to process. | 224 // RpcBroker to process. |
225 std::unique_ptr<pb::RpcMessage> sent_rpc(new pb::RpcMessage()); | 225 std::unique_ptr<pb::RpcMessage> sent_rpc(new pb::RpcMessage()); |
226 int different_handle = handle + 1; | 226 int different_handle = handle + 1; |
227 sent_rpc->set_handle(different_handle); | 227 sent_rpc->set_handle(different_handle); |
228 sent_rpc->set_proc(pb::RpcMessage::RPC_R_SETVOLUME); | 228 sent_rpc->set_proc(pb::RpcMessage::RPC_R_SETVOLUME); |
229 sent_rpc->set_double_value(2.2); | 229 sent_rpc->set_double_value(2.2); |
230 rpc_broker->ProcessMessageFromRemote(std::move(sent_rpc)); | 230 rpc_broker->ProcessMessageFromRemote(std::move(sent_rpc)); |
231 | 231 |
232 // Check if received message is identical to the one sent earlier. | 232 // Check if received message is identical to the one sent earlier. |
233 ASSERT_FALSE(fake_receiver->has_received_message()); | 233 ASSERT_FALSE(fake_receiver->has_received_message()); |
234 | 234 |
235 // Unregisters FakeMessageReceiver. | 235 // Unregisters FakeMessageReceiver. |
236 rpc_broker->UnregisterMessageReceiverCallback(handle); | 236 rpc_broker->UnregisterMessageReceiverCallback(handle); |
237 } | 237 } |
238 | 238 |
239 } // namespace remoting | 239 } // namespace remoting |
240 } // namespace media | 240 } // namespace media |
OLD | NEW |