Change media galleries to external file system type to add toURL support

chrome/browser/media_galleries/fileapi/media_file_system_backend.cc

 // Copyright (c) 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/media_galleries/fileapi/media_file_system_backend.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/sequenced_task_runner.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/media_galleries/fileapi/device_media_async_file_util.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_validator_factory.h"
 #include "chrome/browser/media_galleries/fileapi/media_path_filter.h"
 #include "chrome/browser/media_galleries/fileapi/native_media_file_util.h"
+#include "chrome/browser/media_galleries/media_file_system_registry.h"
+#include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/resource_request_info.h"
+#include "extensions/browser/extension_system.h"
+#include "net/url_request/url_request.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.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/isolated_context.h"
+#include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/native_file_util.h"
 #include "webkit/common/fileapi/file_system_types.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 #include "chrome/browser/media_galleries/fileapi/itunes_file_util.h"
 #include "chrome/browser/media_galleries/fileapi/picasa_file_util.h"
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 
 #if defined(OS_MACOSX)
@@ skipping 42 matching lines @@
 
 // static
 scoped_refptr<base::SequencedTaskRunner>
 MediaFileSystemBackend::MediaTaskRunner() {
   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
   base::SequencedWorkerPool::SequenceToken media_sequence_token =
       pool->GetNamedSequenceToken(kMediaTaskRunnerName);
   return pool->GetSequencedTaskRunner(media_sequence_token);
 }
 
+//static
+std::string MediaFileSystemBackend::ConstructMountName(
+    Profile* profile,
+    const std::string& extension_id,
+    MediaGalleryPrefId pref_id) {
+  std::string name = "media_galleries-";
+  name.append(profile->GetPath().BaseName().MaybeAsASCII());
+  name.append("-");
+  name.append(extension_id);
+  name.append("-");
+  if (pref_id != kInvalidMediaGalleryPrefId)
+    name.append(base::Uint64ToString(pref_id));
+  base::ReplaceChars(name, " /", "_", &name);
+  return name;
+}
+
+void OnFileSystems(
+    MediaGalleryPrefId pref_id,
+    const base::Callback<void(base::File::Error result)>& callback,
+    const std::vector<MediaFileSystemInfo>& filesystems) {
+  for (size_t i = 0; i < filesystems.size(); i++) {
+    if (filesystems[i].pref_id == pref_id) {
+      callback.Run(base::File::FILE_OK);
+      return;
+    }
+  }
+  callback.Run(base::File::FILE_ERROR_NOT_FOUND);
+}
+
+//static
+bool MediaFileSystemBackend::AttemptAutoMountForURLRequest(
+    const net::URLRequest* url_request,
+    const fileapi::FileSystemURL& filesystem_url,
+    const std::string& storage_domain,
+    const base::Callback<void(base::File::Error result)>& callback) {
+  if (storage_domain.empty())
+    return false;
+
+  if (filesystem_url.type() != fileapi::kFileSystemTypeExternal)
+    return false;
+
+  const base::FilePath& virtual_path = filesystem_url.path();
+  if (virtual_path.ReferencesParent())
+    return false;
+  std::vector<base::FilePath::StringType> components;
+  virtual_path.GetComponents(&components);
+  if (components.size() < 1)
+    return false;
+
+  const content::ResourceRequestInfo* request_info =
+      content::ResourceRequestInfo::ForRequest(url_request);
+  if (!request_info)
+    return false;
+  content::RenderViewHost* rvh =
+      content::RenderViewHost::FromID(request_info->GetChildID(),
+                                      request_info->GetRouteID());
+  if (!rvh)
+    return false;
+  Profile* profile =
+      Profile::FromBrowserContext(rvh->GetProcess()->GetBrowserContext());
+
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  const extensions::Extension* extension =
+      extension_service->GetExtensionById(storage_domain,
+                                          false /*include disabled*/);
+  if (!extension)
+    return false;
+
+  std::string expected_name_prefix =
+      ConstructMountName(profile, extension->id(), kInvalidMediaGalleryPrefId);
+  // TODO - handle wstring case
+  if (components[0].compare(0, expected_name_prefix.size(),
+                                           expected_name_prefix) != 0) {
+    return false;
+  }
+  MediaGalleryPrefId pref_id = kInvalidMediaGalleryPrefId;
+  // TODO - handle wstring case
+  if (!base::StringToUint64(
+      components[0].substr(expected_name_prefix.size()),
+      &pref_id) || pref_id == kInvalidMediaGalleryPrefId) {
+    return false;
+  }
+
+  // TODO(vandebo) add a call to get just this file system. No unretained.
+  base::Closure check_fs_callback =
+      base::Bind(&MediaFileSystemRegistry::GetMediaFileSystemsForExtension,
+                 base::Unretained(g_browser_process->media_file_system_registry()),
+                 rvh,
+                 extension,
+                 base::Bind(&OnFileSystems, pref_id, callback));
+
+  MediaGalleriesPreferences* preferences =
+      g_browser_process->media_file_system_registry()->GetPreferences(profile);
+  preferences->EnsureInitialized(check_fs_callback);
+  return true;
+}
+
 bool MediaFileSystemBackend::CanHandleType(
     fileapi::FileSystemType type) const {
   switch (type) {
     case fileapi::kFileSystemTypeNativeMedia:
     case fileapi::kFileSystemTypeDeviceMedia:
 #if defined(OS_WIN) || defined(OS_MACOSX)
     case fileapi::kFileSystemTypePicasa:
     case fileapi::kFileSystemTypeItunes:
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
 #if defined(OS_MACOSX)
     case fileapi::kFileSystemTypeIphoto:
 #endif  // defined(OS_MACOSX)
       return true;
     default:
       return false;
   }
 }
 
 void MediaFileSystemBackend::Initialize(fileapi::FileSystemContext* context) {
 }
 
 void MediaFileSystemBackend::ResolveURL(
     const FileSystemURL& url,
     fileapi::OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback) {
-  // We never allow opening a new isolated FileSystem via usual ResolveURL.
+  // We never allow opening a new FileSystem via usual ResolveURL.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  GURL(),
                  std::string(),
                  base::File::FILE_ERROR_SECURITY));
 }
 
 fileapi::AsyncFileUtil* MediaFileSystemBackend::GetAsyncFileUtil(
     fileapi::FileSystemType type) {
@@ skipping 91 matching lines @@
       fileapi::FileStreamWriter::CreateForLocalFile(
           context->default_file_task_runner(),
           url.path(), offset));
 }
 
 fileapi::FileSystemQuotaUtil*
 MediaFileSystemBackend::GetQuotaUtil() {
   // No quota support.
   return NULL;
 }