src/content/browser/loader/resource_scheduler.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_
   6 #define CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_
   7
   8 #include <map>
   9 #include <set>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/threading/non_thread_safe.h"
  15 #include "base/timer/timer.h"
  16 #include "content/common/content_export.h"
  17 #include "net/base/priority_queue.h"
  18 #include "net/base/request_priority.h"
  19
  20 namespace net {
  21 class HostPortPair;
  22 class URLRequest;
  23 }
  24
  25 namespace content {
  26 class ResourceThrottle;
  27
  28 // There is one ResourceScheduler. All renderer-initiated HTTP requests are
  29 // expected to pass through it.
  30 //
  31 // There are two types of input to the scheduler:
  32 // 1. Requests to start, cancel, or finish fetching a resource.
  33 // 2. Notifications for renderer events, such as new tabs, navigation and
  34 //    painting.
  35 //
  36 // These input come from different threads, so they may not be in sync. The UI
  37 // thread is considered the authority on renderer lifetime, which means some
  38 // IPCs may be meaningless if they arrive after the UI thread signals a renderer
  39 // has been deleted.
  40 //
  41 // The ResourceScheduler tracks many Clients, which should correlate with tabs.
  42 // A client is uniquely identified by its child_id and route_id.
  43 //
  44 // Each Client may have many Requests in flight. Requests are uniquely
  45 // identified within a Client by its ScheduledResourceRequest.
  46 //
  47 // Users should call ScheduleRequest() to notify this ResourceScheduler of a
  48 // new request. The returned ResourceThrottle should be destroyed when the load
  49 // finishes or is canceled.
  50 //
  51 // The scheduler may defer issuing the request via the ResourceThrottle
  52 // interface or it may alter the request's priority by calling set_priority() on
  53 // the URLRequest.
  54 class CONTENT_EXPORT ResourceScheduler : public base::NonThreadSafe {
  55  public:
  56   enum ClientThrottleState {
  57     // TODO(aiolos): Add logic to ShouldStartRequest for PAUSED Clients to only
  58     // issue synchronous requests.
  59     // TODO(aiolos): Add max number of THROTTLED Clients, and logic to set
  60     // subsquent Clients to PAUSED instead. Also add logic to unpause a Client
  61     // when a background Client becomes COALESCED (ie, finishes loading.)
  62     // TODO(aiolos): Add tests for the above mentioned logic.
  63
  64     // Currently being deleted client.
  65     // This state currently follows the same logic for loading requests as
  66     // UNTHROTTLED/ACTIVE_AND_LOADING Clients. See above TODO's.
  67     PAUSED,
  68     // Loaded background client, all observable clients loaded.
  69     COALESCED,
  70     // Background client, an observable client is loading.
  71     THROTTLED,
  72     // Observable (active) loaded client or
  73     // Loading background client, all observable clients loaded.
  74     // Note that clients which would be COALESCED are UNTHROTTLED until
  75     // coalescing is turned on.
  76     UNTHROTTLED,
  77     // Observable (active) loading client.
  78     ACTIVE_AND_LOADING,
  79   };
  80
  81   ResourceScheduler();
  82   ~ResourceScheduler();
  83
  84   // Use a mock timer when testing.
  85   void set_timer_for_testing(scoped_ptr<base::Timer> timer) {
  86     coalescing_timer_.reset(timer.release());
  87   }
  88
  89   // TODO(aiolos): Remove when throttling and coalescing have landed
  90   void SetThrottleOptionsForTesting(bool should_throttle, bool should_coalesce);
  91
  92   bool should_coalesce() const { return should_coalesce_; }
  93   bool should_throttle() const { return should_throttle_; }
  94
  95   ClientThrottleState GetClientStateForTesting(int child_id, int route_id);
  96
  97   // Requests that this ResourceScheduler schedule, and eventually loads, the
  98   // specified |url_request|. Caller should delete the returned ResourceThrottle
  99   // when the load completes or is canceled.
 100   scoped_ptr<ResourceThrottle> ScheduleRequest(
 101       int child_id, int route_id, net::URLRequest* url_request);
 102
 103   // Signals from the UI thread, posted as tasks on the IO thread:
 104
 105   // Called when a renderer is created.
 106   void OnClientCreated(int child_id, int route_id);
 107
 108   // Called when a renderer is destroyed.
 109   void OnClientDeleted(int child_id, int route_id);
 110
 111   // Signals from IPC messages directly from the renderers:
 112
 113   // Called when a client navigates to a new main document.
 114   void OnNavigate(int child_id, int route_id);
 115
 116   // Called when the client has parsed the <body> element. This is a signal that
 117   // resource loads won't interfere with first paint.
 118   void OnWillInsertBody(int child_id, int route_id);
 119
 120   // Signals from the IO thread:
 121
 122   // Called when we received a response to a http request that was served
 123   // from a proxy using SPDY.
 124   void OnReceivedSpdyProxiedHttpResponse(int child_id, int route_id);
 125
 126   // Client functions:
 127
 128   // Called to check if all user observable tabs have completed loading.
 129   bool active_clients_loaded() const { return active_clients_loading_ == 0; }
 130
 131   // Called when a Client starts or stops playing audio.
 132   void OnAudibilityChanged(int child_id, int route_id, bool is_audible);
 133
 134   // Called when a Client is shown or hidden.
 135   void OnVisibilityChanged(int child_id, int route_id, bool is_visible);
 136
 137   void OnLoadingStateChanged(int child_id, int route_id, bool is_loaded);
 138
 139  private:
 140   class RequestQueue;
 141   class ScheduledResourceRequest;
 142   struct RequestPriorityParams;
 143   struct ScheduledResourceSorter {
 144     bool operator()(const ScheduledResourceRequest* a,
 145                     const ScheduledResourceRequest* b) const;
 146   };
 147   class Client;
 148
 149   typedef int64 ClientId;
 150   typedef std::map<ClientId, Client*> ClientMap;
 151   typedef std::set<ScheduledResourceRequest*> RequestSet;
 152
 153   // Called when a ScheduledResourceRequest is destroyed.
 154   void RemoveRequest(ScheduledResourceRequest* request);
 155
 156   // These calls may update the ThrottleState of all clients, and have the
 157   // potential to be re-entrant.
 158   // Called when a Client newly becomes active loading.
 159   void IncrementActiveClientsLoading();
 160   // Called when an active and loading Client either completes loading or
 161   // becomes inactive.
 162   void DecrementActiveClientsLoading();
 163
 164   void OnLoadingActiveClientsStateChangedForAllClients();
 165
 166   size_t CountActiveClientsLoading() const;
 167
 168   // Called when a Client becomes coalesced.
 169   void IncrementCoalescedClients();
 170   // Called when a client stops being coalesced.
 171   void DecrementCoalescedClients();
 172
 173   void LoadCoalescedRequests();
 174
 175   size_t CountCoalescedClients() const;
 176
 177   // Update the queue position for |request|, possibly causing it to start
 178   // loading.
 179   //
 180   // Queues are maintained for each priority level. When |request| is
 181   // reprioritized, it will move to the end of the queue for that priority
 182   // level.
 183   void ReprioritizeRequest(ScheduledResourceRequest* request,
 184                            net::RequestPriority new_priority,
 185                            int intra_priority_value);
 186
 187   // Returns the client ID for the given |child_id| and |route_id| combo.
 188   ClientId MakeClientId(int child_id, int route_id);
 189
 190   // Returns the client for the given |child_id| and |route_id| combo.
 191   Client* GetClient(int child_id, int route_id);
 192
 193   bool should_coalesce_;
 194   bool should_throttle_;
 195   ClientMap client_map_;
 196   size_t active_clients_loading_;
 197   size_t coalesced_clients_;
 198   // This is a repeating timer to initiate requests on COALESCED Clients.
 199   scoped_ptr<base::Timer> coalescing_timer_;
 200   RequestSet unowned_requests_;
 201 };
 202
 203 }  // namespace content
 204
 205 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_