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

webkit/blob/blob_url_request_job.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/blob/blob_url_request_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 41 matching lines @@
     BlobData* blob_data,
     base::MessageLoopProxy* file_thread_proxy)
     : net::URLRequestJob(request),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       blob_data_(blob_data),
       file_thread_proxy_(file_thread_proxy),
       item_index_(0),
       total_size_(0),
       current_item_offset_(0),
       remaining_bytes_(0),
-      read_buf_offset_(0),
-      read_buf_size_(0),
-      read_buf_remaining_bytes_(0),
       bytes_to_read_(0),
       error_(false),
       headers_set_(false),
       byte_range_set_(false) {
   DCHECK(file_thread_proxy_);
 }
 
 BlobURLRequestJob::~BlobURLRequestJob() {
   // FileStream's destructor won't close it for us because we passed in our own
   // file handle.
@@ skipping 151 matching lines @@
 
   // If we should copy zero bytes because |remaining_bytes_| is zero, short
   // circuit here.
   if (!dest_size) {
     *bytes_read = 0;
     return true;
   }
 
   // Keep track of the buffer.
   DCHECK(!read_buf_);
-  read_buf_ = dest;
-  read_buf_offset_ = 0;
-  read_buf_size_ = dest_size;
-  read_buf_remaining_bytes_ = dest_size;
+  read_buf_ = new net::DrainableIOBuffer(dest, dest_size);
 
   return ReadLoop(bytes_read);
 }
 
 bool BlobURLRequestJob::ReadLoop(int* bytes_read) {
   // Read until we encounter an error or could not get the data immediately.
-  while (remaining_bytes_ > 0 && read_buf_remaining_bytes_ > 0) {
+  while (remaining_bytes_ > 0 && read_buf_->BytesRemaining() > 0) {
     if (!ReadItem())
       return false;
   }
 
   *bytes_read = ReadCompleted();
   return true;
 }
 
 int BlobURLRequestJob::ComputeBytesToRead() const {
   int64 current_item_remaining_bytes =
       item_length_list_[item_index_] - current_item_offset_;
-  int bytes_to_read = (read_buf_remaining_bytes_ > current_item_remaining_bytes)
+  int bytes_to_read = (read_buf_->BytesRemaining() >
+                       current_item_remaining_bytes)
       ? static_cast<int>(current_item_remaining_bytes)
-      : read_buf_remaining_bytes_;
+      : read_buf_->BytesRemaining();
   if (bytes_to_read > remaining_bytes_)
     bytes_to_read = static_cast<int>(remaining_bytes_);
   return bytes_to_read;
 }
 
 bool BlobURLRequestJob::ReadItem() {
   // Are we done with reading all the blob data?
   if (remaining_bytes_ == 0)
     return true;
 
@@ skipping 20 matching lines @@
       return ReadBytes(item);
     case BlobData::TYPE_FILE:
       return DispatchReadFile(item);
     default:
       DCHECK(false);
       return false;
   }
 }
 
 bool BlobURLRequestJob::ReadBytes(const BlobData::Item& item) {
-  DCHECK(read_buf_remaining_bytes_ >= bytes_to_read_);
+  DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read_);
 
-  memcpy(read_buf_->data() + read_buf_offset_,
+  memcpy(read_buf_->data(),
          &item.data.at(0) + item.offset + current_item_offset_,
          bytes_to_read_);
 
   AdvanceBytesRead(bytes_to_read_);
   return true;
 }
 
 bool BlobURLRequestJob::DispatchReadFile(const BlobData::Item& item) {
   // If the stream already exists, keep reading from it.
   if (stream_ != NULL)
@@ skipping 27 matching lines @@
       return;
     }
   }
 
   ReadFile(item);
 }
 
 bool BlobURLRequestJob::ReadFile(const BlobData::Item& item) {
   DCHECK(stream_.get());
   DCHECK(stream_->IsOpen());
-  DCHECK(read_buf_remaining_bytes_ >= bytes_to_read_);
+  DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read_);
 
   // Start the asynchronous reading.
-  int rv = stream_->Read(read_buf_->data() + read_buf_offset_,
+  int rv = stream_->Read(read_buf_,
                          bytes_to_read_,
                          base::Bind(&BlobURLRequestJob::DidRead,
                                     base::Unretained(this)));
 
   // If I/O pending error is returned, we just need to wait.
   if (rv == net::ERR_IO_PENDING) {
     SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
     return false;
   }
 
@@ skipping 15 matching lines @@
 void BlobURLRequestJob::DidRead(int result) {
   if (result < 0) {
     NotifyFailure(net::ERR_FAILED);
     return;
   }
   SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status
 
   AdvanceBytesRead(result);
 
   // If the read buffer is completely filled, we're done.
-  if (!read_buf_remaining_bytes_) {
+  if (!read_buf_->BytesRemaining()) {
     int bytes_read = ReadCompleted();
     NotifyReadComplete(bytes_read);
     return;
   }
 
   // Otherwise, continue the reading.
   int bytes_read = 0;
   if (ReadLoop(&bytes_read))
     NotifyReadComplete(bytes_read);
 }
@@ skipping 13 matching lines @@
   // Do we finish reading the current item?
   current_item_offset_ += result;
   if (current_item_offset_ == item_length_list_[item_index_])
     AdvanceItem();
 
   // Subtract the remaining bytes.
   remaining_bytes_ -= result;
   DCHECK_GE(remaining_bytes_, 0);
 
   // Adjust the read buffer.
-  read_buf_offset_ += result;
-  read_buf_remaining_bytes_ -= result;
-  DCHECK_GE(read_buf_remaining_bytes_, 0);
+  read_buf_->DidConsume(result);
+  DCHECK_GE(read_buf_->BytesRemaining(), 0);
 }
 
 int BlobURLRequestJob::ReadCompleted() {
-  int bytes_read = read_buf_size_ - read_buf_remaining_bytes_;
+  int bytes_read = read_buf_->BytesConsumed();
   read_buf_ = NULL;
-  read_buf_offset_ = 0;
-  read_buf_size_ = 0;
-  read_buf_remaining_bytes_ = 0;
   return bytes_read;
 }
 
 void BlobURLRequestJob::HeadersCompleted(int status_code,
                                          const std::string& status_text) {
   std::string status("HTTP/1.1 ");
   status.append(base::IntToString(status_code));
   status.append(" ");
   status.append(status_text);
   status.append("\0\0", 2);
@@ skipping 115 matching lines @@
         // We don't support multiple range requests in one single URL request,
         // because we need to do multipart encoding here.
         // TODO(jianli): Support multipart byte range requests.
         NotifyFailure(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
       }
     }
   }
 }
 
 }  // namespace webkit_blob