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   enum RequestClassification {
  82     NORMAL_REQUEST,
  83     // Low priority in-flight requests
  84     IN_FLIGHT_DELAYABLE_REQUEST,
  85     // High-priority requests received before the renderer has a <body>
  86     LAYOUT_BLOCKING_REQUEST,
  87   };
  88
  89   ResourceScheduler();
  90   ~ResourceScheduler();
  91
  92   // Use a mock timer when testing.
  93   void set_timer_for_testing(scoped_ptr<base::Timer> timer) {
  94     coalescing_timer_.reset(timer.release());
  95   }
  96
  97   // TODO(aiolos): Remove when throttling and coalescing have landed
  98   void SetThrottleOptionsForTesting(bool should_throttle, bool should_coalesce);
  99
 100   bool should_coalesce() const { return should_coalesce_; }
 101   bool should_throttle() const { return should_throttle_; }
 102
 103   ClientThrottleState GetClientStateForTesting(int child_id, int route_id);
 104
 105   // Requests that this ResourceScheduler schedule, and eventually loads, the
 106   // specified |url_request|. Caller should delete the returned ResourceThrottle
 107   // when the load completes or is canceled.
 108   scoped_ptr<ResourceThrottle> ScheduleRequest(
 109       int child_id, int route_id, net::URLRequest* url_request);
 110
 111   // Signals from the UI thread, posted as tasks on the IO thread:
 112
 113   // Called when a renderer is created.
 114   void OnClientCreated(int child_id,
 115                        int route_id,
 116                        bool is_visible,
 117                        bool is_audible);
 118
 119   // Called when a renderer is destroyed.
 120   void OnClientDeleted(int child_id, int route_id);
 121
 122   // Called when a renderer stops or restarts loading.
 123   void OnLoadingStateChanged(int child_id, int route_id, bool is_loaded);
 124
 125   // Called when a Client is shown or hidden.
 126   void OnVisibilityChanged(int child_id, int route_id, bool is_visible);
 127
 128   // Called when a Client starts or stops playing audio.
 129   void OnAudibilityChanged(int child_id, int route_id, bool is_audible);
 130
 131   // Signals from IPC messages directly from the renderers:
 132
 133   // Called when a client navigates to a new main document.
 134   void OnNavigate(int child_id, int route_id);
 135
 136   // Called when the client has parsed the <body> element. This is a signal that
 137   // resource loads won't interfere with first paint.
 138   void OnWillInsertBody(int child_id, int route_id);
 139
 140   // Signals from the IO thread:
 141
 142   // Called when we received a response to a http request that was served
 143   // from a proxy using SPDY.
 144   void OnReceivedSpdyProxiedHttpResponse(int child_id, int route_id);
 145
 146   // Client functions:
 147
 148   // Called to check if all user observable tabs have completed loading.
 149   bool active_clients_loaded() const { return active_clients_loading_ == 0; }
 150
 151   bool IsClientVisibleForTesting(int child_id, int route_id);
 152
 153  private:
 154   enum ClientState {
 155     // Observable client.
 156     ACTIVE,
 157     // Non-observable client.
 158     BACKGROUND,
 159     // No client found.
 160     UNKNOWN,
 161   };
 162
 163   class RequestQueue;
 164   class ScheduledResourceRequest;
 165   struct RequestPriorityParams;
 166   struct ScheduledResourceSorter {
 167     bool operator()(const ScheduledResourceRequest* a,
 168                     const ScheduledResourceRequest* b) const;
 169   };
 170   class Client;
 171
 172   typedef int64 ClientId;
 173   typedef std::map<ClientId, Client*> ClientMap;
 174   typedef std::set<ScheduledResourceRequest*> RequestSet;
 175
 176   // Called when a ScheduledResourceRequest is destroyed.
 177   void RemoveRequest(ScheduledResourceRequest* request);
 178
 179   // These calls may update the ThrottleState of all clients, and have the
 180   // potential to be re-entrant.
 181   // Called when a Client newly becomes active loading.
 182   void IncrementActiveClientsLoading();
 183   // Called when an active and loading Client either completes loading or
 184   // becomes inactive.
 185   void DecrementActiveClientsLoading();
 186
 187   void OnLoadingActiveClientsStateChangedForAllClients();
 188
 189   size_t CountActiveClientsLoading() const;
 190
 191   // Called when a Client becomes coalesced.
 192   void IncrementCoalescedClients();
 193   // Called when a client stops being coalesced.
 194   void DecrementCoalescedClients();
 195
 196   void LoadCoalescedRequests();
 197
 198   size_t CountCoalescedClients() const;
 199
 200   // Returns UNKNOWN if the corresponding client is not found, else returns
 201   // whether the client is ACTIVE (user-observable) or BACKGROUND.
 202   ClientState GetClientState(ClientId client_id) const;
 203
 204   // Update the queue position for |request|, possibly causing it to start
 205   // loading.
 206   //
 207   // Queues are maintained for each priority level. When |request| is
 208   // reprioritized, it will move to the end of the queue for that priority
 209   // level.
 210   void ReprioritizeRequest(ScheduledResourceRequest* request,
 211                            net::RequestPriority new_priority,
 212                            int intra_priority_value);
 213
 214   // Returns the client ID for the given |child_id| and |route_id| combo.
 215   ClientId MakeClientId(int child_id, int route_id);
 216
 217   // Returns the client for the given |child_id| and |route_id| combo.
 218   Client* GetClient(int child_id, int route_id);
 219
 220   bool should_coalesce_;
 221   bool should_throttle_;
 222   ClientMap client_map_;
 223   size_t active_clients_loading_;
 224   size_t coalesced_clients_;
 225   // This is a repeating timer to initiate requests on COALESCED Clients.
 226   scoped_ptr<base::Timer> coalescing_timer_;
 227   RequestSet unowned_requests_;
 228 };
 229
 230 }  // namespace content
 231
 232 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_