net/socket/ssl_client_socket_pool_unittest.cc

   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.
   4
   5 #include "net/http/http_proxy_client_socket_pool.h"
   6
   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"
  37
  38 namespace net {
  39
  40 namespace {
  41
  42 const int kMaxSockets = 32;
  43 const int kMaxSocketsPerGroup = 6;
  44
  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));
  51
  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);
  55
  56   ExpectConnectTimingHasTimes(
  57       load_timing_info.connect_timing,
  58       CONNECT_TIMING_HAS_SSL_TIMES | CONNECT_TIMING_HAS_DNS_TIMES);
  59   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
  60 }
  61
  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));
  67
  68   // None of these tests use a NetLog.
  69   EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
  70
  71   EXPECT_FALSE(load_timing_info.socket_reused);
  72
  73   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
  74                               CONNECT_TIMING_HAS_SSL_TIMES);
  75   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
  76 }
  77
  78 class SSLClientSocketPoolTest
  79     : public testing::Test,
  80       public ::testing::WithParamInterface<NextProto> {
  81  protected:
  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),
  92                 false,
  93                 false,
  94                 OnHostResolutionCallback(),
  95                 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)),
  96         transport_histograms_("MockTCP"),
  97         transport_socket_pool_(kMaxSockets,
  98                                kMaxSocketsPerGroup,
  99                                &transport_histograms_,
 100                                &socket_factory_),
 101         proxy_transport_socket_params_(
 102             new TransportSocketParams(
 103                 HostPortPair("proxy", 443),
 104                 false,
 105                 false,
 106                 OnHostResolutionCallback(),
 107                 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)),
 108         socks_socket_params_(
 109             new SOCKSSocketParams(proxy_transport_socket_params_,
 110                                   true,
 111                                   HostPortPair("sockshost", 443))),
 112         socks_histograms_("MockSOCKS"),
 113         socks_socket_pool_(kMaxSockets,
 114                            kMaxSocketsPerGroup,
 115                            &socks_histograms_,
 116                            &transport_socket_pool_),
 117         http_proxy_socket_params_(
 118             new HttpProxySocketParams(proxy_transport_socket_params_,
 119                                       NULL,
 120                                       GURL("http://host"),
 121                                       std::string(),
 122                                       HostPortPair("host", 80),
 123                                       session_->http_auth_cache(),
 124                                       session_->http_auth_handler_factory(),
 125                                       session_->spdy_session_pool(),
 126                                       true,
 127                                       NULL)),
 128         http_proxy_histograms_("MockHttpProxy"),
 129         http_proxy_socket_pool_(kMaxSockets,
 130                                 kMaxSocketsPerGroup,
 131                                 &http_proxy_histograms_,
 132                                 &host_resolver_,
 133                                 &transport_socket_pool_,
 134                                 NULL,
 135                                 NULL,
 136                                 NULL),
 137         enable_ssl_connect_job_waiting_(false) {
 138     scoped_refptr<SSLConfigService> ssl_config_service(
 139         new SSLConfigServiceDefaults);
 140     ssl_config_service->GetSSLConfig(&ssl_config_);
 141   }
 142
 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(
 146         kMaxSockets,
 147         kMaxSocketsPerGroup,
 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 */,
 155         &socket_factory_,
 156         transport_pool ? &transport_socket_pool_ : NULL,
 157         socks_pool ? &socks_socket_pool_ : NULL,
 158         http_proxy_pool ? &http_proxy_socket_pool_ : NULL,
 159         NULL,
 160         enable_ssl_connect_job_waiting_,
 161         NULL));
 162   }
 163
 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_
 168                                             : NULL,
 169         proxy == ProxyServer::SCHEME_SOCKS5 ? socks_socket_params_ : NULL,
 170         proxy == ProxyServer::SCHEME_HTTP ? http_proxy_socket_params_ : NULL,
 171         HostPortPair("host", 443),
 172         ssl_config_,
 173         PRIVACY_MODE_DISABLED,
 174         0,
 175         false,
 176         want_spdy_over_npn));
 177   }
 178
 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/"),
 183                                      "MyRealm1",
 184                                      HttpAuth::AUTH_SCHEME_BASIC,
 185                                      "Basic realm=MyRealm1",
 186                                      AuthCredentials(kFoo, kBar),
 187                                      "/");
 188   }
 189
 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);
 204   }
 205
 206   void TestIPPoolingDisabled(SSLSocketDataProvider* ssl);
 207
 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_;
 217
 218   scoped_refptr<TransportSocketParams> direct_transport_socket_params_;
 219   ClientSocketPoolHistograms transport_histograms_;
 220   MockTransportClientSocketPool transport_socket_pool_;
 221
 222   scoped_refptr<TransportSocketParams> proxy_transport_socket_params_;
 223
 224   scoped_refptr<SOCKSSocketParams> socks_socket_params_;
 225   ClientSocketPoolHistograms socks_histograms_;
 226   MockSOCKSClientSocketPool socks_socket_pool_;
 227
 228   scoped_refptr<HttpProxySocketParams> http_proxy_socket_params_;
 229   ClientSocketPoolHistograms http_proxy_histograms_;
 230   HttpProxyClientSocketPool http_proxy_socket_pool_;
 231
 232   SSLConfig ssl_config_;
 233   scoped_ptr<ClientSocketPoolHistograms> ssl_histograms_;
 234   scoped_ptr<SSLClientSocketPool> pool_;
 235
 236   bool enable_ssl_connect_job_waiting_;
 237 };
 238
 239 INSTANTIATE_TEST_CASE_P(
 240     NextProto,
 241     SSLClientSocketPoolTest,
 242     testing::Values(kProtoSPDY31, kProtoSPDY4_14, kProtoSPDY4_15));
 243
 244 // Tests that the final socket will connect even if all sockets
 245 // prior to it fail.
 246 //
 247 // All sockets should wait for the first socket to attempt to
 248 // connect. Once it fails to connect, all other sockets should
 249 // attempt to connect. All should fail, except the final socket.
 250 TEST_P(SSLClientSocketPoolTest, AllSocketsFailButLast) {
 251   // Although we request four sockets, the first three socket connect
 252   // failures cause the socket pool to create three more sockets because
 253   // there are pending requests.
 254   StaticSocketDataProvider data1;
 255   StaticSocketDataProvider data2;
 256   StaticSocketDataProvider data3;
 257   StaticSocketDataProvider data4;
 258   StaticSocketDataProvider data5;
 259   StaticSocketDataProvider data6;
 260   StaticSocketDataProvider data7;
 261   socket_factory_.AddSocketDataProvider(&data1);
 262   socket_factory_.AddSocketDataProvider(&data2);
 263   socket_factory_.AddSocketDataProvider(&data3);
 264   socket_factory_.AddSocketDataProvider(&data4);
 265   socket_factory_.AddSocketDataProvider(&data5);
 266   socket_factory_.AddSocketDataProvider(&data6);
 267   socket_factory_.AddSocketDataProvider(&data7);
 268   SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR);
 269   ssl.is_in_session_cache = false;
 270   SSLSocketDataProvider ssl2(ASYNC, ERR_SSL_PROTOCOL_ERROR);
 271   ssl2.is_in_session_cache = false;
 272   SSLSocketDataProvider ssl3(ASYNC, ERR_SSL_PROTOCOL_ERROR);
 273   ssl3.is_in_session_cache = false;
 274   SSLSocketDataProvider ssl4(ASYNC, OK);
 275   ssl4.is_in_session_cache = false;
 276   SSLSocketDataProvider ssl5(ASYNC, OK);
 277   ssl5.is_in_session_cache = false;
 278   SSLSocketDataProvider ssl6(ASYNC, OK);
 279   ssl6.is_in_session_cache = false;
 280   SSLSocketDataProvider ssl7(ASYNC, OK);
 281   ssl7.is_in_session_cache = false;
 282
 283   socket_factory_.AddSSLSocketDataProvider(&ssl);
 284   socket_factory_.AddSSLSocketDataProvider(&ssl2);
 285   socket_factory_.AddSSLSocketDataProvider(&ssl3);
 286   socket_factory_.AddSSLSocketDataProvider(&ssl4);
 287   socket_factory_.AddSSLSocketDataProvider(&ssl5);
 288   socket_factory_.AddSSLSocketDataProvider(&ssl6);
 289   socket_factory_.AddSSLSocketDataProvider(&ssl7);
 290
 291   enable_ssl_connect_job_waiting_ = true;
 292   CreatePool(true, false, false);
 293
 294   scoped_refptr<SSLSocketParams> params1 =
 295       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 296   scoped_refptr<SSLSocketParams> params2 =
 297       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 298   scoped_refptr<SSLSocketParams> params3 =
 299       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 300   scoped_refptr<SSLSocketParams> params4 =
 301       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 302   ClientSocketHandle handle1;
 303   ClientSocketHandle handle2;
 304   ClientSocketHandle handle3;
 305   ClientSocketHandle handle4;
 306   TestCompletionCallback callback1;
 307   TestCompletionCallback callback2;
 308   TestCompletionCallback callback3;
 309   TestCompletionCallback callback4;
 310
 311   handle1.Init(
 312       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 313   handle2.Init(
 314       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 315   handle3.Init(
 316       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 317   handle4.Init(
 318       "b", params4, MEDIUM, callback4.callback(), pool_.get(), BoundNetLog());
 319
 320   base::RunLoop().RunUntilIdle();
 321
 322   // Only the last socket should have connected.
 323   EXPECT_FALSE(handle1.socket());
 324   EXPECT_FALSE(handle2.socket());
 325   EXPECT_FALSE(handle3.socket());
 326   EXPECT_TRUE(handle4.socket()->IsConnected());
 327 }
 328
 329 // Tests that sockets will still connect in parallel if the
 330 // EnableSSLConnectJobWaiting flag is not enabled.
 331 TEST_P(SSLClientSocketPoolTest, SocketsConnectWithoutFlag) {
 332   StaticSocketDataProvider data1;
 333   StaticSocketDataProvider data2;
 334   StaticSocketDataProvider data3;
 335   socket_factory_.AddSocketDataProvider(&data1);
 336   socket_factory_.AddSocketDataProvider(&data2);
 337   socket_factory_.AddSocketDataProvider(&data3);
 338
 339   SSLSocketDataProvider ssl(ASYNC, OK);
 340   ssl.is_in_session_cache = false;
 341   ssl.should_pause_on_connect = true;
 342   SSLSocketDataProvider ssl2(ASYNC, OK);
 343   ssl2.is_in_session_cache = false;
 344   ssl2.should_pause_on_connect = true;
 345   SSLSocketDataProvider ssl3(ASYNC, OK);
 346   ssl3.is_in_session_cache = false;
 347   ssl3.should_pause_on_connect = true;
 348   socket_factory_.AddSSLSocketDataProvider(&ssl);
 349   socket_factory_.AddSSLSocketDataProvider(&ssl2);
 350   socket_factory_.AddSSLSocketDataProvider(&ssl3);
 351
 352   CreatePool(true, false, false);
 353
 354   scoped_refptr<SSLSocketParams> params1 =
 355       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 356   scoped_refptr<SSLSocketParams> params2 =
 357       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 358   scoped_refptr<SSLSocketParams> params3 =
 359       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 360   ClientSocketHandle handle1;
 361   ClientSocketHandle handle2;
 362   ClientSocketHandle handle3;
 363   TestCompletionCallback callback1;
 364   TestCompletionCallback callback2;
 365   TestCompletionCallback callback3;
 366
 367   handle1.Init(
 368       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 369   handle2.Init(
 370       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 371   handle3.Init(
 372       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 373
 374   base::RunLoop().RunUntilIdle();
 375
 376   std::vector<MockSSLClientSocket*> sockets =
 377       socket_factory_.ssl_client_sockets();
 378
 379   // All sockets should have started their connections.
 380   for (std::vector<MockSSLClientSocket*>::iterator it = sockets.begin();
 381        it != sockets.end();
 382        ++it) {
 383     EXPECT_TRUE((*it)->reached_connect());
 384   }
 385
 386   // Resume connecting all of the sockets.
 387   for (std::vector<MockSSLClientSocket*>::iterator it = sockets.begin();
 388        it != sockets.end();
 389        ++it) {
 390     (*it)->RestartPausedConnect();
 391   }
 392
 393   callback1.WaitForResult();
 394   callback2.WaitForResult();
 395   callback3.WaitForResult();
 396
 397   EXPECT_TRUE(handle1.socket()->IsConnected());
 398   EXPECT_TRUE(handle2.socket()->IsConnected());
 399   EXPECT_TRUE(handle3.socket()->IsConnected());
 400 }
 401
 402 // Tests that the pool deleting an SSLConnectJob will not cause a crash,
 403 // or prevent pending sockets from connecting.
 404 TEST_P(SSLClientSocketPoolTest, DeletedSSLConnectJob) {
 405   StaticSocketDataProvider data1;
 406   StaticSocketDataProvider data2;
 407   StaticSocketDataProvider data3;
 408   socket_factory_.AddSocketDataProvider(&data1);
 409   socket_factory_.AddSocketDataProvider(&data2);
 410   socket_factory_.AddSocketDataProvider(&data3);
 411
 412   SSLSocketDataProvider ssl(ASYNC, OK);
 413   ssl.is_in_session_cache = false;
 414   ssl.should_pause_on_connect = true;
 415   SSLSocketDataProvider ssl2(ASYNC, OK);
 416   ssl2.is_in_session_cache = false;
 417   SSLSocketDataProvider ssl3(ASYNC, OK);
 418   ssl3.is_in_session_cache = false;
 419   socket_factory_.AddSSLSocketDataProvider(&ssl);
 420   socket_factory_.AddSSLSocketDataProvider(&ssl2);
 421   socket_factory_.AddSSLSocketDataProvider(&ssl3);
 422
 423   enable_ssl_connect_job_waiting_ = true;
 424   CreatePool(true, false, false);
 425
 426   scoped_refptr<SSLSocketParams> params1 =
 427       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 428   scoped_refptr<SSLSocketParams> params2 =
 429       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 430   scoped_refptr<SSLSocketParams> params3 =
 431       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 432   ClientSocketHandle handle1;
 433   ClientSocketHandle handle2;
 434   ClientSocketHandle handle3;
 435   TestCompletionCallback callback1;
 436   TestCompletionCallback callback2;
 437   TestCompletionCallback callback3;
 438
 439   handle1.Init(
 440       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 441   handle2.Init(
 442       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 443   handle3.Init(
 444       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 445
 446   // Allow the connections to proceed until the first socket has started
 447   // connecting.
 448   base::RunLoop().RunUntilIdle();
 449
 450   std::vector<MockSSLClientSocket*> sockets =
 451       socket_factory_.ssl_client_sockets();
 452
 453   pool_->CancelRequest("b", &handle2);
 454
 455   sockets[0]->RestartPausedConnect();
 456
 457   callback1.WaitForResult();
 458   callback3.WaitForResult();
 459
 460   EXPECT_TRUE(handle1.socket()->IsConnected());
 461   EXPECT_FALSE(handle2.socket());
 462   EXPECT_TRUE(handle3.socket()->IsConnected());
 463 }
 464
 465 // Tests that all pending sockets still connect when the pool deletes a pending
 466 // SSLConnectJob which immediately followed a failed leading connection.
 467 TEST_P(SSLClientSocketPoolTest, DeletedSocketAfterFail) {
 468   StaticSocketDataProvider data1;
 469   StaticSocketDataProvider data2;
 470   StaticSocketDataProvider data3;
 471   StaticSocketDataProvider data4;
 472   socket_factory_.AddSocketDataProvider(&data1);
 473   socket_factory_.AddSocketDataProvider(&data2);
 474   socket_factory_.AddSocketDataProvider(&data3);
 475   socket_factory_.AddSocketDataProvider(&data4);
 476
 477   SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR);
 478   ssl.is_in_session_cache = false;
 479   ssl.should_pause_on_connect = true;
 480   SSLSocketDataProvider ssl2(ASYNC, OK);
 481   ssl2.is_in_session_cache = false;
 482   SSLSocketDataProvider ssl3(ASYNC, OK);
 483   ssl3.is_in_session_cache = false;
 484   SSLSocketDataProvider ssl4(ASYNC, OK);
 485   ssl4.is_in_session_cache = false;
 486   socket_factory_.AddSSLSocketDataProvider(&ssl);
 487   socket_factory_.AddSSLSocketDataProvider(&ssl2);
 488   socket_factory_.AddSSLSocketDataProvider(&ssl3);
 489   socket_factory_.AddSSLSocketDataProvider(&ssl4);
 490
 491   enable_ssl_connect_job_waiting_ = true;
 492   CreatePool(true, false, false);
 493
 494   scoped_refptr<SSLSocketParams> params1 =
 495       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 496   scoped_refptr<SSLSocketParams> params2 =
 497       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 498   scoped_refptr<SSLSocketParams> params3 =
 499       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 500   ClientSocketHandle handle1;
 501   ClientSocketHandle handle2;
 502   ClientSocketHandle handle3;
 503   TestCompletionCallback callback1;
 504   TestCompletionCallback callback2;
 505   TestCompletionCallback callback3;
 506
 507   handle1.Init(
 508       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 509   handle2.Init(
 510       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 511   handle3.Init(
 512       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 513
 514   // Allow the connections to proceed until the first socket has started
 515   // connecting.
 516   base::RunLoop().RunUntilIdle();
 517
 518   std::vector<MockSSLClientSocket*> sockets =
 519       socket_factory_.ssl_client_sockets();
 520
 521   EXPECT_EQ(3u, sockets.size());
 522   EXPECT_TRUE(sockets[0]->reached_connect());
 523   EXPECT_FALSE(handle1.socket());
 524
 525   pool_->CancelRequest("b", &handle2);
 526
 527   sockets[0]->RestartPausedConnect();
 528
 529   callback1.WaitForResult();
 530   callback3.WaitForResult();
 531
 532   EXPECT_FALSE(handle1.socket());
 533   EXPECT_FALSE(handle2.socket());
 534   EXPECT_TRUE(handle3.socket()->IsConnected());
 535 }
 536
 537 // Make sure that sockets still connect after the leader socket's
 538 // connection fails.
 539 TEST_P(SSLClientSocketPoolTest, SimultaneousConnectJobsFail) {
 540   StaticSocketDataProvider data1;
 541   StaticSocketDataProvider data2;
 542   StaticSocketDataProvider data3;
 543   StaticSocketDataProvider data4;
 544   StaticSocketDataProvider data5;
 545   socket_factory_.AddSocketDataProvider(&data1);
 546   socket_factory_.AddSocketDataProvider(&data2);
 547   socket_factory_.AddSocketDataProvider(&data3);
 548   socket_factory_.AddSocketDataProvider(&data4);
 549   socket_factory_.AddSocketDataProvider(&data5);
 550   SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR);
 551   ssl.is_in_session_cache = false;
 552   ssl.should_pause_on_connect = true;
 553   SSLSocketDataProvider ssl2(ASYNC, OK);
 554   ssl2.is_in_session_cache = false;
 555   ssl2.should_pause_on_connect = true;
 556   SSLSocketDataProvider ssl3(ASYNC, OK);
 557   ssl3.is_in_session_cache = false;
 558   SSLSocketDataProvider ssl4(ASYNC, OK);
 559   ssl4.is_in_session_cache = false;
 560   SSLSocketDataProvider ssl5(ASYNC, OK);
 561   ssl5.is_in_session_cache = false;
 562
 563   socket_factory_.AddSSLSocketDataProvider(&ssl);
 564   socket_factory_.AddSSLSocketDataProvider(&ssl2);
 565   socket_factory_.AddSSLSocketDataProvider(&ssl3);
 566   socket_factory_.AddSSLSocketDataProvider(&ssl4);
 567   socket_factory_.AddSSLSocketDataProvider(&ssl5);
 568
 569   enable_ssl_connect_job_waiting_ = true;
 570   CreatePool(true, false, false);
 571   scoped_refptr<SSLSocketParams> params1 =
 572       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 573   scoped_refptr<SSLSocketParams> params2 =
 574       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 575   scoped_refptr<SSLSocketParams> params3 =
 576       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 577   scoped_refptr<SSLSocketParams> params4 =
 578       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 579   ClientSocketHandle handle1;
 580   ClientSocketHandle handle2;
 581   ClientSocketHandle handle3;
 582   ClientSocketHandle handle4;
 583   TestCompletionCallback callback1;
 584   TestCompletionCallback callback2;
 585   TestCompletionCallback callback3;
 586   TestCompletionCallback callback4;
 587   handle1.Init(
 588       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 589   handle2.Init(
 590       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 591   handle3.Init(
 592       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 593   handle4.Init(
 594       "b", params4, MEDIUM, callback4.callback(), pool_.get(), BoundNetLog());
 595
 596   base::RunLoop().RunUntilIdle();
 597
 598   std::vector<MockSSLClientSocket*> sockets =
 599       socket_factory_.ssl_client_sockets();
 600
 601   std::vector<MockSSLClientSocket*>::const_iterator it = sockets.begin();
 602
 603   // The first socket should have had Connect called on it.
 604   EXPECT_TRUE((*it)->reached_connect());
 605   ++it;
 606
 607   // No other socket should have reached connect yet.
 608   for (; it != sockets.end(); ++it)
 609     EXPECT_FALSE((*it)->reached_connect());
 610
 611   // Allow the first socket to resume it's connection process.
 612   sockets[0]->RestartPausedConnect();
 613
 614   base::RunLoop().RunUntilIdle();
 615
 616   // The second socket should have reached connect.
 617   EXPECT_TRUE(sockets[1]->reached_connect());
 618
 619   // Allow the second socket to continue its connection.
 620   sockets[1]->RestartPausedConnect();
 621
 622   base::RunLoop().RunUntilIdle();
 623
 624   EXPECT_FALSE(handle1.socket());
 625   EXPECT_TRUE(handle2.socket()->IsConnected());
 626   EXPECT_TRUE(handle3.socket()->IsConnected());
 627   EXPECT_TRUE(handle4.socket()->IsConnected());
 628 }
 629
 630 // Make sure that no sockets connect before the "leader" socket,
 631 // given that the leader has a successful connection.
 632 TEST_P(SSLClientSocketPoolTest, SimultaneousConnectJobsSuccess) {
 633   StaticSocketDataProvider data1;
 634   StaticSocketDataProvider data2;
 635   StaticSocketDataProvider data3;
 636   socket_factory_.AddSocketDataProvider(&data1);
 637   socket_factory_.AddSocketDataProvider(&data2);
 638   socket_factory_.AddSocketDataProvider(&data3);
 639
 640   SSLSocketDataProvider ssl(ASYNC, OK);
 641   ssl.is_in_session_cache = false;
 642   ssl.should_pause_on_connect = true;
 643   SSLSocketDataProvider ssl2(ASYNC, OK);
 644   ssl2.is_in_session_cache = false;
 645   SSLSocketDataProvider ssl3(ASYNC, OK);
 646   ssl3.is_in_session_cache = false;
 647   socket_factory_.AddSSLSocketDataProvider(&ssl);
 648   socket_factory_.AddSSLSocketDataProvider(&ssl2);
 649   socket_factory_.AddSSLSocketDataProvider(&ssl3);
 650
 651   enable_ssl_connect_job_waiting_ = true;
 652   CreatePool(true, false, false);
 653
 654   scoped_refptr<SSLSocketParams> params1 =
 655       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 656   scoped_refptr<SSLSocketParams> params2 =
 657       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 658   scoped_refptr<SSLSocketParams> params3 =
 659       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 660   ClientSocketHandle handle1;
 661   ClientSocketHandle handle2;
 662   ClientSocketHandle handle3;
 663   TestCompletionCallback callback1;
 664   TestCompletionCallback callback2;
 665   TestCompletionCallback callback3;
 666
 667   handle1.Init(
 668       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 669   handle2.Init(
 670       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 671   handle3.Init(
 672       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 673
 674   // Allow the connections to proceed until the first socket has finished
 675   // connecting.
 676   base::RunLoop().RunUntilIdle();
 677
 678   std::vector<MockSSLClientSocket*> sockets =
 679       socket_factory_.ssl_client_sockets();
 680
 681   std::vector<MockSSLClientSocket*>::const_iterator it = sockets.begin();
 682   // The first socket should have reached connect.
 683   EXPECT_TRUE((*it)->reached_connect());
 684   ++it;
 685   // No other socket should have reached connect yet.
 686   for (; it != sockets.end(); ++it)
 687     EXPECT_FALSE((*it)->reached_connect());
 688
 689   sockets[0]->RestartPausedConnect();
 690
 691   callback1.WaitForResult();
 692   callback2.WaitForResult();
 693   callback3.WaitForResult();
 694
 695   EXPECT_TRUE(handle1.socket()->IsConnected());
 696   EXPECT_TRUE(handle2.socket()->IsConnected());
 697   EXPECT_TRUE(handle3.socket()->IsConnected());
 698 }
 699
 700 TEST_P(SSLClientSocketPoolTest, TCPFail) {
 701   StaticSocketDataProvider data;
 702   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
 703   socket_factory_.AddSocketDataProvider(&data);
 704
 705   CreatePool(true /* tcp pool */, false, false);
 706   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 707                                                     false);
 708
 709   ClientSocketHandle handle;
 710   int rv = handle.Init("a", params, MEDIUM, CompletionCallback(), pool_.get(),
 711                        BoundNetLog());
 712   EXPECT_EQ(ERR_CONNECTION_FAILED, rv);
 713   EXPECT_FALSE(handle.is_initialized());
 714   EXPECT_FALSE(handle.socket());
 715   EXPECT_FALSE(handle.is_ssl_error());
 716 }
 717
 718 TEST_P(SSLClientSocketPoolTest, TCPFailAsync) {
 719   StaticSocketDataProvider data;
 720   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
 721   socket_factory_.AddSocketDataProvider(&data);
 722
 723   CreatePool(true /* tcp pool */, false, false);
 724   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 725                                                     false);
 726
 727   ClientSocketHandle handle;
 728   TestCompletionCallback callback;
 729   int rv = handle.Init(
 730       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 731   EXPECT_EQ(ERR_IO_PENDING, rv);
 732   EXPECT_FALSE(handle.is_initialized());
 733   EXPECT_FALSE(handle.socket());
 734
 735   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
 736   EXPECT_FALSE(handle.is_initialized());
 737   EXPECT_FALSE(handle.socket());
 738   EXPECT_FALSE(handle.is_ssl_error());
 739 }
 740
 741 TEST_P(SSLClientSocketPoolTest, BasicDirect) {
 742   StaticSocketDataProvider data;
 743   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
 744   socket_factory_.AddSocketDataProvider(&data);
 745   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
 746   socket_factory_.AddSSLSocketDataProvider(&ssl);
 747
 748   CreatePool(true /* tcp pool */, false, false);
 749   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 750                                                     false);
 751
 752   ClientSocketHandle handle;
 753   TestCompletionCallback callback;
 754   int rv = handle.Init(
 755       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 756   EXPECT_EQ(OK, rv);
 757   EXPECT_TRUE(handle.is_initialized());
 758   EXPECT_TRUE(handle.socket());
 759   TestLoadTimingInfo(handle);
 760 }
 761
 762 // Make sure that SSLConnectJob passes on its priority to its
 763 // socket request on Init (for the DIRECT case).
 764 TEST_P(SSLClientSocketPoolTest, SetSocketRequestPriorityOnInitDirect) {
 765   CreatePool(true /* tcp pool */, false, false);
 766   scoped_refptr<SSLSocketParams> params =
 767       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 768
 769   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
 770     RequestPriority priority = static_cast<RequestPriority>(i);
 771     StaticSocketDataProvider data;
 772     data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
 773     socket_factory_.AddSocketDataProvider(&data);
 774     SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
 775     socket_factory_.AddSSLSocketDataProvider(&ssl);
 776
 777     ClientSocketHandle handle;
 778     TestCompletionCallback callback;
 779     EXPECT_EQ(OK, handle.Init("a", params, priority, callback.callback(),
 780                               pool_.get(), BoundNetLog()));
 781     EXPECT_EQ(priority, transport_socket_pool_.last_request_priority());
 782     handle.socket()->Disconnect();
 783   }
 784 }
 785
 786 TEST_P(SSLClientSocketPoolTest, BasicDirectAsync) {
 787   StaticSocketDataProvider data;
 788   socket_factory_.AddSocketDataProvider(&data);
 789   SSLSocketDataProvider ssl(ASYNC, OK);
 790   socket_factory_.AddSSLSocketDataProvider(&ssl);
 791
 792   CreatePool(true /* tcp pool */, false, false);
 793   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 794                                                     false);
 795
 796   ClientSocketHandle handle;
 797   TestCompletionCallback callback;
 798   int rv = handle.Init(
 799       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 800   EXPECT_EQ(ERR_IO_PENDING, rv);
 801   EXPECT_FALSE(handle.is_initialized());
 802   EXPECT_FALSE(handle.socket());
 803
 804   EXPECT_EQ(OK, callback.WaitForResult());
 805   EXPECT_TRUE(handle.is_initialized());
 806   EXPECT_TRUE(handle.socket());
 807   TestLoadTimingInfo(handle);
 808 }
 809
 810 TEST_P(SSLClientSocketPoolTest, DirectCertError) {
 811   StaticSocketDataProvider data;
 812   socket_factory_.AddSocketDataProvider(&data);
 813   SSLSocketDataProvider ssl(ASYNC, ERR_CERT_COMMON_NAME_INVALID);
 814   socket_factory_.AddSSLSocketDataProvider(&ssl);
 815
 816   CreatePool(true /* tcp pool */, false, false);
 817   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 818                                                     false);
 819
 820   ClientSocketHandle handle;
 821   TestCompletionCallback callback;
 822   int rv = handle.Init(
 823       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 824   EXPECT_EQ(ERR_IO_PENDING, rv);
 825   EXPECT_FALSE(handle.is_initialized());
 826   EXPECT_FALSE(handle.socket());
 827
 828   EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult());
 829   EXPECT_TRUE(handle.is_initialized());
 830   EXPECT_TRUE(handle.socket());
 831   TestLoadTimingInfo(handle);
 832 }
 833
 834 TEST_P(SSLClientSocketPoolTest, DirectSSLError) {
 835   StaticSocketDataProvider data;
 836   socket_factory_.AddSocketDataProvider(&data);
 837   SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR);
 838   socket_factory_.AddSSLSocketDataProvider(&ssl);
 839
 840   CreatePool(true /* tcp pool */, false, false);
 841   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 842                                                     false);
 843
 844   ClientSocketHandle handle;
 845   TestCompletionCallback callback;
 846   int rv = handle.Init(
 847       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 848   EXPECT_EQ(ERR_IO_PENDING, rv);
 849   EXPECT_FALSE(handle.is_initialized());
 850   EXPECT_FALSE(handle.socket());
 851
 852   EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.WaitForResult());
 853   EXPECT_FALSE(handle.is_initialized());
 854   EXPECT_FALSE(handle.socket());
 855   EXPECT_TRUE(handle.is_ssl_error());
 856 }
 857
 858 TEST_P(SSLClientSocketPoolTest, DirectWithNPN) {
 859   StaticSocketDataProvider data;
 860   socket_factory_.AddSocketDataProvider(&data);
 861   SSLSocketDataProvider ssl(ASYNC, OK);
 862   ssl.SetNextProto(kProtoHTTP11);
 863   socket_factory_.AddSSLSocketDataProvider(&ssl);
 864
 865   CreatePool(true /* tcp pool */, false, false);
 866   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 867                                                     false);
 868
 869   ClientSocketHandle handle;
 870   TestCompletionCallback callback;
 871   int rv = handle.Init(
 872       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 873   EXPECT_EQ(ERR_IO_PENDING, rv);
 874   EXPECT_FALSE(handle.is_initialized());
 875   EXPECT_FALSE(handle.socket());
 876
 877   EXPECT_EQ(OK, callback.WaitForResult());
 878   EXPECT_TRUE(handle.is_initialized());
 879   EXPECT_TRUE(handle.socket());
 880   TestLoadTimingInfo(handle);
 881   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
 882   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
 883 }
 884
 885 TEST_P(SSLClientSocketPoolTest, DirectNoSPDY) {
 886   StaticSocketDataProvider data;
 887   socket_factory_.AddSocketDataProvider(&data);
 888   SSLSocketDataProvider ssl(ASYNC, OK);
 889   ssl.SetNextProto(kProtoHTTP11);
 890   socket_factory_.AddSSLSocketDataProvider(&ssl);
 891
 892   CreatePool(true /* tcp pool */, false, false);
 893   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 894                                                     true);
 895
 896   ClientSocketHandle handle;
 897   TestCompletionCallback callback;
 898   int rv = handle.Init(
 899       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 900   EXPECT_EQ(ERR_IO_PENDING, rv);
 901   EXPECT_FALSE(handle.is_initialized());
 902   EXPECT_FALSE(handle.socket());
 903
 904   EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED, callback.WaitForResult());
 905   EXPECT_FALSE(handle.is_initialized());
 906   EXPECT_FALSE(handle.socket());
 907   EXPECT_TRUE(handle.is_ssl_error());
 908 }
 909
 910 TEST_P(SSLClientSocketPoolTest, DirectGotSPDY) {
 911   StaticSocketDataProvider data;
 912   socket_factory_.AddSocketDataProvider(&data);
 913   SSLSocketDataProvider ssl(ASYNC, OK);
 914   ssl.SetNextProto(GetParam());
 915   socket_factory_.AddSSLSocketDataProvider(&ssl);
 916
 917   CreatePool(true /* tcp pool */, false, false);
 918   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 919                                                     true);
 920
 921   ClientSocketHandle handle;
 922   TestCompletionCallback callback;
 923   int rv = handle.Init(
 924       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 925   EXPECT_EQ(ERR_IO_PENDING, rv);
 926   EXPECT_FALSE(handle.is_initialized());
 927   EXPECT_FALSE(handle.socket());
 928
 929   EXPECT_EQ(OK, callback.WaitForResult());
 930   EXPECT_TRUE(handle.is_initialized());
 931   EXPECT_TRUE(handle.socket());
 932   TestLoadTimingInfo(handle);
 933
 934   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
 935   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
 936   std::string proto;
 937   ssl_socket->GetNextProto(&proto);
 938   EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto));
 939 }
 940
 941 TEST_P(SSLClientSocketPoolTest, DirectGotBonusSPDY) {
 942   StaticSocketDataProvider data;
 943   socket_factory_.AddSocketDataProvider(&data);
 944   SSLSocketDataProvider ssl(ASYNC, OK);
 945   ssl.SetNextProto(GetParam());
 946   socket_factory_.AddSSLSocketDataProvider(&ssl);
 947
 948   CreatePool(true /* tcp pool */, false, false);
 949   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 950                                                     true);
 951
 952   ClientSocketHandle handle;
 953   TestCompletionCallback callback;
 954   int rv = handle.Init(
 955       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 956   EXPECT_EQ(ERR_IO_PENDING, rv);
 957   EXPECT_FALSE(handle.is_initialized());
 958   EXPECT_FALSE(handle.socket());
 959
 960   EXPECT_EQ(OK, callback.WaitForResult());
 961   EXPECT_TRUE(handle.is_initialized());
 962   EXPECT_TRUE(handle.socket());
 963   TestLoadTimingInfo(handle);
 964
 965   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
 966   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
 967   std::string proto;
 968   ssl_socket->GetNextProto(&proto);
 969   EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto));
 970 }
 971
 972 TEST_P(SSLClientSocketPoolTest, SOCKSFail) {
 973   StaticSocketDataProvider data;
 974   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
 975   socket_factory_.AddSocketDataProvider(&data);
 976
 977   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 978   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
 979                                                     false);
 980
 981   ClientSocketHandle handle;
 982   TestCompletionCallback callback;
 983   int rv = handle.Init(
 984       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 985   EXPECT_EQ(ERR_CONNECTION_FAILED, rv);
 986   EXPECT_FALSE(handle.is_initialized());
 987   EXPECT_FALSE(handle.socket());
 988   EXPECT_FALSE(handle.is_ssl_error());
 989 }
 990
 991 TEST_P(SSLClientSocketPoolTest, SOCKSFailAsync) {
 992   StaticSocketDataProvider data;
 993   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
 994   socket_factory_.AddSocketDataProvider(&data);
 995
 996   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 997   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
 998                                                     false);
 999
1000   ClientSocketHandle handle;
1001   TestCompletionCallback callback;
1002   int rv = handle.Init(
1003       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1004   EXPECT_EQ(ERR_IO_PENDING, rv);
1005   EXPECT_FALSE(handle.is_initialized());
1006   EXPECT_FALSE(handle.socket());
1007
1008   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
1009   EXPECT_FALSE(handle.is_initialized());
1010   EXPECT_FALSE(handle.socket());
1011   EXPECT_FALSE(handle.is_ssl_error());
1012 }
1013
1014 TEST_P(SSLClientSocketPoolTest, SOCKSBasic) {
1015   StaticSocketDataProvider data;
1016   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
1017   socket_factory_.AddSocketDataProvider(&data);
1018   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
1019   socket_factory_.AddSSLSocketDataProvider(&ssl);
1020
1021   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1022   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
1023                                                     false);
1024
1025   ClientSocketHandle handle;
1026   TestCompletionCallback callback;
1027   int rv = handle.Init(
1028       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1029   EXPECT_EQ(OK, rv);
1030   EXPECT_TRUE(handle.is_initialized());
1031   EXPECT_TRUE(handle.socket());
1032   // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here
1033   // don't go through the real logic, unlike in the HTTP proxy tests.
1034   TestLoadTimingInfo(handle);
1035 }
1036
1037 // Make sure that SSLConnectJob passes on its priority to its
1038 // transport socket on Init (for the SOCKS_PROXY case).
1039 TEST_P(SSLClientSocketPoolTest, SetTransportPriorityOnInitSOCKS) {
1040   StaticSocketDataProvider data;
1041   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
1042   socket_factory_.AddSocketDataProvider(&data);
1043   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
1044   socket_factory_.AddSSLSocketDataProvider(&ssl);
1045
1046   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1047   scoped_refptr<SSLSocketParams> params =
1048       SSLParams(ProxyServer::SCHEME_SOCKS5, false);
1049
1050   ClientSocketHandle handle;
1051   TestCompletionCallback callback;
1052   EXPECT_EQ(OK, handle.Init("a", params, HIGHEST, callback.callback(),
1053                             pool_.get(), BoundNetLog()));
1054   EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority());
1055 }
1056
1057 TEST_P(SSLClientSocketPoolTest, SOCKSBasicAsync) {
1058   StaticSocketDataProvider data;
1059   socket_factory_.AddSocketDataProvider(&data);
1060   SSLSocketDataProvider ssl(ASYNC, OK);
1061   socket_factory_.AddSSLSocketDataProvider(&ssl);
1062
1063   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1064   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
1065                                                     false);
1066
1067   ClientSocketHandle handle;
1068   TestCompletionCallback callback;
1069   int rv = handle.Init(
1070       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1071   EXPECT_EQ(ERR_IO_PENDING, rv);
1072   EXPECT_FALSE(handle.is_initialized());
1073   EXPECT_FALSE(handle.socket());
1074
1075   EXPECT_EQ(OK, callback.WaitForResult());
1076   EXPECT_TRUE(handle.is_initialized());
1077   EXPECT_TRUE(handle.socket());
1078   // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here
1079   // don't go through the real logic, unlike in the HTTP proxy tests.
1080   TestLoadTimingInfo(handle);
1081 }
1082
1083 TEST_P(SSLClientSocketPoolTest, HttpProxyFail) {
1084   StaticSocketDataProvider data;
1085   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
1086   socket_factory_.AddSocketDataProvider(&data);
1087
1088   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1089   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1090                                                     false);
1091
1092   ClientSocketHandle handle;
1093   TestCompletionCallback callback;
1094   int rv = handle.Init(
1095       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1096   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv);
1097   EXPECT_FALSE(handle.is_initialized());
1098   EXPECT_FALSE(handle.socket());
1099   EXPECT_FALSE(handle.is_ssl_error());
1100 }
1101
1102 TEST_P(SSLClientSocketPoolTest, HttpProxyFailAsync) {
1103   StaticSocketDataProvider data;
1104   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
1105   socket_factory_.AddSocketDataProvider(&data);
1106
1107   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1108   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1109                                                     false);
1110
1111   ClientSocketHandle handle;
1112   TestCompletionCallback callback;
1113   int rv = handle.Init(
1114       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1115   EXPECT_EQ(ERR_IO_PENDING, rv);
1116   EXPECT_FALSE(handle.is_initialized());
1117   EXPECT_FALSE(handle.socket());
1118
1119   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback.WaitForResult());
1120   EXPECT_FALSE(handle.is_initialized());
1121   EXPECT_FALSE(handle.socket());
1122   EXPECT_FALSE(handle.is_ssl_error());
1123 }
1124
1125 TEST_P(SSLClientSocketPoolTest, HttpProxyBasic) {
1126   MockWrite writes[] = {
1127       MockWrite(SYNCHRONOUS,
1128                 "CONNECT host:80 HTTP/1.1\r\n"
1129                 "Host: host\r\n"
1130                 "Proxy-Connection: keep-alive\r\n"
1131                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1132   };
1133   MockRead reads[] = {
1134       MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"),
1135   };
1136   StaticSocketDataProvider data(reads, arraysize(reads), writes,
1137                                 arraysize(writes));
1138   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
1139   socket_factory_.AddSocketDataProvider(&data);
1140   AddAuthToCache();
1141   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
1142   socket_factory_.AddSSLSocketDataProvider(&ssl);
1143
1144   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1145   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1146                                                     false);
1147
1148   ClientSocketHandle handle;
1149   TestCompletionCallback callback;
1150   int rv = handle.Init(
1151       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1152   EXPECT_EQ(OK, rv);
1153   EXPECT_TRUE(handle.is_initialized());
1154   EXPECT_TRUE(handle.socket());
1155   TestLoadTimingInfoNoDns(handle);
1156 }
1157
1158 // Make sure that SSLConnectJob passes on its priority to its
1159 // transport socket on Init (for the HTTP_PROXY case).
1160 TEST_P(SSLClientSocketPoolTest, SetTransportPriorityOnInitHTTP) {
1161   MockWrite writes[] = {
1162       MockWrite(SYNCHRONOUS,
1163                 "CONNECT host:80 HTTP/1.1\r\n"
1164                 "Host: host\r\n"
1165                 "Proxy-Connection: keep-alive\r\n"
1166                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1167   };
1168   MockRead reads[] = {
1169       MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"),
1170   };
1171   StaticSocketDataProvider data(reads, arraysize(reads), writes,
1172                                 arraysize(writes));
1173   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
1174   socket_factory_.AddSocketDataProvider(&data);
1175   AddAuthToCache();
1176   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
1177   socket_factory_.AddSSLSocketDataProvider(&ssl);
1178
1179   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1180   scoped_refptr<SSLSocketParams> params =
1181       SSLParams(ProxyServer::SCHEME_HTTP, false);
1182
1183   ClientSocketHandle handle;
1184   TestCompletionCallback callback;
1185   EXPECT_EQ(OK, handle.Init("a", params, HIGHEST, callback.callback(),
1186                             pool_.get(), BoundNetLog()));
1187   EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority());
1188 }
1189
1190 TEST_P(SSLClientSocketPoolTest, HttpProxyBasicAsync) {
1191   MockWrite writes[] = {
1192       MockWrite("CONNECT host:80 HTTP/1.1\r\n"
1193                 "Host: host\r\n"
1194                 "Proxy-Connection: keep-alive\r\n"
1195                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1196   };
1197   MockRead reads[] = {
1198       MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
1199   };
1200   StaticSocketDataProvider data(reads, arraysize(reads), writes,
1201                                 arraysize(writes));
1202   socket_factory_.AddSocketDataProvider(&data);
1203   AddAuthToCache();
1204   SSLSocketDataProvider ssl(ASYNC, OK);
1205   socket_factory_.AddSSLSocketDataProvider(&ssl);
1206
1207   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1208   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1209                                                     false);
1210
1211   ClientSocketHandle handle;
1212   TestCompletionCallback callback;
1213   int rv = handle.Init(
1214       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1215   EXPECT_EQ(ERR_IO_PENDING, rv);
1216   EXPECT_FALSE(handle.is_initialized());
1217   EXPECT_FALSE(handle.socket());
1218
1219   EXPECT_EQ(OK, callback.WaitForResult());
1220   EXPECT_TRUE(handle.is_initialized());
1221   EXPECT_TRUE(handle.socket());
1222   TestLoadTimingInfoNoDns(handle);
1223 }
1224
1225 TEST_P(SSLClientSocketPoolTest, NeedProxyAuth) {
1226   MockWrite writes[] = {
1227       MockWrite("CONNECT host:80 HTTP/1.1\r\n"
1228                 "Host: host\r\n"
1229                 "Proxy-Connection: keep-alive\r\n\r\n"),
1230   };
1231   MockRead reads[] = {
1232       MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
1233       MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
1234       MockRead("Content-Length: 10\r\n\r\n"),
1235       MockRead("0123456789"),
1236   };
1237   StaticSocketDataProvider data(reads, arraysize(reads), writes,
1238                                 arraysize(writes));
1239   socket_factory_.AddSocketDataProvider(&data);
1240   SSLSocketDataProvider ssl(ASYNC, OK);
1241   socket_factory_.AddSSLSocketDataProvider(&ssl);
1242
1243   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1244   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1245                                                     false);
1246
1247   ClientSocketHandle handle;
1248   TestCompletionCallback callback;
1249   int rv = handle.Init(
1250       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1251   EXPECT_EQ(ERR_IO_PENDING, rv);
1252   EXPECT_FALSE(handle.is_initialized());
1253   EXPECT_FALSE(handle.socket());
1254
1255   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult());
1256   EXPECT_FALSE(handle.is_initialized());
1257   EXPECT_FALSE(handle.socket());
1258   EXPECT_FALSE(handle.is_ssl_error());
1259   const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info();
1260   EXPECT_EQ(tunnel_info.headers->response_code(), 407);
1261   scoped_ptr<ClientSocketHandle> tunnel_handle(
1262       handle.release_pending_http_proxy_connection());
1263   EXPECT_TRUE(tunnel_handle->socket());
1264   EXPECT_FALSE(tunnel_handle->socket()->IsConnected());
1265 }
1266
1267 TEST_P(SSLClientSocketPoolTest, IPPooling) {
1268   const int kTestPort = 80;
1269   struct TestHosts {
1270     std::string name;
1271     std::string iplist;
1272     SpdySessionKey key;
1273     AddressList addresses;
1274   } test_hosts[] = {
1275     { "www.webkit.org",    "192.0.2.33,192.168.0.1,192.168.0.5" },
1276     { "code.google.com",   "192.168.0.2,192.168.0.3,192.168.0.5" },
1277     { "js.webkit.org",     "192.168.0.4,192.168.0.1,192.0.2.33" },
1278   };
1279
1280   host_resolver_.set_synchronous_mode(true);
1281   for (size_t i = 0; i < arraysize(test_hosts); i++) {
1282     host_resolver_.rules()->AddIPLiteralRule(
1283         test_hosts[i].name, test_hosts[i].iplist, std::string());
1284
1285     // This test requires that the HostResolver cache be populated.  Normal
1286     // code would have done this already, but we do it manually.
1287     HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
1288     host_resolver_.Resolve(info,
1289                            DEFAULT_PRIORITY,
1290                            &test_hosts[i].addresses,
1291                            CompletionCallback(),
1292                            NULL,
1293                            BoundNetLog());
1294
1295     // Setup a SpdySessionKey
1296     test_hosts[i].key = SpdySessionKey(
1297         HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(),
1298         PRIVACY_MODE_DISABLED);
1299   }
1300
1301   MockRead reads[] = {
1302       MockRead(ASYNC, ERR_IO_PENDING),
1303   };
1304   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
1305   socket_factory_.AddSocketDataProvider(&data);
1306   SSLSocketDataProvider ssl(ASYNC, OK);
1307   ssl.cert = X509Certificate::CreateFromBytes(
1308       reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
1309   ssl.SetNextProto(GetParam());
1310   socket_factory_.AddSSLSocketDataProvider(&ssl);
1311
1312   CreatePool(true /* tcp pool */, false, false);
1313   base::WeakPtr<SpdySession> spdy_session =
1314       CreateSecureSpdySession(session_, test_hosts[0].key, BoundNetLog());
1315
1316   EXPECT_TRUE(
1317       HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key));
1318   EXPECT_FALSE(
1319       HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key));
1320   EXPECT_TRUE(
1321       HasSpdySession(session_->spdy_session_pool(), test_hosts[2].key));
1322
1323   session_->spdy_session_pool()->CloseAllSessions();
1324 }
1325
1326 void SSLClientSocketPoolTest::TestIPPoolingDisabled(
1327     SSLSocketDataProvider* ssl) {
1328   const int kTestPort = 80;
1329   struct TestHosts {
1330     std::string name;
1331     std::string iplist;
1332     SpdySessionKey key;
1333     AddressList addresses;
1334   } test_hosts[] = {
1335     { "www.webkit.org",    "192.0.2.33,192.168.0.1,192.168.0.5" },
1336     { "js.webkit.com",     "192.168.0.4,192.168.0.1,192.0.2.33" },
1337   };
1338
1339   TestCompletionCallback callback;
1340   int rv;
1341   for (size_t i = 0; i < arraysize(test_hosts); i++) {
1342     host_resolver_.rules()->AddIPLiteralRule(
1343         test_hosts[i].name, test_hosts[i].iplist, std::string());
1344
1345     // This test requires that the HostResolver cache be populated.  Normal
1346     // code would have done this already, but we do it manually.
1347     HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
1348     rv = host_resolver_.Resolve(info,
1349                                 DEFAULT_PRIORITY,
1350                                 &test_hosts[i].addresses,
1351                                 callback.callback(),
1352                                 NULL,
1353                                 BoundNetLog());
1354     EXPECT_EQ(OK, callback.GetResult(rv));
1355
1356     // Setup a SpdySessionKey
1357     test_hosts[i].key = SpdySessionKey(
1358         HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(),
1359         PRIVACY_MODE_DISABLED);
1360   }
1361
1362   MockRead reads[] = {
1363       MockRead(ASYNC, ERR_IO_PENDING),
1364   };
1365   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
1366   socket_factory_.AddSocketDataProvider(&data);
1367   socket_factory_.AddSSLSocketDataProvider(ssl);
1368
1369   CreatePool(true /* tcp pool */, false, false);
1370   base::WeakPtr<SpdySession> spdy_session =
1371       CreateSecureSpdySession(session_, test_hosts[0].key, BoundNetLog());
1372
1373   EXPECT_TRUE(
1374       HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key));
1375   EXPECT_FALSE(
1376       HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key));
1377
1378   session_->spdy_session_pool()->CloseAllSessions();
1379 }
1380
1381 // Verifies that an SSL connection with client authentication disables SPDY IP
1382 // pooling.
1383 TEST_P(SSLClientSocketPoolTest, IPPoolingClientCert) {
1384   SSLSocketDataProvider ssl(ASYNC, OK);
1385   ssl.cert = X509Certificate::CreateFromBytes(
1386       reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
1387   ssl.client_cert_sent = true;
1388   ssl.SetNextProto(GetParam());
1389   TestIPPoolingDisabled(&ssl);
1390 }
1391
1392 // Verifies that an SSL connection with channel ID disables SPDY IP pooling.
1393 TEST_P(SSLClientSocketPoolTest, IPPoolingChannelID) {
1394   SSLSocketDataProvider ssl(ASYNC, OK);
1395   ssl.channel_id_sent = true;
1396   ssl.SetNextProto(GetParam());
1397   TestIPPoolingDisabled(&ssl);
1398 }
1399
1400 // It would be nice to also test the timeouts in SSLClientSocketPool.
1401
1402 }  // namespace
1403
1404 }  // namespace net