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

components/breakpad/browser/crash_handler_host_linux.cc

 // Copyright 2013 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 "components/breakpad/browser/crash_handler_host_linux.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/syscall.h>
@@ skipping 90 matching lines @@
 
   process_socket_ = fds[0];
   browser_socket_ = fds[1];
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CrashHandlerHostLinux::Init, base::Unretained(this)));
 }
 
 CrashHandlerHostLinux::~CrashHandlerHostLinux() {
-  (void) HANDLE_EINTR(close(process_socket_));
-  (void) HANDLE_EINTR(close(browser_socket_));
+  close(process_socket_);
+  close(browser_socket_);
 }
 
 void CrashHandlerHostLinux::StartUploaderThread() {
   uploader_thread_.reset(
       new base::Thread(std::string(process_type_ + "_crash_uploader").c_str()));
   uploader_thread_->Start();
 }
 
 void CrashHandlerHostLinux::Init() {
   base::MessageLoopForIO* ml = base::MessageLoopForIO::current();
@@ skipping 106 matching lines @@
       const unsigned len = hdr->cmsg_len -
           (((uint8_t*)CMSG_DATA(hdr)) - (uint8_t*)hdr);
       DCHECK_EQ(len % sizeof(int), 0u);
       const unsigned num_fds = len / sizeof(int);
       if (num_fds != 2) {
         // A nasty process could try and send us too many descriptors and
         // force a leak.
         LOG(ERROR) << "Death signal contained wrong number of descriptors;"
                    << " num_fds:" << num_fds;
         for (unsigned i = 0; i < num_fds; ++i)
-          (void) HANDLE_EINTR(close(reinterpret_cast<int*>(CMSG_DATA(hdr))[i]));
+          close(reinterpret_cast<int*>(CMSG_DATA(hdr))[i]);
         return;
       } else {
         partner_fd = reinterpret_cast<int*>(CMSG_DATA(hdr))[0];
         signal_fd = reinterpret_cast<int*>(CMSG_DATA(hdr))[1];
       }
     } else if (hdr->cmsg_type == SCM_CREDENTIALS) {
       const struct ucred *cred =
           reinterpret_cast<struct ucred*>(CMSG_DATA(hdr));
       crashing_pid = cred->pid;
     }
   }
 
   if (crashing_pid == -1 || partner_fd == -1 || signal_fd == -1) {
     LOG(ERROR) << "Death signal message didn't contain all expected control"
                << " messages";
     if (partner_fd >= 0)
-      (void) HANDLE_EINTR(close(partner_fd));
+      close(partner_fd);
     if (signal_fd >= 0)
-      (void) HANDLE_EINTR(close(signal_fd));
+      close(signal_fd);
     return;
   }
 
   // Kernel bug workaround (broken in 2.6.30 and 2.6.32, working in 2.6.38).
   // The kernel doesn't translate PIDs in SCM_CREDENTIALS across PID
   // namespaces. Thus |crashing_pid| might be garbage from our point of view.
   // In the future we can remove this workaround, but we have to wait a couple
   // of years to be sure that it's worked its way out into the world.
   // TODO(thestig) Remove the workaround when Ubuntu Lucid is deprecated.
 
   // The crashing process closes its copy of the signal_fd immediately after
   // calling sendmsg(). We can thus not reliably look for with with
   // FindProcessHoldingSocket(). But by necessity, it has to keep the
   // partner_fd open until the crashdump is complete.
   ino_t inode_number;
   if (!base::FileDescriptorGetInode(&inode_number, partner_fd)) {
     LOG(WARNING) << "Failed to get inode number for passed socket";
-    (void) HANDLE_EINTR(close(partner_fd));
-    (void) HANDLE_EINTR(close(signal_fd));
+    close(partner_fd);
+    close(signal_fd);
     return;
   }
-  (void) HANDLE_EINTR(close(partner_fd));
+  close(partner_fd);
 
   pid_t actual_crashing_pid = -1;
   if (!base::FindProcessHoldingSocket(&actual_crashing_pid, inode_number)) {
     LOG(WARNING) << "Failed to find process holding other end of crash reply "
                     "socket";
-    (void) HANDLE_EINTR(close(signal_fd));
+    close(signal_fd);
     return;
   }
 
   crashing_pid = actual_crashing_pid;
 
   // The crashing TID set inside the compromised context via
   // sys_gettid() in ExceptionHandler::HandleSignal might be wrong (if
   // the kernel supports PID namespacing) and may need to be
   // translated.
   //
@@ skipping 138 matching lines @@
 
   // Send the done signal to the process: it can exit now.
   struct msghdr msg = {0};
   struct iovec done_iov;
   done_iov.iov_base = const_cast<char*>("\x42");
   done_iov.iov_len = 1;
   msg.msg_iov = &done_iov;
   msg.msg_iovlen = 1;
 
   (void) HANDLE_EINTR(sendmsg(signal_fd, &msg, MSG_DONTWAIT | MSG_NOSIGNAL));
-  (void) HANDLE_EINTR(close(signal_fd));
+  close(signal_fd);
 
   uploader_thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&CrashDumpTask, base::Unretained(this), info));
 }
 
 void CrashHandlerHostLinux::WillDestroyCurrentMessageLoop() {
   file_descriptor_watcher_.StopWatchingFileDescriptor();
 
   // If we are quitting and there are crash dumps in the queue, turn them into
   // no-ops.
   shutting_down_ = true;
   uploader_thread_->Stop();
 }
 
 bool CrashHandlerHostLinux::IsShuttingDown() const {
   return shutting_down_;
 }
 
 }  // namespace breakpad