net: FileStream::Read/Write() to take IOBuffer* instead of char*

net/base/file_stream_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.h"
 
 #include <sys/types.h>
@@ skipping 10 matching lines @@
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/file_stream_metrics.h"
 #include "net/base/file_stream_net_log_parameters.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
 
@@ skipping 119 matching lines @@
 
 // FileStream::AsyncContext ----------------------------------------------
 
 class FileStream::AsyncContext {
  public:
   AsyncContext();
   ~AsyncContext();
 
   // These methods post synchronous read() and write() calls to a WorkerThread.
   void InitiateAsyncRead(
-      base::PlatformFile file, char* buf, int buf_len,
+      base::PlatformFile file, IOBuffer* buf, int buf_len,
       const net::BoundNetLog& bound_net_log,
       const CompletionCallback& callback);
   void InitiateAsyncWrite(
-      base::PlatformFile file, const char* buf, int buf_len,
+      base::PlatformFile file, IOBuffer* buf, int buf_len,
       const net::BoundNetLog& bound_net_log,
       const CompletionCallback& callback);
 
   const CompletionCallback& callback() const { return callback_; }
 
   // Called by the WorkerPool thread executing the IO after the IO completes.
   // This method queues RunAsynchronousCallback() on the MessageLoop and signals
   // |background_io_completed_callback_|, in case the destructor is waiting.  In
   // that case, the destructor will call RunAsynchronousCallback() instead, and
   // cancel |message_loop_task_|.
   // |result| is the result of the Read/Write task.
   void OnBackgroundIOCompleted(int result);
 
   void EnableErrorStatistics() {
     record_uma_ = true;
   }
 
  private:
   // Always called on the IO thread, either directly by a task on the
   // MessageLoop or by ~AsyncContext().
   void RunAsynchronousCallback();
 
   // The MessageLoopForIO that this AsyncContext is running on.
   MessageLoopForIO* const message_loop_;
   CompletionCallback callback_;  // The user provided callback.
+  scoped_refptr<IOBuffer> in_flight_buf_;
 
   // This is used to synchronize between the AsyncContext destructor (which runs
   // on the IO thread and OnBackgroundIOCompleted() which runs on the WorkerPool
   // thread.
   base::WaitableEvent background_io_completed_;
 
   // These variables are only valid when background_io_completed is signaled.
   int result_;
   CancelableCallback* message_loop_task_;
 
@@ skipping 21 matching lines @@
     RunAsynchronousCallback();
     if (need_to_wait) {
       // We want to see if we block the message loop for too long.
       UMA_HISTOGRAM_TIMES("AsyncIO.FileStreamClose",
                           base::TimeTicks::Now() - start);
     }
   }
 }
 
 void FileStream::AsyncContext::InitiateAsyncRead(
-    base::PlatformFile file, char* buf, int buf_len,
+    base::PlatformFile file, IOBuffer* buf, int buf_len,
     const net::BoundNetLog& bound_net_log,
     const CompletionCallback& callback) {
   DCHECK(callback_.is_null());
+  DCHECK(!in_flight_buf_);
   callback_ = callback;
+  in_flight_buf_ = buf;  // Hold until the async operation ends.
 
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&ReadFileTask,
                  file,
-                 buf,
+                 buf->data(),
                  buf_len,
                  record_uma_,
                  bound_net_log,
                  base::Bind(&AsyncContext::OnBackgroundIOCompleted,
                             base::Unretained(this))),
       true /* task_is_slow */);
 }
 
 void FileStream::AsyncContext::InitiateAsyncWrite(
-    base::PlatformFile file, const char* buf, int buf_len,
+    base::PlatformFile file, IOBuffer* buf, int buf_len,
     const net::BoundNetLog& bound_net_log,
     const CompletionCallback& callback) {
   DCHECK(callback_.is_null());
+  DCHECK(!in_flight_buf_);
   callback_ = callback;
+  in_flight_buf_ = buf;  // Hold until the async operation ends.
 
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&WriteFileTask,
                  file,
-                 buf,
+                 buf->data(),
                  buf_len,
                  record_uma_,
                  bound_net_log,
                  base::Bind(&AsyncContext::OnBackgroundIOCompleted,
                             base::Unretained(this))),
       true /* task_is_slow */);
 }
 
 void FileStream::AsyncContext::OnBackgroundIOCompleted(int result) {
   result_ = result;
@@ skipping 12 matching lines @@
   background_io_completed_.Wait();
 
   // Either we're in the MessageLoop's task, in which case Cancel() doesn't do
   // anything, or we're in ~AsyncContext(), in which case this prevents the call
   // from happening again.  Must do it here after calling Wait().
   message_loop_task_->Cancel();
   message_loop_task_ = NULL;  // lifetime handled by base::Owned
 
   if (is_closing_) {
     callback_.Reset();
+    in_flight_buf_ = NULL;
     return;
   }
 
   DCHECK(!callback_.is_null());
-  CompletionCallback temp;
-  std::swap(temp, callback_);
+  CompletionCallback temp_callback = callback_;
+  callback_.Reset();
+  scoped_refptr<IOBuffer> temp_buf = in_flight_buf_;
+  in_flight_buf_ = NULL;
   background_io_completed_.Reset();
-  temp.Run(result_);
+  temp_callback.Run(result_);
 }
 
 // FileStream ------------------------------------------------------------
 
 FileStream::FileStream(net::NetLog* net_log)
     : file_(base::kInvalidPlatformFileValue),
       open_flags_(0),
       auto_closed_(true),
       record_uma_(false),
       bound_net_log_(net::BoundNetLog::Make(net_log,
@@ skipping 111 matching lines @@
                              bound_net_log_);
   }
 
   int64 size = static_cast<int64>(info.st_size);
   DCHECK_GT(size, cur_pos);
 
   return size - cur_pos;
 }
 
 int FileStream::Read(
-    char* buf, int buf_len, const CompletionCallback& callback) {
+    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
   DCHECK(async_context_.get());
-  return ReadInternal(buf, buf_len, callback);
+
+  if (!IsOpen())
+    return ERR_UNEXPECTED;
+
+  // read(..., 0) will return 0, which indicates end-of-file.
+  DCHECK_GT(buf_len, 0);
+  DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
+
+  DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
+  // Make sure we don't have a request in flight.
+  DCHECK(async_context_->callback().is_null());
+  if (record_uma_)
+    async_context_->EnableErrorStatistics();
+  async_context_->InitiateAsyncRead(file_, buf, buf_len, bound_net_log_,
+                                    callback);
+  return ERR_IO_PENDING;
 }
 
 int FileStream::ReadSync(char* buf, int buf_len) {
   DCHECK(!async_context_.get());
-  return ReadInternal(buf, buf_len, CompletionCallback());
-}
 
