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
26namespace net {
27
28SSLSocketParams::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
61SSLSocketParams::~SSLSocketParams() {}
62
63SSLSocketParams::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
79const scoped_refptr<TransportSocketParams>&
80SSLSocketParams::GetDirectConnectionParams() const {
81  DCHECK_EQ(GetConnectionType(), DIRECT);
82  return direct_params_;
83}
84
85const scoped_refptr<SOCKSSocketParams>&
86SSLSocketParams::GetSocksProxyConnectionParams() const {
87  DCHECK_EQ(GetConnectionType(), SOCKS_PROXY);
88  return socks_proxy_params_;
89}
90
91const scoped_refptr<HttpProxySocketParams>&
92SSLSocketParams::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.
98static const int kSSLHandshakeTimeoutInSeconds = 30;
99
100SSLConnectJob::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() == kPrivacyModeEnabled
128                    ? "pm/" + context.ssl_session_cache_shard
129                    : context.ssl_session_cache_shard)),
130      callback_(base::Bind(&SSLConnectJob::OnIOComplete,
131                           base::Unretained(this))) {}
132
133SSLConnectJob::~SSLConnectJob() {}
134
135LoadState 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
156void 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
168void SSLConnectJob::OnIOComplete(int result) {
169  int rv = DoLoop(result);
170  if (rv != ERR_IO_PENDING)
171    NotifyDelegateOfCompletion(rv);  // Deletes |this|.
172}
173
174int 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
220int 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
235int SSLConnectJob::DoTransportConnectComplete(int result) {
236  if (result == OK)
237    next_state_ = STATE_SSL_CONNECT;
238
239  return result;
240}
241
242int 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
256int SSLConnectJob::DoSOCKSConnectComplete(int result) {
257  if (result == OK)
258    next_state_ = STATE_SSL_CONNECT;
259
260  return result;
261}
262
263int 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
278int 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
298int 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
327int 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
452SSLConnectJob::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
466int SSLConnectJob::ConnectInternal() {
467  next_state_ = GetInitialState(params_->GetConnectionType());
468  return DoLoop(OK);
469}
470
471SSLClientSocketPool::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
504SSLClientSocketPool::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
549SSLClientSocketPool::~SSLClientSocketPool() {
550  if (ssl_config_service_.get())
551    ssl_config_service_->RemoveObserver(this);
552}
553
554scoped_ptr<ConnectJob>
555SSLClientSocketPool::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
566base::TimeDelta
567SSLClientSocketPool::SSLConnectJobFactory::ConnectionTimeout() const {
568  return timeout_;
569}
570
571int 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
584void 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
595void SSLClientSocketPool::CancelRequest(const std::string& group_name,
596                                        ClientSocketHandle* handle) {
597  base_.CancelRequest(group_name, handle);
598}
599
600void 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
606void SSLClientSocketPool::FlushWithError(int error) {
607  base_.FlushWithError(error);
608}
609
610void SSLClientSocketPool::CloseIdleSockets() {
611  base_.CloseIdleSockets();
612}
613
614int SSLClientSocketPool::IdleSocketCount() const {
615  return base_.idle_socket_count();
616}
617
618int SSLClientSocketPool::IdleSocketCountInGroup(
619    const std::string& group_name) const {
620  return base_.IdleSocketCountInGroup(group_name);
621}
622
623LoadState SSLClientSocketPool::GetLoadState(
624    const std::string& group_name, const ClientSocketHandle* handle) const {
625  return base_.GetLoadState(group_name, handle);
626}
627
628base::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
655base::TimeDelta SSLClientSocketPool::ConnectionTimeout() const {
656  return base_.ConnectionTimeout();
657}
658
659ClientSocketPoolHistograms* SSLClientSocketPool::histograms() const {
660  return base_.histograms();
661}
662
663bool SSLClientSocketPool::IsStalled() const {
664  return base_.IsStalled();
665}
666
667void SSLClientSocketPool::AddHigherLayeredPool(HigherLayeredPool* higher_pool) {
668  base_.AddHigherLayeredPool(higher_pool);
669}
670
671void SSLClientSocketPool::RemoveHigherLayeredPool(
672    HigherLayeredPool* higher_pool) {
673  base_.RemoveHigherLayeredPool(higher_pool);
674}
675
676bool SSLClientSocketPool::CloseOneIdleConnection() {
677  if (base_.CloseOneIdleSocket())
678    return true;
679  return base_.CloseOneIdleConnectionInHigherLayeredPool();
680}
681
682void SSLClientSocketPool::OnSSLConfigChanged() {
683  FlushWithError(ERR_NETWORK_CHANGED);
684}
685
686}  // namespace net
687