Add reprioritization to socket pools.

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 170 matching lines @@
             RequestPriority priority,
             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_; }
+    void set_priority(RequestPriority priority) { priority_ = priority; }
     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_;
+    RequestPriority priority_;
     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);
   };
 
@@ skipping 30 matching lines @@
   // See LowerLayeredPool::IsStalled for documentation on this function.
   bool IsStalled() const;
 
   // See LowerLayeredPool for documentation on these functions. It is expected
   // in the destructor that no higher layer pools remain.
   void AddHigherLayeredPool(HigherLayeredPool* higher_pool);
   void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool);
 
   // See ClientSocketPool::RequestSocket for documentation on this function.
   int RequestSocket(const std::string& group_name,
-                    std::unique_ptr<const Request> request);
+                    std::unique_ptr<Request> request);
 
-  // See ClientSocketPool::RequestSocket for documentation on this function.
+  // See ClientSocketPool::RequestSockets for documentation on this function.
   void RequestSockets(const std::string& group_name,
                       const Request& request,
                       int num_sockets);
 
+  // See ClientSocketPool::SetPriority for documentation on this function.
+  void SetPriority(const std::string& group_name,
+                   ClientSocketHandle* handle,
+                   RequestPriority priority);
+
   // See ClientSocketPool::CancelRequest for documentation on this function.
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle);
 
   // See ClientSocketPool::ReleaseSocket for documentation on this function.
   void ReleaseSocket(const std::string& group_name,
                      std::unique_ptr<StreamSocket> socket,
                      int id);
 
   // See ClientSocketPool::FlushWithError for documentation on this function.
@@ skipping 95 matching lines @@
 
     // An idle socket should be removed if it can't be reused, or has been idle
     // for too long. |now| is the current time value (TimeTicks::Now()).
     // |timeout| is the length of time to wait before timing out an idle socket.
     bool ShouldCleanup(base::TimeTicks now, base::TimeDelta timeout) const;
 
     StreamSocket* socket;
     base::TimeTicks start_time;
   };
 
-  typedef PriorityQueue<const Request*> RequestQueue;
-  typedef std::map<const ClientSocketHandle*, const Request*> RequestMap;
+  typedef PriorityQueue<Request*> RequestQueue;
+  typedef std::map<const ClientSocketHandle*, Request*> RequestMap;
 
   // A Group is allocated per group_name when there are idle sockets or pending
   // requests.  Otherwise, the Group object is removed from the map.
   // |active_socket_count| tracks the number of sockets held by clients.
   class Group {
    public:
     Group();
     ~Group();
 
     bool IsEmpty() const {
@@ skipping 55 matching lines @@
     // Gets (but does not remove) the next pending request. Returns
     // NULL if there are no pending requests.
     const Request* GetNextPendingRequest() const;
 
     // Returns true if there is a connect job for |handle|.
     bool HasConnectJobForHandle(const ClientSocketHandle* handle) const;
 
     // Inserts the request into the queue based on priority
     // order. Older requests are prioritized over requests of equal
     // priority.
-    void InsertPendingRequest(std::unique_ptr<const Request> request);
+    void InsertPendingRequest(std::unique_ptr<Request> request);
 
     // Gets and removes the next pending request. Returns NULL if
     // there are no pending requests.
-    std::unique_ptr<const Request> PopNextPendingRequest();
+    std::unique_ptr<Request> PopNextPendingRequest();
 
     // Finds the pending request for |handle| and removes it. Returns
     // the removed pending request, or NULL if there was none.
-    std::unique_ptr<const Request> FindAndRemovePendingRequest(
+    std::unique_ptr<Request> FindAndRemovePendingRequest(
         ClientSocketHandle* handle);
 
     void IncrementActiveSocketCount() { active_socket_count_++; }
     void DecrementActiveSocketCount() { active_socket_count_--; }
 
     int unassigned_job_count() const { return unassigned_job_count_; }
     const std::list<ConnectJob*>& jobs() const { return jobs_; }
     const std::list<IdleSocket>& idle_sockets() const { return idle_sockets_; }
     int active_socket_count() const { return active_socket_count_; }
     std::list<IdleSocket>* mutable_idle_sockets() { return &idle_sockets_; }
 
    private:
     // Returns the iterator's pending request after removing it from
     // the queue.
-    std::unique_ptr<const Request> RemovePendingRequest(
+    std::unique_ptr<Request> RemovePendingRequest(
         const RequestQueue::Pointer& pointer);
 
     // Called when the backup socket timer fires.
     void OnBackupJobTimerFired(
         std::string group_name,
         ClientSocketPoolBaseHelper* pool);
 
     // Checks that |unassigned_job_count_| does not execeed the number of
     // ConnectJobs.
     void SanityCheck();
@@ skipping 265 matching lines @@
 
   // 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) {
-    std::unique_ptr<const Request> request(new Request(
+    std::unique_ptr<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(nullptr /* no handle */, CompletionCallback(), IDLE,
                           ClientSocketPool::RespectLimits::ENABLED,
                           internal::ClientSocketPoolBaseHelper::NO_IDLE_SOCKETS,
                           params, net_log);
     helper_.RequestSockets(group_name, request, num_sockets);
   }
 
+  void SetPriority(const std::string& group_name,
+                   ClientSocketHandle* handle,
+                   RequestPriority priority) {
+    return helper_.SetPriority(group_name, handle, priority);
+  }
+
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle) {
     return helper_.CancelRequest(group_name, handle);
   }
 
   void ReleaseSocket(const std::string& group_name,
                      std::unique_ptr<StreamSocket> socket,
                      int id) {
     return helper_.ReleaseSocket(group_name, std::move(socket), id);
   }
@@ skipping 90 matching lines @@
   };
 
   internal::ClientSocketPoolBaseHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_