Convert ignore_limits from a SocketParam to a socket request argument.

net/http/http_proxy_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/http/http_proxy_client_socket_pool.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 33 matching lines @@
       ssl_params_(ssl_params),
       spdy_session_pool_(spdy_session_pool),
       user_agent_(user_agent),
       endpoint_(endpoint),
       http_auth_cache_(tunnel ? http_auth_cache : NULL),
       http_auth_handler_factory_(tunnel ? http_auth_handler_factory : NULL),
       tunnel_(tunnel),
       proxy_delegate_(proxy_delegate) {
   DCHECK((transport_params.get() == NULL && ssl_params.get() != NULL) ||
          (transport_params.get() != NULL && ssl_params.get() == NULL));
-  if (transport_params_.get()) {
-    ignore_limits_ = transport_params->ignore_limits();
-  } else {
-    ignore_limits_ = ssl_params->ignore_limits();
-  }
 }
 
 const HostResolver::RequestInfo& HttpProxySocketParams::destination() const {
   if (transport_params_.get() == NULL) {
     return ssl_params_->GetDirectConnectionParams()->destination();
   } else {
     return transport_params_->destination();
   }
 }
 
 HttpProxySocketParams::~HttpProxySocketParams() {}
 
 // HttpProxyConnectJobs will time out after this many seconds.  Note this is on
 // top of the timeout for the transport socket.
 // TODO(kundaji): Proxy connect timeout should be independent of platform and be
 // based on proxy. Bug http://crbug.com/407446.
 #if defined(OS_ANDROID) || defined(OS_IOS)
 static const int kHttpProxyConnectJobTimeoutInSeconds = 10;
 #else
 static const int kHttpProxyConnectJobTimeoutInSeconds = 30;
 #endif
 
 HttpProxyConnectJob::HttpProxyConnectJob(
     const std::string& group_name,
     RequestPriority priority,
+    ClientSocketPool::IgnoreLimits ignore_limits,
     const scoped_refptr<HttpProxySocketParams>& params,
     const base::TimeDelta& timeout_duration,
     TransportClientSocketPool* transport_pool,
     SSLClientSocketPool* ssl_pool,
     Delegate* delegate,
     NetLog* net_log)
     : ConnectJob(group_name,
                  base::TimeDelta() /* The socket takes care of timeouts */,
                  priority,
+                 ignore_limits,
                  delegate,
                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       client_socket_(new HttpProxyClientSocketWrapper(
           group_name,
           priority,
+          ignore_limits,
           timeout_duration,
           base::TimeDelta::FromSeconds(kHttpProxyConnectJobTimeoutInSeconds),
           transport_pool,
           ssl_pool,
           params->transport_params(),
           params->ssl_params(),
           params->user_agent(),
           params->endpoint(),
           params->http_auth_cache(),
           params->http_auth_handler_factory(),
@@ skipping 62 matching lines @@
   timeout_ = max_pool_timeout +
     base::TimeDelta::FromSeconds(kHttpProxyConnectJobTimeoutInSeconds);
 }
 
 
 scoped_ptr<ConnectJob>
 HttpProxyClientSocketPool::HttpProxyConnectJobFactory::NewConnectJob(
     const std::string& group_name,
     const PoolBase::Request& request,
     ConnectJob::Delegate* delegate) const {
-  return scoped_ptr<ConnectJob>(new HttpProxyConnectJob(group_name,
-                                                        request.priority(),
-                                                        request.params(),
-                                                        ConnectionTimeout(),
-                                                        transport_pool_,
-                                                        ssl_pool_,
-                                                        delegate,
-                                                        net_log_));
+  return scoped_ptr<ConnectJob>(new HttpProxyConnectJob(
+      group_name, request.priority(), request.ignore_limits(), request.params(),
+      ConnectionTimeout(), transport_pool_, ssl_pool_, delegate, net_log_));
 }
 
 base::TimeDelta
 HttpProxyClientSocketPool::HttpProxyConnectJobFactory::ConnectionTimeout(
     ) const {
   return timeout_;
 }
 
 HttpProxyClientSocketPool::HttpProxyClientSocketPool(
     int max_sockets,
@@ skipping 12 matching lines @@
   // We should always have a |transport_pool_| except in unit tests.
   if (transport_pool_)
     base_.AddLowerLayeredPool(transport_pool_);
   if (ssl_pool_)
     base_.AddLowerLayeredPool(ssl_pool_);
 }
 
 HttpProxyClientSocketPool::~HttpProxyClientSocketPool() {
 }
 
-int HttpProxyClientSocketPool::RequestSocket(
-    const std::string& group_name, const void* socket_params,
-    RequestPriority priority, ClientSocketHandle* handle,
-    const CompletionCallback& callback, const BoundNetLog& net_log) {
+int HttpProxyClientSocketPool::RequestSocket(const std::string& group_name,
+                                             const void* socket_params,
+                                             RequestPriority priority,
+                                             IgnoreLimits ignore_limits,
+                                             ClientSocketHandle* handle,
+                                             const CompletionCallback& callback,
+                                             const BoundNetLog& net_log) {
   const scoped_refptr<HttpProxySocketParams>* casted_socket_params =
       static_cast<const scoped_refptr<HttpProxySocketParams>*>(socket_params);
 
   return base_.RequestSocket(group_name, *casted_socket_params, priority,
-                             handle, callback, net_log);
+                             ignore_limits, handle, callback, net_log);
 }
 
 void HttpProxyClientSocketPool::RequestSockets(
     const std::string& group_name,
     const void* params,
     int num_sockets,
     const BoundNetLog& net_log) {
   const scoped_refptr<HttpProxySocketParams>* casted_params =
       static_cast<const scoped_refptr<HttpProxySocketParams>*>(params);
 
@@ skipping 74 matching lines @@
   base_.RemoveHigherLayeredPool(higher_pool);
 }
 
 bool HttpProxyClientSocketPool::CloseOneIdleConnection() {
   if (base_.CloseOneIdleSocket())
     return true;
   return base_.CloseOneIdleConnectionInHigherLayeredPool();
 }
 
 }  // namespace net