1 // Copyright 2017 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 "remoting/protocol/fake_message_pipe.h"
6
7 #include <utility>
8
9 #include "base/bind.h"
10 #include "base/location.h"
11 #include "base/threading/thread_task_runner_handle.h"
12 #include "remoting/base/compound_buffer.h"
13 #include "remoting/protocol/fake_message_pipe_wrapper.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15 #include "third_party/protobuf/src/google/protobuf/message_lite.h"
16
17 namespace remoting {
18 namespace protocol {
19
FakeMessagePipe(bool asynchronous)20 FakeMessagePipe::FakeMessagePipe(bool asynchronous)
21 : asynchronous_(asynchronous) {}
22
23 FakeMessagePipe::~FakeMessagePipe() = default;
24
Wrap()25 std::unique_ptr<FakeMessagePipeWrapper> FakeMessagePipe::Wrap() {
26 return std::make_unique<FakeMessagePipeWrapper>(this);
27 }
28
Start(EventHandler * event_handler)29 void FakeMessagePipe::Start(EventHandler* event_handler) {
30 ASSERT_TRUE(event_handler_ == nullptr);
31 ASSERT_TRUE(event_handler != nullptr);
32 event_handler_ = event_handler;
33 }
34
Send(google::protobuf::MessageLite * message,base::OnceClosure done)35 void FakeMessagePipe::Send(google::protobuf::MessageLite* message,
36 base::OnceClosure done) {
37 if (asynchronous_) {
38 base::ThreadTaskRunnerHandle::Get()->PostTask(
39 FROM_HERE,
40 base::BindOnce(
41 [](FakeMessagePipe* me, google::protobuf::MessageLite* message,
42 base::OnceClosure done) {
43 me->SendImpl(message, std::move(done));
44 },
45 base::Unretained(this), base::Unretained(message),
46 std::move(done)));
47 return;
48 }
49 SendImpl(message, std::move(done));
50 }
51
Receive(std::unique_ptr<CompoundBuffer> message)52 void FakeMessagePipe::Receive(std::unique_ptr<CompoundBuffer> message) {
53 if (asynchronous_) {
54 base::ThreadTaskRunnerHandle::Get()->PostTask(
55 FROM_HERE,
56 base::BindOnce(
57 [](FakeMessagePipe* me, std::unique_ptr<CompoundBuffer> message) {
58 me->ReceiveImpl(std::move(message));
59 },
60 base::Unretained(this), std::move(message)));
61 return;
62 }
63
64 ReceiveImpl(std::move(message));
65 }
66
OpenPipe()67 void FakeMessagePipe::OpenPipe() {
68 if (asynchronous_) {
69 base::ThreadTaskRunnerHandle::Get()->PostTask(
70 FROM_HERE,
71 base::BindOnce([](FakeMessagePipe* me) { me->OpenPipeImpl(); },
72 base::Unretained(this)));
73 return;
74 }
75
76 OpenPipeImpl();
77 }
78
ClosePipe()79 void FakeMessagePipe::ClosePipe() {
80 if (asynchronous_) {
81 base::ThreadTaskRunnerHandle::Get()->PostTask(
82 FROM_HERE,
83 base::BindOnce([](FakeMessagePipe* me) { me->ClosePipeImpl(); },
84 base::Unretained(this)));
85 return;
86 }
87
88 ClosePipeImpl();
89 }
90
SendImpl(google::protobuf::MessageLite * message,base::OnceClosure done)91 void FakeMessagePipe::SendImpl(google::protobuf::MessageLite* message,
92 base::OnceClosure done) {
93 ASSERT_TRUE(pipe_opened_);
94
95 std::string message_string;
96 message->SerializeToString(&message_string);
97 sent_messages_.push(message_string);
98
99 if (done) {
100 std::move(done).Run();
101 }
102 }
103
ReceiveImpl(std::unique_ptr<CompoundBuffer> message)104 void FakeMessagePipe::ReceiveImpl(std::unique_ptr<CompoundBuffer> message) {
105 ASSERT_TRUE(pipe_opened_);
106 ASSERT_TRUE(event_handler_ != nullptr);
107 if (message) {
108 message->Lock();
109 }
110 event_handler_->OnMessageReceived(std::move(message));
111 }
112
OpenPipeImpl()113 void FakeMessagePipe::OpenPipeImpl() {
114 ASSERT_FALSE(pipe_opened_);
115 ASSERT_TRUE(event_handler_ != nullptr);
116 pipe_opened_ = true;
117 event_handler_->OnMessagePipeOpen();
118 }
119
ClosePipeImpl()120 void FakeMessagePipe::ClosePipeImpl() {
121 ASSERT_TRUE(pipe_opened_);
122 ASSERT_TRUE(event_handler_ != nullptr);
123 pipe_opened_ = false;
124 event_handler_->OnMessagePipeClosed();
125 }
126
127 } // namespace protocol
128 } // namespace remoting
129