Refactor pooled socket request code to prepare for implementation of pretend-to-preconnect.

net/socket/ssl_client_socket_pool.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/ssl_client_socket_pool.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/transport_client_socket_pool.h"
 #include "net/ssl/ssl_cert_request_info.h"
 
 namespace net {
 
+scoped_refptr<SSLSocketParams> SSLSocketParams::CreateForDirectConnection(
+    const scoped_refptr<TransportSocketParams>& transport_params,
+    const HostPortPair& host_and_port,
+    const SSLConfig& ssl_config,
+    int load_flags,
+    bool force_spdy_over_ssl,
+    bool want_spdy_over_npn)
+{
+  return make_scoped_refptr(new SSLSocketParams(
+      transport_params,
+      NULL,
+      NULL,
+      ProxyServer::SCHEME_DIRECT,
+      host_and_port,
+      ssl_config,
+      load_flags,
+      force_spdy_over_ssl,
+      want_spdy_over_npn,
+      transport_params->ignore_limits()
+      ));
+}
+
+scoped_refptr<SSLSocketParams> SSLSocketParams::CreateForHttpProxy(
+    const scoped_refptr<HttpProxySocketParams>& http_proxy_params,
+    ProxyServer::Scheme proxy,
+    const HostPortPair& host_and_port,
+    const SSLConfig& ssl_config,
+    int load_flags,
+    bool force_spdy_over_ssl,
+    bool want_spdy_over_npn) {
+  DCHECK(proxy == ProxyServer::SCHEME_HTTP ||
+         proxy == ProxyServer::SCHEME_HTTPS);
+
+  return make_scoped_refptr(new SSLSocketParams(
+      NULL,
+      NULL,
+      http_proxy_params,
+      proxy,
+      host_and_port,
+      ssl_config,
+      load_flags,
+      force_spdy_over_ssl,
+      want_spdy_over_npn,
+      http_proxy_params->ignore_limits()
+      ));
+}
+
+scoped_refptr<SSLSocketParams> SSLSocketParams::CreateForSocksProxy(
+    const scoped_refptr<SOCKSSocketParams>& socks_params,
+    ProxyServer::Scheme proxy,
+    const HostPortPair& host_and_port,
+    const SSLConfig& ssl_config,
+    int load_flags,
+    bool force_spdy_over_ssl,
+    bool want_spdy_over_npn) {
+  DCHECK(proxy == ProxyServer::SCHEME_SOCKS4 ||
+         proxy == ProxyServer::SCHEME_SOCKS5);
+
+  return make_scoped_refptr(new SSLSocketParams(
+      NULL,
+      socks_params,
+      NULL,
+      proxy,
+      host_and_port,
+      ssl_config,
+      load_flags,
+      force_spdy_over_ssl,
+      want_spdy_over_npn,
+      socks_params->ignore_limits()
+      ));
+}
+
 SSLSocketParams::SSLSocketParams(
     const scoped_refptr<TransportSocketParams>& transport_params,
     const scoped_refptr<SOCKSSocketParams>& socks_params,
     const scoped_refptr<HttpProxySocketParams>& http_proxy_params,
     ProxyServer::Scheme proxy,
     const HostPortPair& host_and_port,
     const SSLConfig& ssl_config,
     int load_flags,
     bool force_spdy_over_ssl,
-    bool want_spdy_over_npn)
+    bool want_spdy_over_npn,
+    bool ignore_limits)
     : transport_params_(transport_params),
       http_proxy_params_(http_proxy_params),
       socks_params_(socks_params),
       proxy_(proxy),
       host_and_port_(host_and_port),
       ssl_config_(ssl_config),
       load_flags_(load_flags),
       force_spdy_over_ssl_(force_spdy_over_ssl),
       want_spdy_over_npn_(want_spdy_over_npn),
-      ignore_limits_(false) {
+      ignore_limits_(ignore_limits) {
   switch (proxy_) {
     case ProxyServer::SCHEME_DIRECT:
       DCHECK(transport_params_.get() != NULL);
       DCHECK(http_proxy_params_.get() == NULL);
       DCHECK(socks_params_.get() == NULL);
-      ignore_limits_ = transport_params_->ignore_limits();
       break;
     case ProxyServer::SCHEME_HTTP:
     case ProxyServer::SCHEME_HTTPS:
       DCHECK(transport_params_.get() == NULL);
       DCHECK(http_proxy_params_.get() != NULL);
       DCHECK(socks_params_.get() == NULL);
-      ignore_limits_ = http_proxy_params_->ignore_limits();
       break;
     case ProxyServer::SCHEME_SOCKS4:
     case ProxyServer::SCHEME_SOCKS5:
       DCHECK(transport_params_.get() == NULL);
       DCHECK(http_proxy_params_.get() == NULL);
       DCHECK(socks_params_.get() != NULL);
-      ignore_limits_ = socks_params_->ignore_limits();
       break;
     default:
       LOG(DFATAL) << "unknown proxy type";
       break;
   }
 }
 
 SSLSocketParams::~SSLSocketParams() {}
 
 // Timeout for the SSL handshake portion of the connect.
@@ skipping 547 matching lines @@
   FlushWithError(ERR_NETWORK_CHANGED);
 }
 
 bool SSLClientSocketPool::CloseOneIdleConnection() {
   if (base_.CloseOneIdleSocket())
     return true;
   return base_.CloseOneIdleConnectionInLayeredPool();
 }
 
 }  // namespace net