Extract Drive related code to drive::MountPointProviderDelegate.

chrome/browser/chromeos/fileapi/cros_mount_point_provider.cc

 // Copyright 2013 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 "chrome/browser/chromeos/fileapi/cros_mount_point_provider.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
+#include "chrome/browser/chromeos/fileapi/cros_mount_point_provider_delegate.h"
 #include "chrome/browser/chromeos/fileapi/file_access_permissions.h"
-#include "chrome/browser/chromeos/fileapi/remote_file_stream_writer.h"
-#include "chrome/browser/chromeos/fileapi/remote_file_system_operation.h"
 #include "chromeos/dbus/cros_disks_client.h"
+#include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/async_file_util_adapter.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_stream_reader.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_task_runners.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/isolated_file_util.h"
@@ skipping 11 matching lines @@
 // static
 bool CrosMountPointProvider::CanHandleURL(const fileapi::FileSystemURL& url) {
   if (!url.is_valid())
     return false;
   return url.type() == fileapi::kFileSystemTypeNativeLocal ||
          url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal ||
          url.type() == fileapi::kFileSystemTypeDrive;
 }
 
 CrosMountPointProvider::CrosMountPointProvider(
+    CrosMountPointProviderDelegate* drive_delegate,
     scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy,
     scoped_refptr<fileapi::ExternalMountPoints> mount_points,
     fileapi::ExternalMountPoints* system_mount_points)
     : special_storage_policy_(special_storage_policy),
       file_access_permissions_(new FileAccessPermissions()),
       local_file_util_(new fileapi::AsyncFileUtilAdapter(
           new fileapi::IsolatedFileUtil())),
+      drive_delegate_(drive_delegate),
       mount_points_(mount_points),
       system_mount_points_(system_mount_points) {
 }
 
 CrosMountPointProvider::~CrosMountPointProvider() {
 }
 
 void CrosMountPointProvider::AddSystemMountPoints() {
   // RegisterFileSystem() is no-op if the mount point with the same name
   // already exists, hence it's safe to call without checking if a mount
@@ skipping 147 matching lines @@
 
 fileapi::FileSystemFileUtil* CrosMountPointProvider::GetFileUtil(
     fileapi::FileSystemType type) {
   DCHECK(type == fileapi::kFileSystemTypeNativeLocal ||
          type == fileapi::kFileSystemTypeRestrictedNativeLocal);
   return local_file_util_->sync_file_util();
 }
 
 fileapi::AsyncFileUtil* CrosMountPointProvider::GetAsyncFileUtil(
     fileapi::FileSystemType type) {
+  if (type == fileapi::kFileSystemTypeDrive)
+    return drive_delegate_->GetAsyncFileUtil(type);
+
   DCHECK(type == fileapi::kFileSystemTypeNativeLocal ||
          type == fileapi::kFileSystemTypeRestrictedNativeLocal);
   return local_file_util_.get();
 }
 
 fileapi::CopyOrMoveFileValidatorFactory*
 CrosMountPointProvider::GetCopyOrMoveFileValidatorFactory(
     fileapi::FileSystemType type, base::PlatformFileError* error_code) {
   DCHECK(error_code);
   *error_code = base::PLATFORM_FILE_OK;
   return NULL;
 }
 
 fileapi::FileSystemOperation* CrosMountPointProvider::CreateFileSystemOperation(
     const fileapi::FileSystemURL& url,
     fileapi::FileSystemContext* context,
     base::PlatformFileError* error_code) const {
   DCHECK(url.is_valid());
 
   if (!IsAccessAllowed(url)) {
     *error_code = base::PLATFORM_FILE_ERROR_SECURITY;
     return NULL;
   }
 
-  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;
-    }
-    return new RemoteFileSystemOperation(remote_proxy);
-  }
+  if (url.type() == fileapi::kFileSystemTypeDrive)
+    return drive_delegate_->CreateFileSystemOperation(url, context, error_code);
 
   DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal ||
          url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal);
   scoped_ptr<fileapi::FileSystemOperationContext> operation_context(
       new fileapi::FileSystemOperationContext(context));
   operation_context->set_root_path(GetFileSystemRootPath(url));
   return new fileapi::LocalFileSystemOperation(url, context,
                                                operation_context.Pass());
 }
 
 scoped_ptr<webkit_blob::FileStreamReader>
 CrosMountPointProvider::CreateFileStreamReader(
     const fileapi::FileSystemURL& url,
     int64 offset,
     const base::Time& expected_modification_time,
     fileapi::FileSystemContext* context) const {
   DCHECK(url.is_valid());
 
   if (!IsAccessAllowed(url))
     return scoped_ptr<webkit_blob::FileStreamReader>();
 
   if (url.type() == fileapi::kFileSystemTypeDrive) {
-    fileapi::RemoteFileSystemProxyInterface* remote_proxy =
-        GetRemoteProxy(url.filesystem_id());
-    if (!remote_proxy)
-      return scoped_ptr<webkit_blob::FileStreamReader>();
-    return remote_proxy->CreateFileStreamReader(
-        context->task_runners()->file_task_runner(),
-        url, offset, expected_modification_time);
+    return drive_delegate_->CreateFileStreamReader(
+        url, offset, expected_modification_time, context);
   }
 
   return scoped_ptr<webkit_blob::FileStreamReader>(
       new fileapi::FileSystemFileStreamReader(
           context, url, offset, expected_modification_time));
 }
 
 scoped_ptr<fileapi::FileStreamWriter>
 CrosMountPointProvider::CreateFileStreamWriter(
     const fileapi::FileSystemURL& url,
     int64 offset,
     fileapi::FileSystemContext* context) const {
   DCHECK(url.is_valid());
 
   if (!IsAccessAllowed(url))
     return scoped_ptr<fileapi::FileStreamWriter>();
 
-  if (url.type() == fileapi::kFileSystemTypeDrive) {
-    fileapi::RemoteFileSystemProxyInterface* remote_proxy =
-        GetRemoteProxy(url.filesystem_id());
-    if (!remote_proxy)
-      return scoped_ptr<fileapi::FileStreamWriter>();
-    return scoped_ptr<fileapi::FileStreamWriter>(
-        new RemoteFileStreamWriter(
-            remote_proxy, url, offset,
-            context->task_runners()->file_task_runner()));
-  }
+  if (url.type() == fileapi::kFileSystemTypeDrive)
+    return drive_delegate_->CreateFileStreamWriter(url, offset, context);
 
   if (url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal)
     return scoped_ptr<fileapi::FileStreamWriter>();
 
   DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal);
   return scoped_ptr<fileapi::FileStreamWriter>(
       new fileapi::LocalFileStreamWriter(
           context->task_runners()->file_task_runner(), url.path(), offset));
 }
 
 bool CrosMountPointProvider::GetVirtualPath(
     const base::FilePath& filesystem_path,
     base::FilePath* virtual_path) {
   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 {
-  fileapi::RemoteFileSystemProxyInterface* proxy =
-      mount_points_->GetRemoteFileSystemProxy(mount_name);
-  if (proxy)
-    return proxy;
-  return system_mount_points_->GetRemoteFileSystemProxy(mount_name);
-}
-
 base::FilePath CrosMountPointProvider::GetFileSystemRootPath(
     const fileapi::FileSystemURL& url) const {
   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();
 }
 
 }  // namespace chromeos