Make isolated file system works for a device root (e.g. X:\\)

webkit/fileapi/isolated_file_util.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/fileapi/isolated_file_util.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/native_file_util.h"
 
 using base::PlatformFileError;
 using base::PlatformFileInfo;
 
 namespace fileapi {
 
+typedef IsolatedContext::FileInfo FileInfo;
+
 namespace {
 
-// Simply enumerate each path from a given paths set.
+// Simply enumerate each path from a given fileinfo set.
 // Used to enumerate top-level paths of an isolated filesystem.
 class SetFileEnumerator : public FileSystemFileUtil::AbstractFileEnumerator {
  public:
-  SetFileEnumerator(const std::vector<FilePath>& paths,
+  SetFileEnumerator(const std::vector<FileInfo>& files,
                     const FilePath& root)
-      : paths_(paths),
+      : files_(files),
         root_(root) {
-    path_iter_ = paths_.begin();
+    file_iter_ = files_.begin();
   }
   virtual ~SetFileEnumerator() {}
 
   // AbstractFileEnumerator overrides.
   virtual FilePath Next() OVERRIDE {
-    if (path_iter_ == paths_.end())
+    if (file_iter_ == files_.end())
       return FilePath();
-    FilePath platform_path = *path_iter_++;
-    NativeFileUtil::GetFileInfo(platform_path, &file_info_);
-    return root_.Append(platform_path.BaseName());
+    FilePath platform_file = (file_iter_++)->path;
+    NativeFileUtil::GetFileInfo(platform_file, &file_info_);
+    return root_.Append(platform_file.BaseName());
   }
   virtual int64 Size() OVERRIDE { return file_info_.size; }
   virtual bool IsDirectory() OVERRIDE { return file_info_.is_directory; }
   virtual base::Time LastModifiedTime() OVERRIDE {
     return file_info_.last_modified;
   }
 
  private:
-  std::vector<FilePath> paths_;
-  std::vector<FilePath>::const_iterator path_iter_;
+  std::vector<FileInfo> files_;
+  std::vector<FileInfo>::const_iterator file_iter_;
   FilePath root_;
   base::PlatformFileInfo file_info_;
 };
 
 // A wrapper file enumerator which returns a virtual path of the path returned
 // by the wrapped enumerator.
 //
 // A virtual path is constructed as following:
 //   virtual_path = |virtual_base_path| + relative-path-to-|platform_base_path|
 //
 // Where |virtual_base_path| is in our case the virtual top-level directory
 // that looks like: '/<filesystem_id>'.
 //
 // Example:
-//    Suppose virtual_base_path is: '/CAFEBABE',
-//           platform_base_path is: '/full/path/to/example/dir', and
-//   a path returned by wrapped_is: '/full/path/to/example/dir/a/b/c',
-//             Next() would return: '/CAFEBABE/dir/a/b/c'.
+//     Suppose virtual_base_path is: '/CAFEBABE/dir',
+//            platform_base_path is: '/full/path/to/example/dir', and
+//   a path returned by wrapped_ is: '/full/path/to/example/dir/a/b/c',
+//              Next() would return: '/CAFEBABE/dir/a/b/c'.
 //
 class PathConverterEnumerator
     : public FileSystemFileUtil::AbstractFileEnumerator {
  public:
   PathConverterEnumerator(
       FileSystemFileUtil::AbstractFileEnumerator* wrapped,
       const FilePath& virtual_base_path,
       const FilePath& platform_base_path)
       : wrapped_(wrapped),
         virtual_base_path_(virtual_base_path),
         platform_base_path_(platform_base_path) {}
   virtual ~PathConverterEnumerator() {}
 
   // AbstractFileEnumerator overrides.
   virtual FilePath Next() OVERRIDE {
     DCHECK(wrapped_.get());
     FilePath path = wrapped_->Next();
     // Don't return symlinks in subdirectories.
     while (!path.empty() && file_util::IsLink(path))
       path = wrapped_->Next();
     if (path.empty())
       return path;
     FilePath virtual_path = virtual_base_path_;
-    platform_base_path_.DirName().AppendRelativePath(path, &virtual_path);
+    platform_base_path_.AppendRelativePath(path, &virtual_path);
     return virtual_path;
   }
   virtual int64 Size() OVERRIDE { return wrapped_->Size(); }
   virtual bool IsDirectory() OVERRIDE { return wrapped_->IsDirectory(); }
   virtual base::Time LastModifiedTime() OVERRIDE {
     return wrapped_->LastModifiedTime();
   }
 
  private:
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> wrapped_;
   FilePath virtual_base_path_;
   FilePath platform_base_path_;
 };
 
 // Recursively enumerate each path from a given paths set.
 class RecursiveSetFileEnumerator
     : public FileSystemFileUtil::AbstractFileEnumerator {
  public:
   RecursiveSetFileEnumerator(const FilePath& virtual_base_path,
-                             const std::vector<FilePath>& paths,
+                             const std::vector<FileInfo>& files,
                              const FilePath& root)
       : virtual_base_path_(virtual_base_path),
-        paths_(paths),
+        files_(files),
         root_(root) {
-    path_iter_ = paths_.begin();
-    current_enumerator_.reset(
-        new SetFileEnumerator(paths, root));
+    file_iter_ = files_.begin();
+    current_enumerator_.reset(new SetFileEnumerator(files, root));
   }
   virtual ~RecursiveSetFileEnumerator() {}
 
   // AbstractFileEnumerator overrides.
   virtual FilePath Next() OVERRIDE;
   virtual int64 Size() OVERRIDE {
     DCHECK(current_enumerator_.get());
     return current_enumerator_->Size();
   }
   virtual bool IsDirectory() OVERRIDE {
     DCHECK(current_enumerator_.get());
     return current_enumerator_->IsDirectory();
   }
   virtual base::Time LastModifiedTime() OVERRIDE {
     DCHECK(current_enumerator_.get());
     return current_enumerator_->LastModifiedTime();
   }
 
  private:
   FilePath virtual_base_path_;
-  std::vector<FilePath> paths_;
-  std::vector<FilePath>::iterator path_iter_;
+  std::vector<FileInfo> files_;
+  std::vector<FileInfo>::iterator file_iter_;
   base::PlatformFileInfo file_info_;
   FilePath root_;
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> current_enumerator_;
 };
 
 FilePath RecursiveSetFileEnumerator::Next() {
   if (current_enumerator_.get()) {
     FilePath path = current_enumerator_->Next();
     if (!path.empty())
       return path;
   }
 
   // We reached the end.
-  if (path_iter_ == paths_.end())
+  if (file_iter_ == files_.end())
     return FilePath();
 
   // Enumerates subdirectories of the next path.
-  FilePath next_path = *path_iter_++;
+  FileInfo& next_file = *file_iter_++;
   current_enumerator_.reset(
       new PathConverterEnumerator(
           NativeFileUtil::CreateFileEnumerator(
-              next_path, true /* recursive */),
-          virtual_base_path_, next_path));
+              next_file.path, true /* recursive */),
+          virtual_base_path_.AppendASCII(next_file.name), next_file.path));
   DCHECK(current_enumerator_.get());
   return current_enumerator_->Next();
 }
 
 }  // namespace
 
 IsolatedFileUtil::IsolatedFileUtil() {
 }
 
 PlatformFileError IsolatedFileUtil::CreateOrOpen(
@@ skipping 25 matching lines @@
   return base::PLATFORM_FILE_ERROR_SECURITY;
 }
 
 PlatformFileError IsolatedFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     PlatformFileInfo* file_info,
     FilePath* platform_path) {
   DCHECK(file_info);
   std::string filesystem_id;
-  FilePath root_unused, cracked_path;
+  FilePath cracked_path;
   if (!IsolatedContext::GetInstance()->CrackIsolatedPath(
-          url.path(), &filesystem_id, &root_unused, &cracked_path))
+          url.path(), &filesystem_id, NULL, &cracked_path))
     return base::PLATFORM_FILE_ERROR_SECURITY;
   if (cracked_path.empty()) {
     // The root directory case.
     // For now we leave three time fields (modified/accessed/creation time)
     // NULL as it is not really clear what to be set for this virtual directory.
     // TODO(kinuko): Maybe we want to set the time when this filesystem is
     // created (i.e. when the files/directories are dropped).
     file_info->is_directory = true;
     file_info->is_symbolic_link = false;
     file_info->size = 0;
     return base::PLATFORM_FILE_OK;
   }
   base::PlatformFileError error =
       NativeFileUtil::GetFileInfo(cracked_path, file_info);
   if (file_util::IsLink(cracked_path) && !FilePath().IsParent(cracked_path)) {
     // Don't follow symlinks unless it's the one that are selected by the user.
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   }
   if (error == base::PLATFORM_FILE_OK)
     *platform_path = cracked_path;
   return error;
 }
 
 FileSystemFileUtil::AbstractFileEnumerator*
 IsolatedFileUtil::CreateFileEnumerator(
     FileSystemOperationContext* context,
     const FileSystemURL& root,
     bool recursive) {
   std::string filesystem_id;
-  FilePath root_path, cracked_path;
+  FileInfo root_info;
+  FilePath cracked_path;
   if (!IsolatedContext::GetInstance()->CrackIsolatedPath(
-          root.path(), &filesystem_id, &root_path, &cracked_path))
+          root.path(), &filesystem_id, &root_info, &cracked_path))
     return NULL;
 
   FilePath virtual_base_path =
