Changed the jingle network code in ChromeAsyncSocket to use the client socket pool. This also all...

net/socket/client_socket_pool_manager.cc

 // Copyright (c) 2011 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.
 //
 // ClientSocketPoolManager manages access to all ClientSocketPools.  It's a
 // simple container for all of them.  Most importantly, it handles the lifetime
 // and destruction order properly.
 
 #include "net/socket/client_socket_pool_manager.h"
 
@@ skipping 47 matching lines @@
 
 // The meat of the implementation for the InitSocketHandleForHttpRequest,
 // InitSocketHandleForRawConnect and PreconnectSocketsForHttpRequest methods.
 int InitSocketPoolHelper(const HttpRequestInfo& request_info,
                          HttpNetworkSession* session,
                          const ProxyInfo& proxy_info,
                          bool force_spdy_over_ssl,
                          bool want_spdy_over_npn,
                          const SSLConfig& ssl_config_for_origin,
                          const SSLConfig& ssl_config_for_proxy,
+                         bool force_tunnel,
                          const BoundNetLog& net_log,
                          int num_preconnect_streams,
                          ClientSocketHandle* socket_handle,
                          CompletionCallback* callback) {
   scoped_refptr<TransportSocketParams> tcp_params;
   scoped_refptr<HttpProxySocketParams> http_proxy_params;
   scoped_refptr<SOCKSSocketParams> socks_params;
   scoped_ptr<HostPortPair> proxy_host_port;
 
   bool using_ssl = request_info.url.SchemeIs("https") || force_spdy_over_ssl;
@@ skipping 56 matching lines @@
 
       http_proxy_params =
           new HttpProxySocketParams(proxy_tcp_params,
                                     ssl_params,
                                     request_info.url,
                                     user_agent,
                                     origin_host_port,
                                     session->http_auth_cache(),
                                     session->http_auth_handler_factory(),
                                     session->spdy_session_pool(),
-                                    using_ssl);
+                                    force_tunnel || using_ssl);
     } else {
       DCHECK(proxy_info.is_socks());
       char socks_version;
       if (proxy_server.scheme() == ProxyServer::SCHEME_SOCKS5)
         socks_version = '5';
       else
         socks_version = '4';
       connection_group = base::StringPrintf(
           "socks%c/%s", socks_version, connection_group.c_str());
 
@@ skipping 456 matching lines @@
     ClientSocketHandle* socket_handle,
     CompletionCallback* callback) {
   DCHECK(socket_handle);
   return InitSocketPoolHelper(request_info,
                               session,
                               proxy_info,
                               force_spdy_over_ssl,
                               want_spdy_over_npn,
                               ssl_config_for_origin,
                               ssl_config_for_proxy,
+                              false,
                               net_log,
                               0,
                               socket_handle,
                               callback);
 }
 
 // static
 int ClientSocketPoolManager::InitSocketHandleForRawConnect(
     const HostPortPair& host_port_pair,
     HttpNetworkSession* session,
     const ProxyInfo& proxy_info,
     const SSLConfig& ssl_config_for_origin,
     const SSLConfig& ssl_config_for_proxy,
     const BoundNetLog& net_log,
     ClientSocketHandle* socket_handle,
     CompletionCallback* callback) {
   DCHECK(socket_handle);
   // Synthesize an HttpRequestInfo.
   HttpRequestInfo request_info;
   request_info.url = GURL("http://" + host_port_pair.ToString());
   return InitSocketPoolHelper(request_info,
                               session,
                               proxy_info,
                               false,
                               false,
                               ssl_config_for_origin,
                               ssl_config_for_proxy,
+                              true,
                               net_log,
                               0,
                               socket_handle,
                               callback);
 }
 
 // static
 int ClientSocketPoolManager::PreconnectSocketsForHttpRequest(
     const HttpRequestInfo& request_info,
     HttpNetworkSession* session,
     const ProxyInfo& proxy_info,
     bool force_spdy_over_ssl,
     bool want_spdy_over_npn,
     const SSLConfig& ssl_config_for_origin,
     const SSLConfig& ssl_config_for_proxy,
     const BoundNetLog& net_log,
     int num_preconnect_streams) {
   return InitSocketPoolHelper(request_info,
                               session,
                               proxy_info,
                               force_spdy_over_ssl,
                               want_spdy_over_npn,
                               ssl_config_for_origin,
                               ssl_config_for_proxy,
+                              false,
                               net_log,
                               num_preconnect_streams,
                               NULL,
                               NULL);
 }
 
 
 }  // namespace net