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/channel_multiplexer.h" | 5 #include "remoting/protocol/channel_multiplexer.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/message_loop.h" | 8 #include "base/message_loop.h" |
9 #include "net/base/net_errors.h" | 9 #include "net/base/net_errors.h" |
10 #include "net/socket/socket.h" | 10 #include "net/socket/socket.h" |
(...skipping 10 matching lines...) Expand all Loading... |
21 | 21 |
22 namespace remoting { | 22 namespace remoting { |
23 namespace protocol { | 23 namespace protocol { |
24 | 24 |
25 namespace { | 25 namespace { |
26 | 26 |
27 const int kMessageSize = 1024; | 27 const int kMessageSize = 1024; |
28 const int kMessages = 100; | 28 const int kMessages = 100; |
29 const char kMuxChannelName[] = "mux"; | 29 const char kMuxChannelName[] = "mux"; |
30 | 30 |
| 31 const char kTestChannelName[] = "test"; |
| 32 const char kTestChannelName2[] = "test2"; |
| 33 |
| 34 |
31 void QuitCurrentThread() { | 35 void QuitCurrentThread() { |
32 MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure()); | 36 MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure()); |
33 } | 37 } |
34 | 38 |
35 class MockSocketCallback { | 39 class MockSocketCallback { |
36 public: | 40 public: |
37 MOCK_METHOD1(OnDone, void(int result)); | 41 MOCK_METHOD1(OnDone, void(int result)); |
38 }; | 42 }; |
39 | 43 |
| 44 class MockConnectCallback { |
| 45 public: |
| 46 MOCK_METHOD1(OnConnectedPtr, void(net::StreamSocket* socket)); |
| 47 void OnConnected(scoped_ptr<net::StreamSocket> socket) { |
| 48 OnConnectedPtr(socket.release()); |
| 49 } |
| 50 }; |
| 51 |
40 } // namespace | 52 } // namespace |
41 | 53 |
42 class ChannelMultiplexerTest : public testing::Test { | 54 class ChannelMultiplexerTest : public testing::Test { |
43 public: | 55 public: |
44 void DeleteAll() { | 56 void DeleteAll() { |
45 host_socket1_.reset(); | 57 host_socket1_.reset(); |
46 host_socket2_.reset(); | 58 host_socket2_.reset(); |
47 client_socket1_.reset(); | 59 client_socket1_.reset(); |
48 client_socket2_.reset(); | 60 client_socket2_.reset(); |
49 host_mux_.reset(); | 61 host_mux_.reset(); |
50 client_mux_.reset(); | 62 client_mux_.reset(); |
51 } | 63 } |
52 | 64 |
| 65 void DeleteAfterSessionFail() { |
| 66 host_mux_->CancelChannelCreation(kTestChannelName2); |
| 67 DeleteAll(); |
| 68 } |
| 69 |
53 protected: | 70 protected: |
54 virtual void SetUp() OVERRIDE { | 71 virtual void SetUp() OVERRIDE { |
55 // Create pair of multiplexers and connect them to each other. | 72 // Create pair of multiplexers and connect them to each other. |
56 host_mux_.reset(new ChannelMultiplexer(&host_session_, kMuxChannelName)); | 73 host_mux_.reset(new ChannelMultiplexer(&host_session_, kMuxChannelName)); |
57 client_mux_.reset(new ChannelMultiplexer(&client_session_, | 74 client_mux_.reset(new ChannelMultiplexer(&client_session_, |
58 kMuxChannelName)); | 75 kMuxChannelName)); |
59 } | 76 } |
60 | 77 |
61 // Connect sockets to each other. Must be called after we've created at least | 78 // Connect sockets to each other. Must be called after we've created at least |
62 // one channel with each multiplexer. | 79 // one channel with each multiplexer. |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
119 scoped_ptr<net::StreamSocket> host_socket1_; | 136 scoped_ptr<net::StreamSocket> host_socket1_; |
120 scoped_ptr<net::StreamSocket> client_socket1_; | 137 scoped_ptr<net::StreamSocket> client_socket1_; |
121 scoped_ptr<net::StreamSocket> host_socket2_; | 138 scoped_ptr<net::StreamSocket> host_socket2_; |
122 scoped_ptr<net::StreamSocket> client_socket2_; | 139 scoped_ptr<net::StreamSocket> client_socket2_; |
123 }; | 140 }; |
124 | 141 |
125 | 142 |
126 TEST_F(ChannelMultiplexerTest, OneChannel) { | 143 TEST_F(ChannelMultiplexerTest, OneChannel) { |
127 scoped_ptr<net::StreamSocket> host_socket; | 144 scoped_ptr<net::StreamSocket> host_socket; |
128 scoped_ptr<net::StreamSocket> client_socket; | 145 scoped_ptr<net::StreamSocket> client_socket; |
129 ASSERT_NO_FATAL_FAILURE(CreateChannel("test", &host_socket, &client_socket)); | 146 ASSERT_NO_FATAL_FAILURE( |
| 147 CreateChannel(kTestChannelName, &host_socket, &client_socket)); |
130 | 148 |
131 ConnectSockets(); | 149 ConnectSockets(); |
132 | 150 |
133 StreamConnectionTester tester(host_socket.get(), client_socket.get(), | 151 StreamConnectionTester tester(host_socket.get(), client_socket.get(), |
134 kMessageSize, kMessages); | 152 kMessageSize, kMessages); |
135 tester.Start(); | 153 tester.Start(); |
136 message_loop_.Run(); | 154 message_loop_.Run(); |
137 tester.CheckResults(); | 155 tester.CheckResults(); |
138 } | 156 } |
139 | 157 |
140 TEST_F(ChannelMultiplexerTest, TwoChannels) { | 158 TEST_F(ChannelMultiplexerTest, TwoChannels) { |
141 scoped_ptr<net::StreamSocket> host_socket1_; | 159 scoped_ptr<net::StreamSocket> host_socket1_; |
142 scoped_ptr<net::StreamSocket> client_socket1_; | 160 scoped_ptr<net::StreamSocket> client_socket1_; |
143 ASSERT_NO_FATAL_FAILURE( | 161 ASSERT_NO_FATAL_FAILURE( |
144 CreateChannel("test", &host_socket1_, &client_socket1_)); | 162 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); |
145 | 163 |
146 scoped_ptr<net::StreamSocket> host_socket2_; | 164 scoped_ptr<net::StreamSocket> host_socket2_; |
147 scoped_ptr<net::StreamSocket> client_socket2_; | 165 scoped_ptr<net::StreamSocket> client_socket2_; |
148 ASSERT_NO_FATAL_FAILURE( | 166 ASSERT_NO_FATAL_FAILURE( |
149 CreateChannel("ch2", &host_socket2_, &client_socket2_)); | 167 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); |
150 | 168 |
151 ConnectSockets(); | 169 ConnectSockets(); |
152 | 170 |
153 StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(), | 171 StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(), |
154 kMessageSize, kMessages); | 172 kMessageSize, kMessages); |
155 StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(), | 173 StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(), |
156 kMessageSize, kMessages); | 174 kMessageSize, kMessages); |
157 tester1.Start(); | 175 tester1.Start(); |
158 tester2.Start(); | 176 tester2.Start(); |
159 while (!tester1.done() || !tester2.done()) { | 177 while (!tester1.done() || !tester2.done()) { |
160 message_loop_.Run(); | 178 message_loop_.Run(); |
161 } | 179 } |
162 tester1.CheckResults(); | 180 tester1.CheckResults(); |
163 tester2.CheckResults(); | 181 tester2.CheckResults(); |
164 } | 182 } |
165 | 183 |
166 // Four channels, two in each direction | 184 // Four channels, two in each direction |
167 TEST_F(ChannelMultiplexerTest, FourChannels) { | 185 TEST_F(ChannelMultiplexerTest, FourChannels) { |
168 scoped_ptr<net::StreamSocket> host_socket1_; | 186 scoped_ptr<net::StreamSocket> host_socket1_; |
169 scoped_ptr<net::StreamSocket> client_socket1_; | 187 scoped_ptr<net::StreamSocket> client_socket1_; |
170 ASSERT_NO_FATAL_FAILURE( | 188 ASSERT_NO_FATAL_FAILURE( |
171 CreateChannel("test", &host_socket1_, &client_socket1_)); | 189 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); |
172 | 190 |
173 scoped_ptr<net::StreamSocket> host_socket2_; | 191 scoped_ptr<net::StreamSocket> host_socket2_; |
174 scoped_ptr<net::StreamSocket> client_socket2_; | 192 scoped_ptr<net::StreamSocket> client_socket2_; |
175 ASSERT_NO_FATAL_FAILURE( | 193 ASSERT_NO_FATAL_FAILURE( |
176 CreateChannel("ch2", &host_socket2_, &client_socket2_)); | 194 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); |
177 | 195 |
178 scoped_ptr<net::StreamSocket> host_socket3; | 196 scoped_ptr<net::StreamSocket> host_socket3; |
179 scoped_ptr<net::StreamSocket> client_socket3; | 197 scoped_ptr<net::StreamSocket> client_socket3; |
180 ASSERT_NO_FATAL_FAILURE( | 198 ASSERT_NO_FATAL_FAILURE( |
181 CreateChannel("test3", &host_socket3, &client_socket3)); | 199 CreateChannel("test3", &host_socket3, &client_socket3)); |
182 | 200 |
183 scoped_ptr<net::StreamSocket> host_socket4; | 201 scoped_ptr<net::StreamSocket> host_socket4; |
184 scoped_ptr<net::StreamSocket> client_socket4; | 202 scoped_ptr<net::StreamSocket> client_socket4; |
185 ASSERT_NO_FATAL_FAILURE( | 203 ASSERT_NO_FATAL_FAILURE( |
186 CreateChannel("ch4", &host_socket4, &client_socket4)); | 204 CreateChannel("ch4", &host_socket4, &client_socket4)); |
(...skipping 15 matching lines...) Expand all Loading... |
202 while (!tester1.done() || !tester2.done() || | 220 while (!tester1.done() || !tester2.done() || |
203 !tester3.done() || !tester4.done()) { | 221 !tester3.done() || !tester4.done()) { |
204 message_loop_.Run(); | 222 message_loop_.Run(); |
205 } | 223 } |
206 tester1.CheckResults(); | 224 tester1.CheckResults(); |
207 tester2.CheckResults(); | 225 tester2.CheckResults(); |
208 tester3.CheckResults(); | 226 tester3.CheckResults(); |
209 tester4.CheckResults(); | 227 tester4.CheckResults(); |
210 } | 228 } |
211 | 229 |
212 TEST_F(ChannelMultiplexerTest, SyncFail) { | 230 TEST_F(ChannelMultiplexerTest, WriteFailSync) { |
213 scoped_ptr<net::StreamSocket> host_socket1_; | 231 scoped_ptr<net::StreamSocket> host_socket1_; |
214 scoped_ptr<net::StreamSocket> client_socket1_; | 232 scoped_ptr<net::StreamSocket> client_socket1_; |
215 ASSERT_NO_FATAL_FAILURE( | 233 ASSERT_NO_FATAL_FAILURE( |
216 CreateChannel("test", &host_socket1_, &client_socket1_)); | 234 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); |
217 | 235 |
218 scoped_ptr<net::StreamSocket> host_socket2_; | 236 scoped_ptr<net::StreamSocket> host_socket2_; |
219 scoped_ptr<net::StreamSocket> client_socket2_; | 237 scoped_ptr<net::StreamSocket> client_socket2_; |
220 ASSERT_NO_FATAL_FAILURE( | 238 ASSERT_NO_FATAL_FAILURE( |
221 CreateChannel("ch2", &host_socket2_, &client_socket2_)); | 239 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); |
222 | 240 |
223 ConnectSockets(); | 241 ConnectSockets(); |
224 | 242 |
225 host_session_.GetStreamChannel(kMuxChannelName)-> | 243 host_session_.GetStreamChannel(kMuxChannelName)-> |
226 set_next_write_error(net::ERR_FAILED); | 244 set_next_write_error(net::ERR_FAILED); |
227 host_session_.GetStreamChannel(kMuxChannelName)-> | 245 host_session_.GetStreamChannel(kMuxChannelName)-> |
228 set_async_write(false); | 246 set_async_write(false); |
229 | 247 |
230 scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100); | 248 scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100); |
231 | 249 |
232 MockSocketCallback cb1; | 250 MockSocketCallback cb1; |
233 MockSocketCallback cb2; | 251 MockSocketCallback cb2; |
234 | 252 |
235 EXPECT_CALL(cb1, OnDone(_)) | 253 EXPECT_CALL(cb1, OnDone(_)) |
236 .Times(0); | 254 .Times(0); |
237 EXPECT_CALL(cb2, OnDone(_)) | 255 EXPECT_CALL(cb2, OnDone(_)) |
238 .Times(0); | 256 .Times(0); |
239 | 257 |
240 EXPECT_EQ(net::ERR_FAILED, host_socket1_->Write(buf, buf->size(), base::Bind( | 258 EXPECT_EQ(net::ERR_FAILED, host_socket1_->Write(buf, buf->size(), base::Bind( |
241 &MockSocketCallback::OnDone, base::Unretained(&cb1)))); | 259 &MockSocketCallback::OnDone, base::Unretained(&cb1)))); |
242 EXPECT_EQ(net::ERR_FAILED, host_socket2_->Write(buf, buf->size(), base::Bind( | 260 EXPECT_EQ(net::ERR_FAILED, host_socket2_->Write(buf, buf->size(), base::Bind( |
243 &MockSocketCallback::OnDone, base::Unretained(&cb2)))); | 261 &MockSocketCallback::OnDone, base::Unretained(&cb2)))); |
244 | 262 |
245 message_loop_.RunAllPending(); | 263 message_loop_.RunAllPending(); |
246 } | 264 } |
247 | 265 |
248 TEST_F(ChannelMultiplexerTest, AsyncFail) { | 266 TEST_F(ChannelMultiplexerTest, WriteFailAsync) { |
249 ASSERT_NO_FATAL_FAILURE( | 267 ASSERT_NO_FATAL_FAILURE( |
250 CreateChannel("test", &host_socket1_, &client_socket1_)); | 268 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); |
251 | 269 |
252 ASSERT_NO_FATAL_FAILURE( | 270 ASSERT_NO_FATAL_FAILURE( |
253 CreateChannel("ch2", &host_socket2_, &client_socket2_)); | 271 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); |
254 | 272 |
255 ConnectSockets(); | 273 ConnectSockets(); |
256 | 274 |
257 host_session_.GetStreamChannel(kMuxChannelName)-> | 275 host_session_.GetStreamChannel(kMuxChannelName)-> |
258 set_next_write_error(net::ERR_FAILED); | 276 set_next_write_error(net::ERR_FAILED); |
259 host_session_.GetStreamChannel(kMuxChannelName)-> | 277 host_session_.GetStreamChannel(kMuxChannelName)-> |
260 set_async_write(true); | 278 set_async_write(true); |
261 | 279 |
262 scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100); | 280 scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100); |
263 | 281 |
264 MockSocketCallback cb1; | 282 MockSocketCallback cb1; |
265 MockSocketCallback cb2; | 283 MockSocketCallback cb2; |
266 EXPECT_CALL(cb1, OnDone(net::ERR_FAILED)); | 284 EXPECT_CALL(cb1, OnDone(net::ERR_FAILED)); |
267 EXPECT_CALL(cb2, OnDone(net::ERR_FAILED)); | 285 EXPECT_CALL(cb2, OnDone(net::ERR_FAILED)); |
268 | 286 |
269 EXPECT_EQ(net::ERR_IO_PENDING, | 287 EXPECT_EQ(net::ERR_IO_PENDING, |
270 host_socket1_->Write(buf, buf->size(), base::Bind( | 288 host_socket1_->Write(buf, buf->size(), base::Bind( |
271 &MockSocketCallback::OnDone, base::Unretained(&cb1)))); | 289 &MockSocketCallback::OnDone, base::Unretained(&cb1)))); |
272 EXPECT_EQ(net::ERR_IO_PENDING, | 290 EXPECT_EQ(net::ERR_IO_PENDING, |
273 host_socket2_->Write(buf, buf->size(), base::Bind( | 291 host_socket2_->Write(buf, buf->size(), base::Bind( |
274 &MockSocketCallback::OnDone, base::Unretained(&cb2)))); | 292 &MockSocketCallback::OnDone, base::Unretained(&cb2)))); |
275 | 293 |
276 message_loop_.RunAllPending(); | 294 message_loop_.RunAllPending(); |
277 } | 295 } |
278 | 296 |
279 TEST_F(ChannelMultiplexerTest, DeleteWhenFailed) { | 297 TEST_F(ChannelMultiplexerTest, DeleteWhenFailed) { |
280 ASSERT_NO_FATAL_FAILURE( | 298 ASSERT_NO_FATAL_FAILURE( |
281 CreateChannel("test", &host_socket1_, &client_socket1_)); | 299 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); |
282 ASSERT_NO_FATAL_FAILURE( | 300 ASSERT_NO_FATAL_FAILURE( |
283 CreateChannel("ch2", &host_socket2_, &client_socket2_)); | 301 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); |
284 | 302 |
285 ConnectSockets(); | 303 ConnectSockets(); |
286 | 304 |
287 host_session_.GetStreamChannel(kMuxChannelName)-> | 305 host_session_.GetStreamChannel(kMuxChannelName)-> |
288 set_next_write_error(net::ERR_FAILED); | 306 set_next_write_error(net::ERR_FAILED); |
289 host_session_.GetStreamChannel(kMuxChannelName)-> | 307 host_session_.GetStreamChannel(kMuxChannelName)-> |
290 set_async_write(true); | 308 set_async_write(true); |
291 | 309 |
292 scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100); | 310 scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100); |
293 | 311 |
(...skipping 13 matching lines...) Expand all Loading... |
307 EXPECT_EQ(net::ERR_IO_PENDING, | 325 EXPECT_EQ(net::ERR_IO_PENDING, |
308 host_socket2_->Write(buf, buf->size(), base::Bind( | 326 host_socket2_->Write(buf, buf->size(), base::Bind( |
309 &MockSocketCallback::OnDone, base::Unretained(&cb2)))); | 327 &MockSocketCallback::OnDone, base::Unretained(&cb2)))); |
310 | 328 |
311 message_loop_.RunAllPending(); | 329 message_loop_.RunAllPending(); |
312 | 330 |
313 // Check that the sockets were destroyed. | 331 // Check that the sockets were destroyed. |
314 EXPECT_FALSE(host_mux_.get()); | 332 EXPECT_FALSE(host_mux_.get()); |
315 } | 333 } |
316 | 334 |
| 335 TEST_F(ChannelMultiplexerTest, SessionFail) { |
| 336 host_session_.set_async_creation(true); |
| 337 host_session_.set_error(AUTHENTICATION_FAILED); |
| 338 |
| 339 MockConnectCallback cb1; |
| 340 MockConnectCallback cb2; |
| 341 |
| 342 host_mux_->CreateStreamChannel(kTestChannelName, base::Bind( |
| 343 &MockConnectCallback::OnConnected, base::Unretained(&cb1))); |
| 344 host_mux_->CreateStreamChannel(kTestChannelName2, base::Bind( |
| 345 &MockConnectCallback::OnConnected, base::Unretained(&cb2))); |
| 346 |
| 347 EXPECT_CALL(cb1, OnConnectedPtr(NULL)) |
| 348 .Times(AtMost(1)) |
| 349 .WillOnce(InvokeWithoutArgs( |
| 350 this, &ChannelMultiplexerTest::DeleteAfterSessionFail)); |
| 351 EXPECT_CALL(cb2, OnConnectedPtr(_)) |
| 352 .Times(0); |
| 353 |
| 354 message_loop_.RunAllPending(); |
| 355 } |
| 356 |
317 } // namespace protocol | 357 } // namespace protocol |
318 } // namespace remoting | 358 } // namespace remoting |
OLD | NEW |