Rename webkit_blob::FileReader to FileStreamReader.

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_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_status.h"
-#include "webkit/blob/local_file_reader.h"
+#include "webkit/blob/local_file_stream_reader.h"
 
 namespace webkit_blob {
 
 namespace {
 
 const int kHTTPOk = 200;
 const int kHTTPPartialContent = 206;
 const int kHTTPNotAllowed = 403;
 const int kHTTPNotFound = 404;
 const int kHTTPMethodNotAllow = 405;
@@ skipping 136 matching lines @@
 void BlobURLRequestJob::CountSize() {
   error_ = false;
   pending_get_file_info_count_ = 0;
   total_size_ = 0;
   item_length_list_.resize(blob_data_->items().size());
 
   for (size_t i = 0; i < blob_data_->items().size(); ++i) {
     const BlobData::Item& item = blob_data_->items().at(i);
     if (item.type == BlobData::TYPE_FILE) {
       ++pending_get_file_info_count_;
-      GetFileReader(i)->GetLength(
+      GetFileStreamReader(i)->GetLength(
           base::Bind(&BlobURLRequestJob::DidGetFileItemLength,
                      weak_factory_.GetWeakPtr(), i));
       continue;
     }
     // Cache the size and add it to the total size.
     int64 item_length = static_cast<int64>(item.length);
     item_length_list_[i] = item_length;
     total_size_ += item_length;
   }
 
@@ skipping 71 matching lines @@
   // Set the offset that need to jump to for the first item in the range.
   current_item_offset_ = offset;
 
   if (offset == 0)
     return;
 
   // Adjust the offset of the first stream if it is of file type.
   const BlobData::Item& item = blob_data_->items().at(current_item_index_);
   if (item.type == BlobData::TYPE_FILE) {
     DeleteCurrentFileReader();
-    index_to_reader_[current_item_index_] = new LocalFileReader(
+    index_to_reader_[current_item_index_] = new LocalFileStreamReader(
         file_thread_proxy_,
         item.file_path,
         item.offset + offset,
         item.expected_modification_time);
   }
 }
 
 bool BlobURLRequestJob::ReadItem() {
   // Are we done with reading all the blob data?
   if (remaining_bytes_ == 0)
@@ skipping 14 matching lines @@
     AdvanceItem();
     return ReadItem();
   }
 
   // Do the reading.
   const BlobData::Item& item = blob_data_->items().at(current_item_index_);
   switch (item.type) {
     case BlobData::TYPE_DATA:
       return ReadBytesItem(item, bytes_to_read);
     case BlobData::TYPE_FILE:
-      return ReadFileItem(GetFileReader(current_item_index_), bytes_to_read);
+      return ReadFileItem(GetFileStreamReader(current_item_index_),
+                          bytes_to_read);
     default:
       DCHECK(false);
       return false;
   }
 }
 
 void BlobURLRequestJob::AdvanceItem() {
   // Close the file if the current item is a file.
   DeleteCurrentFileReader();
 
@@ skipping 24 matching lines @@
   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::ReadFileItem(LocalFileReader* reader,
+bool BlobURLRequestJob::ReadFileItem(LocalFileStreamReader* reader,
                                      int bytes_to_read) {
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
   DCHECK(reader);
   const int result = reader->Read(
       read_buf_, bytes_to_read,
       base::Bind(&BlobURLRequestJob::DidReadFile,
                  base::Unretained(this)));
   if (result >= 0) {
     // Data is immediately available.
     if (GetStatus().is_io_pending())
@@ skipping 150 matching lines @@
 
   response_info_.reset(new net::HttpResponseInfo());
   response_info_->headers = headers;
 
   set_expected_content_size(remaining_bytes_);
   headers_set_ = true;
 
   NotifyHeadersComplete();
 }
 
-LocalFileReader* BlobURLRequestJob::GetFileReader(size_t index) {
+LocalFileStreamReader* BlobURLRequestJob::GetFileStreamReader(size_t index) {
   DCHECK_LT(index, blob_data_->items().size());
   const BlobData::Item& item = blob_data_->items().at(index);
   if (item.type != BlobData::TYPE_FILE)
     return NULL;
   if (index_to_reader_.find(index) == index_to_reader_.end()) {
-    index_to_reader_[index] = new LocalFileReader(
+    index_to_reader_[index] = new LocalFileStreamReader(
         file_thread_proxy_,
         item.file_path,
         item.offset,
         item.expected_modification_time);
   }
   DCHECK(index_to_reader_[index]);
   return index_to_reader_[index];
 }
 
 }  // namespace webkit_blob