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, int route_id, bool is_visible);
 115
 116   // Called when a renderer is destroyed.
 117   void OnClientDeleted(int child_id, int route_id);
 118
 119   // Signals from IPC messages directly from the renderers:
 120
 121   // Called when a client navigates to a new main document.
 122   void OnNavigate(int child_id, int route_id);
 123
 124   // Called when the client has parsed the <body> element. This is a signal that
 125   // resource loads won't interfere with first paint.
 126   void OnWillInsertBody(int child_id, int route_id);
 127
 128   // Signals from the IO thread:
 129
 130   // Called when we received a response to a http request that was served
 131   // from a proxy using SPDY.
 132   void OnReceivedSpdyProxiedHttpResponse(int child_id, int route_id);
 133
 134   // Client functions:
 135
 136   // Called to check if all user observable tabs have completed loading.
 137   bool active_clients_loaded() const { return active_clients_loading_ == 0; }
 138
 139   // Called when a Client starts or stops playing audio.
 140   void OnAudibilityChanged(int child_id, int route_id, bool is_audible);
 141
 142   // Called when a Client is shown or hidden.
 143   void OnVisibilityChanged(int child_id, int route_id, bool is_visible);
 144
 145   void OnLoadingStateChanged(int child_id, int route_id, bool is_loaded);
 146
 147   bool IsClientVisibleForTesting(int child_id, int route_id);
 148
 149  private:
 150   class RequestQueue;
 151   class ScheduledResourceRequest;
 152   struct RequestPriorityParams;
 153   struct ScheduledResourceSorter {
 154     bool operator()(const ScheduledResourceRequest* a,
 155                     const ScheduledResourceRequest* b) const;
 156   };
 157   class Client;
 158
 159   typedef int64 ClientId;
 160   typedef std::map<ClientId, Client*> ClientMap;
 161   typedef std::set<ScheduledResourceRequest*> RequestSet;
 162
 163   // Called when a ScheduledResourceRequest is destroyed.
 164   void RemoveRequest(ScheduledResourceRequest* request);
 165
 166   // These calls may update the ThrottleState of all clients, and have the
 167   // potential to be re-entrant.
 168   // Called when a Client newly becomes active loading.
 169   void IncrementActiveClientsLoading();
 170   // Called when an active and loading Client either completes loading or
 171   // becomes inactive.
 172   void DecrementActiveClientsLoading();
 173
 174   void OnLoadingActiveClientsStateChangedForAllClients();
 175
 176   size_t CountActiveClientsLoading() const;
 177
 178   // Called when a Client becomes coalesced.
 179   void IncrementCoalescedClients();
 180   // Called when a client stops being coalesced.
 181   void DecrementCoalescedClients();
 182
 183   void LoadCoalescedRequests();
 184
 185   size_t CountCoalescedClients() const;
 186
 187   // Update the queue position for |request|, possibly causing it to start
 188   // loading.
 189   //
 190   // Queues are maintained for each priority level. When |request| is
 191   // reprioritized, it will move to the end of the queue for that priority
 192   // level.
 193   void ReprioritizeRequest(ScheduledResourceRequest* request,
 194                            net::RequestPriority new_priority,
 195                            int intra_priority_value);
 196
 197   // Returns the client ID for the given |child_id| and |route_id| combo.
 198   ClientId MakeClientId(int child_id, int route_id);
 199
 200   // Returns the client for the given |child_id| and |route_id| combo.
 201   Client* GetClient(int child_id, int route_id);
 202
 203   bool should_coalesce_;
 204   bool should_throttle_;
 205   ClientMap client_map_;
 206   size_t active_clients_loading_;
 207   size_t coalesced_clients_;
 208   // This is a repeating timer to initiate requests on COALESCED Clients.
 209   scoped_ptr<base::Timer> coalescing_timer_;
 210   RequestSet unowned_requests_;
 211 };
 212
 213 }  // namespace content
 214
 215 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_