Handle AddPreload/AddPendingPreload on UI thread.

chrome/browser/renderer_host/chrome_resource_dispatcher_host_observer.cc

 // Copyright (c) 2011 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_observer.h"
 
 #include "base/logging.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/resource_context.h"
 #include "content/common/resource_messages.h"
 #include "net/base/load_flags.h"
 
 ChromeResourceDispatcherHostObserver::ChromeResourceDispatcherHostObserver(
     prerender::PrerenderTracker* prerender_tracker)
     : prerender_tracker_(prerender_tracker) {
 }
 
 ChromeResourceDispatcherHostObserver::~ChromeResourceDispatcherHostObserver() {
 }
 
 bool ChromeResourceDispatcherHostObserver::ShouldBeginRequest(
     int child_id, int route_id,
     const ResourceHostMsg_Request& request_data,
     const content::ResourceContext& resource_context,
     const GURL& referrer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  bool is_prerendering = prerender_tracker_->IsPrerenderingOnIOThread(
-      child_id, route_id);
 
   // Handle a PREFETCH resource type. If prefetch is disabled, squelch the
   // request.  Otherwise, do a normal request to warm the cache.
   if (request_data.resource_type == ResourceType::PREFETCH) {
     // All PREFETCH requests should be GETs, but be defensive about it.
     if (request_data.method != "GET")
       return false;
 
     // If prefetch is disabled, kill the request.
     if (!ResourceDispatcherHost::is_prefetch_enabled())
       return false;
   }
 
   // Handle a PRERENDER motivated request. Very similar to rel=prefetch, these
   // rel=prerender requests instead launch an early render of the entire page.
   if (request_data.resource_type == ResourceType::PRERENDER) {
     if (prerender::PrerenderManager::IsPrerenderingPossible()) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
           NewRunnableFunction(prerender::HandleTag,
                               resource_context.prerender_manager(),
                               child_id,
                               route_id,
                               request_data.url,
-                              referrer,
-                              is_prerendering));
+                              referrer));
     }
     // Prerendering or not, this request should be aborted.
     return false;
   }
 
   // Abort any prerenders that spawn requests that use invalid HTTP methods.
-  if (is_prerendering &&
+  if (prerender_tracker_->IsPrerenderingOnIOThread(child_id, route_id) &&
       !prerender::PrerenderManager::IsValidHttpMethod(request_data.method)) {
     prerender_tracker_->TryCancelOnIOThread(
         child_id, route_id,
         prerender::FINAL_STATUS_INVALID_HTTP_METHOD);
     return false;
   }
 
   return true;
 }
 
 void ChromeResourceDispatcherHostObserver::MutateLoadFlags(int child_id,
                                                            int route_id,
                                                            int* load_flags) {
   DCHECK(load_flags);
   if (prerender_tracker_->IsPrerenderingOnIOThread(child_id, route_id))
     *load_flags |= net::LOAD_PRERENDERING;
 }