Blocking resource request for hidden page when interstitial showing

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2006-2008 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 <vector>
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
@@ skipping 118 matching lines @@
       safe_browsing_(new SafeBrowsingService),
       request_id_(-1),
       plugin_service_(PluginService::GetInstance()),
       method_runner_(this),
       is_shutdown_(false) {
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
+
+  // Clear blocked requests if any left.
+  // Note that we have to do this in 2 passes as we cannot call
+  // CancelBlockedRequestsForRenderView while iterating over
+  // blocked_requests_map_, as it modifies it.
+  std::set<ProcessRendererIDs> ids;
+  for (BlockedRequestMap::const_iterator iter = blocked_requests_map_.begin();
+       iter != blocked_requests_map_.end(); ++iter) {
+    std::pair<std::set<ProcessRendererIDs>::iterator, bool> result =
+        ids.insert(iter->first);
+    // We should not have duplicates.
+    DCHECK(result.second);
+  }
+  for (std::set<ProcessRendererIDs>::const_iterator iter = ids.begin();
+       iter != ids.end(); ++iter) {
+    CancelBlockedRequestsForRenderView(iter->first, iter->second);
+  }
 }
 
 void ResourceDispatcherHost::Initialize() {
   DCHECK(MessageLoop::current() == ui_loop_);
   download_file_manager_->Initialize();
   safe_browsing_->Initialize(io_loop_);
 }
 
 void ResourceDispatcherHost::Shutdown() {
   DCHECK(MessageLoop::current() == ui_loop_);
@@ skipping 455 matching lines @@
     // matching_requests, it is normal for a matching request to be not found
     // in pending_requests_ after we have removed some matching requests from
     // pending_requests_.  For example, deleting a URLRequest that has
     // exclusive (write) access to an HTTP cache entry may unblock another
     // URLRequest that needs exclusive access to the same cache entry, and
     // that URLRequest may complete and remove itself from pending_requests_.
     // So we need to check that iter is not equal to pending_requests_.end().
     if (iter != pending_requests_.end())
       RemovePendingRequest(iter);
   }
+
+  // Now deal with blocked requests if any.
+  if (render_view_id != -1) {
+    if (blocked_requests_map_.find(std::pair<int, int>(render_process_host_id,
+                                                       render_view_id)) !=
+        blocked_requests_map_.end()) {
+      CancelBlockedRequestsForRenderView(render_process_host_id,
+                                         render_view_id);
+    }
+  } else {
+    // We have to do all render views for the process |render_process_host_id|.
+    // Note that we have to do this in 2 passes as we cannot call
+    // CancelBlockedRequestsForRenderView while iterating over
+    // blocked_requests_map_, as it modifies it.
+    std::set<int> render_view_ids;
+    for (BlockedRequestMap::const_iterator iter = blocked_requests_map_.begin();
+         iter != blocked_requests_map_.end(); ++iter) {
+      if (iter->first.first == render_process_host_id)
+        render_view_ids.insert(iter->first.second);
+    }
+    for (std::set<int>::const_iterator iter = render_view_ids.begin();
+        iter != render_view_ids.end(); ++iter) {
+      CancelBlockedRequestsForRenderView(render_process_host_id, *iter);
+    }
+  }
 }
 
 // Cancels the request and removes it from the list.
 void ResourceDispatcherHost::RemovePendingRequest(int render_process_host_id,
                                                   int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(render_process_host_id, request_id));
   if (i == pending_requests_.end()) {
     NOTREACHED() << "Trying to remove a request that's not here";
     return;
@@ skipping 148 matching lines @@
   }
 
   NotifyResponseStarted(request, info->render_process_host_id);
   return info->resource_handler->OnResponseStarted(info->request_id,
                                                    response.get());
 }
 
 void ResourceDispatcherHost::BeginRequestInternal(URLRequest* request,
                                                   bool mixed_content) {
   ExtraRequestInfo* info = ExtraInfoForRequest(request);
+
+  std::pair<int, int> pair_id(info->render_process_host_id,
+                              info->render_view_id);
+  BlockedRequestMap::const_iterator iter = blocked_requests_map_.find(pair_id);
+  if (iter != blocked_requests_map_.end()) {
+    // The request should be blocked.
+    iter->second->push_back(BlockedRequest(request, mixed_content));
+    return;
+  }
+
   GlobalRequestID global_id(info->render_process_host_id, info->request_id);
   pending_requests_[global_id] = request;
   if (mixed_content) {
     // We don't start the request in that case.  The SSLManager will potentially
     // change the request (potentially to indicate its content should be
     // filtered) and start it itself.
     SSLManager::OnMixedContentRequest(this, request, ui_loop_);
     return;
   }
   request->Start();
@@ skipping 416 matching lines @@
   bool enough_new_progress = (amt_since_last > (size / kHalfPercentIncrements));
   bool too_much_time_passed = time_since_last > kOneSecond;
 
   if (is_finished || enough_new_progress || too_much_time_passed) {
     info->resource_handler->OnUploadProgress(info->request_id, position, size);
     info->waiting_for_upload_progress_ack = true;
     info->last_upload_ticks = TimeTicks::Now();
     info->last_upload_position = position;
   }
 }
+
+void ResourceDispatcherHost::BlockRequestsForRenderView(
+    int render_process_host_id,
+    int render_view_id) {
+  std::pair<int, int> key(render_process_host_id, render_view_id);
+  DCHECK(blocked_requests_map_.find(key) == blocked_requests_map_.end()) <<
+      "BlockRequestsForRenderView called  multiple time for the same RVH";
+  blocked_requests_map_[key] = new BlockedRequestsList();
+}
+
+void ResourceDispatcherHost::ResumeBlockedRequestsForRenderView(
+    int render_process_host_id,
+    int render_view_id) {
+  ProcessBlockedRequestsForRenderView(render_process_host_id,
+                                      render_view_id, false);
+}
+
+void ResourceDispatcherHost::CancelBlockedRequestsForRenderView(
+    int render_process_host_id,
+    int render_view_id) {
+  ProcessBlockedRequestsForRenderView(render_process_host_id,
+                                      render_view_id, true);
+}
+
+void ResourceDispatcherHost::ProcessBlockedRequestsForRenderView(
+    int render_process_host_id,
+    int render_view_id,
+    bool cancel_requests) {
+  BlockedRequestMap::iterator iter =
+      blocked_requests_map_.find(std::pair<int, int>(render_process_host_id,
+                                                     render_view_id));
+  if (iter == blocked_requests_map_.end()) {
+    NOTREACHED();
+    return;
+  }
+
+  BlockedRequestsList* requests = iter->second;
+
+  // Removing the vector from the map unblocks any subsequent requests.
+  blocked_requests_map_.erase(iter);
+
+  for (BlockedRequestsList::iterator req_iter = requests->begin();
+       req_iter != requests->end(); ++req_iter) {
+    if (cancel_requests)
+      delete req_iter->url_request;
+    else
+      BeginRequestInternal(req_iter->url_request, req_iter->mixed_content);
+  }
+
+  delete requests;
+}