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
3 // found in the LICENSE file.
5 #include "net/http/http_proxy_client_socket_pool.h"
7 #include "base/callback.h"
8 #include "base/compiler_specific.h"
9 #include "base/run_loop.h"
10 #include "base/strings/string_util.h"
11 #include "base/strings/utf_string_conversions.h"
12 #include "base/time/time.h"
13 #include "net/base/auth.h"
14 #include "net/base/load_timing_info.h"
15 #include "net/base/load_timing_info_test_util.h"
16 #include "net/base/net_errors.h"
17 #include "net/base/test_completion_callback.h"
18 #include "net/cert/cert_verifier.h"
19 #include "net/dns/mock_host_resolver.h"
20 #include "net/http/http_auth_handler_factory.h"
21 #include "net/http/http_network_session.h"
22 #include "net/http/http_request_headers.h"
23 #include "net/http/http_response_headers.h"
24 #include "net/http/http_server_properties_impl.h"
25 #include "net/http/transport_security_state.h"
26 #include "net/proxy/proxy_service.h"
27 #include "net/socket/client_socket_handle.h"
28 #include "net/socket/client_socket_pool_histograms.h"
29 #include "net/socket/next_proto.h"
30 #include "net/socket/socket_test_util.h"
31 #include "net/spdy/spdy_session.h"
32 #include "net/spdy/spdy_session_pool.h"
33 #include "net/spdy/spdy_test_util_common.h"
34 #include "net/ssl/ssl_config_service_defaults.h"
35 #include "net/test/test_certificate_data.h"
36 #include "testing/gtest/include/gtest/gtest.h"
42 const int kMaxSockets
= 32;
43 const int kMaxSocketsPerGroup
= 6;
45 // Make sure |handle|'s load times are set correctly. DNS and connect start
46 // times comes from mock client sockets in these tests, so primarily serves to
47 // check those times were copied, and ssl times / connect end are set correctly.
48 void TestLoadTimingInfo(const ClientSocketHandle
& handle
) {
49 LoadTimingInfo load_timing_info
;
50 EXPECT_TRUE(handle
.GetLoadTimingInfo(false, &load_timing_info
));
52 EXPECT_FALSE(load_timing_info
.socket_reused
);
53 // None of these tests use a NetLog.
54 EXPECT_EQ(NetLog::Source::kInvalidId
, load_timing_info
.socket_log_id
);
56 ExpectConnectTimingHasTimes(
57 load_timing_info
.connect_timing
,
58 CONNECT_TIMING_HAS_SSL_TIMES
| CONNECT_TIMING_HAS_DNS_TIMES
);
59 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info
);
62 // Just like TestLoadTimingInfo, except DNS times are expected to be null, for
63 // tests over proxies that do DNS lookups themselves.
64 void TestLoadTimingInfoNoDns(const ClientSocketHandle
& handle
) {
65 LoadTimingInfo load_timing_info
;
66 EXPECT_TRUE(handle
.GetLoadTimingInfo(false, &load_timing_info
));
68 // None of these tests use a NetLog.
69 EXPECT_EQ(NetLog::Source::kInvalidId
, load_timing_info
.socket_log_id
);
71 EXPECT_FALSE(load_timing_info
.socket_reused
);
73 ExpectConnectTimingHasTimes(load_timing_info
.connect_timing
,
74 CONNECT_TIMING_HAS_SSL_TIMES
);
75 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info
);
78 class SSLClientSocketPoolTest
79 : public testing::Test
,
80 public ::testing::WithParamInterface
<NextProto
> {
82 SSLClientSocketPoolTest()
83 : transport_security_state_(new TransportSecurityState
),
84 proxy_service_(ProxyService::CreateDirect()),
85 ssl_config_service_(new SSLConfigServiceDefaults
),
86 http_auth_handler_factory_(
87 HttpAuthHandlerFactory::CreateDefault(&host_resolver_
)),
88 session_(CreateNetworkSession()),
89 direct_transport_socket_params_(
90 new TransportSocketParams(
91 HostPortPair("host", 443),
94 OnHostResolutionCallback(),
95 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT
)),
96 transport_histograms_("MockTCP"),
97 transport_socket_pool_(kMaxSockets
,
99 &transport_histograms_
,
101 proxy_transport_socket_params_(
102 new TransportSocketParams(
103 HostPortPair("proxy", 443),
106 OnHostResolutionCallback(),
107 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT
)),
108 socks_socket_params_(
109 new SOCKSSocketParams(proxy_transport_socket_params_
,
111 HostPortPair("sockshost", 443))),
112 socks_histograms_("MockSOCKS"),
113 socks_socket_pool_(kMaxSockets
,
116 &transport_socket_pool_
),
117 http_proxy_socket_params_(
118 new HttpProxySocketParams(proxy_transport_socket_params_
,
122 HostPortPair("host", 80),
123 session_
->http_auth_cache(),
124 session_
->http_auth_handler_factory(),
125 session_
->spdy_session_pool(),
128 http_proxy_histograms_("MockHttpProxy"),
129 http_proxy_socket_pool_(kMaxSockets
,
131 &http_proxy_histograms_
,
133 &transport_socket_pool_
,
137 enable_ssl_connect_job_waiting_(false) {
138 scoped_refptr
<SSLConfigService
> ssl_config_service(
139 new SSLConfigServiceDefaults
);
140 ssl_config_service
->GetSSLConfig(&ssl_config_
);
143 void CreatePool(bool transport_pool
, bool http_proxy_pool
, bool socks_pool
) {
144 ssl_histograms_
.reset(new ClientSocketPoolHistograms("SSLUnitTest"));
145 pool_
.reset(new SSLClientSocketPool(
148 ssl_histograms_
.get(),
149 NULL
/* host_resolver */,
150 NULL
/* cert_verifier */,
151 NULL
/* channel_id_service */,
152 NULL
/* transport_security_state */,
153 NULL
/* cert_transparency_verifier */,
154 std::string() /* ssl_session_cache_shard */,
156 transport_pool
? &transport_socket_pool_
: NULL
,
157 socks_pool
? &socks_socket_pool_
: NULL
,
158 http_proxy_pool
? &http_proxy_socket_pool_
: NULL
,
160 enable_ssl_connect_job_waiting_
,
164 scoped_refptr
<SSLSocketParams
> SSLParams(ProxyServer::Scheme proxy
,
165 bool want_spdy_over_npn
) {
166 return make_scoped_refptr(new SSLSocketParams(
167 proxy
== ProxyServer::SCHEME_DIRECT
? direct_transport_socket_params_
169 proxy
== ProxyServer::SCHEME_SOCKS5
? socks_socket_params_
: NULL
,
170 proxy
== ProxyServer::SCHEME_HTTP
? http_proxy_socket_params_
: NULL
,
171 HostPortPair("host", 443),
173 PRIVACY_MODE_DISABLED
,
176 want_spdy_over_npn
));
179 void AddAuthToCache() {
180 const base::string16
kFoo(base::ASCIIToUTF16("foo"));
181 const base::string16
kBar(base::ASCIIToUTF16("bar"));
182 session_
->http_auth_cache()->Add(GURL("http://proxy:443/"),
184 HttpAuth::AUTH_SCHEME_BASIC
,
185 "Basic realm=MyRealm1",
186 AuthCredentials(kFoo
, kBar
),
190 HttpNetworkSession
* CreateNetworkSession() {
191 HttpNetworkSession::Params params
;
192 params
.host_resolver
= &host_resolver_
;
193 params
.cert_verifier
= cert_verifier_
.get();
194 params
.transport_security_state
= transport_security_state_
.get();
195 params
.proxy_service
= proxy_service_
.get();
196 params
.client_socket_factory
= &socket_factory_
;
197 params
.ssl_config_service
= ssl_config_service_
.get();
198 params
.http_auth_handler_factory
= http_auth_handler_factory_
.get();
199 params
.http_server_properties
=
200 http_server_properties_
.GetWeakPtr();
201 params
.enable_spdy_compression
= false;
202 params
.spdy_default_protocol
= GetParam();
203 return new HttpNetworkSession(params
);
206 void TestIPPoolingDisabled(SSLSocketDataProvider
* ssl
);
208 MockClientSocketFactory socket_factory_
;
209 MockCachingHostResolver host_resolver_
;
210 scoped_ptr
<CertVerifier
> cert_verifier_
;
211 scoped_ptr
<TransportSecurityState
> transport_security_state_
;
212 const scoped_ptr
<ProxyService
> proxy_service_
;
213 const scoped_refptr
<SSLConfigService
> ssl_config_service_
;
214 const scoped_ptr
<HttpAuthHandlerFactory
> http_auth_handler_factory_
;
215 HttpServerPropertiesImpl http_server_properties_
;
216 const scoped_refptr
<HttpNetworkSession
> session_
;
218 scoped_refptr
<TransportSocketParams
> direct_transport_socket_params_
;
219 ClientSocketPoolHistograms transport_histograms_
;
220 MockTransportClientSocketPool transport_socket_pool_
;
222 scoped_refptr
<TransportSocketParams
> proxy_transport_socket_params_
;
224 scoped_refptr
<SOCKSSocketParams
> socks_socket_params_
;
225 ClientSocketPoolHistograms socks_histograms_
;
226 MockSOCKSClientSocketPool socks_socket_pool_
;
228 scoped_refptr
<HttpProxySocketParams
> http_proxy_socket_params_
;
229 ClientSocketPoolHistograms http_proxy_histograms_
;
230 HttpProxyClientSocketPool http_proxy_socket_pool_
;
232 SSLConfig ssl_config_
;
233 scoped_ptr
<ClientSocketPoolHistograms
> ssl_histograms_
;
234 scoped_ptr
<SSLClientSocketPool
> pool_
;
236 bool enable_ssl_connect_job_waiting_
;
239 INSTANTIATE_TEST_CASE_P(
241 SSLClientSocketPoolTest
,
242 testing::Values(kProtoDeprecatedSPDY2
,
243 kProtoSPDY3
, kProtoSPDY31
, kProtoSPDY4
));
245 // Tests that the final socket will connect even if all sockets
248 // All sockets should wait for the first socket to attempt to
249 // connect. Once it fails to connect, all other sockets should
250 // attempt to connect. All should fail, except the final socket.
251 TEST_P(SSLClientSocketPoolTest
, AllSocketsFailButLast
) {
252 // Although we request four sockets, the first three socket connect
253 // failures cause the socket pool to create three more sockets because
254 // there are pending requests.
255 StaticSocketDataProvider data1
;
256 StaticSocketDataProvider data2
;
257 StaticSocketDataProvider data3
;
258 StaticSocketDataProvider data4
;
259 StaticSocketDataProvider data5
;
260 StaticSocketDataProvider data6
;
261 StaticSocketDataProvider data7
;
262 socket_factory_
.AddSocketDataProvider(&data1
);
263 socket_factory_
.AddSocketDataProvider(&data2
);
264 socket_factory_
.AddSocketDataProvider(&data3
);
265 socket_factory_
.AddSocketDataProvider(&data4
);
266 socket_factory_
.AddSocketDataProvider(&data5
);
267 socket_factory_
.AddSocketDataProvider(&data6
);
268 socket_factory_
.AddSocketDataProvider(&data7
);
269 SSLSocketDataProvider
ssl(ASYNC
, ERR_SSL_PROTOCOL_ERROR
);
270 ssl
.is_in_session_cache
= false;
271 SSLSocketDataProvider
ssl2(ASYNC
, ERR_SSL_PROTOCOL_ERROR
);
272 ssl2
.is_in_session_cache
= false;
273 SSLSocketDataProvider
ssl3(ASYNC
, ERR_SSL_PROTOCOL_ERROR
);
274 ssl3
.is_in_session_cache
= false;
275 SSLSocketDataProvider
ssl4(ASYNC
, OK
);
276 ssl4
.is_in_session_cache
= false;
277 SSLSocketDataProvider
ssl5(ASYNC
, OK
);
278 ssl5
.is_in_session_cache
= false;
279 SSLSocketDataProvider
ssl6(ASYNC
, OK
);
280 ssl6
.is_in_session_cache
= false;
281 SSLSocketDataProvider
ssl7(ASYNC
, OK
);
282 ssl7
.is_in_session_cache
= false;
284 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
285 socket_factory_
.AddSSLSocketDataProvider(&ssl2
);
286 socket_factory_
.AddSSLSocketDataProvider(&ssl3
);
287 socket_factory_
.AddSSLSocketDataProvider(&ssl4
);
288 socket_factory_
.AddSSLSocketDataProvider(&ssl5
);
289 socket_factory_
.AddSSLSocketDataProvider(&ssl6
);
290 socket_factory_
.AddSSLSocketDataProvider(&ssl7
);
292 enable_ssl_connect_job_waiting_
= true;
293 CreatePool(true, false, false);
295 scoped_refptr
<SSLSocketParams
> params1
=
296 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
297 scoped_refptr
<SSLSocketParams
> params2
=
298 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
299 scoped_refptr
<SSLSocketParams
> params3
=
300 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
301 scoped_refptr
<SSLSocketParams
> params4
=
302 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
303 ClientSocketHandle handle1
;
304 ClientSocketHandle handle2
;
305 ClientSocketHandle handle3
;
306 ClientSocketHandle handle4
;
307 TestCompletionCallback callback1
;
308 TestCompletionCallback callback2
;
309 TestCompletionCallback callback3
;
310 TestCompletionCallback callback4
;
313 "b", params1
, MEDIUM
, callback1
.callback(), pool_
.get(), BoundNetLog());
315 "b", params2
, MEDIUM
, callback2
.callback(), pool_
.get(), BoundNetLog());
317 "b", params3
, MEDIUM
, callback3
.callback(), pool_
.get(), BoundNetLog());
319 "b", params4
, MEDIUM
, callback4
.callback(), pool_
.get(), BoundNetLog());
321 base::RunLoop().RunUntilIdle();
323 // Only the last socket should have connected.
324 EXPECT_FALSE(handle1
.socket());
325 EXPECT_FALSE(handle2
.socket());
326 EXPECT_FALSE(handle3
.socket());
327 EXPECT_TRUE(handle4
.socket()->IsConnected());
330 // Tests that sockets will still connect in parallel if the
331 // EnableSSLConnectJobWaiting flag is not enabled.
332 TEST_P(SSLClientSocketPoolTest
, SocketsConnectWithoutFlag
) {
333 StaticSocketDataProvider data1
;
334 StaticSocketDataProvider data2
;
335 StaticSocketDataProvider data3
;
336 socket_factory_
.AddSocketDataProvider(&data1
);
337 socket_factory_
.AddSocketDataProvider(&data2
);
338 socket_factory_
.AddSocketDataProvider(&data3
);
340 SSLSocketDataProvider
ssl(ASYNC
, OK
);
341 ssl
.is_in_session_cache
= false;
342 ssl
.should_pause_on_connect
= true;
343 SSLSocketDataProvider
ssl2(ASYNC
, OK
);
344 ssl2
.is_in_session_cache
= false;
345 ssl2
.should_pause_on_connect
= true;
346 SSLSocketDataProvider
ssl3(ASYNC
, OK
);
347 ssl3
.is_in_session_cache
= false;
348 ssl3
.should_pause_on_connect
= true;
349 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
350 socket_factory_
.AddSSLSocketDataProvider(&ssl2
);
351 socket_factory_
.AddSSLSocketDataProvider(&ssl3
);
353 CreatePool(true, false, false);
355 scoped_refptr
<SSLSocketParams
> params1
=
356 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
357 scoped_refptr
<SSLSocketParams
> params2
=
358 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
359 scoped_refptr
<SSLSocketParams
> params3
=
360 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
361 ClientSocketHandle handle1
;
362 ClientSocketHandle handle2
;
363 ClientSocketHandle handle3
;
364 TestCompletionCallback callback1
;
365 TestCompletionCallback callback2
;
366 TestCompletionCallback callback3
;
369 "b", params1
, MEDIUM
, callback1
.callback(), pool_
.get(), BoundNetLog());
371 "b", params2
, MEDIUM
, callback2
.callback(), pool_
.get(), BoundNetLog());
373 "b", params3
, MEDIUM
, callback3
.callback(), pool_
.get(), BoundNetLog());
375 base::RunLoop().RunUntilIdle();
377 std::vector
<MockSSLClientSocket
*> sockets
=
378 socket_factory_
.ssl_client_sockets();
380 // All sockets should have started their connections.
381 for (std::vector
<MockSSLClientSocket
*>::iterator it
= sockets
.begin();
384 EXPECT_TRUE((*it
)->reached_connect());
387 // Resume connecting all of the sockets.
388 for (std::vector
<MockSSLClientSocket
*>::iterator it
= sockets
.begin();
391 (*it
)->RestartPausedConnect();
394 callback1
.WaitForResult();
395 callback2
.WaitForResult();
396 callback3
.WaitForResult();
398 EXPECT_TRUE(handle1
.socket()->IsConnected());
399 EXPECT_TRUE(handle2
.socket()->IsConnected());
400 EXPECT_TRUE(handle3
.socket()->IsConnected());
403 // Tests that the pool deleting an SSLConnectJob will not cause a crash,
404 // or prevent pending sockets from connecting.
405 TEST_P(SSLClientSocketPoolTest
, DeletedSSLConnectJob
) {
406 StaticSocketDataProvider data1
;
407 StaticSocketDataProvider data2
;
408 StaticSocketDataProvider data3
;
409 socket_factory_
.AddSocketDataProvider(&data1
);
410 socket_factory_
.AddSocketDataProvider(&data2
);
411 socket_factory_
.AddSocketDataProvider(&data3
);
413 SSLSocketDataProvider
ssl(ASYNC
, OK
);
414 ssl
.is_in_session_cache
= false;
415 ssl
.should_pause_on_connect
= true;
416 SSLSocketDataProvider
ssl2(ASYNC
, OK
);
417 ssl2
.is_in_session_cache
= false;
418 SSLSocketDataProvider
ssl3(ASYNC
, OK
);
419 ssl3
.is_in_session_cache
= false;
420 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
421 socket_factory_
.AddSSLSocketDataProvider(&ssl2
);
422 socket_factory_
.AddSSLSocketDataProvider(&ssl3
);
424 enable_ssl_connect_job_waiting_
= true;
425 CreatePool(true, false, false);
427 scoped_refptr
<SSLSocketParams
> params1
=
428 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
429 scoped_refptr
<SSLSocketParams
> params2
=
430 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
431 scoped_refptr
<SSLSocketParams
> params3
=
432 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
433 ClientSocketHandle handle1
;
434 ClientSocketHandle handle2
;
435 ClientSocketHandle handle3
;
436 TestCompletionCallback callback1
;
437 TestCompletionCallback callback2
;
438 TestCompletionCallback callback3
;
441 "b", params1
, MEDIUM
, callback1
.callback(), pool_
.get(), BoundNetLog());
443 "b", params2
, MEDIUM
, callback2
.callback(), pool_
.get(), BoundNetLog());
445 "b", params3
, MEDIUM
, callback3
.callback(), pool_
.get(), BoundNetLog());
447 // Allow the connections to proceed until the first socket has started
449 base::RunLoop().RunUntilIdle();
451 std::vector
<MockSSLClientSocket
*> sockets
=
452 socket_factory_
.ssl_client_sockets();
454 pool_
->CancelRequest("b", &handle2
);
456 sockets
[0]->RestartPausedConnect();
458 callback1
.WaitForResult();
459 callback3
.WaitForResult();
461 EXPECT_TRUE(handle1
.socket()->IsConnected());
462 EXPECT_FALSE(handle2
.socket());
463 EXPECT_TRUE(handle3
.socket()->IsConnected());
466 // Tests that all pending sockets still connect when the pool deletes a pending
467 // SSLConnectJob which immediately followed a failed leading connection.
468 TEST_P(SSLClientSocketPoolTest
, DeletedSocketAfterFail
) {
469 StaticSocketDataProvider data1
;
470 StaticSocketDataProvider data2
;
471 StaticSocketDataProvider data3
;
472 StaticSocketDataProvider data4
;
473 socket_factory_
.AddSocketDataProvider(&data1
);
474 socket_factory_
.AddSocketDataProvider(&data2
);
475 socket_factory_
.AddSocketDataProvider(&data3
);
476 socket_factory_
.AddSocketDataProvider(&data4
);
478 SSLSocketDataProvider
ssl(ASYNC
, ERR_SSL_PROTOCOL_ERROR
);
479 ssl
.is_in_session_cache
= false;
480 ssl
.should_pause_on_connect
= true;
481 SSLSocketDataProvider
ssl2(ASYNC
, OK
);
482 ssl2
.is_in_session_cache
= false;
483 SSLSocketDataProvider
ssl3(ASYNC
, OK
);
484 ssl3
.is_in_session_cache
= false;
485 SSLSocketDataProvider
ssl4(ASYNC
, OK
);
486 ssl4
.is_in_session_cache
= false;
487 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
488 socket_factory_
.AddSSLSocketDataProvider(&ssl2
);
489 socket_factory_
.AddSSLSocketDataProvider(&ssl3
);
490 socket_factory_
.AddSSLSocketDataProvider(&ssl4
);
492 enable_ssl_connect_job_waiting_
= true;
493 CreatePool(true, false, false);
495 scoped_refptr
<SSLSocketParams
> params1
=
496 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
497 scoped_refptr
<SSLSocketParams
> params2
=
498 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
499 scoped_refptr
<SSLSocketParams
> params3
=
500 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
501 ClientSocketHandle handle1
;
502 ClientSocketHandle handle2
;
503 ClientSocketHandle handle3
;
504 TestCompletionCallback callback1
;
505 TestCompletionCallback callback2
;
506 TestCompletionCallback callback3
;
509 "b", params1
, MEDIUM
, callback1
.callback(), pool_
.get(), BoundNetLog());
511 "b", params2
, MEDIUM
, callback2
.callback(), pool_
.get(), BoundNetLog());
513 "b", params3
, MEDIUM
, callback3
.callback(), pool_
.get(), BoundNetLog());
515 // Allow the connections to proceed until the first socket has started
517 base::RunLoop().RunUntilIdle();
519 std::vector
<MockSSLClientSocket
*> sockets
=
520 socket_factory_
.ssl_client_sockets();
522 EXPECT_EQ(3u, sockets
.size());
523 EXPECT_TRUE(sockets
[0]->reached_connect());
524 EXPECT_FALSE(handle1
.socket());
526 pool_
->CancelRequest("b", &handle2
);
528 sockets
[0]->RestartPausedConnect();
530 callback1
.WaitForResult();
531 callback3
.WaitForResult();
533 EXPECT_FALSE(handle1
.socket());
534 EXPECT_FALSE(handle2
.socket());
535 EXPECT_TRUE(handle3
.socket()->IsConnected());
538 // Make sure that sockets still connect after the leader socket's
540 TEST_P(SSLClientSocketPoolTest
, SimultaneousConnectJobsFail
) {
541 StaticSocketDataProvider data1
;
542 StaticSocketDataProvider data2
;
543 StaticSocketDataProvider data3
;
544 StaticSocketDataProvider data4
;
545 StaticSocketDataProvider data5
;
546 socket_factory_
.AddSocketDataProvider(&data1
);
547 socket_factory_
.AddSocketDataProvider(&data2
);
548 socket_factory_
.AddSocketDataProvider(&data3
);
549 socket_factory_
.AddSocketDataProvider(&data4
);
550 socket_factory_
.AddSocketDataProvider(&data5
);
551 SSLSocketDataProvider
ssl(ASYNC
, ERR_SSL_PROTOCOL_ERROR
);
552 ssl
.is_in_session_cache
= false;
553 ssl
.should_pause_on_connect
= true;
554 SSLSocketDataProvider
ssl2(ASYNC
, OK
);
555 ssl2
.is_in_session_cache
= false;
556 ssl2
.should_pause_on_connect
= true;
557 SSLSocketDataProvider
ssl3(ASYNC
, OK
);
558 ssl3
.is_in_session_cache
= false;
559 SSLSocketDataProvider
ssl4(ASYNC
, OK
);
560 ssl4
.is_in_session_cache
= false;
561 SSLSocketDataProvider
ssl5(ASYNC
, OK
);
562 ssl5
.is_in_session_cache
= false;
564 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
565 socket_factory_
.AddSSLSocketDataProvider(&ssl2
);
566 socket_factory_
.AddSSLSocketDataProvider(&ssl3
);
567 socket_factory_
.AddSSLSocketDataProvider(&ssl4
);
568 socket_factory_
.AddSSLSocketDataProvider(&ssl5
);
570 enable_ssl_connect_job_waiting_
= true;
571 CreatePool(true, false, false);
572 scoped_refptr
<SSLSocketParams
> params1
=
573 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
574 scoped_refptr
<SSLSocketParams
> params2
=
575 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
576 scoped_refptr
<SSLSocketParams
> params3
=
577 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
578 scoped_refptr
<SSLSocketParams
> params4
=
579 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
580 ClientSocketHandle handle1
;
581 ClientSocketHandle handle2
;
582 ClientSocketHandle handle3
;
583 ClientSocketHandle handle4
;
584 TestCompletionCallback callback1
;
585 TestCompletionCallback callback2
;
586 TestCompletionCallback callback3
;
587 TestCompletionCallback callback4
;
589 "b", params1
, MEDIUM
, callback1
.callback(), pool_
.get(), BoundNetLog());
591 "b", params2
, MEDIUM
, callback2
.callback(), pool_
.get(), BoundNetLog());
593 "b", params3
, MEDIUM
, callback3
.callback(), pool_
.get(), BoundNetLog());
595 "b", params4
, MEDIUM
, callback4
.callback(), pool_
.get(), BoundNetLog());
597 base::RunLoop().RunUntilIdle();
599 std::vector
<MockSSLClientSocket
*> sockets
=
600 socket_factory_
.ssl_client_sockets();
602 std::vector
<MockSSLClientSocket
*>::const_iterator it
= sockets
.begin();
604 // The first socket should have had Connect called on it.
605 EXPECT_TRUE((*it
)->reached_connect());
608 // No other socket should have reached connect yet.
609 for (; it
!= sockets
.end(); ++it
)
610 EXPECT_FALSE((*it
)->reached_connect());
612 // Allow the first socket to resume it's connection process.
613 sockets
[0]->RestartPausedConnect();
615 base::RunLoop().RunUntilIdle();
617 // The second socket should have reached connect.
618 EXPECT_TRUE(sockets
[1]->reached_connect());
620 // Allow the second socket to continue its connection.
621 sockets
[1]->RestartPausedConnect();
623 base::RunLoop().RunUntilIdle();
625 EXPECT_FALSE(handle1
.socket());
626 EXPECT_TRUE(handle2
.socket()->IsConnected());
627 EXPECT_TRUE(handle3
.socket()->IsConnected());
628 EXPECT_TRUE(handle4
.socket()->IsConnected());
631 // Make sure that no sockets connect before the "leader" socket,
632 // given that the leader has a successful connection.
633 TEST_P(SSLClientSocketPoolTest
, SimultaneousConnectJobsSuccess
) {
634 StaticSocketDataProvider data1
;
635 StaticSocketDataProvider data2
;
636 StaticSocketDataProvider data3
;
637 socket_factory_
.AddSocketDataProvider(&data1
);
638 socket_factory_
.AddSocketDataProvider(&data2
);
639 socket_factory_
.AddSocketDataProvider(&data3
);
641 SSLSocketDataProvider
ssl(ASYNC
, OK
);
642 ssl
.is_in_session_cache
= false;
643 ssl
.should_pause_on_connect
= true;
644 SSLSocketDataProvider
ssl2(ASYNC
, OK
);
645 ssl2
.is_in_session_cache
= false;
646 SSLSocketDataProvider
ssl3(ASYNC
, OK
);
647 ssl3
.is_in_session_cache
= false;
648 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
649 socket_factory_
.AddSSLSocketDataProvider(&ssl2
);
650 socket_factory_
.AddSSLSocketDataProvider(&ssl3
);
652 enable_ssl_connect_job_waiting_
= true;
653 CreatePool(true, false, false);
655 scoped_refptr
<SSLSocketParams
> params1
=
656 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
657 scoped_refptr
<SSLSocketParams
> params2
=
658 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
659 scoped_refptr
<SSLSocketParams
> params3
=
660 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
661 ClientSocketHandle handle1
;
662 ClientSocketHandle handle2
;
663 ClientSocketHandle handle3
;
664 TestCompletionCallback callback1
;
665 TestCompletionCallback callback2
;
666 TestCompletionCallback callback3
;
669 "b", params1
, MEDIUM
, callback1
.callback(), pool_
.get(), BoundNetLog());
671 "b", params2
, MEDIUM
, callback2
.callback(), pool_
.get(), BoundNetLog());
673 "b", params3
, MEDIUM
, callback3
.callback(), pool_
.get(), BoundNetLog());
675 // Allow the connections to proceed until the first socket has finished
677 base::RunLoop().RunUntilIdle();
679 std::vector
<MockSSLClientSocket
*> sockets
=
680 socket_factory_
.ssl_client_sockets();
682 std::vector
<MockSSLClientSocket
*>::const_iterator it
= sockets
.begin();
683 // The first socket should have reached connect.
684 EXPECT_TRUE((*it
)->reached_connect());
686 // No other socket should have reached connect yet.
687 for (; it
!= sockets
.end(); ++it
)
688 EXPECT_FALSE((*it
)->reached_connect());
690 sockets
[0]->RestartPausedConnect();
692 callback1
.WaitForResult();
693 callback2
.WaitForResult();
694 callback3
.WaitForResult();
696 EXPECT_TRUE(handle1
.socket()->IsConnected());
697 EXPECT_TRUE(handle2
.socket()->IsConnected());
698 EXPECT_TRUE(handle3
.socket()->IsConnected());
701 TEST_P(SSLClientSocketPoolTest
, TCPFail
) {
702 StaticSocketDataProvider data
;
703 data
.set_connect_data(MockConnect(SYNCHRONOUS
, ERR_CONNECTION_FAILED
));
704 socket_factory_
.AddSocketDataProvider(&data
);
706 CreatePool(true /* tcp pool */, false, false);
707 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
710 ClientSocketHandle handle
;
711 int rv
= handle
.Init("a", params
, MEDIUM
, CompletionCallback(), pool_
.get(),
713 EXPECT_EQ(ERR_CONNECTION_FAILED
, rv
);
714 EXPECT_FALSE(handle
.is_initialized());
715 EXPECT_FALSE(handle
.socket());
716 EXPECT_FALSE(handle
.is_ssl_error());
719 TEST_P(SSLClientSocketPoolTest
, TCPFailAsync
) {
720 StaticSocketDataProvider data
;
721 data
.set_connect_data(MockConnect(ASYNC
, ERR_CONNECTION_FAILED
));
722 socket_factory_
.AddSocketDataProvider(&data
);
724 CreatePool(true /* tcp pool */, false, false);
725 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
728 ClientSocketHandle handle
;
729 TestCompletionCallback callback
;
730 int rv
= handle
.Init(
731 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
732 EXPECT_EQ(ERR_IO_PENDING
, rv
);
733 EXPECT_FALSE(handle
.is_initialized());
734 EXPECT_FALSE(handle
.socket());
736 EXPECT_EQ(ERR_CONNECTION_FAILED
, callback
.WaitForResult());
737 EXPECT_FALSE(handle
.is_initialized());
738 EXPECT_FALSE(handle
.socket());
739 EXPECT_FALSE(handle
.is_ssl_error());
742 TEST_P(SSLClientSocketPoolTest
, BasicDirect
) {
743 StaticSocketDataProvider data
;
744 data
.set_connect_data(MockConnect(SYNCHRONOUS
, OK
));
745 socket_factory_
.AddSocketDataProvider(&data
);
746 SSLSocketDataProvider
ssl(SYNCHRONOUS
, OK
);
747 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
749 CreatePool(true /* tcp pool */, false, false);
750 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
753 ClientSocketHandle handle
;
754 TestCompletionCallback callback
;
755 int rv
= handle
.Init(
756 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
758 EXPECT_TRUE(handle
.is_initialized());
759 EXPECT_TRUE(handle
.socket());
760 TestLoadTimingInfo(handle
);
763 // Make sure that SSLConnectJob passes on its priority to its
764 // socket request on Init (for the DIRECT case).
765 TEST_P(SSLClientSocketPoolTest
, SetSocketRequestPriorityOnInitDirect
) {
766 CreatePool(true /* tcp pool */, false, false);
767 scoped_refptr
<SSLSocketParams
> params
=
768 SSLParams(ProxyServer::SCHEME_DIRECT
, false);
770 for (int i
= MINIMUM_PRIORITY
; i
<= MAXIMUM_PRIORITY
; ++i
) {
771 RequestPriority priority
= static_cast<RequestPriority
>(i
);
772 StaticSocketDataProvider data
;
773 data
.set_connect_data(MockConnect(SYNCHRONOUS
, OK
));
774 socket_factory_
.AddSocketDataProvider(&data
);
775 SSLSocketDataProvider
ssl(SYNCHRONOUS
, OK
);
776 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
778 ClientSocketHandle handle
;
779 TestCompletionCallback callback
;
780 EXPECT_EQ(OK
, handle
.Init("a", params
, priority
, callback
.callback(),
781 pool_
.get(), BoundNetLog()));
782 EXPECT_EQ(priority
, transport_socket_pool_
.last_request_priority());
783 handle
.socket()->Disconnect();
787 TEST_P(SSLClientSocketPoolTest
, BasicDirectAsync
) {
788 StaticSocketDataProvider data
;
789 socket_factory_
.AddSocketDataProvider(&data
);
790 SSLSocketDataProvider
ssl(ASYNC
, OK
);
791 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
793 CreatePool(true /* tcp pool */, false, false);
794 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
797 ClientSocketHandle handle
;
798 TestCompletionCallback callback
;
799 int rv
= handle
.Init(
800 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
801 EXPECT_EQ(ERR_IO_PENDING
, rv
);
802 EXPECT_FALSE(handle
.is_initialized());
803 EXPECT_FALSE(handle
.socket());
805 EXPECT_EQ(OK
, callback
.WaitForResult());
806 EXPECT_TRUE(handle
.is_initialized());
807 EXPECT_TRUE(handle
.socket());
808 TestLoadTimingInfo(handle
);
811 TEST_P(SSLClientSocketPoolTest
, DirectCertError
) {
812 StaticSocketDataProvider data
;
813 socket_factory_
.AddSocketDataProvider(&data
);
814 SSLSocketDataProvider
ssl(ASYNC
, ERR_CERT_COMMON_NAME_INVALID
);
815 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
817 CreatePool(true /* tcp pool */, false, false);
818 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
821 ClientSocketHandle handle
;
822 TestCompletionCallback callback
;
823 int rv
= handle
.Init(
824 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
825 EXPECT_EQ(ERR_IO_PENDING
, rv
);
826 EXPECT_FALSE(handle
.is_initialized());
827 EXPECT_FALSE(handle
.socket());
829 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID
, callback
.WaitForResult());
830 EXPECT_TRUE(handle
.is_initialized());
831 EXPECT_TRUE(handle
.socket());
832 TestLoadTimingInfo(handle
);
835 TEST_P(SSLClientSocketPoolTest
, DirectSSLError
) {
836 StaticSocketDataProvider data
;
837 socket_factory_
.AddSocketDataProvider(&data
);
838 SSLSocketDataProvider
ssl(ASYNC
, ERR_SSL_PROTOCOL_ERROR
);
839 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
841 CreatePool(true /* tcp pool */, false, false);
842 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
845 ClientSocketHandle handle
;
846 TestCompletionCallback callback
;
847 int rv
= handle
.Init(
848 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
849 EXPECT_EQ(ERR_IO_PENDING
, rv
);
850 EXPECT_FALSE(handle
.is_initialized());
851 EXPECT_FALSE(handle
.socket());
853 EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR
, callback
.WaitForResult());
854 EXPECT_FALSE(handle
.is_initialized());
855 EXPECT_FALSE(handle
.socket());
856 EXPECT_TRUE(handle
.is_ssl_error());
859 TEST_P(SSLClientSocketPoolTest
, DirectWithNPN
) {
860 StaticSocketDataProvider data
;
861 socket_factory_
.AddSocketDataProvider(&data
);
862 SSLSocketDataProvider
ssl(ASYNC
, OK
);
863 ssl
.SetNextProto(kProtoHTTP11
);
864 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
866 CreatePool(true /* tcp pool */, false, false);
867 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
870 ClientSocketHandle handle
;
871 TestCompletionCallback callback
;
872 int rv
= handle
.Init(
873 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
874 EXPECT_EQ(ERR_IO_PENDING
, rv
);
875 EXPECT_FALSE(handle
.is_initialized());
876 EXPECT_FALSE(handle
.socket());
878 EXPECT_EQ(OK
, callback
.WaitForResult());
879 EXPECT_TRUE(handle
.is_initialized());
880 EXPECT_TRUE(handle
.socket());
881 TestLoadTimingInfo(handle
);
882 SSLClientSocket
* ssl_socket
= static_cast<SSLClientSocket
*>(handle
.socket());
883 EXPECT_TRUE(ssl_socket
->WasNpnNegotiated());
886 TEST_P(SSLClientSocketPoolTest
, DirectNoSPDY
) {
887 StaticSocketDataProvider data
;
888 socket_factory_
.AddSocketDataProvider(&data
);
889 SSLSocketDataProvider
ssl(ASYNC
, OK
);
890 ssl
.SetNextProto(kProtoHTTP11
);
891 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
893 CreatePool(true /* tcp pool */, false, false);
894 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
897 ClientSocketHandle handle
;
898 TestCompletionCallback callback
;
899 int rv
= handle
.Init(
900 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
901 EXPECT_EQ(ERR_IO_PENDING
, rv
);
902 EXPECT_FALSE(handle
.is_initialized());
903 EXPECT_FALSE(handle
.socket());
905 EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED
, callback
.WaitForResult());
906 EXPECT_FALSE(handle
.is_initialized());
907 EXPECT_FALSE(handle
.socket());
908 EXPECT_TRUE(handle
.is_ssl_error());
911 TEST_P(SSLClientSocketPoolTest
, DirectGotSPDY
) {
912 StaticSocketDataProvider data
;
913 socket_factory_
.AddSocketDataProvider(&data
);
914 SSLSocketDataProvider
ssl(ASYNC
, OK
);
915 ssl
.SetNextProto(GetParam());
916 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
918 CreatePool(true /* tcp pool */, false, false);
919 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
922 ClientSocketHandle handle
;
923 TestCompletionCallback callback
;
924 int rv
= handle
.Init(
925 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
926 EXPECT_EQ(ERR_IO_PENDING
, rv
);
927 EXPECT_FALSE(handle
.is_initialized());
928 EXPECT_FALSE(handle
.socket());
930 EXPECT_EQ(OK
, callback
.WaitForResult());
931 EXPECT_TRUE(handle
.is_initialized());
932 EXPECT_TRUE(handle
.socket());
933 TestLoadTimingInfo(handle
);
935 SSLClientSocket
* ssl_socket
= static_cast<SSLClientSocket
*>(handle
.socket());
936 EXPECT_TRUE(ssl_socket
->WasNpnNegotiated());
938 ssl_socket
->GetNextProto(&proto
);
939 EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto
));
942 TEST_P(SSLClientSocketPoolTest
, DirectGotBonusSPDY
) {
943 StaticSocketDataProvider data
;
944 socket_factory_
.AddSocketDataProvider(&data
);
945 SSLSocketDataProvider
ssl(ASYNC
, OK
);
946 ssl
.SetNextProto(GetParam());
947 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
949 CreatePool(true /* tcp pool */, false, false);
950 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_DIRECT
,
953 ClientSocketHandle handle
;
954 TestCompletionCallback callback
;
955 int rv
= handle
.Init(
956 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
957 EXPECT_EQ(ERR_IO_PENDING
, rv
);
958 EXPECT_FALSE(handle
.is_initialized());
959 EXPECT_FALSE(handle
.socket());
961 EXPECT_EQ(OK
, callback
.WaitForResult());
962 EXPECT_TRUE(handle
.is_initialized());
963 EXPECT_TRUE(handle
.socket());
964 TestLoadTimingInfo(handle
);
966 SSLClientSocket
* ssl_socket
= static_cast<SSLClientSocket
*>(handle
.socket());
967 EXPECT_TRUE(ssl_socket
->WasNpnNegotiated());
969 ssl_socket
->GetNextProto(&proto
);
970 EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto
));
973 TEST_P(SSLClientSocketPoolTest
, SOCKSFail
) {
974 StaticSocketDataProvider data
;
975 data
.set_connect_data(MockConnect(SYNCHRONOUS
, ERR_CONNECTION_FAILED
));
976 socket_factory_
.AddSocketDataProvider(&data
);
978 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
979 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_SOCKS5
,
982 ClientSocketHandle handle
;
983 TestCompletionCallback callback
;
984 int rv
= handle
.Init(
985 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
986 EXPECT_EQ(ERR_CONNECTION_FAILED
, rv
);
987 EXPECT_FALSE(handle
.is_initialized());
988 EXPECT_FALSE(handle
.socket());
989 EXPECT_FALSE(handle
.is_ssl_error());
992 TEST_P(SSLClientSocketPoolTest
, SOCKSFailAsync
) {
993 StaticSocketDataProvider data
;
994 data
.set_connect_data(MockConnect(ASYNC
, ERR_CONNECTION_FAILED
));
995 socket_factory_
.AddSocketDataProvider(&data
);
997 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
998 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_SOCKS5
,
1001 ClientSocketHandle handle
;
1002 TestCompletionCallback callback
;
1003 int rv
= handle
.Init(
1004 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
1005 EXPECT_EQ(ERR_IO_PENDING
, rv
);
1006 EXPECT_FALSE(handle
.is_initialized());
1007 EXPECT_FALSE(handle
.socket());
1009 EXPECT_EQ(ERR_CONNECTION_FAILED
, callback
.WaitForResult());
1010 EXPECT_FALSE(handle
.is_initialized());
1011 EXPECT_FALSE(handle
.socket());
1012 EXPECT_FALSE(handle
.is_ssl_error());
1015 TEST_P(SSLClientSocketPoolTest
, SOCKSBasic
) {
1016 StaticSocketDataProvider data
;
1017 data
.set_connect_data(MockConnect(SYNCHRONOUS
, OK
));
1018 socket_factory_
.AddSocketDataProvider(&data
);
1019 SSLSocketDataProvider
ssl(SYNCHRONOUS
, OK
);
1020 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
1022 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1023 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_SOCKS5
,
1026 ClientSocketHandle handle
;
1027 TestCompletionCallback callback
;
1028 int rv
= handle
.Init(
1029 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
1031 EXPECT_TRUE(handle
.is_initialized());
1032 EXPECT_TRUE(handle
.socket());
1033 // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here
1034 // don't go through the real logic, unlike in the HTTP proxy tests.
1035 TestLoadTimingInfo(handle
);
1038 // Make sure that SSLConnectJob passes on its priority to its
1039 // transport socket on Init (for the SOCKS_PROXY case).
1040 TEST_P(SSLClientSocketPoolTest
, SetTransportPriorityOnInitSOCKS
) {
1041 StaticSocketDataProvider data
;
1042 data
.set_connect_data(MockConnect(SYNCHRONOUS
, OK
));
1043 socket_factory_
.AddSocketDataProvider(&data
);
1044 SSLSocketDataProvider
ssl(SYNCHRONOUS
, OK
);
1045 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
1047 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1048 scoped_refptr
<SSLSocketParams
> params
=
1049 SSLParams(ProxyServer::SCHEME_SOCKS5
, false);
1051 ClientSocketHandle handle
;
1052 TestCompletionCallback callback
;
1053 EXPECT_EQ(OK
, handle
.Init("a", params
, HIGHEST
, callback
.callback(),
1054 pool_
.get(), BoundNetLog()));
1055 EXPECT_EQ(HIGHEST
, transport_socket_pool_
.last_request_priority());
1058 TEST_P(SSLClientSocketPoolTest
, SOCKSBasicAsync
) {
1059 StaticSocketDataProvider data
;
1060 socket_factory_
.AddSocketDataProvider(&data
);
1061 SSLSocketDataProvider
ssl(ASYNC
, OK
);
1062 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
1064 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1065 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_SOCKS5
,
1068 ClientSocketHandle handle
;
1069 TestCompletionCallback callback
;
1070 int rv
= handle
.Init(
1071 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
1072 EXPECT_EQ(ERR_IO_PENDING
, rv
);
1073 EXPECT_FALSE(handle
.is_initialized());
1074 EXPECT_FALSE(handle
.socket());
1076 EXPECT_EQ(OK
, callback
.WaitForResult());
1077 EXPECT_TRUE(handle
.is_initialized());
1078 EXPECT_TRUE(handle
.socket());
1079 // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here
1080 // don't go through the real logic, unlike in the HTTP proxy tests.
1081 TestLoadTimingInfo(handle
);
1084 TEST_P(SSLClientSocketPoolTest
, HttpProxyFail
) {
1085 StaticSocketDataProvider data
;
1086 data
.set_connect_data(MockConnect(SYNCHRONOUS
, ERR_CONNECTION_FAILED
));
1087 socket_factory_
.AddSocketDataProvider(&data
);
1089 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1090 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_HTTP
,
1093 ClientSocketHandle handle
;
1094 TestCompletionCallback callback
;
1095 int rv
= handle
.Init(
1096 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
1097 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED
, rv
);
1098 EXPECT_FALSE(handle
.is_initialized());
1099 EXPECT_FALSE(handle
.socket());
1100 EXPECT_FALSE(handle
.is_ssl_error());
1103 TEST_P(SSLClientSocketPoolTest
, HttpProxyFailAsync
) {
1104 StaticSocketDataProvider data
;
1105 data
.set_connect_data(MockConnect(ASYNC
, ERR_CONNECTION_FAILED
));
1106 socket_factory_
.AddSocketDataProvider(&data
);
1108 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1109 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_HTTP
,
1112 ClientSocketHandle handle
;
1113 TestCompletionCallback callback
;
1114 int rv
= handle
.Init(
1115 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
1116 EXPECT_EQ(ERR_IO_PENDING
, rv
);
1117 EXPECT_FALSE(handle
.is_initialized());
1118 EXPECT_FALSE(handle
.socket());
1120 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED
, callback
.WaitForResult());
1121 EXPECT_FALSE(handle
.is_initialized());
1122 EXPECT_FALSE(handle
.socket());
1123 EXPECT_FALSE(handle
.is_ssl_error());
1126 TEST_P(SSLClientSocketPoolTest
, HttpProxyBasic
) {
1127 MockWrite writes
[] = {
1128 MockWrite(SYNCHRONOUS
,
1129 "CONNECT host:80 HTTP/1.1\r\n"
1131 "Proxy-Connection: keep-alive\r\n"
1132 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1134 MockRead reads
[] = {
1135 MockRead(SYNCHRONOUS
, "HTTP/1.1 200 Connection Established\r\n\r\n"),
1137 StaticSocketDataProvider
data(reads
, arraysize(reads
), writes
,
1139 data
.set_connect_data(MockConnect(SYNCHRONOUS
, OK
));
1140 socket_factory_
.AddSocketDataProvider(&data
);
1142 SSLSocketDataProvider
ssl(SYNCHRONOUS
, OK
);
1143 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
1145 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1146 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_HTTP
,
1149 ClientSocketHandle handle
;
1150 TestCompletionCallback callback
;
1151 int rv
= handle
.Init(
1152 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
1154 EXPECT_TRUE(handle
.is_initialized());
1155 EXPECT_TRUE(handle
.socket());
1156 TestLoadTimingInfoNoDns(handle
);
1159 // Make sure that SSLConnectJob passes on its priority to its
1160 // transport socket on Init (for the HTTP_PROXY case).
1161 TEST_P(SSLClientSocketPoolTest
, SetTransportPriorityOnInitHTTP
) {
1162 MockWrite writes
[] = {
1163 MockWrite(SYNCHRONOUS
,
1164 "CONNECT host:80 HTTP/1.1\r\n"
1166 "Proxy-Connection: keep-alive\r\n"
1167 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1169 MockRead reads
[] = {
1170 MockRead(SYNCHRONOUS
, "HTTP/1.1 200 Connection Established\r\n\r\n"),
1172 StaticSocketDataProvider
data(reads
, arraysize(reads
), writes
,
1174 data
.set_connect_data(MockConnect(SYNCHRONOUS
, OK
));
1175 socket_factory_
.AddSocketDataProvider(&data
);
1177 SSLSocketDataProvider
ssl(SYNCHRONOUS
, OK
);
1178 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
1180 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1181 scoped_refptr
<SSLSocketParams
> params
=
1182 SSLParams(ProxyServer::SCHEME_HTTP
, false);
1184 ClientSocketHandle handle
;
1185 TestCompletionCallback callback
;
1186 EXPECT_EQ(OK
, handle
.Init("a", params
, HIGHEST
, callback
.callback(),
1187 pool_
.get(), BoundNetLog()));
1188 EXPECT_EQ(HIGHEST
, transport_socket_pool_
.last_request_priority());
1191 TEST_P(SSLClientSocketPoolTest
, HttpProxyBasicAsync
) {
1192 MockWrite writes
[] = {
1193 MockWrite("CONNECT host:80 HTTP/1.1\r\n"
1195 "Proxy-Connection: keep-alive\r\n"
1196 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1198 MockRead reads
[] = {
1199 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
1201 StaticSocketDataProvider
data(reads
, arraysize(reads
), writes
,
1203 socket_factory_
.AddSocketDataProvider(&data
);
1205 SSLSocketDataProvider
ssl(ASYNC
, OK
);
1206 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
1208 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1209 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_HTTP
,
1212 ClientSocketHandle handle
;
1213 TestCompletionCallback callback
;
1214 int rv
= handle
.Init(
1215 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
1216 EXPECT_EQ(ERR_IO_PENDING
, rv
);
1217 EXPECT_FALSE(handle
.is_initialized());
1218 EXPECT_FALSE(handle
.socket());
1220 EXPECT_EQ(OK
, callback
.WaitForResult());
1221 EXPECT_TRUE(handle
.is_initialized());
1222 EXPECT_TRUE(handle
.socket());
1223 TestLoadTimingInfoNoDns(handle
);
1226 TEST_P(SSLClientSocketPoolTest
, NeedProxyAuth
) {
1227 MockWrite writes
[] = {
1228 MockWrite("CONNECT host:80 HTTP/1.1\r\n"
1230 "Proxy-Connection: keep-alive\r\n\r\n"),
1232 MockRead reads
[] = {
1233 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
1234 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
1235 MockRead("Content-Length: 10\r\n\r\n"),
1236 MockRead("0123456789"),
1238 StaticSocketDataProvider
data(reads
, arraysize(reads
), writes
,
1240 socket_factory_
.AddSocketDataProvider(&data
);
1241 SSLSocketDataProvider
ssl(ASYNC
, OK
);
1242 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
1244 CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1245 scoped_refptr
<SSLSocketParams
> params
= SSLParams(ProxyServer::SCHEME_HTTP
,
1248 ClientSocketHandle handle
;
1249 TestCompletionCallback callback
;
1250 int rv
= handle
.Init(
1251 "a", params
, MEDIUM
, callback
.callback(), pool_
.get(), BoundNetLog());
1252 EXPECT_EQ(ERR_IO_PENDING
, rv
);
1253 EXPECT_FALSE(handle
.is_initialized());
1254 EXPECT_FALSE(handle
.socket());
1256 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED
, callback
.WaitForResult());
1257 EXPECT_FALSE(handle
.is_initialized());
1258 EXPECT_FALSE(handle
.socket());
1259 EXPECT_FALSE(handle
.is_ssl_error());
1260 const HttpResponseInfo
& tunnel_info
= handle
.ssl_error_response_info();
1261 EXPECT_EQ(tunnel_info
.headers
->response_code(), 407);
1262 scoped_ptr
<ClientSocketHandle
> tunnel_handle(
1263 handle
.release_pending_http_proxy_connection());
1264 EXPECT_TRUE(tunnel_handle
->socket());
1265 EXPECT_FALSE(tunnel_handle
->socket()->IsConnected());
1268 TEST_P(SSLClientSocketPoolTest
, IPPooling
) {
1269 const int kTestPort
= 80;
1274 AddressList addresses
;
1276 { "www.webkit.org", "192.0.2.33,192.168.0.1,192.168.0.5" },
1277 { "code.google.com", "192.168.0.2,192.168.0.3,192.168.0.5" },
1278 { "js.webkit.org", "192.168.0.4,192.168.0.1,192.0.2.33" },
1281 host_resolver_
.set_synchronous_mode(true);
1282 for (size_t i
= 0; i
< arraysize(test_hosts
); i
++) {
1283 host_resolver_
.rules()->AddIPLiteralRule(
1284 test_hosts
[i
].name
, test_hosts
[i
].iplist
, std::string());
1286 // This test requires that the HostResolver cache be populated. Normal
1287 // code would have done this already, but we do it manually.
1288 HostResolver::RequestInfo
info(HostPortPair(test_hosts
[i
].name
, kTestPort
));
1289 host_resolver_
.Resolve(info
,
1291 &test_hosts
[i
].addresses
,
1292 CompletionCallback(),
1296 // Setup a SpdySessionKey
1297 test_hosts
[i
].key
= SpdySessionKey(
1298 HostPortPair(test_hosts
[i
].name
, kTestPort
), ProxyServer::Direct(),
1299 PRIVACY_MODE_DISABLED
);
1302 MockRead reads
[] = {
1303 MockRead(ASYNC
, ERR_IO_PENDING
),
1305 StaticSocketDataProvider
data(reads
, arraysize(reads
), NULL
, 0);
1306 socket_factory_
.AddSocketDataProvider(&data
);
1307 SSLSocketDataProvider
ssl(ASYNC
, OK
);
1308 ssl
.cert
= X509Certificate::CreateFromBytes(
1309 reinterpret_cast<const char*>(webkit_der
), sizeof(webkit_der
));
1310 ssl
.SetNextProto(GetParam());
1311 socket_factory_
.AddSSLSocketDataProvider(&ssl
);
1313 CreatePool(true /* tcp pool */, false, false);
1314 base::WeakPtr
<SpdySession
> spdy_session
=
1315 CreateSecureSpdySession(session_
, test_hosts
[0].key
, BoundNetLog());
1318 HasSpdySession(session_
->spdy_session_pool(), test_hosts
[0].key
));
1320 HasSpdySession(session_
->spdy_session_pool(), test_hosts
[1].key
));
1322 HasSpdySession(session_
->spdy_session_pool(), test_hosts
[2].key
));
1324 session_
->spdy_session_pool()->CloseAllSessions();
1327 void SSLClientSocketPoolTest::TestIPPoolingDisabled(
1328 SSLSocketDataProvider
* ssl
) {
1329 const int kTestPort
= 80;
1334 AddressList addresses
;
1336 { "www.webkit.org", "192.0.2.33,192.168.0.1,192.168.0.5" },
1337 { "js.webkit.com", "192.168.0.4,192.168.0.1,192.0.2.33" },
1340 TestCompletionCallback callback
;
1342 for (size_t i
= 0; i
< arraysize(test_hosts
); i
++) {
1343 host_resolver_
.rules()->AddIPLiteralRule(
1344 test_hosts
[i
].name
, test_hosts
[i
].iplist
, std::string());
1346 // This test requires that the HostResolver cache be populated. Normal
1347 // code would have done this already, but we do it manually.
1348 HostResolver::RequestInfo
info(HostPortPair(test_hosts
[i
].name
, kTestPort
));
1349 rv
= host_resolver_
.Resolve(info
,
1351 &test_hosts
[i
].addresses
,
1352 callback
.callback(),
1355 EXPECT_EQ(OK
, callback
.GetResult(rv
));
1357 // Setup a SpdySessionKey
1358 test_hosts
[i
].key
= SpdySessionKey(
1359 HostPortPair(test_hosts
[i
].name
, kTestPort
), ProxyServer::Direct(),
1360 PRIVACY_MODE_DISABLED
);
1363 MockRead reads
[] = {
1364 MockRead(ASYNC
, ERR_IO_PENDING
),
1366 StaticSocketDataProvider
data(reads
, arraysize(reads
), NULL
, 0);
1367 socket_factory_
.AddSocketDataProvider(&data
);
1368 socket_factory_
.AddSSLSocketDataProvider(ssl
);
1370 CreatePool(true /* tcp pool */, false, false);
1371 base::WeakPtr
<SpdySession
> spdy_session
=
1372 CreateSecureSpdySession(session_
, test_hosts
[0].key
, BoundNetLog());
1375 HasSpdySession(session_
->spdy_session_pool(), test_hosts
[0].key
));
1377 HasSpdySession(session_
->spdy_session_pool(), test_hosts
[1].key
));
1379 session_
->spdy_session_pool()->CloseAllSessions();
1382 // Verifies that an SSL connection with client authentication disables SPDY IP
1384 TEST_P(SSLClientSocketPoolTest
, IPPoolingClientCert
) {
1385 SSLSocketDataProvider
ssl(ASYNC
, OK
);
1386 ssl
.cert
= X509Certificate::CreateFromBytes(
1387 reinterpret_cast<const char*>(webkit_der
), sizeof(webkit_der
));
1388 ssl
.client_cert_sent
= true;
1389 ssl
.SetNextProto(GetParam());
1390 TestIPPoolingDisabled(&ssl
);
1393 // Verifies that an SSL connection with channel ID disables SPDY IP pooling.
1394 TEST_P(SSLClientSocketPoolTest
, IPPoolingChannelID
) {
1395 SSLSocketDataProvider
ssl(ASYNC
, OK
);
1396 ssl
.channel_id_sent
= true;
1397 ssl
.SetNextProto(GetParam());
1398 TestIPPoolingDisabled(&ssl
);
1401 // It would be nice to also test the timeouts in SSLClientSocketPool.