Handle <link rel=prerender> in chrome.

content/browser/renderer_host/resource_dispatcher_host.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 420 matching lines @@
     AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
     return;
   }
 
   const GURL referrer = MaybeStripReferrer(request_data.referrer);
   const bool is_prerendering =
       prerender::PrerenderTracker::GetInstance()->IsPrerenderingOnIOThread(
           child_id, route_id);
 
   // Handle a PREFETCH resource type. If prefetch is disabled, squelch the
-  // request. If prerendering is enabled, trigger a prerender for the URL
-  // and abort the request, to prevent double-gets. Otherwise, do a normal
-  // prefetch.
+  // 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") {
       AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
       return;
     }
     if (!ResourceDispatcherHost::is_prefetch_enabled()) {
       AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
       return;
     }
+    // Otherwise, treat like a normal request, and fall-through.
+  }
+
+  // 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::HandlePrefetchTag,
+          NewRunnableFunction(prerender::HandleTag,
                               resource_context.prerender_manager(),
                               child_id,
                               route_id,
                               request_data.url,
                               referrer,
                               is_prerendering));
-      AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
-      return;
     }
-    // Otherwise, treat like a normal request, and fall-through.
+    // Prerendering or not, this request should stop.
+    AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
+    return;
   }
 
   // Abort any prerenders that spawn requests that use invalid HTTP methods.
   if (is_prerendering &&
       !prerender::PrerenderManager::IsValidHttpMethod(request_data.method)) {
     if (prerender::PrerenderTracker::GetInstance()->TryCancelOnIOThread(
             child_id, route_id, prerender::FINAL_STATUS_INVALID_HTTP_METHOD)) {
       AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
       return;
     }
@@ skipping 40 matching lines @@
     load_flags |= net::LOAD_MAIN_FRAME;
   } else if (request_data.resource_type == ResourceType::SUB_FRAME) {
     load_flags |= net::LOAD_SUB_FRAME;
   } else if (request_data.resource_type == ResourceType::PREFETCH) {
     load_flags |= (net::LOAD_PREFETCH | net::LOAD_DO_NOT_PROMPT_FOR_LOGIN);
   } else if (request_data.resource_type == ResourceType::FAVICON) {
     load_flags |= net::LOAD_DO_NOT_PROMPT_FOR_LOGIN;
   }
 
   if (is_prerendering)
-    load_flags |= net::LOAD_PRERENDER;
+    load_flags |= net::LOAD_PRERENDERING;
 
   if (sync_result)
     load_flags |= net::LOAD_IGNORE_LIMITS;
 
   // Raw headers are sensitive, as they inclide Cookie/Set-Cookie, so only
   // allow requesting them if requestor has ReadRawCookies permission.
   if ((load_flags & net::LOAD_REPORT_RAW_HEADERS)
       && !ChildProcessSecurityPolicy::GetInstance()->
               CanReadRawCookies(child_id)) {
     VLOG(1) << "Denied unathorized request for raw headers";
@@ skipping 1436 matching lines @@
 net::RequestPriority ResourceDispatcherHost::DetermineRequestPriority(
     ResourceType::Type type,
     int load_flags) {
   // Determine request priority based on how critical this resource typically
   // is to user-perceived page load performance. Important considerations are:
   // * Can this resource block the download of other resources.
   // * Can this resource block the rendering of the page.
   // * How useful is the page to the user if this resource is not loaded yet.
 
   // Prerender-motivated requests should be made at IDLE.
-  if (load_flags & net::LOAD_PRERENDER)
+  if (load_flags & net::LOAD_PRERENDERING)
     return net::IDLE;
 
   switch (type) {
     // Main frames are the highest priority because they can block nearly every
     // type of other resource and there is no useful display without them.
     // Sub frames are a close second, however it is a common pattern to wrap
     // ads in an iframe or even in multiple nested iframes. It is worth
     // investigating if there is a better priority for them.
     case ResourceType::MAIN_FRAME:
     case ResourceType::SUB_FRAME:
@@ skipping 19 matching lines @@
 
     // Images are the "lowest" priority because they typically do not block
     // downloads or rendering and most pages have some useful content without
     // them.
     case ResourceType::IMAGE:
     // Favicons aren't required for rendering the current page, but
     // are user visible.
     case ResourceType::FAVICON:
       return net::LOWEST;
 
-    // Prefetches are at a lower priority than even LOWEST, since they
-    // are not even required for rendering of the current page.
+    // Prefetches & prerenders are at a lower priority than even

[cbentzel, 2011/05/24 03:11:07]

Nit: I'd spell out "and" rather than &, which makes me think bitwise-and.

[gavinp, 2011/05/24 13:02:52]

Done.

+    // LOWEST, since they are not even required for rendering of the
+    // current page.
     case ResourceType::PREFETCH:
+    case ResourceType::PRERENDER:
       return net::IDLE;
 
     default:
       // When new resource types are added, their priority must be considered.
       NOTREACHED();
       return net::LOW;
   }
 }
 
 
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled() {
   return is_prefetch_enabled_;
 }
 
 // static
 void ResourceDispatcherHost::set_is_prefetch_enabled(bool value) {
   is_prefetch_enabled_ = value;
 }
 
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled_ = false;