Convert ignore_limits from a SocketParam to a socket request argument.

net/socket/client_socket_handle.h

 // 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.
 
 #ifndef NET_SOCKET_CLIENT_SOCKET_HANDLE_H_
 #define NET_SOCKET_CLIENT_SOCKET_HANDLE_H_
 
 #include <string>
 
 #include "base/logging.h"
@@ skipping 32 matching lines @@
     NUM_TYPES,
   };
 
   ClientSocketHandle();
   ~ClientSocketHandle();
 
   // Initializes a ClientSocketHandle object, which involves talking to the
   // ClientSocketPool to obtain a connected socket, possibly reusing one.  This
   // method returns either OK or ERR_IO_PENDING.  On ERR_IO_PENDING, |priority|
   // is used to determine the placement in ClientSocketPool's wait list.
+  // |ignore_limits| will bypass the wait list, if true, but |priority| must

[eroman, 2016/01/27 20:15:12]

Update comment (ignore_limits is no longer a boolean)

[mmenke, 2016/01/28 15:55:12]

And just for the record, I've fixed this (And updated all reference to
ignore_limits in other methods as well).

+  // also be HIGHEST, if set.
   //
   // If this method succeeds, then the socket member will be set to an existing
   // connected socket if an existing connected socket was available to reuse,
   // otherwise it will be set to a new connected socket.  Consumers can then
   // call is_reused() to see if the socket was reused.  If not reusing an
   // existing socket, ClientSocketPool may need to establish a new
   // connection using |socket_params|.
   //
   // This method returns ERR_IO_PENDING if it cannot complete synchronously, in
   // which case the consumer will be notified of completion via |callback|.
   //
   // If the pool was not able to reuse an existing socket, the new socket
   // may report a recoverable error.  In this case, the return value will
   // indicate an error and the socket member will be set.  If it is determined
   // that the error is not recoverable, the Disconnect method should be used
   // on the socket, so that it does not get reused.
   //
   // A non-recoverable error may set additional state in the ClientSocketHandle
   // to allow the caller to determine what went wrong.
   //
   // Init may be called multiple times.
   //
   // Profiling information for the request is saved to |net_log| if non-NULL.
   //
   template <typename PoolType>
   int Init(const std::string& group_name,
            const scoped_refptr<typename PoolType::SocketParams>& socket_params,
            RequestPriority priority,
+           ClientSocketPool::IgnoreLimits ignore_limits,
            const CompletionCallback& callback,
            PoolType* pool,
            const BoundNetLog& net_log);
 
   // An initialized handle can be reset, which causes it to return to the
   // un-initialized state.  This releases the underlying socket, which in the
   // case of a socket that still has an established connection, indicates that
   // the socket may be kept alive for use by a subsequent ClientSocketHandle.
   //
   // NOTE: To prevent the socket from being kept alive, be sure to call its
@@ skipping 138 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketHandle);
 };
 
 // Template function implementation:
 template <typename PoolType>
 int ClientSocketHandle::Init(
     const std::string& group_name,
     const scoped_refptr<typename PoolType::SocketParams>& socket_params,
     RequestPriority priority,
+    ClientSocketPool::IgnoreLimits ignore_limits,
     const CompletionCallback& callback,
     PoolType* pool,
     const BoundNetLog& net_log) {
   requesting_source_ = net_log.source();
 
   CHECK(!group_name.empty());
   ResetInternal(true);
   ResetErrorState();
   pool_ = pool;
   group_name_ = group_name;
   init_time_ = base::TimeTicks::Now();
-  int rv = pool_->RequestSocket(
-      group_name, &socket_params, priority, this, callback_, net_log);
+  int rv = pool_->RequestSocket(group_name, &socket_params, priority,
+                                ignore_limits, this, callback_, net_log);
   if (rv == ERR_IO_PENDING) {
     user_callback_ = callback;
   } else {
     HandleInitCompletion(rv);
   }
   return rv;
 }
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_HANDLE_H_