POSIX: Add a macro for handling EINTR.

base/file_util_posix.cc

 // Copyright (c) 2006-2008 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/file_util.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <fnmatch.h>
 #include <fts.h>
 #include <libgen.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/errno.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
 
 #include <fstream>
 
 #include "base/basictypes.h"
+#include "base/eintr_wrappers.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/time.h"
 
 namespace file_util {
 
 #if defined(GOOGLE_CHROME_BUILD)
 static const char* kTempFileName = "com.google.chrome.XXXXXX";
 #else
@@ skipping 293 matching lines @@
       CreateFile(filename.c_str(), GENERIC_READ,
                  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL));
   return GetFileCreationLocalTimeFromHandle(file_handle.Get(), creation_time);
 }
 #endif
 
 bool ReadFromFD(int fd, char* buffer, size_t bytes) {
   size_t total_read = 0;
   while (total_read < bytes) {
-    ssize_t bytes_read = read(fd, buffer + total_read, bytes - total_read);
-    if (bytes_read > 0)
-      total_read += bytes_read;
-    else if (bytes_read == 0 || errno != EINTR)
+    ssize_t bytes_read =
+        HANDLE_EINTR(read(fd, buffer + total_read, bytes - total_read));
+    if (bytes_read <= 0)
       break;
+    total_read += bytes_read;
   }
   return total_read == bytes;
 }
 
 // Creates and opens a temporary file in |directory|, returning the
 // file descriptor.  |path| is set to the temporary file path.
 // Note TODO(erikkay) comment in header for BlahFileName() calls; the
 // intent is to rename these files BlahFile() (since they create
 // files, not filenames).  This function does NOT unlink() the file.
 int CreateAndOpenFdForTemporaryFile(FilePath directory, FilePath* path) {
@@ skipping 93 matching lines @@
 
 FILE* OpenFile(const FilePath& filename, const char* mode) {
   return fopen(filename.value().c_str(), mode);
 }
 
 int ReadFile(const FilePath& filename, char* data, int size) {
   int fd = open(filename.value().c_str(), O_RDONLY);
   if (fd < 0)
     return -1;
 
-  int ret_value = read(fd, data, size);
-  close(fd);
+  int ret_value = HANDLE_EINTR(read(fd, data, size));
+  HANDLE_EINTR(close(fd));
   return ret_value;
 }
 
 int WriteFile(const FilePath& filename, const char* data, int size) {
   int fd = creat(filename.value().c_str(), 0666);
   if (fd < 0)
     return -1;
 
   // Allow for partial writes
   ssize_t bytes_written_total = 0;
   do {
-    ssize_t bytes_written_partial = write(fd,
-                                          data + bytes_written_total,
-                                          size - bytes_written_total);
+    ssize_t bytes_written_partial =
+      HANDLE_EINTR(write(fd, data + bytes_written_total,
+                         size - bytes_written_total));
     if (bytes_written_partial < 0) {
-      close(fd);
+      HANDLE_EINTR(close(fd));
       return -1;
     }
     bytes_written_total += bytes_written_partial;
   } while (bytes_written_total < size);
 
-  close(fd);
+  HANDLE_EINTR(close(fd));
   return bytes_written_total;
 }
 
 // Gets the current working directory for the process.
 bool GetCurrentDirectory(FilePath* dir) {
   char system_buffer[PATH_MAX] = "";
   if (!getcwd(system_buffer, sizeof(system_buffer))) {
     NOTREACHED();
     return false;
   }
@@ skipping 142 matching lines @@
     munmap(data_, length_);
   if (file_ != -1)
     close(file_);
 
   data_ = NULL;
   length_ = 0;
   file_ = -1;
 }
 
 } // namespace file_util