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

chrome/browser/media_galleries/media_file_system_registry.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 "chrome/browser/media_galleries/media_file_system_registry.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/media_galleries/fileapi/mtp_device_map_service.h"
 #include "chrome/browser/media_galleries/imported_media_gallery_registry.h"
 #include "chrome/browser/media_galleries/media_file_system_context.h"
 #include "chrome/browser/media_galleries/media_galleries_dialog_controller.h"
 #include "chrome/browser/media_galleries/media_galleries_histograms.h"
 #include "chrome/browser/media_galleries/media_galleries_preferences_factory.h"
 #include "chrome/browser/media_galleries/media_scan_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "components/storage_monitor/media_storage_util.h"
 #include "components/storage_monitor/storage_monitor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
-#include "webkit/browser/fileapi/isolated_context.h"
+#include "webkit/browser/fileapi/external_mount_points.h"
+#include "webkit/common/fileapi/file_system_mount_option.h"
 #include "webkit/common/fileapi/file_system_types.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::RenderProcessHost;
 using content::WebContents;
-using fileapi::IsolatedContext;
 using storage_monitor::MediaStorageUtil;
 using storage_monitor::StorageInfo;
 using storage_monitor::StorageMonitor;
+using fileapi::ExternalMountPoints;
 
 namespace {
 
 struct InvalidatedGalleriesInfo {
   std::set<ExtensionGalleriesHost*> extension_hosts;
   std::set<MediaGalleryPrefId> pref_ids;
 };
 
 // Tracks the liveness of multiple RenderProcessHosts that the caller is
 // interested in. Once all of the RPHs have closed or been destroyed a call
@@ skipping 194 matching lines @@
 
 // The main owner of this class is
 // |MediaFileSystemRegistry::extension_hosts_map_|, but a callback may
 // temporarily hold a reference.
 class ExtensionGalleriesHost
     : public base::RefCountedThreadSafe<ExtensionGalleriesHost> {
  public:
   // |no_references_callback| is called when the last RenderViewHost reference
   // goes away. RenderViewHost references are added through ReferenceFromRVH().
   ExtensionGalleriesHost(MediaFileSystemContext* file_system_context,
+                         const std::string file_system_name_prefix,
                          const base::Closure& no_references_callback)
       : file_system_context_(file_system_context),
+        file_system_name_prefix_(file_system_name_prefix),
         no_references_callback_(no_references_callback),
         rph_refs_(base::Bind(&ExtensionGalleriesHost::CleanUp,
                              base::Unretained(this))) {
   }
 
   // For each gallery in the list of permitted |galleries|, checks if the
   // device is attached and if so looks up or creates a file system id and
   // passes the information needed for the renderer to create those file
   // system objects to the |callback|.
   void GetMediaFileSystems(const MediaGalleryPrefIdSet& galleries,
@@ skipping 71 matching lines @@
         continue;
 
       PrefIdFsInfoMap::const_iterator existing_info =
           pref_id_map_.find(pref_id);
       if (existing_info != pref_id_map_.end()) {
         result.push_back(existing_info->second);
         continue;
       }
 
       base::FilePath path = gallery_info.AbsolutePath();
-      if (!MediaStorageUtil::CanCreateFileSystem(device_id, path))
+      if (path.empty() ||
+          !MediaStorageUtil::CanCreateFileSystem(device_id, path))
         continue;
 
-      std::string fsid =
-          file_system_context_->RegisterFileSystem(device_id, path);
-      if (fsid.empty())
+      std::string fs_name = file_system_name_prefix_;
+      fs_name.append(base::Uint64ToString(pref_id));
+      if (!file_system_context_->RegisterFileSystem(device_id, fs_name, path))
         continue;
 
       MediaFileSystemInfo new_entry(
           gallery_info.GetGalleryDisplayName(),
-          path,
-          fsid,
+          file_system_context_->GetRegisteredPath(fs_name),
+          fs_name,
           pref_id,
           GetTransientIdForRemovableDeviceId(device_id),
           StorageInfo::IsRemovableDevice(device_id),
           StorageInfo::IsMediaDevice(device_id));
       result.push_back(new_entry);
       pref_id_map_[pref_id] = new_entry;
     }
 
     if (result.size() == 0) {
       rph_refs_.Reset();
@@ skipping 20 matching lines @@
     }
     pref_id_map_.clear();
 
     no_references_callback_.Run();
   }
 
   // MediaFileSystemRegistry owns |this| and |file_system_context_|, so it's
   // safe to store a raw pointer.
   MediaFileSystemContext* file_system_context_;
 
+  // A unique name prefix for filesystems.
+  std::string file_system_name_prefix_;
+
   // A callback to call when the last RVH reference goes away.
   base::Closure no_references_callback_;
 
   // A map from the gallery preferences id to the file system information.
   PrefIdFsInfoMap pref_id_map_;
 
   // The set of render processes and web contents that may have references to
   // the file system ids this instance manages.
   RPHReferenceManager rph_refs_;
 
@@ skipping 22 matching lines @@
   }
 
   ExtensionGalleriesHostMap::iterator extension_hosts =
       extension_hosts_map_.find(profile);
   if (extension_hosts->second.empty())
     preferences->AddGalleryChangeObserver(this);
 
   ExtensionGalleriesHost* extension_host =
       extension_hosts->second[extension->id()].get();
   if (!extension_host) {
+    std::string name_prefix = "media_galleries-";
+    name_prefix.append(profile->GetPath().BaseName().MaybeAsASCII());
+    name_prefix.append("-");
+    name_prefix.append(extension->id());
+    name_prefix.append("-");
+    base::ReplaceChars(name_prefix, " /", "_", &name_prefix);
     extension_host = new ExtensionGalleriesHost(
         file_system_context_.get(),
+        name_prefix,
         base::Bind(&MediaFileSystemRegistry::OnExtensionGalleriesHostEmpty,
                    base::Unretained(this),
                    profile,
                    extension->id()));
     extension_hosts_map_[profile][extension->id()] = extension_host;
   }
   // This must come before the GetMediaFileSystems call to make sure the
   // RVH of the context is referenced before the filesystems are retrieved.
   extension_host->ReferenceFromRVH(rvh);
 
