Convert ignore_limits from a SocketParam to a socket request argument.

net/socket/websocket_transport_client_socket_pool.cc

 // Copyright 2014 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/websocket_transport_client_socket_pool.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 21 matching lines @@
 // TODO(ricea): For now, we implement a global timeout for compatability with
 // TransportConnectJob. Since WebSocketTransportConnectJob controls the address
 // selection process more tightly, it could do something smarter here.
 const int kTransportConnectJobTimeoutInSeconds = 240;  // 4 minutes.
 
 }  // namespace
 
 WebSocketTransportConnectJob::WebSocketTransportConnectJob(
     const std::string& group_name,
     RequestPriority priority,
+    bool ignore_limits,
     const scoped_refptr<TransportSocketParams>& params,
     TimeDelta timeout_duration,
     const CompletionCallback& callback,
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     ClientSocketHandle* handle,
     Delegate* delegate,
     NetLog* pool_net_log,
     const BoundNetLog& request_net_log)
     : ConnectJob(group_name,
                  timeout_duration,
                  priority,
+                 ignore_limits,
                  delegate,
                  BoundNetLog::Make(pool_net_log, NetLog::SOURCE_CONNECT_JOB)),
       helper_(params, client_socket_factory, host_resolver, &connect_timing_),
       race_result_(TransportConnectJobHelper::CONNECTION_LATENCY_UNKNOWN),
       handle_(handle),
       callback_(callback),
       request_net_log_(request_net_log),
       had_ipv4_(false),
       had_ipv6_(false) {
   helper_.SetOnIOComplete(this);
@@ skipping 201 matching lines @@
   DCHECK(handle->socket());
   IPEndPoint address;
   if (handle->socket()->GetPeerAddress(&address) == OK)
     WebSocketEndpointLockManager::GetInstance()->UnlockEndpoint(address);
 }
 
 int WebSocketTransportClientSocketPool::RequestSocket(
     const std::string& group_name,
     const void* params,
     RequestPriority priority,
+    bool ignore_limits,
     ClientSocketHandle* handle,
     const CompletionCallback& callback,
     const BoundNetLog& request_net_log) {
   DCHECK(params);
   const scoped_refptr<TransportSocketParams>& casted_params =
       *static_cast<const scoped_refptr<TransportSocketParams>*>(params);
 
   NetLogTcpClientSocketPoolRequestedSocket(request_net_log, &casted_params);
 
   CHECK(!callback.is_null());
   CHECK(handle);
 
   request_net_log.BeginEvent(NetLog::TYPE_SOCKET_POOL);
 
-  if (ReachedMaxSocketsLimit() && !casted_params->ignore_limits()) {
+  if (ReachedMaxSocketsLimit() && !ignore_limits) {
     request_net_log.AddEvent(NetLog::TYPE_SOCKET_POOL_STALLED_MAX_SOCKETS);
     // TODO(ricea): Use emplace_back when C++11 becomes allowed.
     StalledRequest request(
         casted_params, priority, handle, callback, request_net_log);
     stalled_request_queue_.push_back(request);
     StalledRequestQueue::iterator iterator = stalled_request_queue_.end();
     --iterator;
     DCHECK_EQ(handle, iterator->handle);
     // Because StalledRequestQueue is a std::list, its iterators are guaranteed
     // to remain valid as long as the elements are not removed. As long as
     // stalled_request_queue_ and stalled_request_map_ are updated in sync, it
     // is safe to dereference an iterator in stalled_request_map_ to find the
     // corresponding list element.
     stalled_request_map_.insert(
         StalledRequestMap::value_type(handle, iterator));
     return ERR_IO_PENDING;
   }
 
   scoped_ptr<WebSocketTransportConnectJob> connect_job(
-      new WebSocketTransportConnectJob(group_name,
-                                       priority,
-                                       casted_params,
-                                       ConnectionTimeout(),
-                                       callback,
-                                       client_socket_factory_,
-                                       host_resolver_,
-                                       handle,
-                                       &connect_job_delegate_,
-                                       pool_net_log_,
-                                       request_net_log));
+      new WebSocketTransportConnectJob(
+          group_name, priority, ignore_limits, casted_params,
+          ConnectionTimeout(), callback, client_socket_factory_, host_resolver_,
+          handle, &connect_job_delegate_, pool_net_log_, request_net_log));
 
   int rv = connect_job->Connect();
   // Regardless of the outcome of |connect_job|, it will always be bound to
   // |handle|, since this pool uses early-binding. So the binding is logged
   // here, without waiting for the result.
   request_net_log.AddEvent(
       NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
       connect_job->net_log().source().ToEventParametersCallback());
   if (rv == OK) {
     HandOutSocket(connect_job->PassSocket(),
@@ skipping 252 matching lines @@
 void WebSocketTransportClientSocketPool::ActivateStalledRequest() {
   DCHECK(!stalled_request_queue_.empty());
   DCHECK(!ReachedMaxSocketsLimit());
   // Usually we will only be able to activate one stalled request at a time,
   // however if all the connects fail synchronously for some reason, we may be
   // able to clear the whole queue at once.
   while (!stalled_request_queue_.empty() && !ReachedMaxSocketsLimit()) {
     StalledRequest request(stalled_request_queue_.front());
     stalled_request_queue_.pop_front();
     stalled_request_map_.erase(request.handle);
-    int rv = RequestSocket("ignored",
-                           &request.params,
-                           request.priority,
-                           request.handle,
-                           request.callback,
-                           request.net_log);
+    int rv =
+        RequestSocket("ignored", &request.params, request.priority,
+                      // stalled requests can't have |ignore_limits| set.
+                      false, request.handle, request.callback, request.net_log);
     // ActivateStalledRequest() never returns synchronously, so it is never
     // called re-entrantly.
     if (rv != ERR_IO_PENDING)
       InvokeUserCallbackLater(request.handle, request.callback, rv);
   }
 }
 
 bool WebSocketTransportClientSocketPool::DeleteStalledRequest(
     ClientSocketHandle* handle) {
   StalledRequestMap::iterator it = stalled_request_map_.find(handle);
@@ skipping 26 matching lines @@
     const BoundNetLog& net_log)
     : params(params),
       priority(priority),
       handle(handle),
       callback(callback),
       net_log(net_log) {}
 
 WebSocketTransportClientSocketPool::StalledRequest::~StalledRequest() {}
 
 }  // namespace net