Create a content::ResourceContext.

content/browser/worker_host/worker_process_host.cc

 // Copyright (c) 2011 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/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "content/common/content_switches.h"
 #include "content/browser/appcache/appcache_dispatcher_host.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/file_system/file_system_dispatcher_host.h"
 #include "content/browser/mime_registry_message_filter.h"
 #include "content/browser/renderer_host/blob_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.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_notification_task.h"
 #include "content/browser/renderer_host/socket_stream_dispatcher_host.h"
+#include "content/browser/resource_context.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.h"
 #include "content/common/debug_flags.h"
 #include "content/common/result_codes.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "net/base/mime_util.h"
 #include "ipc/ipc_switches.h"
 #include "net/base/registry_controlled_domain.h"
@@ skipping 38 matching lines @@
     if (host)
       host->delegate()->WorkerCrashed();
   }
 
  private:
   int render_process_unique_id_;
   int render_view_id_;
 };
 
 WorkerProcessHost::WorkerProcessHost(
-    ResourceDispatcherHost* resource_dispatcher_host,
-    net::URLRequestContextGetter* request_context)
-    : BrowserChildProcessHost(WORKER_PROCESS, resource_dispatcher_host),
-      request_context_(request_context) {
+    net::URLRequestContextGetter* request_context_getter,
+    const content::ResourceContext* resource_context,
+    ResourceDispatcherHost* resource_dispatcher_host)
+    : BrowserChildProcessHost(WORKER_PROCESS),
+      request_context_getter_(request_context_getter),
+      resource_context_(resource_context),
+      resource_dispatcher_host_(resource_dispatcher_host) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(resource_context);
+  DCHECK(request_context_getter);
 }
 
 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 =
              parents.begin(); parent_iter != parents.end(); ++parent_iter) {
       BrowserThread::PostTask(
@@ skipping 93 matching lines @@
           base::PLATFORM_FILE_TRUNCATE |
           base::PLATFORM_FILE_WRITE_ATTRIBUTES);
   }
 
   CreateMessageFilters(render_process_id);
 
   return true;
 }
 
 void WorkerProcessHost::CreateMessageFilters(int render_process_id) {
+  DCHECK(resource_context_);
   ChromeURLRequestContext* chrome_url_context = GetChromeURLRequestContext();
 
-  worker_message_filter_= new WorkerMessageFilter(
+  ResourceMessageFilter* resource_message_filter = new ResourceMessageFilter(
+      id(), WORKER_PROCESS, resource_context_, resource_dispatcher_host_);
+  resource_message_filter->set_url_request_context_override(
+      new URLRequestContextOverride(chrome_url_context));
+  AddFilter(resource_message_filter);
+
+  worker_message_filter_ = new WorkerMessageFilter(
       render_process_id,
-      request_context_,
-      resource_dispatcher_host(),
+      request_context_getter_,
+      resource_context_,
+      resource_dispatcher_host_,
       NewCallbackWithReturnValue(
           WorkerService::GetInstance(), &WorkerService::next_worker_route_id));
   AddFilter(worker_message_filter_);
   AddFilter(new AppCacheDispatcherHost(chrome_url_context, id()));
   AddFilter(new FileSystemDispatcherHost(chrome_url_context));
   AddFilter(new FileUtilitiesMessageFilter(id()));
   AddFilter(
       new BlobMessageFilter(id(), chrome_url_context->blob_storage_context()));
   AddFilter(new MimeRegistryMessageFilter());
   AddFilter(new DatabaseMessageFilter(
-      chrome_url_context->database_tracker(),
+      resource_context_->database_tracker(),
       chrome_url_context->host_content_settings_map()));
 
   SocketStreamDispatcherHost* socket_stream_dispatcher_host =
       new SocketStreamDispatcherHost();
   socket_stream_dispatcher_host->set_url_request_context_override(
       new URLRequestContextOverride(chrome_url_context));
   AddFilter(socket_stream_dispatcher_host);
 }
 
 void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) {
@@ skipping 235 matching lines @@
     if (!display_title.empty())
       display_title += ", ";
     display_title += *i;
   }
 
   set_name(ASCIIToWide(display_title));
 }
 
 ChromeURLRequestContext* WorkerProcessHost::GetChromeURLRequestContext() {
   return static_cast<ChromeURLRequestContext*>(
-      request_context_->GetURLRequestContext());
+      request_context_getter_->GetURLRequestContext());
 }
 
 void WorkerProcessHost::DocumentDetached(WorkerMessageFilter* filter,
                                          unsigned long long document_id) {
   // Walk all instances and remove the document from their document set.
   for (Instances::iterator i = instances_.begin(); i != instances_.end();) {
     if (!i->shared()) {
       ++i;
     } else {
       i->worker_document_set()->Remove(filter, document_id);
@@ skipping 10 matching lines @@
 
 WorkerProcessHost::WorkerInstance::WorkerInstance(
     const GURL& url,
     bool shared,
     bool incognito,
     const string16& name,
     int worker_route_id,
     int parent_process_id,
     int parent_appcache_host_id,
     int64 main_resource_appcache_id,
-    net::URLRequestContextGetter* request_context)
+    net::URLRequestContextGetter* request_context_getter,
+    const content::ResourceContext& resource_context)
     : url_(url),
       shared_(shared),
       incognito_(incognito),
       closed_(false),
       name_(name),
       worker_route_id_(worker_route_id),
       parent_process_id_(parent_process_id),
       parent_appcache_host_id_(parent_appcache_host_id),
       main_resource_appcache_id_(main_resource_appcache_id),
-      request_context_(request_context),
-      worker_document_set_(new WorkerDocumentSet()) {
+      request_context_getter_(request_context_getter),
+      worker_document_set_(new WorkerDocumentSet()),
+      resource_context_(&resource_context) {
+  DCHECK(request_context_getter_);
+  DCHECK(resource_context_);
+}
+
+WorkerProcessHost::WorkerInstance::WorkerInstance(
+    const GURL& url,
+    bool shared,
+    bool incognito,
+    const string16& name)
+    : url_(url),
+      shared_(shared),
+      incognito_(incognito),
+      closed_(false),
+      name_(name),
+      worker_route_id_(MSG_ROUTING_NONE),
+      parent_process_id_(0),
+      parent_appcache_host_id_(0),
+      main_resource_appcache_id_(0),
+      request_context_getter_(NULL),
+      worker_document_set_(new WorkerDocumentSet()),
+      resource_context_(NULL) {
 }
 
 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
@@ skipping 72 matching lines @@
     }
   }
   return false;
 }
 
 WorkerProcessHost::WorkerInstance::FilterInfo
 WorkerProcessHost::WorkerInstance::GetFilter() const {
   DCHECK(NumFilters() == 1);
   return *filters_.begin();
 }