Remove a chrome dependency by removing Prerender from ResourceDispatcherHost.

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>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/shared_memory.h"
 #include "base/stl_util-inl.h"
 #include "base/time.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/external_protocol_handler.h"
-#include "chrome/browser/prerender/prerender_manager.h"
-#include "chrome/browser/prerender/prerender_tracker.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/download_resource_handler.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_handler.h"
 #include "chrome/browser/renderer_host/save_file_resource_handler.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ssl/ssl_client_auth_handler.h"
 #include "chrome/browser/ssl/ssl_manager.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/cert_store.h"
@@ skipping 233 matching lines @@
       download_request_limiter_(new DownloadRequestLimiter()),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           save_file_manager_(new SaveFileManager(this))),
       safe_browsing_(SafeBrowsingService::CreateSafeBrowsingService()),
       webkit_thread_(new WebKitThread),
       request_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_runner_(this)),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
-      filter_(NULL) {
+      filter_(NULL),
+      observer_(NULL) {
   resource_queue_.Initialize(resource_queue_delegates);
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
 }
 
 void ResourceDispatcherHost::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 131 matching lines @@
         ResolveBlobReferencesInUploadData(request_data.upload_data.get());
   }
 
   if (is_shutdown_ ||
       !ShouldServiceRequest(process_type, child_id, request_data)) {
     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.  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::HandleTag,
-                              resource_context.prerender_manager(),
-                              child_id,
-                              route_id,
-                              request_data.url,
-                              referrer,
-                              is_prerendering));
-    }
-    // Prerendering or not, this request should stop.
+  // Allow the observer to block/handle the request.
+  if (observer_ && !observer_->ShouldBeginRequest(child_id, route_id,
+                                                  request_data,
+                                                  resource_context,
+                                                  referrer)) {
     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;
-    }
-  }
-
   // Construct the event handler.
   scoped_refptr<ResourceHandler> handler;
   if (sync_result) {
     handler = new SyncResourceHandler(
         filter_, request_data.url, sync_result, this);
   } else {
     handler = new AsyncResourceHandler(
         filter_, route_id, request_data.url, resource_context.host_zoom_map(),
         this);
   }
@@ skipping 27 matching lines @@
   if (request_data.resource_type == ResourceType::MAIN_FRAME) {
     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_PRERENDERING;
-
   if (sync_result)
     load_flags |= net::LOAD_IGNORE_LIMITS;
 
+  // Allow the observer to change the load flags.
+  if (observer_)
+    observer_->MutateLoadFlags(child_id, route_id, &load_flags);
+
   // 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";
     load_flags &= ~net::LOAD_REPORT_RAW_HEADERS;
   }
 
   request->set_load_flags(load_flags);
@@ skipping 1486 matching lines @@
     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;