MediaFileSystemRegistry unit tests.

chrome/browser/media_gallery/media_file_system_registry_unittest.cc

Index: chrome/browser/media_gallery/media_file_system_registry_unittest.cc
diff --git a/chrome/browser/media_gallery/media_file_system_registry_unittest.cc b/chrome/browser/media_gallery/media_file_system_registry_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6a3b4aaed65031f9ac1dfb51226a5c0a66c23c43
--- /dev/null
+++ b/chrome/browser/media_gallery/media_file_system_registry_unittest.cc
@@ -0,0 +1,638 @@
+// 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 "base/command_line.h"
+#include "base/file_util.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
+#include "base/message_loop.h"
+#include "base/scoped_temp_dir.h"
+#include "base/stl_util.h"
+#include "base/stringprintf.h"
+#include "base/utf_string_conversions.h"
+#include "base/values.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/extensions/test_extension_system.h"
+#include "chrome/browser/media_gallery/media_file_system_registry.h"
+#include "chrome/browser/media_gallery/media_galleries_preferences_factory.h"
+#include "chrome/browser/media_gallery/media_galleries_test_util.h"
+#include "chrome/browser/system_monitor/media_storage_util.h"
+#include "chrome/browser/system_monitor/removable_device_constants.h"
+#include "chrome/common/extensions/extension.h"
+#include "chrome/test/base/chrome_render_view_host_test_harness.h"
+#include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/render_process_host_factory.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/test/mock_render_process_host.h"
+#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/web_contents_tester.h"
+#include "sync/api/string_ordinal.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chrome {
+
+class TestMediaFileSystemContext : public MediaFileSystemContext {
+ public:
+  struct FSInfo {
+    FSInfo() {}
+    FSInfo(const std::string& device_id, const FilePath& path,
+           const std::string& fsid);
+
+    bool operator<(const FSInfo& other) const;
+
+    std::string device_id;
+    FilePath path;
+    std::string fsid;
+  };
+
+  explicit TestMediaFileSystemContext(MediaFileSystemRegistry* registry);
+  virtual ~TestMediaFileSystemContext() {}
+
+  // MediaFileSystemContext implementation.
+  virtual std::string RegisterFileSystemForMassStorage(
+      const std::string& device_id, const FilePath& path) OVERRIDE;
+
+#if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
+  virtual std::string RegisterFileSystemForMTPDevice(
+      const std::string& device_id, const FilePath& path,
+      scoped_refptr<ScopedMTPDeviceMapEntry>* entry) OVERRIDE;
+#endif
+
+  virtual void RevokeFileSystem(const std::string& fsid) OVERRIDE;
+
+ private:
+  std::string AddFSEntry(const std::string& device_id, const FilePath& path);
+
+  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_;
+};
+
+TestMediaFileSystemContext::FSInfo::FSInfo(const std::string& device_id,
+                                           const FilePath& path,
+                                           const std::string& fsid)
+    : device_id(device_id),
+      path(path),
+      fsid(fsid) {
+}
+
+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;
+}
+
+TestMediaFileSystemContext::TestMediaFileSystemContext(
+    MediaFileSystemRegistry* registry)
+    : registry_(registry),
+      fsid_(0) {
+  registry_->file_system_context_.reset(this);
+}
+
+std::string TestMediaFileSystemContext::RegisterFileSystemForMassStorage(
+    const std::string& device_id, const FilePath& path) {
+  CHECK(MediaStorageUtil::IsMassStorageDevice(device_id));
+  return AddFSEntry(device_id, path);
+}
+
+#if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
+std::string TestMediaFileSystemContext::RegisterFileSystemForMTPDevice(
+    const std::string& device_id, const FilePath& path,
+    scoped_refptr<ScopedMTPDeviceMapEntry>* entry) {
+  CHECK(!MediaStorageUtil::IsMassStorageDevice(device_id));
+  DCHECK(entry);
+  *entry = registry_->GetOrCreateScopedMTPDeviceMapEntry(path.value());
+  return AddFSEntry(device_id, path);
+}
+#endif
+
+void TestMediaFileSystemContext::RevokeFileSystem(const std::string& fsid) {
+  if (!ContainsKey(file_systems_by_id_, fsid))
+    return;
+  EXPECT_EQ(1U, file_systems_by_id_.erase(fsid));
+}
+
+std::string TestMediaFileSystemContext::AddFSEntry(const std::string& device_id,
+                                                   const FilePath& path) {
+  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;
+}
+
+namespace {
+
+class TestMediaStorageUtil : public MediaStorageUtil {
+ public:
+  static void SetTestingMode();
+
+  static bool GetDeviceInfoFromPathTestFunction(const FilePath& path,
+                                                std::string* device_id,
+                                                string16* device_name,
+                                                FilePath* relative_path);
+};
+
+class MockProfileSharedRenderProcessHostFactory
+    : public content::RenderProcessHostFactory {
+ public:
+  MockProfileSharedRenderProcessHostFactory() {}
+  virtual ~MockProfileSharedRenderProcessHostFactory();
+
+  // RPH created with this factory are owned by it.  If the RPH is destroyed
+  // for testing purposes, it must be removed from the factory first.
+  content::MockRenderProcessHost* ReleaseRPH(
+      content::BrowserContext* browser_context);
+
+  virtual content::RenderProcessHost* CreateRenderProcessHost(
+      content::BrowserContext* browser_context) const OVERRIDE;
+
+ private:
+  typedef std::map<content::BrowserContext*, content::MockRenderProcessHost*>
+      ProfileRPHMap;
+  mutable ProfileRPHMap rph_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockProfileSharedRenderProcessHostFactory);
+};
+
+class ProfileState {
+ public:
+  explicit ProfileState(
+      MockProfileSharedRenderProcessHostFactory* rph_factory);
+  ~ProfileState();
+
+  MediaGalleriesPreferences* GetMediaGalleriesPrefs();
+
+  void CheckGalleries(
+      const std::string& test,
+      const std::vector<MediaFileSystemInfo>& regular_extension_galleries,
+      const std::vector<MediaFileSystemInfo>& all_extension_galleries);
+
+  extensions::Extension* all_permission_extension();
+  extensions::Extension* regular_permission_extension();
+
+ private:
+  void CompareResults(const std::string& test,
+                      const std::vector<MediaFileSystemInfo>& expected,
+                      const std::vector<MediaFileSystemInfo>& actual);
+
+  int GetAndClearComparisonCount();
+
+  int num_comparisons_;
+
+  scoped_ptr<TestingProfile> profile_;
+
+  scoped_refptr<extensions::Extension> all_permission_extension_;
+  scoped_refptr<extensions::Extension> regular_permission_extension_;
+  scoped_refptr<extensions::Extension> no_permissions_extension_;
+
+  scoped_ptr<content::WebContents> single_web_contents_;
+  scoped_ptr<content::WebContents> shared_web_contents1_;
+  scoped_ptr<content::WebContents> shared_web_contents2_;
+
+  // The RenderProcessHosts are freed when their respective WebContents /
+  // RenderViewHosts go away.
+  content::MockRenderProcessHost* single_rph_;
+  content::MockRenderProcessHost* shared_rph_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProfileState);
+};
+
+class MediaFileSystemRegistryTest : public ChromeRenderViewHostTestHarness {
+ public:
+  MediaFileSystemRegistryTest();
+  virtual ~MediaFileSystemRegistryTest() {}
+
+  void CreateProfileState(int profile_count);
+
+  ProfileState* GetProfileState(int i);
+
+  FilePath empty_dir() {
+    return empty_dir_;
+  }
+
+  FilePath dcim_dir() {
+    return dcim_dir_;
+  }
+
+  // Create a user added gallery based on the information passed and add it to
+  // |profiles|. Returns the device id.
+  std::string AddUserGallery(MediaStorageUtil::Type type,
+                             const std::string& unique_id,
+                             const FilePath& path);
+
+  void AttachDevice(MediaStorageUtil::Type type, const std::string& unique_id,
+                    const FilePath& location);
+
+  void DetachDevice(const std::string& device_id);
+
+  void SetGalleryPermission(size_t profile, extensions::Extension* extension,
+                            const std::string& device_id, bool has_access);
+
+  void AssertAllAutoAddedGalleries();
+
+  std::vector<MediaFileSystemInfo> GetAutoAddedGalleries(size_t profile);
+
+ protected:
+  void SetUp();
+  void TearDown();
+
+ private:
+  // This makes sure that at least one default gallery exists on the file
+  // system.
+  EnsureMediaDirectoriesExists media_directories_;
+
+  // Some test gallery directories.
+  ScopedTempDir galleries_dir_;
+  // An empty directory in |galleries_dir_|
+  FilePath empty_dir_;
+  // A directory in |galleries_dir_| with a DCIM directory in it.
+  FilePath dcim_dir_;
+
+  // MediaFileSystemRegistry owns this.
+  TestMediaFileSystemContext* test_file_system_context_;
+
+  // Needed for extension service & friends to work.
+  content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread file_thread_;
+
+  MockProfileSharedRenderProcessHostFactory rph_factory_;
+
+  ScopedVector<ProfileState> profile_states_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaFileSystemRegistryTest);
+};
+
+bool MediaFileSystemInfoComparator(const MediaFileSystemInfo& a,
+                                   const MediaFileSystemInfo& b) {
+  if (a.name != b.name)
+    return a.name < b.name;
+  if (a.path.value() != b.path.value())
+    return a.path.value() < b.path.value();
+  return a.fsid < b.fsid;
+}
+
+//////////////////////////
+// TestMediaStorageUtil //
+//////////////////////////
+
+// static
+void TestMediaStorageUtil::SetTestingMode() {
+  SetGetDeviceInfoFromPathFunctionForTesting(
+      &GetDeviceInfoFromPathTestFunction);
+}
+
+// static
+bool TestMediaStorageUtil::GetDeviceInfoFromPathTestFunction(
+    const FilePath& path, std::string* device_id, string16* device_name,
+    FilePath* relative_path) {
+  if (device_id)
+    *device_id = MakeDeviceId(FIXED_MASS_STORAGE, path.AsUTF8Unsafe());
+  if (device_name)
+    *device_name = path.BaseName().LossyDisplayName();
+  if (relative_path)
+    *relative_path = FilePath();
+  return true;
+}
+
+///////////////////////////////////////////////
+// MockProfileSharedRenderProcessHostFactory //
+///////////////////////////////////////////////
+
+MockProfileSharedRenderProcessHostFactory::
+    ~MockProfileSharedRenderProcessHostFactory() {
+  STLDeleteValues(&rph_map_);
+}
+
+content::MockRenderProcessHost*
+MockProfileSharedRenderProcessHostFactory::ReleaseRPH(
+    content::BrowserContext* browser_context) {
+  ProfileRPHMap::iterator existing = rph_map_.find(browser_context);
+  if (existing == rph_map_.end())
+    return NULL;
+  content::MockRenderProcessHost* result = existing->second;
+  rph_map_.erase(existing);
+  return result;
+}
+
+content::RenderProcessHost*
+MockProfileSharedRenderProcessHostFactory::CreateRenderProcessHost(
+    content::BrowserContext* browser_context) const {
+  ProfileRPHMap::const_iterator existing = rph_map_.find(browser_context);
+  if (existing != rph_map_.end())
+    return existing->second;
+  rph_map_[browser_context] =
+      new content::MockRenderProcessHost(browser_context);
+  return rph_map_[browser_context];
+}
+
+//////////////////
+// ProfileState //
+//////////////////
+
+ProfileState::ProfileState(
+    MockProfileSharedRenderProcessHostFactory* rph_factory)
+    : num_comparisons_(0),
+      profile_(new TestingProfile()) {
+  extensions::TestExtensionSystem* extension_system(
+      static_cast<extensions::TestExtensionSystem*>(
+          extensions::ExtensionSystem::Get(profile_.get())));
+  extension_system->CreateExtensionService(
+      CommandLine::ForCurrentProcess(), FilePath(), false);
+
+  std::vector<std::string> all_permissions;
+  all_permissions.push_back("allAutoDetected");
+  all_permissions.push_back("read");
+  std::vector<std::string> read_permissions;
+  read_permissions.push_back("read");
+
+  all_permission_extension_ =
+      AddMediaGalleriesApp("all", all_permissions, profile_.get());
+  regular_permission_extension_ =
+      AddMediaGalleriesApp("regular", read_permissions, profile_.get());
+  no_permissions_extension_ =
+      AddMediaGalleriesApp("no", read_permissions, profile_.get());
+
+  single_web_contents_.reset(
+      content::WebContentsTester::CreateTestWebContents(profile_.get(), NULL));
+  single_rph_ = rph_factory->ReleaseRPH(profile_.get());
+
+  shared_web_contents1_.reset(
+      content::WebContentsTester::CreateTestWebContents(profile_.get(), NULL));
+  shared_web_contents2_.reset(
+      content::WebContentsTester::CreateTestWebContents(profile_.get(), NULL));
+  shared_rph_ = rph_factory->ReleaseRPH(profile_.get());
+}
+
+ProfileState::~ProfileState() {
+  // TestExtensionSystem uses DeleteSoon, so we need to delete the profiles
+  // and then run the message queue to clean up.  But first we have to
+  // delete everything that references the profile.
+  single_web_contents_.reset();
+  shared_web_contents1_.reset();
+  shared_web_contents2_.reset();
+  profile_.reset();
+
+  MessageLoop::current()->RunUntilIdle();
+}
+
+MediaGalleriesPreferences* ProfileState::GetMediaGalleriesPrefs() {
+  return MediaGalleriesPreferencesFactory::GetForProfile(profile_.get());
+}
+
+void ProfileState::CheckGalleries(
+    const std::string& test,
+    const std::vector<MediaFileSystemInfo>& regular_extension_galleries,
+    const std::vector<MediaFileSystemInfo>& all_extension_galleries) {
+  content::RenderViewHost* rvh = single_web_contents_->GetRenderViewHost();
+
+  // No Media Galleries permissions.
+  std::vector<MediaFileSystemInfo> empty_expectation;
+  MediaFileSystemRegistry::GetInstance()->GetMediaFileSystemsForExtension(
+      rvh, no_permissions_extension_.get(),
+      base::Bind(&ProfileState::CompareResults, base::Unretained(this),
+                 StringPrintf("%s (no permission)", test.c_str()),
+                 base::ConstRef(empty_expectation)));
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1, GetAndClearComparisonCount());
+
+  // Read permission only.
+  MediaFileSystemRegistry::GetInstance()->GetMediaFileSystemsForExtension(
+      rvh, regular_permission_extension_.get(),
+      base::Bind(&ProfileState::CompareResults, base::Unretained(this),
+                 StringPrintf("%s (regular permission)", test.c_str()),
+                 base::ConstRef(regular_extension_galleries)));
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1, GetAndClearComparisonCount());
+
+  // All galleries permission.
+  MediaFileSystemRegistry::GetInstance()->GetMediaFileSystemsForExtension(
+      rvh, all_permission_extension_.get(),
+      base::Bind(&ProfileState::CompareResults, base::Unretained(this),
+                 StringPrintf("%s (all permission)", test.c_str()),
+                 base::ConstRef(all_extension_galleries)));
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1, GetAndClearComparisonCount());
+}
+
+extensions::Extension* ProfileState::all_permission_extension() {
+  return all_permission_extension_.get();
+}
+
+extensions::Extension* ProfileState::regular_permission_extension() {
+  return regular_permission_extension_.get();
+}
+
+void ProfileState::CompareResults(
+    const std::string& test,
+    const std::vector<MediaFileSystemInfo>& expected,
+    const std::vector<MediaFileSystemInfo>& actual) {
+  // Order isn't important, so sort the results.  Assume that expected
+  // is already sorted.
+  std::vector<MediaFileSystemInfo> sorted(actual);
+  std::sort(sorted.begin(), sorted.end(), MediaFileSystemInfoComparator);
+
+  num_comparisons_++;
+  EXPECT_EQ(expected.size(), actual.size()) << test;
+  for (size_t i = 0; i < expected.size() && i < actual.size(); i++) {
+    EXPECT_EQ(expected[i].path.value(), actual[i].path.value()) << test;
+    EXPECT_FALSE(actual[i].fsid.empty()) << test;
+    if (!expected[i].fsid.empty())
+      EXPECT_EQ(expected[i].fsid, actual[i].fsid) << test;
+  }
+}
+
+int ProfileState::GetAndClearComparisonCount() {
+  int result = num_comparisons_;
+  num_comparisons_ = 0;
+  return result;
+}
+
+/////////////////////////////////
+// MediaFileSystemRegistryTest //
+/////////////////////////////////
+
+MediaFileSystemRegistryTest::MediaFileSystemRegistryTest()
+    : ui_thread_(content::BrowserThread::UI, MessageLoop::current()),
+      file_thread_(content::BrowserThread::FILE, MessageLoop::current()) {
+}
+
+void MediaFileSystemRegistryTest::CreateProfileState(int profile_count) {
+  for (int i = 0; i < profile_count; i++) {
+    ProfileState * state = new ProfileState(&rph_factory_);
+    profile_states_.push_back(state);
+  }
+}
+
+ProfileState* MediaFileSystemRegistryTest::GetProfileState(int i) {
+  return profile_states_[i];
+}
+
+std::string MediaFileSystemRegistryTest::AddUserGallery(
+    MediaStorageUtil::Type type,
+    const std::string& unique_id,
+    const FilePath& path) {
+  std::string device_id = MediaStorageUtil::MakeDeviceId(type, unique_id);
+  string16 name = path.LossyDisplayName();
+  DCHECK(!MediaStorageUtil::IsMediaDevice(device_id));
+
+  for (size_t i = 0; i < profile_states_.size(); i++) {
+    profile_states_[i]->GetMediaGalleriesPrefs()->AddGallery(
+        device_id, name, FilePath(), true /*user_added*/);
+  }
+  return device_id;
+}
+
+void MediaFileSystemRegistryTest::AttachDevice(MediaStorageUtil::Type type,
+                                               const std::string& unique_id,
+                                               const FilePath& location) {
+  std::string device_id = MediaStorageUtil::MakeDeviceId(type, unique_id);
+  DCHECK(MediaStorageUtil::IsRemovableDevice(device_id));
+  string16 name = location.LossyDisplayName();
+  base::SystemMonitor::Get()->ProcessRemovableStorageAttached(device_id, name,
+                                                              location.value());
+}
+
+void MediaFileSystemRegistryTest::DetachDevice(const std::string& device_id) {
+  DCHECK(MediaStorageUtil::IsRemovableDevice(device_id));
+  base::SystemMonitor::Get()->ProcessRemovableStorageDetached(device_id);
+}
+
+void MediaFileSystemRegistryTest::SetGalleryPermission(
+    size_t profile, extensions::Extension* extension,
+    const std::string& device_id, bool has_access) {
+  MediaGalleriesPreferences* preferences =
+      GetProfileState(profile)->GetMediaGalleriesPrefs();
+  MediaGalleryPrefIdSet pref_id =
+      preferences->LookUpGalleriesByDeviceId(device_id);
+  DCHECK_EQ(1U, pref_id.size());
+  preferences->SetGalleryPermissionForExtension(*extension, *pref_id.begin(),
+                                                has_access);
+}
+
+void MediaFileSystemRegistryTest::AssertAllAutoAddedGalleries() {
+  for (size_t i = 0; i < profile_states_.size(); i++) {
+    MediaGalleriesPreferences* prefs =
+        profile_states_[0]->GetMediaGalleriesPrefs();
+
+    // Make sure that we have at least one gallery and that they are all
+    // auto added galleries.
+    const MediaGalleriesPrefInfoMap& galleries = prefs->known_galleries();
+#if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
+    ASSERT_GT(galleries.size(), 0U);
+#endif
+    for (MediaGalleriesPrefInfoMap::const_iterator it = galleries.begin();
+         it != galleries.end();
+         ++it) {
+      ASSERT_EQ(MediaGalleryPrefInfo::kAutoDetected, it->second.type);
+    }
+  }
+}
+
+std::vector<MediaFileSystemInfo>
+MediaFileSystemRegistryTest::GetAutoAddedGalleries(size_t profile) {
+  DCHECK_LT(profile, profile_states_.size());
+  const MediaGalleriesPrefInfoMap& galleries =
+      GetProfileState(profile)->GetMediaGalleriesPrefs()->known_galleries();
+  std::vector<MediaFileSystemInfo> result;
+  for (MediaGalleriesPrefInfoMap::const_iterator it = galleries.begin();
+       it != galleries.end();
+       ++it) {
+    if (it->second.type == MediaGalleryPrefInfo::kAutoDetected) {
+      FilePath path = it->second.AbsolutePath();
+      MediaFileSystemInfo info(std::string(), path, std::string());
+      result.push_back(info);
+    }
+  }
+  std::sort(result.begin(), result.end(), MediaFileSystemInfoComparator);
+  return result;
+}
+
+void MediaFileSystemRegistryTest::SetUp() {
+  ChromeRenderViewHostTestHarness::SetUp();
+  DeleteContents();
+  SetRenderProcessHostFactory(&rph_factory_);
+
+  TestMediaStorageUtil::SetTestingMode();
+  test_file_system_context_ =
+      new TestMediaFileSystemContext(MediaFileSystemRegistry::GetInstance());
+
+  ASSERT_TRUE(galleries_dir_.CreateUniqueTempDir());
+  empty_dir_ = galleries_dir_.path().AppendASCII("empty");
+  ASSERT_TRUE(file_util::CreateDirectory(empty_dir_));
+  dcim_dir_ = galleries_dir_.path().AppendASCII("with_dcim");
+  ASSERT_TRUE(file_util::CreateDirectory(dcim_dir_));
+  ASSERT_TRUE(file_util::CreateDirectory(dcim_dir_.Append(kDCIMDirectoryName)));
+}
+
+void MediaFileSystemRegistryTest::TearDown() {
+  profile_states_.clear();
+  ChromeRenderViewHostTestHarness::TearDown();
+  MediaFileSystemRegistry* registry = MediaFileSystemRegistry::GetInstance();
+  EXPECT_EQ(0U, registry->GetExtensionHostCountForTests());
+}
+
+///////////
+// Tests //
+///////////
+
+TEST_F(MediaFileSystemRegistryTest, Basic) {
+  CreateProfileState(1);
+  AssertAllAutoAddedGalleries();
+
+  std::vector<MediaFileSystemInfo> empty_expectation;
+  std::vector<MediaFileSystemInfo> auto_galleries = GetAutoAddedGalleries(0);
+  GetProfileState(0)->CheckGalleries("basic", empty_expectation,
+                                     auto_galleries);
+}
+
+TEST_F(MediaFileSystemRegistryTest, UserAddedGallery) {
+  CreateProfileState(1);
+  AssertAllAutoAddedGalleries();
+
+  std::vector<MediaFileSystemInfo> added_galleries;
+  std::vector<MediaFileSystemInfo> auto_galleries = GetAutoAddedGalleries(0);
+  GetProfileState(0)->CheckGalleries("user added init", added_galleries,
+                                     auto_galleries);
+
+  // Add a user gallery to the regular permission extension.
+  std::string device_id = AddUserGallery(MediaStorageUtil::FIXED_MASS_STORAGE,
+                                         empty_dir().AsUTF8Unsafe(),
+                                         empty_dir());
+  SetGalleryPermission(0,
+                       GetProfileState(0)->regular_permission_extension(),
+                       device_id,
+                       true /*has access*/);
+  MediaFileSystemInfo added_info(empty_dir().AsUTF8Unsafe(), empty_dir(),
+                                 std::string());
+  added_galleries.push_back(added_info);
+  GetProfileState(0)->CheckGalleries("user added regular", added_galleries,
+                                     auto_galleries);
+
+  // Add it to the all galleries extension.
+  SetGalleryPermission(0, GetProfileState(0)->all_permission_extension(),
+                       device_id, true /*has access*/);
+  auto_galleries.push_back(added_info);
+  GetProfileState(0)->CheckGalleries("user added all", added_galleries,
+                                     auto_galleries);
+}
+
+}  // namespace
+
+}  // namespace chrome