Preliminary work on resuming downloads whose connections have expired.

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2010 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 "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/format_macros.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/stl_util-inl.h"
 #include "base/time.h"
 #include "chrome/browser/cert_store.h"
 #include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/chrome_blob_storage_context.h"
 #include "chrome/browser/cross_site_request_manager.h"
 #include "chrome/browser/download/download_file_manager.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/download/download_request_limiter.h"
+#include "chrome/browser/download/download_util.h"
 #include "chrome/browser/download/save_file_manager.h"
 #include "chrome/browser/extensions/user_script_listener.h"
 #include "chrome/browser/external_protocol_handler.h"
+#include "chrome/browser/history/download_create_info.h"
 #include "chrome/browser/in_process_webkit/webkit_thread.h"
 #include "chrome/browser/login_prompt.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/url_request_tracking.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/async_resource_handler.h"
 #include "chrome/browser/renderer_host/buffered_resource_handler.h"
 #include "chrome/browser/renderer_host/cross_site_resource_handler.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
@@ skipping 81 matching lines @@
 // Maximum byte "cost" of all the outstanding requests for a renderer.
 // See delcaration of |max_outstanding_requests_cost_per_process_| for details.
 // This bound is 25MB, which allows for around 6000 outstanding requests.
 const int kMaxOutstandingRequestsCostPerProcess = 26214400;
 
 // Consults the RendererSecurity policy to determine whether the
 // ResourceDispatcherHost should service this request.  A request might be
 // disallowed if the renderer is not authorized to retrieve the request URL or
 // if the renderer is attempting to upload an unauthorized file.
 bool ShouldServiceRequest(ChildProcessInfo::ProcessType process_type,
-                          int child_id,
+                          int process_unique_id,
                           const ViewHostMsg_Resource_Request& request_data)  {
   if (process_type == ChildProcessInfo::PLUGIN_PROCESS)
     return true;
 
   if (request_data.resource_type == ResourceType::PREFETCH &&
       !ResourceDispatcherHost::is_prefetch_enabled())
     return false;
 
   ChildProcessSecurityPolicy* policy =
       ChildProcessSecurityPolicy::GetInstance();
 
   // Check if the renderer is permitted to request the requested URL.
-  if (!policy->CanRequestURL(child_id, request_data.url)) {
+  if (!policy->CanRequestURL(process_unique_id, request_data.url)) {
     LOG(INFO) << "Denied unauthorized request for " <<
         request_data.url.possibly_invalid_spec();
     return false;
   }
 
   // Check if the renderer is permitted to upload the requested files.
   if (request_data.upload_data) {
     const std::vector<net::UploadData::Element>* uploads =
         request_data.upload_data->elements();
     std::vector<net::UploadData::Element>::const_iterator iter;
     for (iter = uploads->begin(); iter != uploads->end(); ++iter) {
       if (iter->type() == net::UploadData::TYPE_FILE &&
-          !policy->CanUploadFile(child_id, iter->file_path())) {
+          !policy->CanUploadFile(process_unique_id, iter->file_path())) {
         NOTREACHED() << "Denied unauthorized upload of "
                      << iter->file_path().value();
         return false;
       }
     }
   }
 
   return true;
 }
 
@@ skipping 60 matching lines @@
           kMaxOutstandingRequestsCostPerProcess),
       receiver_(NULL) {
   ResourceQueue::DelegateSet resource_queue_delegates;
   resource_queue_delegates.insert(user_script_listener_.get());
   resource_queue_.Initialize(resource_queue_delegates);
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
+  STLDeleteValues(&interrupted_requests_);
 
   user_script_listener_->ShutdownMainThread();
 }
 
 void ResourceDispatcherHost::Initialize() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   webkit_thread_->Initialize();
   safe_browsing_->Initialize();
   ChromeThread::PostTask(
-      ChromeThread::IO, FROM_HERE,
+      ChromeThread::IO,
+      FROM_HERE,
       NewRunnableFunction(&appcache::AppCacheInterceptor::EnsureRegistered));
 }
 
 void ResourceDispatcherHost::Shutdown() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   ChromeThread::PostTask(ChromeThread::IO, FROM_HERE, new ShutdownTask(this));
 }
 
 void ResourceDispatcherHost::SetRequestInfo(
     URLRequest* request,
     ResourceDispatcherHostRequestInfo* info) {
   request->SetUserData(NULL, info);
 }
 
 void ResourceDispatcherHost::OnShutdown() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   is_shutdown_ = true;
   resource_queue_.Shutdown();
   STLDeleteValues(&pending_requests_);
