net/socket/ssl_client_socket_pool.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/socket/ssl_client_socket_pool.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/metrics/field_trial.h"
  10 #include "base/metrics/histogram.h"
  11 #include "base/metrics/sparse_histogram.h"
  12 #include "base/values.h"
  13 #include "net/base/host_port_pair.h"
  14 #include "net/base/net_errors.h"
  15 #include "net/http/http_proxy_client_socket.h"
  16 #include "net/http/http_proxy_client_socket_pool.h"
  17 #include "net/socket/client_socket_factory.h"
  18 #include "net/socket/client_socket_handle.h"
  19 #include "net/socket/socks_client_socket_pool.h"
  20 #include "net/socket/ssl_client_socket.h"
  21 #include "net/socket/transport_client_socket_pool.h"
  22 #include "net/ssl/ssl_cert_request_info.h"
  23 #include "net/ssl/ssl_connection_status_flags.h"
  24 #include "net/ssl/ssl_info.h"
  25
  26 namespace net {
  27
  28 SSLSocketParams::SSLSocketParams(
  29     const scoped_refptr<TransportSocketParams>& direct_params,
  30     const scoped_refptr<SOCKSSocketParams>& socks_proxy_params,
  31     const scoped_refptr<HttpProxySocketParams>& http_proxy_params,
  32     const HostPortPair& host_and_port,
  33     const SSLConfig& ssl_config,
  34     PrivacyMode privacy_mode,
  35     int load_flags,
  36     bool force_spdy_over_ssl,
  37     bool want_spdy_over_npn)
  38     : direct_params_(direct_params),
  39       socks_proxy_params_(socks_proxy_params),
  40       http_proxy_params_(http_proxy_params),
  41       host_and_port_(host_and_port),
  42       ssl_config_(ssl_config),
  43       privacy_mode_(privacy_mode),
  44       load_flags_(load_flags),
  45       force_spdy_over_ssl_(force_spdy_over_ssl),
  46       want_spdy_over_npn_(want_spdy_over_npn),
  47       ignore_limits_(false) {
  48   if (direct_params_) {
  49     DCHECK(!socks_proxy_params_);
  50     DCHECK(!http_proxy_params_);
  51     ignore_limits_ = direct_params_->ignore_limits();
  52   } else if (socks_proxy_params_) {
  53     DCHECK(!http_proxy_params_);
  54     ignore_limits_ = socks_proxy_params_->ignore_limits();
  55   } else {
  56     DCHECK(http_proxy_params_);
  57     ignore_limits_ = http_proxy_params_->ignore_limits();
  58   }
  59 }
  60
  61 SSLSocketParams::~SSLSocketParams() {}
  62
  63 SSLSocketParams::ConnectionType SSLSocketParams::GetConnectionType() const {
  64   if (direct_params_) {
  65     DCHECK(!socks_proxy_params_);
  66     DCHECK(!http_proxy_params_);
  67     return DIRECT;
  68   }
  69
  70   if (socks_proxy_params_) {
  71     DCHECK(!http_proxy_params_);
  72     return SOCKS_PROXY;
  73   }
  74
  75   DCHECK(http_proxy_params_);
  76   return HTTP_PROXY;
  77 }
  78
  79 const scoped_refptr<TransportSocketParams>&
  80 SSLSocketParams::GetDirectConnectionParams() const {
  81   DCHECK_EQ(GetConnectionType(), DIRECT);
  82   return direct_params_;
  83 }
  84
  85 const scoped_refptr<SOCKSSocketParams>&
  86 SSLSocketParams::GetSocksProxyConnectionParams() const {
  87   DCHECK_EQ(GetConnectionType(), SOCKS_PROXY);
  88   return socks_proxy_params_;
  89 }
  90
  91 const scoped_refptr<HttpProxySocketParams>&
  92 SSLSocketParams::GetHttpProxyConnectionParams() const {
  93   DCHECK_EQ(GetConnectionType(), HTTP_PROXY);
  94   return http_proxy_params_;
  95 }
  96
  97 // Timeout for the SSL handshake portion of the connect.
  98 static const int kSSLHandshakeTimeoutInSeconds = 30;
  99
 100 SSLConnectJob::SSLConnectJob(const std::string& group_name,
 101                              RequestPriority priority,
 102                              const scoped_refptr<SSLSocketParams>& params,
 103                              const base::TimeDelta& timeout_duration,
 104                              TransportClientSocketPool* transport_pool,
 105                              SOCKSClientSocketPool* socks_pool,
 106                              HttpProxyClientSocketPool* http_proxy_pool,
 107                              ClientSocketFactory* client_socket_factory,
 108                              HostResolver* host_resolver,
 109                              const SSLClientSocketContext& context,
 110                              Delegate* delegate,
 111                              NetLog* net_log)
 112     : ConnectJob(group_name,
 113                  timeout_duration,
 114                  priority,
 115                  delegate,
 116                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
 117       params_(params),
 118       transport_pool_(transport_pool),
 119       socks_pool_(socks_pool),
 120       http_proxy_pool_(http_proxy_pool),
 121       client_socket_factory_(client_socket_factory),
 122       host_resolver_(host_resolver),
 123       context_(context.cert_verifier,
 124                context.server_bound_cert_service,
 125                context.transport_security_state,
 126                context.cert_transparency_verifier,
 127                (params->privacy_mode() == PRIVACY_MODE_ENABLED
 128                     ? "pm/" + context.ssl_session_cache_shard
 129                     : context.ssl_session_cache_shard)),
 130       callback_(base::Bind(&SSLConnectJob::OnIOComplete,
 131                            base::Unretained(this))) {}
 132
 133 SSLConnectJob::~SSLConnectJob() {}
 134
 135 LoadState SSLConnectJob::GetLoadState() const {
 136   switch (next_state_) {
 137     case STATE_TUNNEL_CONNECT_COMPLETE:
 138       if (transport_socket_handle_->socket())
 139         return LOAD_STATE_ESTABLISHING_PROXY_TUNNEL;
 140       // else, fall through.
 141     case STATE_TRANSPORT_CONNECT:
 142     case STATE_TRANSPORT_CONNECT_COMPLETE:
 143     case STATE_SOCKS_CONNECT:
 144     case STATE_SOCKS_CONNECT_COMPLETE:
 145     case STATE_TUNNEL_CONNECT:
 146       return transport_socket_handle_->GetLoadState();
 147     case STATE_SSL_CONNECT:
 148     case STATE_SSL_CONNECT_COMPLETE:
 149       return LOAD_STATE_SSL_HANDSHAKE;
 150     default:
 151       NOTREACHED();
 152       return LOAD_STATE_IDLE;
 153   }
 154 }
 155
 156 void SSLConnectJob::GetAdditionalErrorState(ClientSocketHandle* handle) {
 157   // Headers in |error_response_info_| indicate a proxy tunnel setup
 158   // problem. See DoTunnelConnectComplete.
 159   if (error_response_info_.headers.get()) {
 160     handle->set_pending_http_proxy_connection(
 161         transport_socket_handle_.release());
 162   }
 163   handle->set_ssl_error_response_info(error_response_info_);
 164   if (!connect_timing_.ssl_start.is_null())
 165     handle->set_is_ssl_error(true);
 166 }
 167
 168 void SSLConnectJob::OnIOComplete(int result) {
 169   int rv = DoLoop(result);
 170   if (rv != ERR_IO_PENDING)
 171     NotifyDelegateOfCompletion(rv);  // Deletes |this|.
 172 }
 173
 174 int SSLConnectJob::DoLoop(int result) {
 175   DCHECK_NE(next_state_, STATE_NONE);
 176
 177   int rv = result;
 178   do {
 179     State state = next_state_;
 180     next_state_ = STATE_NONE;
 181     switch (state) {
 182       case STATE_TRANSPORT_CONNECT:
 183         DCHECK_EQ(OK, rv);
 184         rv = DoTransportConnect();
 185         break;
 186       case STATE_TRANSPORT_CONNECT_COMPLETE:
 187         rv = DoTransportConnectComplete(rv);
 188         break;
 189       case STATE_SOCKS_CONNECT:
 190         DCHECK_EQ(OK, rv);
 191         rv = DoSOCKSConnect();
 192         break;
 193       case STATE_SOCKS_CONNECT_COMPLETE:
 194         rv = DoSOCKSConnectComplete(rv);
 195         break;
 196       case STATE_TUNNEL_CONNECT:
 197         DCHECK_EQ(OK, rv);
 198         rv = DoTunnelConnect();
 199         break;
 200       case STATE_TUNNEL_CONNECT_COMPLETE:
 201         rv = DoTunnelConnectComplete(rv);
 202         break;
 203       case STATE_SSL_CONNECT:
 204         DCHECK_EQ(OK, rv);
 205         rv = DoSSLConnect();
 206         break;
 207       case STATE_SSL_CONNECT_COMPLETE:
 208         rv = DoSSLConnectComplete(rv);
 209         break;
 210       default:
 211         NOTREACHED() << "bad state";
 212         rv = ERR_FAILED;
 213         break;
 214     }
 215   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 216
 217   return rv;
 218 }
 219
 220 int SSLConnectJob::DoTransportConnect() {
 221   DCHECK(transport_pool_);
 222
 223   next_state_ = STATE_TRANSPORT_CONNECT_COMPLETE;
 224   transport_socket_handle_.reset(new ClientSocketHandle());
 225   scoped_refptr<TransportSocketParams> direct_params =
 226       params_->GetDirectConnectionParams();
 227   return transport_socket_handle_->Init(group_name(),
 228                                         direct_params,
 229                                         priority(),
 230                                         callback_,
 231                                         transport_pool_,
 232                                         net_log());
 233 }
 234
 235 int SSLConnectJob::DoTransportConnectComplete(int result) {
 236   if (result == OK)
 237     next_state_ = STATE_SSL_CONNECT;
 238
 239   return result;
 240 }
 241
 242 int SSLConnectJob::DoSOCKSConnect() {
 243   DCHECK(socks_pool_);
 244   next_state_ = STATE_SOCKS_CONNECT_COMPLETE;
 245   transport_socket_handle_.reset(new ClientSocketHandle());
 246   scoped_refptr<SOCKSSocketParams> socks_proxy_params =
 247       params_->GetSocksProxyConnectionParams();
 248   return transport_socket_handle_->Init(group_name(),
 249                                         socks_proxy_params,
 250                                         priority(),
 251                                         callback_,
 252                                         socks_pool_,
 253                                         net_log());
 254 }
 255
 256 int SSLConnectJob::DoSOCKSConnectComplete(int result) {
 257   if (result == OK)
 258     next_state_ = STATE_SSL_CONNECT;
 259
 260   return result;
 261 }
 262
 263 int SSLConnectJob::DoTunnelConnect() {
 264   DCHECK(http_proxy_pool_);
 265   next_state_ = STATE_TUNNEL_CONNECT_COMPLETE;
 266
 267   transport_socket_handle_.reset(new ClientSocketHandle());
 268   scoped_refptr<HttpProxySocketParams> http_proxy_params =
 269       params_->GetHttpProxyConnectionParams();
 270   return transport_socket_handle_->Init(group_name(),
 271                                         http_proxy_params,
 272                                         priority(),
 273                                         callback_,
 274                                         http_proxy_pool_,
 275                                         net_log());
 276 }
 277
 278 int SSLConnectJob::DoTunnelConnectComplete(int result) {
 279   // Extract the information needed to prompt for appropriate proxy
 280   // authentication so that when ClientSocketPoolBaseHelper calls
 281   // |GetAdditionalErrorState|, we can easily set the state.
 282   if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
 283     error_response_info_ = transport_socket_handle_->ssl_error_response_info();
 284   } else if (result == ERR_PROXY_AUTH_REQUESTED ||
 285              result == ERR_HTTPS_PROXY_TUNNEL_RESPONSE) {
 286     StreamSocket* socket = transport_socket_handle_->socket();
 287     HttpProxyClientSocket* tunnel_socket =
 288         static_cast<HttpProxyClientSocket*>(socket);
 289     error_response_info_ = *tunnel_socket->GetConnectResponseInfo();
 290   }
 291   if (result < 0)
 292     return result;
 293
 294   next_state_ = STATE_SSL_CONNECT;
 295   return result;
 296 }
 297
 298 int SSLConnectJob::DoSSLConnect() {
 299   next_state_ = STATE_SSL_CONNECT_COMPLETE;
 300   // Reset the timeout to just the time allowed for the SSL handshake.
 301   ResetTimer(base::TimeDelta::FromSeconds(kSSLHandshakeTimeoutInSeconds));
 302
 303   // If the handle has a fresh socket, get its connect start and DNS times.
 304   // This should always be the case.
 305   const LoadTimingInfo::ConnectTiming& socket_connect_timing =
 306       transport_socket_handle_->connect_timing();
 307   if (!transport_socket_handle_->is_reused() &&
 308       !socket_connect_timing.connect_start.is_null()) {
 309     // Overwriting |connect_start| serves two purposes - it adjusts timing so
 310     // |connect_start| doesn't include dns times, and it adjusts the time so
 311     // as not to include time spent waiting for an idle socket.
 312     connect_timing_.connect_start = socket_connect_timing.connect_start;
 313     connect_timing_.dns_start = socket_connect_timing.dns_start;
 314     connect_timing_.dns_end = socket_connect_timing.dns_end;
 315   }
 316
 317   connect_timing_.ssl_start = base::TimeTicks::Now();
 318
 319   ssl_socket_ = client_socket_factory_->CreateSSLClientSocket(
 320       transport_socket_handle_.Pass(),
 321       params_->host_and_port(),
 322       params_->ssl_config(),
 323       context_);
 324   return ssl_socket_->Connect(callback_);
 325 }
 326
 327 int SSLConnectJob::DoSSLConnectComplete(int result) {
 328   connect_timing_.ssl_end = base::TimeTicks::Now();
 329
 330   SSLClientSocket::NextProtoStatus status =
 331       SSLClientSocket::kNextProtoUnsupported;
 332   std::string proto;
 333   std::string server_protos;
 334   // GetNextProto will fail and and trigger a NOTREACHED if we pass in a socket
 335   // that hasn't had SSL_ImportFD called on it. If we get a certificate error
 336   // here, then we know that we called SSL_ImportFD.
 337   if (result == OK || IsCertificateError(result))
 338     status = ssl_socket_->GetNextProto(&proto, &server_protos);
 339
 340   // If we want spdy over npn, make sure it succeeded.
 341   if (status == SSLClientSocket::kNextProtoNegotiated) {
 342     ssl_socket_->set_was_npn_negotiated(true);
 343     NextProto protocol_negotiated =
 344         SSLClientSocket::NextProtoFromString(proto);
 345     ssl_socket_->set_protocol_negotiated(protocol_negotiated);
 346     // If we negotiated a SPDY version, it must have been present in
 347     // SSLConfig::next_protos.
 348     // TODO(mbelshe): Verify this.
 349     if (protocol_negotiated >= kProtoSPDYMinimumVersion &&
 350         protocol_negotiated <= kProtoSPDYMaximumVersion) {
 351       ssl_socket_->set_was_spdy_negotiated(true);
 352     }
 353   }
 354   if (params_->want_spdy_over_npn() && !ssl_socket_->was_spdy_negotiated())
 355     return ERR_NPN_NEGOTIATION_FAILED;
 356
 357   // Spdy might be turned on by default, or it might be over npn.
 358   bool using_spdy = params_->force_spdy_over_ssl() ||
 359       params_->want_spdy_over_npn();
 360
 361   if (result == OK ||
 362       ssl_socket_->IgnoreCertError(result, params_->load_flags())) {
 363     DCHECK(!connect_timing_.ssl_start.is_null());
 364     base::TimeDelta connect_duration =
 365         connect_timing_.ssl_end - connect_timing_.ssl_start;
 366     if (using_spdy) {
 367       UMA_HISTOGRAM_CUSTOM_TIMES("Net.SpdyConnectionLatency_2",
 368                                  connect_duration,
 369                                  base::TimeDelta::FromMilliseconds(1),
 370                                  base::TimeDelta::FromMinutes(1),
 371                                  100);
 372     }
 373 #if defined(SPDY_PROXY_AUTH_ORIGIN)
 374     bool using_data_reduction_proxy = params_->host_and_port().Equals(
 375         HostPortPair::FromURL(GURL(SPDY_PROXY_AUTH_ORIGIN)));
 376     if (using_data_reduction_proxy) {
 377       UMA_HISTOGRAM_CUSTOM_TIMES(
 378           "Net.SSL_Connection_Latency_DataReductionProxy",
 379           connect_duration,
 380           base::TimeDelta::FromMilliseconds(1),
 381           base::TimeDelta::FromMinutes(1),
 382           100);
 383     }
 384 #endif
 385
 386     UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency_2",
 387                                connect_duration,
 388                                base::TimeDelta::FromMilliseconds(1),
 389                                base::TimeDelta::FromMinutes(1),
 390                                100);
 391
 392     SSLInfo ssl_info;
 393     ssl_socket_->GetSSLInfo(&ssl_info);
 394
 395     UMA_HISTOGRAM_SPARSE_SLOWLY("Net.SSL_CipherSuite",
 396                                 SSLConnectionStatusToCipherSuite(
 397                                     ssl_info.connection_status));
 398
 399     if (ssl_info.handshake_type == SSLInfo::HANDSHAKE_RESUME) {
 400       UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency_Resume_Handshake",
 401                                  connect_duration,
 402                                  base::TimeDelta::FromMilliseconds(1),
 403                                  base::TimeDelta::FromMinutes(1),
 404                                  100);
 405     } else if (ssl_info.handshake_type == SSLInfo::HANDSHAKE_FULL) {
 406       UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency_Full_Handshake",
 407                                  connect_duration,
 408                                  base::TimeDelta::FromMilliseconds(1),
 409                                  base::TimeDelta::FromMinutes(1),
 410                                  100);
 411     }
 412
 413     const std::string& host = params_->host_and_port().host();
 414     bool is_google = host == "google.com" ||
 415                      (host.size() > 11 &&
 416                       host.rfind(".google.com") == host.size() - 11);
 417     if (is_google) {
 418       UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency_Google2",
 419                                  connect_duration,
 420                                  base::TimeDelta::FromMilliseconds(1),
 421                                  base::TimeDelta::FromMinutes(1),
 422                                  100);
 423       if (ssl_info.handshake_type == SSLInfo::HANDSHAKE_RESUME) {
 424         UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency_Google_"
 425                                        "Resume_Handshake",
 426                                    connect_duration,
 427                                    base::TimeDelta::FromMilliseconds(1),
 428                                    base::TimeDelta::FromMinutes(1),
 429                                    100);
 430       } else if (ssl_info.handshake_type == SSLInfo::HANDSHAKE_FULL) {
 431         UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency_Google_"
 432                                        "Full_Handshake",
 433                                    connect_duration,
 434                                    base::TimeDelta::FromMilliseconds(1),
 435                                    base::TimeDelta::FromMinutes(1),
 436                                    100);
 437       }
 438     }
 439   }
 440
 441   if (result == OK || IsCertificateError(result)) {
 442     SetSocket(ssl_socket_.PassAs<StreamSocket>());
 443   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
 444     error_response_info_.cert_request_info = new SSLCertRequestInfo;
 445     ssl_socket_->GetSSLCertRequestInfo(
 446         error_response_info_.cert_request_info.get());
 447   }
 448
 449   return result;
 450 }
 451
 452 SSLConnectJob::State SSLConnectJob::GetInitialState(
 453     SSLSocketParams::ConnectionType connection_type) {
 454   switch (connection_type) {
 455     case SSLSocketParams::DIRECT:
 456       return STATE_TRANSPORT_CONNECT;
 457     case SSLSocketParams::HTTP_PROXY:
 458       return STATE_TUNNEL_CONNECT;
 459     case SSLSocketParams::SOCKS_PROXY:
 460       return STATE_SOCKS_CONNECT;
 461   }
 462   NOTREACHED();
 463   return STATE_NONE;
 464 }
 465
 466 int SSLConnectJob::ConnectInternal() {
 467   next_state_ = GetInitialState(params_->GetConnectionType());
 468   return DoLoop(OK);
 469 }
 470
 471 SSLClientSocketPool::SSLConnectJobFactory::SSLConnectJobFactory(
 472     TransportClientSocketPool* transport_pool,
 473     SOCKSClientSocketPool* socks_pool,
 474     HttpProxyClientSocketPool* http_proxy_pool,
 475     ClientSocketFactory* client_socket_factory,
 476     HostResolver* host_resolver,
 477     const SSLClientSocketContext& context,
 478     NetLog* net_log)
 479     : transport_pool_(transport_pool),
 480       socks_pool_(socks_pool),
 481       http_proxy_pool_(http_proxy_pool),
 482       client_socket_factory_(client_socket_factory),
 483       host_resolver_(host_resolver),
 484       context_(context),
 485       net_log_(net_log) {
 486   base::TimeDelta max_transport_timeout = base::TimeDelta();
 487   base::TimeDelta pool_timeout;
 488   if (transport_pool_)
 489     max_transport_timeout = transport_pool_->ConnectionTimeout();
 490   if (socks_pool_) {
 491     pool_timeout = socks_pool_->ConnectionTimeout();
 492     if (pool_timeout > max_transport_timeout)
 493       max_transport_timeout = pool_timeout;
 494   }
 495   if (http_proxy_pool_) {
 496     pool_timeout = http_proxy_pool_->ConnectionTimeout();
 497     if (pool_timeout > max_transport_timeout)
 498       max_transport_timeout = pool_timeout;
 499   }
 500   timeout_ = max_transport_timeout +
 501       base::TimeDelta::FromSeconds(kSSLHandshakeTimeoutInSeconds);
 502 }
 503
 504 SSLClientSocketPool::SSLClientSocketPool(
 505     int max_sockets,
 506     int max_sockets_per_group,
 507     ClientSocketPoolHistograms* histograms,
 508     HostResolver* host_resolver,
 509     CertVerifier* cert_verifier,
 510     ServerBoundCertService* server_bound_cert_service,
 511     TransportSecurityState* transport_security_state,
 512     CTVerifier* cert_transparency_verifier,
 513     const std::string& ssl_session_cache_shard,
 514     ClientSocketFactory* client_socket_factory,
 515     TransportClientSocketPool* transport_pool,
 516     SOCKSClientSocketPool* socks_pool,
 517     HttpProxyClientSocketPool* http_proxy_pool,
 518     SSLConfigService* ssl_config_service,
 519     NetLog* net_log)
 520     : transport_pool_(transport_pool),
 521       socks_pool_(socks_pool),
 522       http_proxy_pool_(http_proxy_pool),
 523       base_(this, max_sockets, max_sockets_per_group, histograms,
 524             ClientSocketPool::unused_idle_socket_timeout(),
 525             ClientSocketPool::used_idle_socket_timeout(),
 526             new SSLConnectJobFactory(transport_pool,
 527                                      socks_pool,
 528                                      http_proxy_pool,
 529                                      client_socket_factory,
 530                                      host_resolver,
 531                                      SSLClientSocketContext(
 532                                          cert_verifier,
 533                                          server_bound_cert_service,
 534                                          transport_security_state,
 535                                          cert_transparency_verifier,
 536                                          ssl_session_cache_shard),
 537                                      net_log)),
 538       ssl_config_service_(ssl_config_service) {
 539   if (ssl_config_service_.get())
 540     ssl_config_service_->AddObserver(this);
 541   if (transport_pool_)
 542     base_.AddLowerLayeredPool(transport_pool_);
 543   if (socks_pool_)
 544     base_.AddLowerLayeredPool(socks_pool_);
 545   if (http_proxy_pool_)
 546     base_.AddLowerLayeredPool(http_proxy_pool_);
 547 }
 548
 549 SSLClientSocketPool::~SSLClientSocketPool() {
 550   if (ssl_config_service_.get())
 551     ssl_config_service_->RemoveObserver(this);
 552 }
 553
 554 scoped_ptr<ConnectJob>
 555 SSLClientSocketPool::SSLConnectJobFactory::NewConnectJob(
 556     const std::string& group_name,
 557     const PoolBase::Request& request,
 558     ConnectJob::Delegate* delegate) const {
 559   return scoped_ptr<ConnectJob>(
 560       new SSLConnectJob(group_name, request.priority(), request.params(),
 561                         ConnectionTimeout(), transport_pool_, socks_pool_,
 562                         http_proxy_pool_, client_socket_factory_,
 563                         host_resolver_, context_, delegate, net_log_));
 564 }
 565
 566 base::TimeDelta
 567 SSLClientSocketPool::SSLConnectJobFactory::ConnectionTimeout() const {
 568   return timeout_;
 569 }
 570
 571 int SSLClientSocketPool::RequestSocket(const std::string& group_name,
 572                                        const void* socket_params,
 573                                        RequestPriority priority,
 574                                        ClientSocketHandle* handle,
 575                                        const CompletionCallback& callback,
 576                                        const BoundNetLog& net_log) {
 577   const scoped_refptr<SSLSocketParams>* casted_socket_params =
 578       static_cast<const scoped_refptr<SSLSocketParams>*>(socket_params);
 579
 580   return base_.RequestSocket(group_name, *casted_socket_params, priority,
 581                              handle, callback, net_log);
 582 }
 583
 584 void SSLClientSocketPool::RequestSockets(
 585     const std::string& group_name,
 586     const void* params,
 587     int num_sockets,
 588     const BoundNetLog& net_log) {
 589   const scoped_refptr<SSLSocketParams>* casted_params =
 590       static_cast<const scoped_refptr<SSLSocketParams>*>(params);
 591
 592   base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
 593 }
 594
 595 void SSLClientSocketPool::CancelRequest(const std::string& group_name,
 596                                         ClientSocketHandle* handle) {
 597   base_.CancelRequest(group_name, handle);
 598 }
 599
 600 void SSLClientSocketPool::ReleaseSocket(const std::string& group_name,
 601                                         scoped_ptr<StreamSocket> socket,
 602                                         int id) {
 603   base_.ReleaseSocket(group_name, socket.Pass(), id);
 604 }
 605
 606 void SSLClientSocketPool::FlushWithError(int error) {
 607   base_.FlushWithError(error);
 608 }
 609
 610 void SSLClientSocketPool::CloseIdleSockets() {
 611   base_.CloseIdleSockets();
 612 }
 613
 614 int SSLClientSocketPool::IdleSocketCount() const {
 615   return base_.idle_socket_count();
 616 }
 617
 618 int SSLClientSocketPool::IdleSocketCountInGroup(
 619     const std::string& group_name) const {
 620   return base_.IdleSocketCountInGroup(group_name);
 621 }
 622
 623 LoadState SSLClientSocketPool::GetLoadState(
 624     const std::string& group_name, const ClientSocketHandle* handle) const {
 625   return base_.GetLoadState(group_name, handle);
 626 }
 627
 628 base::DictionaryValue* SSLClientSocketPool::GetInfoAsValue(
 629     const std::string& name,
 630     const std::string& type,
 631     bool include_nested_pools) const {
 632   base::DictionaryValue* dict = base_.GetInfoAsValue(name, type);
 633   if (include_nested_pools) {
 634     base::ListValue* list = new base::ListValue();
 635     if (transport_pool_) {
 636       list->Append(transport_pool_->GetInfoAsValue("transport_socket_pool",
 637                                                    "transport_socket_pool",
 638                                                    false));
 639     }
 640     if (socks_pool_) {
 641       list->Append(socks_pool_->GetInfoAsValue("socks_pool",
 642                                                "socks_pool",
 643                                                true));
 644     }
 645     if (http_proxy_pool_) {
 646       list->Append(http_proxy_pool_->GetInfoAsValue("http_proxy_pool",
 647                                                     "http_proxy_pool",
 648                                                     true));
 649     }
 650     dict->Set("nested_pools", list);
 651   }
 652   return dict;
 653 }
 654
 655 base::TimeDelta SSLClientSocketPool::ConnectionTimeout() const {
 656   return base_.ConnectionTimeout();
 657 }
 658
 659 ClientSocketPoolHistograms* SSLClientSocketPool::histograms() const {
 660   return base_.histograms();
 661 }
 662
 663 bool SSLClientSocketPool::IsStalled() const {
 664   return base_.IsStalled();
 665 }
 666
 667 void SSLClientSocketPool::AddHigherLayeredPool(HigherLayeredPool* higher_pool) {
 668   base_.AddHigherLayeredPool(higher_pool);
 669 }
 670
 671 void SSLClientSocketPool::RemoveHigherLayeredPool(
 672     HigherLayeredPool* higher_pool) {
 673   base_.RemoveHigherLayeredPool(higher_pool);
 674 }
 675
 676 bool SSLClientSocketPool::CloseOneIdleConnection() {
 677   if (base_.CloseOneIdleSocket())
 678     return true;
 679   return base_.CloseOneIdleConnectionInHigherLayeredPool();
 680 }
 681
 682 void SSLClientSocketPool::OnSSLConfigChanged() {
 683   FlushWithError(ERR_NETWORK_CHANGED);
 684 }
 685
 686 }  // namespace net