AppCache and StoragePartition'ing

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 <string>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/appcache/appcache_dispatcher_host.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/browser_child_process_host_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/debugger/worker_devtools_manager.h"
 #include "content/browser/debugger/worker_devtools_message_filter.h"
 #include "content/browser/fileapi/fileapi_message_filter.h"
+#include "content/browser/in_process_webkit/indexed_db_context_impl.h"
 #include "content/browser/in_process_webkit/indexed_db_dispatcher_host.h"
 #include "content/browser/mime_registry_message_filter.h"
 #include "content/browser/renderer_host/database_message_filter.h"
 #include "content/browser/renderer_host/file_utilities_message_filter.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/socket_stream_dispatcher_host.h"
 #include "content/browser/resource_context_impl.h"
+#include "content/browser/storage_partition_impl.h"
 #include "content/browser/worker_host/message_port_service.h"
 #include "content/browser/worker_host/worker_message_filter.h"
 #include "content/browser/worker_host/worker_service_impl.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/debug_flags.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "ipc/ipc_switches.h"
 #include "net/base/mime_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "ui/base/ui_base_switches.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/glue/resource_type.h"
 
 using content::BrowserThread;
 using content::ChildProcessData;
 using content::ChildProcessHost;
 using content::RenderViewHostImpl;
 using content::ResourceContext;
 using content::ResourceMessageFilter;
 using content::SocketStreamDispatcherHost;
+using content::StoragePartitionImpl;
 using content::UserMetricsAction;
 using content::WorkerDevToolsManager;
 using content::WorkerServiceImpl;
 
 namespace {
 
 // Helper class that we pass to SocketStreamDispatcherHost so that it can find
 // the right net::URLRequestContext for a request.
 class URLRequestContextSelector
     : public ResourceMessageFilter::URLRequestContextSelector {
@@ skipping 16 matching lines @@
 }  // namespace
 
 // Notifies RenderViewHost that one or more worker objects crashed.
 void WorkerCrashCallback(int render_process_unique_id, int render_view_id) {
   RenderViewHostImpl* host =
       RenderViewHostImpl::FromID(render_process_unique_id, render_view_id);
   if (host)
     host->GetDelegate()->WorkerCrashed();
 }
 
-WorkerProcessHost::WorkerProcessHost(ResourceContext* resource_context)
-    : resource_context_(resource_context) {
+WorkerProcessHost::WorkerProcessHost(ResourceContext* resource_context,
+                                     StoragePartitionImpl* storage_partition)
+    : resource_context_(resource_context),
+      storage_partition_(storage_partition) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(resource_context);
+  DCHECK(storage_partition);
   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) {
     const WorkerDocumentSet::DocumentInfoSet& parents =
         i->worker_document_set()->documents();
     for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
@@ skipping 83 matching lines @@
   process_->Launch(
 #if defined(OS_WIN)
       FilePath(),
 #elif defined(OS_POSIX)
       use_zygote,
       base::EnvironmentVector(),
 #endif
       cmd_line);
 
   fileapi::FileSystemContext* file_system_context =
-      GetFileSystemContextForResourceContext(resource_context_);
+      storage_partition_->GetFileSystemContext();
   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(
@@ skipping 27 matching lines @@
         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) {
+  // TODO(michaeln): Put ChromeBlobStorageContext in StorageParition too.
+  ChromeBlobStorageContext* blob_storage_context =
+      content::GetChromeBlobStorageContextForResourceContext(
+          resource_context_);
+
+  // TODO(michaeln): this is not correct, workers will not be using the
+  // isolated/partitioned context.
   net::URLRequestContext* request_context =
       resource_context_->GetRequestContext();
 
   ResourceMessageFilter* resource_message_filter = new ResourceMessageFilter(
       process_->GetData().id, content::PROCESS_TYPE_WORKER, resource_context_,
+      static_cast<ChromeAppCacheService*>(

[awong, 2012/09/06 22:29:27]

Also unnecessary with covariant return...

+          storage_partition_->GetAppCacheService()),
+      blob_storage_context,
       new URLRequestContextSelector(request_context));
   process_->GetHost()->AddFilter(resource_message_filter);
 
   worker_message_filter_ = new WorkerMessageFilter(
-      render_process_id, resource_context_,
+      render_process_id, resource_context_, storage_partition_,
       base::Bind(&WorkerServiceImpl::next_worker_route_id,
                  base::Unretained(WorkerServiceImpl::GetInstance())));
   process_->GetHost()->AddFilter(worker_message_filter_);
   process_->GetHost()->AddFilter(new AppCacheDispatcherHost(
       static_cast<ChromeAppCacheService*>(
-          ResourceContext::GetAppCacheService(resource_context_)),
+          storage_partition_->GetAppCacheService()),
       process_->GetData().id));
   process_->GetHost()->AddFilter(new FileAPIMessageFilter(
       process_->GetData().id,
       request_context,
-      GetFileSystemContextForResourceContext(resource_context_),
-      content::GetChromeBlobStorageContextForResourceContext(
-          resource_context_)));
+      storage_partition_->GetFileSystemContext(),
+      blob_storage_context));
   process_->GetHost()->AddFilter(new FileUtilitiesMessageFilter(
       process_->GetData().id));
   process_->GetHost()->AddFilter(new MimeRegistryMessageFilter());
   process_->GetHost()->AddFilter(new DatabaseMessageFilter(
-      content::GetDatabaseTrackerForResourceContext(resource_context_)));
+      storage_partition_->GetDatabaseTracker()));
 
   SocketStreamDispatcherHost* socket_stream_dispatcher_host =
       new SocketStreamDispatcherHost(render_process_id,
           new URLRequestContextSelector(request_context), resource_context_);
   process_->GetHost()->AddFilter(socket_stream_dispatcher_host);
   process_->GetHost()->AddFilter(
       new content::WorkerDevToolsMessageFilter(process_->GetData().id));
   process_->GetHost()->AddFilter(new IndexedDBDispatcherHost(
       process_->GetData().id,
-      content::GetIndexedDBContextForResourceContext(resource_context_)));
+      static_cast<IndexedDBContextImpl*>(
+          storage_partition_->GetIndexedDBContext())));
 }
 
 void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) {
   ChildProcessSecurityPolicyImpl::GetInstance()->GrantRequestURL(
       process_->GetData().id, instance.url());
 
   instances_.push_back(instance);
 
   WorkerProcessMsg_CreateWorker_Params params;
   params.url = instance.url();
@@ skipping 84 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) {
+  // FIXME: Should we introduce a SettingsContext abstraction for settings
+  // related things like this?
   *result = content::GetContentClient()->browser()->AllowWorkerDatabase(
       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));
