[mojo-edk] Make the Mojo EDK compile under NaCl.

mojo/edk/embedder/platform_channel_pair_posix.cc

 // Copyright 2014 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 "mojo/edk/embedder/platform_channel_pair.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
+#if !defined(OS_NACL) || defined(OS_NACL_NONSFI)

[Ken Rockot(use gerrit already), 2016/06/06 02:58:33]

nit: The style guide doesn't make a clear statement about this AFAICT but it
seems uncommon to have conditional includes packed in with the rest, even for
system headers. Can this block move down below with other conditional includes?
Same question for all the other conditional includes in this CL.

[Anand Mistry (off Chromium), 2016/06/06 03:47:02]

Done.

 #include <sys/socket.h>
+#endif
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/posix/global_descriptors.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "mojo/edk/embedder/platform_handle.h"
 
+#if defined(OS_NACL)
+#include "native_client/src/public/imc_syscalls.h"
+#endif
+
 #if !defined(SO_PEEK_OFF)
 #define SO_PEEK_OFF 42
 #endif
 
 namespace mojo {
 namespace edk {
 
 namespace {
 
 bool IsTargetDescriptorUsed(
     const base::FileHandleMappingVector& file_handle_mapping,
     int target_fd) {
   for (size_t i = 0; i < file_handle_mapping.size(); i++) {
     if (file_handle_mapping[i].second == target_fd)
       return true;
   }
   return false;
 }
 
 }  // namespace
 
 PlatformChannelPair::PlatformChannelPair(bool client_is_blocking) {
   // Create the Unix domain socket.
   int fds[2];
   // TODO(vtl): Maybe fail gracefully if |socketpair()| fails.
 
+#if defined(OS_NACL) && !defined(OS_NACL_NONSFI)
+  PCHECK(imc_socketpair(fds) == 0);
+#else
   PCHECK(socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == 0);
 
   // Set the ends to nonblocking.
   PCHECK(fcntl(fds[0], F_SETFL, O_NONBLOCK) == 0);
   if (!client_is_blocking)
     PCHECK(fcntl(fds[1], F_SETFL, O_NONBLOCK) == 0);
 
 #if defined(OS_MACOSX)
   // This turns off |SIGPIPE| when writing to a closed socket (causing it to
   // fail with |EPIPE| instead). On Linux, we have to use |send...()| with
   // |MSG_NOSIGNAL| -- which is not supported on Mac -- instead.
   int no_sigpipe = 1;
   PCHECK(setsockopt(fds[0], SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe,
                     sizeof(no_sigpipe)) == 0);
   PCHECK(setsockopt(fds[1], SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe,
                     sizeof(no_sigpipe)) == 0);
 #endif  // defined(OS_MACOSX)
+#endif  // defined(OS_NACL) && !defined(OS_NACL_NONSFI)
 
   server_handle_.reset(PlatformHandle(fds[0]));
   DCHECK(server_handle_.is_valid());
   client_handle_.reset(PlatformHandle(fds[1]));
   DCHECK(client_handle_.is_valid());
 }
 
 // static
 ScopedPlatformHandle PlatformChannelPair::PassClientHandleFromParentProcess(
     const base::CommandLine& command_line) {
@@ skipping 52 matching lines @@
   while (IsTargetDescriptorUsed(*handle_passing_info, target_fd))
     target_fd++;
 
   handle_passing_info->push_back(
       std::pair<int, int>(client_handle_.get().handle, target_fd));
   return base::IntToString(target_fd);
 }
 
 }  // namespace edk
 }  // namespace mojo