Make PrerenderTracker's resource_throttle_io_thread_map_ use RenderFrame IDs instead of RenderView …

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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.
 
 #include "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/logging.h"
@@ skipping 238 matching lines @@
 }
 
 void ChromeResourceDispatcherHostDelegate::RequestBeginning(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     appcache::AppCacheService* appcache_service,
     ResourceType::Type resource_type,
     int child_id,
     int route_id,
     ScopedVector<content::ResourceThrottle>* throttles) {
-  bool is_prerendering = prerender_tracker_->IsPrerenderingOnIOThread(
-      child_id, route_id);
+  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
+  bool is_prerendering =
+      info->GetVisibilityState() == blink::WebPageVisibilityStatePrerender;
   if (is_prerendering) {
     // Requests with the IGNORE_LIMITS flag set (i.e., sync XHRs)
     // should remain at MAXIMUM_PRIORITY.
     if (request->load_flags() & net::LOAD_IGNORE_LIMITS) {
       DCHECK_EQ(request->priority(), net::MAXIMUM_PRIORITY);
     } else {
       request->SetPriority(net::IDLE);
     }
   }
 
@@ skipping 55 matching lines @@
 
 #if defined(ENABLE_ONE_CLICK_SIGNIN)
   AppendChromeSyncGaiaHeader(request, resource_context);
 #endif
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
   if (io_data->policy_header_helper())
     io_data->policy_header_helper()->AddPolicyHeaders(request);
 #endif
 
-  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   signin::AppendMirrorRequestHeaderIfPossible(
       request, GURL() /* redirect_url */,
       io_data, info->GetChildID(), info->GetRouteID());
 
   AppendStandardResourceThrottles(request,
                                   resource_context,
                                   resource_type,
                                   throttles);
   if (!is_prerendering) {
     AppendComponentUpdaterThrottles(request,
                                     resource_context,
                                     resource_type,
                                     throttles);
   }
 }
 
-void ChromeResourceDispatcherHostDelegate::WillTransferRequestToNewProcess(
-    int old_child_id,
-    int old_route_id,
-    int old_request_id,
-    int new_child_id,
-    int new_route_id,
-    int new_request_id) {
-  // If a prerender, it have should been aborted on cross-process
-  // navigation in PrerenderContents::WebContentsImpl::OpenURLFromTab.
-  DCHECK(!prerender_tracker_->IsPrerenderingOnIOThread(old_child_id,
-                                                       old_route_id));
-}
-
 void ChromeResourceDispatcherHostDelegate::DownloadStarting(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     int child_id,
     int route_id,
     int request_id,
     bool is_content_initiated,
     bool must_download,
     ScopedVector<content::ResourceThrottle>* throttles) {
   BrowserThread::PostTask(
@@ skipping 80 matching lines @@
         io_data->managed_mode_url_filter()));
 #endif
 
   content::ResourceThrottle* throttle =
       user_script_listener_->CreateResourceThrottle(request->url(),
                                                     resource_type);
   if (throttle)
     throttles->push_back(throttle);
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
-  if (prerender_tracker_->IsPrerenderingOnIOThread(info->GetChildID(),
-                                                   info->GetRouteID())) {
-    throttles->push_back(new prerender::PrerenderResourceThrottle(
-        request, prerender_tracker_));
+  if (info->GetVisibilityState() == blink::WebPageVisibilityStatePrerender) {
+    throttles->push_back(new prerender::PrerenderResourceThrottle(request));
   }
   if (prerender_tracker_->IsPendingSwapRequestOnIOThread(
           info->GetChildID(), info->GetRenderFrameID(), request->url())) {
     throttles->push_back(new prerender::PrerenderPendingSwapThrottle(
         request, prerender_tracker_));
   }
 }
 
 #if defined(ENABLE_ONE_CLICK_SIGNIN)
 void ChromeResourceDispatcherHostDelegate::AppendChromeSyncGaiaHeader(
@@ skipping 147 matching lines @@
   signin::AppendMirrorRequestHeaderIfPossible(request, redirect_url, io_data,
       info->GetChildID(), info->GetRouteID());
 }
 
 // static
 void ChromeResourceDispatcherHostDelegate::
     SetExternalProtocolHandlerDelegateForTesting(
     ExternalProtocolHandler::Delegate* delegate) {
   g_external_protocol_handler_delegate = delegate;
 }