+  STLDeleteValues(&interrupted_requests_);
   // 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_.Stop();
 
   // Clear blocked requests if any left.
   // Note that we have to do this in 2 passes as we cannot call
   // CancelBlockedRequestsForRoute while iterating over
   // blocked_requests_map_, as it modifies it.
   std::set<ProcessRouteIDs> ids;
   for (BlockedRequestMap::const_iterator iter = blocked_requests_map_.begin();
        iter != blocked_requests_map_.end(); ++iter) {
     std::pair<std::set<ProcessRouteIDs>::iterator, bool> result =
         ids.insert(iter->first);
     // We should not have duplicates.
     DCHECK(result.second);
   }
   for (std::set<ProcessRouteIDs>::const_iterator iter = ids.begin();
        iter != ids.end(); ++iter) {
     CancelBlockedRequestsForRoute(iter->first, iter->second);
   }
 }
 
 bool ResourceDispatcherHost::HandleExternalProtocol(int request_id,
-                                                    int child_id,
+                                                    int process_unique_id,
                                                     int route_id,
                                                     const GURL& url,
                                                     ResourceType::Type type,
                                                     ResourceHandler* handler) {
   if (!ResourceType::IsFrame(type) || URLRequest::IsHandledURL(url))
     return false;
 
   ChromeThread::PostTask(
-      ChromeThread::UI, FROM_HERE,
+      ChromeThread::UI,
+      FROM_HERE,
       NewRunnableFunction(
-          &ExternalProtocolHandler::LaunchUrl, url, child_id, route_id));
+          &ExternalProtocolHandler::LaunchUrl,
+          url,
+          process_unique_id,
+          route_id));
 
   handler->OnResponseCompleted(request_id, URLRequestStatus(
                                                URLRequestStatus::FAILED,
                                                net::ERR_ABORTED),
                                std::string());  // No security info necessary.
   return true;
 }
 
 bool ResourceDispatcherHost::OnMessageReceived(const IPC::Message& message,
                                                Receiver* receiver,
@@ skipping 43 matching lines @@
   BeginRequest(request_id, request_data, sync_result,
                sync_result->routing_id());
 }
 
 void ResourceDispatcherHost::BeginRequest(
     int request_id,
     const ViewHostMsg_Resource_Request& request_data,
     IPC::Message* sync_result,  // only valid for sync
     int route_id) {
   ChildProcessInfo::ProcessType process_type = receiver_->type();
-  int child_id = receiver_->id();
+  int child_process_unique_id = receiver_->id();
   ChromeURLRequestContext* context = static_cast<ChromeURLRequestContext*>(
       receiver_->GetRequestContext(request_id, request_data));
   if (!context) {
     URLRequestContextGetter* context_getter =
         Profile::GetDefaultRequestContext();
     if (context_getter) {
       context = static_cast<ChromeURLRequestContext*>(
           context_getter->GetURLRequestContext());
     }
   }
 
   // Might need to resolve the blob references in the upload data.
   if (request_data.upload_data) {
     context->blob_storage_context()->controller()->
         ResolveBlobReferencesInUploadData(request_data.upload_data.get());
   }
 
-  if (is_shutdown_ ||
-      !ShouldServiceRequest(process_type, child_id, request_data)) {
+  if (is_shutdown_ || !ShouldServiceRequest(process_type,
+                                            child_process_unique_id,
+                                            request_data)) {
     URLRequestStatus status(URLRequestStatus::FAILED, net::ERR_ABORTED);
     if (sync_result) {
       SyncLoadResult result;
       result.status = status;
       ViewHostMsg_SyncLoad::WriteReplyParams(sync_result, result);
       receiver_->Send(sync_result);
     } else {
       // Tell the renderer that this request was disallowed.
       receiver_->Send(new ViewMsg_Resource_RequestComplete(
           route_id,
           request_id,
           status,
           std::string(),   // No security info needed, connection was not
           base::Time()));  // established.
     }
     return;
   }
 
   // Ensure the Chrome plugins are loaded, as they may intercept network
   // requests.  Does nothing if they are already loaded.
   // TODO(mpcomplete): This takes 200 ms!  Investigate parallelizing this by
   // starting the load earlier in a BG thread.
   PluginService::GetInstance()->LoadChromePlugins(this);
 
   // Construct the event handler.
   scoped_refptr<ResourceHandler> handler;
   if (sync_result) {
     handler = new SyncResourceHandler(receiver_,
-                                      child_id,
+                                      child_process_unique_id,
                                       request_data.url,
                                       sync_result,
                                       this);
   } else {
     handler = new AsyncResourceHandler(receiver_,
-                                       child_id,
+                                       child_process_unique_id,
                                        route_id,
                                        receiver_->handle(),
                                        request_data.url,
                                        this);
   }
 
   if (request_data.download_to_file)
-    handler = new RedirectToFileResourceHandler(handler, child_id, this);
+    handler = new RedirectToFileResourceHandler(handler,
+                                                child_process_unique_id,
+                                                this);
 
-  if (HandleExternalProtocol(request_id, child_id, route_id,
+  if (HandleExternalProtocol(request_id, child_process_unique_id, route_id,
                              request_data.url, request_data.resource_type,
                              handler)) {
     return;
   }
 
   // Construct the request.
   URLRequest* request = new URLRequest(request_data.url, this);
   request->set_method(request_data.method);
   request->set_first_party_for_cookies(request_data.first_party_for_cookies);
   request->set_referrer(CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 22 matching lines @@
     upload_size = request_data.upload_data->GetContentLength();
   }
 
   // Install a CrossSiteResourceHandler if this request is coming from a
   // RenderViewHost with a pending cross-site request.  We only check this for
   // MAIN_FRAME requests. Unblock requests only come from a blocked page, do
   // not count as cross-site, otherwise it gets blocked indefinitely.
   if (request_data.resource_type == ResourceType::MAIN_FRAME &&
       process_type == ChildProcessInfo::RENDER_PROCESS &&
       Singleton<CrossSiteRequestManager>::get()->
-          HasPendingCrossSiteRequest(child_id, route_id)) {
+          HasPendingCrossSiteRequest(child_process_unique_id, route_id)) {
     // Wrap the event handler to be sure the current page's onunload handler
     // has a chance to run before we render the new page.
     handler = new CrossSiteResourceHandler(handler,
-                                           child_id,
+                                           child_process_unique_id,
                                            route_id,
                                            this);
   }
 
   // Insert a buffered event handler before the actual one.
   handler = new BufferedResourceHandler(handler, this, request);
 
   // Insert safe browsing at the front of the chain, so it gets to decide
   // on policies first.
   if (safe_browsing_->enabled()) {
-    handler = CreateSafeBrowsingResourceHandler(handler, child_id, route_id,
+    handler = CreateSafeBrowsingResourceHandler(handler,
+                                                child_process_unique_id,
+                                                route_id,
                                                 request_data.resource_type);
   }
 
 #if defined(OS_CHROMEOS)
   // We check offline first, then check safe browsing so that we still can block
   // unsafe site after we remove offline page.
-  handler =
-      new OfflineResourceHandler(handler, child_id, route_id, this, request);
+  handler = new OfflineResourceHandler(handler,
+                                       child_process_unique_id,
+                                       route_id,
+                                       this,
+                                       request);
 #endif
 
   // Make extra info and read footer (contains request ID).
   ResourceDispatcherHostRequestInfo* extra_info =
       new ResourceDispatcherHostRequestInfo(
           handler,
           process_type,
-          child_id,
+          child_process_unique_id,
           route_id,
           request_id,
           request_data.frame_origin,
           request_data.main_frame_origin,
           request_data.resource_type,
           upload_size,
           false,  // is download
           ResourceType::IsFrame(request_data.resource_type), // allow_download
           request_data.host_renderer_id,
           request_data.host_render_view_id);
   ApplyExtensionLocalizationFilter(request_data.url, request_data.resource_type,
                                    extra_info);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
   chrome_browser_net::SetOriginProcessUniqueIDForRequest(
       request_data.origin_child_id, request);
 
   // Have the appcache associate its extra info with the request.
   appcache::AppCacheInterceptor::SetExtraRequestInfo(
-      request, context ? context->appcache_service() : NULL, child_id,
-      request_data.appcache_host_id, request_data.resource_type);
+      request,
+      context ? context->appcache_service() : NULL,
+      child_process_unique_id,
+      request_data.appcache_host_id,
+      request_data.resource_type);
 
   BeginRequestInternal(request);
 }
 
 void ResourceDispatcherHost::OnDataReceivedACK(int request_id) {
   DataReceivedACK(receiver_->id(), request_id);
 }
 
-void ResourceDispatcherHost::DataReceivedACK(int child_id,
+void ResourceDispatcherHost::DataReceivedACK(int process_unique_id,
                                              int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
-      GlobalRequestID(child_id, request_id));
+      GlobalRequestID(process_unique_id, request_id));
   if (i == pending_requests_.end())
     return;
 
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
 
   // Decrement the number of pending data messages.
   info->DecrementPendingDataCount();
 
   // If the pending data count was higher than the max, resume the request.
   if (info->pending_data_count() == kMaxPendingDataMessages) {
     // Decrement the pending data count one more time because we also
     // incremented it before pausing the request.
     info->DecrementPendingDataCount();
 
     // Resume the request.
-    PauseRequest(child_id, request_id, false);
+    PauseRequest(process_unique_id, request_id, false);
   }
 }
 
 bool ResourceDispatcherHost::Send(IPC::Message* message) {
   delete message;
   return false;
 }
 
 void ResourceDispatcherHost::OnUploadProgressACK(int request_id) {
-  int child_id = receiver_->id();
+  int child_process_unique_id = receiver_->id();
   PendingRequestList::iterator i = pending_requests_.find(
-      GlobalRequestID(child_id, request_id));
+      GlobalRequestID(child_process_unique_id, request_id));
   if (i == pending_requests_.end())
     return;
 
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
   info->set_waiting_for_upload_progress_ack(false);
 }
 
 void ResourceDispatcherHost::OnCancelRequest(int request_id) {
   CancelRequest(receiver_->id(), request_id, true);
 }
 
 void ResourceDispatcherHost::OnFollowRedirect(
     int request_id,
     bool has_new_first_party_for_cookies,
     const GURL& new_first_party_for_cookies) {
   FollowDeferredRedirect(receiver_->id(), request_id,
                          has_new_first_party_for_cookies,
                          new_first_party_for_cookies);
 }
 
 ResourceHandler* ResourceDispatcherHost::CreateSafeBrowsingResourceHandler(
-    ResourceHandler* handler, int child_id, int route_id,
+    ResourceHandler* handler, int process_unique_id, int route_id,
     ResourceType::Type resource_type) {
   return new SafeBrowsingResourceHandler(handler,
-                                         child_id,
+                                         process_unique_id,
                                          route_id,
                                          resource_type,
                                          safe_browsing_,
                                          this,
                                          receiver_);
 }
 
 ResourceDispatcherHostRequestInfo*
 ResourceDispatcherHost::CreateRequestInfoForBrowserRequest(
-    ResourceHandler* handler, int child_id, int route_id, bool download) {
+    ResourceHandler* handler,
+    int process_unique_id,
+    int route_id,
+    bool download) {
   return new ResourceDispatcherHostRequestInfo(handler,
                                                ChildProcessInfo::RENDER_PROCESS,
-                                               child_id,
+                                               process_unique_id,
                                                route_id,
                                                request_id_,
                                                "null",  // frame_origin
                                                "null",  // main_frame_origin
                                                ResourceType::SUB_RESOURCE,
                                                0,  // upload_size
                                                download,  // is_download
                                                download, // allow_download
                                                -1, // Host renderer id
                                                -1); // Host render view id
@@ skipping 22 matching lines @@
                        &RenderViewHost::ClosePageIgnoringUnloadEvents);
   }
 }
 
 // We are explicitly forcing the download of 'url'.
 void ResourceDispatcherHost::BeginDownload(
     const GURL& url,
     const GURL& referrer,
     const DownloadSaveInfo& save_info,
     bool prompt_for_save_location,
-    int child_id,
+    int process_unique_id,
     int route_id,
-    URLRequestContext* request_context) {
+    URLRequestContext* request_context,
+    uint64 start_offset) {
   if (is_shutdown_)
     return;
 
   // Check if the renderer is permitted to request the requested URL.
   if (!ChildProcessSecurityPolicy::GetInstance()->
-          CanRequestURL(child_id, url)) {
+          CanRequestURL(process_unique_id, url)) {
     LOG(INFO) << "Denied unauthorized download request for " <<
         url.possibly_invalid_spec();
     return;
   }
 
   // Ensure the Chrome plugins are loaded, as they may intercept network
   // requests.  Does nothing if they are already loaded.
   PluginService::GetInstance()->LoadChromePlugins(this);
   URLRequest* request = new URLRequest(url, this);
 
   request_id_--;
 
   scoped_refptr<ResourceHandler> handler =
       new DownloadResourceHandler(this,
-                                  child_id,
+                                  process_unique_id,
                                   route_id,
                                   request_id_,
                                   url,
                                   download_file_manager_.get(),
                                   request,
                                   prompt_for_save_location,
                                   save_info);
 
   if (safe_browsing_->enabled()) {
-    handler = CreateSafeBrowsingResourceHandler(handler, child_id, route_id,
+    handler = CreateSafeBrowsingResourceHandler(handler,
+                                                process_unique_id,
+                                                route_id,
                                                 ResourceType::MAIN_FRAME);
   }
 
   if (!URLRequest::IsHandledURL(url)) {
     LOG(INFO) << "Download request for unsupported protocol: " <<
         url.possibly_invalid_spec();
     return;
   }
 
   request->set_method("GET");
   request->set_referrer(CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kNoReferrers) ? std::string() : referrer.spec());
   request->set_context(request_context);
   request->set_load_flags(request->load_flags() |
       net::LOAD_IS_DOWNLOAD);
 
   ResourceDispatcherHostRequestInfo* extra_info =
-      CreateRequestInfoForBrowserRequest(handler, child_id, route_id, true);
+      CreateRequestInfoForBrowserRequest(handler,
+                                         process_unique_id,
+                                         route_id,
+                                         true);
+
+  // If we're not at the beginning of the file, retrieve only the remaining
+  // portion.
+  if (start_offset > 0) {
+    request->SetExtraRequestHeaderByName(
+        "Range",
+        StringPrintf("bytes=%" PRId64 "-", start_offset),
+        false);
+    extra_info->set_was_interrupted(true);
+    extra_info->set_interrupted_bytes(start_offset);
+  }
+
   SetRequestInfo(request, extra_info);  // Request takes ownership.
-  chrome_browser_net::SetOriginProcessUniqueIDForRequest(child_id, request);
+  chrome_browser_net::SetOriginProcessUniqueIDForRequest(process_unique_id,
+                                                         request);
 
   BeginRequestInternal(request);
 }
 
 // This function is only used for saving feature.
 void ResourceDispatcherHost::BeginSaveFile(const GURL& url,
                                            const GURL& referrer,
-                                           int child_id,
+                                           int process_unique_id,
                                            int route_id,
                                            URLRequestContext* request_context) {
   if (is_shutdown_)
     return;
 
   // Ensure the Chrome plugins are loaded, as they may intercept network
   // requests.  Does nothing if they are already loaded.
   PluginService::GetInstance()->LoadChromePlugins(this);
 
   scoped_refptr<ResourceHandler> handler =
-      new SaveFileResourceHandler(child_id,
+      new SaveFileResourceHandler(process_unique_id,
                                   route_id,
                                   url,
                                   save_file_manager_.get());
   request_id_--;
 
   bool known_proto = URLRequest::IsHandledURL(url);
   if (!known_proto) {
     // Since any URLs which have non-standard scheme have been filtered
     // by save manager(see GURL::SchemeIsStandard). This situation
     // should not happen.
     NOTREACHED();
     return;
   }
 
   URLRequest* request = new URLRequest(url, this);
   request->set_method("GET");
   request->set_referrer(CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kNoReferrers) ? std::string() : referrer.spec());
   // So far, for saving page, we need fetch content from cache, in the
   // future, maybe we can use a configuration to configure this behavior.
   request->set_load_flags(net::LOAD_PREFERRING_CACHE);
   request->set_context(request_context);
 
   // Since we're just saving some resources we need, disallow downloading.
   ResourceDispatcherHostRequestInfo* extra_info =
-      CreateRequestInfoForBrowserRequest(handler, child_id, route_id, false);
+      CreateRequestInfoForBrowserRequest(handler,
+                                         process_unique_id,
+                                         route_id,
+                                         false);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
-  chrome_browser_net::SetOriginProcessUniqueIDForRequest(child_id, request);
+  chrome_browser_net::SetOriginProcessUniqueIDForRequest(process_unique_id,
+                                                         request);
 
   BeginRequestInternal(request);
 }
 
 void ResourceDispatcherHost::FollowDeferredRedirect(
-    int child_id,
+    int process_unique_id,
     int request_id,
     bool has_new_first_party_for_cookies,
     const GURL& new_first_party_for_cookies) {
   PendingRequestList::iterator i = pending_requests_.find(
-      GlobalRequestID(child_id, request_id));
+      GlobalRequestID(process_unique_id, request_id));
   if (i == pending_requests_.end() || !i->second->status().is_success()) {
     DLOG(WARNING) << "FollowDeferredRedirect for invalid request";
     return;
   }
 
   if (has_new_first_party_for_cookies)
     i->second->set_first_party_for_cookies(new_first_party_for_cookies);
   i->second->FollowDeferredRedirect();
 }
 
 void ResourceDispatcherHost::StartDeferredRequest(int process_unique_id,
                                                   int request_id) {
   GlobalRequestID global_id(process_unique_id, request_id);
   PendingRequestList::iterator i = pending_requests_.find(global_id);
   if (i == pending_requests_.end()) {
     // The request may have been destroyed
     LOG(WARNING) << "Trying to resume a non-existent request ("
                  << process_unique_id << ", " << request_id << ")";
     return;
   }
 
   // TODO(eroman): are there other considerations for paused or blocked
   //               requests?
 
   URLRequest* request = i->second;
   InsertIntoResourceQueue(request, *InfoForRequest(request));
 }
 
