POSIX: Add a macro for handling EINTR.

base/directory_watcher_inotify.cc

 // Copyright (c) 2009 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 "base/directory_watcher.h"
 
 #include <errno.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <sys/inotify.h>
 #include <sys/select.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
+#include "base/eintr_wrappers.h"
 #include "base/file_path.h"
 #include "base/hash_tables.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "base/task.h"
 #include "base/thread.h"
 
@@ skipping 64 matching lines @@
   }
 
   virtual void Run() {
     while (true) {
       fd_set rfds;
       FD_ZERO(&rfds);
       FD_SET(inotify_fd_, &rfds);
       FD_SET(shutdown_fd_, &rfds);
 
       // Wait until some inotify events are available.
-      int select_result = select(std::max(inotify_fd_, shutdown_fd_) + 1,
-                                 &rfds, NULL, NULL, NULL);
+      int select_result =
+        HANDLE_EINTR(select(std::max(inotify_fd_, shutdown_fd_) + 1,
+                            &rfds, NULL, NULL, NULL));
       if (select_result < 0) {
-        if (errno == EINTR)
-          continue;
         DLOG(WARNING) << "select failed: " << strerror(errno);
         return;
       }
 
       if (FD_ISSET(shutdown_fd_, &rfds))
         return;
 
       // Adjust buffer size to current event queue size.
       int buffer_size;
-      int ioctl_result = ioctl(inotify_fd_, FIONREAD, &buffer_size);
+      int ioctl_result = HANDLE_EINTR(ioctl(inotify_fd_, FIONREAD,
+                                            &buffer_size));
 
       if (ioctl_result != 0) {
         DLOG(WARNING) << "ioctl failed: " << strerror(errno);
         return;
       }
 
       std::vector<char> buffer(buffer_size);
 
-      ssize_t bytes_read;
-      do {
-        bytes_read = read(inotify_fd_, &buffer[0], buffer_size);
-      } while (bytes_read < 0 && errno == EINTR);
+      ssize_t bytes_read = HANDLE_EINTR(read(inotify_fd_, &buffer[0],
+                                             buffer_size));
 
       if (bytes_read < 0) {
         DLOG(WARNING) << "read from inotify fd failed: " << strerror(errno);
         return;
       }
 
       ssize_t i = 0;
       while (i < bytes_read) {
         inotify_event* event = reinterpret_cast<inotify_event*>(&buffer[i]);
         size_t event_size = sizeof(inotify_event) + event->len;
@@ skipping 41 matching lines @@
     thread_.message_loop()->PostTask(
         FROM_HERE, new InotifyReaderTask(this, inotify_fd_, shutdown_pipe_[0]));
     valid_ = true;
   }
 }
 
 InotifyReader::~InotifyReader() {
   if (valid_) {
     // Write to the self-pipe so that the select call in InotifyReaderTask
     // returns.
-    ssize_t bytes_written;
-    do {
-      bytes_written = write(shutdown_pipe_[1], "", 1);
-      if (bytes_written == 0)
-        continue;
-    } while (bytes_written == -1 && errno == EINTR);
+    ssize_t bytes_written = HANDLE_EINTR(write(shutdown_pipe_[1], "", 1));
     thread_.Stop();
   }
   if (inotify_fd_ >= 0)
     close(inotify_fd_);
   if (shutdown_pipe_[0] >= 0)
     close(shutdown_pipe_[0]);
   if (shutdown_pipe_[1] >= 0)
     close(shutdown_pipe_[1]);
 }
 
@@ skipping 111 matching lines @@
   watch_ = Singleton<InotifyReader>::get()->AddWatch(path, delegate_);
 
   return watch_ != InotifyReader::kInvalidWatch;
 }
 
 }  // namespace
 
 DirectoryWatcher::DirectoryWatcher() {
   impl_ = new DirectoryWatcherImpl();
 }