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

chrome/browser/nacl_host/nacl_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 "build/build_config.h"
 
 #include "chrome/browser/nacl_host/nacl_process_host.h"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #endif
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/nacl_cmd_line.h"
 #include "chrome/common/nacl_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
+#include "content/public/browser/browser_child_process_host.h"
+#include "content/public/browser/child_process_data.h"
 #include "content/public/common/child_process_host.h"
 #include "ipc/ipc_switches.h"
 #include "native_client/src/shared/imc/nacl_imc.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #elif defined(OS_WIN)
 #include "chrome/browser/nacl_host/nacl_broker_service_win.h"
 #endif
 
 using content::BrowserThread;
+using content::ChildProcessData;
 using content::ChildProcessHost;
 
 namespace {
 
 void SetCloseOnExec(nacl::Handle fd) {
 #if defined(OS_POSIX)
   int flags = fcntl(fd, F_GETFD);
   CHECK_NE(flags, -1);
   int rc = fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
   CHECK_EQ(rc, 0);
@@ skipping 54 matching lines @@
 };
 
 #if defined(OS_WIN)
 static bool RunningOnWOW64() {
   return (base::win::OSInfo::GetInstance()->wow64_status() ==
           base::win::OSInfo::WOW64_ENABLED);
 }
 #endif
 
 NaClProcessHost::NaClProcessHost(const std::wstring& url)
-    : BrowserChildProcessHost(content::PROCESS_TYPE_NACL_LOADER),
-      reply_msg_(NULL),
+    : reply_msg_(NULL),
       internal_(new NaClInternal()),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
-  SetName(WideToUTF16Hack(url));
+  process_.reset(content::BrowserChildProcessHost::Create(
+      content::PROCESS_TYPE_NACL_LOADER, this));
+  process_->SetName(WideToUTF16Hack(url));
 }
 
 NaClProcessHost::~NaClProcessHost() {
   int exit_code;
-  GetChildTerminationStatus(&exit_code);
+  process_->GetTerminationStatus(&exit_code);
   std::string message =
       base::StringPrintf("NaCl process exited with status %i (0x%x)",
                          exit_code, exit_code);
   if (exit_code == 0) {
     LOG(INFO) << message;
   } else {
     LOG(ERROR) << message;
   }
 
 #if defined(OS_WIN)
@@ skipping 95 matching lines @@
   }
 
   chrome_render_message_filter_ = chrome_render_message_filter;
 
   // On success, we take responsibility for sending the reply.
   reply_msg_ = reply_msg;
   return true;
 }
 
 bool NaClProcessHost::LaunchSelLdr() {
-  std::string channel_id = child_process_host()->CreateChannel();
+  std::string channel_id = process_->GetHost()->CreateChannel();
   if (channel_id.empty())
     return false;
 
   CommandLine::StringType nacl_loader_prefix;
 #if defined(OS_POSIX)
   nacl_loader_prefix = CommandLine::ForCurrentProcess()->GetSwitchValueNative(
       switches::kNaClLoaderCmdPrefix);
 #endif  // defined(OS_POSIX)
 
   // Build command line for nacl.
@@ skipping 28 matching lines @@
 
   if (!nacl_loader_prefix.empty())
     cmd_line->PrependWrapper(nacl_loader_prefix);
 
   // On Windows we might need to start the broker process to launch a new loader
 #if defined(OS_WIN)
   if (RunningOnWOW64()) {
     return NaClBrokerService::GetInstance()->LaunchLoader(
         this, ASCIIToWide(channel_id));
   } else {
-    BrowserChildProcessHost::Launch(FilePath(), cmd_line);
+    process_->Launch(FilePath(), cmd_line);
   }
 #elif defined(OS_POSIX)
-  BrowserChildProcessHost::Launch(nacl_loader_prefix.empty(),  // use_zygote
-                                  base::environment_vector(),
-                                  cmd_line);
+  process_->Launch(nacl_loader_prefix.empty(),  // use_zygote
+                   base::environment_vector(),
+                   cmd_line);
 #endif
 
   return true;
 }
 
 void NaClProcessHost::OnProcessLaunchedByBroker(base::ProcessHandle handle) {
-  SetHandle(handle);
+  process_->SetHandle(handle);
   OnProcessLaunched();
 }
 
 void NaClProcessHost::OnProcessCrashed(int exit_code) {
   std::string message = base::StringPrintf(
       "NaCl process exited with status %i (0x%x)", exit_code, exit_code);
   LOG(ERROR) << message;
 }
 
 namespace {
@@ skipping 153 matching lines @@
 #else
     // No need to dup the imc_handle - we don't pass it anywhere else so
     // it cannot be closed.
     nacl::FileDescriptor imc_handle;
     imc_handle.fd = internal_->sockets_for_renderer[i];
     imc_handle.auto_close = true;
     handles_for_renderer.push_back(imc_handle);
 #endif
   }
 
