Convert ignore_limits from a SocketParam to a socket request argument.

net/socket/client_socket_pool_base.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.
 //
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets for reuse.
 // Subclasses of ClientSocketPool should compose ClientSocketPoolBase to handle
 // the core logic of (1) restricting the number of active (connected or
 // connecting) sockets per "group" (generally speaking, the hostname), (2)
 // maintaining a per-group list of idle, persistent sockets for reuse, and (3)
@@ skipping 63 matching lines @@
                                       ConnectJob* job) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // A |timeout_duration| of 0 corresponds to no timeout.
   ConnectJob(const std::string& group_name,
              base::TimeDelta timeout_duration,
              RequestPriority priority,
+             ClientSocketPool::RespectLimits respect_limits,
              Delegate* delegate,
              const BoundNetLog& net_log);
   virtual ~ConnectJob();
 
   // Accessors
   const std::string& group_name() const { return group_name_; }
   const BoundNetLog& net_log() { return net_log_; }
 
   // Releases ownership of the underlying socket to the caller.
   // Returns the released socket, or NULL if there was a connection
@@ skipping 16 matching lines @@
   virtual void GetAdditionalErrorState(ClientSocketHandle* handle) {}
 
   const LoadTimingInfo::ConnectTiming& connect_timing() const {
     return connect_timing_;
   }
 
   const BoundNetLog& net_log() const { return net_log_; }
 
  protected:
   RequestPriority priority() const { return priority_; }
+  ClientSocketPool::RespectLimits respect_limits() const {
+    return respect_limits_;
+  }
   void SetSocket(scoped_ptr<StreamSocket> socket);
   StreamSocket* socket() { return socket_.get(); }
   void NotifyDelegateOfCompletion(int rv);
   void ResetTimer(base::TimeDelta remainingTime);
 
   // Connection establishment timing information.
   LoadTimingInfo::ConnectTiming connect_timing_;
 
  private:
   virtual int ConnectInternal() = 0;
 
   void LogConnectStart();
   void LogConnectCompletion(int net_error);
 
   // Alerts the delegate that the ConnectJob has timed out.
   void OnTimeout();
 
   const std::string group_name_;
   const base::TimeDelta timeout_duration_;
   // TODO(akalin): Support reprioritization.
   const RequestPriority priority_;
+  const ClientSocketPool::RespectLimits respect_limits_;
   // Timer to abort jobs that take too long.
   base::OneShotTimer timer_;
   Delegate* delegate_;
   scoped_ptr<StreamSocket> socket_;
   BoundNetLog net_log_;
   // A ConnectJob is idle until Connect() has been called.
   bool idle_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectJob);
 };
