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

chrome/browser/media_galleries/media_file_system_registry_unittest.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.
 
 // MediaFileSystemRegistry unit tests.
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind_helpers.h"
@@ skipping 47 matching lines @@
 using storage_monitor::StorageInfo;
 using storage_monitor::StorageMonitor;
 using storage_monitor::TestStorageMonitor;
 
 // Not anonymous so it can be friends with MediaFileSystemRegistry.
 class TestMediaFileSystemContext : public MediaFileSystemContext {
  public:
   struct FSInfo {
     FSInfo() {}
     FSInfo(const std::string& device_id, const base::FilePath& path,
-           const std::string& fsid);
+           const std::string& fs_name);
 
     bool operator<(const FSInfo& other) const;
 
     std::string device_id;
     base::FilePath path;
-    std::string fsid;
+    std::string fs_name;
   };
 
   explicit TestMediaFileSystemContext(MediaFileSystemRegistry* registry);
   virtual ~TestMediaFileSystemContext() {}
 
   // MediaFileSystemContext implementation.
-  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;
 
-  virtual void RevokeFileSystem(const std::string& fsid) OVERRIDE;
+  virtual void RevokeFileSystem(const std::string& fs_name) OVERRIDE;
 
-  base::FilePath GetPathForId(const std::string& fsid) const;
+  virtual base::FilePath GetRegisteredPath(
+      const std::string& fs_name) const OVERRIDE;
 
   MediaFileSystemRegistry* registry() { return registry_; }
 
  private:
-  std::string AddFSEntry(const std::string& device_id,
-                         const base::FilePath& path);
+  void AddFSEntry(const std::string& device_id,
+                  const base::FilePath& path,
+                  const std::string& fs_name);
 
   MediaFileSystemRegistry* registry_;
 
-  // A counter used to construct mock FSIDs.
-  int fsid_;
-
   // The currently allocated mock file systems.
-  std::map<std::string /*fsid*/, FSInfo> file_systems_by_id_;
+  std::map<std::string /*fs_name*/, FSInfo> file_systems_by_name_;
 };
 
 TestMediaFileSystemContext::FSInfo::FSInfo(const std::string& device_id,
                                            const base::FilePath& path,
-                                           const std::string& fsid)
+                                           const std::string& fs_name)
     : device_id(device_id),
       path(path),
-      fsid(fsid) {
+      fs_name(fs_name) {
 }
 
 bool TestMediaFileSystemContext::FSInfo::operator<(const FSInfo& other) const {
   if (device_id != other.device_id)
     return device_id < other.device_id;
   if (path.value() != other.path.value())
     return path.value() < other.path.value();
-  return fsid < other.fsid;
+  return fs_name < other.fs_name;
 }
 
 TestMediaFileSystemContext::TestMediaFileSystemContext(
     MediaFileSystemRegistry* registry)
-    : registry_(registry),
-      fsid_(0) {
+    : registry_(registry) {
   registry_->file_system_context_.reset(this);
 }
 
-std::string TestMediaFileSystemContext::RegisterFileSystem(
-    const std::string& device_id, const base::FilePath& path) {
-  std::string fsid = AddFSEntry(device_id, path);
-  return fsid;
+bool TestMediaFileSystemContext::RegisterFileSystem(
+    const std::string& device_id,
+    const std::string& fs_name,
+    const base::FilePath& path) {
+  AddFSEntry(device_id, path, fs_name);
+  return true;
 }
 
-void TestMediaFileSystemContext::RevokeFileSystem(const std::string& fsid) {
-  if (!ContainsKey(file_systems_by_id_, fsid))
+void TestMediaFileSystemContext::RevokeFileSystem(const std::string& fs_name) {
+  if (!ContainsKey(file_systems_by_name_, fs_name))
     return;
-  EXPECT_EQ(1U, file_systems_by_id_.erase(fsid));
+  EXPECT_EQ(1U, file_systems_by_name_.erase(fs_name));
 }
 
-base::FilePath TestMediaFileSystemContext::GetPathForId(
-    const std::string& fsid) const {
-  std::map<std::string /*fsid*/, FSInfo>::const_iterator it =
-      file_systems_by_id_.find(fsid);
-  if (it == file_systems_by_id_.end())
+base::FilePath TestMediaFileSystemContext::GetRegisteredPath(
+    const std::string& fs_name) const {
+  std::map<std::string /*fs_name*/, FSInfo>::const_iterator it =
+      file_systems_by_name_.find(fs_name);
+  if (it == file_systems_by_name_.end())
     return base::FilePath();
   return it->second.path;
 }
 
-std::string TestMediaFileSystemContext::AddFSEntry(const std::string& device_id,
-                                                   const base::FilePath& path) {
+void TestMediaFileSystemContext::AddFSEntry(const std::string& device_id,
+                                            const base::FilePath& path,
+                                            const std::string& fs_name) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(path.IsAbsolute());
   DCHECK(!path.ReferencesParent());
 
-  std::string fsid = base::StringPrintf("FSID:%d", ++fsid_);
-  FSInfo info(device_id, path, fsid);
-  file_systems_by_id_[fsid] = info;
-  return fsid;
+  FSInfo info(device_id, path, fs_name);
+  file_systems_by_name_[fs_name] = info;
 }
 
 namespace {
 
 typedef std::map<MediaGalleryPrefId, MediaFileSystemInfo> FSInfoMap;
 
 void GetGalleryInfoCallback(
     FSInfoMap* results,
     const std::vector<MediaFileSystemInfo>& file_systems) {
   for (size_t i = 0; i < file_systems.size(); ++i) {
@@ skipping 10 matching lines @@
   EXPECT_EQ(path, info.path);
   EXPECT_EQ(removable, info.removable);
   EXPECT_EQ(media_device, info.media_device);
   EXPECT_NE(0UL, info.pref_id);
 
   if (removable)
     EXPECT_NE(0UL, info.transient_device_id.size());
   else
     EXPECT_EQ(0UL, info.transient_device_id.size());
 
-  base::FilePath fsid_path = fs_context->GetPathForId(info.fsid);
+  base::FilePath fsid_path = fs_context->GetRegisteredPath(info.fsid);
   EXPECT_EQ(path, fsid_path);
 }
 
 class MockProfileSharedRenderProcessHostFactory
     : public content::RenderProcessHostFactory {
  public:
   MockProfileSharedRenderProcessHostFactory() {}
   virtual ~MockProfileSharedRenderProcessHostFactory();
 
   // RPH created with this factory are owned by it.  If the RPH is destroyed
@@ skipping 862 matching lines @@
                                          empty_dir());
   ProfileState* profile_state = GetProfileState(0);
   SetGalleryPermission(profile_state,
                        profile_state->regular_permission_extension(),
                        device_id,
                        true /*has access*/);
 
   FSInfoMap fs_info = profile_state->GetGalleriesInfo(
       profile_state->regular_permission_extension());
   ASSERT_EQ(1U, fs_info.size());
-  EXPECT_FALSE(test_file_system_context()->GetPathForId(
+  EXPECT_FALSE(test_file_system_context()->GetRegisteredPath(
       fs_info.begin()->second.fsid).empty());
 
   // Revoke permission and ensure that the file system is revoked.
   SetGalleryPermission(profile_state,
                        profile_state->regular_permission_extension(),
                        device_id,
                        false /*has access*/);
-  EXPECT_TRUE(test_file_system_context()->GetPathForId(
+  EXPECT_TRUE(test_file_system_context()->GetRegisteredPath(
       fs_info.begin()->second.fsid).empty());
 }