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/message_loop.h" | 8 #include "base/message_loop/message_loop.h" |
9 #include "base/run_loop.h" | 9 #include "base/run_loop.h" |
10 #include "net/base/net_errors.h" | 10 #include "net/base/net_errors.h" |
(...skipping 27 matching lines...) Expand all Loading... |
38 base::MessageLoop::QuitClosure()); | 38 base::MessageLoop::QuitClosure()); |
39 } | 39 } |
40 | 40 |
41 class MockSocketCallback { | 41 class MockSocketCallback { |
42 public: | 42 public: |
43 MOCK_METHOD1(OnDone, void(int result)); | 43 MOCK_METHOD1(OnDone, void(int result)); |
44 }; | 44 }; |
45 | 45 |
46 class MockConnectCallback { | 46 class MockConnectCallback { |
47 public: | 47 public: |
48 MOCK_METHOD1(OnConnectedPtr, void(net::StreamSocket* socket)); | 48 MOCK_METHOD1(OnConnectedPtr, void(P2PStreamSocket* socket)); |
49 void OnConnected(scoped_ptr<net::StreamSocket> socket) { | 49 void OnConnected(scoped_ptr<P2PStreamSocket> socket) { |
50 OnConnectedPtr(socket.release()); | 50 OnConnectedPtr(socket.release()); |
51 } | 51 } |
52 }; | 52 }; |
53 | 53 |
54 } // namespace | 54 } // namespace |
55 | 55 |
56 class ChannelMultiplexerTest : public testing::Test { | 56 class ChannelMultiplexerTest : public testing::Test { |
57 public: | 57 public: |
58 void DeleteAll() { | 58 void DeleteAll() { |
59 host_socket1_.reset(); | 59 host_socket1_.reset(); |
(...skipping 27 matching lines...) Expand all Loading... |
87 FakeStreamSocket* client_socket = | 87 FakeStreamSocket* client_socket = |
88 client_session_.fake_channel_factory().GetFakeChannel( | 88 client_session_.fake_channel_factory().GetFakeChannel( |
89 ChannelMultiplexer::kMuxChannelName); | 89 ChannelMultiplexer::kMuxChannelName); |
90 host_socket->PairWith(client_socket); | 90 host_socket->PairWith(client_socket); |
91 | 91 |
92 // Make writes asynchronous in one direction. | 92 // Make writes asynchronous in one direction. |
93 host_socket->set_async_write(true); | 93 host_socket->set_async_write(true); |
94 } | 94 } |
95 | 95 |
96 void CreateChannel(const std::string& name, | 96 void CreateChannel(const std::string& name, |
97 scoped_ptr<net::StreamSocket>* host_socket, | 97 scoped_ptr<P2PStreamSocket>* host_socket, |
98 scoped_ptr<net::StreamSocket>* client_socket) { | 98 scoped_ptr<P2PStreamSocket>* client_socket) { |
99 int counter = 2; | 99 int counter = 2; |
100 host_mux_->CreateChannel(name, base::Bind( | 100 host_mux_->CreateChannel(name, base::Bind( |
101 &ChannelMultiplexerTest::OnChannelConnected, base::Unretained(this), | 101 &ChannelMultiplexerTest::OnChannelConnected, base::Unretained(this), |
102 host_socket, &counter)); | 102 host_socket, &counter)); |
103 client_mux_->CreateChannel(name, base::Bind( | 103 client_mux_->CreateChannel(name, base::Bind( |
104 &ChannelMultiplexerTest::OnChannelConnected, base::Unretained(this), | 104 &ChannelMultiplexerTest::OnChannelConnected, base::Unretained(this), |
105 client_socket, &counter)); | 105 client_socket, &counter)); |
106 | 106 |
107 message_loop_.Run(); | 107 message_loop_.Run(); |
108 | 108 |
109 EXPECT_TRUE(host_socket->get()); | 109 EXPECT_TRUE(host_socket->get()); |
110 EXPECT_TRUE(client_socket->get()); | 110 EXPECT_TRUE(client_socket->get()); |
111 } | 111 } |
112 | 112 |
113 void OnChannelConnected( | 113 void OnChannelConnected( |
114 scoped_ptr<net::StreamSocket>* storage, | 114 scoped_ptr<P2PStreamSocket>* storage, |
115 int* counter, | 115 int* counter, |
116 scoped_ptr<net::StreamSocket> socket) { | 116 scoped_ptr<P2PStreamSocket> socket) { |
117 *storage = socket.Pass(); | 117 *storage = socket.Pass(); |
118 --(*counter); | 118 --(*counter); |
119 EXPECT_GE(*counter, 0); | 119 EXPECT_GE(*counter, 0); |
120 if (*counter == 0) | 120 if (*counter == 0) |
121 QuitCurrentThread(); | 121 QuitCurrentThread(); |
122 } | 122 } |
123 | 123 |
124 scoped_refptr<net::IOBufferWithSize> CreateTestBuffer(int size) { | 124 scoped_refptr<net::IOBufferWithSize> CreateTestBuffer(int size) { |
125 scoped_refptr<net::IOBufferWithSize> result = | 125 scoped_refptr<net::IOBufferWithSize> result = |
126 new net::IOBufferWithSize(size); | 126 new net::IOBufferWithSize(size); |
127 for (int i = 0; i< size; ++i) { | 127 for (int i = 0; i< size; ++i) { |
128 result->data()[i] = rand() % 256; | 128 result->data()[i] = rand() % 256; |
129 } | 129 } |
130 return result; | 130 return result; |
131 } | 131 } |
132 | 132 |
133 base::MessageLoop message_loop_; | 133 base::MessageLoop message_loop_; |
134 | 134 |
135 FakeSession host_session_; | 135 FakeSession host_session_; |
136 FakeSession client_session_; | 136 FakeSession client_session_; |
137 | 137 |
138 scoped_ptr<ChannelMultiplexer> host_mux_; | 138 scoped_ptr<ChannelMultiplexer> host_mux_; |
139 scoped_ptr<ChannelMultiplexer> client_mux_; | 139 scoped_ptr<ChannelMultiplexer> client_mux_; |
140 | 140 |
141 scoped_ptr<net::StreamSocket> host_socket1_; | 141 scoped_ptr<P2PStreamSocket> host_socket1_; |
142 scoped_ptr<net::StreamSocket> client_socket1_; | 142 scoped_ptr<P2PStreamSocket> client_socket1_; |
143 scoped_ptr<net::StreamSocket> host_socket2_; | 143 scoped_ptr<P2PStreamSocket> host_socket2_; |
144 scoped_ptr<net::StreamSocket> client_socket2_; | 144 scoped_ptr<P2PStreamSocket> client_socket2_; |
145 }; | 145 }; |
146 | 146 |
147 | 147 |
148 TEST_F(ChannelMultiplexerTest, OneChannel) { | 148 TEST_F(ChannelMultiplexerTest, OneChannel) { |
149 scoped_ptr<net::StreamSocket> host_socket; | 149 scoped_ptr<P2PStreamSocket> host_socket; |
150 scoped_ptr<net::StreamSocket> client_socket; | 150 scoped_ptr<P2PStreamSocket> client_socket; |
151 ASSERT_NO_FATAL_FAILURE( | 151 ASSERT_NO_FATAL_FAILURE( |
152 CreateChannel(kTestChannelName, &host_socket, &client_socket)); | 152 CreateChannel(kTestChannelName, &host_socket, &client_socket)); |
153 | 153 |
154 ConnectSockets(); | 154 ConnectSockets(); |
155 | 155 |
156 StreamConnectionTester tester(host_socket.get(), client_socket.get(), | 156 StreamConnectionTester tester(host_socket.get(), client_socket.get(), |
157 kMessageSize, kMessages); | 157 kMessageSize, kMessages); |
158 tester.Start(); | 158 tester.Start(); |
159 message_loop_.Run(); | 159 message_loop_.Run(); |
160 tester.CheckResults(); | 160 tester.CheckResults(); |
161 } | 161 } |
162 | 162 |
163 TEST_F(ChannelMultiplexerTest, TwoChannels) { | 163 TEST_F(ChannelMultiplexerTest, TwoChannels) { |
164 scoped_ptr<net::StreamSocket> host_socket1_; | 164 scoped_ptr<P2PStreamSocket> host_socket1_; |
165 scoped_ptr<net::StreamSocket> client_socket1_; | 165 scoped_ptr<P2PStreamSocket> client_socket1_; |
166 ASSERT_NO_FATAL_FAILURE( | 166 ASSERT_NO_FATAL_FAILURE( |
167 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); | 167 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); |
168 | 168 |
169 scoped_ptr<net::StreamSocket> host_socket2_; | 169 scoped_ptr<P2PStreamSocket> host_socket2_; |
170 scoped_ptr<net::StreamSocket> client_socket2_; | 170 scoped_ptr<P2PStreamSocket> client_socket2_; |
171 ASSERT_NO_FATAL_FAILURE( | 171 ASSERT_NO_FATAL_FAILURE( |
172 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); | 172 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); |
173 | 173 |
174 ConnectSockets(); | 174 ConnectSockets(); |
175 | 175 |
176 StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(), | 176 StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(), |
177 kMessageSize, kMessages); | 177 kMessageSize, kMessages); |
178 StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(), | 178 StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(), |
179 kMessageSize, kMessages); | 179 kMessageSize, kMessages); |
180 tester1.Start(); | 180 tester1.Start(); |
181 tester2.Start(); | 181 tester2.Start(); |
182 while (!tester1.done() || !tester2.done()) { | 182 while (!tester1.done() || !tester2.done()) { |
183 message_loop_.Run(); | 183 message_loop_.Run(); |
184 } | 184 } |
185 tester1.CheckResults(); | 185 tester1.CheckResults(); |
186 tester2.CheckResults(); | 186 tester2.CheckResults(); |
187 } | 187 } |
188 | 188 |
189 // Four channels, two in each direction | 189 // Four channels, two in each direction |
190 TEST_F(ChannelMultiplexerTest, FourChannels) { | 190 TEST_F(ChannelMultiplexerTest, FourChannels) { |
191 scoped_ptr<net::StreamSocket> host_socket1_; | 191 scoped_ptr<P2PStreamSocket> host_socket1_; |
192 scoped_ptr<net::StreamSocket> client_socket1_; | 192 scoped_ptr<P2PStreamSocket> client_socket1_; |
193 ASSERT_NO_FATAL_FAILURE( | 193 ASSERT_NO_FATAL_FAILURE( |
194 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); | 194 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); |
195 | 195 |
196 scoped_ptr<net::StreamSocket> host_socket2_; | 196 scoped_ptr<P2PStreamSocket> host_socket2_; |
197 scoped_ptr<net::StreamSocket> client_socket2_; | 197 scoped_ptr<P2PStreamSocket> client_socket2_; |
198 ASSERT_NO_FATAL_FAILURE( | 198 ASSERT_NO_FATAL_FAILURE( |
199 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); | 199 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); |
200 | 200 |
201 scoped_ptr<net::StreamSocket> host_socket3; | 201 scoped_ptr<P2PStreamSocket> host_socket3; |
202 scoped_ptr<net::StreamSocket> client_socket3; | 202 scoped_ptr<P2PStreamSocket> client_socket3; |
203 ASSERT_NO_FATAL_FAILURE( | 203 ASSERT_NO_FATAL_FAILURE( |
204 CreateChannel("test3", &host_socket3, &client_socket3)); | 204 CreateChannel("test3", &host_socket3, &client_socket3)); |
205 | 205 |
206 scoped_ptr<net::StreamSocket> host_socket4; | 206 scoped_ptr<P2PStreamSocket> host_socket4; |
207 scoped_ptr<net::StreamSocket> client_socket4; | 207 scoped_ptr<P2PStreamSocket> client_socket4; |
208 ASSERT_NO_FATAL_FAILURE( | 208 ASSERT_NO_FATAL_FAILURE( |
209 CreateChannel("ch4", &host_socket4, &client_socket4)); | 209 CreateChannel("ch4", &host_socket4, &client_socket4)); |
210 | 210 |
211 ConnectSockets(); | 211 ConnectSockets(); |
212 | 212 |
213 StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(), | 213 StreamConnectionTester tester1(host_socket1_.get(), client_socket1_.get(), |
214 kMessageSize, kMessages); | 214 kMessageSize, kMessages); |
215 StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(), | 215 StreamConnectionTester tester2(host_socket2_.get(), client_socket2_.get(), |
216 kMessageSize, kMessages); | 216 kMessageSize, kMessages); |
217 StreamConnectionTester tester3(client_socket3.get(), host_socket3.get(), | 217 StreamConnectionTester tester3(client_socket3.get(), host_socket3.get(), |
218 kMessageSize, kMessages); | 218 kMessageSize, kMessages); |
219 StreamConnectionTester tester4(client_socket4.get(), host_socket4.get(), | 219 StreamConnectionTester tester4(client_socket4.get(), host_socket4.get(), |
220 kMessageSize, kMessages); | 220 kMessageSize, kMessages); |
221 tester1.Start(); | 221 tester1.Start(); |
222 tester2.Start(); | 222 tester2.Start(); |
223 tester3.Start(); | 223 tester3.Start(); |
224 tester4.Start(); | 224 tester4.Start(); |
225 while (!tester1.done() || !tester2.done() || | 225 while (!tester1.done() || !tester2.done() || |
226 !tester3.done() || !tester4.done()) { | 226 !tester3.done() || !tester4.done()) { |
227 message_loop_.Run(); | 227 message_loop_.Run(); |
228 } | 228 } |
229 tester1.CheckResults(); | 229 tester1.CheckResults(); |
230 tester2.CheckResults(); | 230 tester2.CheckResults(); |
231 tester3.CheckResults(); | 231 tester3.CheckResults(); |
232 tester4.CheckResults(); | 232 tester4.CheckResults(); |
233 } | 233 } |
234 | 234 |
235 TEST_F(ChannelMultiplexerTest, WriteFailSync) { | 235 TEST_F(ChannelMultiplexerTest, WriteFailSync) { |
236 scoped_ptr<net::StreamSocket> host_socket1_; | 236 scoped_ptr<P2PStreamSocket> host_socket1_; |
237 scoped_ptr<net::StreamSocket> client_socket1_; | 237 scoped_ptr<P2PStreamSocket> client_socket1_; |
238 ASSERT_NO_FATAL_FAILURE( | 238 ASSERT_NO_FATAL_FAILURE( |
239 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); | 239 CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_)); |
240 | 240 |
241 scoped_ptr<net::StreamSocket> host_socket2_; | 241 scoped_ptr<P2PStreamSocket> host_socket2_; |
242 scoped_ptr<net::StreamSocket> client_socket2_; | 242 scoped_ptr<P2PStreamSocket> client_socket2_; |
243 ASSERT_NO_FATAL_FAILURE( | 243 ASSERT_NO_FATAL_FAILURE( |
244 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); | 244 CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_)); |
245 | 245 |
246 ConnectSockets(); | 246 ConnectSockets(); |
247 | 247 |
248 host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)-> | 248 host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)-> |
249 set_next_write_error(net::ERR_FAILED); | 249 set_next_write_error(net::ERR_FAILED); |
250 host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)-> | 250 host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)-> |
251 set_async_write(false); | 251 set_async_write(false); |
252 | 252 |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
368 .WillOnce(InvokeWithoutArgs( | 368 .WillOnce(InvokeWithoutArgs( |
369 this, &ChannelMultiplexerTest::DeleteAfterSessionFail)); | 369 this, &ChannelMultiplexerTest::DeleteAfterSessionFail)); |
370 EXPECT_CALL(cb2, OnConnectedPtr(_)) | 370 EXPECT_CALL(cb2, OnConnectedPtr(_)) |
371 .Times(0); | 371 .Times(0); |
372 | 372 |
373 base::RunLoop().RunUntilIdle(); | 373 base::RunLoop().RunUntilIdle(); |
374 } | 374 } |
375 | 375 |
376 } // namespace protocol | 376 } // namespace protocol |
377 } // namespace remoting | 377 } // namespace remoting |
OLD | NEW |