Convert ignore_limits from a SocketParam to a socket request argument.

net/socket/transport_client_socket_pool.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/transport_client_socket_pool.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 43 matching lines @@
 static base::LazyInstance<base::Lock>::Leaky
     g_last_connect_time_lock = LAZY_INSTANCE_INITIALIZER;
 
 // |g_last_connect_time| has the last time a connect() call is made.
 static base::LazyInstance<base::TimeTicks>::Leaky
     g_last_connect_time = LAZY_INSTANCE_INITIALIZER;
 
 TransportSocketParams::TransportSocketParams(
     const HostPortPair& host_port_pair,
     bool disable_resolver_cache,
-    bool ignore_limits,
     const OnHostResolutionCallback& host_resolution_callback,
     CombineConnectAndWritePolicy combine_connect_and_write_if_supported)
     : destination_(host_port_pair),
-      ignore_limits_(ignore_limits),
       host_resolution_callback_(host_resolution_callback),
       combine_connect_and_write_(combine_connect_and_write_if_supported) {
   if (disable_resolver_cache)
     destination_.set_allow_cached_response(false);
   // combine_connect_and_write currently translates to TCP FastOpen.
   // Enable TCP FastOpen if user wants it.
   if (combine_connect_and_write_ == COMBINE_CONNECT_AND_WRITE_DEFAULT) {
     IsTCPFastOpenUserEnabled() ? combine_connect_and_write_ =
         COMBINE_CONNECT_AND_WRITE_DESIRED :
         COMBINE_CONNECT_AND_WRITE_PROHIBITED;
@@ skipping 110 matching lines @@
       NOTREACHED();
       break;
   }
 
   return connect_duration;
 }
 
 TransportConnectJob::TransportConnectJob(
     const std::string& group_name,
     RequestPriority priority,
+    ClientSocketPool::IgnoreLimits ignore_limits,
     const scoped_refptr<TransportSocketParams>& params,
     base::TimeDelta timeout_duration,
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     Delegate* delegate,
     NetLog* net_log)
     : ConnectJob(group_name,
                  timeout_duration,
                  priority,
+                 ignore_limits,
                  delegate,
                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       helper_(params, client_socket_factory, host_resolver, &connect_timing_),
       interval_between_connects_(CONNECT_INTERVAL_GT_20MS),
       resolve_result_(OK) {
   helper_.SetOnIOComplete(this);
 }
 
 TransportConnectJob::~TransportConnectJob() {
   // We don't worry about cancelling the host resolution and TCP connect, since
@@ skipping 262 matching lines @@
     fallback_transport_socket_->GetConnectionAttempts(
         &fallback_connection_attempts_);
   }
 }
 
 scoped_ptr<ConnectJob>
 TransportClientSocketPool::TransportConnectJobFactory::NewConnectJob(
     const std::string& group_name,
     const PoolBase::Request& request,
     ConnectJob::Delegate* delegate) const {
-  return scoped_ptr<ConnectJob>(
-      new TransportConnectJob(group_name,
-                              request.priority(),
-                              request.params(),
-                              ConnectionTimeout(),
-                              client_socket_factory_,
-                              host_resolver_,
-                              delegate,
-                              net_log_));
+  return scoped_ptr<ConnectJob>(new TransportConnectJob(
+      group_name, request.priority(), request.ignore_limits(), request.params(),
+      ConnectionTimeout(), client_socket_factory_, host_resolver_, delegate,
+      net_log_));
 }
 
 base::TimeDelta
     TransportClientSocketPool::TransportConnectJobFactory::ConnectionTimeout()
     const {
   return base::TimeDelta::FromSeconds(kTransportConnectJobTimeoutInSeconds);
 }
 
 TransportClientSocketPool::TransportClientSocketPool(
     int max_sockets,
     int max_sockets_per_group,
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
     NetLog* net_log)
     : base_(NULL,
             max_sockets,
             max_sockets_per_group,
             ClientSocketPool::unused_idle_socket_timeout(),
             ClientSocketPool::used_idle_socket_timeout(),
             new TransportConnectJobFactory(client_socket_factory,
                                            host_resolver,
                                            net_log)) {
   base_.EnableConnectBackupJobs();
 }
 
 TransportClientSocketPool::~TransportClientSocketPool() {}
 
-int TransportClientSocketPool::RequestSocket(
-    const std::string& group_name,
-    const void* params,
-    RequestPriority priority,
-    ClientSocketHandle* handle,
-    const CompletionCallback& callback,
-    const BoundNetLog& net_log) {
+int TransportClientSocketPool::RequestSocket(const std::string& group_name,
+                                             const void* params,
+                                             RequestPriority priority,
+                                             IgnoreLimits ignore_limits,
+                                             ClientSocketHandle* handle,
+                                             const CompletionCallback& callback,
+                                             const BoundNetLog& net_log) {
   const scoped_refptr<TransportSocketParams>* casted_params =
       static_cast<const scoped_refptr<TransportSocketParams>*>(params);
 
   NetLogTcpClientSocketPoolRequestedSocket(net_log, casted_params);
 
-  return base_.RequestSocket(group_name, *casted_params, priority, handle,
-                             callback, net_log);
+  return base_.RequestSocket(group_name, *casted_params, priority,
+                             ignore_limits, handle, callback, net_log);
 }
 
 void TransportClientSocketPool::NetLogTcpClientSocketPoolRequestedSocket(
     const BoundNetLog& net_log,
     const scoped_refptr<TransportSocketParams>* casted_params) {
   if (net_log.IsCapturing()) {
     // TODO(eroman): Split out the host and port parameters.
     net_log.AddEvent(
         NetLog::TYPE_TCP_CLIENT_SOCKET_POOL_REQUESTED_SOCKET,
         CreateNetLogHostPortPairCallback(
@@ skipping 74 matching lines @@
     HigherLayeredPool* higher_pool) {
   base_.AddHigherLayeredPool(higher_pool);
 }
 
 void TransportClientSocketPool::RemoveHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   base_.RemoveHigherLayeredPool(higher_pool);
 }
 
 }  // namespace net