Add a Content API around BrowserChildProcessHost, similar to what was done with ChildProcessHost....

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"
 #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/browser_child_process_host.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/debugger/worker_devtools_message_filter.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/socket_stream_dispatcher_host.h"
 #include "content/browser/resource_context.h"
@@ skipping 12 matching lines @@
 #include "content/public/common/result_codes.h"
 #include "ipc/ipc_switches.h"
 #include "net/base/mime_util.h"
 #include "net/base/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::UserMetricsAction;
 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 18 matching lines @@
 // 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)
-    : BrowserChildProcessHost(content::PROCESS_TYPE_WORKER),
-      resource_context_(resource_context) {
+    : resource_context_(resource_context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(resource_context);
+  process_.reset(new BrowserChildProcessHost(
+      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 =
              parents.begin(); parent_iter != parents.end(); ++parent_iter) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&WorkerCrashCallback, parent_iter->render_process_id(),
                      parent_iter->render_view_id()));
     }
     WorkerServiceImpl::GetInstance()->NotifyWorkerDestroyed(
         this, i->worker_route_id());
   }
 
-  ChildProcessSecurityPolicy::GetInstance()->Remove(data().id);
+  ChildProcessSecurityPolicy::GetInstance()->Remove(process_->GetData().id);
+}
+
+bool WorkerProcessHost::Send(IPC::Message* message) {
+  return process_->Send(message);
 }
 
 bool WorkerProcessHost::Init(int render_process_id) {
-  std::string channel_id = child_process_host()->CreateChannel();
+  std::string channel_id = process_->GetHost()->CreateChannel();
   if (channel_id.empty())
     return false;
 
 #if defined(OS_LINUX)
   int flags = ChildProcessHost::CHILD_ALLOW_SELF;
 #else
   int flags = ChildProcessHost::CHILD_NORMAL;
 #endif
 
   FilePath exe_path = ChildProcessHost::GetChildPath(flags);
@@ skipping 42 matching lines @@
         switches::kDebugChildren);
     if (value.empty() || value == switches::kWorkerProcess) {
       // launches a new xterm, and runs the worker process in gdb, reading
       // optional commands from gdb_chrome file in the working directory.
       cmd_line->PrependWrapper("xterm -e gdb -x gdb_chrome --args");
       use_zygote = false;
     }
   }
 #endif
 
