Make content::ResourceContext be a real interface like the rest of the Content API (i.e. don't ha...

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 "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"
@@ skipping 74 matching lines @@
 
 ChromeResourceDispatcherHostDelegate::~ChromeResourceDispatcherHostDelegate() {
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldBeginRequest(
     int child_id,
     int route_id,
     const std::string& method,
     const GURL& url,
     ResourceType::Type resource_type,
-    const content::ResourceContext& resource_context,
+    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;
 
@@ skipping 19 matching lines @@
     prerender_tracker_->TryCancelOnIOThread(
         child_id, route_id, prerender::FINAL_STATUS_INVALID_HTTP_METHOD);
     return false;
   }
 
   return true;
 }
 
 void ChromeResourceDispatcherHostDelegate::RequestBeginning(
     net::URLRequest* request,
-    const content::ResourceContext& resource_context,
+    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)) {
     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.
     throttles->push_back(new OfflineResourceThrottle(
-        child_id, route_id, request, resource_context.appcache_service()));
+        child_id, route_id, request, resource_context->GetAppCacheService()));
 #endif
   }
 
 #if defined(ENABLE_SAFE_BROWSING)
   // Insert safe browsing at the front of the chain, so it gets to decide
   // on policies first.
-  ProfileIOData* io_data = reinterpret_cast<ProfileIOData*>(
-      resource_context.GetUserData(NULL));
+  ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
   if (io_data->safe_browsing_enabled()->GetValue()) {
     throttles->push_back(CreateSafeBrowsingResourceThrottle(
         request, child_id, route_id,
         resource_type != ResourceType::MAIN_FRAME));
   }
 #endif
 }
 
 void ChromeResourceDispatcherHostDelegate::DownloadStarting(
     net::URLRequest* request,
-    const content::ResourceContext& resource_context,
+    content::ResourceContext* resource_context,
     int child_id,
     int route_id,
     int request_id,
     bool is_new_request,
     ScopedVector<content::ResourceThrottle>* throttles) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&NotifyDownloadInitiatedOnUI, child_id, route_id));
 
   // If this isn't a new request, we've seen this before and added the safe
   // browsing resource throttle already so no need to add it again. This code
   // path is only hit for requests initiated through the browser, and not the
   // web, so no need to add the download throttle.
   if (is_new_request) {
 #if defined(ENABLE_SAFE_BROWSING)
-    ProfileIOData* io_data = reinterpret_cast<ProfileIOData*>(
-        resource_context.GetUserData(NULL));
+    ProfileIOData* io_data =
+        ProfileIOData::FromResourceContext(resource_context);
     if (io_data->safe_browsing_enabled()->GetValue()) {
       throttles->push_back(CreateSafeBrowsingResourceThrottle(
           request, child_id, route_id, false));
     }
 #endif
   } else {
     throttles->push_back(new DownloadResourceThrottle(
         download_request_limiter_, child_id, route_id, request_id));
   }
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldDeferStart(
     net::URLRequest* request,
-    const content::ResourceContext& resource_context) {
+    content::ResourceContext* resource_context) {
   ResourceDispatcherHostRequestInfo* info =
       resource_dispatcher_host_->InfoForRequest(request);
   return prerender_tracker_->PotentiallyDelayRequestOnIOThread(
       request->url(), info->child_id(), info->route_id(), info->request_id());
 }
 
 bool ChromeResourceDispatcherHostDelegate::AcceptSSLClientCertificateRequest(
     net::URLRequest* request, net::SSLCertRequestInfo* cert_request_info) {
   if (request->load_flags() & net::LOAD_PREFETCH)
     return false;
@@ skipping 105 matching lines @@
   // suggest auto-login, if available.
   AutoLoginPrompter::ShowInfoBarIfPossible(request, info->child_id(),
                                            info->route_id());
 }
 
 void ChromeResourceDispatcherHostDelegate::OnRequestRedirected(
     net::URLRequest* request,
     content::ResourceResponse* response) {
   LoadTimingObserver::PopulateTimingInfo(request, response);
 }