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

webkit/fileapi/file_writer_delegate.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 "webkit/fileapi/file_writer_delegate.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
@@ skipping 177 matching lines @@
   if (!request->status().is_success()) {
     OnError(base::PLATFORM_FILE_ERROR_FAILED);
     return;
   }
   OnDataReceived(bytes_read);
 }
 
 void FileWriterDelegate::Read() {
   bytes_written_ = 0;
   bytes_read_ = 0;
-  if (request_->Read(io_buffer_.get(), io_buffer_->size(), &bytes_read_)) {
+  if (request_->Read(io_buffer_.get(), io_buffer_->size(),
+                     &bytes_read_)) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&FileWriterDelegate::OnDataReceived,
                    weak_factory_.GetWeakPtr(), bytes_read_));
   } else if (!request_->status().is_io_pending()) {
     OnError(base::PLATFORM_FILE_ERROR_FAILED);
   }
 }
 
 void FileWriterDelegate::OnDataReceived(int bytes_read) {
   bytes_read_ = bytes_read;
   if (!bytes_read_) {  // We're done.
     OnProgress(0, true);
   } else {
     // This could easily be optimized to rotate between a pool of buffers, so
     // that we could read and write at the same time.  It's not yet clear that
     // it's necessary.
+    cursor_ = new net::DrainableIOBuffer(io_buffer_, bytes_read_);
     Write();
   }
 }
 
 void FileWriterDelegate::Write() {
   // allowed_bytes_to_write could be negative if the file size is
   // greater than the current (possibly new) quota.
   // (The UI should clear the entire origin data if the smaller quota size
   // is set in general, though the UI/deletion code is not there yet.)
   DCHECK(total_bytes_written_ <= allowed_bytes_to_write_ ||
          allowed_bytes_to_write_ < 0);
   if (total_bytes_written_ >= allowed_bytes_to_write_) {
     OnError(base::PLATFORM_FILE_ERROR_NO_SPACE);
     return;
   }
 
   int64 bytes_to_write = bytes_read_ - bytes_written_;
   if (bytes_to_write > allowed_bytes_to_write_ - total_bytes_written_)
     bytes_to_write = allowed_bytes_to_write_ - total_bytes_written_;
 
   int write_response =
-      file_stream_->Write(io_buffer_->data() + bytes_written_,
+      file_stream_->Write(cursor_,
                           static_cast<int>(bytes_to_write),
                           base::Bind(&FileWriterDelegate::OnDataWritten,
                                      base::Unretained(this)));
   if (write_response > 0)
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&FileWriterDelegate::OnDataWritten,
                    weak_factory_.GetWeakPtr(), write_response));
   else if (net::ERR_IO_PENDING != write_response)
     OnError(base::PLATFORM_FILE_ERROR_FAILED);
 }
 
 void FileWriterDelegate::OnDataWritten(int write_response) {
   if (write_response > 0) {
     OnProgress(write_response, false);
+    cursor_->DidConsume(write_response);
     bytes_written_ += write_response;
     total_bytes_written_ += write_response;
     if (bytes_written_ == bytes_read_)
       Read();
     else
       Write();
   } else {
     OnError(base::PLATFORM_FILE_ERROR_FAILED);
   }
 }
@@ skipping 56 matching lines @@
 
 FileSystemQuotaUtil* FileWriterDelegate::quota_util() const {
   DCHECK(file_system_operation_);
   DCHECK(file_system_operation_->file_system_context());
   DCHECK(file_system_operation_->file_system_operation_context());
   return file_system_operation_->file_system_context()->GetQuotaUtil(
       file_system_operation_context()->src_type());
 }
 
 }  // namespace fileapi