net: FileStream cleanup

net/base/file_stream_context_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.
 
-// For 64-bit file access (off_t = off64_t, lseek64, etc).
-#define _FILE_OFFSET_BITS 64
-
 #include "net/base/file_stream_context.h"
 
 #include <errno.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
-#if defined(OS_ANDROID)
-// Android's bionic libc only supports the LFS transitional API.
-#define off_t off64_t
-#define lseek lseek64
-#define stat stat64
-#define fstat fstat64
-#endif
-
 namespace net {
 
-// 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);
-
-// Make sure our Whence mappings match the system headers.
-COMPILE_ASSERT(FROM_BEGIN   == SEEK_SET &&
-               FROM_CURRENT == SEEK_CUR &&
-               FROM_END     == SEEK_END, whence_matches_system);
-
 FileStream::Context::Context(const scoped_refptr<base::TaskRunner>& task_runner)
     : async_in_progress_(false),
       orphaned_(false),
-      task_runner_(task_runner) {
+      task_runner_(task_runner),
+      in_flight_buf_(0) {

[hashimoto, 2014/06/13 06:10:42]

nit: You meant to initialize buf_len_? No need to initialize in_flight_buf_ with
0(=NULL) as it's initialized by its own ctor.

[rvargas (doing something else), 2014/06/13 19:58:24]

yes I meant it to be the len :(

 }
 
 FileStream::Context::Context(base::File file,
                              const scoped_refptr<base::TaskRunner>& task_runner)
     : file_(file.Pass()),
       async_in_progress_(false),
       orphaned_(false),
-      task_runner_(task_runner) {
+      task_runner_(task_runner),
+      in_flight_buf_(0) {
 }
 
 FileStream::Context::~Context() {
 }
 
-int FileStream::Context::ReadAsync(IOBuffer* in_buf,
-                                   int buf_len,
-                                   const CompletionCallback& callback) {
+int FileStream::Context::Read(IOBuffer* in_buf,
+                              int buf_len,
+                              const CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
 
   scoped_refptr<IOBuffer> buf = in_buf;
+  in_flight_buf_ = NULL;
   const bool posted = base::PostTaskAndReplyWithResult(
       task_runner_.get(),
       FROM_HERE,
       base::Bind(&Context::ReadFileImpl, base::Unretained(this), buf, buf_len),
       base::Bind(&Context::OnAsyncCompleted,
                  base::Unretained(this),
                  IntToInt64(callback)));
   DCHECK(posted);
 
   async_in_progress_ = true;
   return ERR_IO_PENDING;
 }
 
-int FileStream::Context::WriteAsync(IOBuffer* in_buf,
-                                    int buf_len,
-                                    const CompletionCallback& callback) {
+int FileStream::Context::ReadNonBlocking(IOBuffer* buf,
+                                         int buf_len,
+                                         const CompletionCallback& callback) {
+  DCHECK(!async_in_progress_);
+
+  in_flight_buf_ = buf;
+  buf_len_ = buf_len;
+  callback_ = callback;
+
+  base::MessageLoopForIO::current()->WatchFileDescriptor(
+      file_.GetPlatformFile(), false /* persistent */,
+      base::MessageLoopForIO::WATCH_READ, &file_watcher_, this);
+
+  async_in_progress_ = true;
+  return ERR_IO_PENDING;
+}
+
+int FileStream::Context::Write(IOBuffer* in_buf,
+                               int buf_len,
+                               const CompletionCallback& callback) {
   DCHECK(!async_in_progress_);
 
   scoped_refptr<IOBuffer> buf = in_buf;
+  in_flight_buf_ = NULL;
   const bool posted = base::PostTaskAndReplyWithResult(
       task_runner_.get(),
       FROM_HERE,
       base::Bind(&Context::WriteFileImpl, base::Unretained(this), buf, buf_len),
       base::Bind(&Context::OnAsyncCompleted,
                  base::Unretained(this),
                  IntToInt64(callback)));
   DCHECK(posted);
 
   async_in_progress_ = true;
   return ERR_IO_PENDING;
 }
 
-FileStream::Context::IOResult FileStream::Context::SeekFileImpl(Whence whence,
-                                                                int64 offset) {
-  off_t res = lseek(file_.GetPlatformFile(), static_cast<off_t>(offset),
-                    static_cast<int>(whence));
-  if (res == static_cast<off_t>(-1))
-    return IOResult::FromOSError(errno);
+int FileStream::Context::WriteNonBlocking(IOBuffer* buf,
+                                          int buf_len,
+                                          const CompletionCallback& callback) {
+  DCHECK(!async_in_progress_);
 
-  return IOResult(res, 0);
+  in_flight_buf_ = buf;
+  buf_len_ = buf_len;
+  callback_ = callback;
+
+  base::MessageLoopForIO::current()->WatchFileDescriptor(
+      file_.GetPlatformFile(), false /* persistent */,
+      base::MessageLoopForIO::WATCH_WRITE, &file_watcher_, this);
+
+  async_in_progress_ = true;
+  return ERR_IO_PENDING;
 }
 
-FileStream::Context::IOResult FileStream::Context::FlushFileImpl() {
-  ssize_t res = HANDLE_EINTR(fsync(file_.GetPlatformFile()));
+FileStream::Context::IOResult FileStream::Context::SeekFileImpl(
+    base::File::Whence whence,
+    int64 offset) {
+  int64 res = file_.Seek(whence, offset);
   if (res == -1)
     return IOResult::FromOSError(errno);
 
   return IOResult(res, 0);
 }
 
+void FileStream::Context::OnFileOpened() {
+}
+
+void FileStream::Context::CancelIO() {
+  if (!in_flight_buf_)
+    return;
+
+  // Just waiting to issue a non-blocking op. Stop the watcher right away
+  // because CloseAndDelete() will only delete this object after the file is
+  // closed on the task runner.
+  async_in_progress_ = false;
+  file_watcher_.StopWatchingFileDescriptor();
+  CloseAndDelete();
+}
+
 FileStream::Context::IOResult FileStream::Context::ReadFileImpl(
     scoped_refptr<IOBuffer> buf,
     int buf_len) {
-  // Loop in the case of getting interrupted by a signal.
-  ssize_t res = HANDLE_EINTR(read(file_.GetPlatformFile(), buf->data(),
-                                  static_cast<size_t>(buf_len)));
+  int res = file_.ReadAtCurrentPosNoBestEffort(buf->data(), buf_len);
   if (res == -1)
     return IOResult::FromOSError(errno);
 
   return IOResult(res, 0);
 }
 
 FileStream::Context::IOResult FileStream::Context::WriteFileImpl(
     scoped_refptr<IOBuffer> buf,
     int buf_len) {
-  ssize_t res = HANDLE_EINTR(write(file_.GetPlatformFile(), buf->data(),
-                                   buf_len));
+  int res = file_.WriteAtCurrentPosNoBestEffort(buf->data(), buf_len);
   if (res == -1)
     return IOResult::FromOSError(errno);
 
   return IOResult(res, 0);
 }
 
+void FileStream::Context::OnFileCanReadWithoutBlocking(int fd) {
+  DCHECK_EQ(file_.GetPlatformFile(), fd);
+  DCHECK(async_in_progress_);
+  async_in_progress_ = false;
+  Read(in_flight_buf_.get(), buf_len_, callback_);
+}
+
+void FileStream::Context::OnFileCanWriteWithoutBlocking(int fd) {
+  DCHECK_EQ(file_.GetPlatformFile(), fd);
+  DCHECK(async_in_progress_);
+  async_in_progress_ = false;
+  Write(in_flight_buf_.get(), buf_len_, callback_);
+}
+
 }  // namespace net