Cleanup: rename some methods in BlobURLRequestJob for better readability

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 55 matching lines @@
       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.
-  CloseStream();
+  CloseFileStream();
 }
 
 void BlobURLRequestJob::Start() {
   // Continue asynchronously.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&BlobURLRequestJob::DidStart, weak_factory_.GetWeakPtr()));
 }
 
 void BlobURLRequestJob::Kill() {
-  CloseStream();
+  CloseFileStream();
 
   net::URLRequestJob::Kill();
   weak_factory_.InvalidateWeakPtrs();
 }
 
 bool BlobURLRequestJob::ReadRawData(net::IOBuffer* dest,
                                     int dest_size,
                                     int* bytes_read) {
   DCHECK_NE(dest_size, 0);
   DCHECK(bytes_read);
@@ skipping 191 matching lines @@
   // If nothing to read for current item, advance to next item.
   if (bytes_to_read_ == 0) {
     AdvanceItem();
     return ReadItem();
   }
 
   // Do the reading.
   const BlobData::Item& item = blob_data_->items().at(item_index_);
   switch (item.type) {
     case BlobData::TYPE_DATA:
-      return ReadBytes(item);
+      return ReadBytesItem(item);
     case BlobData::TYPE_FILE:
-      return DispatchReadFile(item);
+      return ReadFileItem(item);
     default:
       DCHECK(false);
       return false;
   }
 }
 
 void BlobURLRequestJob::AdvanceItem() {
   // Close the stream if the current item is a file.
-  CloseStream();
+  CloseFileStream();
 
   // Advance to the next item.
   item_index_++;
   current_item_offset_ = 0;
 }
 
 void BlobURLRequestJob::AdvanceBytesRead(int result) {
   DCHECK_GT(result, 0);
 
   // 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_->DidConsume(result);
   DCHECK_GE(read_buf_->BytesRemaining(), 0);
 }
 
-bool BlobURLRequestJob::ReadBytes(const BlobData::Item& item) {
+bool BlobURLRequestJob::ReadBytesItem(const BlobData::Item& item) {
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read_);
 
   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) {
+bool BlobURLRequestJob::ReadFileItem(const BlobData::Item& item) {
   // If the stream already exists, keep reading from it.
   if (stream_ != NULL)
-    return ReadFile();
+    return ReadFileStream();
 
   base::FileUtilProxy::CreateOrOpen(
       file_thread_proxy_, item.file_path, kFileOpenFlags,
-      base::Bind(&BlobURLRequestJob::DidOpen,
+      base::Bind(&BlobURLRequestJob::DidOpenForReadFile,
                  weak_factory_.GetWeakPtr()));
   SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
   return false;
 }
 
-void BlobURLRequestJob::DidOpen(base::PlatformFileError rv,
-                                base::PassPlatformFile file,
-                                bool created) {
+void BlobURLRequestJob::DidOpenForReadFile(base::PlatformFileError rv,
+                                           base::PassPlatformFile file,
+                                           bool created) {
   if (rv != base::PLATFORM_FILE_OK) {
     NotifyFailure(net::ERR_FAILED);
     return;
   }
 
   DCHECK(!stream_.get());
   stream_.reset(new net::FileStream(file.ReleaseValue(), kFileOpenFlags, NULL));
 
   const BlobData::Item& item = blob_data_->items().at(item_index_);
   {
     // stream_.Seek() blocks the IO thread, see http://crbug.com/75548.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     int64 offset = current_item_offset_ + static_cast<int64>(item.offset);
     if (offset > 0 && offset != stream_->Seek(net::FROM_BEGIN, offset)) {
       NotifyFailure(net::ERR_FAILED);
       return;
     }
   }
 
-  ReadFile();
+  ReadFileStream();
 }
 
-bool BlobURLRequestJob::ReadFile() {
+bool BlobURLRequestJob::ReadFileStream() {
   DCHECK(stream_.get());
   DCHECK(stream_->IsOpen());
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read_);
 
   // Start the asynchronous reading.
   int rv = stream_->Read(read_buf_,
                          bytes_to_read_,
-                         base::Bind(&BlobURLRequestJob::DidRead,
+                         base::Bind(&BlobURLRequestJob::DidReadFileStream,
                                     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;
   }
 
   // For all other errors, bail out.
   if (rv < 0) {
     NotifyFailure(net::ERR_FAILED);
     return false;
   }
 
   // Otherwise, data is immediately available.
   if (GetStatus().is_io_pending())
-    DidRead(rv);
+    DidReadFileStream(rv);
   else
     AdvanceBytesRead(rv);
 
   return true;
 }
 
-void BlobURLRequestJob::DidRead(int result) {
+void BlobURLRequestJob::DidReadFileStream(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_->BytesRemaining()) {
-    int bytes_read = ReadCompleted();
+    int bytes_read = BytesReadCompleted();
     NotifyReadComplete(bytes_read);
     return;
   }
 
   // Otherwise, continue the reading.
   int bytes_read = 0;
   if (ReadLoop(&bytes_read))
     NotifyReadComplete(bytes_read);
 }
 
-void BlobURLRequestJob::CloseStream() {
+void BlobURLRequestJob::CloseFileStream() {
   if (stream_ != NULL) {
     // stream_.Close() blocks the IO thread, see http://crbug.com/75548.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     stream_->CloseSync();
     stream_.reset(NULL);
   }
 }
 
-int BlobURLRequestJob::ReadCompleted() {
+int BlobURLRequestJob::BytesReadCompleted() {
   int bytes_read = read_buf_->BytesConsumed();
   read_buf_ = NULL;
   return bytes_read;
 }
 
 int BlobURLRequestJob::ComputeBytesToRead() const {
   int64 current_item_remaining_bytes =
       item_length_list_[item_index_] - current_item_offset_;
   int bytes_to_read = (read_buf_->BytesRemaining() >
                        current_item_remaining_bytes)
       ? static_cast<int>(current_item_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::ReadLoop(int* bytes_read) {
   // Read until we encounter an error or could not get the data immediately.
   while (remaining_bytes_ > 0 && read_buf_->BytesRemaining() > 0) {
     if (!ReadItem())
       return false;
   }
 
-  *bytes_read = ReadCompleted();
+  *bytes_read = BytesReadCompleted();
   return true;
 }
 
 void BlobURLRequestJob::NotifySuccess() {
   int status_code = 0;
   std::string status_text;
   if (byte_range_set_ && byte_range_.IsValid()) {
     status_code = kHTTPPartialContent;
     status_text += kHTTPPartialContentText;
   } else {
@@ skipping 76 matching lines @@
   response_info_.reset(new net::HttpResponseInfo());
   response_info_->headers = headers;
 
   set_expected_content_size(remaining_bytes_);
   headers_set_ = true;
 
   NotifyHeadersComplete();
 }
 
 }  // namespace webkit_blob