[RDHI] Refactored blocked_loaders_map_ to key by render frame route id

content/browser/loader/resource_dispatcher_host_impl.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.
 
 // This is the browser side of the resource dispatcher, it receives requests
 // from the child process (i.e. [Renderer, Plugin, Worker]ProcessHost), and
 // dispatches them to URLRequests. It then forwards the messages from the
 // URLRequests back to the correct process for handling.
 //
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
@@ skipping 20 matching lines @@
 #include "content/browser/loader/resource_loader.h"
 #include "content/browser/loader/resource_loader_delegate.h"
 #include "content/browser/loader/resource_scheduler.h"
 #include "content/common/content_export.h"
 #include "content/common/resource_request_body.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_dispatcher_host.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/resource_type.h"
 #include "ipc/ipc_message.h"
 #include "net/base/request_priority.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/url_request/url_request.h"
 
 class ResourceHandler;
 struct ResourceHostMsg_Request;
 
 namespace base {
 class FilePath;
 }
 
 namespace net {
 class URLRequestJobFactory;
 }
 
 namespace storage {
 class ShareableFileReference;
 }
 
 namespace content {
 class AppCacheService;
 class AsyncRevalidationManager;
+class FrameTree;
 class NavigationURLLoaderImplCore;
 class ResourceContext;
 class ResourceDispatcherHostDelegate;
 class ResourceMessageDelegate;
 class ResourceMessageFilter;
 class ResourceRequestInfoImpl;
 class SaveFileManager;
 class ServiceWorkerNavigationHandleCore;
 class WebContentsImpl;
 struct CommonNavigationParams;
 struct DownloadSaveInfo;
 struct NavigationRequestInfo;
 struct Referrer;
 
+// This class is responsible for notifying the IO thread (specifically, the
+// ResourceDispatcherHostImpl) of frame events. It has an interace for callers
+// to use and also sends notifications on WebContentsObserver events. All
+// methods (static or class) will be called from the UI thread and post to the
+// IO
+// thread.
+// TODO(csharrison): Add methods tracking visibility and audio changes, to
+// propogate to the ResourceScheduler.
+class LoaderIOThreadNotifier : public WebContentsObserver {
+ public:
+  explicit LoaderIOThreadNotifier(WebContents* web_contents);
+  ~LoaderIOThreadNotifier() override;
+
+  // content::WebContentsObserver:
+  void RenderFrameDeleted(RenderFrameHost* render_frame_host) override;
+};
+
 class CONTENT_EXPORT ResourceDispatcherHostImpl
     : public ResourceDispatcherHost,
       public ResourceLoaderDelegate {
  public:
   ResourceDispatcherHostImpl();
   ~ResourceDispatcherHostImpl() override;
 
   // Returns the current ResourceDispatcherHostImpl. May return NULL if it
   // hasn't been created yet.
   static ResourceDispatcherHostImpl* Get();
 
+  // This method notifies the RDHI concerning the status of an entire frame
+  // tree. This will correspond to page-level events affecting resource loading.
+  static void NotifyForEachFrame(
+      FrameTree* frame_tree,
+      base::Callback<void(ResourceDispatcherHostImpl*,
+                          const GlobalFrameRoutingId&)> frame_callback);
+
+  // This method notifies the RDHI concerning the status of a frame. Consumers
+  // should use the public ResourceDispatcherHost static methods if the

[nasko, 2016/01/20 22:22:09]

nit: Well, this *is* a public static method : ). Let's say "content/public" or
something else to emphasize that it is the content/ public interface methods.

[Charlie Harrison, 2016/01/21 18:52:55]

Done.

+  // RenderFrameHost is available.
+  static void NotifyForRoute(const GlobalFrameRoutingId& routing_id,
+                             base::Callback<void(ResourceDispatcherHostImpl*,
+                                                 const GlobalFrameRoutingId&)>
+                                 frame_callback);
+
   // ResourceDispatcherHost implementation:
   void SetDelegate(ResourceDispatcherHostDelegate* delegate) override;
   void SetAllowCrossOriginAuthPrompt(bool value) override;
   DownloadInterruptReason BeginDownload(
       scoped_ptr<net::URLRequest> request,
       const Referrer& referrer,
       bool is_content_initiated,
       ResourceContext* context,
       int child_id,
       int render_view_route_id,
       int render_frame_route_id,
       bool prefer_cache,
       bool do_not_prompt_for_login,
       scoped_ptr<DownloadSaveInfo> save_info,
       uint32_t download_id,
       const DownloadStartedCallback& started_callback) override;
   void ClearLoginDelegateForRequest(net::URLRequest* request) override;
-  void BlockRequestsForRoute(int child_id, int route_id) override;
-  void ResumeBlockedRequestsForRoute(int child_id, int route_id) override;
 
   // Puts the resource dispatcher host in an inactive state (unable to begin
   // new requests).  Cancels all pending requests.
   void Shutdown();
 
   // Notify the ResourceDispatcherHostImpl of a new resource context.
   void AddResourceContext(ResourceContext* context);
 
   // Notify the ResourceDispatcherHostImpl of a resource context destruction.
   void RemoveResourceContext(ResourceContext* context);
@@ skipping 49 matching lines @@
   }
 
   // The average private bytes increase of the browser for each new pending
   // request. Experimentally obtained.
   static const int kAvgBytesPerOutstandingRequest = 4400;
 
   SaveFileManager* save_file_manager() const {
     return save_file_manager_.get();
   }
 
