OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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 <string> | 5 #include <string> |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
| 9 #include "base/callback.h" |
9 #include "base/message_loop.h" | 10 #include "base/message_loop.h" |
10 #include "base/synchronization/waitable_event.h" | 11 #include "base/synchronization/waitable_event.h" |
11 #include "base/threading/thread.h" | 12 #include "base/threading/thread.h" |
12 #include "net/socket/socket.h" | 13 #include "net/socket/socket.h" |
13 #include "remoting/protocol/fake_session.h" | 14 #include "remoting/protocol/fake_session.h" |
14 #include "remoting/protocol/message_reader.h" | 15 #include "remoting/protocol/message_reader.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
16 #include "testing/gmock/include/gmock/gmock.h" | 17 #include "testing/gmock/include/gmock/gmock.h" |
17 #include "third_party/libjingle/source/talk/base/byteorder.h" | 18 #include "third_party/libjingle/source/talk/base/byteorder.h" |
18 | 19 |
19 using testing::_; | 20 using testing::_; |
20 using testing::DoAll; | 21 using testing::DoAll; |
21 using testing::Mock; | 22 using testing::Mock; |
22 using testing::SaveArg; | 23 using testing::SaveArg; |
23 | 24 |
24 namespace remoting { | 25 namespace remoting { |
25 namespace protocol { | 26 namespace protocol { |
26 | 27 |
27 namespace { | 28 namespace { |
28 const char kTestMessage1[] = "Message1"; | 29 const char kTestMessage1[] = "Message1"; |
29 const char kTestMessage2[] = "Message2"; | 30 const char kTestMessage2[] = "Message2"; |
30 | 31 |
31 ACTION(CallDoneTask) { | 32 ACTION(CallDoneTask) { |
32 arg1->Run(); | 33 arg1.Run(); |
33 delete arg1; | |
34 } | 34 } |
35 } | 35 } |
36 | 36 |
37 class MockMessageReceivedCallback { | 37 class MockMessageReceivedCallback { |
38 public: | 38 public: |
39 MOCK_METHOD2(OnMessage, void(CompoundBuffer*, Task*)); | 39 MOCK_METHOD2(OnMessage, void(CompoundBuffer*, const base::Closure&)); |
40 }; | 40 }; |
41 | 41 |
42 class MessageReaderTest : public testing::Test { | 42 class MessageReaderTest : public testing::Test { |
43 public: | 43 public: |
44 MessageReaderTest() | 44 MessageReaderTest() |
45 : other_thread_("SecondTestThread"), | 45 : other_thread_("SecondTestThread"), |
46 run_task_finished_(false, false) { | 46 run_task_finished_(false, false) { |
47 } | 47 } |
48 | 48 |
49 void RunDoneTaskOnOtherThread(CompoundBuffer* buffer, Task* done_task) { | 49 void RunDoneTaskOnOtherThread(CompoundBuffer* buffer, |
| 50 const base::Closure& done_task) { |
50 other_thread_.message_loop()->PostTask( | 51 other_thread_.message_loop()->PostTask( |
51 FROM_HERE, | 52 FROM_HERE, |
52 base::Bind(&MessageReaderTest::RunAndDeleteTask, | 53 base::Bind(&MessageReaderTest::RunAndDeleteTask, |
53 base::Unretained(this), | 54 base::Unretained(this), done_task)); |
54 done_task)); | |
55 } | 55 } |
56 | 56 |
57 protected: | 57 protected: |
58 virtual void SetUp() { | 58 virtual void SetUp() { |
59 reader_ = new MessageReader(); | 59 reader_ = new MessageReader(); |
60 } | 60 } |
61 | 61 |
62 void InitReader() { | 62 void InitReader() { |
63 reader_->Init(&socket_, NewCallback( | 63 reader_->Init(&socket_, base::Bind( |
64 &callback_, &MockMessageReceivedCallback::OnMessage)); | 64 &MockMessageReceivedCallback::OnMessage, base::Unretained(&callback_))); |
65 } | 65 } |
66 | 66 |
67 void AddMessage(const std::string& message) { | 67 void AddMessage(const std::string& message) { |
68 std::string data = std::string(4, ' ') + message; | 68 std::string data = std::string(4, ' ') + message; |
69 talk_base::SetBE32(const_cast<char*>(data.data()), message.size()); | 69 talk_base::SetBE32(const_cast<char*>(data.data()), message.size()); |
70 | 70 |
71 socket_.AppendInputData(data.data(), data.size()); | 71 socket_.AppendInputData(data.data(), data.size()); |
72 } | 72 } |
73 | 73 |
74 bool CompareResult(CompoundBuffer* buffer, const std::string& expected) { | 74 bool CompareResult(CompoundBuffer* buffer, const std::string& expected) { |
75 std::string result(buffer->total_bytes(), ' '); | 75 std::string result(buffer->total_bytes(), ' '); |
76 buffer->CopyTo(const_cast<char*>(result.data()), result.size()); | 76 buffer->CopyTo(const_cast<char*>(result.data()), result.size()); |
77 return result == expected; | 77 return result == expected; |
78 } | 78 } |
79 | 79 |
80 void RunAndDeleteTask(Task* task) { | 80 void RunAndDeleteTask(const base::Closure& task) { |
81 task->Run(); | 81 task.Run(); |
82 delete task; | |
83 run_task_finished_.Signal(); | 82 run_task_finished_.Signal(); |
84 } | 83 } |
85 | 84 |
86 MessageLoop message_loop_; | 85 MessageLoop message_loop_; |
87 base::Thread other_thread_; | 86 base::Thread other_thread_; |
88 base::WaitableEvent run_task_finished_; | 87 base::WaitableEvent run_task_finished_; |
89 scoped_refptr<MessageReader> reader_; | 88 scoped_refptr<MessageReader> reader_; |
90 FakeSocket socket_; | 89 FakeSocket socket_; |
91 MockMessageReceivedCallback callback_; | 90 MockMessageReceivedCallback callback_; |
92 }; | 91 }; |
93 | 92 |
94 // Receive one message and process it with delay | 93 // Receive one message and process it with delay |
95 TEST_F(MessageReaderTest, OneMessage_Delay) { | 94 TEST_F(MessageReaderTest, OneMessage_Delay) { |
96 CompoundBuffer* buffer; | 95 CompoundBuffer* buffer; |
97 Task* done_task; | 96 base::Closure done_task; |
98 | 97 |
99 AddMessage(kTestMessage1); | 98 AddMessage(kTestMessage1); |
100 | 99 |
101 EXPECT_CALL(callback_, OnMessage(_, _)) | 100 EXPECT_CALL(callback_, OnMessage(_, _)) |
102 .Times(1) | 101 .Times(1) |
103 .WillOnce(DoAll(SaveArg<0>(&buffer), | 102 .WillOnce(DoAll(SaveArg<0>(&buffer), |
104 SaveArg<1>(&done_task))); | 103 SaveArg<1>(&done_task))); |
105 | 104 |
106 InitReader(); | 105 InitReader(); |
107 | 106 |
(...skipping 20 matching lines...) Expand all Loading... |
128 .WillOnce(CallDoneTask()); | 127 .WillOnce(CallDoneTask()); |
129 | 128 |
130 InitReader(); | 129 InitReader(); |
131 | 130 |
132 EXPECT_TRUE(socket_.read_pending()); | 131 EXPECT_TRUE(socket_.read_pending()); |
133 } | 132 } |
134 | 133 |
135 // Receive two messages in one packet. | 134 // Receive two messages in one packet. |
136 TEST_F(MessageReaderTest, TwoMessages_Together) { | 135 TEST_F(MessageReaderTest, TwoMessages_Together) { |
137 CompoundBuffer* buffer1; | 136 CompoundBuffer* buffer1; |
138 Task* done_task1; | 137 base::Closure done_task1; |
139 CompoundBuffer* buffer2; | 138 CompoundBuffer* buffer2; |
140 Task* done_task2; | 139 base::Closure done_task2; |
141 | 140 |
142 AddMessage(kTestMessage1); | 141 AddMessage(kTestMessage1); |
143 AddMessage(kTestMessage2); | 142 AddMessage(kTestMessage2); |
144 | 143 |
145 EXPECT_CALL(callback_, OnMessage(_, _)) | 144 EXPECT_CALL(callback_, OnMessage(_, _)) |
146 .Times(2) | 145 .Times(2) |
147 .WillOnce(DoAll(SaveArg<0>(&buffer1), | 146 .WillOnce(DoAll(SaveArg<0>(&buffer1), |
148 SaveArg<1>(&done_task1))) | 147 SaveArg<1>(&done_task1))) |
149 .WillOnce(DoAll(SaveArg<0>(&buffer2), | 148 .WillOnce(DoAll(SaveArg<0>(&buffer2), |
150 SaveArg<1>(&done_task2))); | 149 SaveArg<1>(&done_task2))); |
(...skipping 16 matching lines...) Expand all Loading... |
167 | 166 |
168 RunAndDeleteTask(done_task2); | 167 RunAndDeleteTask(done_task2); |
169 | 168 |
170 EXPECT_TRUE(socket_.read_pending()); | 169 EXPECT_TRUE(socket_.read_pending()); |
171 } | 170 } |
172 | 171 |
173 // Receive two messages in one packet, and process the first one | 172 // Receive two messages in one packet, and process the first one |
174 // instantly. | 173 // instantly. |
175 TEST_F(MessageReaderTest, TwoMessages_Instant) { | 174 TEST_F(MessageReaderTest, TwoMessages_Instant) { |
176 CompoundBuffer* buffer2; | 175 CompoundBuffer* buffer2; |
177 Task* done_task2; | 176 base::Closure done_task2; |
178 | 177 |
179 AddMessage(kTestMessage1); | 178 AddMessage(kTestMessage1); |
180 AddMessage(kTestMessage2); | 179 AddMessage(kTestMessage2); |
181 | 180 |
182 EXPECT_CALL(callback_, OnMessage(_, _)) | 181 EXPECT_CALL(callback_, OnMessage(_, _)) |
183 .Times(2) | 182 .Times(2) |
184 .WillOnce(CallDoneTask()) | 183 .WillOnce(CallDoneTask()) |
185 .WillOnce(DoAll(SaveArg<0>(&buffer2), | 184 .WillOnce(DoAll(SaveArg<0>(&buffer2), |
186 SaveArg<1>(&done_task2))); | 185 SaveArg<1>(&done_task2))); |
187 | 186 |
(...skipping 25 matching lines...) Expand all Loading... |
213 .WillOnce(CallDoneTask()); | 212 .WillOnce(CallDoneTask()); |
214 | 213 |
215 InitReader(); | 214 InitReader(); |
216 | 215 |
217 EXPECT_TRUE(socket_.read_pending()); | 216 EXPECT_TRUE(socket_.read_pending()); |
218 } | 217 } |
219 | 218 |
220 // Receive two messages in separate packets. | 219 // Receive two messages in separate packets. |
221 TEST_F(MessageReaderTest, TwoMessages_Separately) { | 220 TEST_F(MessageReaderTest, TwoMessages_Separately) { |
222 CompoundBuffer* buffer; | 221 CompoundBuffer* buffer; |
223 Task* done_task; | 222 base::Closure done_task; |
224 | 223 |
225 AddMessage(kTestMessage1); | 224 AddMessage(kTestMessage1); |
226 | 225 |
227 EXPECT_CALL(callback_, OnMessage(_, _)) | 226 EXPECT_CALL(callback_, OnMessage(_, _)) |
228 .Times(1) | 227 .Times(1) |
229 .WillOnce(DoAll(SaveArg<0>(&buffer), | 228 .WillOnce(DoAll(SaveArg<0>(&buffer), |
230 SaveArg<1>(&done_task))); | 229 SaveArg<1>(&done_task))); |
231 | 230 |
232 InitReader(); | 231 InitReader(); |
233 | 232 |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
273 .Times(1) | 272 .Times(1) |
274 .WillOnce(Invoke(this, &MessageReaderTest::RunDoneTaskOnOtherThread)); | 273 .WillOnce(Invoke(this, &MessageReaderTest::RunDoneTaskOnOtherThread)); |
275 | 274 |
276 InitReader(); | 275 InitReader(); |
277 | 276 |
278 run_task_finished_.Wait(); | 277 run_task_finished_.Wait(); |
279 message_loop_.RunAllPending(); | 278 message_loop_.RunAllPending(); |
280 | 279 |
281 // Write another message and verify that we receive it. | 280 // Write another message and verify that we receive it. |
282 CompoundBuffer* buffer; | 281 CompoundBuffer* buffer; |
283 Task* done_task; | 282 base::Closure done_task; |
284 EXPECT_CALL(callback_, OnMessage(_, _)) | 283 EXPECT_CALL(callback_, OnMessage(_, _)) |
285 .Times(1) | 284 .Times(1) |
286 .WillOnce(DoAll(SaveArg<0>(&buffer), | 285 .WillOnce(DoAll(SaveArg<0>(&buffer), |
287 SaveArg<1>(&done_task))); | 286 SaveArg<1>(&done_task))); |
288 AddMessage(kTestMessage2); | 287 AddMessage(kTestMessage2); |
289 EXPECT_TRUE(CompareResult(buffer, kTestMessage2)); | 288 EXPECT_TRUE(CompareResult(buffer, kTestMessage2)); |
290 | 289 |
291 RunAndDeleteTask(done_task); | 290 RunAndDeleteTask(done_task); |
292 } | 291 } |
293 | 292 |
294 } // namespace protocol | 293 } // namespace protocol |
295 } // namespace remoting | 294 } // namespace remoting |
OLD | NEW |