Mount MTP devices in Chrome OS Files.app.

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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/fileapi/file_access_permissions.h"
 #include "chrome/browser/chromeos/fileapi/file_system_backend_delegate.h"
+#include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chromeos/dbus/cros_disks_client.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/async_file_util.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 
 namespace chromeos {
 
 // static
 bool FileSystemBackend::CanHandleURL(const fileapi::FileSystemURL& url) {
   if (!url.is_valid())
     return false;
   return url.type() == fileapi::kFileSystemTypeNativeLocal ||
          url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal ||
          url.type() == fileapi::kFileSystemTypeDrive ||
-         url.type() == fileapi::kFileSystemTypeProvided;
+         url.type() == fileapi::kFileSystemTypeProvided ||
+         url.type() == fileapi::kFileSystemTypeDeviceMediaAsFileStorage;
 }
 
 FileSystemBackend::FileSystemBackend(
     FileSystemBackendDelegate* drive_delegate,
     FileSystemBackendDelegate* file_system_provider_delegate,
+    FileSystemBackendDelegate* mtp_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_(fileapi::AsyncFileUtil::CreateForLocalFileSystem()),
       drive_delegate_(drive_delegate),
       file_system_provider_delegate_(file_system_provider_delegate),
+      mtp_delegate_(mtp_delegate),
       mount_points_(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.
@@ skipping 14 matching lines @@
       base::FilePath(FILE_PATH_LITERAL("/usr/share/oem")));
 }
 
 bool FileSystemBackend::CanHandleType(fileapi::FileSystemType type) const {
   switch (type) {
     case fileapi::kFileSystemTypeExternal:
     case fileapi::kFileSystemTypeDrive:
     case fileapi::kFileSystemTypeRestrictedNativeLocal:
     case fileapi::kFileSystemTypeNativeLocal:
     case fileapi::kFileSystemTypeNativeForPlatformApp:
+    case fileapi::kFileSystemTypeDeviceMediaAsFileStorage:
       return true;
     default:
       return false;
   }
 }
 
 void FileSystemBackend::Initialize(fileapi::FileSystemContext* context) {
 }
 
 void FileSystemBackend::ResolveURL(const fileapi::FileSystemURL& url,
@@ skipping 129 matching lines @@
 fileapi::AsyncFileUtil* FileSystemBackend::GetAsyncFileUtil(
     fileapi::FileSystemType type) {
   switch (type) {
     case fileapi::kFileSystemTypeDrive:
       return drive_delegate_->GetAsyncFileUtil(type);
     case fileapi::kFileSystemTypeProvided:
       return file_system_provider_delegate_->GetAsyncFileUtil(type);
     case fileapi::kFileSystemTypeNativeLocal:
     case fileapi::kFileSystemTypeRestrictedNativeLocal:
       return local_file_util_.get();
+    case fileapi::kFileSystemTypeDeviceMediaAsFileStorage:
+      return mtp_delegate_->GetAsyncFileUtil(type);
     default:
       NOTREACHED();
   }
   return NULL;
 }
 
 fileapi::CopyOrMoveFileValidatorFactory*
 FileSystemBackend::GetCopyOrMoveFileValidatorFactory(
     fileapi::FileSystemType type, base::File::Error* error_code) {
   DCHECK(error_code);
   *error_code = base::File::FILE_OK;
   return NULL;
 }
 
 fileapi::FileSystemOperation* FileSystemBackend::CreateFileSystemOperation(
     const fileapi::FileSystemURL& url,
     fileapi::FileSystemContext* context,
     base::File::Error* error_code) const {
   DCHECK(url.is_valid());
 
   if (!IsAccessAllowed(url)) {
     *error_code = base::File::FILE_ERROR_SECURITY;
     return NULL;
   }
 
+  if (url.type() == fileapi::kFileSystemTypeDeviceMediaAsFileStorage) {
+    // MTP file operations run on MediaTaskRunner.
+    return fileapi::FileSystemOperation::Create(
+        url, context,
+        make_scoped_ptr(new fileapi::FileSystemOperationContext(
+            context, MediaFileSystemBackend::MediaTaskRunner())));
+  }
+
   DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal ||
          url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal ||
          url.type() == fileapi::kFileSystemTypeDrive);
   return fileapi::FileSystemOperation::Create(
       url, context,
       make_scoped_ptr(new fileapi::FileSystemOperationContext(context)));
 }
 
 bool FileSystemBackend::SupportsStreaming(
     const fileapi::FileSystemURL& url) const {
@@ skipping 16 matching lines @@
       return drive_delegate_->CreateFileStreamReader(
           url, offset, expected_modification_time, context);
     case fileapi::kFileSystemTypeProvided:
       return file_system_provider_delegate_->CreateFileStreamReader(
           url, offset, expected_modification_time, context);
     case fileapi::kFileSystemTypeNativeLocal:
     case fileapi::kFileSystemTypeRestrictedNativeLocal:
       return scoped_ptr<webkit_blob::FileStreamReader>(
           webkit_blob::FileStreamReader::CreateForFileSystemFile(
               context, url, offset, expected_modification_time));
+    case fileapi::kFileSystemTypeDeviceMediaAsFileStorage:
+      return mtp_delegate_->CreateFileStreamReader(
+          url, offset, expected_modification_time, context);
     default:
       NOTREACHED();
   }
   return scoped_ptr<webkit_blob::FileStreamReader>();
 }
 
 scoped_ptr<fileapi::FileStreamWriter>
 FileSystemBackend::CreateFileStreamWriter(
     const fileapi::FileSystemURL& url,
     int64 offset,
@@ skipping 10 matching lines @@
       return file_system_provider_delegate_->CreateFileStreamWriter(
           url, offset, context);
     case fileapi::kFileSystemTypeNativeLocal:
       return scoped_ptr<fileapi::FileStreamWriter>(
           fileapi::FileStreamWriter::CreateForLocalFile(
               context->default_file_task_runner(), url.path(), offset,
               fileapi::FileStreamWriter::OPEN_EXISTING_FILE));
     case fileapi::kFileSystemTypeRestrictedNativeLocal:
       // Restricted native local file system is read only.
       return scoped_ptr<fileapi::FileStreamWriter>();
+    case fileapi::kFileSystemTypeDeviceMediaAsFileStorage:
+      return mtp_delegate_->CreateFileStreamWriter(url, offset, context);
     default:
       NOTREACHED();
   }
   return scoped_ptr<fileapi::FileStreamWriter>();
 }
 
 bool FileSystemBackend::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);
 }
 
 }  // namespace chromeos