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(kProtoDeprecatedSPDY2,
 243                     kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
 244
 245 // Tests that the final socket will connect even if all sockets
 246 // prior to it fail.
 247 //
 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;
 283
 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);
 291
 292   enable_ssl_connect_job_waiting_ = true;
 293   CreatePool(true, false, false);
 294
 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;
 311
 312   handle1.Init(
 313       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 314   handle2.Init(
 315       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 316   handle3.Init(
 317       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 318   handle4.Init(
 319       "b", params4, MEDIUM, callback4.callback(), pool_.get(), BoundNetLog());
 320
 321   base::RunLoop().RunUntilIdle();
 322
 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());
 328 }
 329
 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);
 339
 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);
 352
 353   CreatePool(true, false, false);
 354
 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;
 367
 368   handle1.Init(
 369       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 370   handle2.Init(
 371       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 372   handle3.Init(
 373       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 374
 375   base::RunLoop().RunUntilIdle();
 376
 377   std::vector<MockSSLClientSocket*> sockets =
 378       socket_factory_.ssl_client_sockets();
 379
 380   // All sockets should have started their connections.
 381   for (std::vector<MockSSLClientSocket*>::iterator it = sockets.begin();
 382        it != sockets.end();
 383        ++it) {
 384     EXPECT_TRUE((*it)->reached_connect());
 385   }
 386
 387   // Resume connecting all of the sockets.
 388   for (std::vector<MockSSLClientSocket*>::iterator it = sockets.begin();
 389        it != sockets.end();
 390        ++it) {
 391     (*it)->RestartPausedConnect();
 392   }
 393
 394   callback1.WaitForResult();
 395   callback2.WaitForResult();
 396   callback3.WaitForResult();
 397
 398   EXPECT_TRUE(handle1.socket()->IsConnected());
 399   EXPECT_TRUE(handle2.socket()->IsConnected());
 400   EXPECT_TRUE(handle3.socket()->IsConnected());
 401 }
 402
 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);
 412
 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);
 423
 424   enable_ssl_connect_job_waiting_ = true;
 425   CreatePool(true, false, false);
 426
 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;
 439
 440   handle1.Init(
 441       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 442   handle2.Init(
 443       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 444   handle3.Init(
 445       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 446
 447   // Allow the connections to proceed until the first socket has started
 448   // connecting.
 449   base::RunLoop().RunUntilIdle();
 450
 451   std::vector<MockSSLClientSocket*> sockets =
 452       socket_factory_.ssl_client_sockets();
 453
 454   pool_->CancelRequest("b", &handle2);
 455
 456   sockets[0]->RestartPausedConnect();
 457
 458   callback1.WaitForResult();
 459   callback3.WaitForResult();
 460
 461   EXPECT_TRUE(handle1.socket()->IsConnected());
 462   EXPECT_FALSE(handle2.socket());
 463   EXPECT_TRUE(handle3.socket()->IsConnected());
 464 }
 465
 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);
 477
 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);
 491
 492   enable_ssl_connect_job_waiting_ = true;
 493   CreatePool(true, false, false);
 494
 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;
 507
 508   handle1.Init(
 509       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 510   handle2.Init(
 511       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 512   handle3.Init(
 513       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 514
 515   // Allow the connections to proceed until the first socket has started
 516   // connecting.
 517   base::RunLoop().RunUntilIdle();
 518
 519   std::vector<MockSSLClientSocket*> sockets =
 520       socket_factory_.ssl_client_sockets();
 521
 522   EXPECT_EQ(3u, sockets.size());
 523   EXPECT_TRUE(sockets[0]->reached_connect());
 524   EXPECT_FALSE(handle1.socket());
 525
 526   pool_->CancelRequest("b", &handle2);
 527
 528   sockets[0]->RestartPausedConnect();
 529
 530   callback1.WaitForResult();
 531   callback3.WaitForResult();
 532
 533   EXPECT_FALSE(handle1.socket());
 534   EXPECT_FALSE(handle2.socket());
 535   EXPECT_TRUE(handle3.socket()->IsConnected());
 536 }
 537
 538 // Make sure that sockets still connect after the leader socket's
 539 // connection fails.
 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;
 563
 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);
 569
 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;
 588   handle1.Init(
 589       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 590   handle2.Init(
 591       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 592   handle3.Init(
 593       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 594   handle4.Init(
 595       "b", params4, MEDIUM, callback4.callback(), pool_.get(), BoundNetLog());
 596
 597   base::RunLoop().RunUntilIdle();
 598
 599   std::vector<MockSSLClientSocket*> sockets =
 600       socket_factory_.ssl_client_sockets();
 601
 602   std::vector<MockSSLClientSocket*>::const_iterator it = sockets.begin();
 603
 604   // The first socket should have had Connect called on it.
 605   EXPECT_TRUE((*it)->reached_connect());
 606   ++it;
 607
 608   // No other socket should have reached connect yet.
 609   for (; it != sockets.end(); ++it)
 610     EXPECT_FALSE((*it)->reached_connect());
 611
 612   // Allow the first socket to resume it's connection process.
 613   sockets[0]->RestartPausedConnect();
 614
 615   base::RunLoop().RunUntilIdle();
 616
 617   // The second socket should have reached connect.
 618   EXPECT_TRUE(sockets[1]->reached_connect());
 619
 620   // Allow the second socket to continue its connection.
 621   sockets[1]->RestartPausedConnect();
 622
 623   base::RunLoop().RunUntilIdle();
 624
 625   EXPECT_FALSE(handle1.socket());
 626   EXPECT_TRUE(handle2.socket()->IsConnected());
 627   EXPECT_TRUE(handle3.socket()->IsConnected());
 628   EXPECT_TRUE(handle4.socket()->IsConnected());
 629 }
 630
 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);
 640
 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);
 651
 652   enable_ssl_connect_job_waiting_ = true;
 653   CreatePool(true, false, false);
 654
 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;
 667
 668   handle1.Init(
 669       "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
 670   handle2.Init(
 671       "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
 672   handle3.Init(
 673       "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
 674
 675   // Allow the connections to proceed until the first socket has finished
 676   // connecting.
 677   base::RunLoop().RunUntilIdle();
 678
 679   std::vector<MockSSLClientSocket*> sockets =
 680       socket_factory_.ssl_client_sockets();
 681
 682   std::vector<MockSSLClientSocket*>::const_iterator it = sockets.begin();
 683   // The first socket should have reached connect.
 684   EXPECT_TRUE((*it)->reached_connect());
 685   ++it;
 686   // No other socket should have reached connect yet.
 687   for (; it != sockets.end(); ++it)
 688     EXPECT_FALSE((*it)->reached_connect());
 689
 690   sockets[0]->RestartPausedConnect();
 691
 692   callback1.WaitForResult();
 693   callback2.WaitForResult();
 694   callback3.WaitForResult();
 695
 696   EXPECT_TRUE(handle1.socket()->IsConnected());
 697   EXPECT_TRUE(handle2.socket()->IsConnected());
 698   EXPECT_TRUE(handle3.socket()->IsConnected());
 699 }
 700
 701 TEST_P(SSLClientSocketPoolTest, TCPFail) {
 702   StaticSocketDataProvider data;
 703   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
 704   socket_factory_.AddSocketDataProvider(&data);
 705
 706   CreatePool(true /* tcp pool */, false, false);
 707   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 708                                                     false);
 709
 710   ClientSocketHandle handle;
 711   int rv = handle.Init("a", params, MEDIUM, CompletionCallback(), pool_.get(),
 712                        BoundNetLog());
 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());
 717 }
 718
 719 TEST_P(SSLClientSocketPoolTest, TCPFailAsync) {
 720   StaticSocketDataProvider data;
 721   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
 722   socket_factory_.AddSocketDataProvider(&data);
 723
 724   CreatePool(true /* tcp pool */, false, false);
 725   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 726                                                     false);
 727
 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());
 735
 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());
 740 }
 741
 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);
 748
 749   CreatePool(true /* tcp pool */, false, false);
 750   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 751                                                     false);
 752
 753   ClientSocketHandle handle;
 754   TestCompletionCallback callback;
 755   int rv = handle.Init(
 756       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 757   EXPECT_EQ(OK, rv);
 758   EXPECT_TRUE(handle.is_initialized());
 759   EXPECT_TRUE(handle.socket());
 760   TestLoadTimingInfo(handle);
 761 }
 762
 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);
 769
 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);
 777
 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();
 784   }
 785 }
 786
 787 TEST_P(SSLClientSocketPoolTest, BasicDirectAsync) {
 788   StaticSocketDataProvider data;
 789   socket_factory_.AddSocketDataProvider(&data);
 790   SSLSocketDataProvider ssl(ASYNC, OK);
 791   socket_factory_.AddSSLSocketDataProvider(&ssl);
 792
 793   CreatePool(true /* tcp pool */, false, false);
 794   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 795                                                     false);
 796
 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());
 804
 805   EXPECT_EQ(OK, callback.WaitForResult());
 806   EXPECT_TRUE(handle.is_initialized());
 807   EXPECT_TRUE(handle.socket());
 808   TestLoadTimingInfo(handle);
 809 }
 810
 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);
 816
 817   CreatePool(true /* tcp pool */, false, false);
 818   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 819                                                     false);
 820
 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());
 828
 829   EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult());
 830   EXPECT_TRUE(handle.is_initialized());
 831   EXPECT_TRUE(handle.socket());
 832   TestLoadTimingInfo(handle);
 833 }
 834
 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);
 840
 841   CreatePool(true /* tcp pool */, false, false);
 842   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 843                                                     false);
 844
 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());
 852
 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());
 857 }
 858
 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);
 865
 866   CreatePool(true /* tcp pool */, false, false);
 867   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 868                                                     false);
 869
 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());
 877
 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());
 884 }
 885
 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);
 892
 893   CreatePool(true /* tcp pool */, false, false);
 894   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 895                                                     true);
 896
 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());
 904
 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());
 909 }
 910
 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);
 917
 918   CreatePool(true /* tcp pool */, false, false);
 919   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 920                                                     true);
 921
 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());
 929
 930   EXPECT_EQ(OK, callback.WaitForResult());
 931   EXPECT_TRUE(handle.is_initialized());
 932   EXPECT_TRUE(handle.socket());
 933   TestLoadTimingInfo(handle);
 934
 935   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
 936   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
 937   std::string proto;
 938   ssl_socket->GetNextProto(&proto);
 939   EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto));
 940 }
 941
 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);
 948
 949   CreatePool(true /* tcp pool */, false, false);
 950   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 951                                                     true);
 952
 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());
 960
 961   EXPECT_EQ(OK, callback.WaitForResult());
 962   EXPECT_TRUE(handle.is_initialized());
 963   EXPECT_TRUE(handle.socket());
 964   TestLoadTimingInfo(handle);
 965
 966   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
 967   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
 968   std::string proto;
 969   ssl_socket->GetNextProto(&proto);
 970   EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto));
 971 }
 972
 973 TEST_P(SSLClientSocketPoolTest, SOCKSFail) {
 974   StaticSocketDataProvider data;
 975   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
 976   socket_factory_.AddSocketDataProvider(&data);
 977
 978   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 979   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
 980                                                     false);
 981
 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());
 990 }
 991
 992 TEST_P(SSLClientSocketPoolTest, SOCKSFailAsync) {
 993   StaticSocketDataProvider data;
 994   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
 995   socket_factory_.AddSocketDataProvider(&data);
 996
 997   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 998   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
 999                                                     false);
