OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "remoting/protocol/connection_tester.h" | 5 #include "remoting/protocol/connection_tester.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/message_loop/message_loop.h" | 8 #include "base/message_loop/message_loop.h" |
9 #include "base/threading/thread_task_runner_handle.h" | 9 #include "base/threading/thread_task_runner_handle.h" |
10 #include "net/base/io_buffer.h" | 10 #include "net/base/io_buffer.h" |
(...skipping 242 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
253 bad_packets_received_++; | 253 bad_packets_received_++; |
254 } else { | 254 } else { |
255 if (memcmp(read_buffer_->data(), sent_packets_[packet_id]->data(), | 255 if (memcmp(read_buffer_->data(), sent_packets_[packet_id]->data(), |
256 message_size_) != 0) | 256 message_size_) != 0) |
257 bad_packets_received_++; | 257 bad_packets_received_++; |
258 } | 258 } |
259 } | 259 } |
260 } | 260 } |
261 } | 261 } |
262 | 262 |
263 class MessagePipeConnectionTester::MessageSender | |
264 : public MessagePipe::EventHandler { | |
265 public: | |
266 MessageSender(MessagePipe* pipe, int message_size, int message_count) | |
267 : pipe_(pipe), | |
268 message_size_(message_size), | |
269 message_count_(message_count) {} | |
270 | |
271 void Start() { pipe_->Start(this); } | |
272 | |
273 const std::vector<std::unique_ptr<VideoPacket>>& sent_messages() { | |
274 return sent_messages_; | |
275 } | |
276 | |
277 // MessagePipe::EventHandler interface. | |
278 void OnMessagePipeOpen() override { | |
279 for (int i = 0; i < message_count_; ++i) { | |
280 std::unique_ptr<VideoPacket> message(new VideoPacket()); | |
281 message->mutable_data()->resize(message_size_); | |
282 for (int p = 0; p < message_size_; ++p) { | |
283 message->mutable_data()[0] = static_cast<char>(i + p); | |
284 } | |
285 pipe_->Send(message.get(), base::Closure()); | |
286 sent_messages_.push_back(std::move(message)); | |
287 } | |
288 } | |
289 void OnMessageReceived(std::unique_ptr<CompoundBuffer> message) override { | |
290 NOTREACHED(); | |
291 } | |
292 void OnMessagePipeClosed() override { NOTREACHED(); } | |
293 | |
294 private: | |
295 MessagePipe* pipe_; | |
296 int message_size_; | |
297 int message_count_; | |
298 | |
299 std::vector<std::unique_ptr<VideoPacket>> sent_messages_; | |
300 }; | |
301 | |
263 MessagePipeConnectionTester::MessagePipeConnectionTester( | 302 MessagePipeConnectionTester::MessagePipeConnectionTester( |
303 MessagePipe* host_pipe, | |
264 MessagePipe* client_pipe, | 304 MessagePipe* client_pipe, |
joedow
2017/03/17 15:13:28
The order of host/client pipe args was changed in
Sergey Ulanov
2017/03/17 18:18:22
Done. I swapped it here to match the order in the
| |
265 MessagePipe* host_pipe, | |
266 int message_size, | 305 int message_size, |
267 int message_count) | 306 int message_count) |
268 : host_pipe_(host_pipe), | 307 : client_pipe_(client_pipe), |
269 client_pipe_(client_pipe), | 308 sender_(new MessageSender(host_pipe, message_size, message_count)) {} |
270 message_size_(message_size), | 309 |
271 message_count_(message_count) {} | |
272 MessagePipeConnectionTester::~MessagePipeConnectionTester() {} | 310 MessagePipeConnectionTester::~MessagePipeConnectionTester() {} |
273 | 311 |
274 void MessagePipeConnectionTester::RunAndCheckResults() { | 312 void MessagePipeConnectionTester::RunAndCheckResults() { |
275 host_pipe_->Start(this); | 313 sender_->Start(); |
276 } | 314 client_pipe_->Start(this); |
277 | |
278 void MessagePipeConnectionTester::OnMessagePipeOpen() { | |
279 for (int i = 0; i < message_count_; ++i) { | |
280 std::unique_ptr<VideoPacket> message(new VideoPacket()); | |
281 message->mutable_data()->resize(message_size_); | |
282 for (int p = 0; p < message_size_; ++p) { | |
283 message->mutable_data()[0] = static_cast<char>(i + p); | |
284 } | |
285 client_pipe_->Send(message.get(), base::Closure()); | |
286 sent_messages_.push_back(std::move(message)); | |
287 } | |
288 | 315 |
289 run_loop_.Run(); | 316 run_loop_.Run(); |
290 | 317 |
291 ASSERT_EQ(sent_messages_.size(), received_messages_.size()); | 318 ASSERT_EQ(sender_->sent_messages().size(), received_messages_.size()); |
292 for (size_t i = 0; i < sent_messages_.size(); ++i) { | 319 for (size_t i = 0; i < sender_->sent_messages().size(); ++i) { |
293 EXPECT_TRUE(sent_messages_[i]->data() == received_messages_[i]->data()); | 320 EXPECT_TRUE(sender_->sent_messages()[i]->data() == |
321 received_messages_[i]->data()); | |
294 } | 322 } |
295 } | 323 } |
296 | 324 |
325 void MessagePipeConnectionTester::OnMessagePipeOpen() {} | |
326 | |
297 void MessagePipeConnectionTester::OnMessageReceived( | 327 void MessagePipeConnectionTester::OnMessageReceived( |
298 std::unique_ptr<CompoundBuffer> message) { | 328 std::unique_ptr<CompoundBuffer> message) { |
299 received_messages_.push_back(ParseMessage<VideoPacket>(message.get())); | 329 received_messages_.push_back(ParseMessage<VideoPacket>(message.get())); |
300 if (received_messages_.size() >= sent_messages_.size()) { | 330 if (received_messages_.size() >= sender_->sent_messages().size()) { |
301 run_loop_.Quit(); | 331 run_loop_.Quit(); |
302 } | 332 } |
303 } | 333 } |
304 | 334 |
305 void MessagePipeConnectionTester::OnMessagePipeClosed() { | 335 void MessagePipeConnectionTester::OnMessagePipeClosed() { |
306 run_loop_.Quit(); | 336 run_loop_.Quit(); |
307 FAIL(); | 337 FAIL(); |
308 } | 338 } |
309 | 339 |
310 } // namespace protocol | 340 } // namespace protocol |
311 } // namespace remoting | 341 } // namespace remoting |
OLD | NEW |