Use native_client/src/public/ for IMC headers

ipc/ipc_channel_nacl.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 "ipc/ipc_channel_nacl.h"
 
 #include <errno.h>
 #include <stddef.h>
-#include <sys/nacl_imc_api.h>
-#include <sys/nacl_syscalls.h>
 #include <sys/types.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/process_util.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner_util.h"
 #include "base/threading/simple_thread.h"
 #include "ipc/file_descriptor_set_posix.h"
 #include "ipc/ipc_logging.h"
+#include "native_client/src/public/imc_syscalls.h"
+#include "native_client/src/public/imc_types.h"
 
 namespace IPC {
 
 struct MessageContents {
   std::vector<char> data;
   std::vector<int> fds;
 };
 
 namespace {
 
 bool ReadDataOnReaderThread(int pipe, MessageContents* contents) {
   DCHECK(pipe >= 0);
   if (pipe < 0)
     return false;
 
   contents->data.resize(Channel::kReadBufferSize);
   contents->fds.resize(FileDescriptorSet::kMaxDescriptorsPerMessage);
 
-  NaClImcMsgIoVec iov = { &contents->data[0], contents->data.size() };
-  NaClImcMsgHdr msg = { &iov, 1, &contents->fds[0], contents->fds.size() };
+  NaClAbiNaClImcMsgIoVec iov = { &contents->data[0], contents->data.size() };
+  NaClAbiNaClImcMsgHdr msg = {
+    &iov, 1, &contents->fds[0], contents->fds.size()
+  };
 
   int bytes_read = imc_recvmsg(pipe, &msg, 0);
 
   if (bytes_read <= 0) {
     // NaClIPCAdapter::BlockingReceive returns -1 when the pipe closes (either
     // due to error or for regular shutdown).
     contents->data.clear();
     contents->fds.clear();
     return false;
   }
@@ skipping 203 matching lines @@
   // block. See NaClIPCAdapter::Send for the implementation of imc_sendmsg.
   while (!output_queue_.empty()) {
     linked_ptr<Message> msg = output_queue_.front();
     output_queue_.pop_front();
 
     int fds[FileDescriptorSet::kMaxDescriptorsPerMessage];
     const size_t num_fds = msg->file_descriptor_set()->size();
     DCHECK(num_fds <= FileDescriptorSet::kMaxDescriptorsPerMessage);
     msg->file_descriptor_set()->GetDescriptors(fds);
 
-    NaClImcMsgIoVec iov = { const_cast<void*>(msg->data()), msg->size() };
-    NaClImcMsgHdr msgh = { &iov, 1, fds, num_fds };
+    NaClAbiNaClImcMsgIoVec iov = {
+      const_cast<void*>(msg->data()), msg->size()
+    };
+    NaClAbiNaClImcMsgHdr msgh = { &iov, 1, fds, num_fds };
     ssize_t bytes_written = imc_sendmsg(pipe_, &msgh, 0);
 
     DCHECK(bytes_written);  // The trusted side shouldn't return 0.
     if (bytes_written < 0) {
       // The trusted side should only ever give us an error of EPIPE. We
       // should never be interrupted, nor should we get EAGAIN.
       DCHECK(errno == EPIPE);
       Close();
       PLOG(ERROR) << "pipe_ error on "
                   << pipe_
@@ skipping 93 matching lines @@
   // This shouldn't actually get used in the untrusted side of the proxy, and we
   // don't have the real pid anyway.
   return -1;
 }
 
 bool Channel::Send(Message* message) {
   return channel_impl_->Send(message);
 }
 
 }  // namespace IPC