Isolated FS for media devices.

webkit/fileapi/isolated_mount_point_provider.cc

 // Copyright (c) 2012 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 "webkit/fileapi/isolated_mount_point_provider.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "webkit/blob/local_file_stream_reader.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_stream_reader.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/isolated_file_util.h"
+#include "webkit/fileapi/media_device_map_service.h"
+#include "webkit/fileapi/media_file_util.h"
 #include "webkit/fileapi/local_file_stream_writer.h"
 #include "webkit/fileapi/native_file_util.h"
 
 namespace fileapi {
 
 namespace {
 
 IsolatedContext* isolated_context() {
   return IsolatedContext::GetInstance();
 }
 
 FilePath GetPathFromURL(const FileSystemURL& url) {
   if (!url.is_valid() || url.type() != kFileSystemTypeIsolated)
     return FilePath();
   std::string fsid;
   FilePath path;
   if (!isolated_context()->CrackIsolatedPath(url.path(), &fsid, NULL, &path))
     return FilePath();
   return path;
 }
 
+bool IsMediaFileSystemURL(const FileSystemURL& url) {
+// TODO(kmadhusu): Query the SystemMonitor for the URL device type.
+#if defined(OS_WIN)
+  FilePath temp = GetPathFromURL(url);
+  if (temp.empty())
+    return false;
+  FilePath::StringType device_name(temp.value());
+  return (!(device_name.substr(0,4)).compare(L"\\\\?\\"));
+#else
+  return true;
+#endif

[kinuko, 2012/07/24 19:57:19]

We are thinking about a refactoring like following:
- Extend the IsolatedContext::Register API to take a filesystem type (therefore
if MTP device is attached we can register the path as MTPFileSystem)
- Make the GetFileUtil take FileSystemType parameter

Then in the fileapi code all we need to do is dispatch appropriate FileUtils
based on the types.  WDYT?  Will it work for you?
(Unsubmitted CL: http://codereview.chromium.org/10810053/)

[kmadhusu, 2012/07/24 20:56:34]

sgtm. Your changes will simplify this CL. I will start working on my TODO list. 

+}
+
 }  // namespace
 
 IsolatedMountPointProvider::IsolatedMountPointProvider()
-    : isolated_file_util_(new IsolatedFileUtil()) {
+    : isolated_file_util_(new IsolatedFileUtil()),
+      media_file_util_(new MediaFileUtil()) {
 }
 
 IsolatedMountPointProvider::~IsolatedMountPointProvider() {
 }
 
 void IsolatedMountPointProvider::ValidateFileSystemRoot(
     const GURL& origin_url,
     FileSystemType type,
     bool create,
     const ValidateFileSystemCallback& callback) {
@@ skipping 27 matching lines @@
   FilePath path;
   return isolated_context()->CrackIsolatedPath(
       virtual_path, &filesystem_id, NULL, &path);
 }
 
 bool IsolatedMountPointProvider::IsRestrictedFileName(
     const FilePath& filename) const {
   return false;
 }
 
-FileSystemFileUtil* IsolatedMountPointProvider::GetFileUtil() {
+FileSystemFileUtil* IsolatedMountPointProvider::GetFileUtil(
+    const FileSystemURL& url) {
+  if (IsMediaFileSystemURL(url))
+    return media_file_util_.get();
   return isolated_file_util_.get();
 }
 
 FilePath IsolatedMountPointProvider::GetPathForPermissionsCheck(
     const FilePath& virtual_path) const {
   std::string fsid;
   FilePath path;
   if (!isolated_context()->CrackIsolatedPath(virtual_path, &fsid, NULL, &path))
     return FilePath();
   return path;
 }
 
 FileSystemOperationInterface*
 IsolatedMountPointProvider::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context) const {
+  if (IsMediaFileSystemURL(url)) {
+    FilePath actual_path = GetPathFromURL(url);
+    if (actual_path.empty())
+      return false;
+    FilePath::StringType device_name(actual_path.value());
+    MediaDeviceMapService::GetInstance()->AddMediaDevice(device_name);
+  }
   return new FileSystemOperation(context);
 }
 
 webkit_blob::FileStreamReader*
 IsolatedMountPointProvider::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   FilePath path = GetPathFromURL(url);
   return path.empty() ? NULL : new webkit_blob::LocalFileStreamReader(
       context->file_task_runner(), path, offset, base::Time());
 }
 
 FileStreamWriter* IsolatedMountPointProvider::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   FilePath path = GetPathFromURL(url);
   return path.empty() ? NULL : new LocalFileStreamWriter(path, offset);
 }
 
 FileSystemQuotaUtil* IsolatedMountPointProvider::GetQuotaUtil() {
   // No quota support.
   return NULL;
 }
 
 }  // namespace fileapi