+  void OnRenderFrameDeleted(const GlobalFrameRoutingId& routing_id);
+
   // Called when a RenderViewHost is created.
   void OnRenderViewHostCreated(int child_id,
                                int route_id,
                                bool is_visible,
                                bool is_audible);
 
   // Called when a RenderViewHost is deleted.
   void OnRenderViewHostDeleted(int child_id, int route_id);
 
   // Called when a RenderViewHost starts or stops loading.
@@ skipping 15 matching lines @@
   // Force cancels any pending requests for the given process.
   void CancelRequestsForProcess(int child_id);
 
   void OnUserGesture(WebContentsImpl* contents);
 
   // Retrieves a net::URLRequest.  Must be called from the IO thread.
   net::URLRequest* GetURLRequest(const GlobalRequestID& request_id);
 
   void RemovePendingRequest(int child_id, int request_id);
 
+  // Causes all new requests for the route identified by |routing_id| to be
+  // blocked (not being started) until ResumeBlockedRequestsForRoute is called.
+  void BlockRequestsForRoute(const GlobalFrameRoutingId& routing_id);
+
+  // Resumes any blocked request for the specified route id.
+  void ResumeBlockedRequestsForRoute(const GlobalFrameRoutingId& routing_id);
+
   // Cancels any blocked request for the specified route id.
-  void CancelBlockedRequestsForRoute(int child_id, int route_id);
+  void CancelBlockedRequestsForRoute(const GlobalFrameRoutingId& routing_id);
 
   // Maintains a collection of temp files created in support of
   // the download_to_file capability. Used to grant access to the
   // child process and to defer deletion of the file until it's
   // no longer needed.
   void RegisterDownloadedTempFile(
       int child_id, int request_id,
       const base::FilePath& file_path);
   void UnregisterDownloadedTempFile(int child_id, int request_id);
 
@@ skipping 145 matching lines @@
   // buffer. |count| indicates whether the request is issuing or finishing.
   // |count| must be 1 or -1.
   OustandingRequestsStats IncrementOutstandingRequestsCount(
       int count,
       ResourceRequestInfoImpl* info);
 
   // Estimate how much heap space |request| will consume to run.
   static int CalculateApproximateMemoryCost(net::URLRequest* request);
 
   // Force cancels any pending requests for the given route id.  This method
-  // acts like CancelRequestsForProcess when route_id is -1.
-  void CancelRequestsForRoute(int child_id, int route_id);
+  // acts like CancelRequestsForProcess when the |route_id| member of
+  // |routing_id| is -1.
+  void CancelRequestsForRoute(const GlobalFrameRoutingId& routing_id);

[nasko, 2016/01/20 22:22:09]

nit: global_routing_id? Otherwise it reads as any other routing id of RFH or
RVH.

[Charlie Harrison, 2016/01/21 18:52:55]

Valid point. For consistency, I'll have to change it everywhere in the file (I
use routing_id to name GlobalFrameRoutingIds). I'll address this in a later
patch (pending architectural changes).

 
   // The list of all requests that we have pending. This list is not really
   // optimized, and assumes that we have relatively few requests pending at once
   // since some operations require brute-force searching of the list.
   //
   // It may be enhanced in the future to provide some kind of prioritization
   // mechanism. We should also consider a hashtable or binary tree if it turns
   // out we have a lot of things here.
   using LoaderMap = std::map<GlobalRequestID, scoped_ptr<ResourceLoader>>;
 
@@ skipping 24 matching lines @@
   // are done as a single callback to avoid spamming the UI thread.
   static void UpdateLoadInfoOnUIThread(scoped_ptr<LoadInfoMap> info_map);
 
   // Gets the most interesting LoadInfo for each GlobalRoutingID.
   scoped_ptr<LoadInfoMap> GetLoadInfoForAllRoutes();
 
   // Checks all pending requests and updates the load info if necessary.
   void UpdateLoadInfo();
 
   // Resumes or cancels (if |cancel_requests| is true) any blocked requests.
-  void ProcessBlockedRequestsForRoute(int child_id,
-                                      int route_id,
+  void ProcessBlockedRequestsForRoute(const GlobalFrameRoutingId& routing_id,
                                       bool cancel_requests);
 
   void OnRequestResource(int routing_id,
                          int request_id,
                          const ResourceHostMsg_Request& request_data);
   void OnSyncLoad(int request_id,
                   const ResourceHostMsg_Request& request_data,
                   IPC::Message* sync_result);
 
   // Update the ResourceRequestInfo and internal maps when a request is
@@ skipping 106 matching lines @@
   // uninitialized variables.) This way, we no longer have the unlikely (but
   // observed in the real world!) event where we have two requests with the same
   // request_id_.
   int request_id_;
 
   // True if the resource dispatcher host has been shut down.
   bool is_shutdown_;
 
   using BlockedLoadersList = std::vector<scoped_ptr<ResourceLoader>>;
   using BlockedLoadersMap =
-      std::map<GlobalRoutingID, scoped_ptr<BlockedLoadersList>>;
+      std::map<GlobalFrameRoutingId, scoped_ptr<BlockedLoadersList>>;
   BlockedLoadersMap blocked_loaders_map_;
 
   // Maps the child_ids to the approximate number of bytes
   // being used to service its resource requests. No entry implies 0 cost.
   typedef std::map<int, OustandingRequestsStats> OutstandingRequestsStatsMap;
   OutstandingRequestsStatsMap outstanding_requests_stats_map_;
 
   // |num_in_flight_requests_| is the total number of requests currently issued
   // summed across all renderers.
   int num_in_flight_requests_;
@@ skipping 45 matching lines @@
   DelegateMap delegate_map_;
 
   scoped_ptr<ResourceScheduler> scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_LOADER_RESOURCE_DISPATCHER_HOST_IMPL_H_