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

content/browser/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/plugin_process_host.h"
 
 #if defined(OS_WIN) && !defined(USE_AURA)
 #include <windows.h>
 #elif defined(OS_POSIX)
 #include <utility>  // for pair<>
 #endif
 
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_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/common/child_process_host_impl.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/resource_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "ipc/ipc_switches.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/gl/gl_switches.h"
 #include "ui/gfx/native_widget_types.h"
 
 using content::BrowserThread;
+using content::ChildProcessData;
 using content::ChildProcessHost;
 
 #if defined(USE_X11)
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "content/common/plugin_carbon_interpose_constants_mac.h"
 #include "ui/gfx/rect.h"
@@ skipping 35 matching lines @@
 }
 
 void PluginProcessHost::AddWindow(HWND window) {
   plugin_parent_windows_set_.insert(window);
 }
 
 void PluginProcessHost::OnReparentPluginWindow(HWND window, HWND parent) {
   // Reparent only from the plugin process to our process.
   DWORD process_id = 0;
   ::GetWindowThreadProcessId(window, &process_id);
-  if (process_id != ::GetProcessId(GetChildProcessHandle()))
+  if (process_id != ::GetProcessId(process_->GetHandle()))
     return;
   ::GetWindowThreadProcessId(parent, &process_id);
   if (process_id != ::GetCurrentProcessId())
     return;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(ReparentPluginWindowHelper, window, parent));
 }
 #endif  // defined(OS_WIN)
 
 #if defined(TOOLKIT_USES_GTK)
 void PluginProcessHost::OnMapNativeViewId(gfx::NativeViewId id,
                                           gfx::PluginWindowHandle* output) {
   *output = 0;
 #if !defined(USE_AURA)
   GtkNativeViewManager::GetInstance()->GetXIDForId(output, id);
 #endif
 }
 #endif  // defined(TOOLKIT_USES_GTK)
 
 PluginProcessHost::PluginProcessHost()
-    : BrowserChildProcessHost(content::PROCESS_TYPE_PLUGIN)
 #if defined(OS_MACOSX)
-      , plugin_cursor_visible_(true)
+    : plugin_cursor_visible_(true)
 #endif
 {
+  process_.reset(new BrowserChildProcessHost(
+      content::PROCESS_TYPE_PLUGIN, this));
 }
 
 PluginProcessHost::~PluginProcessHost() {
 #if defined(OS_WIN) && !defined(USE_AURA)
   // We erase HWNDs from the plugin_parent_windows_set_ when we receive a
   // notification that the window is being destroyed. If we don't receive this
   // notification and the PluginProcessHost instance is being destroyed, it
   // means that the plugin process crashed. We paint a sad face in this case in
   // the renderer process. To ensure that the sad face shows up, and we don't
   // leak HWNDs, we should destroy existing plugin parent windows.
@@ skipping 25 matching lines @@
     } else {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                               base::Bind(base::mac::SetCursorVisibility, true));
     }
   }
 #endif
   // Cancel all pending and sent requests.
   CancelRequests();
 }
 
+bool PluginProcessHost::Send(IPC::Message* message) {
+  return process_->Send(message);
+}
+
 bool PluginProcessHost::Init(const webkit::WebPluginInfo& info) {
   info_ = info;
-  SetName(info_.name);
+  process_->SetName(info_.name);
 
-  std::string channel_id = child_process_host()->CreateChannel();
+  std::string channel_id = process_->GetHost()->CreateChannel();
   if (channel_id.empty())
     return false;
 
   // Build command line for plugin. When we have a plugin launcher, we can't
   // allow "self" on linux and we need the real file path.
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   CommandLine::StringType plugin_launcher =
       browser_command_line.GetSwitchValueNative(switches::kPluginLauncher);
 
 #if defined(OS_MACOSX)
@@ skipping 69 matching lines @@
   if (existing_list) {
     interpose_list.insert(0, ":");
     interpose_list.insert(0, existing_list);
   }
   env.push_back(std::pair<std::string, std::string>(
       plugin_interpose_strings::kDYLDInsertLibrariesKey,
       interpose_list));
 #endif
 #endif
 
-  Launch(
+  process_->Launch(
 #if defined(OS_WIN)
       FilePath(),
 #elif defined(OS_POSIX)
       false,
       env,
 #endif
       cmd_line);
 
   // The plugin needs to be shutdown gracefully, i.e. NP_Shutdown needs to be
   // called on the plugin. The plugin process exits when it receives the
   // OnChannelError notification indicating that the browser plugin channel has
   // been destroyed.
-  SetTerminateChildOnShutdown(false);
+  process_->SetTerminateChildOnShutdown(false);
 
   content::GetContentClient()->browser()->PluginProcessHostCreated(this);
 
   return true;
 }
 
 void PluginProcessHost::ForceShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   Send(new PluginProcessMsg_NotifyRenderersOfPendingShutdown());
-  BrowserChildProcessHost::ForceShutdown();
+  process_->ForceShutdown();
 }
 
 void PluginProcessHost::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
-  child_process_host()->AddFilter(filter);
+  process_->GetHost()->AddFilter(filter);
 }
 
 bool PluginProcessHost::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PluginProcessHost, msg)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_ChannelCreated, OnChannelCreated)
 #if defined(OS_WIN) && !defined(USE_AURA)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_PluginWindowDestroyed,
                         OnPluginWindowDestroyed)
     IPC_MESSAGE_HANDLER(PluginProcessHostMsg_ReparentPluginWindow,
@@ skipping 14 matching lines @@
                         OnPluginSetCursorVisibility)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   DCHECK(handled);
   return handled;
 }
 
 void PluginProcessHost::OnChannelConnected(int32 peer_pid) {
-  BrowserChildProcessHost::OnChannelConnected(peer_pid);
   for (size_t i = 0; i < pending_requests_.size(); ++i) {
     RequestPluginChannel(pending_requests_[i]);
   }
 
   pending_requests_.clear();
 }
 
 void PluginProcessHost::OnChannelError() {
   CancelRequests();
 }
@@ skipping 11 matching lines @@
     Client* client = sent_requests_.front();
     if (client)
       client->OnError();
     sent_requests_.pop_front();
   }
 }
 
 // static
 void PluginProcessHost::CancelPendingRequestsForResourceContext(
     const content::ResourceContext* context) {
-  for (BrowserChildProcessHost::Iterator host_it(content::PROCESS_TYPE_PLUGIN);
-       !host_it.Done(); ++host_it) {
-    PluginProcessHost* host = static_cast<PluginProcessHost*>(*host_it);
+  for (PluginProcessHostIterator host_it; !host_it.Done(); ++host_it) {
+    PluginProcessHost* host = *host_it;
     for (size_t i = 0; i < host->pending_requests_.size(); ++i) {
       if (&host->pending_requests_[i]->GetResourceContext() == context) {
         host->pending_requests_[i]->OnError();
         host->pending_requests_.erase(host->pending_requests_.begin() + i);
         --i;
       }
     }
   }
 }
 
 void PluginProcessHost::OpenChannelToPlugin(Client* client) {
-  Notify(content::NOTIFICATION_CHILD_INSTANCE_CREATED);
+  process_->Notify(content::NOTIFICATION_CHILD_INSTANCE_CREATED);
   client->SetPluginInfo(info_);
-  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);
 }
@@ skipping 42 matching lines @@
 }
 
 void PluginProcessHost::OnChannelCreated(
     const IPC::ChannelHandle& channel_handle) {
   Client* client = sent_requests_.front();
 
   if (client)
     client->OnChannelOpened(channel_handle);
   sent_requests_.pop_front();
 }