Fix error checking for mmap() for POSIX shared memory.

chrome/common/ipc_send_fds_test.cc

 // Copyright (c) 2009 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 "build/build_config.h"
 
 #include "chrome/common/ipc_tests.h"
 
 #if defined(OS_MACOSX)
 extern "C" {
 #include <sandbox.h>
 }
 #endif
 #include <sys/stat.h>
 
 #include "base/message_loop.h"
 #include "chrome/common/ipc_channel.h"
 #include "chrome/common/ipc_message_utils.h"
 
 #if defined(OS_POSIX)
 
 namespace {
 
+const int kNumFDsToSend = 200;
 const char* kDevRandomPath = "/dev/random";
 
 static void VerifyAndCloseDescriptor(int fd, ino_t inode_num) {
   // Check that we can read from the FD.
   char buf;
   ssize_t amt_read = read(fd, &buf, 1);
   ASSERT_EQ(amt_read, 1);
 
   struct stat st;
   ASSERT_EQ(fstat(fd, &st), 0);
 
   ASSERT_EQ(close(fd), 0);
 
   // We compare iNode numbers to check that the file sent over the wire
   // was actually the same physical file as the one we were expecting.
   ASSERT_EQ(inode_num, st.st_ino);
 }
 
 class MyChannelDescriptorListener : public IPC::Channel::Listener {
  public:
   MyChannelDescriptorListener(ino_t expected_inode_num)
-      : expected_inode_num_(expected_inode_num) {}
+      : expected_inode_num_(expected_inode_num),
+        num_fds_received_(0) {}
 
   virtual void OnMessageReceived(const IPC::Message& message) {
     void* iter = NULL;
 
+    ++num_fds_received_;
     FileDescriptor descriptor;
-
     ASSERT_TRUE(
         IPC::ParamTraits<FileDescriptor>::Read(&message, &iter, &descriptor));
 
     VerifyAndCloseDescriptor(descriptor.fd, expected_inode_num_);
-    MessageLoop::current()->Quit();
+
+    if (num_fds_received_ == kNumFDsToSend) {
+      MessageLoop::current()->Quit();
+    }
   }
 
   virtual void OnChannelError() {
     MessageLoop::current()->Quit();
   }
  private:
   ino_t expected_inode_num_;
+  int num_fds_received_;
 };
 
 void TestDescriptorServer(IPC::Channel &chan,
                           base::ProcessHandle process_handle) {
   ASSERT_TRUE(process_handle);
 
-  FileDescriptor descriptor;
-  const int fd = open(kDevRandomPath, O_RDONLY);
-  ASSERT_GE(fd, 0);
-  descriptor.auto_close = true;
-  descriptor.fd = fd;
+  for (int i = 0; i < kNumFDsToSend; ++i) {
+    FileDescriptor descriptor;
+    const int fd = open(kDevRandomPath, O_RDONLY);
+    ASSERT_GE(fd, 0);
+    descriptor.auto_close = true;
+    descriptor.fd = fd;
 
-  IPC::Message* message = new IPC::Message(0, // routing_id
-                                           3, // message type
-                                           IPC::Message::PRIORITY_NORMAL);
-  IPC::ParamTraits<FileDescriptor>::Write(message, descriptor);
-  chan.Send(message);
+    IPC::Message* message = new IPC::Message(0, // routing_id
+                                             3, // message type
+                                             IPC::Message::PRIORITY_NORMAL);
+    IPC::ParamTraits<FileDescriptor>::Write(message, descriptor);
+    chan.Send(message);
+  }
 
   // Run message loop.
   MessageLoop::current()->Run();
 
   // Close Channel so client gets its OnChannelError() callback fired.
   chan.Close();
 
   // Cleanup child process.
   EXPECT_TRUE(base::WaitForSingleProcess(process_handle, 5000));
 }
@@ skipping 75 matching lines @@
   IPC::Channel chan(kTestClientChannel, IPC::Channel::MODE_SERVER,
                     &listener);
   chan.Connect();
 
   base::ProcessHandle process_handle = SpawnChild(TEST_DESCRIPTOR_CLIENT,
                                                   &chan);
   TestDescriptorServer(chan, process_handle);
 }
 
 #endif  // defined(OS_POSIX)