Non-SFI Mode: Build ipc/ library by PNaCl toolchain for nacl_helper_nonsfi.

ipc/ipc_channel.h

 // 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.
 
 #ifndef IPC_IPC_CHANNEL_H_
 #define IPC_IPC_CHANNEL_H_
 
 #include <string>
 
 #if defined(OS_POSIX)
@@ skipping 161 matching lines @@
 
   // Get its own process id. This value is told to the peer.
   virtual base::ProcessId GetSelfPID() const = 0;
 
   // Send a message over the Channel to the listener on the other end.
   //
   // |message| must be allocated using operator new.  This object will be
   // deleted once the contents of the Message have been sent.
   virtual bool Send(Message* message) = 0;
 
-#if defined(OS_POSIX) && !defined(OS_NACL)
+  // The IPC library is built for various platforms, including Win, Mac, Linux
+  // and NaCl in SFI-mode and in Non-SFI mode.
+  // Here, as for NaCl, the IPC library for NaCl in SFI-mode is linked into

[Mark Seaborn, 2014/10/22 00:35:51]

This comment is rather long...  We shouldn't have to explain the background
about SFI vs. non-SFI NaCl next to every #if. :-)  How about creating a readme
doc (perhaps components/nacl/README or components/nacl/loader/nonsfi/README) to
put this explanation in, and then refer to that here?

[hidehiko, 2014/10/22 13:31:05]

Indeed. Added comment in components/nacl_nonsfi.gyp and referred it from here,
instead of introducing README. (README is useful for totally new people, but
IMHO people who'll be interested in the topic would be Chrome developer so
they'd be familiar with .gyp. Also, README can be easily stale. So, I thought
.gyp is better to put some comments).

+  // irt.nexe and loaded by nacl_helper (the channel implementation is
+  // ipc_channel_nacl), while the one for NaCl in Non-SFI mode is linked into
+  // nacl_helper_nonsfi and runs directly on Linux platform (the channel
+  // implementation is ipc_channel_posix).
+  // So, since both are built by the NaCl/PNaCl toolchains, OS_NACL macro is
+  // defined (derived from __native_client__ macro) in both cases, but the
+  // latter is closer to Linux build. Actually GetClientFileDescriptor,
+  // TakeClientFileDescriptor GenerateUniqueRandomChannelID,
+  // GenerateVerifiedChannelID and SetGlobalPid are needed and used to
+  // implement nacl_helper_nonsfi.
+  // The compiler defined macro to figure out if this is compiled for NaCl in
+  // SFI-mode or in Non-SFI mode is __native_client_nonsfi__.
+#if defined(OS_POSIX) && \
+    (!defined(OS_NACL) || defined(__native_client_nonsfi__))
   // On POSIX an IPC::Channel wraps a socketpair(), this method returns the
   // FD # for the client end of the socket.
   // This method may only be called on the server side of a channel.
   // This method can be called on any thread.
   virtual int GetClientFileDescriptor() const = 0;
 
   // Same as GetClientFileDescriptor, but transfers the ownership of the
   // file descriptor to the caller.
   // This method can be called on any thread.
   virtual int TakeClientFileDescriptor() = 0;
-#endif  // defined(OS_POSIX) && !defined(OS_NACL)
+#endif
 
   // Returns true if a named server channel is initialized on the given channel
   // ID. Even if true, the server may have already accepted a connection.
   static bool IsNamedServerInitialized(const std::string& channel_id);
 
-#if !defined(OS_NACL)
+#if !defined(OS_NACL) || defined(__native_client_nonsfi__)
   // Generates a channel ID that's non-predictable and unique.
   static std::string GenerateUniqueRandomChannelID();
 
   // Generates a channel ID that, if passed to the client as a shared secret,
   // will validate that the client's authenticity. On platforms that do not
   // require additional this is simply calls GenerateUniqueRandomChannelID().
   // For portability the prefix should not include the \ character.
   static std::string GenerateVerifiedChannelID(const std::string& prefix);
 #endif
 
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(__native_client_nonsfi__)
   // Sandboxed processes live in a PID namespace, so when sending the IPC hello
   // message from client to server we need to send the PID from the global
   // PID namespace.
   static void SetGlobalPid(int pid);
 #endif
 
 #if defined(OS_ANDROID)
   // Most tests are single process and work the same on all platforms. However
   // in some cases we want to test multi-process, and Android differs in that it
   // can't 'exec' after forking. This callback resets any data in the forked
   // process such that it acts similar to if it was exec'd, for tests.
   static void NotifyProcessForkedForTesting();
 #endif
 
 };
 
 #if defined(OS_POSIX)
 // SocketPair() creates a pair of socket FDs suitable for using with
 // IPC::Channel.
 IPC_EXPORT bool SocketPair(int* fd1, int* fd2);
 #endif
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_H_