Implement async verision of FileSystemFileUtil and in-memory file system for testing purposes.

webkit/chromeos/fileapi/memory_file_util.cc

Index: webkit/chromeos/fileapi/memory_file_util.cc
diff --git a/webkit/chromeos/fileapi/memory_file_util.cc b/webkit/chromeos/fileapi/memory_file_util.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bf5523f0f95c34d222c9130b9d5fa417594a1a66
--- /dev/null
+++ b/webkit/chromeos/fileapi/memory_file_util.cc
@@ -0,0 +1,405 @@
+// Copyright (c) 2011 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 "base/bind.h"
+#include "base/message_loop.h"
+#include "webkit/chromeos/fileapi/memory_file_util.h"
+
+namespace {
+const int kDefaultReadDirectoryBufferSize = 100;
+}  // namespace
+
+namespace fileapi {
+
+MemoryFileUtil::MemoryFileUtil(const FilePath& root_path)
+    : read_directory_buffer_size_(kDefaultReadDirectoryBufferSize) {
+  FileEntry root;
+  root.is_directory = true;
+  root.last_modified = base::Time::Now();
+
+  files_[root_path] = root;
+}
+
+void MemoryFileUtil::GetFileInfo(
+    const FilePath& file_path,
+    const GetFileInfoCallback& callback) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MemoryFileUtil::DoGetFileInfo, base::Unretained(this),
+                 file_path.StripTrailingSeparators(), callback));
+}
+
+void MemoryFileUtil::Create(
+    const FilePath& file_path,
+    const StatusCallback& callback) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MemoryFileUtil::DoCreate, base::Unretained(this),
+                 file_path.StripTrailingSeparators(), false, callback));
+}
+
+void MemoryFileUtil::Truncate(
+    const FilePath& file_path,
+    int64 length,
+    const StatusCallback& callback) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MemoryFileUtil::DoTruncate, base::Unretained(this),
+                 file_path.StripTrailingSeparators(), length, callback));
+}
+
+void MemoryFileUtil::Touch(
+    const FilePath& file_path,
+    const base::Time& last_access_time,
+    const base::Time& last_modified_time,
+    const StatusCallback& callback) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MemoryFileUtil::DoTouch, base::Unretained(this),
+                 file_path.StripTrailingSeparators(),
+                 last_modified_time, callback));
+}
+
+void MemoryFileUtil::Remove(
+    const FilePath& file_path,
+    bool recursive,
+    const StatusCallback& callback) {
+  if (recursive) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&MemoryFileUtil::DoRemoveRecursive,
+                   base::Unretained(this), file_path.StripTrailingSeparators(),
+                   callback));
+  } else {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&MemoryFileUtil::DoRemoveSingleFile,
+                   base::Unretained(this), file_path.StripTrailingSeparators(),
+                   callback));
+  }
+}
+
+void MemoryFileUtil::CreateDirectory(
+    const FilePath& dir_path,
+    const StatusCallback& callback) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MemoryFileUtil::DoCreate,
+                 base::Unretained(this), dir_path.StripTrailingSeparators(),
+                 true, callback));
+}
+
+void MemoryFileUtil::ReadDirectory(
+    const FilePath& dir_path,
+    const ReadDirectoryCallback& callback) {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MemoryFileUtil::DoReadDirectory,
+                 base::Unretained(this), dir_path.StripTrailingSeparators(),
+                 FilePath(), callback));
+}
+
+void MemoryFileUtil::Write(
+    const FilePath& file_path,
+    int64 offset,
+    const char* data,
+    int64 length,
+    const ReadWriteCallback& callback) {
+  DCHECK(data);
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MemoryFileUtil::DoWrite, base::Unretained(this),
+                 file_path.StripTrailingSeparators(),
+                 offset, data, length, callback));
+}
+
+void MemoryFileUtil::Read(
+    const FilePath& file_path,
+    int64 offset,
+    char* buffer,
+    int64 length,
+    const ReadWriteCallback& callback) {
+  DCHECK(buffer);
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MemoryFileUtil::DoRead, base::Unretained(this),
+                 file_path.StripTrailingSeparators(),
+                 offset, buffer, length, callback));
+}
+
+bool MemoryFileUtil::IsDirectory(const FilePath& file_path) {
+  ConstFileIterator it = GetFile(file_path);
+  return it != files_.end() && it->second.is_directory;
+}
+
+void MemoryFileUtil::DoGetFileInfo(const FilePath& file_path,
+                                   const GetFileInfoCallback& callback) {
+  base::PlatformFileInfo file_info;
+
+  FileIterator file_it = GetFile(file_path);
+
+  if (file_it == files_.end()) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND, file_info);
+    return;
+  }
+  FileEntry& file_entry = file_it->second;
+
+  file_info.size = file_entry.contents.size();
+  file_info.is_directory = file_entry.is_directory;
+  file_info.is_symbolic_link = false;
+
+  // In this file system implementation we store only one datetime. Many
+  // popular file systems do the same.
+  file_info.last_modified = file_entry.last_modified;
+  file_info.last_accessed = file_entry.last_modified;
+  file_info.creation_time = file_entry.last_modified;
+
+  callback.Run(base::PLATFORM_FILE_OK, file_info);
+}
+
+void MemoryFileUtil::DoCreate(
+    const FilePath& file_path,
+    bool is_directory,
+    const StatusCallback& callback) {
+  if (FileExists(file_path)) {
+    callback.Run(base::PLATFORM_FILE_ERROR_EXISTS);
+    return;
+  }
+
+  if (!IsDirectory(file_path.DirName())) {
+    callback.Run(base::PLATFORM_FILE_ERROR_FAILED);
+    return;
+  }
+
+  FileEntry file;
+  file.is_directory = is_directory;
+  file.last_modified = base::Time::Now();
+
+  files_[file_path] = file;
+  callback.Run(base::PLATFORM_FILE_OK);
+}
+
+void MemoryFileUtil::DoTruncate(
+    const FilePath& file_path,
+    int64 length,
+    const StatusCallback& callback) {
+  FileIterator file_it = GetFile(file_path);
+  if (file_it == files_.end()) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    return;
+  }
+
+  FileEntry& file = file_it->second;
+
+  // Fill the extended part with 0 if |length| is larger than the original
+  // contents size.
+  file.contents.resize(length, 0);
+  callback.Run(base::PLATFORM_FILE_OK);
+}
+
+void MemoryFileUtil::DoTouch(
+    const FilePath& file_path,
+    const base::Time& last_modified_time,
+    const StatusCallback& callback) {
+  FileIterator file_it = GetFile(file_path);
+  if (file_it == files_.end()) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    return;
+  }
+
+  FileEntry& file = file_it->second;
+
+  file.last_modified = last_modified_time;
+  callback.Run(base::PLATFORM_FILE_OK);
+}
+
+void MemoryFileUtil::DoRemoveSingleFile(
+    const FilePath& file_path,
+    const StatusCallback& callback) {
+  FileIterator file_it = GetFile(file_path);
+  if (file_it == files_.end()) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    return;
+  }
+
+  FileEntry& file = file_it->second;
+  if (file.is_directory) {
+    // Check that directory is empty.
+    FilePath path_with_separator = file_it->first.Append("/");
+    FileIterator file_inside_dir = files_.lower_bound(path_with_separator);
+
+    if (file_it->first.IsParent(file_inside_dir->first)) {
+      callback.Run(base::PLATFORM_FILE_ERROR_NOT_A_FILE);
+      return;
+    }
+  }
+
+  files_.erase(file_it);
+  callback.Run(base::PLATFORM_FILE_OK);
+}
+
+void MemoryFileUtil::DoRemoveRecursive(
+    const FilePath& file_path,
+    const StatusCallback& callback) {
+  FileIterator file_it = GetFile(file_path);
+  if (file_it == files_.end()) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    return;
+  }
+
+  FileEntry& file = file_it->second;
+  if (!file.is_directory) {
+    files_.erase(file_it);
+    callback.Run(base::PLATFORM_FILE_OK);
+    return;
+  }
+
+  // In the following code we rely on the fact that the paths in files_
+  // are ordered lexicographically. We iterate over files_ and delete
+  // the files from files_, then delete in one go all the files from
+  // file_by_name_.
+  FilePath file_path_with_separator = file_path.Append("/");
+  FileIterator it_first = files_.lower_bound(file_path_with_separator);
+  FileIterator it_last = it_first;
+
+  while (it_last != files_.end() && file_path.IsParent(it_last->first)) {
+    ++it_last;
+  }
+  files_.erase(it_first, it_last);
+
+  // The initial path is stored without a separator in the end, so it
+  // has not been removed in the above loop.
+  files_.erase(file_it);
+  callback.Run(base::PLATFORM_FILE_OK);
+}
+
+void MemoryFileUtil::DoReadDirectory(
+    const FilePath& dir_path,
+    const FilePath& in_from,
+    const ReadDirectoryCallback& callback) {
+  FilePath from = in_from;
+  read_directory_buffer_.clear();
+
+  if (!FileExists(dir_path)) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+                 read_directory_buffer_, true);
+    return;
+  }
+
+  if (!IsDirectory(dir_path)) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY,
+                 read_directory_buffer_, true);
+    return;
+  }
+
+  if (from.empty())
+    from = dir_path.Append("/");
+
+  bool completed = true;
+
+  // Here we iterate over all paths starting with the prefix dir_path + '/'.
+  // It is not very efficient in case of a deep tree with many files in
+  // subdirectories. If ever we'll need efficiency from this implementation of
+  // FS, this should be changed. (It could be done by using lower_bound instead
+  // of ++ in case we've met a subdirectory path.)
+  for (ConstFileIterator it = files_.lower_bound(from);
+       it != files_.end() && dir_path.IsParent(it->first);
+       ++it) {
+    if (it->first.DirName() != dir_path)  // a file in subdirectory
+      continue;
+
+    if (read_directory_buffer_.size() == read_directory_buffer_size_) {
+      from = it->first;
+      completed = false;
+      break;
+    }
+
+    const FileEntry& file = it->second;
+    DirectoryEntry entry;
+    entry.name = it->first.BaseName().value();
+    entry.is_directory = file.is_directory;
+    entry.size = file.contents.size();
+    entry.last_modified_time = file.last_modified;
+
+    read_directory_buffer_.push_back(entry);
+  }
+
+  callback.Run(base::PLATFORM_FILE_OK, read_directory_buffer_, completed);
+
+  if (!completed) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&MemoryFileUtil::DoReadDirectory,
+                   base::Unretained(this), dir_path,
+                   from, callback));
+  }
+}
+
+void MemoryFileUtil::DoRead(
+    const FilePath& file_path,
+    int64 offset,
+    char* buffer,
+    int64 length,
+    const ReadWriteCallback& callback) {
+  FileIterator file_it = GetFile(file_path);
+  if (file_it == files_.end()) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND, 0);
+    return;
+  }
+
+  FileEntry& file = file_it->second;
+  if (file.is_directory) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_A_FILE, 0);
+    return;
+  }
+
+  const int64 file_size = static_cast<int64>(file.contents.size());
+  if (offset >= file_size) {
+    callback.Run(base::PLATFORM_FILE_ERROR_FAILED, 0);
+    return;
+  }
+
+  if (offset + length > file_size)
+    length = file.contents.size() - offset;
+
+  copy(file.contents.begin() + offset, file.contents.begin() + offset + length,
+       buffer);
+
+  callback.Run(base::PLATFORM_FILE_OK, length);
+}
+
+void MemoryFileUtil::DoWrite(
+    const FilePath& file_path,
+    int64 offset,
+    const char* data,
+    int64 length,
+    const ReadWriteCallback& callback) {
+  FileIterator file_it = GetFile(file_path);
+  if (file_it == files_.end()) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND, 0);
+    return;
+  }
+
+  FileEntry& file = file_it->second;
+  if (file.is_directory) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_A_FILE, 0);
+    return;
+  }
+
+  const int64 file_size = static_cast<int64>(file.contents.size());
+  if (offset > file_size) {
+    callback.Run(base::PLATFORM_FILE_ERROR_FAILED, 0);
+    return;
+  }
+
+  if (offset + length > file_size)
+    file.contents.resize(offset + length);
+
+  copy(data, data + length, file.contents.begin() + offset);
+  file.last_modified = base::Time::Now();
+
+  callback.Run(base::PLATFORM_FILE_OK, length);
+}
+
+}  // namespace file_api