@@ skipping 167 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,
-    content::ResourceContext* resource_context)
+    content::ResourceContext* resource_context,
+    content::StoragePartitionImpl* storage_partition)
     : 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) {
+      resource_context_(resource_context),
+      storage_partition_(storage_partition) {
   DCHECK(resource_context_);
+  DCHECK(storage_partition_);
 }
 
 WorkerProcessHost::WorkerInstance::WorkerInstance(
     const GURL& url,
     bool shared,
     const string16& name,
-    content::ResourceContext* resource_context)
+    content::ResourceContext* resource_context,
+    content::StoragePartitionImpl* storage_partition)
     : 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) {
+      resource_context_(resource_context),
+      storage_partition_(storage_partition) {
   DCHECK(resource_context_);
+  DCHECK(storage_partition_);
 }
 
 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,
-    content::ResourceContext* resource_context) const {
+    content::ResourceContext* resource_context,
+    content::StoragePartitionImpl* storage_partition) const {
   // Only match open shared workers.
   if (closed_)
     return false;
 
   // ResourceContext equivalence is being used as a proxy to ensure we only
   // matched shared workers within the same BrowserContext.
   if (resource_context_ != resource_context)
     return false;
 
+  // Must be bound to the same storage partition too.
+  if (storage_partition_.get() != storage_partition)
+    return false;
+
   if (url_.GetOrigin() != match_url.GetOrigin())
     return false;
 
   if (name_.empty() && match_name.empty())
     return url_ == match_url;
 
   return name_ == match_name;
 }
 
 void WorkerProcessHost::WorkerInstance::AddFilter(WorkerMessageFilter* filter,
@@ skipping 50 matching lines @@
     }
   }
   return false;
 }
 
 WorkerProcessHost::WorkerInstance::FilterInfo
 WorkerProcessHost::WorkerInstance::GetFilter() const {
   DCHECK(NumFilters() == 1);
   return *filters_.begin();
 }