1000
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());
1008
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());
1013 }
1014
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);
1021
1022   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1023   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
1024                                                     false);
1025
1026   ClientSocketHandle handle;
1027   TestCompletionCallback callback;
1028   int rv = handle.Init(
1029       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1030   EXPECT_EQ(OK, rv);
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);
1036 }
1037
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);
1046
1047   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1048   scoped_refptr<SSLSocketParams> params =
1049       SSLParams(ProxyServer::SCHEME_SOCKS5, false);
1050
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());
1056 }
1057
1058 TEST_P(SSLClientSocketPoolTest, SOCKSBasicAsync) {
1059   StaticSocketDataProvider data;
1060   socket_factory_.AddSocketDataProvider(&data);
1061   SSLSocketDataProvider ssl(ASYNC, OK);
1062   socket_factory_.AddSSLSocketDataProvider(&ssl);
1063
1064   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1065   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
1066                                                     false);
1067
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());
1075
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);
1082 }
1083
1084 TEST_P(SSLClientSocketPoolTest, HttpProxyFail) {
1085   StaticSocketDataProvider data;
1086   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
1087   socket_factory_.AddSocketDataProvider(&data);
1088
1089   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1090   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1091                                                     false);
1092
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());
1101 }
1102
1103 TEST_P(SSLClientSocketPoolTest, HttpProxyFailAsync) {
1104   StaticSocketDataProvider data;
1105   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
1106   socket_factory_.AddSocketDataProvider(&data);
1107
1108   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1109   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1110                                                     false);
1111
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());
1119
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());
1124 }
1125
1126 TEST_P(SSLClientSocketPoolTest, HttpProxyBasic) {
1127   MockWrite writes[] = {
1128       MockWrite(SYNCHRONOUS,
1129                 "CONNECT host:80 HTTP/1.1\r\n"
1130                 "Host: host\r\n"
1131                 "Proxy-Connection: keep-alive\r\n"
1132                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1133   };
1134   MockRead reads[] = {
1135       MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"),
1136   };
1137   StaticSocketDataProvider data(reads, arraysize(reads), writes,
1138                                 arraysize(writes));
1139   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
1140   socket_factory_.AddSocketDataProvider(&data);
1141   AddAuthToCache();
1142   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
1143   socket_factory_.AddSSLSocketDataProvider(&ssl);
1144
1145   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1146   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1147                                                     false);
1148
1149   ClientSocketHandle handle;
1150   TestCompletionCallback callback;
1151   int rv = handle.Init(
1152       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
1153   EXPECT_EQ(OK, rv);
1154   EXPECT_TRUE(handle.is_initialized());
1155   EXPECT_TRUE(handle.socket());
1156   TestLoadTimingInfoNoDns(handle);
1157 }
1158
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"
1165                 "Host: host\r\n"
1166                 "Proxy-Connection: keep-alive\r\n"
1167                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1168   };
1169   MockRead reads[] = {
1170       MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"),
1171   };
1172   StaticSocketDataProvider data(reads, arraysize(reads), writes,
1173                                 arraysize(writes));
1174   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
1175   socket_factory_.AddSocketDataProvider(&data);
1176   AddAuthToCache();
1177   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
1178   socket_factory_.AddSSLSocketDataProvider(&ssl);
1179
1180   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1181   scoped_refptr<SSLSocketParams> params =
1182       SSLParams(ProxyServer::SCHEME_HTTP, false);
1183
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());
1189 }
1190
1191 TEST_P(SSLClientSocketPoolTest, HttpProxyBasicAsync) {
1192   MockWrite writes[] = {
1193       MockWrite("CONNECT host:80 HTTP/1.1\r\n"
1194                 "Host: host\r\n"
1195                 "Proxy-Connection: keep-alive\r\n"
1196                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
1197   };
1198   MockRead reads[] = {
1199       MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
1200   };
1201   StaticSocketDataProvider data(reads, arraysize(reads), writes,
1202                                 arraysize(writes));
1203   socket_factory_.AddSocketDataProvider(&data);
1204   AddAuthToCache();
1205   SSLSocketDataProvider ssl(ASYNC, OK);
1206   socket_factory_.AddSSLSocketDataProvider(&ssl);
1207
1208   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1209   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1210                                                     false);
1211
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());
1219
1220   EXPECT_EQ(OK, callback.WaitForResult());
1221   EXPECT_TRUE(handle.is_initialized());
1222   EXPECT_TRUE(handle.socket());
1223   TestLoadTimingInfoNoDns(handle);
1224 }
1225
1226 TEST_P(SSLClientSocketPoolTest, NeedProxyAuth) {
1227   MockWrite writes[] = {
1228       MockWrite("CONNECT host:80 HTTP/1.1\r\n"
1229                 "Host: host\r\n"
1230                 "Proxy-Connection: keep-alive\r\n\r\n"),
1231   };
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"),
1237   };
1238   StaticSocketDataProvider data(reads, arraysize(reads), writes,
1239                                 arraysize(writes));
1240   socket_factory_.AddSocketDataProvider(&data);
1241   SSLSocketDataProvider ssl(ASYNC, OK);
1242   socket_factory_.AddSSLSocketDataProvider(&ssl);
1243
1244   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
1245   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
1246                                                     false);
1247
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());
1255
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());
1266 }
1267
1268 TEST_P(SSLClientSocketPoolTest, IPPooling) {
1269   const int kTestPort = 80;
1270   struct TestHosts {
1271     std::string name;
1272     std::string iplist;
1273     SpdySessionKey key;
1274     AddressList addresses;
1275   } test_hosts[] = {
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" },
1279   };
1280
1281   host_resolver_.set_synchronous_mode(true);
1282   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) {
1283     host_resolver_.rules()->AddIPLiteralRule(
1284         test_hosts[i].name, test_hosts[i].iplist, std::string());
1285
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,
1290                            DEFAULT_PRIORITY,
1291                            &test_hosts[i].addresses,
1292                            CompletionCallback(),
1293                            NULL,
1294                            BoundNetLog());
1295
1296     // Setup a SpdySessionKey
1297     test_hosts[i].key = SpdySessionKey(
1298         HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(),
1299         PRIVACY_MODE_DISABLED);
1300   }
1301
1302   MockRead reads[] = {
1303       MockRead(ASYNC, ERR_IO_PENDING),
1304   };
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);
1312
1313   CreatePool(true /* tcp pool */, false, false);
1314   base::WeakPtr<SpdySession> spdy_session =
1315       CreateSecureSpdySession(session_, test_hosts[0].key, BoundNetLog());
1316
1317   EXPECT_TRUE(
1318       HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key));
1319   EXPECT_FALSE(
1320       HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key));
1321   EXPECT_TRUE(
1322       HasSpdySession(session_->spdy_session_pool(), test_hosts[2].key));
1323
1324   session_->spdy_session_pool()->CloseAllSessions();
1325 }
1326
1327 void SSLClientSocketPoolTest::TestIPPoolingDisabled(
1328     SSLSocketDataProvider* ssl) {
1329   const int kTestPort = 80;
1330   struct TestHosts {
1331     std::string name;
1332     std::string iplist;
1333     SpdySessionKey key;
1334     AddressList addresses;
1335   } test_hosts[] = {
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" },
1338   };
1339
1340   TestCompletionCallback callback;
1341   int rv;
1342   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) {
1343     host_resolver_.rules()->AddIPLiteralRule(
1344         test_hosts[i].name, test_hosts[i].iplist, std::string());
1345
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,
1350                                 DEFAULT_PRIORITY,
1351                                 &test_hosts[i].addresses,
1352                                 callback.callback(),
1353                                 NULL,
1354                                 BoundNetLog());
1355     EXPECT_EQ(OK, callback.GetResult(rv));
1356
1357     // Setup a SpdySessionKey
1358     test_hosts[i].key = SpdySessionKey(
1359         HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(),
1360         PRIVACY_MODE_DISABLED);
1361   }
1362
1363   MockRead reads[] = {
1364       MockRead(ASYNC, ERR_IO_PENDING),
1365   };
1366   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
1367   socket_factory_.AddSocketDataProvider(&data);
1368   socket_factory_.AddSSLSocketDataProvider(ssl);
1369
1370   CreatePool(true /* tcp pool */, false, false);
1371   base::WeakPtr<SpdySession> spdy_session =
1372       CreateSecureSpdySession(session_, test_hosts[0].key, BoundNetLog());
1373
1374   EXPECT_TRUE(
1375       HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key));
1376   EXPECT_FALSE(
1377       HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key));
1378
1379   session_->spdy_session_pool()->CloseAllSessions();
1380 }
1381
1382 // Verifies that an SSL connection with client authentication disables SPDY IP
1383 // pooling.
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);
1391 }
1392
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);
1399 }
1400
1401 // It would be nice to also test the timeouts in SSLClientSocketPool.
1402
1403 }  // namespace
1404
1405 }  // namespace net