Add a filesystem type for DriveFS.

For DriveFS, most operations are handled as native file operations.
However, some operations require special-casing; for those we need a
custom filesystem implementation to override those implementations.

Bug: 874314
Change-Id: I91fffdfb260d6dc53241eed13b734f2df8354f8a
Reviewed-on: https://chromium-review.googlesource.com/1180829
Commit-Queue: Sam McNally <sammc@chromium.org>
Reviewed-by: Naoki Fukino <fukino@chromium.org>
Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Cr-Commit-Position: refs/heads/master@{#584626}

chrome/browser/chrome_content_browser_client.cc

@@ -314,6 +314,7 @@
 #include "chrome/browser/chromeos/chrome_browser_main_chromeos.h"
 #include "chrome/browser/chromeos/chrome_content_browser_client_chromeos_part.h"
 #include "chrome/browser/chromeos/chrome_service_name.h"
+#include "chrome/browser/chromeos/drive/fileapi/drivefs_file_system_backend_delegate.h"
 #include "chrome/browser/chromeos/drive/fileapi/file_system_backend_delegate.h"
 #include "chrome/browser/chromeos/file_manager/app_id.h"
 #include "chrome/browser/chromeos/file_system_provider/fileapi/backend_delegate.h"
@@ -3334,6 +3335,7 @@ void ChromeContentBrowserClient::GetAdditionalFileSystemBackends(
           storage_partition_path),
       std::make_unique<arc::ArcContentFileSystemBackendDelegate>(),
       std::make_unique<arc::ArcDocumentsProviderBackendDelegate>(),
+      std::make_unique<drive::DriveFsFileSystemBackendDelegate>(),
       external_mount_points, storage::ExternalMountPoints::GetSystemInstance());
   backend->AddSystemMountPoints();
   DCHECK(backend->CanHandleType(storage::kFileSystemTypeExternal));

chrome/browser/chromeos/BUILD.gn

