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/strings/string_util.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/time/time.h"
  12 #include "net/base/auth.h"
  13 #include "net/base/load_timing_info.h"
  14 #include "net/base/load_timing_info_test_util.h"
  15 #include "net/base/net_errors.h"
  16 #include "net/base/test_completion_callback.h"
  17 #include "net/cert/cert_verifier.h"
  18 #include "net/dns/mock_host_resolver.h"
  19 #include "net/http/http_auth_handler_factory.h"
  20 #include "net/http/http_network_session.h"
  21 #include "net/http/http_request_headers.h"
  22 #include "net/http/http_response_headers.h"
  23 #include "net/http/http_server_properties_impl.h"
  24 #include "net/http/transport_security_state.h"
  25 #include "net/proxy/proxy_service.h"
  26 #include "net/socket/client_socket_handle.h"
  27 #include "net/socket/next_proto.h"
  28 #include "net/socket/socket_test_util.h"
  29 #include "net/spdy/spdy_session.h"
  30 #include "net/spdy/spdy_session_pool.h"
  31 #include "net/spdy/spdy_test_util_common.h"
  32 #include "net/ssl/ssl_config_service_defaults.h"
  33 #include "net/test/test_certificate_data.h"
  34 #include "testing/gtest/include/gtest/gtest.h"
  35
  36 namespace net {
  37
  38 namespace {
  39
  40 const int kMaxSockets = 32;
  41 const int kMaxSocketsPerGroup = 6;
  42
  43 // Make sure |handle|'s load times are set correctly.  DNS and connect start
  44 // times comes from mock client sockets in these tests, so primarily serves to
  45 // check those times were copied, and ssl times / connect end are set correctly.
  46 void TestLoadTimingInfo(const ClientSocketHandle& handle) {
  47   LoadTimingInfo load_timing_info;
  48   EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info));
  49
  50   EXPECT_FALSE(load_timing_info.socket_reused);
  51   // None of these tests use a NetLog.
  52   EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
  53
  54   ExpectConnectTimingHasTimes(
  55       load_timing_info.connect_timing,
  56       CONNECT_TIMING_HAS_SSL_TIMES | CONNECT_TIMING_HAS_DNS_TIMES);
  57   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
  58 }
  59
  60 // Just like TestLoadTimingInfo, except DNS times are expected to be null, for
  61 // tests over proxies that do DNS lookups themselves.
  62 void TestLoadTimingInfoNoDns(const ClientSocketHandle& handle) {
  63   LoadTimingInfo load_timing_info;
  64   EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info));
  65
  66   // None of these tests use a NetLog.
  67   EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
  68
  69   EXPECT_FALSE(load_timing_info.socket_reused);
  70
  71   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
  72                               CONNECT_TIMING_HAS_SSL_TIMES);
  73   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
  74 }
  75
  76 class SSLClientSocketPoolTest
  77     : public testing::Test,
  78       public ::testing::WithParamInterface<NextProto> {
  79  protected:
  80   SSLClientSocketPoolTest()
  81       : transport_security_state_(new TransportSecurityState),
  82         proxy_service_(ProxyService::CreateDirect()),
  83         ssl_config_service_(new SSLConfigServiceDefaults),
  84         http_auth_handler_factory_(
  85             HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
  86         session_(CreateNetworkSession()),
  87         direct_transport_socket_params_(new TransportSocketParams(
  88             HostPortPair("host", 443),
  89             false,
  90             false,
  91             OnHostResolutionCallback(),
  92             TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)),
  93         transport_socket_pool_(kMaxSockets,
  94                                kMaxSocketsPerGroup,
  95                                &socket_factory_),
  96         proxy_transport_socket_params_(new TransportSocketParams(
  97             HostPortPair("proxy", 443),
  98             false,
  99             false,
 100             OnHostResolutionCallback(),
 101             TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)),
 102         socks_socket_params_(
 103             new SOCKSSocketParams(proxy_transport_socket_params_,
 104                                   true,
 105                                   HostPortPair("sockshost", 443))),
 106         socks_socket_pool_(kMaxSockets,
 107                            kMaxSocketsPerGroup,
 108                            &transport_socket_pool_),
 109         http_proxy_socket_params_(
 110             new HttpProxySocketParams(proxy_transport_socket_params_,
 111                                       NULL,
 112                                       GURL("http://host"),
 113                                       std::string(),
 114                                       HostPortPair("host", 80),
 115                                       session_->http_auth_cache(),
 116                                       session_->http_auth_handler_factory(),
 117                                       session_->spdy_session_pool(),
 118                                       true,
 119                                       NULL)),
 120         http_proxy_socket_pool_(kMaxSockets,
 121                                 kMaxSocketsPerGroup,
 122                                 &transport_socket_pool_,
 123                                 NULL,
 124                                 NULL) {
 125     scoped_refptr<SSLConfigService> ssl_config_service(
 126         new SSLConfigServiceDefaults);
 127     ssl_config_service->GetSSLConfig(&ssl_config_);
 128   }
 129
 130   void CreatePool(bool transport_pool, bool http_proxy_pool, bool socks_pool) {
 131     pool_.reset(new SSLClientSocketPool(
 132         kMaxSockets, kMaxSocketsPerGroup, NULL /* cert_verifier */,
 133         NULL /* channel_id_service */, NULL /* transport_security_state */,
 134         NULL /* cert_transparency_verifier */, NULL /* cert_policy_enforcer */,
 135         std::string() /* ssl_session_cache_shard */, &socket_factory_,
 136         transport_pool ? &transport_socket_pool_ : NULL,
 137         socks_pool ? &socks_socket_pool_ : NULL,
 138         http_proxy_pool ? &http_proxy_socket_pool_ : NULL, NULL, NULL));
 139   }
 140
 141   scoped_refptr<SSLSocketParams> SSLParams(ProxyServer::Scheme proxy,
 142                                            bool want_spdy_over_npn) {
 143     return make_scoped_refptr(new SSLSocketParams(
 144         proxy == ProxyServer::SCHEME_DIRECT ? direct_transport_socket_params_
 145                                             : NULL,
 146         proxy == ProxyServer::SCHEME_SOCKS5 ? socks_socket_params_ : NULL,
 147         proxy == ProxyServer::SCHEME_HTTP ? http_proxy_socket_params_ : NULL,
 148         HostPortPair("host", 443),
 149         ssl_config_,
 150         PRIVACY_MODE_DISABLED,
 151         0,
 152         false,
 153         want_spdy_over_npn));
 154   }
 155
 156   void AddAuthToCache() {
 157     const base::string16 kFoo(base::ASCIIToUTF16("foo"));
 158     const base::string16 kBar(base::ASCIIToUTF16("bar"));
 159     session_->http_auth_cache()->Add(GURL("http://proxy:443/"),
 160                                      "MyRealm1",
 161                                      HttpAuth::AUTH_SCHEME_BASIC,
 162                                      "Basic realm=MyRealm1",
 163                                      AuthCredentials(kFoo, kBar),
 164                                      "/");
 165   }
 166
 167   HttpNetworkSession* CreateNetworkSession() {
 168     HttpNetworkSession::Params params;
 169     params.host_resolver = &host_resolver_;
 170     params.cert_verifier = cert_verifier_.get();
 171     params.transport_security_state = transport_security_state_.get();
 172     params.proxy_service = proxy_service_.get();
 173     params.client_socket_factory = &socket_factory_;
 174     params.ssl_config_service = ssl_config_service_.get();
 175     params.http_auth_handler_factory = http_auth_handler_factory_.get();
 176     params.http_server_properties =
 177         http_server_properties_.GetWeakPtr();
 178     params.enable_spdy_compression = false;
 179     params.spdy_default_protocol = GetParam();
 180     return new HttpNetworkSession(params);
 181   }
 182
 183   void TestIPPoolingDisabled(SSLSocketDataProvider* ssl);
 184
 185   MockClientSocketFactory socket_factory_;
 186   MockCachingHostResolver host_resolver_;
 187   scoped_ptr<CertVerifier> cert_verifier_;
 188   scoped_ptr<TransportSecurityState> transport_security_state_;
 189   const scoped_ptr<ProxyService> proxy_service_;
 190   const scoped_refptr<SSLConfigService> ssl_config_service_;
 191   const scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_;
 192   HttpServerPropertiesImpl http_server_properties_;
 193   const scoped_refptr<HttpNetworkSession> session_;
 194
 195   scoped_refptr<TransportSocketParams> direct_transport_socket_params_;
 196   MockTransportClientSocketPool transport_socket_pool_;
 197
 198   scoped_refptr<TransportSocketParams> proxy_transport_socket_params_;
 199
 200   scoped_refptr<SOCKSSocketParams> socks_socket_params_;
 201   MockSOCKSClientSocketPool socks_socket_pool_;
 202
 203   scoped_refptr<HttpProxySocketParams> http_proxy_socket_params_;
 204   HttpProxyClientSocketPool http_proxy_socket_pool_;
 205
 206   SSLConfig ssl_config_;
 207   scoped_ptr<SSLClientSocketPool> pool_;
 208 };
 209
 210 INSTANTIATE_TEST_CASE_P(NextProto,
 211                         SSLClientSocketPoolTest,
 212                         testing::Values(kProtoSPDY31,
 213                                         kProtoSPDY4_14,
 214                                         kProtoSPDY4));
 215
 216 TEST_P(SSLClientSocketPoolTest, TCPFail) {
 217   StaticSocketDataProvider data;
 218   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
 219   socket_factory_.AddSocketDataProvider(&data);
 220
 221   CreatePool(true /* tcp pool */, false, false);
 222   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 223                                                     false);
 224
 225   ClientSocketHandle handle;
 226   int rv = handle.Init("a", params, MEDIUM, CompletionCallback(), pool_.get(),
 227                        BoundNetLog());
 228   EXPECT_EQ(ERR_CONNECTION_FAILED, rv);
 229   EXPECT_FALSE(handle.is_initialized());
 230   EXPECT_FALSE(handle.socket());
 231   EXPECT_FALSE(handle.is_ssl_error());
 232 }
 233
 234 TEST_P(SSLClientSocketPoolTest, TCPFailAsync) {
 235   StaticSocketDataProvider data;
 236   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
 237   socket_factory_.AddSocketDataProvider(&data);
 238
 239   CreatePool(true /* tcp pool */, false, false);
 240   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 241                                                     false);
 242
 243   ClientSocketHandle handle;
 244   TestCompletionCallback callback;
 245   int rv = handle.Init(
 246       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 247   EXPECT_EQ(ERR_IO_PENDING, rv);
 248   EXPECT_FALSE(handle.is_initialized());
 249   EXPECT_FALSE(handle.socket());
 250
 251   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
 252   EXPECT_FALSE(handle.is_initialized());
 253   EXPECT_FALSE(handle.socket());
 254   EXPECT_FALSE(handle.is_ssl_error());
 255 }
 256
 257 TEST_P(SSLClientSocketPoolTest, BasicDirect) {
 258   StaticSocketDataProvider data;
 259   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
 260   socket_factory_.AddSocketDataProvider(&data);
 261   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
 262   socket_factory_.AddSSLSocketDataProvider(&ssl);
 263
 264   CreatePool(true /* tcp pool */, false, false);
 265   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 266                                                     false);
 267
 268   ClientSocketHandle handle;
 269   TestCompletionCallback callback;
 270   int rv = handle.Init(
 271       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 272   EXPECT_EQ(OK, rv);
 273   EXPECT_TRUE(handle.is_initialized());
 274   EXPECT_TRUE(handle.socket());
 275   TestLoadTimingInfo(handle);
 276 }
 277
 278 // Make sure that SSLConnectJob passes on its priority to its
 279 // socket request on Init (for the DIRECT case).
 280 TEST_P(SSLClientSocketPoolTest, SetSocketRequestPriorityOnInitDirect) {
 281   CreatePool(true /* tcp pool */, false, false);
 282   scoped_refptr<SSLSocketParams> params =
 283       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 284
 285   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
 286     RequestPriority priority = static_cast<RequestPriority>(i);
 287     StaticSocketDataProvider data;
 288     data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
 289     socket_factory_.AddSocketDataProvider(&data);
 290     SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
 291     socket_factory_.AddSSLSocketDataProvider(&ssl);
 292
 293     ClientSocketHandle handle;
 294     TestCompletionCallback callback;
 295     EXPECT_EQ(OK, handle.Init("a", params, priority, callback.callback(),
 296                               pool_.get(), BoundNetLog()));
 297     EXPECT_EQ(priority, transport_socket_pool_.last_request_priority());
 298     handle.socket()->Disconnect();
 299   }
 300 }
 301
 302 TEST_P(SSLClientSocketPoolTest, BasicDirectAsync) {
 303   StaticSocketDataProvider data;
 304   socket_factory_.AddSocketDataProvider(&data);
 305   SSLSocketDataProvider ssl(ASYNC, OK);
 306   socket_factory_.AddSSLSocketDataProvider(&ssl);
 307
 308   CreatePool(true /* tcp pool */, false, false);
 309   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 310                                                     false);
 311
 312   ClientSocketHandle handle;
 313   TestCompletionCallback callback;
 314   int rv = handle.Init(
 315       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 316   EXPECT_EQ(ERR_IO_PENDING, rv);
 317   EXPECT_FALSE(handle.is_initialized());
 318   EXPECT_FALSE(handle.socket());
 319
 320   EXPECT_EQ(OK, callback.WaitForResult());
 321   EXPECT_TRUE(handle.is_initialized());
 322   EXPECT_TRUE(handle.socket());
 323   TestLoadTimingInfo(handle);
 324 }
 325
 326 TEST_P(SSLClientSocketPoolTest, DirectCertError) {
 327   StaticSocketDataProvider data;
 328   socket_factory_.AddSocketDataProvider(&data);
 329   SSLSocketDataProvider ssl(ASYNC, ERR_CERT_COMMON_NAME_INVALID);
 330   socket_factory_.AddSSLSocketDataProvider(&ssl);
 331
 332   CreatePool(true /* tcp pool */, false, false);
 333   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 334                                                     false);
 335
 336   ClientSocketHandle handle;
 337   TestCompletionCallback callback;
 338   int rv = handle.Init(
 339       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 340   EXPECT_EQ(ERR_IO_PENDING, rv);
 341   EXPECT_FALSE(handle.is_initialized());
 342   EXPECT_FALSE(handle.socket());
 343
 344   EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult());
 345   EXPECT_TRUE(handle.is_initialized());
 346   EXPECT_TRUE(handle.socket());
 347   TestLoadTimingInfo(handle);
 348 }
 349
 350 TEST_P(SSLClientSocketPoolTest, DirectSSLError) {
 351   StaticSocketDataProvider data;
 352   socket_factory_.AddSocketDataProvider(&data);
 353   SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR);
 354   socket_factory_.AddSSLSocketDataProvider(&ssl);
 355
 356   CreatePool(true /* tcp pool */, false, false);
 357   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 358                                                     false);
 359
 360   ClientSocketHandle handle;
 361   TestCompletionCallback callback;
 362   int rv = handle.Init(
 363       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 364   EXPECT_EQ(ERR_IO_PENDING, rv);
 365   EXPECT_FALSE(handle.is_initialized());
 366   EXPECT_FALSE(handle.socket());
 367
 368   EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.WaitForResult());
 369   EXPECT_FALSE(handle.is_initialized());
 370   EXPECT_FALSE(handle.socket());
 371   EXPECT_TRUE(handle.is_ssl_error());
 372 }
 373
 374 TEST_P(SSLClientSocketPoolTest, DirectWithNPN) {
 375   StaticSocketDataProvider data;
 376   socket_factory_.AddSocketDataProvider(&data);
 377   SSLSocketDataProvider ssl(ASYNC, OK);
 378   ssl.SetNextProto(kProtoHTTP11);
 379   socket_factory_.AddSSLSocketDataProvider(&ssl);
 380
 381   CreatePool(true /* tcp pool */, false, false);
 382   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 383                                                     false);
 384
 385   ClientSocketHandle handle;
 386   TestCompletionCallback callback;
 387   int rv = handle.Init(
 388       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 389   EXPECT_EQ(ERR_IO_PENDING, rv);
 390   EXPECT_FALSE(handle.is_initialized());
 391   EXPECT_FALSE(handle.socket());
 392
 393   EXPECT_EQ(OK, callback.WaitForResult());
 394   EXPECT_TRUE(handle.is_initialized());
 395   EXPECT_TRUE(handle.socket());
 396   TestLoadTimingInfo(handle);
 397   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
 398   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
 399 }
 400
 401 TEST_P(SSLClientSocketPoolTest, DirectNoSPDY) {
 402   StaticSocketDataProvider data;
 403   socket_factory_.AddSocketDataProvider(&data);
 404   SSLSocketDataProvider ssl(ASYNC, OK);
 405   ssl.SetNextProto(kProtoHTTP11);
 406   socket_factory_.AddSSLSocketDataProvider(&ssl);
 407
 408   CreatePool(true /* tcp pool */, false, false);
 409   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 410                                                     true);
 411
 412   ClientSocketHandle handle;
 413   TestCompletionCallback callback;
 414   int rv = handle.Init(
 415       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 416   EXPECT_EQ(ERR_IO_PENDING, rv);
 417   EXPECT_FALSE(handle.is_initialized());
 418   EXPECT_FALSE(handle.socket());
 419
 420   EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED, callback.WaitForResult());
 421   EXPECT_FALSE(handle.is_initialized());
 422   EXPECT_FALSE(handle.socket());
 423   EXPECT_TRUE(handle.is_ssl_error());
 424 }
 425
 426 TEST_P(SSLClientSocketPoolTest, DirectGotSPDY) {
 427   StaticSocketDataProvider data;
 428   socket_factory_.AddSocketDataProvider(&data);
 429   SSLSocketDataProvider ssl(ASYNC, OK);
 430   ssl.SetNextProto(GetParam());
 431   socket_factory_.AddSSLSocketDataProvider(&ssl);
 432
 433   CreatePool(true /* tcp pool */, false, false);
 434   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 435                                                     true);
 436
 437   ClientSocketHandle handle;
 438   TestCompletionCallback callback;
 439   int rv = handle.Init(
 440       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 441   EXPECT_EQ(ERR_IO_PENDING, rv);
 442   EXPECT_FALSE(handle.is_initialized());
 443   EXPECT_FALSE(handle.socket());
 444
 445   EXPECT_EQ(OK, callback.WaitForResult());
 446   EXPECT_TRUE(handle.is_initialized());
 447   EXPECT_TRUE(handle.socket());
 448   TestLoadTimingInfo(handle);
 449
 450   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
 451   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
 452   std::string proto;
 453   ssl_socket->GetNextProto(&proto);
 454   EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto));
 455 }
 456
 457 TEST_P(SSLClientSocketPoolTest, DirectGotBonusSPDY) {
 458   StaticSocketDataProvider data;
 459   socket_factory_.AddSocketDataProvider(&data);
 460   SSLSocketDataProvider ssl(ASYNC, OK);
 461   ssl.SetNextProto(GetParam());
 462   socket_factory_.AddSSLSocketDataProvider(&ssl);
 463
 464   CreatePool(true /* tcp pool */, false, false);
 465   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
 466                                                     true);
 467
 468   ClientSocketHandle handle;
 469   TestCompletionCallback callback;
 470   int rv = handle.Init(
 471       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 472   EXPECT_EQ(ERR_IO_PENDING, rv);
 473   EXPECT_FALSE(handle.is_initialized());
 474   EXPECT_FALSE(handle.socket());
 475
 476   EXPECT_EQ(OK, callback.WaitForResult());
 477   EXPECT_TRUE(handle.is_initialized());
 478   EXPECT_TRUE(handle.socket());
 479   TestLoadTimingInfo(handle);
 480
 481   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
 482   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
 483   std::string proto;
 484   ssl_socket->GetNextProto(&proto);
 485   EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto));
 486 }
 487
 488 TEST_P(SSLClientSocketPoolTest, SOCKSFail) {
 489   StaticSocketDataProvider data;
 490   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
 491   socket_factory_.AddSocketDataProvider(&data);
 492
 493   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 494   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
 495                                                     false);
 496
 497   ClientSocketHandle handle;
 498   TestCompletionCallback callback;
 499   int rv = handle.Init(
 500       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 501   EXPECT_EQ(ERR_CONNECTION_FAILED, rv);
 502   EXPECT_FALSE(handle.is_initialized());
 503   EXPECT_FALSE(handle.socket());
 504   EXPECT_FALSE(handle.is_ssl_error());
 505 }
 506
 507 TEST_P(SSLClientSocketPoolTest, SOCKSFailAsync) {
 508   StaticSocketDataProvider data;
 509   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
 510   socket_factory_.AddSocketDataProvider(&data);
 511
 512   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 513   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
 514                                                     false);
 515
 516   ClientSocketHandle handle;
 517   TestCompletionCallback callback;
 518   int rv = handle.Init(
 519       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 520   EXPECT_EQ(ERR_IO_PENDING, rv);
 521   EXPECT_FALSE(handle.is_initialized());
 522   EXPECT_FALSE(handle.socket());
 523
 524   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
 525   EXPECT_FALSE(handle.is_initialized());
 526   EXPECT_FALSE(handle.socket());
 527   EXPECT_FALSE(handle.is_ssl_error());
 528 }
 529
 530 TEST_P(SSLClientSocketPoolTest, SOCKSBasic) {
 531   StaticSocketDataProvider data;
 532   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
 533   socket_factory_.AddSocketDataProvider(&data);
 534   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
 535   socket_factory_.AddSSLSocketDataProvider(&ssl);
 536
 537   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 538   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
 539                                                     false);
 540
 541   ClientSocketHandle handle;
 542   TestCompletionCallback callback;
 543   int rv = handle.Init(
 544       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 545   EXPECT_EQ(OK, rv);
 546   EXPECT_TRUE(handle.is_initialized());
 547   EXPECT_TRUE(handle.socket());
 548   // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here
 549   // don't go through the real logic, unlike in the HTTP proxy tests.
 550   TestLoadTimingInfo(handle);
 551 }
 552
 553 // Make sure that SSLConnectJob passes on its priority to its
 554 // transport socket on Init (for the SOCKS_PROXY case).
 555 TEST_P(SSLClientSocketPoolTest, SetTransportPriorityOnInitSOCKS) {
 556   StaticSocketDataProvider data;
 557   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
 558   socket_factory_.AddSocketDataProvider(&data);
 559   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
 560   socket_factory_.AddSSLSocketDataProvider(&ssl);
 561
 562   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 563   scoped_refptr<SSLSocketParams> params =
 564       SSLParams(ProxyServer::SCHEME_SOCKS5, false);
 565
 566   ClientSocketHandle handle;
 567   TestCompletionCallback callback;
 568   EXPECT_EQ(OK, handle.Init("a", params, HIGHEST, callback.callback(),
 569                             pool_.get(), BoundNetLog()));
 570   EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority());
 571 }
 572
 573 TEST_P(SSLClientSocketPoolTest, SOCKSBasicAsync) {
 574   StaticSocketDataProvider data;
 575   socket_factory_.AddSocketDataProvider(&data);
 576   SSLSocketDataProvider ssl(ASYNC, OK);
 577   socket_factory_.AddSSLSocketDataProvider(&ssl);
 578
 579   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 580   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
 581                                                     false);
 582
 583   ClientSocketHandle handle;
 584   TestCompletionCallback callback;
 585   int rv = handle.Init(
 586       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 587   EXPECT_EQ(ERR_IO_PENDING, rv);
 588   EXPECT_FALSE(handle.is_initialized());
 589   EXPECT_FALSE(handle.socket());
 590
 591   EXPECT_EQ(OK, callback.WaitForResult());
 592   EXPECT_TRUE(handle.is_initialized());
 593   EXPECT_TRUE(handle.socket());
 594   // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here
 595   // don't go through the real logic, unlike in the HTTP proxy tests.
 596   TestLoadTimingInfo(handle);
 597 }
 598
 599 TEST_P(SSLClientSocketPoolTest, HttpProxyFail) {
 600   StaticSocketDataProvider data;
 601   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
 602   socket_factory_.AddSocketDataProvider(&data);
 603
 604   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 605   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
 606                                                     false);
 607
 608   ClientSocketHandle handle;
 609   TestCompletionCallback callback;
 610   int rv = handle.Init(
 611       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 612   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv);
 613   EXPECT_FALSE(handle.is_initialized());
 614   EXPECT_FALSE(handle.socket());
 615   EXPECT_FALSE(handle.is_ssl_error());
 616 }
 617
 618 TEST_P(SSLClientSocketPoolTest, HttpProxyFailAsync) {
 619   StaticSocketDataProvider data;
 620   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
 621   socket_factory_.AddSocketDataProvider(&data);
 622
 623   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 624   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
 625                                                     false);
 626
 627   ClientSocketHandle handle;
 628   TestCompletionCallback callback;
 629   int rv = handle.Init(
 630       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 631   EXPECT_EQ(ERR_IO_PENDING, rv);
 632   EXPECT_FALSE(handle.is_initialized());
 633   EXPECT_FALSE(handle.socket());
 634
 635   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback.WaitForResult());
 636   EXPECT_FALSE(handle.is_initialized());
 637   EXPECT_FALSE(handle.socket());
 638   EXPECT_FALSE(handle.is_ssl_error());
 639 }
 640
 641 TEST_P(SSLClientSocketPoolTest, HttpProxyBasic) {
 642   MockWrite writes[] = {
 643       MockWrite(SYNCHRONOUS,
 644                 "CONNECT host:80 HTTP/1.1\r\n"
 645                 "Host: host\r\n"
 646                 "Proxy-Connection: keep-alive\r\n"
 647                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
 648   };
 649   MockRead reads[] = {
 650       MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"),
 651   };
 652   StaticSocketDataProvider data(reads, arraysize(reads), writes,
 653                                 arraysize(writes));
 654   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
 655   socket_factory_.AddSocketDataProvider(&data);
 656   AddAuthToCache();
 657   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
 658   socket_factory_.AddSSLSocketDataProvider(&ssl);
 659
 660   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 661   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
 662                                                     false);
 663
 664   ClientSocketHandle handle;
 665   TestCompletionCallback callback;
 666   int rv = handle.Init(
 667       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 668   EXPECT_EQ(OK, rv);
 669   EXPECT_TRUE(handle.is_initialized());
 670   EXPECT_TRUE(handle.socket());
 671   TestLoadTimingInfoNoDns(handle);
 672 }
 673
 674 // Make sure that SSLConnectJob passes on its priority to its
 675 // transport socket on Init (for the HTTP_PROXY case).
 676 TEST_P(SSLClientSocketPoolTest, SetTransportPriorityOnInitHTTP) {
 677   MockWrite writes[] = {
 678       MockWrite(SYNCHRONOUS,
 679                 "CONNECT host:80 HTTP/1.1\r\n"
 680                 "Host: host\r\n"
 681                 "Proxy-Connection: keep-alive\r\n"
 682                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
 683   };
 684   MockRead reads[] = {
 685       MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"),
 686   };
 687   StaticSocketDataProvider data(reads, arraysize(reads), writes,
 688                                 arraysize(writes));
 689   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
 690   socket_factory_.AddSocketDataProvider(&data);
 691   AddAuthToCache();
 692   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
 693   socket_factory_.AddSSLSocketDataProvider(&ssl);
 694
 695   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 696   scoped_refptr<SSLSocketParams> params =
 697       SSLParams(ProxyServer::SCHEME_HTTP, false);
 698
 699   ClientSocketHandle handle;
 700   TestCompletionCallback callback;
 701   EXPECT_EQ(OK, handle.Init("a", params, HIGHEST, callback.callback(),
 702                             pool_.get(), BoundNetLog()));
 703   EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority());
 704 }
 705
 706 TEST_P(SSLClientSocketPoolTest, HttpProxyBasicAsync) {
 707   MockWrite writes[] = {
 708       MockWrite("CONNECT host:80 HTTP/1.1\r\n"
 709                 "Host: host\r\n"
 710                 "Proxy-Connection: keep-alive\r\n"
 711                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
 712   };
 713   MockRead reads[] = {
 714       MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
 715   };
 716   StaticSocketDataProvider data(reads, arraysize(reads), writes,
 717                                 arraysize(writes));
 718   socket_factory_.AddSocketDataProvider(&data);
 719   AddAuthToCache();
 720   SSLSocketDataProvider ssl(ASYNC, OK);
 721   socket_factory_.AddSSLSocketDataProvider(&ssl);
 722
 723   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 724   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
 725                                                     false);
 726
 727   ClientSocketHandle handle;
 728   TestCompletionCallback callback;
 729   int rv = handle.Init(
 730       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 731   EXPECT_EQ(ERR_IO_PENDING, rv);
 732   EXPECT_FALSE(handle.is_initialized());
 733   EXPECT_FALSE(handle.socket());
 734
 735   EXPECT_EQ(OK, callback.WaitForResult());
 736   EXPECT_TRUE(handle.is_initialized());
 737   EXPECT_TRUE(handle.socket());
 738   TestLoadTimingInfoNoDns(handle);
 739 }
 740
 741 TEST_P(SSLClientSocketPoolTest, NeedProxyAuth) {
 742   MockWrite writes[] = {
 743       MockWrite("CONNECT host:80 HTTP/1.1\r\n"
 744                 "Host: host\r\n"
 745                 "Proxy-Connection: keep-alive\r\n\r\n"),
 746   };
 747   MockRead reads[] = {
 748       MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
 749       MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
 750       MockRead("Content-Length: 10\r\n\r\n"),
 751       MockRead("0123456789"),
 752   };
 753   StaticSocketDataProvider data(reads, arraysize(reads), writes,
 754                                 arraysize(writes));
 755   socket_factory_.AddSocketDataProvider(&data);
 756   SSLSocketDataProvider ssl(ASYNC, OK);
 757   socket_factory_.AddSSLSocketDataProvider(&ssl);
 758
 759   CreatePool(false, true /* http proxy pool */, true /* socks pool */);
 760   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
 761                                                     false);
 762
 763   ClientSocketHandle handle;
 764   TestCompletionCallback callback;
 765   int rv = handle.Init(
 766       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
 767   EXPECT_EQ(ERR_IO_PENDING, rv);
 768   EXPECT_FALSE(handle.is_initialized());
 769   EXPECT_FALSE(handle.socket());
 770
 771   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult());
 772   EXPECT_FALSE(handle.is_initialized());
 773   EXPECT_FALSE(handle.socket());
 774   EXPECT_FALSE(handle.is_ssl_error());
 775   const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info();
 776   EXPECT_EQ(tunnel_info.headers->response_code(), 407);
 777   scoped_ptr<ClientSocketHandle> tunnel_handle(
 778       handle.release_pending_http_proxy_connection());
 779   EXPECT_TRUE(tunnel_handle->socket());
 780   EXPECT_FALSE(tunnel_handle->socket()->IsConnected());
 781 }
 782
 783 TEST_P(SSLClientSocketPoolTest, IPPooling) {
 784   const int kTestPort = 80;
 785   struct TestHosts {
 786     std::string name;
 787     std::string iplist;
 788     SpdySessionKey key;
 789     AddressList addresses;
 790   } test_hosts[] = {
 791     { "www.webkit.org",    "192.0.2.33,192.168.0.1,192.168.0.5" },
 792     { "code.google.com",   "192.168.0.2,192.168.0.3,192.168.0.5" },
 793     { "js.webkit.org",     "192.168.0.4,192.168.0.1,192.0.2.33" },
 794   };
 795
 796   host_resolver_.set_synchronous_mode(true);
 797   for (size_t i = 0; i < arraysize(test_hosts); i++) {
 798     host_resolver_.rules()->AddIPLiteralRule(
 799         test_hosts[i].name, test_hosts[i].iplist, std::string());
 800
 801     // This test requires that the HostResolver cache be populated.  Normal
 802     // code would have done this already, but we do it manually.
 803     HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
 804     host_resolver_.Resolve(info,
 805                            DEFAULT_PRIORITY,
 806                            &test_hosts[i].addresses,
 807                            CompletionCallback(),
 808                            NULL,
 809                            BoundNetLog());
 810
 811     // Setup a SpdySessionKey
 812     test_hosts[i].key = SpdySessionKey(
 813         HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(),
 814         PRIVACY_MODE_DISABLED);
 815   }
 816
 817   MockRead reads[] = {
 818       MockRead(ASYNC, ERR_IO_PENDING),
 819   };
 820   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
 821   socket_factory_.AddSocketDataProvider(&data);
 822   SSLSocketDataProvider ssl(ASYNC, OK);
 823   ssl.cert = X509Certificate::CreateFromBytes(
 824       reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
 825   ssl.SetNextProto(GetParam());
 826   socket_factory_.AddSSLSocketDataProvider(&ssl);
 827
 828   CreatePool(true /* tcp pool */, false, false);
 829   base::WeakPtr<SpdySession> spdy_session =
 830       CreateSecureSpdySession(session_, test_hosts[0].key, BoundNetLog());
 831
 832   EXPECT_TRUE(
 833       HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key));
 834   EXPECT_FALSE(
 835       HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key));
 836   EXPECT_TRUE(
 837       HasSpdySession(session_->spdy_session_pool(), test_hosts[2].key));
 838
 839   session_->spdy_session_pool()->CloseAllSessions();
 840 }
 841
 842 void SSLClientSocketPoolTest::TestIPPoolingDisabled(
 843     SSLSocketDataProvider* ssl) {
 844   const int kTestPort = 80;
 845   struct TestHosts {
 846     std::string name;
 847     std::string iplist;
 848     SpdySessionKey key;
 849     AddressList addresses;
 850   } test_hosts[] = {
 851     { "www.webkit.org",    "192.0.2.33,192.168.0.1,192.168.0.5" },
 852     { "js.webkit.com",     "192.168.0.4,192.168.0.1,192.0.2.33" },
 853   };
 854
 855   TestCompletionCallback callback;
 856   int rv;
 857   for (size_t i = 0; i < arraysize(test_hosts); i++) {
 858     host_resolver_.rules()->AddIPLiteralRule(
 859         test_hosts[i].name, test_hosts[i].iplist, std::string());
 860
 861     // This test requires that the HostResolver cache be populated.  Normal
 862     // code would have done this already, but we do it manually.
 863     HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
 864     rv = host_resolver_.Resolve(info,
 865                                 DEFAULT_PRIORITY,
 866                                 &test_hosts[i].addresses,
 867                                 callback.callback(),
 868                                 NULL,
 869                                 BoundNetLog());
 870     EXPECT_EQ(OK, callback.GetResult(rv));
 871
 872     // Setup a SpdySessionKey
 873     test_hosts[i].key = SpdySessionKey(
 874         HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(),
 875         PRIVACY_MODE_DISABLED);
 876   }
 877
 878   MockRead reads[] = {
 879       MockRead(ASYNC, ERR_IO_PENDING),
 880   };
 881   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
 882   socket_factory_.AddSocketDataProvider(&data);
 883   socket_factory_.AddSSLSocketDataProvider(ssl);
 884
 885   CreatePool(true /* tcp pool */, false, false);
 886   base::WeakPtr<SpdySession> spdy_session =
 887       CreateSecureSpdySession(session_, test_hosts[0].key, BoundNetLog());
 888
 889   EXPECT_TRUE(
 890       HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key));
 891   EXPECT_FALSE(
 892       HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key));
 893
 894   session_->spdy_session_pool()->CloseAllSessions();
 895 }
 896
 897 // Verifies that an SSL connection with client authentication disables SPDY IP
 898 // pooling.
 899 TEST_P(SSLClientSocketPoolTest, IPPoolingClientCert) {
 900   SSLSocketDataProvider ssl(ASYNC, OK);
 901   ssl.cert = X509Certificate::CreateFromBytes(
 902       reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
 903   ssl.client_cert_sent = true;
 904   ssl.SetNextProto(GetParam());
 905   TestIPPoolingDisabled(&ssl);
 906 }
 907
 908 // Verifies that an SSL connection with channel ID disables SPDY IP pooling.
 909 TEST_P(SSLClientSocketPoolTest, IPPoolingChannelID) {
 910   SSLSocketDataProvider ssl(ASYNC, OK);
 911   ssl.channel_id_sent = true;
 912   ssl.SetNextProto(GetParam());
 913   TestIPPoolingDisabled(&ssl);
 914 }
 915
 916 // It would be nice to also test the timeouts in SSLClientSocketPool.
 917
 918 }  // namespace
 919
 920 }  // namespace net