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

base/process/process_util_unittest.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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 424 matching lines @@
       if ((fd = HANDLE_EINTR(dup(i))) != -1) {
         close(fd);
         num_open_files += 1;
       }
     }
   }
 
   int written = HANDLE_EINTR(write(write_pipe, &num_open_files,
                                    sizeof(num_open_files)));
   DCHECK_EQ(static_cast<size_t>(written), sizeof(num_open_files));
-  int ret = HANDLE_EINTR(close(write_pipe));
+  int ret = IGNORE_EINTR(close(write_pipe));
   DPCHECK(ret == 0);
 
   return 0;
 }
 
 int ProcessUtilTest::CountOpenFDsInChild() {
   int fds[2];
   if (pipe(fds) < 0)
     NOTREACHED();
 
   base::FileHandleMappingVector fd_mapping_vec;
   fd_mapping_vec.push_back(std::pair<int, int>(fds[1], kChildPipe));
   base::ProcessHandle handle = this->SpawnChild(
       "ProcessUtilsLeakFDChildProcess", fd_mapping_vec, false);
   CHECK(handle);
-  int ret = HANDLE_EINTR(close(fds[1]));
+  int ret = IGNORE_EINTR(close(fds[1]));
   DPCHECK(ret == 0);
 
   // Read number of open files in client process from pipe;
   int num_open_files = -1;
   ssize_t bytes_read =
       HANDLE_EINTR(read(fds[0], &num_open_files, sizeof(num_open_files)));
   CHECK_EQ(bytes_read, static_cast<ssize_t>(sizeof(num_open_files)));
 
 #if defined(THREAD_SANITIZER) || defined(USE_HEAPCHECKER)
   // Compiler-based ThreadSanitizer makes this test slow.
   CHECK(base::WaitForSingleProcess(handle, base::TimeDelta::FromSeconds(3)));
 #else
   CHECK(base::WaitForSingleProcess(handle, base::TimeDelta::FromSeconds(1)));
 #endif
   base::CloseProcessHandle(handle);
-  ret = HANDLE_EINTR(close(fds[0]));
+  ret = IGNORE_EINTR(close(fds[0]));
   DPCHECK(ret == 0);
 
   return num_open_files;
 }
 
 #if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER)
 // ProcessUtilTest.FDRemapping is flaky when ran under xvfb-run on Precise.
 // The problem is 100% reproducible with both ASan and TSan.
 // See http://crbug.com/136720.
 #define MAYBE_FDRemapping DISABLED_FDRemapping
 #else
 #define MAYBE_FDRemapping FDRemapping
 #endif
 TEST_F(ProcessUtilTest, MAYBE_FDRemapping) {
   int fds_before = CountOpenFDsInChild();
 
   // open some dummy fds to make sure they don't propagate over to the
   // child process.
   int dev_null = open("/dev/null", O_RDONLY);
   int sockets[2];
   socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
 
   int fds_after = CountOpenFDsInChild();
 
   ASSERT_EQ(fds_after, fds_before);
 
   int ret;
-  ret = HANDLE_EINTR(close(sockets[0]));
+  ret = IGNORE_EINTR(close(sockets[0]));
   DPCHECK(ret == 0);
-  ret = HANDLE_EINTR(close(sockets[1]));
+  ret = IGNORE_EINTR(close(sockets[1]));
   DPCHECK(ret == 0);
-  ret = HANDLE_EINTR(close(dev_null));
+  ret = IGNORE_EINTR(close(dev_null));
   DPCHECK(ret == 0);
 }
 
 namespace {
 
 std::string TestLaunchProcess(const base::EnvironmentMap& env_changes,
                               const int clone_flags) {
   std::vector<std::string> args;
   base::FileHandleMappingVector fds_to_remap;
 
   args.push_back(kPosixShell);
   args.push_back("-c");
   args.push_back("echo $BASE_TEST");
 
   int fds[2];
   PCHECK(pipe(fds) == 0);
 
   fds_to_remap.push_back(std::make_pair(fds[1], 1));
   base::LaunchOptions options;
   options.wait = true;
   options.environ = env_changes;
   options.fds_to_remap = &fds_to_remap;
 #if defined(OS_LINUX)
   options.clone_flags = clone_flags;
 #else
   CHECK_EQ(0, clone_flags);
 #endif  // OS_LINUX
   EXPECT_TRUE(base::LaunchProcess(args, options, NULL));
-  PCHECK(HANDLE_EINTR(close(fds[1])) == 0);
+  PCHECK(IGNORE_EINTR(close(fds[1])) == 0);
 
   char buf[512];
   const ssize_t n = HANDLE_EINTR(read(fds[0], buf, sizeof(buf)));
   PCHECK(n > 0);
 
-  PCHECK(HANDLE_EINTR(close(fds[0])) == 0);
+  PCHECK(IGNORE_EINTR(close(fds[0])) == 0);
 
   return std::string(buf, n);
 }
 
 const char kLargeString[] =
     "0123456789012345678901234567890123456789012345678901234567890123456789"
     "0123456789012345678901234567890123456789012345678901234567890123456789"
     "0123456789012345678901234567890123456789012345678901234567890123456789"
     "0123456789012345678901234567890123456789012345678901234567890123456789"
     "0123456789012345678901234567890123456789012345678901234567890123456789"
@@ skipping 236 matching lines @@
   // Check that process was really killed.
   EXPECT_TRUE(IsProcessDead(child_process));
   base::CloseProcessHandle(child_process);
 }
 
 MULTIPROCESS_TEST_MAIN(process_util_test_die_immediately) {
   return 0;
 }
 
 #endif  // defined(OS_POSIX)