Don't HANDLE_EINTR(close). Either IGNORE_EINTR(close) or just close.

ipc/ipc_send_fds_test.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 "build/build_config.h"
 
 #if defined(OS_POSIX)
 #if defined(OS_MACOSX)
 extern "C" {
 #include <sandbox.h>
@@ skipping 135 matching lines @@
   // of descriptors, and not because of the channel closing unexpectedly.
   CHECK(listener.GotExpectedNumberOfDescriptors());
 
   return 0;
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendFdsClient) {
   struct stat st;
   int fd = open(kDevZeroPath, O_RDONLY);
   fstat(fd, &st);
-  EXPECT_GE(HANDLE_EINTR(close(fd)), 0);
+  EXPECT_GE(IGNORE_EINTR(close(fd)), 0);
   return SendFdsClientCommon("SendFdsClient", st.st_ino);
 }
 
 #if defined(OS_MACOSX)
 // Test that FDs are correctly sent to a sandboxed process.
 // TODO(port): Make this test cross-platform.
 TEST_F(IPCSendFdsTest, DescriptorTestSandboxed) {
   Init("SendFdsSandboxedClient");
   RunServer();
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendFdsSandboxedClient) {
   struct stat st;
   const int fd = open(kDevZeroPath, O_RDONLY);
   fstat(fd, &st);
-  if (HANDLE_EINTR(close(fd)) < 0)
+  if (IGNORE_EINTR(close(fd)) < 0)
     return -1;
 
   // Enable the sandbox.
   char* error_buff = NULL;
   int error = sandbox_init(kSBXProfilePureComputation, SANDBOX_NAMED,
                            &error_buff);
   bool success = (error == 0 && error_buff == NULL);
   if (!success)
     return -1;
 
@@ skipping 131 matching lines @@
     for (int i = 0; i < pipes_to_send; i++) {
       received_.Reset();
       std::pair<int, int> pipe_fds = make_socket_pair();
       t->message_loop()->PostTask(
           FROM_HERE,
           base::Bind(&PipeChannelHelper::Send,
                      base::Unretained(dest),
                      pipe_fds.second));
       char tmp = 'x';
       CHECK_EQ(1, HANDLE_EINTR(write(pipe_fds.first, &tmp, 1)));
-      CHECK_EQ(0, HANDLE_EINTR(close(pipe_fds.first)));
+      CHECK_EQ(0, IGNORE_EINTR(close(pipe_fds.first)));
       received_.Wait();
     }
   }
 
   void ConsumerHandleFD(int fd) {
     char tmp = 'y';
     CHECK_EQ(1, HANDLE_EINTR(read(fd, &tmp, 1)));
     CHECK_EQ(tmp, 'x');
-    CHECK_EQ(0, HANDLE_EINTR(close(fd)));
+    CHECK_EQ(0, IGNORE_EINTR(close(fd)));
     received_.Signal();
   }
 
   base::Thread* CreateThread(const char* name) {
     base::Thread* ret = new base::Thread(name);
     base::Thread::Options options;
     options.message_loop_type = base::MessageLoop::TYPE_IO;
     ret->StartWithOptions(options);
     return ret;
   }
@@ skipping 27 matching lines @@
   base::WaitableEvent received_;
 };
 
 TEST_F(IPCMultiSendingFdsTest, StressTest) {
   Run();
 }
 
 }  // namespace
 
 #endif  // defined(OS_POSIX)