Enables internal filesystem types via Isolated filesystems

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"
@@ skipping 154 matching lines @@
       new PathConverterEnumerator(
           NativeFileUtil::CreateFileEnumerator(
               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() {
+//-------------------------------------------------------------------------
+
+IsolatedFileUtil::IsolatedFileUtil() {}
+
+PlatformFileError IsolatedFileUtil::GetLocalFilePath(
+    FileSystemOperationContext* context,
+    const FileSystemURL& url,
+    FilePath* local_file_path) {
+  DCHECK(local_file_path);
+  std::string filesystem_id;
+  if (!IsolatedContext::GetInstance()->CrackIsolatedPath(
+          url.path(), &filesystem_id, NULL, local_file_path))
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  if (local_file_path->empty()) {
+    // Root direcory case, which should not be accessed.
+    return base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
+  }
+  return base::PLATFORM_FILE_OK;
 }
 
-PlatformFileError IsolatedFileUtil::CreateOrOpen(
-    FileSystemOperationContext* context,
-    const FileSystemURL& url, int file_flags,
-    PlatformFile* file_handle, bool* created) {
-  return base::PLATFORM_FILE_ERROR_SECURITY;
-}
+//-------------------------------------------------------------------------
 
-PlatformFileError IsolatedFileUtil::Close(
-    FileSystemOperationContext* context,
-    PlatformFile file_handle) {
-  // We don't allow open thus Close won't be called.
-  return base::PLATFORM_FILE_ERROR_SECURITY;
-}
+DraggedFileUtil::DraggedFileUtil() {}
 
-PlatformFileError IsolatedFileUtil::EnsureFileExists(
-    FileSystemOperationContext* context,
-    const FileSystemURL& url,
-    bool* created) {
-  return base::PLATFORM_FILE_ERROR_SECURITY;
-}
-
-PlatformFileError IsolatedFileUtil::CreateDirectory(
-    FileSystemOperationContext* context,
-    const FileSystemURL& url,
-    bool exclusive,
-    bool recursive) {
-  return base::PLATFORM_FILE_ERROR_SECURITY;
-}
-
-PlatformFileError IsolatedFileUtil::GetFileInfo(
+PlatformFileError DraggedFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     PlatformFileInfo* file_info,
     FilePath* platform_path) {
   DCHECK(file_info);
   std::string filesystem_id;
   FilePath cracked_path;
   if (!IsolatedContext::GetInstance()->CrackIsolatedPath(
           url.path(), &filesystem_id, NULL, &cracked_path))
     return base::PLATFORM_FILE_ERROR_SECURITY;
@@ skipping 13 matching lines @@
   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(
+DraggedFileUtil::CreateFileEnumerator(
     FileSystemOperationContext* context,
     const FileSystemURL& root,
     bool recursive) {
   std::string filesystem_id;
   FileInfo root_info;
   FilePath cracked_path;
   if (!IsolatedContext::GetInstance()->CrackIsolatedPath(
           root.path(), &filesystem_id, &root_info, &cracked_path))
     return NULL;
 
   FilePath virtual_base_path =
       IsolatedContext::GetInstance()->CreateVirtualRootPath(filesystem_id);
 
   if (!cracked_path.empty()) {
     return new PathConverterEnumerator(
         NativeFileUtil::CreateFileEnumerator(cracked_path, recursive),
         virtual_base_path.AppendASCII(root_info.name), root_info.path);
   }
 
   // Root path case.
   std::vector<FileInfo> toplevels;
-  IsolatedContext::GetInstance()->GetRegisteredFileInfo(
+  IsolatedContext::GetInstance()->GetDraggedFileInfo(
       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) {
-  if (GetPlatformPath(file_system_url, local_file_path))
-    return base::PLATFORM_FILE_OK;
-  return base::PLATFORM_FILE_ERROR_SECURITY;
-}
-
-PlatformFileError IsolatedFileUtil::Touch(
-    FileSystemOperationContext* context,
-    const FileSystemURL& url,
-    const base::Time& last_access_time,
-    const base::Time& last_modified_time) {
-  FilePath platform_path;
-  if (!GetPlatformPath(url, &platform_path) || platform_path.empty())
-    return base::PLATFORM_FILE_ERROR_SECURITY;
-  return NativeFileUtil::Touch(
-      platform_path, last_access_time, last_modified_time);
-}
-
-PlatformFileError IsolatedFileUtil::Truncate(
-    FileSystemOperationContext* context,
-    const FileSystemURL& url,
-    int64 length) {
-  FilePath platform_path;
-  if (!GetPlatformPath(url, &platform_path) || platform_path.empty())
-    return base::PLATFORM_FILE_ERROR_SECURITY;
-  return NativeFileUtil::Truncate(platform_path, length);
-}
-
-bool IsolatedFileUtil::PathExists(
+bool DraggedFileUtil::PathExists(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
   FilePath platform_path;
   if (!GetPlatformPath(url, &platform_path))
     return false;
   if (platform_path.empty()) {
     // The root directory case.
     return true;
   }
   return NativeFileUtil::PathExists(platform_path);
 }
 
-bool IsolatedFileUtil::DirectoryExists(
+bool DraggedFileUtil::DirectoryExists(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
   FilePath platform_path;
   if (!GetPlatformPath(url, &platform_path))
     return false;
   if (platform_path.empty()) {
     // The root directory case.
     return true;
   }
   return NativeFileUtil::DirectoryExists(platform_path);
 }
 
-bool IsolatedFileUtil::IsDirectoryEmpty(
+bool DraggedFileUtil::IsDirectoryEmpty(
     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<FileInfo> toplevels;
-    bool success = IsolatedContext::GetInstance()->GetRegisteredFileInfo(
+    bool success = IsolatedContext::GetInstance()->GetDraggedFileInfo(
         filesystem_id, &toplevels);
     DCHECK(success);
     return toplevels.empty();
   }
   return NativeFileUtil::IsDirectoryEmpty(platform_path);
 }
 
-PlatformFileError IsolatedFileUtil::CopyOrMoveFile(
-      FileSystemOperationContext* context,
-      const FileSystemURL& src_url,
-      const FileSystemURL& dest_url,
-      bool copy) {
-  return base::PLATFORM_FILE_ERROR_SECURITY;
-}
-
-PlatformFileError IsolatedFileUtil::CopyInForeignFile(
-      FileSystemOperationContext* context,
-      const FilePath& src_file_path,
-      const FileSystemURL& dest_url) {
-  return base::PLATFORM_FILE_ERROR_SECURITY;
-}
-
-PlatformFileError IsolatedFileUtil::DeleteFile(
-    FileSystemOperationContext* context,
-    const FileSystemURL& url) {
-  return base::PLATFORM_FILE_ERROR_SECURITY;
-}
-
-PlatformFileError IsolatedFileUtil::DeleteSingleDirectory(
-    FileSystemOperationContext* context,
-    const FileSystemURL& url) {
-  return base::PLATFORM_FILE_ERROR_SECURITY;
-}
-
-scoped_refptr<webkit_blob::ShareableFileReference>
-IsolatedFileUtil::CreateSnapshotFile(
-    FileSystemOperationContext* context,
-    const FileSystemURL& url,
-    base::PlatformFileError* result,
-    base::PlatformFileInfo* file_info,
-    FilePath* platform_path) {
-  DCHECK(result);
-  *result = GetFileInfo(context, url, file_info, platform_path);
-  return NULL;
-}
-
-bool IsolatedFileUtil::GetPlatformPath(const FileSystemURL& url,
+bool DraggedFileUtil::GetPlatformPath(const FileSystemURL& url,
                                        FilePath* platform_path) const {
   DCHECK(platform_path);
   std::string filesystem_id;
   if (!IsolatedContext::GetInstance()->CrackIsolatedPath(
           url.path(), &filesystem_id, NULL, platform_path))
     return false;
   return true;
 }
 
 }  // namespace