Fix filesystem API file_handlers to work for drive on ChromeOS.

webkit/chromeos/fileapi/cros_mount_point_provider.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/chromeos/fileapi/cros_mount_point_provider.h"
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 12 matching lines @@
 #include "webkit/fileapi/file_system_file_stream_reader.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/isolated_file_util.h"
 #include "webkit/fileapi/local_file_stream_writer.h"
 #include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/glue/webkit_glue.h"
 
+using fileapi::FileSystemURL;
+
 namespace {
 
 const char kChromeUIScheme[] = "chrome";
 
 }  // namespace
 
 namespace chromeos {
 
 // static
-bool CrosMountPointProvider::CanHandleURL(const fileapi::FileSystemURL& url) {
+bool CrosMountPointProvider::CanHandleURL(const FileSystemURL& url) {
   if (!url.is_valid())
     return false;
   return url.type() == fileapi::kFileSystemTypeNativeLocal ||
          url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal ||
          url.type() == fileapi::kFileSystemTypeDrive;
 }
 
 CrosMountPointProvider::CrosMountPointProvider(
     scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy,
     scoped_refptr<fileapi::ExternalMountPoints> mount_points,
@@ skipping 13 matching lines @@
     const GURL& origin_url,
     fileapi::FileSystemType type,
     bool create,
     const ValidateFileSystemCallback& callback) {
   DCHECK(fileapi::IsolatedContext::IsIsolatedType(type));
   // Nothing to validate for external filesystem.
   callback.Run(base::PLATFORM_FILE_OK);
 }
 
 base::FilePath CrosMountPointProvider::GetFileSystemRootPathOnFileThread(
-    const fileapi::FileSystemURL& url,
+    const FileSystemURL& url,
     bool create) {
   DCHECK(fileapi::IsolatedContext::IsIsolatedType(url.mount_type()));
   if (!url.is_valid())
     return base::FilePath();
 
   base::FilePath root_path;
   std::string mount_name = url.filesystem_id();
   if (!mount_points_->GetRegisteredPath(mount_name, &root_path) &&
       !system_mount_points_->GetRegisteredPath(mount_name, &root_path)) {
     return base::FilePath();
   }
 
   return root_path.DirName();
 }
 
-bool CrosMountPointProvider::IsAccessAllowed(
-    const fileapi::FileSystemURL& url) {
+bool CrosMountPointProvider::IsAccessAllowed(const FileSystemURL& url) {
   if (!url.is_valid())
     return false;
 
   // Permit access to mount points from internal WebUI.
   const GURL& origin_url = url.origin();
   if (origin_url.SchemeIs(kChromeUIScheme))
     return true;
 
   // No extra check is needed for isolated file systems.
   if (url.mount_type() == fileapi::kFileSystemTypeIsolated)
@@ skipping 96 matching lines @@
 }
 
 fileapi::AsyncFileUtil* CrosMountPointProvider::GetAsyncFileUtil(
     fileapi::FileSystemType type) {
   DCHECK(type == fileapi::kFileSystemTypeNativeLocal ||
          type == fileapi::kFileSystemTypeRestrictedNativeLocal);
   return local_file_util_.get();
 }
 
 fileapi::FilePermissionPolicy CrosMountPointProvider::GetPermissionPolicy(
-    const fileapi::FileSystemURL& url, int permissions) const {
+    const FileSystemURL& url, int permissions) const {
   if (url.mount_type() == fileapi::kFileSystemTypeIsolated) {
     // Permissions in isolated filesystems should be examined with
     // FileSystem permission.
     return fileapi::FILE_PERMISSION_USE_FILESYSTEM_PERMISSION;
   }
   return fileapi::FILE_PERMISSION_USE_FILE_PERMISSION;
 }
 
 fileapi::FileSystemOperation* CrosMountPointProvider::CreateFileSystemOperation(
-    const fileapi::FileSystemURL& url,
+    const FileSystemURL& url,
     fileapi::FileSystemContext* context,
     base::PlatformFileError* error_code) const {
   DCHECK(url.is_valid());
 
   if (url.type() == fileapi::kFileSystemTypeDrive) {
+    FileSystemURL external_url = GetAsExternalFileSystemURL(url);
     fileapi::RemoteFileSystemProxyInterface* remote_proxy =
-        GetRemoteProxy(url.filesystem_id());
+        GetRemoteProxy(external_url);
     if (!remote_proxy) {
       *error_code = base::PLATFORM_FILE_ERROR_NOT_FOUND;
       return NULL;
     }
     return new chromeos::RemoteFileSystemOperation(remote_proxy);
   }
 
   DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal ||
          url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal);
   scoped_ptr<fileapi::FileSystemOperationContext> operation_context(
       new fileapi::FileSystemOperationContext(context));
   return new fileapi::LocalFileSystemOperation(context,
                                                operation_context.Pass());
 }
 
 webkit_blob::FileStreamReader* CrosMountPointProvider::CreateFileStreamReader(
-    const fileapi::FileSystemURL& url,
+    const FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
     fileapi::FileSystemContext* context) const {
   // For now we return a generic Reader implementation which utilizes
   // CreateSnapshotFile internally (i.e. will download everything first).
   // TODO(satorux,zel): implement more efficient reader for remote cases.
   return new fileapi::FileSystemFileStreamReader(
       context, url, offset, expected_modification_time);
 }
 
 fileapi::FileStreamWriter* CrosMountPointProvider::CreateFileStreamWriter(
-    const fileapi::FileSystemURL& url,
+    const FileSystemURL& url,
     int64 offset,
     fileapi::FileSystemContext* context) const {
   DCHECK(url.is_valid());
 
   if (url.type() == fileapi::kFileSystemTypeDrive) {
+    FileSystemURL external_url = GetAsExternalFileSystemURL(url);
     fileapi::RemoteFileSystemProxyInterface* remote_proxy =
-        GetRemoteProxy(url.filesystem_id());
+        GetRemoteProxy(external_url);
     if (!remote_proxy)
       return NULL;
     return new fileapi::RemoteFileStreamWriter(remote_proxy, url, offset);
   }
 
   if (url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal)
     return NULL;
 
   DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal);
   return new fileapi::LocalFileStreamWriter(url.path(), offset);
 }
 
-bool CrosMountPointProvider::GetVirtualPath(const base::FilePath& filesystem_path,
-                                           base::FilePath* virtual_path) {
+bool CrosMountPointProvider::GetVirtualPath(
+    const base::FilePath& filesystem_path,
+    base::FilePath* virtual_path) const {
   return mount_points_->GetVirtualPath(filesystem_path, virtual_path) ||
          system_mount_points_->GetVirtualPath(filesystem_path, virtual_path);
 }
 
+fileapi::FileSystemURL CrosMountPointProvider::GetAsExternalFileSystemURL(
+    const fileapi::FileSystemURL& original) const {

[kinuko, 2013/02/14 17:09:48]

Do we need to specifically crack the isolated URL as 'external FS' URL?
Is it possible to just crack this URL at once in FSC::CrackFileSystemURL by
recursively apply URL crackers?  It'll need some tweaks in several modules but
if it's possible it sounds like lower modules can just get the final cracked URL
and do not need to worry about nested mount details.  (I might be missing some
devils in detail though)

[tbarzic, 2013/02/14 20:22:32]

this could be problematic because we use different policy for isolated and
external mount points when checking access permissions.

Hm, maybe we could add some AsExternalFileSystemURL method to FileSystemURL, but
that would probably mean more members in FileSystemURL (external_type_,
external_virtual_path_, external_mount_name_)

I'll think about this over the weekend..

+  if (original.mount_type() == fileapi::kFileSystemTypeExternal)
+    return original;
+
+  if (original.mount_type() == fileapi::kFileSystemTypeIsolated) {
+    base::FilePath external_path;
+    if (!GetVirtualPath(original.path(), &external_path))
+      return fileapi::FileSystemURL();
+
+    fileapi::FileSystemURL external = mount_points_->CreateCrackedFileSystemURL(
+        original.origin(), fileapi::kFileSystemTypeExternal, external_path);
+    if (external.is_valid() && external.type() == original.type())
+      return external;
+
+    external = system_mount_points_->CreateCrackedFileSystemURL(
+        original.origin(), fileapi::kFileSystemTypeExternal, external_path);
+    if (external.is_valid() && external.type() == original.type())
+      return external;
+  }
+
+  return fileapi::FileSystemURL();
+}
+
 fileapi::RemoteFileSystemProxyInterface* CrosMountPointProvider::GetRemoteProxy(
-    const std::string& mount_name) const {
+    const FileSystemURL& url) const {
+  if (!url.is_valid())
+    return NULL;
   fileapi::RemoteFileSystemProxyInterface* proxy =
-      mount_points_->GetRemoteFileSystemProxy(mount_name);
+      mount_points_->GetRemoteFileSystemProxy(url.filesystem_id());
   if (proxy)
     return proxy;
-  return system_mount_points_->GetRemoteFileSystemProxy(mount_name);
+  return system_mount_points_->GetRemoteFileSystemProxy(url.filesystem_id());
 }
 
 }  // namespace chromeos