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_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/local_file_stream_writer.h"
 #include "webkit/fileapi/local_file_system_operation.h"
+#include "webkit/fileapi/media/media_file_system_config.h"
 #include "webkit/fileapi/native_file_util.h"
 
+#if defined(SUPPORT_MEDIA_FILESYSTEM)
+#include "webkit/fileapi/media/device_media_file_util.h"
+#include "webkit/fileapi/media/media_device_map_service.h"
+#endif
+
 namespace fileapi {
 
 namespace {
 
 IsolatedContext* isolated_context() {
   return IsolatedContext::GetInstance();
 }
 
+#if defined(SUPPORT_MEDIA_FILESYSTEM)
+bool GetDeviceForUrl(const FileSystemURL& url,
+                     FileSystemContext* context,
+                     scoped_refptr<MediaDeviceInterfaceImpl>* device) {

[kinuko, 2012/07/30 23:19:03]

This might be a minor coding-taste issue, but maybe we can simply return
MediaDeviceInterfaceImpl pointer (or NULL on failure) instead of bool and get
rid of this *device param?  Returning a pointer to scoped_refptr via an out
pointer makes me feel a bit uneasy, but it might be just me.

[kmadhusu, 2012/07/31 01:17:48]

As we discussed, I changed this function signature.

+
+  FilePath root_path;
+  if (!isolated_context()->GetRegisteredPath(url.filesystem_id(), &root_path))
+    return false;
+
+  // Add the media device if required.
+  MediaDeviceMapService::GetInstance()->AddMediaDevice(
+      root_path.value(), context->file_task_runner());
+
+  return MediaDeviceMapService::GetInstance()->GetMediaDevice(root_path.value(),
+                                                              device);
+}
+#endif
+
 }  // namespace
 
-IsolatedMountPointProvider::IsolatedMountPointProvider()
-    : isolated_file_util_(new IsolatedFileUtil()),
+IsolatedMountPointProvider::IsolatedMountPointProvider(
+    const FilePath& profile_path)
+    : profile_path_(profile_path),
+      isolated_file_util_(new IsolatedFileUtil()),
       dragged_file_util_(new DraggedFileUtil()) {
+  // TODO(kmadhusu): Initialize device_media_file_util_ in initialization list.
+#if defined(SUPPORT_MEDIA_FILESYSTEM)
+  device_media_file_util_.reset(new DeviceMediaFileUtil(profile_path_));
+#endif
 }
 
 IsolatedMountPointProvider::~IsolatedMountPointProvider() {
 }
 
 void IsolatedMountPointProvider::ValidateFileSystemRoot(
     const GURL& origin_url,
     FileSystemType type,
     bool create,
     const ValidateFileSystemCallback& callback) {
@@ skipping 22 matching lines @@
     const FilePath& filename) const {
   // TODO(kinuko): We need to check platform-specific restricted file names
   // before we actually start allowing file creation in isolated file systems.
   return false;
 }
 
 FileSystemFileUtil* IsolatedMountPointProvider::GetFileUtil(
     FileSystemType type) {
   if (type == kFileSystemTypeDragged)
     return dragged_file_util_.get();
+#if defined(SUPPORT_MEDIA_FILESYSTEM)
+  else if (type == kFileSystemTypeDeviceMedia)
+    return device_media_file_util_.get();
+#endif
   else
     return isolated_file_util_.get();
 }
 
 FilePath IsolatedMountPointProvider::GetPathForPermissionsCheck(
     const FilePath& virtual_path) const {
   // For isolated filesystems we only check per-filesystem permissions.
   NOTREACHED();
   return virtual_path;
 }
 
 FileSystemOperationInterface*
 IsolatedMountPointProvider::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context) const {
   scoped_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(context));
+
+#if defined(SUPPORT_MEDIA_FILESYSTEM)
+  if (url.type() == kFileSystemTypeDeviceMedia) {
+    scoped_refptr<MediaDeviceInterfaceImpl> device;
+    if (GetDeviceForUrl(url, context, &device))
+      operation_context->set_media_device(device);
+  }
+#endif
+
   return new LocalFileSystemOperation(context, operation_context.Pass());
 }
 
 webkit_blob::FileStreamReader*
 IsolatedMountPointProvider::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   return new webkit_blob::LocalFileStreamReader(
       context->file_task_runner(), url.path(), offset, base::Time());
 }
 
 FileStreamWriter* IsolatedMountPointProvider::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   return new LocalFileStreamWriter(url.path(), offset);
 }
 
 FileSystemQuotaUtil* IsolatedMountPointProvider::GetQuotaUtil() {
   // No quota support.
   return NULL;
 }
 
 }  // namespace fileapi