ResourceScheduler: remove dependency on ResourceRequestInfo and request_id

content/browser/loader/resource_scheduler.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 CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_
 #define CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_
 
 #include <map>
 #include <set>
 
@@ skipping 26 matching lines @@
 // thread is considered the authority on renderer lifetime, which means some
 // IPCs may be meaningless if they arrive after the UI thread signals a renderer
 // has been deleted.
 //
 // The ResourceScheduler tracks many Clients, which should correlate with tabs.
 // A client is uniquely identified by its child_id and route_id.
 //
 // Each Client may have many Requests in flight. Requests are uniquely
 // identified within a Client by its ScheduledResourceRequest.
 //
-// Users should call ScheduleRequest() to notify this ResourceScheduler of a
-// new request. The returned ResourceThrottle should be destroyed when the load
-// finishes or is canceled.
+// Users should call ScheduleRequest() to notify this ResourceScheduler of a new
+// request. The returned ResourceThrottle should be destroyed when the load
+// finishes or is canceled, before the net::URLRequest.
 //
 // The scheduler may defer issuing the request via the ResourceThrottle
 // interface or it may alter the request's priority by calling set_priority() on
 // the URLRequest.
 class CONTENT_EXPORT ResourceScheduler : public base::NonThreadSafe {
  public:
   enum ClientThrottleState {
     // TODO(aiolos): Add logic to ShouldStartRequest for PAUSED Clients to only
     // issue synchronous requests.
     // TODO(aiolos): Add max number of THROTTLED Clients, and logic to set
@@ skipping 37 matching lines @@
   // TODO(aiolos): Remove when throttling and coalescing have landed
   void SetThrottleOptionsForTesting(bool should_throttle, bool should_coalesce);
 
   bool should_coalesce() const { return should_coalesce_; }
   bool should_throttle() const { return should_throttle_; }
 
   ClientThrottleState GetClientStateForTesting(int child_id, int route_id);
 
   // Requests that this ResourceScheduler schedule, and eventually loads, the
   // specified |url_request|. Caller should delete the returned ResourceThrottle
-  // when the load completes or is canceled.
-  scoped_ptr<ResourceThrottle> ScheduleRequest(
-      int child_id, int route_id, net::URLRequest* url_request);
+  // when the load completes or is canceled, before |url_request| is deleted.
+  scoped_ptr<ResourceThrottle> ScheduleRequest(int child_id,
+                                               int route_id,
+                                               bool is_async,
+                                               net::URLRequest* url_request);
 
   // Signals from the UI thread, posted as tasks on the IO thread:
 
   // Called when a renderer is created.
   void OnClientCreated(int child_id,
                        int route_id,
                        bool is_visible,
                        bool is_audible);
 
   // Called when a renderer is destroyed.
@@ skipping 26 matching lines @@
   // Client functions:
 
   // Called to check if all user observable tabs have completed loading.
   bool active_clients_loaded() const { return active_clients_loading_ == 0; }
 
   bool IsClientVisibleForTesting(int child_id, int route_id);
 
   // Returns true if at least one client is currently loading.
   bool HasLoadingClients() const;
 
+  // Update the priority for |request|. Modifies request->priority(), and may
+  // start the request loading if it wasn't already started.
+  void ReprioritizeRequest(net::URLRequest* request,
+                           net::RequestPriority new_priority,
+                           int intra_priority_value);
+
  private:
   // Returns true if limiting of outstanding requests is enabled.
   bool limit_outstanding_requests() const {
     return limit_outstanding_requests_;
   }
 
   // Returns the outstanding request limit.  Only valid if
   // |IsLimitingOutstandingRequests()|.
   size_t outstanding_request_limit() const {
     return outstanding_request_limit_;
@@ skipping 42 matching lines @@
   void DecrementCoalescedClients();
 
   void LoadCoalescedRequests();
 
   size_t CountCoalescedClients() const;
 
   // Returns UNKNOWN if the corresponding client is not found, else returns
   // whether the client is ACTIVE (user-observable) or BACKGROUND.
   ClientState GetClientState(ClientId client_id) const;
 
-  // Update the queue position for |request|, possibly causing it to start
-  // loading.
-  //
-  // Queues are maintained for each priority level. When |request| is
-  // reprioritized, it will move to the end of the queue for that priority
-  // level.
-  void ReprioritizeRequest(ScheduledResourceRequest* request,
-                           net::RequestPriority new_priority,
-                           int intra_priority_value);
-
   // Returns the client ID for the given |child_id| and |route_id| combo.
   ClientId MakeClientId(int child_id, int route_id);
 
   // Returns the client for the given |child_id| and |route_id| combo.
   Client* GetClient(int child_id, int route_id);
 
   bool should_coalesce_;
   bool should_throttle_;
   ClientMap client_map_;
   size_t active_clients_loading_;
   size_t coalesced_clients_;
   bool limit_outstanding_requests_;
   size_t outstanding_request_limit_;
   // This is a repeating timer to initiate requests on COALESCED Clients.
   scoped_ptr<base::Timer> coalescing_timer_;
   RequestSet unowned_requests_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResourceScheduler);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_