Rename webkit_blob::FileReader to FileStreamReader.

The name was confusion: it does not directly correspond to FileReader in File API, (which is implemented by WebCore::FileReader).

BUG=128483
TEST=Existing file/blob tests.


Review URL: https://chromiumcodereview.appspot.com/10447083

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@139724 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 87 insertions, 81 deletions

diff --git a/webkit/blob/blob_url_request_job.cc b/webkit/blob/blob_url_request_job.cc
index 6f8ef92..e0ca156 100644
--- a/webkit/blob/blob_url_request_job.cc
+++ b/webkit/blob/blob_url_request_job.cc
@@ -20,7 +20,7 @@
 #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 {
 
@@ -177,7 +177,7 @@ void BlobURLRequestJob::CountSize() {
     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;
@@ -269,7 +269,7 @@ void BlobURLRequestJob::Seek(int64 offset) {
   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,
@@ -304,7 +304,8 @@ bool BlobURLRequestJob::ReadItem() {
     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;
@@ -349,7 +350,7 @@ bool BlobURLRequestJob::ReadBytesItem(const BlobData::Item& item,
   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);
@@ -520,13 +521,13 @@ void BlobURLRequestJob::HeadersCompleted(int status_code,
   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,
diff --git a/webkit/blob/blob_url_request_job.h b/webkit/blob/blob_url_request_job.h
index 436d0a9..676ebaf 100644
--- a/webkit/blob/blob_url_request_job.h
+++ b/webkit/blob/blob_url_request_job.h
@@ -20,13 +20,12 @@ struct PlatformFileInfo;
 
 namespace net {
 class DrainableIOBuffer;
-class FileStream;
 class IOBuffer;
 }
 
 namespace webkit_blob {
 
-class LocalFileReader;
+class LocalFileStreamReader;
 
 // A request job that handles reading blob URLs.
 class BLOB_EXPORT BlobURLRequestJob : public net::URLRequestJob {
@@ -51,7 +50,7 @@ class BLOB_EXPORT BlobURLRequestJob : public net::URLRequestJob {
   virtual ~BlobURLRequestJob();
 
  private:
-  typedef std::map<size_t, LocalFileReader*> IndexToReaderMap;
+  typedef std::map<size_t, LocalFileStreamReader*> IndexToReaderMap;
 
   // For preparing for read: get the size, apply the range and perform seek.
   void DidStart();
@@ -66,7 +65,7 @@ class BLOB_EXPORT BlobURLRequestJob : public net::URLRequestJob {
   void AdvanceItem();
   void AdvanceBytesRead(int result);
   bool ReadBytesItem(const BlobData::Item& item, int bytes_to_read);
-  bool ReadFileItem(LocalFileReader* reader, int bytes_to_read);
+  bool ReadFileItem(LocalFileStreamReader* reader, int bytes_to_read);
 
   void DidReadFile(int result);
   void DeleteCurrentFileReader();
@@ -78,9 +77,9 @@ class BLOB_EXPORT BlobURLRequestJob : public net::URLRequestJob {
   void NotifyFailure(int);
   void HeadersCompleted(int status_code, const std::string& status_txt);
 
-  // Returns a LocalFileReader for a blob item at |index|.
+  // Returns a LocalFileStreamReader for a blob item at |index|.
   // If the item at |index| is not of TYPE_FILE this returns NULL.
-  LocalFileReader* GetFileReader(size_t index);
+  LocalFileStreamReader* GetFileStreamReader(size_t index);
 
   base::WeakPtrFactory<BlobURLRequestJob> weak_factory_;
   scoped_refptr<BlobData> blob_data_;
diff --git a/webkit/blob/file_reader.h b/webkit/blob/file_stream_reader.h
index 8aedf40..ccb8ba3 100644
--- a/webkit/blob/file_reader.h
+++ b/webkit/blob/file_stream_reader.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef WEBKIT_BLOB_FILE_READER_H_
-#define WEBKIT_BLOB_FILE_READER_H_
+#ifndef WEBKIT_BLOB_FILE_STREAM_READER_H_
+#define WEBKIT_BLOB_FILE_STREAM_READER_H_
 #pragma once
 
 #include "base/basictypes.h"
@@ -12,18 +12,17 @@
 #include "webkit/blob/blob_export.h"
 
 namespace net {
-class FileStream;
 class IOBuffer;
 }
 
 namespace webkit_blob {
 
 // A generic interface for reading a file-like object.
-class BLOB_EXPORT FileReader {
+class BLOB_EXPORT FileStreamReader {
  public:
   // It is valid to delete the reader at any time.  If the stream is deleted
   // while it has a pending read, its callback will not be called.
-  virtual ~FileReader() {}
+  virtual ~FileStreamReader() {}
 
   // Reads from the current cursor position asynchronously.
   //
@@ -44,4 +43,4 @@ class BLOB_EXPORT FileReader {
 
 }  // namespace webkit_blob
 
-#endif  // WEBKIT_BLOB_FILE_READER_H_
+#endif  // WEBKIT_BLOB_FILE_STREAM_READER_H_
diff --git a/webkit/blob/local_file_reader.cc b/webkit/blob/local_file_stream_reader.cc
index 7de2686..10276d0 100644
--- a/webkit/blob/local_file_reader.cc
+++ b/webkit/blob/local_file_stream_reader.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "webkit/blob/local_file_reader.h"
+#include "webkit/blob/local_file_stream_reader.h"
 
 #include "base/file_util.h"
 #include "base/file_util_proxy.h"
@@ -33,7 +33,7 @@ bool VerifySnapshotTime(const base::Time& expected_modification_time,
 }  // namespace
 
 // static
-int LocalFileReader::PlatformFileErrorToNetError(
+int LocalFileStreamReader::PlatformFileErrorToNetError(
     base::PlatformFileError file_error) {
   switch (file_error) {
     case base::PLATFORM_FILE_OK:
@@ -47,7 +47,7 @@ int LocalFileReader::PlatformFileErrorToNetError(
   }
 }
 
-LocalFileReader::LocalFileReader(
+LocalFileStreamReader::LocalFileStreamReader(
     base::TaskRunner* task_runner,
     const FilePath& file_path,
     int64 initial_offset,
@@ -59,40 +59,41 @@ LocalFileReader::LocalFileReader(
       has_pending_open_(false),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
-LocalFileReader::~LocalFileReader() {
+LocalFileStreamReader::~LocalFileStreamReader() {
 }
 
-int LocalFileReader::Read(net::IOBuffer* buf, int buf_len,
+int LocalFileStreamReader::Read(net::IOBuffer* buf, int buf_len,
                           const net::CompletionCallback& callback) {
   DCHECK(!has_pending_open_);
   if (stream_impl_.get())
     return stream_impl_->Read(buf, buf_len, callback);
-  return Open(base::Bind(&LocalFileReader::DidOpenForRead,
+  return Open(base::Bind(&LocalFileStreamReader::DidOpenForRead,
                          weak_factory_.GetWeakPtr(),
                          make_scoped_refptr(buf), buf_len, callback));
 }
 
-int LocalFileReader::GetLength(const net::Int64CompletionCallback& callback) {
+int LocalFileStreamReader::GetLength(
+    const net::Int64CompletionCallback& callback) {
   const bool posted = base::FileUtilProxy::GetFileInfo(
       task_runner_, file_path_,
-      base::Bind(&LocalFileReader::DidGetFileInfoForGetLength,
+      base::Bind(&LocalFileStreamReader::DidGetFileInfoForGetLength,
                  weak_factory_.GetWeakPtr(), callback));
   DCHECK(posted);
   return net::ERR_IO_PENDING;
 }
 
-int LocalFileReader::Open(const net::CompletionCallback& callback) {
+int LocalFileStreamReader::Open(const net::CompletionCallback& callback) {
   DCHECK(!has_pending_open_);
   DCHECK(!stream_impl_.get());
   has_pending_open_ = true;
 
   // Call GetLength first to make it perform last-modified-time verification,
   // and then call DidVerifyForOpen for do the rest.
-  return GetLength(base::Bind(&LocalFileReader::DidVerifyForOpen,
+  return GetLength(base::Bind(&LocalFileStreamReader::DidVerifyForOpen,
                               weak_factory_.GetWeakPtr(), callback));
 }
 
-void LocalFileReader::DidVerifyForOpen(
+void LocalFileStreamReader::DidVerifyForOpen(
     const net::CompletionCallback& callback,
     int64 get_length_result) {
   if (get_length_result < 0) {
@@ -103,30 +104,31 @@ void LocalFileReader::DidVerifyForOpen(
   stream_impl_.reset(new net::FileStream(NULL));
   const int result = stream_impl_->Open(
       file_path_, kOpenFlagsForRead,
-      base::Bind(&LocalFileReader::DidOpenFileStream,
+      base::Bind(&LocalFileStreamReader::DidOpenFileStream,
                  weak_factory_.GetWeakPtr(),
                  callback));
   if (result != net::ERR_IO_PENDING)
     callback.Run(result);
 }
 
-void LocalFileReader::DidOpenFileStream(
+void LocalFileStreamReader::DidOpenFileStream(
     const net::CompletionCallback& callback,
     int result) {
   if (result != net::OK) {
     callback.Run(result);
     return;
   }
-  result = stream_impl_->Seek(net::FROM_BEGIN, initial_offset_,
-                              base::Bind(&LocalFileReader::DidSeekFileStream,
-                                         weak_factory_.GetWeakPtr(),
-                                         callback));
+  result = stream_impl_->Seek(
+      net::FROM_BEGIN, initial_offset_,
+      base::Bind(&LocalFileStreamReader::DidSeekFileStream,
+                 weak_factory_.GetWeakPtr(),
+                 callback));
   if (result != net::ERR_IO_PENDING) {
     callback.Run(result);
   }
 }
 
-void LocalFileReader::DidSeekFileStream(
+void LocalFileStreamReader::DidSeekFileStream(
     const net::CompletionCallback& callback,
     int64 seek_result) {
   if (seek_result < 0) {
@@ -140,10 +142,11 @@ void LocalFileReader::DidSeekFileStream(
   callback.Run(net::OK);
 }
 
-void LocalFileReader::DidOpenForRead(net::IOBuffer* buf,
-                                     int buf_len,
-                                     const net::CompletionCallback& callback,
-                                     int open_result) {
+void LocalFileStreamReader::DidOpenForRead(
+    net::IOBuffer* buf,
+    int buf_len,
+    const net::CompletionCallback& callback,
+    int open_result) {
   DCHECK(has_pending_open_);
   has_pending_open_ = false;
   if (open_result != net::OK) {
@@ -157,7 +160,7 @@ void LocalFileReader::DidOpenForRead(net::IOBuffer* buf,
     callback.Run(read_result);
 }
 
-void LocalFileReader::DidGetFileInfoForGetLength(
+void LocalFileStreamReader::DidGetFileInfoForGetLength(
     const net::Int64CompletionCallback& callback,
     base::PlatformFileError error,
     const base::PlatformFileInfo& file_info) {
@@ -166,7 +169,7 @@ void LocalFileReader::DidGetFileInfoForGetLength(
     return;
   }
   if (error != base::PLATFORM_FILE_OK) {
-    callback.Run(LocalFileReader::PlatformFileErrorToNetError(error));
+    callback.Run(LocalFileStreamReader::PlatformFileErrorToNetError(error));
     return;
   }
   if (!VerifySnapshotTime(expected_modification_time_, file_info)) {
diff --git a/webkit/blob/local_file_reader.h b/webkit/blob/local_file_stream_reader.h
index 2bacedf..08dd4c3 100644
--- a/webkit/blob/local_file_reader.h
+++ b/webkit/blob/local_file_stream_reader.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef WEBKIT_BLOB_LOCAL_FILE_READER_H_
-#define WEBKIT_BLOB_LOCAL_FILE_READER_H_
+#ifndef WEBKIT_BLOB_LOCAL_FILE_STREAM_READER_H_
+#define WEBKIT_BLOB_LOCAL_FILE_STREAM_READER_H_
 #pragma once
 
 #include "base/basictypes.h"
@@ -13,17 +13,21 @@
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "webkit/blob/blob_export.h"
-#include "webkit/blob/file_reader.h"
+#include "webkit/blob/file_stream_reader.h"
 
 namespace base {
 class TaskRunner;
 }
 
+namespace net {
+class FileStream;
+}
+
 namespace webkit_blob {
 
 // A thin wrapper of net::FileStream with range support for sliced file
 // handling.
-class BLOB_EXPORT LocalFileReader : public FileReader {
+class BLOB_EXPORT LocalFileStreamReader : public FileStreamReader {
  public:
   // A convenient method to translate platform file error to net error code.
   static int PlatformFileErrorToNetError(base::PlatformFileError file_error);
@@ -38,13 +42,13 @@ class BLOB_EXPORT LocalFileReader : public FileReader {
   // actual modification time to see if the file has been modified, and if
   // it does any succeeding read operations should fail with
   // ERR_UPLOAD_FILE_CHANGED error.
-  LocalFileReader(base::TaskRunner* task_runner,
-                  const FilePath& file_path,
-                  int64 initial_offset,
-                  const base::Time& expected_modification_time);
-  virtual ~LocalFileReader();
+  LocalFileStreamReader(base::TaskRunner* task_runner,
+                        const FilePath& file_path,
+                        int64 initial_offset,
+                   const base::Time& expected_modification_time);
+  virtual ~LocalFileStreamReader();
 
-  // FileReader overrides.
+  // FileStreamReader overrides.
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    const net::CompletionCallback& callback) OVERRIDE;
 
@@ -81,9 +85,9 @@ class BLOB_EXPORT LocalFileReader : public FileReader {
   const int64 initial_offset_;
   const base::Time expected_modification_time_;
   bool has_pending_open_;
-  base::WeakPtrFactory<LocalFileReader> weak_factory_;
+  base::WeakPtrFactory<LocalFileStreamReader> weak_factory_;
 };
 
 }  // namespace webkit_blob
 
-#endif  // WEBKIT_BLOB_LOCAL_FILE_READER_H_
+#endif  // WEBKIT_BLOB_LOCAL_FILE_STREAM_READER_H_
diff --git a/webkit/blob/local_file_reader_unittest.cc b/webkit/blob/local_file_stream_reader_unittest.cc
index 595481e..4087037 100644
--- a/webkit/blob/local_file_reader_unittest.cc
+++ b/webkit/blob/local_file_stream_reader_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "webkit/blob/local_file_reader.h"
+#include "webkit/blob/local_file_stream_reader.h"
 
 #include <string>
 
@@ -25,7 +25,7 @@ namespace {
 const char kTestData[] = "0123456789";
 const int kTestDataSize = arraysize(kTestData) - 1;
 
-void ReadFromReader(LocalFileReader* reader,
+void ReadFromReader(LocalFileStreamReader* reader,
                     std::string* data, size_t size,
                     int* result) {
   ASSERT_TRUE(reader != NULL);
@@ -57,9 +57,9 @@ void QuitLoop() {
 
 }  // namespace
 
-class LocalFileReaderTest : public testing::Test {
+class LocalFileStreamReaderTest : public testing::Test {
  public:
-  LocalFileReaderTest()
+  LocalFileStreamReaderTest()
       : message_loop_(MessageLoop::TYPE_IO),
         file_thread_("FileUtilProxyTestFileThread") {}
 
@@ -80,11 +80,11 @@ class LocalFileReaderTest : public testing::Test {
   }
 
  protected:
-  LocalFileReader* CreateFileReader(
+  LocalFileStreamReader* CreateFileReader(
       const FilePath& path,
       int64 initial_offset,
       const base::Time& expected_modification_time) {
-    return new LocalFileReader(
+    return new LocalFileStreamReader(
             file_task_runner(),
             path,
             initial_offset,
@@ -122,9 +122,9 @@ class LocalFileReaderTest : public testing::Test {
   base::Time test_file_modification_time_;
 };
 
-TEST_F(LocalFileReaderTest, NonExistent) {
+TEST_F(LocalFileStreamReaderTest, NonExistent) {
   FilePath nonexistent_path = test_dir().AppendASCII("nonexistent");
-  scoped_ptr<LocalFileReader> reader(
+  scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(nonexistent_path, 0, base::Time()));
   int result = 0;
   std::string data;
@@ -133,7 +133,7 @@ TEST_F(LocalFileReaderTest, NonExistent) {
   ASSERT_EQ(0U, data.size());
 }
 
-TEST_F(LocalFileReaderTest, Empty) {
+TEST_F(LocalFileStreamReaderTest, Empty) {
   FilePath empty_path = test_dir().AppendASCII("empty");
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   base::PlatformFile file = base::CreatePlatformFile(
@@ -144,7 +144,7 @@ TEST_F(LocalFileReaderTest, Empty) {
   ASSERT_NE(base::kInvalidPlatformFileValue, file);
   base::ClosePlatformFile(file);
 
-  scoped_ptr<LocalFileReader> reader(
+  scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(empty_path, 0, base::Time()));
   int result = 0;
   std::string data;
@@ -159,8 +159,8 @@ TEST_F(LocalFileReaderTest, Empty) {
   ASSERT_EQ(0, result);
 }
 
-TEST_F(LocalFileReaderTest, GetLengthNormal) {
-  scoped_ptr<LocalFileReader> reader(
+TEST_F(LocalFileStreamReaderTest, GetLengthNormal) {
+  scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 0, test_file_modification_time()));
   net::TestInt64CompletionCallback callback;
   int result = reader->GetLength(callback.callback());
@@ -169,12 +169,12 @@ TEST_F(LocalFileReaderTest, GetLengthNormal) {
   ASSERT_EQ(kTestDataSize, result);
 }
 
-TEST_F(LocalFileReaderTest, GetLengthAfterModified) {
+TEST_F(LocalFileStreamReaderTest, GetLengthAfterModified) {
   // Touch file so that the file's modification time becomes different
   // from what we expect.
   TouchTestFile();
 
-  scoped_ptr<LocalFileReader> reader(
+  scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 0, test_file_modification_time()));
   net::TestInt64CompletionCallback callback;
   int result = reader->GetLength(callback.callback());
@@ -190,8 +190,8 @@ TEST_F(LocalFileReaderTest, GetLengthAfterModified) {
   ASSERT_EQ(kTestDataSize, result);
 }
 
-TEST_F(LocalFileReaderTest, GetLengthWithOffset) {
-  scoped_ptr<LocalFileReader> reader(
+TEST_F(LocalFileStreamReaderTest, GetLengthWithOffset) {
+  scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 3, base::Time()));
   net::TestInt64CompletionCallback callback;
   int result = reader->GetLength(callback.callback());
@@ -201,8 +201,8 @@ TEST_F(LocalFileReaderTest, GetLengthWithOffset) {
   ASSERT_EQ(kTestDataSize, result);
 }
 
-TEST_F(LocalFileReaderTest, ReadNormal) {
-  scoped_ptr<LocalFileReader> reader(
+TEST_F(LocalFileStreamReaderTest, ReadNormal) {
+  scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 0, test_file_modification_time()));
   int result = 0;
   std::string data;
@@ -211,12 +211,12 @@ TEST_F(LocalFileReaderTest, ReadNormal) {
   ASSERT_EQ(kTestData, data);
 }
 
-TEST_F(LocalFileReaderTest, ReadAfterModified) {
+TEST_F(LocalFileStreamReaderTest, ReadAfterModified) {
   // Touch file so that the file's modification time becomes different
   // from what we expect.
   TouchTestFile();
 
-  scoped_ptr<LocalFileReader> reader(
+  scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 0, test_file_modification_time()));
   int result = 0;
   std::string data;
@@ -232,8 +232,8 @@ TEST_F(LocalFileReaderTest, ReadAfterModified) {
   ASSERT_EQ(kTestData, data);
 }
 
-TEST_F(LocalFileReaderTest, ReadWithOffset) {
-  scoped_ptr<LocalFileReader> reader(
+TEST_F(LocalFileStreamReaderTest, ReadWithOffset) {
+  scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 3, base::Time()));
   int result = 0;
   std::string data;
@@ -242,8 +242,8 @@ TEST_F(LocalFileReaderTest, ReadWithOffset) {
   ASSERT_EQ(&kTestData[3], data);
 }
 
-TEST_F(LocalFileReaderTest, DeleteWithUnfinishedRead) {
-  scoped_ptr<LocalFileReader> reader(
+TEST_F(LocalFileStreamReaderTest, DeleteWithUnfinishedRead) {
+  scoped_ptr<LocalFileStreamReader> reader(
       CreateFileReader(test_path(), 0, base::Time()));
 
   net::TestCompletionCallback callback;
diff --git a/webkit/blob/webkit_blob.gypi b/webkit/blob/webkit_blob.gypi
index 5a05d7dd..a956305 100644
--- a/webkit/blob/webkit_blob.gypi
+++ b/webkit/blob/webkit_blob.gypi
@@ -37,8 +37,8 @@
         'blob_url_request_job.h',
         'blob_url_request_job_factory.cc',
         'blob_url_request_job_factory.h',
-        'local_file_reader.cc',
-        'local_file_reader.h',
+        'local_file_stream_reader.cc',
+        'local_file_stream_reader.h',
         'shareable_file_reference.cc',
         'shareable_file_reference.h',
         'view_blob_internals_job.cc',