+  const ChildProcessData& data = process_->GetData();
 #if defined(OS_WIN)
   // Copy the process handle into the renderer process.
   if (!DuplicateHandle(base::GetCurrentProcessHandle(),
-                       data().handle,
+                       data.handle,
                        chrome_render_message_filter_->peer_handle(),
                        &nacl_process_handle,
                        PROCESS_DUP_HANDLE,
                        FALSE,
                        0)) {
     LOG(ERROR) << "DuplicateHandle() failed";
     delete this;
     return;
   }
 #else
   // We use pid as process handle on Posix
-  nacl_process_handle = data().handle;
+  nacl_process_handle = data.handle;
 #endif
 
   // Get the pid of the NaCl process
-  base::ProcessId nacl_process_id = base::GetProcId(data().handle);
+  base::ProcessId nacl_process_id = base::GetProcId(data.handle);
 
   ChromeViewHostMsg_LaunchNaCl::WriteReplyParams(
       reply_msg_, handles_for_renderer, nacl_process_handle, nacl_process_id);
   chrome_render_message_filter_->Send(reply_msg_);
   chrome_render_message_filter_ = NULL;
   reply_msg_ = NULL;
   internal_->sockets_for_renderer.clear();
 
   std::vector<nacl::FileDescriptor> handles_for_sel_ldr;
   for (size_t i = 0; i < internal_->sockets_for_sel_ldr.size(); i++) {
-    if (!SendHandleToSelLdr(data().handle,
+    if (!SendHandleToSelLdr(data.handle,
                             internal_->sockets_for_sel_ldr[i], true,
                             &handles_for_sel_ldr)) {
       delete this;
       return;
     }
   }
 
   // Send over the IRT file handle.  We don't close our own copy!
-  if (!SendHandleToSelLdr(
-          data().handle, irt_file, false, &handles_for_sel_ldr)) {
+  if (!SendHandleToSelLdr(data.handle, irt_file, false, &handles_for_sel_ldr)) {
     delete this;
     return;
   }
 
 #if defined(OS_MACOSX)
   // For dynamic loading support, NaCl requires a file descriptor that
   // was created in /tmp, since those created with shm_open() are not
   // mappable with PROT_EXEC.  Rather than requiring an extra IPC
   // round trip out of the sandbox, we create an FD here.
   base::SharedMemory memory_buffer;
   base::SharedMemoryCreateOptions options;
   options.size = 1;
   options.executable = true;
   if (!memory_buffer.Create(options)) {
     LOG(ERROR) << "Failed to allocate memory buffer";
     delete this;
     return;
   }
   nacl::FileDescriptor memory_fd;
   memory_fd.fd = dup(memory_buffer.handle().fd);
   if (memory_fd.fd < 0) {
     LOG(ERROR) << "Failed to dup() a file descriptor";
     delete this;
     return;
   }
   memory_fd.auto_close = true;
   handles_for_sel_ldr.push_back(memory_fd);
 #endif
 
-  Send(new NaClProcessMsg_Start(handles_for_sel_ldr));
+  process_->Send(new NaClProcessMsg_Start(handles_for_sel_ldr));
   internal_->sockets_for_sel_ldr.clear();
 }
 
 bool NaClProcessHost::OnMessageReceived(const IPC::Message& msg) {
   NOTREACHED() << "Invalid message with type = " << msg.type();
   return false;
 }