POSIX: Add a macro for handling EINTR.

net/base/file_stream_posix.cc

 // Copyright (c) 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.
 
 // For 64-bit file access (off_t = off64_t, lseek64, etc).
 #define _FILE_OFFSET_BITS 64
 
 #include "net/base/file_stream.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>
 
 #include "base/basictypes.h"
+#include "base/eintr_wrappers.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/waitable_event.h"
 #include "base/worker_pool.h"
 #include "net/base/net_errors.h"
 
 // We cast back and forth, so make sure it's the size we're expecting.
 COMPILE_ASSERT(sizeof(int64) == sizeof(off_t), off_t_64_bit);
 
@@ skipping 17 matching lines @@
       return ERR_FAILED;
   }
 }
 
 // ReadFile() is a simple wrapper around read() that handles EINTR signals and
 // calls MapErrorCode() to map errno to net error codes.
 int ReadFile(base::PlatformFile file, char* buf, int buf_len) {
   // read(..., 0) returns 0 to indicate end-of-file.
 
   // Loop in the case of getting interrupted by a signal.
-  for (;;) {
-    ssize_t res = read(file, buf, static_cast<size_t>(buf_len));
-    if (res == static_cast<ssize_t>(-1)) {
-      if (errno == EINTR)
-        continue;
-      return MapErrorCode(errno);
-    }
-    return static_cast<int>(res);
-  }
+  ssize_t res = HANDLE_EINTR(read(file, buf, static_cast<size_t>(buf_len)));
+  if (res == static_cast<ssize_t>(-1))
+    return MapErrorCode(errno);
+  return static_cast<int>(res);
 }
 
 // WriteFile() is a simple wrapper around write() that handles EINTR signals and
 // calls MapErrorCode() to map errno to net error codes.  It tries to write to
 // completion.
 int WriteFile(base::PlatformFile file, const char* buf, int buf_len) {
-  while (true) {
-    ssize_t res = write(file, buf, buf_len);
-    if (res == -1) {
-      if (errno == EINTR)
-        continue;
-      return MapErrorCode(errno);
-    }
-    return res;
-  }
+  ssize_t res = HANDLE_EINTR(write(file, buf, buf_len));
+  if (res == -1)
+    return MapErrorCode(errno);
+  return res;
 }
 
 // BackgroundReadTask is a simple task that reads a file and then runs
 // |callback|.  AsyncContext will post this task to the WorkerPool.
 class BackgroundReadTask : public Task {
  public:
   BackgroundReadTask(base::PlatformFile file, char* buf, int buf_len,
                      CompletionCallback* callback);
   ~BackgroundReadTask();
 
@@ skipping 358 matching lines @@
   int64 seek_position = Seek(FROM_BEGIN, bytes);
   if (seek_position != bytes)
     return ERR_UNEXPECTED;
 
   // And truncate the file.
   int result = ftruncate(file_, bytes);
   return result == 0 ? seek_position : MapErrorCode(errno);
 }
 
 }  // namespace net