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

content/browser/gpu/gpu_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/gpu/gpu_process_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.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/browser_child_process_host.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_impl.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"
@@ skipping 125 matching lines @@
 
  private:
   std::string channel_id_;
   // Deleted in CleanUp() on the gpu thread, so don't use smart pointers.
   GpuProcess* gpu_process_;
   GpuChildThread* child_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuMainThread);
 };
 
-static bool HostIsValid(GpuProcessHost* host) {
+// static
+bool GpuProcessHost::HostIsValid(GpuProcessHost* host) {
   if (!host)
     return false;
 
   // Check if the GPU process has died and the host is about to be destroyed.
-  if (host->disconnect_was_alive())
+  if (host->process_->disconnect_was_alive())
     return false;
 
   // The Gpu process is invalid if it's not using software, the card is
   // blacklisted, and we can kill it and start over.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU) ||
       host->software_rendering() ||
       !GpuDataManager::GetInstance()->software_rendering()) {
     return true;
   }
@@ skipping 59 matching lines @@
     return NULL;
 
   GpuProcessHost *host = g_hosts_by_id.Pointer()->Lookup(host_id);
   if (HostIsValid(host))
     return host;
 
   return NULL;
 }
 
 GpuProcessHost::GpuProcessHost(int host_id)
-    : BrowserChildProcessHost(content::PROCESS_TYPE_GPU),
-      host_id_(host_id),
+    : host_id_(host_id),
       gpu_process_(base::kNullProcessHandle),
       in_process_(false),
       software_rendering_(false) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU))
     in_process_ = true;
 
   // If the 'single GPU process' policy ever changes, we still want to maintain
   // it for 'gpu thread' mode and only create one instance of host and thread.
   DCHECK(!in_process_ || g_hosts_by_id.Pointer()->IsEmpty());
 
   g_hosts_by_id.Pointer()->AddWithID(this, host_id_);
 
   // Post a task to create the corresponding GpuProcessHostUIShim.  The
   // GpuProcessHostUIShim will be destroyed if either the browser exits,
   // in which case it calls GpuProcessHostUIShim::DestroyAll, or the
   // GpuProcessHost is destroyed, which happens when the corresponding GPU
   // process terminates or fails to launch.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(base::IgnoreResult(&GpuProcessHostUIShim::Create), host_id));
+
+  process_.reset(new BrowserChildProcessHost(content::PROCESS_TYPE_GPU, this));
 }
 
 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);
+  base::TerminationStatus status = process_->GetTerminationStatus(&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);
   }
@@ skipping 10 matching lines @@
   }
 
   g_hosts_by_id.Pointer()->Remove(host_id_);
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&GpuProcessHostUIShim::Destroy, host_id_));
 }
 
 bool GpuProcessHost::Init() {
-  std::string channel_id = child_process_host()->CreateChannel();
+  std::string channel_id = process_->GetHost()->CreateChannel();
   if (channel_id.empty())
     return false;
 
   if (in_process_) {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kDisableGpuWatchdog);
 
     in_process_gpu_thread_.reset(new GpuMainThread(channel_id));
 
     base::Thread::Options options;
@@ skipping 18 matching lines @@
 
 void GpuProcessHost::RouteOnUIThread(const IPC::Message& message) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&RouteToGpuProcessHostUIShimTask, host_id_, message));
 }
 
 bool GpuProcessHost::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
-  if (child_process_host()->IsChannelOpening()) {
+  if (process_->GetHost()->IsChannelOpening()) {
     queued_messages_.push(msg);
     return true;
   }
 
-  return BrowserChildProcessHost::Send(msg);
+  return process_->Send(msg);
 }
 
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished)
     IPC_MESSAGE_HANDLER(GpuHostMsg_CommandBufferCreated, OnCommandBufferCreated)
     IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyCommandBuffer, OnDestroyCommandBuffer)
     IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message))
   IPC_END_MESSAGE_MAP()
 
   return true;
 }
 
 void GpuProcessHost::OnChannelConnected(int32 peer_pid) {
-  BrowserChildProcessHost::OnChannelConnected(peer_pid);
   while (!queued_messages_.empty()) {
     Send(queued_messages_.front());
     queued_messages_.pop();
   }
 }
 
 void GpuProcessHost::EstablishGpuChannel(
     int client_id,
     const EstablishChannelCallback& callback) {
   DCHECK(CalledOnValidThread());
@@ skipping 97 matching lines @@
     surface_refs_.erase(it);
 #endif  // defined(TOOLKIT_USES_GTK)
 }
 
 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.
 
   base::ProcessHandle child_handle = in_process_ ?
-      base::GetCurrentProcessHandle() : data().handle;
+      base::GetCurrentProcessHandle() : process_->GetData().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::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() {
   return software_rendering_;
 }
 
 void GpuProcessHost::ForceShutdown() {
   g_hosts_by_id.Pointer()->Remove(host_id_);
-  BrowserChildProcessHost::ForceShutdown();
+  process_->ForceShutdown();
 }
 
 bool GpuProcessHost::LaunchGpuProcess(const std::string& channel_id) {
   if (!gpu_enabled_ || g_gpu_crash_count >= kGpuMaxCrashCount) {
     SendOutstandingReplies();
     gpu_enabled_ = false;
     return false;
   }
 
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
@@ skipping 49 matching lines @@
   GpuDataManager::GetInstance()->AppendGpuCommandLine(cmd_line);
 
   if (cmd_line->HasSwitch(switches::kUseGL))
     software_rendering_ =
         (cmd_line->GetSwitchValueASCII(switches::kUseGL) == "swiftshader");
 
   // If specified, prepend a launcher program to the command line.
   if (!gpu_launcher.empty())
     cmd_line->PrependWrapper(gpu_launcher);
 
-  Launch(
+  process_->Launch(
 #if defined(OS_WIN)
       FilePath(),
 #elif defined(OS_POSIX)
       false,  // Never use the zygote (GPU plugin can't be sandboxed).
       base::environment_vector(),
 #endif
       cmd_line);
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             LAUNCHED, GPU_PROCESS_LIFETIME_EVENT_MAX);
@@ skipping 17 matching lines @@
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& gpu_info) {
   callback.Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     const CreateCommandBufferCallback& callback, int32 route_id) {
   callback.Run(route_id);
 }