@@ skipping 68 matching lines @@
   }
 }
 
 /******************
  * Private methods
  ******************/
 
 class MediaFileSystemRegistry::MediaFileSystemContextImpl
     : public MediaFileSystemContext {
  public:
-  explicit MediaFileSystemContextImpl(MediaFileSystemRegistry* registry)
-      : registry_(registry) {
-    DCHECK(registry_);  // Suppresses unused warning on Android.
-  }
+  MediaFileSystemContextImpl() {}
   virtual ~MediaFileSystemContextImpl() {}
 
-  virtual std::string RegisterFileSystem(
-      const std::string& device_id, const base::FilePath& path) OVERRIDE {
+  virtual bool RegisterFileSystem(const std::string& device_id,
+                                  const std::string& fs_name,
+                                  const base::FilePath& path) OVERRIDE {
     if (StorageInfo::IsMassStorageDevice(device_id)) {
-      return RegisterFileSystemForMassStorage(device_id, path);
+      return RegisterFileSystemForMassStorage(device_id, fs_name, path);
     } else {
-      return RegisterFileSystemForMTPDevice(device_id, path);
+      return RegisterFileSystemForMTPDevice(device_id, fs_name, path);
     }
   }
 
-  virtual void RevokeFileSystem(const std::string& fsid) OVERRIDE {
+  virtual void RevokeFileSystem(const std::string& fs_name) OVERRIDE {
     ImportedMediaGalleryRegistry* imported_registry =
         ImportedMediaGalleryRegistry::GetInstance();
-    if (imported_registry->RevokeImportedFilesystemOnUIThread(fsid))
+    if (imported_registry->RevokeImportedFilesystemOnUIThread(fs_name))
       return;
 
-    IsolatedContext::GetInstance()->RevokeFileSystem(fsid);
+    ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(fs_name);
 
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE, base::Bind(
             &MTPDeviceMapService::RevokeMTPFileSystem,
             base::Unretained(MTPDeviceMapService::GetInstance()),
-            fsid));
+            fs_name));
+  }
+
+  virtual base::FilePath GetRegisteredPath(
+      const std::string& fs_name) const OVERRIDE {
+    base::FilePath result;
+    if (!ExternalMountPoints::GetSystemInstance()->GetRegisteredPath(fs_name,
+                                                                     &result)) {
+      return base::FilePath();
+    }
+    return result;
   }
 
  private:
   // Registers and returns the file system id for the mass storage device
   // specified by |device_id| and |path|.
