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

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 188 matching lines @@
   int pipe_fds[2];
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds) != 0) {
     PLOG(ERROR) << "socketpair()";
     return false;
   }
 
   // Set both ends to be non-blocking.
   if (fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK) == -1 ||
       fcntl(pipe_fds[1], F_SETFL, O_NONBLOCK) == -1) {
     PLOG(ERROR) << "fcntl(O_NONBLOCK)";
-    if (HANDLE_EINTR(close(pipe_fds[0])) < 0)
+    if (IGNORE_EINTR(close(pipe_fds[0])) < 0)
       PLOG(ERROR) << "close";
-    if (HANDLE_EINTR(close(pipe_fds[1])) < 0)
+    if (IGNORE_EINTR(close(pipe_fds[1])) < 0)
       PLOG(ERROR) << "close";
     return false;
   }
 
   *fd1 = pipe_fds[0];
   *fd2 = pipe_fds[1];
 
   return true;
 }
 
@@ skipping 318 matching lines @@
     PipeMap::GetInstance()->Remove(pipe_name_);
     client_pipe_ = -1;
   }
   return fd;
 }
 
 void Channel::ChannelImpl::CloseClientFileDescriptor() {
   base::AutoLock lock(client_pipe_lock_);
   if (client_pipe_ != -1) {
     PipeMap::GetInstance()->Remove(pipe_name_);
-    if (HANDLE_EINTR(close(client_pipe_)) < 0)
+    if (IGNORE_EINTR(close(client_pipe_)) < 0)
       PLOG(ERROR) << "close " << pipe_name_;
     client_pipe_ = -1;
   }
 }
 
 bool Channel::ChannelImpl::AcceptsConnections() const {
   return server_listen_pipe_ != -1;
 }
 
 bool Channel::ChannelImpl::HasAcceptedConnection() const {
   return AcceptsConnections() && pipe_ != -1;
 }
 
 bool Channel::ChannelImpl::GetPeerEuid(uid_t* peer_euid) const {
   DCHECK(!(mode_ & MODE_SERVER) || HasAcceptedConnection());
   return IPC::GetPeerEuid(pipe_, peer_euid);
 }
 
 void Channel::ChannelImpl::ResetToAcceptingConnectionState() {
   // Unregister libevent for the unix domain socket and close it.
   read_watcher_.StopWatchingFileDescriptor();
   write_watcher_.StopWatchingFileDescriptor();
   if (pipe_ != -1) {
-    if (HANDLE_EINTR(close(pipe_)) < 0)
+    if (IGNORE_EINTR(close(pipe_)) < 0)
       PLOG(ERROR) << "close pipe_ " << pipe_name_;
     pipe_ = -1;
   }
 #if defined(IPC_USES_READWRITE)
   if (fd_pipe_ != -1) {
-    if (HANDLE_EINTR(close(fd_pipe_)) < 0)
+    if (IGNORE_EINTR(close(fd_pipe_)) < 0)
       PLOG(ERROR) << "close fd_pipe_ " << pipe_name_;
     fd_pipe_ = -1;
   }
   if (remote_fd_pipe_ != -1) {
-    if (HANDLE_EINTR(close(remote_fd_pipe_)) < 0)
+    if (IGNORE_EINTR(close(remote_fd_pipe_)) < 0)
       PLOG(ERROR) << "close remote_fd_pipe_ " << pipe_name_;
     remote_fd_pipe_ = -1;
   }
 #endif  // IPC_USES_READWRITE
 
   while (!output_queue_.empty()) {
     Message* m = output_queue_.front();
     output_queue_.pop();
     delete m;
   }
 
   // Close any outstanding, received file descriptors.
   ClearInputFDs();
 
 #if defined(OS_MACOSX)
   // Clear any outstanding, sent file descriptors.
   for (std::set<int>::iterator i = fds_to_close_.begin();
        i != fds_to_close_.end();
        ++i) {
-    if (HANDLE_EINTR(close(*i)) < 0)
+    if (IGNORE_EINTR(close(*i)) < 0)
       PLOG(ERROR) << "close";
   }
   fds_to_close_.clear();
 #endif
 }
 
 // static
 bool Channel::ChannelImpl::IsNamedServerInitialized(
     const std::string& channel_id) {
   return base::PathExists(base::FilePath(channel_id));
@@ skipping 14 matching lines @@
         new_pipe < 0) {
       Close();
       listener()->OnChannelListenError();
     }
 
     if (pipe_ != -1) {
       // We already have a connection. We only handle one at a time.
       // close our new descriptor.
       if (HANDLE_EINTR(shutdown(new_pipe, SHUT_RDWR)) < 0)
         DPLOG(ERROR) << "shutdown " << pipe_name_;
-      if (HANDLE_EINTR(close(new_pipe)) < 0)
+      if (IGNORE_EINTR(close(new_pipe)) < 0)
         DPLOG(ERROR) << "close " << pipe_name_;
       listener()->OnChannelDenied();
       return;
     }
     pipe_ = new_pipe;
 
     if ((mode_ & MODE_OPEN_ACCESS_FLAG) == 0) {
       // Verify that the IPC channel peer is running as the same user.
       uid_t client_euid;
       if (!GetPeerEuid(&client_euid)) {
@@ skipping 269 matching lines @@
       return true;
     }
   }
 
   // No file descriptors found, but that's OK.
   return true;
 }
 
 void Channel::ChannelImpl::ClearInputFDs() {
   for (size_t i = 0; i < input_fds_.size(); ++i) {
-    if (HANDLE_EINTR(close(input_fds_[i])) < 0)
+    if (IGNORE_EINTR(close(input_fds_[i])) < 0)
       PLOG(ERROR) << "close ";
   }
   input_fds_.clear();
 }
 
 void Channel::ChannelImpl::QueueCloseFDMessage(int fd, int hops) {
   switch (hops) {
     case 1:
     case 2: {
       // Create the message
@@ skipping 48 matching lines @@
 
 #if defined(OS_MACOSX)
     case Channel::CLOSE_FD_MESSAGE_TYPE:
       int fd, hops;
       if (!msg.ReadInt(&iter, &hops))
         NOTREACHED();
       if (!msg.ReadInt(&iter, &fd))
         NOTREACHED();
       if (hops == 0) {
         if (fds_to_close_.erase(fd) > 0) {
-          if (HANDLE_EINTR(close(fd)) < 0)
+          if (IGNORE_EINTR(close(fd)) < 0)
             PLOG(ERROR) << "close";
         } else {
           NOTREACHED();
         }
       } else {
         QueueCloseFDMessage(fd, hops);
       }
       break;
 #endif
   }
 }
 
 void Channel::ChannelImpl::Close() {
   // Close can be called multiple time, so we need to make sure we're
   // idempotent.
 
   ResetToAcceptingConnectionState();
 
   if (must_unlink_) {
     unlink(pipe_name_.c_str());
     must_unlink_ = false;
   }
   if (server_listen_pipe_ != -1) {
-    if (HANDLE_EINTR(close(server_listen_pipe_)) < 0)
+    if (IGNORE_EINTR(close(server_listen_pipe_)) < 0)
       DPLOG(ERROR) << "close " << server_listen_pipe_;
     server_listen_pipe_ = -1;
     // Unregister libevent for the listening socket and close it.
     server_listen_connection_watcher_.StopWatchingFileDescriptor();
   }
 
   CloseClientFileDescriptor();
 }
 
 //------------------------------------------------------------------------------
@@ skipping 67 matching lines @@
 
 
 #if defined(OS_LINUX)
 // static
 void Channel::SetGlobalPid(int pid) {
   ChannelImpl::SetGlobalPid(pid);
 }
 #endif  // OS_LINUX
 
 }  // namespace IPC