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

content/browser/loader/resource_dispatcher_host_impl.cc

 // 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <algorithm>
 #include <set>
@@ skipping 18 matching lines @@
 #include "base/time/time.h"
 #include "content/browser/appcache/appcache_interceptor.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/cert_store_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/download/save_file_manager.h"
 #include "content/browser/download/save_file_resource_handler.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
+#include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/loader/async_resource_handler.h"
 #include "content/browser/loader/async_revalidation_manager.h"
 #include "content/browser/loader/cross_site_resource_handler.h"
 #include "content/browser/loader/detachable_resource_handler.h"
 #include "content/browser/loader/mime_type_resource_handler.h"
 #include "content/browser/loader/navigation_resource_handler.h"
 #include "content/browser/loader/navigation_resource_throttle.h"
 #include "content/browser/loader/navigation_url_loader_impl_core.h"
@@ skipping 510 matching lines @@
       pending_loaders_.erase(i++);
     } else {
       ++i;
     }
   }
 
   for (BlockedLoadersMap::iterator i = blocked_loaders_map_.begin();
        i != blocked_loaders_map_.end();) {
     BlockedLoadersList* loaders = i->second;
     if (loaders->empty()) {
-      // This can happen if BlockRequestsForRoute() has been called for a route,
+      // This can happen if BlockRequestsForFrame() has been called for a route,
       // but we haven't blocked any matching requests yet.
       ++i;
       continue;
     }
     ResourceRequestInfoImpl* info = loaders->front()->GetRequestInfo();
     if (info->GetContext() == context) {
       blocked_loaders_map_.erase(i++);
       for (BlockedLoadersList::const_iterator it = loaders->begin();
            it != loaders->end(); ++it) {
         linked_ptr<ResourceLoader> loader = *it;
@@ skipping 464 matching lines @@
   is_shutdown_ = true;
   pending_loaders_.clear();
 
   // Make sure we shutdown the timer now, otherwise by the time our destructor
   // runs if the timer is still running the Task is deleted twice (once by
   // the MessageLoop and the second time by RepeatingTimer).
   update_load_states_timer_.reset();
 
   // Clear blocked requests if any left.
   // Note that we have to do this in 2 passes as we cannot call
-  // CancelBlockedRequestsForRoute while iterating over
+  // CancelBlockedRequestsForFrame while iterating over
   // blocked_loaders_map_, as it modifies it.
-  std::set<GlobalRoutingID> ids;
+  std::set<GlobalFrameRoutingID> ids;
   for (BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.begin();
        iter != blocked_loaders_map_.end(); ++iter) {
-    std::pair<std::set<GlobalRoutingID>::iterator, bool> result =
+    std::pair<std::set<GlobalFrameRoutingID>::iterator, bool> result =
         ids.insert(iter->first);
     // We should not have duplicates.
     DCHECK(result.second);
   }
-  for (std::set<GlobalRoutingID>::const_iterator iter = ids.begin();
+  for (std::set<GlobalFrameRoutingID>::const_iterator iter = ids.begin();
        iter != ids.end(); ++iter) {
-    CancelBlockedRequestsForRoute(iter->child_id, iter->route_id);
+    CancelBlockedRequestsForFrame(iter->child_id, iter->route_id);
   }
 
   scheduler_.reset();
 }
 
 bool ResourceDispatcherHostImpl::OnMessageReceived(
     const IPC::Message& message,
     ResourceMessageFilter* filter) {
   filter_ = filter;
   bool handled = true;
@@ skipping 73 matching lines @@
                sync_result->routing_id());
 }
 
 void ResourceDispatcherHostImpl::UpdateRequestForTransfer(
     int child_id,
     int route_id,
     int request_id,
     const ResourceHostMsg_Request& request_data,
     const linked_ptr<ResourceLoader>& loader) {
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
-  GlobalRoutingID old_routing_id(
-      request_data.transferred_request_child_id, info->GetRouteID());
+  GlobalFrameRoutingID old_routing_id(request_data.transferred_request_child_id,
+                                      info->GetRenderFrameID());
   GlobalRequestID old_request_id(request_data.transferred_request_child_id,
                                  request_data.transferred_request_request_id);
-  GlobalRoutingID new_routing_id(child_id, route_id);
+  GlobalFrameRoutingID new_routing_id(child_id, request_data.render_frame_id);
   GlobalRequestID new_request_id(child_id, request_id);
 
   // Clear out data that depends on |info| before updating it.
   // We always need to move the memory stats to the new process.  In contrast,
   // stats.num_requests is only tracked for some requests (those that require
   // file descriptors for their shared memory buffer).
   IncrementOutstandingRequestsMemory(-1, *info);
   bool should_update_count = info->counted_as_in_flight_request();
   if (should_update_count)
     IncrementOutstandingRequestsCount(-1, info);
   pending_loaders_.erase(old_request_id);
 
   // ResourceHandlers should always get state related to the request from the
   // ResourceRequestInfo rather than caching it locally.  This lets us update
   // the info object when a transfer occurs.
   info->UpdateForTransfer(child_id, route_id, request_data.origin_pid,
-                          request_id, request_data.parent_render_frame_id,
+                          request_id, request_data.render_frame_id,
+                          request_data.parent_render_frame_id,
                           filter_->GetWeakPtr());
 
   // Update maps that used the old IDs, if necessary.  Some transfers in tests
   // do not actually use a different ID, so not all maps need to be updated.
   pending_loaders_[new_request_id] = loader;
   IncrementOutstandingRequestsMemory(1, *info);
   if (should_update_count)
     IncrementOutstandingRequestsCount(1, info);
   if (old_routing_id != new_routing_id) {
     if (blocked_loaders_map_.find(old_routing_id) !=
@@ skipping 529 matching lines @@
       blink::WebReferrerPolicyDefault,
       blink::WebPageVisibilityStateVisible,
       context,
       base::WeakPtr<ResourceMessageFilter>(),  // filter
       false,                                   // report_raw_headers
       true,                                    // is_async
       false,                                   // is_using_lofi
       std::string());                          // original_headers
 }
 
+void ResourceDispatcherHostImpl::OnRenderFrameHostDeleted(int child_id,
+                                                          int route_id) {
+  CancelRequestsForFrame(child_id, route_id);
+}
+
 void ResourceDispatcherHostImpl::OnRenderViewHostCreated(int child_id,
                                                          int route_id,
                                                          bool is_visible,
                                                          bool is_audible) {
   scheduler_->OnClientCreated(child_id, route_id, is_visible, is_audible);
 }
 
-void ResourceDispatcherHostImpl::OnRenderViewHostDeleted(
-    int child_id,
-    int route_id) {
+void ResourceDispatcherHostImpl::OnRenderViewHostDeleted(int child_id,
+                                                         int route_id) {
   scheduler_->OnClientDeleted(child_id, route_id);
-  CancelRequestsForRoute(child_id, route_id);
 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostSetIsLoading(int child_id,
                                                               int route_id,
                                                               bool is_loading) {
   scheduler_->OnLoadingStateChanged(child_id, route_id, !is_loading);
 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostWasHidden(
     int child_id,
@@ skipping 88 matching lines @@
   ResourceLoader* loader = GetLoader(id);
   // The response we were meant to resume could have already been canceled.
   if (loader)
     loader->CompleteTransfer();
 }
 
 // The object died, so cancel and detach all requests associated with it except
 // for downloads and detachable resources, which belong to the browser process
 // even if initiated via a renderer.
 void ResourceDispatcherHostImpl::CancelRequestsForProcess(int child_id) {
-  CancelRequestsForRoute(child_id, -1 /* cancel all */);
+  CancelRequestsForFrame(child_id, -1 /* cancel all */);
   registered_temp_files_.erase(child_id);
 }
 
-void ResourceDispatcherHostImpl::CancelRequestsForRoute(int child_id,
+void ResourceDispatcherHostImpl::CancelRequestsForFrame(int child_id,
                                                         int route_id) {
   // Since pending_requests_ is a map, we first build up a list of all of the
   // matching requests to be cancelled, and then we cancel them.  Since there
   // may be more than one request to cancel, we cannot simply hold onto the map
   // iterators found in the first loop.
 
   // Find the global ID of all matching elements.
   bool any_requests_transferring = false;
   std::vector<GlobalRequestID> matching_requests;
   for (LoaderMap::const_iterator i = pending_loaders_.begin();
        i != pending_loaders_.end(); ++i) {
     if (i->first.child_id != child_id)
       continue;
 
     ResourceRequestInfoImpl* info = i->second->GetRequestInfo();
 
     GlobalRequestID id(child_id, i->first.request_id);
     DCHECK(id == i->first);
     // Don't cancel navigations that are expected to live beyond this process.
     if (IsTransferredNavigation(id))
       any_requests_transferring = true;
     if (info->detachable_handler()) {
       info->detachable_handler()->Detach();
     } else if (!info->IsDownload() && !info->is_stream() &&
                !IsTransferredNavigation(id) &&
-               (route_id == -1 || route_id == info->GetRouteID())) {
+               (route_id == -1 || route_id == info->GetRenderFrameID())) {
       matching_requests.push_back(id);
     }
   }
 
   // Remove matches.
   for (size_t i = 0; i < matching_requests.size(); ++i) {
     LoaderMap::iterator iter = pending_loaders_.find(matching_requests[i]);
     // Although every matching request was in pending_requests_ when we built
     // matching_requests, it is normal for a matching request to be not found
     // in pending_requests_ after we have removed some matching requests from
@@ skipping 10 matching lines @@
   // Don't clear the blocked loaders or offline policy maps if any of the
   // requests in route_id are being transferred to a new process, since those
   // maps will be updated with the new route_id after the transfer.  Otherwise
   // we will lose track of this info when the old route goes away, before the
   // new one is created.
   if (any_requests_transferring)
     return;
 
   // Now deal with blocked requests if any.
   if (route_id != -1) {
-    if (blocked_loaders_map_.find(GlobalRoutingID(child_id, route_id)) !=
+    if (blocked_loaders_map_.find(GlobalFrameRoutingID(child_id, route_id)) !=
         blocked_loaders_map_.end()) {
-      CancelBlockedRequestsForRoute(child_id, route_id);
+      CancelBlockedRequestsForFrame(child_id, route_id);
     }
   } else {
     // We have to do all render views for the process |child_id|.
     // Note that we have to do this in 2 passes as we cannot call
-    // CancelBlockedRequestsForRoute while iterating over
-    // blocked_loaders_map_, as it modifies it.
+    // CancelBlockedRequestsForFrame while iterating over
+    // blocked_loaders_map_, as blocking requests  modifies the map.
     std::set<int> route_ids;
     for (BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.begin();
          iter != blocked_loaders_map_.end(); ++iter) {
       if (iter->first.child_id == child_id)
         route_ids.insert(iter->first.route_id);
     }
     for (std::set<int>::const_iterator iter = route_ids.begin();
         iter != route_ids.end(); ++iter) {
-      CancelBlockedRequestsForRoute(child_id, *iter);
+      CancelBlockedRequestsForFrame(child_id, *iter);
     }
   }
 }
 
 // Cancels the request and removes it from the list.
 void ResourceDispatcherHostImpl::RemovePendingRequest(int child_id,
                                                       int request_id) {
   LoaderMap::iterator i = pending_loaders_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_loaders_.end()) {
@@ skipping 326 matching lines @@
     IncrementOutstandingRequestsMemory(-1, *info);
 
     // A ResourceHandler must not outlive its associated URLRequest.
     handler.reset();
     return;
   }
 
   linked_ptr<ResourceLoader> loader(
       new ResourceLoader(request.Pass(), handler.Pass(), this));
 
-  GlobalRoutingID id(info->GetGlobalRoutingID());
+  GlobalFrameRoutingID id(info->GetChildID(), info->GetRenderFrameID());
   BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.find(id);
   if (iter != blocked_loaders_map_.end()) {
     // The request should be blocked.
     iter->second->push_back(loader);
     return;
   }
 
   StartLoading(info, loader);
 }
 
@@ skipping 101 matching lines @@
     update_load_states_timer_->Stop();
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&ResourceDispatcherHostImpl::UpdateLoadInfoOnUIThread,
                  base::Passed(&info_map)));
 }
 
-void ResourceDispatcherHostImpl::BlockRequestsForRoute(int child_id,
+void ResourceDispatcherHostImpl::BlockRequestsForFrame(int child_id,
                                                        int route_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  GlobalRoutingID key(child_id, route_id);
-  DCHECK(blocked_loaders_map_.find(key) == blocked_loaders_map_.end()) <<
-      "BlockRequestsForRoute called  multiple time for the same RVH";
+  GlobalFrameRoutingID key(child_id, route_id);
+  DCHECK(blocked_loaders_map_.find(key) == blocked_loaders_map_.end())
+      << "BlockRequestsForFrame called  multiple time for the same RVH";
   blocked_loaders_map_[key] = new BlockedLoadersList();
 }
 
-void ResourceDispatcherHostImpl::ResumeBlockedRequestsForRoute(int child_id,
+void ResourceDispatcherHostImpl::ResumeBlockedRequestsForFrame(int child_id,
                                                                int route_id) {
-  ProcessBlockedRequestsForRoute(child_id, route_id, false);
+  ProcessBlockedRequestsForFrame(child_id, route_id, false);
 }
 
-void ResourceDispatcherHostImpl::CancelBlockedRequestsForRoute(int child_id,
+void ResourceDispatcherHostImpl::CancelBlockedRequestsForFrame(int child_id,
                                                                int route_id) {
-  ProcessBlockedRequestsForRoute(child_id, route_id, true);
+  ProcessBlockedRequestsForFrame(child_id, route_id, true);
 }
 
-void ResourceDispatcherHostImpl::ProcessBlockedRequestsForRoute(
+void ResourceDispatcherHostImpl::ProcessBlockedRequestsForFrame(
     int child_id,
     int route_id,
     bool cancel_requests) {
-  BlockedLoadersMap::iterator iter = blocked_loaders_map_.find(
-      GlobalRoutingID(child_id, route_id));
+  BlockedLoadersMap::iterator iter =
+      blocked_loaders_map_.find(GlobalFrameRoutingID(child_id, route_id));
   if (iter == blocked_loaders_map_.end()) {
     // It's possible to reach here if the renderer crashed while an interstitial
     // page was showing.
     return;
   }
 
   BlockedLoadersList* loaders = iter->second;
 
   // Removing the vector from the map unblocks any subsequent requests.
   blocked_loaders_map_.erase(iter);
@@ skipping 98 matching lines @@
     load_flags |= net::LOAD_PREFETCH;
   }
 
   if (is_sync_load)
     load_flags |= net::LOAD_IGNORE_LIMITS;
 
   return load_flags;
 }
 
 }  // namespace content