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

content/browser/gpu/gpu_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/gpu/gpu_process_host.h"
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/string_piece.h"
 #include "base/threading/thread.h"
 #include "content/browser/gpu/gpu_data_manager.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
+#include "content/common/child_process_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/gpu/gpu_child_thread.h"
 #include "content/gpu/gpu_process.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_implementation.h"
@@ skipping 242 matching lines @@
   // GpuProcessHost is destroyed, which happens when the corresponding GPU
   // process terminates or fails to launch.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       NewRunnableFunction(&GpuProcessHostUIShim::Create, host_id));
 }
 
 GpuProcessHost::~GpuProcessHost() {
   DCHECK(CalledOnValidThread());
+
+  SendOutstandingReplies();
+  UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
+                            DIED_FIRST_TIME + g_gpu_crash_count,
+                            GPU_PROCESS_LIFETIME_EVENT_MAX);
+
+  int exit_code;
+  base::TerminationStatus status = GetChildTerminationStatus(&exit_code);
+  UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessTerminationStatus",
+                            status,
+                            base::TERMINATION_STATUS_MAX_ENUM);
+
+  if (status == base::TERMINATION_STATUS_NORMAL_TERMINATION ||
+      status == base::TERMINATION_STATUS_ABNORMAL_TERMINATION) {
+    UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessExitCode",
+                              exit_code,
+                              content::RESULT_CODE_LAST_CODE);
+  }
+
 #if defined(OS_WIN)
   if (gpu_process_)
     CloseHandle(gpu_process_);
 #endif
 
   // In case we never started, clean up.
   while (!queued_messages_.empty()) {
     delete queued_messages_.front();
     queued_messages_.pop();
   }
 
   g_hosts_by_id.Pointer()->Remove(host_id_);
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           NewRunnableFunction(GpuProcessHostUIShim::Destroy,
                                               host_id_));
 }
 
 bool GpuProcessHost::Init() {
-  if (!CreateChannel())
+  if (!child_process_host()->CreateChannel())
     return false;
 
   if (in_process_) {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kDisableGpuWatchdog);
 
-    in_process_gpu_thread_.reset(new GpuMainThread(channel_id()));
+    in_process_gpu_thread_.reset(new GpuMainThread(
+        child_process_host()->channel_id()));
 
     base::Thread::Options options;
 #if defined(OS_WIN)
   // On Windows the GPU thread needs to pump the compositor child window's
   // message loop. TODO(apatrick): make this an IO thread if / when we get rid
   // of this child window. Unfortunately it might always be necessary for
   // Windows XP because we cannot share the backing store textures between
   // processes.
   options.message_loop_type = MessageLoop::TYPE_UI;
 #else
@@ skipping 10 matching lines @@
 
 void GpuProcessHost::RouteOnUIThread(const IPC::Message& message) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       new RouteToGpuProcessHostUIShimTask(host_id_, message));
 }
 
 bool GpuProcessHost::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
-  if (opening_channel()) {
+  if (child_process_host()->opening_channel()) {
     queued_messages_.push(msg);
     return true;
   }
 
   return BrowserChildProcessHost::Send(msg);
 }
 
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
@@ skipping 126 matching lines @@
   SurfaceRefMap::iterator it = surface_refs_.find(view_id);
   if (it != surface_refs_.end())
     surface_refs_.erase(it);
 #endif  // defined(TOOLKIT_USES_GTK)
 }
 
 void GpuProcessHost::OnGraphicsInfoCollected(const content::GPUInfo& gpu_info) {
   GpuDataManager::GetInstance()->UpdateGpuInfo(gpu_info);
 }
 
-bool GpuProcessHost::CanShutdown() {
-  return true;
-}
-
 void GpuProcessHost::OnProcessLaunched() {
   // Send the GPU process handle to the UI thread before it has to
   // respond to any requests to establish a GPU channel. The response
   // to such requests require that the GPU process handle be known.
 
   TRACE_EVENT0("test_gpu", "GpuProcessLaunched");
 
   base::ProcessHandle child_handle = in_process_ ?
       base::GetCurrentProcessHandle() : handle();
 
 #if defined(OS_WIN)
   DuplicateHandle(base::GetCurrentProcessHandle(),
                   child_handle,
                   base::GetCurrentProcessHandle(),
                   &gpu_process_,
                   PROCESS_DUP_HANDLE,
                   FALSE,
                   0);
 #else
   gpu_process_ = child_handle;
 #endif
 }
 
-void GpuProcessHost::OnChildDied() {
-  SendOutstandingReplies();
-  // Located in OnChildDied because OnProcessCrashed suffers from a race
-  // condition on Linux.
-  UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
-                            DIED_FIRST_TIME + g_gpu_crash_count,
-                            GPU_PROCESS_LIFETIME_EVENT_MAX);
-
-  int exit_code;
-  base::TerminationStatus status = GetChildTerminationStatus(&exit_code);
-  UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessTerminationStatus",
-                            status,
-                            base::TERMINATION_STATUS_MAX_ENUM);
-
-  if (status == base::TERMINATION_STATUS_NORMAL_TERMINATION ||
-      status == base::TERMINATION_STATUS_ABNORMAL_TERMINATION) {
-    UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessExitCode",
-                              exit_code,
-                              content::RESULT_CODE_LAST_CODE);
-  }
-
-  ChildProcessHost::OnChildDied();
-}
-
 void GpuProcessHost::OnProcessCrashed(int exit_code) {
   SendOutstandingReplies();
   if (++g_gpu_crash_count >= kGpuMaxCrashCount) {
     // The gpu process is too unstable to use. Disable it for current session.
     gpu_enabled_ = false;
   }
   BrowserChildProcessHost::OnProcessCrashed(exit_code);
 }
 
 bool GpuProcessHost::software_rendering() {
@@ skipping 18 matching lines @@
 #else
   int child_flags = ChildProcessHost::CHILD_NORMAL;
 #endif
 
   FilePath exe_path = ChildProcessHost::GetChildPath(child_flags);
   if (exe_path.empty())
     return false;
 
   CommandLine* cmd_line = new CommandLine(exe_path);
   cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kGpuProcess);
-  cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id());
+  cmd_line->AppendSwitchASCII(switches::kProcessChannelID,
+                              child_process_host()->channel_id());
 
   // Propagate relevant command line switches.
   static const char* const kSwitchNames[] = {
     switches::kDisableBreakpad,
     switches::kDisableGLMultisampling,
     switches::kDisableGpuDriverBugWorkarounds,
     switches::kDisableGpuSandbox,
     switches::kDisableGpuVsync,
     switches::kDisableGpuWatchdog,
     switches::kDisableLogging,
@@ skipping 60 matching lines @@
   scoped_ptr<EstablishChannelCallback> wrapped_callback(callback);
   wrapped_callback->Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     CreateCommandBufferCallback* callback, int32 route_id) {
   scoped_ptr<GpuProcessHost::CreateCommandBufferCallback>
     wrapped_callback(callback);
   callback->Run(route_id);
 }