Don't make classes derive from ChildProcessHost, and instead have them use it through composition...

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/plugin_service.h"
+#include "content/common/child_process_host.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"
@@ skipping 43 matching lines @@
     return;
 
   plugin_parent_windows_set_.erase(window_index);
   PostMessage(parent, WM_CLOSE, 0, 0);
 }
 
 void PluginProcessHost::AddWindow(HWND window) {
   plugin_parent_windows_set_.insert(window);
 }
 
+void PluginProcessHost::AddFilter(IPC::ChannelProxy::MessageFilter* filter) {
+  child_process_host()->AddFilter(filter);
+}
+
 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()))
     return;
   ::GetWindowThreadProcessId(parent, &process_id);
   if (process_id != ::GetCurrentProcessId())
     return;
 
@@ skipping 62 matching lines @@
 #endif
   // Cancel all pending and sent requests.
   CancelRequests();
 }
 
 bool PluginProcessHost::Init(const webkit::WebPluginInfo& info,
                              const std::string& locale) {
   info_ = info;
   set_name(info_.name);
 
-  if (!CreateChannel())
+  if (!child_process_host()->CreateChannel())
     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)
   // Run the plug-in process in a mode tolerant of heap execution without
   // explicit mprotect calls. Some plug-ins still rely on this quaint and
   // archaic "feature." See http://crbug.com/93551.
   int flags = CHILD_ALLOW_HEAP_EXECUTION;
 #elif defined(OS_LINUX)
-  int flags = plugin_launcher.empty() ? CHILD_ALLOW_SELF : CHILD_NORMAL;
+  int flags = plugin_launcher.empty() ? ChildProcessHost::CHILD_ALLOW_SELF :
+                                        ChildProcessHost::CHILD_NORMAL;
 #else
-  int flags = CHILD_NORMAL;
+  int flags = ChildProcessHost::CHILD_NORMAL;
 #endif
 
-  FilePath exe_path = GetChildPath(flags);
+  FilePath exe_path = ChildProcessHost::GetChildPath(flags);
   if (exe_path.empty())
     return false;
 
   CommandLine* cmd_line = new CommandLine(exe_path);
   // Put the process type and plugin path first so they're easier to see
   // in process listings using native process management tools.
   cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kPluginProcess);
   cmd_line->AppendSwitchPath(switches::kPluginPath, info.path);
 
   // Propagate the following switches to the plugin command line (along with
@@ skipping 25 matching lines @@
   // If specified, prepend a launcher program to the command line.
   if (!plugin_launcher.empty())
     cmd_line->PrependWrapper(plugin_launcher);
 
   if (!locale.empty()) {
     // Pass on the locale so the null plugin will use the right language in the
     // prompt to install the desired plugin.
     cmd_line->AppendSwitchASCII(switches::kLang, locale);
   }
 
-  cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id());
+  cmd_line->AppendSwitchASCII(switches::kProcessChannelID,
+                              child_process_host()->channel_id());
 
 #if defined(OS_POSIX)
   base::environment_vector env;
 #if defined(OS_MACOSX) && !defined(__LP64__)
   // Add our interposing library for Carbon. This is stripped back out in
   // plugin_main.cc, so changes here should be reflected there.
   std::string interpose_list(plugin_interpose_strings::kInterposeLibraryPath);
   const char* existing_list =
       getenv(plugin_interpose_strings::kDYLDInsertLibrariesKey);
   if (existing_list) {
@@ skipping 105 matching lines @@
         host->pending_requests_.erase(host->pending_requests_.begin() + i);
         --i;
       }
     }
   }
 }
 
 void PluginProcessHost::OpenChannelToPlugin(Client* client) {
   Notify(content::NOTIFICATION_CHILD_INSTANCE_CREATED);
   client->SetPluginInfo(info_);
-  if (opening_channel()) {
+  if (child_process_host()->opening_channel()) {
     // 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();
 }