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();
@@ skipping 133 matching lines @@
     // Permissions in isolated filesystems should be examined with
     // FileSystem permission.
     return fileapi::FILE_PERMISSION_USE_FILESYSTEM_PERMISSION;
   }
 
   // Also apply system's file permission by default.
   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) {
-    fileapi::RemoteFileSystemProxyInterface* remote_proxy =
-        GetRemoteProxy(url.filesystem_id());
-    if (!remote_proxy) {
-      *error_code = base::PLATFORM_FILE_ERROR_NOT_FOUND;
-      return NULL;
-    }
+  fileapi::RemoteFileSystemProxyInterface* remote_proxy = GetRemoteProxy(url);
+  if (remote_proxy)
     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) {
-    fileapi::RemoteFileSystemProxyInterface* remote_proxy =
-        GetRemoteProxy(url.filesystem_id());
-    if (!remote_proxy)
-      return NULL;
+  fileapi::RemoteFileSystemProxyInterface* remote_proxy = GetRemoteProxy(url);
+  if (remote_proxy)
     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) {
+    base::FilePath* virtual_path) const {
   return mount_points_->GetVirtualPath(filesystem_path, virtual_path) ||
          system_mount_points_->GetVirtualPath(filesystem_path, virtual_path);
 }
 
 fileapi::RemoteFileSystemProxyInterface* CrosMountPointProvider::GetRemoteProxy(
-    const std::string& mount_name) const {
+    const fileapi::FileSystemURL& url) const {
   fileapi::RemoteFileSystemProxyInterface* proxy =
-      mount_points_->GetRemoteFileSystemProxy(mount_name);
+      mount_points_->GetRemoteFileSystemProxyForPath(url.path());
   if (proxy)
     return proxy;
-  return system_mount_points_->GetRemoteFileSystemProxy(mount_name);
+  return system_mount_points_->GetRemoteFileSystemProxyForPath(url.path());
 }
 
 }  // namespace chromeos