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

webkit/chromeos/fileapi/memory_file_util.cc

+// 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 {
+
+// In-memory implementation of AsyncFileStream.
+class MemoryFileUtilAsyncFileStream : public AsyncFileStream {
+ public:
+  // |file_entry| is owened by MemoryFileUtil.
+  MemoryFileUtilAsyncFileStream(
+      MemoryFileUtil::FileEntry* file_entry, int flags)
+      : file_entry_(file_entry),
+        flags_(flags),
+        offset_(0) {
+  }
+
+  virtual void Read(char* buffer,
+                    int64 length,
+                    const ReadWriteCallback& callback) OVERRIDE {
+    if ((flags_ & base::PLATFORM_FILE_READ) == 0) {
+      callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, 0);
+      return;
+    }
+
+    // Shorten the length so the read does not overrun.
+    length = std::min(length, file_size() - offset_);
+
+    const std::string& contents = file_entry_->contents;
+    std::copy(contents.begin() + offset_,
+              contents.begin() + offset_ + length,
+              buffer);
+    offset_ += length;
+
+    callback.Run(base::PLATFORM_FILE_OK, length);
+  }
+
+  virtual void Write(const char* buffer,
+                     int64 length,
+                     const ReadWriteCallback& callback) OVERRIDE {
+    if ((flags_ & base::PLATFORM_FILE_WRITE) == 0) {
+      callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, 0);
+      return;
+    }
+
+    // Extend the contents if needed.
+    std::string* contents = &file_entry_->contents;
+    if (offset_ + length > file_size())
+      contents->resize(offset_ + length, 0);  // Fill with 0.
+
+    std::copy(buffer, buffer + length,
+              contents->begin() + offset_);
+    file_entry_->last_modified = base::Time::Now();
+    offset_ += length;
+
+    callback.Run(base::PLATFORM_FILE_OK, length);
+  }
+
+  virtual void Seek(int64 offset,
+                    const SeekCallback& callback) OVERRIDE {
+    if (offset > file_size()) {
+      // Unlike lseek(2), we don't allow an offset larger than the file
+      // size for this file implementation.
+      callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+      return;
+    }
+
+    offset_ = offset;
+    callback.Run(base::PLATFORM_FILE_OK);
+  }
+
+ private:
+  int64 file_size() const {
+    return static_cast<int64>(file_entry_->contents.size());
+  }
+
+  MemoryFileUtil::FileEntry* file_entry_;
+  const int flags_;
+  int64 offset_;
+};
+
+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::OpenVerifiedFile(
+    const FilePath& file_path,
+    int flags,
+    const OpenCallback& callback) {
+  FileIterator file_it = files_.find(file_path);
+  // The existence of the file is guranteed here.
+  DCHECK(file_it != files_.end());
+
+  FileEntry* file_entry = &file_it->second;
+  callback.Run(base::PLATFORM_FILE_OK,
+               new MemoryFileUtilAsyncFileStream(file_entry, flags));
+}
+
+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));
+}
+
+bool MemoryFileUtil::IsDirectory(const FilePath& file_path) {
+  ConstFileIterator it = files_.find(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 = files_.find(file_path);
+
+  if (file_it == files_.end()) {
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND, file_info);
+    return;
+  }
+  const 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 = files_.find(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 = files_.find(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 = files_.find(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 = files_.find(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));
+  }
+}
+
+}  // namespace file_api