Attn: Mike Belshe

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"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "net/base/ssl_config_service.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/proxy/proxy_service.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_histograms.h"
+#include "net/socket/sctp_client_socket_pool.h"
+#include "net/socket/sctp_support.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket_pool.h"
 #include "net/socket/tcp_client_socket_pool.h"
 
 namespace net {
 
 namespace {
 
 // Total limit of sockets.
 int g_max_sockets = 256;
@@ skipping 29 matching lines @@
                          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,
                          ClientSocketHandle* socket_handle,
                          CompletionCallback* callback) {
   scoped_refptr<TCPSocketParams> tcp_params;
+  scoped_refptr<SCTPSocketParams> sctp_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;
+  if (using_ssl && sctp_enabled()) {
+    printf("InitSocketPoolHelper: forcing using_ssl = false\n");

[Mike Belshe, 2011/04/06 18:32:53]

nix this

+    using_ssl = false;
+  }
 
   HostPortPair origin_host_port =
       HostPortPair(request_info.url.HostNoBrackets(),
                    request_info.url.EffectiveIntPort());
 
   bool disable_resolver_cache =
       request_info.load_flags & LOAD_BYPASS_CACHE ||
       request_info.load_flags & LOAD_VALIDATE_CACHE ||
       request_info.load_flags & LOAD_DISABLE_CACHE;
 
   int load_flags = request_info.load_flags;
   if (HttpStreamFactory::ignore_certificate_errors())
     load_flags |= LOAD_IGNORE_ALL_CERT_ERRORS;
 
   // Build the string used to uniquely identify connections of this type.
   // Determine the host and port to connect to.
   std::string connection_group = origin_host_port.ToString();
   DCHECK(!connection_group.empty());
   if (using_ssl)
     connection_group = base::StringPrintf("ssl/%s", connection_group.c_str());
 
   bool ignore_limits = (request_info.load_flags & LOAD_IGNORE_LIMITS) != 0;
   if (proxy_info.is_direct()) {
-    tcp_params = new TCPSocketParams(origin_host_port,
-                                     request_info.priority,
-                                     request_info.referrer,
-                                     disable_resolver_cache,
-                                     ignore_limits);
+    if (sctp_enabled()) {
+      sctp_params = new SCTPSocketParams(origin_host_port,
+                                         request_info.priority,
+                                         request_info.referrer,
+                                         disable_resolver_cache,
+                                         ignore_limits);
+    } else {
+      tcp_params = new TCPSocketParams(origin_host_port,
+                                       request_info.priority,
+                                       request_info.referrer,
+                                       disable_resolver_cache,
+                                       ignore_limits);
+    }
   } else {
     ProxyServer proxy_server = proxy_info.proxy_server();
     proxy_host_port.reset(new HostPortPair(proxy_server.host_port_pair()));
     scoped_refptr<TCPSocketParams> proxy_tcp_params(
         new TCPSocketParams(*proxy_host_port,
                             request_info.priority,
                             request_info.referrer,
                             disable_resolver_cache,
                             ignore_limits));
 
@@ skipping 97 matching lines @@
       return OK;
     }
 
     return socket_handle->Init(connection_group, socks_params,
                                request_info.priority, callback, pool,
                                net_log);
   }
 
   DCHECK(proxy_info.is_direct());
 
-  TCPClientSocketPool* pool = session->tcp_socket_pool();
-  if (num_preconnect_streams) {
-    RequestSocketsForPool(pool, connection_group, tcp_params,
-                          num_preconnect_streams, net_log);
-    return OK;
+  if (sctp_enabled()) {
+    SCTPClientSocketPool* pool = session->sctp_socket_pool();
+    if (num_preconnect_streams) {
+      RequestSocketsForPool(pool, connection_group, sctp_params,
+                            num_preconnect_streams, net_log);
+      return OK;
+    }
+
+    return socket_handle->Init(connection_group, sctp_params,
+                                request_info.priority, callback,
+                                pool, net_log);
+  } else {
+    TCPClientSocketPool* pool = session->tcp_socket_pool();
+    if (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_info.priority, callback,
+                               pool, net_log);
   }
-
-  return socket_handle->Init(connection_group, tcp_params,
-                             request_info.priority, callback,
-                             pool, net_log);
 }
 
 }  // namespace
 
 ClientSocketPoolManager::ClientSocketPoolManager(
     NetLog* net_log,
     ClientSocketFactory* socket_factory,
     HostResolver* host_resolver,
     CertVerifier* cert_verifier,
     DnsRRResolver* dnsrr_resolver,
@@ skipping 10 matching lines @@
       ssl_host_info_factory_(ssl_host_info_factory),
       proxy_service_(proxy_service),
       ssl_config_service_(ssl_config_service),
       tcp_pool_histograms_("TCP"),
       tcp_socket_pool_(new TCPClientSocketPool(
           g_max_sockets, g_max_sockets_per_group,
           &tcp_pool_histograms_,
           host_resolver,
           socket_factory_,
           net_log)),
+      sctp_pool_histograms_("SCTP"),
+      sctp_socket_pool_(new SCTPClientSocketPool(
+          g_max_sockets, g_max_sockets_per_group,
+          &sctp_pool_histograms_,
+          host_resolver,
+          socket_factory_,
+          net_log)),
       ssl_pool_histograms_("SSL2"),
       ssl_socket_pool_(new SSLClientSocketPool(
           g_max_sockets, g_max_sockets_per_group,
           &ssl_pool_histograms_,
           host_resolver,
           cert_verifier,
           dnsrr_resolver,
           dns_cert_checker,
           ssl_host_info_factory,
           socket_factory,
@@ skipping 255 matching lines @@
 int ClientSocketPoolManager::max_sockets_per_group() {
   return g_max_sockets_per_group;
 }
 
 // static
 void ClientSocketPoolManager::set_max_sockets_per_group(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;
+  // TODO(jtl): Remove this - it's only used for testing SCTP.
+  g_max_sockets_per_group = 1;

[Mike Belshe, 2011/04/06 18:32:53]

can this be 

  if (sctp_enabled())
    g_max_sockets_per_group = 1;

 
   DCHECK_GE(g_max_sockets, g_max_sockets_per_group);
   DCHECK_GE(g_max_sockets_per_proxy_server, g_max_sockets_per_group);
 }
 
 // static
 void ClientSocketPoolManager::set_max_sockets_per_proxy_server(
     int socket_count) {
   DCHECK_LT(0, socket_count);
   DCHECK_GT(100, socket_count);  // Sanity check.
@@ skipping 107 matching lines @@
                               ssl_config_for_origin,
                               ssl_config_for_proxy,
                               net_log,
                               num_preconnect_streams,
                               NULL,
                               NULL);
 }
 
 
 }  // namespace net