[fsp] Add FileStreamReader for the reading operation.

chrome/browser/chromeos/file_system_provider/fake_provided_file_system.cc

 // Copyright 2014 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 "chrome/browser/chromeos/file_system_provider/fake_provided_file_system.h"
 
 #include <string>
 
 #include "base/files/file.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 13 matching lines @@
   base::Time last_modified_time;
   const bool result = base::Time::FromString(last_modified_time_string.c_str(),
                                              &last_modified_time);
   DCHECK(result);
   entry_list->push_back(
       fileapi::DirectoryEntry(name, type, size, last_modified_time));
 }
 
 }  // namespace
 
+const char kFakeFileName[] = "hello.txt";
+const char kFakeFilePath[] = "/hello.txt";
+const char kFakeFileText[] =
+    "This is a testing file. Lorem ipsum dolor sit amet est.";
+const size_t kFakeFileSize = sizeof(kFakeFileText) - 1u;
+
 FakeProvidedFileSystem::FakeProvidedFileSystem(
     const ProvidedFileSystemInfo& file_system_info)
-    : file_system_info_(file_system_info), last_file_handle_(0) {
+    : file_system_info_(file_system_info),
+      last_file_handle_(0),
+      weak_ptr_factory_(this) {
 }
 
 FakeProvidedFileSystem::~FakeProvidedFileSystem() {}
 
 void FakeProvidedFileSystem::RequestUnmount(
     const fileapi::AsyncFileUtil::StatusCallback& callback) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE, base::Bind(callback, base::File::FILE_OK));
 }
 
 void FakeProvidedFileSystem::GetMetadata(
     const base::FilePath& entry_path,
     const fileapi::AsyncFileUtil::GetFileInfoCallback& callback) {
-  // Return fake metadata for the root directory only.
-  if (entry_path.AsUTF8Unsafe() != "/") {
+  if (entry_path.AsUTF8Unsafe() == "/") {
+    base::File::Info file_info;
+    file_info.size = 0;
+    file_info.is_directory = true;
+    file_info.is_symbolic_link = false;
+    base::Time last_modified_time;
+    const bool result = base::Time::FromString("Thu Apr 24 00:46:52 UTC 2014",
+                                               &last_modified_time);
+    DCHECK(result);
+    file_info.last_modified = last_modified_time;
+
     base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE,
-        base::Bind(
-            callback, base::File::FILE_ERROR_NOT_FOUND, base::File::Info()));
+        FROM_HERE, base::Bind(callback, base::File::FILE_OK, file_info));
     return;
   }
 
