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

content/browser/worker_host/worker_process_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.
 
 #include "content/browser/worker_host/worker_process_host.h"
 
 #include <set>
 #include <vector>
 
 #include "base/base_switches.h"
@@ skipping 70 matching lines @@
 }  // namespace
 
 // Notifies RenderViewHost that one or more worker objects crashed.
 void WorkerCrashCallback(int render_process_unique_id, int render_view_id) {
   RenderViewHost* host =
       RenderViewHost::FromID(render_process_unique_id, render_view_id);
   if (host)
     host->delegate()->WorkerCrashed();
 }
 
-WorkerProcessHost::WorkerProcessHost(
-    const content::ResourceContext* resource_context)
+WorkerProcessHost::WorkerProcessHost(content::ResourceContext* resource_context)
     : resource_context_(resource_context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(resource_context);
   process_.reset(
       new BrowserChildProcessHostImpl(content::PROCESS_TYPE_WORKER, this));
 }
 
 WorkerProcessHost::~WorkerProcessHost() {
   // If we crashed, tell the RenderViewHosts.
   for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
@@ skipping 94 matching lines @@
   ChildProcessSecurityPolicyImpl::GetInstance()->AddWorker(
       process_->GetData().id, render_process_id);
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableFileSystem)) {
     // Grant most file permissions to this worker.
     // PLATFORM_FILE_TEMPORARY, PLATFORM_FILE_HIDDEN and
     // PLATFORM_FILE_DELETE_ON_CLOSE are not granted, because no existing API
     // requests them.
     // This is for the filesystem sandbox.
     ChildProcessSecurityPolicyImpl::GetInstance()->GrantPermissionsForFile(
-        process_->GetData().id, resource_context_->file_system_context()->
+        process_->GetData().id, resource_context_->GetFileSystemContext()->
           sandbox_provider()->new_base_path(),
         base::PLATFORM_FILE_OPEN |
         base::PLATFORM_FILE_CREATE |
         base::PLATFORM_FILE_OPEN_ALWAYS |
         base::PLATFORM_FILE_CREATE_ALWAYS |
         base::PLATFORM_FILE_OPEN_TRUNCATED |
         base::PLATFORM_FILE_READ |
         base::PLATFORM_FILE_WRITE |
         base::PLATFORM_FILE_EXCLUSIVE_READ |
         base::PLATFORM_FILE_EXCLUSIVE_WRITE |
         base::PLATFORM_FILE_ASYNC |
         base::PLATFORM_FILE_WRITE_ATTRIBUTES |
         base::PLATFORM_FILE_ENUMERATE);
     // This is so that we can read and move stuff out of the old filesystem
     // sandbox.
     ChildProcessSecurityPolicyImpl::GetInstance()->GrantPermissionsForFile(
-        process_->GetData().id, resource_context_->file_system_context()->
+        process_->GetData().id, resource_context_->GetFileSystemContext()->
           sandbox_provider()->old_base_path(),
         base::PLATFORM_FILE_READ | base::PLATFORM_FILE_WRITE |
             base::PLATFORM_FILE_WRITE_ATTRIBUTES |
             base::PLATFORM_FILE_ENUMERATE);
     // This is so that we can rename the old sandbox out of the way so that
     // we know we've taken care of it.
     ChildProcessSecurityPolicyImpl::GetInstance()->GrantPermissionsForFile(
-        process_->GetData().id, resource_context_->file_system_context()->
+        process_->GetData().id, resource_context_->GetFileSystemContext()->
           sandbox_provider()->renamed_old_base_path(),
         base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_CREATE_ALWAYS |
             base::PLATFORM_FILE_WRITE);
   }
 
   CreateMessageFilters(render_process_id);
 
   return true;
 }
 
 void WorkerProcessHost::CreateMessageFilters(int render_process_id) {
-  DCHECK(resource_context_);
   net::URLRequestContext* request_context =
-      resource_context_->request_context();
+      resource_context_->GetRequestContext();
 
   ResourceMessageFilter* resource_message_filter = new ResourceMessageFilter(
       process_->GetData().id, content::PROCESS_TYPE_WORKER, resource_context_,
       new URLRequestContextSelector(request_context));
   process_->GetHost()->AddFilter(resource_message_filter);
 
   worker_message_filter_ = new WorkerMessageFilter(
       render_process_id, resource_context_,
       base::Bind(&WorkerServiceImpl::next_worker_route_id,
                  base::Unretained(WorkerServiceImpl::GetInstance())));
   process_->GetHost()->AddFilter(worker_message_filter_);
   process_->GetHost()->AddFilter(new AppCacheDispatcherHost(
-      resource_context_->appcache_service(), process_->GetData().id));
+      resource_context_->GetAppCacheService(), process_->GetData().id));
   process_->GetHost()->AddFilter(new FileSystemDispatcherHost(
-      request_context, resource_context_->file_system_context()));
+      request_context, resource_context_->GetFileSystemContext()));
   process_->GetHost()->AddFilter(new FileUtilitiesMessageFilter(
       process_->GetData().id));
   process_->GetHost()->AddFilter(new BlobMessageFilter(
-      process_->GetData().id, resource_context_->blob_storage_context()));
+      process_->GetData().id, resource_context_->GetBlobStorageContext()));
   process_->GetHost()->AddFilter(new MimeRegistryMessageFilter());
   process_->GetHost()->AddFilter(new DatabaseMessageFilter(
-      resource_context_->database_tracker()));
+      resource_context_->GetDatabaseTracker()));
 
   SocketStreamDispatcherHost* socket_stream_dispatcher_host =
       new SocketStreamDispatcherHost(
           new URLRequestContextSelector(request_context), resource_context_);
   process_->GetHost()->AddFilter(socket_stream_dispatcher_host);
   process_->GetHost()->AddFilter(
       new content::WorkerDevToolsMessageFilter(process_->GetData().id));
 }
 
 void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) {
@@ skipping 90 matching lines @@
   }
 }
 
 void WorkerProcessHost::OnAllowDatabase(int worker_route_id,
                                         const GURL& url,
                                         const string16& name,
                                         const string16& display_name,
                                         unsigned long estimated_size,
                                         bool* result) {
   *result = content::GetContentClient()->browser()->AllowWorkerDatabase(
-      url, name, display_name, estimated_size, *resource_context_,
+      url, name, display_name, estimated_size, resource_context_,
       GetRenderViewIDsForWorker(worker_route_id));
 }
 
 void WorkerProcessHost::OnAllowFileSystem(int worker_route_id,
                                           const GURL& url,
                                           bool* result) {
   *result = content::GetContentClient()->browser()->AllowWorkerFileSystem(
-      url, *resource_context_,
-      GetRenderViewIDsForWorker(worker_route_id));
+      url, resource_context_, GetRenderViewIDsForWorker(worker_route_id));
 }
 
 void WorkerProcessHost::RelayMessage(
     const IPC::Message& message,
     WorkerMessageFilter* filter,
     int route_id) {
   if (message.type() == WorkerMsg_PostMessage::ID) {
     // We want to send the receiver a routing id for the new channel, so
     // crack the message first.
     string16 msg;
@@ skipping 73 matching lines @@
 
 bool WorkerProcessHost::CanShutdown() {
   return instances_.empty();
 }
 
 void WorkerProcessHost::UpdateTitle() {
   std::set<std::string> titles;
   for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
     // Allow the embedder first crack at special casing the title.
     std::string title = content::GetContentClient()->browser()->
-        GetWorkerProcessTitle(i->url(), *resource_context_);
+        GetWorkerProcessTitle(i->url(), resource_context_);
 
     if (title.empty()) {
       title = net::RegistryControlledDomainService::GetDomainAndRegistry(
           i->url());
     }
 
     // Use the host name if the domain is empty, i.e. localhost or IP address.
     if (title.empty())
       title = i->url().host();
 
@@ skipping 55 matching lines @@
   }
   return result;
 }
 
 WorkerProcessHost::WorkerInstance::WorkerInstance(
     const GURL& url,
     const string16& name,
     int worker_route_id,
     int parent_process_id,
     int64 main_resource_appcache_id,
-    const content::ResourceContext* resource_context)
+    content::ResourceContext* resource_context)
     : url_(url),
       closed_(false),
       name_(name),
       worker_route_id_(worker_route_id),
       parent_process_id_(parent_process_id),
       main_resource_appcache_id_(main_resource_appcache_id),
       worker_document_set_(new WorkerDocumentSet()),
       resource_context_(resource_context) {
   DCHECK(resource_context_);
 }
 
 WorkerProcessHost::WorkerInstance::WorkerInstance(
     const GURL& url,
     bool shared,
     const string16& name,
-    const content::ResourceContext* resource_context)
+    content::ResourceContext* resource_context)
     : url_(url),
       closed_(false),
       name_(name),
       worker_route_id_(MSG_ROUTING_NONE),
       parent_process_id_(0),
       main_resource_appcache_id_(0),
       worker_document_set_(new WorkerDocumentSet()),
       resource_context_(resource_context) {
   DCHECK(resource_context_);
 }
 
 WorkerProcessHost::WorkerInstance::~WorkerInstance() {
 }
 
 // Compares an instance based on the algorithm in the WebWorkers spec - an
 // instance matches if the origins of the URLs match, and:
 // a) the names are non-empty and equal
 // -or-
 // b) the names are both empty, and the urls are equal
 bool WorkerProcessHost::WorkerInstance::Matches(
     const GURL& match_url,
     const string16& match_name,
-    const content::ResourceContext* resource_context) const {
+    content::ResourceContext* resource_context) const {
   // Only match open shared workers.
   if (closed_)
     return false;
 
   // Have to match the same ResourceContext.
   if (resource_context_ != resource_context)
     return false;
 
   if (url_.GetOrigin() != match_url.GetOrigin())
     return false;
@@ skipping 57 matching lines @@
     }
   }
   return false;
 }
 
 WorkerProcessHost::WorkerInstance::FilterInfo
 WorkerProcessHost::WorkerInstance::GetFilter() const {
   DCHECK(NumFilters() == 1);
   return *filters_.begin();
 }