Renaming poorly named classes and adding missing unit tests.

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"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/download/download_resource_throttle.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/user_script_listener.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/instant/instant_loader.h"
 #include "chrome/browser/net/load_timing_observer.h"
 #include "chrome/browser/prerender/prerender_manager.h"
-#include "chrome/browser/prerender/prerender_tracker.h"
+#include "chrome/browser/prerender/prerender_render_view_tracker.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/renderer_host/chrome_url_request_user_data.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_throttle.h"
 #include "chrome/browser/renderer_host/transfer_navigation_resource_throttle.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ui/auto_login_prompter.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/ui/sync/one_click_signin_helper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/user_script.h"
@@ skipping 31 matching lines @@
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_DOWNLOAD_INITIATED,
       content::Source<RenderViewHost>(rvh),
       content::NotificationService::NoDetails());
 }
 
 }  // end namespace
 
 ChromeResourceDispatcherHostDelegate::ChromeResourceDispatcherHostDelegate(
-    prerender::PrerenderTracker* prerender_tracker)
+    prerender::PrerenderRenderViewTracker* prerender_render_view_tracker)
     : download_request_limiter_(g_browser_process->download_request_limiter()),
       safe_browsing_(g_browser_process->safe_browsing_service()),
       user_script_listener_(new UserScriptListener()),
-      prerender_tracker_(prerender_tracker),
+      prerender_render_view_tracker_(prerender_render_view_tracker),
       variation_ids_cache_initialized_(false) {
 }
 
 ChromeResourceDispatcherHostDelegate::~ChromeResourceDispatcherHostDelegate() {
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldBeginRequest(
     int child_id,
     int route_id,
     const std::string& method,
     const GURL& url,
     ResourceType::Type resource_type,
     content::ResourceContext* resource_context,
     const content::Referrer& referrer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Handle a PREFETCH resource type. If prefetch is disabled, squelch the
   // request.  Otherwise, do a normal request to warm the cache.
   if (resource_type == ResourceType::PREFETCH) {
     // All PREFETCH requests should be GETs, but be defensive about it.
     if (method != "GET")
       return false;
 
     // If prefetch is disabled, kill the request.
     if (!prerender::PrerenderManager::IsPrefetchEnabled())
       return false;
   }
 
   // Abort any prerenders that spawn requests that use invalid HTTP methods.
-  if (prerender_tracker_->IsPrerenderingOnIOThread(child_id, route_id) &&
+  if (prerender_render_view_tracker_->IsPrerenderingOnIOThread(child_id,
+                                                               route_id) &&
       !prerender::PrerenderManager::IsValidHttpMethod(method)) {
-    prerender_tracker_->TryCancelOnIOThread(
+    prerender_render_view_tracker_->TryCancelOnIOThread(
         child_id, route_id, prerender::FINAL_STATUS_INVALID_HTTP_METHOD);
     return false;
   }
 
   return true;
 }
 
 void ChromeResourceDispatcherHostDelegate::RequestBeginning(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     ResourceType::Type resource_type,
     int child_id,
     int route_id,
     bool is_continuation_of_transferred_request,
     ScopedVector<content::ResourceThrottle>* throttles) {
   if (is_continuation_of_transferred_request)
     ChromeURLRequestUserData::Delete(request);
 
   ChromeURLRequestUserData* user_data =
       ChromeURLRequestUserData::Create(request);
-  if (prerender_tracker_->IsPrerenderingOnIOThread(child_id, route_id)) {
+  if (prerender_render_view_tracker_->IsPrerenderingOnIOThread(child_id,
+                                                               route_id)) {
     user_data->set_is_prerender(true);
     request->set_priority(net::IDLE);
   }
 
   if (resource_type == ResourceType::MAIN_FRAME) {
     throttles->push_back(new TransferNavigationResourceThrottle(request));
 
 #if defined(OS_CHROMEOS)
     // We check offline first, then check safe browsing so that we still can
     // block unsafe site after we remove offline page.
@@ skipping 46 matching lines @@
 bool ChromeResourceDispatcherHostDelegate::AcceptSSLClientCertificateRequest(
     net::URLRequest* request, net::SSLCertRequestInfo* cert_request_info) {
   if (request->load_flags() & net::LOAD_PREFETCH)
     return false;
 
   ChromeURLRequestUserData* user_data = ChromeURLRequestUserData::Get(request);
   if (user_data && user_data->is_prerender()) {
     int child_id, route_id;
     if (ResourceRequestInfo::ForRequest(request)->GetAssociatedRenderView(
             &child_id, &route_id)) {
-      if (prerender_tracker_->TryCancel(
+      if (prerender_render_view_tracker_->TryCancel(
               child_id, route_id,
               prerender::FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED)) {
         return false;
       }
     }
   }
 
   return true;
 }
 
 bool ChromeResourceDispatcherHostDelegate::AcceptAuthRequest(
     net::URLRequest* request,
     net::AuthChallengeInfo* auth_info) {
   ChromeURLRequestUserData* user_data = ChromeURLRequestUserData::Get(request);
   if (!user_data || !user_data->is_prerender())
     return true;
 
   int child_id, route_id;
   if (!ResourceRequestInfo::ForRequest(request)->GetAssociatedRenderView(
           &child_id, &route_id)) {
     NOTREACHED();
     return true;
   }
 
-  if (!prerender_tracker_->TryCancelOnIOThread(
+  if (!prerender_render_view_tracker_->TryCancelOnIOThread(
           child_id, route_id, prerender::FINAL_STATUS_AUTH_NEEDED)) {
     return true;
   }
 
   return false;
 }
 
 ResourceDispatcherHostLoginDelegate*
     ChromeResourceDispatcherHostDelegate::CreateLoginDelegate(
         net::AuthChallengeInfo* auth_info, net::URLRequest* request) {
@@ skipping 179 matching lines @@
   if (base::Base64Encode(serialized, &hashed)) {
     // If successful, swap the header value with the new one.
     // Note that the list of IDs and the header could be temporarily out of sync
     // if IDs are added as we are recreating the header, but we're OK with those
     // descrepancies.
     variation_ids_header_ = hashed;
   } else {
     DVLOG(1) << "Failed to base64 encode Variation IDs value: " << serialized;
   }
 }