@@ skipping 15 matching lines @@
   enum Flag {
     NORMAL = 0,  // Normal behavior.
     NO_IDLE_SOCKETS = 0x1,  // Do not return an idle socket. Create a new one.
   };
 
   class NET_EXPORT_PRIVATE Request {
    public:
     Request(ClientSocketHandle* handle,
             const CompletionCallback& callback,
             RequestPriority priority,
-            bool ignore_limits,
+            ClientSocketPool::RespectLimits respect_limits,
             Flags flags,
             const BoundNetLog& net_log);
 
     virtual ~Request();
 
     ClientSocketHandle* handle() const { return handle_; }
     const CompletionCallback& callback() const { return callback_; }
     RequestPriority priority() const { return priority_; }
-    bool ignore_limits() const { return ignore_limits_; }
+    ClientSocketPool::RespectLimits respect_limits() const {
+      return respect_limits_;
+    }
     Flags flags() const { return flags_; }
     const BoundNetLog& net_log() const { return net_log_; }
 
     // TODO(eroman): Temporary until crbug.com/467797 is solved.
     void CrashIfInvalid() const;
 
    private:
     // TODO(eroman): Temporary until crbug.com/467797 is solved.
     enum Liveness {
       ALIVE = 0xCA11AB13,
       DEAD = 0xDEADBEEF,
     };
 
     ClientSocketHandle* const handle_;
     const CompletionCallback callback_;
     // TODO(akalin): Support reprioritization.
     const RequestPriority priority_;
-    const bool ignore_limits_;
+    const ClientSocketPool::RespectLimits respect_limits_;
     const Flags flags_;
     const BoundNetLog net_log_;
 
     // TODO(eroman): Temporary until crbug.com/467797 is solved.
     Liveness liveness_ = ALIVE;
 
     DISALLOW_COPY_AND_ASSIGN(Request);
   };
 
   class ConnectJobFactory {
@@ skipping 185 matching lines @@
 
     // Returns true if the group could make use of an additional socket slot, if
     // it were given one.
     bool CanUseAdditionalSocketSlot(int max_sockets_per_group) const {
       return HasAvailableSocketSlot(max_sockets_per_group) &&
           pending_requests_.size() > jobs_.size();
     }
 
     // Returns the priority of the top of the pending request queue
     // (which may be less than the maximum priority over the entire
-    // queue, due to how we prioritize requests with |ignore_limits|
-    // set over others).
+    // queue, due to how we prioritize requests with |respect_limits|
+    // DISABLED over others).
     RequestPriority TopPendingPriority() const {
       // NOTE: FirstMax().value()->priority() is not the same as
       // FirstMax().priority()!
       return pending_requests_.FirstMax().value()->priority();
     }
 
     // Set a timer to create a backup job if it takes too long to
     // create one and if a timer isn't already running.
     void StartBackupJobTimer(const std::string& group_name,
                              ClientSocketPoolBaseHelper* pool);
@@ skipping 252 matching lines @@
 }  // namespace internal
 
 template <typename SocketParams>
 class ClientSocketPoolBase {
  public:
   class Request : public internal::ClientSocketPoolBaseHelper::Request {
    public:
     Request(ClientSocketHandle* handle,
             const CompletionCallback& callback,
             RequestPriority priority,
+            ClientSocketPool::RespectLimits respect_limits,
             internal::ClientSocketPoolBaseHelper::Flags flags,
-            bool ignore_limits,
             const scoped_refptr<SocketParams>& params,
             const BoundNetLog& net_log)
-        : internal::ClientSocketPoolBaseHelper::Request(
-              handle, callback, priority, ignore_limits, flags, net_log),
+        : internal::ClientSocketPoolBaseHelper::Request(handle,
+                                                        callback,
+                                                        priority,
+                                                        respect_limits,
+                                                        flags,
+                                                        net_log),
           params_(params) {}
 
     const scoped_refptr<SocketParams>& params() const { return params_; }
 
    private:
     const scoped_refptr<SocketParams> params_;
   };
 
   class ConnectJobFactory {
    public:
@@ skipping 43 matching lines @@
 
   void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) {
     helper_.RemoveHigherLayeredPool(higher_pool);
   }
 
   // RequestSocket bundles up the parameters into a Request and then forwards to
   // ClientSocketPoolBaseHelper::RequestSocket().
   int RequestSocket(const std::string& group_name,
                     const scoped_refptr<SocketParams>& params,
                     RequestPriority priority,
+                    ClientSocketPool::RespectLimits respect_limits,
                     ClientSocketHandle* handle,
                     const CompletionCallback& callback,
                     const BoundNetLog& net_log) {
-    scoped_ptr<const Request> request(
-        new Request(handle, callback, priority,
-                    internal::ClientSocketPoolBaseHelper::NORMAL,
-                    params->ignore_limits(),
-                    params, net_log));
+    scoped_ptr<const Request> request(new Request(
+        handle, callback, priority, respect_limits,
+        internal::ClientSocketPoolBaseHelper::NORMAL, params, net_log));
     return helper_.RequestSocket(group_name, std::move(request));
   }
 
   // RequestSockets bundles up the parameters into a Request and then forwards
   // to ClientSocketPoolBaseHelper::RequestSockets().  Note that it assigns the
   // priority to IDLE and specifies the NO_IDLE_SOCKETS flag.
   void RequestSockets(const std::string& group_name,
                       const scoped_refptr<SocketParams>& params,
                       int num_sockets,
                       const BoundNetLog& net_log) {
-    const Request request(NULL /* no handle */, CompletionCallback(), IDLE,
+    const Request request(nullptr /* no handle */, CompletionCallback(), IDLE,
+                          ClientSocketPool::RespectLimits::ENABLED,
                           internal::ClientSocketPoolBaseHelper::NO_IDLE_SOCKETS,
-                          params->ignore_limits(), params, net_log);
+                          params, net_log);
     helper_.RequestSockets(group_name, request, num_sockets);
   }
 
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle) {
     return helper_.CancelRequest(group_name, handle);
   }
 
   void ReleaseSocket(const std::string& group_name,
                      scoped_ptr<StreamSocket> socket,
@@ skipping 92 matching lines @@
   };
 
   internal::ClientSocketPoolBaseHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_