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

content/browser/renderer_host/resource_dispatcher_host.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.
 
 // 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 347 matching lines @@
 }
 
 void ResourceDispatcherHost::AddResourceQueueDelegate(
     ResourceQueueDelegate* delegate) {
   temporarily_delegate_set_->insert(delegate);
 }
 
 scoped_refptr<ResourceHandler>
 ResourceDispatcherHost::CreateResourceHandlerForDownload(
     net::URLRequest* request,
-    const content::ResourceContext& context,
+    content::ResourceContext* context,
     int child_id,
     int route_id,
     int request_id,
     const DownloadSaveInfo& save_info,
     const DownloadResourceHandler::OnStartedCallback& started_cb) {
   scoped_refptr<ResourceHandler> handler(
       new DownloadResourceHandler(this, child_id, route_id, request_id,
                                   request->url(), download_file_manager_.get(),
                                   request, started_cb, save_info));
   if (delegate_) {
@@ skipping 149 matching lines @@
   GlobalRequestID old_request_id(request_data.transferred_request_child_id,
                                  request_data.transferred_request_request_id);
   TransferredNavigations::iterator iter =
       transferred_navigations_.find(old_request_id);
   if (iter != transferred_navigations_.end()) {
     deferred_request = iter->second;
     pending_requests_.erase(old_request_id);
     transferred_navigations_.erase(iter);
   }
 
-  const content::ResourceContext& resource_context =
-      filter_->resource_context();
+  content::ResourceContext* resource_context = filter_->resource_context();
 
   // Might need to resolve the blob references in the upload data.
   if (request_data.upload_data) {
-    resource_context.blob_storage_context()->controller()->
+    resource_context->GetBlobStorageContext()->controller()->
         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 content::Referrer referrer(MaybeStripReferrer(request_data.referrer),
@@ skipping 19 matching lines @@
   } else {
     handler = new AsyncResourceHandler(
         filter_, route_id, request_data.url, this);
   }
 
   // The RedirectToFileResourceHandler depends on being next in the chain.
   if (request_data.download_to_file)
     handler = new content::RedirectToFileResourceHandler(handler, child_id,
                                                          this);
 
-  if (HandleExternalProtocol(request_id, child_id, route_id,
-                             request_data.url, request_data.resource_type,
-                             *resource_context.request_context()->job_factory(),
-                             handler)) {
+  if (HandleExternalProtocol(
+      request_id, child_id, route_id, request_data.url,
+      request_data.resource_type,
+      *resource_context->GetRequestContext()->job_factory(), handler)) {
     return;
   }
 
   // Construct the request.
   net::URLRequest* request;
   if (deferred_request) {
     request = deferred_request;
   } else {
     request = new net::URLRequest(request_data.url, this);
     request->set_method(request_data.method);
@@ skipping 100 matching lines @@
           request_data.frame_id,
           request_data.parent_is_main_frame,
           request_data.parent_frame_id,
           request_data.resource_type,
           request_data.transition_type,
           upload_size,
           false,  // is download
           ResourceType::IsFrame(request_data.resource_type),  // allow_download
           request_data.has_user_gesture,
           request_data.referrer_policy,
-          &resource_context);
+          resource_context);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
 
   if (request->url().SchemeIs(chrome::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     webkit_blob::BlobStorageController* controller =
-        resource_context.blob_storage_context()->controller();
+        resource_context->GetBlobStorageContext()->controller();
     extra_info->set_requested_blob_data(
         controller->GetBlobDataFromUrl(request->url()));
   }
 
   // Have the appcache associate its extra info with the request.
   appcache::AppCacheInterceptor::SetExtraRequestInfo(
-      request, resource_context.appcache_service(), child_id,
+      request, resource_context->GetAppCacheService(), child_id,
       request_data.appcache_host_id, request_data.resource_type);
 
   if (deferred_request) {
     // This is a request that has been transferred from another process, so
     // resume it rather than continuing the regular procedure for starting a
     // request. Currently this is only done for redirects.
     GlobalRequestID global_id(extra_info->child_id(), extra_info->request_id());
     pending_requests_[global_id] = request;
     request->FollowDeferredRedirect();
   } else {
@@ skipping 116 matching lines @@
   FollowDeferredRedirect(filter_->child_id(), request_id,
                          has_new_first_party_for_cookies,
                          new_first_party_for_cookies);
 }
 
 ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::CreateRequestInfo(
     ResourceHandler* handler,
     int child_id,
     int route_id,
     bool download,
-    const content::ResourceContext& context) {
+    content::ResourceContext* context) {
   return new ResourceDispatcherHostRequestInfo(
       handler,
       content::PROCESS_TYPE_RENDERER,
       child_id,
       route_id,
       0,
       request_id_,
       false,     // is_main_frame
       -1,        // frame_id
       false,     // parent_is_main_frame
       -1,        // parent_frame_id
       ResourceType::SUB_RESOURCE,
       content::PAGE_TRANSITION_LINK,
       0,         // upload_size
       download,  // is_download
       download,  // allow_download
       false,     // has_user_gesture
       WebKit::WebReferrerPolicyDefault,
-      &context);
+      context);
 }
 
 void ResourceDispatcherHost::OnSwapOutACK(
     const ViewMsg_SwapOut_Params& params) {
   // Closes for cross-site transitions are handled such that the cross-site
   // transition continues.
   GlobalRequestID global_id(params.new_render_process_host_id,
                             params.new_request_id);
   PendingRequestList::iterator i = pending_requests_.find(global_id);
   if (i != pending_requests_.end()) {
@@ skipping 24 matching lines @@
 }
 
 // We are explicitly forcing the download of 'url'.
 net::Error ResourceDispatcherHost::BeginDownload(
     scoped_ptr<net::URLRequest> request,
     bool prefer_cache,
     const DownloadSaveInfo& save_info,
     const DownloadResourceHandler::OnStartedCallback& started_cb,
     int child_id,
     int route_id,
-    const content::ResourceContext& context) {
+    content::ResourceContext* context) {
   if (is_shutdown_)
     return net::ERR_INSUFFICIENT_RESOURCES;
 
   const GURL& url = request->original_url();
-  const net::URLRequestContext* request_context = context.request_context();
+  const net::URLRequestContext* request_context = context->GetRequestContext();
   request->set_referrer(MaybeStripReferrer(GURL(request->referrer())).spec());
   request->set_context(request_context);
   int extra_load_flags = net::LOAD_IS_DOWNLOAD;
   if (prefer_cache) {
     // If there is upload data attached, only retrieve from cache because there
     // is no current mechanism to prompt the user for their consent for a
     // re-post. For GETs, try to retrieve data from the cache and skip
     // validating the entry if present.
     if (request->get_upload() != NULL)
       extra_load_flags |= net::LOAD_ONLY_FROM_CACHE;
@@ skipping 32 matching lines @@
 
   return net::OK;
 }
 
 // This function is only used for saving feature.
 void ResourceDispatcherHost::BeginSaveFile(
     const GURL& url,
     const GURL& referrer,
     int child_id,
     int route_id,
-    const content::ResourceContext& context) {
+    content::ResourceContext* context) {
   if (is_shutdown_)
     return;
 
   scoped_refptr<ResourceHandler> handler(
       new SaveFileResourceHandler(child_id,
                                   route_id,
                                   url,
                                   save_file_manager_.get()));
   request_id_--;
 
-  const net::URLRequestContext* request_context = context.request_context();
+  const net::URLRequestContext* request_context = context->GetRequestContext();
   bool known_proto =
       request_context->job_factory()->IsHandledURL(url);
   if (!known_proto) {
     // Since any URLs which have non-standard scheme have been filtered
     // by save manager(see GURL::SchemeIsStandard). This situation
     // should not happen.
     NOTREACHED();
     return;
   }
 
   net::URLRequest* request = new net::URLRequest(url, this);
   request->set_method("GET");
   request->set_referrer(MaybeStripReferrer(referrer).spec());
   // So far, for saving page, we need fetch content from cache, in the
   // future, maybe we can use a configuration to configure this behavior.
   request->set_load_flags(net::LOAD_PREFERRING_CACHE);
-  request->set_context(context.request_context());
+  request->set_context(context->GetRequestContext());
 
   // Since we're just saving some resources we need, disallow downloading.
   ResourceDispatcherHostRequestInfo* extra_info =
       CreateRequestInfo(handler, child_id, route_id, false, context);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
 
   BeginRequestInternal(request);
 }
 
 void ResourceDispatcherHost::FollowDeferredRedirect(
@@ skipping 162 matching lines @@
         route_ids.insert(iter->first.second);
     }
     for (std::set<int>::const_iterator iter = route_ids.begin();
         iter != route_ids.end(); ++iter) {
       CancelBlockedRequestsForRoute(child_id, *iter);
     }
   }
 }
 
 void ResourceDispatcherHost::CancelRequestsForContext(
-    const content::ResourceContext* context) {
+    content::ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(context);
 
   // Note that request cancellation has side effects. Therefore, we gather all
   // the requests to cancel first, and then we start cancelling. We assert at
   // the end that there are no more to cancel since the context is about to go
   // away.
   std::vector<net::URLRequest*> requests_to_cancel;
   for (PendingRequestList::iterator i = pending_requests_.begin();
        i != pending_requests_.end();) {
@@ skipping 233 matching lines @@
     const net::CookieList& cookie_list) const {
   VLOG(1) << "OnGetCookies: " << request->url().spec();
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return false;
 
   const ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   return content::GetContentClient()->browser()->AllowGetCookie(
       request->url(), request->first_party_for_cookies(), cookie_list,
-      *info->context(), render_process_id, render_view_id);
+      info->context(), render_process_id, render_view_id);
 }
 
 bool ResourceDispatcherHost::CanSetCookie(const net::URLRequest* request,
                                           const std::string& cookie_line,
                                           net::CookieOptions* options) const {
   VLOG(1) << "OnSetCookie: " << request->url().spec();
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return false;
 
   const ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
   return content::GetContentClient()->browser()->AllowSetCookie(
       request->url(), request->first_party_for_cookies(), cookie_line,
-      *info->context(), render_process_id, render_view_id, options);
+      info->context(), render_process_id, render_view_id, options);
 }
 
 void ResourceDispatcherHost::OnResponseStarted(net::URLRequest* request) {
   VLOG(1) << "OnResponseStarted: " << request->url().spec();
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   if (request->status().is_success()) {
     if (PauseRequestIfNeeded(info)) {
       VLOG(1) << "OnResponseStarted pausing: " << request->url().spec();
       return;
@@ skipping 829 matching lines @@
   scoped_refptr<ResourceHandler> transferred_resource_handler(
       new DoomedResourceHandler(info->resource_handler()));
   info->set_resource_handler(transferred_resource_handler.get());
 }
 
 bool ResourceDispatcherHost::IsTransferredNavigation(
     const content::GlobalRequestID& transferred_request_id) const {
   return transferred_navigations_.find(transferred_request_id) !=
       transferred_navigations_.end();
 }