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>
 
 #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 "content/public/browser/resource_throttle.h"
 #include "net/base/priority_queue.h"
 #include "net/base/request_priority.h"
 
 namespace net {
 class HostPortPair;
 class URLRequest;
 }
 
 namespace content {
-class ResourceThrottle;
+// Handle for a scheduled request. This is declared at namespace scope so that
+// it can be pre-declared in other header files.
+class ScheduledResourceRequest : public ResourceThrottle {
+ public:
+  ScheduledResourceRequest();
+  ~ScheduledResourceRequest() override;

[davidben, 2015/08/12 23:58:11]

(Hrm, I would have thought this could be inlined.)

[Adam Rice, 2015/08/13 21:21:02]

It can, but then the compiler has to generate a copy of the vtable for every
file that includes this, and the linker has to consolidate them.

I expect the compiler will inline it in practice anyway, since it is defined in
the same file as ScheduledResourceRequestImpl.

+
+  virtual void ChangePriority(net::RequestPriority new_priority,
+                              int intra_priority_value) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScheduledResourceRequest);
+};
 
 // There is one ResourceScheduler. All renderer-initiated HTTP requests are
 // expected to pass through it.
 //
 // There are two types of input to the scheduler:
 // 1. Requests to start, cancel, or finish fetching a resource.
 // 2. Notifications for renderer events, such as new tabs, navigation and
 //    painting.
 //
 // These input come from different threads, so they may not be in sync. The UI
 // 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 ScheduledResourceRequest 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
@@ skipping 36 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);
+  // specified |url_request|. Caller should delete the returned
+  // ScheduledResourceRequest when the load completes or is canceled.
+  scoped_ptr<ScheduledResourceRequest> 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 48 matching lines @@
   enum ClientState {
     // Observable client.
     ACTIVE,
     // Non-observable client.
     BACKGROUND,
     // No client found.
     UNKNOWN,
   };
 
   class RequestQueue;
-  class ScheduledResourceRequest;
+  class ScheduledResourceRequestImpl;
   struct RequestPriorityParams;
   struct ScheduledResourceSorter {
-    bool operator()(const ScheduledResourceRequest* a,
-                    const ScheduledResourceRequest* b) const;
+    bool operator()(const ScheduledResourceRequestImpl* a,
+                    const ScheduledResourceRequestImpl* b) const;
   };
   class Client;
 
   typedef int64 ClientId;
   typedef std::map<ClientId, Client*> ClientMap;
-  typedef std::set<ScheduledResourceRequest*> RequestSet;
+  typedef std::set<ScheduledResourceRequestImpl*> RequestSet;
 
-  // Called when a ScheduledResourceRequest is destroyed.
-  void RemoveRequest(ScheduledResourceRequest* request);
+  // Called when a ScheduledResourceRequestImpl is destroyed.
+  void RemoveRequest(ScheduledResourceRequestImpl* request);
 
   // 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();
 
   void OnLoadingActiveClientsStateChangedForAllClients();
@@ skipping 12 matching lines @@
   // 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,
+  void ReprioritizeRequest(ScheduledResourceRequestImpl* 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_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_SCHEDULER_H_