Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(114)

Side by Side Diff: remoting/protocol/message_reader_unittest.cc

Issue 8116021: Switch remoting/protocol to new callbacks (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: - Created 9 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « remoting/protocol/message_reader.cc ('k') | remoting/protocol/pepper_session.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
OLDNEW
« no previous file with comments | « remoting/protocol/message_reader.cc ('k') | remoting/protocol/pepper_session.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698