-bool ResourceDispatcherHost::WillSendData(int child_id,
+bool ResourceDispatcherHost::WillSendData(int process_unique_id,
                                           int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
-      GlobalRequestID(child_id, request_id));
+      GlobalRequestID(process_unique_id, request_id));
   if (i == pending_requests_.end()) {
     NOTREACHED() << "WillSendData for invalid request";
     return false;
   }
 
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
 
   info->IncrementPendingDataCount();
   if (info->pending_data_count() > kMaxPendingDataMessages) {
     // We reached the max number of data messages that can be sent to
     // the renderer for a given request. Pause the request and wait for
     // the renderer to start processing them before resuming it.
-    PauseRequest(child_id, request_id, true);
+    PauseRequest(process_unique_id, request_id, true);
     return false;
   }
 
   return true;
 }
 
-void ResourceDispatcherHost::PauseRequest(int child_id,
+void ResourceDispatcherHost::PauseRequest(int process_unique_id,
                                           int request_id,
                                           bool pause) {
-  GlobalRequestID global_id(child_id, request_id);
+  GlobalRequestID global_id(process_unique_id, request_id);
   PendingRequestList::iterator i = pending_requests_.find(global_id);
   if (i == pending_requests_.end()) {
     DLOG(WARNING) << "Pausing a request that wasn't found";
     return;
   }
 
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
   int pause_count = info->pause_count() + (pause ? 1 : -1);
   if (pause_count < 0) {
     NOTREACHED();  // Unbalanced call to pause.
     return;
   }
   info->set_pause_count(pause_count);
 
   RESOURCE_LOG("To pause (" << pause << "): " << i->second->url().spec());
 
   // If we're resuming, kick the request to start reading again. Run the read
   // asynchronously to avoid recursion problems.
   if (info->pause_count() == 0) {
-    MessageLoop::current()->PostTask(FROM_HERE,
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
         method_runner_.NewRunnableMethod(
             &ResourceDispatcherHost::ResumeRequest, global_id));
   }
 }
 
+void ResourceDispatcherHost::RestartRequest(int process_unique_id,
+                                            int request_id,
+                                            DownloadCreateInfo* create_info) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+  GlobalRequestID global_id(process_unique_id, request_id);
+  RESOURCE_LOG("Restart : " << url.spec());
+
+  // Copy the IDs from the existing interrupted request.
+  PendingRequestList::iterator i = interrupted_requests_.find(global_id);
+  if (i != interrupted_requests_.end()) {
+    URLRequest* request = i->second;
+    if (request) {
+      ResourceDispatcherHostRequestInfo* req_info = InfoForRequest(request);
+      create_info->render_view_id = req_info->route_id();
+      create_info->child_id = req_info->child_id();
+    }
+
+    MoveInterruptedRequestToPending(process_unique_id, request_id);
+  }
+
+  // Restart the request to continue reading. Run the read asynchronously to
+  // avoid recursion problems.
+  ChromeThread::PostTask(
+      ChromeThread::FILE,
+      FROM_HERE,
+      NewRunnableFunction(&ResourceDispatcherHost::RestartDownload,
+                          this,
+                          global_id,
+                          create_info));
+}
+
 int ResourceDispatcherHost::GetOutstandingRequestsMemoryCost(
-    int child_id) const {
+    int process_unique_id) const {
   OutstandingRequestsMemoryCostMap::const_iterator entry =
-      outstanding_requests_memory_cost_map_.find(child_id);
+      outstanding_requests_memory_cost_map_.find(process_unique_id);
   return (entry == outstanding_requests_memory_cost_map_.end()) ?
       0 : entry->second;
 }
 
 // The object died, so cancel and detach all requests associated with it except
 // for downloads, which belong to the browser process even if initiated via a
 // renderer.
