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(
+    const base::FilePath& profile_path,
     FileSystemBackendDelegate* drive_delegate,
     FileSystemBackendDelegate* file_system_provider_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()),
+      device_media_async_file_util_(
+          DeviceMediaAsyncFileUtil::Create(profile_path)),
       drive_delegate_(drive_delegate),
       file_system_provider_delegate_(file_system_provider_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
@@ skipping 16 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 device_media_async_file_util_.get();
     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;
   }
 
   DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal ||
          url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal ||
-         url.type() == fileapi::kFileSystemTypeDrive);
+         url.type() == fileapi::kFileSystemTypeDrive ||
+         url.type() == fileapi::kFileSystemTypeDeviceMediaAsFileStorage);
   return fileapi::FileSystemOperation::Create(
       url, context,
-      make_scoped_ptr(new fileapi::FileSystemOperationContext(context)));
+      make_scoped_ptr(new fileapi::FileSystemOperationContext(
+          context, MediaFileSystemBackend::MediaTaskRunner())));

[vandebo (ex-Chrome), 2014/04/23 16:24:44]

Passing in the media task runner here will do the file operations for all fs
types on that thread.  I'm not sure, but there are thread ordering restrictions
on the MTP code, so I'd feel safer if the MTP operations where on the media task
runner, but I don't think you want to do everything on that task runner.

[kinaba, 2014/04/24 01:33:30]

Right. I can't remember why I wrote it like the first patchset...

 }
 
 bool FileSystemBackend::SupportsStreaming(
     const fileapi::FileSystemURL& url) const {
   return false;
 }
 
 scoped_ptr<webkit_blob::FileStreamReader>
 FileSystemBackend::CreateFileStreamReader(
     const fileapi::FileSystemURL& url,
@@ skipping 10 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:
+      // TODO(kinaba): the stream reader from device media async util limits

[vandebo (ex-Chrome), 2014/04/23 16:24:44]

I'm not sure what you mean here?

[kinaba, 2014/04/24 01:33:30]

Revised the comment. Does it make sense?

+      // itself only for reading arbitrary file types. Handle non-media files
+      // here as well.
+      return device_media_async_file_util_->GetFileStreamReader(
+          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:
+      // TODO(kinaba): support writing.
+      return scoped_ptr<fileapi::FileStreamWriter>();
     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