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"
@@ skipping 51 matching lines @@
       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(
+    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)
+    : transport_params_(transport_params),
+      proxy_(ProxyServer::SCHEME_DIRECT),
+      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_(transport_params_->ignore_limits()) {}
+
+SSLSocketParams::SSLSocketParams(
+    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)
+    : http_proxy_params_(http_proxy_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_(http_proxy_params_->ignore_limits()) {
+  DCHECK(proxy_ == ProxyServer::SCHEME_HTTP ||
+         proxy_ == ProxyServer::SCHEME_HTTPS);
+}
+
+SSLSocketParams::SSLSocketParams(
+    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)
+    : 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_(socks_params_->ignore_limits()) {
+  DCHECK(proxy_ == ProxyServer::SCHEME_SOCKS4 ||
+         proxy_ == ProxyServer::SCHEME_SOCKS5);
+}
+
 SSLSocketParams::~SSLSocketParams() {}
 
 // Timeout for the SSL handshake portion of the connect.
 static const int kSSLHandshakeTimeoutInSeconds = 30;
 
 SSLConnectJob::SSLConnectJob(const std::string& group_name,
                              const scoped_refptr<SSLSocketParams>& params,
                              const base::TimeDelta& timeout_duration,
                              TransportClientSocketPool* transport_pool,
                              SOCKSClientSocketPool* socks_pool,
@@ skipping 540 matching lines @@
   FlushWithError(ERR_NETWORK_CHANGED);
 }
 
 bool SSLClientSocketPool::CloseOneIdleConnection() {
   if (base_.CloseOneIdleSocket())
     return true;
   return base_.CloseOneIdleConnectionInLayeredPool();
 }
 
 }  // namespace net