-void ResourceDispatcherHost::CancelRequestsForProcess(int child_id) {
-  socket_stream_dispatcher_host_->CancelRequestsForProcess(child_id);
-  CancelRequestsForRoute(child_id, -1 /* cancel all */);
+void ResourceDispatcherHost::CancelRequestsForProcess(int process_unique_id) {
+  socket_stream_dispatcher_host_->CancelRequestsForProcess(process_unique_id);
+  CancelRequestsForRoute(process_unique_id, -1 /* cancel all */);
 }
 
-void ResourceDispatcherHost::CancelRequestsForRoute(int child_id,
+std::vector<GlobalRequestID> ResourceDispatcherHost::GetMatchingRequests(
+    int process_unique_id,
+    int route_id,
+    const PendingRequestList& requests) {
+  std::vector<GlobalRequestID> matching_requests;
+  for (PendingRequestList::const_iterator i = requests.begin();
+       i != requests.end(); ++i) {
+    if (i->first.child_id == process_unique_id) {
+      ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
+      if (!info->is_download() &&
+          (route_id == -1 || route_id == info->route_id())) {
+        matching_requests.push_back(
+            GlobalRequestID(process_unique_id, i->first.request_id));
+      }
+    }
+  }
+  return matching_requests;
+}
+
+void ResourceDispatcherHost::CancelRequestsForRoute(int process_unique_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.
-  std::vector<GlobalRequestID> matching_requests;
-  for (PendingRequestList::const_iterator i = pending_requests_.begin();
-       i != pending_requests_.end(); ++i) {
-    if (i->first.child_id == child_id) {
-      ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
-      if (!info->is_download() &&
-          (route_id == -1 || route_id == info->route_id())) {
-        matching_requests.push_back(
-            GlobalRequestID(child_id, i->first.request_id));
-      }
-    }
-  }
+  std::vector<GlobalRequestID> matching_requests =
+      GetMatchingRequests(process_unique_id, route_id, pending_requests_);
+  std::vector<GlobalRequestID> matching_requests2 =
+      GetMatchingRequests(process_unique_id, route_id, interrupted_requests_);
+  matching_requests.insert(matching_requests.begin(),
+                           matching_requests2.begin(),
+                           matching_requests2.end());
 
   // Remove matches.
   for (size_t i = 0; i < matching_requests.size(); ++i) {
     PendingRequestList::iterator iter =
         pending_requests_.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
     // 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);
+      RemoveRequestFromMap(iter);
+    // Same for interrupted requests.
+    iter = interrupted_requests_.find(matching_requests[i]);
+    if (iter != interrupted_requests_.end())
+      RemoveRequestFromMap(iter);
   }
 
   // Now deal with blocked requests if any.
   if (route_id != -1) {
-    if (blocked_requests_map_.find(std::pair<int, int>(child_id, route_id)) !=
+    if (blocked_requests_map_.find(std::pair<int, int>(process_unique_id,
+                                                       route_id)) !=
         blocked_requests_map_.end()) {
-      CancelBlockedRequestsForRoute(child_id, route_id);
+      CancelBlockedRequestsForRoute(process_unique_id, route_id);
     }
   } else {
-    // We have to do all render views for the process |child_id|.
+    // We have to do all render views for the process |process_unique_id|.
     // Note that we have to do this in 2 passes as we cannot call
     // CancelBlockedRequestsForRoute while iterating over
     // blocked_requests_map_, as it modifies it.
     std::set<int> route_ids;
     for (BlockedRequestMap::const_iterator iter = blocked_requests_map_.begin();
          iter != blocked_requests_map_.end(); ++iter) {
-      if (iter->first.first == child_id)
+      if (iter->first.first == process_unique_id)
         route_ids.insert(iter->first.second);
     }
     for (std::set<int>::const_iterator iter = route_ids.begin();
         iter != route_ids.end(); ++iter) {
-      CancelBlockedRequestsForRoute(child_id, *iter);
+      CancelBlockedRequestsForRoute(process_unique_id, *iter);
     }
   }
 }
 
 // Cancels the request and removes it from the list.
-void ResourceDispatcherHost::RemovePendingRequest(int child_id,
+void ResourceDispatcherHost::RemovePendingRequest(int process_unique_id,
                                                   int request_id) {
-  PendingRequestList::iterator i = pending_requests_.find(
-      GlobalRequestID(child_id, request_id));
+  GlobalRequestID id(process_unique_id, request_id);
+  PendingRequestList::iterator i = pending_requests_.find(id);
   if (i == pending_requests_.end()) {
+    i = interrupted_requests_.find(id);
+    if (i != interrupted_requests_.end())
+      return;
     NOTREACHED() << "Trying to remove a request that's not here";
     return;
   }
-  RemovePendingRequest(i);
+  RemoveRequestFromMap(i);
 }
 
-void ResourceDispatcherHost::RemovePendingRequest(
+// Cancels the request and removes it from the list.
+void ResourceDispatcherHost::RemoveInterruptedRequest(int process_unique_id,
+                                                      int request_id) {
+  GlobalRequestID id(process_unique_id, request_id);
+  PendingRequestList::iterator i = interrupted_requests_.find(id);
+  if (i == interrupted_requests_.end()) {
+    NOTREACHED() << "Trying to remove a request that's not here";
+    return;
+  }
+  RemoveRequestFromMap(i);
+}
+
+void ResourceDispatcherHost::MovePendingRequestToInterrupted(
+    int process_unique_id, int request_id) {
+  GlobalRequestID id(process_unique_id, request_id);
+  PendingRequestList::iterator iter = pending_requests_.find(id);
+  if (iter == pending_requests_.end())
+    return;
+
+  URLRequest* url_req = iter->second;
+
+  ResourceDispatcherHostRequestInfo* info = InfoForRequest(url_req);
+
+  info->set_was_interrupted(true);
+
+  interrupted_requests_[id] = pending_requests_[id];
+  pending_requests_.erase(iter);
+
+  // If we have no more pending requests, then stop the load state monitor
+  if (pending_requests_.empty())
+    update_load_states_timer_.Stop();
+}
+
+void ResourceDispatcherHost::MoveInterruptedRequestToPending(
+    int process_unique_id, int request_id) {
+  GlobalRequestID id(process_unique_id, request_id);
+  PendingRequestList::iterator iter = interrupted_requests_.find(id);
+  if (iter == interrupted_requests_.end())
+    return;
+
+  // Don't need to call info->set_was_interrupted(false), as we will have
+  // a new URLRequest when we resume downloading.  If we clear it here,
+  // then the information won't be available to
+  // DownloadResourceHandler::OnResponseStarted().
+
+  pending_requests_[id] = interrupted_requests_[id];
+  interrupted_requests_.erase(iter);
+}
+
+void ResourceDispatcherHost::RemoveRequestFromMap(
     const PendingRequestList::iterator& iter) {
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(iter->second);
 
   // Remove the memory credit that we added when pushing the request onto
   // the pending list.
   IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
                                          info->child_id());
 
   // Notify interested parties that the request object is going away.
   if (info->login_handler())
     info->login_handler()->OnRequestCancelled();
   if (info->ssl_client_auth_handler())
     info->ssl_client_auth_handler()->OnRequestCancelled();
-  resource_queue_.RemoveRequest(iter->first);
+
+  GlobalRequestID id = iter->first;
+  resource_queue_.RemoveRequest(id);
 
   delete iter->second;
-  pending_requests_.erase(iter);
+  if (pending_requests_.find(id) != pending_requests_.end()) {
+    pending_requests_.erase(iter);
 
-  // If we have no more pending requests, then stop the load state monitor
-  if (pending_requests_.empty())
-    update_load_states_timer_.Stop();
+    // If we have no more pending requests, then stop the load state monitor
+    if (pending_requests_.empty())
+      update_load_states_timer_.Stop();
+  }
+  if (interrupted_requests_.find(id) != interrupted_requests_.end())
+    interrupted_requests_.erase(iter);
 }
 
 // URLRequest::Delegate -------------------------------------------------------
 
 void ResourceDispatcherHost::OnReceivedRedirect(URLRequest* request,
                                                 const GURL& new_url,
                                                 bool* defer_redirect) {
   RESOURCE_LOG("OnReceivedRedirect: " << request->url().spec());
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
@@ skipping 140 matching lines @@
             request->ssl_info().security_bits == 0) &&
            !request->ssl_info().connection_status);
   }
 
   NotifyResponseStarted(request, info->child_id());
   info->set_called_on_response_started(true);
   return info->resource_handler()->OnResponseStarted(info->request_id(),
                                                      response.get());
 }
 
-void ResourceDispatcherHost::CancelRequest(int child_id,
+void ResourceDispatcherHost::CancelRequest(int process_unique_id,
                                            int request_id,
                                            bool from_renderer) {
-  PendingRequestList::iterator i = pending_requests_.find(
-      GlobalRequestID(child_id, request_id));
+  GlobalRequestID id(process_unique_id, request_id);
+  PendingRequestList::iterator i = pending_requests_.find(id);
   if (i == pending_requests_.end()) {
-    // We probably want to remove this warning eventually, but I wanted to be
-    // able to notice when this happens during initial development since it
-    // should be rare and may indicate a bug.
-    DLOG(WARNING) << "Canceling a request that wasn't found";
-    return;
+    i = interrupted_requests_.find(id);
+    if (i == interrupted_requests_.end()) {
+      // We probably want to remove this warning eventually, but I wanted to be
+      // able to notice when this happens during initial development since it
+      // should be rare and may indicate a bug.
+      DLOG(WARNING) << "Canceling a request that wasn't found";
+      return;
+    }
   }
   CancelRequestInternal(i->second, from_renderer);
 }
 
 void ResourceDispatcherHost::CancelRequestInternal(URLRequest* request,
                                                    bool from_renderer) {
   RESOURCE_LOG("CancelRequest: " << request->url().spec());
 
   // WebKit will send us a cancel for downloads since it no longer handles them.
   // In this case, ignore the cancel since we handle downloads in the browser.
@@ skipping 12 matching lines @@
     DCHECK(IsValidRequest(request));
   }
 
   // Do not remove from the pending requests, as the request will still
   // call AllDataReceived, and may even have more data before it does
   // that.
 }
 
 int ResourceDispatcherHost::IncrementOutstandingRequestsMemoryCost(
     int cost,
-    int child_id) {
+    int process_unique_id) {
   // Retrieve the previous value (defaulting to 0 if not found).
   OutstandingRequestsMemoryCostMap::iterator prev_entry =
-      outstanding_requests_memory_cost_map_.find(child_id);
+      outstanding_requests_memory_cost_map_.find(process_unique_id);
   int new_cost = 0;
   if (prev_entry != outstanding_requests_memory_cost_map_.end())
     new_cost = prev_entry->second;
 
   // Insert/update the total; delete entries when their value reaches 0.
   new_cost += cost;
   CHECK(new_cost >= 0);
   if (new_cost == 0)
     outstanding_requests_memory_cost_map_.erase(prev_entry);
   else
-    outstanding_requests_memory_cost_map_[child_id] = new_cost;
+    outstanding_requests_memory_cost_map_[process_unique_id] = new_cost;
 
   return new_cost;
 }
 
 // static
 int ResourceDispatcherHost::CalculateApproximateMemoryCost(
     URLRequest* request) {
   // The following fields should be a minor size contribution (experimentally
   // on the order of 100). However since they are variable length, it could
   // in theory be a sizeable contribution.
@@ skipping 110 matching lines @@
 void ResourceDispatcherHost::ResumeRequest(const GlobalRequestID& request_id) {
   PendingRequestList::iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())  // The request may have been destroyed
     return;
 
   URLRequest* request = i->second;
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   if (!info->is_paused())
     return;
 
-  RESOURCE_LOG("Resuming: " << i->second->url().spec());
+  RESOURCE_LOG("Resuming: " << request->url().spec());
 
   info->set_is_paused(false);
 
   if (info->called_on_response_started()) {
     if (info->has_started_reading()) {
-      OnReadCompleted(i->second, info->paused_read_bytes());
+      OnReadCompleted(request, info->paused_read_bytes());
     } else {
       StartReading(request);
     }
   } else {
-    OnResponseStarted(i->second);
+    OnResponseStarted(request);
   }
 }
 
+// static
+void ResourceDispatcherHost::RestartDownload(
+    ResourceDispatcherHost* rdh,
+    const GlobalRequestID& request_id,
+    DownloadCreateInfo* info) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+  RESOURCE_LOG("Restarting: " << info->url.spec());
+
+  // Restart the request.
+  download_util::RestartDownloadUrl(rdh,
+                                    info->url,
+                                    info->referrer_url,
+                                    info->path,
+                                    info->received_bytes,
+                                    request_id.child_id,
+                                    info->render_view_id);
+
+  // Clean up.
+  delete info;
+}
+
 void ResourceDispatcherHost::StartReading(URLRequest* request) {
   // Start reading.
   int bytes_read = 0;
   if (Read(request, &bytes_read)) {
     OnReadCompleted(request, bytes_read);
   } else if (!request->status().is_io_pending()) {
     DCHECK(!InfoForRequest(request)->is_paused());
     // If the error is not an IO pending, then we're done reading.
     OnResponseCompleted(request);
   }
@@ skipping 106 matching lines @@
     int cert_id = CertStore::GetSharedInstance()->StoreCert(ssl_info.cert,
                                                             info->child_id());
     security_info = SSLManager::SerializeSecurityInfo(
         cert_id, ssl_info.cert_status, ssl_info.security_bits,
         ssl_info.connection_status);
   }
 
   if (info->resource_handler()->OnResponseCompleted(info->request_id(),
                                                     request->status(),
                                                     security_info)) {
+    if ((request->status().status() == URLRequestStatus::FAILED) &&
+        (request->status().os_error() < 0)) {
+      MovePendingRequestToInterrupted(info->child_id(), info->request_id());
+    }
+
     NotifyResponseCompleted(request, info->child_id());
 
     // The request is complete so we can remove it.
     RemovePendingRequest(info->child_id(), info->request_id());
   }
   // If the handler's OnResponseCompleted returns false, we are deferring the
   // call until later.  We will notify the world and clean up when we resume.
 }
 
 // static
 ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::InfoForRequest(
     URLRequest* request) {
-  // Avoid writing this function twice by casting the cosnt version.
+  // Avoid writing this function twice by casting the const version.
   const URLRequest* const_request = request;
   return const_cast<ResourceDispatcherHostRequestInfo*>(
       InfoForRequest(const_request));
 }
 
 // static
 const ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::InfoForRequest(
     const URLRequest* request) {
   const ResourceDispatcherHostRequestInfo* info =
       static_cast<const ResourceDispatcherHostRequestInfo*>(
@@ skipping 43 matching lines @@
 void ResourceDispatcherHost::RemoveObserver(Observer* obs) {
   observer_list_.RemoveObserver(obs);
 }
 
 URLRequest* ResourceDispatcherHost::GetURLRequest(
     const GlobalRequestID& request_id) const {
   // This should be running in the IO loop.
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   PendingRequestList::const_iterator i = pending_requests_.find(request_id);
-  if (i == pending_requests_.end())
-    return NULL;
+  if (i == pending_requests_.end()) {
+    i = interrupted_requests_.find(request_id);
+    if (i == interrupted_requests_.end())
+      return NULL;
+  }
 
   return i->second;
 }
 
-static int GetCertID(URLRequest* request, int child_id) {
+static int GetCertID(URLRequest* request, int process_unique_id) {
   if (request->ssl_info().cert) {
     return CertStore::GetSharedInstance()->StoreCert(request->ssl_info().cert,
-                                                     child_id);
+                                                     process_unique_id);
   }
   // If there is no SSL info attached to this request, we must either be a non
   // secure request, or the request has been canceled or failed (before the SSL
   // info was populated), or the response is an error (we have seen 403, 404,
   // and 501) made up by the proxy.
   DCHECK(!request->url().SchemeIsSecure() ||
          (request->status().status() == URLRequestStatus::CANCELED) ||
          (request->status().status() == URLRequestStatus::FAILED) ||
          ((request->response_headers()->response_code() >= 400) &&
          (request->response_headers()->response_code() <= 599)));
   return 0;
 }
 
 void ResourceDispatcherHost::NotifyResponseStarted(URLRequest* request,
-                                                   int child_id) {
+                                                   int process_unique_id) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_, OnRequestStarted(this, request));
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return;
 
   // Notify the observers on the UI thread.
   CallRenderViewHostResourceDelegate(
       render_process_id, render_view_id,
       &RenderViewHostDelegate::Resource::DidStartReceivingResourceResponse,
-      ResourceRequestDetails(request, GetCertID(request, child_id)));
+      ResourceRequestDetails(request, GetCertID(request, process_unique_id)));
 }
 
 void ResourceDispatcherHost::NotifyResponseCompleted(URLRequest* request,
-                                                     int child_id) {
+                                                     int process_unique_id) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnResponseCompleted(this, request));
 }
 
 void ResourceDispatcherHost::NotifyReceivedRedirect(URLRequest* request,
-                                                    int child_id,
+                                                    int process_unique_id,
                                                     const GURL& new_url) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnReceivedRedirect(this, request, new_url));
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return;
 
   // Notify the observers on the UI thread.
   CallRenderViewHostResourceDelegate(
       render_process_id, render_view_id,
       &RenderViewHostDelegate::Resource::DidRedirectResource,
-      ResourceRedirectDetails(request, GetCertID(request, child_id), new_url));
+      ResourceRedirectDetails(request,
+                              GetCertID(request, process_unique_id),
+                              new_url));
 }
 
 namespace {
 
 // This function attempts to return the "more interesting" load state of |a|
 // and |b|.  We don't have temporal information about these load states
 // (meaning we don't know when we transitioned into these states), so we just
 // rank them according to how "interesting" the states are.
 //
 // We take advantage of the fact that the load states are an enumeration listed
@@ skipping 139 matching lines @@
                                                  position, size);
       info->set_waiting_for_upload_progress_ack(true);
     }
     info->set_last_upload_ticks(TimeTicks::Now());
     info->set_last_upload_position(position);
     return true;
   }
   return false;
 }
 
