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

net/base/file_stream_win.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.
 
 #include "net/base/file_stream.h"
 
 #include <windows.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/threading/thread_restrictions.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"
 
 namespace net {
 
 // Ensure that we can just use our Whence values directly.
 COMPILE_ASSERT(FROM_BEGIN == FILE_BEGIN, bad_whence_begin);
 COMPILE_ASSERT(FROM_CURRENT == FILE_CURRENT, bad_whence_current);
 COMPILE_ASSERT(FROM_END == FILE_END, bad_whence_end);
 
 static void SetOffset(OVERLAPPED* overlapped, const LARGE_INTEGER& offset) {
@@ skipping 36 matching lines @@
 class FileStream::AsyncContext : public MessageLoopForIO::IOHandler {
  public:
   explicit AsyncContext(const net::BoundNetLog& bound_net_log)
       : context_(), is_closing_(false),
         record_uma_(false), bound_net_log_(bound_net_log),
         error_source_(FILE_ERROR_SOURCE_COUNT) {
     context_.handler = this;
   }
   ~AsyncContext();
 
-  void IOCompletionIsPending(const CompletionCallback& callback);
+  void IOCompletionIsPending(const CompletionCallback& callback,
+                             IOBuffer* buf);
 
   OVERLAPPED* overlapped() { return &context_.overlapped; }
   const CompletionCallback& callback() const { return callback_; }
 
   void set_error_source(FileErrorSource source) { error_source_ = source; }
 
   void EnableErrorStatistics() {
     record_uma_ = true;
   }
 
  private:
   virtual void OnIOCompleted(MessageLoopForIO::IOContext* context,
                              DWORD bytes_read, DWORD error) OVERRIDE;
 
   MessageLoopForIO::IOContext context_;
   CompletionCallback callback_;
+  scoped_refptr<IOBuffer> in_flight_buf_;
   bool is_closing_;
   bool record_uma_;
   const net::BoundNetLog bound_net_log_;
   FileErrorSource error_source_;
 };
 
 FileStream::AsyncContext::~AsyncContext() {
   is_closing_ = true;
   bool waited = false;
   base::TimeTicks start = base::TimeTicks::Now();
   while (!callback_.is_null()) {
     waited = true;
     MessageLoopForIO::current()->WaitForIOCompletion(INFINITE, this);
   }
   if (waited) {
     // 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::IOCompletionIsPending(
-    const CompletionCallback& callback) {
+    const CompletionCallback& callback,
+    IOBuffer* buf) {
   DCHECK(callback_.is_null());
   callback_ = callback;
+  in_flight_buf_ = buf;  // Hold until the async operation ends.
 }
 
 void FileStream::AsyncContext::OnIOCompleted(
     MessageLoopForIO::IOContext* context, DWORD bytes_read, DWORD error) {
   DCHECK_EQ(&context_, context);
   DCHECK(!callback_.is_null());
 
   if (is_closing_) {
     callback_.Reset();
+    in_flight_buf_ = NULL;
     return;
   }
 
   int result = static_cast<int>(bytes_read);
   if (error && error != ERROR_HANDLE_EOF) {
     result = RecordAndMapError(error, error_source_, record_uma_,
                                bound_net_log_);
   }
 
   if (bytes_read)
     IncrementOffset(&context->overlapped, bytes_read);
 
-  CompletionCallback temp;
-  std::swap(temp, callback_);
-  temp.Run(result);
+  CompletionCallback temp_callback = callback_;
+  callback_.Reset();
+  scoped_refptr<IOBuffer> temp_buf = in_flight_buf_;
+  in_flight_buf_ = NULL;
+  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 122 matching lines @@
     return RecordAndMapError(error,
                              FILE_ERROR_SOURCE_GET_SIZE,
                              record_uma_,
                              bound_net_log_);
   }
 
   return file_size.QuadPart - 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);
-}
 
-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;
 
   DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
 
   OVERLAPPED* overlapped = NULL;
-  if (async_context_.get()) {
-    DCHECK(!callback.is_null());
-    DCHECK(async_context_->callback().is_null());
-    overlapped = async_context_->overlapped();
-    async_context_->set_error_source(FILE_ERROR_SOURCE_READ);
-  } else {
-    DCHECK(callback.is_null());
-    base::ThreadRestrictions::AssertIOAllowed();
-  }
+  DCHECK(!callback.is_null());
+  DCHECK(async_context_->callback().is_null());
+  overlapped = async_context_->overlapped();
+  async_context_->set_error_source(FILE_ERROR_SOURCE_READ);
 
-  int rv;
+  int rv = 0;
 
   DWORD bytes_read;
-  if (!ReadFile(file_, buf, buf_len, &bytes_read, overlapped)) {
+  if (!ReadFile(file_, buf->data(), buf_len, &bytes_read, overlapped)) {
     DWORD error = GetLastError();
-    if (async_context_.get() && error == ERROR_IO_PENDING) {
-      async_context_->IOCompletionIsPending(callback);
+    if (error == ERROR_IO_PENDING) {
+      async_context_->IOCompletionIsPending(callback, buf);
       rv = ERR_IO_PENDING;
     } else if (error == ERROR_HANDLE_EOF) {
       rv = 0;  // Report EOF by returning 0 bytes read.
     } else {
       LOG(WARNING) << "ReadFile failed: " << error;
       rv = RecordAndMapError(error,
                              FILE_ERROR_SOURCE_READ,
                              record_uma_,
                              bound_net_log_);
     }
   } else if (overlapped) {
-    async_context_->IOCompletionIsPending(callback);
+    async_context_->IOCompletionIsPending(callback, buf);
     rv = ERR_IO_PENDING;
   } else {
     rv = static_cast<int>(bytes_read);
   }
   return rv;
 }
 
+int FileStream::ReadSync(char* buf, int buf_len) {
+  DCHECK(!async_context_.get());
+  base::ThreadRestrictions::AssertIOAllowed();
+
+  if (!IsOpen())
+    return ERR_UNEXPECTED;
+
+  DCHECK(open_flags_ & base::PLATFORM_FILE_READ);
+
+  int rv = 0;
+
+  DWORD bytes_read;
+  if (!ReadFile(file_, buf, buf_len, &bytes_read, NULL)) {
+    DWORD error = GetLastError();
+    if (error == ERROR_HANDLE_EOF) {
+      rv = 0;  // Report EOF by returning 0 bytes read.
+    } else {
+      LOG(WARNING) << "ReadFile failed: " << error;
+      rv = RecordAndMapError(error,
+                             FILE_ERROR_SOURCE_READ,
+                             record_uma_,
+                             bound_net_log_);
+    }
+  } else {
+    rv = static_cast<int>(bytes_read);
+  }
+  return rv;
+}
+
 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) {
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
 
   OVERLAPPED* overlapped = NULL;
-  if (async_context_.get()) {
-    DCHECK(!callback.is_null());
-    DCHECK(async_context_->callback().is_null());
-    overlapped = async_context_->overlapped();
-    async_context_->set_error_source(FILE_ERROR_SOURCE_WRITE);
-  } else {
-    DCHECK(callback.is_null());
-    base::ThreadRestrictions::AssertIOAllowed();
-  }
+  DCHECK(!callback.is_null());
+  DCHECK(async_context_->callback().is_null());
+  overlapped = async_context_->overlapped();
+  async_context_->set_error_source(FILE_ERROR_SOURCE_WRITE);
 
-  int rv;
-  DWORD bytes_written;
-  if (!WriteFile(file_, buf, buf_len, &bytes_written, overlapped)) {
+  int rv = 0;
+  DWORD bytes_written = 0;
+  if (!WriteFile(file_, buf->data(), buf_len, &bytes_written, overlapped)) {
     DWORD error = GetLastError();
-    if (async_context_.get() && error == ERROR_IO_PENDING) {
-      async_context_->IOCompletionIsPending(callback);
+    if (error == ERROR_IO_PENDING) {
+      async_context_->IOCompletionIsPending(callback, buf);
       rv = ERR_IO_PENDING;
     } else {
       LOG(WARNING) << "WriteFile failed: " << error;
       rv = RecordAndMapError(error,
                              FILE_ERROR_SOURCE_WRITE,
                              record_uma_,
                              bound_net_log_);
     }
   } else if (overlapped) {
-    async_context_->IOCompletionIsPending(callback);
+    async_context_->IOCompletionIsPending(callback, buf);
     rv = ERR_IO_PENDING;
   } else {
     rv = static_cast<int>(bytes_written);
   }
   return rv;
 }
 
+int FileStream::WriteSync(
+    const char* buf, int buf_len) {
+  DCHECK(!async_context_.get());
+  base::ThreadRestrictions::AssertIOAllowed();
+
+  if (!IsOpen())
+    return ERR_UNEXPECTED;
+
+  DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
+
+  int rv = 0;
+  DWORD bytes_written = 0;
+  if (!WriteFile(file_, buf, buf_len, &bytes_written, NULL)) {
+    DWORD error = GetLastError();
+    LOG(WARNING) << "WriteFile failed: " << error;
+    rv = RecordAndMapError(error,
+                           FILE_ERROR_SOURCE_WRITE,
+                           record_uma_,
+                           bound_net_log_);
+  } else {
+    rv = static_cast<int>(bytes_written);
+  }
+  return rv;
+}
+
 int FileStream::Flush() {
   base::ThreadRestrictions::AssertIOAllowed();
 
   if (!IsOpen())
     return ERR_UNEXPECTED;
 
   DCHECK(open_flags_ & base::PLATFORM_FILE_WRITE);
   if (FlushFileBuffers(file_)) {
     return OK;
   }
@@ skipping 58 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