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