[WIP] Pretend-to-preconnect for {mouse,touch}-event triggers.

net/socket/client_socket_pool_manager.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/client_socket_pool_manager.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 46 matching lines @@
 // http://crbug.com/44501 for details about proxy server connection limits.
 int g_max_sockets_per_proxy_server[] = {
   kDefaultMaxSocketsPerProxyServer,  // NORMAL_SOCKET_POOL
   kDefaultMaxSocketsPerProxyServer   // WEBSOCKET_SOCKET_POOL
 };
 
 COMPILE_ASSERT(arraysize(g_max_sockets_per_proxy_server) ==
                    HttpNetworkSession::NUM_SOCKET_POOL_TYPES,
                max_sockets_per_proxy_server_length_mismatch);
 
+int PretendToRequestSocketsForPool(ClientSocketPool* pool,
+                                   const std::string& group_name,
+                                   int num_sockets) {
+  int idle_count = pool->IdleSocketCountInGroup(group_name);
+
+  int would_have_been_connected = num_sockets - idle_count;

[mmenke, 2013/05/01 16:55:08]

This count isn't correct.  We actually use NumActiveSocketsInGroup in
client_socket_pool_base (See ClientSocketPoolBaseHelper::RequestSockets).

+  if (would_have_been_connected > 0)
+    would_have_been_connected = 0;
+  return would_have_been_connected;
+}
+
 // The meat of the implementation for the InitSocketHandleForHttpRequest,
 // InitSocketHandleForRawConnect and PreconnectSocketsForHttpRequest methods.
 int InitSocketPoolHelper(const GURL& request_url,
                          const HttpRequestHeaders& request_extra_headers,
                          int request_load_flags,
                          RequestPriority request_priority,
                          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,
+                         bool pretend_to_preconnect,
                          ClientSocketHandle* socket_handle,
                          const OnHostResolutionCallback& resolution_callback,
                          const 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_url.SchemeIs("https") || force_spdy_over_ssl;
 
@@ skipping 139 matching lines @@
     if (proxy_info.is_direct()) {
       ssl_pool = session->GetSSLSocketPool(
           HttpNetworkSession::NORMAL_SOCKET_POOL);
     } else {
       ssl_pool = session->GetSocketPoolForSSLWithProxy(
           HttpNetworkSession::NORMAL_SOCKET_POOL,
           *proxy_host_port);
     }
 
     if (num_preconnect_streams) {
+      if (pretend_to_preconnect)
+        return PretendToRequestSocketsForPool(
+            ssl_pool, connection_group, num_preconnect_streams);
+
       RequestSocketsForPool(ssl_pool, connection_group, ssl_params,
                             num_preconnect_streams, net_log);
+
       return OK;
     }
 
     return socket_handle->Init(connection_group, ssl_params,
                                request_priority, callback, ssl_pool,
                                net_log);
   }
 
   // Finally, get the connection started.
 
   if (proxy_info.is_http() || proxy_info.is_https()) {
     HttpProxyClientSocketPool* pool =
         session->GetSocketPoolForHTTPProxy(
             HttpNetworkSession::NORMAL_SOCKET_POOL,
             *proxy_host_port);
     if (num_preconnect_streams) {
+      if (pretend_to_preconnect)
+        return PretendToRequestSocketsForPool(
+            pool, connection_group, num_preconnect_streams);
+
       RequestSocketsForPool(pool, connection_group, http_proxy_params,
                             num_preconnect_streams, net_log);
       return OK;
     }
 
     return socket_handle->Init(connection_group, http_proxy_params,
                                request_priority, callback,
                                pool, net_log);
   }
 
   if (proxy_info.is_socks()) {
     SOCKSClientSocketPool* pool =
         session->GetSocketPoolForSOCKSProxy(
             HttpNetworkSession::NORMAL_SOCKET_POOL,
             *proxy_host_port);
     if (num_preconnect_streams) {
+      if (pretend_to_preconnect)
+        return PretendToRequestSocketsForPool(
+            pool, connection_group, num_preconnect_streams);
+
       RequestSocketsForPool(pool, connection_group, socks_params,
                             num_preconnect_streams, net_log);
       return OK;
     }
 
     return socket_handle->Init(connection_group, socks_params,
                                request_priority, callback, pool,
                                net_log);
   }
 
   DCHECK(proxy_info.is_direct());
 
   TransportClientSocketPool* pool =
       session->GetTransportSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL);
   if (num_preconnect_streams) {
+    if (pretend_to_preconnect)
+      return PretendToRequestSocketsForPool(
+          pool, connection_group, num_preconnect_streams);
+
     RequestSocketsForPool(pool, connection_group, tcp_params,
                           num_preconnect_streams, net_log);
     return OK;
   }
 
   return socket_handle->Init(connection_group, tcp_params,
                              request_priority, callback,
                              pool, net_log);
 }
 
@@ skipping 76 matching lines @@
     const SSLConfig& ssl_config_for_origin,
     const SSLConfig& ssl_config_for_proxy,
     const BoundNetLog& net_log,
     ClientSocketHandle* socket_handle,
     const OnHostResolutionCallback& resolution_callback,
     const CompletionCallback& callback) {
   DCHECK(socket_handle);
   return InitSocketPoolHelper(
       request_url, request_extra_headers, request_load_flags, request_priority,
       session, proxy_info, force_spdy_over_ssl, want_spdy_over_npn,
-      ssl_config_for_origin, ssl_config_for_proxy, false, net_log, 0,
+      ssl_config_for_origin, ssl_config_for_proxy, false, net_log, 0, true,
       socket_handle, resolution_callback, callback);
 }
 
 int 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,
     const CompletionCallback& callback) {
   DCHECK(socket_handle);
   // Synthesize an HttpRequestInfo.
   GURL request_url = GURL("http://" + host_port_pair.ToString());
   HttpRequestHeaders request_extra_headers;
   int request_load_flags = 0;
   RequestPriority request_priority = MEDIUM;
 
   return InitSocketPoolHelper(
       request_url, request_extra_headers, request_load_flags, request_priority,
       session, proxy_info, false, false, ssl_config_for_origin,
-      ssl_config_for_proxy, true, net_log, 0, socket_handle,
+      ssl_config_for_proxy, true, net_log, 0, true, socket_handle,
       OnHostResolutionCallback(), callback);
 }
 
 int PreconnectSocketsForHttpRequest(
     const GURL& request_url,
     const HttpRequestHeaders& request_extra_headers,
     int request_load_flags,
     RequestPriority request_priority,
     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_url, request_extra_headers, request_load_flags, request_priority,
       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, OnHostResolutionCallback(),
+      num_preconnect_streams, true, NULL, OnHostResolutionCallback(),
       CompletionCallback());
 }
 
+int PretendToPreconnectSocketsForHttpRequest(
+    const GURL& request_url,
+    const HttpRequestHeaders& request_extra_headers,
+    int request_load_flags,
+    RequestPriority request_priority,
+    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_url, request_extra_headers, request_load_flags, request_priority,
+      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, false, NULL, OnHostResolutionCallback(),
+      CompletionCallback());
+}
+
 }  // namespace net