@@ -629,6 +629,10 @@ source_set("chromeos") {
     "drive/file_task_executor.h",
     "drive/fileapi/async_file_util.cc",
     "drive/fileapi/async_file_util.h",
+    "drive/fileapi/drivefs_async_file_util.cc",
+    "drive/fileapi/drivefs_async_file_util.h",
+    "drive/fileapi/drivefs_file_system_backend_delegate.cc",
+    "drive/fileapi/drivefs_file_system_backend_delegate.h",
     "drive/fileapi/file_system_backend_delegate.cc",
     "drive/fileapi/file_system_backend_delegate.h",
     "drive/fileapi/fileapi_worker.cc",

chrome/browser/chromeos/drive/drive_integration_service.cc

@@ -676,7 +676,7 @@ void DriveIntegrationService::AddDriveMountPointAfterMounted() {
 
   bool success = mount_points->RegisterFileSystem(
       mount_point_name_,
-      drivefs_holder_ ? storage::kFileSystemTypeNativeLocal
+      drivefs_holder_ ? storage::kFileSystemTypeDriveFs
                       : storage::kFileSystemTypeDrive,
       storage::FileSystemMountOption(), drive_mount_point);
 

chrome/browser/chromeos/drive/fileapi/drivefs_async_file_util.cc

+// Copyright 2018 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/drive/fileapi/drivefs_async_file_util.h"
+
+#include "storage/browser/fileapi/local_file_util.h"
+
+namespace drive {
+namespace internal {
+
+DriveFsAsyncFileUtil::DriveFsAsyncFileUtil()
+    : AsyncFileUtilAdapter(new storage::LocalFileUtil) {}
+
+DriveFsAsyncFileUtil::~DriveFsAsyncFileUtil() = default;
+
+}  // namespace internal
+}  // namespace drive

chrome/browser/chromeos/drive/fileapi/drivefs_async_file_util.h

+// Copyright 2018 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_DRIVE_FILEAPI_DRIVEFS_ASYNC_FILE_UTIL_H_
+#define CHROME_BROWSER_CHROMEOS_DRIVE_FILEAPI_DRIVEFS_ASYNC_FILE_UTIL_H_
+
+#include "base/macros.h"
+#include "storage/browser/fileapi/async_file_util_adapter.h"
+
+namespace drive {
+namespace internal {
+
+// The implementation of storage::AsyncFileUtil for DriveFS File System. This
+// forwards to a AsyncFileUtil for native files by default.
+class DriveFsAsyncFileUtil : public storage::AsyncFileUtilAdapter {
+ public:
+  DriveFsAsyncFileUtil();
+  ~DriveFsAsyncFileUtil() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DriveFsAsyncFileUtil);
+};
+
+}  // namespace internal
+}  // namespace drive
+
+#endif  // CHROME_BROWSER_CHROMEOS_DRIVE_FILEAPI_DRIVEFS_ASYNC_FILE_UTIL_H_

chrome/browser/chromeos/drive/fileapi/drivefs_file_system_backend_delegate.cc

+// Copyright 2018 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/drive/fileapi/drivefs_file_system_backend_delegate.h"
+
+#include "chrome/browser/chromeos/drive/fileapi/drivefs_async_file_util.h"
+#include "content/public/browser/browser_thread.h"
+#include "storage/browser/fileapi/async_file_util.h"
+#include "storage/browser/fileapi/file_stream_reader.h"
+#include "storage/browser/fileapi/file_stream_writer.h"
+
+namespace drive {
+
+DriveFsFileSystemBackendDelegate::DriveFsFileSystemBackendDelegate()
+    : async_file_util_(std::make_unique<internal::DriveFsAsyncFileUtil>()) {}
+
+DriveFsFileSystemBackendDelegate::~DriveFsFileSystemBackendDelegate() = default;
+
+storage::AsyncFileUtil* DriveFsFileSystemBackendDelegate::GetAsyncFileUtil(
+    storage::FileSystemType type) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK_EQ(storage::kFileSystemTypeDriveFs, type);
+  return async_file_util_.get();
+}
+
+std::unique_ptr<storage::FileStreamReader>
+DriveFsFileSystemBackendDelegate::CreateFileStreamReader(
+    const storage::FileSystemURL& url,
+    int64_t offset,
+    int64_t max_bytes_to_read,
+    const base::Time& expected_modification_time,
+    storage::FileSystemContext* context) {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+std::unique_ptr<storage::FileStreamWriter>
+DriveFsFileSystemBackendDelegate::CreateFileStreamWriter(
+    const storage::FileSystemURL& url,
+    int64_t offset,
+    storage::FileSystemContext* context) {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+storage::WatcherManager* DriveFsFileSystemBackendDelegate::GetWatcherManager(
+    storage::FileSystemType type) {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+void DriveFsFileSystemBackendDelegate::GetRedirectURLForContents(
+    const storage::FileSystemURL& url,
+    const storage::URLCallback& callback) {
+  NOTIMPLEMENTED();
+}
+
+}  // namespace drive

chrome/browser/chromeos/drive/fileapi/drivefs_file_system_backend_delegate.h

+// Copyright 2018 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_DRIVE_FILEAPI_DRIVEFS_FILE_SYSTEM_BACKEND_DELEGATE_H_
+#define CHROME_BROWSER_CHROMEOS_DRIVE_FILEAPI_DRIVEFS_FILE_SYSTEM_BACKEND_DELEGATE_H_
+
+#include <stdint.h>
+
+#include <memory>
+
+#include "base/macros.h"
+#include "chrome/browser/chromeos/fileapi/file_system_backend_delegate.h"
+
+namespace storage {
+class AsyncFileUtil;
+class FileSystemContext;
+class FileStreamReader;
+class FileSystemURL;
+class FileStreamWriter;
+class WatcherManager;
+}  // namespace storage
+
+namespace drive {
+
+// Delegate implementation of the some methods in chromeos::FileSystemBackend
+// for Drive file system.
+class DriveFsFileSystemBackendDelegate
+    : public chromeos::FileSystemBackendDelegate {
+ public:
+  DriveFsFileSystemBackendDelegate();
+  ~DriveFsFileSystemBackendDelegate() override;
+
+  // FileSystemBackend::Delegate overrides.
+  storage::AsyncFileUtil* GetAsyncFileUtil(
+      storage::FileSystemType type) override;
+  std::unique_ptr<storage::FileStreamReader> CreateFileStreamReader(
+      const storage::FileSystemURL& url,
+      int64_t offset,
+      int64_t max_bytes_to_read,
+      const base::Time& expected_modification_time,
+      storage::FileSystemContext* context) override;
+  std::unique_ptr<storage::FileStreamWriter> CreateFileStreamWriter(
+      const storage::FileSystemURL& url,
+      int64_t offset,
+      storage::FileSystemContext* context) override;
+  storage::WatcherManager* GetWatcherManager(
+      storage::FileSystemType type) override;
+  void GetRedirectURLForContents(const storage::FileSystemURL& url,
+                                 const storage::URLCallback& callback) override;
+
+ private:
+  std::unique_ptr<storage::AsyncFileUtil> async_file_util_;
+
+  DISALLOW_COPY_AND_ASSIGN(DriveFsFileSystemBackendDelegate);
+};
+
+}  // namespace drive
+
+#endif  // CHROME_BROWSER_CHROMEOS_DRIVE_FILEAPI_DRIVEFS_FILE_SYSTEM_BACKEND_DELEGATE_H_

chrome/browser/chromeos/extensions/file_manager/private_api_drive.cc

@@ -838,7 +838,7 @@ bool FileManagerPrivateInternalGetEntryPropertiesFunction::RunAsync() {
                            CompleteGetEntryProperties,
                        this, i, file_system_url));
         break;
-      case storage::kFileSystemTypeNativeLocal:
+      case storage::kFileSystemTypeDriveFs:
         SingleEntryPropertiesGetterForDriveFs::Start(
             file_system_url.path(),
             names_as_set.count(
@@ -903,7 +903,7 @@ bool FileManagerPrivateInternalPinDriveFileFunction::RunAsync() {
     case storage::kFileSystemTypeDrive:
       return RunAsyncForDrive(url, params->pin);
 
-    case storage::kFileSystemTypeNativeLocal:
+    case storage::kFileSystemTypeDriveFs:
       return RunAsyncForDriveFs(file_system_url, params->pin);
 
     default:
@@ -1452,7 +1452,7 @@ bool FileManagerPrivateInternalGetDownloadUrlFunction::RunAsync() {
   switch (file_system_url.type()) {
     case storage::kFileSystemTypeDrive:
       return RunAsyncForDrive(url);
-    case storage::kFileSystemTypeNativeLocal:
+    case storage::kFileSystemTypeDriveFs:
       return RunAsyncForDriveFs(file_system_url);
     default:
       return false;

chrome/browser/chromeos/fileapi/file_system_backend.cc

@@ -53,7 +53,8 @@ bool FileSystemBackend::CanHandleURL(const storage::FileSystemURL& url) {
          url.type() == storage::kFileSystemTypeProvided ||
          url.type() == storage::kFileSystemTypeDeviceMediaAsFileStorage ||
          url.type() == storage::kFileSystemTypeArcContent ||
-         url.type() == storage::kFileSystemTypeArcDocumentsProvider;
+         url.type() == storage::kFileSystemTypeArcDocumentsProvider ||
+         url.type() == storage::kFileSystemTypeDriveFs;
 }
 
 FileSystemBackend::FileSystemBackend(
@@ -62,6 +63,7 @@ FileSystemBackend::FileSystemBackend(
     std::unique_ptr<FileSystemBackendDelegate> mtp_delegate,
     std::unique_ptr<FileSystemBackendDelegate> arc_content_delegate,
     std::unique_ptr<FileSystemBackendDelegate> arc_documents_provider_delegate,
+    std::unique_ptr<FileSystemBackendDelegate> drivefs_delegate,
     scoped_refptr<storage::ExternalMountPoints> mount_points,
     storage::ExternalMountPoints* system_mount_points)
     : file_access_permissions_(new FileAccessPermissions()),
@@ -72,6 +74,7 @@ FileSystemBackend::FileSystemBackend(
       arc_content_delegate_(std::move(arc_content_delegate)),
       arc_documents_provider_delegate_(
           std::move(arc_documents_provider_delegate)),
+      drivefs_delegate_(std::move(drivefs_delegate)),
       mount_points_(mount_points),
       system_mount_points_(system_mount_points) {}
 
@@ -109,6 +112,7 @@ bool FileSystemBackend::CanHandleType(storage::FileSystemType type) const {
     case storage::kFileSystemTypeProvided:
     case storage::kFileSystemTypeArcContent:
     case storage::kFileSystemTypeArcDocumentsProvider:
+    case storage::kFileSystemTypeDriveFs:
       return true;
     default:
       return false;
@@ -285,6 +289,8 @@ storage::AsyncFileUtil* FileSystemBackend::GetAsyncFileUtil(
       return arc_content_delegate_->GetAsyncFileUtil(type);
     case storage::kFileSystemTypeArcDocumentsProvider:
       return arc_documents_provider_delegate_->GetAsyncFileUtil(type);
+    case storage::kFileSystemTypeDriveFs:
+      return drivefs_delegate_->GetAsyncFileUtil(type);
     default:
       NOTREACHED();
   }
@@ -342,7 +348,8 @@ storage::FileSystemOperation* FileSystemBackend::CreateFileSystemOperation(
          url.type() == storage::kFileSystemTypeDrive ||
          url.type() == storage::kFileSystemTypeProvided ||
          url.type() == storage::kFileSystemTypeArcContent ||
-         url.type() == storage::kFileSystemTypeArcDocumentsProvider);
+         url.type() == storage::kFileSystemTypeArcDocumentsProvider ||
+         url.type() == storage::kFileSystemTypeDriveFs);
   return storage::FileSystemOperation::Create(
       url, context,
       std::make_unique<storage::FileSystemOperationContext>(context));
@@ -368,6 +375,7 @@ bool FileSystemBackend::HasInplaceCopyImplementation(
     case storage::kFileSystemTypeRestrictedNativeLocal:
     case storage::kFileSystemTypeArcContent:
     case storage::kFileSystemTypeArcDocumentsProvider:
+    case storage::kFileSystemTypeDriveFs:
       return false;
     default:
       NOTREACHED();
@@ -396,6 +404,7 @@ FileSystemBackend::CreateFileStreamReader(
           url, offset, max_bytes_to_read, expected_modification_time, context);
     case storage::kFileSystemTypeNativeLocal:
     case storage::kFileSystemTypeRestrictedNativeLocal:
+    case storage::kFileSystemTypeDriveFs:
       return std::unique_ptr<storage::FileStreamReader>(
           storage::FileStreamReader::CreateForFileSystemFile(
               context, url, offset, expected_modification_time));
@@ -431,6 +440,7 @@ FileSystemBackend::CreateFileStreamWriter(
       return file_system_provider_delegate_->CreateFileStreamWriter(
           url, offset, context);
     case storage::kFileSystemTypeNativeLocal:
+    case storage::kFileSystemTypeDriveFs:
       return std::unique_ptr<storage::FileStreamWriter>(
           storage::FileStreamWriter::CreateForLocalFile(
               context->default_file_task_runner(), url.path(), offset,
@@ -477,6 +487,7 @@ void FileSystemBackend::GetRedirectURLForContents(
     case storage::kFileSystemTypeRestrictedNativeLocal:
     case storage::kFileSystemTypeArcContent:
     case storage::kFileSystemTypeArcDocumentsProvider:
+    case storage::kFileSystemTypeDriveFs:
       callback.Run(GURL());
       return;
     default:

chrome/browser/chromeos/fileapi/file_system_backend.h

@@ -75,6 +75,7 @@ class FileSystemBackend : public storage::ExternalFileSystemBackend {
       std::unique_ptr<FileSystemBackendDelegate> arc_content_delegate,
       std::unique_ptr<FileSystemBackendDelegate>
           arc_documents_provider_delegate,
+      std::unique_ptr<FileSystemBackendDelegate> drivefs_delegate,
       scoped_refptr<storage::ExternalMountPoints> mount_points,
       storage::ExternalMountPoints* system_mount_points);
   ~FileSystemBackend() override;
@@ -160,6 +161,9 @@ class FileSystemBackend : public storage::ExternalFileSystemBackend {
   // The delegate instance for the ARC documents provider related operations.
   std::unique_ptr<FileSystemBackendDelegate> arc_documents_provider_delegate_;
 
+  // The delegate instance for the DriveFS file system related operations.
+  std::unique_ptr<FileSystemBackendDelegate> drivefs_delegate_;
+
   // Mount points specific to the owning context (i.e. per-profile mount
   // points).
   //

chrome/browser/chromeos/fileapi/file_system_backend_unittest.cc

@@ -47,6 +47,7 @@ TEST(ChromeOSFileSystemBackendTest, DefaultMountPoints) {
       nullptr,  // mtp_delegate
       nullptr,  // arc_content_delegate
       nullptr,  // arc_documents_provider_delegate
+      nullptr,  // drivefs_delegate
       mount_points.get(), storage::ExternalMountPoints::GetSystemInstance());
   backend.AddSystemMountPoints();
   std::vector<base::FilePath> root_dirs = backend.GetRootDirectories();
@@ -75,6 +76,7 @@ TEST(ChromeOSFileSystemBackendTest, GetRootDirectories) {
       nullptr,  // mtp_delegate
       nullptr,  // arc_content_delegate
       nullptr,  // arc_documents_provider_delegate
+      nullptr,  // drivefs_delegate
       mount_points.get(), system_mount_points.get());
 
   const size_t initial_root_dirs_size = backend.GetRootDirectories().size();
@@ -121,6 +123,7 @@ TEST(ChromeOSFileSystemBackendTest, AccessPermissions) {
       nullptr,  // mtp_delegate
       nullptr,  // arc_content_delegate
       nullptr,  // arc_documents_provider_delegate
+      nullptr,  // drivefs_delegate
       mount_points.get(), system_mount_points.get());
 
   std::string extension("ddammdhioacbehjngdmkjcjbnfginlla");
@@ -191,6 +194,7 @@ TEST(ChromeOSFileSystemBackendTest, GetVirtualPathConflictWithSystemPoints) {
       nullptr,  // mtp_delegate
       nullptr,  // arc_content_delegate
       nullptr,  // arc_documents_provider_delegate
+      nullptr,  // drivefs_delegate
       mount_points.get(), system_mount_points.get());
 
   const storage::FileSystemType type = storage::kFileSystemTypeNativeLocal;

chrome/browser/platform_util_unittest.cc

@@ -58,7 +58,8 @@ class PlatformUtilTestContentBrowserClient : public ChromeContentBrowserClient {
     // New FileSystemBackend that uses our MockSpecialStoragePolicy.
     additional_backends->push_back(
         std::make_unique<chromeos::FileSystemBackend>(
-            nullptr, nullptr, nullptr, nullptr, nullptr, external_mount_points,
+            nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+            external_mount_points,
             storage::ExternalMountPoints::GetSystemInstance()));
   }
 };

storage/browser/fileapi/file_system_context.cc

@@ -100,6 +100,7 @@ int FileSystemContext::GetPermissionPolicy(FileSystemType type) {
     case kFileSystemTypeCloudDevice:
     case kFileSystemTypeProvided:
     case kFileSystemTypeDeviceMediaAsFileStorage:
+    case kFileSystemTypeDriveFs:
       return FILE_PERMISSION_USE_FILE_PERMISSION;
 
     case kFileSystemTypeRestrictedNativeLocal:

storage/common/fileapi/file_system_type_converters.h

@@ -43,6 +43,7 @@ struct TypeConverter<blink::mojom::FileSystemType, storage::FileSystemType> {
       case storage::FileSystemType::kFileSystemTypeDeviceMediaAsFileStorage:
       case storage::FileSystemType::kFileSystemTypeArcContent:
       case storage::FileSystemType::kFileSystemTypeArcDocumentsProvider:
+      case storage::FileSystemType::kFileSystemTypeDriveFs:
       case storage::FileSystemType::kFileSystemInternalTypeEnumEnd:
         NOTREACHED();
         return blink::mojom::FileSystemType::kTemporary;

storage/common/fileapi/file_system_types.h

@@ -123,7 +123,10 @@ enum FileSystemType {
   // A filesystem to provide access to documents providers in ARC.
   kFileSystemTypeArcDocumentsProvider,
 
-  kFileSystemTypeLast = kFileSystemTypeArcDocumentsProvider,
+  // Indicates a DriveFS filesystem which provides access to Google Drive.
+  kFileSystemTypeDriveFs,
+
+  kFileSystemTypeLast = kFileSystemTypeDriveFs,
 
   // --------------------------------------------------------------------
   // Marks the end of internal type enum. (This is not the actual fs type)

storage/common/fileapi/file_system_util.cc

@@ -312,6 +312,8 @@ std::string GetFileSystemTypeString(FileSystemType type) {
       return "ArcContent";
     case kFileSystemTypeArcDocumentsProvider:
       return "ArcDocumentsProvider";
+    case kFileSystemTypeDriveFs:
+      return "DriveFs";
     case kFileSystemInternalTypeEnumStart:
     case kFileSystemInternalTypeEnumEnd:
       NOTREACHED();