Home | History | Annotate | Download | only in media_galleries 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 // MediaFileSystemRegistry unit tests.
      6 
      7 #include <algorithm>
      8 #include <set>
      9 
     10 #include "base/bind_helpers.h"
     11 #include "base/command_line.h"
     12 #include "base/files/file_util.h"
     13 #include "base/files/scoped_temp_dir.h"
     14 #include "base/memory/ref_counted.h"
     15 #include "base/memory/scoped_ptr.h"
     16 #include "base/memory/scoped_vector.h"
     17 #include "base/message_loop/message_loop.h"
     18 #include "base/path_service.h"
     19 #include "base/run_loop.h"
     20 #include "base/stl_util.h"
     21 #include "base/strings/stringprintf.h"
     22 #include "base/strings/utf_string_conversions.h"
     23 #include "base/threading/sequenced_worker_pool.h"
     24 #include "base/values.h"
     25 #include "chrome/browser/extensions/extension_service.h"
     26 #include "chrome/browser/extensions/test_extension_system.h"
     27 #include "chrome/browser/media_galleries/media_file_system_context.h"
     28 #include "chrome/browser/media_galleries/media_file_system_registry.h"
     29 #include "chrome/browser/media_galleries/media_galleries_preferences_factory.h"
     30 #include "chrome/browser/media_galleries/media_galleries_test_util.h"
     31 #include "chrome/common/chrome_paths.h"
     32 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
     33 #include "chrome/test/base/testing_browser_process.h"
     34 #include "chrome/test/base/testing_profile.h"
     35 #include "components/storage_monitor/removable_device_constants.h"
     36 #include "components/storage_monitor/storage_info.h"
     37 #include "components/storage_monitor/storage_monitor.h"
     38 #include "components/storage_monitor/test_storage_monitor.h"
     39 #include "content/public/browser/render_process_host.h"
     40 #include "content/public/browser/render_process_host_factory.h"
     41 #include "content/public/browser/render_view_host.h"
     42 #include "content/public/browser/web_contents.h"
     43 #include "content/public/test/mock_render_process_host.h"
     44 #include "content/public/test/test_browser_thread.h"
     45 #include "content/public/test/web_contents_tester.h"
     46 #include "extensions/browser/extension_system.h"
     47 #include "extensions/common/extension.h"
     48 #include "sync/api/string_ordinal.h"
     49 #include "testing/gtest/include/gtest/gtest.h"
     50 
     51 #if defined(OS_CHROMEOS)
     52 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
     53 #include "chrome/browser/chromeos/settings/cros_settings.h"
     54 #include "chrome/browser/chromeos/settings/device_settings_service.h"
     55 #endif
     56 
     57 using content::BrowserThread;
     58 using storage_monitor::StorageInfo;
     59 using storage_monitor::StorageMonitor;
     60 using storage_monitor::TestStorageMonitor;
     61 
     62 // Not anonymous so it can be friends with MediaFileSystemRegistry.
     63 class TestMediaFileSystemContext : public MediaFileSystemContext {
     64  public:
     65   struct FSInfo {
     66     FSInfo() {}
     67     FSInfo(const std::string& device_id, const base::FilePath& path,
     68            const std::string& fs_name);
     69 
     70     bool operator<(const FSInfo& other) const;
     71 
     72     std::string device_id;
     73     base::FilePath path;
     74     std::string fs_name;
     75   };
     76 
     77   explicit TestMediaFileSystemContext(MediaFileSystemRegistry* registry);
     78   virtual ~TestMediaFileSystemContext() {}
     79 
     80   // MediaFileSystemContext implementation.
     81   virtual bool RegisterFileSystem(const std::string& device_id,
     82                                   const std::string& fs_name,
     83                                   const base::FilePath& path) OVERRIDE;
     84 
     85   virtual void RevokeFileSystem(const std::string& fs_name) OVERRIDE;
     86 
     87   virtual base::FilePath GetRegisteredPath(
     88       const std::string& fs_name) const OVERRIDE;
     89 
     90   MediaFileSystemRegistry* registry() { return registry_; }
     91 
     92  private:
     93   void AddFSEntry(const std::string& device_id,
     94                   const base::FilePath& path,
     95                   const std::string& fs_name);
     96 
     97   MediaFileSystemRegistry* registry_;
     98 
     99   // The currently allocated mock file systems.
    100   std::map<std::string /*fs_name*/, FSInfo> file_systems_by_name_;
    101 };
    102 
    103 TestMediaFileSystemContext::FSInfo::FSInfo(const std::string& device_id,
    104                                            const base::FilePath& path,
    105                                            const std::string& fs_name)
    106     : device_id(device_id),
    107       path(path),
    108       fs_name(fs_name) {
    109 }
    110 
    111 bool TestMediaFileSystemContext::FSInfo::operator<(const FSInfo& other) const {
    112   if (device_id != other.device_id)
    113     return device_id < other.device_id;
    114   if (path.value() != other.path.value())
    115     return path.value() < other.path.value();
    116   return fs_name < other.fs_name;
    117 }
    118 
    119 TestMediaFileSystemContext::TestMediaFileSystemContext(
    120     MediaFileSystemRegistry* registry)
    121     : registry_(registry) {
    122   registry_->file_system_context_.reset(this);
    123 }
    124 
    125 bool TestMediaFileSystemContext::RegisterFileSystem(
    126     const std::string& device_id,
    127     const std::string& fs_name,
    128     const base::FilePath& path) {
    129   AddFSEntry(device_id, path, fs_name);
    130   return true;
    131 }
    132 
    133 void TestMediaFileSystemContext::RevokeFileSystem(const std::string& fs_name) {
    134   if (!ContainsKey(file_systems_by_name_, fs_name))
    135     return;
    136   EXPECT_EQ(1U, file_systems_by_name_.erase(fs_name));
    137 }
    138 
    139 base::FilePath TestMediaFileSystemContext::GetRegisteredPath(
    140     const std::string& fs_name) const {
    141   std::map<std::string /*fs_name*/, FSInfo>::const_iterator it =
    142       file_systems_by_name_.find(fs_name);
    143   if (it == file_systems_by_name_.end())
    144     return base::FilePath();
    145   return it->second.path;
    146 }
    147 
    148 void TestMediaFileSystemContext::AddFSEntry(const std::string& device_id,
    149                                             const base::FilePath& path,
    150                                             const std::string& fs_name) {
    151   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    152   DCHECK(path.IsAbsolute());
    153   DCHECK(!path.ReferencesParent());
    154 
    155   FSInfo info(device_id, path, fs_name);
    156   file_systems_by_name_[fs_name] = info;
    157 }
    158 
    159 namespace {
    160 
    161 typedef std::map<MediaGalleryPrefId, MediaFileSystemInfo> FSInfoMap;
    162 
    163 void GetGalleryInfoCallback(
    164     FSInfoMap* results,
    165     const std::vector<MediaFileSystemInfo>& file_systems) {
    166   for (size_t i = 0; i < file_systems.size(); ++i) {
    167     ASSERT_FALSE(ContainsKey(*results, file_systems[i].pref_id));
    168     (*results)[file_systems[i].pref_id] = file_systems[i];
    169   }
    170 }
    171 
    172 void CheckGalleryInfo(const MediaFileSystemInfo& info,
    173                       TestMediaFileSystemContext* fs_context,
    174                       const base::FilePath& path,
    175                       bool removable,
    176                       bool media_device) {
    177   EXPECT_EQ(path, info.path);
    178   EXPECT_EQ(removable, info.removable);
    179   EXPECT_EQ(media_device, info.media_device);
    180   EXPECT_NE(0UL, info.pref_id);
    181 
    182   if (removable)
    183     EXPECT_NE(0UL, info.transient_device_id.size());
    184   else
    185     EXPECT_EQ(0UL, info.transient_device_id.size());
    186 
    187   base::FilePath fsid_path = fs_context->GetRegisteredPath(info.fsid);
    188   EXPECT_EQ(path, fsid_path);
    189 }
    190 
    191 class MockProfileSharedRenderProcessHostFactory
    192     : public content::RenderProcessHostFactory {
    193  public:
    194   MockProfileSharedRenderProcessHostFactory() {}
    195   virtual ~MockProfileSharedRenderProcessHostFactory();
    196 
    197   // RPH created with this factory are owned by it.  If the RPH is destroyed
    198   // for testing purposes, it must be removed from the factory first.
    199   content::MockRenderProcessHost* ReleaseRPH(
    200       content::BrowserContext* browser_context);
    201 
    202   virtual content::RenderProcessHost* CreateRenderProcessHost(
    203       content::BrowserContext* browser_context,
    204       content::SiteInstance* site_instance) const OVERRIDE;
    205 
    206  private:
    207   typedef std::map<content::BrowserContext*, content::MockRenderProcessHost*>
    208       ProfileRPHMap;
    209   mutable ProfileRPHMap rph_map_;
    210 
    211   DISALLOW_COPY_AND_ASSIGN(MockProfileSharedRenderProcessHostFactory);
    212 };
    213 
    214 class ProfileState {
    215  public:
    216   explicit ProfileState(
    217       MockProfileSharedRenderProcessHostFactory* rph_factory);
    218   ~ProfileState();
    219 
    220   MediaGalleriesPreferences* GetMediaGalleriesPrefs();
    221 
    222   void CheckGalleries(
    223       const std::string& test,
    224       const std::vector<MediaFileSystemInfo>& regular_extension_galleries,
    225       const std::vector<MediaFileSystemInfo>& all_extension_galleries);
    226 
    227   FSInfoMap GetGalleriesInfo(extensions::Extension* extension);
    228 
    229   extensions::Extension* all_permission_extension();
    230   extensions::Extension* regular_permission_extension();
    231   Profile* profile();
    232 
    233   void AddNameForReadCompare(const base::string16& name);
    234   void AddNameForAllCompare(const base::string16& name);
    235 
    236  private:
    237   void CompareResults(const std::string& test,
    238                       const std::vector<base::string16>& names,
    239                       const std::vector<MediaFileSystemInfo>& expected,
    240                       const std::vector<MediaFileSystemInfo>& actual);
    241   bool ContainsEntry(const MediaFileSystemInfo& info,
    242                      const std::vector<MediaFileSystemInfo>& container);
    243 
    244   int GetAndClearComparisonCount();
    245 
    246   int num_comparisons_;
    247 
    248   scoped_ptr<TestingProfile> profile_;
    249 
    250   scoped_refptr<extensions::Extension> all_permission_extension_;
    251   scoped_refptr<extensions::Extension> regular_permission_extension_;
    252   scoped_refptr<extensions::Extension> no_permissions_extension_;
    253 
    254   scoped_ptr<content::WebContents> single_web_contents_;
    255   scoped_ptr<content::WebContents> shared_web_contents1_;
    256   scoped_ptr<content::WebContents> shared_web_contents2_;
    257 
    258   // The RenderProcessHosts are freed when their respective WebContents /
    259   // RenderViewHosts go away.
    260   content::MockRenderProcessHost* single_rph_;
    261   content::MockRenderProcessHost* shared_rph_;
    262 
    263   std::vector<base::string16> compare_names_read_;
    264   std::vector<base::string16> compare_names_all_;
    265 
    266   DISALLOW_COPY_AND_ASSIGN(ProfileState);
    267 };
    268 
    269 base::string16 GetExpectedFolderName(const base::FilePath& path) {
    270 #if defined(OS_CHROMEOS)
    271   return path.BaseName().LossyDisplayName();
    272 #else
    273   return path.LossyDisplayName();
    274 #endif
    275 }
    276 
    277 }  // namespace
    278 
    279 class MediaFileSystemRegistryTest : public ChromeRenderViewHostTestHarness {
    280  public:
    281   void CreateProfileState(size_t profile_count);
    282 
    283   ProfileState* GetProfileState(size_t i);
    284 
    285   MediaGalleriesPreferences* GetPreferences(Profile* profile);
    286 
    287   base::FilePath empty_dir() {
    288     return empty_dir_;
    289   }
    290 
    291   base::FilePath dcim_dir() {
    292     return dcim_dir_;
    293   }
    294 
    295   TestMediaFileSystemContext* test_file_system_context() {
    296     return test_file_system_context_;
    297   }
    298 
    299   // Create a user added gallery based on the information passed and add it to
    300   // |profiles|. Returns the device id.
    301   std::string AddUserGallery(StorageInfo::Type type,
    302                              const std::string& unique_id,
    303                              const base::FilePath& path);
    304 
    305   // Returns the device id.
    306   std::string AttachDevice(StorageInfo::Type type,
    307                            const std::string& unique_id,
    308                            const base::FilePath& location);
    309 
    310   void DetachDevice(const std::string& device_id);
    311 
    312   void SetGalleryPermission(ProfileState* profile_state,
    313                             extensions::Extension* extension,
    314                             const std::string& device_id,
    315                             bool has_access);
    316 
    317   void AssertAllAutoAddedGalleries();
    318 
    319   void InitForGalleriesInfoTest(FSInfoMap* galleries_info);
    320 
    321   void CheckNewGalleryInfo(ProfileState* profile_state,
    322                            const FSInfoMap& galleries_info,
    323                            const base::FilePath& location,
    324                            bool removable,
    325                            bool media_device);
    326 
    327   std::vector<MediaFileSystemInfo> GetAutoAddedGalleries(
    328       ProfileState* profile_state);
    329 
    330   void ProcessAttach(const std::string& id,
    331                      const base::string16& name,
    332                      const base::FilePath::StringType& location) {
    333     StorageInfo info(id, location, name, base::string16(), base::string16(), 0);
    334     StorageMonitor::GetInstance()->receiver()->ProcessAttach(info);
    335   }
    336 
    337   void ProcessDetach(const std::string& id) {
    338     StorageMonitor::GetInstance()->receiver()->ProcessDetach(id);
    339   }
    340 
    341   MediaFileSystemRegistry* registry() {
    342     return test_file_system_context_->registry();
    343   }
    344 
    345   size_t GetExtensionGalleriesHostCount(
    346       const MediaFileSystemRegistry* registry) const;
    347 
    348   int num_auto_galleries() {
    349     return media_directories_.num_galleries();
    350   }
    351 
    352  protected:
    353   virtual void SetUp() OVERRIDE;
    354   virtual void TearDown() OVERRIDE;
    355 
    356  private:
    357   // This makes sure that at least one default gallery exists on the file
    358   // system.
    359   EnsureMediaDirectoriesExists media_directories_;
    360 
    361   // Some test gallery directories.
    362   base::ScopedTempDir galleries_dir_;
    363   // An empty directory in |galleries_dir_|
    364   base::FilePath empty_dir_;
    365   // A directory in |galleries_dir_| with a DCIM directory in it.
    366   base::FilePath dcim_dir_;
    367 
    368   // MediaFileSystemRegistry owns this.
    369   TestMediaFileSystemContext* test_file_system_context_;
    370 
    371   // Needed for extension service & friends to work.
    372 
    373 #if defined(OS_CHROMEOS)
    374   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
    375   chromeos::ScopedTestCrosSettings test_cros_settings_;
    376   scoped_ptr<chromeos::ScopedTestUserManager> test_user_manager_;
    377 #endif
    378 
    379   MockProfileSharedRenderProcessHostFactory rph_factory_;
    380 
    381   ScopedVector<ProfileState> profile_states_;
    382 };
    383 
    384 namespace {
    385 
    386 bool MediaFileSystemInfoComparator(const MediaFileSystemInfo& a,
    387                                    const MediaFileSystemInfo& b) {
    388   CHECK_NE(a.name, b.name);  // Name must be unique.
    389   return a.name < b.name;
    390 }
    391 
    392 ///////////////////////////////////////////////
    393 // MockProfileSharedRenderProcessHostFactory //
    394 ///////////////////////////////////////////////
    395 
    396 MockProfileSharedRenderProcessHostFactory::
    397     ~MockProfileSharedRenderProcessHostFactory() {
    398   STLDeleteValues(&rph_map_);
    399 }
    400 
    401 content::MockRenderProcessHost*
    402 MockProfileSharedRenderProcessHostFactory::ReleaseRPH(
    403     content::BrowserContext* browser_context) {
    404   ProfileRPHMap::iterator existing = rph_map_.find(browser_context);
    405   if (existing == rph_map_.end())
    406     return NULL;
    407   content::MockRenderProcessHost* result = existing->second;
    408   rph_map_.erase(existing);
    409   return result;
    410 }
    411 
    412 content::RenderProcessHost*
    413 MockProfileSharedRenderProcessHostFactory::CreateRenderProcessHost(
    414     content::BrowserContext* browser_context,
    415     content::SiteInstance* site_instance) const {
    416   ProfileRPHMap::const_iterator existing = rph_map_.find(browser_context);
    417   if (existing != rph_map_.end())
    418     return existing->second;
    419   rph_map_[browser_context] =
    420       new content::MockRenderProcessHost(browser_context);
    421   return rph_map_[browser_context];
    422 }
    423 
    424 //////////////////
    425 // ProfileState //
    426 //////////////////
    427 
    428 ProfileState::ProfileState(
    429     MockProfileSharedRenderProcessHostFactory* rph_factory)
    430     : num_comparisons_(0),
    431       profile_(new TestingProfile()) {
    432   extensions::TestExtensionSystem* extension_system(
    433       static_cast<extensions::TestExtensionSystem*>(
    434           extensions::ExtensionSystem::Get(profile_.get())));
    435   extension_system->CreateExtensionService(
    436       CommandLine::ForCurrentProcess(), base::FilePath(), false);
    437 
    438   std::vector<std::string> all_permissions;
    439   all_permissions.push_back("allAutoDetected");
    440   all_permissions.push_back("read");
    441   std::vector<std::string> read_permissions;
    442   read_permissions.push_back("read");
    443 
    444   all_permission_extension_ =
    445       AddMediaGalleriesApp("all", all_permissions, profile_.get());
    446   regular_permission_extension_ =
    447       AddMediaGalleriesApp("regular", read_permissions, profile_.get());
    448   no_permissions_extension_ =
    449       AddMediaGalleriesApp("no", read_permissions, profile_.get());
    450 
    451   single_web_contents_.reset(
    452       content::WebContentsTester::CreateTestWebContents(profile_.get(), NULL));
    453   single_rph_ = rph_factory->ReleaseRPH(profile_.get());
    454 
    455   shared_web_contents1_.reset(
    456       content::WebContentsTester::CreateTestWebContents(profile_.get(), NULL));
    457   shared_web_contents2_.reset(
    458       content::WebContentsTester::CreateTestWebContents(profile_.get(), NULL));
    459   shared_rph_ = rph_factory->ReleaseRPH(profile_.get());
    460 }
    461 
    462 ProfileState::~ProfileState() {
    463   // TestExtensionSystem uses DeleteSoon, so we need to delete the profiles
    464   // and then run the message queue to clean up.  But first we have to
    465   // delete everything that references the profile.
    466   single_web_contents_.reset();
    467   shared_web_contents1_.reset();
    468   shared_web_contents2_.reset();
    469   profile_.reset();
    470 
    471   base::MessageLoop::current()->RunUntilIdle();
    472 }
    473 
    474 MediaGalleriesPreferences* ProfileState::GetMediaGalleriesPrefs() {
    475   MediaGalleriesPreferences* prefs =
    476       MediaGalleriesPreferencesFactory::GetForProfile(profile_.get());
    477   base::RunLoop loop;
    478   prefs->EnsureInitialized(loop.QuitClosure());
    479   loop.Run();
    480   return prefs;
    481 }
    482 
    483 void ProfileState::CheckGalleries(
    484     const std::string& test,
    485     const std::vector<MediaFileSystemInfo>& regular_extension_galleries,
    486     const std::vector<MediaFileSystemInfo>& all_extension_galleries) {
    487   content::RenderViewHost* rvh = single_web_contents_->GetRenderViewHost();
    488   MediaFileSystemRegistry* registry =
    489       g_browser_process->media_file_system_registry();
    490 
    491   // No Media Galleries permissions.
    492   std::vector<MediaFileSystemInfo> empty_expectation;
    493   std::vector<base::string16> empty_names;
    494   registry->GetMediaFileSystemsForExtension(
    495       rvh, no_permissions_extension_.get(),
    496       base::Bind(&ProfileState::CompareResults, base::Unretained(this),
    497                  base::StringPrintf("%s (no permission)", test.c_str()),
    498                  base::ConstRef(empty_names),
    499                  base::ConstRef(empty_expectation)));
    500   base::MessageLoop::current()->RunUntilIdle();
    501   EXPECT_EQ(1, GetAndClearComparisonCount());
    502 
    503   // Read permission only.
    504   registry->GetMediaFileSystemsForExtension(
    505       rvh, regular_permission_extension_.get(),
    506       base::Bind(&ProfileState::CompareResults, base::Unretained(this),
    507                  base::StringPrintf("%s (regular permission)", test.c_str()),
    508                  base::ConstRef(compare_names_read_),
    509                  base::ConstRef(regular_extension_galleries)));
    510   base::MessageLoop::current()->RunUntilIdle();
    511   EXPECT_EQ(1, GetAndClearComparisonCount());
    512 
    513   // All galleries permission.
    514   registry->GetMediaFileSystemsForExtension(
    515       rvh, all_permission_extension_.get(),
    516       base::Bind(&ProfileState::CompareResults, base::Unretained(this),
    517                  base::StringPrintf("%s (all permission)", test.c_str()),
    518                  base::ConstRef(compare_names_all_),
    519                  base::ConstRef(all_extension_galleries)));
    520   base::MessageLoop::current()->RunUntilIdle();
    521   EXPECT_EQ(1, GetAndClearComparisonCount());
    522 }
    523 
    524 FSInfoMap ProfileState::GetGalleriesInfo(extensions::Extension* extension) {
    525   content::RenderViewHost* rvh = single_web_contents_->GetRenderViewHost();
    526   FSInfoMap results;
    527   MediaFileSystemRegistry* registry =
    528       g_browser_process->media_file_system_registry();
    529   registry->GetMediaFileSystemsForExtension(
    530       rvh, extension,
    531       base::Bind(&GetGalleryInfoCallback, base::Unretained(&results)));
    532   base::MessageLoop::current()->RunUntilIdle();
    533   return results;
    534 }
    535 
    536 extensions::Extension* ProfileState::all_permission_extension() {
    537   return all_permission_extension_.get();
    538 }
    539 
    540 extensions::Extension* ProfileState::regular_permission_extension() {
    541   return regular_permission_extension_.get();
    542 }
    543 
    544 Profile* ProfileState::profile() {
    545   return profile_.get();
    546 }
    547 
    548 void ProfileState::AddNameForReadCompare(const base::string16& name) {
    549   compare_names_read_.push_back(name);
    550 }
    551 
    552 void ProfileState::AddNameForAllCompare(const base::string16& name) {
    553   compare_names_all_.push_back(name);
    554 }
    555 
    556 bool ProfileState::ContainsEntry(
    557     const MediaFileSystemInfo& info,
    558     const std::vector<MediaFileSystemInfo>& container) {
    559   for (size_t i = 0; i < container.size(); ++i) {
    560     if (info.path.value() == container[i].path.value()) {
    561       EXPECT_FALSE(container[i].fsid.empty());
    562       if (!info.fsid.empty())
    563         EXPECT_EQ(info.fsid, container[i].fsid);
    564       return true;
    565     }
    566   }
    567   return false;
    568 }
    569 
    570 void ProfileState::CompareResults(
    571     const std::string& test,
    572     const std::vector<base::string16>& names,
    573     const std::vector<MediaFileSystemInfo>& expected,
    574     const std::vector<MediaFileSystemInfo>& actual) {
    575   num_comparisons_++;
    576   EXPECT_EQ(expected.size(), actual.size()) << test;
    577 
    578   // Order isn't important, so sort the results.
    579   std::vector<MediaFileSystemInfo> sorted(actual);
    580   std::sort(sorted.begin(), sorted.end(), MediaFileSystemInfoComparator);
    581   std::vector<MediaFileSystemInfo> expect(expected);
    582   std::sort(expect.begin(), expect.end(), MediaFileSystemInfoComparator);
    583   std::vector<base::string16> expect_names(names);
    584   std::sort(expect_names.begin(), expect_names.end());
    585 
    586   for (size_t i = 0; i < expect.size() && i < sorted.size(); ++i) {
    587     if (expect_names.size() > i)
    588       EXPECT_EQ(expect_names[i], sorted[i].name) << test;
    589     EXPECT_TRUE(ContainsEntry(expect[i], sorted)) << test;
    590   }
    591 }
    592 
    593 int ProfileState::GetAndClearComparisonCount() {
    594   int result = num_comparisons_;
    595   num_comparisons_ = 0;
    596   return result;
    597 }
    598 
    599 }  // namespace
    600 
    601 /////////////////////////////////
    602 // MediaFileSystemRegistryTest //
    603 /////////////////////////////////
    604 
    605 void MediaFileSystemRegistryTest::CreateProfileState(size_t profile_count) {
    606   for (size_t i = 0; i < profile_count; ++i) {
    607     ProfileState* state = new ProfileState(&rph_factory_);
    608     profile_states_.push_back(state);
    609   }
    610 }
    611 
    612 ProfileState* MediaFileSystemRegistryTest::GetProfileState(size_t i) {
    613   return profile_states_[i];
    614 }
    615 
    616 MediaGalleriesPreferences* MediaFileSystemRegistryTest::GetPreferences(
    617     Profile* profile) {
    618   MediaGalleriesPreferences* prefs = registry()->GetPreferences(profile);
    619   base::RunLoop loop;
    620   prefs->EnsureInitialized(loop.QuitClosure());
    621   loop.Run();
    622   return prefs;
    623 }
    624 
    625 std::string MediaFileSystemRegistryTest::AddUserGallery(
    626     StorageInfo::Type type,
    627     const std::string& unique_id,
    628     const base::FilePath& path) {
    629   std::string device_id = StorageInfo::MakeDeviceId(type, unique_id);
    630   DCHECK(!StorageInfo::IsMediaDevice(device_id));
    631 
    632   for (size_t i = 0; i < profile_states_.size(); ++i) {
    633     profile_states_[i]->GetMediaGalleriesPrefs()->AddGallery(
    634         device_id, base::FilePath(), MediaGalleryPrefInfo::kUserAdded,
    635         base::string16(), base::string16(), base::string16(), 0,
    636         base::Time::Now(), 0, 0, 0);
    637   }
    638   return device_id;
    639 }
    640 
    641 std::string MediaFileSystemRegistryTest::AttachDevice(
    642     StorageInfo::Type type,
    643     const std::string& unique_id,
    644     const base::FilePath& location) {
    645   std::string device_id = StorageInfo::MakeDeviceId(type, unique_id);
    646   DCHECK(StorageInfo::IsRemovableDevice(device_id));
    647   base::string16 label = location.BaseName().LossyDisplayName();
    648   ProcessAttach(device_id, label, location.value());
    649   base::MessageLoop::current()->RunUntilIdle();
    650   return device_id;
    651 }
    652 
    653 void MediaFileSystemRegistryTest::DetachDevice(const std::string& device_id) {
    654   DCHECK(StorageInfo::IsRemovableDevice(device_id));
    655   ProcessDetach(device_id);
    656   base::MessageLoop::current()->RunUntilIdle();
    657 }
    658 
    659 void MediaFileSystemRegistryTest::SetGalleryPermission(
    660     ProfileState* profile_state, extensions::Extension* extension,
    661     const std::string& device_id, bool has_access) {
    662   MediaGalleriesPreferences* preferences =
    663       profile_state->GetMediaGalleriesPrefs();
    664   MediaGalleryPrefIdSet pref_id =
    665       preferences->LookUpGalleriesByDeviceId(device_id);
    666   ASSERT_EQ(1U, pref_id.size());
    667   preferences->SetGalleryPermissionForExtension(*extension, *pref_id.begin(),
    668                                                 has_access);
    669 }
    670 
    671 void MediaFileSystemRegistryTest::AssertAllAutoAddedGalleries() {
    672   for (size_t i = 0; i < profile_states_.size(); ++i) {
    673     MediaGalleriesPreferences* prefs =
    674         profile_states_[0]->GetMediaGalleriesPrefs();
    675 
    676     // Make sure that we have at least one gallery and that they are all
    677     // auto added galleries.
    678     const MediaGalleriesPrefInfoMap& galleries = prefs->known_galleries();
    679 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
    680     ASSERT_GT(galleries.size(), 0U);
    681 #endif
    682     for (MediaGalleriesPrefInfoMap::const_iterator it = galleries.begin();
    683          it != galleries.end();
    684          ++it) {
    685       ASSERT_EQ(MediaGalleryPrefInfo::kAutoDetected, it->second.type);
    686     }
    687   }
    688 }
    689 
    690 void MediaFileSystemRegistryTest::InitForGalleriesInfoTest(
    691     FSInfoMap* galleries_info) {
    692   CreateProfileState(1);
    693   AssertAllAutoAddedGalleries();
    694 
    695   // Get all existing gallery names.
    696   ProfileState* profile_state = GetProfileState(0U);
    697   *galleries_info = profile_state->GetGalleriesInfo(
    698       profile_state->all_permission_extension());
    699 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
    700   ASSERT_EQ(3U, galleries_info->size());
    701 #else
    702   ASSERT_EQ(0U, galleries_info->size());
    703 #endif
    704 }
    705 
    706 void MediaFileSystemRegistryTest::CheckNewGalleryInfo(
    707     ProfileState* profile_state,
    708     const FSInfoMap& galleries_info,
    709     const base::FilePath& location,
    710     bool removable,
    711     bool media_device) {
    712   // Get new galleries.
    713   FSInfoMap new_galleries_info = profile_state->GetGalleriesInfo(
    714       profile_state->all_permission_extension());
    715   ASSERT_EQ(galleries_info.size() + 1U, new_galleries_info.size());
    716 
    717   bool found_new = false;
    718   for (FSInfoMap::const_iterator it = new_galleries_info.begin();
    719        it != new_galleries_info.end();
    720        ++it) {
    721     if (ContainsKey(galleries_info, it->first))
    722       continue;
    723 
    724     ASSERT_FALSE(found_new);
    725     CheckGalleryInfo(it->second, test_file_system_context_, location,
    726                      removable, media_device);
    727     found_new = true;
    728   }
    729   ASSERT_TRUE(found_new);
    730 }
    731 
    732 std::vector<MediaFileSystemInfo>
    733 MediaFileSystemRegistryTest::GetAutoAddedGalleries(
    734     ProfileState* profile_state) {
    735   const MediaGalleriesPrefInfoMap& galleries =
    736       profile_state->GetMediaGalleriesPrefs()->known_galleries();
    737   std::vector<MediaFileSystemInfo> result;
    738   for (MediaGalleriesPrefInfoMap::const_iterator it = galleries.begin();
    739        it != galleries.end();
    740        ++it) {
    741     if (it->second.type == MediaGalleryPrefInfo::kAutoDetected) {
    742       base::FilePath path = it->second.AbsolutePath();
    743       MediaFileSystemInfo info(path.BaseName().LossyDisplayName(), path,
    744                                std::string(), 0, std::string(), false, false);
    745       result.push_back(info);
    746     }
    747   }
    748   std::sort(result.begin(), result.end(), MediaFileSystemInfoComparator);
    749   return result;
    750 }
    751 
    752 size_t MediaFileSystemRegistryTest::GetExtensionGalleriesHostCount(
    753     const MediaFileSystemRegistry* registry) const {
    754   size_t extension_galleries_host_count = 0;
    755   for (MediaFileSystemRegistry::ExtensionGalleriesHostMap::const_iterator it =
    756            registry->extension_hosts_map_.begin();
    757        it != registry->extension_hosts_map_.end();
    758        ++it) {
    759     extension_galleries_host_count += it->second.size();
    760   }
    761   return extension_galleries_host_count;
    762 }
    763 
    764 
    765 void MediaFileSystemRegistryTest::SetUp() {
    766   ChromeRenderViewHostTestHarness::SetUp();
    767   ASSERT_TRUE(TestStorageMonitor::CreateAndInstall());
    768 
    769   DeleteContents();
    770   SetRenderProcessHostFactory(&rph_factory_);
    771 
    772   test_file_system_context_ = new TestMediaFileSystemContext(
    773       g_browser_process->media_file_system_registry());
    774 
    775 #if defined(OS_CHROMEOS)
    776   test_user_manager_.reset(new chromeos::ScopedTestUserManager());
    777 #endif
    778 
    779   ASSERT_TRUE(galleries_dir_.CreateUniqueTempDir());
    780   empty_dir_ = galleries_dir_.path().AppendASCII("empty");
    781   ASSERT_TRUE(base::CreateDirectory(empty_dir_));
    782   dcim_dir_ = galleries_dir_.path().AppendASCII("with_dcim");
    783   ASSERT_TRUE(base::CreateDirectory(dcim_dir_));
    784   ASSERT_TRUE(base::CreateDirectory(
    785       dcim_dir_.Append(storage_monitor::kDCIMDirectoryName)));
    786 }
    787 
    788 void MediaFileSystemRegistryTest::TearDown() {
    789   profile_states_.clear();
    790   MediaFileSystemRegistry* registry =
    791       g_browser_process->media_file_system_registry();
    792   EXPECT_EQ(0U, GetExtensionGalleriesHostCount(registry));
    793   TestStorageMonitor::Destroy();
    794 #if defined(OS_CHROMEOS)
    795   test_user_manager_.reset();
    796 #endif
    797 
    798   ChromeRenderViewHostTestHarness::TearDown();
    799 }
    800 
    801 ///////////
    802 // Tests //
    803 ///////////
    804 
    805 TEST_F(MediaFileSystemRegistryTest, Basic) {
    806   CreateProfileState(1);
    807   AssertAllAutoAddedGalleries();
    808 
    809   ProfileState* profile_state = GetProfileState(0);
    810   std::vector<MediaFileSystemInfo> auto_galleries =
    811       GetAutoAddedGalleries(profile_state);
    812   std::vector<MediaFileSystemInfo> empty_expectation;
    813   profile_state->CheckGalleries("basic", empty_expectation, auto_galleries);
    814 }
    815 
    816 TEST_F(MediaFileSystemRegistryTest, UserAddedGallery) {
    817   CreateProfileState(1);
    818   AssertAllAutoAddedGalleries();
    819   ProfileState* profile_state = GetProfileState(0);
    820   std::vector<MediaFileSystemInfo> auto_galleries =
    821       GetAutoAddedGalleries(profile_state);
    822   std::vector<MediaFileSystemInfo> added_galleries;
    823   profile_state->CheckGalleries("user added init", added_galleries,
    824                                 auto_galleries);
    825 
    826   // Add a user gallery to the regular permission extension.
    827   std::string device_id = AddUserGallery(StorageInfo::FIXED_MASS_STORAGE,
    828                                          empty_dir().AsUTF8Unsafe(),
    829                                          empty_dir());
    830   SetGalleryPermission(profile_state,
    831                        profile_state->regular_permission_extension(),
    832                        device_id,
    833                        true /*has access*/);
    834   MediaFileSystemInfo added_info(empty_dir().LossyDisplayName(), empty_dir(),
    835                                  std::string(), 0, std::string(), false, false);
    836   added_galleries.push_back(added_info);
    837   profile_state->CheckGalleries("user added regular", added_galleries,
    838                                 auto_galleries);
    839 
    840   // Add it to the all galleries extension.
    841   SetGalleryPermission(profile_state,
    842                        profile_state->all_permission_extension(),
    843                        device_id,
    844                        true /*has access*/);
    845   auto_galleries.push_back(added_info);
    846   profile_state->CheckGalleries("user added all", added_galleries,
    847                                 auto_galleries);
    848 }
    849 
    850 // Regression test to make sure erasing galleries does not result a crash.
    851 TEST_F(MediaFileSystemRegistryTest, EraseGalleries) {
    852   CreateProfileState(1);
    853   AssertAllAutoAddedGalleries();
    854 
    855   ProfileState* profile_state = GetProfileState(0);
    856   std::vector<MediaFileSystemInfo> auto_galleries =
    857       GetAutoAddedGalleries(profile_state);
    858   std::vector<MediaFileSystemInfo> empty_expectation;
    859   profile_state->CheckGalleries("erase", empty_expectation, auto_galleries);
    860 
    861   MediaGalleriesPreferences* prefs = profile_state->GetMediaGalleriesPrefs();
    862   MediaGalleriesPrefInfoMap galleries = prefs->known_galleries();
    863   for (MediaGalleriesPrefInfoMap::const_iterator it = galleries.begin();
    864        it != galleries.end(); ++it) {
    865     prefs->ForgetGalleryById(it->first);
    866   }
    867 }
    868 
    869 // Regression test to make sure calling GetPreferences() does not re-insert
    870 // galleries on auto-detected removable devices that were blacklisted.
    871 TEST_F(MediaFileSystemRegistryTest,
    872        GetPreferencesDoesNotReinsertBlacklistedGalleries) {
    873   CreateProfileState(1);
    874   AssertAllAutoAddedGalleries();
    875 
    876   ProfileState* profile_state = GetProfileState(0);
    877   const size_t gallery_count = GetAutoAddedGalleries(profile_state).size();
    878 
    879   // Attach a device.
    880   const std::string device_id = AttachDevice(
    881       StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM,
    882       "removable_dcim_fake_id",
    883       dcim_dir());
    884   EXPECT_EQ(gallery_count + 1, GetAutoAddedGalleries(profile_state).size());
    885 
    886   // Forget the device.
    887   bool forget_gallery = false;
    888   MediaGalleriesPreferences* prefs = GetPreferences(profile_state->profile());
    889   const MediaGalleriesPrefInfoMap& galleries = prefs->known_galleries();
    890   for (MediaGalleriesPrefInfoMap::const_iterator it = galleries.begin();
    891        it != galleries.end(); ++it) {
    892     if (it->second.device_id == device_id) {
    893       prefs->ForgetGalleryById(it->first);
    894       forget_gallery = true;
    895       break;
    896     }
    897   }
    898   base::MessageLoop::current()->RunUntilIdle();
    899   EXPECT_TRUE(forget_gallery);
    900   EXPECT_EQ(gallery_count, GetAutoAddedGalleries(profile_state).size());
    901 
    902   // Call GetPreferences() and the gallery count should not change.
    903   prefs = GetPreferences(profile_state->profile());
    904   EXPECT_EQ(gallery_count, GetAutoAddedGalleries(profile_state).size());
    905 }
    906 
    907 TEST_F(MediaFileSystemRegistryTest, GalleryNameDefault) {
    908   FSInfoMap galleries_info;
    909   InitForGalleriesInfoTest(&galleries_info);
    910 
    911   for (FSInfoMap::const_iterator it = galleries_info.begin();
    912        it != galleries_info.end();
    913        ++it) {
    914     CheckGalleryInfo(it->second, test_file_system_context(),
    915                      it->second.path, false, false);
    916   }
    917 }
    918 
    919 // TODO(gbillock): Move the remaining test into the linux directory.
    920 #if !defined(OS_MACOSX) && !defined(OS_WIN)
    921 TEST_F(MediaFileSystemRegistryTest, GalleryMTP) {
    922   FSInfoMap galleries_info;
    923   InitForGalleriesInfoTest(&galleries_info);
    924 
    925   base::FilePath location(FILE_PATH_LITERAL("/mtp_bogus"));
    926   AttachDevice(StorageInfo::MTP_OR_PTP, "mtp_fake_id", location);
    927   CheckNewGalleryInfo(GetProfileState(0U), galleries_info, location,
    928                       true /*removable*/, true /* media device */);
    929 }
    930 #endif
    931 
    932 TEST_F(MediaFileSystemRegistryTest, GalleryDCIM) {
    933   FSInfoMap galleries_info;
    934   InitForGalleriesInfoTest(&galleries_info);
    935 
    936   AttachDevice(StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM,
    937                "removable_dcim_fake_id",
    938                dcim_dir());
    939   CheckNewGalleryInfo(GetProfileState(0U), galleries_info, dcim_dir(),
    940                       true /*removable*/, true /* media device */);
    941 }
    942 
    943 TEST_F(MediaFileSystemRegistryTest, GalleryNoDCIM) {
    944   FSInfoMap galleries_info;
    945   InitForGalleriesInfoTest(&galleries_info);
    946 
    947   std::string device_id =
    948       AttachDevice(StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM,
    949                    empty_dir().AsUTF8Unsafe(),
    950                    empty_dir());
    951   std::string device_id2 =
    952       AddUserGallery(StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM,
    953                      empty_dir().AsUTF8Unsafe(),
    954                      empty_dir());
    955   ASSERT_EQ(device_id, device_id2);
    956   // Add permission for new non-default gallery.
    957   ProfileState* profile_state = GetProfileState(0U);
    958   SetGalleryPermission(profile_state,
    959                        profile_state->all_permission_extension(),
    960                        device_id,
    961                        true /*has access*/);
    962   CheckNewGalleryInfo(profile_state, galleries_info, empty_dir(),
    963                       true /*removable*/, false /* media device */);
    964 }
    965 
    966 TEST_F(MediaFileSystemRegistryTest, GalleryUserAddedPath) {
    967   FSInfoMap galleries_info;
    968   InitForGalleriesInfoTest(&galleries_info);
    969 
    970   std::string device_id = AddUserGallery(StorageInfo::FIXED_MASS_STORAGE,
    971                                          empty_dir().AsUTF8Unsafe(),
    972                                          empty_dir());
    973   // Add permission for new non-default gallery.
    974   ProfileState* profile_state = GetProfileState(0U);
    975   SetGalleryPermission(profile_state,
    976                        profile_state->all_permission_extension(),
    977                        device_id,
    978                        true /*has access*/);
    979   CheckNewGalleryInfo(profile_state, galleries_info, empty_dir(),
    980                       false /*removable*/, false /* media device */);
    981 }
    982 
    983 TEST_F(MediaFileSystemRegistryTest, DetachedDeviceGalleryPath) {
    984   const std::string device_id = AttachDevice(
    985       StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM,
    986       "removable_dcim_fake_id",
    987       dcim_dir());
    988 
    989   MediaGalleryPrefInfo pref_info;
    990   pref_info.device_id = device_id;
    991   EXPECT_EQ(dcim_dir().value(), pref_info.AbsolutePath().value());
    992 
    993   MediaGalleryPrefInfo pref_info_with_relpath;
    994   pref_info_with_relpath.path =
    995       base::FilePath(FILE_PATH_LITERAL("test_relpath"));
    996   pref_info_with_relpath.device_id = device_id;
    997   EXPECT_EQ(dcim_dir().Append(pref_info_with_relpath.path).value(),
    998             pref_info_with_relpath.AbsolutePath().value());
    999 
   1000   DetachDevice(device_id);
   1001   EXPECT_TRUE(pref_info.AbsolutePath().empty());
   1002   EXPECT_TRUE(pref_info_with_relpath.AbsolutePath().empty());
   1003 }
   1004 
   1005 TEST_F(MediaFileSystemRegistryTest, TestNameConstruction) {
   1006   CreateProfileState(1);
   1007   AssertAllAutoAddedGalleries();
   1008 
   1009   ProfileState* profile_state = GetProfileState(0);
   1010 
   1011   std::string user_gallery = AddUserGallery(StorageInfo::FIXED_MASS_STORAGE,
   1012                                             empty_dir().AsUTF8Unsafe(),
   1013                                             empty_dir());
   1014   SetGalleryPermission(profile_state,
   1015                        profile_state->regular_permission_extension(),
   1016                        user_gallery,
   1017                        true /*has access*/);
   1018   SetGalleryPermission(profile_state,
   1019                        profile_state->all_permission_extension(),
   1020                        user_gallery,
   1021                        true /*has access*/);
   1022 
   1023   std::vector<MediaFileSystemInfo> auto_galleries =
   1024       GetAutoAddedGalleries(profile_state);
   1025   MediaFileSystemInfo added_info(empty_dir().BaseName().LossyDisplayName(),
   1026                                  empty_dir(), std::string(), 0, std::string(),
   1027                                  false, false);
   1028   auto_galleries.push_back(added_info);
   1029   std::vector<MediaFileSystemInfo> one_expectation;
   1030   one_expectation.push_back(added_info);
   1031 
   1032   base::string16 empty_dir_name = GetExpectedFolderName(empty_dir());
   1033   profile_state->AddNameForReadCompare(empty_dir_name);
   1034   profile_state->AddNameForAllCompare(empty_dir_name);
   1035 
   1036   // This part of the test is conditional on default directories existing
   1037   // on the test platform. In ChromeOS, these directories do not exist.
   1038   base::FilePath path;
   1039   if (num_auto_galleries() > 0) {
   1040     ASSERT_TRUE(PathService::Get(chrome::DIR_USER_MUSIC, &path));
   1041     profile_state->AddNameForAllCompare(GetExpectedFolderName(path));
   1042     ASSERT_TRUE(PathService::Get(chrome::DIR_USER_PICTURES, &path));
   1043     profile_state->AddNameForAllCompare(GetExpectedFolderName(path));
   1044     ASSERT_TRUE(PathService::Get(chrome::DIR_USER_VIDEOS, &path));
   1045     profile_state->AddNameForAllCompare(GetExpectedFolderName(path));
   1046 
   1047     profile_state->CheckGalleries("names-dir", one_expectation, auto_galleries);
   1048   } else {
   1049     profile_state->CheckGalleries("names", one_expectation, one_expectation);
   1050   }
   1051 }
   1052 
   1053 TEST_F(MediaFileSystemRegistryTest, PreferenceListener) {
   1054   CreateProfileState(1);
   1055   AssertAllAutoAddedGalleries();
   1056 
   1057   // Add a user gallery to the regular permission extension.
   1058   std::string device_id = AddUserGallery(StorageInfo::FIXED_MASS_STORAGE,
   1059                                          empty_dir().AsUTF8Unsafe(),
   1060                                          empty_dir());
   1061   ProfileState* profile_state = GetProfileState(0);
   1062   SetGalleryPermission(profile_state,
   1063                        profile_state->regular_permission_extension(),
   1064                        device_id,
   1065                        true /*has access*/);
   1066 
   1067   FSInfoMap fs_info = profile_state->GetGalleriesInfo(
   1068       profile_state->regular_permission_extension());
   1069   ASSERT_EQ(1U, fs_info.size());
   1070   EXPECT_FALSE(test_file_system_context()->GetRegisteredPath(
   1071       fs_info.begin()->second.fsid).empty());
   1072 
   1073   // Revoke permission and ensure that the file system is revoked.
   1074   SetGalleryPermission(profile_state,
   1075                        profile_state->regular_permission_extension(),
   1076                        device_id,
   1077                        false /*has access*/);
   1078   EXPECT_TRUE(test_file_system_context()->GetRegisteredPath(
   1079       fs_info.begin()->second.fsid).empty());
   1080 }
   1081