arc: Register ARC content file system

chrome/browser/chromeos/fileapi/file_system_backend.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/file_system_backend.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 31 matching lines @@
 }  // namespace
 
 // static
 bool FileSystemBackend::CanHandleURL(const storage::FileSystemURL& url) {
   if (!url.is_valid())
     return false;
   return url.type() == storage::kFileSystemTypeNativeLocal ||
          url.type() == storage::kFileSystemTypeRestrictedNativeLocal ||
          url.type() == storage::kFileSystemTypeDrive ||
          url.type() == storage::kFileSystemTypeProvided ||
-         url.type() == storage::kFileSystemTypeDeviceMediaAsFileStorage;
+         url.type() == storage::kFileSystemTypeDeviceMediaAsFileStorage ||
+         url.type() == storage::kFileSystemTypeArcContent;
 }
 
 FileSystemBackend::FileSystemBackend(
-    FileSystemBackendDelegate* drive_delegate,
-    FileSystemBackendDelegate* file_system_provider_delegate,
-    FileSystemBackendDelegate* mtp_delegate,
+    std::unique_ptr<FileSystemBackendDelegate> drive_delegate,
+    std::unique_ptr<FileSystemBackendDelegate> file_system_provider_delegate,
+    std::unique_ptr<FileSystemBackendDelegate> mtp_delegate,
+    std::unique_ptr<FileSystemBackendDelegate> arc_content_delegate,
     scoped_refptr<storage::ExternalMountPoints> mount_points,
     storage::ExternalMountPoints* system_mount_points)
     : file_access_permissions_(new FileAccessPermissions()),
       local_file_util_(storage::AsyncFileUtil::CreateForLocalFileSystem()),
-      drive_delegate_(drive_delegate),
-      file_system_provider_delegate_(file_system_provider_delegate),
-      mtp_delegate_(mtp_delegate),
+      drive_delegate_(std::move(drive_delegate)),
+      file_system_provider_delegate_(std::move(file_system_provider_delegate)),
+      mtp_delegate_(std::move(mtp_delegate)),
+      arc_content_delegate_(std::move(arc_content_delegate)),
       mount_points_(mount_points),