-int FileStream::ReadInternal(
-    char* buf, int buf_len, const CompletionCallback& callback) {
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   // read(..., 0) will return 0, which indicates end-of-file.
   DCHECK_GT(buf_len, 0);
   DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
 
-  if (async_context_.get()) {
-    DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
-    // If we're in async, make sure we don't have a request in flight.
-    DCHECK(async_context_->callback().is_null());
-    if (record_uma_)
-      async_context_->EnableErrorStatistics();
-    async_context_->InitiateAsyncRead(file_, buf, buf_len, bound_net_log_,
-                                      callback);
-    return ERR_IO_PENDING;
-  } else {
-    return ReadFile(file_, buf, buf_len, record_uma_, bound_net_log_);
-  }
+  return ReadFile(file_, buf, buf_len, record_uma_, bound_net_log_);
 }
 
 int FileStream::ReadUntilComplete(char *buf, int buf_len) {
   int to_read = buf_len;
   int bytes_total = 0;
 
   do {
     int bytes_read = ReadSync(buf, to_read);
     if (bytes_read <= 0) {
       if (bytes_total == 0)
         return bytes_read;
 
       return bytes_total;
     }
 
     bytes_total += bytes_read;
     buf += bytes_read;
     to_read -= bytes_read;
   } while (bytes_total < buf_len);
 
   return bytes_total;
 }
 
 int FileStream::Write(
-    const char* buf, int buf_len, const CompletionCallback& callback) {
+    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
   DCHECK(async_context_.get());
-  return WriteInternal(buf, buf_len, callback);
-}
 
-int FileStream::WriteSync(
-    const char* buf, int buf_len) {
-  DCHECK(!async_context_.get());
-  return WriteInternal(buf, buf_len, CompletionCallback());
-}
-
-int FileStream::WriteInternal(
-    const char* buf, int buf_len, const CompletionCallback& callback) {
   // write(..., 0) will return 0, which indicates end-of-file.
   DCHECK_GT(buf_len, 0);
 
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
-  if (async_context_.get()) {
-    DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
-    // If we're in async, make sure we don't have a request in flight.
-    DCHECK(async_context_->callback().is_null());
-    if (record_uma_)
-      async_context_->EnableErrorStatistics();
-    async_context_->InitiateAsyncWrite(file_, buf, buf_len, bound_net_log_,
-                                       callback);
-    return ERR_IO_PENDING;
-  } else {
-    return WriteFile(file_, buf, buf_len, record_uma_, bound_net_log_);
-  }
+  DCHECK(open_flags_ & base::PLATFORM_FILE_ASYNC);
+  // Make sure we don't have a request in flight.
+  DCHECK(async_context_->callback().is_null());
+  if (record_uma_)
+    async_context_->EnableErrorStatistics();
+  async_context_->InitiateAsyncWrite(file_, buf, buf_len, bound_net_log_,
+                                     callback);
+  return ERR_IO_PENDING;
+}
+
+int FileStream::WriteSync(
+    const char* buf, int buf_len) {
+  DCHECK(!async_context_.get());
+
+  // write(..., 0) will return 0, which indicates end-of-file.
+  DCHECK_GT(buf_len, 0);
+
+  if (!IsOpen())
+    return ERR_UNEXPECTED;
+
+  return WriteFile(file_, buf, buf_len, record_uma_, bound_net_log_);
 }
 
 int64 FileStream::Truncate(int64 bytes) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   // We'd better be open for writing.
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
@@ skipping 43 matching lines @@
                                          owner_bound_net_log.source())));
 
   owner_bound_net_log.AddEvent(
       net::NetLog::TYPE_FILE_STREAM_SOURCE,
       make_scoped_refptr(
           new net::NetLogSourceParameter("source_dependency",
                                          bound_net_log_.source())));
 }
 
 }  // namespace net