-  std::string RegisterFileSystemForMassStorage(
-      const std::string& device_id, const base::FilePath& path) {
+  bool RegisterFileSystemForMassStorage(const std::string& device_id,
+                                        const std::string& fs_name,
+                                        const base::FilePath& path) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(StorageInfo::IsMassStorageDevice(device_id));
 
     // Sanity checks for |path|.
     CHECK(path.IsAbsolute());
     CHECK(!path.ReferencesParent());
 
     // TODO(gbillock): refactor ImportedMediaGalleryRegistry to delegate this
     // call tree, probably by having it figure out by device id what
     // registration is needed, or having per-device-type handlers at the
     // next higher level.
-    std::string fsid;
+    bool result = false;
     if (StorageInfo::IsITunesDevice(device_id)) {
-      ImportedMediaGalleryRegistry* imported_registry =
+      ImportedMediaGalleryRegistry* registry =
           ImportedMediaGalleryRegistry::GetInstance();
-      fsid = imported_registry->RegisterITunesFilesystemOnUIThread(path);
+      result = registry->RegisterITunesFilesystemOnUIThread(fs_name, path);
     } else if (StorageInfo::IsPicasaDevice(device_id)) {
-      ImportedMediaGalleryRegistry* imported_registry =
+      ImportedMediaGalleryRegistry* registry =
           ImportedMediaGalleryRegistry::GetInstance();
-      fsid = imported_registry->RegisterPicasaFilesystemOnUIThread(
-          path);
+      result = registry->RegisterPicasaFilesystemOnUIThread(fs_name, path);
     } else if (StorageInfo::IsIPhotoDevice(device_id)) {
-      ImportedMediaGalleryRegistry* imported_registry =
+      ImportedMediaGalleryRegistry* registry =
           ImportedMediaGalleryRegistry::GetInstance();
-      fsid = imported_registry->RegisterIPhotoFilesystemOnUIThread(
-          path);
+      result = registry->RegisterIPhotoFilesystemOnUIThread(fs_name, path);
     } else {
-      std::string fs_name(extension_misc::kMediaFileSystemPathPart);
-      fsid = IsolatedContext::GetInstance()->RegisterFileSystemForPath(
-          fileapi::kFileSystemTypeNativeMedia, path, &fs_name);
+      result = ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
+          fs_name, fileapi::kFileSystemTypeNativeMedia,
+          fileapi::FileSystemMountOption(), path);
     }
-    return fsid;
+    return result;
   }
 
-  std::string RegisterFileSystemForMTPDevice(
-      const std::string& device_id, const base::FilePath& path) {
+  bool RegisterFileSystemForMTPDevice(const std::string& device_id,
+                                      const std::string fs_name,
+                                      const base::FilePath& path) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(!StorageInfo::IsMassStorageDevice(device_id));
 
     // Sanity checks for |path|.
     CHECK(MediaStorageUtil::CanCreateFileSystem(device_id, path));
-    std::string fs_name(extension_misc::kMediaFileSystemPathPart);
-    const std::string fsid =
-        IsolatedContext::GetInstance()->RegisterFileSystemForPath(
-            fileapi::kFileSystemTypeDeviceMedia, path, &fs_name);
-    CHECK(!fsid.empty());
+    bool result = ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
+        fs_name, fileapi::kFileSystemTypeDeviceMedia,
+        fileapi::FileSystemMountOption(), path);
+    CHECK(result);
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE, base::Bind(
             &MTPDeviceMapService::RegisterMTPFileSystem,
             base::Unretained(MTPDeviceMapService::GetInstance()),
-            path.value(), fsid));
-    return fsid;
+            path.value(), fs_name));
+    return result;
   }
 
-  MediaFileSystemRegistry* registry_;
-
   DISALLOW_COPY_AND_ASSIGN(MediaFileSystemContextImpl);
 };
 
 // Constructor in 'private' section because depends on private class definition.
 MediaFileSystemRegistry::MediaFileSystemRegistry()
-    : file_system_context_(new MediaFileSystemContextImpl(this)) {
+    : file_system_context_(new MediaFileSystemContextImpl) {
   StorageMonitor::GetInstance()->AddObserver(this);
 }
 
 MediaFileSystemRegistry::~MediaFileSystemRegistry() {
   // TODO(gbillock): This is needed because the unit test uses the
   // g_browser_process registry. We should create one in the unit test,
   // and then can remove this.
   if (StorageMonitor::GetInstance())
     StorageMonitor::GetInstance()->RemoveObserver(this);
 }
@@ skipping 62 matching lines @@
   DCHECK_EQ(1U, erase_count);
   if (extension_hosts->second.empty()) {
     // When a profile has no ExtensionGalleriesHosts left, remove the
     // matching gallery-change-watcher since it is no longer needed. Leave the
     // |extension_hosts| entry alone, since it indicates the profile has been
     // previously used.
     MediaGalleriesPreferences* preferences = GetPreferences(profile);
     preferences->RemoveGalleryChangeObserver(this);
   }
 }