-      system_mount_points_(system_mount_points) {
-}
+      system_mount_points_(system_mount_points) {}
 
 FileSystemBackend::~FileSystemBackend() {
 }
 
 void FileSystemBackend::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
   // point already exists or not.
   system_mount_points_->RegisterFileSystem(
       "archive",
@@ skipping 13 matching lines @@
 
 bool FileSystemBackend::CanHandleType(storage::FileSystemType type) const {
   switch (type) {
     case storage::kFileSystemTypeExternal:
     case storage::kFileSystemTypeDrive:
     case storage::kFileSystemTypeRestrictedNativeLocal:
     case storage::kFileSystemTypeNativeLocal:
     case storage::kFileSystemTypeNativeForPlatformApp:
     case storage::kFileSystemTypeDeviceMediaAsFileStorage:
     case storage::kFileSystemTypeProvided:
+    case storage::kFileSystemTypeArcContent:
       return true;
     default:
       return false;
   }
 }
 
 void FileSystemBackend::Initialize(storage::FileSystemContext* context) {
 }
 
 void FileSystemBackend::ResolveURL(const storage::FileSystemURL& url,
@@ skipping 130 matching lines @@
   switch (type) {
     case storage::kFileSystemTypeDrive:
       return drive_delegate_->GetAsyncFileUtil(type);
     case storage::kFileSystemTypeProvided:
       return file_system_provider_delegate_->GetAsyncFileUtil(type);
     case storage::kFileSystemTypeNativeLocal:
     case storage::kFileSystemTypeRestrictedNativeLocal:
       return local_file_util_.get();
     case storage::kFileSystemTypeDeviceMediaAsFileStorage:
       return mtp_delegate_->GetAsyncFileUtil(type);
+    case storage::kFileSystemTypeArcContent:
+      return arc_content_delegate_->GetAsyncFileUtil(type);
     default:
       NOTREACHED();
   }
   return NULL;
 }
 
 storage::WatcherManager* FileSystemBackend::GetWatcherManager(
     storage::FileSystemType type) {
   if (type == storage::kFileSystemTypeProvided)
     return file_system_provider_delegate_->GetWatcherManager(type);
@@ skipping 32 matching lines @@
     // MTP file operations run on MediaTaskRunner.
     return storage::FileSystemOperation::Create(
         url, context,
         base::MakeUnique<storage::FileSystemOperationContext>(
             context, MediaFileSystemBackend::MediaTaskRunner().get()));
   }
 
   DCHECK(url.type() == storage::kFileSystemTypeNativeLocal ||
          url.type() == storage::kFileSystemTypeRestrictedNativeLocal ||
          url.type() == storage::kFileSystemTypeDrive ||
-         url.type() == storage::kFileSystemTypeProvided);
+         url.type() == storage::kFileSystemTypeProvided ||
+         url.type() == storage::kFileSystemTypeArcContent);
   return storage::FileSystemOperation::Create(
       url, context,
       base::MakeUnique<storage::FileSystemOperationContext>(context));
 }
 
 bool FileSystemBackend::SupportsStreaming(
     const storage::FileSystemURL& url) const {
   return url.type() == storage::kFileSystemTypeDrive ||
          url.type() == storage::kFileSystemTypeProvided ||
-         url.type() == storage::kFileSystemTypeDeviceMediaAsFileStorage;
+         url.type() == storage::kFileSystemTypeDeviceMediaAsFileStorage ||
+         url.type() == storage::kFileSystemTypeArcContent;
 }
 
 bool FileSystemBackend::HasInplaceCopyImplementation(
     storage::FileSystemType type) const {
   switch (type) {
     case storage::kFileSystemTypeDrive:
     case storage::kFileSystemTypeProvided:
     case storage::kFileSystemTypeDeviceMediaAsFileStorage:
       return true;
     case storage::kFileSystemTypeNativeLocal:
     case storage::kFileSystemTypeRestrictedNativeLocal:
+    case storage::kFileSystemTypeArcContent:
       return false;
     default:
       NOTREACHED();
   }
   return true;
 }
 
 std::unique_ptr<storage::FileStreamReader>
 FileSystemBackend::CreateFileStreamReader(
     const storage::FileSystemURL& url,
@@ skipping 14 matching lines @@
       return file_system_provider_delegate_->CreateFileStreamReader(
           url, offset, max_bytes_to_read, expected_modification_time, context);
     case storage::kFileSystemTypeNativeLocal:
     case storage::kFileSystemTypeRestrictedNativeLocal:
       return std::unique_ptr<storage::FileStreamReader>(
           storage::FileStreamReader::CreateForFileSystemFile(
               context, url, offset, expected_modification_time));
     case storage::kFileSystemTypeDeviceMediaAsFileStorage:
       return mtp_delegate_->CreateFileStreamReader(
           url, offset, max_bytes_to_read, expected_modification_time, context);
+    case storage::kFileSystemTypeArcContent:
+      return arc_content_delegate_->CreateFileStreamReader(
+          url, offset, max_bytes_to_read, expected_modification_time, context);
     default:
       NOTREACHED();
   }
   return std::unique_ptr<storage::FileStreamReader>();
 }
 
 std::unique_ptr<storage::FileStreamWriter>
 FileSystemBackend::CreateFileStreamWriter(
     const storage::FileSystemURL& url,
     int64_t offset,
     storage::FileSystemContext* context) const {
   DCHECK(url.is_valid());
 
   if (!IsAccessAllowed(url))
     return std::unique_ptr<storage::FileStreamWriter>();
 
   switch (url.type()) {
     case storage::kFileSystemTypeDrive:
       return drive_delegate_->CreateFileStreamWriter(url, offset, context);
     case storage::kFileSystemTypeProvided:
       return file_system_provider_delegate_->CreateFileStreamWriter(
           url, offset, context);
     case storage::kFileSystemTypeNativeLocal:
       return std::unique_ptr<storage::FileStreamWriter>(
           storage::FileStreamWriter::CreateForLocalFile(
               context->default_file_task_runner(), url.path(), offset,
               storage::FileStreamWriter::OPEN_EXISTING_FILE));
-    case storage::kFileSystemTypeRestrictedNativeLocal:
-      // Restricted native local file system is read only.
-      return std::unique_ptr<storage::FileStreamWriter>();
     case storage::kFileSystemTypeDeviceMediaAsFileStorage:
       return mtp_delegate_->CreateFileStreamWriter(url, offset, context);
+    // Read only file systems.
+    case storage::kFileSystemTypeRestrictedNativeLocal:
+    case storage::kFileSystemTypeArcContent:
+      return std::unique_ptr<storage::FileStreamWriter>();
     default:
       NOTREACHED();
   }
   return std::unique_ptr<storage::FileStreamWriter>();
 }
 
 bool FileSystemBackend::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);
@@ skipping 13 matching lines @@
       return;
     case storage::kFileSystemTypeProvided:
       file_system_provider_delegate_->GetRedirectURLForContents(url,
                                                                   callback);
       return;
     case storage::kFileSystemTypeDeviceMediaAsFileStorage:
       mtp_delegate_->GetRedirectURLForContents(url, callback);
       return;
     case storage::kFileSystemTypeNativeLocal:
     case storage::kFileSystemTypeRestrictedNativeLocal:
+    case storage::kFileSystemTypeArcContent:
       callback.Run(GURL());
       return;
     default:
       NOTREACHED();
   }
   callback.Run(GURL());
 }
 
 storage::FileSystemURL FileSystemBackend::CreateInternalURL(
     storage::FileSystemContext* context,
     const base::FilePath& entry_path) const {
   base::FilePath virtual_path;
   if (!GetVirtualPath(entry_path, &virtual_path))
     return storage::FileSystemURL();
 
   return context->CreateCrackedFileSystemURL(
       GURL() /* origin */, storage::kFileSystemTypeExternal, virtual_path);
 }
 
 }  // namespace chromeos