-  Launch(
+  process_->Launch(
 #if defined(OS_WIN)
       FilePath(),
 #elif defined(OS_POSIX)
       use_zygote,
       base::environment_vector(),
 #endif
       cmd_line);
 
   ChildProcessSecurityPolicy::GetInstance()->AddWorker(
-      data().id, render_process_id);
+      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.
     ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-        data().id, resource_context_->file_system_context()->
+        process_->GetData().id, resource_context_->file_system_context()->
           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.
     ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-        data().id, resource_context_->file_system_context()->
+        process_->GetData().id, resource_context_->file_system_context()->
           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.
     ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-        data().id, resource_context_->file_system_context()->
+        process_->GetData().id, resource_context_->file_system_context()->
           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();
 
   ResourceMessageFilter* resource_message_filter = new ResourceMessageFilter(
-      data().id, content::PROCESS_TYPE_WORKER, resource_context_,
+      process_->GetData().id, content::PROCESS_TYPE_WORKER, resource_context_,
       new URLRequestContextSelector(request_context));
-  child_process_host()->AddFilter(resource_message_filter);
+  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())));
-  child_process_host()->AddFilter(worker_message_filter_);
-  child_process_host()->AddFilter(new AppCacheDispatcherHost(
-      resource_context_->appcache_service(), data().id));
-  child_process_host()->AddFilter(new FileSystemDispatcherHost(
+  process_->GetHost()->AddFilter(worker_message_filter_);
+  process_->GetHost()->AddFilter(new AppCacheDispatcherHost(
+      resource_context_->appcache_service(), process_->GetData().id));
+  process_->GetHost()->AddFilter(new FileSystemDispatcherHost(
       request_context, resource_context_->file_system_context()));
-  child_process_host()->AddFilter(new FileUtilitiesMessageFilter(data().id));
-  child_process_host()->AddFilter(new BlobMessageFilter(
-      data().id, resource_context_->blob_storage_context()));
-  child_process_host()->AddFilter(new MimeRegistryMessageFilter());
-  child_process_host()->AddFilter(new DatabaseMessageFilter(
+  process_->GetHost()->AddFilter(new FileUtilitiesMessageFilter(
+      process_->GetData().id));
+  process_->GetHost()->AddFilter(new BlobMessageFilter(
+      process_->GetData().id, resource_context_->blob_storage_context()));
+  process_->GetHost()->AddFilter(new MimeRegistryMessageFilter());
+  process_->GetHost()->AddFilter(new DatabaseMessageFilter(
       resource_context_->database_tracker()));
 
   SocketStreamDispatcherHost* socket_stream_dispatcher_host =
       new SocketStreamDispatcherHost(
           new URLRequestContextSelector(request_context), resource_context_);
-  child_process_host()->AddFilter(socket_stream_dispatcher_host);
-  child_process_host()->AddFilter(
-      new content::WorkerDevToolsMessageFilter(data().id));
+  process_->GetHost()->AddFilter(socket_stream_dispatcher_host);
+  process_->GetHost()->AddFilter(
+      new content::WorkerDevToolsMessageFilter(process_->GetData().id));
 }
 
 void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) {
   ChildProcessSecurityPolicy::GetInstance()->GrantRequestURL(
-      data().id, instance.url());
+      process_->GetData().id, instance.url());
 
   instances_.push_back(instance);
 
   WorkerProcessMsg_CreateWorker_Params params;
   params.url = instance.url();
   params.name = instance.name();
   params.route_id = instance.worker_route_id();
   params.creator_process_id = instance.parent_process_id();
   params.shared_worker_appcache_id = instance.main_resource_appcache_id();
   Send(new WorkerProcessMsg_CreateWorker(params));
@@ skipping 33 matching lines @@
                         OnWorkerContextClosed)
     IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowDatabase, OnAllowDatabase)
     IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowFileSystem, OnAllowFileSystem)
     IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP_EX()
 
   if (!msg_is_ok) {
     NOTREACHED();
     content::RecordAction(UserMetricsAction("BadMessageTerminate_WPH"));
     base::KillProcess(
-        data().handle, content::RESULT_CODE_KILLED_BAD_MESSAGE, false);
+        process_->GetData().handle, content::RESULT_CODE_KILLED_BAD_MESSAGE,
+        false);
   }
 
   if (handled)
     return true;
 
   if (message.type() == WorkerHostMsg_WorkerContextDestroyed::ID) {
     WorkerServiceImpl::GetInstance()->NotifyWorkerDestroyed(
         this, message.routing_id());
   }
 
@@ skipping 149 matching lines @@
   }
 
   std::string display_title;
   for (std::set<std::string>::iterator i = titles.begin();
        i != titles.end(); ++i) {
     if (!display_title.empty())
       display_title += ", ";
     display_title += *i;
   }
 
-  SetName(ASCIIToUTF16(display_title));
+  process_->SetName(ASCIIToUTF16(display_title));
 }
 
 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();) {
     i->worker_document_set()->Remove(filter, document_id);
     if (i->worker_document_set()->IsEmpty()) {
       // This worker has no more associated documents - shut it down.
       Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id()));
       i = instances_.erase(i);
     } else {
       ++i;
     }
   }
 }
 
 void WorkerProcessHost::TerminateWorker(int worker_route_id) {
   Send(new WorkerMsg_TerminateWorkerContext(worker_route_id));
 }
 
+const ChildProcessData& WorkerProcessHost::GetData() {
+  return process_->GetData();
+}
+
 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)
     : url_(url),
       closed_(false),
       name_(name),
@@ skipping 103 matching lines @@
     }
   }
   return false;
 }
 
 WorkerProcessHost::WorkerInstance::FilterInfo
 WorkerProcessHost::WorkerInstance::GetFilter() const {
   DCHECK(NumFilters() == 1);
   return *filters_.begin();
 }