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
3 // found in the LICENSE file.
4
5 #include "media/remoting/rpc_broker.h"
6
7 #include <memory>
8 #include <vector>
9
10 #include "base/bind.h"
11 #include "base/callback_helpers.h"
12 #include "base/macros.h"
13 #include "base/memory/ref_counted.h"
14 #include "base/run_loop.h"
15 #include "base/test/task_environment.h"
16 #include "media/remoting/media_remoting_rpc.pb.h"
17 #include "testing/gmock/include/gmock/gmock.h"
18 #include "testing/gtest/include/gtest/gtest.h"
19
20 using testing::_;
21 using testing::Invoke;
22 using testing::Return;
23
24 namespace media {
25 namespace remoting {
26
27 namespace {
28
29 class FakeMessageSender {
30 public:
FakeMessageSender()31 FakeMessageSender()
32 : received_rpc_(new pb::RpcMessage()),
33 has_sent_message_(false),
34 send_count_(0) {}
35 ~FakeMessageSender() = default;
36
OnSendMessageAndQuit(std::unique_ptr<std::vector<uint8_t>> message)37 void OnSendMessageAndQuit(std::unique_ptr<std::vector<uint8_t>> message) {
38 EXPECT_TRUE(
39 received_rpc_->ParseFromArray(message->data(), message->size()));
40 has_sent_message_ = true;
41 }
42
OnSendMessage(std::unique_ptr<std::vector<uint8_t>> message)43 void OnSendMessage(std::unique_ptr<std::vector<uint8_t>> message) {
44 ++send_count_;
45 }
GetWeakPtr()46 base::WeakPtr<FakeMessageSender> GetWeakPtr() {
47 return weak_factory_.GetWeakPtr();
48 }
has_sent_message() const49 bool has_sent_message() const { return has_sent_message_; }
received_rpc() const50 const pb::RpcMessage* received_rpc() const { return received_rpc_.get(); }
send_count() const51 int send_count() const { return send_count_; }
52
53 private:
54 std::unique_ptr<pb::RpcMessage> received_rpc_;
55 bool has_sent_message_;
56 int send_count_;
57 base::WeakPtrFactory<FakeMessageSender> weak_factory_{this};
58
59 DISALLOW_COPY_AND_ASSIGN(FakeMessageSender);
60 };
61
62 class FakeMessageReceiver {
63 public:
FakeMessageReceiver()64 FakeMessageReceiver() : has_received_message_(false) {}
65 ~FakeMessageReceiver() = default;
66
67 // RpcBroker::MessageReceiver implementation.
OnReceivedRpc(std::unique_ptr<pb::RpcMessage> message)68 void OnReceivedRpc(std::unique_ptr<pb::RpcMessage> message) {
69 received_rpc_ = std::move(message);
70 has_received_message_++;
71 }
72
OnSendMessage(std::unique_ptr<std::vector<uint8_t>> message)73 void OnSendMessage(std::unique_ptr<std::vector<uint8_t>> message) {}
GetWeakPtr()74 base::WeakPtr<FakeMessageReceiver> GetWeakPtr() {
75 return weak_factory_.GetWeakPtr();
76 }
has_received_message() const77 int has_received_message() const { return has_received_message_; }
received_rpc() const78 const pb::RpcMessage* received_rpc() const { return received_rpc_.get(); }
79
80 private:
81 std::unique_ptr<pb::RpcMessage> received_rpc_;
82 int has_received_message_;
83 base::WeakPtrFactory<FakeMessageReceiver> weak_factory_{this};
84
85 DISALLOW_COPY_AND_ASSIGN(FakeMessageReceiver);
86 };
87
88 } // namespace
89
90 class RpcBrokerTest : public testing::Test {
91 protected:
SetUp()92 void SetUp() override {}
93 };
94
TEST_F(RpcBrokerTest,TestProcessMessageFromRemoteRegistered)95 TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteRegistered) {
96 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver());
97 ASSERT_FALSE(fake_receiver->has_received_message());
98
99 // Creates receiver RpcBroker and registers FakeMessageReceiver.
100 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::BindRepeating(
101 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr())));
102
103 int handle = rpc_broker->GetUniqueHandle();
104 const RpcBroker::ReceiveMessageCallback receive_callback =
105 base::BindRepeating(&FakeMessageReceiver::OnReceivedRpc,
106 fake_receiver->GetWeakPtr());
107 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback);
108
109 std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage());
110 rpc->set_handle(handle);
111 rpc_broker->ProcessMessageFromRemote(std::move(rpc));
112 ASSERT_EQ(fake_receiver->has_received_message(), 1);
113 }
114
TEST_F(RpcBrokerTest,TestProcessMessageFromRemoteUnregistered)115 TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteUnregistered) {
116 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver());
117 ASSERT_FALSE(fake_receiver->has_received_message());
118
119 // Creates receiver RpcBroker and registers FakeMessageReceiver.
120 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::BindRepeating(
121 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr())));
122
123 int handle = rpc_broker->GetUniqueHandle();
124 const RpcBroker::ReceiveMessageCallback receive_callback =
125 base::BindRepeating(&FakeMessageReceiver::OnReceivedRpc,
126 fake_receiver->GetWeakPtr());
127 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback);
128
129 std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage());
130 rpc_broker->UnregisterMessageReceiverCallback(handle);
131 rpc_broker->ProcessMessageFromRemote(std::move(rpc));
132 ASSERT_EQ(fake_receiver->has_received_message(), 0);
133 }
134
TEST_F(RpcBrokerTest,TestSendMessageToRemote)135 TEST_F(RpcBrokerTest, TestSendMessageToRemote) {
136 base::test::SingleThreadTaskEnvironment task_environment;
137
138 std::unique_ptr<FakeMessageSender> fake_sender(new FakeMessageSender());
139 ASSERT_FALSE(fake_sender->has_sent_message());
140
141 // Creates RpcBroker and set message callback.
142 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::BindRepeating(
143 &FakeMessageSender::OnSendMessage, fake_sender->GetWeakPtr())));
144
145 for (int i = 0; i < 10; ++i) {
146 std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage());
147 rpc_broker->SendMessageToRemote(std::move(rpc));
148 }
149 EXPECT_EQ(10, fake_sender->send_count());
150 }
151
TEST_F(RpcBrokerTest,RpcBrokerSendMessageCallback)152 TEST_F(RpcBrokerTest, RpcBrokerSendMessageCallback) {
153 base::test::SingleThreadTaskEnvironment task_environment;
154
155 std::unique_ptr<FakeMessageSender> fake_sender(new FakeMessageSender());
156 ASSERT_FALSE(fake_sender->has_sent_message());
157
158 // Creates RpcBroker and set message callback.
159 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::BindRepeating(
160 &FakeMessageSender::OnSendMessageAndQuit, fake_sender->GetWeakPtr())));
161
162 // Sends RPC message.
163 std::unique_ptr<pb::RpcMessage> sent_rpc(new pb::RpcMessage());
164 sent_rpc->set_handle(2);
165 sent_rpc->set_proc(pb::RpcMessage::RPC_R_SETVOLUME);
166 sent_rpc->set_double_value(2.2);
167 rpc_broker->SendMessageToRemote(std::move(sent_rpc));
168
169 // Wait for messge callback.
170 // message_loop->Run();
171 base::RunLoop().RunUntilIdle();
172
173 // Check if received message is identical to the one sent earlier.
174 ASSERT_TRUE(fake_sender->has_sent_message());
175 const auto* received_rpc = fake_sender->received_rpc();
176 ASSERT_EQ(2, received_rpc->handle());
177 ASSERT_EQ(pb::RpcMessage::RPC_R_SETVOLUME, received_rpc->proc());
178 ASSERT_EQ(2.2, received_rpc->double_value());
179 }
180
TEST_F(RpcBrokerTest,RpcBrokerProcessMessageWithRegisteredHandle)181 TEST_F(RpcBrokerTest, RpcBrokerProcessMessageWithRegisteredHandle) {
182 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver());
183 ASSERT_FALSE(fake_receiver->has_received_message());
184
185 // Creates receiver RpcBroker and registers FakeMessageReceiver.
186 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::BindRepeating(
187 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr())));
188 int handle = rpc_broker->GetUniqueHandle();
189 const RpcBroker::ReceiveMessageCallback receive_callback =
190 base::BindRepeating(&FakeMessageReceiver::OnReceivedRpc,
191 fake_receiver->GetWeakPtr());
192 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback);
193
194 // Generates RPC message with handle value |handle| and send it to receover
195 // RpcBroker to process.
196 std::unique_ptr<pb::RpcMessage> sent_rpc(new pb::RpcMessage());
197 sent_rpc->set_handle(handle);
198 sent_rpc->set_proc(pb::RpcMessage::RPC_R_SETVOLUME);
199 sent_rpc->set_double_value(2.2);
200 rpc_broker->ProcessMessageFromRemote(std::move(sent_rpc));
201
202 // Checks if received message is identical to the one sent earlier.
203 ASSERT_TRUE(fake_receiver->has_received_message());
204 auto* received_rpc = fake_receiver->received_rpc();
205 ASSERT_EQ(handle, received_rpc->handle());
206 ASSERT_EQ(pb::RpcMessage::RPC_R_SETVOLUME, received_rpc->proc());
207 ASSERT_EQ(2.2, received_rpc->double_value());
208
209 // Unregisters FakeMessageReceiver.
210 rpc_broker->UnregisterMessageReceiverCallback(handle);
211 }
212
TEST_F(RpcBrokerTest,RpcBrokerProcessMessageWithUnregisteredHandle)213 TEST_F(RpcBrokerTest, RpcBrokerProcessMessageWithUnregisteredHandle) {
214 std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver());
215 ASSERT_FALSE(fake_receiver->has_received_message());
216
217 // Creates receiver RpcBroker and registers FakeMessageReceiver.
218 std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::BindRepeating(
219 &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr())));
220 int handle = rpc_broker->GetUniqueHandle();
221 const RpcBroker::ReceiveMessageCallback receive_callback =
222 base::BindRepeating(&FakeMessageReceiver::OnReceivedRpc,
223 fake_receiver->GetWeakPtr());
224 rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback);
225
226 // Generates RPC message with handle value |handle| and send it to receover
227 // RpcBroker to process.
228 std::unique_ptr<pb::RpcMessage> sent_rpc(new pb::RpcMessage());
229 int different_handle = handle + 1;
230 sent_rpc->set_handle(different_handle);
231 sent_rpc->set_proc(pb::RpcMessage::RPC_R_SETVOLUME);
232 sent_rpc->set_double_value(2.2);
233 rpc_broker->ProcessMessageFromRemote(std::move(sent_rpc));
234
235 // Check if received message is identical to the one sent earlier.
236 ASSERT_FALSE(fake_receiver->has_received_message());
237
238 // Unregisters FakeMessageReceiver.
239 rpc_broker->UnregisterMessageReceiverCallback(handle);
240 }
241
242 } // namespace remoting
243 } // namespace media
244