-      IsolatedContext::GetInstance()->CreateVirtualPath(filesystem_id,
-                                                        FilePath());
+      IsolatedContext::GetInstance()->CreateVirtualRootPath(filesystem_id);
 
   if (!cracked_path.empty()) {
     return new PathConverterEnumerator(
         NativeFileUtil::CreateFileEnumerator(cracked_path, recursive),
-        virtual_base_path, root_path);
+        virtual_base_path.AppendASCII(root_info.name), root_info.path);
   }
 
   // Root path case.
-  std::vector<FilePath> toplevels;
-  IsolatedContext::GetInstance()->GetTopLevelPaths(filesystem_id, &toplevels);
+  std::vector<FileInfo> toplevels;
+  IsolatedContext::GetInstance()->GetRegisteredFileInfo(
+      filesystem_id, &toplevels);
   if (!recursive)
     return new SetFileEnumerator(toplevels, root.path());
   return new RecursiveSetFileEnumerator(
       virtual_base_path, toplevels, root.path());
 }
 
 PlatformFileError IsolatedFileUtil::GetLocalFilePath(
     FileSystemOperationContext* context,
     const FileSystemURL& file_system_url,
     FilePath* local_file_path) {
@@ skipping 54 matching lines @@
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
   std::string filesystem_id;
   FilePath platform_path;
   if (!IsolatedContext::GetInstance()->CrackIsolatedPath(
           url.path(), &filesystem_id,
           NULL, &platform_path))
     return false;
   if (platform_path.empty()) {
     // The root directory case.
-    std::vector<FilePath> toplevels;
-    bool success = IsolatedContext::GetInstance()->GetTopLevelPaths(
+    std::vector<FileInfo> toplevels;
+    bool success = IsolatedContext::GetInstance()->GetRegisteredFileInfo(
         filesystem_id, &toplevels);
     DCHECK(success);
     return toplevels.empty();
   }
   return NativeFileUtil::IsDirectoryEmpty(platform_path);
 }
 
 PlatformFileError IsolatedFileUtil::CopyOrMoveFile(
       FileSystemOperationContext* context,
       const FileSystemURL& src_url,
@@ skipping 18 matching lines @@
 PlatformFileError IsolatedFileUtil::DeleteSingleDirectory(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
   return base::PLATFORM_FILE_ERROR_SECURITY;
 }
 
 bool IsolatedFileUtil::GetPlatformPath(const FileSystemURL& url,
                                        FilePath* platform_path) const {
   DCHECK(platform_path);
   std::string filesystem_id;
-  FilePath root_path;
   if (!IsolatedContext::GetInstance()->CrackIsolatedPath(
-          url.path(), &filesystem_id, &root_path, platform_path))
+          url.path(), &filesystem_id, NULL, platform_path))
     return false;
   return true;
 }
 
 }  // namespace