-  base::File::Info file_info;
-  file_info.size = 0;
-  file_info.is_directory = true;
-  file_info.is_symbolic_link = false;
-  base::Time last_modified_time;
-  const bool result = base::Time::FromString("Thu Apr 24 00:46:52 UTC 2014",
-                                             &last_modified_time);
-  DCHECK(result);
-  file_info.last_modified = last_modified_time;
+  if (entry_path.AsUTF8Unsafe() == kFakeFilePath) {
+    base::File::Info file_info;
+    file_info.size = kFakeFileSize;
+    file_info.is_directory = false;
+    file_info.is_symbolic_link = false;
+    base::Time last_modified_time;
+    const bool result = base::Time::FromString("Fri Apr 25 01:47:53 UTC 2014",
+                                               &last_modified_time);
+    DCHECK(result);
+    file_info.last_modified = last_modified_time;
+
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE, base::Bind(callback, base::File::FILE_OK, file_info));
+    return;
+  }
 
   base::MessageLoopProxy::current()->PostTask(
-      FROM_HERE, base::Bind(callback, base::File::FILE_OK, file_info));
+      FROM_HERE,
+      base::Bind(
+          callback, base::File::FILE_ERROR_NOT_FOUND, base::File::Info()));
 }
 
 void FakeProvidedFileSystem::ReadDirectory(
     const base::FilePath& directory_path,
     const fileapi::AsyncFileUtil::ReadDirectoryCallback& callback) {
   // Return fake contents for the root directory only.
   if (directory_path.AsUTF8Unsafe() != "/") {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::File::FILE_ERROR_NOT_FOUND,
                    fileapi::AsyncFileUtil::EntryList(),
                    false /* has_more */));
     return;
   }
 
   {
     fileapi::AsyncFileUtil::EntryList entry_list;
     AddDirectoryEntry(&entry_list,
-                      "hello.txt",
+                      kFakeFileName,
                       fileapi::DirectoryEntry::FILE,
-                      1024 /* size */,
+                      kFakeFileSize,
                       "Thu Apr 24 00:46:52 UTC 2014");
 
     AddDirectoryEntry(&entry_list,
                       "world.txt",
                       fileapi::DirectoryEntry::FILE,
                       1024 /* size */,
                       "Wed Apr 23 00:20:30 UTC 2014");
 
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
@@ skipping 20 matching lines @@
                                       OpenFileMode mode,
                                       bool create,
                                       const OpenFileCallback& callback) {
   if (file_path.AsUTF8Unsafe() != "/hello.txt" ||
       mode == OPEN_FILE_MODE_WRITE || create) {
     callback.Run(0 /* file_handle */, base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   const int file_handle = ++last_file_handle_;
-  opened_files_.insert(file_handle);
+  opened_files_[file_handle] = file_path;
   callback.Run(file_handle, base::File::FILE_OK);
 }
 
 void FakeProvidedFileSystem::CloseFile(
     int file_handle,
     const fileapi::AsyncFileUtil::StatusCallback& callback) {
-  const std::set<int>::iterator opened_file_it =
+  const OpenedFilesMap::iterator opened_file_it =
       opened_files_.find(file_handle);
   if (opened_file_it == opened_files_.end()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, base::File::FILE_ERROR_NOT_FOUND));
     return;
   }
 
   opened_files_.erase(opened_file_it);
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE, base::Bind(callback, base::File::FILE_OK));
 }
 
 void FakeProvidedFileSystem::ReadFile(
     int file_handle,
     net::IOBuffer* buffer,
     int64 offset,
     int length,
     const ProvidedFileSystemInterface::ReadChunkReceivedCallback& callback) {
-  // TODO(mtomasz): Implement together with the FileStreamReader.
-  base::MessageLoopProxy::current()->PostTask(
-      FROM_HERE,
-      base::Bind(callback,
-                 0 /* chunk_length */,
-                 false /* has_next */,
-                 base::File::FILE_ERROR_SECURITY));
+  const OpenedFilesMap::iterator opened_file_it =
+      opened_files_.find(file_handle);
+  if (opened_file_it == opened_files_.end() ||
+      opened_file_it->second.AsUTF8Unsafe() != kFakeFilePath) {
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   0 /* chunk_length */,
+                   false /* has_next */,
+                   base::File::FILE_ERROR_SECURITY));
+    return;
+  }
+
+  // Send the response byte by byte.
+  size_t current_offset = static_cast<size_t>(offset);
+  size_t current_length = static_cast<size_t>(length);
+
+  // Reading behind EOF, is fine, it will just read 0 bytes.
+  if (current_offset > kFakeFileSize || !current_length) {
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   0 /* chunk_length */,
+                   false /* has_next */,
+                   base::File::FILE_OK));
+  }
+
+  while (current_offset < kFakeFileSize && current_length) {
+    buffer->data()[current_offset - offset] = kFakeFileText[current_offset];
+    const bool has_next =
+        (current_offset + 1 < kFakeFileSize) && (current_length - 1);
+    callback.Run(1, has_next, base::File::FILE_OK);
+    current_offset++;
+    current_length--;
+  }
 }
 
 const ProvidedFileSystemInfo& FakeProvidedFileSystem::GetFileSystemInfo()
     const {
   return file_system_info_;
 }
 
 RequestManager* FakeProvidedFileSystem::GetRequestManager() {
   NOTREACHED();
   return NULL;
 }
 
 ProvidedFileSystemInterface* FakeProvidedFileSystem::Create(
     extensions::EventRouter* event_router,
     const ProvidedFileSystemInfo& file_system_info) {
   return new FakeProvidedFileSystem(file_system_info);
 }
 
+base::WeakPtr<ProvidedFileSystemInterface>
+FakeProvidedFileSystem::GetWeakPtr() {
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
 }  // namespace file_system_provider
 }  // namespace chromeos