Add coalescing timer to ResourceScheduler. CL 2 from BUG=128035.

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>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
+#include "base/timer/timer.h"
 #include "content/common/content_export.h"
 #include "net/base/priority_queue.h"
 #include "net/base/request_priority.h"
 
 namespace net {
 class HostPortPair;
 class URLRequest;
 }
 
 namespace content {
@@ skipping 21 matching lines @@
 // 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.
 //
 // 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
+    // subsquent Clients to PAUSED instead. Also add logic to unpause a Client
+    // when a background Client becomes COALESCED (ie, finishes loading.)
+    // TODO(aiolos): Add tests for the above mentioned logic.
+
+    // Currently being deleted client.
+    // This state currently follows the same logic for loading requests as
+    // UNTHROTTLED/ACTIVE_AND_LOADING Clients. See above TODO's.
+    PAUSED,
     // Loaded background client, all observable clients loaded.
     COALESCED,
     // Background client, an observable client is loading.
     THROTTLED,
     // Observable (active) loaded client or
     // Loading background client, all observable clients loaded.
     // Note that clients which would be COALESCED are UNTHROTTLED until
     // coalescing is turned on.
     UNTHROTTLED,
     // Observable (active) loading client.
     ACTIVE_AND_LOADING,
   };
 
   ResourceScheduler();
   ~ResourceScheduler();
 
+  // Use a mock timer when testing.
+  void set_timer_for_testing(scoped_ptr<base::Timer> timer) {
+    coalescing_timer_.reset(timer.release());
+  }
+
   // 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
@@ skipping 47 matching lines @@
   };
   class Client;
 
   typedef int64 ClientId;
   typedef std::map<ClientId, Client*> ClientMap;
   typedef std::set<ScheduledResourceRequest*> RequestSet;
 
   // Called when a ScheduledResourceRequest is destroyed.
   void RemoveRequest(ScheduledResourceRequest* request);
 
-  // These Calls may update the ThrottleState of all clients, and have the
-  // potential to be re-entarant.
+  // These calls may update the ThrottleState of all clients, and have the
+  // potential to be re-entrant.
   // Called when a Client newly becomes active loading.
+  void IncrementActiveClientsLoading();
+  // Called when an active and loading Client either completes loading or
+  // becomes inactive.
   void DecrementActiveClientsLoading();
-  // Caled when a Client stops being active loading.
-  void IncrementActiveClientsLoading();
 
-  void OnLoadingActiveClientsStateChanged();
+  void OnLoadingActiveClientsStateChangedForAllClients();
 
-  size_t CountActiveClientsLoading();
+  size_t CountActiveClientsLoading() const;
+
+  // Called when a Client becomes coalesced.
+  void IncrementCoalescedClients();
+  // Called when a client stops being coalesced.
+  void DecrementCoalescedClients();
+
+  void LoadCoalescedRequests();
+
+  size_t CountCoalescedClients() 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_;
+  // This is a repeating timer to initiate requests on COALESCED Clients.
+  scoped_ptr<base::Timer> coalescing_timer_;
   RequestSet unowned_requests_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_