-void ResourceDispatcherHost::BlockRequestsForRoute(int child_id, int route_id) {
-  std::pair<int, int> key(child_id, route_id);
+void ResourceDispatcherHost::BlockRequestsForRoute(int process_unique_id,
+                                                   int route_id) {
+  std::pair<int, int> key(process_unique_id, route_id);
   DCHECK(blocked_requests_map_.find(key) == blocked_requests_map_.end()) <<
       "BlockRequestsForRoute called  multiple time for the same RVH";
   blocked_requests_map_[key] = new BlockedRequestsList();
 }
 
-void ResourceDispatcherHost::ResumeBlockedRequestsForRoute(int child_id,
-                                                           int route_id) {
-  ProcessBlockedRequestsForRoute(child_id, route_id, false);
+void ResourceDispatcherHost::ResumeBlockedRequestsForRoute(
+    int process_unique_id,
+    int route_id) {
+  ProcessBlockedRequestsForRoute(process_unique_id, route_id, false);
 }
 
-void ResourceDispatcherHost::CancelBlockedRequestsForRoute(int child_id,
-                                                           int route_id) {
-  ProcessBlockedRequestsForRoute(child_id, route_id, true);
+void ResourceDispatcherHost::CancelBlockedRequestsForRoute(
+    int process_unique_id,
+    int route_id) {
+  ProcessBlockedRequestsForRoute(process_unique_id, route_id, true);
 }
 
 void ResourceDispatcherHost::ProcessBlockedRequestsForRoute(
-    int child_id,
+    int process_unique_id,
     int route_id,
     bool cancel_requests) {
   BlockedRequestMap::iterator iter = blocked_requests_map_.find(
-      std::pair<int, int>(child_id, route_id));
+      std::pair<int, int>(process_unique_id, route_id));
   if (iter == blocked_requests_map_.end()) {
     // It's possible to reach here if the renderer crashed while an interstitial
     // page was showing.
     return;
   }
 
   BlockedRequestsList* requests = iter->second;
 
   // Removing the vector from the map unblocks any subsequent requests.
   blocked_requests_map_.erase(iter);
@@ skipping 12 matching lines @@
       BeginRequestInternal(request);
   }
 
   delete requests;
 }
 
 bool ResourceDispatcherHost::IsValidRequest(URLRequest* request) {
   if (!request)
     return false;
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
-  return pending_requests_.find(
-      GlobalRequestID(info->child_id(), info->request_id())) !=
-      pending_requests_.end();
+  GlobalRequestID id(info->child_id(), info->request_id());
+  return (pending_requests_.find(id) != pending_requests_.end()) ||
+         (interrupted_requests_.find(id) != interrupted_requests_.end());
+}
+
+bool ResourceDispatcherHost::IsInterruptedRequest(URLRequest* request) {
+  if (!request)
+    return false;
+  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  GlobalRequestID id(info->child_id(), info->request_id());
+  return interrupted_requests_.find(id) != interrupted_requests_.end();
 }
 
 // static
 bool ResourceDispatcherHost::IsResourceDispatcherHostMessage(
     const IPC::Message& message) {
   switch (message.type()) {
     case ViewHostMsg_RequestResource::ID:
     case ViewHostMsg_CancelRequest::ID:
     case ViewHostMsg_FollowRedirect::ID:
     case ViewHostMsg_ClosePage_ACK::ID:
@@ skipping 80 matching lines @@
   return is_prefetch_enabled_;
 }
 
 // static
 void ResourceDispatcherHost::set_is_prefetch_enabled(bool value) {
   is_prefetch_enabled_ = value;
 }
 
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled_ = false;