Increase number of max sockets per group for WebSocket connections.

This change makes ClientSocketPoolManager aware of SocketPoolType so it can
pick a different limit for normal socket pools and WebSocket socket pools.

As an initial (experimental) setting, number of max sockets per group for
WebSocket connections is raised to 30, and other limits are set to the same
value as normal socket pools. This configuration should be revisited later
when WebSocket protocol stack starts to work and a good amount of usage metrics
are collected.

BUG=118268
TEST=none


Review URL: http://codereview.chromium.org/9764003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@128044 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 107 insertions, 45 deletions

diff --git a/net/socket/client_socket_pool_manager.cc b/net/socket/client_socket_pool_manager.cc
index 2cfcffdf..20b02f4 100644
--- a/net/socket/client_socket_pool_manager.cc
+++ b/net/socket/client_socket_pool_manager.cc
@@ -6,10 +6,10 @@
 
 #include <string>
 
+#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "net/base/load_flags.h"
-#include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_factory.h"
@@ -24,17 +24,45 @@ namespace net {
 namespace {
 
 // Limit of sockets of each socket pool.
-int g_max_sockets_per_pool = 256;
+int g_max_sockets_per_pool[] = {
+  256,  // NORMAL_SOCKET_POOL
+  256   // WEBSOCKET_SOCKET_POOL
+};
+
+COMPILE_ASSERT(arraysize(g_max_sockets_per_pool) ==
+                   HttpNetworkSession::NUM_SOCKET_POOL_TYPES,
+               max_sockets_per_pool_length_mismatch);
 
 // Default to allow up to 6 connections per host. Experiment and tuning may
 // try other values (greater than 0).  Too large may cause many problems, such
 // as home routers blocking the connections!?!?  See http://crbug.com/12066.
-int g_max_sockets_per_group = 6;
+//
+// WebSocket connections are long-lived, and should be treated differently
+// than normal other connections. 6 connections per group sounded too small
+// for such use, thus we use a larger limit which was determined somewhat
+// arbitrarily.
+// TODO(yutak): Look at the usage and determine the right value after
+// WebSocket protocol stack starts to work.
+int g_max_sockets_per_group[] = {
+  6,  // NORMAL_SOCKET_POOL
+  30  // WEBSOCKET_SOCKET_POOL
+};
+
+COMPILE_ASSERT(arraysize(g_max_sockets_per_group) ==
+                   HttpNetworkSession::NUM_SOCKET_POOL_TYPES,
+               max_sockets_per_group_length_mismatch);
 
 // The max number of sockets to allow per proxy server.  This applies both to
 // http and SOCKS proxies.  See http://crbug.com/12066 and
 // http://crbug.com/44501 for details about proxy server connection limits.
-int g_max_sockets_per_proxy_server = kDefaultMaxSocketsPerProxyServer;
+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);
 
 // The meat of the implementation for the InitSocketHandleForHttpRequest,
 // InitSocketHandleForRawConnect and PreconnectSocketsForHttpRequest methods.
@@ -188,6 +216,7 @@ int InitSocketPoolHelper(const GURL& request_url,
   }
 
   // Finally, get the connection started.
+
   if (proxy_info.is_http() || proxy_info.is_https()) {
     HttpProxyClientSocketPool* pool =
         session->GetSocketPoolForHTTPProxy(
@@ -241,48 +270,65 @@ ClientSocketPoolManager::ClientSocketPoolManager() {}
 ClientSocketPoolManager::~ClientSocketPoolManager() {}
 
 // static
-int ClientSocketPoolManager::max_sockets_per_pool() {
-  return g_max_sockets_per_pool;
+int ClientSocketPoolManager::max_sockets_per_pool(
+    HttpNetworkSession::SocketPoolType pool_type) {
+  DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
+  return g_max_sockets_per_pool[pool_type];
 }
 
 // static
-void ClientSocketPoolManager::set_max_sockets_per_pool(int socket_count) {
+void ClientSocketPoolManager::set_max_sockets_per_pool(
+    HttpNetworkSession::SocketPoolType pool_type,
+    int socket_count) {
   DCHECK_LT(0, socket_count);
   DCHECK_GT(1000, socket_count);  // Sanity check.
-  g_max_sockets_per_pool = socket_count;
-  DCHECK_GE(g_max_sockets_per_pool, g_max_sockets_per_group);
+  DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
+  g_max_sockets_per_pool[pool_type] = socket_count;
+  DCHECK_GE(g_max_sockets_per_pool[pool_type],
+            g_max_sockets_per_group[pool_type]);
 }
 
 // static
-int ClientSocketPoolManager::max_sockets_per_group() {
-  return g_max_sockets_per_group;
+int ClientSocketPoolManager::max_sockets_per_group(
+    HttpNetworkSession::SocketPoolType pool_type) {
+  DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
+  return g_max_sockets_per_group[pool_type];
 }
 
 // static
-void ClientSocketPoolManager::set_max_sockets_per_group(int socket_count) {
+void ClientSocketPoolManager::set_max_sockets_per_group(
+    HttpNetworkSession::SocketPoolType pool_type,
+    int socket_count) {
   DCHECK_LT(0, socket_count);
   // The following is a sanity check... but we should NEVER be near this value.
   DCHECK_GT(100, socket_count);
-  g_max_sockets_per_group = socket_count;
+  DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
+  g_max_sockets_per_group[pool_type] = socket_count;
 
-  DCHECK_GE(g_max_sockets_per_pool, g_max_sockets_per_group);
-  DCHECK_GE(g_max_sockets_per_proxy_server, g_max_sockets_per_group);
+  DCHECK_GE(g_max_sockets_per_pool[pool_type],
+            g_max_sockets_per_group[pool_type]);
+  DCHECK_GE(g_max_sockets_per_proxy_server[pool_type],
+            g_max_sockets_per_group[pool_type]);
 }
 
 // static
-int ClientSocketPoolManager::max_sockets_per_proxy_server() {
-  return g_max_sockets_per_proxy_server;
+int ClientSocketPoolManager::max_sockets_per_proxy_server(
+    HttpNetworkSession::SocketPoolType pool_type) {
+  DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
+  return g_max_sockets_per_proxy_server[pool_type];
 }
 
 // static
 void ClientSocketPoolManager::set_max_sockets_per_proxy_server(
+    HttpNetworkSession::SocketPoolType pool_type,
     int socket_count) {
   DCHECK_LT(0, socket_count);
   DCHECK_GT(100, socket_count);  // Sanity check.
+  DCHECK_LT(pool_type, HttpNetworkSession::NUM_SOCKET_POOL_TYPES);
   // Assert this case early on. The max number of sockets per group cannot
   // exceed the max number of sockets per proxy server.
-  DCHECK_LE(g_max_sockets_per_group, socket_count);
-  g_max_sockets_per_proxy_server = socket_count;
+  DCHECK_LE(g_max_sockets_per_group[pool_type], socket_count);
+  g_max_sockets_per_proxy_server[pool_type] = socket_count;
 }
 
 int InitSocketHandleForHttpRequest(
diff --git a/net/socket/client_socket_pool_manager.h b/net/socket/client_socket_pool_manager.h
index 7c1f865..5175de9 100644
--- a/net/socket/client_socket_pool_manager.h
+++ b/net/socket/client_socket_pool_manager.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 //
@@ -13,6 +13,7 @@
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/base/request_priority.h"
+#include "net/http/http_network_session.h"
 
 class GURL;
 
@@ -47,14 +48,22 @@ class NET_EXPORT_PRIVATE ClientSocketPoolManager {
   // The setter methods below affect only newly created socket pools after the
   // methods are called. Normally they should be called at program startup
   // before any ClientSocketPoolManagerImpl is created.
-  static int max_sockets_per_pool();
-  static void set_max_sockets_per_pool(int socket_count);
-
-  static int max_sockets_per_group();
-  static void set_max_sockets_per_group(int socket_count);
-
-  static int max_sockets_per_proxy_server();
-  static void set_max_sockets_per_proxy_server(int socket_count);
+  static int max_sockets_per_pool(HttpNetworkSession::SocketPoolType pool_type);
+  static void set_max_sockets_per_pool(
+      HttpNetworkSession::SocketPoolType pool_type,
+      int socket_count);
+
+  static int max_sockets_per_group(
+      HttpNetworkSession::SocketPoolType pool_type);
+  static void set_max_sockets_per_group(
+      HttpNetworkSession::SocketPoolType pool_type,
+      int socket_count);
+
+  static int max_sockets_per_proxy_server(
+      HttpNetworkSession::SocketPoolType pool_type);
+  static void set_max_sockets_per_proxy_server(
+      HttpNetworkSession::SocketPoolType pool_type,
+      int socket_count);
 
   virtual void FlushSocketPools() = 0;
   virtual void CloseIdleSockets() = 0;
diff --git a/net/socket/client_socket_pool_manager_impl.cc b/net/socket/client_socket_pool_manager_impl.cc
index ccd3965..2124cc7 100644
--- a/net/socket/client_socket_pool_manager_impl.cc
+++ b/net/socket/client_socket_pool_manager_impl.cc
@@ -8,6 +8,7 @@
 #include "base/values.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_proxy_client_socket_pool.h"
+#include "net/http/http_network_session.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket_pool.h"
 #include "net/socket/transport_client_socket_pool.h"
@@ -42,7 +43,8 @@ ClientSocketPoolManagerImpl::ClientSocketPoolManagerImpl(
     SSLHostInfoFactory* ssl_host_info_factory,
     const std::string& ssl_session_cache_shard,
     ProxyService* proxy_service,
-    SSLConfigService* ssl_config_service)
+    SSLConfigService* ssl_config_service,
+    HttpNetworkSession::SocketPoolType pool_type)
     : net_log_(net_log),
       socket_factory_(socket_factory),
       host_resolver_(host_resolver),
@@ -53,16 +55,17 @@ ClientSocketPoolManagerImpl::ClientSocketPoolManagerImpl(
       ssl_session_cache_shard_(ssl_session_cache_shard),
       proxy_service_(proxy_service),
       ssl_config_service_(ssl_config_service),
+      pool_type_(pool_type),
       transport_pool_histograms_("TCP"),
       transport_socket_pool_(new TransportClientSocketPool(
-          max_sockets_per_pool(), max_sockets_per_group(),
+          max_sockets_per_pool(pool_type), max_sockets_per_group(pool_type),
           &transport_pool_histograms_,
           host_resolver,
           socket_factory_,
           net_log)),
       ssl_pool_histograms_("SSL2"),
       ssl_socket_pool_(new SSLClientSocketPool(
-          max_sockets_per_pool(), max_sockets_per_group(),
+          max_sockets_per_pool(pool_type), max_sockets_per_group(pool_type),
           &ssl_pool_histograms_,
           host_resolver,
           cert_verifier,
@@ -213,8 +216,8 @@ SOCKSClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSOCKSProxy(
           std::make_pair(
               socks_proxy,
               new TransportClientSocketPool(
-                  max_sockets_per_proxy_server(),
-                  max_sockets_per_group(),
+                  max_sockets_per_proxy_server(pool_type_),
+                  max_sockets_per_group(pool_type_),
                   &transport_for_socks_pool_histograms_,
                   host_resolver_,
                   socket_factory_,
@@ -224,8 +227,8 @@ SOCKSClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSOCKSProxy(
   std::pair<SOCKSSocketPoolMap::iterator, bool> ret =
       socks_socket_pools_.insert(
           std::make_pair(socks_proxy, new SOCKSClientSocketPool(
-              max_sockets_per_proxy_server(),
-              max_sockets_per_group(),
+              max_sockets_per_proxy_server(pool_type_),
+              max_sockets_per_group(pool_type_),
               &socks_pool_histograms_,
               host_resolver_,
               tcp_ret.first->second,
@@ -255,8 +258,8 @@ ClientSocketPoolManagerImpl::GetSocketPoolForHTTPProxy(
           std::make_pair(
               http_proxy,
               new TransportClientSocketPool(
-                  max_sockets_per_proxy_server(),
-                  max_sockets_per_group(),
+                  max_sockets_per_proxy_server(pool_type_),
+                  max_sockets_per_group(pool_type_),
                   &transport_for_http_proxy_pool_histograms_,
                   host_resolver_,
                   socket_factory_,
@@ -268,8 +271,8 @@ ClientSocketPoolManagerImpl::GetSocketPoolForHTTPProxy(
           std::make_pair(
               http_proxy,
               new TransportClientSocketPool(
-                  max_sockets_per_proxy_server(),
-                  max_sockets_per_group(),
+                  max_sockets_per_proxy_server(pool_type_),
+                  max_sockets_per_group(pool_type_),
                   &transport_for_https_proxy_pool_histograms_,
                   host_resolver_,
                   socket_factory_,
@@ -281,8 +284,8 @@ ClientSocketPoolManagerImpl::GetSocketPoolForHTTPProxy(
           std::make_pair(
               http_proxy,
               new SSLClientSocketPool(
-                  max_sockets_per_proxy_server(),
-                  max_sockets_per_group(),
+                  max_sockets_per_proxy_server(pool_type_),
+                  max_sockets_per_group(pool_type_),
                   &ssl_for_https_proxy_pool_histograms_,
                   host_resolver_,
                   cert_verifier_,
@@ -302,8 +305,8 @@ ClientSocketPoolManagerImpl::GetSocketPoolForHTTPProxy(
           std::make_pair(
               http_proxy,
               new HttpProxyClientSocketPool(
-                  max_sockets_per_proxy_server(),
-                  max_sockets_per_group(),
+                  max_sockets_per_proxy_server(pool_type_),
+                  max_sockets_per_group(pool_type_),
                   &http_proxy_pool_histograms_,
                   host_resolver_,
                   tcp_http_ret.first->second,
@@ -321,7 +324,8 @@ SSLClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSSLWithProxy(
     return it->second;
 
   SSLClientSocketPool* new_pool = new SSLClientSocketPool(
-      max_sockets_per_proxy_server(), max_sockets_per_group(),
+      max_sockets_per_proxy_server(pool_type_),
+      max_sockets_per_group(pool_type_),
       &ssl_pool_histograms_,
       host_resolver_,
       cert_verifier_,
diff --git a/net/socket/client_socket_pool_manager_impl.h b/net/socket/client_socket_pool_manager_impl.h
index 2559aad..eff1a36 100644
--- a/net/socket/client_socket_pool_manager_impl.h
+++ b/net/socket/client_socket_pool_manager_impl.h
@@ -15,6 +15,7 @@
 #include "base/template_util.h"
 #include "base/threading/non_thread_safe.h"
 #include "net/base/cert_database.h"
+#include "net/http/http_network_session.h"
 #include "net/socket/client_socket_pool_histograms.h"
 #include "net/socket/client_socket_pool_manager.h"
 
@@ -66,7 +67,8 @@ class ClientSocketPoolManagerImpl : public base::NonThreadSafe,
                               SSLHostInfoFactory* ssl_host_info_factory,
                               const std::string& ssl_session_cache_shard,
                               ProxyService* proxy_service,
-                              SSLConfigService* ssl_config_service);
+                              SSLConfigService* ssl_config_service,
+                              HttpNetworkSession::SocketPoolType pool_type);
   virtual ~ClientSocketPoolManagerImpl();
 
   virtual void FlushSocketPools() OVERRIDE;
@@ -113,6 +115,7 @@ class ClientSocketPoolManagerImpl : public base::NonThreadSafe,
   const std::string ssl_session_cache_shard_;
   ProxyService* const proxy_service_;
   const scoped_refptr<SSLConfigService> ssl_config_service_;
+  const HttpNetworkSession::SocketPoolType pool_type_;
 
   // Note: this ordering is important.