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

sandbox/linux/services/broker_process.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 "sandbox/linux/services/broker_process.h"
 
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
@@ skipping 113 matching lines @@
       fast_check_in_client_(fast_check_in_client),
       quiet_failures_for_tests_(quiet_failures_for_tests),
       broker_pid_(-1),
       allowed_r_files_(allowed_r_files),
       allowed_w_files_(allowed_w_files),
       ipc_socketpair_(-1) {
 }
 
 BrokerProcess::~BrokerProcess() {
   if (initialized_ && ipc_socketpair_ != -1) {
-    void (HANDLE_EINTR(close(ipc_socketpair_)));
+    close(ipc_socketpair_);
   }
 }
 
 bool BrokerProcess::Init(bool (*sandbox_callback)(void)) {
   CHECK(!initialized_);
   int socket_pair[2];
   // Use SOCK_SEQPACKET, because we need to preserve message boundaries
   // but we also want to be notified (recvmsg should return and not block)
   // when the connection has been broken (one of the processes died).
   if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, socket_pair)) {
     LOG(ERROR) << "Failed to create socketpair";
     return false;
   }
 
   int child_pid = fork();
   if (child_pid == -1) {
-    ignore_result(HANDLE_EINTR(close(socket_pair[0])));
-    ignore_result(HANDLE_EINTR(close(socket_pair[1])));
+    close(socket_pair[0]);
+    close(socket_pair[1]);
     return false;
   }
   if (child_pid) {
     // We are the parent and we have just forked our broker process.
-    ignore_result(HANDLE_EINTR(close(socket_pair[0])));
+    close(socket_pair[0]);
     // We should only be able to write to the IPC channel. We'll always send
     // a new file descriptor to receive the reply on.
     shutdown(socket_pair[1], SHUT_RD);
     ipc_socketpair_ = socket_pair[1];
     is_child_ = false;
     broker_pid_ = child_pid;
     initialized_ = true;
     return true;
   } else {
     // We are the broker.
-    ignore_result(HANDLE_EINTR(close(socket_pair[1])));
+    close(socket_pair[1]);
     // We should only be able to read from this IPC channel. We will send our
     // replies on a new file descriptor attached to the requests.
     shutdown(socket_pair[0], SHUT_WR);
     ipc_socketpair_ = socket_pair[0];
     is_child_ = true;
     // Enable the sandbox if provided.
     if (sandbox_callback) {
       CHECK(sandbox_callback());
     }
     initialized_ = true;
@@ skipping 143 matching lines @@
       case kCommandOpen:
         // We reply on the file descriptor sent to us via the IPC channel.
         r = HandleRemoteCommand(static_cast<IPCCommands>(command_type),
                                 temporary_ipc, pickle, iter);
         break;
       default:
         NOTREACHED();
         r = false;
         break;
     }
-    int ret = HANDLE_EINTR(close(temporary_ipc));
+    int ret = IGNORE_EINTR(close(temporary_ipc));
     DCHECK(!ret) << "Could not close temporary IPC channel";
     return r;
   }
 
   LOG(ERROR) << "Error parsing IPC request";
   return false;
 }
 
 // Handle a |command_type| request contained in |read_pickle| and send the reply
 // on |reply_ipc|.
@@ skipping 24 matching lines @@
       break;
   }
 
   CHECK_LE(write_pickle.size(), kMaxMessageLength);
   ssize_t sent = UnixDomainSocket::SendMsg(reply_ipc, write_pickle.data(),
                                            write_pickle.size(), opened_files);
 
   // Close anything we have opened in this process.
   for (std::vector<int>::iterator it = opened_files.begin();
        it < opened_files.end(); ++it) {
-    int ret = HANDLE_EINTR(close(*it));
+    int ret = IGNORE_EINTR(close(*it));
     DCHECK(!ret) << "Could not close file descriptor";
   }
 
   if (sent <= 0) {
     LOG(ERROR) << "Could not send IPC reply";
     return false;
   }
   return true;
 }
 
@@ skipping 121 matching lines @@
           GetFileNameInWhitelist(allowed_w_files_, requested_filename,
                                  file_to_open);
       return allowed_for_read_and_write;
     }
     default:
       return false;
   }
 }
 
 }  // namespace sandbox.