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 "net/socket/transport_client_socket_pool.h" | 5 #include "net/socket/websocket_transport_client_socket_pool.h" |
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/callback.h" |
10 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
11 #include "base/logging.h" | 11 #include "base/logging.h" |
12 #include "base/message_loop/message_loop.h" | 12 #include "base/message_loop/message_loop.h" |
13 #include "base/threading/platform_thread.h" | 13 #include "base/threading/platform_thread.h" |
14 #include "net/base/capturing_net_log.h" | 14 #include "net/base/capturing_net_log.h" |
15 #include "net/base/ip_endpoint.h" | 15 #include "net/base/ip_endpoint.h" |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
82 IPAddressNumber number; | 82 IPAddressNumber number; |
83 CHECK(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number)); | 83 CHECK(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number)); |
84 *address = IPEndPoint(number, 80); | 84 *address = IPEndPoint(number, 80); |
85 } | 85 } |
86 | 86 |
87 class MockClientSocket : public StreamSocket { | 87 class MockClientSocket : public StreamSocket { |
88 public: | 88 public: |
89 MockClientSocket(const AddressList& addrlist, net::NetLog* net_log) | 89 MockClientSocket(const AddressList& addrlist, net::NetLog* net_log) |
90 : connected_(false), | 90 : connected_(false), |
91 addrlist_(addrlist), | 91 addrlist_(addrlist), |
92 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) { | 92 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {} |
93 } | |
94 | 93 |
95 // StreamSocket implementation. | 94 // StreamSocket implementation. |
96 virtual int Connect(const CompletionCallback& callback) OVERRIDE { | 95 virtual int Connect(const CompletionCallback& callback) OVERRIDE { |
97 connected_ = true; | 96 connected_ = true; |
98 return OK; | 97 return OK; |
99 } | 98 } |
100 virtual void Disconnect() OVERRIDE { | 99 virtual void Disconnect() OVERRIDE { connected_ = false; } |
101 connected_ = false; | 100 virtual bool IsConnected() const OVERRIDE { return connected_; } |
102 } | 101 virtual bool IsConnectedAndIdle() const OVERRIDE { return connected_; } |
103 virtual bool IsConnected() const OVERRIDE { | |
104 return connected_; | |
105 } | |
106 virtual bool IsConnectedAndIdle() const OVERRIDE { | |
107 return connected_; | |
108 } | |
109 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { | 102 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { |
110 return ERR_UNEXPECTED; | 103 *address = addrlist_.front(); |
| 104 return OK; |
111 } | 105 } |
112 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { | 106 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { |
113 if (!connected_) | 107 if (!connected_) |
114 return ERR_SOCKET_NOT_CONNECTED; | 108 return ERR_SOCKET_NOT_CONNECTED; |
115 if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4) | 109 if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4) |
116 SetIPv4Address(address); | 110 SetIPv4Address(address); |
117 else | 111 else |
118 SetIPv6Address(address); | 112 SetIPv6Address(address); |
119 return OK; | 113 return OK; |
120 } | 114 } |
121 virtual const BoundNetLog& NetLog() const OVERRIDE { | 115 virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; } |
122 return net_log_; | |
123 } | |
124 | 116 |
125 virtual void SetSubresourceSpeculation() OVERRIDE {} | 117 virtual void SetSubresourceSpeculation() OVERRIDE {} |
126 virtual void SetOmniboxSpeculation() OVERRIDE {} | 118 virtual void SetOmniboxSpeculation() OVERRIDE {} |
127 virtual bool WasEverUsed() const OVERRIDE { return false; } | 119 virtual bool WasEverUsed() const OVERRIDE { return false; } |
128 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } | 120 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } |
129 virtual bool WasNpnNegotiated() const OVERRIDE { | 121 virtual bool WasNpnNegotiated() const OVERRIDE { return false; } |
130 return false; | |
131 } | |
132 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { | 122 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { |
133 return kProtoUnknown; | 123 return kProtoUnknown; |
134 } | 124 } |
135 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { | 125 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; } |
136 return false; | |
137 } | |
138 | 126 |
139 // Socket implementation. | 127 // Socket implementation. |
140 virtual int Read(IOBuffer* buf, int buf_len, | 128 virtual int Read(IOBuffer* buf, |
| 129 int buf_len, |
141 const CompletionCallback& callback) OVERRIDE { | 130 const CompletionCallback& callback) OVERRIDE { |
142 return ERR_FAILED; | 131 return ERR_FAILED; |
143 } | 132 } |
144 virtual int Write(IOBuffer* buf, int buf_len, | 133 virtual int Write(IOBuffer* buf, |
| 134 int buf_len, |
145 const CompletionCallback& callback) OVERRIDE { | 135 const CompletionCallback& callback) OVERRIDE { |
146 return ERR_FAILED; | 136 return ERR_FAILED; |
147 } | 137 } |
148 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } | 138 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } |
149 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } | 139 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } |
150 | 140 |
151 private: | 141 private: |
152 bool connected_; | 142 bool connected_; |
153 const AddressList addrlist_; | 143 const AddressList addrlist_; |
154 BoundNetLog net_log_; | 144 BoundNetLog net_log_; |
155 | 145 |
156 DISALLOW_COPY_AND_ASSIGN(MockClientSocket); | 146 DISALLOW_COPY_AND_ASSIGN(MockClientSocket); |
157 }; | 147 }; |
158 | 148 |
159 class MockFailingClientSocket : public StreamSocket { | 149 class MockFailingClientSocket : public StreamSocket { |
160 public: | 150 public: |
161 MockFailingClientSocket(const AddressList& addrlist, net::NetLog* net_log) | 151 MockFailingClientSocket(const AddressList& addrlist, net::NetLog* net_log) |
162 : addrlist_(addrlist), | 152 : addrlist_(addrlist), |
163 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) { | 153 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {} |
164 } | |
165 | 154 |
166 // StreamSocket implementation. | 155 // StreamSocket implementation. |
167 virtual int Connect(const CompletionCallback& callback) OVERRIDE { | 156 virtual int Connect(const CompletionCallback& callback) OVERRIDE { |
168 return ERR_CONNECTION_FAILED; | 157 return ERR_CONNECTION_FAILED; |
169 } | 158 } |
170 | 159 |
171 virtual void Disconnect() OVERRIDE {} | 160 virtual void Disconnect() OVERRIDE {} |
172 | 161 |
173 virtual bool IsConnected() const OVERRIDE { | 162 virtual bool IsConnected() const OVERRIDE { return false; } |
174 return false; | 163 virtual bool IsConnectedAndIdle() const OVERRIDE { return false; } |
175 } | |
176 virtual bool IsConnectedAndIdle() const OVERRIDE { | |
177 return false; | |
178 } | |
179 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { | 164 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { |
180 return ERR_UNEXPECTED; | 165 return ERR_UNEXPECTED; |
181 } | 166 } |
182 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { | 167 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { |
183 return ERR_UNEXPECTED; | 168 return ERR_UNEXPECTED; |
184 } | 169 } |
185 virtual const BoundNetLog& NetLog() const OVERRIDE { | 170 virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; } |
186 return net_log_; | |
187 } | |
188 | 171 |
189 virtual void SetSubresourceSpeculation() OVERRIDE {} | 172 virtual void SetSubresourceSpeculation() OVERRIDE {} |
190 virtual void SetOmniboxSpeculation() OVERRIDE {} | 173 virtual void SetOmniboxSpeculation() OVERRIDE {} |
191 virtual bool WasEverUsed() const OVERRIDE { return false; } | 174 virtual bool WasEverUsed() const OVERRIDE { return false; } |
192 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } | 175 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } |
193 virtual bool WasNpnNegotiated() const OVERRIDE { | 176 virtual bool WasNpnNegotiated() const OVERRIDE { return false; } |
194 return false; | |
195 } | |
196 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { | 177 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { |
197 return kProtoUnknown; | 178 return kProtoUnknown; |
198 } | 179 } |
199 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { | 180 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; } |
200 return false; | |
201 } | |
202 | 181 |
203 // Socket implementation. | 182 // Socket implementation. |
204 virtual int Read(IOBuffer* buf, int buf_len, | 183 virtual int Read(IOBuffer* buf, |
| 184 int buf_len, |
205 const CompletionCallback& callback) OVERRIDE { | 185 const CompletionCallback& callback) OVERRIDE { |
206 return ERR_FAILED; | 186 return ERR_FAILED; |
207 } | 187 } |
208 | 188 |
209 virtual int Write(IOBuffer* buf, int buf_len, | 189 virtual int Write(IOBuffer* buf, |
| 190 int buf_len, |
210 const CompletionCallback& callback) OVERRIDE { | 191 const CompletionCallback& callback) OVERRIDE { |
211 return ERR_FAILED; | 192 return ERR_FAILED; |
212 } | 193 } |
213 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } | 194 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } |
214 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } | 195 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } |
215 | 196 |
216 private: | 197 private: |
217 const AddressList addrlist_; | 198 const AddressList addrlist_; |
218 BoundNetLog net_log_; | 199 BoundNetLog net_log_; |
219 | 200 |
220 DISALLOW_COPY_AND_ASSIGN(MockFailingClientSocket); | 201 DISALLOW_COPY_AND_ASSIGN(MockFailingClientSocket); |
221 }; | 202 }; |
222 | 203 |
223 class MockPendingClientSocket : public StreamSocket { | 204 class MockPendingClientSocket : public StreamSocket { |
224 public: | 205 public: |
225 // |should_connect| indicates whether the socket should successfully complete | 206 // |should_connect| indicates whether the socket should successfully complete |
226 // or fail. | 207 // or fail. |
227 // |should_stall| indicates that this socket should never connect. | 208 // |should_stall| indicates that this socket should never connect. |
228 // |delay_ms| is the delay, in milliseconds, before simulating a connect. | 209 // |delay_ms| is the delay, in milliseconds, before simulating a connect. |
229 MockPendingClientSocket( | 210 MockPendingClientSocket(const AddressList& addrlist, |
230 const AddressList& addrlist, | 211 bool should_connect, |
231 bool should_connect, | 212 bool should_stall, |
232 bool should_stall, | 213 base::TimeDelta delay, |
233 base::TimeDelta delay, | 214 net::NetLog* net_log) |
234 net::NetLog* net_log) | |
235 : should_connect_(should_connect), | 215 : should_connect_(should_connect), |
236 should_stall_(should_stall), | 216 should_stall_(should_stall), |
237 delay_(delay), | 217 delay_(delay), |
238 is_connected_(false), | 218 is_connected_(false), |
239 addrlist_(addrlist), | 219 addrlist_(addrlist), |
240 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)), | 220 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)), |
241 weak_factory_(this) { | 221 weak_factory_(this) {} |
242 } | |
243 | 222 |
244 // StreamSocket implementation. | 223 // StreamSocket implementation. |
245 virtual int Connect(const CompletionCallback& callback) OVERRIDE { | 224 virtual int Connect(const CompletionCallback& callback) OVERRIDE { |
246 base::MessageLoop::current()->PostDelayedTask( | 225 base::MessageLoop::current()->PostDelayedTask( |
247 FROM_HERE, | 226 FROM_HERE, |
248 base::Bind(&MockPendingClientSocket::DoCallback, | 227 base::Bind(&MockPendingClientSocket::DoCallback, |
249 weak_factory_.GetWeakPtr(), callback), | 228 weak_factory_.GetWeakPtr(), |
| 229 callback), |
250 delay_); | 230 delay_); |
251 return ERR_IO_PENDING; | 231 return ERR_IO_PENDING; |
252 } | 232 } |
253 | 233 |
254 virtual void Disconnect() OVERRIDE {} | 234 virtual void Disconnect() OVERRIDE {} |
255 | 235 |
256 virtual bool IsConnected() const OVERRIDE { | 236 virtual bool IsConnected() const OVERRIDE { return is_connected_; } |
257 return is_connected_; | 237 virtual bool IsConnectedAndIdle() const OVERRIDE { return is_connected_; } |
258 } | |
259 virtual bool IsConnectedAndIdle() const OVERRIDE { | |
260 return is_connected_; | |
261 } | |
262 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { | 238 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { |
263 return ERR_UNEXPECTED; | 239 return ERR_UNEXPECTED; |
264 } | 240 } |
265 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { | 241 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { |
266 if (!is_connected_) | 242 if (!is_connected_) |
267 return ERR_SOCKET_NOT_CONNECTED; | 243 return ERR_SOCKET_NOT_CONNECTED; |
268 if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4) | 244 if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4) |
269 SetIPv4Address(address); | 245 SetIPv4Address(address); |
270 else | 246 else |
271 SetIPv6Address(address); | 247 SetIPv6Address(address); |
272 return OK; | 248 return OK; |
273 } | 249 } |
274 virtual const BoundNetLog& NetLog() const OVERRIDE { | 250 virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; } |
275 return net_log_; | |
276 } | |
277 | 251 |
278 virtual void SetSubresourceSpeculation() OVERRIDE {} | 252 virtual void SetSubresourceSpeculation() OVERRIDE {} |
279 virtual void SetOmniboxSpeculation() OVERRIDE {} | 253 virtual void SetOmniboxSpeculation() OVERRIDE {} |
280 virtual bool WasEverUsed() const OVERRIDE { return false; } | 254 virtual bool WasEverUsed() const OVERRIDE { return false; } |
281 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } | 255 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } |
282 virtual bool WasNpnNegotiated() const OVERRIDE { | 256 virtual bool WasNpnNegotiated() const OVERRIDE { return false; } |
283 return false; | |
284 } | |
285 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { | 257 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { |
286 return kProtoUnknown; | 258 return kProtoUnknown; |
287 } | 259 } |
288 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { | 260 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; } |
289 return false; | |
290 } | |
291 | 261 |
292 // Socket implementation. | 262 // Socket implementation. |
293 virtual int Read(IOBuffer* buf, int buf_len, | 263 virtual int Read(IOBuffer* buf, |
| 264 int buf_len, |
294 const CompletionCallback& callback) OVERRIDE { | 265 const CompletionCallback& callback) OVERRIDE { |
295 return ERR_FAILED; | 266 return ERR_FAILED; |
296 } | 267 } |
297 | 268 |
298 virtual int Write(IOBuffer* buf, int buf_len, | 269 virtual int Write(IOBuffer* buf, |
| 270 int buf_len, |
299 const CompletionCallback& callback) OVERRIDE { | 271 const CompletionCallback& callback) OVERRIDE { |
300 return ERR_FAILED; | 272 return ERR_FAILED; |
301 } | 273 } |
302 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } | 274 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } |
303 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } | 275 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } |
304 | 276 |
305 private: | 277 private: |
306 void DoCallback(const CompletionCallback& callback) { | 278 void DoCallback(const CompletionCallback& callback) { |
307 if (should_stall_) | 279 if (should_stall_) |
308 return; | 280 return; |
(...skipping 26 matching lines...) Expand all Loading... |
335 MOCK_FAILING_CLIENT_SOCKET, | 307 MOCK_FAILING_CLIENT_SOCKET, |
336 MOCK_PENDING_CLIENT_SOCKET, | 308 MOCK_PENDING_CLIENT_SOCKET, |
337 MOCK_PENDING_FAILING_CLIENT_SOCKET, | 309 MOCK_PENDING_FAILING_CLIENT_SOCKET, |
338 // A delayed socket will pause before connecting through the message loop. | 310 // A delayed socket will pause before connecting through the message loop. |
339 MOCK_DELAYED_CLIENT_SOCKET, | 311 MOCK_DELAYED_CLIENT_SOCKET, |
340 // A stalled socket that never connects at all. | 312 // A stalled socket that never connects at all. |
341 MOCK_STALLED_CLIENT_SOCKET, | 313 MOCK_STALLED_CLIENT_SOCKET, |
342 }; | 314 }; |
343 | 315 |
344 explicit MockClientSocketFactory(NetLog* net_log) | 316 explicit MockClientSocketFactory(NetLog* net_log) |
345 : net_log_(net_log), allocation_count_(0), | 317 : net_log_(net_log), |
346 client_socket_type_(MOCK_CLIENT_SOCKET), client_socket_types_(NULL), | 318 allocation_count_(0), |
347 client_socket_index_(0), client_socket_index_max_(0), | 319 client_socket_type_(MOCK_CLIENT_SOCKET), |
| 320 client_socket_types_(NULL), |
| 321 client_socket_index_(0), |
| 322 client_socket_index_max_(0), |
348 delay_(base::TimeDelta::FromMilliseconds( | 323 delay_(base::TimeDelta::FromMilliseconds( |
349 ClientSocketPool::kMaxConnectRetryIntervalMs)) {} | 324 ClientSocketPool::kMaxConnectRetryIntervalMs)) {} |
350 | 325 |
351 virtual scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket( | 326 virtual scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket( |
352 DatagramSocket::BindType bind_type, | 327 DatagramSocket::BindType bind_type, |
353 const RandIntCallback& rand_int_cb, | 328 const RandIntCallback& rand_int_cb, |
354 NetLog* net_log, | 329 NetLog* net_log, |
355 const NetLog::Source& source) OVERRIDE { | 330 const NetLog::Source& source) OVERRIDE { |
356 NOTREACHED(); | 331 NOTREACHED(); |
357 return scoped_ptr<DatagramClientSocket>(); | 332 return scoped_ptr<DatagramClientSocket>(); |
(...skipping 12 matching lines...) Expand all Loading... |
370 } | 345 } |
371 | 346 |
372 switch (type) { | 347 switch (type) { |
373 case MOCK_CLIENT_SOCKET: | 348 case MOCK_CLIENT_SOCKET: |
374 return scoped_ptr<StreamSocket>( | 349 return scoped_ptr<StreamSocket>( |
375 new MockClientSocket(addresses, net_log_)); | 350 new MockClientSocket(addresses, net_log_)); |
376 case MOCK_FAILING_CLIENT_SOCKET: | 351 case MOCK_FAILING_CLIENT_SOCKET: |
377 return scoped_ptr<StreamSocket>( | 352 return scoped_ptr<StreamSocket>( |
378 new MockFailingClientSocket(addresses, net_log_)); | 353 new MockFailingClientSocket(addresses, net_log_)); |
379 case MOCK_PENDING_CLIENT_SOCKET: | 354 case MOCK_PENDING_CLIENT_SOCKET: |
380 return scoped_ptr<StreamSocket>( | 355 return scoped_ptr<StreamSocket>(new MockPendingClientSocket( |
381 new MockPendingClientSocket( | 356 addresses, true, false, base::TimeDelta(), net_log_)); |
382 addresses, true, false, base::TimeDelta(), net_log_)); | |
383 case MOCK_PENDING_FAILING_CLIENT_SOCKET: | 357 case MOCK_PENDING_FAILING_CLIENT_SOCKET: |
384 return scoped_ptr<StreamSocket>( | 358 return scoped_ptr<StreamSocket>(new MockPendingClientSocket( |
385 new MockPendingClientSocket( | 359 addresses, false, false, base::TimeDelta(), net_log_)); |
386 addresses, false, false, base::TimeDelta(), net_log_)); | |
387 case MOCK_DELAYED_CLIENT_SOCKET: | 360 case MOCK_DELAYED_CLIENT_SOCKET: |
388 return scoped_ptr<StreamSocket>( | 361 return scoped_ptr<StreamSocket>(new MockPendingClientSocket( |
389 new MockPendingClientSocket( | 362 addresses, true, false, delay_, net_log_)); |
390 addresses, true, false, delay_, net_log_)); | |
391 case MOCK_STALLED_CLIENT_SOCKET: | 363 case MOCK_STALLED_CLIENT_SOCKET: |
392 return scoped_ptr<StreamSocket>( | 364 return scoped_ptr<StreamSocket>(new MockPendingClientSocket( |
393 new MockPendingClientSocket( | 365 addresses, true, true, base::TimeDelta(), net_log_)); |
394 addresses, true, true, base::TimeDelta(), net_log_)); | |
395 default: | 366 default: |
396 NOTREACHED(); | 367 NOTREACHED(); |
397 return scoped_ptr<StreamSocket>( | 368 return scoped_ptr<StreamSocket>( |
398 new MockClientSocket(addresses, net_log_)); | 369 new MockClientSocket(addresses, net_log_)); |
399 } | 370 } |
400 } | 371 } |
401 | 372 |
402 virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket( | 373 virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket( |
403 scoped_ptr<ClientSocketHandle> transport_socket, | 374 scoped_ptr<ClientSocketHandle> transport_socket, |
404 const HostPortPair& host_and_port, | 375 const HostPortPair& host_and_port, |
405 const SSLConfig& ssl_config, | 376 const SSLConfig& ssl_config, |
406 const SSLClientSocketContext& context) OVERRIDE { | 377 const SSLClientSocketContext& context) OVERRIDE { |
407 NOTIMPLEMENTED(); | 378 NOTIMPLEMENTED(); |
408 return scoped_ptr<SSLClientSocket>(); | 379 return scoped_ptr<SSLClientSocket>(); |
409 } | 380 } |
410 | 381 |
411 virtual void ClearSSLSessionCache() OVERRIDE { | 382 virtual void ClearSSLSessionCache() OVERRIDE { NOTIMPLEMENTED(); } |
412 NOTIMPLEMENTED(); | |
413 } | |
414 | 383 |
415 int allocation_count() const { return allocation_count_; } | 384 int allocation_count() const { return allocation_count_; } |
416 | 385 |
417 // Set the default ClientSocketType. | 386 // Set the default ClientSocketType. |
418 void set_client_socket_type(ClientSocketType type) { | 387 void set_client_socket_type(ClientSocketType type) { |
419 client_socket_type_ = type; | 388 client_socket_type_ = type; |
420 } | 389 } |
421 | 390 |
422 // Set a list of ClientSocketTypes to be used. | 391 // Set a list of ClientSocketTypes to be used. |
423 void set_client_socket_types(ClientSocketType* type_list, int num_types) { | 392 void set_client_socket_types(ClientSocketType* type_list, int num_types) { |
(...skipping 10 matching lines...) Expand all Loading... |
434 int allocation_count_; | 403 int allocation_count_; |
435 ClientSocketType client_socket_type_; | 404 ClientSocketType client_socket_type_; |
436 ClientSocketType* client_socket_types_; | 405 ClientSocketType* client_socket_types_; |
437 int client_socket_index_; | 406 int client_socket_index_; |
438 int client_socket_index_max_; | 407 int client_socket_index_max_; |
439 base::TimeDelta delay_; | 408 base::TimeDelta delay_; |
440 | 409 |
441 DISALLOW_COPY_AND_ASSIGN(MockClientSocketFactory); | 410 DISALLOW_COPY_AND_ASSIGN(MockClientSocketFactory); |
442 }; | 411 }; |
443 | 412 |
444 class TransportClientSocketPoolTest : public testing::Test { | 413 class WebSocketTransportClientSocketPoolTest : public testing::Test { |
445 protected: | 414 protected: |
446 TransportClientSocketPoolTest() | 415 WebSocketTransportClientSocketPoolTest() |
447 : connect_backup_jobs_enabled_( | 416 : connect_backup_jobs_enabled_( |
448 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true)), | 417 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true)), |
449 params_( | 418 params_(new TransportSocketParams(HostPortPair("www.google.com", 80), |
450 new TransportSocketParams(HostPortPair("www.google.com", 80), | 419 false, |
451 false, false, | 420 false, |
452 OnHostResolutionCallback())), | 421 OnHostResolutionCallback())), |
453 histograms_(new ClientSocketPoolHistograms("TCPUnitTest")), | 422 histograms_(new ClientSocketPoolHistograms("TCPUnitTest")), |
454 host_resolver_(new MockHostResolver), | 423 host_resolver_(new MockHostResolver), |
455 client_socket_factory_(&net_log_), | 424 client_socket_factory_(&net_log_), |
456 pool_(kMaxSockets, | 425 pool_(kMaxSockets, |
457 kMaxSocketsPerGroup, | 426 kMaxSocketsPerGroup, |
458 histograms_.get(), | 427 histograms_.get(), |
459 host_resolver_.get(), | 428 host_resolver_.get(), |
460 &client_socket_factory_, | 429 &client_socket_factory_, |
461 NULL) { | 430 NULL) {} |
462 } | |
463 | 431 |
464 virtual ~TransportClientSocketPoolTest() { | 432 virtual ~WebSocketTransportClientSocketPoolTest() { |
465 internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled( | 433 internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled( |
466 connect_backup_jobs_enabled_); | 434 connect_backup_jobs_enabled_); |
467 } | 435 } |
468 | 436 |
469 int StartRequest(const std::string& group_name, RequestPriority priority) { | 437 int StartRequest(const std::string& group_name, RequestPriority priority) { |
470 scoped_refptr<TransportSocketParams> params(new TransportSocketParams( | 438 scoped_refptr<TransportSocketParams> params( |
471 HostPortPair("www.google.com", 80), false, false, | 439 new TransportSocketParams(HostPortPair("www.google.com", 80), |
472 OnHostResolutionCallback())); | 440 false, |
| 441 false, |
| 442 OnHostResolutionCallback())); |
473 return test_base_.StartRequestUsingPool( | 443 return test_base_.StartRequestUsingPool( |
474 &pool_, group_name, priority, params); | 444 &pool_, group_name, priority, params); |
475 } | 445 } |
476 | 446 |
477 int GetOrderOfRequest(size_t index) { | 447 int GetOrderOfRequest(size_t index) { |
478 return test_base_.GetOrderOfRequest(index); | 448 return test_base_.GetOrderOfRequest(index); |
479 } | 449 } |
480 | 450 |
481 bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) { | 451 bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) { |
482 return test_base_.ReleaseOneConnection(keep_alive); | 452 return test_base_.ReleaseOneConnection(keep_alive); |
483 } | 453 } |
484 | 454 |
485 void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) { | 455 void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) { |
486 test_base_.ReleaseAllConnections(keep_alive); | 456 test_base_.ReleaseAllConnections(keep_alive); |
487 } | 457 } |
488 | 458 |
489 ScopedVector<TestSocketRequest>* requests() { return test_base_.requests(); } | 459 ScopedVector<TestSocketRequest>* requests() { return test_base_.requests(); } |
490 size_t completion_count() const { return test_base_.completion_count(); } | 460 size_t completion_count() const { return test_base_.completion_count(); } |
491 | 461 |
492 bool connect_backup_jobs_enabled_; | 462 bool connect_backup_jobs_enabled_; |
493 CapturingNetLog net_log_; | 463 CapturingNetLog net_log_; |
494 scoped_refptr<TransportSocketParams> params_; | 464 scoped_refptr<TransportSocketParams> params_; |
495 scoped_ptr<ClientSocketPoolHistograms> histograms_; | 465 scoped_ptr<ClientSocketPoolHistograms> histograms_; |
496 scoped_ptr<MockHostResolver> host_resolver_; | 466 scoped_ptr<MockHostResolver> host_resolver_; |
497 MockClientSocketFactory client_socket_factory_; | 467 MockClientSocketFactory client_socket_factory_; |
498 TransportClientSocketPool pool_; | 468 WebSocketTransportClientSocketPool pool_; |
499 ClientSocketPoolTest test_base_; | 469 ClientSocketPoolTest test_base_; |
500 | 470 |
501 DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPoolTest); | 471 DISALLOW_COPY_AND_ASSIGN(WebSocketTransportClientSocketPoolTest); |
502 }; | 472 }; |
503 | 473 |
504 TEST(TransportConnectJobTest, MakeAddrListStartWithIPv4) { | 474 TEST_F(WebSocketTransportClientSocketPoolTest, Basic) { |
505 IPAddressNumber ip_number; | |
506 ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.1", &ip_number)); | |
507 IPEndPoint addrlist_v4_1(ip_number, 80); | |
508 ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.2", &ip_number)); | |
509 IPEndPoint addrlist_v4_2(ip_number, 80); | |
510 ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::64", &ip_number)); | |
511 IPEndPoint addrlist_v6_1(ip_number, 80); | |
512 ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::66", &ip_number)); | |
513 IPEndPoint addrlist_v6_2(ip_number, 80); | |
514 | |
515 AddressList addrlist; | |
516 | |
517 // Test 1: IPv4 only. Expect no change. | |
518 addrlist.clear(); | |
519 addrlist.push_back(addrlist_v4_1); | |
520 addrlist.push_back(addrlist_v4_2); | |
521 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); | |
522 ASSERT_EQ(2u, addrlist.size()); | |
523 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); | |
524 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily()); | |
525 | |
526 // Test 2: IPv6 only. Expect no change. | |
527 addrlist.clear(); | |
528 addrlist.push_back(addrlist_v6_1); | |
529 addrlist.push_back(addrlist_v6_2); | |
530 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); | |
531 ASSERT_EQ(2u, addrlist.size()); | |
532 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[0].GetFamily()); | |
533 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[1].GetFamily()); | |
534 | |
535 // Test 3: IPv4 then IPv6. Expect no change. | |
536 addrlist.clear(); | |
537 addrlist.push_back(addrlist_v4_1); | |
538 addrlist.push_back(addrlist_v4_2); | |
539 addrlist.push_back(addrlist_v6_1); | |
540 addrlist.push_back(addrlist_v6_2); | |
541 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); | |
542 ASSERT_EQ(4u, addrlist.size()); | |
543 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); | |
544 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily()); | |
545 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[2].GetFamily()); | |
546 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily()); | |
547 | |
548 // Test 4: IPv6, IPv4, IPv6, IPv4. Expect first IPv6 moved to the end. | |
549 addrlist.clear(); | |
550 addrlist.push_back(addrlist_v6_1); | |
551 addrlist.push_back(addrlist_v4_1); | |
552 addrlist.push_back(addrlist_v6_2); | |
553 addrlist.push_back(addrlist_v4_2); | |
554 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); | |
555 ASSERT_EQ(4u, addrlist.size()); | |
556 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); | |
557 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[1].GetFamily()); | |
558 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[2].GetFamily()); | |
559 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily()); | |
560 | |
561 // Test 5: IPv6, IPv6, IPv4, IPv4. Expect first two IPv6's moved to the end. | |
562 addrlist.clear(); | |
563 addrlist.push_back(addrlist_v6_1); | |
564 addrlist.push_back(addrlist_v6_2); | |
565 addrlist.push_back(addrlist_v4_1); | |
566 addrlist.push_back(addrlist_v4_2); | |
567 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); | |
568 ASSERT_EQ(4u, addrlist.size()); | |
569 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); | |
570 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily()); | |
571 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[2].GetFamily()); | |
572 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily()); | |
573 } | |
574 | |
575 TEST_F(TransportClientSocketPoolTest, Basic) { | |
576 TestCompletionCallback callback; | 475 TestCompletionCallback callback; |
577 ClientSocketHandle handle; | 476 ClientSocketHandle handle; |
578 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_, | 477 int rv = handle.Init( |
579 BoundNetLog()); | 478 "a", params_, LOW, callback.callback(), &pool_, BoundNetLog()); |
580 EXPECT_EQ(ERR_IO_PENDING, rv); | 479 EXPECT_EQ(ERR_IO_PENDING, rv); |
581 EXPECT_FALSE(handle.is_initialized()); | 480 EXPECT_FALSE(handle.is_initialized()); |
582 EXPECT_FALSE(handle.socket()); | 481 EXPECT_FALSE(handle.socket()); |
583 | 482 |
584 EXPECT_EQ(OK, callback.WaitForResult()); | 483 EXPECT_EQ(OK, callback.WaitForResult()); |
585 EXPECT_TRUE(handle.is_initialized()); | 484 EXPECT_TRUE(handle.is_initialized()); |
586 EXPECT_TRUE(handle.socket()); | 485 EXPECT_TRUE(handle.socket()); |
587 TestLoadTimingInfoConnectedNotReused(handle); | 486 TestLoadTimingInfoConnectedNotReused(handle); |
588 } | 487 } |
589 | 488 |
590 // Make sure that TransportConnectJob passes on its priority to its | 489 // Make sure that WebSocketTransportConnectJob passes on its priority to its |
591 // HostResolver request on Init. | 490 // HostResolver request on Init. |
592 TEST_F(TransportClientSocketPoolTest, SetResolvePriorityOnInit) { | 491 TEST_F(WebSocketTransportClientSocketPoolTest, SetResolvePriorityOnInit) { |
593 for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) { | 492 for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) { |
594 RequestPriority priority = static_cast<RequestPriority>(i); | 493 RequestPriority priority = static_cast<RequestPriority>(i); |
595 TestCompletionCallback callback; | 494 TestCompletionCallback callback; |
596 ClientSocketHandle handle; | 495 ClientSocketHandle handle; |
597 EXPECT_EQ(ERR_IO_PENDING, | 496 EXPECT_EQ(ERR_IO_PENDING, |
598 handle.Init("a", params_, priority, callback.callback(), &pool_, | 497 handle.Init("a", |
| 498 params_, |
| 499 priority, |
| 500 callback.callback(), |
| 501 &pool_, |
599 BoundNetLog())); | 502 BoundNetLog())); |
600 EXPECT_EQ(priority, host_resolver_->last_request_priority()); | 503 EXPECT_EQ(priority, host_resolver_->last_request_priority()); |
601 } | 504 } |
602 } | 505 } |
603 | 506 |
604 TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) { | 507 TEST_F(WebSocketTransportClientSocketPoolTest, InitHostResolutionFailure) { |
605 host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name"); | 508 host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name"); |
606 TestCompletionCallback callback; | 509 TestCompletionCallback callback; |
607 ClientSocketHandle handle; | 510 ClientSocketHandle handle; |
608 HostPortPair host_port_pair("unresolvable.host.name", 80); | 511 HostPortPair host_port_pair("unresolvable.host.name", 80); |
609 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( | 512 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( |
610 host_port_pair, false, false, | 513 host_port_pair, false, false, OnHostResolutionCallback())); |
611 OnHostResolutionCallback())); | |
612 EXPECT_EQ(ERR_IO_PENDING, | 514 EXPECT_EQ(ERR_IO_PENDING, |
613 handle.Init("a", dest, kDefaultPriority, callback.callback(), | 515 handle.Init("a", |
614 &pool_, BoundNetLog())); | 516 dest, |
| 517 kDefaultPriority, |
| 518 callback.callback(), |
| 519 &pool_, |
| 520 BoundNetLog())); |
615 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult()); | 521 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult()); |
616 } | 522 } |
617 | 523 |
618 TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) { | 524 TEST_F(WebSocketTransportClientSocketPoolTest, InitConnectionFailure) { |
619 client_socket_factory_.set_client_socket_type( | 525 client_socket_factory_.set_client_socket_type( |
620 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET); | 526 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET); |
621 TestCompletionCallback callback; | 527 TestCompletionCallback callback; |
622 ClientSocketHandle handle; | 528 ClientSocketHandle handle; |
623 EXPECT_EQ(ERR_IO_PENDING, | 529 EXPECT_EQ(ERR_IO_PENDING, |
624 handle.Init("a", params_, kDefaultPriority, callback.callback(), | 530 handle.Init("a", |
625 &pool_, BoundNetLog())); | 531 params_, |
| 532 kDefaultPriority, |
| 533 callback.callback(), |
| 534 &pool_, |
| 535 BoundNetLog())); |
626 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 536 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
627 | 537 |
628 // Make the host resolutions complete synchronously this time. | 538 // Make the host resolutions complete synchronously this time. |
629 host_resolver_->set_synchronous_mode(true); | 539 host_resolver_->set_synchronous_mode(true); |
630 EXPECT_EQ(ERR_CONNECTION_FAILED, | 540 EXPECT_EQ(ERR_CONNECTION_FAILED, |
631 handle.Init("a", params_, kDefaultPriority, callback.callback(), | 541 handle.Init("a", |
632 &pool_, BoundNetLog())); | 542 params_, |
| 543 kDefaultPriority, |
| 544 callback.callback(), |
| 545 &pool_, |
| 546 BoundNetLog())); |
633 } | 547 } |
634 | 548 |
635 TEST_F(TransportClientSocketPoolTest, PendingRequests) { | 549 TEST_F(WebSocketTransportClientSocketPoolTest, PendingRequestsFinishFifo) { |
636 // First request finishes asynchronously. | 550 // First request finishes asynchronously. |
637 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 551 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
638 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); | 552 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); |
639 | 553 |
640 // Make all subsequent host resolutions complete synchronously. | 554 // Make all subsequent host resolutions complete synchronously. |
641 host_resolver_->set_synchronous_mode(true); | 555 host_resolver_->set_synchronous_mode(true); |
642 | 556 |
643 // Rest of them finish synchronously, until we reach the per-group limit. | 557 // Rest of them wait for the first socket to be released. |
644 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 558 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
645 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 559 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
646 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 560 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
647 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 561 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
648 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 562 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
649 | |
650 // The rest are pending since we've used all active sockets. | |
651 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); | |
652 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); | |
653 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); | |
654 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); | |
655 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); | |
656 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); | |
657 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); | |
658 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); | |
659 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); | |
660 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); | |
661 | 563 |
662 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); | 564 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); |
663 | 565 |
664 EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count()); | 566 EXPECT_EQ(6, client_socket_factory_.allocation_count()); |
665 | 567 |
666 // One initial asynchronous request and then 10 pending requests. | 568 // One initial asynchronous request and then 5 pending requests. |
667 EXPECT_EQ(11U, completion_count()); | 569 EXPECT_EQ(6U, completion_count()); |
668 | 570 |
669 // First part of requests, all with the same priority, finishes in FIFO order. | 571 // The requests finish in FIFO order. |
670 EXPECT_EQ(1, GetOrderOfRequest(1)); | 572 EXPECT_EQ(1, GetOrderOfRequest(1)); |
671 EXPECT_EQ(2, GetOrderOfRequest(2)); | 573 EXPECT_EQ(2, GetOrderOfRequest(2)); |
672 EXPECT_EQ(3, GetOrderOfRequest(3)); | 574 EXPECT_EQ(3, GetOrderOfRequest(3)); |
673 EXPECT_EQ(4, GetOrderOfRequest(4)); | 575 EXPECT_EQ(4, GetOrderOfRequest(4)); |
674 EXPECT_EQ(5, GetOrderOfRequest(5)); | 576 EXPECT_EQ(5, GetOrderOfRequest(5)); |
675 EXPECT_EQ(6, GetOrderOfRequest(6)); | 577 EXPECT_EQ(6, GetOrderOfRequest(6)); |
676 | 578 |
677 // Make sure that rest of the requests complete in the order of priority. | |
678 EXPECT_EQ(7, GetOrderOfRequest(7)); | |
679 EXPECT_EQ(14, GetOrderOfRequest(8)); | |
680 EXPECT_EQ(15, GetOrderOfRequest(9)); | |
681 EXPECT_EQ(10, GetOrderOfRequest(10)); | |
682 EXPECT_EQ(13, GetOrderOfRequest(11)); | |
683 EXPECT_EQ(8, GetOrderOfRequest(12)); | |
684 EXPECT_EQ(16, GetOrderOfRequest(13)); | |
685 EXPECT_EQ(11, GetOrderOfRequest(14)); | |
686 EXPECT_EQ(12, GetOrderOfRequest(15)); | |
687 EXPECT_EQ(9, GetOrderOfRequest(16)); | |
688 | |
689 // Make sure we test order of all requests made. | 579 // Make sure we test order of all requests made. |
690 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17)); | 580 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(7)); |
691 } | 581 } |
692 | 582 |
693 TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) { | 583 TEST_F(WebSocketTransportClientSocketPoolTest, PendingRequests_NoKeepAlive) { |
694 // First request finishes asynchronously. | 584 // First request finishes asynchronously. |
695 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 585 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
696 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); | 586 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); |
697 | 587 |
698 // Make all subsequent host resolutions complete synchronously. | 588 // Make all subsequent host resolutions complete synchronously. |
699 host_resolver_->set_synchronous_mode(true); | 589 host_resolver_->set_synchronous_mode(true); |
700 | 590 |
701 // Rest of them finish synchronously, until we reach the per-group limit. | 591 // Rest of them wait foe the first socket to be released. |
702 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | |
703 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | |
704 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | |
705 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | |
706 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | |
707 | |
708 // The rest are pending since we've used all active sockets. | |
709 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 592 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
710 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 593 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
711 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 594 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
712 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 595 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
713 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 596 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
714 | 597 |
715 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); | 598 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); |
716 | 599 |
717 // The pending requests should finish successfully. | 600 // The pending requests should finish successfully. |
718 EXPECT_EQ(OK, (*requests())[6]->WaitForResult()); | 601 EXPECT_EQ(OK, (*requests())[1]->WaitForResult()); |
719 EXPECT_EQ(OK, (*requests())[7]->WaitForResult()); | 602 EXPECT_EQ(OK, (*requests())[2]->WaitForResult()); |
720 EXPECT_EQ(OK, (*requests())[8]->WaitForResult()); | 603 EXPECT_EQ(OK, (*requests())[3]->WaitForResult()); |
721 EXPECT_EQ(OK, (*requests())[9]->WaitForResult()); | 604 EXPECT_EQ(OK, (*requests())[4]->WaitForResult()); |
722 EXPECT_EQ(OK, (*requests())[10]->WaitForResult()); | 605 EXPECT_EQ(OK, (*requests())[5]->WaitForResult()); |
723 | 606 |
724 EXPECT_EQ(static_cast<int>(requests()->size()), | 607 EXPECT_EQ(static_cast<int>(requests()->size()), |
725 client_socket_factory_.allocation_count()); | 608 client_socket_factory_.allocation_count()); |
726 | 609 |
727 // First asynchronous request, and then last 5 pending requests. | 610 // First asynchronous request, and then last 5 pending requests. |
728 EXPECT_EQ(6U, completion_count()); | 611 EXPECT_EQ(6U, completion_count()); |
729 } | 612 } |
730 | 613 |
731 // This test will start up a RequestSocket() and then immediately Cancel() it. | 614 // This test will start up a RequestSocket() and then immediately Cancel() it. |
732 // The pending host resolution will eventually complete, and destroy the | 615 // The pending host resolution will eventually complete, and destroy the |
733 // ClientSocketPool which will crash if the group was not cleared properly. | 616 // ClientSocketPool which will crash if the group was not cleared properly. |
734 TEST_F(TransportClientSocketPoolTest, CancelRequestClearGroup) { | 617 TEST_F(WebSocketTransportClientSocketPoolTest, CancelRequestClearGroup) { |
735 TestCompletionCallback callback; | 618 TestCompletionCallback callback; |
736 ClientSocketHandle handle; | 619 ClientSocketHandle handle; |
737 EXPECT_EQ(ERR_IO_PENDING, | 620 EXPECT_EQ(ERR_IO_PENDING, |
738 handle.Init("a", params_, kDefaultPriority, callback.callback(), | 621 handle.Init("a", |
739 &pool_, BoundNetLog())); | 622 params_, |
| 623 kDefaultPriority, |
| 624 callback.callback(), |
| 625 &pool_, |
| 626 BoundNetLog())); |
740 handle.Reset(); | 627 handle.Reset(); |
741 } | 628 } |
742 | 629 |
743 TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) { | 630 TEST_F(WebSocketTransportClientSocketPoolTest, TwoRequestsCancelOne) { |
744 ClientSocketHandle handle; | 631 ClientSocketHandle handle; |
745 TestCompletionCallback callback; | 632 TestCompletionCallback callback; |
746 ClientSocketHandle handle2; | 633 ClientSocketHandle handle2; |
747 TestCompletionCallback callback2; | 634 TestCompletionCallback callback2; |
748 | 635 |
749 EXPECT_EQ(ERR_IO_PENDING, | 636 EXPECT_EQ(ERR_IO_PENDING, |
750 handle.Init("a", params_, kDefaultPriority, callback.callback(), | 637 handle.Init("a", |
751 &pool_, BoundNetLog())); | 638 params_, |
| 639 kDefaultPriority, |
| 640 callback.callback(), |
| 641 &pool_, |
| 642 BoundNetLog())); |
752 EXPECT_EQ(ERR_IO_PENDING, | 643 EXPECT_EQ(ERR_IO_PENDING, |
753 handle2.Init("a", params_, kDefaultPriority, callback2.callback(), | 644 handle2.Init("a", |
754 &pool_, BoundNetLog())); | 645 params_, |
| 646 kDefaultPriority, |
| 647 callback2.callback(), |
| 648 &pool_, |
| 649 BoundNetLog())); |
755 | 650 |
756 handle.Reset(); | 651 handle.Reset(); |
757 | 652 |
758 EXPECT_EQ(OK, callback2.WaitForResult()); | 653 EXPECT_EQ(OK, callback2.WaitForResult()); |
759 handle2.Reset(); | 654 handle2.Reset(); |
760 } | 655 } |
761 | 656 |
762 TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) { | 657 TEST_F(WebSocketTransportClientSocketPoolTest, ConnectCancelConnect) { |
763 client_socket_factory_.set_client_socket_type( | 658 client_socket_factory_.set_client_socket_type( |
764 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); | 659 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); |
765 ClientSocketHandle handle; | 660 ClientSocketHandle handle; |
766 TestCompletionCallback callback; | 661 TestCompletionCallback callback; |
767 EXPECT_EQ(ERR_IO_PENDING, | 662 EXPECT_EQ(ERR_IO_PENDING, |
768 handle.Init("a", params_, kDefaultPriority, callback.callback(), | 663 handle.Init("a", |
769 &pool_, BoundNetLog())); | 664 params_, |
| 665 kDefaultPriority, |
| 666 callback.callback(), |
| 667 &pool_, |
| 668 BoundNetLog())); |
770 | 669 |
771 handle.Reset(); | 670 handle.Reset(); |
772 | 671 |
773 TestCompletionCallback callback2; | 672 TestCompletionCallback callback2; |
774 EXPECT_EQ(ERR_IO_PENDING, | 673 EXPECT_EQ(ERR_IO_PENDING, |
775 handle.Init("a", params_, kDefaultPriority, callback2.callback(), | 674 handle.Init("a", |
776 &pool_, BoundNetLog())); | 675 params_, |
| 676 kDefaultPriority, |
| 677 callback2.callback(), |
| 678 &pool_, |
| 679 BoundNetLog())); |
777 | 680 |
778 host_resolver_->set_synchronous_mode(true); | 681 host_resolver_->set_synchronous_mode(true); |
779 // At this point, handle has two ConnectingSockets out for it. Due to the | 682 // At this point, handle has two ConnectingSockets out for it. Due to the |
780 // setting the mock resolver into synchronous mode, the host resolution for | 683 // setting the mock resolver into synchronous mode, the host resolution for |
781 // both will return in the same loop of the MessageLoop. The client socket | 684 // both will return in the same loop of the MessageLoop. The client socket |
782 // is a pending socket, so the Connect() will asynchronously complete on the | 685 // is a pending socket, so the Connect() will asynchronously complete on the |
783 // next loop of the MessageLoop. That means that the first | 686 // next loop of the MessageLoop. That means that the first |
784 // ConnectingSocket will enter OnIOComplete, and then the second one will. | 687 // ConnectingSocket will enter OnIOComplete, and then the second one will. |
785 // If the first one is not cancelled, it will advance the load state, and | 688 // If the first one is not cancelled, it will advance the load state, and |
786 // then the second one will crash. | 689 // then the second one will crash. |
787 | 690 |
788 EXPECT_EQ(OK, callback2.WaitForResult()); | 691 EXPECT_EQ(OK, callback2.WaitForResult()); |
789 EXPECT_FALSE(callback.have_result()); | 692 EXPECT_FALSE(callback.have_result()); |
790 | 693 |
791 handle.Reset(); | 694 handle.Reset(); |
792 } | 695 } |
793 | 696 |
794 TEST_F(TransportClientSocketPoolTest, CancelRequest) { | 697 TEST_F(WebSocketTransportClientSocketPoolTest, CancelRequest) { |
795 // First request finishes asynchronously. | 698 // First request finishes asynchronously. |
796 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 699 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
797 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); | 700 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); |
798 | 701 |
799 // Make all subsequent host resolutions complete synchronously. | 702 // Make all subsequent host resolutions complete synchronously. |
800 host_resolver_->set_synchronous_mode(true); | 703 host_resolver_->set_synchronous_mode(true); |
801 | 704 |
802 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 705 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
803 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 706 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
804 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 707 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
805 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 708 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
806 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 709 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
807 | |
808 // Reached per-group limit, queue up requests. | |
809 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); | |
810 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); | |
811 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); | |
812 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); | |
813 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); | |
814 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); | |
815 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); | |
816 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); | |
817 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); | |
818 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); | |
819 | 710 |
820 // Cancel a request. | 711 // Cancel a request. |
821 size_t index_to_cancel = kMaxSocketsPerGroup + 2; | 712 const size_t index_to_cancel = 2; |
822 EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized()); | 713 EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized()); |
823 (*requests())[index_to_cancel]->handle()->Reset(); | 714 (*requests())[index_to_cancel]->handle()->Reset(); |
824 | 715 |
825 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); | 716 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); |
826 | 717 |
827 EXPECT_EQ(kMaxSocketsPerGroup, | 718 EXPECT_EQ(5, client_socket_factory_.allocation_count()); |
828 client_socket_factory_.allocation_count()); | |
829 EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count()); | |
830 | 719 |
831 EXPECT_EQ(1, GetOrderOfRequest(1)); | 720 EXPECT_EQ(1, GetOrderOfRequest(1)); |
832 EXPECT_EQ(2, GetOrderOfRequest(2)); | 721 EXPECT_EQ(2, GetOrderOfRequest(2)); |
833 EXPECT_EQ(3, GetOrderOfRequest(3)); | |
834 EXPECT_EQ(4, GetOrderOfRequest(4)); | |
835 EXPECT_EQ(5, GetOrderOfRequest(5)); | |
836 EXPECT_EQ(6, GetOrderOfRequest(6)); | |
837 EXPECT_EQ(14, GetOrderOfRequest(7)); | |
838 EXPECT_EQ(7, GetOrderOfRequest(8)); | |
839 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, | 722 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, |
840 GetOrderOfRequest(9)); // Canceled request. | 723 GetOrderOfRequest(3)); // Canceled request. |
841 EXPECT_EQ(9, GetOrderOfRequest(10)); | 724 EXPECT_EQ(3, GetOrderOfRequest(4)); |
842 EXPECT_EQ(10, GetOrderOfRequest(11)); | 725 EXPECT_EQ(4, GetOrderOfRequest(5)); |
843 EXPECT_EQ(11, GetOrderOfRequest(12)); | 726 EXPECT_EQ(5, GetOrderOfRequest(6)); |
844 EXPECT_EQ(8, GetOrderOfRequest(13)); | |
845 EXPECT_EQ(12, GetOrderOfRequest(14)); | |
846 EXPECT_EQ(13, GetOrderOfRequest(15)); | |
847 EXPECT_EQ(15, GetOrderOfRequest(16)); | |
848 | 727 |
849 // Make sure we test order of all requests made. | 728 // Make sure we test order of all requests made. |
850 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17)); | 729 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(7)); |
851 } | 730 } |
852 | 731 |
853 class RequestSocketCallback : public TestCompletionCallbackBase { | 732 class RequestSocketCallback : public TestCompletionCallbackBase { |
854 public: | 733 public: |
855 RequestSocketCallback(ClientSocketHandle* handle, | 734 RequestSocketCallback(ClientSocketHandle* handle, |
856 TransportClientSocketPool* pool) | 735 WebSocketTransportClientSocketPool* pool) |
857 : handle_(handle), | 736 : handle_(handle), |
858 pool_(pool), | 737 pool_(pool), |
859 within_callback_(false), | 738 within_callback_(false), |
860 callback_(base::Bind(&RequestSocketCallback::OnComplete, | 739 callback_(base::Bind(&RequestSocketCallback::OnComplete, |
861 base::Unretained(this))) { | 740 base::Unretained(this))) {} |
862 } | |
863 | 741 |
864 virtual ~RequestSocketCallback() {} | 742 virtual ~RequestSocketCallback() {} |
865 | 743 |
866 const CompletionCallback& callback() const { return callback_; } | 744 const CompletionCallback& callback() const { return callback_; } |
867 | 745 |
868 private: | 746 private: |
869 void OnComplete(int result) { | 747 void OnComplete(int result) { |
870 SetResult(result); | 748 SetResult(result); |
871 ASSERT_EQ(OK, result); | 749 ASSERT_EQ(OK, result); |
872 | 750 |
873 if (!within_callback_) { | 751 if (!within_callback_) { |
874 // Don't allow reuse of the socket. Disconnect it and then release it and | 752 // Don't allow reuse of the socket. Disconnect it and then release it and |
875 // run through the MessageLoop once to get it completely released. | 753 // run through the MessageLoop once to get it completely released. |
876 handle_->socket()->Disconnect(); | 754 handle_->socket()->Disconnect(); |
877 handle_->Reset(); | 755 handle_->Reset(); |
878 { | 756 { |
879 base::MessageLoop::ScopedNestableTaskAllower allow( | 757 base::MessageLoop::ScopedNestableTaskAllower allow( |
880 base::MessageLoop::current()); | 758 base::MessageLoop::current()); |
881 base::MessageLoop::current()->RunUntilIdle(); | 759 base::MessageLoop::current()->RunUntilIdle(); |
882 } | 760 } |
883 within_callback_ = true; | 761 within_callback_ = true; |
884 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( | 762 scoped_refptr<TransportSocketParams> dest( |
885 HostPortPair("www.google.com", 80), false, false, | 763 new TransportSocketParams(HostPortPair("www.google.com", 80), |
886 OnHostResolutionCallback())); | 764 false, |
887 int rv = handle_->Init("a", dest, LOWEST, callback(), pool_, | 765 false, |
888 BoundNetLog()); | 766 OnHostResolutionCallback())); |
| 767 int rv = |
| 768 handle_->Init("a", dest, LOWEST, callback(), pool_, BoundNetLog()); |
889 EXPECT_EQ(OK, rv); | 769 EXPECT_EQ(OK, rv); |
890 } | 770 } |
891 } | 771 } |
892 | 772 |
893 ClientSocketHandle* const handle_; | 773 ClientSocketHandle* const handle_; |
894 TransportClientSocketPool* const pool_; | 774 WebSocketTransportClientSocketPool* const pool_; |
895 bool within_callback_; | 775 bool within_callback_; |
896 CompletionCallback callback_; | 776 CompletionCallback callback_; |
897 | 777 |
898 DISALLOW_COPY_AND_ASSIGN(RequestSocketCallback); | 778 DISALLOW_COPY_AND_ASSIGN(RequestSocketCallback); |
899 }; | 779 }; |
900 | 780 |
901 TEST_F(TransportClientSocketPoolTest, RequestTwice) { | 781 TEST_F(WebSocketTransportClientSocketPoolTest, RequestTwice) { |
902 ClientSocketHandle handle; | 782 ClientSocketHandle handle; |
903 RequestSocketCallback callback(&handle, &pool_); | 783 RequestSocketCallback callback(&handle, &pool_); |
904 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( | 784 scoped_refptr<TransportSocketParams> dest( |
905 HostPortPair("www.google.com", 80), false, false, | 785 new TransportSocketParams(HostPortPair("www.google.com", 80), |
906 OnHostResolutionCallback())); | 786 false, |
907 int rv = handle.Init("a", dest, LOWEST, callback.callback(), &pool_, | 787 false, |
908 BoundNetLog()); | 788 OnHostResolutionCallback())); |
| 789 int rv = handle.Init( |
| 790 "a", dest, LOWEST, callback.callback(), &pool_, BoundNetLog()); |
909 ASSERT_EQ(ERR_IO_PENDING, rv); | 791 ASSERT_EQ(ERR_IO_PENDING, rv); |
910 | 792 |
911 // The callback is going to request "www.google.com". We want it to complete | 793 // The callback is going to request "www.google.com". We want it to complete |
912 // synchronously this time. | 794 // synchronously this time. |
913 host_resolver_->set_synchronous_mode(true); | 795 host_resolver_->set_synchronous_mode(true); |
914 | 796 |
915 EXPECT_EQ(OK, callback.WaitForResult()); | 797 EXPECT_EQ(OK, callback.WaitForResult()); |
916 | 798 |
917 handle.Reset(); | 799 handle.Reset(); |
918 } | 800 } |
919 | 801 |
920 // Make sure that pending requests get serviced after active requests get | 802 // Make sure that pending requests get serviced after active requests get |
921 // cancelled. | 803 // cancelled. |
922 TEST_F(TransportClientSocketPoolTest, CancelActiveRequestWithPendingRequests) { | 804 TEST_F(WebSocketTransportClientSocketPoolTest, |
| 805 CancelActiveRequestWithPendingRequests) { |
923 client_socket_factory_.set_client_socket_type( | 806 client_socket_factory_.set_client_socket_type( |
924 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); | 807 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); |
925 | 808 |
926 // Queue up all the requests | 809 // Queue up all the requests |
927 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 810 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
928 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 811 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
929 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 812 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
930 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 813 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
931 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 814 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
932 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 815 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
933 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 816 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
934 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 817 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
935 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 818 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
936 | 819 |
937 // Now, kMaxSocketsPerGroup requests should be active. Let's cancel them. | 820 // Now, kMaxSocketsPerGroup requests should be active. Let's cancel them. |
938 ASSERT_LE(kMaxSocketsPerGroup, static_cast<int>(requests()->size())); | 821 ASSERT_LE(kMaxSocketsPerGroup, static_cast<int>(requests()->size())); |
939 for (int i = 0; i < kMaxSocketsPerGroup; i++) | 822 for (int i = 0; i < kMaxSocketsPerGroup; i++) |
940 (*requests())[i]->handle()->Reset(); | 823 (*requests())[i]->handle()->Reset(); |
941 | 824 |
942 // Let's wait for the rest to complete now. | 825 // Let's wait for the rest to complete now. |
943 for (size_t i = kMaxSocketsPerGroup; i < requests()->size(); ++i) { | 826 for (size_t i = kMaxSocketsPerGroup; i < requests()->size(); ++i) { |
944 EXPECT_EQ(OK, (*requests())[i]->WaitForResult()); | 827 EXPECT_EQ(OK, (*requests())[i]->WaitForResult()); |
945 (*requests())[i]->handle()->Reset(); | 828 (*requests())[i]->handle()->Reset(); |
946 } | 829 } |
947 | 830 |
948 EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count()); | 831 EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count()); |
949 } | 832 } |
950 | 833 |
951 // Make sure that pending requests get serviced after active requests fail. | 834 // Make sure that pending requests get serviced after active requests fail. |
952 TEST_F(TransportClientSocketPoolTest, FailingActiveRequestWithPendingRequests) { | 835 TEST_F(WebSocketTransportClientSocketPoolTest, |
| 836 FailingActiveRequestWithPendingRequests) { |
953 client_socket_factory_.set_client_socket_type( | 837 client_socket_factory_.set_client_socket_type( |
954 MockClientSocketFactory::MOCK_PENDING_FAILING_CLIENT_SOCKET); | 838 MockClientSocketFactory::MOCK_PENDING_FAILING_CLIENT_SOCKET); |
955 | 839 |
956 const int kNumRequests = 2 * kMaxSocketsPerGroup + 1; | 840 const int kNumRequests = 2 * kMaxSocketsPerGroup + 1; |
957 ASSERT_LE(kNumRequests, kMaxSockets); // Otherwise the test will hang. | 841 ASSERT_LE(kNumRequests, kMaxSockets); // Otherwise the test will hang. |
958 | 842 |
959 // Queue up all the requests | 843 // Queue up all the requests |
960 for (int i = 0; i < kNumRequests; i++) | 844 for (int i = 0; i < kNumRequests; i++) |
961 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 845 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
962 | 846 |
963 for (int i = 0; i < kNumRequests; i++) | 847 for (int i = 0; i < kNumRequests; i++) |
964 EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult()); | 848 EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult()); |
965 } | 849 } |
966 | 850 |
967 TEST_F(TransportClientSocketPoolTest, IdleSocketLoadTiming) { | |
968 TestCompletionCallback callback; | |
969 ClientSocketHandle handle; | |
970 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_, | |
971 BoundNetLog()); | |
972 EXPECT_EQ(ERR_IO_PENDING, rv); | |
973 EXPECT_FALSE(handle.is_initialized()); | |
974 EXPECT_FALSE(handle.socket()); | |
975 | |
976 EXPECT_EQ(OK, callback.WaitForResult()); | |
977 EXPECT_TRUE(handle.is_initialized()); | |
978 EXPECT_TRUE(handle.socket()); | |
979 TestLoadTimingInfoConnectedNotReused(handle); | |
980 | |
981 handle.Reset(); | |
982 // Need to run all pending to release the socket back to the pool. | |
983 base::MessageLoop::current()->RunUntilIdle(); | |
984 | |
985 // Now we should have 1 idle socket. | |
986 EXPECT_EQ(1, pool_.IdleSocketCount()); | |
987 | |
988 rv = handle.Init("a", params_, LOW, callback.callback(), &pool_, | |
989 BoundNetLog()); | |
990 EXPECT_EQ(OK, rv); | |
991 EXPECT_EQ(0, pool_.IdleSocketCount()); | |
992 TestLoadTimingInfoConnectedReused(handle); | |
993 } | |
994 | |
995 TEST_F(TransportClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) { | |
996 TestCompletionCallback callback; | |
997 ClientSocketHandle handle; | |
998 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_, | |
999 BoundNetLog()); | |
1000 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1001 EXPECT_FALSE(handle.is_initialized()); | |
1002 EXPECT_FALSE(handle.socket()); | |
1003 | |
1004 EXPECT_EQ(OK, callback.WaitForResult()); | |
1005 EXPECT_TRUE(handle.is_initialized()); | |
1006 EXPECT_TRUE(handle.socket()); | |
1007 | |
1008 handle.Reset(); | |
1009 | |
1010 // Need to run all pending to release the socket back to the pool. | |
1011 base::MessageLoop::current()->RunUntilIdle(); | |
1012 | |
1013 // Now we should have 1 idle socket. | |
1014 EXPECT_EQ(1, pool_.IdleSocketCount()); | |
1015 | |
1016 // After an IP address change, we should have 0 idle sockets. | |
1017 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); | |
1018 base::MessageLoop::current()->RunUntilIdle(); // Notification happens async. | |
1019 | |
1020 EXPECT_EQ(0, pool_.IdleSocketCount()); | |
1021 } | |
1022 | |
1023 TEST_F(TransportClientSocketPoolTest, BackupSocketConnect) { | |
1024 // Case 1 tests the first socket stalling, and the backup connecting. | |
1025 MockClientSocketFactory::ClientSocketType case1_types[] = { | |
1026 // The first socket will not connect. | |
1027 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, | |
1028 // The second socket will connect more quickly. | |
1029 MockClientSocketFactory::MOCK_CLIENT_SOCKET | |
1030 }; | |
1031 | |
1032 // Case 2 tests the first socket being slow, so that we start the | |
1033 // second connect, but the second connect stalls, and we still | |
1034 // complete the first. | |
1035 MockClientSocketFactory::ClientSocketType case2_types[] = { | |
1036 // The first socket will connect, although delayed. | |
1037 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, | |
1038 // The second socket will not connect. | |
1039 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET | |
1040 }; | |
1041 | |
1042 MockClientSocketFactory::ClientSocketType* cases[2] = { | |
1043 case1_types, | |
1044 case2_types | |
1045 }; | |
1046 | |
1047 for (size_t index = 0; index < arraysize(cases); ++index) { | |
1048 client_socket_factory_.set_client_socket_types(cases[index], 2); | |
1049 | |
1050 EXPECT_EQ(0, pool_.IdleSocketCount()); | |
1051 | |
1052 TestCompletionCallback callback; | |
1053 ClientSocketHandle handle; | |
1054 int rv = handle.Init("b", params_, LOW, callback.callback(), &pool_, | |
1055 BoundNetLog()); | |
1056 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1057 EXPECT_FALSE(handle.is_initialized()); | |
1058 EXPECT_FALSE(handle.socket()); | |
1059 | |
1060 // Create the first socket, set the timer. | |
1061 base::MessageLoop::current()->RunUntilIdle(); | |
1062 | |
1063 // Wait for the backup socket timer to fire. | |
1064 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( | |
1065 ClientSocketPool::kMaxConnectRetryIntervalMs + 50)); | |
1066 | |
1067 // Let the appropriate socket connect. | |
1068 base::MessageLoop::current()->RunUntilIdle(); | |
1069 | |
1070 EXPECT_EQ(OK, callback.WaitForResult()); | |
1071 EXPECT_TRUE(handle.is_initialized()); | |
1072 EXPECT_TRUE(handle.socket()); | |
1073 | |
1074 // One socket is stalled, the other is active. | |
1075 EXPECT_EQ(0, pool_.IdleSocketCount()); | |
1076 handle.Reset(); | |
1077 | |
1078 // Close all pending connect jobs and existing sockets. | |
1079 pool_.FlushWithError(ERR_NETWORK_CHANGED); | |
1080 } | |
1081 } | |
1082 | |
1083 // Test the case where a socket took long enough to start the creation | |
1084 // of the backup socket, but then we cancelled the request after that. | |
1085 TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) { | |
1086 client_socket_factory_.set_client_socket_type( | |
1087 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET); | |
1088 | |
1089 enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT }; | |
1090 | |
1091 for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) { | |
1092 EXPECT_EQ(0, pool_.IdleSocketCount()); | |
1093 | |
1094 TestCompletionCallback callback; | |
1095 ClientSocketHandle handle; | |
1096 int rv = handle.Init("c", params_, LOW, callback.callback(), &pool_, | |
1097 BoundNetLog()); | |
1098 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1099 EXPECT_FALSE(handle.is_initialized()); | |
1100 EXPECT_FALSE(handle.socket()); | |
1101 | |
1102 // Create the first socket, set the timer. | |
1103 base::MessageLoop::current()->RunUntilIdle(); | |
1104 | |
1105 if (index == CANCEL_AFTER_WAIT) { | |
1106 // Wait for the backup socket timer to fire. | |
1107 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( | |
1108 ClientSocketPool::kMaxConnectRetryIntervalMs)); | |
1109 } | |
1110 | |
1111 // Let the appropriate socket connect. | |
1112 base::MessageLoop::current()->RunUntilIdle(); | |
1113 | |
1114 handle.Reset(); | |
1115 | |
1116 EXPECT_FALSE(callback.have_result()); | |
1117 EXPECT_FALSE(handle.is_initialized()); | |
1118 EXPECT_FALSE(handle.socket()); | |
1119 | |
1120 // One socket is stalled, the other is active. | |
1121 EXPECT_EQ(0, pool_.IdleSocketCount()); | |
1122 } | |
1123 } | |
1124 | |
1125 // Test the case where a socket took long enough to start the creation | |
1126 // of the backup socket and never completes, and then the backup | |
1127 // connection fails. | |
1128 TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterStall) { | |
1129 MockClientSocketFactory::ClientSocketType case_types[] = { | |
1130 // The first socket will not connect. | |
1131 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, | |
1132 // The second socket will fail immediately. | |
1133 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET | |
1134 }; | |
1135 | |
1136 client_socket_factory_.set_client_socket_types(case_types, 2); | |
1137 | |
1138 EXPECT_EQ(0, pool_.IdleSocketCount()); | |
1139 | |
1140 TestCompletionCallback callback; | |
1141 ClientSocketHandle handle; | |
1142 int rv = handle.Init("b", params_, LOW, callback.callback(), &pool_, | |
1143 BoundNetLog()); | |
1144 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1145 EXPECT_FALSE(handle.is_initialized()); | |
1146 EXPECT_FALSE(handle.socket()); | |
1147 | |
1148 // Create the first socket, set the timer. | |
1149 base::MessageLoop::current()->RunUntilIdle(); | |
1150 | |
1151 // Wait for the backup socket timer to fire. | |
1152 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( | |
1153 ClientSocketPool::kMaxConnectRetryIntervalMs)); | |
1154 | |
1155 // Let the second connect be synchronous. Otherwise, the emulated | |
1156 // host resolution takes an extra trip through the message loop. | |
1157 host_resolver_->set_synchronous_mode(true); | |
1158 | |
1159 // Let the appropriate socket connect. | |
1160 base::MessageLoop::current()->RunUntilIdle(); | |
1161 | |
1162 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | |
1163 EXPECT_FALSE(handle.is_initialized()); | |
1164 EXPECT_FALSE(handle.socket()); | |
1165 EXPECT_EQ(0, pool_.IdleSocketCount()); | |
1166 handle.Reset(); | |
1167 | |
1168 // Reset for the next case. | |
1169 host_resolver_->set_synchronous_mode(false); | |
1170 } | |
1171 | |
1172 // Test the case where a socket took long enough to start the creation | |
1173 // of the backup socket and eventually completes, but the backup socket | |
1174 // fails. | |
1175 TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) { | |
1176 MockClientSocketFactory::ClientSocketType case_types[] = { | |
1177 // The first socket will connect, although delayed. | |
1178 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, | |
1179 // The second socket will not connect. | |
1180 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET | |
1181 }; | |
1182 | |
1183 client_socket_factory_.set_client_socket_types(case_types, 2); | |
1184 client_socket_factory_.set_delay(base::TimeDelta::FromSeconds(5)); | |
1185 | |
1186 EXPECT_EQ(0, pool_.IdleSocketCount()); | |
1187 | |
1188 TestCompletionCallback callback; | |
1189 ClientSocketHandle handle; | |
1190 int rv = handle.Init("b", params_, LOW, callback.callback(), &pool_, | |
1191 BoundNetLog()); | |
1192 EXPECT_EQ(ERR_IO_PENDING, rv); | |
1193 EXPECT_FALSE(handle.is_initialized()); | |
1194 EXPECT_FALSE(handle.socket()); | |
1195 | |
1196 // Create the first socket, set the timer. | |
1197 base::MessageLoop::current()->RunUntilIdle(); | |
1198 | |
1199 // Wait for the backup socket timer to fire. | |
1200 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( | |
1201 ClientSocketPool::kMaxConnectRetryIntervalMs)); | |
1202 | |
1203 // Let the second connect be synchronous. Otherwise, the emulated | |
1204 // host resolution takes an extra trip through the message loop. | |
1205 host_resolver_->set_synchronous_mode(true); | |
1206 | |
1207 // Let the appropriate socket connect. | |
1208 base::MessageLoop::current()->RunUntilIdle(); | |
1209 | |
1210 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | |
1211 EXPECT_FALSE(handle.is_initialized()); | |
1212 EXPECT_FALSE(handle.socket()); | |
1213 handle.Reset(); | |
1214 | |
1215 // Reset for the next case. | |
1216 host_resolver_->set_synchronous_mode(false); | |
1217 } | |
1218 | |
1219 // Test the case of the IPv6 address stalling, and falling back to the IPv4 | 851 // Test the case of the IPv6 address stalling, and falling back to the IPv4 |
1220 // socket which finishes first. | 852 // socket which finishes first. |
1221 TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv4FinishesFirst) { | 853 TEST_F(WebSocketTransportClientSocketPoolTest, |
| 854 IPv6FallbackSocketIPv4FinishesFirst) { |
1222 // Create a pool without backup jobs. | 855 // Create a pool without backup jobs. |
1223 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); | 856 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); |
1224 TransportClientSocketPool pool(kMaxSockets, | 857 WebSocketTransportClientSocketPool pool(kMaxSockets, |
1225 kMaxSocketsPerGroup, | 858 kMaxSocketsPerGroup, |
1226 histograms_.get(), | 859 histograms_.get(), |
1227 host_resolver_.get(), | 860 host_resolver_.get(), |
1228 &client_socket_factory_, | 861 &client_socket_factory_, |
1229 NULL); | 862 NULL); |
1230 | 863 |
1231 MockClientSocketFactory::ClientSocketType case_types[] = { | 864 MockClientSocketFactory::ClientSocketType case_types[] = { |
1232 // This is the IPv6 socket. | 865 // This is the IPv6 socket. |
1233 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, | 866 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, |
1234 // This is the IPv4 socket. | 867 // This is the IPv4 socket. |
1235 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET | 868 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET}; |
1236 }; | |
1237 | 869 |
1238 client_socket_factory_.set_client_socket_types(case_types, 2); | 870 client_socket_factory_.set_client_socket_types(case_types, 2); |
1239 | 871 |
1240 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. | 872 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. |
1241 host_resolver_->rules() | 873 host_resolver_->rules()->AddIPLiteralRule( |
1242 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); | 874 "*", "2:abcd::3:4:ff,2.2.2.2", std::string()); |
1243 | 875 |
1244 TestCompletionCallback callback; | 876 TestCompletionCallback callback; |
1245 ClientSocketHandle handle; | 877 ClientSocketHandle handle; |
1246 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool, | 878 int rv = |
1247 BoundNetLog()); | 879 handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog()); |
1248 EXPECT_EQ(ERR_IO_PENDING, rv); | 880 EXPECT_EQ(ERR_IO_PENDING, rv); |
1249 EXPECT_FALSE(handle.is_initialized()); | 881 EXPECT_FALSE(handle.is_initialized()); |
1250 EXPECT_FALSE(handle.socket()); | 882 EXPECT_FALSE(handle.socket()); |
1251 | 883 |
1252 EXPECT_EQ(OK, callback.WaitForResult()); | 884 EXPECT_EQ(OK, callback.WaitForResult()); |
1253 EXPECT_TRUE(handle.is_initialized()); | 885 EXPECT_TRUE(handle.is_initialized()); |
1254 EXPECT_TRUE(handle.socket()); | 886 EXPECT_TRUE(handle.socket()); |
1255 IPEndPoint endpoint; | 887 IPEndPoint endpoint; |
1256 handle.socket()->GetLocalAddress(&endpoint); | 888 handle.socket()->GetLocalAddress(&endpoint); |
1257 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); | 889 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); |
1258 EXPECT_EQ(2, client_socket_factory_.allocation_count()); | 890 EXPECT_EQ(2, client_socket_factory_.allocation_count()); |
1259 } | 891 } |
1260 | 892 |
1261 // Test the case of the IPv6 address being slow, thus falling back to trying to | 893 // Test the case of the IPv6 address being slow, thus falling back to trying to |
1262 // connect to the IPv4 address, but having the connect to the IPv6 address | 894 // connect to the IPv4 address, but having the connect to the IPv6 address |
1263 // finish first. | 895 // finish first. |
1264 TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv6FinishesFirst) { | 896 TEST_F(WebSocketTransportClientSocketPoolTest, |
| 897 IPv6FallbackSocketIPv6FinishesFirst) { |
1265 // Create a pool without backup jobs. | 898 // Create a pool without backup jobs. |
1266 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); | 899 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); |
1267 TransportClientSocketPool pool(kMaxSockets, | 900 WebSocketTransportClientSocketPool pool(kMaxSockets, |
1268 kMaxSocketsPerGroup, | 901 kMaxSocketsPerGroup, |
1269 histograms_.get(), | 902 histograms_.get(), |
1270 host_resolver_.get(), | 903 host_resolver_.get(), |
1271 &client_socket_factory_, | 904 &client_socket_factory_, |
1272 NULL); | 905 NULL); |
1273 | 906 |
1274 MockClientSocketFactory::ClientSocketType case_types[] = { | 907 MockClientSocketFactory::ClientSocketType case_types[] = { |
1275 // This is the IPv6 socket. | 908 // This is the IPv6 socket. |
1276 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, | 909 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, |
1277 // This is the IPv4 socket. | 910 // This is the IPv4 socket. |
1278 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET | 911 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET}; |
1279 }; | |
1280 | 912 |
1281 client_socket_factory_.set_client_socket_types(case_types, 2); | 913 client_socket_factory_.set_client_socket_types(case_types, 2); |
1282 client_socket_factory_.set_delay(base::TimeDelta::FromMilliseconds( | 914 client_socket_factory_.set_delay(base::TimeDelta::FromMilliseconds( |
1283 TransportConnectJob::kIPv6FallbackTimerInMs + 50)); | 915 WebSocketTransportConnectJob::kIPv6FallbackTimerInMs + 50)); |
1284 | 916 |
1285 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. | 917 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. |
1286 host_resolver_->rules() | 918 host_resolver_->rules()->AddIPLiteralRule( |
1287 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); | 919 "*", "2:abcd::3:4:ff,2.2.2.2", std::string()); |
1288 | 920 |
1289 TestCompletionCallback callback; | 921 TestCompletionCallback callback; |
1290 ClientSocketHandle handle; | 922 ClientSocketHandle handle; |
1291 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool, | 923 int rv = |
1292 BoundNetLog()); | 924 handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog()); |
1293 EXPECT_EQ(ERR_IO_PENDING, rv); | 925 EXPECT_EQ(ERR_IO_PENDING, rv); |
1294 EXPECT_FALSE(handle.is_initialized()); | 926 EXPECT_FALSE(handle.is_initialized()); |
1295 EXPECT_FALSE(handle.socket()); | 927 EXPECT_FALSE(handle.socket()); |
1296 | 928 |
1297 EXPECT_EQ(OK, callback.WaitForResult()); | 929 EXPECT_EQ(OK, callback.WaitForResult()); |
1298 EXPECT_TRUE(handle.is_initialized()); | 930 EXPECT_TRUE(handle.is_initialized()); |
1299 EXPECT_TRUE(handle.socket()); | 931 EXPECT_TRUE(handle.socket()); |
1300 IPEndPoint endpoint; | 932 IPEndPoint endpoint; |
1301 handle.socket()->GetLocalAddress(&endpoint); | 933 handle.socket()->GetLocalAddress(&endpoint); |
1302 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); | 934 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); |
1303 EXPECT_EQ(2, client_socket_factory_.allocation_count()); | 935 EXPECT_EQ(2, client_socket_factory_.allocation_count()); |
1304 } | 936 } |
1305 | 937 |
1306 TEST_F(TransportClientSocketPoolTest, IPv6NoIPv4AddressesToFallbackTo) { | 938 TEST_F(WebSocketTransportClientSocketPoolTest, |
| 939 IPv6NoIPv4AddressesToFallbackTo) { |
1307 // Create a pool without backup jobs. | 940 // Create a pool without backup jobs. |
1308 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); | 941 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); |
1309 TransportClientSocketPool pool(kMaxSockets, | 942 WebSocketTransportClientSocketPool pool(kMaxSockets, |
1310 kMaxSocketsPerGroup, | 943 kMaxSocketsPerGroup, |
1311 histograms_.get(), | 944 histograms_.get(), |
1312 host_resolver_.get(), | 945 host_resolver_.get(), |
1313 &client_socket_factory_, | 946 &client_socket_factory_, |
1314 NULL); | 947 NULL); |
1315 | 948 |
1316 client_socket_factory_.set_client_socket_type( | 949 client_socket_factory_.set_client_socket_type( |
1317 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); | 950 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); |
1318 | 951 |
1319 // Resolve an AddressList with only IPv6 addresses. | 952 // Resolve an AddressList with only IPv6 addresses. |
1320 host_resolver_->rules() | 953 host_resolver_->rules()->AddIPLiteralRule( |
1321 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string()); | 954 "*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string()); |
1322 | 955 |
1323 TestCompletionCallback callback; | 956 TestCompletionCallback callback; |
1324 ClientSocketHandle handle; | 957 ClientSocketHandle handle; |
1325 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool, | 958 int rv = |
1326 BoundNetLog()); | 959 handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog()); |
1327 EXPECT_EQ(ERR_IO_PENDING, rv); | 960 EXPECT_EQ(ERR_IO_PENDING, rv); |
1328 EXPECT_FALSE(handle.is_initialized()); | 961 EXPECT_FALSE(handle.is_initialized()); |
1329 EXPECT_FALSE(handle.socket()); | 962 EXPECT_FALSE(handle.socket()); |
1330 | 963 |
1331 EXPECT_EQ(OK, callback.WaitForResult()); | 964 EXPECT_EQ(OK, callback.WaitForResult()); |
1332 EXPECT_TRUE(handle.is_initialized()); | 965 EXPECT_TRUE(handle.is_initialized()); |
1333 EXPECT_TRUE(handle.socket()); | 966 EXPECT_TRUE(handle.socket()); |
1334 IPEndPoint endpoint; | 967 IPEndPoint endpoint; |
1335 handle.socket()->GetLocalAddress(&endpoint); | 968 handle.socket()->GetLocalAddress(&endpoint); |
1336 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); | 969 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); |
1337 EXPECT_EQ(1, client_socket_factory_.allocation_count()); | 970 EXPECT_EQ(1, client_socket_factory_.allocation_count()); |
1338 } | 971 } |
1339 | 972 |
1340 TEST_F(TransportClientSocketPoolTest, IPv4HasNoFallback) { | 973 TEST_F(WebSocketTransportClientSocketPoolTest, IPv4HasNoFallback) { |
1341 // Create a pool without backup jobs. | 974 // Create a pool without backup jobs. |
1342 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); | 975 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); |
1343 TransportClientSocketPool pool(kMaxSockets, | 976 WebSocketTransportClientSocketPool pool(kMaxSockets, |
1344 kMaxSocketsPerGroup, | 977 kMaxSocketsPerGroup, |
1345 histograms_.get(), | 978 histograms_.get(), |
1346 host_resolver_.get(), | 979 host_resolver_.get(), |
1347 &client_socket_factory_, | 980 &client_socket_factory_, |
1348 NULL); | 981 NULL); |
1349 | 982 |
1350 client_socket_factory_.set_client_socket_type( | 983 client_socket_factory_.set_client_socket_type( |
1351 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); | 984 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); |
1352 | 985 |
1353 // Resolve an AddressList with only IPv4 addresses. | 986 // Resolve an AddressList with only IPv4 addresses. |
1354 host_resolver_->rules()->AddIPLiteralRule("*", "1.1.1.1", std::string()); | 987 host_resolver_->rules()->AddIPLiteralRule("*", "1.1.1.1", std::string()); |
1355 | 988 |
1356 TestCompletionCallback callback; | 989 TestCompletionCallback callback; |
1357 ClientSocketHandle handle; | 990 ClientSocketHandle handle; |
1358 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool, | 991 int rv = |
1359 BoundNetLog()); | 992 handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog()); |
1360 EXPECT_EQ(ERR_IO_PENDING, rv); | 993 EXPECT_EQ(ERR_IO_PENDING, rv); |
1361 EXPECT_FALSE(handle.is_initialized()); | 994 EXPECT_FALSE(handle.is_initialized()); |
1362 EXPECT_FALSE(handle.socket()); | 995 EXPECT_FALSE(handle.socket()); |
1363 | 996 |
1364 EXPECT_EQ(OK, callback.WaitForResult()); | 997 EXPECT_EQ(OK, callback.WaitForResult()); |
1365 EXPECT_TRUE(handle.is_initialized()); | 998 EXPECT_TRUE(handle.is_initialized()); |
1366 EXPECT_TRUE(handle.socket()); | 999 EXPECT_TRUE(handle.socket()); |
1367 IPEndPoint endpoint; | 1000 IPEndPoint endpoint; |
1368 handle.socket()->GetLocalAddress(&endpoint); | 1001 handle.socket()->GetLocalAddress(&endpoint); |
1369 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); | 1002 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); |
1370 EXPECT_EQ(1, client_socket_factory_.allocation_count()); | 1003 EXPECT_EQ(1, client_socket_factory_.allocation_count()); |
1371 } | 1004 } |
1372 | 1005 |
1373 } // namespace | 1006 } // namespace |
1374 | 1007 |
1375 } // namespace net | 1008 } // namespace net |
OLD | NEW |