Move core pieces of browser\renderer_host to src\content.

chrome/browser/nacl_host/nacl_process_host.cc

 // Copyright (c) 2010 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/command_line.h"
 #include "base/metrics/nacl_histogram.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/renderer_host/render_message_filter.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 "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
 
 namespace {
 
 #if !defined(DISABLE_NACL)
 void SetCloseOnExec(nacl::Handle fd) {
 #if defined(OS_POSIX)
   int flags = fcntl(fd, F_GETFD);
   CHECK(flags != -1);
   int rc = fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
   CHECK(rc == 0);
 #endif
 }
 #endif
 
 }  // namespace
 
+struct NaClProcessHost::NaClInternal {
+  std::vector<nacl::Handle> sockets_for_renderer;
+  std::vector<nacl::Handle> sockets_for_sel_ldr;
+};
+
 NaClProcessHost::NaClProcessHost(
     ResourceDispatcherHost *resource_dispatcher_host,
     const std::wstring& url)
     : BrowserChildProcessHost(NACL_LOADER_PROCESS, resource_dispatcher_host),
       resource_dispatcher_host_(resource_dispatcher_host),
       reply_msg_(NULL),
+      internal_(new NaClInternal()),
       running_on_wow64_(false) {
   set_name(url);
 #if defined(OS_WIN)
   CheckIsWow64();
 #endif
 }
 
 NaClProcessHost::~NaClProcessHost() {
   if (!reply_msg_)
     return;
 
   // nacl::Close() is not available at link time if DISABLE_NACL is
   // defined, but we still compile a bunch of other code from this
   // file anyway.  TODO(mseaborn): Make this less messy.
 #ifndef DISABLE_NACL
-  for (size_t i = 0; i < sockets_for_renderer_.size(); i++) {
-    nacl::Close(sockets_for_renderer_[i]);
+  for (size_t i = 0; i < internal_->sockets_for_renderer.size(); i++) {
+    nacl::Close(internal_->sockets_for_renderer[i]);
   }
-  for (size_t i = 0; i < sockets_for_sel_ldr_.size(); i++) {
-    nacl::Close(sockets_for_sel_ldr_[i]);
+  for (size_t i = 0; i < internal_->sockets_for_sel_ldr.size(); i++) {
+    nacl::Close(internal_->sockets_for_sel_ldr[i]);
   }
 #endif
 
   // OnProcessLaunched didn't get called because the process couldn't launch.
   // Don't keep the renderer hanging.
   reply_msg_->set_reply_error();
   render_message_filter_->Send(reply_msg_);
 }
 
 bool NaClProcessHost::Launch(RenderMessageFilter* render_message_filter,
@@ skipping 17 matching lines @@
   // This is mainly for the benefit of Windows, where sockets cannot
   // be passed in messages, but are copied via DuplicateHandle().
   // This means the sandboxed renderer cannot send handles to the
   // browser process.
 
   for (int i = 0; i < socket_count; i++) {
     nacl::Handle pair[2];
     // Create a connected socket
     if (nacl::SocketPair(pair) == -1)
       return false;
-    sockets_for_renderer_.push_back(pair[0]);
-    sockets_for_sel_ldr_.push_back(pair[1]);
+    internal_->sockets_for_renderer.push_back(pair[0]);
+    internal_->sockets_for_sel_ldr.push_back(pair[1]);
     SetCloseOnExec(pair[0]);
     SetCloseOnExec(pair[1]);
   }
 
   // Launch the process
   if (!LaunchSelLdr()) {
     return false;
   }
   UmaNaclHistogramEnumeration(NACL_STARTED);
   render_message_filter_ = render_message_filter;
@@ skipping 56 matching lines @@
 #if defined(OS_WIN)
   NaClBrokerService::GetInstance()->OnLoaderDied();
 #endif
   BrowserChildProcessHost::OnChildDied();
 }
 
 void NaClProcessHost::OnProcessLaunched() {
   std::vector<nacl::FileDescriptor> handles_for_renderer;
   base::ProcessHandle nacl_process_handle;
 
-  for (size_t i = 0; i < sockets_for_renderer_.size(); i++) {
+  for (size_t i = 0; i < internal_->sockets_for_renderer.size(); i++) {
 #if defined(OS_WIN)
     // Copy the handle into the renderer process.
     HANDLE handle_in_renderer;
     DuplicateHandle(base::GetCurrentProcessHandle(),
-                    reinterpret_cast<HANDLE>(sockets_for_renderer_[i]),
+                    reinterpret_cast<HANDLE>(
+                        internal_->sockets_for_renderer[i]),
                     render_message_filter_->peer_handle(),
                     &handle_in_renderer,
                     GENERIC_READ | GENERIC_WRITE,
                     FALSE,
                     DUPLICATE_CLOSE_SOURCE);
     handles_for_renderer.push_back(
         reinterpret_cast<nacl::FileDescriptor>(handle_in_renderer));
 #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 = sockets_for_renderer_[i];
+    imc_handle.fd = internal_->sockets_for_renderer[i];
     imc_handle.auto_close = true;
     handles_for_renderer.push_back(imc_handle);
 #endif
   }
 
 #if defined(OS_WIN)
   // Copy the process handle into the renderer process.
   DuplicateHandle(base::GetCurrentProcessHandle(),
                   handle(),
                   render_message_filter_->peer_handle(),
                   &nacl_process_handle,
                   PROCESS_DUP_HANDLE,
                   FALSE,
                   0);
 #else
   // We use pid as process handle on Posix
   nacl_process_handle = handle();
 #endif
 
   // Get the pid of the NaCl process
   base::ProcessId nacl_process_id = base::GetProcId(handle());
 
   ViewHostMsg_LaunchNaCl::WriteReplyParams(
       reply_msg_, handles_for_renderer, nacl_process_handle, nacl_process_id);
   render_message_filter_->Send(reply_msg_);
   render_message_filter_ = NULL;
   reply_msg_ = NULL;
-  sockets_for_renderer_.clear();
+  internal_->sockets_for_renderer.clear();
 
   SendStartMessage();
 }
 
 void NaClProcessHost::SendStartMessage() {
   std::vector<nacl::FileDescriptor> handles_for_sel_ldr;
-  for (size_t i = 0; i < sockets_for_sel_ldr_.size(); i++) {
+  for (size_t i = 0; i < internal_->sockets_for_sel_ldr.size(); i++) {
 #if defined(OS_WIN)
     HANDLE channel;
     if (!DuplicateHandle(GetCurrentProcess(),
-                         reinterpret_cast<HANDLE>(sockets_for_sel_ldr_[i]),
+                         reinterpret_cast<HANDLE>(
+                             internal_->sockets_for_sel_ldr[i]),
                          handle(),
                          &channel,
                          GENERIC_READ | GENERIC_WRITE,
                          FALSE, DUPLICATE_CLOSE_SOURCE)) {
       return;
     }
     handles_for_sel_ldr.push_back(
         reinterpret_cast<nacl::FileDescriptor>(channel));
 #else
     nacl::FileDescriptor channel;
-    channel.fd = dup(sockets_for_sel_ldr_[i]);
+    channel.fd = dup(internal_->sockets_for_sel_ldr[i]);
     if (channel.fd < 0) {
       LOG(ERROR) << "Failed to dup() a file descriptor";
       return;
     }
     channel.auto_close = true;
     handles_for_sel_ldr.push_back(channel);
 #endif
   }
 
 #if defined(OS_MACOSX)
@@ skipping 10 matching lines @@
   memory_fd.fd = dup(memory_buffer.handle().fd);
   if (memory_fd.fd < 0) {
     LOG(ERROR) << "Failed to dup() a file descriptor";
     return;
   }
   memory_fd.auto_close = true;
   handles_for_sel_ldr.push_back(memory_fd);
 #endif
 
   Send(new NaClProcessMsg_Start(handles_for_sel_ldr));
-  sockets_for_sel_ldr_.clear();
+  internal_->sockets_for_sel_ldr.clear();
 }
 
 bool NaClProcessHost::OnMessageReceived(const IPC::Message& msg) {
   NOTREACHED() << "Invalid message with type = " << msg.type();
   return false;
 }
 
 bool NaClProcessHost::CanShutdown() {
   return true;
 }
@@ skipping 11 matching lines @@
   if (fnIsWow64Process != NULL) {
     BOOL bIsWow64 = FALSE;
     if (fnIsWow64Process(GetCurrentProcess(),&bIsWow64)) {
       if (bIsWow64) {
         running_on_wow64_ = true;
       }
     }
   }
 }
 #endif