Remove a chrome dependency by removing Prerender from ResourceDispatcherHost.

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));
+      return false;

[mmenke, 2011/05/24 19:50:20]

You should be doing this one line down.  If prerendering isn't possible, we want
to cancel prerendering requests, too.

[dominich, 2011/05/24 20:20:34]

Good catch, thank you!

Done.

+    }
+  }
+
+  // Abort any prerenders that spawn requests that use invalid HTTP methods.
+  if (is_prerendering &&
+      !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;
+}