IPC: Make ipc_perftests run on Android.

ipc/ipc_channel_posix.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_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
@@ skipping 117 matching lines @@
                            << "(fd " << i->second << ") still exists";
     map_[channel_id] = fd;
   }
 
  private:
   base::Lock lock_;
   typedef std::map<std::string, int> ChannelToFDMap;
   ChannelToFDMap map_;
 
   friend struct DefaultSingletonTraits<PipeMap>;
+#if defined(OS_ANDROID)
+  friend void ::IPC::Channel::NotifyProcessForkedForTesting();
+#endif
 };
 
 //------------------------------------------------------------------------------
 
 bool SocketWriteErrorIsRecoverable() {
 #if defined(OS_MACOSX)
   // On OS X if sendmsg() is trying to send fds between processes and there
   // isn't enough room in the output buffer to send the fd structure over
   // atomically then EMSGSIZE is returned.
   //
   // EMSGSIZE presents a problem since the system APIs can only call us when
   // there's room in the socket buffer and not when there is "enough" room.
   //
   // The current behavior is to return to the event loop when EMSGSIZE is
   // received and hopefull service another FD.  This is however still
   // technically a busy wait since the event loop will call us right back until
   // the receiver has read enough data to allow passing the FD over atomically.
   return errno == EAGAIN || errno == EMSGSIZE;
 #else
   return errno == EAGAIN;
 #endif  // OS_MACOSX
 }
 
 }  // namespace
+
+#if defined(OS_ANDROID)
+// When we fork for simple tests on Android, we can't 'exec', so we need to
+// reset these entries manually to get the expected testing behavior.
+void Channel::NotifyProcessForkedForTesting() {
+  PipeMap::GetInstance()->map_.clear();
+}
+#endif
+
 //------------------------------------------------------------------------------
 
 #if defined(OS_LINUX)
 int Channel::ChannelImpl::global_pid_ = 0;
 #endif  // OS_LINUX
 
 Channel::ChannelImpl::ChannelImpl(const IPC::ChannelHandle& channel_handle,
                                   Mode mode, Listener* listener)
     : ChannelReader(listener),
       mode_(mode),
@@ skipping 48 matching lines @@
 }
 
 bool Channel::ChannelImpl::CreatePipe(
     const IPC::ChannelHandle& channel_handle) {
   DCHECK(server_listen_pipe_ == -1 && pipe_ == -1);
 
   // Four possible cases:
   // 1) It's a channel wrapping a pipe that is given to us.
   // 2) It's for a named channel, so we create it.
   // 3) It's for a client that we implement ourself. This is used
-  //    in unittesting.
+  //    in single-process unittesting.
   // 4) It's the initial IPC channel:
   //   4a) Client side: Pull the pipe out of the GlobalDescriptors set.
   //   4b) Server side: create the pipe.
 
   int local_pipe = -1;
   if (channel_handle.socket.fd != -1) {
     // Case 1 from comment above.
     local_pipe = channel_handle.socket.fd;
 #if defined(IPC_USES_READWRITE)
     // Test the socket passed into us to make sure it is nonblocking.
@@ skipping 864 matching lines @@
 
 
 #if defined(OS_LINUX)
 // static
 void Channel::SetGlobalPid(int pid) {
   ChannelImpl::SetGlobalPid(pid);
 }
 #endif  // OS_LINUX
 
 }  // namespace IPC