Convert ignore_limits from a SocketParam to a socket request argument.

net/socket/client_socket_pool.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_POOL_H_
 #define NET_SOCKET_CLIENT_SOCKET_POOL_H_
 
 #include <deque>
 #include <string>
 
@@ skipping 43 matching lines @@
   // Called to add or remove a higher layer pool on top of |this|.  A higher
   // layer pool may be added at most once to |this|, and must be removed prior
   // to destruction of |this|.
   virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) = 0;
   virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) = 0;
 };
 
 // A ClientSocketPool is used to restrict the number of sockets open at a time.
 // It also maintains a list of idle persistent sockets.
 //
+// Subclasses must also have an inner class SocketParams which is
+// the type for the |params| argument in RequestSocket() and
+// RequestSockets() below.
 class NET_EXPORT ClientSocketPool : public LowerLayeredPool {
  public:
-  // Subclasses must also have an inner class SocketParams which is
-  // the type for the |params| argument in RequestSocket() and
-  // RequestSockets() below.
+  // Indicates whether a request for a socket should ignore the SocketPool's
+  // global and per-group socket limits.
+  enum class IgnoreLimits { DISABLED, ENABLED };

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

Not sure what to suggest in its place, but "ENABLED" to my ear sounds like the
normal flow, and DISABLED as the exceptional case.

Ideally I would like for the name to sound scarier for the enabled case, since
this is really a very special case that callers shouldn't be using.

Maybe something that implies "default" or "normal" for the DISABLED case, or
even flipping the enum's meaning to "respect limits" or "enforce limits" so
disabled becomes the unusual case.

[mmenke, 2016/01/27 20:37:27]

Hrm...  IgnoreLimits::DEFAULT / NORMAL seems less clear to me.  Could go with
ClientSocketPool::PoolLimits::IGNORE (BYPASS?) / DEFAULT (I think we're missing
a RETRY and ABORT in there).  That does sound a bit like it affects some
permanent property of the socket pool, though, rather than a per-request value.

Think I'll just go with RespectLimits::ENABLED / DISABLED, unless you chime in. 
Now that I've stuck IgnoreLimits everywhere, mass renaming is pretty easy, just
have to be careful with comments.

[eroman, 2016/01/27 20:40:21]

ok

 
   // Requests a connected socket for a group_name.
   //
   // There are five possible results from calling this function:
   // 1) RequestSocket returns OK and initializes |handle| with a reused socket.
   // 2) RequestSocket returns OK with a newly connected socket.
   // 3) RequestSocket returns ERR_IO_PENDING.  The handle will be added to a
   // wait list until a socket is available to reuse or a new socket finishes
   // connecting.  |priority| will determine the placement into the wait list.
   // 4) An error occurred early on, so RequestSocket returns an error code.
@@ skipping 10 matching lines @@
   // StreamSocket was reused, then ClientSocketPool will call
   // |handle|->set_reused(true).  In either case, the socket will have been
   // allocated and will be connected.  A client might want to know whether or
   // not the socket is reused in order to request a new socket if it encounters
   // an error with the reused socket.
   //
   // If ERR_IO_PENDING is returned, then the callback will be used to notify the
   // client of completion.
   //
   // Profiling information for the request is saved to |net_log| if non-NULL.
+  //
+  // If |ignore_limits| is ENABLED, priority must be HIGHEST.
   virtual int RequestSocket(const std::string& group_name,
                             const void* params,
                             RequestPriority priority,
+                            IgnoreLimits ignore_limits,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
                             const BoundNetLog& net_log) = 0;
 
   // RequestSockets is used to request that |num_sockets| be connected in the
   // connection group for |group_name|.  If the connection group already has
   // |num_sockets| idle sockets / active sockets / currently connecting sockets,
   // then this function doesn't do anything.  Otherwise, it will start up as
   // many connections as necessary to reach |num_sockets| total sockets for the
   // group.  It uses |params| to control how to connect the sockets.   The
@@ skipping 80 matching lines @@
     const std::string& group_name,
     const scoped_refptr<typename PoolType::SocketParams>& params,
     int num_sockets,
     const BoundNetLog& net_log) {
   pool->RequestSockets(group_name, &params, num_sockets, net_log);
 }
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_H_