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

content/browser/ppapi_plugin_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/ppapi_plugin_process_host.h"
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/process_util.h"
 #include "base/utf_string_conversions.h"
+#include "content/browser/browser_child_process_host.h"
 #include "content/browser/plugin_service_impl.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/child_process_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "content/public/common/process_type.h"
 #include "ipc/ipc_switches.h"
 #include "net/base/network_change_notifier.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 58 matching lines @@
     const content::PepperPluginInfo& info) {
   PpapiPluginProcessHost* plugin_host =
       new PpapiPluginProcessHost();
   if(plugin_host->Init(info))
     return plugin_host;
 
   NOTREACHED();  // Init is not expected to fail.
   return NULL;
 }
 
+bool PpapiPluginProcessHost::Send(IPC::Message* message) {
+  return process_->Send(message);
+}
+
 void PpapiPluginProcessHost::OpenChannelToPlugin(Client* client) {
-  if (child_process_host()->IsChannelOpening()) {
+  if (process_->GetHost()->IsChannelOpening()) {
     // The channel is already in the process of being opened.  Put
     // this "open channel" request into a queue of requests that will
     // be run once the channel is open.
     pending_requests_.push_back(client);
     return;
   }
 
   // We already have an open channel, send a request right away to plugin.
   RequestPluginChannel(client);
 }
 
 PpapiPluginProcessHost::PpapiPluginProcessHost(net::HostResolver* host_resolver)
-    : BrowserChildProcessHost(content::PROCESS_TYPE_PPAPI_PLUGIN),
-      filter_(new PepperMessageFilter(host_resolver)),
+    : filter_(new PepperMessageFilter(host_resolver)),
       network_observer_(new PluginNetworkObserver(this)),
       is_broker_(false),
       process_id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()) {
-  child_process_host()->AddFilter(filter_.get());
+  process_.reset(new BrowserChildProcessHost(
+      content::PROCESS_TYPE_PPAPI_PLUGIN, this));
+  process_->GetHost()->AddFilter(filter_.get());
 }
 
 PpapiPluginProcessHost::PpapiPluginProcessHost()
-    : BrowserChildProcessHost(content::PROCESS_TYPE_PPAPI_BROKER),
-      is_broker_(true),
+    : is_broker_(true),
       process_id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()) {
+  process_.reset(new BrowserChildProcessHost(
+      content::PROCESS_TYPE_PPAPI_BROKER, this));
 }
 
 bool PpapiPluginProcessHost::Init(const content::PepperPluginInfo& info) {
   plugin_path_ = info.path;
   if (info.name.empty()) {
-    SetName(plugin_path_.BaseName().LossyDisplayName());
+    process_->SetName(plugin_path_.BaseName().LossyDisplayName());
   } else {
-    SetName(UTF8ToUTF16(info.name));
+    process_->SetName(UTF8ToUTF16(info.name));
   }
 
-  std::string channel_id = child_process_host()->CreateChannel();
+  std::string channel_id = process_->GetHost()->CreateChannel();
   if (channel_id.empty())
     return false;
 
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   CommandLine::StringType plugin_launcher =
       browser_command_line.GetSwitchValueNative(switches::kPpapiPluginLauncher);
 
 #if defined(OS_LINUX)
   int flags = plugin_launcher.empty() ? ChildProcessHost::CHILD_ALLOW_SELF :
                                         ChildProcessHost::CHILD_NORMAL;
@@ skipping 32 matching lines @@
   if (!plugin_launcher.empty())
     cmd_line->PrependWrapper(plugin_launcher);
 
   // On posix, never use the zygote for the broker. Also, only use the zygote if
   // the plugin is sandboxed, and we are not using a plugin launcher - having a
   // plugin launcher means we need to use another process instead of just
   // forking the zygote.
 #if defined(OS_POSIX)
   bool use_zygote = !is_broker_ && plugin_launcher.empty() && info.is_sandboxed;
 #endif  // OS_POSIX
-  Launch(
+  process_->Launch(
 #if defined(OS_WIN)
       FilePath(),
 #elif defined(OS_POSIX)
       use_zygote,
       base::environment_vector(),
 #endif
       cmd_line);
   return true;
 }
 
@@ skipping 22 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_ChannelCreated,
                         OnRendererPluginChannelCreated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
   return handled;
 }
 
 // Called when the browser <--> plugin channel has been established.
 void PpapiPluginProcessHost::OnChannelConnected(int32 peer_pid) {
-  BrowserChildProcessHost::OnChannelConnected(peer_pid);
   // This will actually load the plugin. Errors will actually not be reported
   // back at this point. Instead, the plugin will fail to establish the
   // connections when we request them on behalf of the renderer(s).
   Send(new PpapiMsg_LoadPlugin(plugin_path_));
 
   // Process all pending channel requests from the renderers.
   for (size_t i = 0; i < pending_requests_.size(); i++)
     RequestPluginChannel(pending_requests_[i]);
   pending_requests_.clear();
 }
@@ skipping 31 matching lines @@
     const IPC::ChannelHandle& channel_handle) {
   if (sent_requests_.empty())
     return;
 
   // All requests should be processed FIFO, so the next item in the
   // sent_requests_ queue should be the one that the plugin just created.
   Client* client = sent_requests_.front();
   sent_requests_.pop();
 
   // Prepare the handle to send to the renderer.
-  base::ProcessHandle plugin_process = GetChildProcessHandle();
+  base::ProcessHandle plugin_process = process_->GetHandle();
 #if defined(OS_WIN)
   base::ProcessHandle renderer_process;
   int renderer_id;
   client->GetChannelInfo(&renderer_process, &renderer_id);
 
   base::ProcessHandle renderers_plugin_handle = NULL;
   ::DuplicateHandle(::GetCurrentProcess(), plugin_process,
                     renderer_process, &renderers_plugin_handle,
                     0, FALSE, DUPLICATE_SAME_ACCESS);
 #elif defined(OS_POSIX)
   // Don't need to duplicate anything on POSIX since it's just a PID.
   base::ProcessHandle renderers_plugin_handle = plugin_process;
 #endif
 
   client->OnChannelOpened(renderers_plugin_handle, channel_handle);
 }