Convert ignore_limits from a SocketParam to a socket request argument.

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/logging.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_factory.h"
 #include "net/proxy/proxy_info.h"
 #include "net/socket/client_socket_handle.h"
+#include "net/socket/client_socket_pool.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"
 #include "net/ssl/ssl_config.h"
 
 namespace net {
 
 namespace {
 
 // Limit of sockets of each socket pool.
@@ skipping 114 matching lines @@
           break;
       }
     }
     // Place sockets with and without deprecated ciphers into separate
     // connection groups.
     if (ssl_config_for_origin.deprecated_cipher_suites_enabled)
       prefix += "deprecatedciphers/";
     connection_group = prefix + connection_group;
   }
 
-  bool ignore_limits = (request_load_flags & LOAD_IGNORE_LIMITS) != 0;
+  ClientSocketPool::RespectLimits respect_limits =
+      ClientSocketPool::RespectLimits::ENABLED;
+  if ((request_load_flags & LOAD_IGNORE_LIMITS) != 0)
+    respect_limits = ClientSocketPool::RespectLimits::DISABLED;
   if (!proxy_info.is_direct()) {
     ProxyServer proxy_server = proxy_info.proxy_server();
     proxy_host_port.reset(new HostPortPair(proxy_server.host_port_pair()));
     scoped_refptr<TransportSocketParams> proxy_tcp_params(
         new TransportSocketParams(
             *proxy_host_port,
             disable_resolver_cache,
-            ignore_limits,
             resolution_callback,
             TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
 
     if (proxy_info.is_http() || proxy_info.is_https()) {
       std::string user_agent;
       request_extra_headers.GetHeader(HttpRequestHeaders::kUserAgent,
                                       &user_agent);
       scoped_refptr<SSLSocketParams> ssl_params;
       if (proxy_info.is_https()) {
         // Combine connect and write for SSL sockets in TCP FastOpen
         // field trial.
         TransportSocketParams::CombineConnectAndWritePolicy
             combine_connect_and_write =
                 session->params().enable_tcp_fast_open_for_ssl ?
                     TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DESIRED :
                     TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT;
         proxy_tcp_params = new TransportSocketParams(*proxy_host_port,
                                                      disable_resolver_cache,
-                                                     ignore_limits,
                                                      resolution_callback,
                                                      combine_connect_and_write);
         // Set ssl_params, and unset proxy_tcp_params
         ssl_params =
             new SSLSocketParams(proxy_tcp_params, NULL, NULL,
                                 *proxy_host_port.get(), ssl_config_for_proxy,
                                 PRIVACY_MODE_DISABLED, load_flags, expect_spdy);
         proxy_tcp_params = NULL;
       }
 
@@ skipping 33 matching lines @@
     if (proxy_info.is_direct()) {
       // Setup TCP params if non-proxied SSL connection.
       // Combine connect and write for SSL sockets in TCP FastOpen field trial.
       TransportSocketParams::CombineConnectAndWritePolicy
           combine_connect_and_write =
               session->params().enable_tcp_fast_open_for_ssl ?
                   TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DESIRED :
                   TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT;
       ssl_tcp_params = new TransportSocketParams(origin_host_port,
                                                  disable_resolver_cache,
-                                                 ignore_limits,
                                                  resolution_callback,
                                                  combine_connect_and_write);
     }
     scoped_refptr<SSLSocketParams> ssl_params = new SSLSocketParams(
         ssl_tcp_params, socks_params, http_proxy_params, origin_host_port,
         ssl_config_for_origin, privacy_mode, load_flags, expect_spdy);
     SSLClientSocketPool* ssl_pool = NULL;
     if (proxy_info.is_direct()) {
       ssl_pool = session->GetSSLSocketPool(socket_pool_type);
     } else {
       ssl_pool = session->GetSocketPoolForSSLWithProxy(socket_pool_type,
                                                        *proxy_host_port);
     }
 
     if (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);
+    return socket_handle->Init(connection_group, ssl_params, request_priority,
+                               respect_limits, callback, ssl_pool, net_log);
   }
 
   // Finally, get the connection started.
 
   if (proxy_info.is_http() || proxy_info.is_https()) {
     HttpProxyClientSocketPool* pool =
         session->GetSocketPoolForHTTPProxy(socket_pool_type, *proxy_host_port);
     if (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);
+                               request_priority, respect_limits, callback, pool,
+                               net_log);
   }
 
   if (proxy_info.is_socks()) {
     SOCKSClientSocketPool* pool =
         session->GetSocketPoolForSOCKSProxy(socket_pool_type, *proxy_host_port);
     if (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);
+    return socket_handle->Init(connection_group, socks_params, request_priority,
+                               respect_limits, callback, pool, net_log);
   }
 
   DCHECK(proxy_info.is_direct());
   scoped_refptr<TransportSocketParams> tcp_params =
       new TransportSocketParams(
           origin_host_port,
           disable_resolver_cache,
-          ignore_limits,
           resolution_callback,
           TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT);
   TransportClientSocketPool* pool =
       session->GetTransportSocketPool(socket_pool_type);
   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_priority, callback,
-                             pool, net_log);
+  return socket_handle->Init(connection_group, tcp_params, request_priority,
+                             respect_limits, callback, pool, net_log);
 }
 
 }  // namespace
 
 ClientSocketPoolManager::ClientSocketPoolManager() {}
 ClientSocketPoolManager::~ClientSocketPoolManager() {}
 
 // static
 int ClientSocketPoolManager::max_sockets_per_pool(
     HttpNetworkSession::SocketPoolType pool_type) {
@@ skipping 167 matching lines @@
     int num_preconnect_streams) {
   return InitSocketPoolHelper(
       group_type, endpoint, request_extra_headers, request_load_flags,
       request_priority, session, proxy_info, expect_spdy, ssl_config_for_origin,
       ssl_config_for_proxy, /*force_tunnel=*/false, privacy_mode, net_log,
       num_preconnect_streams, NULL, HttpNetworkSession::NORMAL_SOCKET_POOL,
       OnHostResolutionCallback(), CompletionCallback());
 }
 
 }  // namespace net