NaCl: Remove use of the C++ IMC interface; use the C version instead

chrome/browser/nacl_host/nacl_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 "chrome/browser/nacl_host/nacl_process_host.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 25 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/process_type.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/url_pattern.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_switches.h"
-#include "native_client/src/shared/imc/nacl_imc.h"
+#include "native_client/src/shared/imc/nacl_imc_c.h"
 #include "net/base/net_util.h"
 #include "net/base/tcp_listen_socket.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 #if defined(OS_POSIX)
 #include <fcntl.h>
 
 #include "ipc/ipc_channel_posix.h"
 #elif defined(OS_WIN)
 #include <windows.h>
@@ skipping 13 matching lines @@
 
 namespace {
 
 #if defined(OS_WIN)
 bool RunningOnWOW64() {
   return (base::win::OSInfo::GetInstance()->wow64_status() ==
           base::win::OSInfo::WOW64_ENABLED);
 }
 #endif
 
-void SetCloseOnExec(nacl::Handle fd) {
+void SetCloseOnExec(NaClHandle 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);
 #endif
 }
 
 bool ShareHandleToSelLdr(
     base::ProcessHandle processh,
-    nacl::Handle sourceh,
+    NaClHandle sourceh,
     bool close_source,
     std::vector<nacl::FileDescriptor> *handles_for_sel_ldr) {
 #if defined(OS_WIN)
   HANDLE channel;
   int flags = DUPLICATE_SAME_ACCESS;
   if (close_source)
     flags |= DUPLICATE_CLOSE_SOURCE;
   if (!DuplicateHandle(GetCurrentProcess(),
                        reinterpret_cast<HANDLE>(sourceh),
                        processh,
@@ skipping 19 matching lines @@
   // Only allow NaCl plugins to request certain permissions. We don't want
   // a compromised renderer to be able to start a nacl plugin with e.g. Flash
   // permissions which may expand the surface area of the sandbox.
   uint32 masked_bits = permission_bits & ppapi::PERMISSION_DEV;
   return ppapi::PpapiPermissions::GetForCommandLine(masked_bits);
 }
 
 }  // namespace
 
 struct NaClProcessHost::NaClInternal {
-  nacl::Handle socket_for_renderer;
-  nacl::Handle socket_for_sel_ldr;
+  NaClHandle socket_for_renderer;
+  NaClHandle socket_for_sel_ldr;
 
   NaClInternal()
-    : socket_for_renderer(nacl::kInvalidHandle),
-      socket_for_sel_ldr(nacl::kInvalidHandle) { }
+    : socket_for_renderer(NACL_INVALID_HANDLE),
+      socket_for_sel_ldr(NACL_INVALID_HANDLE) { }
 };
 
 // -----------------------------------------------------------------------------
 
 NaClProcessHost::PluginListener::PluginListener(NaClProcessHost* host)
     : host_(host) {
 }
 
 bool NaClProcessHost::PluginListener::OnMessageReceived(
     const IPC::Message& msg) {
@@ skipping 49 matching lines @@
   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 (internal_->socket_for_renderer != nacl::kInvalidHandle) {
-    if (nacl::Close(internal_->socket_for_renderer) != 0) {
-      NOTREACHED() << "nacl::Close() failed";
+  if (internal_->socket_for_renderer != NACL_INVALID_HANDLE) {
+    if (NaClClose(internal_->socket_for_renderer) != 0) {
+      NOTREACHED() << "NaClClose() failed";
     }
   }
 
-  if (internal_->socket_for_sel_ldr != nacl::kInvalidHandle) {
-    if (nacl::Close(internal_->socket_for_sel_ldr) != 0) {
-      NOTREACHED() << "nacl::Close() failed";
+  if (internal_->socket_for_sel_ldr != NACL_INVALID_HANDLE) {
+    if (NaClClose(internal_->socket_for_sel_ldr) != 0) {
+      NOTREACHED() << "NaClClose() failed";
     }
   }
 
   if (reply_msg_) {
     // The process failed to launch for some reason.
     // Don't keep the renderer hanging.
     reply_msg_->set_reply_error();
     chrome_render_message_filter_->Send(reply_msg_);
   }
 #if defined(OS_WIN)
@@ skipping 46 matching lines @@
 
   // Rather than creating a socket pair in the renderer, and passing
   // one side through the browser to sel_ldr, socket pairs are created
   // in the browser and then passed to the renderer and sel_ldr.
   //
   // 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.
 
-  nacl::Handle pair[2];
+  NaClHandle pair[2];
   // Create a connected socket
-  if (nacl::SocketPair(pair) == -1) {
+  if (NaClSocketPair(pair) == -1) {
     LOG(ERROR) << "NaCl process launch failed: could not create a socket pair";
     delete this;
     return;
   }
   internal_->socket_for_renderer = pair[0];
   internal_->socket_for_sel_ldr = pair[1];
   SetCloseOnExec(pair[0]);
   SetCloseOnExec(pair[1]);
 
   // Launch the process
@@ skipping 366 matching lines @@
   }
 #endif
 
   const ChildProcessData& data = process_->GetData();
   ChromeViewHostMsg_LaunchNaCl::WriteReplyParams(
       reply_msg_, handle_for_renderer,
       channel_handle, base::GetProcId(data.handle), data.id);
   chrome_render_message_filter_->Send(reply_msg_);
   chrome_render_message_filter_ = NULL;
   reply_msg_ = NULL;
-  internal_->socket_for_renderer = nacl::kInvalidHandle;
+  internal_->socket_for_renderer = NACL_INVALID_HANDLE;
   return true;
 }
 
 // TCP port we chose for NaCl debug stub. It can be any other number.
 static const int kDebugStubPort = 4014;
 
 #if defined(OS_POSIX)
 SocketDescriptor NaClProcessHost::GetDebugStubSocketHandle() {
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
   SocketDescriptor s;
@@ skipping 80 matching lines @@
     SocketDescriptor server_bound_socket = GetDebugStubSocketHandle();
     if (server_bound_socket != net::TCPListenSocket::kInvalidSocket) {
       params.debug_stub_server_bound_socket =
           nacl::FileDescriptor(server_bound_socket, true);
     }
   }
 #endif
 
   process_->Send(new NaClProcessMsg_Start(params));
 
-  internal_->socket_for_sel_ldr = nacl::kInvalidHandle;
+  internal_->socket_for_sel_ldr = NACL_INVALID_HANDLE;
   return true;
 }
 
 bool NaClProcessHost::SendStart() {
   if (!enable_ppapi_proxy()) {
     if (!ReplyToRenderer(IPC::ChannelHandle()))
       return false;
   }
   return StartNaClExecution();
 }
@@ skipping 157 matching lines @@
   } else {
     NaClStartDebugExceptionHandlerThread(
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif